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

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

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/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

@@ -6,6 +6,7 @@ export function projectionEditRecord(edit) {
   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',
@@ -26,9 +27,14 @@ export function projectionEditRecord(edit) {
     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,
@@ -48,6 +54,7 @@ export function projectionEditRecord(edit) {
     replacementBytes: edit.replacement.length,
     deletedTextHash,
     replacementTextHash,
+    deletedText: deletedTextForEdit(edit),
     deletedTextLineEndingStableHash: lineEndingStableTextHash(edit.current),
     replacementTextLineEndingStableHash: lineEndingStableTextHash(edit.replacement),
     anchorDeletedTextHash: edit.anchorDeletedTextHash,
@@ -63,6 +70,28 @@ export function projectionEditRecord(edit) {
   });
 }
 
+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);

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

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

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

@@ -7,18 +7,20 @@ export function createSemanticPatchBundleAdmission(input = {}, context = {}) {
   );
   const evidenceAdmission = autoMergeEvidenceAdmission(context, { transformAdmission, semanticEditAdmission });
   const fallbackReadiness = fallbackAdmissionReadiness(transformAdmission, semanticEditAdmission, evidenceAdmission, context.readiness);
-  const inputReadiness = normalizeSemanticMergeReadiness(input.readiness ?? fallbackReadiness) ?? input.readiness ?? fallbackReadiness;
-  const readiness = hasPositiveApplyAction(transformAdmission, semanticEditAdmission) && evidenceAdmission.action !== 'admit'
+  const requestedReadiness = normalizeSemanticMergeReadiness(input.readiness) ?? input.readiness;
+  const inputReadiness = fallbackReadiness === 'blocked' ? 'blocked' : requestedReadiness ?? fallbackReadiness;
+  const positiveApply = !hasSkipReadyAction(semanticEditAdmission) && hasPositiveApplyAction(transformAdmission, semanticEditAdmission);
+  const readiness = positiveApply && evidenceAdmission.action !== 'admit'
     ? evidenceAdmission.readiness
     : inputReadiness;
   const computedStatus = admissionStatusForReadiness(readiness, transformAdmission, semanticEditAdmission, evidenceAdmission);
-  const status = input.status === 'admitted' && computedStatus !== 'admitted' ? computedStatus : input.status ?? computedStatus;
+  const status = safePatchBundleStatus(input.status, computedStatus);
   const computedAutoApplyCandidate = status === 'admitted' &&
-    hasPositiveApplyAction(transformAdmission, semanticEditAdmission) &&
+    positiveApply &&
     evidenceAdmission.action === 'admit';
   const autoApplyCandidate = input.autoApplyCandidate === true ? computedAutoApplyCandidate : input.autoApplyCandidate ?? computedAutoApplyCandidate;
   const admittedWithoutPositiveProof = status === 'admitted' &&
-    hasPositiveApplyAction(transformAdmission, semanticEditAdmission) &&
+    positiveApply &&
     evidenceAdmission.action !== 'admit';
   return compactRecord({
     status,
@@ -72,10 +74,15 @@ function semanticTransformAdmission(context) {
     transformKeys: strings(index.semanticTransformKeys),
     contentHashes: strings(index.semanticTransformContentHashes),
     projectionIdentityHashes: strings(index.projectionIdentityHashes),
+    baseHashes: strings(index.transformBaseHashes),
+    targetHashes: strings(index.transformTargetHashes),
     sourceLanguages: strings(index.transformSourceLanguages),
     targetLanguages: strings(index.transformTargetLanguages),
     sourcePaths: strings(index.transformSourcePaths),
     targetPaths: strings(index.transformTargetPaths),
+    sourceMapIds: strings(index.transformSourceMapIds),
+    sourceMapLinkIds: strings(index.transformSourceMapLinkIds),
+    sourceMapMappingIds: strings(index.transformSourceMapMappingIds),
     evidenceIds: strings(index.semanticTransformEvidenceIds)
   });
 }
@@ -108,8 +115,12 @@ function autoMergeEvidenceAdmission(context, admissions) {
     ...array(context.source?.semanticPatch?.evidence),
     ...array(context.mergeCandidate?.evidence)
   ]);
-  const positiveApply = hasPositiveApplyAttempt(admissions.transformAdmission, admissions.semanticEditAdmission);
-  if (!positiveApply) return { status: 'none', action: 'none', readiness: 'needs-review', reasonCodes: [], evidenceIds: evidenceIds(evidence) };
+  const skipReady = hasSkipReadyAction(admissions.semanticEditAdmission);
+  const positiveApply = !skipReady &&
+    hasPositiveApplyAttempt(admissions.transformAdmission, admissions.semanticEditAdmission);
+  if (!positiveApply) return skipReady
+    ? skipEvidenceAdmission(evidence)
+    : { status: 'none', action: 'none', readiness: 'needs-review', reasonCodes: [], evidenceIds: evidenceIds(evidence) };
   const summary = summarizeAutoMergeEvidence(evidence);
   const blocked = summary.failed > 0 || summary.conflict > 0;
   const ready = !blocked && summary.stale === 0 && summary.passed > 0;
