@shapeshift-labs/frontier-lang-compiler 0.2.65 → 0.2.67

package/README.md

@@ -36,17 +36,19 @@ npm run build
 node examples/native-js-to-rust-demo.mjs
 ```
 
-Run the interactive Frontier-style workbench with editable TypeScript and Rust panes:
+Run the interactive Frontier-style workbench with a submitted TypeScript source pane,
+Frontier graph/JSON pane, and independent Rust/Python projection panes:
 
 ```sh
 npm run demo:ts-rust -- --port 4177
 ```
 
 The workbench converts only when `Run` is pressed. TypeScript edits project through
-the Frontier semantic graph into Rust scaffolding; Rust edits project back through
-the graph into TypeScript scaffolding. The middle pane shows symbols, relations,
-source maps, readiness, losses, patch hints, and the explicit supported/review-only/
-unsupported bounds for the current direction.
+the Frontier semantic graph into Rust and Python scaffolding. The middle pane shows
+symbols, relations, source maps, readiness, losses, patch hints, and the explicit
+supported/review-only/unsupported bounds for the projection. Run
+`npm run demo:ts-rust:smoke` to verify the conversion output and layout scaffold
+without starting the server.
 
 The demo prints JavaScript source, the Frontier universal AST/semantic-index summary,
 Rust declaration stubs, a host-adapter Rust projection, and a direct Frontier-source
@@ -117,11 +119,12 @@ const importedIndex = importExternalSemanticIndex({
 });
 
 console.log(importedIndex.semanticIndex.symbols.length);
+console.log(importedIndex.ownershipRegions[0]?.key);
 console.log(importedIndex.summary.sourceMapMappings);
 console.log(importedIndex.readiness.readiness); // "ready-with-losses" or review-required
 ```
 
-External semantic-index imports create Frontier `SemanticIndexRecord`, `SourceMapRecord`, evidence, losses, ownership facts, and a universal AST envelope. They are a bridge from existing language servers/indexers into semantic merge tooling; they do not claim full parser AST coverage, macro expansion, type checking, comments/trivia preservation, or lossless cross-language code generation by themselves.
+External semantic-index imports create Frontier `SemanticIndexRecord`, `SourceMapRecord`, evidence, losses, ownership facts, first-class `ownershipRegions`, and a universal AST envelope. They are a bridge from existing language servers/indexers into semantic merge tooling; they do not claim full parser AST coverage, macro expansion, type checking, comments/trivia preservation, or lossless cross-language code generation by themselves.
 
 Native imports include source maps, semantic merge candidates, and a loss summary for admission queues and dashboards. Informational losses produce `ready-with-losses`, warning losses produce `needs-review`, and error losses or failed import evidence produce `blocked`:
 
@@ -137,6 +140,28 @@ console.log(readiness.readiness);
 
 The loss taxonomy separates broad scanner limits from specific round-trip risks such as conditional compilation, reflection, overload/type-inference gaps, comments/trivia preservation, source-map approximation, parser diagnostics, and target projection loss. These records are evidence labels for merge admission; they are not claims that the lightweight scanner expanded macros, evaluated inactive branches, resolved overloads, or ran a type checker.
 
