@shapeshift-labs/frontier-lang-compiler 0.2.48 → 0.2.50

package/dist/universal-conversion-artifacts.js

@@ -0,0 +1,287 @@
+import { idFragment, uniqueStrings } from './native-import-utils.js';
+import { createUniversalConversionPlan } from './universal-conversion-plan.js';
+import { artifactIndex } from './universal-conversion-artifact-query.js';
+import { createSemanticHistoryRecord } from './internal/index-impl/semanticHistoryRecords.js';
+import { createSemanticPatchBundleRecord } from './internal/index-impl/semanticPatchBundleRecords.js';
+
+export { queryUniversalConversionArtifacts } from './universal-conversion-artifact-query.js';
+
+export function createUniversalConversionArtifacts(input = {}, options = {}) {
+  const generatedAt = options.generatedAt ?? input.generatedAt ?? Date.now();
+  const plan = input?.kind === 'frontier.lang.universalConversionPlan'
+    ? input
+    : input?.target && input?.sourceLanguage
+      ? undefined
+      : createUniversalConversionPlan(input);
+  const routes = selectRoutes(plan?.routes ?? (input?.target && input?.sourceLanguage ? [input] : []), options);
+  const routeArtifacts = routes.map((route) => createRouteArtifact(route, {
+    generatedAt,
+    planId: options.planId ?? plan?.id ?? route.mergeRefs?.planId,
+    metadata: options.metadata
+  }));
+  const historyRecords = routeArtifacts.map((artifact) => artifact.history);
+  const patchBundleRecords = routeArtifacts.map((artifact) => artifact.patchBundle);
+  const index = artifactIndex(routeArtifacts);
+  return {
+    kind: 'frontier.lang.universalConversionArtifacts',
+    version: 1,
+    schema: 'frontier.lang.universalConversionArtifacts.v1',
+    id: options.id ?? `universal_conversion_artifacts_${idFragment(index.routeIds.join('_') || plan?.id || 'routes')}`,
+    planId: plan?.id ?? options.planId,
+    generatedAt,
+    routeArtifacts,
+    historyRecords,
+    patchBundleRecords,
+    index,
+    summary: {
+      routes: routeArtifacts.length,
+      histories: historyRecords.length,
+      patchBundles: patchBundleRecords.length,
+      reviewRequired: routeArtifacts.filter((artifact) => artifact.reviewRequired).length,
+      blocked: routeArtifacts.filter((artifact) => artifact.admissionStatus === 'blocked').length,
+      autoMergeClaims: 0,
+      semanticEquivalenceClaims: 0
+    },
+    metadata: {
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      note: 'Materialized conversion artifacts are merge-review records. They preserve provenance and admission state but do not prove target semantic equivalence.',
+      ...options.metadata
+    }
+  };
+}
+
+function createRouteArtifact(route, options) {
+  const refs = route.mergeRefs ?? {};
+  const planId = options.planId ?? refs.planId;
+  const sources = normalizeSources(refs.sources, route);
+  const regions = routeRegions(route, refs, sources);
+  const sourceMapLinks = routeSourceMapLinks(route, refs, sources, regions);
+  const admissionStatus = routeAdmissionStatus(route);
+  const reasonCodes = routeReasonCodes(route);
+  const historyId = refs.historyIds?.[0] ?? `history_${route.id}`;
+  const patchBundleId = refs.patchBundleIds?.[0] ?? `semantic_patch_bundle_${route.id}`;
+  const history = createSemanticHistoryRecord({
+    id: historyId,
+    createdAt: options.generatedAt,
+    language: route.sourceLanguage,
+    sourcePath: sources[0]?.sourcePath,
+    sources,
+    ownershipRegions: regions,
+    semanticCandidates: routeSemanticCandidates(route, refs),
+    evidenceIds: refs.evidenceIds,
+    proofIds: refs.proofIds,
+    replayLinks: refs.replayLinks,
+    admission: {
+      status: admissionStatus,
+      readiness: route.readiness,
+      reasonCodes,
+      evidenceIds: refs.evidenceIds,
+      metadata: routeAdmissionMetadata(route, planId)
+    },
+    metadata: routeRecordMetadata(route, planId, options.metadata)
+  }, { id: historyId, createdAt: options.generatedAt });
+  const patchBundle = createSemanticPatchBundleRecord({
+    id: patchBundleId,
+    language: route.sourceLanguage,
+    sourcePath: sources[0]?.sourcePath,
+    sources,
+    changedRegions: regions,
+    sourceMapLinks,
+    evidenceIds: refs.evidenceIds,
+    proofIds: refs.proofIds,
+    historyIds: [history.id],
+    readiness: route.readiness,
+    conflictKeys: refs.conflictKeys,
+    admission: {
+      status: admissionStatus,
+      readiness: route.readiness,
+      reviewRequired: true,
+      reasonCodes,
+      conflictKeys: refs.conflictKeys,
+      evidenceIds: refs.evidenceIds,
+      metadata: routeAdmissionMetadata(route, planId)
+    },
+    metadata: routeRecordMetadata(route, planId, options.metadata)
+  }, { id: patchBundleId, createdAt: options.generatedAt });
+  const materialization = {
+    status: 'materialized',
+    plannedHistoryIds: refs.historyIds ?? [],
+    materializedHistoryIds: [history.id],
+    patchBundleIds: [patchBundle.id],
+    sourceMapLinkIds: patchBundle.index.sourceMapLinkIds,
+    evidenceIds: history.evidenceIds,
+    proofIds: history.proofIds,
+    autoMergeClaim: false,
+    semanticEquivalenceClaim: false
+  };
+  return {
+    kind: 'frontier.lang.universalConversionRouteArtifact',
+    version: 1,
+    schema: 'frontier.lang.universalConversionRouteArtifact.v1',
+    routeId: route.id,
+    planId,
+    sourceLanguage: route.sourceLanguage,
+    target: route.target,
+    mode: route.mode,
+    routeAction: route.routeAction,
+    priority: route.priority,
+    readiness: route.readiness,
+    admissionAction: route.admissionAction,
+    admissionStatus,
+    reviewRequired: true,
+    history,
+    patchBundle,
+    materialization,
+    mergeScore: route.mergeScore,
+    autoMergeClaim: false,
+    semanticEquivalenceClaim: false,
+    metadata: { ...routeRecordMetadata(route, planId, options.metadata), materialization }
+  };
+}
+
+function selectRoutes(routes, options) {
+  const selected = (routes ?? []).filter((route) => {
+    if (options.routeId && route.id !== options.routeId) return false;
+    if (options.sourceLanguage && route.sourceLanguage !== options.sourceLanguage) return false;
+    if (options.target && route.target !== options.target) return false;
+    if (options.mode && route.mode !== options.mode) return false;
+    if (options.readiness && route.readiness !== options.readiness) return false;
+    if (options.admissionAction && route.admissionAction !== options.admissionAction) return false;
+    return true;
+  });
+  return Number.isFinite(options.maxRoutes) ? selected.slice(0, Math.max(0, Number(options.maxRoutes))) : selected;
+}
+
+function normalizeSources(sources, route) {
+  return (sources?.length ? sources : [{}]).map((source, index) => ({
+    id: source.sourceId ?? source.id ?? `route_source_${idFragment(route.id)}_${index + 1}`,
+    importId: source.importId,
+    language: route.sourceLanguage,
+    sourcePath: source.sourcePath,
+    sourceHash: source.sourceHash,
+    baseHash: source.baseHash,
+    targetHash: source.targetHash,
+    metadata: {
+      routeId: route.id,
+      target: route.target,
+      mode: route.mode
+    }
+  }));
+}
+
+function routeRegions(route, refs, sources) {
+  const source = sources[0] ?? {};
+  const keys = refs.semanticOwnershipKeys?.length
+    ? refs.semanticOwnershipKeys
+    : [`conversion#${route.sourceLanguage ?? 'source'}#${route.target ?? 'target'}#${route.id}`];
+  return uniqueStrings(keys).map((key, index) => ({
+    id: `route_region_${idFragment(route.id)}_${index + 1}`,
+    key,
+    conflictKey: refs.conflictKeys?.[index] ?? refs.conflictKeys?.[0] ?? key,
+    changeKind: 'conversion-route',
+    regionKind: route.mode,
+    granularity: 'conversion-route',
+    precision: route.mode === 'preserve-source' ? 'exact-source' : 'semantic-route',
+    language: route.sourceLanguage,
+    sourcePath: source.sourcePath,
+    sourceHash: source.sourceHash,
+    sourceMapIds: refs.sourceMapIds,
+    sourceMapMappingIds: refs.sourceMapMappingIds,
+    admission: {
+      readiness: route.readiness,
+      action: route.admissionAction,
+      conflictKeys: refs.conflictKeys
+    },
+    metadata: {
+      routeId: route.id,
+      target: route.target,
+      mode: route.mode,
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false
+    }
+  }));
+}
+
+function routeSourceMapLinks(route, refs, sources, regions) {
+  const source = sources[0] ?? {};
+  const max = Math.max(refs.sourceMapIds?.length ?? 0, refs.sourceMapMappingIds?.length ?? 0);
+  return Array.from({ length: max }, (_, index) => ({
+    id: refs.sourceMapLinkIds?.[index] ?? `route_source_map_link_${idFragment(route.id)}_${index + 1}`,
+    sourceMapId: refs.sourceMapIds?.[index] ?? refs.sourceMapIds?.[0],
+    sourceMapMappingId: refs.sourceMapMappingIds?.[index],
+    sourcePath: source.sourcePath,
+    sourceHash: source.sourceHash,
+    targetPath: `${route.target}:${source.sourcePath ?? route.id}`,
+    precision: route.mode === 'preserve-source' ? 'exact-source' : 'semantic-route',
+    regionKey: regions[index % Math.max(1, regions.length)]?.key,
+    regionKind: route.mode
+  }));
+}
+
+function routeSemanticCandidates(route, refs) {
+  const ids = refs.mergeCandidateIds?.length ? refs.mergeCandidateIds : [`candidate_${route.id}`];
+  return uniqueStrings(ids).map((id) => ({
+    id,
+    sourcePath: refs.sources?.[0]?.sourcePath,
+    baseHash: refs.sources?.[0]?.baseHash,
+    targetHash: refs.sources?.[0]?.targetHash,
+    readiness: route.readiness,
+    conflictKeys: refs.conflictKeys ?? [],
+    ownershipKeys: refs.semanticOwnershipKeys ?? [],
+    evidenceIds: refs.evidenceIds ?? [],
+    proofIds: refs.proofIds ?? [],
+    replayIds: (refs.replayLinks ?? []).map((link) => link?.id).filter(Boolean),
+    metadata: {
+      routeId: route.id,
+      target: route.target,
+      mode: route.mode,
+      risk: route.mergeScore?.risk
+    }
+  }));
+}
+
+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-merge-refs.js

