@shapeshift-labs/frontier-lang-compiler 0.2.41 → 0.2.42

package/dist/native-parser-ast-format-profiles.js

@@ -0,0 +1,271 @@
+import {
+  uniqueStrings
+} from './native-import-utils.js';
+
+export const NativeParserFeatureCategories = Object.freeze([
+  'syntax',
+  'semantic',
+  'type',
+  'controlFlow',
+  'macroMetaprogramming',
+  'sourcePreservation'
+]);
+
+export const NativeParserFeatureCoverageStatuses = Object.freeze([
+  'full',
+  'partial',
+  'evidence-required',
+  'missing',
+  'blocked',
+  'not-applicable'
+]);
+
+
+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('clang-ast-json', {
+    aliases: ['clang', 'libclang', 'clang-json', 'clang-ast-dump-json'],
+    kind: 'compiler-ast',
+    languages: ['c', 'cpp'],
+    parserAdapters: ['clang', 'libclang', 'clang-ast-json'],
+    exactness: 'exact-parser-ast',
+    sourceRangeModel: 'clang-loc-range',
+    preservesTokens: false,
+    preservesTrivia: false,
+    supportsErrorRecovery: false,
+    notes: ['Clang JSON AST dumps expose compiler AST declarations and source ranges after preprocessing; compile commands, macros, inactive branches, type checking, and lossless formatting remain host-owned evidence.']
+  }),
+  nativeParserAstFormatProfile('go-ast', {
+    aliases: ['go/parser', 'goast', 'golang-ast'],
+    kind: 'compiler-ast',
+    languages: ['go'],
+    parserAdapters: ['go/ast', 'go/parser', 'go-ast'],
+    exactness: 'exact-parser-ast',
+    sourceRangeModel: 'token-position',
+    preservesTokens: false,
+    preservesTrivia: false,
+    supportsErrorRecovery: true,
+    notes: ['Go go/ast trees expose parser syntax nodes and token positions; FileSet, build tags, generated-code classification, package loading, go/types, comments/trivia, and control-flow evidence remain host-owned.']
+  }),
+  nativeParserAstFormatProfile('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('kotlin-psi', {
+    aliases: ['kotlin-compiler', 'kotlin-compiler-psi', 'intellij-psi', 'kt-psi', 'kotlin-ast'],
+    kind: 'compiler-ast',
+    languages: ['kotlin'],
+    parserAdapters: ['kotlin-compiler', 'kotlin-psi', 'intellij-psi'],
+    exactness: 'exact-parser-ast',
+    sourceRangeModel: 'text-range-line-column',
+    preservesTokens: true,
+    preservesTrivia: true,
+    supportsErrorRecovery: true,
+    notes: ['Kotlin PSI exposes source syntax and IntelliJ parser errors; Analysis API symbols, FIR/K2 types, expect/actual matching, compiler plugins, generated sources, scripts, and build variants remain host-owned evidence.']
+  }),
+  nativeParserAstFormatProfile('roslyn-csharp', {
+    aliases: ['roslyn', 'csharp-roslyn', 'c#-roslyn', 'microsoft-codeanalysis-csharp', 'csharp-syntax'],
+    kind: 'compiler-ast',
+    languages: ['csharp'],
+    parserAdapters: ['roslyn', 'microsoft.codeanalysis.csharp', 'csharp-roslyn'],
+    exactness: 'exact-parser-ast',
+    sourceRangeModel: 'text-span-line-position-span',
+    preservesTokens: true,
+    preservesTrivia: true,
+    supportsIncremental: true,
+    supportsErrorRecovery: true,
+    notes: ['Roslyn C# syntax trees expose immutable nodes, tokens, trivia, spans, diagnostics, directives, and skipped text; SemanticModel symbols, nullable analysis, generated sources, partial type stitching, analyzer results, and project references remain host-owned evidence.']
+  }),
+  nativeParserAstFormatProfile('swift-syntax', {
+    aliases: ['swiftsyntax', 'swiftparser', 'swift-parser', 'swift-syntax-json'],
+    kind: 'concrete-syntax-tree',
+    languages: ['swift'],
+    parserAdapters: ['swift-syntax', 'swiftparser'],
+    exactness: 'parser-tree',
+    sourceRangeModel: 'absolute-position-source-location',
+    preservesTokens: true,
+    preservesTrivia: true,
+    supportsIncremental: false,
+    supportsErrorRecovery: true,
+    notes: ['SwiftSyntax exposes a source-accurate syntax tree with missing/unexpected nodes and token/trivia structure; SourceKit symbols, macro expansion, conditional compilation branch resolution, type checking, generated sources, and package/module dependency resolution remain host-owned 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 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 ?? []))
+  });
+}
+
+export function normalizeParserAstFormatId(format) {
+  return String(format ?? '').trim().toLowerCase().replace(/[_\s]+/g, '-');
+}
+
+
+export 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('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 === 'kotlin' || text === 'kt' || text.includes('kotlin-psi') || text.includes('kotlin-compiler') || text.includes('intellij-psi') || text.includes('kt-psi')) return 'kotlin-psi';
+  if (text === 'csharp' || text === 'c#' || text === 'cs' || text.includes('roslyn') || text.includes('microsoft-codeanalysis-csharp') || text.includes('csharp-syntax')) return 'roslyn-csharp';
+  if (text.includes('swift-syntax') || text.includes('swiftsyntax') || text.includes('swiftparser') || text.includes('swift-parser')) return 'swift-syntax';
+  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';
+}
+
+export function parserAstFormatIdForImport(imported) {
+  return parserAstFormatIdForParser(
+    imported?.metadata?.adapter?.parser
+      ?? imported?.metadata?.astFormat
+      ?? imported?.nativeAst?.metadata?.astFormat
+      ?? imported?.nativeAst?.parser
+      ?? imported?.parser
+      ?? imported?.metadata?.parser
+  );
+}

