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

package/dist/internal/index-impl/clangTypeName.js

@@ -0,0 +1,9 @@
+export function clangTypeName(value) {
+  if (!value) return undefined;
+  if (typeof value === 'string') return value;
+  if (typeof value.qualType === 'string') return value.qualType;
+  if (typeof value.desugaredQualType === 'string') return value.desugaredQualType;
+  if (typeof value.name === 'string') return value.name;
+  if (value.type && typeof value.type === 'object') return clangTypeName(value.type);
+  return undefined;
+}

package/dist/internal/index-impl/classifyNativeImportReadiness.js

@@ -0,0 +1,9 @@
+import{summarizeNativeImportLosses}from'./summarizeNativeImportLosses.js';
+export function classifyNativeImportReadiness(losses = [], options = {}) {
+  const summary = summarizeNativeImportLosses(losses, options);
+  return {
+    readiness: summary.semanticMergeReadiness,
+    reasons: summary.readinessReasons,
+    summary
+  };
+}

package/dist/internal/index-impl/classifyNativeImportRoundtripReadiness.js

@@ -0,0 +1,129 @@
+import{maxSemanticMergeReadiness,uniqueByEvidenceId,uniqueByLossId,uniqueStrings}from'../../native-import-utils.js';import{validateUniversalAstEnvelope}from'@shapeshift-labs/frontier-lang-kernel';
+import{classifyNativeImportReadiness}from'./classifyNativeImportReadiness.js';import{nativeImportEntries}from'./nativeImportEntries.js';import{nativeImportHasExactAstCoverage}from'./nativeImportHasExactAstCoverage.js';import{nativeImportRoundtripParser}from'./nativeImportRoundtripParser.js';import{nativeImportRoundtripReasons}from'./nativeImportRoundtripReasons.js';import{projectNativeImportToSource}from'./projectNativeImportToSource.js';
+export function classifyNativeImportRoundtripReadiness(importResult, options = {}) {
+  if (!importResult || typeof importResult !== 'object') {
+    throw new Error('classifyNativeImportRoundtripReadiness requires a native import result');
+  }
+  const imports = nativeImportEntries(importResult);
+  const importLosses = uniqueByLossId([
+    ...(importResult.losses ?? []),
+    ...imports.flatMap((imported) => imported?.losses ?? [])
+  ]);
+  const importEvidence = uniqueByEvidenceId([
+    ...(importResult.evidence ?? []),
+    ...imports.flatMap((imported) => imported?.evidence ?? [])
+  ]);
+  const exactAst = imports.length > 0 && imports.every((imported) => nativeImportHasExactAstCoverage(imported));
+  const importReadiness = classifyNativeImportReadiness(importLosses, {
+    exactAst,
+    evidence: importEvidence,
+    parser: nativeImportRoundtripParser(importResult, imports),
+    scanKind: importResult.metadata?.nativeImportLossSummary?.scanKind,
+    semanticStatus: importResult.metadata?.semanticStatus ?? importResult.universalAst?.metadata?.semanticStatus
+  });
+  const projection = options.projection ?? projectNativeImportToSource(importResult, options);
+  const projectionReadiness = projection.readiness ?? classifyNativeImportReadiness(projection.losses ?? [], {
+    evidence: projection.evidence,
+    parser: projection.metadata?.nativeImportLossSummary?.parser,
+    scanKind: 'native-source-projection'
+  });
+  const universalAst = importResult.universalAst;
+  const universalAstIssues = universalAst
+    ? validateUniversalAstEnvelope(universalAst)
+    : ['missing-universal-ast'];
+  const universalAstNativeSources = universalAst?.nativeSources?.length ?? importResult.nativeSources?.length ?? (importResult.nativeSource ? 1 : 0);
+  const semanticIndex = importResult.semanticIndex ?? universalAst?.semanticIndex;
+  const semanticSymbols = semanticIndex?.symbols?.length ?? 0;
+  const sourceMaps = importResult.sourceMaps ?? universalAst?.sourceMaps ?? [];
+  const sourceMapMappings = sourceMaps.reduce((sum, sourceMap) => sum + (sourceMap?.mappings?.length ?? 0), 0);
+  const projectionMatchesSourceHash = Boolean(projection.sourceHash && projection.outputHash === projection.sourceHash);
+  const preservedSource = projection.mode === 'preserved-source';
+  const failedEvidenceIds = uniqueStrings([
+    ...importEvidence.filter((record) => record?.status === 'failed').map((record) => record.id),
+    ...(projection.evidence ?? []).filter((record) => record?.status === 'failed').map((record) => record.id)
+  ]);
+  const blockingReasons = [
+    ...(importReadiness.readiness === 'blocked' ? importReadiness.reasons : []),
+    ...(projectionReadiness.readiness === 'blocked' ? projectionReadiness.reasons : []),
+    ...(failedEvidenceIds.length ? [`Failed evidence prevents native roundtrip readiness: ${failedEvidenceIds.join(', ')}`] : []),
+    ...(universalAstIssues.length ? [`Universal AST validation failed: ${universalAstIssues.join('; ')}`] : [])
+  ];
+  const reviewReasons = [
+    ...(semanticSymbols === 0 ? ['Universal AST semantic index has no symbols for source projection review.'] : []),
+    ...(sourceMapMappings === 0 ? ['Universal AST has no native source-map mappings for roundtrip review.'] : []),
+    ...(preservedSource && !projectionMatchesSourceHash ? ['Projected source was preserved without a verified import source hash match.'] : []),
+    ...importReadiness.reasons.filter((reason) => importReadiness.readiness !== 'ready' || !exactAst),
+    ...projectionReadiness.reasons.filter((reason) => projectionReadiness.readiness !== 'ready')
+  ];
+  let status;
+  if (blockingReasons.length) {
+    status = 'blocked';
+  } else if (projection.mode === 'native-source-stubs') {
+    status = 'stub-only';
+  } else if (reviewReasons.some((reason) => reason.startsWith('Universal AST')) || (preservedSource && !projectionMatchesSourceHash)) {
+    status = 'needs-review';
+  } else if (exactAst && preservedSource && projectionMatchesSourceHash && projectionReadiness.readiness === 'ready') {
+    status = 'exact';
+  } else if (preservedSource && projectionMatchesSourceHash) {
+    status = 'preserved-source';
+  } else {
+    status = 'needs-review';
+  }
+  const reasons = nativeImportRoundtripReasons(status, {
+    blockingReasons,
+    reviewReasons,
+    projection,
+    importReadiness,
+    projectionReadiness
+  });
+  return {
+    kind: 'frontier.lang.nativeImportRoundtripReadiness',
+    version: 1,
+    status,
+    semanticMergeReadiness: maxSemanticMergeReadiness(importReadiness.readiness, projectionReadiness.readiness),
+    reasons,
+    importReadiness,
+    projectionReadiness,
+    projectionMode: projection.mode,
+    checks: {
+      nativeImport: {
+        imports: imports.length,
+        exactAst,
+        losses: importReadiness.summary.total,
+        readiness: importReadiness.readiness
+      },
+      universalAst: {
+        present: Boolean(universalAst),
+        valid: universalAstIssues.length === 0,
+        issues: universalAstIssues,
+        nativeSources: universalAstNativeSources,
+        semanticSymbols,
+        sourceMaps: sourceMaps.length,
+        sourceMapMappings
+      },
+      projectedSource: {
+        mode: projection.mode,
+        outputHash: projection.outputHash,
+        expectedSourceHash: projection.sourceHash,
+        sourceHashVerified: projectionMatchesSourceHash,
+        declarations: projection.declarations?.length ?? 0,
+        losses: projection.lossSummary?.total ?? projection.losses?.length ?? 0,
+        readiness: projectionReadiness.readiness
+      }
+    },
+    evidence: {
+      importEvidenceIds: importEvidence.map((record) => record.id).filter(Boolean),
+      projectionEvidenceIds: (projection.evidence ?? []).map((record) => record.id).filter(Boolean),
+      failedEvidenceIds
+    },
+    metadata: {
+      nativeImportId: importResult.id,
+      universalAstId: universalAst?.id,
+      projectionId: projection.id,
+      sourcePath: projection.sourcePath ?? importResult.sourcePath,
+      language: projection.language ?? importResult.language,
+      sourcePreservationId: projection.metadata?.sourcePreservationId,
+      ...options.metadata
+    }
+  };
+}

