@shapeshift-labs/frontier-lang-compiler 0.2.27 → 0.2.29

package/README.md

@@ -332,6 +332,8 @@ Use injected parser adapters when a real language parser is available but should
 ```js
 import {
   createBabelNativeImporterAdapter,
+  createClangAstNativeImporterAdapter,
+  createGoAstNativeImporterAdapter,
   createPythonAstNativeImporterAdapter,
   createRustSynNativeImporterAdapter,
   importNativeProject,
@@ -348,6 +350,15 @@ const rustSynAdapter = createRustSynNativeImporterAdapter({
   parserModule: hostRustSynParser,
   rustEdition: '2021'
 });
+const clangAstAdapter = createClangAstNativeImporterAdapter({
+  parserModule: hostClangJsonParser,
+  cStandard: 'c11',
+  compileFlags: ['-std=c11']
+});
+const goAstAdapter = createGoAstNativeImporterAdapter({
+  parserModule: hostGoAstParser,
+  goVersion: '1.22'
+});
 
 const imported = await runNativeImporterAdapter(babelAdapter, {
   sourcePath: 'src/todo.ts',
@@ -356,11 +367,13 @@ const imported = await runNativeImporterAdapter(babelAdapter, {
 
 const project = await importNativeProject({
   projectRoot: 'src',
-  adapters: [babelAdapter, pythonAstAdapter, rustSynAdapter],
+  adapters: [babelAdapter, pythonAstAdapter, rustSynAdapter, clangAstAdapter, goAstAdapter],
   sources: [
     { language: 'typescript', adapter: babelAdapter.id, sourcePath: 'src/todo.ts', sourceText },
     { language: 'python', adapter: pythonAstAdapter.id, sourcePath: 'tools/todo.py', sourceText: pythonSource },
-    { language: 'rust', adapter: rustSynAdapter.id, sourcePath: 'src/todo.rs', sourceText: rustSource }
+    { language: 'rust', adapter: rustSynAdapter.id, sourcePath: 'src/todo.rs', sourceText: rustSource },
+    { language: 'c', adapter: clangAstAdapter.id, sourcePath: 'native/todo.c', sourceText: cSource },
+    { language: 'go', adapter: goAstAdapter.id, sourcePath: 'cmd/todo/main.go', sourceText: goSource }
   ]
 });
 
@@ -381,6 +394,8 @@ The built-in adapter factories are dependency-light wrappers for caller-owned pa
 - `createTypeScriptCompilerNativeImporterAdapter`
 - `createPythonAstNativeImporterAdapter`
 - `createRustSynNativeImporterAdapter`
+- `createClangAstNativeImporterAdapter`
+- `createGoAstNativeImporterAdapter`
 - `createTreeSitterNativeImporterAdapter`
 
 Adapter summaries include a structured `coverage` record so merge queues can distinguish exact parser AST imports from declaration scans. The record declares exactness, parser token/trivia support, diagnostics support, source-range and generated-range support, and semantic coverage. Built-in wrappers normalize native AST/CST nodes and declaration-level semantic indexes; they do not claim resolved references, types, control flow, generated ranges, or token/trivia fidelity unless the host adapter supplies that evidence.

package/bench/smoke.mjs

@@ -2,7 +2,9 @@ import { performance } from 'node:perf_hooks';
 import {
   compileNativeSource,
   compileFrontierSource,
+  createClangAstNativeImporterAdapter,
   createEstreeNativeImporterAdapter,
+  createGoAstNativeImporterAdapter,
   createNativeImportCoverageMatrix,
   createNativeParserAstFormatMatrix,
   createProjectionTargetLossMatrix,
@@ -79,7 +81,7 @@ const matrixDurationMs = performance.now() - matrixStart;
 const parserFormatMatrixStart = performance.now();
 const parserFormatMatrix = createNativeParserAstFormatMatrix({
   imports: nativeImportResults,
-  adapters: [estreeAdapter, createPythonAstNativeImporterAdapter(), createRustSynNativeImporterAdapter()]
+  adapters: [estreeAdapter, createPythonAstNativeImporterAdapter(), createRustSynNativeImporterAdapter(), createClangAstNativeImporterAdapter(), createGoAstNativeImporterAdapter()]
 });
 const parserFormatMatrixDurationMs = performance.now() - parserFormatMatrixStart;
 

package/dist/index.d.ts

@@ -1410,6 +1410,61 @@ export interface RustSynNativeImporterAdapterOptions {
   readonly maxNodes?: number;
 }
 
+export interface ClangAstNativeImporterAdapterOptions {
+  readonly id?: string;
+  readonly language?: FrontierSourceLanguage;
+  readonly parser?: string;
+  readonly version?: string;
+  readonly capabilities?: readonly string[];
+  readonly coverage?: NativeImporterAdapterCoverageInput;
+  readonly supportedExtensions?: readonly string[];
+  readonly diagnostics?: readonly NativeImporterAdapterDiagnostic[];
+  readonly ast?: unknown;
+  readonly translationUnit?: unknown;
+  readonly tu?: unknown;
+  readonly parse?: (sourceText: string, options: Record<string, unknown>) => unknown;
+  readonly parserModule?: { readonly parse: (sourceText: string, options: Record<string, unknown>) => unknown };
+  readonly clang?: { readonly parse: (sourceText: string, options: Record<string, unknown>) => unknown };
+  readonly libclang?: { readonly parse: (sourceText: string, options: Record<string, unknown>) => unknown };
+  readonly parserOptions?: Record<string, unknown>;
+  readonly cStandard?: 'c89' | 'c99' | 'c11' | 'c17' | 'c23' | 'gnu11' | 'gnu17' | 'gnu23' | string;
+  readonly compileFlags?: readonly string[];
+  readonly includeSystemHeaders?: boolean;
+  readonly preprocessorRecords?: readonly unknown[] | { readonly records?: readonly unknown[] };
+  readonly includeGraph?: unknown;
+  readonly maxNodes?: number;
+}
+
+export interface GoAstNativeImporterAdapterOptions {
+  readonly id?: string;
+  readonly language?: FrontierSourceLanguage;
+  readonly parser?: string;
+  readonly version?: string;
+  readonly capabilities?: readonly string[];
+  readonly coverage?: NativeImporterAdapterCoverageInput;
+  readonly supportedExtensions?: readonly string[];
+  readonly diagnostics?: readonly NativeImporterAdapterDiagnostic[];
+  readonly ast?: unknown;
+  readonly file?: unknown;
+  readonly sourceFile?: unknown;
+  readonly package?: unknown;
+  readonly parse?: (sourceText: string, options: Record<string, unknown>) => unknown;
+  readonly parserModule?: { readonly parse: (sourceText: string, options: Record<string, unknown>) => unknown };
+  readonly goAst?: { readonly parse: (sourceText: string, options: Record<string, unknown>) => unknown };
+  readonly goParser?: { readonly parse: (sourceText: string, options: Record<string, unknown>) => unknown };
+  readonly parserOptions?: Record<string, unknown>;
+  readonly mode?: string | number;
+  readonly goVersion?: string;
+  readonly packageName?: string;
+  readonly fileSet?: unknown;
+  readonly fset?: unknown;
+  readonly includeComments?: boolean;
+  readonly buildTags?: readonly string[];
+  readonly generated?: boolean;
+  readonly typeEvidence?: unknown;
+  readonly maxNodes?: number;
+}
+
 export interface TreeSitterNativeImporterAdapterOptions {
   readonly id?: string;
   readonly language?: FrontierSourceLanguage;
@@ -1781,6 +1836,8 @@ export declare function createBabelNativeImporterAdapter(options?: JavaScriptNat
 export declare function createTypeScriptCompilerNativeImporterAdapter(options?: TypeScriptCompilerNativeImporterAdapterOptions): NativeImporterAdapter;
 export declare function createPythonAstNativeImporterAdapter(options?: PythonAstNativeImporterAdapterOptions): NativeImporterAdapter;
 export declare function createRustSynNativeImporterAdapter(options?: RustSynNativeImporterAdapterOptions): NativeImporterAdapter;
+export declare function createClangAstNativeImporterAdapter(options?: ClangAstNativeImporterAdapterOptions): NativeImporterAdapter;
+export declare function createGoAstNativeImporterAdapter(options?: GoAstNativeImporterAdapterOptions): NativeImporterAdapter;
 export declare function createTreeSitterNativeImporterAdapter(options?: TreeSitterNativeImporterAdapterOptions): NativeImporterAdapter;
 export declare function runNativeImporterAdapter(adapter: NativeImporterAdapter, input: RunNativeImporterAdapterOptions): Promise<NativeImporterAdapterImportResult>;
 export declare function runNativeTargetProjectionAdapter(adapter: NativeTargetProjectionAdapter, input: NativeTargetProjectionAdapterInput): NativeTargetProjectionResult;

package/dist/index.js

@@ -403,6 +403,30 @@ export const NativeParserAstFormatProfiles = Object.freeze([
     supportsErrorRecovery: true,
     notes: ['rust-analyzer uses rowan-backed concrete syntax trees with AST wrappers; semantic richness still depends on host analysis evidence.']
   }),
+  nativeParserAstFormatProfile('clang-ast-json', {
+    aliases: ['clang', 'libclang', 'clang-json', 'clang-ast-dump-json'],
+    kind: 'compiler-ast',
+    languages: ['c', 'cpp'],
+    parserAdapters: ['clang', 'libclang', 'clang-ast-json'],
+    exactness: 'exact-parser-ast',
+    sourceRangeModel: 'clang-loc-range',
+    preservesTokens: false,
+    preservesTrivia: false,
+    supportsErrorRecovery: false,
+    notes: ['Clang JSON AST dumps expose compiler AST declarations and source ranges after preprocessing; compile commands, macros, inactive branches, type checking, and lossless formatting remain host-owned evidence.']
+  }),
+  nativeParserAstFormatProfile('go-ast', {
+    aliases: ['go/parser', 'goast', 'golang-ast'],
+    kind: 'compiler-ast',
+    languages: ['go'],
+    parserAdapters: ['go/ast', 'go/parser', 'go-ast'],
+    exactness: 'exact-parser-ast',
+    sourceRangeModel: 'token-position',
+    preservesTokens: false,
+    preservesTrivia: false,
+    supportsErrorRecovery: true,
+    notes: ['Go go/ast trees expose parser syntax nodes and token positions; FileSet, build tags, generated-code classification, package loading, go/types, comments/trivia, and control-flow evidence remain host-owned.']
+  }),
   nativeParserAstFormatProfile('tree-sitter', {
     kind: 'concrete-syntax-tree',
     languages: ['mixed'],
@@ -2711,6 +2735,126 @@ export function createRustSynNativeImporterAdapter(options = {}) {
   };
 }
 
+export function createClangAstNativeImporterAdapter(options = {}) {
+  return {
+    id: options.id ?? 'frontier.clang-ast-native-importer',
+    language: options.language ?? 'c',
+    parser: options.parser ?? 'clang',
+    version: options.version,
+    capabilities: uniqueStrings(['nativeAst', 'semanticIndex', 'sourceMaps', 'diagnostics', ...(options.capabilities ?? [])]),
+    coverage: nativeImporterAdapterCoverage({
+      exactness: 'exact-parser-ast',
+      exactAst: true,
+      tokens: false,
+      trivia: false,
+      diagnostics: true,
+      sourceRanges: true,
+      generatedRanges: false,
+      semanticCoverage: declarationSemanticCoverage(),
+      notes: [
+        'Normalizes caller-owned Clang -ast-dump=json shaped ASTs into native AST nodes and declaration-level semantic index records.',
+        'Clang JSON ASTs reflect a preprocessed compiler view; compile commands, macros, inactive preprocessor branches, comments/trivia, and full type/reference analysis require host evidence.'
+      ]
+    }, options.coverage),
+    supportedExtensions: options.supportedExtensions ?? ['.c', '.h', '.cc', '.cpp', '.cxx', '.hpp', '.hh'],
+    diagnostics: options.diagnostics,
+    parse(input) {
+      const parsed = input.options?.ast
+        ?? input.options?.nativeAst
+        ?? input.options?.translationUnit
+        ?? input.options?.tu
+        ?? options.ast
+        ?? options.translationUnit
+        ?? options.tu
+        ?? parseClangAstSource(input, options);
+      const root = clangAstRoot(parsed);
+      if (!root) {
+        return missingInjectedParserResult(input, {
+          parser: options.parser ?? 'clang',
+          adapterId: options.id ?? 'frontier.clang-ast-native-importer',
+          message: 'createClangAstNativeImporterAdapter requires an injected Clang JSON AST object, parserModule.parse function, parse function, or adapterOptions.ast.'
+        });
+      }
+      const parseDiagnostics = normalizeParserErrors(parsed?.errors ?? parsed?.diagnostics, input, {
+        parser: options.parser ?? 'clang'
+      });
+      return createNativeImportFromClangAst(root, input, {
+        parser: options.parser ?? 'clang',
+        astFormat: 'clang-ast-json',
+        maxNodes: options.maxNodes,
+        diagnostics: parseDiagnostics,
+        cStandard: options.cStandard ?? input.options?.cStandard ?? parsed?.cStandard,
+        compileFlags: options.compileFlags ?? input.options?.compileFlags ?? parsed?.compileFlags,
+        includeSystemHeaders: options.includeSystemHeaders ?? input.options?.includeSystemHeaders,
+        preprocessorRecords: input.options?.preprocessorRecords ?? options.preprocessorRecords ?? parsed?.preprocessorRecords,
+        includeGraph: input.options?.includeGraph ?? options.includeGraph ?? parsed?.includeGraph
+      });
+    }
+  };
+}
+
+export function createGoAstNativeImporterAdapter(options = {}) {
+  return {
+    id: options.id ?? 'frontier.go-ast-native-importer',
+    language: options.language ?? 'go',
+    parser: options.parser ?? 'go/parser',
+    version: options.version,
+    capabilities: uniqueStrings(['nativeAst', 'semanticIndex', 'sourceMaps', 'diagnostics', ...(options.capabilities ?? [])]),
+    coverage: nativeImporterAdapterCoverage({
+      exactness: 'exact-parser-ast',
+      exactAst: true,
+      tokens: false,
+      trivia: false,
+      diagnostics: true,
+      sourceRanges: true,
+      generatedRanges: false,
+      semanticCoverage: declarationSemanticCoverage(),
+      notes: [
+        'Normalizes caller-owned Go go/ast-shaped File or Package trees into native AST nodes and declaration-level semantic index records.',
+        'Go AST imports do not resolve types, imports, build tags, generated code, or control flow by themselves; attach FileSet, go/types, go/packages, and build context evidence for those claims.'
+      ]
+    }, options.coverage),
+    supportedExtensions: options.supportedExtensions ?? ['.go'],
+    diagnostics: options.diagnostics,
+    parse(input) {
+      const parsed = input.options?.ast
+        ?? input.options?.nativeAst
+        ?? input.options?.file
+        ?? input.options?.sourceFile
+        ?? input.options?.package
+        ?? options.ast
+        ?? options.file
+        ?? options.sourceFile
+        ?? options.package
+        ?? parseGoAstSource(input, options);
+      const root = goAstRoot(parsed);
+      if (!root) {
+        return missingInjectedParserResult(input, {
+          parser: options.parser ?? 'go/parser',
+          adapterId: options.id ?? 'frontier.go-ast-native-importer',
+          message: 'createGoAstNativeImporterAdapter requires an injected Go ast.File/Package-shaped object, parserModule.parse function, parse function, or adapterOptions.ast.'
+        });
+      }
+      const parseDiagnostics = normalizeParserErrors(parsed?.errors ?? parsed?.diagnostics, input, {
+        parser: options.parser ?? 'go/parser'
+      });
+      return createNativeImportFromGoAst(root, input, {
+        parser: options.parser ?? 'go/parser',
+        astFormat: 'go-ast',
+        maxNodes: options.maxNodes,
+        diagnostics: parseDiagnostics,
+        goVersion: options.goVersion ?? input.options?.goVersion ?? parsed?.goVersion,
+        packageName: options.packageName ?? input.options?.packageName ?? parsed?.packageName ?? root?.Name?.Name ?? root?.Name,
+        fileSet: input.options?.fileSet ?? input.options?.fset ?? options.fileSet ?? options.fset ?? parsed?.fileSet ?? parsed?.fset,
+        includeComments: options.includeComments ?? input.options?.includeComments,
+        buildTags: input.options?.buildTags ?? options.buildTags ?? parsed?.buildTags,
+        generated: input.options?.generated ?? options.generated ?? parsed?.generated,
+        typeEvidence: input.options?.typeEvidence ?? options.typeEvidence ?? parsed?.typeEvidence
+      });
+    }
+  };
+}
+
 export function createTreeSitterNativeImporterAdapter(options = {}) {
   return {
     id: options.id ?? `frontier.tree-sitter-${idFragment(options.language ?? 'source')}-native-importer`,
@@ -7151,6 +7295,8 @@ function parserAstFormatIdForParser(parser) {
   if (text.includes('python') && text.includes('ast')) return 'python-ast';
   if (text === 'syn' || text.includes('rust-syn')) return 'rust-syn';
   if (text.includes('rust-analyzer') || text.includes('rowan')) return 'rust-analyzer-rowan';
+  if (text.includes('clang') || text.includes('libclang')) return 'clang-ast-json';
+  if (text === 'go' || text.includes('go-parser') || text.includes('go-ast') || text.includes('go/parser') || text.includes('go/ast')) return 'go-ast';
   if (text.includes('tree-sitter') || text.includes('treesitter')) return 'tree-sitter';
   if (text.includes('babel')) return 'babel';
   if (text.includes('estree')) return 'estree';
@@ -8199,6 +8345,39 @@ function parseRustSynSource(input, options) {
   return parse(input.sourceText, parserOptions);
 }
 
+function parseClangAstSource(input, options) {
+  const parse = options.parse ?? options.parserModule?.parse ?? options.clang?.parse ?? options.libclang?.parse;
+  if (typeof parse !== 'function') return undefined;
+  const parserOptions = {
+    sourcePath: input.sourcePath,
+    filename: input.sourcePath,
+    language: options.language ?? input.language,
+    standard: options.cStandard ?? input.options?.cStandard,
+    compileFlags: options.compileFlags ?? input.options?.compileFlags,
+    includeSystemHeaders: options.includeSystemHeaders ?? input.options?.includeSystemHeaders,
+    astDumpFormat: 'json',
+    ...(options.parserOptions ?? {}),
+    ...(input.options?.parserOptions ?? {})
+  };
+  return parse(input.sourceText, parserOptions);
+}
+
+function parseGoAstSource(input, options) {
+  const parse = options.parse ?? options.parserModule?.parse ?? options.goAst?.parse ?? options.goParser?.parse;
+  if (typeof parse !== 'function') return undefined;
+  const parserOptions = {
+    sourcePath: input.sourcePath,
+    filename: input.sourcePath,
+    mode: options.mode ?? input.options?.mode ?? 'ParseComments',
+    goVersion: options.goVersion ?? input.options?.goVersion,
+    packageName: options.packageName ?? input.options?.packageName,
+    includeComments: options.includeComments ?? input.options?.includeComments,
+    ...(options.parserOptions ?? {}),
+    ...(input.options?.parserOptions ?? {})
+  };
+  return parse(input.sourceText, parserOptions);
+}
+
 function createNativeImportFromSyntaxAst(ast, input, options) {
   const root = normalizeSyntaxAstRoot(ast, options.astFormat);
   if (!root) {
@@ -8319,6 +8498,77 @@ function createNativeImportFromRustSyn(root, input, options) {
   };
 }
 
+function createNativeImportFromClangAst(root, input, options) {
+  const context = createAstNormalizationContext(input, options);
+  visitClangAstNode(root, context, 'root');
+  for (const [index, record] of clangPreprocessorRecords(options.preprocessorRecords).entries()) {
+    visitClangAstNode(record, context, `preprocessorRecords[${index}]`);
+  }
+  if (context.truncated) {
+    context.losses.push(truncatedAstLoss(input, context, options));
+  }
+  const semantic = semanticIndexFromNativeDeclarations(context.declarations, input, options);
+  return {
+    rootId: context.rootId,
+    nodes: context.nodes,
+    semanticIndex: semantic.semanticIndex,
+    mappings: semantic.mappings,
+    losses: mergeNativeLosses(context.losses, options.diagnostics?.map((diagnostic, index) => adapterDiagnosticToLoss(diagnostic, index, {
+      id: input.adapterId,
+      version: input.adapterVersion
+    }, input)) ?? []),
+    evidence: semantic.evidence,
+    diagnostics: options.diagnostics,
+    metadata: {
+      astFormat: options.astFormat,
+      parser: options.parser,
+      cStandard: options.cStandard,
+      compileFlags: Array.isArray(options.compileFlags) ? options.compileFlags.slice() : options.compileFlags,
+      includeSystemHeaders: Boolean(options.includeSystemHeaders),
+      preprocessorRecordCount: clangPreprocessorRecords(options.preprocessorRecords).length,
+      includeGraph: serializableIncludeGraphSummary(options.includeGraph),
+      normalizedNodeCount: Object.keys(context.nodes).length,
+      declarationCount: context.declarations.length,
+      truncated: context.truncated
+    }
+  };
+}
+
+function createNativeImportFromGoAst(root, input, options) {
+  const context = createAstNormalizationContext(input, options);
+  visitGoAstNode(root, context, 'root');
+  if (context.truncated) {
+    context.losses.push(truncatedAstLoss(input, context, options));
+  }
+  const semantic = semanticIndexFromNativeDeclarations(context.declarations, input, options);
+  return {
+    rootId: context.rootId,
+    nodes: context.nodes,
+    semanticIndex: semantic.semanticIndex,
+    mappings: semantic.mappings,
+    losses: mergeNativeLosses(context.losses, options.diagnostics?.map((diagnostic, index) => adapterDiagnosticToLoss(diagnostic, index, {
+      id: input.adapterId,
+      version: input.adapterVersion
+    }, input)) ?? []),
+    evidence: semantic.evidence,
+    diagnostics: options.diagnostics,
+    metadata: {
+      astFormat: options.astFormat,
+      parser: options.parser,
+      goVersion: options.goVersion,
+      packageName: options.packageName,
+      includeComments: Boolean(options.includeComments),
+      buildTags: Array.isArray(options.buildTags) ? options.buildTags.slice() : options.buildTags,
+      generated: options.generated,
+      fileSetEvidence: Boolean(options.fileSet),
+      typeEvidence: goTypeEvidenceSummary(options.typeEvidence),
+      normalizedNodeCount: Object.keys(context.nodes).length,
+      declarationCount: context.declarations.length,
+      truncated: context.truncated
+    }
+  };
+}
+
 function createNativeImportFromTreeSitter(root, input, options) {
   const context = createAstNormalizationContext(input, options);
   visitTreeSitterNode(root, context, 'root');
@@ -8563,6 +8813,165 @@ function visitRustSynNode(node, context, propertyPath) {
   return id;
 }
 
+function visitClangAstNode(node, context, propertyPath) {
+  if (!isClangAstNode(node) || context.truncated) return undefined;
+  if (context.objectIds.has(node)) return context.objectIds.get(node);
+  if (context.counter >= context.maxNodes) {
+    context.truncated = true;
+    return undefined;
+  }
+  const kind = clangAstKind(node);
+  const span = spanFromClangAstNode(node, context.input);
+  const id = nativeNodeId(context, kind, { start: { line: span?.startLine, column: span?.startColumn } }, propertyPath);
+  context.objectIds.set(node, id);
+  if (!context.rootId) context.rootId = id;
+  const children = [];
+  for (const [field, value] of clangAstChildEntries(node)) {
+    if (Array.isArray(value)) {
+      value.forEach((entry, index) => {
+        const childId = visitClangAstNode(entry, context, `${propertyPath}.${field}[${index}]`);
+        if (childId) children.push(childId);
+      });
+    } else {
+      const childId = visitClangAstNode(value, context, `${propertyPath}.${field}`);
+      if (childId) children.push(childId);
+    }
+  }
+  const declaration = clangAstDeclaration(node, kind, id, context.input);
+  const nativeNode = {
+    id,
+    kind,
+    languageKind: `${context.input.language}.${kind}`,
+    span,
+    value: declaration?.name ?? clangAstNodeValue(node),
+    fields: primitiveClangAstFields(node, kind),
+    children,
+    metadata: {
+      astFormat: context.options.astFormat,
+      propertyPath,
+      clangId: typeof node.id === 'string' || typeof node.id === 'number' ? String(node.id) : undefined,
+      locationKind: clangLocationKind(node)
+    }
+  };
+  context.nodes[id] = nativeNode;
+  if (declaration) context.declarations.push({ ...declaration, nativeNode });
+  if (clangPreprocessorKind(kind)) {
+    context.losses.push({
+      id: `loss_${idFragment(id)}_clang_preprocessor`,
+      severity: 'warning',
+      phase: 'parse',
+      sourceFormat: context.input.language,
+      kind: 'preprocessor',
+      message: 'Clang AST preprocessor records were imported, but macro expansion, inactive branches, and compile-command provenance require host evidence.',
+      span,
+      nodeId: id,
+      metadata: {
+        parser: context.options.parser,
+        astFormat: context.options.astFormat
+      }
+    });
+  }
+  return id;
+}
+
+function visitGoAstNode(node, context, propertyPath) {
+  if (!isGoAstNode(node) || context.truncated) return undefined;
+  if (context.objectIds.has(node)) return context.objectIds.get(node);
+  if (context.counter >= context.maxNodes) {
+    context.truncated = true;
+    return undefined;
+  }
+  const kind = goAstKind(node);
+  const span = spanFromGoAstNode(node, context.input, context.options);
+  const id = nativeNodeId(context, kind, { start: { line: span?.startLine, column: span?.startColumn } }, propertyPath);
+  context.objectIds.set(node, id);
+  if (!context.rootId) context.rootId = id;
+  const children = [];
+  for (const [field, value] of goAstChildEntries(node)) {
+    if (Array.isArray(value)) {
+      value.forEach((entry, index) => {
+        const childId = visitGoAstNode(entry, context, `${propertyPath}.${field}[${index}]`);
+        if (childId) children.push(childId);
+      });
+    } else {
+      const childId = visitGoAstNode(value, context, `${propertyPath}.${field}`);
+      if (childId) children.push(childId);
+    }
+  }
+  const declarations = goAstDeclarations(node, kind, id, context.input);
+  const declaration = declarations[0];
+  const nativeNode = {
+    id,
+    kind,
+    languageKind: `${context.input.language}.${kind}`,
+    span,
+    value: declaration?.name ?? goAstNodeValue(node),
+    fields: primitiveGoAstFields(node, kind),
+    children,
+    metadata: {
+      astFormat: context.options.astFormat,
+      propertyPath,
+      positionKind: goAstPositionKind(node),
+      packageName: context.options.packageName
+    }
+  };
+  context.nodes[id] = nativeNode;
+  for (const entry of declarations) {
+    context.declarations.push({ ...entry, nativeNode });
+  }
+  if (goBadAstKind(kind)) {
+    context.losses.push({
+      id: `loss_${idFragment(id)}_go_bad_node`,
+      severity: 'error',
+      phase: 'parse',
+      sourceFormat: context.input.language,
+      kind: 'unsupportedSyntax',
+      message: 'Go parser recovered a BadDecl/BadExpr/BadStmt node; semantic import is partial until syntax errors are resolved.',
+      span,
+      nodeId: id,
+      metadata: {
+        parser: context.options.parser,
+        astFormat: context.options.astFormat,
+        nodeKind: kind
+      }
+    });
+  }
+  if (kind === 'FuncDecl' && goReceiverFieldCount(node) > 1) {
+    context.losses.push({
+      id: `loss_${idFragment(id)}_go_multiple_receivers`,
+      severity: 'warning',
+      phase: 'parse',
+      sourceFormat: context.input.language,
+      kind: 'unsupportedSyntax',
+      message: 'Go parser accepted multiple receiver fields; valid method ownership requires a single receiver.',
+      span,
+      nodeId: id,
+      metadata: {
+        parser: context.options.parser,
+        astFormat: context.options.astFormat,
+        receiverFieldCount: goReceiverFieldCount(node)
+      }
+    });
+  }
+  if (goGeneratedCodeMarker(node, kind)) {
+    context.losses.push({
+      id: `loss_${idFragment(id)}_go_generated_code`,
+      severity: 'warning',
+      phase: 'parse',
+      sourceFormat: context.input.language,
+      kind: 'generatedCode',
+      message: 'Go generated-code marker was imported; regeneration provenance and source ownership require host evidence.',
+      span,
+      nodeId: id,
+      metadata: {
+        parser: context.options.parser,
+        astFormat: context.options.astFormat
+      }
+    });
+  }
+  return id;
+}
+
 function visitTreeSitterNode(node, context, propertyPath) {
   if (!node || typeof node !== 'object' || context.truncated) return undefined;
   if (context.objectIds.has(node)) return context.objectIds.get(node);
@@ -10229,6 +10638,575 @@ function rustSynMacroKind(kind) {
   return /Macro|MacroRules|MacroCall/.test(String(kind));
 }
 
+function clangAstRoot(value) {
+  if (!value || typeof value !== 'object') return undefined;
+  if (Array.isArray(value)) return { kind: 'TranslationUnitDecl', inner: value };
+  if (isClangAstNode(value)) return value;
+  if (Array.isArray(value.ast)) return { kind: 'TranslationUnitDecl', inner: value.ast };
+  if (isClangAstNode(value.ast)) return value.ast;
+  if (isClangAstNode(value.root)) return value.root;
+  if (isClangAstNode(value.translationUnit)) return value.translationUnit;
+  if (isClangAstNode(value.tu)) return value.tu;
+  if (isClangAstNode(value.file)) return value.file;
+  if (isClangAstNode(value.sourceFile)) return value.sourceFile;
+  return undefined;
+}
+
+function isClangAstNode(value) {
+  return Boolean(value && typeof value === 'object' && typeof clangAstKind(value) === 'string');
+}
+
+function clangAstKind(node) {
+  if (!node || typeof node !== 'object') return undefined;
+  const declared = node.kind ?? node._type ?? node.type ?? node.nodeType ?? node.declKind ?? node.stmtKind;
+  if (typeof declared === 'string') return declared;
+  if (Array.isArray(node.inner) || Array.isArray(node.children) || Array.isArray(node.decls)) return 'TranslationUnitDecl';
+  return undefined;
+}
+
+function ignoredClangAstField(key) {
+  return key === '_type'
+    || key === 'type'
+    || key === 'kind'
+    || key === 'nodeType'
+    || key === 'declKind'
+    || key === 'stmtKind'
+    || key === 'id'
+    || key === 'loc'
+    || key === 'range'
+    || key === 'name'
+    || key === 'displayName'
+    || key === 'qualifiedName'
+    || key === 'mangledName'
+    || key === 'parent'
+    || key === 'parentDeclContextId'
+    || key === 'previousDecl'
+    || key === 'referencedDecl';
+}
+
+function primitiveClangAstFields(node, kind) {
+  const fields = { kind };
+  const name = clangDeclarationName(node);
+  if (name) fields.name = name;
+  const type = clangTypeName(node.type ?? node.qualType);
+  if (type) fields.type = type;
+  for (const key of [
+    'mangledName',
+    'storageClass',
+    'tagUsed',
+    'completeDefinition',
+    'isThisDeclarationADefinition',
+    'inline',
+    'isUsed',
+    'isReferenced',
+    'valueCategory',
+    'opcode',
+    'castKind'
+  ]) {
+    const value = node[key];
+    if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean' || value === null) fields[key] = value;
+  }
+  const includePath = clangIncludePath(node);
+  if (includePath) fields.includePath = includePath;
+  const literal = clangLiteralValue(node);
+  if (literal !== undefined) fields.literal = literal;
+  const referenced = clangDeclarationName(node.referencedDecl);
+  if (referenced) fields.referenced = referenced;
+  return fields;
+}
+
+function spanFromClangAstNode(node, input) {
+  const range = node.range ?? {};
+  const begin = range.begin ?? node.loc ?? node.spellingLoc ?? node.expansionLoc;
+  const end = range.end ?? node.end;
+  const start = clangLocPosition(begin);
+  if (!start) return undefined;
+  const finish = clangLocPosition(end);
+  return {
+    sourceId: input.sourceHash,
+    path: start.path ?? finish?.path ?? input.sourcePath,
+    startLine: start.line,
+    startColumn: start.column,
+    endLine: finish?.line,
+    endColumn: finish?.column
+  };
+}
+
+function clangLocPosition(loc) {
+  if (!loc || typeof loc !== 'object') return undefined;
+  const expanded = loc.expansionLoc ?? loc.spellingLoc ?? loc;
+  const line = expanded.line ?? expanded.startLine ?? expanded.begin?.line;
+  const column = expanded.col ?? expanded.column ?? expanded.startColumn ?? expanded.begin?.col ?? expanded.begin?.column;
+  if (typeof line !== 'number') return undefined;
+  return {
+    path: expanded.file ?? expanded.filename ?? expanded.path,
+    line,
+    column: typeof column === 'number' ? column : undefined
+  };
+}
+
+function clangLocationKind(node) {
+  const loc = node.loc ?? node.range?.begin;
+  if (!loc || typeof loc !== 'object') return undefined;
+  if (loc.expansionLoc) return 'expansionLoc';
+  if (loc.spellingLoc) return 'spellingLoc';
+  if (loc.includedFrom) return 'includedFrom';
+  return 'clang-loc';
+}
+
+function clangAstDeclaration(node, kind, nativeNodeId, input) {
+  if (kind === 'FunctionDecl' || kind === 'CXXMethodDecl' || kind === 'FunctionTemplateDecl') {
+    const name = clangDeclarationName(node);
+    if (name) return declarationRecord(input, nativeNodeId, name, kind === 'CXXMethodDecl' ? 'method' : 'function', clangDeclarationAction(node));
+  }
+  if (kind === 'ParmVarDecl') {
+    const name = clangDeclarationName(node);
+    if (name) return declarationRecord(input, nativeNodeId, name, 'parameter', 'definition');
+  }
+  if (kind === 'RecordDecl' || kind === 'CXXRecordDecl' || kind === 'ClassTemplateDecl') {
+    const name = clangDeclarationName(node);
+    if (name) return declarationRecord(input, nativeNodeId, name, kind === 'CXXRecordDecl' ? 'class' : 'type', clangDeclarationAction(node));
+  }
+  if (kind === 'FieldDecl') {
+    const name = clangDeclarationName(node);
+    if (name) return declarationRecord(input, nativeNodeId, name, 'property', 'definition');
+  }
+  if (kind === 'TypedefDecl' || kind === 'TypeAliasDecl' || kind === 'TypeAliasTemplateDecl') {
+    const name = clangDeclarationName(node);
+    if (name) return declarationRecord(input, nativeNodeId, name, 'type', 'definition');
+  }
+  if (kind === 'EnumDecl') {
+    const name = clangDeclarationName(node);
+    if (name) return declarationRecord(input, nativeNodeId, name, 'type', clangDeclarationAction(node));
+  }
+  if (kind === 'EnumConstantDecl') {
+    const name = clangDeclarationName(node);
+    if (name) return declarationRecord(input, nativeNodeId, name, 'enumMember', 'definition');
+  }
+  if (kind === 'VarDecl') {
+    const name = clangDeclarationName(node);
+    if (name) return declarationRecord(input, nativeNodeId, name, 'variable', clangDeclarationAction(node));
+  }
+  if (/IncludeDirective|InclusionDirective/.test(kind)) {
+    const name = clangIncludePath(node);
+    if (name) return declarationRecord(input, nativeNodeId, name, 'module', 'import');
+  }
+  if (/MacroDefinition|MacroExpansion|MacroInstantiation/.test(kind)) {
+    const name = clangDeclarationName(node) ?? clangIncludePath(node);
+    if (name) return declarationRecord(input, nativeNodeId, name, 'macro', 'definition');
+  }
+  return undefined;
+}
+
+function clangDeclarationAction(node) {
+  if (node.isThisDeclarationADefinition === false) return 'declaration';
+  if (node.isThisDeclarationADefinition === true) return 'definition';
+  if (Array.isArray(node.inner) && node.inner.some((entry) => ['CompoundStmt', 'FieldDecl', 'EnumConstantDecl'].includes(clangAstKind(entry)))) return 'definition';
+  return 'declaration';
+}
+
+function clangAstChildEntries(node) {
+  const fieldNames = Object.keys(node).filter((key) => !ignoredClangAstField(key));
+  return fieldNames
+    .map((field) => [field, node[field]])
+    .filter(([, value]) => Array.isArray(value)
+      ? value.some(isClangAstNode)
+      : isClangAstNode(value));
+}
+
+function clangAstNodeValue(node) {
+  return clangDeclarationName(node)
+    ?? clangIncludePath(node)
+    ?? clangTypeName(node.type ?? node.qualType)
+    ?? clangLiteralValue(node);
+}
+
+function clangDeclarationName(node) {
+  if (!node || typeof node !== 'object') return undefined;
+  for (const key of ['qualifiedName', 'displayName', 'name', 'mangledName']) {
+    if (typeof node[key] === 'string' && node[key]) return node[key];
+  }
+  if (node.name && typeof node.name === 'object') return clangDeclarationName(node.name);
+  if (node.referencedDecl && typeof node.referencedDecl === 'object') return clangDeclarationName(node.referencedDecl);
+  if (node.decl && typeof node.decl === 'object') return clangDeclarationName(node.decl);
+  return undefined;
+}
+
+function clangIncludePath(node) {
+  if (!node || typeof node !== 'object') return undefined;
+  for (const key of ['file', 'filename', 'path', 'spelling', 'source']) {
+    if (typeof node[key] === 'string' && node[key]) return node[key];
+  }
+  if (node.include && typeof node.include === 'object') return clangIncludePath(node.include);
+  return undefined;
+}
+
+function clangTypeName(value) {
+  if (!value) return undefined;
+  if (typeof value === 'string') return value;
+  if (typeof value.qualType === 'string') return value.qualType;
+  if (typeof value.desugaredQualType === 'string') return value.desugaredQualType;
+  if (typeof value.name === 'string') return value.name;
+  if (value.type && typeof value.type === 'object') return clangTypeName(value.type);
+  return undefined;
+}
+
+function clangLiteralValue(node) {
+  const value = node.value ?? node.val ?? node.literal;
+  if (value === null || typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') return value;
+  if (typeof node.valueAsString === 'string') return node.valueAsString;
+  return undefined;
+}
+
+function clangPreprocessorKind(kind) {
+  return /Macro|Preprocess|Preprocessor|IfDirective|IfdefDirective|IfndefDirective|ElifDirective|ElseDirective|EndifDirective/.test(String(kind));
+}
+
+function clangPreprocessorRecords(value) {
+  if (!value) return [];
+  if (Array.isArray(value)) return value.filter(isClangAstNode);
+  if (typeof value === 'object' && Array.isArray(value.records)) return value.records.filter(isClangAstNode);
+  if (isClangAstNode(value)) return [value];
+  return [];
+}
+
+function serializableIncludeGraphSummary(value) {
+  if (!value || typeof value !== 'object') return undefined;
+  if (Array.isArray(value)) return { edgeCount: value.length };
+  const summary = {};
+  if (typeof value.hash === 'string') summary.hash = value.hash;
+  if (typeof value.root === 'string') summary.root = value.root;
+  if (Array.isArray(value.edges)) summary.edgeCount = value.edges.length;
+  if (Array.isArray(value.includes)) summary.includeCount = value.includes.length;
+  return Object.keys(summary).length ? summary : { present: true };
+}
+
+function goAstRoot(value) {
+  if (!value || typeof value !== 'object') return undefined;
+  if (isGoAstNode(value)) return value;
+  if (isGoAstNode(value.ast)) return value.ast;
+  if (isGoAstNode(value.file)) return value.file;
+  if (isGoAstNode(value.sourceFile)) return value.sourceFile;
+  if (isGoAstNode(value.root)) return value.root;
+  if (isGoAstNode(value.package)) return value.package;
+  if (value.files && typeof value.files === 'object') return { kind: 'Package', Name: value.name ?? value.packageName, Files: value.files };
+  return undefined;
+}
+
+function isGoAstNode(value) {
+  return Boolean(value && typeof value === 'object' && typeof goAstKind(value) === 'string');
+}
+
+function goAstKind(node) {
+  if (!node || typeof node !== 'object') return undefined;
+  const declared = node.kind ?? node._type ?? node.type ?? node.nodeType ?? node.astKind;
+  if (typeof declared === 'string') return normalizeGoAstKind(declared);
+  if (Array.isArray(node.Decls) || Array.isArray(node.decls)) return 'File';
+  if (node.Files || node.files) return 'Package';
+  if (node.Name && node.Type && (node.Body || node.Recv !== undefined || node.recv !== undefined)) return 'FuncDecl';
+  if (node.Tok && (node.Specs || node.specs)) return 'GenDecl';
+  if (node.Path && (node.Name !== undefined || node.EndPos !== undefined)) return 'ImportSpec';
+  if (node.Names && node.Type !== undefined) return 'ValueSpec';
+  if (node.Name && node.Type !== undefined) return 'TypeSpec';
+  if (node.List && (node.Opening !== undefined || node.Closing !== undefined)) return 'FieldList';
+  return undefined;
+}
+
+function normalizeGoAstKind(kind) {
+  const text = String(kind).replace(/^(?:ast\.)?\*/, '').replace(/^(?:go\/ast\.)/, '');
+  if (/^file$/i.test(text)) return 'File';
+  if (/^package$/i.test(text)) return 'Package';
+  if (/^funcdecl$/i.test(text) || /^func_decl$/i.test(text)) return 'FuncDecl';
+  if (/^gendecl$/i.test(text) || /^gen_decl$/i.test(text)) return 'GenDecl';
+  if (/^importspec$/i.test(text) || /^import_spec$/i.test(text)) return 'ImportSpec';
+  if (/^typespec$/i.test(text) || /^type_spec$/i.test(text)) return 'TypeSpec';
+  if (/^valuespec$/i.test(text) || /^value_spec$/i.test(text)) return 'ValueSpec';
+  if (/^structtype$/i.test(text) || /^struct_type$/i.test(text)) return 'StructType';
+  if (/^interfacetype$/i.test(text) || /^interface_type$/i.test(text)) return 'InterfaceType';
+  if (/^fieldlist$/i.test(text) || /^field_list$/i.test(text)) return 'FieldList';
+  return text;
+}
+
+function ignoredGoAstField(key) {
+  return key === '_type'
+    || key === 'type'
+    || key === 'kind'
+    || key === 'nodeType'
+    || key === 'astKind'
+    || key === 'parent'
+    || key === 'Obj'
+    || key === 'object'
+    || key === 'Scope'
+    || key === 'scope'
+    || key === 'Unresolved'
+    || key === 'unresolved'
+    || key === 'FileStart'
+    || key === 'FileEnd'
+    || key === 'Package'
+    || key === 'Name'
+    || key === 'Path'
+    || key === 'Pos'
+    || key === 'End'
+    || key === 'pos'
+    || key === 'end';
+}
+
+function primitiveGoAstFields(node, kind) {
+  const fields = { kind };
+  const name = goAstDeclarationName(node);
+  if (name) fields.name = name;
+  const type = goAstTypeName(node.Type ?? node.type);
+  if (type) fields.type = type;
+  const tok = goAstTokenName(node.Tok ?? node.tok);
+  if (tok) fields.token = tok;
+  const importPath = goAstImportPath(node);
+  if (importPath) fields.importPath = importPath;
+  const receiver = goAstReceiverName(node);
+  if (receiver) fields.receiver = receiver;
+  for (const key of ['Incomplete', 'Doc', 'Comment']) {
+    const value = node[key] ?? node[key[0].toLowerCase() + key.slice(1)];
+    if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean' || value === null) fields[key[0].toLowerCase() + key.slice(1)] = value;
+  }
+  if (Array.isArray(node.Names ?? node.names)) {
+    fields.names = (node.Names ?? node.names).map(goAstIdentName).filter(Boolean).join(',');
+  }
+  return fields;
+}
+
+function spanFromGoAstNode(node, input, options = {}) {
+  const start = goAstPosition(node.Pos ?? node.pos ?? node.Name?.NamePos ?? node.name?.namePos ?? node.Package, options);
+  const end = goAstPosition(node.End ?? node.end ?? node.EndPos ?? node.endPos, options);
+  if (!start) return undefined;
+  return {
+    sourceId: input.sourceHash,
+    path: start.path ?? end?.path ?? input.sourcePath,
+    startLine: start.line,
+    startColumn: start.column,
+    endLine: end?.line,
+    endColumn: end?.column
+  };
+}
+
+function goAstPosition(value, options = {}) {
+  if (!value) return undefined;
+  if (typeof value === 'object') {
+    const position = value.position ?? value.Position ?? value.pos ?? value.Pos ?? value;
+    const line = position.Line ?? position.line;
+    const column = position.Column ?? position.column ?? position.Col ?? position.col;
+    if (typeof line === 'number') {
+      return {
+        path: position.Filename ?? position.filename ?? position.file ?? position.path,
+        line,
+        column: typeof column === 'number' ? column : undefined
+      };
+    }
+  }
+  const fileSet = options.fileSet ?? options.fset;
+  const positionFor = typeof fileSet?.PositionFor === 'function'
+    ? fileSet.PositionFor.bind(fileSet)
+    : typeof fileSet?.positionFor === 'function'
+      ? fileSet.positionFor.bind(fileSet)
+      : typeof fileSet?.Position === 'function'
+        ? fileSet.Position.bind(fileSet)
+        : typeof fileSet?.position === 'function'
+          ? fileSet.position.bind(fileSet)
+          : undefined;
+  if (positionFor) {
+    const resolved = positionFor(value, true);
+    return goAstPosition(resolved, options);
+  }
+  return undefined;
+}
+
+function goAstPositionKind(node) {
+  const pos = node.Pos ?? node.pos ?? node.Name?.NamePos ?? node.name?.namePos;
+  if (!pos) return undefined;
+  if (typeof pos === 'object') return 'token.Position';
+  return 'token.Pos';
+}
+
+function goAstDeclarations(node, kind, nativeNodeId, input) {
+  if (kind === 'ImportSpec') {
+    const name = goAstImportPath(node);
+    return name ? [declarationRecord(input, nativeNodeId, name, 'module', 'import')] : [];
+  }
+  if (kind === 'FuncDecl') {
+    const name = goAstDeclarationName(node);
+    if (!name) return [];
+    const receiver = goAstReceiverName(node);
+    return [declarationRecord(input, nativeNodeId, receiver ? `${receiver}.${name}` : name, receiver ? 'method' : 'function', node.Body || node.body ? 'definition' : 'declaration')];
+  }
+  if (kind === 'TypeSpec') {
+    const name = goAstDeclarationName(node);
+    return name ? [declarationRecord(input, nativeNodeId, name, goAstTypeSpecSymbolKind(node), 'definition')] : [];
+  }
+  if (kind === 'ValueSpec') {
+    const names = goAstValueSpecNames(node);
+    const token = goAstTokenName(node.parentTok ?? node.Tok ?? node.tok);
+    return names.map((name) => declarationRecord(input, nativeNodeId, name, token === 'CONST' || token === 'const' ? 'constant' : 'variable', 'definition'));
+  }
+  if (kind === 'Field') {
+    return goAstValueSpecNames(node).map((name) => declarationRecord(input, nativeNodeId, name, 'property', 'definition'));
+  }
+  if (kind === 'Package' || kind === 'File') {
+    const name = goAstPackageName(node);
+    return name ? [declarationRecord(input, nativeNodeId, name, 'module', 'definition')] : [];
+  }
+  return [];
+}
+
+function goAstChildEntries(node) {
+  const fieldNames = Object.keys(node).filter((key) => !ignoredGoAstField(key));
+  const entries = [];
+  for (const field of fieldNames) {
+    const value = node[field];
+    if (field === 'Files' || field === 'files') {
+      if (value && typeof value === 'object') entries.push([field, Array.isArray(value) ? value : Object.values(value)]);
+      continue;
+    }
+    if (field === 'Specs' || field === 'specs') {
+      const token = goAstTokenName(node.Tok ?? node.tok);
+      entries.push([field, Array.isArray(value)
+        ? value.map((entry) => entry && typeof entry === 'object' ? { parentTok: token, ...entry } : entry)
+        : value]);
+      continue;
+    }
+    entries.push([field, value]);
+  }
+  return entries.filter(([, value]) => Array.isArray(value)
+    ? value.some(isGoAstNode)
+    : isGoAstNode(value));
+}
+
+function goAstNodeValue(node) {
+  return goAstDeclarationName(node)
+    ?? goAstImportPath(node)
+    ?? goAstTypeName(node.Type ?? node.type)
+    ?? goAstLiteralValue(node);
+}
+
+function goAstDeclarationName(node) {
+  if (!node || typeof node !== 'object') return undefined;
+  return goAstIdentName(node.Name ?? node.name)
+    ?? goAstIdentName(node.Ident ?? node.ident)
+    ?? goAstIdentName(node.Sel ?? node.sel)
+    ?? (typeof node.Name === 'string' ? node.Name : undefined)
+    ?? (typeof node.name === 'string' ? node.name : undefined);
+}
+
+function goAstPackageName(node) {
+  if (!node || typeof node !== 'object') return undefined;
+  return goAstIdentName(node.Name ?? node.name) ?? node.PackageName ?? node.packageName;
+}
+
+function goAstIdentName(value) {
+  if (!value) return undefined;
+  if (typeof value === 'string') return value;
+  return value.Name ?? value.name ?? value.Value ?? value.value;
+}
+
+function goAstImportPath(node) {
+  if (!node || typeof node !== 'object') return undefined;
+  const path = node.Path ?? node.path;
+  const raw = typeof path === 'string' ? path : path?.Value ?? path?.value ?? path?.Kind;
+  if (typeof raw !== 'string') return undefined;
+  return raw.replace(/^"|"$/g, '').replace(/^`|`$/g, '');
+}
+
+function goAstReceiverName(node) {
+  const recv = node?.Recv ?? node?.recv;
+  const list = recv?.List ?? recv?.list;
+  if (!Array.isArray(list) || !list.length) return undefined;
+  const first = list[0];
+  return goAstTypeName(first?.Type ?? first?.type);
+}
+
+function goAstValueSpecName(node) {
+  return goAstValueSpecNames(node)[0];
+}
+
+function goAstValueSpecNames(node) {
+  const names = node.Names ?? node.names;
+  if (Array.isArray(names)) return names.map(goAstIdentName).filter(Boolean);
+  const name = goAstDeclarationName(node);
+  return name ? [name] : [];
+}
+
+function goAstTypeSpecSymbolKind(node) {
+  const type = node.Type ?? node.type;
+  const kind = goAstKind(type);
+  if (kind === 'InterfaceType') return 'interface';
+  if (kind === 'StructType') return 'class';
+  return 'type';
+}
+
+function goAstTypeName(value) {
+  if (!value) return undefined;
+  if (typeof value === 'string') return value;
+  const kind = goAstKind(value);
+  if (kind === 'Ident') return goAstIdentName(value);
+  if (kind === 'StarExpr') {
+    const inner = goAstTypeName(value.X ?? value.x);
+    return inner ? `*${inner}` : '*';
+  }
+  if (kind === 'SelectorExpr') {
+    const left = goAstTypeName(value.X ?? value.x);
+    const right = goAstIdentName(value.Sel ?? value.sel);
+    return [left, right].filter(Boolean).join('.');
+  }
+  if (kind === 'ArrayType') {
+    const inner = goAstTypeName(value.Elt ?? value.elt);
+    return `[]${inner ?? 'unknown'}`;
+  }
+  if (kind === 'MapType') {
+    return `map[${goAstTypeName(value.Key ?? value.key) ?? 'unknown'}]${goAstTypeName(value.Value ?? value.value) ?? 'unknown'}`;
+  }
+  if (kind === 'StructType') return 'struct';
+  if (kind === 'InterfaceType') return 'interface';
+  if (kind === 'FuncType') return 'func';
+  return goAstDeclarationName(value);
+}
+
+function goAstTokenName(value) {
+  if (!value) return undefined;
+  if (typeof value === 'string') return value;
+  if (typeof value === 'number') return String(value);
+  return value.String ?? value.string ?? value.Name ?? value.name;
+}
+
+function goAstLiteralValue(node) {
+  const value = node.Value ?? node.value;
+  if (value === null || typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') return value;
+  return undefined;
+}
+
+function goGeneratedCodeMarker(node, kind) {
+  if (kind !== 'File') return false;
+  if (node.Generated || node.generated) return true;
+  const comments = node.Comments ?? node.comments;
+  if (!Array.isArray(comments)) return false;
+  return comments.some((group) => JSON.stringify(group).includes('Code generated') && JSON.stringify(group).includes('DO NOT EDIT'));
+}
+
+function goBadAstKind(kind) {
+  return kind === 'BadDecl' || kind === 'BadExpr' || kind === 'BadStmt';
+}
+
+function goReceiverFieldCount(node) {
+  const list = (node?.Recv ?? node?.recv)?.List ?? (node?.Recv ?? node?.recv)?.list;
+  return Array.isArray(list) ? list.length : 0;
+}
+
+function goTypeEvidenceSummary(value) {
+  if (!value || typeof value !== 'object') return undefined;
+  const summary = {};
+  if (typeof value.packagePath === 'string') summary.packagePath = value.packagePath;
+  if (typeof value.hash === 'string') summary.hash = value.hash;
+  if (Array.isArray(value.types)) summary.typeCount = value.types.length;
+  if (Array.isArray(value.references)) summary.referenceCount = value.references.length;
+  return Object.keys(summary).length ? summary : { present: true };
+}
+
 function declarationRecord(input, nativeNodeId, name, symbolKind, role = 'definition') {
   return {
     name: String(name),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shapeshift-labs/frontier-lang-compiler",
-  "version": "0.2.27",
+  "version": "0.2.29",
   "description": "Compiler facade for Frontier Lang source documents and language projection adapters.",
   "type": "module",
   "main": "./dist/index.js",