@@ -127,6 +138,23 @@ function autoMergeEvidenceAdmission(context, admissions) {
   });
 }
 
+function skipEvidenceAdmission(evidence) {
+  const summary = summarizeAutoMergeEvidence(evidence);
+  const blocked = summary.failed > 0 || summary.conflict > 0;
+  const status = blocked ? 'blocked' : summary.stale > 0 ? 'stale' : summary.passed > 0 ? 'ready' : 'none';
+  return compactRecord({
+    status,
+    action: blocked ? 'block' : status === 'stale' ? 'rerun-semantic-import' : status === 'ready' ? 'skip' : 'none',
+    readiness: blocked ? 'blocked' : status === 'ready' ? 'ready' : 'needs-review',
+    reasonCodes: status === 'none' ? [] : autoMergeEvidenceReasonCodes(summary, status),
+    evidenceIds: summary.evidenceIds,
+    passed: summary.passed,
+    failed: summary.failed,
+    conflict: summary.conflict,
+    stale: summary.stale
+  });
+}
+
 function summarizeAutoMergeEvidence(evidence) {
   const testLike = evidence.filter(isAutoMergeTestEvidence);
   const failed = testLike.filter((record) => evidenceStatus(record, ['failed', 'failure', 'error', 'blocked', 'rejected']));
@@ -167,6 +195,12 @@ function admissionStatusForReadiness(readiness, transformAdmission, semanticEdit
   return readiness === 'needs-review' ? 'needs-review' : 'proposed';
 }
 
+function safePatchBundleStatus(requested, computed) {
+  if (computed === 'blocked' && requested !== 'rejected') return 'blocked';
+  if (requested === 'admitted' && computed !== 'admitted') return computed;
+  return requested ?? computed;
+}
+
 function hasAdmissibleReadyAction(transformAdmission, semanticEditAdmission, evidenceAdmission) {
   return hasSkipReadyAction(semanticEditAdmission) ||
     (hasPositiveApplyAction(transformAdmission, semanticEditAdmission) && evidenceAdmission.action === 'admit');

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

@@ -141,11 +141,13 @@ function recordIndex(parts){
     semanticEditReplayIds:editIndex.semanticEditReplayIds,
     semanticEditReplayStatuses:editIndex.semanticEditReplayStatuses,
     semanticEditReplayActions:editIndex.semanticEditReplayActions,
+    semanticEditReplayReasonCodes:editIndex.semanticEditReplayReasonCodes,
     semanticEditAdmissionStatuses:uniqueStrings([editAdmission.status]),
     semanticEditAdmissionActions:uniqueStrings([editAdmission.action]),
     semanticEditAdmissionReadinesses:uniqueStrings([editAdmission.readiness]),
     semanticEditReplayCurrentHashes:editIndex.semanticEditReplayCurrentHashes,
     semanticEditReplayOutputHashes:editIndex.semanticEditReplayOutputHashes,
+    sourceBackprojectionModes:editIndex.sourceBackprojectionModes,
     semanticEditKeys:editIndex.semanticEditKeys,
     semanticIdentityHashes:editIndex.semanticIdentityHashes,
     sourceIdentityHashes:editIndex.sourceIdentityHashes,
@@ -156,12 +158,18 @@ function recordIndex(parts){
     semanticTransformIdentityHashes:semanticTransformIndex.semanticTransformIdentityHashes,
     semanticTransformContentHashes:semanticTransformIndex.semanticTransformContentHashes,
     projectionIdentityHashes:semanticTransformIndex.projectionIdentityHashes,
+    transformBaseHashes:semanticTransformIndex.transformBaseHashes,
+    transformTargetHashes:semanticTransformIndex.transformTargetHashes,
     semanticTransformReadinesses:semanticTransformIndex.semanticTransformReadinesses,
     semanticTransformEvidenceIds:semanticTransformIndex.semanticTransformEvidenceIds,
     transformSourceLanguages:semanticTransformIndex.transformSourceLanguages,
     transformTargetLanguages:semanticTransformIndex.transformTargetLanguages,
     transformSourcePaths:semanticTransformIndex.transformSourcePaths,
     transformTargetPaths:semanticTransformIndex.transformTargetPaths,
+    transformCrossLanguages:semanticTransformIndex.transformCrossLanguages,
+    transformSourceMapIds:semanticTransformIndex.transformSourceMapIds,
+    transformSourceMapLinkIds:semanticTransformIndex.transformSourceMapLinkIds,
+    transformSourceMapMappingIds:semanticTransformIndex.transformSourceMapMappingIds,
     targetPortabilityStatuses:uniqueStrings([parts.targetPortability?.status]),
     targetPortabilityActions:uniqueStrings([parts.targetPortability?.action]),
     targetPortabilityReasonCodes:uniqueStrings(parts.targetPortability?.reasonCodes),
@@ -202,11 +210,13 @@ function matchesRecord(record,query){
     &&matchAny(queryValues(query.semanticEditReplayId,query.semanticEditReplayIds),index.semanticEditReplayIds)
     &&matchAny(queryValues(query.semanticEditReplayStatus,query.semanticEditReplayStatuses),index.semanticEditReplayStatuses)
     &&matchAny(queryValues(query.semanticEditReplayAction,query.semanticEditReplayActions),index.semanticEditReplayActions)
+    &&matchAny(queryValues(query.semanticEditReplayReasonCode,query.semanticEditReplayReasonCodes),index.semanticEditReplayReasonCodes)
     &&matchAny(queryValues(query.semanticEditAdmissionStatus,query.semanticEditAdmissionStatuses),index.semanticEditAdmissionStatuses)
     &&matchAny(queryValues(query.semanticEditAdmissionAction,query.semanticEditAdmissionActions),index.semanticEditAdmissionActions)
     &&matchAny(queryValues(query.semanticEditAdmissionReadiness,query.semanticEditAdmissionReadinesses),index.semanticEditAdmissionReadinesses)
     &&matchAny(queryValues(query.semanticEditReplayCurrentHash,query.semanticEditReplayCurrentHashes),index.semanticEditReplayCurrentHashes)
     &&matchAny(queryValues(query.semanticEditReplayOutputHash,query.semanticEditReplayOutputHashes),index.semanticEditReplayOutputHashes)
+    &&matchAny(queryValues(query.sourceBackprojectionMode,query.sourceBackprojectionModes),index.sourceBackprojectionModes)
     &&matchAny(queryValues(query.semanticEditKey,query.semanticEditKeys),index.semanticEditKeys)
     &&matchAny(queryValues(query.semanticIdentityHash,query.semanticIdentityHashes),index.semanticIdentityHashes)
     &&matchAny(queryValues(query.sourceIdentityHash,query.sourceIdentityHashes),index.sourceIdentityHashes)
@@ -217,12 +227,18 @@ function matchesRecord(record,query){
     &&matchAny(queryValues(query.semanticTransformIdentityHash,query.semanticTransformIdentityHashes),index.semanticTransformIdentityHashes)
     &&matchAny(queryValues(query.semanticTransformContentHash,query.semanticTransformContentHashes),index.semanticTransformContentHashes)
     &&matchAny(queryValues(query.projectionIdentityHash,query.projectionIdentityHashes),index.projectionIdentityHashes)
+    &&matchAny(queryValues(query.transformBaseHash,query.transformBaseHashes),index.transformBaseHashes)
+    &&matchAny(queryValues(query.transformTargetHash,query.transformTargetHashes),index.transformTargetHashes)
     &&matchAny(queryValues(query.semanticTransformReadiness,query.semanticTransformReadinesses),index.semanticTransformReadinesses)
     &&matchAny(queryValues(query.semanticTransformEvidenceId,query.semanticTransformEvidenceIds),index.semanticTransformEvidenceIds)
     &&matchAny(queryValues(query.transformSourceLanguage,query.transformSourceLanguages),index.transformSourceLanguages)
     &&matchAny(queryValues(query.transformTargetLanguage,query.transformTargetLanguages),index.transformTargetLanguages)
     &&matchAny(queryValues(query.transformSourcePath,query.transformSourcePaths),index.transformSourcePaths)
     &&matchAny(queryValues(query.transformTargetPath,query.transformTargetPaths),index.transformTargetPaths)
+    &&matchAny(queryValues(query.transformCrossLanguage,query.transformCrossLanguages),index.transformCrossLanguages)
+    &&matchAny(queryValues(query.transformSourceMapId,query.transformSourceMapIds),index.transformSourceMapIds)
+    &&matchAny(queryValues(query.transformSourceMapLinkId,query.transformSourceMapLinkIds),index.transformSourceMapLinkIds)
+    &&matchAny(queryValues(query.transformSourceMapMappingId,query.transformSourceMapMappingIds),index.transformSourceMapMappingIds)
     &&matchAny(queryValues(query.targetPortabilityStatus,query.targetPortabilityStatuses),index.targetPortabilityStatuses)
     &&matchAny(queryValues(query.targetPortabilityAction,query.targetPortabilityActions),index.targetPortabilityActions)
     &&matchAny(queryValues(query.targetPortabilityReasonCode,query.targetPortabilityReasonCodes),index.targetPortabilityReasonCodes)