@shapeshift-labs/frontier-lang-compiler 0.2.18 → 0.2.20

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:
@@ -166,6 +167,67 @@ console.log(changeSet.mergeCandidate.readiness); // merge-admission classificati
 
 Use `diffNativeSourceImports` when the worker or runner already produced `importNativeSource` results. Body-only edits that the lightweight scanner cannot anchor to a symbol are still reported as file-level changed regions instead of being silently treated as safe.
 
+Compile native source imports through the same reader/IR/writer facade that swarms use for sidecar evidence. Same-language targets preserve exact source when hashes match; cross-language targets emit declaration stubs until a real adapter provides stronger evidence:
+
+```js
+import { compileNativeSource } from '@shapeshift-labs/frontier-lang-compiler';
+
+const compiledJs = compileNativeSource({
+  language: 'javascript',
+  sourcePath: 'src/runtime.js',
+  sourceText: 'export function step(frame) { return frame + 1; }\n'
+});
+
+console.log(compiledJs.outputMode); // "preserved-source"
+console.log(compiledJs.readiness.readiness); // scanner imports can still be "needs-review"
+
+const rustCandidate = compileNativeSource(compiledJs.importResult, {
+  target: 'rust',
+  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
+```
+
+`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.
+
+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',
+  targetAdapters: [jsToRustAdapter]
+});
+
+console.log(rustWithAdapter.outputMode); // "target-adapter"
+console.log(rustWithAdapter.targetCoverage.lossClass); // "targetAdapterProjection"
+console.log(rustWithAdapter.targetProjection.adapter.id); // "app-js-to-rust"
+```
+
 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:
 
 ```js

package/bench/smoke.mjs

@@ -1,5 +1,6 @@
 import { performance } from 'node:perf_hooks';
 import {
+  compileNativeSource,
   compileFrontierSource,
   createEstreeNativeImporterAdapter,
   createNativeImportCoverageMatrix,
@@ -92,6 +93,36 @@ const nativeProjections = nativeImportResults.map((imported) => projectNativeImp
 const projectionDurationMs = performance.now() - projectionStart;
 const projectionBytes = nativeProjections.reduce((sum, projection) => sum + projection.sourceText.length, 0);
 
+const nativeCompileStart = performance.now();
+const nativeCompiles = nativeImportResults.map((imported, index) => compileNativeSource(imported, {
+  target: index % 2 === 0 ? 'javascript' : 'rust',
+  emitOnBlocked: true
+}));
+const nativeCompileDurationMs = performance.now() - nativeCompileStart;
+const nativeCompileBytes = nativeCompiles.reduce((sum, result) => sum + result.output.length, 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);
+
 console.log(JSON.stringify({
   compiles: 250,
   bytes,
@@ -118,5 +149,12 @@ console.log(JSON.stringify({
   sidecarDurationMs: Number(sidecarDurationMs.toFixed(2)),
   nativeProjections: nativeProjections.length,
   projectionBytes,
-  projectionDurationMs: Number(projectionDurationMs.toFixed(2))
+  projectionDurationMs: Number(projectionDurationMs.toFixed(2)),
+  nativeCompiles: nativeCompiles.length,
+  nativeCompileBytes,
+  nativeCompileBlocked,
+  nativeCompileDurationMs: Number(nativeCompileDurationMs.toFixed(2)),
+  nativeTargetAdapterCompiles: nativeTargetAdapterCompiles.length,
+  nativeTargetAdapterBytes,
+  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,6 +1315,52 @@ export interface NativeSourceProjectionResult {
   readonly metadata: Record<string, unknown>;
 }
 
+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 projectionId?: string;
+  readonly projectionEvidenceId?: string;
+  readonly compileEvidenceId?: string;
+  readonly evidence?: readonly EvidenceRecord[];
+  readonly losses?: readonly NativeAstLossRecord[];
+}
+
+export interface NativeSourceCompileResult {
+  readonly kind: 'frontier.lang.nativeSourceCompileResult';
+  readonly version: 1;
+  readonly id: string;
+  readonly ok: boolean;
+  readonly target: FrontierCompileTarget | string;
+  readonly language: FrontierSourceLanguage | string;
+  readonly sourcePath?: string;
+  readonly output: string;
+  readonly outputHash: string;
+  readonly outputMode: NativeSourceCompileOutputMode;
+  readonly importResult: NativeSourceImportResult;
+  readonly projection: NativeSourceProjectionResult;
+  readonly targetProjection?: NativeTargetProjectionResult;
+  readonly targetCoverage: ProjectionTargetCoverageEntry;
+  readonly projectionMatrix: ProjectionTargetLossMatrix;
+  readonly losses: readonly NativeAstLossRecord[];
+  readonly lossSummary: NativeImportLossSummary;
+  readonly readiness: NativeImportReadinessClassification;
+  readonly evidence: readonly EvidenceRecord[];
+  readonly metadata: Record<string, unknown>;
+}
+
 export type NativeImportRoundtripReadinessStatus =
   | 'exact'
   | 'preserved-source'
@@ -1286,6 +1426,7 @@ export declare const NativeImportLanguageProfiles: readonly NativeImportLanguage
 export declare function normalizeCompileTarget(target?: string): FrontierCompileTarget;
 export declare function compileFrontierSource(source: string, options?: FrontierCompileOptions): FrontierCompileResult;
 export declare function compileFrontierDocument(document: FrontierLangDocument, options?: FrontierCompileOptions): FrontierCompileResult;
+export declare function compileNativeSource(input: ImportNativeSourceOptions | NativeSourceImportResult, options?: CompileNativeSourceOptions): NativeSourceCompileResult;
 export declare function projectFrontierAst(document: FrontierLangDocument, target?: FrontierCompileOptions['target'], options?: FrontierCompileEmitOptions): FrontierTargetAst;
 export declare function renderTargetAst(ast: FrontierTargetAst, target?: FrontierCompileOptions['target']): string;
 export declare function renderTargetAstWithSourceMap(ast: FrontierTargetAst, target?: FrontierCompileOptions['target'], options?: FrontierCompileEmitOptions): FrontierTargetSourceMapResult;
@@ -1304,6 +1445,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'
 ]);
 
@@ -253,6 +254,152 @@ export function compileFrontierDocument(document, options = {}) {
   };
 }
 
+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
+  });
+  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,
+    importResult,
+    projection,
+    targetProjection,
+    targetCoverage,
+    projectionMatrix,
+    losses,
+    lossSummary,
+    readiness,
+    evidence,
+    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,
+      projectionMode: projection.mode,
+      outputMode,
+      sourceTarget,
+      sameSourceTarget,
+      targetLossClass: targetCoverage.lossClass,
+      targetReadiness: targetCoverage.readiness,
+      targetSupported: targetCoverage.supported,
+      ...options.metadata
+    }
+  };
+}
+
 export function projectFrontierAst(document, target = 'typescript', options = {}) {
   const normalized = normalizeCompileTarget(target);
   const projector = projectors[normalized];
@@ -547,11 +694,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);
@@ -564,7 +713,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.'
     }
   };
 }
@@ -1049,6 +1198,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');
@@ -3840,6 +4103,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([
@@ -3850,6 +4114,7 @@ function projectionTargetCoverageForProfile(profile, context) {
   const targets = (context.targets ?? FrontierCompileTargets).map((target) => projectionTargetCoverageEntry(profile, target, {
     matchingImports,
     matchingAdapters,
+    matchingTargetAdapters,
     knownLossKinds
   }));
   return {
@@ -3927,8 +4192,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,
@@ -3944,6 +4215,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,
@@ -4005,6 +4318,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
   };
@@ -4075,6 +4389,161 @@ function nativeLanguageCompileTarget(language, aliases = []) {
   return undefined;
 }
 
+function isNativeSourceImportResult(input) {
+  return Boolean(input && typeof input === 'object' && input.kind === 'frontier.lang.importResult' && input.nativeSource && input.universalAst);
+}
+
+function nativeCompileSourceLanguage(importResult, input) {
+  return normalizeNativeLanguageId(
+    importResult.language
+      ?? importResult.nativeSource?.language
+      ?? importResult.nativeAst?.language
+      ?? importResult.nativeSource?.ast?.language
+      ?? input?.language
+  ) || String(importResult.language ?? input?.language ?? 'source');
+}
+
+function nativeCompileTarget(input, importResult, options) {
+  const targetInput = options.target
+    ?? compileTargetLanguage(input?.target)
+    ?? compileTargetLanguage(importResult.nativeSource?.target)
+    ?? nativeLanguageCompileTarget(nativeCompileSourceLanguage(importResult, input))
+    ?? 'typescript';
+  return normalizeProjectionMatrixTargets([targetInput])[0] ?? String(targetInput ?? 'typescript').toLowerCase();
+}
+
+function compileTargetLanguage(target) {
+  if (!target) return undefined;
+  if (typeof target === 'string') return target;
+  return target.language ?? target.emitLanguage ?? target.target ?? target.name;
+}
+
+function nativeSourceCompileTargetCoverage(matrix, language, target) {
+  const sourceLanguage = normalizeNativeLanguageId(language);
+  const entry = (matrix.languages ?? []).find((candidate) => {
+    const ids = [candidate.language, ...(candidate.aliases ?? [])].map(normalizeNativeLanguageId);
+    return ids.includes(sourceLanguage);
+  });
+  const coverage = entry?.targets?.find((candidate) => candidate.target === target);
+  if (coverage) return coverage;
+  return {
+    target,
+    lossClass: 'missingAdapter',
+    supported: false,
+    readiness: 'blocked',
+    lossKinds: ['targetProjectionLoss'],
+    categories: ['targetProjectionLoss'],
+    reason: `No native-to-${target} projection coverage is available for ${language}.`,
+    adapter: undefined,
+    notes: ['Inject a source-language parser and target projection adapter before treating this cross-language output as merge-ready.']
+  };
+}
+
+function nativeSourceCompileTargetLosses(input) {
+  const { importResult, projection, targetCoverage, sourceLanguage, target, idPart } = input;
+  if (!targetCoverage || targetCoverage.lossClass === 'exactSourceProjection') return [];
+  if (targetCoverage.lossClass === 'missingAdapter') {
+    return [nativeSourceCompileTargetLoss({
+      id: `loss_${idPart}_${idFragment(target)}_missing_projection_adapter`,
+      severity: 'error',
+      message: targetCoverage.reason,
+      importResult,
+      projection,
+      targetCoverage,
+      sourceLanguage,
+      target
+    })];
+  }
+  if (targetCoverage.lossClass === 'unsupportedTargetFeatures') {
+    return [nativeSourceCompileTargetLoss({
+      id: `loss_${idPart}_${idFragment(target)}_unsupported_target_features`,
+      severity: 'warning',
+      message: targetCoverage.reason,
+      importResult,
+      projection,
+      targetCoverage,
+      sourceLanguage,
+      target
+    })];
+  }
+  if (targetCoverage.lossClass === 'nativeSourceStubs') {
+    return [nativeSourceCompileTargetLoss({
+      id: `loss_${idPart}_${idFragment(target)}_target_stubs`,
+      severity: 'warning',
+      message: targetCoverage.reason,
+      importResult,
+      projection,
+      targetCoverage,
+      sourceLanguage,
+      target
+    })];
+  }
+  return [];
+}
+
+function nativeSourceCompileTargetLoss(input) {
+  const rootSpan = input.importResult.nativeAst?.nodes?.[input.importResult.nativeAst?.rootId]?.span
+    ?? input.importResult.nativeSource?.ast?.nodes?.[input.importResult.nativeSource?.ast?.rootId]?.span;
+  return {
+    id: input.id,
+    severity: input.severity,
+    phase: 'emit',
+    sourceFormat: input.sourceLanguage,
+    kind: 'targetProjectionLoss',
+    message: input.message,
+    span: rootSpan ?? {
+      sourceId: input.importResult.nativeSource?.sourceHash ?? input.importResult.sourceHash,
+      path: input.importResult.sourcePath ?? input.importResult.nativeSource?.sourcePath,
+      startLine: 1,
+      startColumn: 1
+    },
+    metadata: {
+      target: input.target,
+      sourceLanguage: input.sourceLanguage,
+      projectionId: input.projection.id,
+      projectionMode: input.projection.mode,
+      targetLossClass: input.targetCoverage.lossClass,
+      targetReadiness: input.targetCoverage.readiness,
+      targetSupported: input.targetCoverage.supported,
+      targetAdapter: input.targetCoverage.adapter,
+      targetLossKinds: input.targetCoverage.lossKinds,
+      lossCategory: 'targetProjectionLoss',
+      semanticMergeAdmission: semanticMergeAdmissionForSeverity(input.severity)
+    }
+  };
+}
+
+function nativeSourceCompileEvidence(input) {
+  const failed = input.targetLosses.some((loss) => loss.severity === 'error')
+    || input.projection.evidence?.some((record) => record.status === 'failed')
+    || input.targetCoverage.readiness === 'blocked';
+  return {
+    id: input.id,
+    kind: 'projection',
+    status: failed ? 'failed' : 'passed',
+    path: input.importResult.sourcePath ?? input.importResult.nativeSource?.sourcePath,
+    summary: failed
+      ? `Compiled ${input.sourceLanguage} native source to ${input.target} with blocked projection evidence.`
+      : `Compiled ${input.sourceLanguage} native source to ${input.target} as ${input.outputMode}.`,
+    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.outputHash ?? input.projection.outputHash,
+      outputMode: input.outputMode,
+      projectionMode: input.projection.mode,
+      targetLossClass: input.targetCoverage.lossClass,
+      targetReadiness: input.targetCoverage.readiness,
+      targetSupported: input.targetCoverage.supported,
+      targetReason: input.targetCoverage.reason,
+      targetLossIds: input.targetLosses.map((loss) => loss.id)
+    }
+  };
+}
+
 function nativeProjectionTargetsForLanguage(language, aliases = []) {
   const target = nativeLanguageCompileTarget(language, aliases);
   return target ? [target] : [];
@@ -4096,7 +4565,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);
@@ -4122,6 +4591,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));
 }
 
@@ -4954,6 +5433,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)}`,
@@ -5623,6 +6107,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.18",
+  "version": "0.2.20",
   "description": "Compiler facade for Frontier Lang source documents and language projection adapters.",
   "type": "module",
   "main": "./dist/index.js",