package/dist/internal/index-impl/compileFrontierDocument.js

@@ -0,0 +1,28 @@
+import{checkDocument}from'@shapeshift-labs/frontier-lang-checker';import{hashDocumentBase}from'@shapeshift-labs/frontier-lang-kernel';
+import{normalizeCompileTarget}from'./normalizeCompileTarget.js';import{projectFrontierAst}from'./projectFrontierAst.js';import{renderTargetAst}from'./renderTargetAst.js';
+export function compileFrontierDocument(document, options = {}) {
+  const target = normalizeCompileTarget(options.target);
+  const check = checkDocument(document, options.check ?? {});
+  const hash = hashDocumentBase(document);
+  if (!check.ok && options.emitOnError !== true) {
+    return {
+      ok: false,
+      target,
+      hash,
+      document,
+      diagnostics: check.diagnostics,
+      ast: undefined,
+      output: ''
+    };
+  }
+  const ast = projectFrontierAst(document, target, options.emit ?? {});
+  return {
+    ok: check.ok,
+    target,
+    hash,
+    document,
+    diagnostics: check.diagnostics,
+    ast,
+    output: renderTargetAst(ast, target)
+  };
+}

package/dist/internal/index-impl/compileFrontierSource.js

@@ -0,0 +1,8 @@
+import{parseFrontierFile,parseFrontierSource}from'@shapeshift-labs/frontier-lang-parser';
+import{compileFrontierDocument}from'./compileFrontierDocument.js';
+export function compileFrontierSource(source, options = {}) {
+  const document = options.fileName
+    ? parseFrontierFile(options.fileName, source)
+    : parseFrontierSource(source, options.parse);
+  return compileFrontierDocument(document, options);
+}

