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

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

@@ -1,12 +1,12 @@
 import{countBy,maxSemanticMergeReadiness,uniqueRecordsById,uniqueStrings}from'../../native-import-utils.js';
 import{createSemanticMergeCandidateAdmissionRecord,querySemanticMergeCandidateAdmissionOverlaps,sortSemanticMergeCandidateAdmissionRecords}from'./semanticMergeCandidateRecords.js';
-import{compactAdmissionSource,importLosses,sourceLossClasses,summarizeImportPreservation,summarizeParserEvidence}from'./projectImportAdmissionImportEvidence.js';
+import{compactAdmissionSource,importLosses,sourceLossClasses,summarizeImportPreservation,summarizeParserEvidence,summarizeSemanticAdmissionWarnings}from'./projectImportAdmissionImportEvidence.js';
 import{sourceMissingEvidence,sourceMissingTasks,sourceSemanticMergeScore}from'./projectImportAdmissionTasks.js';
 import{candidateRisk,maxPreservationQuality,maxRisk,normalizeRisk}from'./projectImportAdmissionRanks.js';
 
 export{admissionLanguages}from'./projectImportAdmissionLanguageSummaries.js';
 
-export function projectAdmissionImports(imports,sourceRows,mergeCandidates){
+export function projectAdmissionImports(imports,sourceRows,mergeCandidates,projectResult){
   return imports.map((imported,index)=>{
     const source=sourceRows?.[index]??compactAdmissionSource(imported,index);
     const sourcePath=source.sourcePath??imported?.sourcePath;
@@ -22,6 +22,7 @@ export function projectAdmissionImports(imports,sourceRows,mergeCandidates){
     };
     const readiness=source.readiness??imported?.metadata?.semanticMergeReadiness??candidates[0]?.readiness??'ready';
     const emptySemanticEvidence=Object.values(semanticCounts).reduce((sum,value)=>sum+value,0)===0;
+    const semanticAdmission=summarizeSemanticAdmissionWarnings(imported,{source,sourcePath,candidates,projectResult});
     const sourcePreservation=summarizeImportPreservation(imported,source);
     const losses=importLosses(imported);
     const lossClasses=sourceLossClasses(imported,losses);
@@ -55,6 +56,7 @@ export function projectAdmissionImports(imports,sourceRows,mergeCandidates){
       readiness,
       semanticCounts,
       emptySemanticEvidence,
+      semanticAdmission,
       parserEvidence,
       lossClasses,
       missingEvidence,
@@ -90,6 +92,7 @@ export function admissionSemanticEvidence(projectResult,imports,importSummaries)
     .filter((entry)=>entry.emptySemanticEvidence)
     .map((entry)=>entry.sourcePath)
     .filter(Boolean));
+  const warnings=uniqueSemanticAdmissionWarnings(importSummaries.flatMap((entry)=>entry.semanticAdmission?.warnings??[]));
   return {
     empty:Object.values(totals).reduce((sum,value)=>sum+value,0)===0,
     emptySourceCount:importSummaries.filter((entry)=>entry.emptySemanticEvidence).length,
@@ -98,10 +101,26 @@ export function admissionSemanticEvidence(projectResult,imports,importSummaries)
     evidenceRecords:uniqueRecordsById([
       ...(projectResult?.evidence??[]),
       ...imports.flatMap((imported)=>imported?.evidence??[])
-    ]).length
+    ]).length,
+    warningCount:warnings.length,
+    warningReasonCodes:uniqueStrings(warnings.map((warning)=>warning.reasonCode??warning.code)),
+    warningSourcePaths:uniqueStrings(warnings.flatMap((warning)=>warning.sourcePaths??[warning.sourcePath]).filter(Boolean)),
+    warnings
   };
 }
 
+function uniqueSemanticAdmissionWarnings(warnings){
+  const seen=new Set();
+  const result=[];
+  for(const warning of warnings.filter(Boolean)){
+    const key=[warning.reasonCode??warning.code,(warning.sourcePaths??[warning.sourcePath]).join('|')].join('\u0000');
+    if(seen.has(key)) continue;
+    seen.add(key);
+    result.push(warning);
+  }
+  return result;
+}
+
 export function admissionSourcePreservation(importSummaries,contract){
   const qualities=importSummaries.map((entry)=>entry.sourcePreservation.quality);
   const quality=qualities.length?qualities.reduce(maxPreservationQuality,'exact'):'empty';

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

@@ -3,7 +3,8 @@ import { idFragment, normalizeNativeLanguageId, uniqueStrings } from '../../nati
 import { createSemanticImportSidecar } from './createSemanticImportSidecar.js';
 import { mapDiffSymbols } from './mapDiffSymbols.js';
 import { normalizeNativeDiffImport } from './normalizeNativeDiffImport.js';
-import { semanticEditIdentityFields } from './semanticEditIdentityRecords.js';
+import { alreadyAppliedImportEditForOperation } from './semanticEditImportProjection.js';
+import { projectionEditRecord } from './semanticEditProjectionRecord.js';
 import {
   insertionOffset,
   insertionReplacement,
@@ -40,7 +41,8 @@ export function projectSemanticEditScriptToSource(input = {}) {
     }
     const edit = sourceEditForOperation(operation, workerSourceText, headSourceText, index, {
       headSourcePath: input.headSourcePath,
-      headSymbols
+      headSymbols,
+      symbolIndexAvailable: isJavaScriptLike(language)
     });
     if (edit.ok) edits.push(edit.value);
     else reasonCodes.push(...edit.reasonCodes);
@@ -175,14 +177,20 @@ function insertionEditForOperation(operation, identity, workerSourceText, headSo
   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, { 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);
   if (operation.hashes?.workerTextHash && hashSemanticValue(spanText) !== operation.hashes.workerTextHash) {
     reasons.push(`worker-span-hash-mismatch:${operation.id}`);
   }
   if (reasons.length) return { ok: false, reasonCodes: reasons };
+  const alreadyAppliedImport = alreadyAppliedImportEditForOperation(operation, identity, spanText, headSourceText, workerOffsets, order, context);
+  if (alreadyAppliedImport) return { ok: true, value: alreadyAppliedImport };
+  const insertion = insertionOffset(headSourceText, operation.insertion, {
+    symbols: context.headSymbols,
+    symbolIndexAvailable: context.symbolIndexAvailable
+  });
+  if (!insertion.ok) reasons.push(...insertion.reasonCodes.map((reason) => `${reason}:${operation.id}`));
+  if (reasons.length) return { ok: false, reasonCodes: reasons };
   return {
     ok: true,
     value: {
@@ -212,64 +220,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);
-  const identity = semanticEditIdentityFields(edit);
-  return compactRecord({
-    operationId: edit.operationId,
-    status: edit.alreadyApplied ? 'already-applied' : 'applied',
-    kind: edit.kind,
-    editKind: edit.editKind,
-    changeKind: edit.changeKind,
-    anchorKey: edit.anchorKey,
-    conflictKey: edit.conflictKey,
-    regionId: edit.regionId,
-    regionKind: edit.regionKind,
-    sourcePath: edit.sourcePath,
-    originalSourcePath: edit.originalSourcePath,
-    targetAnchorKey: edit.targetAnchorKey,
-    targetSourcePath: edit.targetSourcePath,
-    targetSymbolName: edit.targetSymbolName,
-    targetSymbolKind: edit.targetSymbolKind,
-    symbolId: edit.symbolId,
-    symbolName: edit.symbolName,
-    symbolKind: edit.symbolKind,
-    ...identity,
-    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({

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

@@ -4,7 +4,14 @@ 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';
+import {
+  findCurrentSymbol,
+  findInsertionAnchor,
+  hasSymbolAnchorIdentity,
+  insertionAnchorCandidates,
+  insertionRange
+} from './semanticEditReplayAnchors.js';
+import { bodyContentRange, removalRange, spanOffsets } from './semanticEditSourceRanges.js';
 
 export function replaySemanticEditProjection(input = {}) {
   const projection = input.projection ?? input.semanticEditProjection;
@@ -19,7 +26,11 @@ export function replaySemanticEditProjection(input = {}) {
     ? currentSymbolIndex({ currentSourceText, sourcePath, language, parser: input.parser })
     : [];
   const replayedEdits = projection.status === 'projected' && typeof currentSourceText === 'string'
-    ? (projection.edits ?? []).map((edit, index) => replayProjectionEdit(projectionEditWithOrder(edit, index), { currentSourceText, currentSymbols }))
+    ? (projection.edits ?? []).map((edit, index) => replayProjectionEdit(projectionEditWithOrder(edit, index), {
+      currentSourceText,
+      currentSymbols,
+      symbolIndexAvailable: isJavaScriptLike(language)
+    }))
     : [];
   const edits = replayEditsWithOverlapDiagnostics(replayedEdits);
   const status = replayStatus(reasonCodes, edits, projection);
@@ -72,7 +83,7 @@ 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'], context.currentSourceText);
+    if (moved) return replayEditRecord(edit, moved.status, replayAppliedRange(edit, moved.range, context.currentSourceText), [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);
     }
@@ -80,12 +91,17 @@ function replayProjectionEdit(edit, context) {
   }
   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);
+  if (anchored) return replayEditRecord(edit, anchored.status, replayAppliedRange(edit, anchored.range, context.currentSourceText), [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 replayAppliedRange(edit, range, sourceText) {
+  if (edit.editKind !== 'delete' || !range || typeof sourceText !== 'string') return range;
+  return removalRange(sourceText, range);
+}
+
 function replayInsertionEdit(edit, context) {
   const inserted = findCurrentSymbol(edit, context.currentSymbols);
   const insertedRange = spanOffsets(context.currentSourceText, inserted?.sourceSpan);
@@ -97,7 +113,8 @@ function replayInsertionEdit(edit, context) {
   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, [
+  const missingStableAnchor = context.symbolIndexAvailable && insertionAnchorCandidates(edit).some(hasSymbolAnchorIdentity);
+  return replayEditRecord(edit, anchor || missingStableAnchor ? 'conflict' : 'stale', undefined, [
     anchor ? 'current-insertion-anchor-unusable' : 'current-insertion-anchor-missing'
   ], context.currentSourceText);
 }
@@ -106,10 +123,26 @@ function checkRange(edit, range, sourceText, label) {
   if (!range || range.end < range.start) return undefined;
   const current = sourceText.slice(range.start, range.end);
   const currentHash = hashSemanticValue(current);
+  const currentLineEndingStableText = lineEndingStableText(current);
+  const currentLineEndingStableHash = currentLineEndingStableText === undefined
+    ? undefined
+    : hashSemanticValue(currentLineEndingStableText);
   if (edit.replacementSpanTextHash && currentHash === edit.replacementSpanTextHash) return { status: 'already-applied', range, reason: `${label}-matches-replacement-span` };
   if (edit.replacementTextHash && currentHash === edit.replacementTextHash) return { status: 'already-applied', range, reason: `${label}-matches-replacement` };
   if (current === edit.replacementText) return { status: 'already-applied', range, reason: `${label}-matches-replacement-text` };
+  if (edit.replacementSpanTextLineEndingStableHash && currentLineEndingStableHash === edit.replacementSpanTextLineEndingStableHash) {
+    return { status: 'already-applied', range, reason: `${label}-matches-replacement-span-line-ending-stable` };
+  }
+  if (edit.replacementTextLineEndingStableHash && currentLineEndingStableHash === edit.replacementTextLineEndingStableHash) {
+    return { status: 'already-applied', range, reason: `${label}-matches-replacement-line-ending-stable` };
+  }
+  if (typeof edit.replacementText === 'string' && currentLineEndingStableText === lineEndingStableText(edit.replacementText)) {
+    return { status: 'already-applied', range, reason: `${label}-matches-replacement-text-line-ending-stable` };
+  }
   if (edit.deletedTextHash && currentHash === edit.deletedTextHash) return { status: 'applied', range, reason: `${label}-matches-deleted` };
+  if (edit.deletedTextLineEndingStableHash && currentLineEndingStableHash === edit.deletedTextLineEndingStableHash) {
+    return { status: 'applied', range, reason: `${label}-matches-deleted-line-ending-stable` };
+  }
   return undefined;
 }
 
@@ -147,64 +180,6 @@ function currentSymbolIndex(input) {
   return [...mapDiffSymbols(imported, createSemanticImportSidecar(imported)).values()];
 }
 
-function findCurrentSymbol(edit, symbols) {
-  const exact = symbols.find((symbol) => [symbol.ownershipKey, symbol.key, symbol.id].some((key) => key && [
-    edit.anchorKey,
-    edit.targetAnchorKey,
-    edit.symbolId
-  ].includes(key)));
-  if (exact) return exact;
-  const name = edit.targetSymbolName ?? edit.symbolName;
-  const kind = edit.targetSymbolKind ?? edit.symbolKind;
-  return symbols.find((symbol) => symbol.name === name && (!kind || symbol.kind === kind));
-}
-
-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, 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 (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);
@@ -296,4 +271,9 @@ function rangesOverlap(left, right) {
 
 function isJavaScriptLike(language) { return language === 'javascript' || language === 'typescript'; }
 function reasonList(values) { return uniqueStrings((values ?? []).filter(Boolean)); }
+function lineEndingStableText(value) {
+  if (typeof value !== 'string') return undefined;
+  const normalized = value.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+  return normalized.length > 1 && normalized.endsWith('\n') ? normalized.slice(0, -1) : normalized;
+}
 function compactRecord(value) { return Object.fromEntries(Object.entries(value ?? {}).filter(([, entry]) => entry !== undefined && (!Array.isArray(entry) || entry.length > 0))); }

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

@@ -0,0 +1,53 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import { spanOffsets } from './semanticEditSourceRanges.js';
+
+export function alreadyAppliedImportEditForOperation(operation, identity, spanText, headSourceText, workerOffsets, order, context) {
+  if (!isAddImportOperation(operation) || typeof headSourceText !== 'string') return undefined;
+  const match = findHeadImportSymbol(operation, context.headSymbols);
+  const range = spanOffsets(headSourceText, match?.symbol?.sourceSpan);
+  if (!range) return undefined;
+  const current = headSourceText.slice(range.start, range.end);
+  if (!headImportMatchesOperation(operation, spanText, current, match.symbol)) return undefined;
+  return {
+    operationId: operation.id,
+    order,
+    ...identity,
+    start: range.start,
+    end: range.end,
+    workerStart: workerOffsets.start,
+    workerEnd: workerOffsets.end,
+    replacement: current,
+    replacementSpanText: spanText,
+    current,
+    alreadyApplied: true
+  };
+}
+
+function findHeadImportSymbol(operation, symbols) {
+  const symbolList = Array.isArray(symbols) ? symbols : [];
+  const exactKeys = [
+    operation.anchor?.key,
+    operation.anchor?.symbolId,
+    operation.insertion?.insertedSymbolId
+  ].filter(Boolean);
+  const exact = symbolList.find((symbol) => [symbol.ownershipKey, symbol.key, symbol.id].some((key) => key && exactKeys.includes(key)));
+  if (exact) return { symbol: exact, exact: true };
+  const name = operation.insertion?.insertedSymbolName ?? operation.anchor?.symbolName;
+  const kind = operation.insertion?.insertedSymbolKind ?? operation.anchor?.symbolKind;
+  const semantic = symbolList.find((symbol) => symbol.name === name && (!kind || symbol.kind === kind));
+  return semantic ? { symbol: semantic, exact: false } : undefined;
+}
+
+function headImportMatchesOperation(operation, spanText, current, symbol) {
+  const workerTextHash = operation.hashes?.workerTextHash ?? hashSemanticValue(spanText);
+  const workerSpanHash = operation.hashes?.workerSpanHash ?? workerTextHash;
+  const currentHash = hashSemanticValue(current);
+  if ([workerTextHash, workerSpanHash].includes(currentHash)) return true;
+  if ([workerTextHash, workerSpanHash].includes(symbol?.spanHash)) return true;
+  const signatureHash = operation.hashes?.afterSignatureHash;
+  return Boolean(signatureHash && symbol?.signatureHash === signatureHash);
+}
+
+function isAddImportOperation(operation) {
+  return operation?.kind === 'addImport' || (operation?.changeKind === 'added' && operation?.anchor?.regionKind === 'import');
+}

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

@@ -0,0 +1,79 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import { semanticEditIdentityFields } from './semanticEditIdentityRecords.js';
+
+export function projectionEditRecord(edit) {
+  const deletedTextHash = hashSemanticValue(edit.current);
+  const replacementTextHash = hashSemanticValue(edit.replacement);
+  const replacementSpanText = edit.replacementSpanText ?? edit.replacement;
+  const identity = semanticEditIdentityFields(edit);
+  return compactRecord({
+    operationId: edit.operationId,
+    status: edit.alreadyApplied ? 'already-applied' : 'applied',
+    kind: edit.kind,
+    editKind: edit.editKind,
+    changeKind: edit.changeKind,
+    anchorKey: edit.anchorKey,
+    conflictKey: edit.conflictKey,
+    regionId: edit.regionId,
+    regionKind: edit.regionKind,
+    sourcePath: edit.sourcePath,
+    originalSourcePath: edit.originalSourcePath,
+    targetAnchorKey: edit.targetAnchorKey,
+    targetSourcePath: edit.targetSourcePath,
+    targetSymbolName: edit.targetSymbolName,
+    targetSymbolKind: edit.targetSymbolKind,
+    symbolId: edit.symbolId,
+    symbolName: edit.symbolName,
+    symbolKind: edit.symbolKind,
+    ...identity,
+    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,
+    deletedTextLineEndingStableHash: lineEndingStableTextHash(edit.current),
+    replacementTextLineEndingStableHash: lineEndingStableTextHash(edit.replacement),
+    anchorDeletedTextHash: edit.anchorDeletedTextHash,
+    anchorReplacementTextHash: edit.anchorReplacementTextHash,
+    replacementSpanTextHash: hashSemanticValue(replacementSpanText),
+    replacementSpanTextLineEndingStableHash: lineEndingStableTextHash(replacementSpanText),
+    insertionMode: edit.insertion?.mode,
+    insertionAnchorKey: edit.insertion?.anchorKey,
+    insertionAnchorSymbolName: edit.insertion?.anchorSymbolName,
+    insertionAnchorSymbolKind: edit.insertion?.anchorSymbolKind,
+    insertionAnchorCandidates: edit.insertion?.anchorCandidates,
+    replacementText: edit.replacement
+  });
+}
+
+function lineEndingStableTextHash(value) {
+  const normalized = lineEndingStableText(value);
+  return normalized === undefined ? undefined : hashSemanticValue(normalized);
+}
+
+function lineEndingStableText(value) {
+  if (typeof value !== 'string') return undefined;
+  const normalized = value.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+  return normalized.length > 1 && normalized.endsWith('\n') ? normalized.slice(0, -1) : normalized;
+}
+
+function compactRecord(value) {
+  return Object.fromEntries(Object.entries(value ?? {}).filter(([, entry]) => entry !== undefined && (!Array.isArray(entry) || entry.length > 0)));
+}

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

@@ -0,0 +1,63 @@
+import { afterLineOffset, spanOffsets } from './semanticEditSourceRanges.js';
+
+export function findCurrentSymbol(edit, symbols) {
+  const exact = symbols.find((symbol) => [symbol.ownershipKey, symbol.key, symbol.id].some((key) => key && [
+    edit.anchorKey,
+    edit.targetAnchorKey,
+    edit.symbolId
+  ].includes(key)));
+  if (exact) return exact;
+  const name = edit.targetSymbolName ?? edit.symbolName;
+  const kind = edit.targetSymbolKind ?? edit.symbolKind;
+  return symbols.find((symbol) => symbol.name === name && (!kind || symbol.kind === kind));
+}
+
+export function findInsertionAnchor(edit, symbols) {
+  for (const candidate of insertionAnchorCandidates(edit)) {
+    const symbol = findInsertionAnchorSymbol(candidate, symbols);
+    if (symbol) return { candidate, symbol };
+  }
+  return undefined;
+}
+
+export 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;
+}
+
+export function hasSymbolAnchorIdentity(candidate) {
+  return Boolean(candidate.anchorKey || candidate.anchorSymbolId || candidate.anchorSymbolName);
+}
+
+export 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 (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 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));
+}

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

@@ -168,6 +168,7 @@ function insertionAnchorResolution(sourceText, insertion, context) {
     const range = spanOffsets(sourceText, symbol?.sourceSpan);
     if (range) return { mode: candidate.mode, range };
   }
+  if (context.symbolIndexAvailable && candidates.some(hasSymbolAnchorIdentity)) return undefined;
   for (const candidate of candidates) {
     const range = spanOffsets(sourceText, candidate.headSpan);
     if (range) return { mode: candidate.mode, range };
@@ -175,6 +176,10 @@ function insertionAnchorResolution(sourceText, insertion, context) {
   return undefined;
 }
 
+function hasSymbolAnchorIdentity(candidate) {
+  return Boolean(candidate.anchorKey || candidate.anchorSymbolId || candidate.anchorSymbolName);
+}
+
 function insertionAnchorCandidates(insertion) {
   const seen = new Set();
   const result = [];

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

@@ -2,7 +2,9 @@ import { normalizeSemanticMergeReadiness, uniqueStrings } from '../../native-imp
 
 export function createSemanticPatchBundleAdmission(input = {}, context = {}) {
   const transformAdmission = semanticTransformAdmission(context);
-  const semanticEditAdmission = context.semanticEditAdmission ?? { status: 'none', action: 'none', readiness: 'needs-review', reasonCodes: [] };
+  const semanticEditAdmission = semanticEditAdmissionWithReplayRequirement(
+    context.semanticEditAdmission ?? { status: 'none', action: 'none', readiness: 'needs-review', reasonCodes: [] }
+  );
   const evidenceAdmission = autoMergeEvidenceAdmission(context, { transformAdmission, semanticEditAdmission });
   const fallbackReadiness = fallbackAdmissionReadiness(transformAdmission, semanticEditAdmission, evidenceAdmission, context.readiness);
   const inputReadiness = normalizeSemanticMergeReadiness(input.readiness ?? fallbackReadiness) ?? input.readiness ?? fallbackReadiness;
@@ -35,7 +37,7 @@ export function createSemanticPatchBundleAdmission(input = {}, context = {}) {
       ...strings(semanticEditAdmission.reasonCodes),
       ...strings(evidenceAdmission.reasonCodes)
     ].filter(Boolean)),
-    conflictKeys: uniqueStrings([...strings(input.conflictKeys), ...context.conflictKeys]),
+    conflictKeys: uniqueStrings([...strings(input.conflictKeys), ...strings(context.conflictKeys)]),
     admittedAt: input.admittedAt,
     reviewerId: input.reviewerId,
     evidenceIds: uniqueStrings([...strings(input.evidenceIds), ...strings(transformAdmission.evidenceIds), ...strings(evidenceAdmission.evidenceIds)]),
@@ -155,6 +157,7 @@ function fallbackAdmissionReadiness(transformAdmission, semanticEditAdmission, e
   if ([transformAdmission.readiness, semanticEditAdmission.readiness, evidenceAdmission.readiness].includes('blocked')) return 'blocked';
   if (hasSkipReadyAction(semanticEditAdmission)) return 'ready';
   if (hasPositiveApplyAction(transformAdmission, semanticEditAdmission)) return evidenceAdmission.action === 'admit' ? 'ready' : evidenceAdmission.readiness;
+  if (semanticEditAdmission.action === 'review' || semanticEditAdmission.status === 'needs-review') return 'needs-review';
   return fallback;
 }
 
@@ -183,6 +186,51 @@ function hasSkipReadyAction(semanticEditAdmission) {
   return semanticEditAdmission.action === 'skip' && semanticEditAdmission.readiness === 'ready' && semanticEditAdmission.reviewRequired === false;
 }
 
+function semanticEditAdmissionWithReplayRequirement(admission) {
+  if (!requiresSemanticEditReplay(admission) || hasAcceptedCleanSemanticEditReplay(admission)) return admission;
+  return compactRecord({
+    ...admission,
+    status: 'needs-review',
+    action: 'review',
+    readiness: 'needs-review',
+    reviewRequired: true,
+    autoApplyCandidate: false,
+    reasonCodes: uniqueStrings([
+      ...strings(admission.reasonCodes).filter((reason) => reason !== 'semantic-edit-positive-auto-merge-proof'),
+      ...semanticEditReplayRequirementReasonCodes(admission)
+    ])
+  });
+}
+
+function requiresSemanticEditReplay(admission) {
+  return admission.action === 'admit' ||
+    admission.autoApplyCandidate === true ||
+    admission.status === 'ready' ||
+    strings(admission.reasonCodes).includes('semantic-edit-positive-auto-merge-proof');
+}
+
+function hasAcceptedCleanSemanticEditReplay(admission) {
+  const summary = admission.summary ?? {};
+  const acceptedClean = count(summary.acceptedClean);
+  const alreadyApplied = count(summary.alreadyApplied);
+  const replays = count(summary.replays);
+  return acceptedClean > 0 && replays > 0 && acceptedClean + alreadyApplied === replays;
+}
+
+function semanticEditReplayRequirementReasonCodes(admission) {
+  const summary = admission.summary ?? {};
+  const scripts = count(summary.scripts);
+  const projections = count(summary.projections);
+  const replays = count(summary.replays);
+  const acceptedClean = count(summary.acceptedClean);
+  return [
+    scripts > 0 && projections === 0 ? 'semantic-edit-projection-missing' : undefined,
+    (scripts > 0 || projections > 0) && replays === 0 ? 'semantic-edit-replay-missing' : undefined,
+    replays > 0 && acceptedClean === 0 ? 'semantic-edit-replay-accepted-clean-missing' : undefined,
+    'semantic-edit-replay-required'
+  ].filter(Boolean);
+}
+
 function hasCrossLanguageTransform(index) {
   const source = new Set(strings(index.transformSourceLanguages));
   return strings(index.transformTargetLanguages).some((target) => !source.has(target));
@@ -211,6 +259,7 @@ function uniqueEvidenceRecords(records) {
 }
 
 function evidenceIds(evidence) { return uniqueStrings(evidence.map((record) => record.id)); }
+function count(value) { const number = Number(value ?? 0); return Number.isFinite(number) ? number : 0; }
 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))); }