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

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

@@ -1,30 +1,55 @@
 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,
+  insertionReplacement,
+  projectionCoveredContainerOperationIds,
+  removalRange,
+  scopedBodyReplacement,
+  spanOffsets
+} from './semanticEditSourceRanges.js';
 import { applySourceEdits, dedupeSourceEdits, validateSourceEdits } from './semanticSourceEditDedupe.js';
-
 export function projectSemanticEditScriptToSource(input = {}) {
   const script = input.script;
   const workerSourceText = input.workerSourceText;
   const headSourceText = input.headSourceText;
   const reasonCodes = [];
   if (!script) throw new Error('projectSemanticEditScriptToSource requires a script');
-  if (script.admission?.status !== 'auto-merge-candidate') reasonCodes.push('script-not-auto-merge-candidate');
   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);
   for (const [index, operation] of (script.operations ?? []).entries()) {
-    if (operation.status === 'covered') {
+    if (operation.status === 'covered' || projectionCoveredOperationIds.has(operation.id)) {
       coveredOperationIds.push(operation.id);
       continue;
     }
-    const edit = sourceEditForOperation(operation, workerSourceText, headSourceText, index);
+    const edit = sourceEditForOperation(operation, workerSourceText, headSourceText, index, {
+      headSourcePath: input.headSourcePath,
+      headSymbols
+    });
     if (edit.ok) edits.push(edit.value);
     else reasonCodes.push(...edit.reasonCodes);
   }
   const deduped = dedupeSourceEdits(edits);
   reasonCodes.push(...validateSourceEdits(deduped.edits));
+  if (script.admission?.status !== 'auto-merge-candidate' && (reasonCodes.length > 0 || (!edits.length && !coveredOperationIds.length))) {
+    reasonCodes.push('script-not-auto-merge-candidate');
+  }
   const blocked = reasonCodes.length > 0;
   const sourceText = blocked ? undefined : applySourceEdits(headSourceText, deduped.edits);
   const core = {
@@ -56,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) {
-  const identity = projectionIdentity(operation);
+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);
@@ -80,16 +105,23 @@ function sourceEditForOperation(operation, workerSourceText, headSourceText, ord
   if (!workerOffsets) reasons.push(`worker-span-not-resolvable:${operation.id}`);
   if (!headOffsets) reasons.push(`head-span-not-resolvable:${operation.id}`);
   if (reasons.length) return { ok: false, reasonCodes: reasons };
-  const replacement = workerSourceText.slice(workerOffsets.start, workerOffsets.end);
-  const current = headSourceText.slice(headOffsets.start, headOffsets.end);
-  if (operation.hashes?.workerTextHash && hashSemanticValue(replacement) !== operation.hashes.workerTextHash) {
+  const anchorReplacement = workerSourceText.slice(workerOffsets.start, workerOffsets.end);
+  const anchorCurrent = headSourceText.slice(headOffsets.start, headOffsets.end);
+  if (operation.hashes?.workerTextHash && hashSemanticValue(anchorReplacement) !== operation.hashes.workerTextHash) {
     reasons.push(`worker-span-hash-mismatch:${operation.id}`);
   }
   const expectedHeadHash = operation.hashes?.headTextHash ?? operation.hashes?.baseTextHash;
-  if (expectedHeadHash && hashSemanticValue(current) !== expectedHeadHash) {
+  if (expectedHeadHash && hashSemanticValue(anchorCurrent) !== expectedHeadHash) {
     reasons.push(`head-span-hash-mismatch:${operation.id}`);
   }
   if (reasons.length) return { ok: false, reasonCodes: reasons };
+  const scoped = scopedBodyReplacement(operation, headSourceText, workerSourceText, headOffsets, workerOffsets);
+  const replacement = scoped
+    ? workerSourceText.slice(scoped.worker.start, scoped.worker.end)
+    : anchorReplacement;
+  const current = scoped
+    ? headSourceText.slice(scoped.head.start, scoped.head.end)
+    : anchorCurrent;
   return {
     ok: true,
     value: {
@@ -97,16 +129,22 @@ function sourceEditForOperation(operation, workerSourceText, headSourceText, ord
       order,
       ...identity,
       editKind: 'replace',
-      start: headOffsets.start,
-      end: headOffsets.end,
-      workerStart: workerOffsets.start,
-      workerEnd: workerOffsets.end,
+      sourceRangeKind: scoped?.sourceRangeKind,
+      start: scoped?.head.start ?? headOffsets.start,
+      end: scoped?.head.end ?? headOffsets.end,
+      workerStart: scoped?.worker.start ?? workerOffsets.start,
+      workerEnd: scoped?.worker.end ?? workerOffsets.end,
+      headAnchorStart: scoped ? headOffsets.start : undefined,
+      headAnchorEnd: scoped ? headOffsets.end : undefined,
+      workerAnchorStart: scoped ? workerOffsets.start : undefined,
+      workerAnchorEnd: scoped ? workerOffsets.end : undefined,
+      anchorDeletedTextHash: scoped ? hashSemanticValue(anchorCurrent) : undefined,
+      anchorReplacementTextHash: scoped ? hashSemanticValue(anchorReplacement) : undefined,
       replacement,
       current
     }
   };
 }
-
 function removalEditForOperation(operation, identity, headSourceText, order) {
   const headOffsets = spanOffsets(headSourceText, operation.spans?.head ?? operation.spans?.base ?? operation.anchor?.sourceSpan);
   const reasons = [];
@@ -133,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);
@@ -164,12 +201,17 @@ function insertionEditForOperation(operation, identity, workerSourceText, headSo
     }
   };
 }
-
-function projectionIdentity(operation) {
+function projectionIdentity(operation, headSourcePath) {
   const identity = semanticEditIdentity(operation);
-  return { ...identity, sourcePath: operation.reanchor?.toSourcePath ?? identity.sourcePath };
+  const sourcePath = operation.reanchor?.toSourcePath ?? headSourcePath ?? operation.insertion?.sourcePath ?? identity.sourcePath;
+  const originalSourcePath = sourcePath && identity.sourcePath && sourcePath !== identity.sourcePath
+    ? identity.sourcePath
+    : identity.originalSourcePath;
+  const targetSourcePath = sourcePath && sourcePath !== identity.sourcePath
+    ? sourcePath
+    : identity.targetSourcePath;
+  return { ...identity, sourcePath, originalSourcePath, targetSourcePath };
 }
-
 function projectionEditRecord(edit) {
   const deletedTextHash = hashSemanticValue(edit.current);
   const replacementTextHash = hashSemanticValue(edit.replacement);
@@ -197,27 +239,51 @@ function projectionEditRecord(edit) {
     operationContentHash: edit.operationContentHash,
     editContentHash: hashSemanticValue(compactRecord({
       semanticIdentityHash: identity.semanticIdentityHash,
+      sourceRangeKind: edit.sourceRangeKind,
       deletedTextHash,
       replacementTextHash,
       status: edit.alreadyApplied ? 'already-applied' : 'applied'
     })),
+    sourceRangeKind: edit.sourceRangeKind,
     headStart: edit.start,
     headEnd: edit.end,
     workerStart: edit.workerStart,
     workerEnd: edit.workerEnd,
+    editOrder: edit.order,
+    headAnchorStart: edit.headAnchorStart,
+    headAnchorEnd: edit.headAnchorEnd,
+    workerAnchorStart: edit.workerAnchorStart,
+    workerAnchorEnd: edit.workerAnchorEnd,
     deletedBytes: edit.current.length,
     replacementBytes: edit.replacement.length,
     deletedTextHash,
     replacementTextHash,
+    anchorDeletedTextHash: edit.anchorDeletedTextHash,
+    anchorReplacementTextHash: edit.anchorReplacementTextHash,
     replacementSpanTextHash: hashSemanticValue(edit.replacementSpanText ?? edit.replacement),
     insertionMode: edit.insertion?.mode,
     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({
@@ -247,55 +313,7 @@ function projectedSourcePath(script, edits) {
   return edits.map((edit) => edit.sourcePath).find(Boolean) ?? script.sourcePath;
 }
 
-function spanOffsets(sourceText, span) {
-  if (typeof sourceText !== 'string' || !span) return undefined;
-  if (typeof span.start === 'number' && typeof span.end === 'number' && span.end >= span.start) return { start: span.start, end: span.end };
-  if (typeof span.startLine !== 'number') return undefined;
-  const lineStarts = [0];
-  for (let index = 0; index < sourceText.length; index += 1) if (sourceText[index] === '\n') lineStarts.push(index + 1);
-  const startLine = Math.max(1, span.startLine);
-  const endLine = Math.max(startLine, typeof span.endLine === 'number' ? span.endLine : startLine);
-  const start = lineStarts[startLine - 1];
-  const endLineStart = lineStarts[endLine - 1];
-  if (start === undefined || endLineStart === undefined) return undefined;
-  const startColumn = Math.max(1, span.startColumn ?? 1) - 1;
-  const lineEnd = lineStarts[endLine] === undefined ? sourceText.length : lineStarts[endLine] - 1;
-  const endColumn = span.endColumn === undefined ? lineEnd - endLineStart : Math.max(1, span.endColumn) - 1;
-  return { start: start + startColumn, end: endLineStart + endColumn };
-}
-
-function insertionOffset(sourceText, insertion) {
-  if (typeof sourceText !== 'string') return { ok: false, reasonCodes: ['missing-head-source-text'] };
-  const mode = insertion?.mode;
-  if (mode === 'file-start') return { ok: true, offset: 0 };
-  if (mode === 'file-end') return { ok: true, offset: sourceText.length };
-  const range = spanOffsets(sourceText, insertion?.headSpan);
-  if (!range) return { ok: false, reasonCodes: ['insertion-anchor-not-resolvable'] };
-  if (mode === 'before') return { ok: true, offset: range.start };
-  if (mode === 'after') return { ok: true, offset: afterLineOffset(sourceText, range.end) };
-  return { ok: false, reasonCodes: ['insertion-mode-unsupported'] };
-}
-
-function removalRange(sourceText, span) {
-  const range = { ...span };
-  if (range.end < sourceText.length && sourceText[range.end] === '\n') range.end += 1;
-  else if (range.start > 0 && sourceText[range.start - 1] === '\n') range.start -= 1;
-  return range;
-}
-
-function insertionReplacement(text, sourceText, offset) {
-  let replacement = String(text ?? '');
-  if (offset > 0 && sourceText[offset - 1] !== '\n') replacement = `\n${replacement}`;
-  if (offset < sourceText.length && !replacement.endsWith('\n')) replacement += '\n';
-  if (offset === sourceText.length && sourceText && !sourceText.endsWith('\n')) replacement = `\n${replacement}`;
-  if (offset === sourceText.length && !replacement.endsWith('\n')) replacement += '\n';
-  return replacement;
-}
-
-function afterLineOffset(sourceText, offset) {
-  return sourceText[offset] === '\n' ? offset + 1 : offset;
-}
-
+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,8 @@ 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 = {}) {
   const projection = input.projection ?? input.semanticEditProjection;
@@ -16,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'
-    ? (projection.edits ?? []).map((edit) => replayProjectionEdit(edit, { currentSourceText, currentSymbols }))
+  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,
@@ -37,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),
@@ -51,31 +63,43 @@ 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 offset = checkRange(edit, { start: edit.headStart, end: edit.headEnd }, context.currentSourceText, 'head-offset');
-  if (offset) return replayEditRecord(edit, offset.status, offset.range, [offset.reason]);
+  const headRange = { start: edit.headStart, end: edit.headEnd };
+  const offset = checkRange(edit, headRange, context.currentSourceText, 'head-offset');
   const symbol = findCurrentSymbol(edit, context.currentSymbols);
-  const spanRange = spanOffsets(context.currentSourceText, symbol?.sourceSpan);
-  const anchored = checkRange(edit, spanRange, context.currentSourceText, 'current-symbol-anchor');
-  if (anchored) return replayEditRecord(edit, anchored.status, anchored.range, [anchored.reason, 'offset-reanchored-by-symbol']);
+  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'], context.currentSourceText);
+    if (edit.editKind === 'delete' && offset && rangesOverlap(headRange, spanRange)) {
+      return replayEditRecord(edit, offset.status, offset.range, [offset.reason], context.currentSourceText);
+    }
+    return replayEditRecord(edit, 'conflict', spanRange, [`${currentSymbolRangeLabel(edit)}-content-mismatch`], context.currentSourceText);
+  }
+  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'], context.currentSourceText);
   return replayEditRecord(edit, symbol ? 'conflict' : 'stale', spanRange, [
-    symbol ? 'current-symbol-anchor-content-mismatch' : 'current-symbol-anchor-missing'
-  ]);
+    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]);
-  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}`]);
+  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'], context.currentSourceText);
+  }
+  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) {
@@ -89,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,
@@ -97,6 +122,8 @@ function replayEditRecord(edit, status, range, reasonCodes) {
     sourceIdentityHash: edit.sourceIdentityHash,
     editContentHash: edit.editContentHash,
     editKind: edit.editKind,
+    editOrder: edit.editOrder,
+    sourceRangeKind: edit.sourceRangeKind,
     sourcePath: edit.targetSourcePath ?? edit.sourcePath,
     symbolName: edit.targetSymbolName ?? edit.symbolName,
     symbolKind: edit.targetSymbolKind ?? edit.symbolKind,
@@ -105,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)
   });
 }
 
@@ -131,24 +159,62 @@ 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 insertionRange(edit, anchor, sourceText) {
+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, 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') {
-    const offset = sourceText[anchorRange.end] === '\n' ? anchorRange.end + 1 : anchorRange.end;
-    return { start: offset, end: offset };
+  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;
 }
 
+function currentSymbolEditRange(edit, symbolRange, sourceText) {
+  if (!symbolRange) return undefined;
+  if (edit.sourceRangeKind === 'body-content') return bodyContentRange(sourceText, symbolRange);
+  return symbolRange;
+}
+
+function currentSymbolRangeLabel(edit) {
+  return edit.sourceRangeKind === 'body-content' ? 'current-symbol-body' : 'current-symbol-anchor';
+}
+
 function replayStatus(reasonCodes, edits, projection) {
   if (reasonCodes.some((reason) => reason !== 'current-source-hash-mismatch')) return 'blocked';
   if (!edits.length && !(projection.edits ?? []).length) return 'evidence-only';
@@ -189,10 +255,25 @@ function replayOutputSource(status, sourceText, edits) {
   if (status === 'already-applied') return sourceText;
   if (status !== 'accepted-clean') return undefined;
   return edits.filter((edit) => edit.status === 'applied')
-    .sort((left, right) => right.start - left.start)
+    .sort(replaySourceEditSort)
     .reduce((text, edit) => text.slice(0, edit.start) + editReplacement(edit, edits) + text.slice(edit.end), sourceText);
 }
 
+function replaySourceEditSort(left, right) {
+  return right.start - left.start || right.end - left.end || (right.editOrder ?? 0) - (left.editOrder ?? 0);
+}
+
+function projectionEditWithOrder(edit, index) {
+  return {
+    ...edit,
+    editOrder: typeof edit.editOrder === 'number'
+      ? edit.editOrder
+      : typeof edit.order === 'number'
+        ? edit.order
+        : index
+  };
+}
+
 function editReplacement(edit, edits) {
   return edits.find((candidate) => candidate.operationId === edit.operationId)?.replacementText ?? '';
 }
@@ -205,19 +286,12 @@ function baseReasonCodes(projection, currentSourceText) {
   ]);
 }
 
-function spanOffsets(sourceText, span) {
-  if (typeof sourceText !== 'string' || !span) return undefined;
-  if (typeof span.start === 'number' && typeof span.end === 'number' && span.end >= span.start) return { start: span.start, end: span.end };
-  if (typeof span.startLine !== 'number') return undefined;
-  const starts = [0];
-  for (let index = 0; index < sourceText.length; index += 1) if (sourceText[index] === '\n') starts.push(index + 1);
-  const startLine = Math.max(1, span.startLine);
-  const endLine = Math.max(startLine, typeof span.endLine === 'number' ? span.endLine : startLine);
-  const lineStart = starts[startLine - 1];
-  const endLineStart = starts[endLine - 1];
-  if (lineStart === undefined || endLineStart === undefined) return undefined;
-  const lineEnd = starts[endLine] === undefined ? sourceText.length : starts[endLine] - 1;
-  return { start: lineStart + Math.max(0, (span.startColumn ?? 1) - 1), end: endLineStart + (span.endColumn === undefined ? lineEnd - endLineStart : Math.max(0, span.endColumn - 1)) };
+function sameRange(left, right) {
+  return left?.start === right?.start && left?.end === right?.end;
+}
+
+function rangesOverlap(left, right) {
+  return Boolean(left && right && left.start < right.end && right.start < left.end);
 }
 
 function isJavaScriptLike(language) { return language === 'javascript' || language === 'typescript'; }