package/dist/internal/index-impl/compileNativeSource.js

@@ -0,0 +1,186 @@
+import{nativeLanguageCompileTarget}from'../../coverage-matrix-profiles.js';import{idFragment,uniqueByEvidenceId,uniqueByLossId}from'../../native-import-utils.js';
+import{classifyNativeImportReadiness}from'./classifyNativeImportReadiness.js';import{createNativeRoundtripEvidence}from'./createNativeRoundtripEvidence.js';import{createProjectionTargetLossMatrix}from'./createProjectionTargetLossMatrix.js';import{importNativeSource}from'./importNativeSource.js';import{isNativeSourceImportResult}from'./isNativeSourceImportResult.js';import{nativeCompileSourceLanguage}from'./nativeCompileSourceLanguage.js';import{nativeCompileTarget}from'./nativeCompileTarget.js';import{nativeSourceCompileEvidence}from'./nativeSourceCompileEvidence.js';import{nativeSourceCompileSourceMaps}from'./nativeSourceCompileSourceMaps.js';import{nativeSourceCompileTargetCoverage}from'./nativeSourceCompileTargetCoverage.js';import{nativeSourceCompileTargetLosses}from'./nativeSourceCompileTargetLosses.js';import{projectNativeImportToSource}from'./projectNativeImportToSource.js';import{resolveNativeTargetProjectionAdapter}from'./resolveNativeTargetProjectionAdapter.js';import{runNativeTargetProjectionAdapter}from'./runNativeTargetProjectionAdapter.js';import{summarizeNativeImportLosses}from'./summarizeNativeImportLosses.js';
+export function compileNativeSource(input, options = {}) {
+  const importResult = isNativeSourceImportResult(input) ? input : importNativeSource(input);
+  const sourceLanguage = nativeCompileSourceLanguage(importResult, input);
+  const target = nativeCompileTarget(input, importResult, options);
+  const sourceTarget = nativeLanguageCompileTarget(sourceLanguage);
+  const sameSourceTarget = sourceTarget === target;
+  const idPart = idFragment(options.id ?? importResult.id ?? importResult.sourcePath ?? sourceLanguage ?? target);
+  const id = options.id ?? `native_source_compile_${idPart}_${idFragment(target)}`;
+  const projection = projectNativeImportToSource(importResult, {
+    ...options,
+    id: options.projectionId ?? `${id}_projection`,
+    language: sameSourceTarget ? sourceLanguage : target,
+    preferPreservedSource: sameSourceTarget ? options.preferPreservedSource : false,
+    evidenceId: options.projectionEvidenceId ?? options.evidenceId,
+    metadata: {
+      sourceLanguage,
+      target,
+      nativeCompileResultId: id,
+      ...options.metadata
+    }
+  });
+  const projectionMatrix = createProjectionTargetLossMatrix({
+    imports: [importResult],
+    adapters: options.adapters,
+    targetAdapters: options.targetAdapters,
+    languages: options.languages,
+    targets: [target],
+    generatedAt: options.generatedAt
+  });
+  const targetCoverage = nativeSourceCompileTargetCoverage(projectionMatrix, sourceLanguage, target);
+  const targetAdapter = resolveNativeTargetProjectionAdapter({
+    importResult,
+    sourceProjection: projection,
+    sourceLanguage,
+    target,
+    sourcePath: importResult.sourcePath ?? importResult.nativeSource?.sourcePath,
+    parser: importResult.nativeAst?.parser ?? importResult.nativeSource?.parser ?? options.parser
+  }, options);
+  const targetProjection = targetAdapter
+    ? runNativeTargetProjectionAdapter(targetAdapter, {
+      importResult,
+      sourceProjection: projection,
+      sourceLanguage,
+      target,
+      targetPath: options.targetPath,
+      targetCoverage,
+      options: options.targetAdapterOptions ?? {},
+      metadata: {
+        nativeCompileResultId: id,
+        sourceLanguage,
+        target,
+        projectionId: projection.id,
+        ...options.targetAdapterMetadata
+      }
+    })
+    : undefined;
+  const targetLosses = nativeSourceCompileTargetLosses({
+    importResult,
+    projection,
+    targetCoverage,
+    sourceLanguage,
+    target,
+    idPart
+  });
+  const output = targetProjection?.output ?? projection.sourceText;
+  const outputHash = targetProjection?.outputHash ?? projection.outputHash;
+  const outputMode = targetProjection ? targetProjection.outputMode : sameSourceTarget ? projection.mode : 'target-stubs';
+  const compileEvidence = nativeSourceCompileEvidence({
+    id: options.compileEvidenceId ?? `evidence_${idPart}_${idFragment(target)}_native_source_compile`,
+    importResult,
+    projection,
+    targetProjection,
+    targetCoverage,
+    targetLosses,
+    sourceLanguage,
+    target,
+    outputHash,
+    outputMode
+  });
+  const evidence = uniqueByEvidenceId([
+    ...(importResult.evidence ?? []),
+    ...(projection.evidence ?? []),
+    ...(targetProjection?.evidence ?? []),
+    compileEvidence,
+    ...(options.evidence ?? [])
+  ]);
+  const losses = uniqueByLossId([
+    ...(importResult.losses ?? []),
+    ...(projection.losses ?? []),
+    ...(targetProjection?.losses ?? []),
+    ...targetLosses,
+    ...(options.losses ?? [])
+  ]);
+  const lossSummary = summarizeNativeImportLosses(losses, {
+    evidence,
+    parser: importResult.nativeAst?.parser ?? importResult.nativeSource?.parser ?? options.parser,
+    scanKind: 'native-source-compile',
+    semanticStatus: importResult.metadata?.semanticStatus ?? options.semanticStatus
+  });
+  const readiness = classifyNativeImportReadiness(losses, {
+    evidence,
+    parser: importResult.nativeAst?.parser ?? importResult.nativeSource?.parser ?? options.parser,
+    scanKind: 'native-source-compile',
+    semanticStatus: importResult.metadata?.semanticStatus ?? options.semanticStatus
+  });
+  const sourceMaps = options.emitSourceMap === false
+    ? []
+    : nativeSourceCompileSourceMaps({
+      id: options.sourceMapId ?? `source_map_${idFragment(id)}_${idFragment(target)}`,
+      importResult,
+      projection,
+      targetProjection,
+      sourceLanguage,
+      target,
+      targetPath: options.targetPath ?? targetProjection?.targetPath,
+      targetHash: options.targetHash ?? outputHash,
+      output,
+      outputHash,
+      outputMode,
+      evidence,
+      losses,
+      compileResultId: id
+    });
+  const sourceMap = sourceMaps[0];
+  const roundtripEvidence = createNativeRoundtripEvidence(importResult, {
+    id: `evidence_${idPart}_${idFragment(target)}_native_roundtrip`,
+    projection,
+    targetProjection,
+    targetCoverage,
+    sourceMaps,
+    losses,
+    readiness,
+    target,
+    outputMode
+  });
+  const resultEvidence = uniqueByEvidenceId([...evidence, roundtripEvidence]);
+  return {
+    kind: 'frontier.lang.nativeSourceCompileResult',
+    version: 1,
+    id,
+    ok: readiness.readiness !== 'blocked' || options.emitOnBlocked === true,
+    target,
+    language: sourceLanguage,
+    sourcePath: importResult.sourcePath ?? importResult.nativeSource?.sourcePath,
+    output,
+    outputHash,
+    outputMode,
+    sourceMap,
+    sourceMaps,
+    importResult,
+    projection,
+    targetProjection,
+    targetCoverage,
+    projectionMatrix,
+    losses,
+    lossSummary,
+    readiness,
+    evidence: resultEvidence,
+    metadata: {
+      nativeImportId: importResult.id,
+      nativeSourceId: importResult.nativeSource?.id,
+      nativeAstId: importResult.nativeAst?.id ?? importResult.nativeSource?.ast?.id,
+      semanticIndexId: importResult.semanticIndex?.id ?? importResult.universalAst?.semanticIndex?.id,
+      universalAstId: importResult.universalAst?.id,
+      projectionId: projection.id,
+      targetProjectionId: targetProjection?.id,
+      targetProjectionAdapterId: targetProjection?.adapter?.id,
+      sourceMapId: sourceMap?.id,
+      sourceMapIds: sourceMaps.map((record) => record.id).filter(Boolean),
+      sourceMapMappings: sourceMaps.reduce((sum, record) => sum + (record.mappings?.length ?? 0), 0),
+      projectionMode: projection.mode,
+      outputMode,
+      targetPath: sourceMap?.targetPath ?? options.targetPath ?? targetProjection?.targetPath,
+      targetHash: sourceMap?.targetHash ?? options.targetHash ?? outputHash,
+      sourceTarget,
+      sameSourceTarget,
+      targetLossClass: targetCoverage.lossClass,
+      targetReadiness: targetCoverage.readiness,
+      targetSupported: targetCoverage.supported,
+      ...options.metadata,
+      roundtripEvidence: roundtripEvidence.metadata.roundtripEvidence
+    }
+  };
+}

