@shapeshift-labs/frontier-lang-compiler 0.2.32 → 0.2.34

package/dist/index.js

@@ -277,6 +277,24 @@ export const ProjectionTargetLossClasses = Object.freeze([
   'missingAdapter'
 ]);
 
+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 NativeImportLanguageProfiles = Object.freeze([
   nativeImportLanguageProfile('javascript', {
     aliases: ['js', 'mjs', 'cjs', 'jsx'],
@@ -439,6 +457,18 @@ export const NativeParserAstFormatProfiles = Object.freeze([
     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',
@@ -2357,6 +2387,78 @@ export function createNativeParserAstFormatMatrix(input = {}) {
   };
 }
 
+export function createNativeParserFeatureMatrix(input = {}) {
+  const imports = input.imports ?? [];
+  const adapters = input.adapters ?? [];
+  const profiles = mergeNativeImportProfiles(input.languages ?? NativeImportLanguageProfiles, imports, adapters);
+  const parsers = nativeParserFeatureRowsForProfiles(profiles, {
+    imports,
+    adapters,
+    requiredFeatures: input.requiredFeatures,
+    minimumReadiness: input.minimumReadiness,
+    includeEmptyParsers: input.includeEmptyParsers
+  });
+  const summary = nativeParserFeatureMatrixSummary(parsers);
+  return {
+    kind: 'frontier.lang.nativeParserFeatureMatrix',
+    version: 1,
+    generatedAt: input.generatedAt ?? Date.now(),
+    parsers,
+    languages: summarizeNativeParserFeatureLanguages(profiles, parsers),
+    summary,
+    metadata: {
+      categories: [...NativeParserFeatureCategories],
+      statuses: [...NativeParserFeatureCoverageStatuses],
+      requiredFeatures: normalizeNativeParserRequiredFeatures(input.requiredFeatures),
+      minimumReadiness: normalizeSemanticMergeReadiness(input.minimumReadiness ?? 'ready'),
+      note: 'Native parser feature coverage is admission evidence per language/parser. It does not promote lightweight scans or host adapters beyond their declared and observed capabilities.'
+    }
+  };
+}
+
+export function queryNativeParserFeatureMatrix(matrixOrInput = {}, query = {}) {
+  const matrix = matrixOrInput?.kind === 'frontier.lang.nativeParserFeatureMatrix'
+    ? matrixOrInput
+    : createNativeParserFeatureMatrix(matrixOrInput);
+  const language = normalizeNativeLanguageId(query.language);
+  const parser = query.parser === undefined ? undefined : parserAstFormatIdForParser(query.parser);
+  const requiredFeatures = normalizeNativeParserRequiredFeatures(query.requiredFeatures ?? matrix.metadata?.requiredFeatures);
+  const minimumReadiness = normalizeSemanticMergeReadiness(query.minimumReadiness ?? matrix.metadata?.minimumReadiness ?? 'ready');
+  const row = matrix.parsers.find((entry) => {
+    if (language && normalizeNativeLanguageId(entry.language) !== language && !(entry.aliases ?? []).map(normalizeNativeLanguageId).includes(language)) {
+      return false;
+    }
+    if (!parser) return true;
+    const parserIds = [
+      entry.parser,
+      entry.parserFormat,
+      ...(entry.parserAliases ?? []),
+      ...(entry.parserAdapters ?? [])
+    ].map(parserAstFormatIdForParser);
+    return parserIds.includes(parser);
+  });
+  const merge = row
+    ? nativeParserFeatureMergeAssessment(row, { requiredFeatures, minimumReadiness })
+    : {
+      mergeReady: false,
+      readiness: 'blocked',
+      requiredFeatures,
+      minimumReadiness,
+      blockingFeatures: requiredFeatures,
+      reviewFeatures: [],
+      reasons: [`No native parser feature coverage row matched language=${query.language ?? '*'} parser=${query.parser ?? '*'}.`]
+    };
+  return {
+    kind: 'frontier.lang.nativeParserFeatureQuery',
+    version: 1,
+    found: Boolean(row),
+    language: row?.language ?? language,
+    parser: row?.parser ?? parser,
+    row,
+    merge
+  };
+}
+
 export function createProjectionTargetLossMatrix(input = {}) {
   const imports = input.imports ?? [];
   const adapters = input.adapters ?? [];
@@ -2958,6 +3060,78 @@ export function createJavaAstNativeImporterAdapter(options = {}) {
   };
 }
 
+export function createKotlinPsiNativeImporterAdapter(options = {}) {
+  return {
+    id: options.id ?? 'frontier.kotlin-psi-native-importer',
+    language: options.language ?? 'kotlin',
+    parser: options.parser ?? 'kotlin-psi',
+    version: options.version,
+    capabilities: uniqueStrings(['nativeAst', 'semanticIndex', 'sourceMaps', 'diagnostics', ...(options.capabilities ?? [])]),
+    coverage: nativeImporterAdapterCoverage({
+      exactness: 'exact-parser-ast',
+      exactAst: true,
+      tokens: true,
+      trivia: true,
+      diagnostics: true,
+      sourceRanges: true,
+      generatedRanges: false,
+      semanticCoverage: declarationSemanticCoverage(),
+      notes: [
+        'Normalizes caller-owned Kotlin PSI/KtFile-shaped syntax trees into native AST nodes and declaration-level semantic index records.',
+        'Kotlin PSI imports do not resolve Analysis API symbols, FIR/K2 types, overloads, nullability flow, expect/actual matching, compiler-plugin generated declarations, KSP/KAPT output, scripts, build variants, or control flow by themselves; attach host evidence for those claims.'
+      ]
+    }, options.coverage),
+    supportedExtensions: options.supportedExtensions ?? ['.kt', '.kts'],
+    diagnostics: options.diagnostics,
+    parse(input) {
+      const parsed = input.options?.ast
+        ?? input.options?.nativeAst
+        ?? input.options?.ktFile
+        ?? input.options?.file
+        ?? input.options?.sourceFile
+        ?? input.options?.root
+        ?? options.ast
+        ?? options.ktFile
+        ?? options.file
+        ?? options.sourceFile
+        ?? options.root
+        ?? parseKotlinPsiSource(input, options);
+      const root = kotlinPsiRoot(parsed);
+      if (!root) {
+        return missingInjectedParserResult(input, {
+          parser: options.parser ?? 'kotlin-psi',
+          adapterId: options.id ?? 'frontier.kotlin-psi-native-importer',
+          message: 'createKotlinPsiNativeImporterAdapter requires an injected Kotlin PSI KtFile-shaped object, parserModule.parse function, parse function, or adapterOptions.ast.'
+        });
+      }
+      const parseDiagnostics = normalizeParserErrors(parsed?.errors ?? parsed?.diagnostics ?? parsed?.parseDiagnostics, input, {
+        parser: options.parser ?? 'kotlin-psi'
+      });
+      return createNativeImportFromKotlinPsi(root, input, {
+        parser: options.parser ?? 'kotlin-psi',
+        astFormat: 'kotlin-psi',
+        maxNodes: options.maxNodes,
+        diagnostics: parseDiagnostics,
+        kotlinVersion: options.kotlinVersion ?? input.options?.kotlinVersion ?? parsed?.kotlinVersion,
+        languageVersion: options.languageVersion ?? input.options?.languageVersion ?? parsed?.languageVersion,
+        apiVersion: options.apiVersion ?? input.options?.apiVersion ?? parsed?.apiVersion,
+        script: input.options?.script ?? options.script ?? parsed?.script ?? /\.kts$/i.test(input.sourcePath ?? ''),
+        generated: input.options?.generated ?? options.generated ?? parsed?.generated ?? kotlinGeneratedSourcePath(input.sourcePath),
+        analysisApiEvidence: input.options?.analysisApiEvidence ?? options.analysisApiEvidence ?? parsed?.analysisApiEvidence,
+        firEvidence: input.options?.firEvidence ?? options.firEvidence ?? parsed?.firEvidence,
+        compilerPluginEvidence: input.options?.compilerPluginEvidence ?? options.compilerPluginEvidence ?? parsed?.compilerPluginEvidence,
+        kspEvidence: input.options?.kspEvidence ?? options.kspEvidence ?? parsed?.kspEvidence,
+        kaptEvidence: input.options?.kaptEvidence ?? options.kaptEvidence ?? parsed?.kaptEvidence,
+        multiplatformEvidence: input.options?.multiplatformEvidence ?? options.multiplatformEvidence ?? parsed?.multiplatformEvidence,
+        buildVariantEvidence: input.options?.buildVariantEvidence ?? options.buildVariantEvidence ?? parsed?.buildVariantEvidence,
+        positionResolver: input.options?.positionResolver ?? options.positionResolver,
+        lineMap: input.options?.lineMap ?? options.lineMap ?? parsed?.lineMap,
+        includeAnnotations: options.includeAnnotations ?? input.options?.includeAnnotations
+      });
+    }
+  };
+}
+
 export function createCSharpRoslynNativeImporterAdapter(options = {}) {
   return {
     id: options.id ?? 'frontier.csharp-roslyn-native-importer',
@@ -7439,136 +7613,688 @@ 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'
-      }));
+const nativeParserMacroMetaprogrammingLossKinds = new Set([
+  'macroExpansion',
+  'macroHygiene',
+  'preprocessor',
+  'conditionalCompilation',
+  'metaprogramming',
+  'reflection',
+  'generatedCode'
+]);
+
+const nativeParserTypeCoverageLossKinds = new Set([
+  'typeInference',
+  'overloadResolution',
+  'overloadTypeInference',
+  'unsupportedSemantic'
+]);
+
+function nativeParserFeatureRowsForProfiles(profiles, context) {
+  const rows = [];
+  for (const profile of profiles) {
+    const matchingImports = nativeParserFeatureImportsForProfile(profile, context.imports);
+    const matchingAdapters = nativeParserFeatureAdapterSummariesForProfile(profile, context.adapters);
+    for (const parser of nativeParserFeatureParserSlots(profile, matchingImports, matchingAdapters)) {
+      const row = nativeParserFeatureRowForParser(profile, parser, {
+        ...context,
+        imports: matchingImports.filter((imported) => nativeParserFeatureParserMatches(nativeParserParserForImport(imported), parser)),
+        adapters: matchingAdapters.filter((adapter) => nativeParserFeatureParserMatches(adapter.parser, parser))
+      });
+      if (context.includeEmptyParsers === false && row.imports.total === 0 && row.adapters.total === 0) continue;
+      rows.push(row);
     }
   }
-  return [...byId.values()].sort((left, right) => left.id.localeCompare(right.id));
+  return rows.sort((left, right) => {
+    const languageOrder = left.language.localeCompare(right.language);
+    return languageOrder || left.parser.localeCompare(right.parser);
+  });
 }
 
-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,
+function nativeParserFeatureRowForParser(profile, parser, context) {
+  const imports = context.imports ?? [];
+  const adapters = context.adapters ?? [];
+  const parserFormat = parserAstFormatIdForParser(parser);
+  const parserProfile = getNativeParserAstFormatProfile(parserFormat);
+  const adapterCoverage = summarizeNativeImporterAdapterCoverageEntries([
+    ...imports.map((imported) => nativeImporterAdapterCoverageEntryFromImport(imported)).filter(Boolean),
+    ...adapters.map((adapter) => ({
+      adapterId: adapter.id,
+      language: adapter.language,
+      parser: adapter.parser,
+      coverage: adapter.coverage
+    }))
+  ]);
+  const losses = imports.flatMap((imported) => imported?.losses ?? imported?.nativeAst?.losses ?? []);
+  const evidence = imports.flatMap((imported) => imported?.evidence ?? []);
+  const lossSummary = summarizeNativeImportLosses(losses, { evidence, parser });
+  const semanticEvidence = nativeParserFeatureSemanticEvidence(imports);
+  const sourceMaps = imports.flatMap((imported) => imported?.sourceMaps ?? imported?.universalAst?.sourceMaps ?? []);
+  const sourceMapMappings = sourceMaps.reduce((sum, sourceMap) => sum + (sourceMap?.mappings?.length ?? 0), 0);
+  const sourcePreservation = summarizeImportSourcePreservation(undefined, imports);
+  const nativeAstNodes = imports.reduce((sum, imported) => sum + Object.keys(imported?.nativeAst?.nodes ?? imported?.nativeSource?.ast?.nodes ?? {}).length, 0);
+  const featureContext = {
+    profile,
+    parser,
+    parserFormat,
+    parserProfile,
+    imports,
+    adapters,
+    adapterCoverage,
+    losses,
+    evidence,
+    lossSummary,
+    semanticEvidence,
+    sourceMaps,
+    sourceMapMappings,
+    sourcePreservation,
+    nativeAstNodes
+  };
+  const features = {
+    syntax: nativeParserSyntaxFeature(featureContext),
+    semantic: nativeParserSemanticFeature(featureContext),
+    type: nativeParserTypeFeature(featureContext),
+    controlFlow: nativeParserControlFlowFeature(featureContext),
+    macroMetaprogramming: nativeParserMacroMetaprogrammingFeature(featureContext),
+    sourcePreservation: nativeParserSourcePreservationFeature(featureContext)
+  };
+  const importReadiness = imports.length
+    ? lossSummary.semanticMergeReadiness
+    : adapters.length ? 'needs-review' : normalizeSemanticMergeReadiness(profile.defaultReadiness) ?? 'needs-review';
+  const row = {
+    language: profile.language,
+    aliases: profile.aliases,
+    parser,
+    parserFormat,
+    parserAliases: uniqueStrings([...(parserProfile?.aliases ?? []), ...(parserProfile?.parserAdapters ?? [])]),
+    parserAdapters: uniqueStrings([parser, ...(parserProfile?.parserAdapters ?? [])]),
+    extensions: profile.extensions,
+    supportsLightweightScan: profile.supportsLightweightScan,
+    projectionTargets: profile.projectionTargets,
+    knownLossKinds: uniqueStrings([...(profile.knownLossKinds ?? []), ...Object.keys(lossSummary.byKind)]),
+    defaultReadiness: profile.defaultReadiness,
+    notes: uniqueStrings([...(profile.notes ?? []), ...(parserProfile?.notes ?? [])]),
     adapters: {
-      total: matchingAdapters.length,
-      ids: matchingAdapters.map((adapter) => adapter.id),
-      parsers: uniqueStrings(matchingAdapters.map((adapter) => adapter.parser)),
-      effectiveCapabilities
+      total: adapters.length,
+      ids: adapters.map((adapter) => adapter.id),
+      versions: uniqueStrings(adapters.map((adapter) => adapter.version).filter(Boolean)),
+      exactness: uniqueStrings(adapters.map((adapter) => adapter.coverage?.exactness).filter(Boolean)),
+      coverage: adapterCoverage
     },
     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)
-    }
+      total: imports.length,
+      sourcePaths: uniqueStrings(imports.map((imported) => imported?.sourcePath ?? imported?.nativeSource?.sourcePath ?? imported?.nativeAst?.sourcePath).filter(Boolean)),
+      readiness: importReadiness,
+      readinessReasons: imports.length ? lossSummary.readinessReasons : nativeImportCoverageReasons(profile),
+      nativeAstNodes,
+      symbols: semanticEvidence.symbols,
+      references: semanticEvidence.references,
+      types: semanticEvidence.types,
+      controlFlow: semanticEvidence.controlFlow,
+      sourceMaps: sourceMaps.length,
+      sourceMapMappings,
+      losses: lossSummary.total,
+      lossKinds: lossSummary.byKind,
+      lossCategories: lossSummary.categories,
+      sourcePreservation
+    },
+    features
+  };
+  return {
+    ...row,
+    merge: nativeParserFeatureMergeAssessment(row, {
+      requiredFeatures: context.requiredFeatures,
+      minimumReadiness: context.minimumReadiness
+    })
   };
 }
 
-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 === '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';
+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.']
+  });
 }
 
