@shapeshift-labs/frontier-lang-compiler 0.2.52 → 0.2.54

package/README.md

@@ -183,6 +183,7 @@ console.log(pythonToRust.mergeScore.value); // sortable merge-review score, not
 const conversionArtifacts = createUniversalConversionArtifacts(conversionPlan);
 console.log(conversionArtifacts.historyRecords[0].kind); // "frontier.lang.semanticHistoryRecord"
 console.log(conversionArtifacts.patchBundleRecords[0].admission.autoMergeClaim); // false
+console.log(conversionArtifacts.admissionRecords[0].admissionBucket); // "blocked", "needs-evidence", "merge-ready", etc.
 console.log(conversionArtifacts.index.semanticOperationKinds); // sourcePreservation/projection/merge
 console.log(conversionArtifacts.routeArtifacts[0].semanticOperations.summary.conflictKeys);
 ```
@@ -199,7 +200,7 @@ The projection target matrix separates five runtime/API classes:
 
 `createUniversalConversionPlan` turns that capability evidence into coordinator tasks: preserve exact source, run a target adapter, emit stubs, attach semantic-index evidence, or block the route until missing parser/adapter/proof evidence exists. Every route carries `autoMergeClaim: false`, `semanticEquivalenceClaim: false`, missing evidence, task hints, and a `frontier.lang.semanticMergeScore.v1` score for swarm merge admission.
 
-`createUniversalConversionArtifacts` materializes those route refs into compact `SemanticHistoryRecord`, `SemanticPatchBundleRecord`, and semantic-operation artifacts that swarm collectors can index by route, history ID, patch-bundle ID, operation kind, source path, ownership key, conflict key, evidence, proof, readiness, and admission status. It is still review evidence, not target-code proof: blocked and semantic-index-only routes stay blocked/needs-review, and every artifact keeps `autoMergeClaim: false` plus `semanticEquivalenceClaim: false`.
+`createUniversalConversionArtifacts` materializes those route refs into compact `SemanticHistoryRecord`, `SemanticPatchBundleRecord`, semantic operation sets, and `UniversalConversionAdmissionRecord` rows that swarm collectors can index by route, history ID, patch-bundle ID, admission-record ID, admission bucket, risk, operation kind, source path, ownership key, conflict key, evidence, proof, readiness, and admission status. It is still review evidence, not target-code proof: blocked and semantic-index-only routes stay blocked/needs-review, and every artifact keeps `autoMergeClaim: false` plus `semanticEquivalenceClaim: false`.
 
 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:
 

package/bench/native-transform-suite.mjs

@@ -95,6 +95,22 @@ export function measureNativeTransformations(nativeImportResults) {
     conversionArtifacts: conversionArtifacts.summary.routes,
     conversionArtifactHistories: conversionArtifacts.summary.histories,
     conversionArtifactPatchBundles: conversionArtifacts.summary.patchBundles,
+    conversionArtifactAdmissionRecords: conversionArtifacts.summary.admissionRecords,
+    conversionArtifactMergeReady: conversionArtifacts.summary.mergeReady,
+    conversionArtifactNeedsEvidence: conversionArtifacts.summary.needsEvidence,
+    conversionArtifactNeedsAdapter: conversionArtifacts.summary.needsAdapter,
+    conversionArtifactNeedsReview: conversionArtifacts.summary.needsReview,
+    conversionArtifactAdmissionBlocked: conversionArtifacts.summary.admissionBlocked,
+    conversionArtifactLowRisk: conversionArtifacts.summary.lowRisk,
+    conversionArtifactMediumRisk: conversionArtifacts.summary.mediumRisk,
+    conversionArtifactHighRisk: conversionArtifacts.summary.highRisk,
+    conversionArtifactQueued: conversionArtifacts.summary.queued,
+    conversionArtifactAdmissionReasonCodes: conversionArtifacts.summary.reasonCodes,
+    conversionArtifactAdmissionMissingEvidence: conversionArtifacts.summary.missingEvidence,
+    conversionArtifactAdmissionBlockers: conversionArtifacts.summary.blockers,
+    conversionArtifactAdmissionReviewReasons: conversionArtifacts.summary.reviewReasons,
+    conversionArtifactAdmissionEvidenceIds: conversionArtifacts.summary.evidenceIds,
+    conversionArtifactAdmissionProofIds: conversionArtifacts.summary.proofIds,
     conversionArtifactsDurationMs,
     featureEvidencePolicyMatches,
     featureEvidenceDurationMs,

package/bench/smoke.mjs

@@ -63,6 +63,22 @@ console.log(JSON.stringify({
   conversionArtifacts: transformMetrics.conversionArtifacts,
   conversionArtifactHistories: transformMetrics.conversionArtifactHistories,
   conversionArtifactPatchBundles: transformMetrics.conversionArtifactPatchBundles,
+  conversionArtifactAdmissionRecords: transformMetrics.conversionArtifactAdmissionRecords,
+  conversionArtifactMergeReady: transformMetrics.conversionArtifactMergeReady,
+  conversionArtifactNeedsEvidence: transformMetrics.conversionArtifactNeedsEvidence,
+  conversionArtifactNeedsAdapter: transformMetrics.conversionArtifactNeedsAdapter,
+  conversionArtifactNeedsReview: transformMetrics.conversionArtifactNeedsReview,
+  conversionArtifactAdmissionBlocked: transformMetrics.conversionArtifactAdmissionBlocked,
+  conversionArtifactLowRisk: transformMetrics.conversionArtifactLowRisk,
+  conversionArtifactMediumRisk: transformMetrics.conversionArtifactMediumRisk,
+  conversionArtifactHighRisk: transformMetrics.conversionArtifactHighRisk,
+  conversionArtifactQueued: transformMetrics.conversionArtifactQueued,
+  conversionArtifactAdmissionReasonCodes: transformMetrics.conversionArtifactAdmissionReasonCodes,
+  conversionArtifactAdmissionMissingEvidence: transformMetrics.conversionArtifactAdmissionMissingEvidence,
+  conversionArtifactAdmissionBlockers: transformMetrics.conversionArtifactAdmissionBlockers,
+  conversionArtifactAdmissionReviewReasons: transformMetrics.conversionArtifactAdmissionReviewReasons,
+  conversionArtifactAdmissionEvidenceIds: transformMetrics.conversionArtifactAdmissionEvidenceIds,
+  conversionArtifactAdmissionProofIds: transformMetrics.conversionArtifactAdmissionProofIds,
   conversionArtifactsDurationMs: Number(transformMetrics.conversionArtifactsDurationMs.toFixed(2)),
   featureEvidencePolicyMatches: transformMetrics.featureEvidencePolicyMatches,
   featureEvidenceDurationMs: Number(transformMetrics.featureEvidenceDurationMs.toFixed(2)),
@@ -81,6 +97,7 @@ console.log(JSON.stringify({
   nativeTargetAdapterDurationMs: Number(transformMetrics.nativeTargetAdapterDurationMs.toFixed(2)),
   regionScanImports: sourceChangeMetrics.regionScanImports,
   regionScanSymbols: sourceChangeMetrics.regionScanSymbols,
+  regionScanDependencyRelations: sourceChangeMetrics.regionScanDependencyRelations,
   regionScanOwnershipRegions: sourceChangeMetrics.regionScanOwnershipRegions,
   regionScanDurationMs: Number(sourceChangeMetrics.regionScanDurationMs.toFixed(2)),
   changeProjectionSets: sourceChangeMetrics.changeProjectionSets,

package/bench/source-change-suite.mjs

@@ -22,6 +22,7 @@ function measureRegionScan() {
       language: 'typescript',
       sourcePath: `src/regions-${index}.ts`,
       sourceText: `