package/dist/internal/index-impl/compileTargetLanguage.js

@@ -0,0 +1,5 @@
+export function compileTargetLanguage(target) {
+  if (!target) return undefined;
+  if (typeof target === 'string') return target;
+  return target.language ?? target.emitLanguage ?? target.target ?? target.name;
+}

package/dist/internal/index-impl/coverageMatrixContext.js

@@ -0,0 +1,20 @@
+import{summarizeImportSourcePreservation}from'../../semantic-import-source-preservation.js';
+import{adapterCoverageSnapshotFromSummary}from'./adapterCoverageSnapshotFromSummary.js';import{effectiveNativeImporterAdapterCoverage}from'./effectiveNativeImporterAdapterCoverage.js';import{FrontierCompileTargets}from'./FrontierCompileTargets.js';import{matchingNativeTargetProjectionAdapter}from'./matchingNativeTargetProjectionAdapter.js';import{nativeImportCategoryForLossKind}from'./nativeImportCategoryForLossKind.js';import{nativeImporterAdapterCapabilityEvidence}from'./nativeImporterAdapterCapabilityEvidence.js';import{normalizeNativeImporterAdapter}from'./normalizeNativeImporterAdapter.js';import{normalizeNativeImporterAdapterObservedCoverage}from'./normalizeNativeImporterAdapterObservedCoverage.js';import{normalizeNativeTargetProjectionAdapter}from'./normalizeNativeTargetProjectionAdapter.js';import{observeNativeImporterSemanticEvidence}from'./observeNativeImporterSemanticEvidence.js';import{safeNativeTargetProjectionAdapterSummary}from'./safeNativeTargetProjectionAdapterSummary.js';import{summarizeNativeImportFeatureEvidence}from'./summarizeNativeImportFeatureEvidence.js';import{summarizeNativeImportLosses}from'./summarizeNativeImportLosses.js';
+export function coverageMatrixContext() {
+  return {
+    compileTargets: FrontierCompileTargets,
+    adapterCoverageSnapshotFromSummary,
+    effectiveNativeImporterAdapterCoverage,
+    matchingNativeTargetProjectionAdapter,
+    nativeImportCategoryForLossKind,
+    nativeImporterAdapterCapabilityEvidence,
+    normalizeNativeImporterAdapter,
+    normalizeNativeImporterAdapterObservedCoverage,
+    normalizeNativeTargetProjectionAdapter,
+    observeNativeImporterSemanticEvidence,
+    safeNativeTargetProjectionAdapterSummary,
+    summarizeImportSourcePreservation,
+    summarizeNativeImportFeatureEvidence,
+    summarizeNativeImportLosses
+  };
+}

