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

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

@@ -0,0 +1,40 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import { spanOffsets } from './semanticEditSourceRanges.js';
+
+export function explicitSourceReplacementEditForOperation(operation, identity, headSourceText, order) {
+  const backprojection = operation.metadata?.sourceBackprojection;
+  if (backprojection?.mode !== 'cross-language-explicit-source-replacement') return undefined;
+  const replacement = backprojection.sourceReplacementText;
+  const range = spanOffsets(headSourceText, backprojection.sourceEditSpan ?? operation.spans?.head ?? operation.spans?.base);
+  const anchorRange = spanOffsets(headSourceText, operation.anchor?.sourceSpan);
+  const reasons = [];
+  if (typeof replacement !== 'string') reasons.push(`source-replacement-text-missing:${operation.id}`);
+  if (!range) reasons.push(`head-span-not-resolvable:${operation.id}`);
+  if (reasons.length) return { ok: false, reasonCodes: reasons };
+  const current = headSourceText.slice(range.start, range.end);
+  const currentHash = hashSemanticValue(current);
+  const replacementHash = hashSemanticValue(replacement);
+  const expectedCurrentHash = backprojection.sourceEditTextHash ?? operation.hashes?.headTextHash ?? operation.hashes?.baseTextHash;
+  if (expectedCurrentHash && currentHash !== expectedCurrentHash) reasons.push(`head-span-hash-mismatch:${operation.id}`);
+  if (backprojection.sourceReplacementTextHash && replacementHash !== backprojection.sourceReplacementTextHash) {
+    reasons.push(`source-replacement-text-hash-mismatch:${operation.id}`);
+  }
+  if (reasons.length) return { ok: false, reasonCodes: reasons };
+  return {
+    ok: true,
+    value: {
+      operationId: operation.id,
+      order,
+      ...identity,
+      editKind: 'replace',
+      sourceRangeKind: 'cross-language-explicit-source-replacement',
+      start: range.start,
+      end: range.end,
+      headAnchorStart: anchorRange?.start,
+      headAnchorEnd: anchorRange?.end,
+      replacement,
+      replacementSpanText: replacement,
+      current
+    }
+  };
+}

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/semanticEditOperationCoverage.js

