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

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)),

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/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.53",
   "description": "Compiler facade for Frontier Lang source documents and language projection adapters.",
   "type": "module",
   "main": "./dist/index.js",