package/dist/internal/index-impl/createAstNormalizationContext.js

@@ -0,0 +1,14 @@
+export function createAstNormalizationContext(input, options) {
+  return {
+    input,
+    options,
+    maxNodes: Number.isFinite(options.maxNodes) ? Math.max(1, options.maxNodes) : 5000,
+    counter: 0,
+    objectIds: new WeakMap(),
+    nodes: {},
+    declarations: [],
+    losses: [],
+    rootId: undefined,
+    truncated: false
+  };
+}

package/dist/internal/index-impl/createBabelNativeImporterAdapter.js

@@ -0,0 +1,18 @@
+import{createJavaScriptSyntaxImporterAdapter}from'../../native-js-ts-importers.js';
+import{nativeJavaScriptImporterDeps}from'./nativeJavaScriptImporterDeps.js';
+export function createBabelNativeImporterAdapter(options = {}) {
+  return createJavaScriptSyntaxImporterAdapter({
+    id: 'frontier.babel-native-importer',
+    language: 'javascript',
+    parser: 'babel',
+    supportedExtensions: ['.js', '.mjs', '.cjs', '.jsx', '.ts', '.tsx'],
+    astFormat: 'babel',
+    defaultParserOptions: {
+      errorRecovery: true,
+      ranges: true,
+      sourceType: 'unambiguous',
+      plugins: ['typescript', 'jsx']
+    },
+    ...options
+  }, nativeJavaScriptImporterDeps());
+}

