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

package/dist/native-import-language-profiles.js

@@ -0,0 +1,169 @@
+import {
+  normalizeNativeLanguageId,
+  uniqueStrings
+} from './native-import-utils.js';
+
+export const ProjectionTargetLossClasses = Object.freeze([
+  'exactSourceProjection',
+  'nativeSourceStubs',
+  'unsupportedTargetFeatures',
+  'targetAdapterProjection',
+  'missingAdapter'
+]);
+
+
+export const NativeImportLanguageProfiles = Object.freeze([
+  nativeImportLanguageProfile('javascript', {
+    aliases: ['js', 'mjs', 'cjs', 'jsx'],
+    extensions: ['.js', '.mjs', '.cjs', '.jsx'],
+    parserAdapters: ['estree', 'babel', 'tree-sitter'],
+    lossKinds: ['declarationOnlyCoverage', 'opaqueNative', 'sourceMapApproximation', 'sourcePreservation', 'dynamicRuntime']
+  }),
+  nativeImportLanguageProfile('typescript', {
+    aliases: ['ts', 'tsx'],
+    extensions: ['.ts', '.tsx'],
+    parserAdapters: ['typescript-compiler-api', 'babel', 'tree-sitter'],
+    lossKinds: ['declarationOnlyCoverage', 'opaqueNative', 'sourceMapApproximation', 'sourcePreservation', 'unsupportedSyntax']
+  }),
+  nativeImportLanguageProfile('python', {
+    aliases: ['py'],
+    extensions: ['.py', '.pyi'],
+    parserAdapters: ['python-ast', 'libcst', 'parso', 'tree-sitter'],
+    lossKinds: ['declarationOnlyCoverage', 'opaqueNative', 'sourceMapApproximation', 'sourcePreservation', 'dynamicRuntime']
+  }),
+  nativeImportLanguageProfile('rust', {
+    aliases: ['rs'],
+    extensions: ['.rs'],
+    parserAdapters: ['syn', 'rust-analyzer-rowan', 'tree-sitter'],
+    lossKinds: ['declarationOnlyCoverage', 'opaqueNative', 'macroExpansion', 'sourceMapApproximation', 'sourcePreservation']
+  }),
+  nativeImportLanguageProfile('c', {
+    aliases: ['h'],
+    extensions: ['.c', '.h'],
+    parserAdapters: ['clang', 'libclang', 'tree-sitter'],
+    lossKinds: ['declarationOnlyCoverage', 'opaqueNative', 'preprocessor', 'sourceMapApproximation', 'sourcePreservation']
+  }),
+  nativeImportLanguageProfile('cpp', {
+    aliases: ['c++', 'cc', 'cxx', 'hpp'],
+    extensions: ['.cc', '.cpp', '.cxx', '.hpp', '.hh'],
+    parserAdapters: ['clang', 'libclang', 'tree-sitter'],
+    lossKinds: ['declarationOnlyCoverage', 'opaqueNative', 'preprocessor', 'metaprogramming', 'sourceMapApproximation', 'sourcePreservation']
+  }),
+  nativeImportLanguageProfile('java', { extensions: ['.java'], parserAdapters: ['javac', 'jdt', 'javaparser', 'tree-sitter'] }),
+  nativeImportLanguageProfile('go', { extensions: ['.go'], parserAdapters: ['go/parser', 'tree-sitter'] }),
+  nativeImportLanguageProfile('swift', { extensions: ['.swift'], parserAdapters: ['swift-syntax', 'tree-sitter'] }),
+  nativeImportLanguageProfile('csharp', { aliases: ['c#', 'cs'], extensions: ['.cs'], parserAdapters: ['roslyn', 'tree-sitter'] }),
+  nativeImportLanguageProfile('php', { extensions: ['.php'], parserAdapters: ['php-parser', 'tree-sitter'], lossKinds: ['declarationOnlyCoverage', 'opaqueNative', 'metaprogramming', 'sourceMapApproximation', 'sourcePreservation'] }),
+  nativeImportLanguageProfile('ruby', { aliases: ['rb'], extensions: ['.rb', '.rake'], parserAdapters: ['prism', 'ripper', 'tree-sitter'], lossKinds: ['declarationOnlyCoverage', 'opaqueNative', 'metaprogramming', 'sourceMapApproximation', 'sourcePreservation'] }),
+  nativeImportLanguageProfile('kotlin', { aliases: ['kt', 'kts'], extensions: ['.kt', '.kts'], parserAdapters: ['kotlin-compiler', 'intellij-psi', 'tree-sitter'] }),
+  nativeImportLanguageProfile('scala', { aliases: ['sc'], extensions: ['.scala', '.sc'], parserAdapters: ['scala-compiler', 'scalameta', 'tree-sitter'] }),
+  nativeImportLanguageProfile('dart', { extensions: ['.dart'], parserAdapters: ['dart-analyzer', 'tree-sitter'] }),
+  nativeImportLanguageProfile('lua', { extensions: ['.lua'], parserAdapters: ['luaparse', 'tree-sitter'], lossKinds: ['declarationOnlyCoverage', 'opaqueNative', 'dynamicRuntime', 'sourceMapApproximation', 'sourcePreservation'] }),
+  nativeImportLanguageProfile('shell', { aliases: ['sh', 'bash', 'zsh'], extensions: ['.sh', '.bash', '.zsh'], parserAdapters: ['bash-parser', 'tree-sitter'], lossKinds: ['declarationOnlyCoverage', 'opaqueNative', 'dynamicRuntime', 'sourceMapApproximation', 'sourcePreservation'] }),
+  nativeImportLanguageProfile('sql', { aliases: ['postgresql', 'postgres', 'mysql', 'sqlite'], extensions: ['.sql'], parserAdapters: ['sqlparser', 'tree-sitter'], lossKinds: ['declarationOnlyCoverage', 'opaqueNative', 'unsupportedSyntax', 'sourceMapApproximation', 'sourcePreservation'] }),
+  nativeImportLanguageProfile('zig', { extensions: ['.zig'], parserAdapters: ['zig-ast', 'tree-sitter'], lossKinds: ['declarationOnlyCoverage', 'opaqueNative', 'generatedCode', 'sourceMapApproximation', 'sourcePreservation'] }),
+  nativeImportLanguageProfile('elixir', { aliases: ['ex', 'exs'], extensions: ['.ex', '.exs'], parserAdapters: ['elixir-quoted', 'tree-sitter'], lossKinds: ['declarationOnlyCoverage', 'opaqueNative', 'macroExpansion', 'sourceMapApproximation', 'sourcePreservation'] }),
+  nativeImportLanguageProfile('erlang', { aliases: ['erl', 'hrl'], extensions: ['.erl', '.hrl'], parserAdapters: ['erl_parse', 'tree-sitter'], lossKinds: ['declarationOnlyCoverage', 'opaqueNative', 'preprocessor', 'macroExpansion', 'sourceMapApproximation', 'sourcePreservation'] }),
+  nativeImportLanguageProfile('haskell', { aliases: ['hs'], extensions: ['.hs', '.lhs'], parserAdapters: ['ghc-api', 'tree-sitter'], lossKinds: ['declarationOnlyCoverage', 'opaqueNative', 'macroExpansion', 'sourceMapApproximation', 'sourcePreservation'] }),
+  nativeImportLanguageProfile('r', { aliases: ['R'], extensions: ['.r', '.R'], parserAdapters: ['r-parser', 'tree-sitter'], lossKinds: ['declarationOnlyCoverage', 'opaqueNative', 'dynamicRuntime', 'sourceMapApproximation', 'sourcePreservation'] })
+]);
+
+
+export function nativeProjectionTargetsForLanguage(language, aliases = []) {
+  const target = nativeLanguageCompileTarget(language, aliases);
+  return target ? [target] : [];
+}
+
+function nativeImportLanguageProfile(language, input = {}) {
+  const lossKinds = input.lossKinds ?? ['declarationOnlyCoverage', 'opaqueNative', 'sourceMapApproximation', 'sourcePreservation'];
+  const aliases = uniqueStrings(input.aliases ?? []);
+  return Object.freeze({
+    language,
+    aliases: Object.freeze(aliases),
+    extensions: Object.freeze(uniqueStrings(input.extensions ?? [])),
+    supportsLightweightScan: input.supportsLightweightScan !== false,
+    parserAdapters: Object.freeze(uniqueStrings(input.parserAdapters ?? ['tree-sitter'])),
+    projectionTargets: Object.freeze(uniqueStrings(input.projectionTargets ?? nativeProjectionTargetsForLanguage(language, aliases))),
+    knownLossKinds: Object.freeze(uniqueStrings(lossKinds)),
+    defaultReadiness: input.defaultReadiness ?? 'needs-review',
+    notes: Object.freeze(uniqueStrings(input.notes ?? ['lightweight scanner records declarations only; exact parser adapters must be injected by the host']))
+  });
+}
+
+
+export function normalizeProjectionMatrixTargets(targets) {
+  const canonicalTargets = { ts: 'typescript', js: 'javascript', rs: 'rust', py: 'python', h: 'c' };
+  return uniqueStrings((Array.isArray(targets) ? targets : [targets])
+    .map((target) => {
+      if (target === undefined || target === null) return undefined;
+      const normalized = String(target).trim().toLowerCase();
+      return canonicalTargets[normalized] ?? normalized;
+    })
+    .filter(Boolean));
+}
+
+
+export function nativeLanguageCompileTarget(language, aliases = []) {
+  const ids = [language, ...aliases].map(normalizeNativeLanguageId);
+  if (ids.includes('typescript')) return 'typescript';
+  if (ids.includes('javascript')) return 'javascript';
+  if (ids.includes('rust')) return 'rust';
+  if (ids.includes('python')) return 'python';
+  if (ids.includes('c')) return 'c';
+  return undefined;
+}
+
+
+function normalizeNativeImportLanguageProfile(profile, fallbackLanguage) {
+  const language = normalizeNativeLanguageId(profile.language ?? fallbackLanguage);
+  return {
+    language,
+    aliases: uniqueStrings(profile.aliases ?? []),
+    extensions: uniqueStrings(profile.extensions ?? []),
+    supportsLightweightScan: profile.supportsLightweightScan !== false,
+    parserAdapters: uniqueStrings(profile.parserAdapters ?? []),
+    projectionTargets: uniqueStrings(profile.projectionTargets ?? nativeProjectionTargetsForLanguage(language, profile.aliases ?? [])),
+    knownLossKinds: uniqueStrings(profile.knownLossKinds ?? profile.lossKinds ?? []),
+    defaultReadiness: profile.defaultReadiness ?? 'needs-review',
+    notes: uniqueStrings(profile.notes ?? [])
+  };
+}
+
+export function mergeNativeImportProfiles(languages, imports = [], adapters = [], targetAdapters = [], context = {}) {
+  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: [] });
+    profilesByLanguage.set(normalized, {
+      ...existing,
+      parserAdapters: uniqueStrings([...(existing.parserAdapters ?? []), adapter.parser ?? adapter.id].filter(Boolean))
+    });
+  }
+  for (const adapter of targetAdapters ?? []) {
+    const summary = context.safeNativeTargetProjectionAdapterSummary?.(adapter);
+    const normalized = normalizeNativeLanguageId(summary?.sourceLanguage ?? adapter?.sourceLanguage ?? adapter?.language);
+    if (!normalized) continue;
+    const existing = profilesByLanguage.get(normalized) ?? nativeImportLanguageProfile(normalized, { supportsLightweightScan: false, parserAdapters: [] });
+    profilesByLanguage.set(normalized, {
+      ...existing,
+      projectionTargets: uniqueStrings([...(existing.projectionTargets ?? []), summary?.target ?? adapter?.target ?? adapter?.targetLanguage].filter(Boolean))
+    });
+  }
+  return [...profilesByLanguage.values()].sort((left, right) => left.language.localeCompare(right.language));
+}

