@shapeshift-labs/frontier-lang-compiler 0.2.28 → 0.2.30

package/dist/index.js

@@ -415,6 +415,30 @@ export const NativeParserAstFormatProfiles = Object.freeze([
     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('java-ast', {
+    aliases: ['javac', 'javac-tree', 'jdt', 'eclipse-jdt', 'javaparser', 'java-parser'],
+    kind: 'compiler-ast',
+    languages: ['java'],
+    parserAdapters: ['javac', 'jdt', 'javaparser', 'java-ast'],
+    exactness: 'exact-parser-ast',
+    sourceRangeModel: 'java-source-range',
+    preservesTokens: false,
+    preservesTrivia: false,
+    supportsErrorRecovery: true,
+    notes: ['Java compiler/parser ASTs expose package/import/type/member declarations and source ranges; classpath/module-path, bindings, annotation processors, generated sources, Lombok expansion, comments/trivia, and control-flow evidence remain host-owned.']
+  }),
   nativeParserAstFormatProfile('tree-sitter', {
     kind: 'concrete-syntax-tree',
     languages: ['mixed'],
@@ -2781,6 +2805,133 @@ export function createClangAstNativeImporterAdapter(options = {}) {
   };
 }
 
+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 createJavaAstNativeImporterAdapter(options = {}) {
+  return {
+    id: options.id ?? 'frontier.java-ast-native-importer',
+    language: options.language ?? 'java',
+    parser: options.parser ?? 'javac',
+    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 javac/JDT/JavaParser-shaped Java ASTs into native AST nodes and declaration-level semantic index records.',
+        'Java AST imports do not resolve overloads, bindings, annotation processors, generated Lombok code, classpaths, modules, bytecode, comments/trivia, or control flow by themselves; attach host evidence for those claims.'
+      ]
+    }, options.coverage),
+    supportedExtensions: options.supportedExtensions ?? ['.java'],
+    diagnostics: options.diagnostics,
+    parse(input) {
+      const parsed = input.options?.ast
+        ?? input.options?.nativeAst
+        ?? input.options?.compilationUnit
+        ?? input.options?.unit
+        ?? input.options?.sourceFile
+        ?? options.ast
+        ?? options.compilationUnit
+        ?? options.unit
+        ?? options.sourceFile
+        ?? parseJavaAstSource(input, options);
+      const root = javaAstRoot(parsed);
+      if (!root) {
+        return missingInjectedParserResult(input, {
+          parser: options.parser ?? 'javac',
+          adapterId: options.id ?? 'frontier.java-ast-native-importer',
+          message: 'createJavaAstNativeImporterAdapter requires an injected Java AST object, parserModule.parse function, parse function, or adapterOptions.ast.'
+        });
+      }
+      const parseDiagnostics = normalizeParserErrors(parsed?.errors ?? parsed?.diagnostics ?? parsed?.problems, input, {
+        parser: options.parser ?? 'javac'
+      });
+      return createNativeImportFromJavaAst(root, input, {
+        parser: options.parser ?? 'javac',
+        astFormat: 'java-ast',
+        maxNodes: options.maxNodes,
+        diagnostics: parseDiagnostics,
+        javaVersion: options.javaVersion ?? input.options?.javaVersion ?? parsed?.javaVersion,
+        sourceLevel: options.sourceLevel ?? input.options?.sourceLevel ?? parsed?.sourceLevel,
+        classPath: input.options?.classPath ?? options.classPath ?? parsed?.classPath,
+        modulePath: input.options?.modulePath ?? options.modulePath ?? parsed?.modulePath,
+        generated: input.options?.generated ?? options.generated ?? parsed?.generated,
+        annotationProcessing: input.options?.annotationProcessing ?? options.annotationProcessing ?? parsed?.annotationProcessing,
+        bindingEvidence: input.options?.bindingEvidence ?? options.bindingEvidence ?? parsed?.bindingEvidence,
+        positionResolver: input.options?.positionResolver ?? options.positionResolver,
+        lineMap: input.options?.lineMap ?? options.lineMap ?? parsed?.lineMap,
+        includeAnnotations: options.includeAnnotations ?? input.options?.includeAnnotations
+      });
+    }
+  };
+}
+
 export function createTreeSitterNativeImporterAdapter(options = {}) {
   return {
     id: options.id ?? `frontier.tree-sitter-${idFragment(options.language ?? 'source')}-native-importer`,
@@ -7222,6 +7373,8 @@ function parserAstFormatIdForParser(parser) {
   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 === 'java' || text.includes('javac') || text.includes('jdt') || text.includes('javaparser') || text.includes('java-parser') || text.includes('java-ast')) return 'java-ast';
   if (text.includes('tree-sitter') || text.includes('treesitter')) return 'tree-sitter';
   if (text.includes('babel')) return 'babel';
   if (text.includes('estree')) return 'estree';
@@ -8287,6 +8440,39 @@ function parseClangAstSource(input, options) {
   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 parseJavaAstSource(input, options) {
+  const parse = options.parse ?? options.parserModule?.parse ?? options.javac?.parse ?? options.jdt?.parse ?? options.javaParser?.parse;
+  if (typeof parse !== 'function') return undefined;
+  const parserOptions = {
+    sourcePath: input.sourcePath,
+    filename: input.sourcePath,
+    javaVersion: options.javaVersion ?? input.options?.javaVersion,
+    sourceLevel: options.sourceLevel ?? input.options?.sourceLevel,
+    classPath: options.classPath ?? input.options?.classPath,
+    modulePath: options.modulePath ?? input.options?.modulePath,
+    includeAnnotations: options.includeAnnotations ?? input.options?.includeAnnotations,
+    ...(options.parserOptions ?? {}),
+    ...(input.options?.parserOptions ?? {})
+  };
+  return parse(input.sourceText, parserOptions);
+}
+
 function createNativeImportFromSyntaxAst(ast, input, options) {
   const root = normalizeSyntaxAstRoot(ast, options.astFormat);
   if (!root) {
@@ -8443,6 +8629,80 @@ function createNativeImportFromClangAst(root, input, options) {
   };
 }
 
+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 createNativeImportFromJavaAst(root, input, options) {
+  const context = createAstNormalizationContext(input, options);
+  visitJavaAstNode(root, context, 'root');
+  if (context.truncated) {
+    context.losses.push(truncatedAstLoss(input, context, options));
+  }
+  if (options.generated && !context.losses.some((loss) => loss.kind === 'generatedCode')) {
+    context.losses.push(javaGeneratedCodeLoss(input, context.rootId, undefined, 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,
+      javaVersion: options.javaVersion,
+      sourceLevel: options.sourceLevel,
+      classPathEvidence: javaPathEvidenceSummary(options.classPath),
+      modulePathEvidence: javaPathEvidenceSummary(options.modulePath),
+      annotationProcessing: javaAnnotationProcessingSummary(options.annotationProcessing),
+      bindingEvidence: javaBindingEvidenceSummary(options.bindingEvidence),
+      generated: options.generated,
+      includeAnnotations: Boolean(options.includeAnnotations),
+      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');
@@ -8748,117 +9008,287 @@ function visitClangAstNode(node, context, propertyPath) {
   return id;
 }
 
-function visitTreeSitterNode(node, context, propertyPath) {
-  if (!node || typeof node !== 'object' || context.truncated) return undefined;
+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 = String(node.type ?? node.kind ?? 'node');
-  const span = spanFromTreeSitterNode(node, context.input);
+  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 = [];
-  const rawChildren = Array.isArray(node.namedChildren)
-    ? node.namedChildren
-    : Array.isArray(node.children)
-      ? node.children
-      : [];
-  rawChildren.forEach((child, index) => {
-    const childId = visitTreeSitterNode(child, context, `${propertyPath}.children[${index}]`);
-    if (childId) children.push(childId);
-  });
-  const declaration = treeSitterDeclaration(node, kind, id, context.input, context.options);
+  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 ?? shortNodeText(node),
-    fields: {
-      named: Boolean(node.isNamed ?? node.named),
-      missing: Boolean(node.isMissing),
-      error: Boolean(node.hasError || kind === 'ERROR')
-    },
+    value: declaration?.name ?? goAstNodeValue(node),
+    fields: primitiveGoAstFields(node, kind),
     children,
     metadata: {
       astFormat: context.options.astFormat,
       propertyPath,
-      startIndex: numberOrUndefined(node.startIndex),
-      endIndex: numberOrUndefined(node.endIndex)
+      positionKind: goAstPositionKind(node),
+      packageName: context.options.packageName
     }
   };
   context.nodes[id] = nativeNode;
-  if (declaration) context.declarations.push({ ...declaration, nativeNode });
-  if (node.hasError || kind === 'ERROR') {
+  for (const entry of declarations) {
+    context.declarations.push({ ...entry, nativeNode });
+  }
+  if (goBadAstKind(kind)) {
     context.losses.push({
-      id: `loss_${idFragment(id)}_tree_sitter_error`,
+      id: `loss_${idFragment(id)}_go_bad_node`,
       severity: 'error',
       phase: 'parse',
       sourceFormat: context.input.language,
       kind: 'unsupportedSyntax',
-      message: 'Tree-sitter reported a parse error node.',
+      message: 'Go parser recovered a BadDecl/BadExpr/BadStmt node; semantic import is partial until syntax errors are resolved.',
       span,
-      nodeId: id
+      nodeId: id,
+      metadata: {
+        parser: context.options.parser,
+        astFormat: context.options.astFormat,
+        nodeKind: kind
+      }
     });
   }
-  return id;
-}
-
-function semanticIndexFromNativeDeclarations(declarations, input, options) {
-  const documentId = `doc_${idFragment(input.sourcePath ?? input.language)}_${idFragment(input.sourceHash)}`;
-  const evidenceId = `evidence_${idFragment(input.sourcePath ?? input.language)}_${idFragment(options.astFormat ?? options.parser)}_import`;
-  const symbols = [];
-  const occurrences = [];
-  const relations = [];
-  const facts = [];
-  const mappings = [];
-  for (const declaration of declarations) {
-    const symbolId = declaration.symbolId ?? `symbol:${input.language}:${declaration.role === 'import' ? 'import:' : ''}${idFragment(declaration.name)}`;
-    const occurrenceId = `occ_${idFragment(declaration.nativeNode.id)}_${declaration.role ?? 'definition'}`;
-    const ownershipRegion = semanticOwnershipRegionForDeclaration(input, {
-      ...declaration,
-      nodeId: declaration.nativeNode.id,
-      kind: declaration.nativeNode.kind,
-      languageKind: declaration.nativeNode.languageKind,
-      span: declaration.nativeNode.span,
-      symbolId
-    }, documentId);
-    declaration.nativeNode.metadata = {
-      ...declaration.nativeNode.metadata,
-      ownershipRegionId: ownershipRegion.id,
-      ownershipRegionKey: ownershipRegion.key,
-      ownershipRegionKind: ownershipRegion.regionKind
-    };
-    symbols.push({
-      id: symbolId,
-      scheme: 'frontier',
-      name: declaration.name,
-      kind: declaration.symbolKind,
-      language: input.language,
-      nativeAstNodeId: declaration.nativeNode.id,
-      signatureHash: hashSemanticValue([input.language, declaration.nativeNode.kind, declaration.name, declaration.nativeNode.fields ?? {}]),
-      definitionSpan: declaration.nativeNode.span,
+  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: {
-        ownershipRegionId: ownershipRegion.id,
-        ownershipRegionKey: ownershipRegion.key,
-        ownershipRegionKind: ownershipRegion.regionKind
+        parser: context.options.parser,
+        astFormat: context.options.astFormat,
+        receiverFieldCount: goReceiverFieldCount(node)
       }
     });
-    occurrences.push({
-      id: occurrenceId,
-      documentId,
-      symbolId,
-      role: declaration.role ?? 'definition',
-      span: declaration.nativeNode.span,
-      nativeAstNodeId: declaration.nativeNode.id
-    });
-    relations.push({
-      id: `rel_${idFragment(documentId)}_${idFragment(declaration.nativeNode.id)}`,
-      sourceId: documentId,
-      predicate: relationPredicateForDeclaration(declaration),
+  }
+  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 visitJavaAstNode(node, context, propertyPath) {
+  if (!isJavaAstNode(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 = javaAstKind(node);
+  const span = spanFromJavaAstNode(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 javaAstChildEntries(node, kind)) {
+    if (Array.isArray(value)) {
+      value.forEach((entry, index) => {
+        const childId = visitJavaAstNode(entry, context, `${propertyPath}.${field}[${index}]`);
+        if (childId) children.push(childId);
+      });
+    } else {
+      const childId = visitJavaAstNode(value, context, `${propertyPath}.${field}`);
+      if (childId) children.push(childId);
+    }
+  }
+  const declarations = javaAstDeclarations(node, kind, id, context.input);
+  const declaration = declarations[0];
+  const nativeNode = {
+    id,
+    kind,
+    languageKind: `${context.input.language}.${kind}`,
+    span,
+    value: declaration?.name ?? javaAstNodeValue(node),
+    fields: primitiveJavaAstFields(node, kind),
+    children,
+    metadata: {
+      astFormat: context.options.astFormat,
+      propertyPath,
+      positionKind: javaAstPositionKind(node),
+      parser: context.options.parser
+    }
+  };
+  context.nodes[id] = nativeNode;
+  for (const entry of declarations) {
+    context.declarations.push({ ...entry, nativeNode });
+  }
+  if (javaRecoveredAstKind(kind) || javaProblemNode(node, kind)) {
+    context.losses.push({
+      id: `loss_${idFragment(id)}_java_recovered_node`,
+      severity: 'error',
+      phase: 'parse',
+      sourceFormat: context.input.language,
+      kind: 'unsupportedSyntax',
+      message: 'Java parser reported a recovered, erroneous, malformed, or problem 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 (javaGeneratedCodeMarker(node, kind) || javaLombokAnnotationMarker(node, kind)) {
+    context.losses.push(javaGeneratedCodeLoss(context.input, id, span, context.options, {
+      nodeKind: kind,
+      generatedMarker: javaGeneratedCodeMarker(node, kind),
+      lombokMarker: javaLombokAnnotationMarker(node, kind)
+    }));
+  }
+  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);
+  if (context.counter >= context.maxNodes) {
+    context.truncated = true;
+    return undefined;
+  }
+  const kind = String(node.type ?? node.kind ?? 'node');
+  const span = spanFromTreeSitterNode(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 = [];
+  const rawChildren = Array.isArray(node.namedChildren)
+    ? node.namedChildren
+    : Array.isArray(node.children)
+      ? node.children
+      : [];
+  rawChildren.forEach((child, index) => {
+    const childId = visitTreeSitterNode(child, context, `${propertyPath}.children[${index}]`);
+    if (childId) children.push(childId);
+  });
+  const declaration = treeSitterDeclaration(node, kind, id, context.input, context.options);
+  const nativeNode = {
+    id,
+    kind,
+    languageKind: `${context.input.language}.${kind}`,
+    span,
+    value: declaration?.name ?? shortNodeText(node),
+    fields: {
+      named: Boolean(node.isNamed ?? node.named),
+      missing: Boolean(node.isMissing),
+      error: Boolean(node.hasError || kind === 'ERROR')
+    },
+    children,
+    metadata: {
+      astFormat: context.options.astFormat,
+      propertyPath,
+      startIndex: numberOrUndefined(node.startIndex),
+      endIndex: numberOrUndefined(node.endIndex)
+    }
+  };
+  context.nodes[id] = nativeNode;
+  if (declaration) context.declarations.push({ ...declaration, nativeNode });
+  if (node.hasError || kind === 'ERROR') {
+    context.losses.push({
+      id: `loss_${idFragment(id)}_tree_sitter_error`,
+      severity: 'error',
+      phase: 'parse',
+      sourceFormat: context.input.language,
+      kind: 'unsupportedSyntax',
+      message: 'Tree-sitter reported a parse error node.',
+      span,
+      nodeId: id
+    });
+  }
+  return id;
+}
+
+function semanticIndexFromNativeDeclarations(declarations, input, options) {
+  const documentId = `doc_${idFragment(input.sourcePath ?? input.language)}_${idFragment(input.sourceHash)}`;
+  const evidenceId = `evidence_${idFragment(input.sourcePath ?? input.language)}_${idFragment(options.astFormat ?? options.parser)}_import`;
+  const symbols = [];
+  const occurrences = [];
+  const relations = [];
+  const facts = [];
+  const mappings = [];
+  for (const declaration of declarations) {
+    const symbolId = declaration.symbolId ?? `symbol:${input.language}:${declaration.role === 'import' ? 'import:' : ''}${idFragment(declaration.name)}`;
+    const occurrenceId = `occ_${idFragment(declaration.nativeNode.id)}_${declaration.role ?? 'definition'}`;
+    const ownershipRegion = semanticOwnershipRegionForDeclaration(input, {
+      ...declaration,
+      nodeId: declaration.nativeNode.id,
+      kind: declaration.nativeNode.kind,
+      languageKind: declaration.nativeNode.languageKind,
+      span: declaration.nativeNode.span,
+      symbolId
+    }, documentId);
+    declaration.nativeNode.metadata = {
+      ...declaration.nativeNode.metadata,
+      ownershipRegionId: ownershipRegion.id,
+      ownershipRegionKey: ownershipRegion.key,
+      ownershipRegionKind: ownershipRegion.regionKind
+    };
+    symbols.push({
+      id: symbolId,
+      scheme: 'frontier',
+      name: declaration.name,
+      kind: declaration.symbolKind,
+      language: input.language,
+      nativeAstNodeId: declaration.nativeNode.id,
+      signatureHash: hashSemanticValue([input.language, declaration.nativeNode.kind, declaration.name, declaration.nativeNode.fields ?? {}]),
+      definitionSpan: declaration.nativeNode.span,
+      metadata: {
+        ownershipRegionId: ownershipRegion.id,
+        ownershipRegionKey: ownershipRegion.key,
+        ownershipRegionKind: ownershipRegion.regionKind
+      }
+    });
+    occurrences.push({
+      id: occurrenceId,
+      documentId,
+      symbolId,
+      role: declaration.role ?? 'definition',
+      span: declaration.nativeNode.span,
+      nativeAstNodeId: declaration.nativeNode.id
+    });
+    relations.push({
+      id: `rel_${idFragment(documentId)}_${idFragment(declaration.nativeNode.id)}`,
+      sourceId: documentId,
+      predicate: relationPredicateForDeclaration(declaration),
       targetId: symbolId
     });
     facts.push({
@@ -10657,6 +11087,815 @@ function serializableIncludeGraphSummary(value) {
   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 javaAstRoot(value) {
+  if (!value || typeof value !== 'object') return undefined;
+  if (isJavaAstNode(value)) return value;
+  if (isJavaAstNode(value.ast)) return value.ast;
+  if (isJavaAstNode(value.root)) return value.root;
+  if (isJavaAstNode(value.compilationUnit)) return value.compilationUnit;
+  if (isJavaAstNode(value.unit)) return value.unit;
+  if (isJavaAstNode(value.sourceFile)) return value.sourceFile;
+  if (Array.isArray(value.types) || Array.isArray(value.imports) || value.packageDeclaration || value.package) {
+    return { kind: 'CompilationUnit', ...value };
+  }
+  return undefined;
+}
+
+function isJavaAstNode(value) {
+  return Boolean(value && typeof value === 'object' && typeof javaAstKind(value) === 'string');
+}
+
+function javaAstKind(node) {
+  if (!node || typeof node !== 'object') return undefined;
+  const declared = node.kind ?? node._type ?? node.type ?? node.nodeType ?? node.astKind ?? node.treeKind ?? node.nodeKind;
+  if (typeof declared === 'string') return normalizeJavaAstKind(declared);
+  if (Array.isArray(node.imports) || Array.isArray(node.types) || node.packageDeclaration || node.package) return 'CompilationUnit';
+  if (node.name && (node.members || node.bodyDeclarations || node.extends || node.implements || node.permittedTypes)) return 'ClassDeclaration';
+  if (node.name && (node.returnType || node.parameters || node.body) && (node.modifiers || node.thrownExceptions || node.throws)) return 'MethodDeclaration';
+  if (node.variables || node.fragments) return 'FieldDeclaration';
+  if (node.name && node.type && (node.initializer !== undefined || node.extraDimensions !== undefined)) return 'VariableDeclarator';
+  return undefined;
+}
+
+function normalizeJavaAstKind(kind) {
+  const text = String(kind).replace(/^(?:com\.sun\.source\.tree\.|org\.eclipse\.jdt\.core\.dom\.|com\.github\.javaparser\.ast\.)/, '');
+  const compact = text.replace(/[_\s.-]+/g, '').replace(/Tree$/, '').toLowerCase();
+  if (compact === 'compilationunit' || compact === 'compilationunitnode') return 'CompilationUnit';
+  if (compact === 'package' || compact === 'packagedeclaration' || compact === 'packageclause') return 'PackageDeclaration';
+  if (compact === 'import' || compact === 'importdeclaration') return 'ImportDeclaration';
+  if (compact === 'class' || compact === 'classdeclaration' || compact === 'normalclassdeclaration' || compact === 'classorinterfacedeclaration') return 'ClassDeclaration';
+  if (compact === 'interface' || compact === 'interfacedeclaration' || compact === 'normalinterfacedeclaration') return 'InterfaceDeclaration';
+  if (compact === 'enum' || compact === 'enumdeclaration') return 'EnumDeclaration';
+  if (compact === 'record' || compact === 'recorddeclaration') return 'RecordDeclaration';
+  if (compact === 'annotation' || compact === 'annotationdeclaration' || compact === 'annotationtypedeclaration' || compact === 'annotationinterface') return 'AnnotationDeclaration';
+  if (compact === 'method' || compact === 'methoddeclaration') return 'MethodDeclaration';
+  if (compact === 'constructor' || compact === 'constructordeclaration') return 'ConstructorDeclaration';
+  if (compact === 'variable' || compact === 'variabledeclaration' || compact === 'variabledeclarator' || compact === 'variabletree') return 'VariableDeclarator';
+  if (compact === 'field' || compact === 'fielddeclaration') return 'FieldDeclaration';
+  if (compact === 'enumconstant' || compact === 'enumconstantdeclaration') return 'EnumConstantDeclaration';
+  if (compact === 'parameter' || compact === 'formalparameter' || compact === 'receiverparameter') return 'Parameter';
+  if (compact === 'modifiers' || compact === 'modifier') return 'Modifiers';
+  if (compact === 'markerannotationexpr' || compact === 'singlememberannotationexpr' || compact === 'normalannotationexpr' || compact === 'annotationexpr') return 'Annotation';
+  if (compact === 'erroneous' || compact === 'erroneoustree' || compact === 'malformed' || compact === 'error' || compact === 'errornode' || compact === 'problem' || compact === 'problemtree' || compact === 'recovered') return 'Erroneous';
+  if (/^[A-Z0-9_]+$/.test(text)) return text.toLowerCase().split('_').map(upperFirst).join('');
+  return text;
+}
+
+function ignoredJavaAstField(key) {
+  return key === '_type'
+    || key === 'type'
+    || key === 'kind'
+    || key === 'nodeType'
+    || key === 'astKind'
+    || key === 'treeKind'
+    || key === 'nodeKind'
+    || key === 'parent'
+    || key === 'parentKind'
+    || key === 'parentField'
+    || key === 'binding'
+    || key === 'resolvedBinding'
+    || key === 'symbol'
+    || key === 'scope'
+    || key === 'range'
+    || key === 'loc'
+    || key === 'location'
+    || key === 'pos'
+    || key === 'end'
+    || key === 'start'
+    || key === 'endPosition'
+    || key === 'startPosition'
+    || key === 'length'
+    || key === 'name'
+    || key === 'identifier'
+    || key === 'simpleName'
+    || key === 'qualifiedName';
+}
+
+function primitiveJavaAstFields(node, kind) {
+  const fields = { kind };
+  const name = javaAstDeclarationName(node);
+  if (name) fields.name = name;
+  const importPath = javaAstImportPath(node);
+  if (importPath) fields.importPath = importPath;
+  const type = javaAstTypeName(node.type ?? node.typeName ?? node.returnType ?? node.elementType);
+  if (type) fields.type = type;
+  const packageName = javaAstPackageName(node);
+  if (packageName) fields.packageName = packageName;
+  const modifiers = javaAstModifierNames(node);
+  if (modifiers.length) fields.modifiers = modifiers.join(',');
+  if (node.static === true || node.isStatic === true) fields.static = true;
+  if (node.default === true || node.isDefault === true) fields.default = true;
+  if (node.generated === true || node.Generated === true) fields.generated = true;
+  if (typeof node.binaryName === 'string') fields.binaryName = node.binaryName;
+  if (typeof node.qualifiedName === 'string') fields.qualifiedName = node.qualifiedName;
+  if (Array.isArray(node.parameters)) fields.parameterCount = node.parameters.length;
+  if (Array.isArray(node.throws ?? node.thrownExceptions)) fields.throwsCount = (node.throws ?? node.thrownExceptions).length;
+  return fields;
+}
+
+function spanFromJavaAstNode(node, input, options = {}) {
+  const direct = spanFromJavaRange(node.range ?? node.loc ?? node.location, input)
+    ?? spanFromJavaLineFields(node, input);
+  if (direct) return direct;
+  const start = javaAstPosition(
+    node.begin ?? node.start ?? node.pos ?? node.position ?? node.startPosition ?? node.name?.range?.begin ?? node.name?.loc?.start,
+    options
+  );
+  const end = javaAstPosition(
+    node.end ?? node.endPosition ?? node.stopPosition ?? node.finishPosition ?? node.name?.range?.end ?? node.name?.loc?.end,
+    options
+  );
+  const sourceRange = node.sourceRange ?? node.rangeInfo;
+  const sourceStart = javaAstPosition(
+    sourceRange?.start ?? sourceRange?.offset ?? sourceRange?.startPosition,
+    options
+  );
+  const sourceEnd = javaAstPosition(
+    typeof sourceRange?.offset === 'number' && typeof sourceRange?.length === 'number'
+      ? sourceRange.offset + sourceRange.length
+      : sourceRange?.end ?? sourceRange?.endPosition,
+    options
+  );
+  const resolvedStart = start ?? sourceStart;
+  const resolvedEnd = end ?? sourceEnd;
+  if (!resolvedStart) return undefined;
+  return {
+    sourceId: input.sourceHash,
+    path: resolvedStart.path ?? resolvedEnd?.path ?? input.sourcePath,
+    startLine: resolvedStart.line,
+    startColumn: resolvedStart.column,
+    endLine: resolvedEnd?.line,
+    endColumn: resolvedEnd?.column
+  };
+}
+
+function spanFromJavaRange(range, input) {
+  if (!range || typeof range !== 'object') return undefined;
+  const start = range.begin ?? range.start;
+  const end = range.end ?? range.stop;
+  if (start && typeof start === 'object') {
+    const startLine = start.line ?? start.Line;
+    const startColumn = start.column ?? start.col ?? start.Column ?? start.character;
+    const endLine = end?.line ?? end?.Line;
+    const endColumn = end?.column ?? end?.col ?? end?.Column ?? end?.character;
+    if (typeof startLine === 'number') {
+      return {
+        sourceId: input.sourceHash,
+        path: start.path ?? start.file ?? end?.path ?? end?.file ?? input.sourcePath,
+        startLine,
+        startColumn,
+        endLine,
+        endColumn
+      };
+    }
+  }
+  return undefined;
+}
+
+function spanFromJavaLineFields(node, input) {
+  const startLine = node.startLine ?? node.line ?? node.beginLine ?? node.lineno;
+  if (typeof startLine !== 'number') return undefined;
+  return {
+    sourceId: input.sourceHash,
+    path: node.path ?? node.file ?? node.filename ?? input.sourcePath,
+    startLine,
+    startColumn: node.startColumn ?? node.column ?? node.beginColumn ?? node.col,
+    endLine: node.endLine ?? node.end_lineno,
+    endColumn: node.endColumn ?? node.end_col_offset
+  };
+}
+
+function javaAstPosition(value, options = {}) {
+  if (value === undefined || value === null) return undefined;
+  if (typeof value === 'object') {
+    const position = value.position ?? value.Position ?? value.pos ?? value.start ?? value;
+    const line = position.line ?? position.Line ?? position.lineno;
+    const column = position.column ?? position.Column ?? position.col ?? position.character;
+    if (typeof line === 'number') {
+      return {
+        path: position.path ?? position.file ?? position.filename ?? position.Filename,
+        line,
+        column: typeof column === 'number' ? column : undefined
+      };
+    }
+  }
+  const resolver = typeof options.positionResolver === 'function'
+    ? options.positionResolver
+    : typeof options.lineMap?.position === 'function'
+      ? options.lineMap.position.bind(options.lineMap)
+      : typeof options.lineMap?.getPosition === 'function'
+        ? options.lineMap.getPosition.bind(options.lineMap)
+        : typeof options.lineMap?.getLineNumber === 'function'
+          ? (offset) => ({
+            line: options.lineMap.getLineNumber(offset),
+            column: typeof options.lineMap.getColumnNumber === 'function' ? options.lineMap.getColumnNumber(offset) : undefined
+          })
+          : undefined;
+  if (resolver) {
+    const resolved = resolver(value);
+    if (resolved !== value) return javaAstPosition(resolved, options);
+  }
+  return undefined;
+}
+
+function javaAstPositionKind(node) {
+  if (node.range?.begin || node.loc?.start) return 'line-column-range';
+  if (typeof node.startLine === 'number' || typeof node.line === 'number') return 'line-column-fields';
+  if (node.pos !== undefined || node.startPosition !== undefined) return 'offset-position';
+  if (node.sourceRange) return 'source-range';
+  return undefined;
+}
+
+function javaAstDeclarations(node, kind, nativeNodeId, input) {
+  if (kind === 'PackageDeclaration') {
+    const name = javaAstPackageName(node) ?? javaAstDeclarationName(node);
+    return name ? [declarationRecord(input, nativeNodeId, name, 'module', 'definition')] : [];
+  }
+  if (kind === 'ImportDeclaration') {
+    const name = javaAstImportPath(node);
+    return name ? [declarationRecord(input, nativeNodeId, name, 'module', 'import')] : [];
+  }
+  if (javaTypeDeclarationKind(kind)) {
+    const name = javaAstDeclarationName(node);
+    return name ? [declarationRecord(input, nativeNodeId, name, javaTypeDeclarationSymbolKind(kind), 'definition')] : [];
+  }
+  if (kind === 'MethodDeclaration' || kind === 'ConstructorDeclaration') {
+    const name = javaAstDeclarationName(node);
+    if (!name) return [];
+    return [declarationRecord(input, nativeNodeId, name, 'method', javaAstHasBody(node) ? 'definition' : 'declaration')];
+  }
+  if (kind === 'FieldDeclaration') {
+    return javaAstFieldNames(node).map((name) => declarationRecord(input, nativeNodeId, name, 'property', 'definition'));
+  }
+  if (kind === 'VariableDeclarator') {
+    if (node.parentField === 'parameters' || node.parentKind === 'MethodDeclaration' || node.parentKind === 'ConstructorDeclaration') return [];
+    const name = javaAstDeclarationName(node);
+    if (!name) return [];
+    const symbolKind = node.parentKind === 'FieldDeclaration' || javaTypeDeclarationKind(node.parentKind) ? 'property' : 'variable';
+    return [declarationRecord(input, nativeNodeId, name, symbolKind, 'definition')];
+  }
+  if (kind === 'EnumConstantDeclaration') {
+    const name = javaAstDeclarationName(node);
+    return name ? [declarationRecord(input, nativeNodeId, name, 'enumMember', 'definition')] : [];
+  }
+  return [];
+}
+
+function javaAstChildEntries(node, kind = javaAstKind(node)) {
+  const fieldNames = Object.keys(node).filter((key) => !ignoredJavaAstField(key));
+  const entries = [];
+  for (const field of fieldNames) {
+    const value = node[field];
+    if (Array.isArray(value)) {
+      entries.push([field, value.map((entry) => javaAstChildWithParent(entry, kind, field))]);
+      continue;
+    }
+    if (value && typeof value === 'object') {
+      entries.push([field, javaAstChildWithParent(value, kind, field)]);
+    }
+  }
+  return entries.filter(([, value]) => Array.isArray(value)
+    ? value.some(isJavaAstNode)
+    : isJavaAstNode(value));
+}
+
+function javaAstChildWithParent(entry, parentKind, parentField) {
+  if (!entry || typeof entry !== 'object' || Array.isArray(entry)) return entry;
+  if (!isJavaAstNode(entry)) return entry;
+  return { parentKind, parentField, ...entry };
+}
+
+function javaAstNodeValue(node) {
+  return javaAstDeclarationName(node)
+    ?? javaAstImportPath(node)
+    ?? javaAstPackageName(node)
+    ?? javaAstTypeName(node.type ?? node.returnType ?? node.elementType)
+    ?? javaAstLiteralValue(node);
+}
+
+function javaAstDeclarationName(node) {
+  if (!node || typeof node !== 'object') return undefined;
+  for (const key of ['name', 'identifier', 'simpleName', 'qualifiedName', 'id']) {
+    const value = node[key];
+    const name = javaAstName(value);
+    if (name) return name;
+  }
+  if (node.declaration && typeof node.declaration === 'object') return javaAstDeclarationName(node.declaration);
+  return undefined;
+}
+
+function javaAstName(value) {
+  if (!value) return undefined;
+  if (typeof value === 'string') return value;
+  if (typeof value.identifier === 'string') return value.identifier;
+  if (typeof value.name === 'string') return value.name;
+  if (typeof value.simpleName === 'string') return value.simpleName;
+  if (typeof value.qualifiedName === 'string') return value.qualifiedName;
+  if (typeof value.fullyQualifiedName === 'string') return value.fullyQualifiedName;
+  if (typeof value.id === 'string') return value.id;
+  if (typeof value.value === 'string') return value.value;
+  if (value.name && value.name !== value) return javaAstName(value.name);
+  if (value.identifier && value.identifier !== value) return javaAstName(value.identifier);
+  return undefined;
+}
+
+function javaAstPackageName(node) {
+  if (!node || typeof node !== 'object') return undefined;
+  return javaAstName(node.packageName ?? node.packageDeclaration ?? node.package ?? node.name);
+}
+
+function javaAstImportPath(node) {
+  if (!node || typeof node !== 'object') return undefined;
+  const candidate = node.qualifiedIdentifier ?? node.qualifiedName ?? node.path ?? node.name ?? node.identifier;
+  const path = javaAstName(candidate);
+  if (!path) return undefined;
+  return node.asterisk || node.wildcard || node.onDemand || node.isAsterisk ? `${path.replace(/\.\*$/, '')}.*` : path;
+}
+
+function javaAstFieldNames(node) {
+  const fragments = node.variables ?? node.fragments ?? node.declarators ?? node.variableDeclarators;
+  if (Array.isArray(fragments)) return fragments.map(javaAstDeclarationName).filter(Boolean);
+  const name = javaAstDeclarationName(node);
+  return name ? [name] : [];
+}
+
+function javaAstTypeName(value) {
+  if (!value) return undefined;
+  if (typeof value === 'string') return value;
+  if (typeof value.name === 'string') return value.name;
+  if (typeof value.typeName === 'string') return value.typeName;
+  if (typeof value.qualifiedName === 'string') return value.qualifiedName;
+  if (value.elementType) {
+    const inner = javaAstTypeName(value.elementType);
+    return inner ? `${inner}[]` : '[]';
+  }
+  if (value.componentType) {
+    const inner = javaAstTypeName(value.componentType);
+    return inner ? `${inner}[]` : '[]';
+  }
+  if (Array.isArray(value.typeArguments)) {
+    const base = javaAstName(value.name) ?? javaAstName(value);
+    const args = value.typeArguments.map(javaAstTypeName).filter(Boolean);
+    return base ? `${base}<${args.join(', ')}>` : undefined;
+  }
+  return javaAstName(value);
+}
+
+function javaAstModifierNames(node) {
+  const modifiers = node.modifiers ?? node.Modifiers ?? node.flags;
+  if (!modifiers) return [];
+  if (Array.isArray(modifiers)) {
+    return uniqueStrings(modifiers.map((entry) => typeof entry === 'string' ? entry : javaAstName(entry) ?? entry.keyword ?? entry.kind).filter(Boolean));
+  }
+  if (typeof modifiers === 'string') return uniqueStrings(modifiers.split(/\s+/).filter(Boolean));
+  if (typeof modifiers === 'object') {
+    return uniqueStrings(Object.entries(modifiers)
+      .filter(([, enabled]) => enabled === true)
+      .map(([key]) => key));
+  }
+  return [];
+}
+
+function javaTypeDeclarationKind(kind) {
+  return kind === 'ClassDeclaration'
+    || kind === 'InterfaceDeclaration'
+    || kind === 'EnumDeclaration'
+    || kind === 'RecordDeclaration'
+    || kind === 'AnnotationDeclaration';
+}
+
+function javaTypeDeclarationSymbolKind(kind) {
+  if (kind === 'InterfaceDeclaration' || kind === 'AnnotationDeclaration') return 'interface';
+  if (kind === 'ClassDeclaration') return 'class';
+  return 'type';
+}
+
+function javaAstHasBody(node) {
+  return Boolean(node.body || node.block || node.statements || node.defaultValue || Array.isArray(node.bodyDeclarations));
+}
+
+function javaAstLiteralValue(node) {
+  const value = node.value ?? node.literal ?? node.token;
+  if (value === null || typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') return value;
+  return undefined;
+}
+
+function javaRecoveredAstKind(kind) {
+  return kind === 'Erroneous'
+    || /Error|Erroneous|Malformed|Recovered|Problem|Missing/.test(String(kind));
+}
+
+function javaProblemNode(node, kind) {
+  return Boolean(node.problem || node.error || node.malformed || node.recovered || node.hasError || node.hasErrors || kind === 'Erroneous');
+}
+
+function javaGeneratedCodeMarker(node, kind) {
+  if (node.generated || node.Generated || node.isGenerated) return true;
+  if (kind === 'Annotation') {
+    const name = javaAstDeclarationName(node);
+    if (name && /(^|\.)(Generated|GeneratedValue)$/.test(name)) return true;
+  }
+  const annotations = node.annotations ?? node.modifiers?.annotations ?? node.modifiers;
+  if (Array.isArray(annotations)) {
+    return annotations.some((annotation) => {
+      const name = javaAstDeclarationName(annotation) ?? javaAstName(annotation);
+      return Boolean(name && /(^|\.)(Generated|GeneratedValue)$/.test(name));
+    });
+  }
+  return false;
+}
+
+function javaLombokAnnotationMarker(node, kind) {
+  if (kind !== 'Annotation') return false;
+  const name = javaAstDeclarationName(node);
+  return Boolean(name && /^(lombok\.|Data$|Value$|Builder$|Getter$|Setter$|AllArgsConstructor$|NoArgsConstructor$|RequiredArgsConstructor$)/.test(name));
+}
+
+function javaGeneratedCodeLoss(input, nodeId, span, options = {}, metadata = {}) {
+  return {
+    id: `loss_${idFragment(nodeId ?? input.sourcePath ?? 'java')}_java_generated_code`,
+    severity: 'warning',
+    phase: 'parse',
+    sourceFormat: input.language,
+    kind: 'generatedCode',
+    message: 'Java generated-source, annotation-generated, or Lombok-derived code marker was imported; regenerated members and source ownership require host evidence.',
+    span,
+    nodeId,
+    metadata: {
+      parser: options.parser,
+      astFormat: options.astFormat,
+      annotationProcessing: javaAnnotationProcessingSummary(options.annotationProcessing),
+      ...metadata
+    }
+  };
+}
+
+function javaPathEvidenceSummary(value) {
+  if (!value) return undefined;
+  if (Array.isArray(value)) return { entryCount: value.length };
+  if (typeof value === 'string') return { entryCount: value.split(/[:;]/).filter(Boolean).length };
+  if (typeof value === 'object') {
+    const summary = {};
+    if (typeof value.hash === 'string') summary.hash = value.hash;
+    if (Array.isArray(value.entries)) summary.entryCount = value.entries.length;
+    if (Array.isArray(value.roots)) summary.rootCount = value.roots.length;
+    if (typeof value.source === 'string') summary.source = value.source;
+    return Object.keys(summary).length ? summary : { present: true };
+  }
+  return { present: true };
+}
+
+function javaAnnotationProcessingSummary(value) {
+  if (!value) return undefined;
+  if (Array.isArray(value)) return { processorCount: value.length };
+  if (typeof value === 'object') {
+    const summary = {};
+    if (typeof value.hash === 'string') summary.hash = value.hash;
+    if (typeof value.enabled === 'boolean') summary.enabled = value.enabled;
+    if (Array.isArray(value.processors)) summary.processorCount = value.processors.length;
+    if (Array.isArray(value.generatedSources)) summary.generatedSourceCount = value.generatedSources.length;
+    return Object.keys(summary).length ? summary : { present: true };
+  }
+  return { present: Boolean(value) };
+}
+
+function javaBindingEvidenceSummary(value) {
+  if (!value || typeof value !== 'object') return undefined;
+  const summary = {};
+  if (typeof value.hash === 'string') summary.hash = value.hash;
+  if (Array.isArray(value.bindings)) summary.bindingCount = value.bindings.length;
+  if (Array.isArray(value.types)) summary.typeCount = value.types.length;
+  if (Array.isArray(value.references)) summary.referenceCount = value.references.length;
+  if (typeof value.solver === 'string') summary.solver = value.solver;
+  return Object.keys(summary).length ? summary : { present: true };
+}
+
 function declarationRecord(input, nativeNodeId, name, symbolKind, role = 'definition') {
   return {
     name: String(name),