package/dist/internal/index-impl/createCSharpRoslynNativeImporterAdapter.js

@@ -0,0 +1,68 @@
+import{uniqueStrings}from'../../native-import-utils.js';
+import{createNativeImportFromCSharpRoslyn}from'./createNativeImportFromCSharpRoslyn.js';import{csharpGeneratedSourcePath}from'./csharpGeneratedSourcePath.js';import{csharpRoslynRoot}from'./csharpRoslynRoot.js';import{declarationSemanticCoverage}from'./declarationSemanticCoverage.js';import{missingInjectedParserResult}from'./missingInjectedParserResult.js';import{nativeImporterAdapterCoverage}from'./nativeImporterAdapterCoverage.js';import{normalizeParserErrors}from'./normalizeParserErrors.js';import{parseCSharpRoslynSource}from'./parseCSharpRoslynSource.js';
+export function createCSharpRoslynNativeImporterAdapter(options = {}) {
+  return {
+    id: options.id ?? 'frontier.csharp-roslyn-native-importer',
+    language: options.language ?? 'csharp',
+    parser: options.parser ?? 'roslyn',
+    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 Roslyn C# SyntaxTree/SyntaxNode-shaped objects into native AST nodes and declaration-level semantic index records.',
+        'Roslyn syntax imports do not resolve SemanticModel symbols, overloads, nullable flow, source generators, partial types, project references, or analyzer results by themselves; attach host evidence for those claims.'
+      ]
+    }, options.coverage),
+    supportedExtensions: options.supportedExtensions ?? ['.cs'],
+    diagnostics: options.diagnostics,
+    parse(input) {
+      const parsed = input.options?.ast
+        ?? input.options?.nativeAst
+        ?? input.options?.syntaxTree
+        ?? input.options?.tree
+        ?? input.options?.root
+        ?? input.options?.compilationUnit
+        ?? options.ast
+        ?? options.syntaxTree
+        ?? options.tree
+        ?? options.root
+        ?? options.compilationUnit
+        ?? parseCSharpRoslynSource(input, options);
+      const root = csharpRoslynRoot(parsed);
+      if (!root) {
+        return missingInjectedParserResult(input, {
+          parser: options.parser ?? 'roslyn',
+          adapterId: options.id ?? 'frontier.csharp-roslyn-native-importer',
+          message: 'createCSharpRoslynNativeImporterAdapter requires an injected Roslyn SyntaxTree/SyntaxNode object, parserModule.parse function, parse function, or adapterOptions.ast.'
+        });
+      }
+      const parseDiagnostics = normalizeParserErrors(parsed?.errors ?? parsed?.diagnostics ?? parsed?.parseDiagnostics, input, {
+        parser: options.parser ?? 'roslyn'
+      });
+      return createNativeImportFromCSharpRoslyn(root, input, {
+        parser: options.parser ?? 'roslyn',
+        astFormat: 'roslyn-csharp',
+        maxNodes: options.maxNodes,
+        diagnostics: parseDiagnostics,
+        csharpVersion: options.csharpVersion ?? input.options?.csharpVersion ?? parsed?.csharpVersion,
+        languageVersion: options.languageVersion ?? input.options?.languageVersion ?? parsed?.languageVersion,
+        nullableContext: input.options?.nullableContext ?? options.nullableContext ?? parsed?.nullableContext,
+        generated: input.options?.generated ?? options.generated ?? parsed?.generated ?? csharpGeneratedSourcePath(input.sourcePath),
+        projectReferences: input.options?.projectReferences ?? options.projectReferences ?? parsed?.projectReferences,
+        analyzerDiagnostics: input.options?.analyzerDiagnostics ?? options.analyzerDiagnostics ?? parsed?.analyzerDiagnostics,
+        semanticModelEvidence: input.options?.semanticModelEvidence ?? options.semanticModelEvidence ?? parsed?.semanticModelEvidence,
+        sourceGeneratorEvidence: input.options?.sourceGeneratorEvidence ?? options.sourceGeneratorEvidence ?? parsed?.sourceGeneratorEvidence,
+        positionResolver: input.options?.positionResolver ?? options.positionResolver,
+        lineMap: input.options?.lineMap ?? options.lineMap ?? parsed?.lineMap
+      });
+    }
+  };
+}

