@shapeshift-labs/frontier-lang-compiler 0.2.99 → 0.2.101

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

@@ -14,16 +14,20 @@ export function createSemanticEditBundleAdmission(input = {}, options = {}) {
   const scripts = array(input.semanticEditScripts ?? input.scripts ?? input.semanticEditScript);
   const projections = array(input.semanticEditProjections ?? input.projections ?? input.semanticEditProjection);
   const replays = array(input.semanticEditReplays ?? input.replays ?? input.semanticEditReplay);
-  const summary = summarizeSemanticEditBundle(scripts, projections, replays);
-  const status = input.status ?? options.status ?? semanticEditBundleStatus(summary);
+  const evidence = evidenceRecords(input, options);
+  const summary = summarizeSemanticEditBundle(scripts, projections, replays, evidence);
+  const computedStatus = semanticEditBundleStatus(summary);
+  const status = safeStatus(input.status ?? options.status, computedStatus, summary);
   const readiness = normalizeSemanticMergeReadiness(input.readiness ?? options.readiness ?? readinessForStatus(status))
     ?? input.readiness ?? options.readiness ?? readinessForStatus(status);
+  const positiveAutoApplyCandidate = status === 'ready' && hasPositiveAutoMergeProof(summary);
+  const computedReviewRequired = !['ready', 'already-applied', 'none'].includes(status) || (status === 'ready' && !positiveAutoApplyCandidate);
   return compactRecord({
     status,
-    action: input.action ?? options.action ?? actionForStatus(status),
+    action: safeAction(input.action ?? options.action, status, positiveAutoApplyCandidate),
     readiness,
-    reviewRequired: input.reviewRequired ?? !['ready', 'already-applied', 'none'].includes(status),
-    autoApplyCandidate: input.autoApplyCandidate ?? status === 'ready',
+    reviewRequired: input.reviewRequired === true || computedReviewRequired,
+    autoApplyCandidate: input.autoApplyCandidate === false ? false : positiveAutoApplyCandidate,
     autoMergeClaim: false,
     semanticEquivalenceClaim: false,
     reasonCodes: uniqueStrings([
@@ -31,7 +35,7 @@ export function createSemanticEditBundleAdmission(input = {}, options = {}) {
       ...strings(options.reasonCodes),
       ...summary.reasonCodes,
       ...derivedReasonCodes(summary, status)
-    ]),
+    ].filter(Boolean)),
     sourcePaths: summary.sourcePaths,
     scriptIds: summary.scriptIds,
     projectionIds: summary.projectionIds,
@@ -41,7 +45,7 @@ export function createSemanticEditBundleAdmission(input = {}, options = {}) {
   });
 }
 
