@shapeshift-labs/frontier-lang-compiler 0.2.100 → 0.2.102

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

@@ -0,0 +1,74 @@
+const readinessScore = Object.freeze({ ready: 100, 'ready-with-losses': 75, 'needs-review': 45, blocked: 0 });
+
+export function targetProjectionCoverageSignals(input) {
+  const entries = targetProjectionEntries(input.projectResult, input.imports);
+  const matrices = projectionMatrices(input.projectResult, input.imports);
+  for (const matrix of matrices) {
+    for (const language of matrix?.languages ?? []) entries.push(...(language?.targets ?? []));
+  }
+  const sourceMapSummary = input.contract?.sourceMaps ?? {};
+  const summary = matrices.reduce((current, matrix) => {
+    current.exactSourceProjection += matrix?.summary?.exactSourceProjection ?? 0;
+    current.targetAdapterProjection += matrix?.summary?.targetAdapterProjection ?? 0;
+    current.missingAdapters += matrix?.summary?.missingAdapters ?? 0;
+    current.unsupportedTargetFeatures += matrix?.summary?.unsupportedTargetFeatures ?? 0;
+    return current;
+  }, { exactSourceProjection: 0, targetAdapterProjection: 0, missingAdapters: 0, unsupportedTargetFeatures: 0 });
+  const targetEntries = entries.length;
+  const supportedTargets = entries.filter((entry) => entry?.supported === true).length;
+  const adapterProjectionTargets = entries.filter((entry) =>
+    entry?.lossClass === 'targetAdapterProjection' || entry?.lossClass === 'exactSourceProjection' || entry?.adapter || entry?.adapterKind === 'targetProjection'
+  ).length + summary.targetAdapterProjection + summary.exactSourceProjection;
+  const readinessValues = entries.map((entry) => readinessScore[entry?.readiness] ?? 45);
+  const readinessAverage = readinessValues.length ? readinessValues.reduce((sum, value) => sum + value, 0) / readinessValues.length : 0;
+  return {
+    targetEntries,
+    supportedTargets,
+    adapterProjectionTargets,
+    exactSourceProjection: Math.max(summary.exactSourceProjection, input.sourcePreservation.exactSourceAvailable ?? 0),
+    targetAdapterProjection: summary.targetAdapterProjection,
+    missingAdapters: summary.missingAdapters + entries.filter((entry) => entry?.lossClass === 'missingAdapter' || entry?.supported === false).length,
+    unsupportedTargetFeatures: summary.unsupportedTargetFeatures + entries.filter((entry) => entry?.lossClass === 'unsupportedTargetFeatures').length,
+    readinessScore: roundScore(readinessAverage),
+    sourceMapMappings: sourceMapSummary.mappingCount ?? 0,
+    generatedRangeMappings: sourceMapSummary.generatedRangeMappings ?? 0,
+    targetPaths: sourceMapSummary.targetPaths?.length ?? 0,
+    adapterGeneratedRanges: input.contract?.adapterCoverage?.generatedRanges ?? 0
+  };
+}
+
+function targetProjectionEntries(projectResult, imports) {
+  return [
+    projectResult?.targetCoverage,
+    projectResult?.metadata?.targetCoverage,
+    projectResult?.metadata?.targetProjectionCoverage,
+    ...(projectResult?.targetCoverages ?? []),
+    ...(projectResult?.metadata?.targetCoverages ?? []),
+    ...(imports ?? []).flatMap((imported) => [
+      imported?.targetCoverage,
+      imported?.metadata?.targetCoverage,
+      imported?.metadata?.targetProjectionCoverage,
+      ...(imported?.targetCoverages ?? []),
+      ...(imported?.metadata?.targetCoverages ?? [])
+    ])
+  ].flatMap((entry) => Array.isArray(entry) ? entry : [entry]).filter((entry) => entry && typeof entry === 'object' && (entry.target || entry.lossClass || entry.supported !== undefined));
+}
+
+function projectionMatrices(projectResult, imports) {
+  return [
+    projectResult?.projectionMatrix,
+    projectResult?.metadata?.projectionMatrix,
+    ...(projectResult?.projectionMatrices ?? []),
+    ...(projectResult?.metadata?.projectionMatrices ?? []),
+    ...(imports ?? []).flatMap((imported) => [
+      imported?.projectionMatrix,
+      imported?.metadata?.projectionMatrix,
+      ...(imported?.projectionMatrices ?? []),
+      ...(imported?.metadata?.projectionMatrices ?? [])
+    ])
+  ].filter((matrix) => matrix?.kind === 'frontier.lang.projectionTargetLossMatrix' || Array.isArray(matrix?.languages));
+}
+
+function roundScore(value) {
+  return Math.round((Number.isFinite(value) ? value : 0) * 100) / 100;
+}

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

