@c4a/extract-go 0.6.19 → 0.7.0

package/README.md

@@ -28,10 +28,19 @@ Context candidates → review → approved knowledge
 ## Public APIs
 
 ```ts
-import { GoPlugin, indexGoRepository, indexGoSource } from "@c4a/extract-go";
+import {
+  GoPlugin,
+  goExtractionToEvidenceAdapterResult,
+  indexGoRepository,
+  indexGoSource,
+} from "@c4a/extract-go";
 ```
 
 - `GoPlugin` implements the standard `@c4a/extract` plugin protocol.
+- `GoPlugin` reports `ast-catalog` capabilities and an explicit disposition for
+  every parsed Go file.
+- `goExtractionToEvidenceAdapterResult()` publishes the common
+  `context.indexer.evidence-adapter-result/v1` wire result.
 - `indexGoSource()` parses one source unit when an adapter needs detailed facts
   before producing candidates.
 - `indexGoRepository()` indexes a repository tree with deterministic controls

package/README.zh-CN.md

@@ -24,10 +24,18 @@ Context 候选 → 审核 → 正式知识
 ## 公开 API
 
 ```ts
-import { GoPlugin, indexGoRepository, indexGoSource } from "@c4a/extract-go";
+import {
+  GoPlugin,
+  goExtractionToEvidenceAdapterResult,
+  indexGoRepository,
+  indexGoSource,
+} from "@c4a/extract-go";
 ```
 
 - `GoPlugin` 实现标准 `@c4a/extract` 插件协议；
+- `GoPlugin` 声明 `ast-catalog` capability，并为每个解析的 Go 文件返回显式 disposition；
+- `goExtractionToEvidenceAdapterResult()` 发布统一的
+  `context.indexer.evidence-adapter-result/v1` 线协议结果；
 - `indexGoSource()` 解析一个源码单元，供 Adapter 在生成候选前读取细粒度事实；
 - `indexGoRepository()` 索引仓库树，并通过确定性参数控制 include root、测试文件、
   生成文件和排除目录。

package/index.js

