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

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

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

@@ -24,7 +24,7 @@ export function spanOffsets(sourceText, span) {
   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 lineEnd = lineContentEndOffset(sourceText, lineStarts[endLine]);
   const endColumn = span.endColumn === undefined ? lineEnd - endLineStart : Math.max(1, span.endColumn) - 1;
   return { start: start + startColumn, end: endLineStart + endColumn };
 }
@@ -49,36 +49,41 @@ export function bodyContentRange(sourceText, range) {
   return pair ? { start: pair.open + 1, end: pair.close } : undefined;
 }
 
-export function insertionOffset(sourceText, insertion) {
+export function insertionOffset(sourceText, insertion, context = {}) {
   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) };
+  const resolved = insertionAnchorResolution(sourceText, insertion, context);
+  if (!resolved?.range) return { ok: false, reasonCodes: ['insertion-anchor-not-resolvable'] };
+  if (resolved.mode === 'before') return { ok: true, offset: resolved.range.start };
+  if (resolved.mode === 'after') return { ok: true, offset: afterLineOffset(sourceText, resolved.range.end) };
   return { ok: false, reasonCodes: ['insertion-mode-unsupported'] };
 }
 
 export 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;
+  const next = lineBreakEndOffset(sourceText, range.end);
+  if (next !== range.end) range.end = next;
+  else {
+    const previous = previousLineBreakStartOffset(sourceText, range.start);
+    if (previous !== range.start) range.start = previous;
+  }
   return range;
 }
 
 export 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';