@@ -1,5 +1,8 @@
 import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
-import { idFragment, uniqueStrings } from '../../native-import-utils.js';
+import { idFragment, normalizeNativeLanguageId, uniqueStrings } from '../../native-import-utils.js';
+import { createSemanticImportSidecar } from './createSemanticImportSidecar.js';
+import { mapDiffSymbols } from './mapDiffSymbols.js';
+import { normalizeNativeDiffImport } from './normalizeNativeDiffImport.js';
 import { semanticEditIdentityFields } from './semanticEditIdentityRecords.js';
 import {
   insertionOffset,
@@ -10,7 +13,6 @@ import {
   spanOffsets
 } from './semanticEditSourceRanges.js';
 import { applySourceEdits, dedupeSourceEdits, validateSourceEdits } from './semanticSourceEditDedupe.js';
-
 export function projectSemanticEditScriptToSource(input = {}) {
   const script = input.script;
   const workerSourceText = input.workerSourceText;
@@ -19,6 +21,15 @@ export function projectSemanticEditScriptToSource(input = {}) {
   if (!script) throw new Error('projectSemanticEditScriptToSource requires a script');
   if (typeof workerSourceText !== 'string') reasonCodes.push('missing-worker-source-text');
   if (typeof headSourceText !== 'string') reasonCodes.push('missing-head-source-text');
+  const language = normalizeNativeLanguageId(script.language);
+  const headSymbols = typeof headSourceText === 'string' && isJavaScriptLike(language)
+    ? sourceSymbolIndex({
+      sourceText: headSourceText,
+      sourcePath: input.headSourcePath ?? script.sourcePath,
+      language,
+      parser: input.parser
+    })
+    : [];
   const edits = [];
   const coveredOperationIds = [];
   const projectionCoveredOperationIds = projectionCoveredContainerOperationIds(script.operations ?? [], workerSourceText);
@@ -27,7 +38,10 @@ export function projectSemanticEditScriptToSource(input = {}) {
       coveredOperationIds.push(operation.id);
       continue;
     }
-    const edit = sourceEditForOperation(operation, workerSourceText, headSourceText, index, input.headSourcePath);
+    const edit = sourceEditForOperation(operation, workerSourceText, headSourceText, index, {
+      headSourcePath: input.headSourcePath,
+      headSymbols
+    });
     if (edit.ok) edits.push(edit.value);
     else reasonCodes.push(...edit.reasonCodes);
   }
@@ -67,20 +81,20 @@ export function projectSemanticEditScriptToSource(input = {}) {
       appliedEditCount: deduped.edits.filter((edit) => !edit.alreadyApplied).length,
       alreadyAppliedEditCount: deduped.edits.filter((edit) => edit.alreadyApplied).length,
       dedupedEditCount: deduped.skippedOperationIds.length,
+      anchorMode: headSymbols.length ? 'javascript-like-symbols' : 'offsets',
       ...input.metadata
     })
   };
   return { ...core, hash: hashSemanticValue(core) };
 }