@@ -11375,6 +11375,397 @@ 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 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 +11881,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" }
@@ -11951,6 +12350,13 @@ class GoPlugin {
   id = "c4a-extract-go";
   languages = ["go"];
   packageManagers = ["go"];
+  coverageTier = "ast-catalog";
+  capabilities = [
+    "go-ast",
+    "go-call-relations",
+    "go-http-routes",
+    "parser.go"
+  ];
   manifestTypes = ["go.mod"];
   #lastDetection = null;
   canHandle(source) {
@@ -12038,6 +12444,16 @@ class GoPlugin {
       files,
       symbols,
       relations,
+      coverage: {
+        tier: this.coverageTier,
+        capabilities: [...this.capabilities],
+        files: files.map((file) => ({
+          path: file.path,
+          disposition: "analyzed",
+          diagnosticCodes: []
+        })),
+        diagnostics: []
+      },
       stats: {
         files: files.length,
         lines: files.reduce((sum, file) => sum + file.lines, 0),
@@ -12133,8 +12549,905 @@ async function indexGoRepository(repositoryRoot, options = {}) {
     files
   };
 }
+// ../extract/src/types.ts
+var symbolKindSchema2 = exports_external.enum(Object.values(SymbolKind));
+var visibilitySchema2 = exports_external.enum(Object.values(Visibility));
+var relationTypeSchema = exports_external.enum([
+  "imports" /* Imports */,
+  "imports_type" /* ImportsType */,
+  "calls" /* Calls */,
+  "extends" /* Extends */,
+  "implements" /* Implements */,
+  "param_type" /* ParamType */,
+  "return_type" /* ReturnType */,
+  "of_type" /* OfType */,
+  "depends_on" /* DependsOn */,
+  "contains" /* Contains */
+]);
+var relationSourceSchema = exports_external.enum([
+  "ast" /* Ast */,
+  "doc" /* Doc */,
+  "manual" /* Manual */
+]);
+var packageKindSchema2 = exports_external.enum(Object.values(PackageKind));
+var symbolParamSchema = exports_external.object({
+  name: exports_external.string().min(1),
+  type: exports_external.string().min(1).nullable()
+});
+var symbolInfoSchema = exports_external.lazy(() => exports_external.object({
+  name: exports_external.string().min(1),
+  kind: symbolKindSchema2,
+  visibility: visibilitySchema2,
+  file: exports_external.string().min(1),
+  line: exports_external.number().int().positive(),
+  endLine: exports_external.number().int().positive(),
+  members: exports_external.array(symbolInfoSchema).optional(),
+  params: exports_external.array(symbolParamSchema).optional(),
+  returnType: exports_external.string().min(1).nullable().optional(),
+  typeAnnotation: exports_external.string().min(1).nullable().optional(),
+  extends: exports_external.string().min(1).nullable().optional(),
+  implements: exports_external.array(exports_external.string().min(1)).optional(),
+  doc: exports_external.string().nullable().optional(),
+  propsType: exports_external.string().min(1).nullable().optional(),
+  unionValues: exports_external.array(exports_external.string()).optional(),
+  initializer: exports_external.string().min(1).nullable().optional(),
+  signature: exports_external.string().min(1).nullable().optional()
+}));
+var relationInfoSchema = exports_external.object({
+  type: relationTypeSchema,
+  from: exports_external.string().min(1),
+  to: exports_external.string().min(1),
+  isExternal: exports_external.boolean(),
+  grounding: groundingSchema,
+  confidence: exports_external.number().min(0).max(1),
+  source: relationSourceSchema,
+  line: exports_external.number().int().positive().optional()
+});
+var fileInfoSchema = exports_external.object({
+  path: exports_external.string().min(1),
+  language: exports_external.string().min(1),
+  lines: exports_external.number().int().nonnegative()
+});
+var extractionDiagnosticSchema = exports_external.object({
+  code: exports_external.string().min(1),
+  severity: exports_external.enum(["info", "warning", "error"]),
+  file: exports_external.string().min(1),
+  line: exports_external.number().int().positive(),
+  column: exports_external.number().int().positive()
+});
+var extractionCoverageSchema = exports_external.object({
+  tier: exports_external.enum(["ast-catalog", "lightweight-evidence"]),
+  capabilities: exports_external.array(exports_external.string().min(1)),
+  files: exports_external.array(exports_external.object({
+    path: exports_external.string().min(1),
+    disposition: exports_external.enum(["analyzed", "unsupported", "excluded"]),
+    diagnosticCodes: exports_external.array(exports_external.string().min(1))
+  })),
+  diagnostics: exports_external.array(extractionDiagnosticSchema)
+});
+var extractionMetaSchema = exports_external.object({
+  extractedAt: exports_external.string().datetime(),
+  pluginId: exports_external.string().min(1),
+  commitHash: exports_external.string().min(1).nullable(),
+  language: exports_external.string().min(1)
+});
+var extractionPackageSchema = exports_external.object({
+  name: exports_external.string().min(1),
+  kind: packageKindSchema2,
+  language: exports_external.string().min(1),
+  version: exports_external.string().min(1).optional()
+});
+var extractionStatsSchema = exports_external.object({
+  files: exports_external.number().int().nonnegative(),
+  lines: exports_external.number().int().nonnegative(),
+  exportedSymbols: exports_external.number().int().nonnegative(),
+  internalSymbols: exports_external.number().int().nonnegative(),
+  relations: exports_external.number().int().nonnegative()
+});
+var extractionResultSchema = exports_external.object({
+  version: exports_external.literal("2"),
+  meta: extractionMetaSchema,
+  package: extractionPackageSchema,
+  files: exports_external.array(fileInfoSchema),
+  symbols: exports_external.array(symbolInfoSchema),
+  relations: exports_external.array(relationInfoSchema),
+  coverage: extractionCoverageSchema.optional(),
+  stats: extractionStatsSchema
+});
+var digestStatsSchema = exports_external.object({
+  files: exports_external.number().int().nonnegative(),
+  lines: exports_external.number().int().nonnegative(),
+  exported_count: exports_external.number().int().nonnegative(),
+  internal_count: exports_external.number().int().nonnegative(),
+  relations: exports_external.number().int().nonnegative()
+});
+var digestDataSchema = exports_external.object({
+  version: exports_external.literal("2"),
+  meta: extractionMetaSchema,
+  package: extractionPackageSchema,
+  files: exports_external.array(fileInfoSchema),
+  symbols: exports_external.array(symbolInfoSchema),
+  relations: exports_external.array(relationInfoSchema),
+  coverage: extractionCoverageSchema.optional(),
+  stats: digestStatsSchema
+});
+var symbolDiffSchema = exports_external.object({
+  added: exports_external.array(exports_external.string().min(1)),
+  removed: exports_external.array(exports_external.string().min(1))
+});
+// ../extract/src/protocol.ts
+var packageKindSchema3 = exports_external.enum(Object.values(PackageKind));
+var manifestTypeSchema = exports_external.enum([
+  "package.json",
+  "pyproject.toml",
+  "Cargo.toml",
+  "go.mod",
+  "pom.xml"
+]);
+var entryFileSchema = exports_external.object({
+  path: exports_external.string().min(1),
+  subpath: exports_external.string().min(1),
+  type: exports_external.enum(["library", "cli", "service", "webapp"])
+});
+var manifestInfoSchema = exports_external.object({
+  type: manifestTypeSchema,
+  path: exports_external.string().min(1),
+  content: exports_external.record(exports_external.unknown())
+});
+var sourceInfoSchema = exports_external.object({
+  path: exports_external.string().min(1),
+  manifests: exports_external.array(manifestInfoSchema),
+  language: exports_external.string().min(1).optional()
+});
+var entryDetectionResultSchema = exports_external.lazy(() => exports_external.object({
+  package: exports_external.object({
+    name: exports_external.string().min(1),
+    kind: packageKindSchema3,
+    language: exports_external.string().min(1),
+    version: exports_external.string().min(1).optional()
+  }),
+  entries: exports_external.array(entryFileSchema),
+  subPackages: exports_external.array(entryDetectionResultSchema).optional()
+}));
+var patternDetectionResultSchema = exports_external.object({
+  endpoints: exports_external.array(exports_external.object({
+    handler: exports_external.string().min(1),
+    method: exports_external.string().min(1),
+    path: exports_external.string().min(1),
+    file: exports_external.string().min(1),
+    line: exports_external.number().int().positive()
+  })).optional(),
+  implicitDeps: exports_external.array(exports_external.object({
+    verb: exports_external.enum(["produce", "consume", "depends_on", "serve"]),
+    target: exports_external.string().min(1),
+    file: exports_external.string().min(1),
+    line: exports_external.number().int().positive()
+  })).optional(),
+  configRefs: exports_external.array(exports_external.object({
+    key: exports_external.string().min(1),
+    file: exports_external.string().min(1),
+    line: exports_external.number().int().positive()
+  })).optional()
+});
+// ../extract/src/registry.ts
+var MANIFEST_LANGUAGE_CANDIDATES = {
+  "package.json": ["typescript", "tsx", "javascript", "jsx"],
+  "pyproject.toml": ["python"],
+  "Cargo.toml": ["rust"],
+  "go.mod": ["go"],
+  "pom.xml": ["java"]
+};
+
+class ExtractionPluginRegistry {
+  #plugins = [];
+  register(plugin) {
+    this.#plugins.push(plugin);
+  }
+  resolve(source) {
+    const declaredLanguage = source.language?.toLowerCase();
+    const manifestLanguages = new Set(source.manifests.flatMap((manifest) => MANIFEST_LANGUAGE_CANDIDATES[manifest.type] ?? []));
+    const candidates = this.#plugins.filter((plugin) => {
+      const pluginLanguages = plugin.languages.map((language) => language.toLowerCase());
+      if (declaredLanguage) {
+        return pluginLanguages.includes(declaredLanguage);
+      }
+      if (manifestLanguages.size === 0) {
+        return true;
+      }
+      return pluginLanguages.some((language) => manifestLanguages.has(language));
+    });
+    for (const plugin of candidates) {
+      if (plugin.canHandle(source)) {
+        return plugin;
+      }
+    }
+    return null;
+  }
+  list() {
+    return [...this.#plugins];
+  }
+}
+// ../extract/src/scanner.ts
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+var execFileAsync = promisify(execFile);
+var SUPPORTED_EXTENSIONS = new Set([
+  ".ts",
+  ".tsx",
+  ".mts",
+  ".cts",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs"
+]);
+var MANIFEST_FILES = [
+  "package.json",
+  "pyproject.toml",
+  "setup.py",
+  "go.mod",
+  "Cargo.toml",
+  "pom.xml",
+  "build.gradle"
+];
+var MANIFEST_NAMES = new Set(MANIFEST_FILES.map((f) => f.toLowerCase()));
+// ../extract/src/runner.ts
+var pluginSpecSchema = exports_external.object({
+  package: exports_external.string().min(1),
+  exportName: exports_external.string().min(1).optional()
+});
+var entrySelectionSchema = exports_external.discriminatedUnion("mode", [
+  exports_external.object({ mode: exports_external.literal("auto") }),
+  exports_external.object({ mode: exports_external.literal("configured"), entries: exports_external.array(exports_external.string().min(1)) }),
+  exports_external.object({ mode: exports_external.literal("scan") })
+]);
+var codeExtractRunnerInputSchema = exports_external.object({
+  repoPath: exports_external.string().min(1),
+  modules: exports_external.array(exports_external.string().min(1)).optional(),
+  ref: exports_external.string().min(1).optional(),
+  commitHash: exports_external.string().min(1).nullable().optional(),
+  moduleCommits: exports_external.record(exports_external.string().nullable()).optional(),
+  pathFilter: PathFilterConfigSchema.optional(),
+  entrySelection: entrySelectionSchema.optional(),
+  plugins: exports_external.array(pluginSpecSchema).min(1),
+  snapshot: exports_external.object({
+    sourceId: exports_external.string().min(1),
+    sourceSlug: exports_external.string().min(1),
+    snapshotId: exports_external.string().min(1),
+    codeSnapshotContractVersion: exports_external.string().min(1),
+    scriptHash: exports_external.string().min(1),
+    toolchain: exports_external.object({
+      manager_package: exports_external.string().min(1),
+      manager_version: exports_external.string().min(1),
+      runner_package: exports_external.string().min(1),
+      runner_package_version: exports_external.string().min(1),
+      runner_bin: exports_external.string().min(1),
+      plugin_package: exports_external.string().min(1),
+      plugin_package_version: exports_external.string().min(1),
+      plugin_export: exports_external.string().min(1)
+    }),
+    sourceCommit: exports_external.string().min(1).nullable().optional(),
+    versionPolicy: exports_external.enum(["package-version", "module-commit", "explicit", "none"]).optional(),
+    originPath: exports_external.string().min(1).optional(),
+    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 normalizedPath = coverageFile.path;
+    const fileRef = indexerEvidenceAdapterFileRef({
+      source_ref: invocation.authorized_scope.source_ref,
+      module_ref: invocation.module_ref,
+      normalized_path: normalizedPath
+    });
+    const fileInfo = fileInfoByPath.get(normalizedPath);
+    if (coverageFile.disposition === "analyzed" && !fileInfo) {
+      throw new TypeError(`Analyzed file ${normalizedPath} 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,
+        qualifiedItemPath: "file",
+        kind: "source-file",
+        signature: { path: normalizedPath, language: fileInfo.language },
+        payload: fileInfo,
+        denominator: ownsDenominators ? "eligible-file" : "none"
+      }));
+      facts.push(fact2({
+        sourceRef: invocation.authorized_scope.source_ref,
+        moduleRef: invocation.module_ref,
+        normalizedPath,
+        qualifiedItemPath: "loc",
+        kind: "source-loc",
+        signature: { path: normalizedPath },
+        payload: { lines: fileInfo.lines },
+        denominator: ownsDenominators ? "loc" : "none"
+      }));
+      for (const symbol of extraction.symbols.filter((item) => item.file === normalizedPath)) {
+        facts.push(fact2({
+          sourceRef: invocation.authorized_scope.source_ref,
+          moduleRef: invocation.module_ref,
+          normalizedPath,
+          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(normalizedPath) ?? []) {
+        facts.push(fact2({
+          sourceRef: invocation.authorized_scope.source_ref,
+          moduleRef: invocation.module_ref,
+          normalizedPath,
+          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: normalizedPath,
+      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 * as WebTreeSitter from "web-tree-sitter";
+var treeSitterRuntime = WebTreeSitter;
+var Parser2 = treeSitterRuntime.default ?? treeSitterRuntime.Parser;
+if (!Parser2) {
+  throw new TypeError("web-tree-sitter runtime does not expose Parser");
+}
+var PARSER_RESET_THRESHOLD = 16 * 1024 * 1024;
+// src/evidenceAdapter.ts
+function goExtractionToEvidenceAdapterResult(extraction, invocation) {
+  if (extraction.meta.pluginId !== "c4a-extract-go") {
+    throw new TypeError("Go evidence adapter requires c4a-extract-go output");
+  }
+  return extractionResultToEvidenceAdapterResult(extraction, invocation);
+}
 export {
   indexGoSource,
   indexGoRepository,
+  goExtractionToEvidenceAdapterResult,
   GoPlugin
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@c4a/extract-go",
-  "version": "0.6.19",
+  "version": "0.7.0",
   "type": "module",
   "description": "Go extraction plugin and structural index for Context",
   "license": "MIT",