@shapeshift-labs/frontier-lang-compiler 0.2.103 → 0.2.105

package/dist/universal-conversion-artifact-semantic-edit.js

@@ -0,0 +1,103 @@
+import { uniqueStrings } from './native-import-utils.js';
+import { semanticEditRecordIndex } from './internal/index-impl/semanticEditBundleIndex.js';
+
+export function artifactSemanticEditIndex(record) {
+  const patchIndex = record.patchBundle?.index ?? {};
+  const scripts = semanticEditRecords(record, 'semanticEditScript', 'semanticEditScripts', 'script', 'scripts');
+  const projections = semanticEditRecords(record, 'semanticEditProjection', 'semanticEditProjections', 'projection', 'projections');
+  const replays = semanticEditRecords(record, 'semanticEditReplay', 'semanticEditReplays', 'replay', 'replays');
+  const editIndex = semanticEditRecordIndex(scripts, projections, replays, {
+    index: patchIndex,
+    metadata: { semanticEditSummary: record.patchBundle?.metadata?.semanticEditSummary ?? record.metadata?.semanticEditSummary }
+  });
+  const admissions = semanticEditAdmissions(record);
+  const admissionStatuses = uniqueStrings([...strings(patchIndex.semanticEditAdmissionStatuses), ...admissions.map((admission) => admission.status)]);
+  const admissionActions = uniqueStrings([...strings(patchIndex.semanticEditAdmissionActions), ...admissions.map((admission) => admission.action)]);
+  const admissionReadinesses = uniqueStrings([...strings(patchIndex.semanticEditAdmissionReadinesses), ...admissions.map((admission) => admission.readiness)]);
+  return {
+    semanticEditStatuses: uniqueStrings([
+      ...editIndex.semanticEditReplayStatuses,
+      ...admissionStatuses,
+      ...scripts.flatMap((script) => array(script.operations).map((operation) => operation.status)),
+      ...projections.flatMap((projection) => [projection.status, projection.admission?.status]),
+      ...replays.flatMap((replay) => [replay.status, replay.admission?.status])
+    ]),
+    semanticEditScriptIds: editIndex.semanticEditScriptIds,
+    semanticEditProjectionIds: editIndex.semanticEditProjectionIds,
+    semanticEditReplayIds: editIndex.semanticEditReplayIds,
+    semanticEditReplayStatuses: editIndex.semanticEditReplayStatuses,
+    semanticEditReplayActions: editIndex.semanticEditReplayActions,
+    semanticEditAdmissionStatuses: admissionStatuses,
+    semanticEditAdmissionActions: admissionActions,
+    semanticEditAdmissionReadinesses: admissionReadinesses,
+    semanticEditReplayCurrentHashes: editIndex.semanticEditReplayCurrentHashes,
+    semanticEditReplayOutputHashes: editIndex.semanticEditReplayOutputHashes,
+    semanticEditKeys: editIndex.semanticEditKeys,
+    semanticEditHashes: uniqueStrings([
+      ...editIndex.semanticEditReplayCurrentHashes,
+      ...editIndex.semanticEditReplayOutputHashes,
+      ...editIndex.semanticIdentityHashes,
+      ...editIndex.sourceIdentityHashes,
+      ...editIndex.operationContentHashes,
+      ...editIndex.editContentHashes,
+      ...semanticEditRecordHashes(scripts),
+      ...semanticEditRecordHashes(projections),
+      ...semanticEditRecordHashes(replays)
+    ]),
+    semanticIdentityHashes: editIndex.semanticIdentityHashes,
+    sourceIdentityHashes: editIndex.sourceIdentityHashes,
+    operationContentHashes: editIndex.operationContentHashes,
+    editContentHashes: editIndex.editContentHashes
+  };
+}
+
+function semanticEditAdmissions(record) {
+  return [
+    record.patchBundle?.admission?.semanticEditAdmission,
+    record.patchBundle?.metadata?.semanticEditAdmission,
+    record.metadata?.semanticEditAdmission,
+    record.metadata?.semanticEdit?.admission
+  ].filter(Boolean);
+}
+
+function semanticEditRecords(record, singularKey, pluralKey, nestedSingularKey, nestedPluralKey) {
+  const metadata = record.metadata ?? {};
+  const semanticEdit = metadata.semanticEdit ?? {};
+  const patchMetadata = record.patchBundle?.metadata ?? {};
+  const patchSemanticEdit = patchMetadata.semanticEdit ?? {};
+  return [
+    ...array(record[pluralKey] ?? record[singularKey]),
+    ...array(metadata[pluralKey] ?? metadata[singularKey]),
+    ...array(semanticEdit[nestedPluralKey] ?? semanticEdit[nestedSingularKey]),
+    ...array(record.patchBundle?.[pluralKey] ?? record.patchBundle?.[singularKey]),
+    ...array(patchMetadata[pluralKey] ?? patchMetadata[singularKey]),
+    ...array(patchSemanticEdit[nestedPluralKey] ?? patchSemanticEdit[nestedSingularKey])
+  ].filter(Boolean);
+}
+
+function semanticEditRecordHashes(records) {
+  return records.flatMap((record) => {
+    const hashes = record?.hashes;
+    return [
+      record?.hash,
+      record?.stableHash,
+      record?.semanticIdentityHash,
+      record?.sourceIdentityHash,
+      record?.operationContentHash,
+      record?.editContentHash,
+      record?.currentHash,
+      record?.projectedHash,
+      record?.outputHash,
+      ...(hashes && typeof hashes === 'object' ? Object.values(hashes) : [])
+    ];
+  });
+}
+
+function array(value) {
+  if (value === undefined || value === null) return [];
+  return Array.isArray(value) ? value : [value];
+}
+
+function strings(value) {
+  return array(value).map((entry) => String(entry ?? '')).filter(Boolean);
+}

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