-
-function sourceEditForOperation(operation, workerSourceText, headSourceText, order, headSourcePath) {
-  const identity = projectionIdentity(operation, headSourcePath);
+function sourceEditForOperation(operation, workerSourceText, headSourceText, order, context) {
+  const identity = projectionIdentity(operation, context.headSourcePath);
   if (operation.status === 'already-applied') {
     return { ok: true, value: { ...identity, operationId: operation.id, order, start: 0, end: 0, replacement: '', current: '', alreadyApplied: true } };
   }
   if (operation.status !== 'portable') return { ok: false, reasonCodes: [`operation-not-portable:${operation.id}`] };
   if (operation.changeKind === 'added' || String(operation.kind ?? '').startsWith('add')) {
-    return insertionEditForOperation(operation, identity, workerSourceText, headSourceText, order);
+    return insertionEditForOperation(operation, identity, workerSourceText, headSourceText, order, context);
   }
   if (operation.changeKind === 'removed' || String(operation.kind ?? '').startsWith('remove')) {
     return removalEditForOperation(operation, identity, headSourceText, order);
@@ -131,7 +145,6 @@ function sourceEditForOperation(operation, workerSourceText, headSourceText, ord
     }
   };
 }
-
 function removalEditForOperation(operation, identity, headSourceText, order) {
   const headOffsets = spanOffsets(headSourceText, operation.spans?.head ?? operation.spans?.base ?? operation.anchor?.sourceSpan);
   const reasons = [];
@@ -158,12 +171,11 @@ function removalEditForOperation(operation, identity, headSourceText, order) {
     }
   };
 }
-
-function insertionEditForOperation(operation, identity, workerSourceText, headSourceText, order) {
+function insertionEditForOperation(operation, identity, workerSourceText, headSourceText, order, context) {
   const workerOffsets = spanOffsets(workerSourceText, operation.spans?.worker);
   const reasons = [];
   if (!workerOffsets) reasons.push(`worker-span-not-resolvable:${operation.id}`);
-  const insertion = insertionOffset(headSourceText, operation.insertion);
+  const insertion = insertionOffset(headSourceText, operation.insertion, { symbols: context.headSymbols });
   if (!insertion.ok) reasons.push(...insertion.reasonCodes.map((reason) => `${reason}:${operation.id}`));
   if (reasons.length) return { ok: false, reasonCodes: reasons };
   const spanText = workerSourceText.slice(workerOffsets.start, workerOffsets.end);
@@ -189,7 +201,6 @@ function insertionEditForOperation(operation, identity, workerSourceText, headSo
     }
   };
 }
-
 function projectionIdentity(operation, headSourcePath) {
   const identity = semanticEditIdentity(operation);
   const sourcePath = operation.reanchor?.toSourcePath ?? headSourcePath ?? operation.insertion?.sourcePath ?? identity.sourcePath;
@@ -201,7 +212,6 @@ function projectionIdentity(operation, headSourcePath) {
     : identity.targetSourcePath;
   return { ...identity, sourcePath, originalSourcePath, targetSourcePath };
 }
-
 function projectionEditRecord(edit) {
   const deletedTextHash = hashSemanticValue(edit.current);
   const replacementTextHash = hashSemanticValue(edit.replacement);
@@ -255,10 +265,25 @@ function projectionEditRecord(edit) {
     insertionAnchorKey: edit.insertion?.anchorKey,
     insertionAnchorSymbolName: edit.insertion?.anchorSymbolName,
     insertionAnchorSymbolKind: edit.insertion?.anchorSymbolKind,
+    insertionAnchorCandidates: edit.insertion?.anchorCandidates,
     replacementText: edit.replacement
   });
 }
 