package/dist/native-parser-feature-assessment.js

@@ -0,0 +1,118 @@
+import {
+  maxSemanticMergeReadiness,
+  normalizeSemanticMergeReadiness,
+  normalizeStringList,
+  uniqueStrings
+} from './native-import-utils.js';
+import {
+  NativeParserFeatureCategories
+} from './coverage-matrix-profiles.js';
+import {
+  nativeParserFeatureStatusMergeReady
+} from './native-parser-feature-coverage.js';
+
+const semanticMergeReadinessRank = Object.freeze({
+  ready: 0,
+  'ready-with-losses': 1,
+  'needs-review': 2,
+  blocked: 3
+});
+
+export function nativeParserFeatureMergeAssessment(row, input = {}) {
+  const requiredFeatures = normalizeNativeParserRequiredFeatures(input.requiredFeatures);
+  const minimumReadiness = normalizeSemanticMergeReadiness(input.minimumReadiness ?? 'ready') ?? 'ready';
+  const featureReadiness = requiredFeatures.reduce(
+    (current, category) => maxSemanticMergeReadiness(current, row.features?.[category]?.readiness ?? 'blocked'),
+    'ready'
+  );
+  const readiness = maxSemanticMergeReadiness(row.imports?.readiness ?? 'needs-review', featureReadiness);
+  const blockingFeatures = requiredFeatures.filter((category) => !nativeParserFeatureStatusMergeReady(row.features?.[category]?.status));
+  const reviewFeatures = requiredFeatures.filter((category) => {
+    const featureReadiness = row.features?.[category]?.readiness ?? 'blocked';
+    return semanticMergeReadinessRank[featureReadiness] > semanticMergeReadinessRank.ready
+      && semanticMergeReadinessRank[featureReadiness] <= semanticMergeReadinessRank['needs-review'];
+  });
+  const reasons = [];
+  if ((row.imports?.total ?? 0) === 0) reasons.push('No native import evidence matched this language/parser row.');
+  for (const category of blockingFeatures) {
+    const feature = row.features?.[category];
+    reasons.push(`${category} coverage is ${feature?.status ?? 'missing'}: ${(feature?.reasons ?? []).join(' ')}`);
+  }
+  if (semanticMergeReadinessRank[readiness] > semanticMergeReadinessRank[minimumReadiness]) {
+    reasons.push(`Readiness ${readiness} is weaker than required threshold ${minimumReadiness}.`);
+  }
+  const mergeReady = (row.imports?.total ?? 0) > 0
+    && blockingFeatures.length === 0
+    && semanticMergeReadinessRank[readiness] <= semanticMergeReadinessRank[minimumReadiness];
+  if (mergeReady) reasons.push(`Native import is merge-ready for required features: ${requiredFeatures.join(', ')}.`);
+  return Object.freeze({
+    mergeReady,
+    readiness,
+    requiredFeatures,
+    minimumReadiness,
+    blockingFeatures,
+    reviewFeatures,
+    reasons: uniqueStrings(reasons)
+  });
+}
+
+export function normalizeNativeParserRequiredFeatures(value) {
+  const requested = normalizeStringList(value);
+  const features = requested.length ? requested : ['syntax', 'semantic', 'sourcePreservation'];
+  return uniqueStrings(features.map(normalizeNativeParserFeatureCategory).filter((feature) => NativeParserFeatureCategories.includes(feature)));
+}
+
+function normalizeNativeParserFeatureCategory(value) {
+  const normalized = String(value ?? '').trim().replace(/[-_\s]+([a-zA-Z])/g, (_, letter) => letter.toUpperCase());
+  if (normalized.toLowerCase() === 'macrometaprogramming' || normalized.toLowerCase() === 'macro') return 'macroMetaprogramming';
+  if (normalized.toLowerCase() === 'controlflow' || normalized.toLowerCase() === 'cfg') return 'controlFlow';
+  if (normalized.toLowerCase() === 'sourcepreservation' || normalized.toLowerCase() === 'source') return 'sourcePreservation';
+  if (normalized.toLowerCase() === 'types') return 'type';
+  return normalized;
+}
+
+export function nativeParserFeatureMatrixSummary(rows) {
+  const summary = {
+    languages: new Set(),
+    parsers: rows.length,
+    imports: 0,
+    adapters: 0,
+    mergeReady: 0,
+    byReadiness: {},
+    byFeatureStatus: {},
+    byFeatureReadiness: {}
+  };
+  for (const row of rows) {
+    summary.languages.add(row.language);
+    summary.imports += row.imports.total;
+    summary.adapters += row.adapters.total;
+    if (row.merge.mergeReady) summary.mergeReady += 1;
+    summary.byReadiness[row.merge.readiness] = (summary.byReadiness[row.merge.readiness] ?? 0) + 1;
+    for (const [category, feature] of Object.entries(row.features)) {
+      summary.byFeatureStatus[category] ??= {};
+      summary.byFeatureReadiness[category] ??= {};
+      summary.byFeatureStatus[category][feature.status] = (summary.byFeatureStatus[category][feature.status] ?? 0) + 1;
+      summary.byFeatureReadiness[category][feature.readiness] = (summary.byFeatureReadiness[category][feature.readiness] ?? 0) + 1;
+    }
+  }
+  return {
+    ...summary,
+    languages: summary.languages.size
+  };
+}
+
+export function summarizeNativeParserFeatureLanguages(profiles, rows) {
+  return profiles.map((profile) => {
+    const languageRows = rows.filter((row) => row.language === profile.language);
+    return {
+      language: profile.language,
+      aliases: profile.aliases,
+      parserRows: languageRows.length,
+      parsers: languageRows.map((row) => row.parser),
+      imports: languageRows.reduce((sum, row) => sum + row.imports.total, 0),
+      adapters: languageRows.reduce((sum, row) => sum + row.adapters.total, 0),
+      mergeReadyParsers: languageRows.filter((row) => row.merge.mergeReady).map((row) => row.parser),
+      readiness: languageRows.reduce((current, row) => maxSemanticMergeReadiness(current, row.merge.readiness), 'ready')
+    };
+  });
+}