@@ -1,11 +1,16 @@
+import { countBy } from './native-import-utils.js';
+
 export function universalConversionArtifactSummary(routeArtifacts, records) {
   const admissionRecords = records.admissionRecords;
+  const semanticOperations = routeArtifacts.flatMap((artifact) => artifact.semanticOperations?.operations ?? []);
+  const compactCounts = compactArtifactCounts(routeArtifacts, admissionRecords, semanticOperations);
   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),
+    semanticOperations: semanticOperations.length,
+    compactCounts,
     mergeReady: countAdmissionBucket(admissionRecords, 'merge-ready'),
     needsEvidence: countAdmissionBucket(admissionRecords, 'needs-evidence'),
     needsAdapter: countAdmissionBucket(admissionRecords, 'needs-adapter'),
@@ -35,3 +40,30 @@ function countAdmissionBucket(records, bucket) {
 function countAdmissionRisk(records, risk) {
   return records.filter((record) => record.risk === risk).length;
 }
+
+function compactArtifactCounts(routeArtifacts, admissionRecords, semanticOperations) {
+  const constructKinds = routeArtifacts.flatMap((artifact) => artifact.metadata?.representation?.constructKinds ?? []);
+  const missingConstructs = routeArtifacts.flatMap((artifact) => artifact.metadata?.representation?.missing ?? []);
+  return {
+    representationConstructs: {
+      total: constructKinds.length,
+      routeArtifacts: routeArtifacts.filter((artifact) => artifact.metadata?.representation?.constructKinds?.length).length,
+      byKind: countBy(constructKinds)
+    },
+    missingConstructs: {
+      total: missingConstructs.length,
+      routeArtifacts: routeArtifacts.filter((artifact) => artifact.metadata?.representation?.missing?.length).length,
+      byKind: countBy(missingConstructs)
+    },
+    semanticEditReadiness: {
+      routeArtifacts: countBy(routeArtifacts.map((artifact) => artifact.readiness)),
+      semanticOperations: countBy(semanticOperations.map((operation) => operation.readiness))
+    },
+    admissionStatuses: {
+      byStatus: countBy(routeArtifacts.map((artifact) => artifact.admissionStatus)),
+      byBucket: countBy(admissionRecords.map((record) => record.admissionBucket)),
+      byAction: countBy(admissionRecords.map((record) => record.admissionAction)),
+      byRisk: countBy(admissionRecords.map((record) => record.risk))
+    }
+  };
+}

package/dist/universal-conversion-artifacts.js

@@ -3,6 +3,13 @@ import { universalConversionArtifactSummary } from './universal-conversion-artif
 import { createUniversalConversionPlan } from './universal-conversion-plan.js';
 import { artifactIndex } from './universal-conversion-artifact-query.js';
 import { createUniversalConversionAdmissionRecord } from './universal-conversion-admission-record.js';
+import {
+  routeAdmissionMetadata,
+  routeAdmissionStatus,
+  routeReasonCodes,
+  routeRecordMetadata,
+  routeSemanticEditBundle
+} from './universal-conversion-route-metadata.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';
@@ -60,6 +67,8 @@ function createRouteArtifact(route, options) {
   const regions = routeRegions(route, refs, sources);
   const sourceMapLinks = routeSourceMapLinks(route, refs, sources, regions);
   const semanticOperations = routeSemanticOperations(route, refs, sources, regions, sourceMapLinks);
+  const semanticEditBundle = routeSemanticEditBundle(route);
+  const recordMetadata = routeRecordMetadata(route, planId, options.metadata);
   const admissionStatus = routeAdmissionStatus(route);
   const reasonCodes = routeReasonCodes(route);
   const historyId = refs.historyIds?.[0] ?? `history_${route.id}`;
@@ -82,7 +91,7 @@ function createRouteArtifact(route, options) {
       evidenceIds: refs.evidenceIds,
       metadata: routeAdmissionMetadata(route, planId)
     },
-    metadata: routeRecordMetadata(route, planId, options.metadata)
+    metadata: recordMetadata
   }, { id: historyId, createdAt: options.generatedAt });
   const patchBundle = createSemanticPatchBundleRecord({
     id: patchBundleId,
@@ -97,6 +106,7 @@ function createRouteArtifact(route, options) {
     historyIds: [history.id],
     readiness: route.readiness,
     conflictKeys: refs.conflictKeys,
+    ...semanticEditBundle,
     admission: {
       status: admissionStatus,
       readiness: route.readiness,
@@ -106,7 +116,7 @@ function createRouteArtifact(route, options) {
       evidenceIds: refs.evidenceIds,
       metadata: routeAdmissionMetadata(route, planId)
     },
-    metadata: routeRecordMetadata(route, planId, options.metadata)
+    metadata: recordMetadata
   }, { id: patchBundleId, createdAt: options.generatedAt });
   const materialization = {
     status: 'materialized',
@@ -154,7 +164,7 @@ function createRouteArtifact(route, options) {
     admissionBucket: admissionRecord.admissionBucket,
     autoMergeClaim: false,
     semanticEquivalenceClaim: false,
-    metadata: { ...routeRecordMetadata(route, planId, options.metadata), materialization }
+    metadata: { ...recordMetadata, materialization }
   };
 }
 
@@ -258,48 +268,3 @@ function routeSemanticCandidates(route, refs) {
     }
   }));
 }
