@c4a/extract-ts 0.6.19 → 0.7.0

package/index.js

@@ -11375,6 +11375,416 @@ var factSchema = exports_external.union([
   activeFactSchema,
   deprecatedFactSchema
 ]);
+// ../core/src/schemas/indexerEvidenceAdapterSchema.ts
+import { createHash } from "node:crypto";
+
+// ../core/src/indexerOutputRedaction.ts
+var INDEXER_OUTPUT_REDACTION_MARKER = "[REDACTED:indexer-output]";
+var SECRET_TOKEN = /^(?:password|passwd|pwd|secret|token|credential|credentials|cookie)$/u;
+var SECRET_COMPOUND = /^(?:api-key|access-key|private-key|client-secret|access-token|refresh-token)$/u;
+var NON_SECRET_SUFFIX = new Set([
+  "budget",
+  "count",
+  "digest",
+  "fingerprint",
+  "hash",
+  "index",
+  "kind",
+  "length",
+  "limit",
+  "name",
+  "ref",
+  "reference",
+  "references",
+  "refs",
+  "status",
+  "type"
+]);
+function keyTokens(key) {
+  return key.replace(/([a-z0-9])([A-Z])/gu, "$1-$2").replace(/[^A-Za-z0-9]+/gu, "-").toLowerCase().split("-").filter(Boolean);
+}
+function sensitiveKey(key, value) {
+  const tokens = keyTokens(key);
+  if (tokens.length === 0)
+    return false;
+  const normalized = tokens.join("-");
+  if (normalized === "authorization" && value !== null && typeof value === "object") {
+    return false;
+  }
+  if (NON_SECRET_SUFFIX.has(tokens.at(-1)))
+    return false;
+  return SECRET_COMPOUND.test(normalized) || tokens.some((token) => SECRET_TOKEN.test(token)) || normalized === "authorization";
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+}
+function normalizedBlockedScalars(policy) {
+  const identities = new Set;
+  const values = [];
+  for (const value of policy.blocked_scalars ?? []) {
+    if (typeof value === "number" && !Number.isFinite(value))
+      continue;
+    if (typeof value === "string" && value.length === 0)
+      continue;
+    const identity = `${typeof value}:${String(value)}`;
+    if (identities.has(identity))
+      continue;
+    identities.add(identity);
+    values.push(value);
+  }
+  return values.sort((left, right) => String(right).length - String(left).length);
+}
+function replaceWithCount(value, pattern, replacement, count) {
+  return value.replace(pattern, (...args) => {
+    count.replacements += 1;
+    if (typeof replacement === "string")
+      return replacement;
+    return replacement(...args.slice(0, -2));
+  });
+}
+function redactKnownText(value, count) {
+  let output = value;
+  output = replaceWithCount(output, /-----BEGIN (?:RSA |EC |OPENSSH )?PRIVATE KEY-----[\s\S]*?-----END (?:RSA |EC |OPENSSH )?PRIVATE KEY-----/gu, INDEXER_OUTPUT_REDACTION_MARKER, count);
+  output = replaceWithCount(output, /(\bauthorization\s*:\s*(?:bearer|basic)\s+)[^\s,;]+/giu, (_match, prefix) => `${prefix}${INDEXER_OUTPUT_REDACTION_MARKER}`, count);
+  output = replaceWithCount(output, /([a-z][a-z0-9+.-]*:\/\/)[^\s/@:]+:[^\s/@]+@/giu, (_match, prefix) => `${prefix}${INDEXER_OUTPUT_REDACTION_MARKER}@`, count);
+  output = replaceWithCount(output, /([?&](?:access_token|refresh_token|api_key|password|secret)=)[^&#\s]+/giu, (_match, prefix) => `${prefix}${INDEXER_OUTPUT_REDACTION_MARKER}`, count);
+  const key = "(?:[A-Za-z0-9_.-]*(?:password|passwd|pwd|secret|token|credential|cookie)[A-Za-z0-9_.-]*|api[-_]?key|access[-_]?(?:key|token)|private[-_]?key|client[-_]?secret|authorization)";
+  const assignment = `(?:=\\s*|:\\s+(?=\\S)|:\\s*(?=["']))`;
+  output = replaceWithCount(output, new RegExp(`((?:["']?${key}["']?)\\s*${assignment})(?:"(?:\\\\.|[^"])*"|'(?:\\\\.|[^'])*'|[^\\s,;}\\]]+)`, "giu"), (_match, prefix) => `${prefix}"${INDEXER_OUTPUT_REDACTION_MARKER}"`, count);
+  return output;
+}
+function redactBlockedText(value, blocked, count) {
+  let output = value;
+  for (const scalar of blocked) {
+    const pattern = typeof scalar === "number" ? new RegExp(`(?<![0-9.])${escapeRegExp(String(scalar))}(?![0-9.])`, "gu") : new RegExp(escapeRegExp(scalar), "gu");
+    output = replaceWithCount(output, pattern, INDEXER_OUTPUT_REDACTION_MARKER, count);
+  }
+  return output;
+}
+function redactText(value, blocked, count) {
+  return redactBlockedText(redactKnownText(value, count), blocked, count);
+}
+function blockedScalar(value, blocked) {
+  return blocked.some((candidate) => typeof candidate === typeof value && Object.is(candidate, value));
+}
+function redactStructured(value, blocked, count, seen) {
+  if (blockedScalar(value, blocked)) {
+    count.replacements += 1;
+    return INDEXER_OUTPUT_REDACTION_MARKER;
+  }
+  if (typeof value === "string")
+    return redactText(value, blocked, count);
+  if (value === null || typeof value !== "object")
+    return value;
+  if (seen.has(value))
+    throw new TypeError("Indexer output redaction requires an acyclic value");
+  seen.add(value);
+  if (value instanceof Date) {
+    const redacted2 = redactText(value.toISOString(), blocked, count);
+    seen.delete(value);
+    return redacted2;
+  }
+  if (value instanceof Error) {
+    const redacted2 = {
+      name: redactText(value.name, blocked, count),
+      message: redactText(value.message, blocked, count)
+    };
+    seen.delete(value);
+    return redacted2;
+  }
+  if (Array.isArray(value)) {
+    const redacted2 = value.map((item) => redactStructured(item, blocked, count, seen));
+    seen.delete(value);
+    return redacted2;
+  }
+  const redacted = {};
+  for (const [key, item] of Object.entries(value)) {
+    const safeKey = redactText(key, blocked, count);
+    if (sensitiveKey(key, item)) {
+      count.replacements += 1;
+      redacted[safeKey] = INDEXER_OUTPUT_REDACTION_MARKER;
+    } else {
+      redacted[safeKey] = redactStructured(item, blocked, count, seen);
+    }
+  }
+  seen.delete(value);
+  return redacted;
+}
+function redactIndexerOutput(input) {
+  const count = { replacements: 0 };
+  const blocked = normalizedBlockedScalars(input.policy ?? {});
+  const value = typeof input.value === "string" ? redactText(input.value, blocked, count) : redactStructured(input.value, blocked, count, new WeakSet);
+  return {
+    value,
+    redacted: count.replacements > 0,
+    replacement_count: count.replacements
+  };
+}
+function assertIndexerOutputSafe(input) {
+  const result = redactIndexerOutput(input);
+  if (result.redacted) {
+    throw new TypeError(`Indexer ${input.channel} was blocked by the common output redaction boundary`);
+  }
+  return input.value;
+}
+
+// ../core/src/schemas/indexerEvidenceAdapterSchema.ts
+var digestSchema = exports_external.string().regex(/^sha256:[a-f0-9]{64}$/u);
+var idSchema = exports_external.string().regex(/^[a-z0-9][a-z0-9._/-]*$/u).superRefine((value, context) => {
+  if (value.split("/").some((segment) => segment.length === 0 || segment === "." || segment === "..")) {
+    context.addIssue({
+      code: exports_external.ZodIssueCode.custom,
+      message: "must not contain empty, current-directory, or parent-directory segments"
+    });
+  }
+});
+var semverSchema = exports_external.string().regex(/^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/u);
+var canonicalRefSchema = exports_external.string().regex(/^[a-z][a-z0-9.-]*:[A-Za-z0-9][A-Za-z0-9._~:/#@+-]*$/u);
+var packageCoordinateSchema = exports_external.string().regex(/^(?:@[a-z0-9._-]+\/)?[a-z0-9][a-z0-9._-]*$/u);
+var portablePathSchema = exports_external.string().superRefine((value, context) => {
+  const segments = value.split("/");
+  if (value.length === 0 || value.includes("\x00") || value.includes("\\") || value.startsWith("/") || /^[A-Za-z]:\//u.test(value) || segments.some((segment) => segment.length === 0 || segment === "." || segment === "..")) {
+    context.addIssue({
+      code: exports_external.ZodIssueCode.custom,
+      message: "must be a portable relative path"
+    });
+  }
+});
+function addDuplicateIssues(values, context, field) {
+  const seen = new Set;
+  values.forEach((value, index) => {
+    if (seen.has(value)) {
+      context.addIssue({
+        code: exports_external.ZodIssueCode.custom,
+        message: `${field} must not contain duplicate value ${value}`,
+        path: [index]
+      });
+    }
+    seen.add(value);
+  });
+}
+var adapterIdentitySchema = exports_external.object({
+  id: idSchema,
+  package: packageCoordinateSchema,
+  export: exports_external.string().regex(/^[A-Za-z_$][A-Za-z0-9_$.-]*$/u),
+  version: semverSchema,
+  digest: digestSchema
+}).strict();
+var adapterLocatorSchema = exports_external.object({
+  source_ref: canonicalRefSchema,
+  module_ref: canonicalRefSchema.nullable(),
+  normalized_path: portablePathSchema,
+  qualified_item_path: exports_external.string().min(1).max(1024),
+  signature_digest: digestSchema
+}).strict();
+var indexerEvidenceAdapterFactSchema = exports_external.object({
+  fact_ref: canonicalRefSchema,
+  kind: idSchema,
+  locator: adapterLocatorSchema,
+  payload_digest: digestSchema,
+  denominator: exports_external.enum(["none", "eligible-file", "loc", "symbol", "protocol-item"])
+}).strict();
+var indexerEvidenceAdapterFileSchema = exports_external.object({
+  file_ref: canonicalRefSchema,
+  source_ref: canonicalRefSchema,
+  module_ref: canonicalRefSchema.nullable(),
+  normalized_path: portablePathSchema,
+  role: exports_external.enum(["primary-owner", "enricher"]),
+  coverage_tier: exports_external.enum(["ast-catalog", "lightweight-evidence"]),
+  disposition: exports_external.enum(["analyzed", "unsupported", "excluded"]),
+  facts: exports_external.array(indexerEvidenceAdapterFactSchema)
+}).strict().superRefine((value, context) => {
+  addDuplicateIssues(value.facts.map((fact2) => fact2.fact_ref), context, "facts");
+  if (value.disposition !== "analyzed" && value.facts.length > 0) {
+    context.addIssue({
+      code: exports_external.ZodIssueCode.custom,
+      message: "unsupported or excluded files cannot publish facts",
+      path: ["facts"]
+    });
+  }
+  if ((value.role === "enricher" || value.coverage_tier === "lightweight-evidence") && value.facts.some((fact2) => fact2.denominator !== "none")) {
+    context.addIssue({
+      code: exports_external.ZodIssueCode.custom,
+      message: "enricher and lightweight evidence facts cannot contribute denominators",
+      path: ["facts"]
+    });
+  }
+});
+var toolchainStepSchema = exports_external.object({
+  step: idSchema,
+  package: packageCoordinateSchema,
+  export: exports_external.string().regex(/^[A-Za-z_$][A-Za-z0-9_$.-]*$/u),
+  version: semverSchema,
+  digest: digestSchema,
+  capabilities: exports_external.array(idSchema).min(1),
+  input_digest: digestSchema,
+  output_digest: digestSchema
+}).strict().superRefine((value, context) => {
+  addDuplicateIssues(value.capabilities, context, "capabilities");
+});
+var adapterDiagnosticSchema = exports_external.object({
+  code: idSchema,
+  fact_ref: canonicalRefSchema.optional(),
+  severity: exports_external.enum(["info", "warning", "error"]),
+  detail_digest: digestSchema
+}).strict();
+var indexerEvidenceAdapterResultSchema = exports_external.object({
+  protocol: exports_external.literal("context.indexer.evidence-adapter-result/v1"),
+  adapter: adapterIdentitySchema,
+  authorized_scope: exports_external.object({
+    source_ref: canonicalRefSchema,
+    module_refs: exports_external.array(canonicalRefSchema),
+    scope_digest: digestSchema
+  }).strict(),
+  input_digest: digestSchema,
+  precedence: exports_external.number().int().nonnegative(),
+  files: exports_external.array(indexerEvidenceAdapterFileSchema).min(1),
+  diagnostics: exports_external.array(adapterDiagnosticSchema),
+  toolchain: exports_external.array(toolchainStepSchema).min(1),
+  output_digest: digestSchema
+}).strict().superRefine((value, context) => {
+  addDuplicateIssues(value.authorized_scope.module_refs, context, "authorized_scope.module_refs");
+  addDuplicateIssues(value.files.map((file) => file.file_ref), context, "files");
+  addDuplicateIssues(value.toolchain.map((step) => step.step), context, "toolchain");
+});
+var FACT_PAYLOADS = new WeakMap;
+function canonicalFactPayload(value, seen = new WeakSet, path = "$") {
+  if (value === null || typeof value === "boolean" || typeof value === "string") {
+    return value;
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      throw new TypeError("Indexer Evidence Adapter fact payload numbers must be finite");
+    }
+    return value;
+  }
+  if (typeof value !== "object") {
+    throw new TypeError(`Indexer Evidence Adapter fact payload ${path} must contain only JSON values`);
+  }
+  if (seen.has(value)) {
+    throw new TypeError(`Indexer Evidence Adapter fact payload ${path} must be acyclic`);
+  }
+  seen.add(value);
+  if (Array.isArray(value)) {
+    const output2 = value.map((item, index) => canonicalFactPayload(item, seen, `${path}[${index}]`));
+    seen.delete(value);
+    return output2;
+  }
+  if (Object.prototype.toString.call(value) !== "[object Object]") {
+    throw new TypeError(`Indexer Evidence Adapter fact payload ${path} must use plain JSON objects; received ${Object.prototype.toString.call(value)}`);
+  }
+  const output = {};
+  for (const [key, item] of Object.entries(value).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0)) {
+    output[key] = canonicalFactPayload(item, seen, `${path}.${key}`);
+  }
+  seen.delete(value);
+  return output;
+}
+function canonicalize(value) {
+  if (Array.isArray(value))
+    return value.map(canonicalize);
+  if (value !== null && typeof value === "object") {
+    return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([key, item]) => [key, canonicalize(item)]));
+  }
+  return value;
+}
+function indexerEvidenceAdapterProtocolDigest(value) {
+  const canonical = JSON.stringify(canonicalize(value));
+  return `sha256:${createHash("sha256").update(canonical).digest("hex")}`;
+}
+function indexerEvidenceAdapterFileRef(input) {
+  return `adapter-file:${indexerEvidenceAdapterProtocolDigest(input)}`;
+}
+function indexerEvidenceAdapterFactRef(input) {
+  return `adapter-fact:${indexerEvidenceAdapterProtocolDigest(input)}`;
+}
+function createIndexerEvidenceAdapterFact(input) {
+  const payload = canonicalFactPayload(input.payload);
+  const qualifiedItemPath = input.qualified_item_path.length <= 1024 ? input.qualified_item_path : `${input.qualified_item_path.slice(0, 950)}#${indexerEvidenceAdapterProtocolDigest(input.qualified_item_path)}`;
+  const locator = {
+    source_ref: input.source_ref,
+    module_ref: input.module_ref,
+    normalized_path: input.normalized_path,
+    qualified_item_path: qualifiedItemPath,
+    signature_digest: indexerEvidenceAdapterProtocolDigest(input.signature)
+  };
+  const fact2 = {
+    fact_ref: indexerEvidenceAdapterFactRef({ ...locator, kind: input.kind }),
+    kind: input.kind,
+    locator,
+    payload_digest: indexerEvidenceAdapterProtocolDigest(payload),
+    denominator: input.denominator
+  };
+  FACT_PAYLOADS.set(fact2, payload);
+  return fact2;
+}
+function indexerEvidenceAdapterFactPayloads(result) {
+  const payloads = result.files.flatMap((file) => file.facts.map((fact2) => {
+    const payload = FACT_PAYLOADS.get(fact2);
+    if (payload === undefined) {
+      throw new TypeError(`Evidence Adapter fact payload ${fact2.fact_ref} is no longer materialized in this process`);
+    }
+    if (indexerEvidenceAdapterProtocolDigest(payload) !== fact2.payload_digest) {
+      throw new TypeError(`Evidence Adapter fact payload ${fact2.fact_ref} is stale`);
+    }
+    return { fact_ref: fact2.fact_ref, payload };
+  })).sort((left, right) => compareCanonicalText(left.fact_ref, right.fact_ref));
+  return assertIndexerOutputSafe({ channel: "ipc-envelope", value: payloads });
+}
+function materializeIndexerEvidenceAdapterResult(result) {
+  return {
+    result,
+    fact_payloads: indexerEvidenceAdapterFactPayloads(result)
+  };
+}
+function indexerEvidenceAdapterOutputDigest(value) {
+  return indexerEvidenceAdapterProtocolDigest(value);
+}
+function compareCanonicalText(left, right) {
+  if (left < right)
+    return -1;
+  if (left > right)
+    return 1;
+  return 0;
+}
+function buildIndexerEvidenceAdapterResult(input) {
+  const canonical = {
+    ...input,
+    authorized_scope: {
+      ...input.authorized_scope,
+      module_refs: [...input.authorized_scope.module_refs].sort(compareCanonicalText)
+    },
+    files: input.files.map((file) => ({
+      ...file,
+      facts: [...file.facts].sort((left, right) => compareCanonicalText(left.fact_ref, right.fact_ref))
+    })).sort((left, right) => compareCanonicalText(left.file_ref, right.file_ref)),
+    diagnostics: [...input.diagnostics].sort((left, right) => compareCanonicalText(left.fact_ref ?? "", right.fact_ref ?? "") || compareCanonicalText(left.code, right.code) || compareCanonicalText(left.severity, right.severity) || compareCanonicalText(left.detail_digest, right.detail_digest)),
+    toolchain: input.toolchain.map((step) => ({
+      ...step,
+      capabilities: [...step.capabilities].sort(compareCanonicalText)
+    }))
+  };
+  const payloads = new Map;
+  for (const file of canonical.files) {
+    for (const fact2 of file.facts) {
+      const payload = FACT_PAYLOADS.get(fact2);
+      if (payload !== undefined)
+        payloads.set(fact2.fact_ref, payload);
+    }
+  }
+  const parsed = indexerEvidenceAdapterResultSchema.parse({
+    ...canonical,
+    output_digest: indexerEvidenceAdapterOutputDigest(canonical)
+  });
+  for (const file of parsed.files) {
+    for (const fact2 of file.facts) {
+      const payload = payloads.get(fact2.fact_ref);
+      if (payload !== undefined)
+        FACT_PAYLOADS.set(fact2, payload);
+    }
+  }
+  return assertIndexerOutputSafe({ channel: "success-payload", value: parsed });
+}
 // ../core/src/errors/httpStatus.ts
 var ERROR_CODE_HTTP_STATUS = {
   ["VALIDATION_FAILED" /* VALIDATION_FAILED */]: 400,
@@ -11490,7 +11900,15 @@ var DEFAULT_CONTENT_TYPES = [
   {
     id: "typescript",
     category: "code",
-    match: { extensions: [".ts", ".tsx"] },
+    match: { extensions: [".ts", ".tsx", ".mts", ".cts"] },
+    cas: { encoding: "utf8", hashInput: "content" },
+    pipeline: { digest: ["ast", "summary"], extraction: ["entities", "relations"] },
+    display: { icon: "\uD83D\uDCDC", renderer: "code" }
+  },
+  {
+    id: "javascript",
+    category: "code",
+    match: { extensions: [".js", ".jsx", ".mjs", ".cjs"] },
     cas: { encoding: "utf8", hashInput: "content" },
     pipeline: { digest: ["ast", "summary"], extraction: ["entities", "relations"] },
     display: { icon: "\uD83D\uDCDC", renderer: "code" }
@@ -11598,6 +12016,50 @@ var INDEXABLE_EXTENSIONS = new Set([
 var UPLOAD_ALLOWED_EXTENSIONS = collectExtensions(() => true);
 var TEXT_EXTENSIONS = collectExtensions((definition) => definition.cas.encoding === "utf8");
 var UPLOAD_MAX_FILE_SIZE = 5 * 1024 * 1024;
+// src/ecmaScriptLanguage.ts
+var LANGUAGE_BY_EXTENSION = {
+  ".ts": "typescript",
+  ".tsx": "tsx",
+  ".mts": "typescript",
+  ".cts": "typescript",
+  ".js": "javascript",
+  ".jsx": "jsx",
+  ".mjs": "javascript",
+  ".cjs": "javascript"
+};
+var EXTRACT_TS_CAPABILITIES = [
+  "commonjs-module",
+  "esm-module",
+  "javascript-ast",
+  "jsx-ast",
+  "parser.javascript",
+  "parser.typescript",
+  "static-call-relations",
+  "tsx-ast",
+  "typescript-ast"
+];
+var EXTRACT_TS_COVERAGE_TIER = "ast-catalog";
+var ecmaScriptLanguage = (filePath) => {
+  const lower = filePath.toLowerCase();
+  const extension = Object.keys(LANGUAGE_BY_EXTENSION).find((candidate) => lower.endsWith(candidate));
+  return extension ? LANGUAGE_BY_EXTENSION[extension] : "typescript";
+};
+var isJsxLikePath = (filePath) => {
+  const language = ecmaScriptLanguage(filePath);
+  return language === "tsx" || language === "jsx";
+};
+var isJavaScriptPath = (filePath) => {
+  const language = ecmaScriptLanguage(filePath);
+  return language === "javascript" || language === "jsx";
+};
+var packageLanguage = (filePaths) => {
+  const hasJavaScript = filePaths.some(isJavaScriptPath);
+  const hasTypeScript = filePaths.some((filePath) => !isJavaScriptPath(filePath));
+  if (hasJavaScript && hasTypeScript)
+    return "ecmascript";
+  return hasJavaScript ? "javascript" : "typescript";
+};
+
 // src/pathUtils.ts
 import { posix as posix2 } from "node:path";
 
@@ -11781,8 +12243,9 @@ function resolveTsConfigCandidates(specifier, resolver) {
 }
 
 // src/pathUtils.ts
-var SOURCE_EXTENSIONS = [".ts", ".tsx", ".mts", ".cts"];
-var BUILD_EXTENSIONS = [".js", ".jsx", ".mjs", ".cjs"];
+var TYPESCRIPT_EXTENSIONS = [".ts", ".tsx", ".mts", ".cts"];
+var JAVASCRIPT_EXTENSIONS = [".js", ".jsx", ".mjs", ".cjs"];
+var SOURCE_EXTENSIONS = [...TYPESCRIPT_EXTENSIONS, ...JAVASCRIPT_EXTENSIONS];
 var DECLARATION_EXTENSIONS = [".d.ts", ".d.mts", ".d.cts"];
 var KNOWN_CODE_SUFFIXES = [
   ...DECLARATION_EXTENSIONS,
@@ -11794,7 +12257,7 @@ var KNOWN_CODE_SUFFIXES = [
   ".system.js",
   ".min.js",
   ...SOURCE_EXTENSIONS,
-  ...BUILD_EXTENSIONS
+  ...JAVASCRIPT_EXTENSIONS
 ];
 var BUILD_OUTPUT_ROOTS = new Set(["dist", "lib", "build", "output", "out"]);
 var BUILD_FORMAT_DIRS = new Set([
@@ -11857,25 +12320,27 @@ var createCandidatePaths = (value, options = {}) => {
     return [];
   const withoutExtension = removeKnownExtension(normalized);
   const mappedSourcePaths = buildToSourcePaths(withoutExtension);
-  const directFirst = SOURCE_EXTENSIONS.some((extension) => normalized.endsWith(extension));
+  const isBuildOutput = buildToSourcePaths(withoutExtension).length > 0;
+  const directFirst = SOURCE_EXTENSIONS.some((extension) => normalized.endsWith(extension)) && !isBuildOutput;
+  const preferredExtensions = options.preferJavaScript ? [...JAVASCRIPT_EXTENSIONS, ...TYPESCRIPT_EXTENSIONS] : [...TYPESCRIPT_EXTENSIONS, ...JAVASCRIPT_EXTENSIONS];
   const bases = directFirst ? unique([normalized, withoutExtension, ...mappedSourcePaths]) : unique([...mappedSourcePaths, normalized, withoutExtension]);
   const candidates = new Set;
   for (const base of bases) {
     if (SOURCE_EXTENSIONS.some((ext) => base.endsWith(ext))) {
       candidates.add(base);
     }
-    for (const extension of SOURCE_EXTENSIONS) {
+    for (const extension of preferredExtensions) {
       candidates.add(`${base}${extension}`);
       candidates.add(posix2.join(base, `index${extension}`));
     }
-    if (BUILD_EXTENSIONS.some((extension) => normalized.endsWith(extension))) {
-      for (const extension of SOURCE_EXTENSIONS) {
+    if (JAVASCRIPT_EXTENSIONS.some((extension) => normalized.endsWith(extension))) {
+      for (const extension of preferredExtensions) {
         candidates.add(removeKnownExtension(normalized) + extension);
       }
     }
   }
   if (options.allowIndexFallback ?? true) {
-    for (const extension of SOURCE_EXTENSIONS) {
+    for (const extension of preferredExtensions) {
       candidates.add(`src/index${extension}`);
     }
   }
@@ -11896,7 +12361,10 @@ var resolveImportSourcePath = async (fromFile, specifier, fs, resolver) => {
     if (resolver === undefined)
       return null;
     for (const target of resolveTsConfigCandidates(specifier, resolver)) {
-      for (const candidate of createCandidatePaths(target, { allowIndexFallback: false })) {
+      for (const candidate of createCandidatePaths(target, {
+        allowIndexFallback: false,
+        preferJavaScript: isJavaScriptPath(fromFile)
+      })) {
         if (await fs.exists(candidate))
           return normalizeRelativePath(candidate);
       }
@@ -11904,7 +12372,7 @@ var resolveImportSourcePath = async (fromFile, specifier, fs, resolver) => {
     return null;
   }
   const baseDir = posix2.dirname(fromFile);
-  for (const candidate of createCandidatePaths(specifier)) {
+  for (const candidate of createCandidatePaths(specifier, { preferJavaScript: isJavaScriptPath(fromFile) })) {
     const fullPath = baseDir === "." ? candidate : posix2.join(baseDir, candidate);
     if (await fs.exists(fullPath)) {
       return normalizeRelativePath(fullPath);
@@ -12053,7 +12521,7 @@ var detectEntries = async (manifest, fs) => {
     package: {
       name: readString(pkg.name) ?? "unknown-package",
       kind: detectPackageKind(pkg),
-      language: "typescript",
+      language: packageLanguage(entries.map((entry) => entry.path)),
       version: readString(pkg.version) ?? undefined
     },
     entries,
@@ -12120,6 +12588,23 @@ var fileInfoSchema = exports_external.object({
   language: exports_external.string().min(1),
   lines: exports_external.number().int().nonnegative()
 });
+var extractionDiagnosticSchema = exports_external.object({
+  code: exports_external.string().min(1),
+  severity: exports_external.enum(["info", "warning", "error"]),
+  file: exports_external.string().min(1),
+  line: exports_external.number().int().positive(),
+  column: exports_external.number().int().positive()
+});
+var extractionCoverageSchema = exports_external.object({
+  tier: exports_external.enum(["ast-catalog", "lightweight-evidence"]),
+  capabilities: exports_external.array(exports_external.string().min(1)),
+  files: exports_external.array(exports_external.object({
+    path: exports_external.string().min(1),
+    disposition: exports_external.enum(["analyzed", "unsupported", "excluded"]),
+    diagnosticCodes: exports_external.array(exports_external.string().min(1))
+  })),
+  diagnostics: exports_external.array(extractionDiagnosticSchema)
+});
 var extractionMetaSchema = exports_external.object({
   extractedAt: exports_external.string().datetime(),
   pluginId: exports_external.string().min(1),
@@ -12146,6 +12631,7 @@ var extractionResultSchema = exports_external.object({
   files: exports_external.array(fileInfoSchema),
   symbols: exports_external.array(symbolInfoSchema),
   relations: exports_external.array(relationInfoSchema),
+  coverage: extractionCoverageSchema.optional(),
   stats: extractionStatsSchema
 });
 var digestStatsSchema = exports_external.object({
@@ -12162,6 +12648,7 @@ var digestDataSchema = exports_external.object({
   files: exports_external.array(fileInfoSchema),
   symbols: exports_external.array(symbolInfoSchema),
   relations: exports_external.array(relationInfoSchema),
+  coverage: extractionCoverageSchema.optional(),
   stats: digestStatsSchema
 });
 var symbolDiffSchema = exports_external.object({
@@ -12264,7 +12751,16 @@ class ExtractionPluginRegistry {
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 var execFileAsync = promisify(execFile);
-var SUPPORTED_EXTENSIONS = new Set([".ts", ".tsx"]);
+var SUPPORTED_EXTENSIONS = new Set([
+  ".ts",
+  ".tsx",
+  ".mts",
+  ".cts",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs"
+]);
 var MANIFEST_FILES = [
   "package.json",
   "pyproject.toml",
@@ -12316,10 +12812,613 @@ var codeExtractRunnerInputSchema = exports_external.object({
     worktreeContentHash: exports_external.string().min(1).optional()
   }).optional()
 });
+// ../extract/src/evidenceAdapter.ts
+function fact2(input) {
+  return createIndexerEvidenceAdapterFact({
+    source_ref: input.sourceRef,
+    module_ref: input.moduleRef,
+    normalized_path: input.normalizedPath,
+    qualified_item_path: input.qualifiedItemPath,
+    kind: input.kind,
+    signature: input.signature,
+    payload: input.payload,
+    denominator: input.denominator
+  });
+}
+function semanticExtractionPayload(extraction) {
+  return {
+    version: extraction.version,
+    meta: {
+      pluginId: extraction.meta.pluginId,
+      commitHash: extraction.meta.commitHash,
+      language: extraction.meta.language
+    },
+    package: extraction.package,
+    files: extraction.files,
+    symbols: extraction.symbols,
+    relations: extraction.relations,
+    coverage: extraction.coverage,
+    stats: extraction.stats
+  };
+}
+function relationSourceFile(relation, symbols) {
+  const candidates = symbols.filter((symbol) => symbol.name === relation.from);
+  if (candidates.length === 1)
+    return candidates[0].file;
+  if (relation.line !== undefined) {
+    const containing = candidates.filter((symbol) => symbol.line <= relation.line && symbol.endLine >= relation.line);
+    if (containing.length === 1)
+      return containing[0].file;
+  }
+  return null;
+}
+function diagnosticPayload(diagnostic) {
+  return {
+    code: diagnostic.code,
+    severity: diagnostic.severity,
+    file: diagnostic.file,
+    line: diagnostic.line,
+    column: diagnostic.column
+  };
+}
+function extractionResultToEvidenceAdapterResult(extraction, invocation) {
+  const coverage = extraction.coverage;
+  if (!coverage) {
+    throw new TypeError("ExtractionResult coverage is required for Evidence Adapter Result conversion");
+  }
+  if (coverage.capabilities.length === 0) {
+    throw new TypeError("ExtractionResult coverage must declare at least one parser capability");
+  }
+  const coverageByPath = new Map(coverage.files.map((file) => [file.path, file]));
+  const fileInfoByPath = new Map(extraction.files.map((file) => [file.path, file]));
+  for (const file of extraction.files) {
+    if (!coverageByPath.has(file.path)) {
+      throw new TypeError(`ExtractionResult file ${file.path} has no coverage disposition`);
+    }
+  }
+  for (const symbol of extraction.symbols) {
+    const disposition = coverageByPath.get(symbol.file)?.disposition;
+    if (disposition !== "analyzed") {
+      throw new TypeError(`ExtractionResult symbol ${symbol.name} belongs to a file without analyzed disposition`);
+    }
+  }
+  const role = invocation.role ?? "primary-owner";
+  const ownsDenominators = role === "primary-owner" && coverage.tier === "ast-catalog";
+  const generatedDiagnostics = [];
+  const relationsByFile = new Map;
+  for (const relation of extraction.relations) {
+    const file = relationSourceFile(relation, extraction.symbols);
+    if (file === null || coverageByPath.get(file)?.disposition !== "analyzed") {
+      generatedDiagnostics.push({
+        code: "relation-locator-unresolved",
+        severity: "warning",
+        detail_digest: indexerEvidenceAdapterProtocolDigest(relation)
+      });
+      continue;
+    }
+    const current = relationsByFile.get(file) ?? [];
+    current.push(relation);
+    relationsByFile.set(file, current);
+  }
+  const files = coverage.files.map((coverageFile) => {
+    const normalizedPath2 = coverageFile.path;
+    const fileRef = indexerEvidenceAdapterFileRef({
+      source_ref: invocation.authorized_scope.source_ref,
+      module_ref: invocation.module_ref,
+      normalized_path: normalizedPath2
+    });
+    const fileInfo = fileInfoByPath.get(normalizedPath2);
+    if (coverageFile.disposition === "analyzed" && !fileInfo) {
+      throw new TypeError(`Analyzed file ${normalizedPath2} has no ExtractionResult file metadata`);
+    }
+    const facts = [];
+    if (coverageFile.disposition === "analyzed" && fileInfo) {
+      facts.push(fact2({
+        sourceRef: invocation.authorized_scope.source_ref,
+        moduleRef: invocation.module_ref,
+        normalizedPath: normalizedPath2,
+        qualifiedItemPath: "file",
+        kind: "source-file",
+        signature: { path: normalizedPath2, language: fileInfo.language },
+        payload: fileInfo,
+        denominator: ownsDenominators ? "eligible-file" : "none"
+      }));
+      facts.push(fact2({
+        sourceRef: invocation.authorized_scope.source_ref,
+        moduleRef: invocation.module_ref,
+        normalizedPath: normalizedPath2,
+        qualifiedItemPath: "loc",
+        kind: "source-loc",
+        signature: { path: normalizedPath2 },
+        payload: { lines: fileInfo.lines },
+        denominator: ownsDenominators ? "loc" : "none"
+      }));
+      for (const symbol of extraction.symbols.filter((item) => item.file === normalizedPath2)) {
+        facts.push(fact2({
+          sourceRef: invocation.authorized_scope.source_ref,
+          moduleRef: invocation.module_ref,
+          normalizedPath: normalizedPath2,
+          qualifiedItemPath: `symbol:${symbol.kind}:${symbol.name}@${symbol.line}`,
+          kind: "code-symbol",
+          signature: {
+            name: symbol.name,
+            kind: symbol.kind,
+            signature: symbol.signature ?? null,
+            params: symbol.params ?? null,
+            returnType: symbol.returnType ?? null,
+            typeAnnotation: symbol.typeAnnotation ?? null
+          },
+          payload: symbol,
+          denominator: ownsDenominators ? "symbol" : "none"
+        }));
+      }
+      for (const relation of relationsByFile.get(normalizedPath2) ?? []) {
+        facts.push(fact2({
+          sourceRef: invocation.authorized_scope.source_ref,
+          moduleRef: invocation.module_ref,
+          normalizedPath: normalizedPath2,
+          qualifiedItemPath: `relation:${relation.type}:${relation.from}->${relation.to}@${relation.line ?? 0}`,
+          kind: "code-relation",
+          signature: relation,
+          payload: relation,
+          denominator: "none"
+        }));
+      }
+    }
+    return {
+      file_ref: fileRef,
+      source_ref: invocation.authorized_scope.source_ref,
+      module_ref: invocation.module_ref,
+      normalized_path: normalizedPath2,
+      role,
+      coverage_tier: coverage.tier,
+      disposition: coverageFile.disposition,
+      facts
+    };
+  });
+  const diagnostics = [
+    ...coverage.diagnostics.map((diagnostic) => {
+      const coverageFile = coverageByPath.get(diagnostic.file);
+      const fileRef = coverageFile ? indexerEvidenceAdapterFileRef({
+        source_ref: invocation.authorized_scope.source_ref,
+        module_ref: invocation.module_ref,
+        normalized_path: diagnostic.file
+      }) : undefined;
+      return {
+        code: diagnostic.code,
+        severity: diagnostic.severity,
+        detail_digest: indexerEvidenceAdapterProtocolDigest(diagnosticPayload(diagnostic)),
+        ...fileRef ? { fact_ref: fileRef } : {}
+      };
+    }),
+    ...generatedDiagnostics
+  ];
+  const parserOutputDigest = indexerEvidenceAdapterProtocolDigest(semanticExtractionPayload(extraction));
+  return buildIndexerEvidenceAdapterResult({
+    protocol: "context.indexer.evidence-adapter-result/v1",
+    adapter: invocation.adapter,
+    authorized_scope: invocation.authorized_scope,
+    input_digest: invocation.input_digest,
+    precedence: invocation.precedence,
+    files,
+    diagnostics,
+    toolchain: [{
+      step: "parse-source",
+      package: invocation.adapter.package,
+      export: invocation.adapter.export,
+      version: invocation.adapter.version,
+      digest: invocation.adapter.digest,
+      capabilities: coverage.capabilities,
+      input_digest: invocation.input_digest,
+      output_digest: parserOutputDigest
+    }]
+  });
+}
+// ../../node_modules/.bun/eslint-visitor-keys@5.0.1/node_modules/eslint-visitor-keys/lib/visitor-keys.js
+var KEYS = {
+  ArrayExpression: ["elements"],
+  ArrayPattern: ["elements"],
+  ArrowFunctionExpression: ["params", "body"],
+  AssignmentExpression: ["left", "right"],
+  AssignmentPattern: ["left", "right"],
+  AwaitExpression: ["argument"],
+  BinaryExpression: ["left", "right"],
+  BlockStatement: ["body"],
+  BreakStatement: ["label"],
+  CallExpression: ["callee", "arguments"],
+  CatchClause: ["param", "body"],
+  ChainExpression: ["expression"],
+  ClassBody: ["body"],
+  ClassDeclaration: ["id", "superClass", "body"],
+  ClassExpression: ["id", "superClass", "body"],
+  ConditionalExpression: ["test", "consequent", "alternate"],
+  ContinueStatement: ["label"],
+  DebuggerStatement: [],
+  DoWhileStatement: ["body", "test"],
+  EmptyStatement: [],
+  ExperimentalRestProperty: ["argument"],
+  ExperimentalSpreadProperty: ["argument"],
+  ExportAllDeclaration: ["exported", "source", "attributes"],
+  ExportDefaultDeclaration: ["declaration"],
+  ExportNamedDeclaration: [
+    "declaration",
+    "specifiers",
+    "source",
+    "attributes"
+  ],
+  ExportSpecifier: ["local", "exported"],
+  ExpressionStatement: ["expression"],
+  ForInStatement: ["left", "right", "body"],
+  ForOfStatement: ["left", "right", "body"],
+  ForStatement: ["init", "test", "update", "body"],
+  FunctionDeclaration: ["id", "params", "body"],
+  FunctionExpression: ["id", "params", "body"],
+  Identifier: [],
+  IfStatement: ["test", "consequent", "alternate"],
+  ImportAttribute: ["key", "value"],
+  ImportDeclaration: ["specifiers", "source", "attributes"],
+  ImportDefaultSpecifier: ["local"],
+  ImportExpression: ["source", "options"],
+  ImportNamespaceSpecifier: ["local"],
+  ImportSpecifier: ["imported", "local"],
+  JSXAttribute: ["name", "value"],
+  JSXClosingElement: ["name"],
+  JSXClosingFragment: [],
+  JSXElement: ["openingElement", "children", "closingElement"],
+  JSXEmptyExpression: [],
+  JSXExpressionContainer: ["expression"],
+  JSXFragment: ["openingFragment", "children", "closingFragment"],
+  JSXIdentifier: [],
+  JSXMemberExpression: ["object", "property"],
+  JSXNamespacedName: ["namespace", "name"],
+  JSXOpeningElement: ["name", "attributes"],
+  JSXOpeningFragment: [],
+  JSXSpreadAttribute: ["argument"],
+  JSXSpreadChild: ["expression"],
+  JSXText: [],
+  LabeledStatement: ["label", "body"],
+  Literal: [],
+  LogicalExpression: ["left", "right"],
+  MemberExpression: ["object", "property"],
+  MetaProperty: ["meta", "property"],
+  MethodDefinition: ["key", "value"],
+  NewExpression: ["callee", "arguments"],
+  ObjectExpression: ["properties"],
+  ObjectPattern: ["properties"],
+  PrivateIdentifier: [],
+  Program: ["body"],
+  Property: ["key", "value"],
+  PropertyDefinition: ["key", "value"],
+  RestElement: ["argument"],
+  ReturnStatement: ["argument"],
+  SequenceExpression: ["expressions"],
+  SpreadElement: ["argument"],
+  StaticBlock: ["body"],
+  Super: [],
+  SwitchCase: ["test", "consequent"],
+  SwitchStatement: ["discriminant", "cases"],
+  TaggedTemplateExpression: ["tag", "quasi"],
+  TemplateElement: [],
+  TemplateLiteral: ["quasis", "expressions"],
+  ThisExpression: [],
+  ThrowStatement: ["argument"],
+  TryStatement: ["block", "handler", "finalizer"],
+  UnaryExpression: ["argument"],
+  UpdateExpression: ["argument"],
+  VariableDeclaration: ["declarations"],
+  VariableDeclarator: ["id", "init"],
+  WhileStatement: ["test", "body"],
+  WithStatement: ["object", "body"],
+  YieldExpression: ["argument"]
+};
+var NODE_TYPES = Object.keys(KEYS);
+for (const type of NODE_TYPES) {
+  Object.freeze(KEYS[type]);
+}
+Object.freeze(KEYS);
+var visitor_keys_default = KEYS;
+
+// ../../node_modules/.bun/eslint-visitor-keys@5.0.1/node_modules/eslint-visitor-keys/lib/index.js
+var KEY_BLACKLIST = new Set([
+  "parent",
+  "leadingComments",
+  "trailingComments"
+]);
+function unionWith(additionalKeys) {
+  const retv = Object.assign({}, visitor_keys_default);
+  for (const type of Object.keys(additionalKeys)) {
+    if (Object.hasOwn(retv, type)) {
+      const keys = new Set(additionalKeys[type]);
+      for (const key of retv[type]) {
+        keys.add(key);
+      }
+      retv[type] = Object.freeze(Array.from(keys));
+    } else {
+      retv[type] = Object.freeze(Array.from(additionalKeys[type]));
+    }
+  }
+  return Object.freeze(retv);
+}
+
+// ../../node_modules/.bun/toml-eslint-parser@1.0.3/node_modules/toml-eslint-parser/lib/index.mjs
+function last(arr) {
+  return arr[arr.length - 1] ?? null;
+}
+var TOMLVerImpl = class {
+  constructor(major, minor) {
+    this.major = major;
+    this.minor = minor;
+  }
+  lt(major, minor) {
+    return this.major < major || this.major === major && this.minor < minor;
+  }
+  gte(major, minor) {
+    return this.major > major || this.major === major && this.minor >= minor;
+  }
+};
+var TOML_VERSION_1_0 = new TOMLVerImpl(1, 0);
+var TOML_VERSION_1_1 = new TOMLVerImpl(1, 1);
+var CodePoint = {
+  EOF: -1,
+  NULL: 0,
+  SOH: 1,
+  BACKSPACE: 8,
+  TABULATION: 9,
+  LINE_FEED: 10,
+  FORM_FEED: 12,
+  CARRIAGE_RETURN: 13,
+  ESCAPE: 27,
+  SO: 14,
+  US: 31,
+  SPACE: 32,
+  QUOTATION_MARK: 34,
+  HASH: 35,
+  SINGLE_QUOTE: 39,
+  PLUS_SIGN: 43,
+  COMMA: 44,
+  DASH: 45,
+  DOT: 46,
+  DIGIT_0: 48,
+  DIGIT_1: 49,
+  DIGIT_2: 50,
+  DIGIT_3: 51,
+  DIGIT_7: 55,
+  DIGIT_9: 57,
+  COLON: 58,
+  EQUALS_SIGN: 61,
+  LATIN_CAPITAL_A: 65,
+  LATIN_CAPITAL_E: 69,
+  LATIN_CAPITAL_F: 70,
+  LATIN_CAPITAL_T: 84,
+  LATIN_CAPITAL_U: 85,
+  LATIN_CAPITAL_Z: 90,
+  LEFT_BRACKET: 91,
+  BACKSLASH: 92,
+  RIGHT_BRACKET: 93,
+  UNDERSCORE: 95,
+  LATIN_SMALL_A: 97,
+  LATIN_SMALL_B: 98,
+  LATIN_SMALL_E: 101,
+  LATIN_SMALL_F: 102,
+  LATIN_SMALL_I: 105,
+  LATIN_SMALL_L: 108,
+  LATIN_SMALL_N: 110,
+  LATIN_SMALL_O: 111,
+  LATIN_SMALL_R: 114,
+  LATIN_SMALL_S: 115,
+  LATIN_SMALL_T: 116,
+  LATIN_SMALL_U: 117,
+  LATIN_SMALL_X: 120,
+  LATIN_SMALL_Z: 122,
+  LEFT_BRACE: 123,
+  RIGHT_BRACE: 125,
+  TILDE: 126,
+  DELETE: 127,
+  PAD: 128,
+  SUPERSCRIPT_TWO: 178,
+  SUPERSCRIPT_THREE: 179,
+  SUPERSCRIPT_ONE: 185,
+  VULGAR_FRACTION_ONE_QUARTER: 188,
+  VULGAR_FRACTION_THREE_QUARTERS: 190,
+  LATIN_CAPITAL_LETTER_A_WITH_GRAVE: 192,
+  LATIN_CAPITAL_LETTER_O_WITH_DIAERESIS: 214,
+  LATIN_CAPITAL_LETTER_O_WITH_STROKE: 216,
+  LATIN_SMALL_LETTER_O_WITH_DIAERESIS: 246,
+  LATIN_SMALL_LETTER_O_WITH_STROKE: 248,
+  GREEK_SMALL_REVERSED_DOTTED_LUNATE_SIGMA_SYMBOL: 891,
+  GREEK_CAPITAL_LETTER_YOT: 895,
+  CP_1FFF: 8191,
+  ZERO_WIDTH_NON_JOINER: 8204,
+  ZERO_WIDTH_JOINER: 8205,
+  UNDERTIE: 8255,
+  CHARACTER_TIE: 8256,
+  SUPERSCRIPT_ZERO: 8304,
+  CP_218F: 8591,
+  CIRCLED_DIGIT_ONE: 9312,
+  NEGATIVE_CIRCLED_DIGIT_ZERO: 9471,
+  GLAGOLITIC_CAPITAL_LETTER_AZU: 11264,
+  CP_2FEF: 12271,
+  IDEOGRAPHIC_COMMA: 12289,
+  CP_D7FF: 55295,
+  CP_E000: 57344,
+  CJK_COMPATIBILITY_IDEOGRAPH_F900: 63744,
+  ARABIC_LIGATURE_SALAAMUHU_ALAYNAA: 64975,
+  ARABIC_LIGATURE_SALLA_USED_AS_KORANIC_STOP_SIGN_ISOLATED_FORM: 65008,
+  REPLACEMENT_CHARACTER: 65533,
+  LINEAR_B_SYLLABLE_B008_A: 65536,
+  CP_EFFFF: 983039,
+  CP_10FFFF: 1114111
+};
+var ESCAPES_1_0 = {
+  [CodePoint.QUOTATION_MARK]: CodePoint.QUOTATION_MARK,
+  [CodePoint.BACKSLASH]: CodePoint.BACKSLASH,
+  [CodePoint.LATIN_SMALL_B]: CodePoint.BACKSPACE,
+  [CodePoint.LATIN_SMALL_F]: CodePoint.FORM_FEED,
+  [CodePoint.LATIN_SMALL_N]: CodePoint.LINE_FEED,
+  [CodePoint.LATIN_SMALL_R]: CodePoint.CARRIAGE_RETURN,
+  [CodePoint.LATIN_SMALL_T]: CodePoint.TABULATION
+};
+var ESCAPES_LATEST = {
+  ...ESCAPES_1_0,
+  [CodePoint.LATIN_SMALL_E]: CodePoint.ESCAPE
+};
+var VALUE_KIND_VALUE = Symbol("VALUE_KIND_VALUE");
+var VALUE_KIND_INTERMEDIATE = Symbol("VALUE_KIND_INTERMEDIATE");
+var tomlKeys = {
+  Program: ["body"],
+  TOMLTopLevelTable: ["body"],
+  TOMLTable: ["key", "body"],
+  TOMLKeyValue: ["key", "value"],
+  TOMLKey: ["keys"],
+  TOMLArray: ["elements"],
+  TOMLInlineTable: ["body"],
+  TOMLBare: [],
+  TOMLQuoted: [],
+  TOMLValue: []
+};
+var KEYS2 = unionWith(tomlKeys);
+var getStaticTOMLValue = generateConvertTOMLValue((node2) => node2.value);
+function generateConvertTOMLValue(convertValue) {
+  function resolveValue(node2, baseTable) {
+    return resolver[node2.type](node2, baseTable);
+  }
+  const resolver = {
+    Program(node2, baseTable = {}) {
+      return resolveValue(node2.body[0], baseTable);
+    },
+    TOMLTopLevelTable(node2, baseTable = {}) {
+      for (const body of node2.body)
+        resolveValue(body, baseTable);
+      return baseTable;
+    },
+    TOMLKeyValue(node2, baseTable = {}) {
+      const value = resolveValue(node2.value);
+      set(baseTable, resolveValue(node2.key), value);
+      return baseTable;
+    },
+    TOMLTable(node2, baseTable = {}) {
+      const table = getTable(baseTable, resolveValue(node2.key), node2.kind === "array");
+      for (const body of node2.body)
+        resolveValue(body, table);
+      return baseTable;
+    },
+    TOMLArray(node2) {
+      return node2.elements.map((e) => resolveValue(e));
+    },
+    TOMLInlineTable(node2) {
+      const table = {};
+      for (const body of node2.body)
+        resolveValue(body, table);
+      return table;
+    },
+    TOMLKey(node2) {
+      return node2.keys.map((key) => resolveValue(key));
+    },
+    TOMLBare(node2) {
+      return node2.name;
+    },
+    TOMLQuoted(node2) {
+      return node2.value;
+    },
+    TOMLValue(node2) {
+      return convertValue(node2);
+    }
+  };
+  return (node2) => resolveValue(node2);
+}
+function getTable(baseTable, keys, array) {
+  let target = baseTable;
+  for (let index = 0;index < keys.length - 1; index++) {
+    const key = keys[index];
+    target = getNextTargetFromKey(target, key);
+  }
+  const lastKey = last(keys);
+  const lastTarget = target[lastKey];
+  if (lastTarget == null) {
+    const tableValue$1 = {};
+    target[lastKey] = array ? [tableValue$1] : tableValue$1;
+    return tableValue$1;
+  }
+  if (isValue(lastTarget)) {
+    const tableValue$1 = {};
+    target[lastKey] = array ? [tableValue$1] : tableValue$1;
+    return tableValue$1;
+  }
+  if (!array) {
+    if (Array.isArray(lastTarget)) {
+      const tableValue$1 = {};
+      target[lastKey] = tableValue$1;
+      return tableValue$1;
+    }
+    return lastTarget;
+  }
+  if (Array.isArray(lastTarget)) {
+    const tableValue$1 = {};
+    lastTarget.push(tableValue$1);
+    return tableValue$1;
+  }
+  const tableValue = {};
+  target[lastKey] = [tableValue];
+  return tableValue;
+  function getNextTargetFromKey(currTarget, key) {
+    const nextTarget = currTarget[key];
+    if (nextTarget == null) {
+      const val = {};
+      currTarget[key] = val;
+      return val;
+    }
+    if (isValue(nextTarget)) {
+      const val = {};
+      currTarget[key] = val;
+      return val;
+    }
+    let resultTarget = nextTarget;
+    while (Array.isArray(resultTarget)) {
+      const lastIndex = resultTarget.length - 1;
+      const nextElement = resultTarget[lastIndex];
+      if (isValue(nextElement)) {
+        const val = {};
+        resultTarget[lastIndex] = val;
+        return val;
+      }
+      resultTarget = nextElement;
+    }
+    return resultTarget;
+  }
+}
+function set(baseTable, keys, value) {
+  let target = baseTable;
+  for (let index = 0;index < keys.length - 1; index++) {
+    const key = keys[index];
+    const nextTarget = target[key];
+    if (nextTarget == null) {
+      const val = {};
+      target[key] = val;
+      target = val;
+    } else if (isValue(nextTarget) || Array.isArray(nextTarget)) {
+      const val = {};
+      target[key] = val;
+      target = val;
+    } else
+      target = nextTarget;
+  }
+  target[last(keys)] = value;
+}
+function isValue(value) {
+  return typeof value !== "object" || value instanceof Date;
+}
+
+// ../extract/src/configEvidenceParser.ts
+var import_yaml2 = __toESM(require_dist(), 1);
 // ../extract/src/parser.ts
-import Parser from "web-tree-sitter";
+import * as WebTreeSitter from "web-tree-sitter";
 import { existsSync } from "node:fs";
 import { fileURLToPath } from "node:url";
+var treeSitterRuntime = WebTreeSitter;
+var Parser = treeSitterRuntime.default ?? treeSitterRuntime.Parser;
+if (!Parser) {
+  throw new TypeError("web-tree-sitter runtime does not expose Parser");
+}
 var parserInitPromise = null;
 var parsedBytesSinceReset = 0;
 var parserDead = false;
@@ -12329,9 +13428,13 @@ var createParserInstance = async () => {
   const localWasm = resolveWasmPath("./wasm/tree-sitter.wasm");
   const initOptions = existsSync(localWasm) ? { locateFile: (scriptName) => resolveWasmPath(`./wasm/${scriptName}`) } : undefined;
   await Parser.init(initOptions);
+  const LanguageRuntime = treeSitterRuntime.default?.Language ?? treeSitterRuntime.Language;
+  if (!LanguageRuntime) {
+    throw new TypeError("web-tree-sitter runtime does not expose Language after initialization");
+  }
   const parser = new Parser;
-  const tsLanguage = await Parser.Language.load(resolveWasmPath("./wasm/tree-sitter-typescript.wasm"));
-  const tsxLanguage = await Parser.Language.load(resolveWasmPath("./wasm/tree-sitter-tsx.wasm"));
+  const tsLanguage = await LanguageRuntime.load(resolveWasmPath("./wasm/tree-sitter-typescript.wasm"));
+  const tsxLanguage = await LanguageRuntime.load(resolveWasmPath("./wasm/tree-sitter-tsx.wasm"));
   return { parser, tsLanguage, tsxLanguage };
 };
 var initParser = async () => {
@@ -12382,6 +13485,363 @@ var parseFile = async (source, isTsx) => {
     return null;
   }
 };
+// src/commonJsModule.ts
+import ts2 from "typescript";
+
+// src/typescriptAst.ts
+import ts from "typescript";
+var scriptKind = (filePath) => {
+  const lower = filePath.toLowerCase();
+  if (lower.endsWith(".tsx"))
+    return ts.ScriptKind.TSX;
+  if (lower.endsWith(".jsx"))
+    return ts.ScriptKind.JSX;
+  if (lower.endsWith(".js") || lower.endsWith(".mjs") || lower.endsWith(".cjs")) {
+    return ts.ScriptKind.JS;
+  }
+  return ts.ScriptKind.TS;
+};
+var createEcmaScriptSourceFile = (source, filePath) => ts.createSourceFile(filePath, source, ts.ScriptTarget.Latest, true, scriptKind(filePath));
+var syntaxDiagnostics = (sourceFile) => {
+  const diagnostics = sourceFile.parseDiagnostics ?? [];
+  return diagnostics.map((diagnostic) => {
+    const start = diagnostic.start ?? 0;
+    const position = sourceFile.getLineAndCharacterOfPosition(start);
+    return {
+      code: "ecmascript-syntax-error",
+      severity: "error",
+      file: sourceFile.fileName,
+      line: position.line + 1,
+      column: position.character + 1
+    };
+  });
+};
+var nodeLocation = (sourceFile, node2) => {
+  const start = sourceFile.getLineAndCharacterOfPosition(node2.getStart(sourceFile));
+  const end = sourceFile.getLineAndCharacterOfPosition(node2.getEnd());
+  return {
+    line: start.line + 1,
+    column: start.character + 1,
+    endLine: end.line + 1
+  };
+};
+var staticStringValue = (node2) => {
+  if (!node2)
+    return null;
+  if (ts.isStringLiteral(node2) || ts.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 requireReference = (node2) => {
+  const direct = requireCall(node2);
+  if (direct) {
+    const source = staticStringValue(direct.arguments[0]);
+    return source ? { source, importedName: "*" } : null;
+  }
+  if (ts2.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)) {
+    const call = requireCall(node2.expression);
+    const source = call ? staticStringValue(call.arguments[0]) : null;
+    const importedName = staticStringValue(node2.argumentExpression);
+    return source && importedName ? { source, importedName } : null;
+  }
+  return null;
+};
+var isModuleExports = (node2) => {
+  if (ts2.isPropertyAccessExpression(node2) && ts2.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";
+};
+var isExportsObject = (node2) => ts2.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])) {
+    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);
+};
+var commonJsExportTarget = (node2) => {
+  if (ts2.isPropertyAccessExpression(node2)) {
+    if (ts2.isIdentifier(node2.expression) && node2.expression.text === "exports") {
+      return { kind: "named", exportedName: node2.name.text };
+    }
+    if (isModuleExports(node2.expression)) {
+      return { kind: "named", exportedName: node2.name.text };
+    }
+    if (isModuleExports(node2))
+      return { kind: "whole" };
+  }
+  if (ts2.isElementAccessExpression(node2)) {
+    const property = staticStringValue(node2.argumentExpression);
+    if (ts2.isIdentifier(node2.expression) && node2.expression.text === "exports" && property) {
+      return { kind: "named", exportedName: property };
+    }
+    if (isModuleExports(node2.expression) && property) {
+      return { kind: "named", exportedName: property };
+    }
+    if (isModuleExports(node2))
+      return { kind: "whole" };
+  }
+  return null;
+};
+var localReference = (expression, bindings) => {
+  if (ts2.isIdentifier(expression)) {
+    const binding = bindings.get(expression.text);
+    if (binding) {
+      return {
+        source: binding.source,
+        importedName: binding.importedName
+      };
+    }
+    return { localName: expression.text };
+  }
+  if (ts2.isPropertyAccessExpression(expression) && ts2.isIdentifier(expression.expression)) {
+    const binding = bindings.get(expression.expression.text);
+    if (binding)
+      return { source: binding.source, importedName: expression.name.text };
+  }
+  const required = requireReference(expression);
+  return required ? { source: required.source, importedName: required.importedName } : null;
+};
+var syntheticDeclaration = (name, expression, sourceFile) => {
+  const location = nodeLocation(sourceFile, expression);
+  if (ts2.isFunctionExpression(expression) || ts2.isArrowFunction(expression)) {
+    return {
+      name,
+      kind: "function",
+      line: location.line,
+      endLine: location.endLine,
+      params: expression.parameters.map((parameter) => parameter.name.getText(sourceFile))
+    };
+  }
+  if (ts2.isClassExpression(expression)) {
+    return { name, kind: "class", line: location.line, endLine: location.endLine, params: [] };
+  }
+  if (ts2.isObjectLiteralExpression(expression) || ts2.isArrayLiteralExpression(expression) || ts2.isLiteralExpression(expression)) {
+    return { name, kind: "variable", line: location.line, endLine: location.endLine, params: [] };
+  }
+  return null;
+};
+var pushExport = (result, exportedName, expression, line, bindings, sourceFile) => {
+  const reference = localReference(expression, bindings);
+  if (reference) {
+    result.exports.push({ exportedName, ...reference, line });
+    return true;
+  }
+  const synthetic = syntheticDeclaration(exportedName, expression, sourceFile);
+  if (synthetic) {
+    result.syntheticDeclarations.push(synthetic);
+    result.exports.push({ exportedName, localName: exportedName, line });
+    return true;
+  }
+  return false;
+};
+var appendUnsupportedExportDiagnostic = (result, sourceFile, node2) => {
+  const location = nodeLocation(sourceFile, node2);
+  if (result.diagnostics.some((diagnostic) => diagnostic.code === "dynamic-commonjs-require" && diagnostic.line === location.line && diagnostic.column === location.column))
+    return;
+  result.diagnostics.push({
+    code: "unsupported-commonjs-export-expression",
+    severity: "error",
+    file: sourceFile.fileName,
+    line: location.line,
+    column: location.column
+  });
+};
+var collectBindings = (sourceFile) => {
+  const bindings = [];
+  for (const statement of sourceFile.statements) {
+    if (!ts2.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)) {
+        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 visit = (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, visit);
+  };
+  visit(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",
@@ -12499,12 +13959,24 @@ var traceFile = async (filePath, fs, state) => {
     state.inFlight.add(filePath);
     state.files.add(filePath);
     const source = await fs.readFile(filePath);
-    const tree = await parseFile(source, filePath.endsWith(".tsx"));
+    const commonJs = analyzeCommonJsModule(source, filePath);
+    if (commonJs.diagnostics.length > 0)
+      return [];
+    const tree = await parseFile(source, isJsxLikePath(filePath));
     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")
@@ -12576,6 +14048,16 @@ var traceFile = async (filePath, fs, state) => {
         });
       }
     }
+    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);
   })();
@@ -12727,7 +14209,7 @@ var appendTypeRelations = (relations, relationType, from, typeText, importBindin
   }
 };
 var classifyVariable = (name, filePath) => {
-  if (filePath.endsWith(".tsx") && /^[A-Z]/.test(name)) {
+  if ((filePath.endsWith(".tsx") || filePath.endsWith(".jsx")) && /^[A-Z]/.test(name)) {
     return "component" /* Component */;
   }
   return "variable" /* Variable */;
@@ -12887,6 +14369,146 @@ var findObjectTypeNodes = (node2) => {
   return [];
 };
 
+// src/staticCallRelations.ts
+import ts3 from "typescript";
+var callTarget = (expression, sourceFile) => {
+  if (ts3.isIdentifier(expression))
+    return expression.text === "require" ? null : expression.text;
+  if (ts3.isPropertyAccessExpression(expression))
+    return expression.getText(sourceFile).replace(/\s+/gu, "");
+  if (ts3.isElementAccessExpression(expression)) {
+    const property = staticStringValue(expression.argumentExpression);
+    return property ? `${expression.expression.getText(sourceFile).replace(/\s+/gu, "")}.${property}` : null;
+  }
+  return null;
+};
+var rootIdentifier = (expression) => {
+  let current = expression;
+  while (ts3.isPropertyAccessExpression(current) || ts3.isElementAccessExpression(current)) {
+    current = current.expression;
+  }
+  return ts3.isIdentifier(current) ? current.text : null;
+};
+var declarationName = (node2, sourceFile) => {
+  if (ts3.isFunctionDeclaration(node2) && node2.name)
+    return node2.name.text;
+  if (ts3.isClassDeclaration(node2) && node2.name)
+    return node2.name.text;
+  if (ts3.isVariableDeclaration(node2) && ts3.isIdentifier(node2.name))
+    return node2.name.text;
+  if (ts3.isMethodDeclaration(node2) || ts3.isGetAccessorDeclaration(node2) || ts3.isSetAccessorDeclaration(node2)) {
+    const parent = node2.parent;
+    if (parent && ts3.isClassDeclaration(parent) && parent.name)
+      return parent.name.text;
+    return node2.name?.getText(sourceFile) ?? null;
+  }
+  return null;
+};
+var collectStaticCallRelations = (source, filePath, importBindings) => {
+  const sourceFile = createEcmaScriptSourceFile(source, filePath);
+  const relations = [];
+  const visit = (node2, owner) => {
+    const namedOwner = declarationName(node2, sourceFile) ?? owner;
+    if (ts3.isCallExpression(node2) || ts3.isNewExpression(node2)) {
+      const target = callTarget(node2.expression, sourceFile);
+      if (target) {
+        const root = rootIdentifier(node2.expression);
+        const isExternal = root ? importBindings.get(root)?.isExternal ?? false : false;
+        relations.push(createRelation("calls" /* Calls */, namedOwner, target, isExternal, nodeLocation(sourceFile, node2).line));
+      }
+    }
+    ts3.forEachChild(node2, (child) => visit(child, namedOwner));
+  };
+  visit(sourceFile, filePath);
+  const seen = new Set;
+  return relations.sort((left, right) => (left.line ?? 0) - (right.line ?? 0) || left.from.localeCompare(right.from) || left.to.localeCompare(right.to)).filter((relation) => {
+    const key = `${relation.from}\x00${relation.to}\x00${relation.line ?? 0}`;
+    if (seen.has(key))
+      return false;
+    seen.add(key);
+    return true;
+  });
+};
+
+// src/symbolExtractorImports.ts
+var esmImportParts = (node2, bindings, isExternal, statementTypeOnly) => {
+  let hasValueImport = !statementTypeOnly;
+  let hasTypeImport = statementTypeOnly;
+  const clause = node2.namedChildren.find((child) => child.type === "import_clause");
+  for (const part of clause?.namedChildren ?? []) {
+    if (part.type === "identifier") {
+      bindings.set(part.text, { isExternal, typeOnly: statementTypeOnly });
+      continue;
+    }
+    if (part.type === "namespace_import") {
+      const identifier = part.namedChildren.find((child) => child.type === "identifier");
+      if (identifier)
+        bindings.set(identifier.text, { isExternal, typeOnly: statementTypeOnly });
+      continue;
+    }
+    if (part.type !== "named_imports")
+      continue;
+    for (const specifierNode of part.namedChildren.filter((child) => child.type === "import_specifier")) {
+      const identifiers = specifierNode.namedChildren.filter((child) => child.type === "identifier" || child.type === "type_identifier").map((child) => child.text);
+      const localName = identifiers[1] ?? identifiers[0];
+      if (!localName)
+        continue;
+      const typeOnly = statementTypeOnly || specifierNode.text.trim().startsWith("type ");
+      bindings.set(localName, { isExternal, typeOnly });
+      hasValueImport ||= !typeOnly;
+      hasTypeImport ||= typeOnly;
+    }
+  }
+  return { hasValueImport, hasTypeImport };
+};
+var appendEsmImport = async (input) => {
+  const specifierNode = input.node.namedChildren.find((child) => child.type === "string");
+  if (!specifierNode)
+    return;
+  const specifier = specifierNode.text.replace(/^['"]/, "").replace(/['"]$/, "");
+  const resolvedAlias = isRelativeModuleSpecifier(specifier) ? null : await resolveImportSourcePath(input.filePath, specifier, input.fs, input.resolver);
+  const isExternal = !isRelativeModuleSpecifier(specifier) && resolvedAlias === null;
+  const statementTypeOnly = input.node.text.startsWith("import type ");
+  const parts = esmImportParts(input.node, input.bindings, isExternal, statementTypeOnly);
+  if (parts.hasValueImport) {
+    input.relations.push(createRelation("imports" /* Imports */, "", resolvedAlias ?? specifier, isExternal, getLine(input.node)));
+  }
+  if (parts.hasTypeImport) {
+    input.relations.push(createRelation("imports_type" /* ImportsType */, "", resolvedAlias ?? specifier, isExternal, getLine(input.node)));
+  }
+};
+var appendCommonJsImports = async (input) => {
+  const recordedSources = new Set;
+  for (const binding of input.commonJs.bindings) {
+    const resolved = await resolveImportSourcePath(input.filePath, binding.source, input.fs, input.resolver);
+    const isExternal = !isRelativeModuleSpecifier(binding.source) && resolved === null;
+    input.bindings.set(binding.localName, { isExternal, typeOnly: false });
+    if (recordedSources.has(binding.source))
+      continue;
+    recordedSources.add(binding.source);
+    input.relations.push(createRelation("imports" /* Imports */, "", resolved ?? binding.source, isExternal, binding.line));
+  }
+  const remainingSources = [...new Set([
+    ...input.commonJs.wildcardSources,
+    ...input.commonJs.exports.flatMap((item) => item.source ? [item.source] : [])
+  ])].sort();
+  for (const source of remainingSources) {
+    if (recordedSources.has(source))
+      continue;
+    const resolved = await resolveImportSourcePath(input.filePath, source, input.fs, input.resolver);
+    const isExternal = !isRelativeModuleSpecifier(source) && resolved === null;
+    input.relations.push(createRelation("imports" /* Imports */, "", resolved ?? source, isExternal, input.commonJs.exports.find((item) => item.source === source)?.line ?? 1));
+  }
+};
+var collectImportBindings2 = async (root, filePath, fs, resolver, relations, commonJs) => {
+  const bindings = new Map;
+  for (const node2 of root.namedChildren.filter((child) => child.type === "import_statement")) {
+    await appendEsmImport({ node: node2, filePath, fs, resolver, bindings, relations });
+  }
+  await appendCommonJsImports({ commonJs, filePath, fs, resolver, bindings, relations });
+  return bindings;
+};
+
 // src/symbolExtractorAnalyze.ts
 var analyzeDeclaration = (node2, filePath, declarations, importBindings, relations) => {
   if (node2.type === "lexical_declaration") {
@@ -12971,7 +14593,7 @@ var analyzeFunctionDeclaration = (node2, name, filePath, declarations, importBin
   declarations.set(name, {
     info: {
       name,
-      kind: "function" /* Function */,
+      kind: isJsxLikePath(filePath) && /^[A-Z]/u.test(name) && containsJsx(node2) ? "component" /* Component */ : "function" /* Function */,
       visibility: "internal" /* Internal */,
       file: filePath,
       line: getLine(node2),
@@ -13078,68 +14700,61 @@ var analyzeEnumDeclaration = (node2, name, symbolDoc, filePath, declarations) =>
     }
   });
 };
-var collectImportBindings2 = async (root, filePath, fs, resolver, relations) => {
-  const bindings = new Map;
-  for (const node2 of root.namedChildren.filter((child) => child.type === "import_statement")) {
-    const specifierNode = node2.namedChildren.find((child) => child.type === "string");
-    if (!specifierNode)
+var appendCommonJsSyntheticDeclarations = (commonJs, filePath, declarations) => {
+  for (const declaration of commonJs.syntheticDeclarations) {
+    if (declarations.has(declaration.name))
       continue;
-    const specifier = specifierNode.text.replace(/^['"]/, "").replace(/['"]$/, "");
-    const resolvedAlias = isRelativeModuleSpecifier(specifier) ? null : await resolveImportSourcePath(filePath, specifier, fs, resolver);
-    const isExternal = !isRelativeModuleSpecifier(specifier) && resolvedAlias === null;
-    const relationTarget = resolvedAlias ?? specifier;
-    const statementTypeOnly = node2.text.startsWith("import type ");
-    let hasValueImport = !statementTypeOnly;
-    let hasTypeImport = statementTypeOnly;
-    const clause = node2.namedChildren.find((child) => child.type === "import_clause");
-    for (const part of clause?.namedChildren ?? []) {
-      if (part.type === "identifier") {
-        bindings.set(part.text, { isExternal, typeOnly: statementTypeOnly });
-        continue;
-      }
-      if (part.type === "namespace_import") {
-        const identifier = part.namedChildren.find((child) => child.type === "identifier");
-        if (identifier) {
-          bindings.set(identifier.text, { isExternal, typeOnly: statementTypeOnly });
-        }
-        continue;
-      }
-      if (part.type !== "named_imports")
-        continue;
-      for (const specifierNode2 of part.namedChildren.filter((child) => child.type === "import_specifier")) {
-        const identifiers = specifierNode2.namedChildren.filter((child) => child.type === "identifier" || child.type === "type_identifier").map((child) => child.text);
-        const localName = identifiers[1] ?? identifiers[0];
-        if (!localName)
-          continue;
-        const typeOnly = statementTypeOnly || specifierNode2.text.trim().startsWith("type ");
-        bindings.set(localName, { isExternal, typeOnly });
-        hasValueImport ||= !typeOnly;
-        hasTypeImport ||= typeOnly;
+    declarations.set(declaration.name, {
+      info: {
+        name: declaration.name,
+        kind: declaration.kind === "function" ? isJsxLikePath(filePath) && /^[A-Z]/u.test(declaration.name) ? "component" /* Component */ : "function" /* Function */ : declaration.kind === "class" ? "class" /* Class */ : "variable" /* Variable */,
+        visibility: "internal" /* Internal */,
+        file: filePath,
+        line: declaration.line,
+        endLine: declaration.endLine,
+        ...declaration.params.length > 0 ? { params: declaration.params.map((name) => ({ name, type: null })) } : {}
       }
-    }
-    if (hasValueImport) {
-      relations.push(createRelation("imports" /* Imports */, "", relationTarget, isExternal, getLine(node2)));
-    }
-    if (hasTypeImport) {
-      relations.push(createRelation("imports_type" /* ImportsType */, "", relationTarget, isExternal, getLine(node2)));
-    }
+    });
   }
-  return bindings;
 };
 var analyzeFile = async (filePath, fs, resolver = { mappings: [] }) => {
   const source = await fs.readFile(filePath);
-  const tree = await parseFile(source, filePath.endsWith(".tsx"));
+  const sourceFile = createEcmaScriptSourceFile(source, filePath);
+  const commonJs = analyzeCommonJsModule(source, filePath);
+  const tree = await parseFile(source, isJsxLikePath(filePath));
   if (!tree) {
+    const diagnostics = syntaxDiagnostics(sourceFile);
+    if (diagnostics.length === 0) {
+      diagnostics.push({
+        code: "ecmascript-parser-unsupported",
+        severity: "error",
+        file: filePath,
+        line: 1,
+        column: 1
+      });
+    }
+    return {
+      declarations: new Map,
+      importBindings: new Map,
+      relations: [],
+      lines: countLines(source),
+      disposition: "unsupported",
+      diagnostics
+    };
+  }
+  if (commonJs.diagnostics.length > 0) {
     return {
       declarations: new Map,
       importBindings: new Map,
       relations: [],
-      lines: countLines(source)
+      lines: countLines(source),
+      disposition: "unsupported",
+      diagnostics: commonJs.diagnostics
     };
   }
   const root = tree.rootNode;
   const relations = [];
-  const importBindings = await collectImportBindings2(root, filePath, fs, resolver, relations);
+  const importBindings = await collectImportBindings2(root, filePath, fs, resolver, relations, commonJs);
   const declarations = new Map;
   for (const relation of relations) {
     if (relation.from === "") {
@@ -13158,11 +14773,15 @@ var analyzeFile = async (filePath, fs, resolver = { mappings: [] }) => {
       analyzeDeclaration(declaration, filePath, declarations, importBindings, relations);
     }
   }
+  appendCommonJsSyntheticDeclarations(commonJs, filePath, declarations);
+  relations.push(...collectStaticCallRelations(source, filePath, importBindings));
   return {
     declarations,
     importBindings,
     relations,
-    lines: countLines(source)
+    lines: countLines(source),
+    disposition: "analyzed",
+    diagnostics: []
   };
 };
 
@@ -13243,21 +14862,38 @@ var extractSymbols = async (entries, fs, options) => {
   }
   const files = [...filePaths].sort().map((filePath) => ({
     path: filePath,
-    language: filePath.endsWith(".tsx") ? "tsx" : "typescript",
+    language: ecmaScriptLanguage(filePath),
     lines: analyses.get(filePath)?.lines ?? 0
   }));
+  const coverageFiles = files.map((file) => {
+    const analysis = analyses.get(file.path);
+    return {
+      path: file.path,
+      disposition: analysis?.disposition ?? "unsupported",
+      diagnosticCodes: analysis?.diagnostics.map((diagnostic) => diagnostic.code) ?? [
+        "ecmascript-analysis-missing"
+      ]
+    };
+  });
+  const diagnostics = [...analyses.values()].flatMap((analysis) => analysis.diagnostics).sort((left, right) => left.file.localeCompare(right.file) || left.line - right.line || left.column - right.column);
   return {
     version: "2",
     meta: {
       extractedAt: new Date().toISOString(),
       pluginId: options.pluginId,
       commitHash: null,
-      language: "typescript"
+      language: options.packageInfo.language
     },
     package: options.packageInfo,
     files,
     symbols,
     relations,
+    coverage: {
+      tier: EXTRACT_TS_COVERAGE_TIER,
+      capabilities: [...EXTRACT_TS_CAPABILITIES],
+      files: coverageFiles,
+      diagnostics
+    },
     stats: {
       files: files.length,
       lines: files.reduce((sum, file) => sum + file.lines, 0),
@@ -13271,8 +14907,10 @@ var extractSymbols = async (entries, fs, options) => {
 // src/plugin.ts
 class TypeScriptPlugin {
   id = "c4a-extract-ts";
-  languages = ["typescript", "tsx"];
+  languages = ["typescript", "tsx", "javascript", "jsx"];
   packageManagers = ["npm"];
+  capabilities = [...EXTRACT_TS_CAPABILITIES];
+  coverageTier = EXTRACT_TS_COVERAGE_TIER;
   manifestTypes = ["package.json"];
   #lastDetection = null;
   canHandle(source) {
@@ -13297,20 +14935,20 @@ class TypeScriptPlugin {
   }
 }
 // src/reactRouter.ts
-import * as ts from "typescript";
+import * as ts4 from "typescript";
 function compact(value) {
   return value.replace(/\s+/gu, " ").trim();
 }
 function scalarValue(node2) {
   if (!node2)
     return;
-  if (ts.isStringLiteralLike(node2) || ts.isNoSubstitutionTemplateLiteral(node2))
+  if (ts4.isStringLiteralLike(node2) || ts4.isNoSubstitutionTemplateLiteral(node2))
     return node2.text;
-  if (ts.isNumericLiteral(node2))
+  if (ts4.isNumericLiteral(node2))
     return Number(node2.text);
-  if (node2.kind === ts.SyntaxKind.TrueKeyword)
+  if (node2.kind === ts4.SyntaxKind.TrueKeyword)
     return true;
-  if (node2.kind === ts.SyntaxKind.FalseKeyword)
+  if (node2.kind === ts4.SyntaxKind.FalseKeyword)
     return false;
   return;
 }
@@ -13319,37 +14957,37 @@ function findDynamicImport(node2) {
   const visit = (child) => {
     if (result)
       return;
-    if (ts.isCallExpression(child) && child.expression.kind === ts.SyntaxKind.ImportKeyword && child.arguments[0] && ts.isStringLiteralLike(child.arguments[0])) {
+    if (ts4.isCallExpression(child) && child.expression.kind === ts4.SyntaxKind.ImportKeyword && child.arguments[0] && ts4.isStringLiteralLike(child.arguments[0])) {
       result = child.arguments[0].text;
       return;
     }
-    ts.forEachChild(child, visit);
+    ts4.forEachChild(child, visit);
   };
   visit(node2);
   return result;
 }
 function parseSource(source, filePath) {
-  const sourceFile = ts.createSourceFile(filePath, source, ts.ScriptTarget.Latest, true, filePath.endsWith(".tsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS);
+  const sourceFile = ts4.createSourceFile(filePath, source, ts4.ScriptTarget.Latest, true, filePath.endsWith(".tsx") ? ts4.ScriptKind.TSX : ts4.ScriptKind.TS);
   const imports = new Map;
   const constants2 = new Map;
   for (const statement of sourceFile.statements) {
-    if (ts.isImportDeclaration(statement) && ts.isStringLiteral(statement.moduleSpecifier)) {
+    if (ts4.isImportDeclaration(statement) && ts4.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 && ts.isNamedImports(bindings)) {
+      if (bindings && ts4.isNamedImports(bindings)) {
         for (const element of bindings.elements)
           imports.set(element.name.text, moduleSource);
       }
-      if (bindings && ts.isNamespaceImport(bindings))
+      if (bindings && ts4.isNamespaceImport(bindings))
         imports.set(bindings.name.text, moduleSource);
     }
-    if (!ts.isVariableStatement(statement))
+    if (!ts4.isVariableStatement(statement))
       continue;
     for (const declaration of statement.declarationList.declarations) {
-      if (!ts.isIdentifier(declaration.name) || !declaration.initializer)
+      if (!ts4.isIdentifier(declaration.name) || !declaration.initializer)
         continue;
       const scalar = scalarValue(declaration.initializer);
       if (scalar !== undefined)
@@ -13378,13 +15016,13 @@ function routeConditions(node2, sourceFile) {
   let current = node2;
   while (current?.parent) {
     const parent = current.parent;
-    if (ts.isConditionalExpression(parent)) {
+    if (ts4.isConditionalExpression(parent)) {
       const condition = compact(parent.condition.getText(sourceFile));
       conditions.push(current === parent.whenTrue ? condition : `!(${condition})`);
-    } else if (ts.isBinaryExpression(parent) && parent.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken && current === parent.right) {
+    } else if (ts4.isBinaryExpression(parent) && parent.operatorToken.kind === ts4.SyntaxKind.AmpersandAmpersandToken && current === parent.right) {
       conditions.push(compact(parent.left.getText(sourceFile)));
     }
-    if (ts.isFunctionLike(parent))
+    if (ts4.isFunctionLike(parent))
       break;
     current = parent;
   }
@@ -13393,36 +15031,36 @@ function routeConditions(node2, sourceFile) {
 function jsxAttributes(node2) {
   const result = new Map;
   for (const property of node2.attributes.properties)
-    if (ts.isJsxAttribute(property))
+    if (ts4.isJsxAttribute(property))
       result.set(property.name.getText(), property);
   return result;
 }
 function jsxExpression(attribute) {
   const initializer = attribute?.initializer;
-  return initializer && ts.isJsxExpression(initializer) ? initializer.expression : undefined;
+  return initializer && ts4.isJsxExpression(initializer) ? initializer.expression : undefined;
 }
 function jsxScalar(attribute, constants2) {
   if (!attribute)
     return;
   if (!attribute.initializer)
     return true;
-  if (ts.isStringLiteral(attribute.initializer))
+  if (ts4.isStringLiteral(attribute.initializer))
     return attribute.initializer.text;
   const expression = jsxExpression(attribute);
-  return scalarValue(expression) ?? (expression && ts.isIdentifier(expression) ? constants2.get(expression.text) : undefined);
+  return scalarValue(expression) ?? (expression && ts4.isIdentifier(expression) ? constants2.get(expression.text) : undefined);
 }
 function descendantTags(node2) {
   const tags = new Set;
   const visit = (child) => {
-    if (ts.isJsxElement(child) || ts.isJsxSelfClosingElement(child)) {
-      const opening = ts.isJsxElement(child) ? child.openingElement : child;
+    if (ts4.isJsxElement(child) || ts4.isJsxSelfClosingElement(child)) {
+      const opening = ts4.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);
     }
-    ts.forEachChild(child, visit);
+    ts4.forEachChild(child, visit);
   };
   visit(node2);
   return [...tags];
@@ -13432,8 +15070,8 @@ function navigateTarget(node2, sourceFile) {
   const visit = (child) => {
     if (target)
       return;
-    if (ts.isJsxElement(child) || ts.isJsxSelfClosingElement(child)) {
-      const opening = ts.isJsxElement(child) ? child.openingElement : child;
+    if (ts4.isJsxElement(child) || ts4.isJsxSelfClosingElement(child)) {
+      const opening = ts4.isJsxElement(child) ? child.openingElement : child;
       if (child !== node2 && opening.tagName.getText() === "Route")
         return;
       if (opening.tagName.getText() === "Navigate") {
@@ -13448,7 +15086,7 @@ function navigateTarget(node2, sourceFile) {
         }
       }
     }
-    ts.forEachChild(child, visit);
+    ts4.forEachChild(child, visit);
   };
   visit(node2);
   return target;
@@ -13465,12 +15103,12 @@ function componentSource(component, imports) {
 }
 function objectProperty(object2, name) {
   for (const property of object2.properties) {
-    if (!ts.isPropertyAssignment(property) && !ts.isShorthandPropertyAssignment(property))
+    if (!ts4.isPropertyAssignment(property) && !ts4.isShorthandPropertyAssignment(property))
       continue;
-    const key = property.name && (ts.isIdentifier(property.name) || ts.isStringLiteralLike(property.name)) ? property.name.text : undefined;
+    const key = property.name && (ts4.isIdentifier(property.name) || ts4.isStringLiteralLike(property.name)) ? property.name.text : undefined;
     if (key !== name)
       continue;
-    return ts.isPropertyAssignment(property) ? property.initializer : property.name;
+    return ts4.isPropertyAssignment(property) ? property.initializer : property.name;
   }
   return;
 }
@@ -13512,7 +15150,7 @@ function extractReactRouterRoutes(source, filePath, options = {}) {
   };
   const visitRouteObjects = (array, parentPath) => {
     for (const element of array.elements) {
-      if (!ts.isObjectLiteralExpression(element))
+      if (!ts4.isObjectLiteralExpression(element))
         continue;
       const index = scalarValue(objectProperty(element, "index")) === true;
       const pathValue = scalarValue(objectProperty(element, "path"));
@@ -13528,13 +15166,13 @@ function extractReactRouterRoutes(source, filePath, options = {}) {
         index,
         ...component ? { component } : {},
         ...typeof redirect === "string" ? { redirectTo: redirect } : {},
-        ...children && ts.isArrayLiteralExpression(children) ? { children } : {}
+        ...children && ts4.isArrayLiteralExpression(children) ? { children } : {}
       });
     }
   };
   const visit = (node2, parentPath) => {
-    if (ts.isJsxElement(node2) || ts.isJsxSelfClosingElement(node2)) {
-      const opening = ts.isJsxElement(node2) ? node2.openingElement : node2;
+    if (ts4.isJsxElement(node2) || ts4.isJsxSelfClosingElement(node2)) {
+      const opening = ts4.isJsxElement(node2) ? node2.openingElement : node2;
       if (opening.tagName.getText() === "Route") {
         const attributes = jsxAttributes(opening);
         const index = jsxScalar(attributes.get("index"), parsed.constants) === true;
@@ -13547,61 +15185,61 @@ 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 (ts.isJsxElement(node2))
+        if (ts4.isJsxElement(node2))
           for (const child of node2.children)
             visit(child, fullPath);
         return;
       }
     }
-    if (ts.isCallExpression(node2)) {
+    if (ts4.isCallExpression(node2)) {
       const callee = node2.expression.getText(parsed.sourceFile);
-      if ((callee === "createBrowserRouter" || callee === "createHashRouter" || callee === "useRoutes") && node2.arguments[0] && ts.isArrayLiteralExpression(node2.arguments[0])) {
+      if ((callee === "createBrowserRouter" || callee === "createHashRouter" || callee === "useRoutes") && node2.arguments[0] && ts4.isArrayLiteralExpression(node2.arguments[0])) {
         visitRouteObjects(node2.arguments[0], mountPath);
       }
     }
-    ts.forEachChild(node2, (child) => visit(child, parentPath));
+    ts4.forEachChild(node2, (child) => visit(child, parentPath));
   };
   visit(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 ts2 from "typescript";
+import * as ts5 from "typescript";
 function exportedDeclarationName(statement) {
-  const exported = ts2.canHaveModifiers(statement) && ts2.getModifiers(statement)?.some((modifier) => modifier.kind === ts2.SyntaxKind.ExportKeyword);
+  const exported = ts5.canHaveModifiers(statement) && ts5.getModifiers(statement)?.some((modifier) => modifier.kind === ts5.SyntaxKind.ExportKeyword);
   if (!exported)
     return;
-  if ((ts2.isFunctionDeclaration(statement) || ts2.isClassDeclaration(statement) || ts2.isInterfaceDeclaration(statement) || ts2.isTypeAliasDeclaration(statement) || ts2.isEnumDeclaration(statement)) && statement.name) {
+  if ((ts5.isFunctionDeclaration(statement) || ts5.isClassDeclaration(statement) || ts5.isInterfaceDeclaration(statement) || ts5.isTypeAliasDeclaration(statement) || ts5.isEnumDeclaration(statement)) && statement.name) {
     return statement.name.text;
   }
   return;
 }
 function extractTypeScriptModuleExports(source, filePath = "module.ts") {
-  const sourceFile = ts2.createSourceFile(filePath, source, ts2.ScriptTarget.Latest, true, filePath.endsWith("x") ? ts2.ScriptKind.TSX : ts2.ScriptKind.TS);
+  const sourceFile = createEcmaScriptSourceFile(source, filePath);
   const named = new Set;
   const wildcard = new Set;
   const targets = new Set;
   for (const statement of sourceFile.statements) {
-    if (ts2.isExportDeclaration(statement)) {
-      const target = statement.moduleSpecifier && ts2.isStringLiteral(statement.moduleSpecifier) ? statement.moduleSpecifier.text : undefined;
+    if (ts5.isExportDeclaration(statement)) {
+      const target = statement.moduleSpecifier && ts5.isStringLiteral(statement.moduleSpecifier) ? statement.moduleSpecifier.text : undefined;
       if (target)
         targets.add(target);
       if (!statement.exportClause) {
         if (target)
           wildcard.add(target);
-      } else if (ts2.isNamedExports(statement.exportClause)) {
+      } else if (ts5.isNamedExports(statement.exportClause)) {
         for (const element of statement.exportClause.elements)
           named.add(element.name.text);
-      } else if (ts2.isNamespaceExport(statement.exportClause)) {
+      } else if (ts5.isNamespaceExport(statement.exportClause)) {
         named.add(statement.exportClause.name.text);
       }
       continue;
     }
-    const declarationName = exportedDeclarationName(statement);
-    if (declarationName)
-      named.add(declarationName);
-    if (ts2.isVariableStatement(statement) && ts2.getModifiers(statement)?.some((modifier) => modifier.kind === ts2.SyntaxKind.ExportKeyword)) {
+    const declarationName2 = exportedDeclarationName(statement);
+    if (declarationName2)
+      named.add(declarationName2);
+    if (ts5.isVariableStatement(statement) && ts5.getModifiers(statement)?.some((modifier) => modifier.kind === ts5.SyntaxKind.ExportKeyword)) {
       for (const declaration of statement.declarationList.declarations) {
-        if (ts2.isIdentifier(declaration.name))
+        if (ts5.isIdentifier(declaration.name))
           named.add(declaration.name.text);
       }
     }
@@ -13612,8 +15250,61 @@ function extractTypeScriptModuleExports(source, filePath = "module.ts") {
     targets: [...targets].sort()
   };
 }
+function extractEcmaScriptModuleExports(source, filePath = "module.ts") {
+  const esm = extractTypeScriptModuleExports(source, filePath);
+  const sourceFile = createEcmaScriptSourceFile(source, filePath);
+  const commonJs = analyzeCommonJsModule(source, filePath);
+  const diagnostics = [
+    ...syntaxDiagnostics(sourceFile),
+    ...commonJs.diagnostics
+  ].map(({ code, line, column }) => ({ code, line, column }));
+  if (diagnostics.length > 0) {
+    return {
+      named: [],
+      wildcard: [],
+      targets: [],
+      coverageTier: EXTRACT_TS_COVERAGE_TIER,
+      capabilities: [...EXTRACT_TS_CAPABILITIES],
+      disposition: "unsupported",
+      diagnostics
+    };
+  }
+  return {
+    named: [...new Set([
+      ...esm.named,
+      ...commonJs.exports.map((item) => item.exportedName)
+    ])].sort(),
+    wildcard: [...new Set([...esm.wildcard, ...commonJs.wildcardSources])].sort(),
+    targets: [...new Set([
+      ...esm.targets,
+      ...commonJs.bindings.map((binding) => binding.source),
+      ...commonJs.exports.flatMap((item) => item.source ? [item.source] : []),
+      ...commonJs.wildcardSources
+    ])].sort(),
+    coverageTier: EXTRACT_TS_COVERAGE_TIER,
+    capabilities: [...EXTRACT_TS_CAPABILITIES],
+    disposition: "analyzed",
+    diagnostics
+  };
+}
+// src/evidenceAdapter.ts
+function typeScriptExtractionToEvidenceAdapterResult(extraction, invocation) {
+  if (extraction.meta.pluginId !== "c4a-extract-ts") {
+    throw new TypeError("TypeScript evidence adapter requires c4a-extract-ts output");
+  }
+  return extractionResultToEvidenceAdapterResult(extraction, invocation);
+}
+function typeScriptExtractionToEvidenceAdapterMaterialization(extraction, invocation) {
+  return materializeIndexerEvidenceAdapterResult(typeScriptExtractionToEvidenceAdapterResult(extraction, invocation));
+}
 export {
+  typeScriptExtractionToEvidenceAdapterResult,
+  typeScriptExtractionToEvidenceAdapterMaterialization,
   extractTypeScriptModuleExports,
   extractReactRouterRoutes,
-  TypeScriptPlugin
+  extractEcmaScriptModuleExports,
+  ecmaScriptLanguage,
+  TypeScriptPlugin,
+  EXTRACT_TS_COVERAGE_TIER,
+  EXTRACT_TS_CAPABILITIES
 };