package/dist/internal/index-impl/createClangAstNativeImporterAdapter.js

@@ -0,0 +1,59 @@
+import{uniqueStrings}from'../../native-import-utils.js';
+import{clangAstRoot}from'./clangAstRoot.js';import{createNativeImportFromClangAst}from'./createNativeImportFromClangAst.js';import{declarationSemanticCoverage}from'./declarationSemanticCoverage.js';import{missingInjectedParserResult}from'./missingInjectedParserResult.js';import{nativeImporterAdapterCoverage}from'./nativeImporterAdapterCoverage.js';import{normalizeParserErrors}from'./normalizeParserErrors.js';import{parseClangAstSource}from'./parseClangAstSource.js';
+export function createClangAstNativeImporterAdapter(options = {}) {
+  return {
+    id: options.id ?? 'frontier.clang-ast-native-importer',
+    language: options.language ?? 'c',
+    parser: options.parser ?? 'clang',
+    version: options.version,
+    capabilities: uniqueStrings(['nativeAst', 'semanticIndex', 'sourceMaps', 'diagnostics', ...(options.capabilities ?? [])]),
+    coverage: nativeImporterAdapterCoverage({
+      exactness: 'exact-parser-ast',
+      exactAst: true,
+      tokens: false,
+      trivia: false,
+      diagnostics: true,
+      sourceRanges: true,
+      generatedRanges: false,
+      semanticCoverage: declarationSemanticCoverage(),
+      notes: [
+        'Normalizes caller-owned Clang -ast-dump=json shaped ASTs into native AST nodes and declaration-level semantic index records.',
+        'Clang JSON ASTs reflect a preprocessed compiler view; compile commands, macros, inactive preprocessor branches, comments/trivia, and full type/reference analysis require host evidence.'
+      ]
+    }, options.coverage),
+    supportedExtensions: options.supportedExtensions ?? ['.c', '.h', '.cc', '.cpp', '.cxx', '.hpp', '.hh'],
+    diagnostics: options.diagnostics,
+    parse(input) {
+      const parsed = input.options?.ast
+        ?? input.options?.nativeAst
+        ?? input.options?.translationUnit
+        ?? input.options?.tu
+        ?? options.ast
+        ?? options.translationUnit
+        ?? options.tu
+        ?? parseClangAstSource(input, options);
+      const root = clangAstRoot(parsed);
+      if (!root) {
+        return missingInjectedParserResult(input, {
+          parser: options.parser ?? 'clang',
+          adapterId: options.id ?? 'frontier.clang-ast-native-importer',
+          message: 'createClangAstNativeImporterAdapter requires an injected Clang JSON AST object, parserModule.parse function, parse function, or adapterOptions.ast.'
+        });
+      }
+      const parseDiagnostics = normalizeParserErrors(parsed?.errors ?? parsed?.diagnostics, input, {
+        parser: options.parser ?? 'clang'
+      });
+      return createNativeImportFromClangAst(root, input, {
+        parser: options.parser ?? 'clang',
+        astFormat: 'clang-ast-json',
+        maxNodes: options.maxNodes,
+        diagnostics: parseDiagnostics,
+        cStandard: options.cStandard ?? input.options?.cStandard ?? parsed?.cStandard,
+        compileFlags: options.compileFlags ?? input.options?.compileFlags ?? parsed?.compileFlags,
+        includeSystemHeaders: options.includeSystemHeaders ?? input.options?.includeSystemHeaders,
+        preprocessorRecords: input.options?.preprocessorRecords ?? options.preprocessorRecords ?? parsed?.preprocessorRecords,
+        includeGraph: input.options?.includeGraph ?? options.includeGraph ?? parsed?.includeGraph
+      });
+    }
+  };
+}

package/dist/internal/index-impl/createEstreeNativeImporterAdapter.js

