@shapeshift-labs/frontier-lang-compiler 0.2.19 → 0.2.21

package/README.md

@@ -93,11 +93,12 @@ console.log(pythonProjection.sourceProjection.stubs.lossClass); // "nativeSource
 console.log(pythonProjection.targets.find((entry) => entry.target === 'rust').lossClass); // "missingAdapter"
 ```
 
-The projection target matrix separates four runtime/API classes:
+The projection target matrix separates five runtime/API classes:
 
 - `exactSourceProjection`: exact source can be emitted when the import carries matching source text or source-preservation evidence.
 - `nativeSourceStubs`: declaration stubs can be emitted, but bodies, resolved types, and executable semantics are review-required.
 - `unsupportedTargetFeatures`: a target slot exists, but the source profile or import evidence declares features such as macros, preprocessors, dynamic runtime behavior, generated code, unsupported syntax, or unresolved inference that this facade cannot prove lossless.
+- `targetAdapterProjection`: a host-owned native-to-target adapter is present and produced target output with its own evidence/readiness.
 - `missingAdapter`: no native-to-target projection adapter is declared; preserve or stub the original source language instead, or inject host-owned parser/semantic adapter evidence.
 
 Preserve exact native source text, token/trivia hashes, comments, whitespace, and source directives as evidence. This does not claim full semantic understanding; it keeps round-trip material available while exact parser adapters catch up:
@@ -182,15 +183,55 @@ console.log(compiledJs.readiness.readiness); // scanner imports can still be "ne
 
 const rustCandidate = compileNativeSource(compiledJs.importResult, {
   target: 'rust',
+  targetPath: 'dist/runtime.rs',
   emitOnBlocked: true
 });
 
 console.log(rustCandidate.outputMode); // "target-stubs"
 console.log(rustCandidate.targetCoverage.lossClass); // "missingAdapter" without a JS-to-Rust adapter
 console.log(rustCandidate.ok); // true only because emitOnBlocked requested code anyway
+console.log(rustCandidate.sourceMap.targetPath); // "dist/runtime.rs"
+console.log(rustCandidate.sourceMap.mappings[0]?.semanticSymbolId); // generated span -> source symbol
 ```
 
