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

package/dist/index.js

@@ -333,6 +333,125 @@ export const NativeImportLanguageProfiles = Object.freeze([
   nativeImportLanguageProfile('r', { aliases: ['R'], extensions: ['.r', '.R'], parserAdapters: ['r-parser', 'tree-sitter'], lossKinds: ['declarationOnlyCoverage', 'opaqueNative', 'dynamicRuntime', 'sourceMapApproximation', 'sourcePreservation'] })
 ]);
 
+export const NativeParserAstFormatProfiles = Object.freeze([
+  nativeParserAstFormatProfile('estree', {
+    kind: 'abstract-ast',
+    languages: ['javascript'],
+    parserAdapters: ['estree'],
+    exactness: 'exact-parser-ast',
+    sourceRangeModel: 'loc-range',
+    preservesTokens: false,
+    preservesTrivia: false,
+    supportsErrorRecovery: false,
+    notes: ['Community JavaScript AST shape used by many JS tooling parsers.']
+  }),
+  nativeParserAstFormatProfile('babel', {
+    kind: 'abstract-ast',
+    languages: ['javascript', 'typescript'],
+    parserAdapters: ['babel'],
+    exactness: 'exact-parser-ast',
+    sourceRangeModel: 'loc-range',
+    preservesTokens: false,
+    preservesTrivia: false,
+    supportsErrorRecovery: true,
+    notes: ['Babel-compatible ESTree-like ASTs can report parser errors when error recovery is enabled.']
+  }),
+  nativeParserAstFormatProfile('typescript-compiler-api', {
+    kind: 'compiler-ast',
+    languages: ['typescript', 'javascript'],
+    parserAdapters: ['typescript-compiler-api'],
+    exactness: 'exact-parser-ast',
+    sourceRangeModel: 'pos-end',
+    preservesTokens: false,
+    preservesTrivia: false,
+    supportsErrorRecovery: true,
+    notes: ['TypeScript SourceFile trees can be parsed without a full Program; richer type/checker evidence remains host-owned.']
+  }),
+  nativeParserAstFormatProfile('python-ast', {
+    kind: 'abstract-ast',
+    languages: ['python'],
+    parserAdapters: ['python-ast'],
+    exactness: 'exact-parser-ast',
+    sourceRangeModel: 'lineno-col-offset',
+    preservesTokens: false,
+    preservesTrivia: false,
+    supportsErrorRecovery: false,
+    notes: ['Python stdlib AST exposes versioned abstract grammar and source locations, but not formatting trivia.']
+  }),
+  nativeParserAstFormatProfile('rust-syn', {
+    aliases: ['syn'],
+    kind: 'abstract-ast',
+    languages: ['rust'],
+    parserAdapters: ['syn', 'rust-syn'],
+    exactness: 'exact-parser-ast',
+    sourceRangeModel: 'proc-macro2-span',
+    preservesTokens: false,
+    preservesTrivia: false,
+    supportsErrorRecovery: false,
+    notes: ['syn parses Rust token streams into an abstract syntax tree; macro expansion, name resolution, type checking, and lossless trivia remain host-owned evidence.']
+  }),
+  nativeParserAstFormatProfile('rust-analyzer-rowan', {
+    aliases: ['rowan', 'rust-analyzer'],
+    kind: 'concrete-syntax-tree',
+    languages: ['rust'],
+    parserAdapters: ['rust-analyzer-rowan'],
+    exactness: 'parser-tree',
+    sourceRangeModel: 'text-range',
+    preservesTokens: true,
+    preservesTrivia: true,
+    supportsIncremental: true,
+    supportsErrorRecovery: true,
+    notes: ['rust-analyzer uses rowan-backed concrete syntax trees with AST wrappers; semantic richness still depends on host analysis evidence.']
+  }),
+  nativeParserAstFormatProfile('tree-sitter', {
+    kind: 'concrete-syntax-tree',
+    languages: ['mixed'],
+    parserAdapters: ['tree-sitter'],
+    exactness: 'parser-tree',
+    sourceRangeModel: 'row-column',
+    preservesTokens: false,
+    preservesTrivia: false,
+    supportsIncremental: true,
+    supportsErrorRecovery: true,
+    notes: ['Tree-sitter provides cross-language concrete syntax trees; language-specific queries still decide semantic richness.']
+  }),
+  nativeParserAstFormatProfile('libcst', {
+    kind: 'concrete-syntax-tree',
+    languages: ['python'],
+    parserAdapters: ['libcst'],
+    exactness: 'parser-tree',
+    sourceRangeModel: 'metadata-position-provider',
+    preservesTokens: true,
+    preservesTrivia: true,
+    supportsErrorRecovery: false,
+    notes: ['LibCST-style trees preserve formatting and are best treated as host-owned evidence until normalized explicitly.']
+  }),
+  nativeParserAstFormatProfile('scip', {
+    kind: 'semantic-index',
+    languages: ['mixed'],
+    parserAdapters: ['scip'],
+    exactness: 'loss-aware-native-ast',
+    sourceRangeModel: 'range-tuples',
+    preservesTokens: false,
+    preservesTrivia: false,
+    supportsErrorRecovery: false,
+    notes: ['SCIP is semantic index evidence rather than a full parser AST; it is useful for symbols/references and source maps.']
+  }),
+  nativeParserAstFormatProfile('lsif', {
+    kind: 'semantic-index',
+    languages: ['mixed'],
+    parserAdapters: ['lsif'],
+    exactness: 'loss-aware-native-ast',
+    sourceRangeModel: 'lsp-ranges',
+    preservesTokens: false,
+    preservesTrivia: false,
+    supportsErrorRecovery: false,
+    notes: ['LSIF graph dumps are semantic/source-map evidence, not complete native ASTs.']
+  })
+]);
+
+export const NativeParserAstFormats = Object.freeze(NativeParserAstFormatProfiles.map((profile) => profile.id));
+
 export const ExternalSemanticIndexFormats = Object.freeze([
   'frontier-semantic-index',
   'scip',
@@ -2125,6 +2244,57 @@ export function createNativeImportCoverageMatrix(input = {}) {
   };
 }
 
+export function getNativeParserAstFormatProfile(format) {
+  const normalized = normalizeParserAstFormatId(format);
+  return NativeParserAstFormatProfiles.find((profile) => profile.id === normalized || profile.aliases.includes(normalized));
+}
+
+export function createNativeParserAstFormatMatrix(input = {}) {
+  const imports = input.imports ?? [];
+  const adapters = input.adapters ?? [];
+  const profiles = mergeNativeParserAstFormatProfiles(input.formats ?? NativeParserAstFormatProfiles, imports, adapters);
+  const formats = profiles.map((profile) => nativeParserAstFormatCoverageForProfile(profile, imports, adapters));
+  const summary = formats.reduce((totals, entry) => {
+    totals.formats += 1;
+    totals.adapterSlots += entry.parserAdapters.length;
+    totals.adapters += entry.adapters.total;
+    totals.imports += entry.imports.total;
+    totals.nativeAstNodes += entry.imports.nativeAstNodes;
+    totals.symbols += entry.imports.symbols;
+    totals.sourceMapMappings += entry.imports.sourceMapMappings;
+    totals.losses += entry.imports.losses;
+    totals.byKind[entry.kind] = (totals.byKind[entry.kind] ?? 0) + 1;
+    totals.byReadiness[entry.imports.readiness] = (totals.byReadiness[entry.imports.readiness] ?? 0) + 1;
+    for (const [capability, count] of Object.entries(entry.adapters.effectiveCapabilities)) {
+      totals.effectiveCapabilities[capability] = (totals.effectiveCapabilities[capability] ?? 0) + count;
+    }
+    return totals;
+  }, {
+    formats: 0,
+    adapterSlots: 0,
+    adapters: 0,
+    imports: 0,
+    nativeAstNodes: 0,
+    symbols: 0,
+    sourceMapMappings: 0,
+    losses: 0,
+    byKind: {},
+    byReadiness: {},
+    effectiveCapabilities: {}
+  });
+  return {
+    kind: 'frontier.lang.nativeParserAstFormatMatrix',
+    version: 1,
+    generatedAt: input.generatedAt ?? Date.now(),
+    formats,
+    summary,
+    metadata: {
+      note: 'Parser AST format coverage describes normalization evidence and host-parser obligations; it is not a lossless portability claim.',
+      profileIds: profiles.map((profile) => profile.id)
+    }
+  };
+}
+
 export function createProjectionTargetLossMatrix(input = {}) {
   const imports = input.imports ?? [];
   const adapters = input.adapters ?? [];
@@ -2435,6 +2605,112 @@ export function createTypeScriptCompilerNativeImporterAdapter(options = {}) {
   };
 }
 
+export function createPythonAstNativeImporterAdapter(options = {}) {
+  return {
+    id: options.id ?? 'frontier.python-ast-native-importer',
+    language: options.language ?? 'python',
+    parser: options.parser ?? 'python-ast',
+    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 Python stdlib ast trees into native AST nodes and declaration-level semantic index records.',
+        'Python ast does not preserve comments, whitespace, or concrete formatting; use LibCST/parso-style host evidence for round-trip trivia.'
+      ]
+    }, options.coverage),
+    supportedExtensions: options.supportedExtensions ?? ['.py', '.pyi'],
+    diagnostics: options.diagnostics,
+    parse(input) {
+      const parsed = input.options?.ast
+        ?? input.options?.nativeAst
+        ?? options.ast
+        ?? parsePythonAstSource(input, options);
+      const root = pythonAstRoot(parsed);
+      if (!root) {
+        return missingInjectedParserResult(input, {
+          parser: options.parser ?? 'python-ast',
+          adapterId: options.id ?? 'frontier.python-ast-native-importer',
+          message: 'createPythonAstNativeImporterAdapter requires an injected Python AST object, parserModule.parse function, parse function, or adapterOptions.ast.'
+        });
+      }
+      const parseDiagnostics = normalizeParserErrors(parsed?.errors ?? parsed?.diagnostics, input, {
+        parser: options.parser ?? 'python-ast'
+      });
+      return createNativeImportFromPythonAst(root, input, {
+        parser: options.parser ?? 'python-ast',
+        astFormat: 'python-ast',
+        maxNodes: options.maxNodes,
+        diagnostics: parseDiagnostics,
+        pythonVersion: options.pythonVersion ?? input.options?.pythonVersion ?? parsed?.pythonVersion,
+        includeAttributes: options.includeAttributes ?? input.options?.includeAttributes
+      });
+    }
+  };
+}
+
+export function createRustSynNativeImporterAdapter(options = {}) {
+  return {
+    id: options.id ?? 'frontier.rust-syn-native-importer',
+    language: options.language ?? 'rust',
+    parser: options.parser ?? 'syn',
+    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: false,
+      generatedRanges: false,
+      semanticCoverage: declarationSemanticCoverage(),
+      notes: [
+        'Normalizes caller-owned syn-shaped Rust ASTs into native AST nodes and declaration-level semantic index records.',
+        'syn does not expand macros, resolve names, type-check, or preserve full concrete syntax/trivia; attach rust-analyzer/rustc evidence for those claims.'
+      ]
+    }, options.coverage),
+    supportedExtensions: options.supportedExtensions ?? ['.rs'],
+    diagnostics: options.diagnostics,
+    parse(input) {
+      const parsed = input.options?.ast
+        ?? input.options?.nativeAst
+        ?? input.options?.file
+        ?? input.options?.sourceFile
+        ?? options.ast
+        ?? options.file
+        ?? options.sourceFile
+        ?? parseRustSynSource(input, options);
+      const root = rustSynAstRoot(parsed);
+      if (!root) {
+        return missingInjectedParserResult(input, {
+          parser: options.parser ?? 'syn',
+          adapterId: options.id ?? 'frontier.rust-syn-native-importer',
+          message: 'createRustSynNativeImporterAdapter requires an injected syn-shaped AST object, parserModule.parse function, parse function, or adapterOptions.ast.'
+        });
+      }
+      const parseDiagnostics = normalizeParserErrors(parsed?.errors ?? parsed?.diagnostics, input, {
+        parser: options.parser ?? 'syn'
+      });
+      return createNativeImportFromRustSyn(root, input, {
+        parser: options.parser ?? 'syn',
+        astFormat: 'rust-syn',
+        maxNodes: options.maxNodes,
+        diagnostics: parseDiagnostics,
+        rustEdition: options.rustEdition ?? input.options?.rustEdition ?? parsed?.rustEdition,
+        includeAttributes: options.includeAttributes ?? input.options?.includeAttributes
+      });
+    }
+  };
+}
+
 export function createTreeSitterNativeImporterAdapter(options = {}) {
   return {
     id: options.id ?? `frontier.tree-sitter-${idFragment(options.language ?? 'source')}-native-importer`,
@@ -6767,6 +7043,134 @@ function nativeImportLanguageProfile(language, input = {}) {
   });
 }
 