+Semantic merge candidates also expose compiler-normalized admission records for coordinator queues:
+
+```js
+import {
+  createSemanticMergeCandidateAdmissionRecord,
+  querySemanticMergeCandidateAdmissionOverlaps,
+  sortSemanticMergeCandidateAdmissionRecords
+} from '@shapeshift-labs/frontier-lang-compiler';
+
+const record = createSemanticMergeCandidateAdmissionRecord(changeSet);
+
+console.log(record.changedSemanticRegions);
+console.log(record.sourceHashes.baseHash, record.sourceHashes.targetHash);
+console.log(record.conflictKeys, record.evidenceIds);
+console.log(record.projectionRisk, record.readiness, record.readinessSortKey);
+
+const queue = sortSemanticMergeCandidateAdmissionRecords([record, otherRecord]);
+const overlaps = querySemanticMergeCandidateAdmissionOverlaps(queue);
+```
+
+These candidate records are compact merge-admission evidence. They preserve changed semantic regions, source/base/target hashes, conflict keys, evidence IDs, projection risk, readiness, and overlap pairs so swarm coordinators can sort likely-ready candidates first and detect conflicting regions before patch review.
+
 High-risk native features also have explicit evidence policies. These policies are advisory in this package: they tell a swarm or admission queue what evidence is missing without silently changing the existing readiness classification.
 
 ```js
@@ -414,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']
 });
@@ -423,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/import-adapter-core.d.ts

@@ -154,6 +154,8 @@ export interface ExternalSemanticIndexImportSummary {
   readonly occurrences: number;
   readonly relations: number;
   readonly facts: number;
+  readonly ownershipRegions: number;
+  readonly ownershipRegionKinds: readonly string[];
   readonly sourceMapMappings: number;
   readonly losses: number;
   readonly readiness: SemanticMergeReadiness;
@@ -170,6 +172,7 @@ export interface ExternalSemanticIndexImportResult {
   readonly semanticIndex: SemanticIndexRecord;
   readonly universalAst: FrontierUniversalAstEnvelope;
   readonly sourceMaps: readonly SourceMapRecord[];
+  readonly ownershipRegions: readonly SemanticImportOwnershipRegion[];
   readonly losses: readonly NativeAstLossRecord[];
   readonly evidence: readonly EvidenceRecord[];
   readonly readiness: NativeImportReadinessClassification;

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

@@ -2,12 +2,114 @@ import type { FrontierSourceLanguage, SemanticMergeReadiness } from '@shapeshift
 import type { NativeImportLossSummary } from './native-import-losses.js';
 import type { NativeImportResultContract } from './native-import-contracts.js';
 import type { NativeProjectImportResult } from './native-project.js';
+import type { SemanticMergeCandidateAdmissionRecord, SemanticMergeCandidateOverlapRecord, SemanticMergeCandidateProjectionRisk } from './semantic-merge-candidates.js';
 
 export type NativeProjectImportAdmissionAction = 'admit' | 'prioritize' | 'reject';
 export type NativeProjectImportAdmissionPriority = 'low' | 'normal' | 'high' | 'critical' | 'blocker';
 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;
@@ -19,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[];
 }
 
@@ -78,10 +194,27 @@ export interface NativeProjectAdmissionMergeCandidates {
   readonly highestRisk: NativeProjectImportAdmissionRisk;
   readonly byRisk: Readonly<Record<string, number>>;
   readonly byReadiness: Readonly<Record<string, number>>;
+  readonly byProjectionRisk: Readonly<Record<string, number>>;
   readonly highRiskCandidateIds: readonly string[];
   readonly reviewCandidateIds: readonly string[];
   readonly blockedCandidateIds: readonly string[];
+  readonly highProjectionRiskCandidateIds: readonly string[];
   readonly conflictKeys: readonly string[];
+  readonly readinessOrderCandidateIds: readonly string[];
+  readonly changedSemanticRegions: {
+    readonly total: number;
+    readonly byKind: Readonly<Record<string, number>>;
+    readonly conflictKeys: readonly string[];
+  };
+  readonly overlaps: {
+    readonly total: number;
+    readonly candidateIds: readonly string[];
+    readonly conflictKeys: readonly string[];
+    readonly sourcePaths: readonly string[];
+    readonly pairs: readonly SemanticMergeCandidateOverlapRecord[];
+  };
+  readonly records: readonly SemanticMergeCandidateAdmissionRecord[];
+  readonly projectionRisk?: SemanticMergeCandidateProjectionRisk;
   readonly patchRisk?: NativeProjectImportAdmissionRisk;
 }
 

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

@@ -0,0 +1,177 @@
+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[];
+}