package/dist/native-import-utils.js

@@ -0,0 +1,143 @@
+export function uniqueStrings(values) {
+  return [...new Set((values ?? []).map((value) => String(value)).filter(Boolean))];
+}
+
+export function uniqueRecordsById(records) {
+  const seen = new Set();
+  const result = [];
+  for (const record of records ?? []) {
+    if (!record?.id || seen.has(record.id)) continue;
+    seen.add(record.id);
+    result.push(record);
+  }
+  return result;
+}
+
+export function uniqueByLossId(values) {
+  const seen = new Set();
+  const result = [];
+  for (const value of values ?? []) {
+    const id = value?.id ?? `loss_${result.length + 1}`;
+    if (seen.has(id)) continue;
+    seen.add(id);
+    result.push(value.id ? value : { ...value, id });
+  }
+  return result;
+}
+
+export function uniqueByEvidenceId(values) {
+  const seen = new Set();
+  const result = [];
+  for (const value of values ?? []) {
+    const id = value?.id ?? `evidence_${result.length + 1}`;
+    if (seen.has(id)) continue;
+    seen.add(id);
+    result.push(value.id ? value : { ...value, id });
+  }
+  return result;
+}
+
+export function normalizeStringList(value) {
+  if (value === undefined || value === null) return [];
+  if (Array.isArray(value)) return value.map((item) => String(item)).filter(Boolean);
+  return [String(value)].filter(Boolean);
+}
+
+export function normalizeNativeLanguageId(value) {
+  if (!value) return '';
+  const text = String(value).trim().toLowerCase();
+  if (text === 'js' || text === 'mjs' || text === 'cjs' || text === 'jsx') return 'javascript';
+  if (text === 'ts' || text === 'tsx') return 'typescript';
+  if (text === 'py' || text === 'pyi') return 'python';
+  if (text === 'rs') return 'rust';
+  if (text === 'h') return 'c';
+  if (text === 'c++' || text === 'cc' || text === 'cxx' || text === 'hpp' || text === 'hh') return 'cpp';
+  if (text === 'c#' || text === 'cs') return 'csharp';
+  if (text === 'rb' || text === 'rake') return 'ruby';
+  if (text === 'kt' || text === 'kts') return 'kotlin';
+  if (text === 'sc') return 'scala';
+  if (text === 'sh' || text === 'bash' || text === 'zsh') return 'shell';
+  if (text === 'postgresql' || text === 'postgres' || text === 'mysql' || text === 'sqlite') return 'sql';
+  if (text === 'ex' || text === 'exs') return 'elixir';
+  if (text === 'erl' || text === 'hrl') return 'erlang';
+  if (text === 'hs' || text === 'lhs') return 'haskell';
+  return text;
+}
+
+export function upperFirst(value) {
+  return String(value).charAt(0).toUpperCase() + String(value).slice(1);
+}
+
+export function reserveUniqueId(baseId, usedIds) {
+  const safeBase = String(baseId || 'id');
+  if (!usedIds.has(safeBase)) {
+    usedIds.add(safeBase);
+    return safeBase;
+  }
+  let index = 2;
+  while (usedIds.has(`${safeBase}_${index}`)) index += 1;
+  const id = `${safeBase}_${index}`;
+  usedIds.add(id);
+  return id;
+}
+
+export function commonGeneratedTargetPath(mappings) {
+  const paths = uniqueStrings((mappings ?? [])
+    .map((mapping) => mapping.generatedSpan?.targetPath ?? mapping.target?.emitPath)
+    .filter(Boolean));
+  return paths.length === 1 ? paths[0] : undefined;
+}
+
+export function normalizeSourcePreservationLevel(value, context = {}) {
+  const explicit = value === undefined || value === null ? '' : String(value).trim();
+  if (explicit) {
+    const normalized = explicit.toLowerCase();
+    if (normalized === 'exact' || normalized === 'declaration' || normalized === 'estimated' || normalized === 'blocked') return normalized;
+    if (normalized === 'estimate' || normalized === 'approx' || normalized === 'approximate' || normalized === 'approximated' || normalized === 'line') return 'estimated';
+    return explicit;
+  }
+
+  const lossIds = new Set(context.lossIds ?? []);
+  const linkedLosses = (context.losses ?? []).filter((loss) => lossIds.has(loss.id));
+  if (linkedLosses.some((loss) => loss.severity === 'error')) return 'blocked';
+  if (context.precision === 'exact') return 'exact';
+  if (context.precision === 'declaration') return 'declaration';
+  if (context.precision === 'line' || context.precision === 'estimated' || context.precision === 'unknown') return 'estimated';
+  if (context.sourcePreservation?.summary?.exactSourceAvailable === true) return 'estimated';
+  return 'estimated';
+}
+
+export function countBy(values) {
+  const counts = {};
+  for (const value of values ?? []) {
+    const key = String(value ?? 'unknown');
+    counts[key] = (counts[key] ?? 0) + 1;
+  }
+  return counts;
+}
+
+const semanticMergeReadinessRank = Object.freeze({
+  ready: 0,
+  'ready-with-losses': 1,
+  'needs-review': 2,
+  blocked: 3
+});
+
+export function maxSemanticMergeReadiness(left, right) {
+  const leftRank = semanticMergeReadinessRank[left] ?? semanticMergeReadinessRank['needs-review'];
+  const rightRank = semanticMergeReadinessRank[right] ?? semanticMergeReadinessRank['needs-review'];
+  return leftRank >= rightRank ? left : right;
+}
+
+export function normalizeSemanticMergeReadiness(value) {
+  const readiness = String(value ?? '').toLowerCase();
+  return Object.prototype.hasOwnProperty.call(semanticMergeReadinessRank, readiness) ? readiness : undefined;
+}
+
+export function idFragment(value) {
+  return String(value ?? 'native')
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '_')
+    .replace(/^_+|_+$/g, '')
+    .slice(0, 80) || 'native';
+}