-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 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.']
+  });
 }
 
-function mergeNativeImportProfiles(languages, imports, adapters, targetAdapters = []) {
-  const profilesByLanguage = new Map();
-  for (const profile of languages) {
-    const normalized = normalizeNativeLanguageId(profile.language ?? profile);
-    profilesByLanguage.set(normalized, normalizeNativeImportLanguageProfile(profile, normalized));
-  }
-  for (const imported of imports) {
-    const normalized = normalizeNativeLanguageId(imported?.language ?? imported?.nativeAst?.language);
-    if (!normalized || profilesByLanguage.has(normalized)) continue;
-    profilesByLanguage.set(normalized, nativeImportLanguageProfile(normalized, {
-      supportsLightweightScan: false,
-      parserAdapters: [],
-      defaultReadiness: 'blocked',
-      lossKinds: ['unsupportedSyntax'],
-      notes: ['language appeared in import evidence but has no declared Frontier coverage profile']
-    }));
+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.');
   }
-  for (const adapter of adapters) {
+  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.']
+  });
+}
+
+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.']
+  });
+}
+
+function nativeParserMacroMetaprogrammingFeature(context) {
+  const macroLossKinds = nativeParserFeaturePresentLossKinds(context, nativeParserMacroMetaprogrammingLossKinds);
+  const macroLosses = context.losses.filter((loss) => nativeParserMacroMetaprogrammingLossKinds.has(loss.kind));
+  const featureEvidence = 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.']
+  });
+}
+
+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';
+}
+
+function nativeParserFeatureStatusMergeReady(status) {
+  return status === 'full' || status === 'not-applicable';
+}
+
+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)
+  });
+}
+
+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;
+}
+
+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
+  };
+}
+
+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')
+    };
+  });
+}
+
+function nativeParserFeatureParserSlots(profile, imports, adapters) {
+  const slots = [
+    ...(profile.parserAdapters ?? []),
+    ...adapters.map((adapter) => adapter.parser),
+    ...imports.map(nativeParserParserForImport)
+  ].filter(Boolean);
+  if (!slots.length && profile.supportsLightweightScan) slots.push(`${profile.language}.lightweight-declaration-scan`);
+  const seen = new Set();
+  const result = [];
+  for (const slot of slots) {
+    const key = `${normalizeParserAstFormatId(slot)}#${parserAstFormatIdForParser(slot)}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    result.push(String(slot));
+  }
+  return result;
+}
+
+function nativeParserFeatureImportsForProfile(profile, imports = []) {
+  const languages = nativeParserFeatureLanguageSet(profile);
+  return imports.filter((imported) => languages.has(normalizeNativeLanguageId(imported?.language ?? imported?.nativeAst?.language ?? imported?.nativeSource?.language)));
+}
+
+function nativeParserFeatureAdapterSummariesForProfile(profile, adapters = []) {
+  const languages = nativeParserFeatureLanguageSet(profile);
+  return adapters
+    .map((adapter) => safeNativeImporterAdapterSummary(adapter))
+    .filter(Boolean)
+    .filter((adapter) => languages.has(normalizeNativeLanguageId(adapter.language)));
+}
+
+function nativeParserFeatureLanguageSet(profile) {
+  return new Set([profile.language, ...(profile.aliases ?? [])].map(normalizeNativeLanguageId).filter(Boolean));
+}
+
+function nativeParserParserForImport(imported) {
+  return imported?.adapter?.parser
+    ?? imported?.metadata?.adapterCoverage?.parser
+    ?? imported?.nativeAst?.parser
+    ?? imported?.nativeSource?.parser
+    ?? imported?.parser
+    ?? imported?.metadata?.parser;
+}
+
+function nativeParserFeatureParserMatches(candidateParser, rowParser) {
+  if (!candidateParser || !rowParser) return false;
+  const candidate = normalizeParserAstFormatId(candidateParser);
+  const row = normalizeParserAstFormatId(rowParser);
+  return candidate === row || parserAstFormatIdForParser(candidateParser) === parserAstFormatIdForParser(rowParser);
+}
+
+function nativeParserFeatureSemanticEvidence(imports) {
+  const totals = {
+    declarations: 0,
+    symbols: 0,
+    references: 0,
+    types: 0,
+    controlFlow: 0
+  };
+  for (const imported of imports) {
+    const semanticIndex = imported?.semanticIndex ?? imported?.universalAst?.semanticIndex;
+    const evidence = observeNativeImporterSemanticEvidence(semanticIndex);
+    totals.declarations += evidence.declarations;
+    totals.symbols += semanticIndex?.symbols?.length ?? 0;
+    totals.references += evidence.references;
+    totals.types += evidence.types;
+    totals.controlFlow += evidence.controlFlow;
+  }
+  return totals;
+}
+
+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)));
+}
+
+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('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';
+}
+
+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) {
+    const normalized = normalizeNativeLanguageId(profile.language ?? profile);
+    profilesByLanguage.set(normalized, normalizeNativeImportLanguageProfile(profile, normalized));
+  }
+  for (const imported of imports) {
+    const normalized = normalizeNativeLanguageId(imported?.language ?? imported?.nativeAst?.language);
+    if (!normalized || profilesByLanguage.has(normalized)) continue;
+    profilesByLanguage.set(normalized, nativeImportLanguageProfile(normalized, {
+      supportsLightweightScan: false,
+      parserAdapters: [],
+      defaultReadiness: 'blocked',
+      lossKinds: ['unsupportedSyntax'],
+      notes: ['language appeared in import evidence but has no declared Frontier coverage profile']
+    }));
+  }
+  for (const adapter of adapters) {
     const normalized = normalizeNativeLanguageId(adapter?.language);
     if (!normalized) continue;
     const existing = profilesByLanguage.get(normalized) ?? nativeImportLanguageProfile(normalized, { supportsLightweightScan: false, parserAdapters: [] });
@@ -8629,6 +9355,23 @@ function parseJavaAstSource(input, options) {
   return parse(input.sourceText, parserOptions);
 }
 
+function parseKotlinPsiSource(input, options) {
+  const parse = options.parse ?? options.parserModule?.parse ?? options.kotlinPsi?.parse ?? options.kotlinCompiler?.parse ?? options.intellijPsi?.parse;
+  if (typeof parse !== 'function') return undefined;
+  const parserOptions = {
+    sourcePath: input.sourcePath,
+    filename: input.sourcePath,
+    kotlinVersion: options.kotlinVersion ?? input.options?.kotlinVersion,
+    languageVersion: options.languageVersion ?? input.options?.languageVersion,
+    apiVersion: options.apiVersion ?? input.options?.apiVersion,
+    script: options.script ?? input.options?.script ?? /\.kts$/i.test(input.sourcePath ?? ''),
+    includeAnnotations: options.includeAnnotations ?? input.options?.includeAnnotations,
+    ...(options.parserOptions ?? {}),
+    ...(input.options?.parserOptions ?? {})
+  };
+  return parse(input.sourceText, parserOptions);
+}
+
 function parseCSharpRoslynSource(input, options) {
   const parse = options.parse ?? options.parserModule?.parse ?? options.roslyn?.parse ?? options.csharpRoslyn?.parse;
   if (typeof parse !== 'function') return undefined;
@@ -8891,14 +9634,17 @@ function createNativeImportFromJavaAst(root, input, options) {
   };
 }
 
-function createNativeImportFromCSharpRoslyn(root, input, options) {
+function createNativeImportFromKotlinPsi(root, input, options) {
   const context = createAstNormalizationContext(input, options);
-  visitCSharpRoslynNode(root, context, 'root');
+  visitKotlinPsiNode(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(csharpGeneratedCodeLoss(input, context.rootId, undefined, options));
+    context.losses.push(kotlinGeneratedCodeLoss(input, context.rootId, undefined, options));
+  }
+  if (options.script && !context.losses.some((loss) => loss.metadata?.script === true)) {
+    context.losses.push(kotlinScriptLoss(input, context.rootId, undefined, options));
   }
   const semantic = semanticIndexFromNativeDeclarations(context.declarations, input, options);
   return {
@@ -8915,12 +9661,56 @@ function createNativeImportFromCSharpRoslyn(root, input, options) {
     metadata: {
       astFormat: options.astFormat,
       parser: options.parser,
-      csharpVersion: options.csharpVersion,
+      kotlinVersion: options.kotlinVersion,
       languageVersion: options.languageVersion,
-      nullableContext: options.nullableContext,
+      apiVersion: options.apiVersion,
+      script: Boolean(options.script),
       generated: options.generated,
-      projectReferences: csharpEvidenceSummary(options.projectReferences),
-      analyzerDiagnostics: csharpEvidenceSummary(options.analyzerDiagnostics),
+      analysisApiEvidence: kotlinEvidenceSummary(options.analysisApiEvidence),
+      firEvidence: kotlinEvidenceSummary(options.firEvidence),
+      compilerPluginEvidence: kotlinEvidenceSummary(options.compilerPluginEvidence),
+      kspEvidence: kotlinEvidenceSummary(options.kspEvidence),
+      kaptEvidence: kotlinEvidenceSummary(options.kaptEvidence),
+      multiplatformEvidence: kotlinEvidenceSummary(options.multiplatformEvidence),
+      buildVariantEvidence: kotlinEvidenceSummary(options.buildVariantEvidence),
+      includeAnnotations: Boolean(options.includeAnnotations),
+      normalizedNodeCount: Object.keys(context.nodes).length,
+      declarationCount: context.declarations.length,
+      truncated: context.truncated
+    }
+  };
+}
+
+function createNativeImportFromCSharpRoslyn(root, input, options) {
+  const context = createAstNormalizationContext(input, options);
+  visitCSharpRoslynNode(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(csharpGeneratedCodeLoss(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,
+      csharpVersion: options.csharpVersion,
+      languageVersion: options.languageVersion,
+      nullableContext: options.nullableContext,
+      generated: options.generated,
+      projectReferences: csharpEvidenceSummary(options.projectReferences),
+      analyzerDiagnostics: csharpEvidenceSummary(options.analyzerDiagnostics),
       semanticModelEvidence: csharpEvidenceSummary(options.semanticModelEvidence),
       sourceGeneratorEvidence: csharpEvidenceSummary(options.sourceGeneratorEvidence),
       normalizedNodeCount: Object.keys(context.nodes).length,
@@ -12348,6 +13138,658 @@ function javaBindingEvidenceSummary(value) {
   return Object.keys(summary).length ? summary : { present: true };
 }
 
+function kotlinPsiRoot(value) {
+  if (!value || typeof value !== 'object') return undefined;
+  if (isKotlinPsiNode(value)) return value;
+  if (isKotlinPsiNode(value.ast)) return value.ast;
+  if (isKotlinPsiNode(value.root)) return value.root;
+  if (isKotlinPsiNode(value.rootNode)) return value.rootNode;
+  if (isKotlinPsiNode(value.ktFile)) return value.ktFile;
+  if (isKotlinPsiNode(value.file)) return value.file;
+  if (isKotlinPsiNode(value.sourceFile)) return value.sourceFile;
+  if (Array.isArray(value.declarations) || Array.isArray(value.imports) || value.packageDirective) {
+    return { kind: 'KtFile', ...value };
+  }
+  return undefined;
+}
+
+function isKotlinPsiNode(value) {
+  return Boolean(value && typeof value === 'object' && typeof kotlinPsiKind(value) === 'string');
+}
+
+function kotlinPsiKind(node) {
+  if (!node || typeof node !== 'object') return undefined;
+  const declared = node.kind ?? node.nodeType ?? node.elementType ?? node.psiKind ?? node._type ?? node.type;
+  if (typeof declared === 'string') return normalizeKotlinPsiKind(declared);
+  if (Array.isArray(node.declarations) || Array.isArray(node.imports) || node.packageDirective) return 'KtFile';
+  if (node.fqName || node.packageFqName) return 'KtPackageDirective';
+  if (node.importedFqName || node.importedReference) return 'KtImportDirective';
+  if (node.classKind || node.primaryConstructor || node.superTypeListEntries) return 'KtClass';
+  if (node.funKeyword || node.valueParameters || node.bodyExpression) return 'KtNamedFunction';
+  if (node.valOrVarKeyword || node.delegateExpression || node.initializer) return 'KtProperty';
+  return undefined;
+}
+
+function normalizeKotlinPsiKind(kind) {
+  const text = String(kind)
+    .replace(/^org\.jetbrains\.kotlin\.psi\./, '')
+    .replace(/^KtNodeTypes\./, '')
+    .replace(/ElementType$/, '');
+  const compact = text.replace(/[_\s.-]+/g, '').toLowerCase();
+  const known = {
+    kotlinfile: 'KtFile',
+    ktfile: 'KtFile',
+    file: 'KtFile',
+    script: 'KtScript',
+    ktscript: 'KtScript',
+    packagedirective: 'KtPackageDirective',
+    ktpackagedirective: 'KtPackageDirective',
+    importdirective: 'KtImportDirective',
+    ktimportdirective: 'KtImportDirective',
+    class: 'KtClass',
+    ktclass: 'KtClass',
+    classorobject: 'KtClassOrObject',
+    ktclassorobject: 'KtClassOrObject',
+    objectdeclaration: 'KtObjectDeclaration',
+    ktobjectdeclaration: 'KtObjectDeclaration',
+    enumentry: 'KtEnumEntry',
+    ktenumentry: 'KtEnumEntry',
+    namedfunction: 'KtNamedFunction',
+    ktnamedfunction: 'KtNamedFunction',
+    function: 'KtNamedFunction',
+    property: 'KtProperty',
+    ktproperty: 'KtProperty',
+    typealias: 'KtTypeAlias',
+    kttypealias: 'KtTypeAlias',
+    parameter: 'KtParameter',
+    ktparameter: 'KtParameter',
+    primaryconstructor: 'KtPrimaryConstructor',
+    ktprimaryconstructor: 'KtPrimaryConstructor',
+    secondaryconstructor: 'KtSecondaryConstructor',
+    ktsecondaryconstructor: 'KtSecondaryConstructor',
+    classinitializer: 'KtClassInitializer',
+    ktclassinitializer: 'KtClassInitializer',
+    annotationentry: 'KtAnnotationEntry',
+    ktannotationentry: 'KtAnnotationEntry',
+    contracteffect: 'KtContractEffect',
+    ktcontracteffect: 'KtContractEffect',
+    contractdescription: 'KtContractDescription',
+    ktcontractdescription: 'KtContractDescription',
+    error: 'PsiErrorElement',
+    psierror: 'PsiErrorElement',
+    psierrorelement: 'PsiErrorElement'
+  };
+  if (known[compact]) return known[compact];
+  if (/^[A-Z0-9_]+$/.test(text)) return text.toLowerCase().split('_').map(upperFirst).join('');
+  return text;
+}
+
+function ignoredKotlinPsiField(key) {
+  return key === '_type'
+    || key === 'type'
+    || key === 'kind'
+    || key === 'nodeType'
+    || key === 'elementType'
+    || key === 'psiKind'
+    || key === 'parent'
+    || key === 'parentKind'
+    || key === 'parentField'
+    || key === 'textRange'
+    || key === 'range'
+    || key === 'span'
+    || key === 'location'
+    || key === 'name'
+    || key === 'nameIdentifier'
+    || key === 'identifier'
+    || key === 'fqName'
+    || key === 'packageFqName'
+    || key === 'analysisSymbol'
+    || key === 'symbol'
+    || key === 'typeInfo'
+    || key === 'bindingContext'
+    || key === 'fir'
+    || key === 'ir';
+}
+
+function visitKotlinPsiNode(node, context, propertyPath) {
+  if (!isKotlinPsiNode(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 = kotlinPsiKind(node);
+  const span = spanFromKotlinPsiNode(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 kotlinPsiChildEntries(node, kind)) {
+    if (Array.isArray(value)) {
+      value.forEach((entry, index) => {
+        const childId = visitKotlinPsiNode(entry, context, `${propertyPath}.${field}[${index}]`);
+        if (childId) children.push(childId);
+      });
+    } else {
+      const childId = visitKotlinPsiNode(value, context, `${propertyPath}.${field}`);
+      if (childId) children.push(childId);
+    }
+  }
+  const declarations = kotlinPsiDeclarations(node, kind, id, context.input);
+  const declaration = declarations[0];
+  const nativeNode = {
+    id,
+    kind,
+    languageKind: `${context.input.language}.${kind}`,
+    span,
+    value: declaration?.name ?? kotlinPsiNodeValue(node),
+    fields: primitiveKotlinPsiFields(node, kind),
+    children,
+    metadata: {
+      astFormat: context.options.astFormat,
+      propertyPath,
+      positionKind: kotlinPsiPositionKind(node),
+      parser: context.options.parser
+    }
+  };
+  context.nodes[id] = nativeNode;
+  for (const entry of declarations) {
+    context.declarations.push({ ...entry, nativeNode });
+  }
+  if (kotlinPsiRecoveredKind(kind) || kotlinPsiProblemNode(node, kind)) {
+    context.losses.push({
+      id: `loss_${idFragment(id)}_kotlin_psi_recovered_node`,
+      severity: 'error',
+      phase: 'parse',
+      sourceFormat: context.input.language,
+      kind: 'unsupportedSyntax',
+      message: 'Kotlin PSI reported an error or recovered syntax 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 (kotlinExpectActualNode(node, kind)) {
+    context.losses.push(kotlinUnsupportedSemanticLoss(context.input, id, span, context.options, {
+      nodeKind: kind,
+      feature: 'expect-actual',
+      message: 'Kotlin expect/actual syntax was imported; matching platform declarations requires multiplatform build evidence.'
+    }));
+  }
+  if (kotlinCoroutineNode(node, kind)) {
+    context.losses.push(kotlinUnsupportedSemanticLoss(context.input, id, span, context.options, {
+      nodeKind: kind,
+      feature: 'coroutine',
+      message: 'Kotlin coroutine syntax was imported; suspend lowering, scheduling, and effect semantics require host compiler/runtime evidence.'
+    }));
+  }
+  if (kotlinContractNode(kind)) {
+    context.losses.push(kotlinUnsupportedSemanticLoss(context.input, id, span, context.options, {
+      nodeKind: kind,
+      feature: 'contract',
+      message: 'Kotlin contract syntax was imported; data-flow effects require Analysis API or compiler evidence.'
+    }));
+  }
+  if (kotlinCompilerPluginAnnotationNode(node, kind) && !context.options.compilerPluginEvidence) {
+    context.losses.push({
+      id: `loss_${idFragment(id)}_kotlin_compiler_plugin_semantics`,
+      severity: 'warning',
+      phase: 'parse',
+      sourceFormat: context.input.language,
+      kind: 'metaprogramming',
+      message: 'Kotlin compiler-plugin-style annotation was imported; generated declarations and transformed semantics require compiler plugin evidence.',
+      span,
+      nodeId: id,
+      metadata: {
+        parser: context.options.parser,
+        astFormat: context.options.astFormat,
+        nodeKind: kind,
+        annotations: kotlinPsiAnnotationNames(node)
+      }
+    });
+  }
+  if (kotlinGeneratedCodeMarker(node, kind)) {
+    context.losses.push(kotlinGeneratedCodeLoss(context.input, id, span, context.options, { nodeKind: kind }));
+  }
+  return id;
+}
+
+function primitiveKotlinPsiFields(node, kind) {
+  const fields = { kind };
+  const name = kotlinPsiDeclarationName(node, kind);
+  if (name) fields.name = name;
+  const importPath = kotlinPsiImportPath(node);
+  if (importPath) fields.importPath = importPath;
+  const packageName = kotlinPsiPackageName(node);
+  if (packageName) fields.packageName = packageName;
+  const type = kotlinPsiTypeName(node.typeReference ?? node.returnTypeRef ?? node.returnType ?? node.type);
+  if (type) fields.type = type;
+  const receiver = kotlinPsiTypeName(node.receiverTypeReference ?? node.receiverTypeRef);
+  if (receiver) fields.receiverType = receiver;
+  const modifiers = kotlinPsiModifiers(node);
+  if (modifiers.length) fields.modifiers = modifiers.join(',');
+  const annotations = kotlinPsiAnnotationNames(node);
+  if (annotations.length) fields.annotations = annotations.join(',');
+  if (node.generated === true || node.isGenerated === true) fields.generated = true;
+  if (node.isScript === true || kind === 'KtScript') fields.script = true;
+  if (Array.isArray(node.typeParameters ?? node.typeParameterList?.parameters)) fields.typeParameterCount = (node.typeParameters ?? node.typeParameterList?.parameters).length;
+  if (Array.isArray(node.valueParameters ?? node.valueParameterList?.parameters ?? node.parameters)) fields.parameterCount = (node.valueParameters ?? node.valueParameterList?.parameters ?? node.parameters).length;
+  if (Array.isArray(node.superTypeListEntries ?? node.superTypes)) fields.superTypeCount = (node.superTypeListEntries ?? node.superTypes).length;
+  return fields;
+}
+
+function spanFromKotlinPsiNode(node, input, options = {}) {
+  const direct = spanFromKotlinLineFields(node, input);
+  if (direct) return direct;
+  const range = node.sourceRange ?? node.range ?? node.span ?? node.textRange;
+  const fromRange = spanFromKotlinRange(range, input);
+  if (fromRange) return fromRange;
+  const start = kotlinPsiPosition(node.start ?? node.startOffset ?? range?.startOffset ?? range?.start, options);
+  const end = kotlinPsiPosition(node.end ?? node.endOffset ?? range?.endOffset ?? range?.end, 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 spanFromKotlinLineFields(node, input) {
+  const startLine = node.startLine ?? node.line ?? node.beginLine;
+  if (typeof startLine !== 'number') return undefined;
+  return {
+    sourceId: input.sourceHash,
+    path: node.path ?? node.filePath ?? node.file ?? input.sourcePath,
+    startLine,
+    startColumn: node.startColumn ?? node.column ?? node.beginColumn,
+    endLine: node.endLine,
+    endColumn: node.endColumn
+  };
+}
+
+function spanFromKotlinRange(range, input) {
+  if (!range || typeof range !== 'object') return undefined;
+  const start = range.start ?? range.startPosition ?? range.lowerBound ?? range.begin;
+  const end = range.end ?? range.endPosition ?? range.upperBound;
+  const line = start?.line ?? start?.Line;
+  if (typeof line !== 'number') return undefined;
+  const column = start.column ?? start.character ?? start.offset ?? start.Column;
+  const endLine = end?.line ?? end?.Line;
+  const endColumn = end?.column ?? end?.character ?? end?.offset ?? end?.Column;
+  return {
+    sourceId: input.sourceHash,
+    path: range.path ?? range.filePath ?? range.file ?? input.sourcePath,
+    startLine: line,
+    startColumn: typeof column === 'number' ? column : undefined,
+    endLine: typeof endLine === 'number' ? endLine : undefined,
+    endColumn: typeof endColumn === 'number' ? endColumn : undefined
+  };
+}
+
+function kotlinPsiPosition(value, options = {}) {
+  if (value === undefined || value === null) return undefined;
+  if (typeof value === 'object') {
+    const position = value.position ?? value.location ?? value;
+    const line = position.line ?? position.Line;
+    const column = position.column ?? position.character ?? position.Column;
+    if (typeof line === 'number') {
+      return {
+        path: position.path ?? position.filePath ?? position.file,
+        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?.getLineAndColumn === 'function'
+        ? options.lineMap.getLineAndColumn.bind(options.lineMap)
+        : undefined;
+  if (resolver) {
+    const resolved = resolver(value);
+    if (resolved !== value) return kotlinPsiPosition(resolved, options);
+  }
+  return undefined;
+}
+
+function kotlinPsiPositionKind(node) {
+  if (node.textRange || node.range) return 'text-range';
+  if (typeof node.startOffset === 'number') return 'offset';
+  if (typeof node.startLine === 'number' || typeof node.line === 'number') return 'line-column-fields';
+  return undefined;
+}
+
+function kotlinPsiDeclarations(node, kind, nativeNodeId, input) {
+  if (kind === 'KtPackageDirective') {
+    const name = kotlinPsiPackageName(node);
+    return name ? [declarationRecord(input, nativeNodeId, name, 'namespace', 'definition')] : [];
+  }
+  if (kind === 'KtImportDirective') {
+    const name = kotlinPsiImportPath(node);
+    return name ? [declarationRecord(input, nativeNodeId, name, 'module', 'import')] : [];
+  }
+  if (kotlinPsiTypeDeclarationKind(kind)) {
+    const name = kotlinPsiDeclarationName(node, kind);
+    return name ? [declarationRecord(input, nativeNodeId, name, kotlinPsiTypeDeclarationSymbolKind(node, kind), 'definition')] : [];
+  }
+  if (kind === 'KtTypeAlias') {
+    const name = kotlinPsiDeclarationName(node, kind);
+    return name ? [declarationRecord(input, nativeNodeId, name, 'type', 'definition')] : [];
+  }
+  if (kind === 'KtNamedFunction') {
+    const name = kotlinPsiDeclarationName(node, kind);
+    return name ? [declarationRecord(input, nativeNodeId, name, node.parentKind && kotlinPsiTypeDeclarationKind(node.parentKind) ? 'method' : 'function', kotlinPsiHasBody(node) ? 'definition' : 'declaration')] : [];
+  }
+  if (kind === 'KtProperty') {
+    return kotlinPsiVariableNames(node).map((name) => declarationRecord(input, nativeNodeId, name, 'property', 'definition'));
+  }
+  if (kind === 'KtParameter' && node.parentKind === 'KtPrimaryConstructor') {
+    return kotlinPsiVariableNames(node).map((name) => declarationRecord(input, nativeNodeId, name, 'property', 'definition'));
+  }
+  if (kind === 'KtPrimaryConstructor' || kind === 'KtSecondaryConstructor') {
+    return [declarationRecord(input, nativeNodeId, kotlinPsiDeclarationName(node, kind) ?? 'constructor', 'method', 'definition')];
+  }
+  if (kind === 'KtEnumEntry') {
+    const name = kotlinPsiDeclarationName(node, kind);
+    return name ? [declarationRecord(input, nativeNodeId, name, 'enumMember', 'definition')] : [];
+  }
+  return [];
+}
+
+function kotlinPsiChildEntries(node, kind = kotlinPsiKind(node)) {
+  const fieldNames = Object.keys(node).filter((key) => !ignoredKotlinPsiField(key));
+  const entries = [];
+  for (const field of fieldNames) {
+    const value = node[field];
+    if (Array.isArray(value)) {
+      entries.push([field, value.map((entry) => kotlinPsiChildWithParent(entry, kind, field))]);
+      continue;
+    }
+    if (value && typeof value === 'object') {
+      entries.push([field, kotlinPsiChildWithParent(value, kind, field)]);
+    }
+  }
+  return entries.filter(([, value]) => Array.isArray(value)
+    ? value.some(isKotlinPsiNode)
+    : isKotlinPsiNode(value));
+}
+
+function kotlinPsiChildWithParent(entry, parentKind, parentField) {
+  if (!entry || typeof entry !== 'object' || Array.isArray(entry)) return entry;
+  if (!isKotlinPsiNode(entry)) return entry;
+  return { parentKind, parentField, ...entry };
+}
+
+function kotlinPsiNodeValue(node) {
+  return kotlinPsiDeclarationName(node, kotlinPsiKind(node))
+    ?? kotlinPsiImportPath(node)
+    ?? kotlinPsiPackageName(node)
+    ?? kotlinPsiTypeName(node.typeReference ?? node.returnTypeRef ?? node.type);
+}
+
+function kotlinPsiDeclarationName(node, kind = kotlinPsiKind(node)) {
+  if (!node || typeof node !== 'object') return undefined;
+  if (kind === 'KtPrimaryConstructor' || kind === 'KtSecondaryConstructor') return 'constructor';
+  if (kind === 'KtClassInitializer') return 'init';
+  if (kind === 'KtObjectDeclaration' && node.isCompanion === true && !node.name && !node.nameIdentifier) return 'companion object';
+  for (const key of ['nameIdentifier', 'identifier', 'name', 'simpleName', 'classId', 'fqName', 'id']) {
+    const name = kotlinPsiName(node[key]);
+    if (name) return name;
+  }
+  const variable = kotlinPsiVariableNames(node)[0];
+  if (variable) return variable;
+  return undefined;
+}
+
+function kotlinPsiName(value) {
+  if (!value) return undefined;
+  if (typeof value === 'string') return value;
+  if (typeof value.asString === 'string') return value.asString;
+  if (typeof value.identifier === 'string') return value.identifier;
+  if (typeof value.name === 'string') return value.name;
+  if (typeof value.text === 'string') return value.text;
+  if (typeof value.value === 'string') return value.value;
+  if (typeof value.fqName === 'string') return value.fqName;
+  if (value.shortName && value.shortName !== value) return kotlinPsiName(value.shortName);
+  if (value.name && value.name !== value) return kotlinPsiName(value.name);
+  if (value.identifier && value.identifier !== value) return kotlinPsiName(value.identifier);
+  return undefined;
+}
+
+function kotlinPsiImportPath(node) {
+  if (!node || typeof node !== 'object') return undefined;
+  const path = node.importedFqName ?? node.importedReference ?? node.importPath ?? node.path ?? node.name;
+  if (typeof path === 'string') return path;
+  if (path && typeof path === 'object') return kotlinPsiName(path.fqName ?? path.name ?? path);
+  return undefined;
+}
+
+function kotlinPsiPackageName(node) {
+  if (!node || typeof node !== 'object') return undefined;
+  const value = node.packageFqName ?? node.fqName ?? node.qualifiedName ?? node.packageName;
+  if (typeof value === 'string') return value;
+  if (value && typeof value === 'object') return kotlinPsiName(value);
+  return undefined;
+}
+
+function kotlinPsiVariableNames(node) {
+  const variables = node.variables ?? node.entries ?? node.declarations;
+  if (Array.isArray(variables)) return variables.map(kotlinPsiDeclarationName).filter(Boolean);
+  const name = kotlinPsiName(node.nameIdentifier ?? node.identifier ?? node.name);
+  return name ? [name] : [];
+}
+
+function kotlinPsiTypeName(value) {
+  if (!value) return undefined;
+  if (typeof value === 'string') return value;
+  if (typeof value.text === 'string') return value.text.trim();
+  if (typeof value.name === 'string') return value.name;
+  if (typeof value.fqName === 'string') return value.fqName;
+  if (value.typeElement) return kotlinPsiTypeName(value.typeElement);
+  if (value.typeReference) return kotlinPsiTypeName(value.typeReference);
+  if (value.referencedName) return kotlinPsiName(value.referencedName);
+  if (value.constructorReferenceExpression) return kotlinPsiTypeName(value.constructorReferenceExpression);
+  if (Array.isArray(value.typeArguments) || Array.isArray(value.arguments)) {
+    const base = kotlinPsiName(value.name ?? value.referencedName ?? value.constructorReferenceExpression);
+    const args = (value.typeArguments ?? value.arguments).map((entry) => kotlinPsiTypeName(entry.typeReference ?? entry)).filter(Boolean);
+    return base ? `${base}<${args.join(', ')}>` : undefined;
+  }
+  return kotlinPsiName(value);
+}
+
+function kotlinPsiModifiers(node) {
+  const raw = node.modifiers ?? node.modifierList?.modifiers ?? node.modifierList?.children;
+  const names = [];
+  if (Array.isArray(raw)) {
+    for (const entry of raw) {
+      const name = typeof entry === 'string' ? entry : kotlinPsiName(entry) ?? entry?.keyword ?? entry?.tokenType ?? entry?.text;
+      if (name) names.push(String(name).toLowerCase());
+    }
+  } else if (typeof raw === 'string') {
+    names.push(...raw.split(/\s+/).filter(Boolean).map((entry) => entry.toLowerCase()));
+  } else if (raw && typeof raw === 'object') {
+    for (const [key, enabled] of Object.entries(raw)) {
+      if (enabled === true) names.push(key.toLowerCase());
+    }
+  }
+  for (const key of ['suspend', 'expect', 'actual', 'inline', 'operator', 'infix', 'tailrec', 'external', 'override', 'data', 'sealed', 'value']) {
+    if (node[key] === true || node[`is${upperFirst(key)}`] === true) names.push(key);
+  }
+  return uniqueStrings(names.map((entry) => entry.replace(/keyword$/i, '').replace(/_keyword$/i, '').replace(/[_\s-]+/g, '').toLowerCase()).filter(Boolean));
+}
+
+function kotlinPsiAnnotationNames(node) {
+  const entries = node.annotationEntries ?? node.annotations ?? node.modifierList?.annotationEntries;
+  if (!entries) return [];
+  if (Array.isArray(entries)) {
+    return uniqueStrings(entries.map((entry) => typeof entry === 'string' ? entry : kotlinPsiName(entry.shortName ?? entry.calleeExpression ?? entry.typeReference ?? entry.name ?? entry)).filter(Boolean));
+  }
+  return [];
+}
+
+function kotlinPsiTypeDeclarationKind(kind) {
+  return kind === 'KtClass'
+    || kind === 'KtClassOrObject'
+    || kind === 'KtObjectDeclaration';
+}
+
+function kotlinPsiTypeDeclarationSymbolKind(node, kind) {
+  const classKind = String(node.classKind ?? node.kindKeyword ?? '').toLowerCase();
+  if (kind === 'KtObjectDeclaration') return 'class';
+  if (classKind.includes('interface')) return 'interface';
+  if (classKind.includes('enum')) return 'enum';
+  if (classKind.includes('annotation')) return 'type';
+  return 'class';
+}
+
+function kotlinPsiHasBody(node) {
+  return Boolean(node.bodyExpression || node.bodyBlockExpression || node.body || Array.isArray(node.statements));
+}
+
+function kotlinPsiRecoveredKind(kind) {
+  return kind === 'PsiErrorElement'
+    || kind === 'KtErrorElement'
+    || /Error|Recovery|Incomplete|Missing|Skipped/.test(String(kind));
+}
+
+function kotlinPsiProblemNode(node, kind) {
+  return Boolean(
+    node.hasError
+    || node.containsDiagnostics
+    || node.containsSkippedText
+    || node.isMissing
+    || kind === 'PsiErrorElement'
+    || kind === 'KtErrorElement'
+  );
+}
+
+function kotlinExpectActualNode(node) {
+  const modifiers = kotlinPsiModifiers(node);
+  return modifiers.includes('expect') || modifiers.includes('actual');
+}
+
+function kotlinCoroutineNode(node, kind) {
+  const modifiers = kotlinPsiModifiers(node);
+  return modifiers.includes('suspend')
+    || /Coroutine|Suspend/i.test(String(kind))
+    || node.isSuspend === true
+    || node.suspend === true;
+}
+
+function kotlinContractNode(kind) {
+  return /Contract/i.test(String(kind));
+}
+
+function kotlinCompilerPluginAnnotationNode(node) {
+  const names = kotlinPsiAnnotationNames(node);
+  return names.some((name) => /^(Composable|Serializable|Parcelize|Entity|Immutable|Stable|AutoService|AssistedInject|Hilt|Inject|Room|KSerializable)$/i.test(name.replace(/^.*\./, '')));
+}
+
+function kotlinGeneratedCodeMarker(node) {
+  if (node.generated || node.isGenerated) return true;
+  const path = String(node.filePath ?? node.path ?? node.sourcePath ?? '');
+  return kotlinGeneratedSourcePath(path);
+}
+
+function kotlinGeneratedSourcePath(path) {
+  return typeof path === 'string' && (/(\.g|\.generated)\.kts?$/i.test(path) || /[\/\\](build|generated|ksp|kapt)[\/\\]/i.test(path));
+}
+
+function kotlinGeneratedCodeLoss(input, nodeId, span, options = {}, metadata = {}) {
+  return {
+    id: `loss_${idFragment(nodeId ?? input.sourcePath ?? 'kotlin')}_kotlin_generated_code`,
+    severity: 'warning',
+    phase: 'parse',
+    sourceFormat: input.language,
+    kind: 'generatedCode',
+    message: 'Kotlin generated-source marker was imported; generated member provenance and source ownership require host evidence.',
+    span,
+    nodeId,
+    metadata: {
+      parser: options.parser,
+      astFormat: options.astFormat,
+      kspEvidence: kotlinEvidenceSummary(options.kspEvidence),
+      kaptEvidence: kotlinEvidenceSummary(options.kaptEvidence),
+      compilerPluginEvidence: kotlinEvidenceSummary(options.compilerPluginEvidence),
+      ...metadata
+    }
+  };
+}
+
+function kotlinScriptLoss(input, nodeId, span, options = {}) {
+  return {
+    id: `loss_${idFragment(nodeId ?? input.sourcePath ?? 'kotlin')}_kotlin_script_semantics`,
+    severity: 'warning',
+    phase: 'parse',
+    sourceFormat: input.language,
+    kind: 'unsupportedSemantic',
+    message: 'Kotlin script source was imported; script templates, implicit receivers, dependencies, and host execution environment require build/runtime evidence.',
+    span,
+    nodeId,
+    metadata: {
+      parser: options.parser,
+      astFormat: options.astFormat,
+      feature: 'script',
+      unsupportedSemanticKind: 'kotlin.scriptContext',
+      script: true,
+      buildVariantEvidence: kotlinEvidenceSummary(options.buildVariantEvidence)
+    }
+  };
+}
+
+function kotlinUnsupportedSemanticLoss(input, nodeId, span, options = {}, metadata = {}) {
+  return {
+    id: `loss_${idFragment(nodeId ?? input.sourcePath ?? 'kotlin')}_kotlin_${idFragment(metadata.feature ?? 'semantic')}`,
+    severity: 'warning',
+    phase: 'parse',
+    sourceFormat: input.language,
+    kind: 'unsupportedSemantic',
+    message: metadata.message ?? 'Kotlin semantic feature requires host compiler evidence.',
+    span,
+    nodeId,
+    metadata: {
+      parser: options.parser,
+      astFormat: options.astFormat,
+      unsupportedSemanticKind: metadata.unsupportedSemanticKind ?? `kotlin.${idFragment(metadata.feature ?? 'semantic')}`,
+      analysisApiEvidence: kotlinEvidenceSummary(options.analysisApiEvidence),
+      firEvidence: kotlinEvidenceSummary(options.firEvidence),
+      multiplatformEvidence: kotlinEvidenceSummary(options.multiplatformEvidence),
+      ...metadata
+    }
+  };
+}
+
+function kotlinEvidenceSummary(value) {
+  if (!value) return undefined;
+  if (Array.isArray(value)) return { entryCount: value.length };
+  if (typeof value === 'string') return { value };
+  if (typeof value === 'object') {
+    const summary = {};
+    if (typeof value.hash === 'string') summary.hash = value.hash;
+    if (typeof value.solver === 'string') summary.solver = value.solver;
+    if (Array.isArray(value.entries)) summary.entryCount = value.entries.length;
+    if (Array.isArray(value.symbols)) summary.symbolCount = value.symbols.length;
+    if (Array.isArray(value.references)) summary.referenceCount = value.references.length;
+    if (Array.isArray(value.types)) summary.typeCount = value.types.length;
+    if (Array.isArray(value.diagnostics)) summary.diagnosticCount = value.diagnostics.length;
+    if (Array.isArray(value.plugins)) summary.pluginCount = value.plugins.length;
+    if (Array.isArray(value.generatedSources)) summary.generatedSourceCount = value.generatedSources.length;
+    if (Array.isArray(value.platforms)) summary.platformCount = value.platforms.length;
+    if (Array.isArray(value.variants)) summary.variantCount = value.variants.length;
+    return Object.keys(summary).length ? summary : { present: true };
+  }
+  return { present: true };
+}
+
 function csharpRoslynRoot(value) {
   if (!value || typeof value !== 'object') return undefined;
   if (isCSharpRoslynNode(value)) return value;