@shapeshift-labs/frontier-lang-compiler 0.2.13 → 0.2.14

package/README.md

@@ -57,6 +57,7 @@ Ask the compiler what is actually covered before sending native imports into a m
 ```js
 import {
   createNativeImportCoverageMatrix,
+  createProjectionTargetLossMatrix,
   importNativeSource
 } from '@shapeshift-labs/frontier-lang-compiler';
 
@@ -71,8 +72,22 @@ const python = matrix.languages.find((entry) => entry.language === 'python');
 
 console.log(python.imports.readiness); // scanner imports are intentionally review-required
 console.log(python.parserAdapters); // host-owned exact parsers such as LibCST can be injected
+
+const projectionMatrix = createProjectionTargetLossMatrix({ imports: [imported] });
+const pythonProjection = projectionMatrix.languages.find((entry) => entry.language === 'python');
+
+console.log(pythonProjection.sourceProjection.exactSource.lossClass); // "exactSourceProjection"
+console.log(pythonProjection.sourceProjection.stubs.lossClass); // "nativeSourceStubs"
+console.log(pythonProjection.targets.find((entry) => entry.target === 'rust').lossClass); // "missingAdapter"
 ```
 
+The projection target matrix separates four 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.
+- `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:
 
 ```js

package/bench/smoke.mjs

