@shapeshift-labs/frontier-lang-compiler 0.2.66 → 0.2.68

package/README.md

@@ -439,6 +439,8 @@ const imported = importNativeSource({
 const slice = createSemanticSlice(imported, {
   entryRefs: ['symbol:parseExpression'],
   includeDependencies: true,
+  expectedSymbols: ['parseExpression'],
+  expectedSourceHashes: { 'src/parser.ts': imported.nativeSource.sourceHash },
   focusedCommands: ['npm test -- parser-expression'],
   fixtureHints: ['operator precedence corpus']
 });
@@ -448,17 +450,19 @@ console.log(slice.mergeAdmission.conflictKeys); // semantic ownership keys
 console.log(slice.sourceFiles[0].sourceHash); // stale-check input for admission
 
 const gate = testSemanticSlice(slice, {
-  currentSources: { 'src/parser.ts': sourceText }
+  currentSources: { 'src/parser.ts': sourceText },
+  expectedRegions: [slice.ownershipRegions[0].key]
 });
 
 console.log(gate.status); // "passed", "needs-review", or "failed"
 const admission = createSemanticSliceAdmissionRecord(slice, { testResult: gate });
 console.log(admission.mergeScore.value); // sortable 0-100 semantic merge score
+console.log(admission.selectedSurface.sourceHashes); // compact selected-surface evidence
 console.log(admission.autoMergeClaim); // always false
 console.log(writeSemanticSliceJson(slice)); // stable JSON for worker inputs
 ```
 
-A semantic slice is the small unit a swarm can hand to a worker instead of copying a full repository. It carries the selected symbols, ownership regions, native nodes, relations, occurrences, source-map links, source spans, source excerpts, source hashes, focused verification commands, fixture hints, and merge-admission metadata. It does not claim the patch is correct; it makes the context and conflicts machine-readable so admission scoring can combine changed ownership, focused test status, stale/source-hash checks, evidence, and semantic risk in one sortable record.
+A semantic slice is the small unit a swarm can hand to a worker instead of copying a full repository. It carries the selected symbols, ownership regions, native nodes, relations, occurrences, source-map links, source spans, source excerpts, source hashes, focused verification commands, fixture hints, and merge-admission metadata. Slice tests can assert exact selected symbols, regions, source-file hashes, and expected counts; admission records also include a compact `selectedSurface` plus `semantic-slice-selected-surface` evidence with hashes and spans but no whole-repository source copy. It does not claim the patch is correct; it makes the context and conflicts machine-readable so admission scoring can combine changed ownership, focused test status, stale/source-hash checks, evidence, and semantic risk in one sortable record.
 
 Slice admission records add a compact `frontier.lang.semanticMergeScore.v1` score with semantic-selection, source-freshness, ownership-isolation, verification-evidence, and review-risk components. They are built for coordinator queues and dashboards: sort likely useful slices first, reject stale or empty slices early, and keep correctness proof separate from merge metadata.
 

package/bench/smoke.mjs

@@ -3,12 +3,14 @@ import { collectNativeImports } from './native-import-suite.mjs';
 import { measureNativeMatrices } from './native-matrix-suite.mjs';
 import { measureNativeTransformations } from './native-transform-suite.mjs';
 import { measureSourceChangeSuites } from './source-change-suite.mjs';
+import { measureUniversalFixtureSuite } from './universal-fixture-suite.mjs';
 
 const compileMetrics = measureFrontierCompile();
 const importMetrics = await collectNativeImports();
 const matrixMetrics = measureNativeMatrices(importMetrics.nativeImportResults, importMetrics.adapters);
 const transformMetrics = measureNativeTransformations(importMetrics.nativeImportResults);
 const sourceChangeMetrics = measureSourceChangeSuites();
+const universalFixtureMetrics = measureUniversalFixtureSuite(importMetrics.adapters);
 
 console.log(JSON.stringify({
   compiles: 250,
@@ -107,5 +109,17 @@ console.log(JSON.stringify({
   externalSemanticImports: sourceChangeMetrics.externalSemanticImports,
   externalSemanticSymbols: sourceChangeMetrics.externalSemanticSymbols,
   externalSemanticMappings: sourceChangeMetrics.externalSemanticMappings,
-  externalSemanticDurationMs: Number(sourceChangeMetrics.externalSemanticDurationMs.toFixed(2))
+  externalSemanticDurationMs: Number(sourceChangeMetrics.externalSemanticDurationMs.toFixed(2)),
+  universalFixtureImports: universalFixtureMetrics.imports,
+  universalFixtureLanguages: universalFixtureMetrics.languages,
+  universalFixtureRoutes: universalFixtureMetrics.routes,
+  universalFixtureTargetAdapterRoutes: universalFixtureMetrics.targetAdapterRoutes,
+  universalFixtureSemanticIndexOnlyRoutes: universalFixtureMetrics.semanticIndexOnlyRoutes,
+  universalFixtureRouteScoreMin: universalFixtureMetrics.routeScoreMin,
+  universalFixtureRouteScoreMax: universalFixtureMetrics.routeScoreMax,
+  universalFixtureLossSummaries: universalFixtureMetrics.lossSummaries,
+  universalFixtureLossCategories: universalFixtureMetrics.lossCategories,
+  universalFixtureCandidateRecords: universalFixtureMetrics.candidateRecords,
+  universalFixtureBestCandidateSortKey: universalFixtureMetrics.bestCandidateSortKey,
+  universalFixtureDurationMs: Number(universalFixtureMetrics.durationMs.toFixed(2))
 }));

package/bench/universal-fixture-suite.mjs

@@ -0,0 +1,183 @@
+import { performance } from 'node:perf_hooks';
+import {
+  createSemanticMergeCandidateAdmissionRecord,
+  createUniversalCapabilityMatrix,
+  createUniversalConversionArtifacts,
+  createUniversalConversionPlan,
+  diffNativeSources,
+  importNativeSource,
+  sortSemanticMergeCandidateAdmissionRecords,
+  summarizeNativeImportLosses
+} from '../dist/index.js';
+import { createBenchMatrixAdapters } from './native-adapters.mjs';
+
+const requiredFeatures = ['syntax', 'semantic', 'sourcePreservation'];
+const targets = ['javascript', 'python', 'rust', 'c'];
+const handledHighRiskLossKinds = [
+  'conditionalCompilation',
+  'dynamicDispatch',
+  'dynamicRuntime',
+  'generatedCode',
+  'macroExpansion',
+  'macroHygiene',
+  'metaprogramming',
+  'overloadResolution',
+  'preprocessor',
+  'reflection',
+  'typeInference',
+  'unsupportedSemantic',
+  'unsupportedSyntax'
+];
+
+export function measureUniversalFixtureSuite(adapters) {
+  const start = performance.now();
+  const imports = createImports();
+  const targetAdapters = createTargetAdapters();
+  const matrix = createUniversalCapabilityMatrix({
+    generatedAt: 1201,
+    imports,
+    adapters: createBenchMatrixAdapters(adapters),
+    targetAdapters,
+    targets,
+    requiredFeatures
+  });
+  const plan = createUniversalConversionPlan({
+    generatedAt: 1202,
+    imports,
+    adapters: createBenchMatrixAdapters(adapters),
+    targetAdapters,
+    targets,
+    requiredFeatures,
+    evidence: [{
+      id: 'bench_universal_fixture_replay',
+      kind: 'conversion-replay-proof',
+      status: 'passed'
+    }]
+  });
+  const artifacts = createUniversalConversionArtifacts(plan, { generatedAt: 1203 });
+  const lossSummaries = imports.map((imported) => summarizeNativeImportLosses(imported.losses, {
+    evidence: imported.evidence,
+    exactAst: imported.metadata?.nativeImportLossSummary?.exactAst
+  }));
+  const candidateRecords = sortSemanticMergeCandidateAdmissionRecords(createCandidateRecords());
+  const routeScores = plan.routes.map((route) => route.mergeScore.value);
+  return {
+    imports: imports.length,
+    languages: matrix.summary.languages,
+    routes: plan.routes.length,
+    targetAdapterRoutes: plan.summary.targetAdapterRoutes,
+    semanticIndexOnlyRoutes: plan.summary.semanticIndexOnlyRoutes,
+    routeScoreMin: Math.min(...routeScores),
+    routeScoreMax: Math.max(...routeScores),
+    lossSummaries: lossSummaries.length,
+    lossCategories: lossSummaries.reduce((sum, summary) => sum + summary.categories.length, 0),
+    candidateRecords: candidateRecords.length,
+    bestCandidateSortKey: candidateRecords[0]?.readinessSortKey ?? 0,
+    artifactAdmissionRecords: artifacts.summary.admissionRecords,
+    durationMs: performance.now() - start
+  };
+}
+
+function createImports() {
+  return [{
+    language: 'javascript',
+    sourcePath: 'src/bench-universal.js',
+    sourceText: 'export function benchUniversal(value) { return value + 1; }\n'
+  }, {
+    language: 'python',
+    sourcePath: 'bench_universal.py',
+    sourceText: 'def bench_universal(value):\n    return value + 1\n'
+  }, {
+    language: 'rust',
+    sourcePath: 'src/bench_universal.rs',
+    sourceText: 'pub fn bench_universal(value: i32) -> i32 { value + 1 }\nmacro_rules! bench_universal_macro { () => {} }\n'
+  }, {
+    language: 'c',
+    sourcePath: 'bench_universal.h',
+    sourceText: '#define BENCH_UNIVERSAL 1\ntypedef struct BenchUniversal { int value; } BenchUniversal;\nint bench_universal(void);\n'
+  }, {
+    language: 'go',
+    sourcePath: 'bench_universal.go',
+    sourceText: 'package bench\nfunc BenchUniversal(value int) int { return value + 1 }\n'
+  }, {
+    language: 'swift',
+    sourcePath: 'BenchUniversal.swift',
+    sourceText: 'struct BenchUniversal { var value: Int }\nfunc benchUniversal(_ value: Int) -> Int { value + 1 }\n'
+  }, {
+    language: 'r',
+    sourcePath: 'bench_universal.R',
+    sourceText: 'bench_universal <- function(value) { value + 1 }\neval(parse(text = "generated <- TRUE"))\n'
+  }].map((fixture) => importNativeSource(fixture));
+}
+
+function createTargetAdapters() {
+  return [{
+    id: 'bench-js-to-rust-universal-fixture',
+    sourceLanguage: 'javascript',
+    target: 'rust',
+    coverage: { readiness: 'ready', handledLossKinds: handledHighRiskLossKinds },
+    project() {
+      return { output: 'pub fn bench_js_to_rust() {}\n', readiness: 'ready' };
+    }
+  }, {
+    id: 'bench-python-to-rust-universal-fixture',
+    sourceLanguage: 'python',
+    target: 'rust',
+    coverage: { readiness: 'ready', handledLossKinds: handledHighRiskLossKinds },
+    project() {
+      return { output: 'pub fn bench_python_to_rust() {}\n', readiness: 'ready' };
+    }
+  }, {
+    id: 'bench-c-to-rust-universal-fixture',
+    sourceLanguage: 'c',
+    target: 'rust',
+    coverage: { readiness: 'ready', handledLossKinds: handledHighRiskLossKinds },
+    project() {
+      return { output: 'pub fn bench_c_to_rust() {}\n', readiness: 'ready' };
+    }
+  }];
+}
+
+function createCandidateRecords() {
+  return [{
+    language: 'javascript',
+    sourcePath: 'src/bench-candidate.js',
+    beforeSourceText: 'export function benchCandidate(value) { return value + 1; }\n',
+    afterSourceText: 'export function benchCandidate(value) { return value + 2; }\n',
+    readiness: 'ready'
+  }, {
+    language: 'python',
+    sourcePath: 'bench_candidate.py',
+    beforeSourceText: 'def bench_candidate(value):\n    return value + 1\n',
+    afterSourceText: 'def bench_candidate(value):\n    return value + 2\n',
+    readiness: 'ready-with-losses'
+  }, {
+    language: 'rust',
+    sourcePath: 'src/bench_candidate.rs',
+    beforeSourceText: 'pub fn bench_candidate(value: i32) -> i32 { value + 1 }\n',
+    afterSourceText: 'pub fn bench_candidate(value: i32) -> i32 { value + 2 }\n',
+    readiness: 'needs-review'
+  }, {
+    language: 'c',
+    sourcePath: 'bench_candidate.c',
+    beforeSourceText: 'int bench_candidate(int value) { return value + 1; }\n',
+    afterSourceText: 'int bench_candidate(int value) { return value + 2; }\n',
+    readiness: 'blocked'
+  }].map((spec, index) => createSemanticMergeCandidateAdmissionRecord(diffNativeSources({
+    id: `bench_candidate_change_${index}`,
+    language: spec.language,
+    sourcePath: spec.sourcePath,
+    beforeSourceText: spec.beforeSourceText,
+    afterSourceText: spec.afterSourceText,
+    evidenceId: `bench_candidate_evidence_${index}`,
+    patchId: `bench_candidate_patch_${index}`,
+    mergeCandidateId: `bench_candidate_${index}`
+  }), {
+    readiness: spec.readiness,
+    evidence: [{
+      id: `bench_candidate_verification_${index}`,
+      kind: 'candidate-verification-proof',
+      status: 'passed'
+    }]
+  }));
+}

package/dist/declarations/native-project-admission.d.ts

@@ -9,6 +9,107 @@ export type NativeProjectImportAdmissionPriority = 'low' | 'normal' | 'high' | '
 export type NativeProjectImportAdmissionRisk = 'low' | 'medium' | 'high' | 'unknown';
 export type NativeProjectSourcePreservationQuality = 'exact' | 'lossy' | 'missing' | 'stale' | 'empty';
 
+export interface NativeProjectAdmissionParserEvidence {
+  readonly parser?: string;
+  readonly astFormat?: string;
+  readonly exactness?: string;
+  readonly semanticCoverageLevel?: string;
+  readonly exactAst: boolean;
+  readonly tokens: boolean;
+  readonly trivia: boolean;
+  readonly diagnostics: boolean;
+  readonly diagnosticCount: number;
+  readonly sourceRanges: boolean;
+  readonly generatedRanges: boolean;
+  readonly evidenceRecords: number;
+  readonly missing: boolean;
+}
+
+export interface NativeProjectAdmissionParserEvidenceSummary {
+  readonly parsers: readonly string[];
+  readonly byParser: Readonly<Record<string, number>>;
+  readonly byExactness: Readonly<Record<string, number>>;
+  readonly semanticCoverageLevels: readonly string[];
+  readonly exactAstSources: number;
+  readonly tokenSources: number;
+  readonly triviaSources: number;
+  readonly sourceRangeSources: number;
+  readonly generatedRangeSources: number;
+  readonly diagnosticsSources: number;
+  readonly missingParserSources: number;
+  readonly evidenceRecords: number;
+}
+
+export interface NativeProjectAdmissionSemanticMergeScoreSummary {
+  readonly sourceCount: number;
+  readonly min: number;
+  readonly max: number;
+  readonly average: number;
+  readonly sortKey: number;
+  readonly lowestSourcePaths: readonly string[];
+}
+
+export interface NativeProjectAdmissionMissingEvidenceHint {
+  readonly evidenceKey?: string;
+  readonly task: string;
+  readonly count: number;
+  readonly sourcePaths: readonly string[];
+  readonly languages: readonly string[];
+  readonly lossIds: readonly string[];
+  readonly lossKinds: readonly string[];
+  readonly lossClasses: readonly string[];
+  readonly readiness: SemanticMergeReadiness;
+}
+
+export interface NativeProjectAdmissionTaskHint {
+  readonly id?: string;
+  readonly task: string;
+  readonly reason?: string;
+  readonly priority: NativeProjectImportAdmissionPriority;
+  readonly readiness: SemanticMergeReadiness;
+  readonly count: number;
+  readonly sourcePaths: readonly string[];
+  readonly languages: readonly string[];
+  readonly lossClasses: readonly string[];
+  readonly evidenceKeys: readonly string[];
+}
+
+export interface NativeProjectAdmissionSourceSummary {
+  readonly id?: string;
+  readonly language: FrontierSourceLanguage | string;
+  readonly sourcePath?: string;
+  readonly sourceHash?: string;
+  readonly readiness: SemanticMergeReadiness;
+  readonly parser?: string;
+  readonly parserEvidence: NativeProjectAdmissionParserEvidence;
+  readonly semanticCounts: {
+    readonly symbols: number;
+    readonly occurrences: number;
+    readonly relations: number;
+    readonly facts: number;
+  };
+  readonly semanticSymbols: number;
+  readonly emptySemanticEvidence: boolean;
+  readonly sourcePreservationQuality: NativeProjectSourcePreservationQuality;
+  readonly lossClasses: readonly string[];
+  readonly semanticMergeScore: number;
+  readonly missingEvidence: readonly NativeProjectAdmissionMissingEvidenceHint[];
+  readonly nextMissingTask?: NativeProjectAdmissionTaskHint;
+  readonly nextMissingTasks: readonly NativeProjectAdmissionTaskHint[];
+}
+
+export interface NativeProjectAdmissionLanguageReadinessSummary {
+  readonly language: FrontierSourceLanguage | string;
+  readonly readiness: SemanticMergeReadiness;
+  readonly sourceCount: number;
+  readonly sourcePaths: readonly string[];
+  readonly byLossClass: Readonly<Record<string, number>>;
+  readonly parserEvidence: NativeProjectAdmissionParserEvidenceSummary;
+  readonly semanticMergeScore: NativeProjectAdmissionSemanticMergeScoreSummary;
+  readonly topMissingEvidence: readonly NativeProjectAdmissionMissingEvidenceHint[];
+  readonly nextMissingTasks: readonly NativeProjectAdmissionTaskHint[];
+}
+
 export interface NativeProjectAdmissionLanguageSummary {
   readonly language: FrontierSourceLanguage | string;
   readonly sourceCount: number;
@@ -20,12 +121,26 @@ export interface NativeProjectAdmissionLanguageSummary {
   readonly staleSourcePaths: readonly string[];
   readonly mergeCandidates: number;
   readonly highestRisk: NativeProjectImportAdmissionRisk;
+  readonly byReadiness: Readonly<Record<string, number>>;
+  readonly byLossClass: Readonly<Record<string, number>>;
+  readonly parserEvidence: NativeProjectAdmissionParserEvidenceSummary;
+  readonly semanticMergeScore: NativeProjectAdmissionSemanticMergeScoreSummary;
+  readonly topMissingEvidence: readonly NativeProjectAdmissionMissingEvidenceHint[];
+  readonly nextMissingTasks: readonly NativeProjectAdmissionTaskHint[];
 }
 
 export interface NativeProjectAdmissionLanguages {
   readonly total: number;
   readonly byReadiness: Readonly<Record<string, number>>;
+  readonly bySourceReadiness: Readonly<Record<string, number>>;
+  readonly byLossClass: Readonly<Record<string, number>>;
   readonly bySourcePreservationQuality: Readonly<Record<string, number>>;
+  readonly parserEvidence: NativeProjectAdmissionParserEvidenceSummary;
+  readonly semanticMergeScore: NativeProjectAdmissionSemanticMergeScoreSummary;
+  readonly topMissingEvidence: readonly NativeProjectAdmissionMissingEvidenceHint[];
+  readonly nextMissingTasks: readonly NativeProjectAdmissionTaskHint[];
+  readonly sourceRows: readonly NativeProjectAdmissionSourceSummary[];
+  readonly readinessRows: readonly NativeProjectAdmissionLanguageReadinessSummary[];
   readonly rows: readonly NativeProjectAdmissionLanguageSummary[];
 }
 

package/dist/declarations/roundtrip-audit.d.ts

@@ -0,0 +1,186 @@
+import type {
+  CompileTarget,
+  FrontierSourceLanguage,
+  SemanticMergeReadiness,
+  SourceMapMappingRecord
+} from '@shapeshift-labs/frontier-lang-kernel';
+import type { ProjectionTargetLossClass } from './projection-coverage.js';
+import type { NativeSourceCompileOutputMode, NativeSourceProjectionMode } from './native-project.js';
+
+export type NativeRoundtripSourceMapPrecision = SourceMapMappingRecord['precision'] | 'line' | 'declaration' | 'estimated' | 'unknown' | 'none' | string;
+
+export type NativeRoundtripAuditDisposition =
+  | 'reversible'
+  | 'preserved-source'
+  | 'stub-only'
+  | 'adapter-projected'
+  | 'review-required';
+
+export type NativeRoundtripAuditClaim =
+  | 'source-text-reversible'
+  | 'source-preserved'
+  | 'declaration-stubs-only'
+  | 'host-adapter-projected'
+  | 'review-required';
+
+export interface NativeRoundtripSourceMapEvidence {
+  readonly total: number;
+  readonly ids: readonly string[];
+  readonly mappings: number;
+  readonly precision: NativeRoundtripSourceMapPrecision;
+  readonly byPrecision: Readonly<Record<string, number>>;
+  readonly byOrigin: Readonly<Record<string, number>>;
+  readonly withSourceSpan: number;
+  readonly withGeneratedSpan: number;
+  readonly withSemanticSymbol: number;
+  readonly targetPaths: readonly string[];
+}
+
+export interface NativeRoundtripRoutePathSignal {
+  readonly selected: boolean;
+  readonly available: boolean;
+  readonly reasonCodes: readonly string[];
+}
+
+export interface NativeRoundtripRoutePathsAudit {
+  readonly reversible: NativeRoundtripRoutePathSignal;
+  readonly preservedSource: NativeRoundtripRoutePathSignal;
+  readonly stubOnly: NativeRoundtripRoutePathSignal;
+  readonly adapterProjected: NativeRoundtripRoutePathSignal;
+}
+
+export interface NativeRoundtripSourcePreservationAudit {
+  readonly id?: string;
+  readonly exactSourceAvailable: boolean;
+  readonly sourceTextAvailable: boolean;
+  readonly recordCount: number;
+  readonly byLevel: Readonly<Record<string, number>>;
+  readonly exactRecords: number;
+  readonly declarationRecords: number;
+  readonly estimatedRecords: number;
+  readonly blockedRecords: number;
+  readonly sourcePaths: readonly string[];
+  readonly sourceMapIds: readonly string[];
+  readonly mappingPreservation: Readonly<Record<string, number>>;
+  readonly comments: number;
+  readonly trivia: number;
+  readonly directives: number;
+  readonly tokens: number;
+  readonly whitespace: number;
+  readonly truncated: boolean;
+}
+
+export interface NativeRoundtripGeneratedStubsAudit {
+  readonly available: boolean;
+  readonly selected: boolean;
+  readonly projectionMode?: NativeSourceProjectionMode;
+  readonly outputMode?: NativeSourceCompileOutputMode;
+  readonly declarationCount: number;
+  readonly emittedDeclarationCount: number;
+  readonly declarationKinds: Readonly<Record<string, number>>;
+  readonly declarationsWithSourceSpan: number;
+  readonly symbolIds: readonly string[];
+  readonly nativeAstNodeIds: readonly string[];
+  readonly lossCount: number;
+}
+
+export interface NativeRoundtripAdapterProjectionAudit {
+  readonly available: boolean;
+  readonly selected: boolean;
+  readonly id?: string;
+  readonly adapterId?: string;
+  readonly adapterVersion?: string;
+  readonly outputMode?: 'target-adapter';
+  readonly readiness?: SemanticMergeReadiness;
+  readonly lossCount: number;
+  readonly evidenceIds: readonly string[];
+  readonly sourceMaps: NativeRoundtripSourceMapEvidence;
+}
+
+export interface NativeRoundtripRouteSourceMapsAudit {
+  readonly hasOutputSourceMaps: boolean;
+  readonly output: NativeRoundtripSourceMapEvidence;
+  readonly universal: NativeRoundtripSourceMapEvidence;
+  readonly outputExact: boolean;
+  readonly outputEstimated: boolean;
+  readonly universalEstimated: boolean;
+}
+
+export interface NativeRoundtripHashChecksAudit {
+  readonly sourceHashPresent: boolean;
+  readonly declaredSourceHashPresent: boolean;
+  readonly declaredSourceHashVerified?: boolean;
+  readonly expectedSourceHashPresent: boolean;
+  readonly outputHashPresent: boolean;
+  readonly projectionOutputHashPresent: boolean;
+  readonly targetOutputHashPresent: boolean;
+  readonly sourceHashVerified: boolean;
+  readonly projectionOutputMatchesSourceHash: boolean;
+  readonly targetOutputMatchesSourceHash: boolean;
+  readonly outputMatchesSourceHash: boolean;
+}
+
+export interface NativeRoundtripCommentsTriviaAudit {
+  readonly comments: number;
+  readonly trivia: number;
+  readonly directives: number;
+  readonly tokens: number;
+  readonly whitespace: number;
+  readonly truncated: boolean;
+  readonly exactSourceAvailable: boolean;
+  readonly sourceTextAvailable: boolean;
+}
+
+export interface NativeRoundtripTargetCoverageAudit {
+  readonly target?: CompileTarget | string;
+  readonly supported?: boolean;
+  readonly readiness?: SemanticMergeReadiness;
+  readonly lossClass?: ProjectionTargetLossClass | string;
+  readonly adapterId?: string;
+  readonly adapterKind?: string;
+  readonly adapterVersion?: string;
+  readonly lossKinds: readonly string[];
+  readonly categories: readonly string[];
+  readonly reason?: string;
+  readonly notes: readonly string[];
+}
+
+export interface NativeRoundtripSemanticEquivalenceAudit {
+  readonly claimed: false;
+  readonly proofAdapterId?: string;
+  readonly evidenceIds: readonly string[];
+  readonly reasonCode: string;
+}
+
+export interface NativeRoundtripAuditSignal {
+  readonly schema: 'frontier.lang.nativeRoundtripAuditSignal';
+  readonly version: 1;
+  readonly disposition: NativeRoundtripAuditDisposition;
+  readonly claim: NativeRoundtripAuditClaim;
+  readonly sourceLanguage?: FrontierSourceLanguage | string;
+  readonly target?: CompileTarget | string;
+  readonly sameLanguage: boolean;
+  readonly outputMode?: NativeSourceCompileOutputMode;
+  readonly projectionMode?: NativeSourceProjectionMode;
+  readonly sourceHashVerified: boolean;
+  readonly outputSourceMapPrecision: NativeRoundtripSourceMapPrecision;
+  readonly universalSourceMapPrecision: NativeRoundtripSourceMapPrecision;
+  readonly targetProjectionAdapterId?: string;
+  readonly targetCoverageLossClass?: ProjectionTargetLossClass | string;
+  readonly reviewRequired: boolean;
+  readonly semanticMergeReadiness: SemanticMergeReadiness;
+  readonly semanticEquivalenceClaim: false;
+  readonly autoMergeClaim: false;
+  readonly paths: NativeRoundtripRoutePathsAudit;
+  readonly sourcePreservation: NativeRoundtripSourcePreservationAudit;
+  readonly generatedStubs: NativeRoundtripGeneratedStubsAudit;
+  readonly adapterProjection: NativeRoundtripAdapterProjectionAudit;
+  readonly sourceMaps: NativeRoundtripRouteSourceMapsAudit;
+  readonly hashChecks: NativeRoundtripHashChecksAudit;
+  readonly commentsTrivia: NativeRoundtripCommentsTriviaAudit;
+  readonly targetCoverage: NativeRoundtripTargetCoverageAudit;
+  readonly semanticEquivalence: NativeRoundtripSemanticEquivalenceAudit;
+  readonly blockingLossCount: number;
+  readonly reviewLossCount: number;
+  readonly reasonCodes: readonly string[];
+}

package/dist/declarations/roundtrip.d.ts

@@ -105,59 +105,8 @@ export interface NativeImportRoundtripReadinessClassification {
 
 export type NativeRoundtripEvidenceStatus = NativeImportRoundtripReadinessStatus | 'target-adapter';
 
-export type NativeRoundtripSourceMapPrecision = SourceMapMappingRecord['precision'] | 'line' | 'declaration' | 'estimated' | 'unknown' | 'none' | string;
-
-export type NativeRoundtripAuditDisposition =
-  | 'reversible'
-  | 'preserved-source'
-  | 'stub-only'
-  | 'adapter-projected'
-  | 'review-required';
-
-export type NativeRoundtripAuditClaim =
-  | 'source-text-reversible'
-  | 'source-preserved'
-  | 'declaration-stubs-only'
-  | 'host-adapter-projected'
-  | 'review-required';
-
-export interface NativeRoundtripSourceMapEvidence {
-  readonly total: number;
-  readonly ids: readonly string[];
-  readonly mappings: number;
-  readonly precision: NativeRoundtripSourceMapPrecision;
-  readonly byPrecision: Readonly<Record<string, number>>;
-  readonly byOrigin: Readonly<Record<string, number>>;
-  readonly withSourceSpan: number;
-  readonly withGeneratedSpan: number;
-  readonly withSemanticSymbol: number;
-  readonly targetPaths: readonly string[];
-}
-
-export interface NativeRoundtripAuditSignal {
-  readonly schema: 'frontier.lang.nativeRoundtripAuditSignal';
-  readonly version: 1;
-  readonly disposition: NativeRoundtripAuditDisposition;
-  readonly claim: NativeRoundtripAuditClaim;
-  readonly sourceLanguage?: FrontierSourceLanguage | string;
-  readonly target?: CompileTarget | string;
-  readonly sameLanguage: boolean;
-  readonly outputMode?: NativeSourceCompileOutputMode;
-  readonly projectionMode?: NativeSourceProjectionMode;
-  readonly sourceHashVerified: boolean;
-  readonly outputSourceMapPrecision: NativeRoundtripSourceMapPrecision;
-  readonly universalSourceMapPrecision: NativeRoundtripSourceMapPrecision;
-  readonly targetProjectionAdapterId?: string;
-  readonly targetCoverageLossClass?: ProjectionTargetLossClass | string;
-  readonly reviewRequired: boolean;
-  readonly semanticMergeReadiness: SemanticMergeReadiness;
-  readonly semanticEquivalenceClaim: false;
-  readonly autoMergeClaim: false;
-  readonly blockingLossCount: number;
-  readonly reviewLossCount: number;
-  readonly reasonCodes: readonly string[];
-}
-
+import type { NativeRoundtripSourceMapPrecision, NativeRoundtripAuditDisposition, NativeRoundtripAuditClaim, NativeRoundtripSourceMapEvidence, NativeRoundtripRoutePathSignal, NativeRoundtripRoutePathsAudit, NativeRoundtripSourcePreservationAudit, NativeRoundtripGeneratedStubsAudit, NativeRoundtripAdapterProjectionAudit, NativeRoundtripRouteSourceMapsAudit, NativeRoundtripHashChecksAudit, NativeRoundtripCommentsTriviaAudit, NativeRoundtripTargetCoverageAudit, NativeRoundtripSemanticEquivalenceAudit, NativeRoundtripAuditSignal } from './roundtrip-audit.js';
+export type { NativeRoundtripSourceMapPrecision, NativeRoundtripAuditDisposition, NativeRoundtripAuditClaim, NativeRoundtripSourceMapEvidence, NativeRoundtripRoutePathSignal, NativeRoundtripRoutePathsAudit, NativeRoundtripSourcePreservationAudit, NativeRoundtripGeneratedStubsAudit, NativeRoundtripAdapterProjectionAudit, NativeRoundtripRouteSourceMapsAudit, NativeRoundtripHashChecksAudit, NativeRoundtripCommentsTriviaAudit, NativeRoundtripTargetCoverageAudit, NativeRoundtripSemanticEquivalenceAudit, NativeRoundtripAuditSignal } from './roundtrip-audit.js';
 export interface NativeRoundtripEvidenceMetadata {
   readonly status: NativeRoundtripEvidenceStatus;
   readonly semanticMergeReadiness: SemanticMergeReadiness;

package/dist/declarations/runtime.d.ts

@@ -89,16 +89,6 @@ export declare function createNativeParserFeatureMatrix(options?: NativeParserFe
 export declare function queryNativeParserFeatureMatrix(matrixOrOptions?: NativeParserFeatureMatrix | NativeParserFeatureMatrixOptions, query?: NativeParserFeatureMatrixQuery): NativeParserFeatureMatrixQueryResult;
 export declare function createProjectionTargetLossMatrix(options?: ProjectionTargetLossMatrixOptions): ProjectionTargetLossMatrix;
 export declare function createUniversalCapabilityMatrix(options?: UniversalCapabilityMatrixOptions): UniversalCapabilityMatrix;
-export declare function createUniversalConversionArtifacts(input?: CreateUniversalConversionArtifactsInput, options?: CreateUniversalConversionArtifactsOptions): UniversalConversionArtifacts;
-export declare function createUniversalConversionPlan(options?: UniversalConversionPlanOptions): UniversalConversionPlan;
-export declare function queryUniversalConversionArtifacts(
-  records: UniversalConversionArtifacts | UniversalConversionRouteArtifact | readonly (UniversalConversionArtifacts | UniversalConversionRouteArtifact)[],
-  query?: UniversalConversionArtifactQuery
-): readonly UniversalConversionRouteArtifact[];
-export declare function queryUniversalConversionPlan(
-  planOrOptions?: UniversalConversionPlan | UniversalConversionPlanOptions,
-  query?: UniversalConversionPlanQuery
-): UniversalConversionPlanQueryResult;
 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;
@@ -122,7 +112,6 @@ export declare function importNativeSource(input: ImportNativeSourceOptions): Na
 export declare function diffNativeSources(input: DiffNativeSourcesOptions): NativeSourceChangeSet;
 export declare function diffNativeSourceImports(input: DiffNativeSourceImportsOptions): NativeSourceChangeSet;
 export declare function createSemanticSlice(input: SemanticSliceInput, options?: CreateSemanticSliceOptions): SemanticSlice;
-export declare function createSemanticSliceAdmissionRecord(slice: SemanticSlice, options?: CreateSemanticSliceAdmissionRecordOptions): SemanticSliceAdmissionRecord;
 export declare function testSemanticSlice(slice: SemanticSlice, options?: TestSemanticSliceOptions): SemanticSliceTestResult;
 export declare function readSemanticSliceJson(source: string): SemanticSlice;
 export declare function writeSemanticSliceJson(slice: SemanticSlice): string;