+  const newline = sourceLineEnding(sourceText);
+  if (offset > 0 && !isLineBreak(sourceText[offset - 1])) replacement = `${newline}${replacement}`;
+  if (offset < sourceText.length && !endsWithLineBreak(replacement)) replacement += newline;
+  if (offset === sourceText.length && sourceText && !endsWithLineBreak(sourceText)) replacement = `${newline}${replacement}`;
+  if (offset === sourceText.length && !endsWithLineBreak(replacement)) replacement += newline;
   return replacement;
 }
 
 export function afterLineOffset(sourceText, offset) {
-  return sourceText[offset] === '\n' ? offset + 1 : offset;
+  return lineBreakEndOffset(sourceText, offset);
 }
 
 function isProjectionCoverableContainer(operation) {
@@ -112,15 +117,89 @@ function containedRange(inner, outer) {
 
 function insertionRemovalRange(sourceText, span, container) {
   const range = { ...span };
-  if (range.end < container.end && sourceText[range.end] === '\n') range.end += 1;
-  else if (range.start > container.start && sourceText[range.start - 1] === '\n') range.start -= 1;
+  const next = lineBreakEndOffset(sourceText, range.end);
+  if (next !== range.end && next <= container.end) range.end = next;
+  else {
+    const previous = previousLineBreakStartOffset(sourceText, range.start);
+    if (previous !== range.start && previous >= container.start) range.start = previous;
+  }
   return range;
 }
 
+function lineContentEndOffset(sourceText, nextLineStart) {
+  if (nextLineStart === undefined) return sourceText.length;
+  const lineBreakStart = sourceText[nextLineStart - 2] === '\r' ? nextLineStart - 2 : nextLineStart - 1;
+  return Math.max(0, lineBreakStart);
+}
+
+function lineBreakEndOffset(sourceText, offset) {
+  if (sourceText[offset] === '\r' && sourceText[offset + 1] === '\n') return offset + 2;
+  if (isLineBreak(sourceText[offset])) return offset + 1;
+  return offset;
+}
+
+function previousLineBreakStartOffset(sourceText, offset) {
+  if (sourceText[offset - 1] === '\n') return sourceText[offset - 2] === '\r' ? offset - 2 : offset - 1;
+  if (sourceText[offset - 1] === '\r') return offset - 1;
+  return offset;
+}
+
+function sourceLineEnding(sourceText) {
+  if (sourceText.includes('\r\n')) return '\r\n';
+  return sourceText.includes('\r') ? '\r' : '\n';
+}
+
+function endsWithLineBreak(value) {
+  return isLineBreak(value[value.length - 1]);
+}
+
+function isLineBreak(char) {
+  return char === '\n' || char === '\r';
+}
+
 function isBodyReplacement(operation) {
   return operation.changeKind === 'modified' && (operation.kind === 'replaceBody' || operation.anchor?.regionKind === 'body');
 }
 
+function insertionAnchorResolution(sourceText, insertion, context) {
+  const candidates = insertionAnchorCandidates(insertion);
+  for (const candidate of candidates) {
+    const symbol = insertionAnchorSymbol(candidate, context.symbols);
+    const range = spanOffsets(sourceText, symbol?.sourceSpan);
+    if (range) return { mode: candidate.mode, range };
+  }
+  for (const candidate of candidates) {
+    const range = spanOffsets(sourceText, candidate.headSpan);
+    if (range) return { mode: candidate.mode, range };
+  }
+  return undefined;
+}
+
+function insertionAnchorCandidates(insertion) {
+  const seen = new Set();
+  const result = [];
+  for (const candidate of [insertion, ...(Array.isArray(insertion?.anchorCandidates) ? insertion.anchorCandidates : [])]) {
+    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 insertionAnchorSymbol(candidate, symbols) {
+  const symbolList = Array.isArray(symbols)
+    ? symbols
+    : symbols?.values
+      ? [...symbols.values()]
+      : [];
+  const keys = [candidate.anchorKey, candidate.anchorSymbolId].filter(Boolean);
+  const exact = symbolList.find((symbol) => [symbol.ownershipKey, symbol.key, symbol.id].some((key) => key && keys.includes(key)));
+  if (exact) return exact;
+  return symbolList.find((symbol) => symbol.name === candidate.anchorSymbolName && (!candidate.anchorSymbolKind || symbol.kind === candidate.anchorSymbolKind));
+}
+
 function trailingBodyCloseOffset(sourceText, range) {
   if (typeof sourceText !== 'string' || !range) return undefined;
   let index = range.end - 1;

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

@@ -137,12 +137,17 @@ function resolveIndexKeys(values, resolutions, options) {
     const key = String(value);
     const resolution = resolutions.get(key);
     if (!resolution) return [key];
+    const current = resolution.currentAnchors.map((anchor) => anchor.key).filter(Boolean);
     if (resolution.status === 'deleted' && options.keepDeletedAnchors !== true) return [];
     if (resolution.status === 'cycle' && options.keepBlockedAnchors !== true) return [];
     if (resolution.status === 'max-depth' && options.keepBlockedAnchors !== true) return [];
     if (resolution.status === 'not-found' && options.keepUnresolvedAnchors !== true) return [];
+    if (resolution.status === 'ambiguous' && resolutionHasInactiveTerminal(resolution)) {
+      if (options.keepCandidateAnchors === true) return current.length ? current : [key];
+      if (options.keepDeletedAnchors === true || options.keepInactiveAnchors === true) return [key];
+      return [];
+    }
     if (resolution.status === 'ambiguous' && options.keepCandidateAnchors === false) return [];
-    const current = resolution.currentAnchors.map((anchor) => anchor.key).filter(Boolean);
     return current.length ? current : [key];
   }));
 }
@@ -193,7 +198,10 @@ function createAnchorInventory(resolutions) {
     const current = resolution.currentAnchors.map((anchor) => anchorEntry(anchor, resolution));
     if (resolution.status === 'ambiguous') {
       inventory.candidate.push(...current);
-      if (start) inventory.inactive.push(start);
+      if (start) {
+        inventory.inactive.push(start);
+        if (resolutionHasDeletedTerminal(resolution)) inventory.deleted.push(start);
+      }
       continue;
     }
     if (resolution.status === 'deleted') {
@@ -254,6 +262,17 @@ function anchorEntry(anchor, resolution) {
   });
 }
 
+function resolutionHasInactiveTerminal(resolution) {
+  return array(resolution.terminalEventIds).length > 0
+    || resolutionHasDeletedTerminal(resolution)
+    || array(resolution.reasonCodes).some((code) => code === 'lineage-event-without-target-anchor' || code === 'inactive-anchor-has-active-candidates');
+}
+
+function resolutionHasDeletedTerminal(resolution) {
+  return array(resolution.lineageEventKinds).includes('deleted')
+    || array(resolution.reasonCodes).includes('anchor-deleted');
+}
+
 function queryAnchor(resolution) {
   return compactRecord({
     key: resolution.query?.anchorKey,

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

@@ -0,0 +1,97 @@
+import { uniqueStrings } from '../../native-import-utils.js';
+
+export function addIdentityHashEvidence(before, after, add, note) {
+  const matches = matchingIdentityHashReasons(before, after);
+  if (matches.length === 0) return;
+  if (!compatibleLineageSurface(before, after)) {
+    note('identity-hash-match-surface-mismatch');
+    return;
+  }
+  const primary = matches.includes('semantic-identity-hash-match')
+    ? 'semantic-identity-hash-match'
+    : matches.includes('source-identity-hash-match')
+      ? 'source-identity-hash-match'
+      : 'identity-hash-match';
+  add(0.62, primary);
+  for (const reason of matches) {
+    if (reason !== primary) note(reason);
+  }
+}
+
+export function addSourceHashEvidence(before, after, add, note, reasons, sameSymbolSurface) {
+  const beforeHash = firstString(before.anchor.sourceHash, before.sourceHash);
+  const afterHash = firstString(after.anchor.sourceHash, after.sourceHash);
+  if (!beforeHash || !afterHash) return;
+  if (beforeHash !== afterHash) {
+    note('source-hash-changed');
+    return;
+  }
+  if (!hasSourceHashSupport(before, after, reasons, sameSymbolSurface)) {
+    note('source-hash-match-without-lineage-support');
+    return;
+  }
+  add(0.04, 'source-hash-match');
+  if (before.anchor.sourcePath && after.anchor.sourcePath && before.anchor.sourcePath !== after.anchor.sourcePath) {
+    note('source-hash-preserved-across-path');
+  }
+}
+
+export function hashEvidenceSummary(reasons) {
+  return {
+    semanticIdentityHashMatch: reasons.includes('semantic-identity-hash-match'),
+    sourceIdentityHashMatch: reasons.includes('source-identity-hash-match'),
+    identityHashMatch: reasons.includes('identity-hash-match'),
+    sourceHashMatch: reasons.includes('source-hash-match'),
+    signatureHashMatch: reasons.includes('signature-hash-match'),
+    bodyHashMatch: reasons.includes('body-hash-match')
+  };
+}
+
+function matchingIdentityHashReasons(before, after) {
+  const beforeHashes = identityHashEntries(before);
+  const afterHashes = new Map(identityHashEntries(after).map((entry) => [entry.value, entry.reason]));
+  const reasons = [];
+  for (const entry of beforeHashes) {
+    const afterReason = afterHashes.get(entry.value);
+    if (!afterReason) continue;
+    reasons.push(identityHashMatchReason(entry.reason, afterReason));
+  }
+  return uniqueStrings(reasons);
+}
+
+function identityHashEntries(symbol) {
+  return [
+    { reason: 'semantic-identity-hash-match', value: firstString(symbol.semanticIdentityHash, symbol.anchor.metadata?.semanticIdentityHash) },
+    { reason: 'source-identity-hash-match', value: firstString(symbol.sourceIdentityHash, symbol.anchor.metadata?.sourceIdentityHash) },
+    { reason: 'identity-hash-match', value: firstString(symbol.identityHash, symbol.anchor.metadata?.identityHash) }
+  ].filter((entry) => entry.value);
+}
+
+function identityHashMatchReason(beforeReason, afterReason) {
+  if (beforeReason === afterReason) return beforeReason;
+  if (beforeReason === 'semantic-identity-hash-match' || afterReason === 'semantic-identity-hash-match') return 'semantic-identity-hash-match';
+  if (beforeReason === 'source-identity-hash-match' || afterReason === 'source-identity-hash-match') return 'source-identity-hash-match';
+  return 'identity-hash-match';
+}
+
+function compatibleLineageSurface(before, after) {
+  return (!before.language || !after.language || before.language === after.language)
+    && (!before.kind || !after.kind || before.kind === after.kind)
+    && (!before.anchor.kind || !after.anchor.kind || before.anchor.kind === after.anchor.kind);
+}
+
+function hasSourceHashSupport(before, after, reasons, sameSymbolSurface) {
+  return reasons.some((reason) => [
+    'semantic-identity-hash-match',
+    'source-identity-hash-match',
+    'identity-hash-match',
+    'signature-hash-match',
+    'body-hash-match',
+    'symbol-name-match'
+  ].includes(reason))
+    || sameSymbolSurface(before, after);
+}
+
+function firstString(...values) {
+  return values.map((value) => value === undefined || value === null ? '' : String(value)).find(Boolean);
+}