@@ -7,14 +7,16 @@ export function markCoveredSemanticEditOperations(operations, context) {
     worker: nativeImportSourceText(context.worker)
   };
   return (operations ?? []).map((operation) => {
-    const coveredBy = coveredByChildOperations(operation, operations, sourceText);
+    const childCoverage = coveredByChildOperations(operation, operations, sourceText);
+    const parentCoverage = childCoverage.length ? [] : coveredByParentOperations(operation, operations, sourceText);
+    const coveredBy = childCoverage.length ? childCoverage : parentCoverage;
     if (!coveredBy.length) return operation;
     return {
       ...operation,
       status: 'covered',
       readiness: 'ready',
       confidence: Math.max(operation.confidence ?? 0, 0.82),
-      reasonCodes: uniqueStrings([...(operation.reasonCodes ?? []), 'container-covered-by-child-edits']),
+      reasonCodes: uniqueStrings([...(operation.reasonCodes ?? []), coverageReason(childCoverage)]),
       evidenceIds: uniqueStrings(operation.evidenceIds ?? []),
       metadata: {
         ...(operation.metadata ?? {}),
@@ -24,6 +26,10 @@ export function markCoveredSemanticEditOperations(operations, context) {
   });
 }
 
+function coverageReason(childCoverage) {
+  return childCoverage.length ? 'container-covered-by-child-edits' : 'child-covered-by-container-edit';
+}
+
 function coveredByChildOperations(container, operations, sourceText) {
   if (!isCoverableContainer(container)) return [];
   const containerBase = spanOffsets(sourceText.base, container.spans?.base);
@@ -43,7 +49,31 @@ function isCoverableContainer(operation) {
   if (operation.changeKind !== 'modified') return false;
   if (!operation.spans?.base || !operation.spans?.worker) return false;
   const kind = String(operation.anchor?.regionKind ?? operation.regionKind ?? '');
-  return kind === 'type' || kind === 'config' || kind === 'content' || kind === 'route' || kind === 'property';
+  return ['type', 'config', 'content', 'route', 'property', 'controlFlow', 'effect', 'mutation'].includes(kind);
+}
+
+function coveredByParentOperations(child, operations, sourceText) {
+  if (child.changeKind !== 'added' && child.changeKind !== 'removed') return [];
+  if (!isSemanticFactRegion(child)) return [];
+  const side = child.changeKind === 'removed' ? 'base' : 'worker';
+  const childRange = spanOffsets(sourceText[side], child.spans?.[side]);
+  if (!childRange) return [];
+  return (operations ?? []).filter((parent) => parent.id !== child.id
+    && parent.changeKind === child.changeKind
+    && ['portable', 'already-applied'].includes(parent.status)
+    && parent.anchor?.regionKind === 'body'
+    && sameSourcePath(parent, child)
+    && contained(childRange, spanOffsets(sourceText[side], parent.spans?.[side])));
+}
+
+function isSemanticFactRegion(operation) {
+  return ['controlFlow', 'effect', 'mutation', 'call'].includes(String(operation.anchor?.regionKind ?? ''));
+}
+
+function sameSourcePath(left, right) {
+  const leftPath = left.anchor?.sourcePath ?? left.insertion?.sourcePath;
+  const rightPath = right.anchor?.sourcePath ?? right.insertion?.sourcePath;
+  return !leftPath || !rightPath || leftPath === rightPath;
 }
 
 function childEdit(operation, sourceText, containerBase) {

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

@@ -0,0 +1,108 @@
+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);
+  const sourceIdentity = sourceIdentityAnchorFields(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,
+    ...sourceIdentity,
+    operationContentHash: edit.operationContentHash,
+    editContentHash: hashSemanticValue(compactRecord({
+      semanticIdentityHash: identity.semanticIdentityHash,
+      sourceIdentityHash: identity.sourceIdentityHash,
+      sourceIdentityStatus: sourceIdentity.sourceIdentityStatus,
+      sourceIdentityAnchorKey: sourceIdentity.sourceIdentityAnchorKey,
+      targetIdentityAnchorKey: sourceIdentity.targetIdentityAnchorKey,
+      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,
+    deletedText: deletedTextForEdit(edit),
+    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 deletedTextForEdit(edit) {
+  return edit.sourceRangeKind === 'cross-language-explicit-source-replacement' ? edit.current : undefined;
+}
+
+function sourceIdentityAnchorFields(edit) {
+  const sourceIdentityAnchorKey = edit.sourceIdentityAnchorKey ?? edit.anchorKey;
+  const targetIdentityAnchorKey = edit.targetIdentityAnchorKey ?? edit.targetAnchorKey ?? sourceIdentityAnchorKey;
+  const sourceIdentitySourcePath = edit.sourceIdentitySourcePath ?? edit.originalSourcePath ?? edit.sourcePath;
+  const targetIdentitySourcePath = edit.targetIdentitySourcePath ?? edit.targetSourcePath ?? edit.sourcePath;
+  const moved = Boolean(
+    (sourceIdentityAnchorKey && targetIdentityAnchorKey && sourceIdentityAnchorKey !== targetIdentityAnchorKey)
+    || (sourceIdentitySourcePath && targetIdentitySourcePath && sourceIdentitySourcePath !== targetIdentitySourcePath)
+  );
+  return compactRecord({
+    sourceIdentityStatus: edit.sourceIdentityStatus ?? (moved ? 'moved-source' : 'same-source'),
+    sourceIdentityAnchorKey,
+    targetIdentityAnchorKey,
+    sourceIdentitySourcePath,
+    targetIdentitySourcePath
+  });
+}
+
+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/semanticEditReplayDiagnostics.js

@@ -8,6 +8,7 @@ export function replayEditDiagnostics(edit, status, range, reasonCodes, sourceTe
     status,
     operationId: edit.operationId,
     sourcePath: edit.targetSourcePath ?? edit.sourcePath,
+    ...sourceIdentityDiagnosticContext(edit),
     symbolName: edit.targetSymbolName ?? edit.symbolName,
     symbolKind: edit.targetSymbolKind ?? edit.symbolKind,
     editKind: edit.editKind,
@@ -64,6 +65,7 @@ function appendOverlapDiagnostic(overlapDiagnostics, edit, code, operationIds) {
     status: 'conflict',
     operationId: edit.operationId,
     sourcePath: edit.sourcePath,
+    ...sourceIdentityDiagnosticContext(edit),
     symbolName: edit.symbolName,
     symbolKind: edit.symbolKind,
     editKind: edit.editKind,
@@ -93,6 +95,18 @@ function replayDiagnostic(code, context) {
     status: context.status,
     operationId: context.operationId,
     sourcePath: context.sourcePath,
+    originalSourcePath: context.originalSourcePath,
+    targetSourcePath: context.targetSourcePath,
+    anchorKey: context.anchorKey,
+    targetAnchorKey: context.targetAnchorKey,
+    sourceIdentityStatus: context.sourceIdentityStatus,
+    sourceIdentityAnchorKey: context.sourceIdentityAnchorKey,
+    targetIdentityAnchorKey: context.targetIdentityAnchorKey,
+    sourceIdentitySourcePath: context.sourceIdentitySourcePath,
+    targetIdentitySourcePath: context.targetIdentitySourcePath,
+    semanticIdentityHash: context.semanticIdentityHash,
+    sourceIdentityHash: context.sourceIdentityHash,
+    editContentHash: context.editContentHash,
     symbolName: context.symbolName,
     symbolKind: context.symbolKind,
     editKind: context.editKind,
@@ -105,6 +119,31 @@ function replayDiagnostic(code, context) {
   });
 }
 
+function sourceIdentityDiagnosticContext(edit) {
+  const sourceIdentityAnchorKey = edit.sourceIdentityAnchorKey ?? edit.anchorKey;
+  const targetIdentityAnchorKey = edit.targetIdentityAnchorKey ?? edit.targetAnchorKey ?? sourceIdentityAnchorKey;
+  const sourceIdentitySourcePath = edit.sourceIdentitySourcePath ?? edit.originalSourcePath ?? edit.sourcePath;
+  const targetIdentitySourcePath = edit.targetIdentitySourcePath ?? edit.targetSourcePath ?? edit.sourcePath;
+  const moved = Boolean(
+    (sourceIdentityAnchorKey && targetIdentityAnchorKey && sourceIdentityAnchorKey !== targetIdentityAnchorKey)
+    || (sourceIdentitySourcePath && targetIdentitySourcePath && sourceIdentitySourcePath !== targetIdentitySourcePath)
+  );
+  return compactRecord({
+    originalSourcePath: edit.originalSourcePath,
+    targetSourcePath: edit.targetSourcePath,
+    anchorKey: edit.anchorKey,
+    targetAnchorKey: edit.targetAnchorKey,
+    sourceIdentityStatus: edit.sourceIdentityStatus ?? (moved ? 'moved-source' : 'same-source'),
+    sourceIdentityAnchorKey,
+    targetIdentityAnchorKey,
+    sourceIdentitySourcePath,
+    targetIdentitySourcePath,
+    semanticIdentityHash: edit.semanticIdentityHash,
+    sourceIdentityHash: edit.sourceIdentityHash,
+    editContentHash: edit.editContentHash
+  });
+}
+
 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';

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

@@ -0,0 +1,85 @@
+export function explicitSourceReplacementReplayRange(edit, symbolRange, sourceText) {
+  if (edit.sourceRangeKind !== 'cross-language-explicit-source-replacement' || !symbolRange || typeof sourceText !== 'string') {
+    return undefined;
+  }
+  const deleted = uniqueTextRange(sourceText, symbolRange, edit.deletedText, 'deleted-text');
+  if (deleted.status === 'matched') return deleted;
+  const replacement = uniqueTextRange(sourceText, symbolRange, edit.replacementText, 'replacement-text');
+  if (replacement.status === 'matched') return replacement;
+  const relative = relativeAnchorRange(edit, symbolRange);
+  return {
+    ...relative,
+    conflictReasonCodes: [deleted.reasonCode, replacement.reasonCode].filter(Boolean)
+  };
+}
+
+function uniqueTextRange(sourceText, symbolRange, needle, label) {
+  if (typeof needle !== 'string' || needle.length === 0) {
+    return { status: 'missing', reasonCode: `current-symbol-explicit-source-replacement-${label}-missing` };
+  }
+  const symbolText = sourceText.slice(symbolRange.start, symbolRange.end);
+  const matches = [];
+  for (let index = symbolText.indexOf(needle); index >= 0; index = symbolText.indexOf(needle, index + 1)) {
+    const start = symbolRange.start + index;
+    if (isCodeOffset(sourceText, start)) matches.push(start);
+  }
+  if (matches.length !== 1) {
+    return { status: matches.length ? 'ambiguous' : 'missing', reasonCode: `current-symbol-explicit-source-replacement-${label}-${matches.length ? 'ambiguous' : 'missing'}` };
+  }
+  const first = matches[0] - symbolRange.start;
+  return {
+    status: 'matched',
+    range: { start: symbolRange.start + first, end: symbolRange.start + first + needle.length },
+    reasonCode: `current-symbol-explicit-source-replacement-${label}`
+  };
+}
+
+function isCodeOffset(sourceText, offset) {
+  let state = 'code';
+  for (let index = 0; index < offset; index += 1) {
+    const char = sourceText[index];
+    const next = sourceText[index + 1];
+    if (state === 'line-comment') {
+      if (char === '\n' || char === '\r') state = 'code';
+      continue;
+    }
+    if (state === 'block-comment') {
+      if (char === '*' && next === '/') {
+        index += 1;
+        state = 'code';
+      }
+      continue;
+    }
+    if (state === 'single' || state === 'double' || state === 'template') {
+      if (char === '\\') {
+        index += 1;
+        continue;
+      }
+      if ((state === 'single' && char === "'") || (state === 'double' && char === '"') || (state === 'template' && char === '`')) state = 'code';
+      continue;
+    }
+    if (char === '/' && next === '/') {
+      index += 1;
+      state = 'line-comment';
+    } else if (char === '#') {
+      state = 'line-comment';
+    } else if (char === '/' && next === '*') {
+      index += 1;
+      state = 'block-comment';
+    } else if (char === "'") state = 'single';
+    else if (char === '"') state = 'double';
+    else if (char === '`') state = 'template';
+  }
+  return state === 'code';
+}
+
+function relativeAnchorRange(edit, symbolRange) {
+  if (!Number.isFinite(edit.headAnchorStart) || !Number.isFinite(edit.headAnchorEnd)) return undefined;
+  if (!Number.isFinite(edit.headStart) || !Number.isFinite(edit.headEnd)) return undefined;
+  const offset = edit.headStart - edit.headAnchorStart;
+  const length = edit.headEnd - edit.headStart;
+  if (offset < 0 || length < 0) return undefined;
+  const range = { start: symbolRange.start + offset, end: symbolRange.start + offset + length };
+  if (range.start < symbolRange.start || range.end > symbolRange.end) return undefined;
+  return { range, reasonCode: 'current-symbol-explicit-source-replacement-relative-offset' };
+}

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

@@ -226,6 +226,10 @@ function semanticEditOperationKind(region) {
   if (kind === 'import') return `${prefix}Import`;
   if (kind === 'type') return `${prefix}TypeDeclaration`;
   if (kind === 'property') return `${prefix}Property`;
+  if (kind === 'call') return `${prefix}Callsite`;
+  if (kind === 'controlFlow') return `${prefix}ControlFlow`;
+  if (kind === 'effect') return `${prefix}Effect`;
+  if (kind === 'mutation') return `${prefix}Mutation`;
   return `${prefix}Region`;
 }
 

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

@@ -1,5 +1,7 @@
 import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
 
+const nestedBodyCoveredKinds = new Set(['export', 'call', 'controlFlow', 'effect', 'mutation']);
+
 export function projectionCoveredContainerOperationIds(operations, workerSourceText) {
   if (typeof workerSourceText !== 'string') return new Set();
   const result = new Set();
@@ -7,6 +9,9 @@ export function projectionCoveredContainerOperationIds(operations, workerSourceT
     if (!isProjectionCoverableContainer(operation)) continue;
     if (workerContainerCoveredByInsertedChildren(operation, operations, workerSourceText)) result.add(operation.id);
   }
+  for (const operation of operations ?? []) {
+    if (operationCoveredByBody(operation, operations, workerSourceText)) result.add(operation.id);
+  }
   return result;
 }
 
@@ -111,6 +116,28 @@ function workerContainerCoveredByInsertedChildren(container, operations, workerS
   return hashSemanticValue(stripped) === container.hashes.baseTextHash;
 }
 
+function operationCoveredByBody(operation, operations, workerSourceText) {
+  const kind = operation.anchor?.regionKind;
+  if (!nestedBodyCoveredKinds.has(kind)) return false;
+  if (!['added', 'modified'].includes(operation.changeKind)) return false;
+  const range = spanOffsets(workerSourceText, operation.spans?.worker);
+  if (!range) return false;
+  return (operations ?? []).some((candidate) => (
+    candidate.id !== operation.id
+    && ['portable', 'already-applied'].includes(candidate.status)
+    && candidate.anchor?.regionKind === 'body'
+    && (kind !== 'export' || candidate.anchor?.symbolName === operation.anchor?.symbolName)
+    && sameOperationSourcePath(candidate, operation)
+    && containedRange(range, spanOffsets(workerSourceText, candidate.spans?.worker))
+  ));
+}
+
+function sameOperationSourcePath(left, right) {
+  const leftPath = left.anchor?.sourcePath ?? left.insertion?.sourcePath;
+  const rightPath = right.anchor?.sourcePath ?? right.insertion?.sourcePath;
+  return !leftPath || !rightPath || leftPath === rightPath;
+}
+
 function containedRange(inner, outer) {
   return Boolean(inner && outer && outer.start <= inner.start && inner.end <= outer.end);
 }
@@ -168,6 +195,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 +203,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/semanticIndexFromNativeDeclarations.js

@@ -35,6 +35,7 @@ export function semanticIndexFromNativeDeclarations(declarations, input, options
       signatureHash: hashSemanticValue([input.language, declaration.nativeNode.kind, declaration.name, declaration.nativeNode.fields ?? {}]),
       definitionSpan: declaration.nativeNode.span,
       metadata: {
+        ...declaration.nativeNode.metadata,
         ownershipRegionId: ownershipRegion.id,
         ownershipRegionKey: ownershipRegion.key,
         ownershipRegionKind: ownershipRegion.regionKind