+function nativeParserAstFormatProfile(id, input = {}) {
+  return Object.freeze({
+    id,
+    aliases: Object.freeze(uniqueStrings(input.aliases ?? [])),
+    kind: input.kind ?? 'abstract-ast',
+    languages: Object.freeze(uniqueStrings(input.languages ?? [])),
+    parserAdapters: Object.freeze(uniqueStrings(input.parserAdapters ?? [id])),
+    exactness: input.exactness ?? 'unknown',
+    sourceRangeModel: input.sourceRangeModel ?? 'unknown',
+    preservesTokens: Boolean(input.preservesTokens),
+    preservesTrivia: Boolean(input.preservesTrivia),
+    supportsIncremental: Boolean(input.supportsIncremental),
+    supportsErrorRecovery: Boolean(input.supportsErrorRecovery),
+    notes: Object.freeze(uniqueStrings(input.notes ?? []))
+  });
+}
+
+function normalizeParserAstFormatId(format) {
+  return String(format ?? '').trim().toLowerCase().replace(/[_\s]+/g, '-');
+}
+
+function mergeNativeParserAstFormatProfiles(profiles, imports, adapters) {
+  const byId = new Map((profiles ?? []).map((profile) => [normalizeParserAstFormatId(profile.id ?? profile), nativeParserAstFormatProfile(normalizeParserAstFormatId(profile.id ?? profile), profile)]));
+  for (const adapter of adapters ?? []) {
+    const summary = safeNativeImporterAdapterSummary(adapter);
+    if (!summary) continue;
+    const formatId = parserAstFormatIdForParser(summary.parser);
+    if (!byId.has(formatId)) {
+      byId.set(formatId, nativeParserAstFormatProfile(formatId, {
+        languages: [summary.language],
+        parserAdapters: [summary.parser],
+        exactness: summary.coverage.exactness,
+        sourceRangeModel: summary.coverage.sourceRanges ? 'adapter-reported' : 'unknown'
+      }));
+    }
+  }
+  for (const imported of imports ?? []) {
+    const formatId = parserAstFormatIdForImport(imported);
+    if (formatId && !byId.has(formatId)) {
+      byId.set(formatId, nativeParserAstFormatProfile(formatId, {
+        languages: [imported.language].filter(Boolean),
+        parserAdapters: [imported.parser ?? imported.nativeAst?.parser ?? formatId],
+        exactness: 'unknown',
+        sourceRangeModel: (imported.sourceMaps ?? []).some((sourceMap) => sourceMap.mappings?.some((mapping) => mapping.sourceSpan)) ? 'adapter-reported' : 'unknown'
+      }));
+    }
+  }
+  return [...byId.values()].sort((left, right) => left.id.localeCompare(right.id));
+}
+
+function nativeParserAstFormatCoverageForProfile(profile, imports, adapters) {
+  const formatIds = new Set([profile.id, ...profile.aliases].map(normalizeParserAstFormatId));
+  const adapterParsers = new Set(profile.parserAdapters.map(parserAstFormatIdForParser));
+  const matchingAdapters = (adapters ?? [])
+    .map((adapter) => safeNativeImporterAdapterSummary(adapter))
+    .filter(Boolean)
+    .filter((adapter) => formatIds.has(parserAstFormatIdForParser(adapter.parser)) || adapterParsers.has(parserAstFormatIdForParser(adapter.parser)));
+  const matchingImports = (imports ?? [])
+    .filter((imported) => {
+      const formatId = parserAstFormatIdForImport(imported);
+      return formatId && (formatIds.has(formatId) || adapterParsers.has(formatId));
+    });
+  const effectiveCapabilities = {};
+  for (const adapter of matchingAdapters) {
+    for (const row of adapter.coverage.capabilityEvidence?.capabilities ?? []) {
+      if (row.effective) effectiveCapabilities[row.capability] = (effectiveCapabilities[row.capability] ?? 0) + 1;
+    }
+  }
+  const readiness = matchingImports.reduce(
+    (current, imported) => maxSemanticMergeReadiness(current, nativeImportReadiness(imported)),
+    matchingImports.length ? 'ready' : 'needs-review'
+  );
+  return {
+    id: profile.id,
+    kind: profile.kind,
+    languages: profile.languages,
+    parserAdapters: profile.parserAdapters,
+    exactness: profile.exactness,
+    sourceRangeModel: profile.sourceRangeModel,
+    preservesTokens: profile.preservesTokens,
+    preservesTrivia: profile.preservesTrivia,
+    supportsIncremental: profile.supportsIncremental,
+    supportsErrorRecovery: profile.supportsErrorRecovery,
+    notes: profile.notes,
+    adapters: {
+      total: matchingAdapters.length,
+      ids: matchingAdapters.map((adapter) => adapter.id),
+      parsers: uniqueStrings(matchingAdapters.map((adapter) => adapter.parser)),
+      effectiveCapabilities
+    },
+    imports: {
+      total: matchingImports.length,
+      sourcePaths: matchingImports.map((imported) => imported.sourcePath).filter(Boolean),
+      readiness,
+      nativeAstNodes: matchingImports.reduce((sum, imported) => sum + Object.keys(imported.nativeAst?.nodes ?? {}).length, 0),
+      symbols: matchingImports.reduce((sum, imported) => sum + (imported.semanticIndex?.symbols?.length ?? 0), 0),
+      sourceMapMappings: matchingImports.reduce((sum, imported) => sum + (imported.sourceMaps ?? []).reduce((mapSum, sourceMap) => mapSum + (sourceMap.mappings?.length ?? 0), 0), 0),
+      losses: matchingImports.reduce((sum, imported) => sum + (imported.losses?.length ?? 0), 0)
+    }
+  };
+}
+
+function parserAstFormatIdForParser(parser) {
+  const text = normalizeParserAstFormatId(parser);
+  if (text.includes('typescript')) return 'typescript-compiler-api';
+  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('tree-sitter') || text.includes('treesitter')) return 'tree-sitter';
+  if (text.includes('babel')) return 'babel';
+  if (text.includes('estree')) return 'estree';
+  if (text.includes('libcst')) return 'libcst';
+  if (text.includes('scip')) return 'scip';
+  if (text.includes('lsif')) return 'lsif';
+  return text || 'unknown';
+}
+
+function parserAstFormatIdForImport(imported) {
+  return parserAstFormatIdForParser(
+    imported?.metadata?.adapter?.parser
+      ?? imported?.metadata?.astFormat
+      ?? imported?.nativeAst?.metadata?.astFormat
+      ?? imported?.nativeAst?.parser
+      ?? imported?.parser
+      ?? imported?.metadata?.parser
+  );
+}
+
 function mergeNativeImportProfiles(languages, imports, adapters, targetAdapters = []) {
   const profilesByLanguage = new Map();
   for (const profile of languages) {
@@ -7764,6 +8168,37 @@ function parseTreeSitterSource(input, options) {
   return undefined;
 }
 
+function parsePythonAstSource(input, options) {
+  const parse = options.parse ?? options.parserModule?.parse ?? options.pythonAst?.parse;
+  if (typeof parse !== 'function') return undefined;
+  const parserOptions = {
+    sourcePath: input.sourcePath,
+    filename: input.sourcePath,
+    mode: options.mode ?? input.options?.mode ?? 'exec',
+    typeComments: options.typeComments ?? input.options?.typeComments,
+    featureVersion: options.featureVersion ?? input.options?.featureVersion,
+    optimize: options.optimize ?? input.options?.optimize,
+    includeAttributes: options.includeAttributes ?? input.options?.includeAttributes,
+    ...(options.parserOptions ?? {}),
+    ...(input.options?.parserOptions ?? {})
+  };
+  return parse(input.sourceText, parserOptions);
+}
+
+function parseRustSynSource(input, options) {
+  const parse = options.parse ?? options.parserModule?.parse ?? options.rustSyn?.parse ?? options.syn?.parse;
+  if (typeof parse !== 'function') return undefined;
+  const parserOptions = {
+    sourcePath: input.sourcePath,
+    filename: input.sourcePath,
+    edition: options.rustEdition ?? input.options?.rustEdition ?? '2021',
+    includeAttributes: options.includeAttributes ?? input.options?.includeAttributes,
+    ...(options.parserOptions ?? {}),
+    ...(input.options?.parserOptions ?? {})
+  };
+  return parse(input.sourceText, parserOptions);
+}
+
 function createNativeImportFromSyntaxAst(ast, input, options) {
   const root = normalizeSyntaxAstRoot(ast, options.astFormat);
   if (!root) {
@@ -7824,6 +8259,66 @@ function createNativeImportFromTypeScriptAst(sourceFile, input, options) {
   };
 }
 
+function createNativeImportFromPythonAst(root, input, options) {
+  const context = createAstNormalizationContext(input, options);
+  visitPythonAstNode(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,
+      pythonVersion: options.pythonVersion,
+      includeAttributes: Boolean(options.includeAttributes),
+      normalizedNodeCount: Object.keys(context.nodes).length,
+      declarationCount: context.declarations.length,
+      truncated: context.truncated
+    }
+  };
+}
+
+function createNativeImportFromRustSyn(root, input, options) {
+  const context = createAstNormalizationContext(input, options);
+  visitRustSynNode(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,
+      rustEdition: options.rustEdition,
+      includeAttributes: Boolean(options.includeAttributes),
+      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');
@@ -7960,6 +8455,114 @@ function visitTypeScriptAstNode(node, sourceFile, context, propertyPath, ts) {
   return id;
 }
 
+function visitPythonAstNode(node, context, propertyPath) {
+  if (!isPythonAstNode(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 = pythonAstKind(node);
+  const span = spanFromPythonAstNode(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 pythonAstChildEntries(node)) {
+    if (Array.isArray(value)) {
+      value.forEach((entry, index) => {
+        const childId = visitPythonAstNode(entry, context, `${propertyPath}.${field}[${index}]`);
+        if (childId) children.push(childId);
+      });
+    } else {
+      const childId = visitPythonAstNode(value, context, `${propertyPath}.${field}`);
+      if (childId) children.push(childId);
+    }
+  }
+  const declaration = pythonAstDeclaration(node, kind, id, context.input);
+  const nativeNode = {
+    id,
+    kind,
+    languageKind: `${context.input.language}.${kind}`,
+    span,
+    value: declaration?.name ?? pythonAstNodeValue(node),
+    fields: primitivePythonAstFields(node, kind),
+    children,
+    metadata: {
+      astFormat: context.options.astFormat,
+      propertyPath,
+      lineno: numberOrUndefined(node.lineno ?? node.line),
+      colOffset: numberOrUndefined(node.col_offset ?? node.colOffset),
+      endLineno: numberOrUndefined(node.end_lineno ?? node.endLine),
+      endColOffset: numberOrUndefined(node.end_col_offset ?? node.endColOffset)
+    }
+  };
+  context.nodes[id] = nativeNode;
+  if (declaration) context.declarations.push({ ...declaration, nativeNode });
+  return id;
+}
+
+function visitRustSynNode(node, context, propertyPath) {
+  if (!isRustSynAstNode(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 = rustSynKind(node);
+  const payload = rustSynPayload(node);
+  const span = spanFromRustSynNode(payload, 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 rustSynChildEntries(node)) {
+    if (Array.isArray(value)) {
+      value.forEach((entry, index) => {
+        const childId = visitRustSynNode(entry, context, `${propertyPath}.${field}[${index}]`);
+        if (childId) children.push(childId);
+      });
+    } else {
+      const childId = visitRustSynNode(value, context, `${propertyPath}.${field}`);
+      if (childId) children.push(childId);
+    }
+  }
+  const declaration = rustSynDeclaration(payload, kind, id, context.input);
+  const nativeNode = {
+    id,
+    kind,
+    languageKind: `${context.input.language}.${kind}`,
+    span,
+    value: declaration?.name ?? rustSynNodeValue(payload),
+    fields: primitiveRustSynFields(payload, kind),
+    children,
+    metadata: {
+      astFormat: context.options.astFormat,
+      propertyPath,
+      spanKind: rustSynSpanKind(payload)
+    }
+  };
+  context.nodes[id] = nativeNode;
+  if (declaration) context.declarations.push({ ...declaration, nativeNode });
+  if (rustSynMacroKind(kind)) {
+    context.losses.push({
+      id: `loss_${idFragment(id)}_rust_macro_expansion`,
+      severity: 'warning',
+      phase: 'parse',
+      sourceFormat: context.input.language,
+      kind: 'macroExpansion',
+      message: 'Rust macro syntax was parsed but macro expansion and generated items require host compiler 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);
@@ -8455,6 +9058,14 @@ function nativeTargetProjectionDiagnosticToLoss(diagnostic, index, adapter, inpu
   };
 }
 
+function safeNativeImporterAdapterSummary(adapter) {
+  try {
+    return normalizeNativeImporterAdapter(adapter);
+  } catch {
+    return undefined;
+  }
+}
+
 function normalizeNativeImporterAdapter(adapter) {
   if (!adapter || typeof adapter !== 'object') {
     throw new Error('Native importer adapter must be an object');
@@ -9089,6 +9700,104 @@ function isSyntaxAstNode(value) {
   return Boolean(value && typeof value === 'object' && typeof (value.type ?? value.kind) === 'string');
 }
 
+function pythonAstRoot(value) {
+  if (!value || typeof value !== 'object') return undefined;
+  if (isPythonAstNode(value)) return value;
+  if (isPythonAstNode(value.ast)) return value.ast;
+  if (isPythonAstNode(value.root)) return value.root;
+  if (isPythonAstNode(value.module)) return value.module;
+  return undefined;
+}
+
+function isPythonAstNode(value) {
+  return Boolean(value && typeof value === 'object' && typeof pythonAstKind(value) === 'string');
+}
+
+function pythonAstKind(node) {
+  return node?._type ?? node?.type ?? node?.kind ?? node?.nodeType;
+}
+
+function rustSynAstRoot(value) {
+  if (!value || typeof value !== 'object') return undefined;
+  if (isRustSynAstNode(value)) return value;
+  if (isRustSynAstNode(value.ast)) return value.ast;
+  if (isRustSynAstNode(value.file)) return value.file;
+  if (isRustSynAstNode(value.root)) return value.root;
+  if (isRustSynAstNode(value.module)) return value.module;
+  if (isRustSynAstNode(value.sourceFile)) return value.sourceFile;
+  return undefined;
+}
+
+function isRustSynAstNode(value) {
+  return Boolean(value && typeof value === 'object' && typeof rustSynKind(value) === 'string');
+}
+
+function rustSynKind(node) {
+  const declared = node?._type ?? node?.type ?? node?.kind ?? node?.nodeType ?? node?.synKind;
+  if (typeof declared === 'string') return normalizeRustSynKind(declared);
+  const wrapper = rustSynWrapperKind(node);
+  if (wrapper) return normalizeRustSynKind(wrapper);
+  if (Array.isArray(node?.items)) return 'File';
+  if (node?.sig && node?.block) return 'ItemFn';
+  if (node?.ident && node?.fields && Array.isArray(node?.variants)) return 'ItemEnum';
+  if (node?.ident && node?.fields) return 'ItemStruct';
+  if (node?.ident && Array.isArray(node?.items)) return 'ItemMod';
+  if (node?.trait_ || node?.self_ty || node?.selfType) return 'ItemImpl';
+  if (node?.path && (node?.tree || node?.trees)) return 'ItemUse';
+  return undefined;
+}
+
+function rustSynPayload(node) {
+  if (!node || typeof node !== 'object') return node;
+  const wrapper = rustSynWrapperKind(node);
+  return wrapper ? node[wrapper] : node;
+}
+
+function rustSynWrapperKind(node) {
+  if (!node || typeof node !== 'object') return undefined;
+  const keys = Object.keys(node).filter((key) => !ignoredRustSynField(key));
+  if (keys.length !== 1) return undefined;
+  const key = keys[0];
+  const value = node[key];
+  if (!value || typeof value !== 'object') return undefined;
+  if (/^(?:Fn|Struct|Enum|Trait|Impl|Use|Mod|Type|Const|Static|Union|Macro)$/.test(key)) return key;
+  if (/^(?:Item|ImplItem|TraitItem|ForeignItem)/.test(key)) return key;
+  return undefined;
+}
+
+function normalizeRustSynKind(kind) {
+  const text = String(kind);
+  const compact = text.replace(/^(?:syn::)?/, '').replace(/^Item::/, 'Item').replace(/^ImplItem::/, 'ImplItem').replace(/^TraitItem::/, 'TraitItem');
+  if (/^fn$/i.test(compact)) return 'ItemFn';
+  if (/^struct$/i.test(compact)) return 'ItemStruct';
+  if (/^enum$/i.test(compact)) return 'ItemEnum';
+  if (/^trait$/i.test(compact)) return 'ItemTrait';
+  if (/^impl$/i.test(compact)) return 'ItemImpl';
+  if (/^use$/i.test(compact)) return 'ItemUse';
+  if (/^mod$/i.test(compact)) return 'ItemMod';
+  if (/^type$/i.test(compact)) return 'ItemType';
+  if (/^const$/i.test(compact)) return 'ItemConst';
+  if (/^static$/i.test(compact)) return 'ItemStatic';
+  if (/^union$/i.test(compact)) return 'ItemUnion';
+  if (/^item_fn$/i.test(compact)) return 'ItemFn';
+  if (/^item_struct$/i.test(compact)) return 'ItemStruct';
+  if (/^item_enum$/i.test(compact)) return 'ItemEnum';
+  if (/^item_trait$/i.test(compact)) return 'ItemTrait';
+  if (/^item_impl$/i.test(compact)) return 'ItemImpl';
+  if (/^item_use$/i.test(compact)) return 'ItemUse';
+  if (/^item_mod$/i.test(compact)) return 'ItemMod';
+  if (/^item_type$/i.test(compact)) return 'ItemType';
+  if (/^item_const$/i.test(compact)) return 'ItemConst';
+  if (/^item_static$/i.test(compact)) return 'ItemStatic';
+  if (/^item_union$/i.test(compact)) return 'ItemUnion';
+  if (/^item_macro$/i.test(compact)) return 'ItemMacro';
+  if (/^macro$/i.test(compact)) return 'Macro';
+  if (/^impl_item_fn$/i.test(compact)) return 'ImplItemFn';
+  if (/^trait_item_fn$/i.test(compact)) return 'TraitItemFn';
+  if (/^foreign_item_fn$/i.test(compact)) return 'ForeignItemFn';
+  return compact;
+}
+
 function ignoredSyntaxField(key) {
   return key === 'type'
     || key === 'kind'
@@ -9105,6 +9814,36 @@ function ignoredSyntaxField(key) {
     || key === 'parent';
 }
 
+function ignoredPythonAstField(key) {
+  return key === '_type'
+    || key === 'type'
+    || key === 'kind'
+    || key === 'nodeType'
+    || key === '_fields'
+    || key === 'lineno'
+    || key === 'col_offset'
+    || key === 'end_lineno'
+    || key === 'end_col_offset'
+    || key === 'line'
+    || key === 'colOffset'
+    || key === 'endLine'
+    || key === 'endColOffset'
+    || key === 'ctx'
+    || key === 'parent';
+}
+
+function ignoredRustSynField(key) {
+  return key === '_type'
+    || key === 'type'
+    || key === 'kind'
+    || key === 'nodeType'
+    || key === 'synKind'
+    || key === 'span'
+    || key === 'tokens'
+    || key === 'tokenStream'
+    || key === 'parent';
+}
+
 function primitiveSyntaxFields(node) {
   const fields = {};
   for (const key of ['name', 'operator', 'sourceType', 'async', 'generator', 'computed', 'static', 'exportKind', 'importKind', 'optional']) {
@@ -9118,11 +9857,52 @@ function primitiveSyntaxFields(node) {
   return fields;
 }
 
+function primitivePythonAstFields(node, kind) {
+  const fields = { kind };
+  for (const key of ['name', 'id', 'arg', 'module', 'level', 'attr', 'asname', 'type_comment']) {
+    if (typeof node[key] === 'string' || typeof node[key] === 'number' || typeof node[key] === 'boolean' || node[key] === null) {
+      fields[key] = node[key];
+    }
+  }
+  if (Array.isArray(node.names)) {
+    fields.names = node.names
+      .map((entry) => pythonAliasName(entry))
+      .filter(Boolean)
+      .join(',');
+  }
+  const literal = pythonAstLiteralValue(node);
+  if (literal !== undefined) fields.literal = literal;
+  return fields;
+}
+
+function primitiveRustSynFields(node, kind) {
+  const fields = { kind };
+  const ident = rustSynIdentName(node.ident ?? node.name ?? node.sig?.ident);
+  if (ident) fields.ident = ident;
+  const path = rustSynPathName(node.path ?? node.trait_ ?? node.self_ty ?? node.selfType ?? node.ty);
+  if (path) fields.path = path;
+  const visibility = rustSynVisibility(node.vis ?? node.visibility);
+  if (visibility) fields.visibility = visibility;
+  for (const key of ['mutability', 'defaultness', 'constness', 'asyncness', 'unsafety', 'abi']) {
+    const value = node[key];
+    if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean' || value === null) fields[key] = value;
+  }
+  if (Array.isArray(node.attrs) && node.attrs.length) fields.attributeCount = node.attrs.length;
+  return fields;
+}
+
 function literalSyntaxValue(node) {
   if (node.value === null || typeof node.value === 'string' || typeof node.value === 'number' || typeof node.value === 'boolean') return node.value;
   return undefined;
 }
 
+function pythonAstLiteralValue(node) {
+  if (node.value === null || typeof node.value === 'string' || typeof node.value === 'number' || typeof node.value === 'boolean') return node.value;
+  if (typeof node.s === 'string' || typeof node.s === 'number') return node.s;
+  if (typeof node.n === 'number') return node.n;
+  return undefined;
+}
+
 function spanFromLoc(loc, input) {
   if (!loc?.start) return undefined;
   return {
@@ -9135,6 +9915,52 @@ function spanFromLoc(loc, input) {
   };
 }
 
+function spanFromPythonAstNode(node, input) {
+  const line = node.lineno ?? node.line;
+  if (typeof line !== 'number') return undefined;
+  const col = node.col_offset ?? node.colOffset;
+  const endLine = node.end_lineno ?? node.endLine;
+  const endCol = node.end_col_offset ?? node.endColOffset;
+  return {
+    sourceId: input.sourceHash,
+    path: input.sourcePath,
+    startLine: line,
+    startColumn: typeof col === 'number' ? col + 1 : undefined,
+    endLine: typeof endLine === 'number' ? endLine : undefined,
+    endColumn: typeof endCol === 'number' ? endCol + 1 : undefined
+  };
+}
+
+function spanFromRustSynNode(node, input) {
+  const span = node.span ?? node.ident?.span ?? node.sig?.ident?.span ?? node.name?.span;
+  if (!span || typeof span !== 'object') return undefined;
+  const start = span.start ?? span.lo ?? span.begin;
+  const end = span.end ?? span.hi;
+  const startLine = span.startLine ?? span.line ?? start?.line;
+  const startColumn = span.startColumn ?? span.column ?? start?.column;
+  const endLine = span.endLine ?? end?.line;
+  const endColumn = span.endColumn ?? end?.column;
+  if (typeof startLine !== 'number') return undefined;
+  return {
+    sourceId: input.sourceHash,
+    path: input.sourcePath,
+    startLine,
+    startColumn: typeof startColumn === 'number' ? rustSynColumnToOneBased(startColumn, span) : undefined,
+    endLine: typeof endLine === 'number' ? endLine : undefined,
+    endColumn: typeof endColumn === 'number' ? rustSynColumnToOneBased(endColumn, span) : undefined
+  };
+}
+
+function rustSynColumnToOneBased(column, span) {
+  return span.columnBase === 1 || span.columnsOneBased ? column : column + 1;
+}
+
+function rustSynSpanKind(node) {
+  const span = node.span ?? node.ident?.span ?? node.sig?.ident?.span ?? node.name?.span;
+  if (!span || typeof span !== 'object') return undefined;
+  return span.kind ?? span.source ?? 'host-span';
+}
+
 function syntaxDeclaration(node, nativeNodeId, input) {
   const kind = String(node.type ?? node.kind ?? '');
   if (kind === 'ImportDeclaration') {
@@ -9153,6 +9979,64 @@ function syntaxDeclaration(node, nativeNodeId, input) {
   return undefined;
 }
 
+function pythonAstDeclaration(node, kind, nativeNodeId, input) {
+  if (kind === 'Import') {
+    const name = (node.names ?? []).map((entry) => pythonAliasName(entry)).find(Boolean);
+    if (name) return declarationRecord(input, nativeNodeId, name, 'module', 'import');
+  }
+  if (kind === 'ImportFrom') {
+    const name = node.module ?? (node.names ?? []).map((entry) => pythonAliasName(entry)).find(Boolean);
+    if (name) return declarationRecord(input, nativeNodeId, name, 'module', 'import');
+  }
+  if (kind === 'FunctionDef' || kind === 'AsyncFunctionDef') return declarationRecord(input, nativeNodeId, node.name, 'function', 'definition');
+  if (kind === 'ClassDef') return declarationRecord(input, nativeNodeId, node.name, 'class', 'definition');
+  if (kind === 'AnnAssign' || kind === 'Assign') {
+    const name = pythonAssignmentName(node);
+    if (name) return declarationRecord(input, nativeNodeId, name, 'variable', 'definition');
+  }
+  return undefined;
+}
+
+function rustSynDeclaration(node, kind, nativeNodeId, input) {
+  if (kind === 'ItemUse' || kind === 'UseTree' || kind === 'UsePath' || kind === 'UseName') {
+    const name = rustSynUseName(node);
+    if (name) return declarationRecord(input, nativeNodeId, name, 'module', 'import');
+  }
+  if (kind === 'ItemFn' || kind === 'ForeignItemFn') {
+    const name = rustSynIdentName(node.sig?.ident ?? node.ident ?? node.name);
+    if (name) return declarationRecord(input, nativeNodeId, name, 'function', 'definition');
+  }
+  if (kind === 'ImplItemFn' || kind === 'TraitItemFn') {
+    const name = rustSynIdentName(node.sig?.ident ?? node.ident ?? node.name);
+    if (name) return declarationRecord(input, nativeNodeId, name, 'method', 'definition');
+  }
+  if (kind === 'ItemStruct' || kind === 'ItemUnion') {
+    const name = rustSynIdentName(node.ident ?? node.name);
+    if (name) return declarationRecord(input, nativeNodeId, name, 'class', 'definition');
+  }
+  if (kind === 'ItemEnum' || kind === 'ItemTrait' || kind === 'ItemType') {
+    const name = rustSynIdentName(node.ident ?? node.name);
+    if (name) return declarationRecord(input, nativeNodeId, name, 'type', 'definition');
+  }
+  if (kind === 'ItemMod') {
+    const name = rustSynIdentName(node.ident ?? node.name);
+    if (name) return declarationRecord(input, nativeNodeId, name, 'module', 'definition');
+  }
+  if (kind === 'ItemConst' || kind === 'ItemStatic') {
+    const name = rustSynIdentName(node.ident ?? node.name);
+    if (name) return declarationRecord(input, nativeNodeId, name, 'variable', 'definition');
+  }
+  if (kind === 'ItemImpl') {
+    const name = rustSynImplName(node);
+    if (name) return declarationRecord(input, nativeNodeId, name, 'type', 'definition');
+  }
+  if (rustSynMacroKind(kind)) {
+    const name = rustSynIdentName(node.ident ?? node.mac?.path ?? node.path);
+    if (name) return declarationRecord(input, nativeNodeId, name, 'macro', 'definition');
+  }
+  return undefined;
+}
+
 function typeScriptDeclaration(node, kind, nativeNodeId, input) {
   if (kind === 'ImportDeclaration' || kind === 'ImportEqualsDeclaration') {
     const name = stringFromTsExpression(node.moduleSpecifier) ?? stringFromTsExpression(node.externalModuleReference?.expression);
@@ -9196,6 +10080,155 @@ function namedDeclaration(input, nativeNodeId, nameNode, symbolKind) {
   return name ? declarationRecord(input, nativeNodeId, name, symbolKind, 'definition') : undefined;
 }
 
+function pythonAstChildEntries(node) {
+  const fieldNames = Array.isArray(node._fields)
+    ? node._fields
+    : Object.keys(node).filter((key) => !ignoredPythonAstField(key));
+  return fieldNames
+    .map((field) => [field, node[field]])
+    .filter(([, value]) => Array.isArray(value)
+      ? value.some(isPythonAstNode)
+      : isPythonAstNode(value));
+}
+
+function rustSynChildEntries(node) {
+  const payload = rustSynPayload(node);
+  const fieldNames = Object.keys(payload).filter((key) => !ignoredRustSynField(key));
+  return fieldNames
+    .map((field) => [field, payload[field]])
+    .filter(([, value]) => Array.isArray(value)
+      ? value.some(isRustSynAstNode)
+      : isRustSynAstNode(value));
+}
+
+function pythonAstNodeValue(node) {
+  return node.name ?? node.id ?? node.arg ?? node.module ?? pythonAstLiteralValue(node);
+}
+
+function rustSynNodeValue(node) {
+  return rustSynIdentName(node.ident ?? node.name ?? node.sig?.ident)
+    ?? rustSynPathName(node.path ?? node.trait_ ?? node.self_ty ?? node.selfType ?? node.ty)
+    ?? rustSynLiteralValue(node);
+}
+
+function pythonAliasName(alias) {
+  if (!alias) return undefined;
+  if (typeof alias === 'string') return alias;
+  return alias.name ?? alias.asname ?? alias.id;
+}
+
+function pythonAssignmentName(node) {
+  if (node.target) return pythonTargetName(node.target);
+  for (const target of node.targets ?? []) {
+    const name = pythonTargetName(target);
+    if (name) return name;
+  }
+  return undefined;
+}
+
+function pythonTargetName(target) {
+  if (!target) return undefined;
+  if (typeof target === 'string') return target;
+  if (typeof target.id === 'string') return target.id;
+  if (typeof target.name === 'string') return target.name;
+  if (typeof target.arg === 'string') return target.arg;
+  if (target.attr && target.value) {
+    const base = pythonTargetName(target.value);
+    return base ? `${base}.${target.attr}` : target.attr;
+  }
+  return undefined;
+}
+
+function rustSynIdentName(value) {
+  if (!value) return undefined;
+  if (typeof value === 'string') return value;
+  if (typeof value.ident === 'string') return value.ident;
+  if (typeof value.name === 'string') return value.name;
+  if (typeof value.text === 'string') return value.text;
+  if (typeof value.sym === 'string') return value.sym;
+  if (typeof value.value === 'string') return value.value;
+  if (typeof value.path === 'string') return value.path;
+  return rustSynPathName(value.path ?? value);
+}
+
+function rustSynPathName(value) {
+  if (!value) return undefined;
+  if (typeof value === 'string') return value;
+  if (typeof value.ident === 'string') return value.ident;
+  if (typeof value.name === 'string') return value.name;
+  if (typeof value.path === 'string') return value.path;
+  if (value.path && typeof value.path === 'object') return rustSynPathName(value.path);
+  if (Array.isArray(value.segments)) {
+    const names = value.segments
+      .map((segment) => rustSynIdentName(segment.ident ?? segment))
+      .filter(Boolean);
+    return names.length ? names.join('::') : undefined;
+  }
+  if (Array.isArray(value.qself)) return value.qself.map(rustSynPathName).filter(Boolean).join('::');
+  if (value.leading_colon && value.segments) {
+    const name = rustSynPathName({ segments: value.segments });
+    return name ? `::${name}` : undefined;
+  }
+  return undefined;
+}
+
+function rustSynUseName(node) {
+  if (!node) return undefined;
+  if (node.prefix && node.tree) {
+    const prefix = rustSynPathName(node.prefix);
+    const child = rustSynUseName(node.tree);
+    return [prefix, child].filter(Boolean).join('::') || undefined;
+  }
+  if (node.ident && node.tree) {
+    const prefix = rustSynIdentName(node.ident);
+    const child = rustSynUseName(node.tree);
+    return [prefix, child].filter(Boolean).join('::') || undefined;
+  }
+  if (node.path && node.tree) {
+    const prefix = rustSynPathName(node.path);
+    const child = rustSynUseName(node.tree);
+    return [prefix, child].filter(Boolean).join('::') || undefined;
+  }
+  if (Array.isArray(node.trees)) return node.trees.map(rustSynUseName).find(Boolean);
+  if (node.tree) return rustSynUseName(node.tree);
+  if (node.path) return rustSynPathName(node.path);
+  if (node.name) return rustSynIdentName(node.name);
+  if (node.ident) return rustSynIdentName(node.ident);
+  if (node.rename) return rustSynIdentName(node.rename);
+  return undefined;
+}
+
+function rustSynImplName(node) {
+  const selfType = rustSynPathName(node.self_ty ?? node.selfType ?? node.ty);
+  const traitPath = Array.isArray(node.trait_)
+    ? rustSynPathName(node.trait_[1] ?? node.trait_[0])
+    : rustSynPathName(node.trait_);
+  if (selfType && traitPath) return `${selfType}.${traitPath}.impl`;
+  if (selfType) return `${selfType}.impl`;
+  if (traitPath) return `${traitPath}.impl`;
+  return undefined;
+}
+
+function rustSynVisibility(value) {
+  if (!value) return undefined;
+  if (typeof value === 'string') return value;
+  if (typeof value.kind === 'string') return value.kind;
+  if (typeof value.type === 'string') return value.type;
+  if (value.pub || value.Public) return 'pub';
+  if (value.restricted || value.Restricted) return 'restricted';
+  return undefined;
+}
+
+function rustSynLiteralValue(node) {
+  const value = node.value ?? node.lit?.value ?? node.lit;
+  if (value === null || typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') return value;
+  return undefined;
+}
+
+function rustSynMacroKind(kind) {
+  return /Macro|MacroRules|MacroCall/.test(String(kind));
+}
+
 function declarationRecord(input, nativeNodeId, name, symbolKind, role = 'definition') {
   return {
     name: String(name),