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

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

@@ -3,7 +3,10 @@ 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 { explicitSourceReplacementEditForOperation } from './semanticEditExplicitSourceReplacement.js';
+import { projectionEditRecord } from './semanticEditProjectionRecord.js';
+import { findCurrentSymbol } from './semanticEditReplayAnchors.js';
 import {
   insertionOffset,
   insertionReplacement,
@@ -22,7 +25,7 @@ export function projectSemanticEditScriptToSource(input = {}) {
   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)
+  const headSymbols = typeof headSourceText === 'string' && language
     ? sourceSymbolIndex({
       sourceText: headSourceText,
       sourcePath: input.headSourcePath ?? script.sourcePath,
@@ -40,7 +43,8 @@ export function projectSemanticEditScriptToSource(input = {}) {
     }
     const edit = sourceEditForOperation(operation, workerSourceText, headSourceText, index, {
       headSourcePath: input.headSourcePath,
-      headSymbols
+      headSymbols,
+      symbolIndexAvailable: headSymbols.length > 0
     });
     if (edit.ok) edits.push(edit.value);
     else reasonCodes.push(...edit.reasonCodes);
@@ -93,14 +97,16 @@ function sourceEditForOperation(operation, workerSourceText, headSourceText, ord
     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}`] };
+  const explicit = explicitSourceReplacementEditForOperation(operation, identity, headSourceText, order);
+  if (explicit) return explicit;
   if (operation.changeKind === 'added' || String(operation.kind ?? '').startsWith('add')) {
     return insertionEditForOperation(operation, identity, workerSourceText, headSourceText, order, context);
   }
   if (operation.changeKind === 'removed' || String(operation.kind ?? '').startsWith('remove')) {
-    return removalEditForOperation(operation, identity, headSourceText, order);
+    return removalEditForOperation(operation, identity, headSourceText, order, context);
   }
   const workerOffsets = spanOffsets(workerSourceText, operation.spans?.worker);
-  const headOffsets = spanOffsets(headSourceText, operation.spans?.head ?? operation.spans?.base ?? operation.anchor?.sourceSpan);
+  const headOffsets = headOffsetsForOperation(operation, identity, headSourceText, context);
   const reasons = [];
   if (!workerOffsets) reasons.push(`worker-span-not-resolvable:${operation.id}`);
   if (!headOffsets) reasons.push(`head-span-not-resolvable:${operation.id}`);
@@ -116,9 +122,12 @@ function sourceEditForOperation(operation, workerSourceText, headSourceText, ord
   }
   if (reasons.length) return { ok: false, reasonCodes: reasons };
   const scoped = scopedBodyReplacement(operation, headSourceText, workerSourceText, headOffsets, workerOffsets);
-  const replacement = scoped
+  const rawReplacement = scoped
     ? workerSourceText.slice(scoped.worker.start, scoped.worker.end)
     : anchorReplacement;
+  const replacement = operation.metadata?.sourceBackprojection?.lineEndingStable
+    ? normalizeReplacementLineEndings(rawReplacement, anchorCurrent)
+    : rawReplacement;
   const current = scoped
     ? headSourceText.slice(scoped.head.start, scoped.head.end)
     : anchorCurrent;
@@ -145,8 +154,8 @@ function sourceEditForOperation(operation, workerSourceText, headSourceText, ord
     }
   };
 }
-function removalEditForOperation(operation, identity, headSourceText, order) {
-  const headOffsets = spanOffsets(headSourceText, operation.spans?.head ?? operation.spans?.base ?? operation.anchor?.sourceSpan);
+function removalEditForOperation(operation, identity, headSourceText, order, context) {
+  const headOffsets = headOffsetsForOperation(operation, identity, headSourceText, context);
   const reasons = [];
   if (!headOffsets) reasons.push(`head-span-not-resolvable:${operation.id}`);
   if (reasons.length) return { ok: false, reasonCodes: reasons };
@@ -171,18 +180,53 @@ function removalEditForOperation(operation, identity, headSourceText, order) {
     }
   };
 }
+
+function headOffsetsForOperation(operation, identity, headSourceText, context) {
+  const span = operation.spans?.head ?? operation.spans?.base ?? operation.anchor?.sourceSpan;
+  const spanRange = spanOffsets(headSourceText, span);
+  const symbol = context.symbolIndexAvailable ? findCurrentSymbol(identity, context.headSymbols) : undefined;
+  const symbolRange = spanOffsets(headSourceText, symbol?.sourceSpan);
+  if (!symbolRange) return spanRange;
+  if (!spanRange || sameRange(spanRange, symbolRange)) return symbolRange;
+  const expectedHash = operation.hashes?.headTextHash ?? operation.hashes?.baseTextHash;
+  if (expectedHash && rangeHash(headSourceText, symbolRange) === expectedHash) return symbolRange;
+  if (expectedHash && rangeHash(headSourceText, spanRange) === expectedHash) return spanRange;
+  return spanRange;
+}
+
+function rangeHash(sourceText, range) {
+  return range && typeof sourceText === 'string'
+    ? hashSemanticValue(sourceText.slice(range.start, range.end))
+    : undefined;
+}
+
+function sameRange(left, right) {
+  return left?.start === right?.start && left?.end === right?.end;
+}
+
+function normalizeReplacementLineEndings(replacement, current) {
+  const newline = current.includes('\r\n') ? '\r\n' : current.includes('\r') ? '\r' : '\n';
+  return String(replacement ?? '').replace(/\r\n/g, '\n').replace(/\r/g, '\n').replace(/\n/g, newline);
+}
+
 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, { 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 +256,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({
@@ -313,7 +299,6 @@ function projectedSourcePath(script, edits) {
   return edits.map((edit) => edit.sourcePath).find(Boolean) ?? script.sourcePath;
 }
 
-function isJavaScriptLike(language) { return language === 'javascript' || language === 'typescript'; }
 function compactRecord(value) {
   return Object.fromEntries(Object.entries(value ?? {}).filter(([, entry]) => entry !== undefined && (!Array.isArray(entry) || entry.length > 0)));
 }

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

@@ -0,0 +1,34 @@
+function replayReplacementText(edit, status, range, sourceText) {
+  const replacement = edit.replacementText;
+  if (status !== 'applied'
+    || typeof replacement !== 'string'
+    || !/[\r\n]/.test(replacement)
+    || typeof sourceText !== 'string') return replacement;
+  return replacement.replace(/\r\n/g, '\n').replace(/\r/g, '\n').replace(/\n/g, replayLineEnding(sourceText, range));
+}
+
+function replayLineEnding(sourceText, range) {
+  const offset = Math.max(0, Math.min(sourceText.length, range?.start ?? 0));
+  return lineEndingInText(range ? sourceText.slice(range.start, range.end) : '')
+    ?? nearbyLineEnding(sourceText, offset)
+    ?? lineEndingInText(sourceText)
+    ?? '\n';
+}
+
+function lineEndingInText(value) { return /\r\n|\r|\n/.exec(value)?.[0]; }
+
+function nearbyLineEnding(sourceText, offset) {
+  for (let distance = 0; distance <= sourceText.length; distance += 1) {
+    const ending = lineEndingAt(sourceText, offset - distance - 1) ?? lineEndingAt(sourceText, offset + distance);
+    if (ending) return ending;
+  }
+  return undefined;
+}
+
+function lineEndingAt(sourceText, index) {
+  const char = sourceText[index];
+  if (char === '\n') return sourceText[index - 1] === '\r' ? '\r\n' : '\n';
+  return char === '\r' ? sourceText[index + 1] === '\n' ? '\r\n' : '\r' : undefined;
+}
+
+export { replayReplacementText };

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

@@ -3,8 +3,17 @@ import { idFragment, normalizeNativeLanguageId, uniqueStrings } from '../../nati
 import { createSemanticImportSidecar } from './createSemanticImportSidecar.js';
 import { mapDiffSymbols } from './mapDiffSymbols.js';
 import { normalizeNativeDiffImport } from './normalizeNativeDiffImport.js';
+import { replayReplacementText } from './replaySemanticEditLineEndings.js';
 import { replayDiagnostics, replayEditDiagnostics, replayEditsWithOverlapDiagnostics } from './semanticEditReplayDiagnostics.js';
-import { afterLineOffset, bodyContentRange, spanOffsets } from './semanticEditSourceRanges.js';
+import { explicitSourceReplacementReplayRange } from './semanticEditReplaySourceReplacement.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;
@@ -15,11 +24,15 @@ export function replaySemanticEditProjection(input = {}) {
   const reasonCodes = baseReasonCodes(projection, currentSourceText);
   const currentHash = typeof currentSourceText === 'string' ? hashSemanticValue(currentSourceText) : undefined;
   if (input.currentSourceHash && currentHash !== input.currentSourceHash) reasonCodes.push('current-source-hash-mismatch');
-  const currentSymbols = currentSourceText && isJavaScriptLike(language)
+  const currentSymbols = currentSourceText && language
     ? 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: currentSymbols.length > 0
+    }))
     : [];
   const edits = replayEditsWithOverlapDiagnostics(replayedEdits);
   const status = replayStatus(reasonCodes, edits, projection);
@@ -69,23 +82,36 @@ function replayProjectionEdit(edit, context) {
   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 = currentSymbolEditRange(edit, spanOffsets(context.currentSourceText, symbol?.sourceSpan), context.currentSourceText);
+  const symbolRange = spanOffsets(context.currentSourceText, symbol?.sourceSpan);
+  const explicitRange = explicitSourceReplacementReplayRange(edit, symbolRange, context.currentSourceText);
+  const spanRange = explicitRange?.range ?? currentSymbolEditRange(edit, symbolRange, context.currentSourceText);
+  const reanchorReason = explicitRange?.reasonCode ?? 'offset-reanchored-by-symbol';
+  const explicitConflictReasons = explicitRange?.conflictReasonCodes ?? [];
   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, reanchorReason], context.currentSourceText);
+    if (offset && containedRange(headRange, spanRange)) {
+      return replayEditRecord(edit, offset.status, offset.range, [offset.reason, 'offset-contained-in-current-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);
+    return replayEditRecord(edit, 'conflict', spanRange, [`${currentSymbolRangeLabel(edit)}-content-mismatch`, ...explicitConflictReasons], 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);
+  if (anchored) return replayEditRecord(edit, anchored.status, replayAppliedRange(edit, anchored.range, context.currentSourceText), [anchored.reason, reanchorReason], context.currentSourceText);
   return replayEditRecord(edit, symbol ? 'conflict' : 'stale', spanRange, [
-    symbol ? `${currentSymbolRangeLabel(edit)}-content-mismatch` : 'current-symbol-anchor-missing'
+    symbol ? `${currentSymbolRangeLabel(edit)}-content-mismatch` : 'current-symbol-anchor-missing',
+    ...explicitConflictReasons
   ], 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 +123,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,15 +133,32 @@ 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;
 }
 
 function replayEditRecord(edit, status, range, reasonCodes, sourceText) {
   const normalizedReasonCodes = reasonList(reasonCodes);
+  const replacementText = replayReplacementText(edit, status, range, sourceText);
   return compactRecord({
     operationId: edit.operationId,
     semanticKey: edit.semanticKey,
@@ -130,79 +174,25 @@ function replayEditRecord(edit, status, range, reasonCodes, sourceText) {
     status,
     start: range?.start,
     end: range?.end,
-    replacementBytes: edit.replacementBytes,
-    replacementText: edit.replacementText,
+    replacementBytes: typeof replacementText === 'string' ? replacementText.length : edit.replacementBytes,
+    replacementText,
     reasonCodes: normalizedReasonCodes,
     diagnostics: replayEditDiagnostics(edit, status, range, normalizedReasonCodes, sourceText)
   });
 }
 
 function currentSymbolIndex(input) {
-  const imported = normalizeNativeDiffImport({
-    language: input.language,
-    sourcePath: input.sourcePath,
-    sourceText: input.currentSourceText,
-    parser: input.parser
-  }, input, 'current');
-  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 };
+  try {
+    const imported = normalizeNativeDiffImport({
+      language: input.language,
+      sourcePath: input.sourcePath,
+      sourceText: input.currentSourceText,
+      parser: input.parser
+    }, input, 'current');
+    return [...mapDiffSymbols(imported, createSemanticImportSidecar(imported)).values()];
+  } catch {
+    return [];
   }
-  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) {
@@ -212,6 +202,7 @@ function currentSymbolEditRange(edit, symbolRange, sourceText) {
 }
 
 function currentSymbolRangeLabel(edit) {
+  if (edit.sourceRangeKind === 'cross-language-explicit-source-replacement') return 'current-symbol-explicit-source-replacement';
   return edit.sourceRangeKind === 'body-content' ? 'current-symbol-body' : 'current-symbol-anchor';
 }
 
@@ -227,10 +218,11 @@ function replayStatus(reasonCodes, edits, projection) {
 
 function replayAdmission(status, reasonCodes, edits) {
   const apply = status === 'accepted-clean';
+  const skip = status === 'already-applied';
   return {
     status,
-    action: apply ? 'apply' : status === 'already-applied' ? 'skip' : status === 'stale' ? 'rerun-semantic-import' : status === 'blocked' ? 'block' : 'human-review',
-    reviewRequired: !apply,
+    action: apply ? 'apply' : skip ? 'skip' : status === 'stale' ? 'rerun-semantic-import' : status === 'blocked' ? 'block' : 'human-review',
+    reviewRequired: !(apply || skip),
     autoApplyCandidate: apply,
     autoMergeClaim: false,
     semanticEquivalenceClaim: false,
@@ -294,6 +286,14 @@ function rangesOverlap(left, right) {
   return Boolean(left && right && left.start < right.end && right.start < left.end);
 }
 
-function isJavaScriptLike(language) { return language === 'javascript' || language === 'typescript'; }
+function containedRange(inner, outer) {
+  return Boolean(inner && outer && outer.start <= inner.start && inner.end <= outer.end);
+}
+
 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/semanticEditBundleAdmission.js

@@ -1,4 +1,5 @@
 import { normalizeSemanticMergeReadiness, uniqueStrings } from '../../native-import-utils.js';
+import { summarizeSemanticSidecarQuality } from './semanticSidecarQuality.js';
 
 export const SemanticEditBundleAdmissionStatuses = Object.freeze([
   'none',
@@ -15,7 +16,7 @@ export function createSemanticEditBundleAdmission(input = {}, options = {}) {
   const projections = array(input.semanticEditProjections ?? input.projections ?? input.semanticEditProjection);
   const replays = array(input.semanticEditReplays ?? input.replays ?? input.semanticEditReplay);
   const evidence = evidenceRecords(input, options);
-  const summary = summarizeSemanticEditBundle(scripts, projections, replays, evidence);
+  const summary = summarizeSemanticEditBundle(scripts, projections, replays, evidence, input, options);
   const computedStatus = semanticEditBundleStatus(summary);
   const status = safeStatus(input.status ?? options.status, computedStatus, summary);
   const readiness = normalizeSemanticMergeReadiness(input.readiness ?? options.readiness ?? readinessForStatus(status))
@@ -45,7 +46,7 @@ export function createSemanticEditBundleAdmission(input = {}, options = {}) {
   });
 }
 
-function summarizeSemanticEditBundle(scripts, projections, replays, evidence) {
+function summarizeSemanticEditBundle(scripts, projections, replays, evidence, input, options) {
   const scriptStatusEntries = scripts.map((script) => script.admission?.status);
   const projectionStatusEntries = projections.flatMap((projection) => [projection.status, projection.admission?.status]);
   const replayStatusEntries = replays.map((replay) => replay.status);
@@ -54,6 +55,7 @@ function summarizeSemanticEditBundle(scripts, projections, replays, evidence) {
   const replayStatuses = uniqueStrings(strings(replayStatusEntries));
   const replayActions = uniqueStrings(strings(replays.map((replay) => replay.admission?.action)));
   const evidenceSummary = summarizeEvidence(evidence);
+  const sidecarQuality = summarizeSemanticSidecarQuality([input, options, ...scripts, ...projections, ...replays]);
   return {
     scripts: scripts.length,
     projections: projections.length,
@@ -82,11 +84,13 @@ function summarizeSemanticEditBundle(scripts, projections, replays, evidence) {
     failedTestEvidence: evidenceSummary.failed,
     conflictEvidence: evidenceSummary.conflict,
     staleEvidence: evidenceSummary.stale,
+    semanticSidecarQuality: sidecarQuality,
     reasonCodes: uniqueStrings([
       ...scripts.flatMap((script) => strings(script.admission?.reasonCodes)),
       ...projections.flatMap((projection) => strings(projection.admission?.reasonCodes)),
       ...replays.flatMap((replay) => strings(replay.admission?.reasonCodes)),
-      ...evidenceSummary.reasonCodes
+      ...evidenceSummary.reasonCodes,
+      ...sidecarQuality.warningCodes
     ])
   };
 }

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

@@ -1,4 +1,5 @@
 import { uniqueStrings } from '../../native-import-utils.js';
+import { summarizeSemanticSidecarQuality } from './semanticSidecarQuality.js';
 
 export function semanticEditRecordIndex(scripts, projections, replays, source = {}) {
   const operations = scripts.flatMap((script) => array(script.operations));
@@ -6,6 +7,8 @@ export function semanticEditRecordIndex(scripts, projections, replays, source =
   const replayEdits = replays.flatMap((replay) => array(replay.edits));
   const index = source.index ?? {};
   const summary = source.metadata?.semanticEditSummary ?? {};
+  const sidecarQuality = summarizeSemanticSidecarQuality([source, ...scripts, ...projections, ...replays]);
+  const priorSidecarQuality = summary.semanticSidecarQuality ?? {};
   return {
     semanticEditScriptIds: uniqueStrings([...strings(source.semanticEditScriptIds), ...strings(source.semanticEditScriptId), ...strings(index.semanticEditScriptIds), ...strings(summary.scriptIds), ...scripts.map((script) => script.id), ...replays.map((replay) => replay.scriptId)]),
     semanticEditProjectionIds: uniqueStrings([...strings(source.semanticEditProjectionIds), ...strings(source.semanticEditProjectionId), ...strings(index.semanticEditProjectionIds), ...strings(summary.projectionIds), ...projections.map((projection) => projection.id), ...replays.map((replay) => replay.projectionId)]),
@@ -15,8 +18,10 @@ export function semanticEditRecordIndex(scripts, projections, replays, source =
     semanticEditReplayEditCount: replayEdits.length,
     semanticEditReplayStatuses: uniqueStrings([...strings(source.semanticEditReplayStatuses), ...strings(index.semanticEditReplayStatuses), ...strings(summary.replayStatuses), ...replays.map((replay) => replay.status)]),
     semanticEditReplayActions: uniqueStrings([...strings(source.semanticEditReplayActions), ...strings(index.semanticEditReplayActions), ...strings(summary.replayActions), ...replays.map((replay) => replay.admission?.action)]),
+    semanticEditReplayReasonCodes: uniqueStrings([...strings(source.semanticEditReplayReasonCodes), ...strings(index.semanticEditReplayReasonCodes), ...strings(summary.replayReasonCodes), ...replays.flatMap(replayReasonCodes)]),
     semanticEditReplayCurrentHashes: uniqueStrings([...strings(source.semanticEditReplayCurrentHashes), ...strings(index.semanticEditReplayCurrentHashes), ...strings(summary.replayCurrentHashes), ...strings(summary.semanticEditReplayCurrentHashes), ...replays.map((replay) => replay.currentHash)]),
     semanticEditReplayOutputHashes: uniqueStrings([...strings(source.semanticEditReplayOutputHashes), ...strings(index.semanticEditReplayOutputHashes), ...strings(summary.replayOutputHashes), ...strings(summary.semanticEditReplayOutputHashes), ...replays.map((replay) => replay.outputHash)]),
+    sourceBackprojectionModes: uniqueStrings([...strings(source.sourceBackprojectionModes), ...strings(index.sourceBackprojectionModes), ...strings(summary.sourceBackprojectionModes), ...scripts.flatMap(scriptBackprojectionModes), ...projections.map((projection) => projection.metadata?.sourceBackprojectionMode), ...replays.map((replay) => replay.metadata?.sourceBackprojectionMode)]),
     semanticEditKeys: uniqueStrings([...strings(source.semanticEditKeys), ...strings(index.semanticEditKeys), ...strings(summary.semanticEditKeys), ...operations.map((operation) => operation.semanticKey), ...edits.map((edit) => edit.semanticKey), ...replayEdits.map((edit) => edit.semanticKey)]),
     semanticIdentityHashes: uniqueStrings([...strings(source.semanticIdentityHashes), ...strings(index.semanticIdentityHashes), ...strings(summary.semanticIdentityHashes), ...operations.map((operation) => operation.semanticIdentityHash), ...edits.map((edit) => edit.semanticIdentityHash), ...replayEdits.map((edit) => edit.semanticIdentityHash)]),
     sourceIdentityHashes: uniqueStrings([...strings(source.sourceIdentityHashes), ...strings(index.sourceIdentityHashes), ...strings(summary.sourceIdentityHashes), ...operations.map((operation) => operation.sourceIdentityHash), ...edits.map((edit) => edit.sourceIdentityHash), ...replayEdits.map((edit) => edit.sourceIdentityHash)]),
@@ -24,7 +29,15 @@ export function semanticEditRecordIndex(scripts, projections, replays, source =
     editContentHashes: uniqueStrings([...strings(source.editContentHashes), ...strings(index.editContentHashes), ...strings(summary.editContentHashes), ...edits.map((edit) => edit.editContentHash), ...replayEdits.map((edit) => edit.editContentHash)]),
     anchorKeys: uniqueStrings([...strings(source.anchorKeys), ...strings(index.anchorKeys), ...strings(summary.anchorKeys), ...operations.map((operation) => operation.anchor?.key), ...edits.map((edit) => edit.anchorKey), ...replayEdits.map((edit) => edit.anchorKey)]),
     conflictKeys: uniqueStrings([...strings(source.conflictKeys), ...strings(index.conflictKeys), ...strings(summary.conflictKeys), ...operations.map((operation) => operation.anchor?.conflictKey), ...edits.map((edit) => edit.conflictKey), ...replayEdits.map((edit) => edit.conflictKey)]),
-    projectedSourcePaths: uniqueStrings([...strings(source.projectedSourcePaths), ...strings(index.projectedSourcePaths), ...strings(summary.projectedSourcePaths), ...projections.map((projection) => projection.sourcePath), ...edits.flatMap((edit) => [edit.sourcePath, edit.targetSourcePath]), ...replays.map((replay) => replay.sourcePath), ...replayEdits.map((edit) => edit.sourcePath)])
+    projectedSourcePaths: uniqueStrings([...strings(source.projectedSourcePaths), ...strings(index.projectedSourcePaths), ...strings(summary.projectedSourcePaths), ...projections.map((projection) => projection.sourcePath), ...edits.flatMap((edit) => [edit.sourcePath, edit.targetSourcePath]), ...replays.map((replay) => replay.sourcePath), ...replayEdits.map((edit) => edit.sourcePath)]),
+    semanticEditSidecarQualityRecords: maxCount(sidecarQuality.records, source.semanticEditSidecarQualityRecords, index.semanticEditSidecarQualityRecords, priorSidecarQuality.records),
+    semanticEditSidecarSymbolCount: maxCount(sidecarQuality.symbols, source.semanticEditSidecarSymbolCount, index.semanticEditSidecarSymbolCount, priorSidecarQuality.symbols),
+    semanticEditSidecarOwnershipRegionCount: maxCount(sidecarQuality.ownershipRegions, source.semanticEditSidecarOwnershipRegionCount, index.semanticEditSidecarOwnershipRegionCount, priorSidecarQuality.ownershipRegions),
+    semanticEditSidecarPatchHintCount: maxCount(sidecarQuality.patchHints, source.semanticEditSidecarPatchHintCount, index.semanticEditSidecarPatchHintCount, priorSidecarQuality.patchHints),
+    semanticEditSidecarWarningCount: maxCount(sidecarQuality.warnings, source.semanticEditSidecarWarningCount, index.semanticEditSidecarWarningCount, priorSidecarQuality.warnings),
+    semanticEditSidecarZeroRecordWarningCount: maxCount(sidecarQuality.zeroRecordWarnings, source.semanticEditSidecarZeroRecordWarningCount, index.semanticEditSidecarZeroRecordWarningCount, priorSidecarQuality.zeroRecordWarnings),
+    semanticEditSidecarWarningCodes: uniqueStrings([...strings(source.semanticEditSidecarWarningCodes), ...strings(index.semanticEditSidecarWarningCodes), ...strings(priorSidecarQuality.warningCodes), ...sidecarQuality.warningCodes]),
+    semanticEditSidecarZeroRecordWarningCodes: uniqueStrings([...strings(source.semanticEditSidecarZeroRecordWarningCodes), ...strings(index.semanticEditSidecarZeroRecordWarningCodes), ...strings(priorSidecarQuality.zeroRecordWarningCodes), ...sidecarQuality.zeroRecordWarningCodes])
   };
 }
 
@@ -36,8 +49,10 @@ export function semanticEditSummary(index) {
     replayIds: index.semanticEditReplayIds,
     replayStatuses: index.semanticEditReplayStatuses,
     replayActions: index.semanticEditReplayActions,
+    replayReasonCodes: index.semanticEditReplayReasonCodes,
     replayCurrentHashes: index.semanticEditReplayCurrentHashes,
     replayOutputHashes: index.semanticEditReplayOutputHashes,
+    sourceBackprojectionModes: index.sourceBackprojectionModes,
     semanticEditKeys: index.semanticEditKeys,
     semanticIdentityHashes: index.semanticIdentityHashes,
     sourceIdentityHashes: index.sourceIdentityHashes,
@@ -46,6 +61,16 @@ export function semanticEditSummary(index) {
     anchorKeys: index.anchorKeys,
     conflictKeys: index.conflictKeys,
     projectedSourcePaths: index.projectedSourcePaths,
+    semanticSidecarQuality: {
+      records: index.semanticEditSidecarQualityRecords,
+      symbols: index.semanticEditSidecarSymbolCount,
+      ownershipRegions: index.semanticEditSidecarOwnershipRegionCount,
+      patchHints: index.semanticEditSidecarPatchHintCount,
+      warnings: index.semanticEditSidecarWarningCount,
+      zeroRecordWarnings: index.semanticEditSidecarZeroRecordWarningCount,
+      warningCodes: index.semanticEditSidecarWarningCodes,
+      zeroRecordWarningCodes: index.semanticEditSidecarZeroRecordWarningCodes
+    },
     replayEditCount: index.semanticEditReplayEditCount
   });
 }
@@ -57,6 +82,27 @@ function replayOperationIds(replays) {
     ...array(replay.edits).map((edit) => edit.operationId)
   ]);
 }
+function replayReasonCodes(replay) {
+  return [
+    ...array(replay.admission?.reasonCodes),
+    ...array(replay.summary?.reasonCodes),
+    ...array(replay.diagnostics).flatMap((diagnostic) => array(diagnostic.reasonCodes)),
+    ...array(replay.edits).flatMap((edit) => array(edit.reasonCodes))
+  ];
+}
+function scriptBackprojectionModes(script) {
+  return [
+    script.metadata?.sourceBackprojectionMode,
+    script.metadata?.sourceProjectionHint?.sourceBackprojectionMode,
+    ...array(script.operations).map((operation) => operation.metadata?.sourceBackprojection?.mode)
+  ];
+}
+function maxCount(...values) {
+  return Math.max(0, ...values.map((value) => {
+    const count = Number(value ?? 0);
+    return Number.isFinite(count) ? count : 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))); }