@@ -0,0 +1,12 @@
+import{createJavaScriptSyntaxImporterAdapter}from'../../native-js-ts-importers.js';
+import{nativeJavaScriptImporterDeps}from'./nativeJavaScriptImporterDeps.js';
+export function createEstreeNativeImporterAdapter(options = {}) {
+  return createJavaScriptSyntaxImporterAdapter({
+    id: 'frontier.estree-native-importer',
+    language: 'javascript',
+    parser: 'estree',
+    supportedExtensions: ['.js', '.mjs', '.cjs', '.jsx'],
+    astFormat: 'estree',
+    ...options
+  }, nativeJavaScriptImporterDeps());
+}

package/dist/internal/index-impl/createGoAstNativeImporterAdapter.js

@@ -0,0 +1,63 @@
+import{uniqueStrings}from'../../native-import-utils.js';
+import{createNativeImportFromGoAst}from'./createNativeImportFromGoAst.js';import{declarationSemanticCoverage}from'./declarationSemanticCoverage.js';import{goAstRoot}from'./goAstRoot.js';import{missingInjectedParserResult}from'./missingInjectedParserResult.js';import{nativeImporterAdapterCoverage}from'./nativeImporterAdapterCoverage.js';import{normalizeParserErrors}from'./normalizeParserErrors.js';import{parseGoAstSource}from'./parseGoAstSource.js';
+export function createGoAstNativeImporterAdapter(options = {}) {
+  return {
+    id: options.id ?? 'frontier.go-ast-native-importer',
+    language: options.language ?? 'go',
+    parser: options.parser ?? 'go/parser',
+    version: options.version,
+    capabilities: uniqueStrings(['nativeAst', 'semanticIndex', 'sourceMaps', 'diagnostics', ...(options.capabilities ?? [])]),
+    coverage: nativeImporterAdapterCoverage({
+      exactness: 'exact-parser-ast',
+      exactAst: true,
+      tokens: false,
+      trivia: false,
+      diagnostics: true,
+      sourceRanges: true,
+      generatedRanges: false,
+      semanticCoverage: declarationSemanticCoverage(),
+      notes: [
+        'Normalizes caller-owned Go go/ast-shaped File or Package trees into native AST nodes and declaration-level semantic index records.',
+        'Go AST imports do not resolve types, imports, build tags, generated code, or control flow by themselves; attach FileSet, go/types, go/packages, and build context evidence for those claims.'
+      ]
+    }, options.coverage),
+    supportedExtensions: options.supportedExtensions ?? ['.go'],
+    diagnostics: options.diagnostics,
+    parse(input) {
+      const parsed = input.options?.ast
+        ?? input.options?.nativeAst
+        ?? input.options?.file
+        ?? input.options?.sourceFile
+        ?? input.options?.package
+        ?? options.ast
+        ?? options.file
+        ?? options.sourceFile
+        ?? options.package
+        ?? parseGoAstSource(input, options);
+      const root = goAstRoot(parsed);
+      if (!root) {
+        return missingInjectedParserResult(input, {
+          parser: options.parser ?? 'go/parser',
+          adapterId: options.id ?? 'frontier.go-ast-native-importer',
+          message: 'createGoAstNativeImporterAdapter requires an injected Go ast.File/Package-shaped object, parserModule.parse function, parse function, or adapterOptions.ast.'
+        });
+      }
+      const parseDiagnostics = normalizeParserErrors(parsed?.errors ?? parsed?.diagnostics, input, {
+        parser: options.parser ?? 'go/parser'
+      });
+      return createNativeImportFromGoAst(root, input, {
+        parser: options.parser ?? 'go/parser',
+        astFormat: 'go-ast',
+        maxNodes: options.maxNodes,
+        diagnostics: parseDiagnostics,
+        goVersion: options.goVersion ?? input.options?.goVersion ?? parsed?.goVersion,
+        packageName: options.packageName ?? input.options?.packageName ?? parsed?.packageName ?? root?.Name?.Name ?? root?.Name,
+        fileSet: input.options?.fileSet ?? input.options?.fset ?? options.fileSet ?? options.fset ?? parsed?.fileSet ?? parsed?.fset,
+        includeComments: options.includeComments ?? input.options?.includeComments,
+        buildTags: input.options?.buildTags ?? options.buildTags ?? parsed?.buildTags,
+        generated: input.options?.generated ?? options.generated ?? parsed?.generated,
+        typeEvidence: input.options?.typeEvidence ?? options.typeEvidence ?? parsed?.typeEvidence
+      });
+    }
+  };
+}