-
-function routeAdmissionStatus(route) {
-  if (route.readiness === 'blocked' || route.admissionAction === 'reject') return 'blocked';
-  if (route.readiness === 'ready' && route.missingEvidence?.length === 0) return 'queued';
-  return 'needs-review';
-}
-
-function routeReasonCodes(route) {
-  return uniqueStrings([
-    `mode:${route.mode}`,
-    `action:${route.routeAction}`,
-    ...(route.missingEvidence ?? []).map((item) => `missing:${item}`),
-    ...(route.blockers ?? []).map((item) => `blocker:${item}`),
-    ...(route.review ?? []).map((item) => `review:${item}`)
-  ]);
-}
-
-function routeAdmissionMetadata(route, planId) {
-  return {
-    planId,
-    routeId: route.id,
-    routeAction: route.routeAction,
-    admissionAction: route.admissionAction,
-    priority: route.priority,
-    mergeScore: route.mergeScore,
-    autoMergeClaim: false,
-    semanticEquivalenceClaim: false
-  };
-}
-
-function routeRecordMetadata(route, planId, metadata) {
-  return {
-    planId,
-    routeId: route.id,
-    target: route.target,
-    mode: route.mode,
-    routeAction: route.routeAction,
-    missingEvidence: route.missingEvidence ?? [],
-    blockers: route.blockers ?? [],
-    review: route.review ?? [],
-    autoMergeClaim: false,
-    semanticEquivalenceClaim: false,
-    ...metadata
-  };
-}

package/dist/universal-conversion-plan-scoring.js

@@ -14,11 +14,12 @@ const componentWeights = Object.freeze({
   importEvidence: 22,
   parserEvidence: 18,
   semanticIndex: 18,
+  representationCoverage: 18,
   projectionPath: 24,
   proofEvidence: 18
 });
 