+      export function normalizeCount${index}(value) { return value; }
       export const appRoutes${index} = [
         { path: "/${index}", component: Screen${index} },
         { path: "/${index}/settings", component: Settings${index} }
@@ -31,7 +32,7 @@ function measureRegionScan() {
         legal: { title: "Legal ${index}" }
       };
       export const runtimeConfig${index} = {
-        limits: { count: ${index} },
+        limits: { count: normalizeCount${index}(${index}) },
         resolve(id) { return id; }
       };
       export const helpers${index} = {
@@ -45,6 +46,7 @@ function measureRegionScan() {
   return {
     regionScanImports: regionScanImports.length,
     regionScanSymbols: regionScanImports.reduce((sum, entry) => sum + entry.imported.semanticIndex.symbols.length, 0),
+    regionScanDependencyRelations: regionScanImports.reduce((sum, entry) => sum + entry.sidecar.dependencies.total, 0),
     regionScanOwnershipRegions: regionScanImports.reduce((sum, entry) => sum + entry.sidecar.ownershipRegions.length, 0),
     regionScanDurationMs
   };

package/dist/declarations/semantic-sidecar.d.ts

@@ -132,6 +132,7 @@ export interface SemanticImportSidecarImportEntry {
   readonly universalAstLayerIds: readonly string[];
   readonly proofSpec: SemanticImportSidecarProofSpecSummary;
   readonly paradigmSemantics: SemanticImportSidecarParadigmSemanticsSummary;
+  readonly dependencyRelationCount: number; readonly dependencyPredicates: readonly string[];
   readonly readiness: SemanticMergeReadiness;
   readonly emptySemanticIndex: boolean;
   readonly regionTaxonomy?: SemanticImportRegionTaxonomySummary;
@@ -228,6 +229,13 @@ export interface SemanticImportSidecarParadigmSemanticsSummary {
   readonly empty: boolean;
 }
 
+export interface SemanticImportDependencySummary {
+  readonly total: number; readonly calls: number; readonly uses: number; readonly references: number;
+  readonly imports: number; readonly extends: number; readonly implements: number; readonly includes: number; readonly requires: number;
+  readonly byPredicate: Readonly<Record<string, number>>; readonly predicates: readonly string[];
+  readonly ids: readonly string[]; readonly sourceSymbolIds: readonly string[]; readonly targetSymbolIds: readonly string[];
+}
+
 export interface SemanticImportSidecar {
   readonly kind: 'frontier.lang.semanticImportSidecar';
   readonly version: 1;
@@ -238,11 +246,7 @@ export interface SemanticImportSidecar {
   readonly imports: readonly SemanticImportSidecarImportEntry[];
   readonly symbols: readonly SemanticImportSidecarSymbol[];
   readonly ownershipRegions: readonly SemanticImportOwnershipRegion[];
-  readonly sourceMaps: {
-    readonly total: number;
-    readonly mappings: number;
-    readonly ids: readonly string[];
-  };
+  readonly sourceMaps: { readonly total: number; readonly mappings: number; readonly ids: readonly string[] };
   readonly sourcePreservation: {
     readonly total: number;
     readonly ids: readonly string[];
@@ -259,6 +263,7 @@ export interface SemanticImportSidecar {
   readonly universalAstLayers: SemanticImportSidecarUniversalAstLayerSummary;
   readonly proofSpec: SemanticImportSidecarProofSpecSummary;
   readonly paradigmSemantics: SemanticImportSidecarParadigmSemanticsSummary;
+  readonly dependencies: SemanticImportDependencySummary;
   readonly patchHints: readonly SemanticImportPatchHint[];
   readonly quality: SemanticImportSidecarQuality;
   readonly admission: SemanticImportSidecarAdmission;
@@ -280,11 +285,7 @@ export interface SemanticImportSidecar {
     readonly reviewLossIds: readonly string[];
   };
   readonly regionTaxonomy: SemanticImportRegionTaxonomySummary;
-  readonly evidence: {
-    readonly total: number;
-    readonly failed: readonly string[];
-    readonly ids: readonly string[];
-  };
+  readonly evidence: { readonly total: number; readonly failed: readonly string[]; readonly ids: readonly string[] };
   readonly summary: {
     readonly imports: number;
     readonly symbols: number;
@@ -300,6 +301,7 @@ export interface SemanticImportSidecar {
     readonly paradigmSemanticsRecords: number;
     readonly paradigmSemanticsGroups: number;
     readonly paradigmSemanticsLoweringRecords: number;
+    readonly dependencyRelations: number; readonly dependencyPredicates: readonly string[];
     readonly patchHints: number;
     readonly evidenceWarnings: number;
     readonly readiness: SemanticMergeReadiness;

package/dist/declarations/universal-conversion-artifacts.d.ts

@@ -14,10 +14,18 @@ import type {
   UniversalConversionRoute,
   UniversalConversionRouteAction,
   UniversalConversionRouteMode,
-  UniversalConversionMergeScore
+  UniversalConversionMergeScore,
+  UniversalConversionRisk
 } from './universal-conversion-plan.js';
 
 export type UniversalConversionArtifactAdmissionStatus = 'queued' | 'needs-review' | 'blocked' | string;
+export type UniversalConversionArtifactAdmissionBucket =
+  | 'merge-ready'
+  | 'needs-evidence'
+  | 'needs-adapter'
+  | 'needs-review'
+  | 'blocked'
+  | string;
 export type UniversalConversionArtifactMaterializationStatus = 'materialized' | 'planned-only' | 'missing' | 'failed' | string;
 
 export interface UniversalConversionArtifactMaterialization {
@@ -33,6 +41,69 @@ export interface UniversalConversionArtifactMaterialization {
   readonly semanticEquivalenceClaim: false;
 }
 
+export interface UniversalConversionAdmissionRecord {
+  readonly kind: 'frontier.lang.universalConversionAdmissionRecord';
+  readonly version: 1;
+  readonly schema: 'frontier.lang.universalConversionAdmissionRecord.v1';
+  readonly id: string;
+  readonly routeId: string;
+  readonly planId?: string;
+  readonly sourceLanguage?: FrontierSourceLanguage | string;
+  readonly target?: FrontierCompileTarget | string;
+  readonly mode: UniversalConversionRouteMode;
+  readonly routeAction: UniversalConversionRouteAction;
+  readonly admissionStatus: UniversalConversionArtifactAdmissionStatus;
+  readonly admissionAction: UniversalConversionAdmissionAction;
+  readonly admissionBucket: UniversalConversionArtifactAdmissionBucket;
+  readonly reviewRequired: true;
+  readonly readiness: SemanticMergeReadiness | string;
+  readonly risk: UniversalConversionRisk | string;
+  readonly score: {
+    readonly value: number;
+    readonly uncappedValue: number;
+    readonly sortKey: number;
+    readonly higherIsBetter: true;
+    readonly componentStatuses: Record<string, string>;
+    readonly penalties: readonly string[];
+  };
+  readonly ids: {
+    readonly historyId?: string;
+    readonly patchBundleId?: string;
+    readonly semanticOperationIds: readonly string[];
+    readonly sourceMapLinkIds: readonly string[];
+    readonly evidenceIds: readonly string[];
+    readonly proofIds: readonly string[];
+  };
+  readonly semanticOperations: {
+    readonly total: number;
+    readonly byKind: Record<string, number>;
+    readonly kinds: readonly string[];
+    readonly dynamic: readonly string[];
+    readonly opaque: readonly string[];
+  };
+  readonly ownership: {
+    readonly keys: readonly string[];
+    readonly conflictKeys: readonly string[];
+  };
+  readonly source: {
+    readonly paths: readonly string[];
+    readonly hashes: readonly string[];
+    readonly baseHashes: readonly string[];
+    readonly targetHashes: readonly string[];
+  };
+  readonly evidence: {
+    readonly total: number;
+    readonly proofArtifacts: number;
+    readonly missing: readonly string[];
+    readonly blockers: readonly string[];
+    readonly review: readonly string[];
+  };
+  readonly reasons: readonly string[];
+  readonly autoMergeClaim: false;
+  readonly semanticEquivalenceClaim: false;
+  readonly metadata: Record<string, unknown>;
+}
+
 export interface UniversalConversionRouteArtifact {
   readonly kind: 'frontier.lang.universalConversionRouteArtifact';
   readonly version: 1;
@@ -50,9 +121,11 @@ export interface UniversalConversionRouteArtifact {
   readonly reviewRequired: true;
   readonly history: SemanticHistoryRecord;
   readonly patchBundle: SemanticPatchBundleRecord;
+  readonly admissionRecord: UniversalConversionAdmissionRecord;
   readonly semanticOperations: SemanticOperationSet;
   readonly materialization: UniversalConversionArtifactMaterialization;
   readonly mergeScore?: UniversalConversionMergeScore;
+  readonly admissionBucket: UniversalConversionArtifactAdmissionBucket;
   readonly autoMergeClaim: false;
   readonly semanticEquivalenceClaim: false;
   readonly metadata: Record<string, unknown>;
@@ -62,11 +135,14 @@ export interface UniversalConversionArtifactIndex {
   readonly routeIds: readonly string[];
   readonly historyIds: readonly string[];
   readonly patchBundleIds: readonly string[];
+  readonly admissionRecordIds: readonly string[];
   readonly languages: readonly string[];
   readonly targets: readonly string[];
   readonly modes: readonly string[];
   readonly readinesses: readonly string[];
   readonly admissionStatuses: readonly string[];
+  readonly admissionBuckets: readonly string[];
+  readonly admissionRisks: readonly string[];
   readonly sourcePaths: readonly string[];
   readonly sourceHashes: readonly string[];
   readonly ownershipKeys: readonly string[];
@@ -87,14 +163,31 @@ export interface UniversalConversionArtifacts {
   readonly routeArtifacts: readonly UniversalConversionRouteArtifact[];
   readonly historyRecords: readonly SemanticHistoryRecord[];
   readonly patchBundleRecords: readonly SemanticPatchBundleRecord[];
+  readonly admissionRecords: readonly UniversalConversionAdmissionRecord[];
   readonly index: UniversalConversionArtifactIndex;
   readonly summary: {
     readonly routes: number;
     readonly histories: number;
     readonly patchBundles: number;
+    readonly admissionRecords: number;
     readonly semanticOperations: number;
+    readonly mergeReady: number;
+    readonly needsEvidence: number;
+    readonly needsAdapter: number;
+    readonly needsReview: number;
+    readonly admissionBlocked: number;
+    readonly lowRisk: number;
+    readonly mediumRisk: number;
+    readonly highRisk: number;
+    readonly queued: number;
     readonly reviewRequired: number;
     readonly blocked: number;
+    readonly reasonCodes: number;
+    readonly missingEvidence: number;
+    readonly blockers: number;
+    readonly reviewReasons: number;
+    readonly evidenceIds: number;
+    readonly proofIds: number;
     readonly autoMergeClaims: 0;
     readonly semanticEquivalenceClaims: 0;
   };
@@ -128,12 +221,15 @@ export interface UniversalConversionArtifactQuery {
   readonly routeId?: string | readonly string[];
   readonly historyId?: string | readonly string[];
   readonly patchBundleId?: string | readonly string[];
+  readonly admissionRecordId?: string | readonly string[];
   readonly sourceLanguage?: FrontierSourceLanguage | string | readonly string[];
   readonly target?: FrontierCompileTarget | string | readonly string[];
   readonly mode?: UniversalConversionRouteMode | readonly string[];
   readonly readiness?: SemanticMergeReadiness | string | readonly string[];
   readonly admissionAction?: UniversalConversionAdmissionAction | readonly string[];
   readonly admissionStatus?: UniversalConversionArtifactAdmissionStatus | readonly string[];
+  readonly admissionBucket?: UniversalConversionArtifactAdmissionBucket | readonly string[];
+  readonly risk?: UniversalConversionRisk | string | readonly string[];
   readonly priority?: UniversalConversionPriority | readonly string[];
   readonly routeAction?: UniversalConversionRouteAction | readonly string[];
   readonly sourcePath?: string | readonly string[];

package/dist/internal/index-impl/createLightweightNativeImport.js

@@ -1,4 +1,4 @@
-import{idFragment}from'../../native-import-utils.js';import{lightweightCoverageLosses,scanNativeDeclarations}from'../../native-region-scanner.js';import{semanticOwnershipRegionForDeclaration}from'../../semantic-import-regions.js';import{createSemanticIndexRecord,hashSemanticValue}from'@shapeshift-labs/frontier-lang-kernel';
+import{idFragment}from'../../native-import-utils.js';import{lightweightDependencyRelations}from'../../lightweight-dependency-relations.js';import{lightweightCoverageLosses,scanNativeDeclarations}from'../../native-region-scanner.js';import{semanticOwnershipRegionForDeclaration}from'../../semantic-import-regions.js';import{createSemanticIndexRecord,hashSemanticValue}from'@shapeshift-labs/frontier-lang-kernel';
 export function createLightweightNativeImport(input) {
   const parser = input.parser ?? `${input.language}.lightweight-declaration-scan`;
   const rootId = 'native_root';
@@ -20,6 +20,7 @@ export function createLightweightNativeImport(input) {
   const facts = [];
   const mappings = [];
   const evidenceId = `evidence_${idFragment(input.sourcePath ?? input.language)}_lightweight_scan`;
+  const dependencies = lightweightDependencyRelations(input, declarations, documentId);
 
   for (const declaration of declarations) {
     const ownershipRegion = semanticOwnershipRegionForDeclaration(input, declaration, documentId);
@@ -105,6 +106,9 @@ export function createLightweightNativeImport(input) {
     }
     if (declaration.loss) losses.push(declaration.loss);
   }
+  occurrences.push(...dependencies.occurrences);
+  relations.push(...dependencies.relations);
+  facts.push(...dependencies.facts);
   losses.push(...lightweightCoverageLosses(input, declarations, input.sourcePreservation));
 
   const semanticIndex = createSemanticIndexRecord({
@@ -124,12 +128,13 @@ export function createLightweightNativeImport(input) {
       kind: 'import',
       status: 'passed',
       path: input.sourcePath,
-      summary: `Lightweight declaration scan found ${symbols.length} symbol(s).`,
-      metadata: { parser }
+      summary: `Lightweight declaration scan found ${symbols.length} symbol(s) and ${dependencies.summary.total} dependency edge(s).`,
+      metadata: { parser, dependencyRelations: dependencies.summary.total }
     }],
     metadata: {
       parser,
       coverage: 'declarations-only',
+      dependencyRelations: dependencies.summary,
       unsupported: ['full expression AST', 'type checking', 'control flow', 'comments and formatting preservation']
     }
   });
@@ -145,6 +150,8 @@ export function createLightweightNativeImport(input) {
       parser,
       scanKind: 'lightweight-declaration-scan',
       declarationCount: declarations.length,
+      dependencyRelationCount: dependencies.summary.total,
+      dependencyOccurrenceCount: dependencies.occurrences.length,
       ...(input.sourcePreservation ? {
         sourcePreservationId: input.sourcePreservation.id,
         sourcePreservationSummary: input.sourcePreservation.summary

package/dist/internal/index-impl/createSemanticImportSidecar.js

@@ -1,4 +1,4 @@
-import{idFragment,maxSemanticMergeReadiness,uniqueRecordsById}from'../../native-import-utils.js';import{summarizeSemanticImportSidecarParadigmSemantics,summarizeSemanticImportSidecarProofSpec,summarizeSemanticImportSidecarUniversalAstLayers}from'../../semantic-import-layers.js';import{semanticPatchHintForRegion,summarizeSemanticImportRegionTaxonomy}from'../../semantic-import-regions.js';import{semanticImportSidecarEntry}from'../../semantic-import-sidecar-entry.js';import{summarizeKernelSourcePreservation}from'../../semantic-import-source-preservation.js';
+import{idFragment,maxSemanticMergeReadiness,uniqueRecordsById}from'../../native-import-utils.js';import{summarizeSemanticImportDependencies}from'../../semantic-import-dependencies.js';import{summarizeSemanticImportSidecarParadigmSemantics,summarizeSemanticImportSidecarProofSpec,summarizeSemanticImportSidecarUniversalAstLayers}from'../../semantic-import-layers.js';import{semanticPatchHintForRegion,summarizeSemanticImportRegionTaxonomy}from'../../semantic-import-regions.js';import{semanticImportSidecarEntry}from'../../semantic-import-sidecar-entry.js';import{summarizeKernelSourcePreservation}from'../../semantic-import-source-preservation.js';
 import{createSemanticImportSidecarAdmission,createSemanticImportSidecarQuality}from'./createSemanticImportSidecarAdmission.js';
 import{summarizeNativeImportLosses}from'./summarizeNativeImportLosses.js';
 export function createSemanticImportSidecar(importResult, options = {}) {
@@ -17,6 +17,7 @@ export function createSemanticImportSidecar(importResult, options = {}) {
   const universalAstLayers = summarizeSemanticImportSidecarUniversalAstLayers(importEntries);
   const proofSpec = summarizeSemanticImportSidecarProofSpec(importEntries);
   const paradigmSemantics = summarizeSemanticImportSidecarParadigmSemantics(importEntries);
+  const dependencies = summarizeSemanticImportDependencies(imports);
   const readiness = mergeCandidates.reduce(
     (current, candidate) => maxSemanticMergeReadiness(current, candidate.readiness),
     lossSummary.semanticMergeReadiness
@@ -51,6 +52,7 @@ export function createSemanticImportSidecar(importResult, options = {}) {
     universalAstLayers,
     proofSpec,
     paradigmSemantics,
+    dependencies,
     patchHints,
     quality,
     admission,
@@ -92,6 +94,8 @@ export function createSemanticImportSidecar(importResult, options = {}) {
       paradigmSemanticsRecords: paradigmSemantics.total,
       paradigmSemanticsGroups: paradigmSemantics.groups.length,
       paradigmSemanticsLoweringRecords: paradigmSemantics.loweringRecords,
+      dependencyRelations: dependencies.total,
+      dependencyPredicates: dependencies.predicates,
       patchHints: patchHints.length,
       evidenceWarnings: quality.emptyEvidenceWarnings.length,
       readiness,

package/dist/lightweight-dependency-relations.js

@@ -0,0 +1,271 @@
+import { idFragment } from './native-import-utils.js';
+import { sourceLines } from './native-region-scanner-core.js';
+
+const jsLikeLanguages = new Set(['javascript', 'typescript']);
+const ignoredIdentifiers = new Set([
+  'async', 'await', 'break', 'case', 'catch', 'class', 'const', 'continue', 'default',
+  'delete', 'do', 'else', 'export', 'extends', 'false', 'finally', 'for', 'from',
+  'function', 'if', 'import', 'in', 'instanceof', 'let', 'new', 'null', 'of',
+  'return', 'static', 'super', 'switch', 'this', 'throw', 'true', 'try', 'typeof',
+  'undefined', 'var', 'void', 'while', 'with', 'yield'
+]);
+
+export function lightweightDependencyRelations(input, declarations, documentId) {
+  if (!jsLikeLanguages.has(String(input.language ?? '').toLowerCase())) {
+    return { relations: [], occurrences: [], facts: [], summary: emptySummary() };
+  }
+  const lines = sourceLines(input.sourceText);
+  const identifiers = declarationIdentifierMap(input, declarations, lines);
+  const records = { relations: [], occurrences: [], facts: [], seen: new Set() };
+  for (const scan of declarationScanRanges(declarations, lines)) {
+    scanDeclarationDependencies(input, documentId, scan, identifiers, lines, records);
+  }
+  return {
+    relations: records.relations,
+    occurrences: records.occurrences,
+    facts: records.facts,
+    summary: {
+      total: records.relations.length,
+      calls: records.relations.filter((relation) => relation.predicate === 'calls').length,
+      uses: records.relations.filter((relation) => relation.predicate === 'uses').length
+    }
+  };
+}
+
+function declarationIdentifierMap(input, declarations, lines) {
+  const identifiers = new Map();
+  for (const declaration of declarations ?? []) {
+    if (!declaration?.symbolId) continue;
+    const target = {
+      name: declaration.name,
+      symbolId: declaration.symbolId,
+      symbolKind: declaration.symbolKind,
+      nodeId: declaration.nodeId,
+      role: declaration.role
+    };
+    for (const identifier of identifiersForDeclaration(input, declaration, lines)) {
+      addIdentifierTarget(identifiers, identifier, target);
+    }
+  }
+  return identifiers;
+}
+
+function identifiersForDeclaration(input, declaration, lines) {
+  const identifiers = new Set();
+  addIdentifier(identifiers, declaration.name);
+  const parts = String(declaration.name ?? '').split('.');
+  addIdentifier(identifiers, parts[parts.length - 1]);
+  if (declaration.role === 'import') {
+    const line = lines[(declaration.span?.startLine ?? 1) - 1]?.line ?? '';
+    for (const identifier of importLocalIdentifiers(line)) addIdentifier(identifiers, identifier);
+    addIdentifier(identifiers, packageIdentifier(declaration.importPath ?? declaration.name));
+  }
+  return [...identifiers];
+}
+
+function importLocalIdentifiers(line) {
+  const source = String(line ?? '');
+  const identifiers = [];
+  let match = source.match(/^import\s+([A-Za-z_$][\w$]*)\s+from\b/);
+  if (match) identifiers.push(match[1]);
+  match = source.match(/^import\s+\*\s+as\s+([A-Za-z_$][\w$]*)\s+from\b/);
+  if (match) identifiers.push(match[1]);
+  match = source.match(/^import\s+[^,{]+,\s*\{([^}]+)\}\s+from\b/);
+  if (match) identifiers.push(...namedImportIdentifiers(match[1]));
+  match = source.match(/^import\s+\{([^}]+)\}\s+from\b/);
+  if (match) identifiers.push(...namedImportIdentifiers(match[1]));
+  return identifiers;
+}
+
+function namedImportIdentifiers(raw) {
+  return String(raw ?? '')
+    .split(',')
+    .map((part) => part.trim().split(/\s+as\s+/i).pop()?.trim())
+    .filter(Boolean);
+}
+
+function packageIdentifier(value) {
+  const parts = String(value ?? '').split('/').filter(Boolean);
+  const last = parts[parts.length - 1] ?? value;
+  return String(last).replace(/[^A-Za-z0-9_$]/g, '');
+}
+
+function addIdentifierTarget(map, identifier, target) {
+  if (!isIdentifier(identifier)) return;
+  const existing = map.get(identifier) ?? [];
+  if (!existing.some((entry) => entry.symbolId === target.symbolId)) existing.push(target);
+  map.set(identifier, existing);
+}
+
+function addIdentifier(set, value) {
+  if (isIdentifier(value)) set.add(value);
+}
+
+function isIdentifier(value) {
+  const text = String(value ?? '');
+  return /^[A-Za-z_$][\w$]*$/.test(text) && !ignoredIdentifiers.has(text);
+}
+
+function declarationScanRanges(declarations, lines) {
+  return (declarations ?? [])
+    .filter((declaration) => declaration?.symbolId && declaration.role !== 'import')
+    .map((declaration) => ({
+      declaration,
+      startLine: declaration.span?.startLine ?? 1,
+      endLine: declarationScanEndLine(declaration, lines)
+    }));
+}
+
+function declarationScanEndLine(declaration, lines) {
+  const startLine = declaration.span?.startLine ?? 1;
+  if (!declaration.metadata?.hasBody || declaration.kind === 'ClassDeclaration') return startLine;
+  return balancedRegionEndLine(lines, startLine);
+}
+
+function balancedRegionEndLine(lines, startLine) {
+  const state = { inBlockComment: false, inTemplateString: false };
+  let depth = 0;
+  let opened = false;
+  for (let index = Math.max(0, startLine - 1); index < lines.length; index += 1) {
+    for (const char of maskReferenceLine(lines[index].line, state)) {
+      if (char === '{' || char === '[' || char === '(') {
+        depth += 1;
+        opened = true;
+      } else if (char === '}' || char === ']' || char === ')') {
+        depth -= 1;
+      }
+    }
+    if (opened && depth <= 0) return lines[index].number;
+  }
+  return startLine;
+}
+
+function scanDeclarationDependencies(input, documentId, scan, identifiers, lines, records) {
+  const state = { inBlockComment: false, inTemplateString: false };
+  for (let lineNumber = scan.startLine; lineNumber <= scan.endLine; lineNumber += 1) {
+    const scanLine = maskReferenceLine(lines[lineNumber - 1]?.line ?? '', state);
+    for (const match of scanLine.matchAll(/[A-Za-z_$][\w$]*/g)) {
+      const name = match[0];
+      if (ignoredIdentifiers.has(name) || !identifiers.has(name)) continue;
+      const targets = identifiers.get(name).filter((target) => target.symbolId !== scan.declaration.symbolId);
+      for (const target of targets) {
+        addDependencyRecord(input, documentId, scan.declaration, target, {
+          line: scanLine,
+          lineNumber,
+          startColumn: match.index + 1,
+          name
+        }, records);
+      }
+    }
+  }
+}
+
+function addDependencyRecord(input, documentId, caller, target, occurrence, records) {
+  const predicate = isCallReference(occurrence.line, occurrence.startColumn + occurrence.name.length - 1) ? 'calls' : 'uses';
+  const key = `${caller.symbolId}|${predicate}|${target.symbolId}|${occurrence.lineNumber}|${occurrence.startColumn}`;
+  if (records.seen.has(key)) return;
+  records.seen.add(key);
+  const relationId = `rel_${idFragment(caller.symbolId)}_${predicate}_${idFragment(target.symbolId)}_${occurrence.lineNumber}_${occurrence.startColumn}`;
+  const occurrenceId = `occ_${idFragment(caller.nodeId)}_${predicate}_${idFragment(target.symbolId)}_${occurrence.lineNumber}_${occurrence.startColumn}`;
+  const span = {
+    sourceId: input.sourceHash,
+    path: input.sourcePath,
+    startLine: occurrence.lineNumber,
+    endLine: occurrence.lineNumber,
+    startColumn: occurrence.startColumn,
+    endColumn: occurrence.startColumn + occurrence.name.length
+  };
+  records.relations.push({
+    id: relationId,
+    sourceId: caller.symbolId,
+    predicate,
+    targetId: target.symbolId,
+    metadata: {
+      scan: 'lightweight-dependency',
+      confidence: 'lexical-reference',
+      sourceDocumentId: documentId,
+      sourceName: caller.name,
+      targetName: target.name
+    }
+  });
+  records.occurrences.push({
+    id: occurrenceId,
+    documentId,
+    symbolId: target.symbolId,
+    role: 'reference',
+    span,
+    nativeAstNodeId: caller.nodeId
+  });
+  records.facts.push({
+    id: `fact_${idFragment(relationId)}_lightweight_dependency`,
+    predicate: 'lightweightDependency',
+    subjectId: caller.symbolId,
+    value: {
+      relationId,
+      predicate,
+      targetId: target.symbolId,
+      line: occurrence.lineNumber,
+      confidence: 'lexical-reference'
+    }
+  });
+}
+
+function isCallReference(line, afterIdentifierIndex) {
+  return /^\s*\(/.test(String(line ?? '').slice(afterIdentifierIndex));
+}
+
+function maskReferenceLine(line, state) {
+  const text = String(line ?? '');
+  let output = '';
+  let quote;
+  let escaped = false;
+  for (let index = 0; index < text.length; index += 1) {
+    const char = text[index];
+    const next = text[index + 1];
+    if (state.inBlockComment) {
+      output += ' ';
+      if (char === '*' && next === '/') {
+        output += ' ';
+        index += 1;
+        state.inBlockComment = false;
+      }
+      continue;
+    }
+    if (state.inTemplateString) {
+      output += ' ';
+      if (char === '`' && !escaped) state.inTemplateString = false;
+      escaped = char === '\\' && !escaped;
+      continue;
+    }
+    if (quote) {
+      output += ' ';
+      if (escaped) escaped = false;
+      else if (char === '\\') escaped = true;
+      else if (char === quote) quote = undefined;
+      continue;
+    }
+    if (char === '/' && next === '/') break;
+    if (char === '/' && next === '*') {
+      output += '  ';
+      index += 1;
+      state.inBlockComment = true;
+      continue;
+    }
+    if (char === '\'' || char === '"') {
+      output += ' ';
+      quote = char;
+      continue;
+    }
+    if (char === '`') {
+      output += ' ';
+      state.inTemplateString = true;
+      continue;
+    }
+    output += char;
+  }
+  return output;
+}
+
+function emptySummary() {
+  return { total: 0, calls: 0, uses: 0 };
+}

package/dist/semantic-import-dependencies.js

@@ -0,0 +1,62 @@
+import { countBy, uniqueRecordsById, uniqueStrings } from './native-import-utils.js';
+
+function summarizeSemanticImportDependencies(imports) {
+  return summarizeSemanticImportDependencyRelations((imports ?? [])
+    .flatMap((imported) => imported?.semanticIndex?.relations ?? imported?.universalAst?.semanticIndex?.relations ?? []));
+}
+
+function summarizeSemanticImportDependencyRelations(relations) {
+  const dependencyRelations = uniqueRecordsById((relations ?? []).filter(isDependencyRelation));
+  const predicateKeys = dependencyRelations.map((relation) => semanticDependencyPredicateKey(relation.predicate));
+  const byPredicate = countBy(predicateKeys);
+  return {
+    total: dependencyRelations.length,
+    calls: byPredicate.calls ?? 0,
+    uses: byPredicate.uses ?? 0,
+    references: byPredicate.references ?? 0,
+    imports: byPredicate.imports ?? 0,
+    extends: byPredicate.extends ?? 0,
+    implements: byPredicate.implements ?? 0,
+    includes: byPredicate.includes ?? 0,
+    requires: byPredicate.requires ?? 0,
+    byPredicate,
+    predicates: uniqueStrings(predicateKeys),
+    ids: dependencyRelations.map((relation) => relation.id).filter(Boolean),
+    sourceSymbolIds: uniqueStrings(dependencyRelations.map((relation) => relation.sourceId).filter(Boolean)),
+    targetSymbolIds: uniqueStrings(dependencyRelations.map((relation) => relation.targetId).filter(Boolean))
+  };
+}
+
+function isDependencyRelation(relation) {
+  const predicate = String(relation?.predicate ?? '').toLowerCase();
+  if (!predicate || predicate === 'defines' || predicate === 'definitionof') return false;
+  return predicate === 'imports'
+    || predicate === 'calls'
+    || predicate === 'uses'
+    || predicate.includes('reference')
+    || predicate.includes('depend')
+    || predicate.includes('require')
+    || predicate.includes('include')
+    || predicate.includes('extend')
+    || predicate.includes('implement');
+}
+
+function semanticDependencyPredicateKey(predicate) {
+  const value = String(predicate ?? 'unknown').toLowerCase();
+  if (value.includes('call')) return 'calls';
+  if (value.includes('reference')) return 'references';
+  if (value.includes('import')) return 'imports';
+  if (value.includes('depend')) return 'depends';
+  if (value.includes('require')) return 'requires';
+  if (value.includes('include')) return 'includes';
+  if (value.includes('extend')) return 'extends';
+  if (value.includes('implement')) return 'implements';
+  if (value === 'uses') return 'uses';
+  return value || 'unknown';
+}
+
+export {
+  semanticDependencyPredicateKey,
+  summarizeSemanticImportDependencies,
+  summarizeSemanticImportDependencyRelations
+};

package/dist/semantic-import-sidecar-entry.js

@@ -1,4 +1,5 @@
 import { uniqueRecordsById, uniqueStrings } from './native-import-utils.js';
+import { summarizeSemanticImportDependencyRelations } from './semantic-import-dependencies.js';
 import { semanticOwnershipRegionForSymbol, summarizeSemanticImportRegionTaxonomy } from './semantic-import-regions.js';
 import { collectKernelSourcePreservationFromImport } from './semantic-import-source-preservation.js';
 import {
@@ -16,6 +17,7 @@ function semanticImportSidecarEntry(imported, index, options) {
   const universalAstLayers = summarizeUniversalAstLayers(imported?.universalAst);
   const proofSpec = summarizeProofSpecLayer(imported?.universalAst?.proof ?? imported?.proof);
   const paradigmSemantics = summarizeParadigmSemanticsLayer(imported?.universalAst?.paradigmSemantics ?? imported?.paradigmSemantics);
+  const dependencies = summarizeSemanticImportDependencyRelations(semanticIndex?.relations ?? []);
   const mappingsBySymbolId = new Map();
   for (const mapping of sourceMapMappings) {
     if (mapping.semanticSymbolId && !mappingsBySymbolId.has(mapping.semanticSymbolId)) {
@@ -67,6 +69,8 @@ function semanticImportSidecarEntry(imported, index, options) {
     universalAstLayerIds: universalAstLayers.ids,
     proofSpec,
     paradigmSemantics,
+    dependencyRelationCount: dependencies.total,
+    dependencyPredicates: dependencies.predicates,
     readiness: imported?.metadata?.semanticMergeReadiness ?? imported?.mergeCandidates?.[0]?.readiness ?? 'needs-review',
     emptySemanticIndex: symbols.length === 0,
     regionTaxonomy,

package/dist/semantic-import-sidecar-types.d.ts

@@ -90,6 +90,8 @@ export interface SemanticImportSidecarImportEntry {
   readonly universalAstLayerIds: readonly string[];
   readonly proofSpec: SemanticImportSidecarProofSpecSummary;
   readonly paradigmSemantics: SemanticImportSidecarParadigmSemanticsSummary;
+  readonly dependencyRelationCount: number;
+  readonly dependencyPredicates: readonly string[];
   readonly readiness: SemanticMergeReadiness;
   readonly emptySemanticIndex: boolean;
   readonly regionTaxonomy?: SemanticImportRegionTaxonomySummary;
@@ -186,6 +188,23 @@ export interface SemanticImportSidecarParadigmSemanticsSummary {
   readonly empty: boolean;
 }
 
+export interface SemanticImportDependencySummary {
+  readonly total: number;
+  readonly calls: number;
+  readonly uses: number;
+  readonly references: number;
+  readonly imports: number;
+  readonly extends: number;
+  readonly implements: number;
+  readonly includes: number;
+  readonly requires: number;
+  readonly byPredicate: Readonly<Record<string, number>>;
+  readonly predicates: readonly string[];
+  readonly ids: readonly string[];
+  readonly sourceSymbolIds: readonly string[];
+  readonly targetSymbolIds: readonly string[];
+}
+
 export interface SemanticImportSidecar {
   readonly kind: 'frontier.lang.semanticImportSidecar';
   readonly version: 1;
@@ -217,6 +236,7 @@ export interface SemanticImportSidecar {
   readonly universalAstLayers: SemanticImportSidecarUniversalAstLayerSummary;
   readonly proofSpec: SemanticImportSidecarProofSpecSummary;
   readonly paradigmSemantics: SemanticImportSidecarParadigmSemanticsSummary;
+  readonly dependencies: SemanticImportDependencySummary;
   readonly patchHints: readonly SemanticImportPatchHint[];
   readonly quality: SemanticImportSidecarQuality;
   readonly admission: SemanticImportSidecarAdmission;
@@ -258,6 +278,8 @@ export interface SemanticImportSidecar {
     readonly paradigmSemanticsRecords: number;
     readonly paradigmSemanticsGroups: number;
     readonly paradigmSemanticsLoweringRecords: number;
+    readonly dependencyRelations: number;
+    readonly dependencyPredicates: readonly string[];
     readonly patchHints: number;
     readonly evidenceWarnings: number;
     readonly readiness: SemanticMergeReadiness;

package/dist/universal-conversion-admission-record.js

@@ -0,0 +1,122 @@
+import { countBy, idFragment, uniqueStrings } from './native-import-utils.js';
+
+export function createUniversalConversionAdmissionRecord(input) {
+  const route = input.route;
+  const operations = input.semanticOperations?.operations ?? [];
+  const operationKinds = uniqueStrings(operations.map((operation) => operation.operationKind));
+  const sourceRecords = input.patchBundle?.sources ?? input.history?.sources ?? [];
+  const evidenceIds = uniqueStrings([
+    ...(input.history?.evidenceIds ?? []),
+    ...(input.patchBundle?.evidenceIds ?? []),
+    ...(input.materialization?.evidenceIds ?? [])
+  ]);
+  const proofIds = uniqueStrings([
+    ...(input.history?.proofIds ?? []),
+    ...(input.patchBundle?.proofIds ?? []),
+    ...(input.materialization?.proofIds ?? [])
+  ]);
+  const score = route.mergeScore ?? {};
+  const missingEvidence = route.missingEvidence ?? [];
+  const blockers = route.blockers ?? [];
+  const bucket = admissionBucket({
+    action: score.action ?? route.admissionAction,
+    blockers,
+    missingEvidence,
+    mode: route.mode,
+    operationKinds,
+    opaqueOperations: operations.filter((operation) => operation.opaque).length,
+    scoreValue: score.value,
+    status: input.admissionStatus
+  });
+  return {
+    kind: 'frontier.lang.universalConversionAdmissionRecord',
+    version: 1,
+    schema: 'frontier.lang.universalConversionAdmissionRecord.v1',
+    id: `admission_${idFragment(route.id)}`,
+    routeId: route.id,
+    planId: input.planId,
+    sourceLanguage: route.sourceLanguage,
+    target: route.target,
+    mode: route.mode,
+    routeAction: route.routeAction,
+    admissionStatus: input.admissionStatus,
+    admissionAction: score.action ?? route.admissionAction,
+    admissionBucket: bucket,
+    reviewRequired: true,
+    readiness: route.readiness,
+    risk: score.risk ?? riskForRoute(route, input.admissionStatus),
+    score: {
+      value: Number(score.value ?? 0),
+      uncappedValue: Number(score.uncappedValue ?? score.value ?? 0),
+      sortKey: Number(score.sortKey ?? score.value ?? 0),
+      higherIsBetter: true,
+      componentStatuses: componentStatuses(score.components),
+      penalties: score.penalties ?? []
+    },
+    ids: {
+      historyId: input.history?.id,
+      patchBundleId: input.patchBundle?.id,
+      semanticOperationIds: operations.map((operation) => operation.id),
+      sourceMapLinkIds: input.materialization?.sourceMapLinkIds ?? [],
+      evidenceIds,
+      proofIds
+    },
+    semanticOperations: {
+      total: operations.length,
+      byKind: countBy(operations.map((operation) => operation.operationKind)),
+      kinds: operationKinds,
+      dynamic: operations.filter((operation) => operation.dynamic).map((operation) => operation.id),
+      opaque: operations.filter((operation) => operation.opaque).map((operation) => operation.id)
+    },
+    ownership: {
+      keys: uniqueStrings(input.history?.index?.ownershipKeys ?? input.patchBundle?.index?.ownershipKeys ?? []),
+      conflictKeys: uniqueStrings(input.history?.index?.conflictKeys ?? input.patchBundle?.index?.conflictKeys ?? [])
+    },
+    source: {
+      paths: uniqueStrings(sourceRecords.map((source) => source.sourcePath)),
+      hashes: uniqueStrings(sourceRecords.map((source) => source.sourceHash)),
+      baseHashes: uniqueStrings(sourceRecords.map((source) => source.baseHash)),
+      targetHashes: uniqueStrings(sourceRecords.map((source) => source.targetHash))
+    },
+    evidence: {
+      total: evidenceIds.length,
+      proofArtifacts: proofIds.length,
+      missing: missingEvidence,
+      blockers,
+      review: route.review ?? []
+    },
+    reasons: uniqueStrings([
+      ...(input.reasonCodes ?? []),
+      ...missingEvidence.map((reason) => `missing:${reason}`),
+      ...blockers.map((reason) => `blocker:${reason}`),
+      ...(route.review ?? []).map((reason) => `review:${reason}`),
+      ...(score.penalties ?? [])
+    ]),
+    autoMergeClaim: false,
+    semanticEquivalenceClaim: false,
+    metadata: {
+      routeId: route.id,
+      planId: input.planId,
+      mergeScoreSchema: score.schema,
+      note: 'Admission records are sortable merge-review evidence, not proof of target semantic equivalence.'
+    }
+  };
+}
+
+function admissionBucket(input) {
+  if (input.status === 'blocked' || input.action === 'reject' || input.blockers.length) return 'blocked';
+  if (input.mode === 'semantic-index-only' || input.missingEvidence.includes('target-adapter')) return 'needs-adapter';
+  if (input.missingEvidence.length || input.opaqueOperations || input.operationKinds.includes('merge')) return 'needs-evidence';
+  if (Number(input.scoreValue ?? 0) >= 80) return 'merge-ready';
+  return 'needs-review';
+}
+
+function riskForRoute(route, status) {
+  if (status === 'blocked' || route.readiness === 'blocked') return 'high';
+  if (route.readiness === 'needs-review' || route.mode === 'stub-only') return 'medium';
+  return 'low';
+}
+
+function componentStatuses(components = {}) {
+  return Object.fromEntries(Object.entries(components).map(([key, component]) => [key, component.status]));
+}

package/dist/universal-conversion-artifact-query.js

@@ -12,11 +12,14 @@ export function artifactIndex(routeArtifacts) {
     routeIds: uniqueStrings(routeArtifacts.map((artifact) => artifact.routeId)),
     historyIds: uniqueStrings(routeArtifacts.map((artifact) => artifact.history.id)),
     patchBundleIds: uniqueStrings(routeArtifacts.map((artifact) => artifact.patchBundle.id)),
+    admissionRecordIds: uniqueStrings(routeArtifacts.map((artifact) => artifact.admissionRecord.id)),
     languages: uniqueStrings(routeArtifacts.map((artifact) => artifact.sourceLanguage)),
     targets: uniqueStrings(routeArtifacts.map((artifact) => artifact.target)),
     modes: uniqueStrings(routeArtifacts.map((artifact) => artifact.mode)),
     readinesses: uniqueStrings(routeArtifacts.map((artifact) => artifact.readiness)),
     admissionStatuses: uniqueStrings(routeArtifacts.map((artifact) => artifact.admissionStatus)),
+    admissionBuckets: uniqueStrings(routeArtifacts.map((artifact) => artifact.admissionRecord.admissionBucket)),
+    admissionRisks: uniqueStrings(routeArtifacts.map((artifact) => artifact.admissionRecord.risk)),
     sourcePaths: uniqueStrings(routeArtifacts.flatMap((artifact) => artifact.history.index.sourcePaths)),
     sourceHashes: uniqueStrings(routeArtifacts.flatMap((artifact) => artifact.history.index.sourceHashes)),
     ownershipKeys: uniqueStrings(routeArtifacts.flatMap((artifact) => artifact.history.index.ownershipKeys)),
@@ -39,6 +42,7 @@ function matchesArtifact(record, query) {
   return match(query.routeId, [record.routeId])
     && match(query.historyId, [record.history.id])
     && match(query.patchBundleId, [record.patchBundle.id])
+    && match(query.admissionRecordId, [record.admissionRecord.id])
     && match(query.sourceLanguage, [record.sourceLanguage])
     && match(query.target, [record.target])
     && match(query.mode, [record.mode])
@@ -46,6 +50,8 @@ function matchesArtifact(record, query) {
     && match(query.priority, [record.priority])
     && match(query.readiness, [record.readiness])
     && match(query.admissionStatus, [record.admissionStatus])
+    && match(query.admissionBucket, [record.admissionRecord.admissionBucket])
+    && match(query.risk, [record.admissionRecord.risk])
     && match(query.sourcePath, record.history.index.sourcePaths)
     && match(query.sourceHash, record.history.index.sourceHashes)
     && match(query.ownershipKey, record.history.index.ownershipKeys)

package/dist/universal-conversion-artifact-summary.js

@@ -0,0 +1,37 @@
+export function universalConversionArtifactSummary(routeArtifacts, records) {
+  const admissionRecords = records.admissionRecords;
+  return {
+    routes: routeArtifacts.length,
+    histories: records.historyRecords.length,
+    patchBundles: records.patchBundleRecords.length,
+    admissionRecords: admissionRecords.length,
+    semanticOperations: routeArtifacts.reduce((sum, artifact) => sum + artifact.semanticOperations.operations.length, 0),
+    mergeReady: countAdmissionBucket(admissionRecords, 'merge-ready'),
+    needsEvidence: countAdmissionBucket(admissionRecords, 'needs-evidence'),
+    needsAdapter: countAdmissionBucket(admissionRecords, 'needs-adapter'),
+    needsReview: countAdmissionBucket(admissionRecords, 'needs-review'),
+    admissionBlocked: countAdmissionBucket(admissionRecords, 'blocked'),
+    lowRisk: countAdmissionRisk(admissionRecords, 'low'),
+    mediumRisk: countAdmissionRisk(admissionRecords, 'medium'),
+    highRisk: countAdmissionRisk(admissionRecords, 'high'),
+    queued: routeArtifacts.filter((artifact) => artifact.admissionStatus === 'queued').length,
+    reviewRequired: routeArtifacts.filter((artifact) => artifact.reviewRequired).length,
+    blocked: routeArtifacts.filter((artifact) => artifact.admissionStatus === 'blocked').length,
+    reasonCodes: admissionRecords.reduce((sum, record) => sum + record.reasons.length, 0),
+    missingEvidence: admissionRecords.reduce((sum, record) => sum + record.evidence.missing.length, 0),
+    blockers: admissionRecords.reduce((sum, record) => sum + record.evidence.blockers.length, 0),
+    reviewReasons: admissionRecords.reduce((sum, record) => sum + record.evidence.review.length, 0),
+    evidenceIds: admissionRecords.reduce((sum, record) => sum + record.ids.evidenceIds.length, 0),
+    proofIds: admissionRecords.reduce((sum, record) => sum + record.ids.proofIds.length, 0),
+    autoMergeClaims: 0,
+    semanticEquivalenceClaims: 0
+  };
+}
+
+function countAdmissionBucket(records, bucket) {
+  return records.filter((record) => record.admissionBucket === bucket).length;
+}
+
+function countAdmissionRisk(records, risk) {
+  return records.filter((record) => record.risk === risk).length;
+}

package/dist/universal-conversion-artifacts.js

@@ -1,6 +1,8 @@
 import { idFragment, uniqueStrings } from './native-import-utils.js';
+import { universalConversionArtifactSummary } from './universal-conversion-artifact-summary.js';
 import { createUniversalConversionPlan } from './universal-conversion-plan.js';
 import { artifactIndex } from './universal-conversion-artifact-query.js';
+import { createUniversalConversionAdmissionRecord } from './universal-conversion-admission-record.js';
 import { routeSemanticOperations } from './universal-conversion-route-operations.js';
 import { createSemanticHistoryRecord } from './internal/index-impl/semanticHistoryRecords.js';
 import { createSemanticPatchBundleRecord } from './internal/index-impl/semanticPatchBundleRecords.js';
@@ -23,6 +25,7 @@ export function createUniversalConversionArtifacts(input = {}, options = {}) {
   }));
   const historyRecords = routeArtifacts.map((artifact) => artifact.history);
   const patchBundleRecords = routeArtifacts.map((artifact) => artifact.patchBundle);
+  const admissionRecords = routeArtifacts.map((artifact) => artifact.admissionRecord);
   const index = artifactIndex(routeArtifacts);
   return {
     kind: 'frontier.lang.universalConversionArtifacts',
@@ -34,17 +37,13 @@ export function createUniversalConversionArtifacts(input = {}, options = {}) {
     routeArtifacts,
     historyRecords,
     patchBundleRecords,
+    admissionRecords,
     index,
-    summary: {
-      routes: routeArtifacts.length,
-      histories: historyRecords.length,
-      patchBundles: patchBundleRecords.length,
-      semanticOperations: routeArtifacts.reduce((sum, artifact) => sum + artifact.semanticOperations.operations.length, 0),
-      reviewRequired: routeArtifacts.filter((artifact) => artifact.reviewRequired).length,
-      blocked: routeArtifacts.filter((artifact) => artifact.admissionStatus === 'blocked').length,
-      autoMergeClaims: 0,
-      semanticEquivalenceClaims: 0
-    },
+    summary: universalConversionArtifactSummary(routeArtifacts, {
+      historyRecords,
+      patchBundleRecords,
+      admissionRecords
+    }),
     metadata: {
       autoMergeClaim: false,
       semanticEquivalenceClaim: false,
@@ -121,6 +120,16 @@ function createRouteArtifact(route, options) {
     autoMergeClaim: false,
     semanticEquivalenceClaim: false
   };
+  const admissionRecord = createUniversalConversionAdmissionRecord({
+    route,
+    planId,
+    admissionStatus,
+    reasonCodes,
+    history,
+    patchBundle,
+    semanticOperations,
+    materialization
+  });
   return {
     kind: 'frontier.lang.universalConversionRouteArtifact',
     version: 1,
@@ -138,9 +147,11 @@ function createRouteArtifact(route, options) {
     reviewRequired: true,
     history,
     patchBundle,
+    admissionRecord,
     semanticOperations,
     materialization,
     mergeScore: route.mergeScore,
+    admissionBucket: admissionRecord.admissionBucket,
     autoMergeClaim: false,
     semanticEquivalenceClaim: false,
     metadata: { ...routeRecordMetadata(route, planId, options.metadata), materialization }

package/package.json

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