-function summarizeSemanticEditBundle(scripts, projections, replays) {
+function summarizeSemanticEditBundle(scripts, projections, replays, evidence) {
   const scriptStatusEntries = scripts.map((script) => script.admission?.status);
   const projectionStatusEntries = projections.flatMap((projection) => [projection.status, projection.admission?.status]);
   const replayStatusEntries = replays.map((replay) => replay.status);
@@ -49,11 +53,14 @@ function summarizeSemanticEditBundle(scripts, projections, replays) {
   const projectionStatuses = uniqueStrings(strings(projectionStatusEntries));
   const replayStatuses = uniqueStrings(strings(replayStatusEntries));
   const replayActions = uniqueStrings(strings(replays.map((replay) => replay.admission?.action)));
+  const evidenceSummary = summarizeEvidence(evidence);
   return {
     scripts: scripts.length,
     projections: projections.length,
     replays: replays.length,
     files: sourcePaths(scripts, projections, replays).length,
+    portableScripts: scripts.filter((script) => script.admission?.status === 'auto-merge-candidate').length,
+    portableProjections: projections.filter((projection) => projection.status === 'projected' && projection.admission?.status === 'auto-merge-candidate').length,
     acceptedClean: replays.filter((replay) => replay.status === 'accepted-clean').length,
     alreadyApplied: replays.filter((replay) => replay.status === 'already-applied').length,
     conflicts: countStatuses(scriptStatusEntries, replayStatusEntries, ['conflict']),
@@ -70,30 +77,43 @@ function summarizeSemanticEditBundle(scripts, projections, replays) {
     scriptIds: uniqueStrings(scripts.map((script) => script.id)),
     projectionIds: uniqueStrings(projections.map((projection) => projection.id)),
     replayIds: uniqueStrings(replays.map((replay) => replay.id)),
+    evidenceIds: evidenceSummary.evidenceIds,
+    passedTestEvidence: evidenceSummary.passed,
+    failedTestEvidence: evidenceSummary.failed,
+    conflictEvidence: evidenceSummary.conflict,
+    staleEvidence: evidenceSummary.stale,
     reasonCodes: uniqueStrings([
       ...scripts.flatMap((script) => strings(script.admission?.reasonCodes)),
       ...projections.flatMap((projection) => strings(projection.admission?.reasonCodes)),
-      ...replays.flatMap((replay) => strings(replay.admission?.reasonCodes))
+      ...replays.flatMap((replay) => strings(replay.admission?.reasonCodes)),
+      ...evidenceSummary.reasonCodes
     ])
   };
 }
 
 function semanticEditBundleStatus(summary) {
   const total = summary.scripts + summary.projections + summary.replays;
+  if (summary.blocked || summary.projectionBlocked || summary.failedTestEvidence) return 'blocked';
+  if (summary.conflicts || summary.conflictEvidence) return 'conflict';
+  if (summary.stale || summary.staleEvidence) return 'stale';
   if (total === 0) return 'none';
-  if (summary.blocked || summary.projectionBlocked) return 'blocked';
-  if (summary.conflicts) return 'conflict';
-  if (summary.stale) return 'stale';
   if (!summary.replays || summary.needsReview) return 'needs-review';
   if (summary.acceptedClean === 0 && summary.alreadyApplied === summary.replays) return 'already-applied';
-  return summary.acceptedClean + summary.alreadyApplied === summary.replays ? 'ready' : 'needs-review';
+  return hasPositiveAutoMergeProof(summary) ? 'ready' : 'needs-review';
 }
 
 function derivedReasonCodes(summary, status) {
   return [
     summary.scripts && !summary.projections ? 'semantic-edit-projection-missing' : undefined,
     (summary.scripts || summary.projections) && !summary.replays ? 'semantic-edit-replay-missing' : undefined,
+    summary.scripts && summary.portableScripts !== summary.scripts ? 'semantic-edit-script-not-portable' : undefined,
+    summary.projections && summary.portableProjections !== summary.projections ? 'semantic-edit-projection-not-portable' : undefined,
+    summary.acceptedClean && !summary.passedTestEvidence ? 'semantic-edit-tests-passed-evidence-missing' : undefined,
+    summary.failedTestEvidence ? 'semantic-edit-tests-failed' : undefined,
+    summary.conflictEvidence ? 'semantic-edit-conflict-evidence' : undefined,
+    summary.staleEvidence ? 'semantic-edit-stale-evidence' : undefined,
     status === 'ready' ? 'semantic-edit-replay-accepted-clean' : undefined,
+    status === 'ready' ? 'semantic-edit-positive-auto-merge-proof' : undefined,
     status === 'already-applied' ? 'semantic-edit-replay-already-applied' : undefined,
     status === 'blocked' ? 'semantic-edit-blocked' : undefined,
     status === 'conflict' ? 'semantic-edit-conflict' : undefined,
@@ -101,6 +121,19 @@ function derivedReasonCodes(summary, status) {
   ];
 }
 
+function hasPositiveAutoMergeProof(summary) {
+  return summary.acceptedClean > 0 &&
+    summary.acceptedClean + summary.alreadyApplied === summary.replays &&
+    summary.scripts > 0 &&
+    summary.projections > 0 &&
+    summary.portableScripts === summary.scripts &&
+    summary.portableProjections === summary.projections &&
+    summary.passedTestEvidence > 0 &&
+    summary.failedTestEvidence === 0 &&
+    summary.conflictEvidence === 0 &&
+    summary.staleEvidence === 0;
+}
+
 function readinessForStatus(status) {
   if (['ready', 'already-applied'].includes(status)) return 'ready';
   if (['blocked', 'conflict'].includes(status)) return 'blocked';
@@ -116,6 +149,20 @@ function actionForStatus(status) {
   return 'review';
 }
 
+function safeStatus(requested, computed, summary) {
+  if (!requested) return computed;
+  if (requested === 'ready' && !hasPositiveAutoMergeProof(summary)) return computed;
+  if (requested === 'already-applied' && computed !== 'already-applied') return computed;
+  if (['blocked', 'conflict', 'stale'].includes(requested)) return requested;
+  return computed;
+}
+
+function safeAction(requested, status, positiveAutoApplyCandidate) {
+  if (requested === 'admit' && !positiveAutoApplyCandidate) return actionForStatus(status);
+  if (requested === 'skip' && status !== 'already-applied') return actionForStatus(status);
+  return requested ?? actionForStatus(status);
+}
+
 function sourcePaths(scripts, projections, replays) {
   return uniqueStrings(strings([
     ...scripts.map((script) => script.sourcePath),
@@ -132,6 +179,42 @@ function countStatuses(...args) {
   return statuses.filter((status) => needles.has(status)).length;
 }
 
+function evidenceRecords(...sources) {
+  return sources.flatMap((source) => [
+    ...array(source?.evidence),
+    ...array(source?.testEvidence),
+    ...array(source?.testResults),
+    ...array(source?.gateEvidence),
+    ...array(source?.proofEvidence)
+  ]).filter(Boolean);
+}
+
+function summarizeEvidence(evidence) {
+  const testLike = evidence.filter(isAutoMergeTestEvidence);
+  const conflict = evidence.filter((record) => evidenceStatus(record, ['conflict', 'conflicted']) || record?.metadata?.conflict === true || strings(record?.reasonCodes ?? record?.reasons).some((reason) => reason.toLowerCase().includes('conflict')));
+  const stale = evidence.filter((record) => evidenceStatus(record, ['stale']) || record?.metadata?.stale === true || strings(record?.reasonCodes ?? record?.reasons).some((reason) => reason.toLowerCase().includes('stale')));
+  const failed = testLike.filter((record) => evidenceStatus(record, ['failed', 'failure', 'error', 'blocked', 'rejected']));
+  const passed = testLike.filter((record) => evidenceStatus(record, ['passed', 'ok', 'success', 'succeeded', 'accepted', 'verified']));
+  return {
+    evidenceIds: uniqueStrings(evidence.map((record) => record.id)),
+    passed: passed.length,
+    failed: failed.length,
+    conflict: conflict.length,
+    stale: stale.length,
+    reasonCodes: uniqueStrings(evidence.flatMap((record) => strings(record.reasonCodes ?? record.reasons)))
+  };
+}
+
+function isAutoMergeTestEvidence(record) {
+  const kind = String(record?.kind ?? record?.type ?? '').toLowerCase();
+  return ['test', 'tests', 'proof', 'gate', 'verification', 'check'].includes(kind);
+}
+
+function evidenceStatus(record, statuses) {
+  const status = String(record?.status ?? record?.outcome ?? '').toLowerCase();
+  return statuses.includes(status);
+}
+
 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); }
 function compactRecord(value) { return Object.fromEntries(Object.entries(value ?? {}).filter(([, entry]) => entry !== undefined && (!Array.isArray(entry) || entry.length > 0))); }

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

@@ -15,16 +15,16 @@ export function semanticEditRecordIndex(scripts, projections, replays, source =
     semanticEditReplayEditCount: replayEdits.length,
     semanticEditReplayStatuses: uniqueStrings([...strings(source.semanticEditReplayStatuses), ...strings(index.semanticEditReplayStatuses), ...strings(summary.replayStatuses), ...replays.map((replay) => replay.status)]),
     semanticEditReplayActions: uniqueStrings([...strings(source.semanticEditReplayActions), ...strings(index.semanticEditReplayActions), ...strings(summary.replayActions), ...replays.map((replay) => replay.admission?.action)]),
-    semanticEditReplayCurrentHashes: uniqueStrings([...strings(source.semanticEditReplayCurrentHashes), ...strings(index.semanticEditReplayCurrentHashes), ...replays.map((replay) => replay.currentHash)]),
-    semanticEditReplayOutputHashes: uniqueStrings([...strings(source.semanticEditReplayOutputHashes), ...strings(index.semanticEditReplayOutputHashes), ...replays.map((replay) => replay.outputHash)]),
-    semanticEditKeys: uniqueStrings([...strings(source.semanticEditKeys), ...strings(index.semanticEditKeys), ...operations.map((operation) => operation.semanticKey), ...edits.map((edit) => edit.semanticKey), ...replayEdits.map((edit) => edit.semanticKey)]),
-    semanticIdentityHashes: uniqueStrings([...strings(source.semanticIdentityHashes), ...strings(index.semanticIdentityHashes), ...operations.map((operation) => operation.semanticIdentityHash), ...edits.map((edit) => edit.semanticIdentityHash), ...replayEdits.map((edit) => edit.semanticIdentityHash)]),
-    sourceIdentityHashes: uniqueStrings([...strings(source.sourceIdentityHashes), ...strings(index.sourceIdentityHashes), ...operations.map((operation) => operation.sourceIdentityHash), ...edits.map((edit) => edit.sourceIdentityHash), ...replayEdits.map((edit) => edit.sourceIdentityHash)]),
-    operationContentHashes: uniqueStrings([...strings(source.operationContentHashes), ...strings(index.operationContentHashes), ...operations.map((operation) => operation.operationContentHash), ...edits.map((edit) => edit.operationContentHash)]),
-    editContentHashes: uniqueStrings([...strings(source.editContentHashes), ...strings(index.editContentHashes), ...edits.map((edit) => edit.editContentHash), ...replayEdits.map((edit) => edit.editContentHash)]),
-    anchorKeys: uniqueStrings([...operations.map((operation) => operation.anchor?.key), ...edits.map((edit) => edit.anchorKey)]),
-    conflictKeys: uniqueStrings([...operations.map((operation) => operation.anchor?.conflictKey), ...edits.map((edit) => edit.conflictKey)]),
-    projectedSourcePaths: uniqueStrings([...projections.map((projection) => projection.sourcePath), ...edits.flatMap((edit) => [edit.sourcePath, edit.targetSourcePath]), ...replays.map((replay) => replay.sourcePath), ...replayEdits.map((edit) => edit.sourcePath)])
+    semanticEditReplayCurrentHashes: uniqueStrings([...strings(source.semanticEditReplayCurrentHashes), ...strings(index.semanticEditReplayCurrentHashes), ...strings(summary.replayCurrentHashes), ...strings(summary.semanticEditReplayCurrentHashes), ...replays.map((replay) => replay.currentHash)]),
+    semanticEditReplayOutputHashes: uniqueStrings([...strings(source.semanticEditReplayOutputHashes), ...strings(index.semanticEditReplayOutputHashes), ...strings(summary.replayOutputHashes), ...strings(summary.semanticEditReplayOutputHashes), ...replays.map((replay) => replay.outputHash)]),
+    semanticEditKeys: uniqueStrings([...strings(source.semanticEditKeys), ...strings(index.semanticEditKeys), ...strings(summary.semanticEditKeys), ...operations.map((operation) => operation.semanticKey), ...edits.map((edit) => edit.semanticKey), ...replayEdits.map((edit) => edit.semanticKey)]),
+    semanticIdentityHashes: uniqueStrings([...strings(source.semanticIdentityHashes), ...strings(index.semanticIdentityHashes), ...strings(summary.semanticIdentityHashes), ...operations.map((operation) => operation.semanticIdentityHash), ...edits.map((edit) => edit.semanticIdentityHash), ...replayEdits.map((edit) => edit.semanticIdentityHash)]),
+    sourceIdentityHashes: uniqueStrings([...strings(source.sourceIdentityHashes), ...strings(index.sourceIdentityHashes), ...strings(summary.sourceIdentityHashes), ...operations.map((operation) => operation.sourceIdentityHash), ...edits.map((edit) => edit.sourceIdentityHash), ...replayEdits.map((edit) => edit.sourceIdentityHash)]),
+    operationContentHashes: uniqueStrings([...strings(source.operationContentHashes), ...strings(index.operationContentHashes), ...strings(summary.operationContentHashes), ...operations.map((operation) => operation.operationContentHash), ...edits.map((edit) => edit.operationContentHash), ...replayEdits.map((edit) => edit.operationContentHash)]),
+    editContentHashes: uniqueStrings([...strings(source.editContentHashes), ...strings(index.editContentHashes), ...strings(summary.editContentHashes), ...edits.map((edit) => edit.editContentHash), ...replayEdits.map((edit) => edit.editContentHash)]),
+    anchorKeys: uniqueStrings([...strings(source.anchorKeys), ...strings(index.anchorKeys), ...strings(summary.anchorKeys), ...operations.map((operation) => operation.anchor?.key), ...edits.map((edit) => edit.anchorKey), ...replayEdits.map((edit) => edit.anchorKey)]),
+    conflictKeys: uniqueStrings([...strings(source.conflictKeys), ...strings(index.conflictKeys), ...strings(summary.conflictKeys), ...operations.map((operation) => operation.anchor?.conflictKey), ...edits.map((edit) => edit.conflictKey), ...replayEdits.map((edit) => edit.conflictKey)]),
+    projectedSourcePaths: uniqueStrings([...strings(source.projectedSourcePaths), ...strings(index.projectedSourcePaths), ...strings(summary.projectedSourcePaths), ...projections.map((projection) => projection.sourcePath), ...edits.flatMap((edit) => [edit.sourcePath, edit.targetSourcePath]), ...replays.map((replay) => replay.sourcePath), ...replayEdits.map((edit) => edit.sourcePath)])
   };
 }
 
@@ -36,9 +36,15 @@ export function semanticEditSummary(index) {
     replayIds: index.semanticEditReplayIds,
     replayStatuses: index.semanticEditReplayStatuses,
     replayActions: index.semanticEditReplayActions,
+    replayCurrentHashes: index.semanticEditReplayCurrentHashes,
+    replayOutputHashes: index.semanticEditReplayOutputHashes,
     semanticEditKeys: index.semanticEditKeys,
+    semanticIdentityHashes: index.semanticIdentityHashes,
+    sourceIdentityHashes: index.sourceIdentityHashes,
     operationContentHashes: index.operationContentHashes,
     editContentHashes: index.editContentHashes,
+    anchorKeys: index.anchorKeys,
+    conflictKeys: index.conflictKeys,
     projectedSourcePaths: index.projectedSourcePaths,
     replayEditCount: index.semanticEditReplayEditCount
   });

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

@@ -7,13 +7,16 @@ export function semanticEditInsertionAnchor(region, context) {
     .filter((symbol) => hasSymbol(context.baseSymbols, symbol));
   const before = nearestBefore(workers, workerSymbol);
   const after = nearestAfter(workers, workerSymbol);
-  const anchor = before
-    ? insertionFromSymbol('after', before, context, 'nearest-previous-base-symbol')
-    : after
-      ? insertionFromSymbol('before', after, context, 'nearest-next-base-symbol')
-      : fallbackInsertion(region, context, 'no-neighbor-base-symbol');
+  const anchorCandidates = [
+    before ? insertionFromSymbol('after', before, context, 'nearest-previous-base-symbol') : undefined,
+    after ? insertionFromSymbol('before', after, context, 'nearest-next-base-symbol') : undefined
+  ].filter(Boolean);
+  const anchor = anchorCandidates.find((candidate) => candidate.headSpan)
+    ?? anchorCandidates[0]
+    ?? fallbackInsertion(region, context, 'no-neighbor-base-symbol');
   return compactRecord({
     ...anchor,
+    anchorCandidates,
     insertedSymbolId: workerSymbol.id,
     insertedSymbolName: workerSymbol.name,
     insertedSymbolKind: workerSymbol.kind,

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

@@ -0,0 +1,167 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import { uniqueStrings } from '../../native-import-utils.js';
+
+export function replayEditDiagnostics(edit, status, range, reasonCodes, sourceText) {
+  if (status === 'applied' || status === 'already-applied') return [];
+  return reasonCodes.map((code) => replayDiagnostic(code, {
+    scope: 'edit',
+    status,
+    operationId: edit.operationId,
+    sourcePath: edit.targetSourcePath ?? edit.sourcePath,
+    symbolName: edit.targetSymbolName ?? edit.symbolName,
+    symbolKind: edit.targetSymbolKind ?? edit.symbolKind,
+    editKind: edit.editKind,
+    start: range?.start,
+    end: range?.end,
+    expectedHash: replayDiagnosticExpectedHash(code, edit),
+    actualHash: replayDiagnosticActualHash(range, sourceText),
+    replacementHash: edit.replacementTextHash ?? edit.replacementSpanTextHash
+  }));
+}
+
+export function replayEditsWithOverlapDiagnostics(edits) {
+  const overlapDiagnostics = new Map();
+  const ordered = edits
+    .filter((edit) => edit.status === 'applied' && hasNumericReplayRange(edit))
+    .sort((left, right) => left.start - right.start || left.end - right.end || (left.editOrder ?? 0) - (right.editOrder ?? 0));
+  for (let leftIndex = 0; leftIndex < ordered.length; leftIndex += 1) {
+    for (let rightIndex = leftIndex + 1; rightIndex < ordered.length; rightIndex += 1) {
+      const left = ordered[leftIndex];
+      const right = ordered[rightIndex];
+      if (!rangesOverlap(left, right)) continue;
+      const operationIds = [left.operationId, right.operationId].filter(Boolean);
+      const fallbackId = `${left.editOrder ?? leftIndex}:${right.editOrder ?? rightIndex}`;
+      const code = `replay-edit-overlap:${operationIds.join(':') || fallbackId}`;
+      appendOverlapDiagnostic(overlapDiagnostics, left, code, operationIds);
+      appendOverlapDiagnostic(overlapDiagnostics, right, code, operationIds);
+    }
+  }
+  if (!overlapDiagnostics.size) return edits;
+  return edits.map((edit) => {
+    const diagnostics = overlapDiagnostics.get(edit);
+    if (!diagnostics) return edit;
+    return diagnostics.reduce((record, diagnostic) => appendReplayEditDiagnostic(record, diagnostic), edit);
+  });
+}
+
+export function replayDiagnostics(input) {
+  return uniqueDiagnostics([
+    ...reasonList(input.reasonCodes).map((code) => replayDiagnostic(code, {
+      scope: 'replay',
+      status: input.status,
+      sourcePath: input.sourcePath,
+      expectedHash: code === 'current-source-hash-mismatch' ? input.expectedCurrentHash : undefined,
+      actualHash: code === 'current-source-hash-mismatch' ? input.currentHash : undefined
+    })),
+    ...input.edits.flatMap((edit) => edit.diagnostics ?? [])
+  ]);
+}
+
+function appendOverlapDiagnostic(overlapDiagnostics, edit, code, operationIds) {
+  const diagnostics = overlapDiagnostics.get(edit) ?? [];
+  diagnostics.push(replayDiagnostic(code, {
+    scope: 'edit',
+    status: 'conflict',
+    operationId: edit.operationId,
+    sourcePath: edit.sourcePath,
+    symbolName: edit.symbolName,
+    symbolKind: edit.symbolKind,
+    editKind: edit.editKind,
+    start: edit.start,
+    end: edit.end,
+    overlapOperationIds: operationIds
+  }));
+  overlapDiagnostics.set(edit, diagnostics);
+}
+
+function appendReplayEditDiagnostic(edit, diagnostic) {
+  return compactRecord({
+    ...edit,
+    status: edit.status === 'applied' ? 'conflict' : edit.status,
+    reasonCodes: reasonList([...(edit.reasonCodes ?? []), diagnostic.code]),
+    diagnostics: uniqueDiagnostics([...(edit.diagnostics ?? []), diagnostic])
+  });
+}
+
+function replayDiagnostic(code, context) {
+  const category = replayDiagnosticCategory(code, context.status);
+  return compactRecord({
+    code,
+    category,
+    severity: replayDiagnosticSeverity(code, category, context.status),
+    scope: context.scope,
+    status: context.status,
+    operationId: context.operationId,
+    sourcePath: context.sourcePath,
+    symbolName: context.symbolName,
+    symbolKind: context.symbolKind,
+    editKind: context.editKind,
+    start: context.start,
+    end: context.end,
+    expectedHash: context.expectedHash,
+    actualHash: context.actualHash,
+    replacementHash: context.replacementHash,
+    overlapOperationIds: context.overlapOperationIds
+  });
+}
+
+function replayDiagnosticCategory(code, status) {
+  if (code.includes('overlap')) return 'overlap';
+  if (code.startsWith('missing-current-source') || code.startsWith('missing-head-source') || code.startsWith('missing-worker-source')) return 'missing-source';
+  if (code === 'current-symbol-anchor-missing' || code.includes('anchor-missing') || code.includes('anchor-unusable')) return 'stale-anchor';
+  if (code.includes('content-mismatch') || code.includes('hash-mismatch') || code.includes('span-not-resolvable') || code.startsWith('projection-not-') || code === 'missing-replacement-text') return 'projection-mismatch';
+  if (code.includes('reanchored')) return 'reanchored';
+  if (code.includes('matches-')) return 'matched-source';
+  if (status === 'stale') return 'stale-anchor';
+  if (status === 'conflict' || status === 'blocked') return 'projection-mismatch';
+  return 'replay';
+}
+
+function replayDiagnosticSeverity(code, category, status) {
+  if (code === 'current-source-hash-mismatch' && (status === 'accepted-clean' || status === 'already-applied')) return 'warning';
+  if (category === 'matched-source' || category === 'reanchored' || status === 'applied' || status === 'already-applied') return 'info';
+  if (category === 'overlap' || category === 'missing-source' || category === 'stale-anchor' || category === 'projection-mismatch') return 'error';
+  return status === 'accepted-clean' ? 'info' : 'warning';
+}
+
+function replayDiagnosticExpectedHash(code, edit) {
+  if (code.includes('matches-replacement')) return edit.replacementTextHash ?? edit.replacementSpanTextHash;
+  if (code.includes('content-mismatch') || code.includes('matches-deleted')) return edit.deletedTextHash ?? edit.anchorDeletedTextHash;
+  return undefined;
+}
+
+function replayDiagnosticActualHash(range, sourceText) {
+  if (!range || typeof sourceText !== 'string') return undefined;
+  return hashSemanticValue(sourceText.slice(range.start, range.end));
+}
+
+function uniqueDiagnostics(diagnostics) {
+  const seen = new Set();
+  const result = [];
+  for (const diagnostic of diagnostics.filter(Boolean)) {
+    const key = [
+      diagnostic.scope,
+      diagnostic.operationId,
+      diagnostic.status,
+      diagnostic.code,
+      diagnostic.start,
+      diagnostic.end,
+      (diagnostic.overlapOperationIds ?? []).join('|')
+    ].join(':');
+    if (seen.has(key)) continue;
+    seen.add(key);
+    result.push(diagnostic);
+  }
+  return result;
+}
+
+function rangesOverlap(left, right) {
+  return Boolean(left && right && left.start < right.end && right.start < left.end);
+}
+
+function hasNumericReplayRange(edit) {
+  return typeof edit.start === 'number' && typeof edit.end === 'number';
+}
+
+function reasonList(values) { return uniqueStrings((values ?? []).filter(Boolean)); }
+function compactRecord(value) { return Object.fromEntries(Object.entries(value ?? {}).filter(([, entry]) => entry !== undefined && (!Array.isArray(entry) || entry.length > 0))); }