-export function conversionScoreComponents(language, targetCell, readiness, mode, evidence) {
+export function conversionScoreComponents(language, targetCell, readiness, mode, evidence, representation) {
   return {
     importEvidence: scoreComponent('importEvidence', readinessScore[language.imports.readiness] ?? 48, [
       ...(language.imports.total ? [] : ['No source import evidence.']),
@@ -32,6 +33,16 @@ export function conversionScoreComponents(language, targetCell, readiness, mode,
       ...(language.imports.symbols ? [] : ['No semantic symbols were imported.']),
       ...(language.imports.sourceMapMappings ? [] : ['No source-map mappings were imported.'])
     ], { symbols: language.imports.symbols, sourceMapMappings: language.imports.sourceMapMappings }),
+    representationCoverage: scoreComponent('representationCoverage', representationScore(representation), [
+      ...(representation?.missing ?? []).map((item) => `Missing representation evidence: ${item}.`),
+      ...(representation?.blockers ?? [])
+    ], {
+      constructKinds: representation?.constructKinds ?? [],
+      representedConstructs: representation?.summary?.representedConstructs ?? 0,
+      missing: representation?.summary?.missing ?? 0,
+      runtimeCapabilities: representation?.surfaces?.runtime?.requiredCapabilities ?? [],
+      sourceMapPrecisions: representation?.surfaces?.sourceMaps?.precisions ?? []
+    }),
     projectionPath: scoreComponent('projectionPath', projectionPathScore(targetCell, mode, readiness), projectionPathReasons(targetCell, mode), {
       mode,
       lossClass: targetCell?.lossClass,
@@ -84,6 +95,15 @@ function semanticIndexScore(language) {
   return Math.min(100, 62 + Math.min(22, symbols * 3) + Math.min(16, mappings * 2));
 }
 
+function representationScore(representation) {
+  if (!representation) return 0;
+  const summary = representation.summary ?? {};
+  const represented = Number(summary.representedConstructs ?? 0);
+  const missing = Number(summary.missing ?? 0);
+  const blockers = Number(summary.blockers ?? 0);
+  return Math.max(0, Math.min(100, 44 + represented * 8 - missing * 5 - blockers * 18));
+}
+
 function projectionPathScore(targetCell, mode, readiness) {
   if (mode === 'blocked') return 0;
   if (mode === 'preserve-source') return 92;

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

@@ -1,9 +1,13 @@
+import { countBy } from './native-import-utils.js';
+
 export function conversionPlanSummary(routes) {
+  const compactCounts = compactRouteCounts(routes);
   const summary = {
     routes: routes.length,
     byMode: {},
     byReadiness: {},
     byAdmissionAction: {},
+    compactCounts,
     readyRoutes: 0,
     reviewRoutes: 0,
     blockedRoutes: 0,
@@ -40,3 +44,29 @@ export function conversionPlanSummary(routes) {
   }
   return summary;
 }
+
+function compactRouteCounts(routes) {
+  const constructs = routes.flatMap((route) => route.representation?.constructs ?? []);
+  const missingConstructs = routes.flatMap((route) => route.representation?.missing ?? []);
+  return {
+    representationConstructs: {
+      total: constructs.length,
+      represented: constructs.filter((construct) => construct.status === 'represented').length,
+      missing: constructs.filter((construct) => construct.status === 'missing').length,
+      review: constructs.filter((construct) => construct.status === 'review').length,
+      blocked: constructs.filter((construct) => construct.status === 'blocked').length,
+      byKind: countBy(constructs.map((construct) => construct.kind)),
+      byStatus: countBy(constructs.map((construct) => construct.status))
+    },
+    missingConstructs: {
+      total: missingConstructs.length,
+      byKind: countBy(missingConstructs)
+    },
+    semanticEditReadiness: { routes: countBy(routes.map((route) => route.readiness)) },
+    admissionStatuses: {
+      byAction: countBy(routes.map((route) => route.admissionAction)),
+      byRouteStatus: countBy(routes.map((route) => route.mergeRefs?.admissionStatus ?? route.admissionAction)),
+      byRisk: countBy(routes.map((route) => route.mergeScore?.risk))
+    }
+  };
+}

package/dist/universal-conversion-plan.js

@@ -22,6 +22,10 @@ import {
   conversionScoreComponents
 } from './universal-conversion-plan-scoring.js';
 import { conversionPlanSummary } from './universal-conversion-plan-summary.js';
+import {
+  createUniversalRepresentationCoverage,
+  representationCoverageMatches
+} from './universal-representation-coverage.js';
 
 export function createUniversalConversionPlan(input = {}, context = {}) {
   const generatedAt = input.generatedAt ?? Date.now();
@@ -81,6 +85,7 @@ export function queryUniversalConversionPlan(planOrInput = {}, query = {}, conte
     if (query.mode && route.mode !== query.mode) return false;
     if (query.readiness && route.readiness !== query.readiness) return false;
     if (query.admissionAction && route.admissionAction !== query.admissionAction) return false;
+    if (!representationCoverageMatches(route.representation, query)) return false;
     return true;
   });
   return {
@@ -113,10 +118,26 @@ function conversionRoute(language, target, input, planId) {
   const readiness = blockers.length
     ? 'blocked'
     : maxSemanticMergeReadiness(language.readiness, targetCell?.readiness ?? readinessCell?.readiness ?? 'needs-review');
-  const components = conversionScoreComponents(language, targetCell, readiness, mode, input.evidence);
-  const mergeScore = conversionMergeScore({ readiness, mode, components, blockers, review });
   const id = `conversion_${idFragment(language.language)}_to_${idFragment(target)}`;
   const routeImports = importsForConversionLanguage(input.imports, language);
+  const mergeRefs = conversionMergeRefs({
+    planId,
+    routeId: id,
+    imports: routeImports,
+    readiness,
+    admissionStatus: 'pending'
+  });
+  const representation = createUniversalRepresentationCoverage({
+    language,
+    target,
+    targetCell,
+    runtime,
+    mergeRefs,
+    evidence: input.evidence
+  });
+  const components = conversionScoreComponents(language, targetCell, readiness, mode, input.evidence, representation);
+  const mergeScore = conversionMergeScore({ readiness, mode, components, blockers, review });
+  const admissionStatus = mergeScore.action;
   return {
     id,
     sourceLanguage: language.language,
@@ -135,18 +156,13 @@ function conversionRoute(language, target, input, planId) {
     runtime,
     runtimeAdapterRequirements: runtime.adapterRequirements,
     evidence: conversionEvidence(language, targetCell),
+    representation,
     missingEvidence: conversionMissingEvidence(language, targetCell, mode),
     blockers,
     review,
     tasks: conversionTasks(language, target, mode, blockers, review),
     mergeScore,
-    mergeRefs: conversionMergeRefs({
-      planId,
-      routeId: id,
-      imports: routeImports,
-      readiness,
-      admissionStatus: mergeScore.action
-    }),
+    mergeRefs: { ...mergeRefs, admissionStatus },
     autoMergeClaim: false,
     semanticEquivalenceClaim: false,
     metadata: {

package/dist/universal-conversion-route-metadata.js

@@ -0,0 +1,96 @@
+import { uniqueStrings } from './native-import-utils.js';
+
+export function routeAdmissionStatus(route) {
+  if (route.readiness === 'blocked' || route.admissionAction === 'reject') return 'blocked';
+  if (route.readiness === 'ready' && route.missingEvidence?.length === 0) return 'queued';
+  return 'needs-review';
+}
+
+export function routeReasonCodes(route) {
+  return uniqueStrings([
+    `mode:${route.mode}`,
+    `action:${route.routeAction}`,
+    ...(route.missingEvidence ?? []).map((item) => `missing:${item}`),
+    ...(route.blockers ?? []).map((item) => `blocker:${item}`),
+    ...(route.review ?? []).map((item) => `review:${item}`)
+  ]);
+}
+
+export function routeAdmissionMetadata(route, planId) {
+  return {
+    planId,
+    routeId: route.id,
+    routeAction: route.routeAction,
+    admissionAction: route.admissionAction,
+    priority: route.priority,
+    mergeScore: route.mergeScore,
+    representation: routeRepresentationMetadata(route),
+    ...routeSemanticEditRecordMetadata(route),
+    autoMergeClaim: false,
+    semanticEquivalenceClaim: false
+  };
+}
+
+export function routeRecordMetadata(route, planId, metadata) {
+  return {
+    planId,
+    routeId: route.id,
+    target: route.target,
+    mode: route.mode,
+    routeAction: route.routeAction,
+    representation: routeRepresentationMetadata(route),
+    ...routeSemanticEditRecordMetadata(route),
+    missingEvidence: route.missingEvidence ?? [],
+    blockers: route.blockers ?? [],
+    review: route.review ?? [],
+    autoMergeClaim: false,
+    semanticEquivalenceClaim: false,
+    ...metadata
+  };
+}
+
+export function routeSemanticEditBundle(route) {
+  const metadata = route.metadata ?? {};
+  const semanticEdit = metadata.semanticEdit ?? {};
+  return compactRecord({
+    semanticEditScript: firstDefined(route.semanticEditScript, metadata.semanticEditScript, semanticEdit.script),
+    semanticEditScripts: firstDefined(route.semanticEditScripts, metadata.semanticEditScripts, semanticEdit.scripts),
+    semanticEditProjection: firstDefined(route.semanticEditProjection, metadata.semanticEditProjection, semanticEdit.projection),
+    semanticEditProjections: firstDefined(route.semanticEditProjections, metadata.semanticEditProjections, semanticEdit.projections),
+    semanticEditReplay: firstDefined(route.semanticEditReplay, metadata.semanticEditReplay, semanticEdit.replay),
+    semanticEditReplays: firstDefined(route.semanticEditReplays, metadata.semanticEditReplays, semanticEdit.replays),
+    semanticEditAdmission: firstDefined(route.semanticEditAdmission, metadata.semanticEditAdmission, semanticEdit.admission),
+    evidence: firstDefined(route.semanticEditEvidence, metadata.semanticEditEvidence, semanticEdit.evidence),
+    testEvidence: firstDefined(route.semanticEditTestEvidence, metadata.semanticEditTestEvidence, semanticEdit.testEvidence),
+    gateEvidence: firstDefined(route.semanticEditGateEvidence, metadata.semanticEditGateEvidence, semanticEdit.gateEvidence),
+    proofEvidence: firstDefined(route.semanticEditProofEvidence, metadata.semanticEditProofEvidence, semanticEdit.proofEvidence)
+  });
+}
+
+function routeRepresentationMetadata(route) {
+  return {
+    constructKinds: route.representation?.constructKinds ?? [],
+    runtimeCapabilities: route.representation?.surfaces?.runtime?.requiredCapabilities ?? [],
+    sourceMapPrecisions: route.representation?.surfaces?.sourceMaps?.precisions ?? [],
+    transformIdentityHashes: route.representation?.surfaces?.mergeRefs?.transformIdentityHashes ?? [],
+    missing: route.representation?.missing ?? [],
+    blockers: route.representation?.blockers ?? []
+  };
+}
+
+function routeSemanticEditRecordMetadata(route) {
+  const metadata = route.metadata ?? {};
+  const semanticEdit = metadata.semanticEdit ?? {};
+  return compactRecord({
+    semanticEditSummary: firstDefined(metadata.semanticEditSummary, semanticEdit.summary),
+    semanticEditAdmission: firstDefined(route.semanticEditAdmission, metadata.semanticEditAdmission, semanticEdit.admission)
+  });
+}
+
+function firstDefined(...values) {
+  return values.find((value) => value !== undefined);
+}
+
+function compactRecord(value) {
+  return Object.fromEntries(Object.entries(value ?? {}).filter(([, entry]) => entry !== undefined && (!Array.isArray(entry) || entry.length > 0)));
+}

package/dist/universal-conversion-route-operations.js

@@ -47,6 +47,13 @@ function routeOperationMetadata(route, source, sourceMapLinks) {
     sourcePath: source.sourcePath,
     sourceHash: source.sourceHash,
     sourceMapLinkIds: sourceMapLinks.map((link) => link.id),
+    representation: {
+      constructKinds: route.representation?.constructKinds ?? [],
+      runtimeCapabilities: route.representation?.surfaces?.runtime?.requiredCapabilities ?? [],
+      sourceMapPrecisions: route.representation?.surfaces?.sourceMaps?.precisions ?? [],
+      missing: route.representation?.missing ?? [],
+      blockers: route.representation?.blockers ?? []
+    },
     targetLossKinds: route.evidence?.targetLossKinds ?? [],
     missingEvidence: route.missingEvidence ?? [],
     blockers: route.blockers ?? [],