+function sourceSymbolIndex(input) {
+  try {
+    const imported = normalizeNativeDiffImport({
+      language: input.language,
+      sourcePath: input.sourcePath,
+      sourceText: input.sourceText,
+      parser: input.parser
+    }, input, 'head');
+    return [...mapDiffSymbols(imported, createSemanticImportSidecar(imported)).values()];
+  } catch {
+    return [];
+  }
+}
+
 function semanticEditIdentity(operation) {
   const anchor = operation.anchor ?? {};
   return compactRecord({
@@ -288,6 +313,7 @@ function projectedSourcePath(script, edits) {
   return edits.map((edit) => edit.sourcePath).find(Boolean) ?? script.sourcePath;
 }
 
+function isJavaScriptLike(language) { return language === 'javascript' || language === 'typescript'; }
 function compactRecord(value) {
   return Object.fromEntries(Object.entries(value ?? {}).filter(([, entry]) => entry !== undefined && (!Array.isArray(entry) || entry.length > 0)));
 }

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

@@ -3,6 +3,7 @@ import { idFragment, normalizeNativeLanguageId, uniqueStrings } from '../../nati
 import { createSemanticImportSidecar } from './createSemanticImportSidecar.js';
 import { mapDiffSymbols } from './mapDiffSymbols.js';
 import { normalizeNativeDiffImport } from './normalizeNativeDiffImport.js';
+import { replayDiagnostics, replayEditDiagnostics, replayEditsWithOverlapDiagnostics } from './semanticEditReplayDiagnostics.js';
 import { afterLineOffset, bodyContentRange, spanOffsets } from './semanticEditSourceRanges.js';
 
 export function replaySemanticEditProjection(input = {}) {
@@ -17,11 +18,20 @@ export function replaySemanticEditProjection(input = {}) {
   const currentSymbols = currentSourceText && isJavaScriptLike(language)
     ? currentSymbolIndex({ currentSourceText, sourcePath, language, parser: input.parser })
     : [];
-  const edits = projection.status === 'projected' && typeof currentSourceText === 'string'
+  const replayedEdits = projection.status === 'projected' && typeof currentSourceText === 'string'
     ? (projection.edits ?? []).map((edit, index) => replayProjectionEdit(projectionEditWithOrder(edit, index), { currentSourceText, currentSymbols }))
     : [];
+  const edits = replayEditsWithOverlapDiagnostics(replayedEdits);
   const status = replayStatus(reasonCodes, edits, projection);
   const outputSourceText = replayOutputSource(status, currentSourceText, edits);
+  const diagnostics = replayDiagnostics({
+    status,
+    reasonCodes,
+    edits,
+    sourcePath,
+    currentHash,
+    expectedCurrentHash: input.currentSourceHash
+  });
   const core = {
     kind: 'frontier.lang.semanticEditReplay',
     version: 1,
@@ -38,6 +48,7 @@ export function replaySemanticEditProjection(input = {}) {
     edits,
     appliedOperations: edits.filter((edit) => edit.status === 'applied').map((edit) => edit.operationId).filter(Boolean),
     skippedOperations: edits.filter((edit) => edit.status !== 'applied').map((edit) => edit.operationId).filter(Boolean),
+    diagnostics,
     admission: replayAdmission(status, reasonCodes, edits),
     outputSourceText,
     summary: replaySummary(edits, reasonCodes),
@@ -52,8 +63,8 @@ export function replaySemanticEditProjection(input = {}) {
 }
 
 function replayProjectionEdit(edit, context) {
-  if (edit.status === 'already-applied') return replayEditRecord(edit, 'already-applied', undefined, ['projection-edit-already-applied']);
-  if (typeof edit.replacementText !== 'string') return replayEditRecord(edit, 'blocked', undefined, ['missing-replacement-text']);
+  if (edit.status === 'already-applied') return replayEditRecord(edit, 'already-applied', undefined, ['projection-edit-already-applied'], context.currentSourceText);
+  if (typeof edit.replacementText !== 'string') return replayEditRecord(edit, 'blocked', undefined, ['missing-replacement-text'], context.currentSourceText);
   if (edit.editKind === 'insert') return replayInsertionEdit(edit, context);
   const headRange = { start: edit.headStart, end: edit.headEnd };
   const offset = checkRange(edit, headRange, context.currentSourceText, 'head-offset');
@@ -61,34 +72,34 @@ function replayProjectionEdit(edit, context) {
   const spanRange = currentSymbolEditRange(edit, spanOffsets(context.currentSourceText, symbol?.sourceSpan), context.currentSourceText);
   if (symbol && spanRange && !sameRange(headRange, spanRange)) {
     const moved = checkRange(edit, spanRange, context.currentSourceText, currentSymbolRangeLabel(edit));
-    if (moved) return replayEditRecord(edit, moved.status, moved.range, [moved.reason, 'offset-reanchored-by-symbol']);
+    if (moved) return replayEditRecord(edit, moved.status, moved.range, [moved.reason, 'offset-reanchored-by-symbol'], context.currentSourceText);
     if (edit.editKind === 'delete' && offset && rangesOverlap(headRange, spanRange)) {
-      return replayEditRecord(edit, offset.status, offset.range, [offset.reason]);
+      return replayEditRecord(edit, offset.status, offset.range, [offset.reason], context.currentSourceText);
     }
-    return replayEditRecord(edit, 'conflict', spanRange, [`${currentSymbolRangeLabel(edit)}-content-mismatch`]);
+    return replayEditRecord(edit, 'conflict', spanRange, [`${currentSymbolRangeLabel(edit)}-content-mismatch`], context.currentSourceText);
   }
-  if (offset) return replayEditRecord(edit, offset.status, offset.range, [offset.reason]);
+  if (offset) return replayEditRecord(edit, offset.status, offset.range, [offset.reason], context.currentSourceText);
   const anchored = checkRange(edit, spanRange, context.currentSourceText, currentSymbolRangeLabel(edit));
-  if (anchored) return replayEditRecord(edit, anchored.status, anchored.range, [anchored.reason, 'offset-reanchored-by-symbol']);
+  if (anchored) return replayEditRecord(edit, anchored.status, anchored.range, [anchored.reason, 'offset-reanchored-by-symbol'], context.currentSourceText);
   return replayEditRecord(edit, symbol ? 'conflict' : 'stale', spanRange, [
     symbol ? `${currentSymbolRangeLabel(edit)}-content-mismatch` : 'current-symbol-anchor-missing'
-  ]);
+  ], context.currentSourceText);
 }
 
 function replayInsertionEdit(edit, context) {
   const inserted = findCurrentSymbol(edit, context.currentSymbols);
   const insertedRange = spanOffsets(context.currentSourceText, inserted?.sourceSpan);
   const already = checkRange(edit, insertedRange, context.currentSourceText, 'current-inserted-symbol');
-  if (already?.status === 'already-applied') return replayEditRecord(edit, 'already-applied', already.range, [already.reason]);
+  if (already?.status === 'already-applied') return replayEditRecord(edit, 'already-applied', already.range, [already.reason], context.currentSourceText);
   if (inserted && insertedRange) {
-    return replayEditRecord(edit, 'conflict', insertedRange, ['current-inserted-symbol-content-mismatch']);
+    return replayEditRecord(edit, 'conflict', insertedRange, ['current-inserted-symbol-content-mismatch'], context.currentSourceText);
   }
-  const anchor = findInsertionAnchorSymbol(edit, context.currentSymbols);
-  const range = insertionRange(edit, anchor, context.currentSourceText);
-  if (range) return replayEditRecord(edit, 'applied', range, [anchor ? 'current-insertion-anchor' : `current-${edit.insertionMode}`]);
+  const anchor = findInsertionAnchor(edit, context.currentSymbols);
+  const range = insertionRange(edit, anchor?.candidate, anchor?.symbol, context.currentSourceText);
+  if (range) return replayEditRecord(edit, 'applied', range, [anchor ? 'current-insertion-anchor' : `current-${edit.insertionMode}`], context.currentSourceText);
   return replayEditRecord(edit, anchor ? 'conflict' : 'stale', undefined, [
     anchor ? 'current-insertion-anchor-unusable' : 'current-insertion-anchor-missing'
-  ]);
+  ], context.currentSourceText);
 }
 
 function checkRange(edit, range, sourceText, label) {
@@ -102,7 +113,8 @@ function checkRange(edit, range, sourceText, label) {
   return undefined;
 }
 
-function replayEditRecord(edit, status, range, reasonCodes) {
+function replayEditRecord(edit, status, range, reasonCodes, sourceText) {
+  const normalizedReasonCodes = reasonList(reasonCodes);
   return compactRecord({
     operationId: edit.operationId,
     semanticKey: edit.semanticKey,
@@ -120,7 +132,8 @@ function replayEditRecord(edit, status, range, reasonCodes) {
     end: range?.end,
     replacementBytes: edit.replacementBytes,
     replacementText: edit.replacementText,
-    reasonCodes: reasonList(reasonCodes)
+    reasonCodes: normalizedReasonCodes,
+    diagnostics: replayEditDiagnostics(edit, status, range, normalizedReasonCodes, sourceText)
   });
 }
 
@@ -146,18 +159,47 @@ function findCurrentSymbol(edit, symbols) {
   return symbols.find((symbol) => symbol.name === name && (!kind || symbol.kind === kind));
 }
 
-function findInsertionAnchorSymbol(edit, symbols) {
-  return symbols.find((symbol) => [symbol.ownershipKey, symbol.key, symbol.id].some((key) => key && key === edit.insertionAnchorKey))
-    ?? symbols.find((symbol) => symbol.name === edit.insertionAnchorSymbolName && (!edit.insertionAnchorSymbolKind || symbol.kind === edit.insertionAnchorSymbolKind));
+function findInsertionAnchor(edit, symbols) {
+  for (const candidate of insertionAnchorCandidates(edit)) {
+    const symbol = findInsertionAnchorSymbol(candidate, symbols);
+    if (symbol) return { candidate, symbol };
+  }
+  return undefined;
+}
+
+function findInsertionAnchorSymbol(candidate, symbols) {
+  const keys = [candidate.anchorKey, candidate.anchorSymbolId].filter(Boolean);
+  return symbols.find((symbol) => [symbol.ownershipKey, symbol.key, symbol.id].some((key) => key && keys.includes(key)))
+    ?? symbols.find((symbol) => symbol.name === candidate.anchorSymbolName && (!candidate.anchorSymbolKind || symbol.kind === candidate.anchorSymbolKind));
+}
+
+function insertionAnchorCandidates(edit) {
+  const primary = {
+    mode: edit.insertionMode,
+    anchorKey: edit.insertionAnchorKey,
+    anchorSymbolName: edit.insertionAnchorSymbolName,
+    anchorSymbolKind: edit.insertionAnchorSymbolKind
+  };
+  const seen = new Set();
+  const result = [];
+  for (const candidate of [primary, ...(Array.isArray(edit.insertionAnchorCandidates) ? edit.insertionAnchorCandidates : [])]) {
+    if (!candidate || (candidate.mode !== 'before' && candidate.mode !== 'after')) continue;
+    const key = [candidate.mode, candidate.anchorKey, candidate.anchorSymbolId, candidate.anchorSymbolName, candidate.anchorSymbolKind].join('\0');
+    if (seen.has(key)) continue;
+    seen.add(key);
+    result.push(candidate);
+  }
+  return result;
 }
 
-function insertionRange(edit, anchor, sourceText) {
+function insertionRange(edit, candidate, anchor, sourceText) {
   if (edit.insertionMode === 'file-start') return { start: 0, end: 0 };
   if (edit.insertionMode === 'file-end') return { start: sourceText.length, end: sourceText.length };
+  const mode = candidate?.mode ?? edit.insertionMode;
   const anchorRange = spanOffsets(sourceText, anchor?.sourceSpan);
   if (!anchorRange) return undefined;
-  if (edit.insertionMode === 'before') return { start: anchorRange.start, end: anchorRange.start };
-  if (edit.insertionMode === 'after') {
+  if (mode === 'before') return { start: anchorRange.start, end: anchorRange.start };
+  if (mode === 'after') {
     return { start: afterLineOffset(sourceText, anchorRange.end), end: afterLineOffset(sourceText, anchorRange.end) };
   }
   return undefined;

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))); }