@@ -0,0 +1,125 @@
+import {
+  idFragment,
+  normalizeNativeLanguageId,
+  uniqueStrings
+} from './native-import-utils.js';
+
+export function importsForConversionLanguage(imports, language) {
+  const ids = new Set([language?.language, ...(language?.aliases ?? [])].map(normalizeNativeLanguageId).filter(Boolean));
+  return (imports ?? []).filter((imported) => ids.has(normalizeNativeLanguageId(imported?.language ?? imported?.nativeAst?.language)));
+}
+
+export function conversionMergeRefs(input) {
+  const routeImports = input.imports ?? [];
+  const routeId = input.routeId;
+  const sourceMaps = routeImports.flatMap(sourceMapsForImport);
+  return {
+    planId: input.planId,
+    routeId,
+    historyIds: [`history_${routeId}`],
+    patchBundleIds: [],
+    patchIds: [],
+    mergeCandidateIds: uniqueStrings(routeImports.flatMap(mergeCandidateIds)),
+    replayLinks: routeImports.flatMap((imported) => imported?.replayLinks ?? imported?.universalAst?.replayLinks ?? []),
+    evidenceIds: uniqueStrings(routeImports.flatMap((imported) => evidenceRecords(imported).map((record) => record.id))),
+    proofIds: uniqueStrings(routeImports.flatMap(proofIdsForImport)),
+    sources: routeImports.map(conversionSourceRef),
+    semanticOwnershipKeys: uniqueStrings(routeImports.flatMap(semanticOwnershipKeysForImport)),
+    conflictKeys: uniqueStrings(routeImports.flatMap(conflictKeysForImport)),
+    sourceMapIds: uniqueStrings(sourceMaps.map((sourceMap) => sourceMap?.id)),
+    sourceMapMappingIds: uniqueStrings(sourceMaps.flatMap((sourceMap) => (sourceMap?.mappings ?? []).map((mapping) => mapping.id))),
+    sourceMapLinkIds: [],
+    readiness: input.readiness,
+    admissionStatus: input.admissionStatus,
+    metadata: {
+      plannedHistoryId: true,
+      note: 'Merge refs are compact route provenance for semantic history and patch-bundle builders; planned IDs are not proof records until materialized.'
+    }
+  };
+}
+
+function conversionSourceRef(imported) {
+  return {
+    sourceId: imported?.nativeSource?.id ?? imported?.id,
+    importId: imported?.id,
+    sourcePath: imported?.sourcePath ?? imported?.nativeSource?.sourcePath,
+    sourceHash: imported?.sourceHash
+      ?? imported?.nativeSource?.sourceHash
+      ?? imported?.metadata?.sourcePreservation?.sourceHash,
+    baseHash: imported?.baseHash ?? imported?.metadata?.baseHash,
+    targetHash: imported?.targetHash ?? imported?.metadata?.targetHash
+  };
+}
+
+function evidenceRecords(imported) {
+  return [
+    ...(imported?.evidence ?? []),
+    ...(imported?.universalAst?.evidence ?? []),
+    ...(imported?.patch?.evidence ?? [])
+  ].filter((record) => record?.id);
+}
+
+function proofIdsForImport(imported) {
+  return [
+    ...(imported?.proofIds ?? []),
+    ...evidenceRecords(imported).filter((record) => record?.kind === 'proof' || record?.type === 'proof').map((record) => record.id)
+  ];
+}
+
+function mergeCandidateIds(imported) {
+  return (imported?.mergeCandidates ?? []).map((candidate) => candidate.id);
+}
+
+function sourceMapsForImport(imported) {
+  return [
+    ...(imported?.sourceMaps ?? []),
+    ...(imported?.universalAst?.sourceMaps ?? [])
+  ];
+}
+
+function semanticOwnershipKeysForImport(imported) {
+  return uniqueStrings([
+    ...ownershipKeysFromCandidates(imported),
+    ...ownershipKeysFromSourceMaps(imported),
+    ...ownershipKeysFromSymbols(imported)
+  ]);
+}
+
+function conflictKeysForImport(imported) {
+  return uniqueStrings([
+    ...conflictKeysFromCandidates(imported),
+    ...ownershipKeysFromSourceMaps(imported)
+  ]);
+}
+
+function ownershipKeysFromCandidates(imported) {
+  return uniqueStrings((imported?.mergeCandidates ?? []).flatMap((candidate) => [
+    ...(candidate?.ownershipKeys ?? []),
+    ...(candidate?.semanticOwnershipKeys ?? []),
+    ...(candidate?.changedRegions ?? []).map((region) => region?.key)
+  ]));
+}
+
+function conflictKeysFromCandidates(imported) {
+  return uniqueStrings((imported?.mergeCandidates ?? []).flatMap((candidate) => [
+    ...(candidate?.conflictKeys ?? []),
+    ...(candidate?.changedRegions ?? []).flatMap((region) => [region?.conflictKey, ...(region?.admission?.conflictKeys ?? [])])
+  ]));
+}
+
+function ownershipKeysFromSourceMaps(imported) {
+  return uniqueStrings(sourceMapsForImport(imported).flatMap((sourceMap) => (sourceMap?.mappings ?? []).flatMap((mapping) => [
+    mapping?.ownershipRegionKey,
+    mapping?.ownershipRegionId,
+    mapping?.ownershipRegionKind ? `${mapping.sourceSpan?.path ?? imported?.sourcePath ?? 'source'}#${mapping.ownershipRegionKind}` : undefined
+  ])));
+}
+
+function ownershipKeysFromSymbols(imported) {
+  const symbols = imported?.semanticIndex?.symbols ?? imported?.universalAst?.semanticIndex?.symbols ?? [];
+  return uniqueStrings(symbols.flatMap((symbol) => [
+    symbol?.metadata?.ownershipRegionKey,
+    symbol?.metadata?.ownershipRegionId,
+    symbol?.metadata?.ownershipRegionKind ? `${symbol.language ?? imported?.language ?? 'source'}#${idFragment(symbol.name)}#${symbol.metadata.ownershipRegionKind}` : undefined
+  ]));
+}

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