-`compileNativeSource` returns the import result, projection, target loss matrix cell, combined losses, readiness, evidence, and output hash. Admission queues should treat `ok` as "code was emitted", not as merge approval; `readiness` and `targetCoverage` carry the merge signal.
+`compileNativeSource` returns the import result, projection, target loss matrix cell, combined losses, readiness, evidence, output hash, and generated-output source maps. Same-language preserved output uses exact source mappings when the hash matches; generated stubs use declaration-level spans; adapter output uses adapter-supplied maps when present and otherwise gets an estimated fallback. Admission queues should treat `ok` as "code was emitted", not as merge approval; `readiness`, `targetCoverage`, and source-map precision carry the merge signal.
+
+Provide a target projection adapter when the host owns real native-to-target translation semantics:
+
+```js
+const jsToRustAdapter = {
+  id: 'app-js-to-rust',
+  sourceLanguage: 'javascript',
+  target: 'rust',
+  coverage: {
+    readiness: 'needs-review',
+    handledLossKinds: ['dynamicRuntime']
+  },
+  project(input) {
+    return {
+      output: `// projected from ${input.sourceLanguage}\npub fn add_todo() {}\n`,
+      readiness: 'needs-review',
+      evidence: [{
+        id: 'evidence_app_js_to_rust',
+        kind: 'projection',
+        status: 'passed',
+        summary: 'Host JS-to-Rust adapter emitted declaration-compatible Rust.'
+      }]
+    };
+  }
+};
+
+const rustWithAdapter = compileNativeSource(compiledJs.importResult, {
+  target: 'rust',
+  targetPath: 'dist/runtime.rs',
+  targetAdapters: [jsToRustAdapter]
+});
+
+console.log(rustWithAdapter.outputMode); // "target-adapter"
+console.log(rustWithAdapter.targetCoverage.lossClass); // "targetAdapterProjection"
+console.log(rustWithAdapter.targetProjection.adapter.id); // "app-js-to-rust"
+console.log(rustWithAdapter.sourceMaps.length); // adapter maps or compiler fallback map
+```
 
 Project a native import back to source. Exact source is preserved when the import carries matching source-preservation evidence or when supplied text matches the import hash; otherwise the compiler emits declaration stubs with review-required loss evidence:
 

package/bench/smoke.mjs

@@ -100,7 +100,31 @@ const nativeCompiles = nativeImportResults.map((imported, index) => compileNativ
 }));
 const nativeCompileDurationMs = performance.now() - nativeCompileStart;
 const nativeCompileBytes = nativeCompiles.reduce((sum, result) => sum + result.output.length, 0);
+const nativeCompileSourceMaps = nativeCompiles.reduce((sum, result) => sum + result.sourceMaps.length, 0);
+const nativeCompileSourceMapMappings = nativeCompiles.reduce((sum, result) => sum + result.sourceMaps.reduce((mapSum, sourceMap) => mapSum + sourceMap.mappings.length, 0), 0);
 const nativeCompileBlocked = nativeCompiles.filter((result) => result.readiness.readiness === 'blocked').length;
+const nativeTargetAdapterStart = performance.now();
+const nativeTargetAdapterCompiles = nativeImportResults.slice(0, 25).map((imported, index) => {
+  const target = index % 2 === 0 ? 'rust' : 'python';
+  return compileNativeSource(imported, {
+    target,
+    targetAdapters: [{
+      id: `bench-target-adapter-${index}`,
+      sourceLanguage: imported.language,
+      target,
+      coverage: {
+        readiness: 'needs-review',
+        handledLossKinds: ['dynamicRuntime', 'dynamicDispatch', 'typeInference', 'overloadResolution']
+      },
+      project() {
+        return { output: `// bench target adapter ${index}\n`, readiness: 'needs-review' };
+      }
+    }]
+  });
+});
+const nativeTargetAdapterDurationMs = performance.now() - nativeTargetAdapterStart;
+const nativeTargetAdapterBytes = nativeTargetAdapterCompiles.reduce((sum, result) => sum + result.output.length, 0);
+const nativeTargetAdapterSourceMaps = nativeTargetAdapterCompiles.reduce((sum, result) => sum + result.sourceMaps.length, 0);
 
 console.log(JSON.stringify({
   compiles: 250,
@@ -131,6 +155,12 @@ console.log(JSON.stringify({
   projectionDurationMs: Number(projectionDurationMs.toFixed(2)),
   nativeCompiles: nativeCompiles.length,
   nativeCompileBytes,
+  nativeCompileSourceMaps,
+  nativeCompileSourceMapMappings,
   nativeCompileBlocked,
-  nativeCompileDurationMs: Number(nativeCompileDurationMs.toFixed(2))
+  nativeCompileDurationMs: Number(nativeCompileDurationMs.toFixed(2)),
+  nativeTargetAdapterCompiles: nativeTargetAdapterCompiles.length,
+  nativeTargetAdapterBytes,
+  nativeTargetAdapterSourceMaps,
+  nativeTargetAdapterDurationMs: Number(nativeTargetAdapterDurationMs.toFixed(2))
 }));

package/dist/index.d.ts

@@ -271,6 +271,7 @@ export type ProjectionTargetLossClass =
   | 'exactSourceProjection'
   | 'nativeSourceStubs'
   | 'unsupportedTargetFeatures'
+  | 'targetAdapterProjection'
   | 'missingAdapter'
   | string;
 
@@ -299,6 +300,9 @@ export interface ProjectionTargetCoverageEntry {
   readonly categories: readonly NativeImportTaxonomyKind[];
   readonly reason: string;
   readonly adapter?: string;
+  readonly adapterKind?: 'importer' | 'targetProjection' | string;
+  readonly adapterVersion?: string;
+  readonly adapterCoverage?: NativeTargetProjectionAdapterCoverageInput;
   readonly notes: readonly string[];
 }
 
@@ -339,6 +343,7 @@ export interface ProjectionTargetLossMatrix {
     readonly sourceProjectionByLossClass: Readonly<Record<ProjectionTargetLossClass, number>>;
     readonly exactSourceProjection: number;
     readonly nativeSourceStubs: number;
+    readonly targetAdapterProjection: number;
     readonly unsupportedTargetFeatures: number;
     readonly missingAdapters: number;
   };
@@ -353,6 +358,7 @@ export interface ProjectionTargetLossMatrixOptions {
   readonly languages?: readonly NativeImportLanguageProfile[];
   readonly imports?: readonly NativeSourceImportResult[];
   readonly adapters?: readonly NativeImporterAdapter[];
+  readonly targetAdapters?: readonly NativeTargetProjectionAdapter[];
   readonly targets?: readonly (FrontierCompileTarget | string)[];
   readonly generatedAt?: number;
 }
@@ -1124,6 +1130,94 @@ export type NativeImporterAdapterImportResult = NativeSourceImportResult & {
   readonly diagnostics: readonly NativeImporterAdapterDiagnostic[];
 };
 
+export interface NativeTargetProjectionAdapterCoverageInput {
+  readonly readiness?: SemanticMergeReadiness;
+  readonly lossKinds?: readonly NativeImportKnownLossKind[];
+  readonly handledLossKinds?: readonly NativeImportKnownLossKind[];
+  readonly sourceMapPrecision?: SourceMapMappingRecord['precision'] | 'none' | string;
+  readonly semanticCoverage?: Partial<NativeImporterAdapterSemanticCoverage>;
+  readonly notes?: readonly string[];
+}
+
+export interface NativeTargetProjectionAdapterSummary {
+  readonly id: string;
+  readonly sourceLanguage: FrontierSourceLanguage | string;
+  readonly target: FrontierCompileTarget | string;
+  readonly version?: string;
+  readonly capabilities: readonly string[];
+  readonly supportedParsers: readonly string[];
+  readonly supportedExtensions: readonly string[];
+  readonly coverage: Required<Pick<NativeTargetProjectionAdapterCoverageInput, 'readiness' | 'lossKinds' | 'handledLossKinds' | 'notes'>> & NativeTargetProjectionAdapterCoverageInput;
+  readonly diagnostics: readonly NativeImporterAdapterDiagnostic[];
+}
+
+export interface NativeTargetProjectionAdapterInput {
+  readonly importResult: NativeSourceImportResult;
+  readonly sourceProjection: NativeSourceProjectionResult;
+  readonly sourceLanguage: FrontierSourceLanguage | string;
+  readonly target: FrontierCompileTarget | string;
+  readonly targetPath?: string;
+  readonly targetCoverage?: ProjectionTargetCoverageEntry;
+  readonly options: Record<string, unknown>;
+  readonly metadata: Record<string, unknown>;
+}
+
+export interface NativeTargetProjectionAdapterResult {
+  readonly id?: string;
+  readonly output?: string;
+  readonly outputHash?: string;
+  readonly sourceMaps?: readonly SourceMapRecord[];
+  readonly losses?: readonly NativeAstLossRecord[];
+  readonly evidence?: readonly EvidenceRecord[];
+  readonly diagnostics?: readonly NativeImporterAdapterDiagnostic[];
+  readonly readiness?: SemanticMergeReadiness;
+  readonly metadata?: Record<string, unknown>;
+}
+
+export interface NativeTargetProjectionAdapter {
+  readonly id: string;
+  readonly sourceLanguage?: FrontierSourceLanguage | string;
+  readonly language?: FrontierSourceLanguage | string;
+  readonly target: FrontierCompileTarget | string;
+  readonly targetLanguage?: FrontierCompileTarget | string;
+  readonly version?: string;
+  readonly capabilities?: readonly string[];
+  readonly supportedParsers?: readonly string[];
+  readonly supportedExtensions?: readonly string[];
+  readonly coverage?: NativeTargetProjectionAdapterCoverageInput;
+  readonly diagnostics?: readonly NativeImporterAdapterDiagnostic[];
+  readonly project: (input: NativeTargetProjectionAdapterInput) => NativeTargetProjectionAdapterResult;
+}
+
+export interface NativeTargetProjectionAdapterResolverInput {
+  readonly importResult: NativeSourceImportResult;
+  readonly sourceProjection: NativeSourceProjectionResult;
+  readonly sourceLanguage: FrontierSourceLanguage | string;
+  readonly target: FrontierCompileTarget | string;
+  readonly sourcePath?: string;
+  readonly parser?: string;
+}
+
+export interface NativeTargetProjectionResult {
+  readonly kind: 'frontier.lang.nativeTargetProjection';
+  readonly version: 1;
+  readonly id: string;
+  readonly sourceLanguage: FrontierSourceLanguage | string;
+  readonly target: FrontierCompileTarget | string;
+  readonly targetPath?: string;
+  readonly adapter: NativeTargetProjectionAdapterSummary;
+  readonly output: string;
+  readonly outputHash: string;
+  readonly outputMode: 'target-adapter';
+  readonly sourceMaps: readonly SourceMapRecord[];
+  readonly losses: readonly NativeAstLossRecord[];
+  readonly lossSummary: NativeImportLossSummary;
+  readonly readiness: NativeImportReadinessClassification;
+  readonly evidence: readonly EvidenceRecord[];
+  readonly diagnostics: readonly NativeImporterAdapterDiagnostic[];
+  readonly metadata: Record<string, unknown>;
+}
+
 export interface NativeProjectSourceInput extends ImportNativeSourceOptions {
   readonly adapter?: NativeImporterAdapter | string;
   readonly adapterOptions?: Record<string, unknown>;
@@ -1221,14 +1315,26 @@ export interface NativeSourceProjectionResult {
   readonly metadata: Record<string, unknown>;
 }
 
-export type NativeSourceCompileOutputMode = NativeSourceProjectionMode | 'target-stubs';
+export type NativeSourceCompileOutputMode = NativeSourceProjectionMode | 'target-stubs' | 'target-adapter';
 
 export interface CompileNativeSourceOptions extends ProjectNativeImportToSourceOptions {
   readonly target?: FrontierCompileTarget | string;
   readonly adapters?: readonly NativeImporterAdapter[];
+  readonly targetAdapters?: readonly NativeTargetProjectionAdapter[];
+  readonly targetAdapter?: NativeTargetProjectionAdapter | string;
+  readonly targetAdapterResolver?: (
+    input: NativeTargetProjectionAdapterResolverInput,
+    adapters: readonly NativeTargetProjectionAdapter[]
+  ) => NativeTargetProjectionAdapter | undefined;
+  readonly targetAdapterOptions?: Record<string, unknown>;
+  readonly targetAdapterMetadata?: Record<string, unknown>;
   readonly languages?: readonly NativeImportLanguageProfile[];
   readonly generatedAt?: number;
   readonly emitOnBlocked?: boolean;
+  readonly emitSourceMap?: boolean;
+  readonly targetPath?: string;
+  readonly targetHash?: string;
+  readonly sourceMapId?: string;
   readonly projectionId?: string;
   readonly projectionEvidenceId?: string;
   readonly compileEvidenceId?: string;
@@ -1247,8 +1353,11 @@ export interface NativeSourceCompileResult {
   readonly output: string;
   readonly outputHash: string;
   readonly outputMode: NativeSourceCompileOutputMode;
+  readonly sourceMap?: SourceMapRecord;
+  readonly sourceMaps: readonly SourceMapRecord[];
   readonly importResult: NativeSourceImportResult;
   readonly projection: NativeSourceProjectionResult;
+  readonly targetProjection?: NativeTargetProjectionResult;
   readonly targetCoverage: ProjectionTargetCoverageEntry;
   readonly projectionMatrix: ProjectionTargetLossMatrix;
   readonly losses: readonly NativeAstLossRecord[];
@@ -1342,6 +1451,7 @@ export declare function createBabelNativeImporterAdapter(options?: JavaScriptNat
 export declare function createTypeScriptCompilerNativeImporterAdapter(options?: TypeScriptCompilerNativeImporterAdapterOptions): NativeImporterAdapter;
 export declare function createTreeSitterNativeImporterAdapter(options?: TreeSitterNativeImporterAdapterOptions): NativeImporterAdapter;
 export declare function runNativeImporterAdapter(adapter: NativeImporterAdapter, input: RunNativeImporterAdapterOptions): Promise<NativeImporterAdapterImportResult>;
+export declare function runNativeTargetProjectionAdapter(adapter: NativeTargetProjectionAdapter, input: NativeTargetProjectionAdapterInput): NativeTargetProjectionResult;
 export declare function projectNativeImportToSource(importResult: NativeSourceImportResult | NativeProjectImportResult, options?: ProjectNativeImportToSourceOptions): NativeSourceProjectionResult;
 export declare function importNativeSource(input: ImportNativeSourceOptions): NativeSourceImportResult;
 export declare function diffNativeSources(input: DiffNativeSourcesOptions): NativeSourceChangeSet;

package/dist/index.js

@@ -151,6 +151,7 @@ export const ProjectionTargetLossClasses = Object.freeze([
   'exactSourceProjection',
   'nativeSourceStubs',
   'unsupportedTargetFeatures',
+  'targetAdapterProjection',
   'missingAdapter'
 ]);
 
@@ -277,11 +278,38 @@ export function compileNativeSource(input, options = {}) {
   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,
@@ -290,26 +318,32 @@ export function compileNativeSource(input, options = {}) {
     target,
     idPart
   });
-  const outputMode = sameSourceTarget ? projection.mode : 'target-stubs';
+  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 ?? [])
   ]);
@@ -325,6 +359,25 @@ export function compileNativeSource(input, options = {}) {
     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];
   return {
     kind: 'frontier.lang.nativeSourceCompileResult',
     version: 1,
@@ -333,11 +386,14 @@ export function compileNativeSource(input, options = {}) {
     target,
     language: sourceLanguage,
     sourcePath: importResult.sourcePath ?? importResult.nativeSource?.sourcePath,
-    output: projection.sourceText,
-    outputHash: projection.outputHash,
+    output,
+    outputHash,
     outputMode,
+    sourceMap,
+    sourceMaps,
     importResult,
     projection,
+    targetProjection,
     targetCoverage,
     projectionMatrix,
     losses,
@@ -351,8 +407,15 @@ export function compileNativeSource(input, options = {}) {
       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,
@@ -657,11 +720,13 @@ export function createNativeImportCoverageMatrix(input = {}) {
 export function createProjectionTargetLossMatrix(input = {}) {
   const imports = input.imports ?? [];
   const adapters = input.adapters ?? [];
-  const profiles = mergeNativeImportProfiles(input.languages ?? NativeImportLanguageProfiles, imports, adapters);
+  const targetAdapters = input.targetAdapters ?? [];
+  const profiles = mergeNativeImportProfiles(input.languages ?? NativeImportLanguageProfiles, imports, adapters, targetAdapters);
   const targets = normalizeProjectionMatrixTargets(input.targets ?? FrontierCompileTargets);
   const languages = profiles.map((profile) => projectionTargetCoverageForProfile(profile, {
     imports,
     adapters,
+    targetAdapters,
     targets
   }));
   const summary = projectionTargetLossMatrixSummary(languages);
@@ -674,7 +739,7 @@ export function createProjectionTargetLossMatrix(input = {}) {
     metadata: {
       compileTargets: targets,
       lossClasses: [...ProjectionTargetLossClasses],
-      note: 'Projection target coverage separates exact source preservation, declaration stubs, known unsupported target features, and missing native-to-target adapters.'
+      note: 'Projection target coverage separates exact source preservation, declaration stubs, host-owned target adapters, known unsupported target features, and missing native-to-target adapters.'
     }
   };
 }
@@ -1159,6 +1224,120 @@ export async function runNativeImporterAdapter(adapter, input = {}) {
   };
 }
 
+export function runNativeTargetProjectionAdapter(adapter, input = {}) {
+  const summary = normalizeNativeTargetProjectionAdapter(adapter);
+  const sourceLanguage = normalizeNativeLanguageId(input.sourceLanguage ?? summary.sourceLanguage);
+  const target = normalizeProjectionMatrixTargets([input.target ?? summary.target])[0] ?? summary.target;
+  const diagnosticContext = {
+    sourcePath: input.importResult?.sourcePath ?? input.importResult?.nativeSource?.sourcePath,
+    sourceHash: input.importResult?.sourceHash ?? input.importResult?.nativeSource?.sourceHash,
+    language: sourceLanguage,
+    parser: `target:${target}`,
+    parserVersion: summary.version
+  };
+  const projectInput = {
+    importResult: input.importResult,
+    sourceProjection: input.sourceProjection,
+    sourceLanguage,
+    target,
+    targetPath: input.targetPath,
+    targetCoverage: input.targetCoverage,
+    options: input.options ?? {},
+    metadata: input.metadata ?? {}
+  };
+  let projected;
+  let thrownDiagnostic;
+  try {
+    projected = adapter.project(projectInput) ?? {};
+  } catch (error) {
+    thrownDiagnostic = {
+      severity: 'error',
+      code: 'targetAdapter.project.threw',
+      phase: 'emit',
+      kind: 'targetProjectionLoss',
+      message: error instanceof Error ? error.message : String(error),
+      metadata: {
+        errorName: error instanceof Error ? error.name : undefined
+      }
+    };
+    projected = {};
+  }
+  const diagnostics = [
+    ...normalizeAdapterDiagnostics(summary.diagnostics, summary, diagnosticContext, 'target-adapter'),
+    ...(thrownDiagnostic ? normalizeAdapterDiagnostics([thrownDiagnostic], summary, diagnosticContext, 'throw') : []),
+    ...normalizeAdapterDiagnostics(projected.diagnostics, summary, diagnosticContext, 'project')
+  ];
+  const output = typeof projected.output === 'string' ? projected.output : input.sourceProjection?.sourceText ?? '';
+  const outputHash = projected.outputHash ?? hashSemanticValue(output);
+  const adapterEvidence = nativeTargetProjectionAdapterEvidence(summary, diagnostics, {
+    ...diagnosticContext,
+    sourceLanguage,
+    target,
+    outputHash,
+    targetPath: input.targetPath
+  });
+  const evidence = uniqueByEvidenceId([
+    ...(projected.evidence ?? []),
+    adapterEvidence
+  ]);
+  const losses = uniqueByLossId([
+    ...(projected.losses ?? []),
+    ...diagnostics.map((diagnostic, index) => nativeTargetProjectionDiagnosticToLoss(diagnostic, index, summary, {
+      ...diagnosticContext,
+      sourceLanguage,
+      target
+    }))
+  ]);
+  const lossSummary = summarizeNativeImportLosses(losses, {
+    evidence,
+    parser: diagnosticContext.parser,
+    scanKind: 'native-target-projection',
+    semanticStatus: input.importResult?.metadata?.semanticStatus
+  });
+  const classifiedReadiness = classifyNativeImportReadiness(losses, {
+    evidence,
+    parser: diagnosticContext.parser,
+    scanKind: 'native-target-projection',
+    semanticStatus: input.importResult?.metadata?.semanticStatus
+  });
+  const declaredReadiness = normalizeSemanticMergeReadiness(projected.readiness ?? summary.coverage.readiness);
+  const readiness = declaredReadiness
+    ? {
+      ...classifiedReadiness,
+      readiness: maxSemanticMergeReadiness(classifiedReadiness.readiness, declaredReadiness),
+      reasons: uniqueStrings([
+        ...classifiedReadiness.reasons,
+        ...(declaredReadiness === classifiedReadiness.readiness ? [] : [`Target adapter declared readiness ${declaredReadiness}.`])
+      ])
+    }
+    : classifiedReadiness;
+  return {
+    kind: 'frontier.lang.nativeTargetProjection',
+    version: 1,
+    id: projected.id ?? `native_target_projection_${idFragment(summary.id)}_${idFragment(sourceLanguage)}_${idFragment(target)}`,
+    sourceLanguage,
+    target,
+    targetPath: input.targetPath,
+    adapter: summary,
+    output,
+    outputHash,
+    outputMode: 'target-adapter',
+    sourceMaps: projected.sourceMaps ?? [],
+    losses,
+    lossSummary,
+    readiness,
+    evidence,
+    diagnostics: diagnostics.map(serializableDiagnostic),
+    metadata: {
+      importId: input.importResult?.id,
+      projectionId: input.sourceProjection?.id,
+      targetCoverageLossClass: input.targetCoverage?.lossClass,
+      targetCoverageReadiness: input.targetCoverage?.readiness,
+      ...projected.metadata
+    }
+  };
+}
+
 export function projectNativeImportToSource(importResult, options = {}) {
   if (!importResult || typeof importResult !== 'object') {
     throw new Error('projectNativeImportToSource requires a native import result');
@@ -3950,6 +4129,7 @@ function projectionTargetCoverageForProfile(profile, context) {
   const aliases = new Set([profile.language, ...(profile.aliases ?? [])].map(normalizeNativeLanguageId).filter(Boolean));
   const matchingImports = (context.imports ?? []).filter((imported) => aliases.has(normalizeNativeLanguageId(imported?.language ?? imported?.nativeAst?.language)));
   const matchingAdapters = (context.adapters ?? []).filter((adapter) => aliases.has(normalizeNativeLanguageId(adapter?.language)));
+  const matchingTargetAdapters = (context.targetAdapters ?? []).filter((adapter) => aliases.has(normalizeNativeLanguageId(adapter?.sourceLanguage ?? adapter?.language)));
   const importedLossKinds = uniqueStrings(matchingImports.flatMap((imported) => (imported?.losses ?? []).map((loss) => loss.kind).filter(Boolean)));
   const knownLossKinds = uniqueStrings([...(profile.knownLossKinds ?? []), ...importedLossKinds]);
   const parserAdapters = uniqueStrings([
@@ -3960,6 +4140,7 @@ function projectionTargetCoverageForProfile(profile, context) {
   const targets = (context.targets ?? FrontierCompileTargets).map((target) => projectionTargetCoverageEntry(profile, target, {
     matchingImports,
     matchingAdapters,
+    matchingTargetAdapters,
     knownLossKinds
   }));
   return {
@@ -4037,8 +4218,14 @@ function projectionTargetCoverageEntry(profile, target, context) {
   const normalizedTarget = normalizeProjectionMatrixTargets([target])[0] ?? String(target);
   const declaredTargets = new Set(normalizeProjectionMatrixTargets(profile.projectionTargets ?? []));
   const adapterTargets = new Set((context.matchingAdapters ?? []).flatMap(adapterProjectionTargets));
+  const targetAdapter = matchingNativeTargetProjectionAdapter({
+    sourceLanguage: profile.language,
+    target: normalizedTarget,
+    sourcePath: context.matchingImports?.[0]?.sourcePath ?? context.matchingImports?.[0]?.nativeSource?.sourcePath
+  }, context.matchingTargetAdapters ?? []);
+  const targetAdapterSummary = targetAdapter ? normalizeNativeTargetProjectionAdapter(targetAdapter) : undefined;
   const sameSourceTarget = nativeLanguageCompileTarget(profile.language, profile.aliases) === normalizedTarget;
-  const hasProjectionAdapter = declaredTargets.has(normalizedTarget) || adapterTargets.has(normalizedTarget);
+  const hasProjectionAdapter = Boolean(targetAdapterSummary) || declaredTargets.has(normalizedTarget) || adapterTargets.has(normalizedTarget);
   if (!hasProjectionAdapter) {
     return {
       target: normalizedTarget,
@@ -4054,6 +4241,48 @@ function projectionTargetCoverageEntry(profile, target, context) {
   }
 
   const featureLossKinds = projectionUnsupportedFeatureLossKinds(context.knownLossKinds);
+  if (targetAdapterSummary) {
+    const handledLossKinds = new Set(targetAdapterSummary.coverage.handledLossKinds ?? []);
+    const unhandledFeatureLossKinds = featureLossKinds.filter((kind) => !handledLossKinds.has(kind));
+    if (unhandledFeatureLossKinds.length) {
+      return {
+        target: normalizedTarget,
+        lossClass: 'unsupportedTargetFeatures',
+        supported: true,
+        readiness: 'needs-review',
+        lossKinds: unhandledFeatureLossKinds,
+        categories: uniqueStrings(unhandledFeatureLossKinds.map(nativeImportCategoryForLossKind)),
+        reason: `${profile.language} has target adapter ${targetAdapterSummary.id}, but source feature losses remain unhandled for ${normalizedTarget}: ${unhandledFeatureLossKinds.join(', ')}.`,
+        adapter: targetAdapterSummary.id,
+        adapterKind: 'targetProjection',
+        adapterVersion: targetAdapterSummary.version,
+        adapterCoverage: targetAdapterSummary.coverage,
+        notes: uniqueStrings([
+          ...(targetAdapterSummary.coverage.notes ?? []),
+          'Adapter output is available, but merge readiness still requires review for unhandled source-language feature losses.'
+        ])
+      };
+    }
+    const adapterLossKinds = uniqueStrings(targetAdapterSummary.coverage.lossKinds ?? []);
+    return {
+      target: normalizedTarget,
+      lossClass: 'targetAdapterProjection',
+      supported: true,
+      readiness: targetAdapterSummary.coverage.readiness ?? 'needs-review',
+      lossKinds: adapterLossKinds,
+      categories: uniqueStrings(adapterLossKinds.map(nativeImportCategoryForLossKind)),
+      reason: `${profile.language} can project to ${normalizedTarget} through host target adapter ${targetAdapterSummary.id}.`,
+      adapter: targetAdapterSummary.id,
+      adapterKind: 'targetProjection',
+      adapterVersion: targetAdapterSummary.version,
+      adapterCoverage: targetAdapterSummary.coverage,
+      notes: uniqueStrings([
+        ...(targetAdapterSummary.coverage.notes ?? []),
+        'The host adapter owns native-to-target translation semantics and must provide evidence for merge admission.'
+      ])
+    };
+  }
+
   if (featureLossKinds.length) {
     return {
       target: normalizedTarget,
@@ -4115,6 +4344,7 @@ function projectionTargetLossMatrixSummary(languages) {
     sourceProjectionByLossClass,
     exactSourceProjection: (sourceProjectionByLossClass.exactSourceProjection ?? 0) + (byLossClass.exactSourceProjection ?? 0),
     nativeSourceStubs: (sourceProjectionByLossClass.nativeSourceStubs ?? 0) + (byLossClass.nativeSourceStubs ?? 0),
+    targetAdapterProjection: byLossClass.targetAdapterProjection ?? 0,
     unsupportedTargetFeatures: byLossClass.unsupportedTargetFeatures ?? 0,
     missingAdapters: byLossClass.missingAdapter ?? 0
   };
@@ -4324,9 +4554,11 @@ function nativeSourceCompileEvidence(input) {
     metadata: {
       importId: input.importResult.id,
       projectionId: input.projection.id,
+      targetProjectionId: input.targetProjection?.id,
+      targetProjectionAdapterId: input.targetProjection?.adapter?.id,
       sourceLanguage: input.sourceLanguage,
       target: input.target,
-      outputHash: input.projection.outputHash,
+      outputHash: input.outputHash ?? input.projection.outputHash,
       outputMode: input.outputMode,
       projectionMode: input.projection.mode,
       targetLossClass: input.targetCoverage.lossClass,
@@ -4338,6 +4570,251 @@ function nativeSourceCompileEvidence(input) {
   };
 }
 
+function nativeSourceCompileSourceMaps(input) {
+  const adapterSourceMaps = input.targetProjection?.sourceMaps ?? [];
+  if (adapterSourceMaps.length) return adapterSourceMaps;
+  const targetPath = nativeSourceCompileTargetPath(input);
+  const targetHash = input.targetHash ?? input.outputHash;
+  const target = nativeSourceCompileMapTarget(input, targetPath);
+  const mappings = input.projection.mode === 'preserved-source'
+    ? nativeSourceCompilePreservedMappings({ ...input, targetPath, targetHash, target })
+    : nativeSourceCompileDeclarationMappings({ ...input, targetPath, targetHash, target });
+  const resolvedMappings = mappings.length
+    ? mappings
+    : [nativeSourceCompileFileMapping({ ...input, targetPath, targetHash, target })];
+  return [createSourceMapRecord({
+    id: input.id,
+    sourcePath: input.importResult.sourcePath ?? input.importResult.nativeSource?.sourcePath,
+    sourceHash: input.importResult.nativeSource?.sourceHash ?? input.importResult.nativeAst?.sourceHash ?? input.importResult.sourceHash,
+    target,
+    targetPath: targetPath ?? commonGeneratedTargetPath(resolvedMappings),
+    targetHash,
+    semanticIndexId: input.importResult.semanticIndex?.id ?? input.importResult.universalAst?.semanticIndex?.id,
+    universalAstId: input.importResult.universalAst?.id,
+    nativeAstId: input.importResult.nativeAst?.id ?? input.importResult.nativeSource?.ast?.id,
+    nativeSourceId: input.importResult.nativeSource?.id,
+    mappings: resolvedMappings,
+    evidence: input.evidence ?? [],
+    metadata: {
+      compileResultId: input.compileResultId,
+      importId: input.importResult.id,
+      projectionId: input.projection.id,
+      targetProjectionId: input.targetProjection?.id,
+      targetProjectionAdapterId: input.targetProjection?.adapter?.id,
+      sourceLanguage: input.sourceLanguage,
+      target: input.target,
+      outputMode: input.outputMode,
+      outputHash: input.outputHash,
+      generatedBy: 'compileNativeSource'
+    }
+  })];
+}
+
+function nativeSourceCompilePreservedMappings(input) {
+  const sourceMaps = input.importResult.sourceMaps ?? input.importResult.universalAst?.sourceMaps ?? [];
+  const sourceHash = input.importResult.nativeSource?.sourceHash ?? input.importResult.nativeAst?.sourceHash ?? input.importResult.sourceHash;
+  const exact = input.projection.mode === 'preserved-source' && (!input.projection.sourceHash || input.outputHash === input.projection.sourceHash);
+  const usedIds = new Set();
+  return sourceMaps
+    .flatMap((sourceMap) => sourceMap?.mappings ?? [])
+    .filter((mapping) => mapping?.sourceSpan)
+    .map((mapping, index) => ({
+      id: reserveUniqueId(`compile_map_${idFragment(mapping.id ?? mapping.semanticSymbolId ?? mapping.nativeAstNodeId ?? index + 1)}`, usedIds),
+      nativeSourceId: mapping.nativeSourceId ?? input.importResult.nativeSource?.id,
+      nativeAstNodeId: mapping.nativeAstNodeId,
+      semanticSymbolId: mapping.semanticSymbolId,
+      semanticOccurrenceId: mapping.semanticOccurrenceId,
+      semanticNodeId: mapping.semanticNodeId,
+      mergeCandidateId: mapping.mergeCandidateId,
+      sourceSpan: {
+        ...mapping.sourceSpan,
+        sourceId: mapping.sourceSpan.sourceId ?? sourceHash,
+        path: mapping.sourceSpan.path ?? input.importResult.sourcePath ?? input.importResult.nativeSource?.sourcePath
+      },
+      generatedSpan: nativeSourceCompileGeneratedSpanFromSource(mapping.sourceSpan, input, mapping.generatedName),
+      target: input.target,
+      generatedName: mapping.generatedName,
+      evidenceIds: uniqueStrings([
+        ...(mapping.evidenceIds ?? []),
+        ...(input.evidence ?? []).map((record) => record.id).filter(Boolean)
+      ]),
+      lossIds: uniqueStrings([
+        ...(mapping.lossIds ?? []),
+        ...lossIdsForNativeNode(input.losses ?? [], mapping.nativeAstNodeId)
+      ]),
+      ownershipRegionId: mapping.ownershipRegionId,
+      ownershipRegionKey: mapping.ownershipRegionKey,
+      ownershipRegionKind: mapping.ownershipRegionKind,
+      precision: exact ? 'exact' : mapping.precision === 'exact' ? 'line' : mapping.precision ?? 'line',
+      metadata: {
+        ...mapping.metadata,
+        compileResultId: input.compileResultId,
+        sourceMapOrigin: 'preserved-source'
+      }
+    }));
+}
+
+function nativeSourceCompileDeclarationMappings(input) {
+  const usedIds = new Set();
+  return (input.projection.declarations ?? []).map((declaration, index) => {
+    const generated = nativeSourceCompileDeclarationGeneratedSpan(input, declaration);
+    return {
+      id: reserveUniqueId(`compile_map_${idFragment(declaration.symbolId ?? declaration.nativeAstNodeId ?? declaration.name ?? index + 1)}`, usedIds),
+      nativeSourceId: input.importResult.nativeSource?.id,
+      nativeAstNodeId: declaration.nativeAstNodeId,
+      semanticSymbolId: declaration.symbolId,
+      sourceSpan: declaration.sourceSpan,
+      generatedSpan: generated.span,
+      target: input.target,
+      generatedName: generated.name,
+      evidenceIds: (input.evidence ?? []).map((record) => record.id).filter(Boolean),
+      lossIds: lossIdsForNativeNode(input.losses ?? [], declaration.nativeAstNodeId),
+      ownershipRegionId: declaration.ownershipRegionId,
+      ownershipRegionKey: declaration.metadata?.ownershipRegionKey,
+      ownershipRegionKind: declaration.metadata?.ownershipRegionKind,
+      precision: generated.exactName ? 'declaration' : 'estimated',
+      metadata: {
+        ...declaration.metadata,
+        compileResultId: input.compileResultId,
+        declarationKind: declaration.kind,
+        sourceMapOrigin: input.outputMode === 'target-adapter' ? 'target-adapter-fallback' : 'declaration-stub'
+      }
+    };
+  });
+}
+
+function nativeSourceCompileFileMapping(input) {
+  const rootSpan = input.importResult.nativeAst?.nodes?.[input.importResult.nativeAst?.rootId]?.span
+    ?? input.importResult.nativeSource?.ast?.nodes?.[input.importResult.nativeSource?.ast?.rootId]?.span
+    ?? input.projection.declarations?.find((declaration) => declaration.sourceSpan)?.sourceSpan;
+  return {
+    id: `compile_map_${idFragment(input.compileResultId ?? input.id)}_file`,
+    nativeSourceId: input.importResult.nativeSource?.id,
+    sourceSpan: rootSpan,
+    generatedSpan: nativeSourceCompileFullGeneratedSpan(input),
+    target: input.target,
+    evidenceIds: (input.evidence ?? []).map((record) => record.id).filter(Boolean),
+    precision: input.projection.mode === 'preserved-source' && input.outputHash === input.projection.sourceHash ? 'line' : 'estimated',
+    metadata: {
+      compileResultId: input.compileResultId,
+      sourceMapOrigin: 'file-fallback'
+    }
+  };
+}
+
+function nativeSourceCompileGeneratedSpanFromSource(sourceSpan, input, generatedName) {
+  if (!sourceSpan) return nativeSourceCompileFullGeneratedSpan(input, generatedName);
+  return {
+    ...sourceSpan,
+    sourceId: input.targetHash ?? input.outputHash,
+    path: input.targetPath,
+    target: input.target,
+    targetPath: input.targetPath,
+    targetHash: input.targetHash ?? input.outputHash,
+    generatedName
+  };
+}
+
+function nativeSourceCompileDeclarationGeneratedSpan(input, declaration) {
+  const identifiers = uniqueStrings([
+    declaration.name,
+    safeProjectionIdentifier(declaration.name),
+    upperFirst(safeProjectionIdentifier(declaration.name)),
+    safeProjectionIdentifier(declaration.name).toUpperCase()
+  ]).filter(Boolean);
+  for (const identifier of identifiers) {
+    const offset = input.output.indexOf(identifier);
+    if (offset >= 0) {
+      return {
+        name: identifier,
+        exactName: true,
+        span: nativeSourceCompileGeneratedSpanForOffset(input, offset, identifier.length, identifier)
+      };
+    }
+  }
+  return {
+    name: safeProjectionIdentifier(declaration.name),
+    exactName: false,
+    span: nativeSourceCompileFullGeneratedSpan(input, safeProjectionIdentifier(declaration.name))
+  };
+}
+
+function nativeSourceCompileGeneratedSpanForOffset(input, offset, length, generatedName) {
+  const start = lineColumnForOffset(input.output, offset);
+  const end = lineColumnForOffset(input.output, offset + Math.max(1, length));
+  return {
+    sourceId: input.targetHash ?? input.outputHash,
+    path: input.targetPath,
+    startLine: start.line,
+    startColumn: start.column,
+    endLine: end.line,
+    endColumn: end.column,
+    target: input.target,
+    targetPath: input.targetPath,
+    targetHash: input.targetHash ?? input.outputHash,
+    generatedName
+  };
+}
+
+function nativeSourceCompileFullGeneratedSpan(input, generatedName) {
+  const lines = String(input.output ?? '').split(/\r?\n/);
+  const lastLine = lines.at(-1) ?? '';
+  return {
+    sourceId: input.targetHash ?? input.outputHash,
+    path: input.targetPath,
+    startLine: 1,
+    startColumn: 1,
+    endLine: Math.max(1, lines.length),
+    endColumn: Math.max(1, lastLine.length + 1),
+    target: input.target,
+    targetPath: input.targetPath,
+    targetHash: input.targetHash ?? input.outputHash,
+    generatedName
+  };
+}
+
+function nativeSourceCompileTargetPath(input) {
+  if (input.targetPath) return input.targetPath;
+  const sourcePath = input.importResult.sourcePath ?? input.importResult.nativeSource?.sourcePath;
+  if (!sourcePath) return undefined;
+  const targetExt = nativeSourceCompileTargetExtension(input.target);
+  if (!targetExt) return sourcePath;
+  return sourcePath.replace(/(\.[^./\\]+)?$/, targetExt);
+}
+
+function nativeSourceCompileTargetExtension(target) {
+  const normalized = normalizeNativeLanguageId(target);
+  if (normalized === 'typescript') return '.ts';
+  if (normalized === 'javascript') return '.js';
+  if (normalized === 'rust') return '.rs';
+  if (normalized === 'python') return '.py';
+  if (normalized === 'c') return '.h';
+  return undefined;
+}
+
+function nativeSourceCompileMapTarget(input, targetPath) {
+  return {
+    language: input.target,
+    emitPath: targetPath
+  };
+}
+
+function lineColumnForOffset(source, offset) {
+  const text = String(source ?? '');
+  const safeOffset = Math.max(0, Math.min(offset, text.length));
+  let line = 1;
+  let column = 1;
+  for (let index = 0; index < safeOffset; index += 1) {
+    if (text[index] === '\n') {
+      line += 1;
+      column = 1;
+    } else {
+      column += 1;
+    }
+  }
+  return { line, column };
+}
+
 function nativeProjectionTargetsForLanguage(language, aliases = []) {
   const target = nativeLanguageCompileTarget(language, aliases);
   return target ? [target] : [];
@@ -4359,7 +4836,7 @@ function nativeImportLanguageProfile(language, input = {}) {
   });
 }
 
-function mergeNativeImportProfiles(languages, imports, adapters) {
+function mergeNativeImportProfiles(languages, imports, adapters, targetAdapters = []) {
   const profilesByLanguage = new Map();
   for (const profile of languages) {
     const normalized = normalizeNativeLanguageId(profile.language ?? profile);
@@ -4385,6 +4862,16 @@ function mergeNativeImportProfiles(languages, imports, adapters) {
       parserAdapters: uniqueStrings([...(existing.parserAdapters ?? []), adapter.parser ?? adapter.id].filter(Boolean))
     });
   }
+  for (const adapter of targetAdapters) {
+    const summary = safeNativeTargetProjectionAdapterSummary(adapter);
+    const normalized = normalizeNativeLanguageId(summary?.sourceLanguage);
+    if (!normalized) continue;
+    const existing = profilesByLanguage.get(normalized) ?? nativeImportLanguageProfile(normalized, { supportsLightweightScan: false, parserAdapters: [] });
+    profilesByLanguage.set(normalized, {
+      ...existing,
+      projectionTargets: uniqueStrings([...(existing.projectionTargets ?? []), summary.target].filter(Boolean))
+    });
+  }
   return [...profilesByLanguage.values()].sort((left, right) => left.language.localeCompare(right.language));
 }
 
@@ -5217,6 +5704,11 @@ function maxSemanticMergeReadiness(left, right) {
   return leftRank >= rightRank ? left : right;
 }
 
+function normalizeSemanticMergeReadiness(value) {
+  const readiness = String(value ?? '').toLowerCase();
+  return Object.prototype.hasOwnProperty.call(semanticMergeReadinessRank, readiness) ? readiness : undefined;
+}
+
 export function createUniversalAstFromDocument(document, input = {}) {
   return createUniversalAstEnvelope({
     id: input.id ?? `universal_ast_${idFragment(document.id)}`,
@@ -5886,6 +6378,150 @@ function resolveNativeProjectAdapter(source, adapters, input) {
   });
 }
 
+function resolveNativeTargetProjectionAdapter(input, options = {}) {
+  const adapters = options.targetAdapters ?? [];
+  if (options.targetAdapter && typeof options.targetAdapter === 'object') return options.targetAdapter;
+  if (typeof options.targetAdapter === 'string') {
+    const explicit = adapters.find((adapter) => adapter?.id === options.targetAdapter);
+    if (explicit) return explicit;
+  }
+  if (typeof options.targetAdapterResolver === 'function') {
+    const resolved = options.targetAdapterResolver(input, adapters);
+    if (resolved) return resolved;
+  }
+  return matchingNativeTargetProjectionAdapter(input, adapters);
+}
+
+function matchingNativeTargetProjectionAdapter(input, adapters = []) {
+  return adapters.find((adapter) => nativeTargetProjectionAdapterMatches(adapter, input));
+}
+
+function nativeTargetProjectionAdapterMatches(adapter, input = {}) {
+  const summary = safeNativeTargetProjectionAdapterSummary(adapter);
+  if (!summary) return false;
+  if (input.sourceLanguage && normalizeNativeLanguageId(input.sourceLanguage) !== summary.sourceLanguage) return false;
+  const target = normalizeProjectionMatrixTargets([input.target])[0] ?? String(input.target ?? '').toLowerCase();
+  if (target && target !== summary.target) return false;
+  const parser = input.parser ? String(input.parser).toLowerCase() : undefined;
+  if (parser && summary.supportedParsers.length && !summary.supportedParsers.map((item) => item.toLowerCase()).includes(parser)) return false;
+  const sourcePath = String(input.sourcePath ?? '').toLowerCase();
+  if (sourcePath && summary.supportedExtensions.length) {
+    return summary.supportedExtensions.some((extension) => sourcePath.endsWith(extension));
+  }
+  return true;
+}
+
+function safeNativeTargetProjectionAdapterSummary(adapter) {
+  try {
+    return normalizeNativeTargetProjectionAdapter(adapter);
+  } catch {
+    return undefined;
+  }
+}
+
+function normalizeNativeTargetProjectionAdapter(adapter) {
+  if (!adapter || typeof adapter !== 'object') {
+    throw new Error('Native target projection adapter must be an object');
+  }
+  if (!adapter.id) throw new Error('Native target projection adapter requires an id');
+  const sourceLanguage = normalizeNativeLanguageId(adapter.sourceLanguage ?? adapter.language);
+  if (!sourceLanguage) throw new Error(`Native target projection adapter ${adapter.id} requires a sourceLanguage`);
+  const target = normalizeProjectionMatrixTargets([adapter.target ?? adapter.targetLanguage])[0];
+  if (!target) throw new Error(`Native target projection adapter ${adapter.id} requires a target`);
+  if (typeof adapter.project !== 'function') throw new Error(`Native target projection adapter ${adapter.id} requires a project function`);
+  const capabilities = normalizeStringList(adapter.capabilities);
+  const summaryInput = {
+    id: String(adapter.id),
+    sourceLanguage,
+    language: sourceLanguage,
+    target,
+    parser: `target:${target}`,
+    version: adapter.version === undefined ? undefined : String(adapter.version)
+  };
+  return Object.freeze({
+    id: summaryInput.id,
+    sourceLanguage,
+    target,
+    version: summaryInput.version,
+    capabilities,
+    supportedParsers: normalizeStringList(adapter.supportedParsers),
+    supportedExtensions: normalizeStringList(adapter.supportedExtensions).map((extension) => extension.startsWith('.') ? extension.toLowerCase() : `.${extension.toLowerCase()}`),
+    coverage: normalizeNativeTargetProjectionAdapterCoverage(adapter.coverage, { capabilities }),
+    diagnostics: normalizeAdapterDiagnostics(adapter.diagnostics, summaryInput, {
+      language: sourceLanguage,
+      parser: summaryInput.parser,
+      parserVersion: summaryInput.version
+    }, 'target-adapter')
+  });
+}
+
+function normalizeNativeTargetProjectionAdapterCoverage(value = {}, context = {}) {
+  const capabilities = new Set(normalizeStringList(context.capabilities).map((capability) => capability.toLowerCase()));
+  const lossKinds = uniqueStrings(value.lossKinds ?? []);
+  const handledLossKinds = uniqueStrings([
+    ...(value.handledLossKinds ?? []),
+    ...(capabilities.has('macros') || capabilities.has('macroexpansion') ? ['macroExpansion', 'macroHygiene'] : []),
+    ...(capabilities.has('preprocessor') ? ['preprocessor', 'conditionalCompilation'] : []),
+    ...(capabilities.has('dynamicruntime') ? ['dynamicRuntime', 'dynamicDispatch'] : []),
+    ...(capabilities.has('typeinference') ? ['typeInference', 'overloadResolution'] : [])
+  ]);
+  return Object.freeze({
+    readiness: normalizeSemanticMergeReadiness(value.readiness) ?? 'needs-review',
+    lossKinds,
+    handledLossKinds,
+    sourceMapPrecision: value.sourceMapPrecision,
+    semanticCoverage: value.semanticCoverage ?? {},
+    notes: uniqueStrings(value.notes ?? ['Target projection adapter output is host-owned evidence and should be reviewed unless declared ready.'])
+  });
+}
+
+function nativeTargetProjectionAdapterEvidence(adapter, diagnostics, input) {
+  const errors = diagnostics.filter((diagnostic) => diagnostic.severity === 'error').length;
+  const warnings = diagnostics.filter((diagnostic) => diagnostic.severity === 'warning').length;
+  return {
+    id: `evidence_${idFragment(adapter.id)}_native_target_projection_adapter`,
+    kind: 'projection',
+    status: errors ? 'failed' : 'passed',
+    path: input.sourcePath,
+    summary: `Ran ${adapter.id} native target projection adapter from ${input.sourceLanguage} to ${input.target} with ${diagnostics.length} diagnostic(s).`,
+    metadata: {
+      adapterId: adapter.id,
+      adapterVersion: adapter.version,
+      sourceLanguage: input.sourceLanguage,
+      target: input.target,
+      targetPath: input.targetPath,
+      outputHash: input.outputHash,
+      capabilities: adapter.capabilities,
+      coverage: adapter.coverage,
+      diagnostics: diagnostics.map(serializableDiagnostic),
+      errors,
+      warnings
+    }
+  };
+}
+
+function nativeTargetProjectionDiagnosticToLoss(diagnostic, index, adapter, input) {
+  return {
+    id: `loss_${idFragment(diagnostic.id ?? `${adapter.id}_${index}_${diagnostic.code ?? diagnostic.severity}`)}`,
+    severity: diagnostic.severity,
+    phase: diagnostic.phase ?? 'emit',
+    sourceFormat: input.sourceLanguage,
+    kind: diagnostic.kind ?? 'targetProjectionLoss',
+    message: diagnostic.message,
+    span: diagnostic.span,
+    metadata: {
+      adapterId: adapter.id,
+      adapterVersion: adapter.version,
+      diagnosticId: diagnostic.id,
+      diagnosticCode: diagnostic.code,
+      sourceLanguage: input.sourceLanguage,
+      target: input.target,
+      path: diagnostic.path,
+      ...diagnostic.metadata
+    }
+  };
+}
+
 function normalizeNativeImporterAdapter(adapter) {
   if (!adapter || typeof adapter !== 'object') {
     throw new Error('Native importer adapter must be an object');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shapeshift-labs/frontier-lang-compiler",
-  "version": "0.2.19",
+  "version": "0.2.21",
   "description": "Compiler facade for Frontier Lang source documents and language projection adapters.",
   "type": "module",
   "main": "./dist/index.js",