package/dist/native-parser-feature-coverage.js

@@ -0,0 +1,268 @@
+import {
+  uniqueStrings
+} from './native-import-utils.js';
+import {
+  NativeParserFeatureCoverageStatuses
+} from './coverage-matrix-profiles.js';
+
+const nativeParserMacroMetaprogrammingLossKinds = new Set([
+  'macroExpansion',
+  'macroHygiene',
+  'preprocessor',
+  'conditionalCompilation',
+  'metaprogramming',
+  'reflection',
+  'generatedCode'
+]);
+
+const nativeParserTypeCoverageLossKinds = new Set([
+  'typeInference',
+  'overloadResolution',
+  'overloadTypeInference',
+  'unsupportedSemantic'
+]);
+
+export function nativeParserSyntaxFeature(context) {
+  const blockingSyntaxLosses = context.losses.filter((loss) => loss.severity === 'error' && (loss.kind === 'unsupportedSyntax' || loss.kind === 'parserDiagnostic'));
+  const exactAst = context.adapterCoverage.effective.exactAst ?? 0;
+  const sourceRanges = context.adapterCoverage.effective.sourceRanges ?? 0;
+  const parserDiagnostics = context.adapterCoverage.effective.parserDiagnostics ?? 0;
+  let status = 'missing';
+  const reasons = [];
+  if (blockingSyntaxLosses.length) {
+    status = 'blocked';
+    reasons.push('Parser diagnostics or unsupported syntax errors block syntax coverage.');
+  } else if (exactAst > 0 && (sourceRanges > 0 || context.sourceMapMappings > 0)) {
+    status = 'full';
+    reasons.push('Exact parser AST and source-range evidence are available.');
+  } else if (exactAst > 0 || sourceRanges > 0 || context.nativeAstNodes > 1 || context.sourceMapMappings > 0) {
+    status = 'partial';
+    reasons.push('Syntax evidence exists, but exact AST/source-range coverage is incomplete.');
+  } else if (context.adapters.length || context.parserProfile) {
+    status = 'evidence-required';
+    reasons.push('Parser slot is declared, but no observed syntax import evidence is attached.');
+  } else {
+    reasons.push('No syntax parser coverage is declared or observed.');
+  }
+  return nativeParserFeatureCoverage('syntax', status, {
+    capabilities: {
+      exactAst,
+      sourceRanges,
+      parserDiagnostics,
+      nativeAstNodes: context.nativeAstNodes,
+      sourceMapMappings: context.sourceMapMappings
+    },
+    gaps: nativeParserFeatureCapabilityGaps(context.adapterCoverage, ['exactAst', 'sourceRanges', 'parserDiagnostics']),
+    lossKinds: nativeParserFeatureLossKindCounts(context.losses, ['unsupportedSyntax', 'parserDiagnostic']),
+    reasons,
+    notes: ['Syntax coverage covers parser AST/CST structure, diagnostics, source ranges, and source-map anchors.']
+  });
+}
+
+export function nativeParserSemanticFeature(context) {
+  const declarations = (context.adapterCoverage.effective.semanticDeclarations ?? 0) + context.semanticEvidence.declarations;
+  const symbols = (context.adapterCoverage.effective.semanticSymbols ?? 0) + context.semanticEvidence.symbols;
+  let status = 'missing';
+  const reasons = [];
+  if (symbols > 0 && declarations > 0) {
+    status = 'full';
+    reasons.push('Declaration and symbol evidence are available.');
+  } else if (symbols > 0 || declarations > 0 || context.nativeAstNodes > 1) {
+    status = 'partial';
+    reasons.push('Semantic evidence is present, but declaration/symbol coverage is incomplete.');
+  } else if (context.adapters.length || context.imports.length) {
+    status = 'evidence-required';
+    reasons.push('Import evidence exists, but no semantic declarations or symbols were observed.');
+  } else {
+    reasons.push('No semantic index evidence is declared or observed.');
+  }
+  return nativeParserFeatureCoverage('semantic', status, {
+    capabilities: {
+      declarations,
+      symbols,
+      semanticIndexLevel: nativeParserFeatureSemanticLevel(context.adapterCoverage, context.semanticEvidence)
+    },
+    gaps: nativeParserFeatureCapabilityGaps(context.adapterCoverage, ['semanticDeclarations', 'semanticSymbols']),
+    lossKinds: nativeParserFeatureLossKindCounts(context.losses, ['partialSemanticIndex', 'unsupportedSemantic']),
+    reasons,
+    notes: ['Semantic coverage covers declaration and symbol evidence. References, types, and control flow are reported separately.']
+  });
+}
+
+export function nativeParserTypeFeature(context) {
+  const types = (context.adapterCoverage.effective.types ?? 0) + context.semanticEvidence.types;
+  const typeLossKinds = nativeParserFeaturePresentLossKinds(context, nativeParserTypeCoverageLossKinds);
+  let status = 'missing';
+  const reasons = [];
+  if (types > 0) {
+    status = 'full';
+    reasons.push('Resolved or declared type evidence is available.');
+  } else if (typeLossKinds.length > 0 || context.semanticEvidence.symbols > 0) {
+    status = 'evidence-required';
+    reasons.push('Type-sensitive coverage needs compiler or language-server evidence.');
+  } else {
+    reasons.push('No type evidence is declared or observed.');
+  }
+  return nativeParserFeatureCoverage('type', status, {
+    capabilities: { types },
+    gaps: nativeParserFeatureCapabilityGaps(context.adapterCoverage, ['types']),
+    lossKinds: nativeParserFeatureLossKindCounts(context.losses, [...nativeParserTypeCoverageLossKinds]),
+    reasons,
+    notes: ['Type coverage covers declared/inferred type facts and overload or inference evidence.']
+  });
+}
+
+export function nativeParserControlFlowFeature(context) {
+  const controlFlow = (context.adapterCoverage.effective.controlFlow ?? 0) + context.semanticEvidence.controlFlow;
+  let status = 'missing';
+  const reasons = [];
+  if (controlFlow > 0) {
+    status = 'full';
+    reasons.push('Control-flow or CFG evidence is available.');
+  } else if (context.imports.length || context.adapters.length) {
+    status = 'evidence-required';
+    reasons.push('Control-flow evidence was not observed for this parser row.');
+  } else {
+    reasons.push('No control-flow evidence is declared or observed.');
+  }
+  return nativeParserFeatureCoverage('controlFlow', status, {
+    capabilities: { controlFlow },
+    gaps: nativeParserFeatureCapabilityGaps(context.adapterCoverage, ['controlFlow']),
+    lossKinds: {},
+    reasons,
+    notes: ['Control-flow coverage covers call/branch/CFG facts supplied by host parsers or semantic indexers.']
+  });
+}
+
+export function nativeParserMacroMetaprogrammingFeature(context, dependencies = {}) {
+  const macroLossKinds = nativeParserFeaturePresentLossKinds(context, nativeParserMacroMetaprogrammingLossKinds);
+  const macroLosses = context.losses.filter((loss) => nativeParserMacroMetaprogrammingLossKinds.has(loss.kind));
+  const featureEvidence = dependencies.summarizeNativeImportFeatureEvidence(macroLosses, { evidence: context.evidence });
+  const generatedRanges = context.adapterCoverage.effective.generatedRanges ?? 0;
+  let status = 'not-applicable';
+  const reasons = [];
+  if (!macroLossKinds.length) {
+    reasons.push('No macro, preprocessor, generator, or metaprogramming coverage risk is declared for this parser row.');
+  } else if (macroLosses.some((loss) => loss.severity === 'error')) {
+    status = 'blocked';
+    reasons.push('Macro or metaprogramming evidence includes blocking loss records.');
+  } else if (featureEvidence.missingRequiredEvidence.length > 0 || generatedRanges === 0) {
+    status = 'evidence-required';
+    reasons.push('Macro/metaprogramming coverage requires generated-range and policy evidence before merge admission.');
+  } else {
+    status = 'partial';
+    reasons.push('Macro/metaprogramming risk has attached evidence, but this facade still treats generated behavior as review-required.');
+  }
+  return nativeParserFeatureCoverage('macroMetaprogramming', status, {
+    capabilities: {
+      generatedRanges,
+      policyKinds: featureEvidence.policyKinds,
+      highestRisk: featureEvidence.highestRisk
+    },
+    gaps: nativeParserFeatureCapabilityGaps(context.adapterCoverage, ['generatedRanges']),
+    lossKinds: nativeParserFeatureLossKindCounts(context.losses, [...nativeParserMacroMetaprogrammingLossKinds]),
+    reasons: uniqueStrings([...reasons, ...featureEvidence.reasons]),
+    notes: ['Macro/metaprogramming coverage covers macros, preprocessors, generated code, reflection, and conditional compilation evidence.']
+  });
+}
+
+export function nativeParserSourcePreservationFeature(context) {
+  const exactSource = context.sourcePreservation.exactSourceAvailable;
+  const tokens = context.sourcePreservation.tokens + (context.adapterCoverage.effective.tokens ?? 0);
+  const trivia = context.sourcePreservation.trivia + (context.adapterCoverage.effective.trivia ?? 0);
+  const sourceRanges = context.adapterCoverage.effective.sourceRanges ?? 0;
+  let status = 'missing';
+  const reasons = [];
+  if (exactSource > 0 && (tokens > 0 || trivia > 0 || sourceRanges > 0)) {
+    status = 'full';
+    reasons.push('Exact source text and token/trivia or source-range evidence are available.');
+  } else if (exactSource > 0 || tokens > 0 || trivia > 0 || sourceRanges > 0) {
+    status = 'partial';
+    reasons.push('Source-preservation evidence exists, but exact source, tokens, trivia, or ranges are incomplete.');
+  } else if (context.imports.length || context.adapters.length) {
+    status = 'evidence-required';
+    reasons.push('Import or adapter evidence exists, but no exact source-preservation record was observed.');
+  } else {
+    reasons.push('No source-preservation evidence is declared or observed.');
+  }
+  return nativeParserFeatureCoverage('sourcePreservation', status, {
+    capabilities: {
+      exactSourceAvailable: exactSource,
+      tokens,
+      trivia,
+      comments: context.sourcePreservation.comments,
+      whitespace: context.sourcePreservation.whitespace,
+      directives: context.sourcePreservation.directives,
+      sourceRanges
+    },
+    gaps: nativeParserFeatureCapabilityGaps(context.adapterCoverage, ['tokens', 'trivia', 'sourceRanges']),
+    lossKinds: nativeParserFeatureLossKindCounts(context.losses, ['sourcePreservation', 'commentsTrivia', 'sourceMapApproximation']),
+    reasons,
+    notes: ['Source-preservation coverage covers exact source text, token/trivia retention, comments, whitespace, directives, and source ranges.']
+  });
+}
+
+function nativeParserFeatureCoverage(category, status, input = {}) {
+  const normalizedStatus = NativeParserFeatureCoverageStatuses.includes(status) ? status : 'missing';
+  return Object.freeze({
+    category,
+    status: normalizedStatus,
+    readiness: nativeParserFeatureReadinessForStatus(normalizedStatus),
+    mergeReady: nativeParserFeatureStatusMergeReady(normalizedStatus),
+    supported: normalizedStatus === 'full' || normalizedStatus === 'partial' || normalizedStatus === 'not-applicable',
+    capabilities: Object.freeze(input.capabilities ?? {}),
+    gaps: Object.freeze(uniqueStrings(input.gaps ?? [])),
+    lossKinds: Object.freeze(input.lossKinds ?? {}),
+    reasons: Object.freeze(uniqueStrings(input.reasons ?? [])),
+    notes: Object.freeze(uniqueStrings(input.notes ?? []))
+  });
+}
+
+function nativeParserFeatureReadinessForStatus(status) {
+  if (status === 'full' || status === 'not-applicable') return 'ready';
+  if (status === 'partial') return 'ready-with-losses';
+  if (status === 'blocked') return 'blocked';
+  return 'needs-review';
+}
+
+export function nativeParserFeatureStatusMergeReady(status) {
+  return status === 'full' || status === 'not-applicable';
+}
+
+function nativeParserFeatureSemanticLevel(adapterCoverage, semanticEvidence) {
+  if ((adapterCoverage.effective.types ?? 0) > 0 || (adapterCoverage.effective.controlFlow ?? 0) > 0 || semanticEvidence.types > 0 || semanticEvidence.controlFlow > 0 || semanticEvidence.references > 0) {
+    return 'semantic-index';
+  }
+  if ((adapterCoverage.effective.semanticDeclarations ?? 0) > 0 || (adapterCoverage.effective.semanticSymbols ?? 0) > 0 || semanticEvidence.declarations > 0 || semanticEvidence.symbols > 0) {
+    return 'declaration-index';
+  }
+  return 'native-ast';
+}
+
+function nativeParserFeatureCapabilityGaps(adapterCoverage, capabilities) {
+  const gaps = new Set();
+  for (const capability of capabilities) {
+    if ((adapterCoverage.effective?.[capability] ?? 0) === 0) gaps.add(capability);
+  }
+  for (const capability of Object.keys(adapterCoverage.gaps ?? {})) {
+    if (capabilities.includes(capability)) gaps.add(capability);
+  }
+  return [...gaps];
+}
+
+function nativeParserFeatureLossKindCounts(losses, kinds) {
+  const wanted = new Set(kinds);
+  const counts = {};
+  for (const loss of losses) {
+    if (!wanted.has(loss?.kind)) continue;
+    counts[loss.kind] = (counts[loss.kind] ?? 0) + 1;
+  }
+  return counts;
+}
+
+function nativeParserFeaturePresentLossKinds(context, kindSet) {
+  return uniqueStrings([
+    ...(context.profile.knownLossKinds ?? []),
+    ...Object.keys(context.lossSummary.byKind ?? {})
+  ].filter((kind) => kindSet.has(kind)));
+}