package/dist/native-js-ts-importers.js

@@ -0,0 +1,85 @@
+function createJavaScriptSyntaxImporterAdapter(options, deps) {
+  const {
+    createNativeImportFromSyntaxAst,
+    declarationSemanticCoverage,
+    missingInjectedParserResult,
+    nativeImporterAdapterCoverage,
+    normalizeParserErrors,
+    uniqueStrings
+  } = deps;
+  return {
+    id: options.id,
+    language: options.language,
+    parser: options.parser,
+    version: options.version,
+    capabilities: uniqueStrings(['nativeAst', 'semanticIndex', 'sourceMaps', 'diagnostics', ...(options.capabilities ?? [])]),
+    coverage: nativeImporterAdapterCoverage({
+      exactness: 'exact-parser-ast',
+      exactAst: true,
+      tokens: false,
+      trivia: false,
+      diagnostics: true,
+      sourceRanges: true,
+      generatedRanges: false,
+      semanticCoverage: declarationSemanticCoverage(),
+      notes: [
+        'Normalizes a caller-owned ESTree/Babel-compatible AST into native AST nodes and declaration-level semantic index records.',
+        'The wrapper ignores parser token/trivia/comment arrays unless a host adapter explicitly maps them into preservation evidence.'
+      ]
+    }, options.coverage),
+    supportedExtensions: options.supportedExtensions,
+    diagnostics: options.diagnostics,
+    parse(input) {
+      const ast = input.options?.ast ?? input.options?.nativeAst ?? options.ast ?? parseJavaScriptSyntax(input, options);
+      if (!ast) {
+        return missingInjectedParserResult(input, {
+          parser: options.parser,
+          adapterId: options.id,
+          message: `${options.id} requires an injected parse function, parserModule.parse, ast, or adapterOptions.ast.`
+        });
+      }
+      const parseDiagnostics = normalizeParserErrors(ast.errors, input, options);
+      return createNativeImportFromSyntaxAst(ast, input, {
+        parser: options.parser,
+        astFormat: options.astFormat,
+        maxNodes: options.maxNodes,
+        diagnostics: parseDiagnostics
+      });
+    }
+  };
+}
+
+function parseJavaScriptSyntax(input, options) {
+  const parse = options.parse ?? options.parserModule?.parse ?? options.babelParser?.parse;
+  if (typeof parse !== 'function') return undefined;
+  const parserOptions = {
+    sourceFilename: input.sourcePath,
+    ...(options.defaultParserOptions ?? {}),
+    ...(typeof options.parserOptions === 'function'
+      ? options.parserOptions(input)
+      : options.parserOptions ?? {}),
+    ...(input.options?.parserOptions ?? {})
+  };
+  return parse(input.sourceText, parserOptions);
+}
+
+function createTypeScriptSourceFile(ts, input, options) {
+  if (typeof options.createSourceFile === 'function') return options.createSourceFile(input, ts);
+  if (!ts || typeof ts.createSourceFile !== 'function') return undefined;
+  const scriptTarget = options.scriptTarget ?? ts.ScriptTarget?.Latest ?? ts.ScriptTarget?.ESNext ?? 99;
+  const scriptKind = options.scriptKind ?? inferTypeScriptScriptKind(ts, input);
+  return ts.createSourceFile(input.sourcePath ?? 'frontier-input.ts', input.sourceText, scriptTarget, true, scriptKind);
+}
+
+function inferTypeScriptScriptKind(ts, input) {
+  const path = String(input.sourcePath ?? '').toLowerCase();
+  if (path.endsWith('.tsx')) return ts.ScriptKind?.TSX;
+  if (path.endsWith('.jsx')) return ts.ScriptKind?.JSX;
+  if (path.endsWith('.js') || path.endsWith('.mjs') || path.endsWith('.cjs')) return ts.ScriptKind?.JS;
+  return ts.ScriptKind?.TS;
+}
+
+export {
+  createJavaScriptSyntaxImporterAdapter,
+  createTypeScriptSourceFile
+};

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