@@ -3,6 +3,7 @@ import {
   compileFrontierSource,
   createEstreeNativeImporterAdapter,
   createNativeImportCoverageMatrix,
+  createProjectionTargetLossMatrix,
   createNativeSourcePreservation,
   createSemanticImportSidecar,
   importNativeSource,
@@ -68,6 +69,10 @@ const matrixStart = performance.now();
 const coverageMatrix = createNativeImportCoverageMatrix({ imports: nativeImportResults });
 const matrixDurationMs = performance.now() - matrixStart;
 
+const projectionMatrixStart = performance.now();
+const projectionLossMatrix = createProjectionTargetLossMatrix({ imports: nativeImportResults });
+const projectionMatrixDurationMs = performance.now() - projectionMatrixStart;
+
 const preservationStart = performance.now();
 const preservationRecords = nativeImportResults.map((imported) => imported.metadata.sourcePreservation ?? createNativeSourcePreservation({
   language: imported.language,
@@ -101,6 +106,10 @@ console.log(JSON.stringify({
   adapterCoverageTokenGaps: coverageMatrix.summary.adapterCoverage.gaps.tokens ?? 0,
   adapterCoverageReferenceGaps: coverageMatrix.summary.adapterCoverage.gaps.references ?? 0,
   coverageMatrixDurationMs: Number(matrixDurationMs.toFixed(2)),
+  projectionMatrixLanguages: projectionLossMatrix.summary.languages,
+  projectionMatrixMissingAdapters: projectionLossMatrix.summary.missingAdapters,
+  projectionMatrixUnsupportedTargetFeatures: projectionLossMatrix.summary.unsupportedTargetFeatures,
+  projectionMatrixDurationMs: Number(projectionMatrixDurationMs.toFixed(2)),
   sourcePreservationRecords: preservationRecords.length,
   sourcePreservationTokens: preservationTokens,
   sourcePreservationDurationMs: Number(preservationDurationMs.toFixed(2)),

package/dist/index.d.ts

@@ -168,7 +168,7 @@ export interface NativeImportLanguageProfile {
   readonly extensions: readonly string[];
   readonly supportsLightweightScan: boolean;
   readonly parserAdapters: readonly string[];
-  readonly projectionTargets: readonly FrontierCompileTarget[];
+  readonly projectionTargets: readonly (FrontierCompileTarget | string)[];
   readonly knownLossKinds: readonly NativeImportKnownLossKind[];
   readonly defaultReadiness: SemanticMergeReadiness;
   readonly notes: readonly string[];
@@ -202,7 +202,7 @@ export interface NativeImportCoverageLanguage {
   readonly extensions: readonly string[];
   readonly supportsLightweightScan: boolean;
   readonly parserAdapters: readonly string[];
-  readonly projectionTargets: readonly FrontierCompileTarget[];
+  readonly projectionTargets: readonly (FrontierCompileTarget | string)[];
   readonly knownLossKinds: readonly NativeImportKnownLossKind[];
   readonly defaultReadiness: SemanticMergeReadiness;
   readonly notes: readonly string[];
@@ -241,6 +241,7 @@ export interface NativeImportCoverageMatrix {
   };
   readonly metadata: {
     readonly compileTargets: readonly FrontierCompileTarget[];
+    readonly projectionTargetLossClasses: readonly ProjectionTargetLossClass[];
     readonly note: string;
   };
 }
@@ -252,6 +253,96 @@ export interface NativeImportCoverageMatrixOptions {
   readonly generatedAt?: number;
 }
 
+export type ProjectionTargetLossClass =
+  | 'exactSourceProjection'
+  | 'nativeSourceStubs'
+  | 'unsupportedTargetFeatures'
+  | 'missingAdapter'
+  | string;
+
+export interface ProjectionSourceProjectionCoverage {
+  readonly lossClass: ProjectionTargetLossClass;
+  readonly mode: NativeSourceProjectionMode;
+  readonly supported: boolean;
+  readonly readiness: SemanticMergeReadiness;
+  readonly lossKinds: readonly NativeImportKnownLossKind[];
+  readonly categories: readonly NativeImportTaxonomyKind[];
+  readonly reason: string;
+  readonly evidence: {
+    readonly imports: number;
+    readonly importsWithExactSource?: number;
+    readonly importsWithDeclarations?: number;
+  };
+  readonly notes: readonly string[];
+}
+
+export interface ProjectionTargetCoverageEntry {
+  readonly target: FrontierCompileTarget | string;
+  readonly lossClass: ProjectionTargetLossClass;
+  readonly supported: boolean;
+  readonly readiness: SemanticMergeReadiness;
+  readonly lossKinds: readonly NativeImportKnownLossKind[];
+  readonly categories: readonly NativeImportTaxonomyKind[];
+  readonly reason: string;
+  readonly adapter?: string;
+  readonly notes: readonly string[];
+}
+
+export interface ProjectionTargetLanguageCoverage {
+  readonly language: FrontierSourceLanguage | string;
+  readonly aliases: readonly string[];
+  readonly extensions: readonly string[];
+  readonly supportsLightweightScan: boolean;
+  readonly parserAdapters: readonly string[];
+  readonly projectionTargets: readonly (FrontierCompileTarget | string)[];
+  readonly knownLossKinds: readonly NativeImportKnownLossKind[];
+  readonly defaultReadiness: SemanticMergeReadiness;
+  readonly notes: readonly string[];
+  readonly sourceProjection: {
+    readonly exactSource: ProjectionSourceProjectionCoverage;
+    readonly stubs: ProjectionSourceProjectionCoverage;
+  };
+  readonly targets: readonly ProjectionTargetCoverageEntry[];
+  readonly summary: {
+    readonly imports: number;
+    readonly parserAdapters: number;
+    readonly targetEntries: number;
+    readonly byLossClass: Readonly<Record<ProjectionTargetLossClass, number>>;
+    readonly exactSourceImports: number;
+    readonly stubDeclarationImports: number;
+  };
+}
+
+export interface ProjectionTargetLossMatrix {
+  readonly kind: 'frontier.lang.projectionTargetLossMatrix';
+  readonly version: 1;
+  readonly generatedAt: number;
+  readonly languages: readonly ProjectionTargetLanguageCoverage[];
+  readonly summary: {
+    readonly languages: number;
+    readonly targetEntries: number;
+    readonly byLossClass: Readonly<Record<ProjectionTargetLossClass, number>>;
+    readonly sourceProjectionByLossClass: Readonly<Record<ProjectionTargetLossClass, number>>;
+    readonly exactSourceProjection: number;
+    readonly nativeSourceStubs: number;
+    readonly unsupportedTargetFeatures: number;
+    readonly missingAdapters: number;
+  };
+  readonly metadata: {
+    readonly compileTargets: readonly (FrontierCompileTarget | string)[];
+    readonly lossClasses: readonly ProjectionTargetLossClass[];
+    readonly note: string;
+  };
+}
+
+export interface ProjectionTargetLossMatrixOptions {
+  readonly languages?: readonly NativeImportLanguageProfile[];
+  readonly imports?: readonly NativeSourceImportResult[];
+  readonly adapters?: readonly NativeImporterAdapter[];
+  readonly targets?: readonly (FrontierCompileTarget | string)[];
+  readonly generatedAt?: number;
+}
+
 export interface NativeImportContractSource {
   readonly id: string;
   readonly language?: FrontierSourceLanguage | string;
@@ -1081,6 +1172,7 @@ export declare const NativeImportRoundtripReadinessStatuses: readonly NativeImpo
 export declare const NativeImportTaxonomyKinds: readonly NativeImportTaxonomyKind[];
 export declare const NativeImportLossKinds: readonly NativeImportKnownLossKind[];
 export declare const NativeImportRegionTaxonomyKinds: readonly NativeImportRegionTaxonomyKind[];
+export declare const ProjectionTargetLossClasses: readonly ProjectionTargetLossClass[];
 export declare const NativeImportReadinessBySeverity: Readonly<Record<NativeImportLossSummary['highestSeverity'], SemanticMergeReadiness>>;
 export declare const NativeImportLanguageProfiles: readonly NativeImportLanguageProfile[];
 export declare function normalizeCompileTarget(target?: string): FrontierCompileTarget;
@@ -1093,6 +1185,7 @@ export declare function summarizeNativeImportLosses(losses?: readonly NativeAstL
 export declare function classifyNativeImportReadiness(losses?: readonly NativeAstLossRecord[], options?: NativeImportLossSummaryOptions): NativeImportReadinessClassification;
 export declare function classifyNativeImportRoundtripReadiness(importResult: NativeSourceImportResult | NativeProjectImportResult, options?: NativeImportRoundtripReadinessOptions): NativeImportRoundtripReadinessClassification;
 export declare function createNativeImportCoverageMatrix(options?: NativeImportCoverageMatrixOptions): NativeImportCoverageMatrix;
+export declare function createProjectionTargetLossMatrix(options?: ProjectionTargetLossMatrixOptions): ProjectionTargetLossMatrix;
 export declare function createNativeSourcePreservation(options: CreateNativeSourcePreservationOptions): NativeSourcePreservation;
 export declare function createSemanticImportSidecar(importResult: NativeSourceImportResult | NativeProjectImportResult, options?: SemanticImportSidecarOptions): SemanticImportSidecar;
 export declare function createNativeImportResultContract(importResult: NativeSourceImportResult | NativeProjectImportResult, options?: NativeImportResultContractOptions): NativeImportResultContract;

package/dist/index.js

@@ -138,6 +138,13 @@ export const NativeImportRegionTaxonomyKinds = Object.freeze([
   'generatedOutput'
 ]);
 
+export const ProjectionTargetLossClasses = Object.freeze([
+  'exactSourceProjection',
+  'nativeSourceStubs',
+  'unsupportedTargetFeatures',
+  'missingAdapter'
+]);
+
 export const NativeImportLanguageProfiles = Object.freeze([
   nativeImportLanguageProfile('javascript', {
     aliases: ['js', 'mjs', 'cjs', 'jsx'],
@@ -516,11 +523,37 @@ export function createNativeImportCoverageMatrix(input = {}) {
     summary,
     metadata: {
       compileTargets: [...FrontierCompileTargets],
+      projectionTargetLossClasses: [...ProjectionTargetLossClasses],
       note: 'Coverage is evidence and capability metadata, not a claim that every language feature is losslessly portable.'
     }
   };
 }
 
+export function createProjectionTargetLossMatrix(input = {}) {
+  const imports = input.imports ?? [];
+  const adapters = input.adapters ?? [];
+  const profiles = mergeNativeImportProfiles(input.languages ?? NativeImportLanguageProfiles, imports, adapters);
+  const targets = normalizeProjectionMatrixTargets(input.targets ?? FrontierCompileTargets);
+  const languages = profiles.map((profile) => projectionTargetCoverageForProfile(profile, {
+    imports,
+    adapters,
+    targets
+  }));
+  const summary = projectionTargetLossMatrixSummary(languages);
+  return {
+    kind: 'frontier.lang.projectionTargetLossMatrix',
+    version: 1,
+    generatedAt: input.generatedAt ?? Date.now(),
+    languages,
+    summary,
+    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.'
+    }
+  };
+}
+
 export function createNativeSourcePreservation(options) {
   if (!options || typeof options.sourceText !== 'string') {
     throw new Error('createNativeSourcePreservation requires sourceText');
@@ -3371,15 +3404,273 @@ function nativeImportCategoryForLossKind(kind) {
   return String(kind ?? 'opaqueNative');
 }
 
+function normalizeProjectionMatrixTargets(targets) {
+  return uniqueStrings((Array.isArray(targets) ? targets : [targets])
+    .map((target) => {
+      if (target === undefined || target === null) return undefined;
+      try {
+        return normalizeCompileTarget(target);
+      } catch {
+        return String(target).trim().toLowerCase();
+      }
+    })
+    .filter(Boolean));
+}
+
+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 importedLossKinds = uniqueStrings(matchingImports.flatMap((imported) => (imported?.losses ?? []).map((loss) => loss.kind).filter(Boolean)));
+  const knownLossKinds = uniqueStrings([...(profile.knownLossKinds ?? []), ...importedLossKinds]);
+  const parserAdapters = uniqueStrings([
+    ...(profile.parserAdapters ?? []),
+    ...matchingAdapters.map((adapter) => adapter.parser ?? adapter.id).filter(Boolean)
+  ]);
+  const sourceProjection = sourceProjectionCoverageForProfile(profile, matchingImports, knownLossKinds);
+  const targets = (context.targets ?? FrontierCompileTargets).map((target) => projectionTargetCoverageEntry(profile, target, {
+    matchingImports,
+    matchingAdapters,
+    knownLossKinds
+  }));
+  return {
+    language: profile.language,
+    aliases: profile.aliases,
+    extensions: profile.extensions,
+    supportsLightweightScan: profile.supportsLightweightScan,
+    parserAdapters,
+    projectionTargets: profile.projectionTargets,
+    knownLossKinds,
+    defaultReadiness: profile.defaultReadiness,
+    notes: profile.notes,
+    sourceProjection,
+    targets,
+    summary: {
+      imports: matchingImports.length,
+      parserAdapters: parserAdapters.length,
+      targetEntries: targets.length,
+      byLossClass: countProjectionLossClasses(targets),
+      exactSourceImports: sourceProjection.exactSource.evidence.importsWithExactSource,
+      stubDeclarationImports: sourceProjection.stubs.evidence.importsWithDeclarations
+    }
+  };
+}
+
+function sourceProjectionCoverageForProfile(profile, imports, knownLossKinds) {
+  const exactSourceImports = imports.filter(hasExactSourceProjectionEvidence).length;
+  const declarationImports = imports.filter(hasNativeProjectionDeclarations).length;
+  return {
+    exactSource: {
+      lossClass: 'exactSourceProjection',
+      mode: 'preserved-source',
+      supported: true,
+      readiness: 'ready',
+      lossKinds: [],
+      categories: [],
+      reason: exactSourceImports
+        ? 'At least one import carries matching source-preservation evidence, so projectNativeImportToSource can emit the original source exactly.'
+        : 'Exact source projection is available when the import carries sourceText or source-preservation evidence whose hash matches the native source hash.',
+      evidence: {
+        imports: imports.length,
+        importsWithExactSource: exactSourceImports
+      },
+      notes: ['Preserved source is the only currently lossless native-source projection mode in this facade.']
+    },
+    stubs: {
+      lossClass: 'nativeSourceStubs',
+      mode: 'native-source-stubs',
+      supported: profile.supportsLightweightScan || declarationImports > 0,
+      readiness: 'needs-review',
+      lossKinds: uniqueStrings([
+        'targetProjectionLoss',
+        ...(declarationImports || profile.supportsLightweightScan ? [] : ['declarationOnlyCoverage'])
+      ]),
+      categories: uniqueStrings([
+        'targetProjectionLoss',
+        ...(declarationImports || profile.supportsLightweightScan ? [] : ['declarationsOnly'])
+      ]),
+      reason: 'Declaration stubs are emitted when exact source is unavailable or disabled; executable bodies and full type semantics remain unavailable.',
+      evidence: {
+        imports: imports.length,
+        importsWithDeclarations: declarationImports
+      },
+      notes: uniqueStrings([
+        'Stub projection is review-required and should not be treated as a round-trip proof.',
+        ...(projectionUnsupportedFeatureLossKinds(knownLossKinds).length
+          ? ['Known source-language feature losses may still be present behind preserved source or stubs.']
+          : [])
+      ])
+    }
+  };
+}
+
+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 sameSourceTarget = nativeLanguageCompileTarget(profile.language, profile.aliases) === normalizedTarget;
+  const hasProjectionAdapter = declaredTargets.has(normalizedTarget) || adapterTargets.has(normalizedTarget);
+  if (!hasProjectionAdapter) {
+    return {
+      target: normalizedTarget,
+      lossClass: 'missingAdapter',
+      supported: false,
+      readiness: 'blocked',
+      lossKinds: ['targetProjectionLoss'],
+      categories: ['targetProjectionLoss'],
+      reason: `No native-to-${normalizedTarget} projection adapter is declared for ${profile.language}.`,
+      adapter: undefined,
+      notes: ['The source can still be preserved or stubbed in its original language when import evidence supports that mode.']
+    };
+  }
+
+  const featureLossKinds = projectionUnsupportedFeatureLossKinds(context.knownLossKinds);
+  if (featureLossKinds.length) {
+    return {
+      target: normalizedTarget,
+      lossClass: 'unsupportedTargetFeatures',
+      supported: true,
+      readiness: 'needs-review',
+      lossKinds: featureLossKinds,
+      categories: uniqueStrings(featureLossKinds.map(nativeImportCategoryForLossKind)),
+      reason: `${profile.language} coverage declares source features that this facade cannot prove lossless for ${normalizedTarget}: ${featureLossKinds.join(', ')}.`,
+      adapter: projectionTargetAdapterName(profile, normalizedTarget, context.matchingAdapters),
+      notes: ['Use exact parser or semantic adapter evidence before treating this target projection as merge-ready.']
+    };
+  }
+
+  if (sameSourceTarget) {
+    return {
+      target: normalizedTarget,
+      lossClass: 'exactSourceProjection',
+      supported: true,
+      readiness: 'ready',
+      lossKinds: [],
+      categories: [],
+      reason: `${profile.language} can project to its source language exactly when source preservation evidence is available.`,
+      adapter: projectionTargetAdapterName(profile, normalizedTarget, context.matchingAdapters),
+      notes: ['Without exact source text, the source projection falls back to declaration stubs.']
+    };
+  }
+
+  return {
+    target: normalizedTarget,
+    lossClass: 'nativeSourceStubs',
+    supported: true,
+    readiness: 'needs-review',
+    lossKinds: ['targetProjectionLoss'],
+    categories: ['targetProjectionLoss'],
+    reason: `${profile.language} declares a ${normalizedTarget} target slot, but this facade only exposes declaration-level native import projection evidence.`,
+    adapter: projectionTargetAdapterName(profile, normalizedTarget, context.matchingAdapters),
+    notes: ['Host-owned semantic adapters can upgrade this cell with stronger evidence.']
+  };
+}
+
+function projectionTargetLossMatrixSummary(languages) {
+  const byLossClass = {};
+  const sourceProjectionByLossClass = {};
+  let targetEntries = 0;
+  for (const language of languages) {
+    for (const projection of [language.sourceProjection?.exactSource, language.sourceProjection?.stubs].filter(Boolean)) {
+      sourceProjectionByLossClass[projection.lossClass] = (sourceProjectionByLossClass[projection.lossClass] ?? 0) + 1;
+    }
+    for (const target of language.targets ?? []) {
+      targetEntries += 1;
+      byLossClass[target.lossClass] = (byLossClass[target.lossClass] ?? 0) + 1;
+    }
+  }
+  return {
+    languages: languages.length,
+    targetEntries,
+    byLossClass,
+    sourceProjectionByLossClass,
+    exactSourceProjection: (sourceProjectionByLossClass.exactSourceProjection ?? 0) + (byLossClass.exactSourceProjection ?? 0),
+    nativeSourceStubs: (sourceProjectionByLossClass.nativeSourceStubs ?? 0) + (byLossClass.nativeSourceStubs ?? 0),
+    unsupportedTargetFeatures: byLossClass.unsupportedTargetFeatures ?? 0,
+    missingAdapters: byLossClass.missingAdapter ?? 0
+  };
+}
+
+function countProjectionLossClasses(entries) {
+  const counts = {};
+  for (const entry of entries ?? []) {
+    counts[entry.lossClass] = (counts[entry.lossClass] ?? 0) + 1;
+  }
+  return counts;
+}
+
+function hasExactSourceProjectionEvidence(imported) {
+  const preservation = imported?.metadata?.sourcePreservation
+    ?? imported?.nativeSource?.metadata?.sourcePreservation
+    ?? imported?.nativeAst?.metadata?.sourcePreservation;
+  const expectedHash = imported?.nativeSource?.sourceHash ?? imported?.nativeAst?.sourceHash ?? imported?.sourceHash;
+  return Boolean(preservation?.summary?.exactSourceAvailable && (!expectedHash || preservation.sourceHash === expectedHash));
+}
+
+function hasNativeProjectionDeclarations(imported) {
+  const semanticIndex = imported?.semanticIndex ?? imported?.universalAst?.semanticIndex;
+  return (semanticIndex?.symbols?.length ?? 0) > 0;
+}
+
+function projectionUnsupportedFeatureLossKinds(lossKinds) {
+  const unsupported = new Set([
+    'macroExpansion',
+    'macroHygiene',
+    'preprocessor',
+    'conditionalCompilation',
+    'metaprogramming',
+    'reflection',
+    'dynamicRuntime',
+    'dynamicDispatch',
+    'generatedCode',
+    'overloadResolution',
+    'typeInference',
+    'unsupportedSyntax',
+    'unsupportedSemantic'
+  ]);
+  return uniqueStrings((lossKinds ?? []).filter((kind) => unsupported.has(kind)));
+}
+
+function adapterProjectionTargets(adapter) {
+  return normalizeProjectionMatrixTargets(
+    adapter?.projectionTargets
+      ?? adapter?.coverage?.projectionTargets
+      ?? adapter?.metadata?.projectionTargets
+      ?? []
+  );
+}
+
+function projectionTargetAdapterName(profile, target, adapters = []) {
+  const adapter = adapters.find((candidate) => adapterProjectionTargets(candidate).includes(target));
+  if (adapter) return adapter.id ?? adapter.parser;
+  return profile.projectionTargets?.includes(target) ? `frontier-native-source-${target}` : undefined;
+}
+
+function nativeLanguageCompileTarget(language, aliases = []) {
+  const ids = [language, ...aliases].map(normalizeNativeLanguageId);
+  if (ids.includes('typescript')) return 'typescript';
+  if (ids.includes('javascript')) return 'javascript';
+  if (ids.includes('rust')) return 'rust';
+  if (ids.includes('python')) return 'python';
+  if (ids.includes('c')) return 'c';
+  return undefined;
+}
+
+function nativeProjectionTargetsForLanguage(language, aliases = []) {
+  const target = nativeLanguageCompileTarget(language, aliases);
+  return target ? [target] : [];
+}
+
 function nativeImportLanguageProfile(language, input = {}) {
   const lossKinds = input.lossKinds ?? ['declarationOnlyCoverage', 'opaqueNative', 'sourceMapApproximation', 'sourcePreservation'];
+  const aliases = uniqueStrings(input.aliases ?? []);
   return Object.freeze({
     language,
-    aliases: Object.freeze(uniqueStrings(input.aliases ?? [])),
+    aliases: Object.freeze(aliases),
     extensions: Object.freeze(uniqueStrings(input.extensions ?? [])),
     supportsLightweightScan: input.supportsLightweightScan !== false,
     parserAdapters: Object.freeze(uniqueStrings(input.parserAdapters ?? ['tree-sitter'])),
-    projectionTargets: Object.freeze(uniqueStrings(input.projectionTargets ?? FrontierCompileTargets)),
+    projectionTargets: Object.freeze(uniqueStrings(input.projectionTargets ?? nativeProjectionTargetsForLanguage(language, aliases))),
     knownLossKinds: Object.freeze(uniqueStrings(lossKinds)),
     defaultReadiness: input.defaultReadiness ?? 'needs-review',
     notes: Object.freeze(uniqueStrings(input.notes ?? ['lightweight scanner records declarations only; exact parser adapters must be injected by the host']))
@@ -3423,7 +3714,7 @@ function normalizeNativeImportLanguageProfile(profile, fallbackLanguage) {
     extensions: uniqueStrings(profile.extensions ?? []),
     supportsLightweightScan: profile.supportsLightweightScan !== false,
     parserAdapters: uniqueStrings(profile.parserAdapters ?? []),
-    projectionTargets: uniqueStrings(profile.projectionTargets ?? FrontierCompileTargets),
+    projectionTargets: uniqueStrings(profile.projectionTargets ?? nativeProjectionTargetsForLanguage(language, profile.aliases ?? [])),
     knownLossKinds: uniqueStrings(profile.knownLossKinds ?? profile.lossKinds ?? []),
     defaultReadiness: profile.defaultReadiness ?? 'needs-review',
     notes: uniqueStrings(profile.notes ?? [])

package/package.json

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