@@ -0,0 +1,134 @@
+import { uniqueStrings } from './native-import-utils.js';
+
+const readinessScore = Object.freeze({ ready: 100, 'ready-with-losses': 76, 'needs-review': 48, blocked: 0 });
+const readinessRank = Object.freeze({ ready: 3, 'ready-with-losses': 2, 'needs-review': 1, blocked: 0 });
+const actionRank = Object.freeze({ admit: 2, prioritize: 1, reject: 0 });
+const modeRank = Object.freeze({
+  'preserve-source': 5,
+  'target-adapter': 4,
+  'stub-only': 3,
+  'semantic-index-only': 2,
+  blocked: 0
+});
+const componentWeights = Object.freeze({
+  importEvidence: 22,
+  parserEvidence: 18,
+  semanticIndex: 18,
+  projectionPath: 24,
+  proofEvidence: 18
+});
+
+export function conversionScoreComponents(language, targetCell, readiness, mode, evidence) {
+  return {
+    importEvidence: scoreComponent('importEvidence', readinessScore[language.imports.readiness] ?? 48, [
+      ...(language.imports.total ? [] : ['No source import evidence.']),
+      ...(language.imports.readiness === 'ready' ? [] : [`Import readiness is ${language.imports.readiness}.`])
+    ], { imports: language.imports.total, losses: language.imports.losses }),
+    parserEvidence: scoreComponent('parserEvidence', parserScore(language), [
+      ...(language.parser.rows ? [] : ['No parser feature row matched this language.']),
+      ...(language.parser.blockingFeatures ?? []).map((feature) => `Parser feature is blocked: ${feature}.`)
+    ], { rows: language.parser.rows, mergeReadyParsers: language.parser.mergeReadyParsers.length }),
+    semanticIndex: scoreComponent('semanticIndex', semanticIndexScore(language), [
+      ...(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 }),
+    projectionPath: scoreComponent('projectionPath', projectionPathScore(targetCell, mode, readiness), projectionPathReasons(targetCell, mode), {
+      mode,
+      lossClass: targetCell?.lossClass,
+      adapter: targetCell?.adapter,
+      readiness
+    }),
+    proofEvidence: scoreComponent('proofEvidence', proofEvidenceScore(evidence), proofEvidenceReasons(evidence), {
+      records: evidence.length,
+      passed: evidence.filter((record) => passedEvidence(record)).length,
+      failed: evidence.filter((record) => record?.status === 'failed').length
+    })
+  };
+}
+
+export function conversionMergeScore(input) {
+  const weighted = Object.values(input.components).reduce((sum, component) => sum + component.weightedScore, 0);
+  const weight = Object.values(input.components).reduce((sum, component) => sum + component.weight, 0);
+  const uncappedValue = Math.round(weight ? weighted * 100 / weight : 0);
+  const action = input.blockers.length || input.readiness === 'blocked' || input.mode === 'blocked' ? 'reject'
+    : input.readiness === 'ready' && input.mode !== 'stub-only' && input.mode !== 'semantic-index-only' ? 'admit'
+      : 'prioritize';
+  const value = action === 'reject' ? Math.min(35, uncappedValue) : uncappedValue;
+  return {
+    schema: 'frontier.lang.semanticMergeScore.v1',
+    version: 1,
+    value,
+    uncappedValue,
+    sortKey: value + (actionRank[action] ?? 0) * 1000 + (modeRank[input.mode] ?? 0) * 100 + (readinessRank[input.readiness] ?? 0) * 10,
+    higherIsBetter: true,
+    readiness: input.readiness,
+    risk: input.readiness === 'blocked' ? 'high' : input.readiness === 'needs-review' ? 'medium' : 'low',
+    action,
+    components: input.components,
+    penalties: uniqueStrings([
+      ...(action === 'reject' ? ['Conversion route is rejected until blockers are resolved.'] : []),
+      ...Object.values(input.components).flatMap((component) => component.score < 100 ? component.reasons : [])
+    ])
+  };
+}
+
+function parserScore(language) {
+  if (!language.parser.rows) return 0;
+  return Math.min(100, (readinessScore[language.parser.readiness] ?? 48) + Math.min(16, language.parser.mergeReadyParsers.length * 8));
+}
+
+function semanticIndexScore(language) {
+  const symbols = language.imports.symbols ?? 0;
+  const mappings = language.imports.sourceMapMappings ?? 0;
+  if (!symbols) return 0;
+  return Math.min(100, 62 + Math.min(22, symbols * 3) + Math.min(16, mappings * 2));
+}
+
+function projectionPathScore(targetCell, mode, readiness) {
+  if (mode === 'blocked') return 0;
+  if (mode === 'preserve-source') return 92;
+  if (mode === 'target-adapter') return Math.min(92, (readinessScore[readiness] ?? 48) + (targetCell?.adapter ? 12 : 0));
+  if (mode === 'stub-only') return 44;
+  if (mode === 'semantic-index-only') return 30;
+  return 10;
+}
+
+function proofEvidenceScore(evidence) {
+  if (!evidence.length) return 45;
+  const passed = evidence.filter((record) => passedEvidence(record)).length;
+  const failed = evidence.filter((record) => record?.status === 'failed').length;
+  return Math.max(0, Math.min(100, 55 + passed * 12 - failed * 35));
+}
+
+function projectionPathReasons(targetCell, mode) {
+  return uniqueStrings([
+    ...(targetCell?.reason ? [targetCell.reason] : []),
+    ...(mode === 'blocked' ? ['Projection path is blocked.'] : []),
+    ...(mode === 'semantic-index-only' ? ['Semantic index can guide review, but code emission needs a target adapter.'] : [])
+  ]);
+}
+
+function proofEvidenceReasons(evidence) {
+  return uniqueStrings([
+    ...(!evidence.length ? ['No proof, oracle, test, or replay evidence was attached to this conversion route.'] : []),
+    ...(evidence.filter((record) => record?.status === 'failed').length ? ['At least one attached evidence record failed.'] : [])
+  ]);
+}
+
+function scoreComponent(key, score, reasons, signals) {
+  const normalized = Math.max(0, Math.min(100, Math.round(score)));
+  const weight = componentWeights[key];
+  return {
+    key,
+    score: normalized,
+    weight,
+    weightedScore: normalized * weight / 100,
+    status: normalized >= 80 ? 'strong' : normalized >= 50 ? 'partial' : normalized > 0 ? 'weak' : 'blocked',
+    reasons: uniqueStrings(reasons),
+    signals
+  };
+}
+
+function passedEvidence(record) {
+  return record?.status === 'passed' || record?.status === 'ok' || record?.status === 'success';
+}