@@ -0,0 +1,147 @@
+import {
+  maxSemanticMergeReadiness,
+  uniqueStrings
+} from './native-import-utils.js';
+import {
+  NativeParserAstFormatProfiles,
+  nativeParserAstFormatProfile,
+  normalizeParserAstFormatId,
+  parserAstFormatIdForImport,
+  parserAstFormatIdForParser
+} from './coverage-matrix-profiles.js';
+import {
+  nativeImportReadiness,
+  safeNativeImporterAdapterSummary
+} from './native-import-coverage-matrix.js';
+
+export function getNativeParserAstFormatProfile(format) {
+  const normalized = normalizeParserAstFormatId(format);
+  return NativeParserAstFormatProfiles.find((profile) => profile.id === normalized || profile.aliases.includes(normalized));
+}
+
+export function createNativeParserAstFormatMatrix(input = {}, context = {}) {
+  const imports = input.imports ?? [];
+  const adapters = input.adapters ?? [];
+  const profiles = mergeNativeParserAstFormatProfiles(input.formats ?? NativeParserAstFormatProfiles, imports, adapters, context);
+  const formats = profiles.map((profile) => nativeParserAstFormatCoverageForProfile(profile, imports, adapters, context));
+  const summary = formats.reduce((totals, entry) => {
+    totals.formats += 1;
+    totals.adapterSlots += entry.parserAdapters.length;
+    totals.adapters += entry.adapters.total;
+    totals.imports += entry.imports.total;
+    totals.nativeAstNodes += entry.imports.nativeAstNodes;
+    totals.symbols += entry.imports.symbols;
+    totals.sourceMapMappings += entry.imports.sourceMapMappings;
+    totals.losses += entry.imports.losses;
+    totals.byKind[entry.kind] = (totals.byKind[entry.kind] ?? 0) + 1;
+    totals.byReadiness[entry.imports.readiness] = (totals.byReadiness[entry.imports.readiness] ?? 0) + 1;
+    for (const [capability, count] of Object.entries(entry.adapters.effectiveCapabilities)) {
+      totals.effectiveCapabilities[capability] = (totals.effectiveCapabilities[capability] ?? 0) + count;
+    }
+    return totals;
+  }, {
+    formats: 0,
+    adapterSlots: 0,
+    adapters: 0,
+    imports: 0,
+    nativeAstNodes: 0,
+    symbols: 0,
+    sourceMapMappings: 0,
+    losses: 0,
+    byKind: {},
+    byReadiness: {},
+    effectiveCapabilities: {}
+  });
+  return {
+    kind: 'frontier.lang.nativeParserAstFormatMatrix',
+    version: 1,
+    generatedAt: input.generatedAt ?? Date.now(),
+    formats,
+    summary,
+    metadata: {
+      note: 'Parser AST format coverage describes normalization evidence and host-parser obligations; it is not a lossless portability claim.',
+      profileIds: profiles.map((profile) => profile.id)
+    }
+  };
+}
+
+export function mergeNativeParserAstFormatProfiles(profiles, imports, adapters, context = {}) {
+  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, context);
+    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));
+}
+
+export function nativeParserAstFormatCoverageForProfile(profile, imports, adapters, context = {}) {
+  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, context))
+    .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)
+    }
+  };
+}