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

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

@@ -3,6 +3,7 @@ import { idFragment, normalizeNativeLanguageId, uniqueStrings } from '../../nati
 import { createSemanticImportSidecar } from './createSemanticImportSidecar.js';
 import { mapDiffSymbols } from './mapDiffSymbols.js';
 import { normalizeNativeDiffImport } from './normalizeNativeDiffImport.js';
+import { afterLineOffset, bodyContentRange, spanOffsets } from './semanticEditSourceRanges.js';
 
 export function replaySemanticEditProjection(input = {}) {
   const projection = input.projection ?? input.semanticEditProjection;
@@ -17,7 +18,7 @@ export function replaySemanticEditProjection(input = {}) {
     ? currentSymbolIndex({ currentSourceText, sourcePath, language, parser: input.parser })
     : [];
   const edits = projection.status === 'projected' && typeof currentSourceText === 'string'
-    ? (projection.edits ?? []).map((edit) => replayProjectionEdit(edit, { currentSourceText, currentSymbols }))
+    ? (projection.edits ?? []).map((edit, index) => replayProjectionEdit(projectionEditWithOrder(edit, index), { currentSourceText, currentSymbols }))
     : [];
   const status = replayStatus(reasonCodes, edits, projection);
   const outputSourceText = replayOutputSource(status, currentSourceText, edits);
@@ -54,14 +55,23 @@ function replayProjectionEdit(edit, context) {
   if (edit.status === 'already-applied') return replayEditRecord(edit, 'already-applied', undefined, ['projection-edit-already-applied']);
   if (typeof edit.replacementText !== 'string') return replayEditRecord(edit, 'blocked', undefined, ['missing-replacement-text']);
   if (edit.editKind === 'insert') return replayInsertionEdit(edit, context);
-  const offset = checkRange(edit, { start: edit.headStart, end: edit.headEnd }, context.currentSourceText, 'head-offset');
-  if (offset) return replayEditRecord(edit, offset.status, offset.range, [offset.reason]);
+  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 = spanOffsets(context.currentSourceText, symbol?.sourceSpan);
-  const anchored = checkRange(edit, spanRange, context.currentSourceText, 'current-symbol-anchor');
+  const spanRange = currentSymbolEditRange(edit, spanOffsets(context.currentSourceText, symbol?.sourceSpan), context.currentSourceText);
+  if (symbol && spanRange && !sameRange(headRange, spanRange)) {
+    const moved = checkRange(edit, spanRange, context.currentSourceText, currentSymbolRangeLabel(edit));
+    if (moved) return replayEditRecord(edit, moved.status, moved.range, [moved.reason, 'offset-reanchored-by-symbol']);
+    if (edit.editKind === 'delete' && offset && rangesOverlap(headRange, spanRange)) {
+      return replayEditRecord(edit, offset.status, offset.range, [offset.reason]);
+    }
+    return replayEditRecord(edit, 'conflict', spanRange, [`${currentSymbolRangeLabel(edit)}-content-mismatch`]);
+  }
+  if (offset) return replayEditRecord(edit, offset.status, offset.range, [offset.reason]);
+  const anchored = checkRange(edit, spanRange, context.currentSourceText, currentSymbolRangeLabel(edit));
   if (anchored) return replayEditRecord(edit, anchored.status, anchored.range, [anchored.reason, 'offset-reanchored-by-symbol']);
   return replayEditRecord(edit, symbol ? 'conflict' : 'stale', spanRange, [
-    symbol ? 'current-symbol-anchor-content-mismatch' : 'current-symbol-anchor-missing'
+    symbol ? `${currentSymbolRangeLabel(edit)}-content-mismatch` : 'current-symbol-anchor-missing'
   ]);
 }
 
@@ -70,6 +80,9 @@ function replayInsertionEdit(edit, context) {
   const insertedRange = spanOffsets(context.currentSourceText, inserted?.sourceSpan);
   const already = checkRange(edit, insertedRange, context.currentSourceText, 'current-inserted-symbol');
   if (already?.status === 'already-applied') return replayEditRecord(edit, 'already-applied', already.range, [already.reason]);
+  if (inserted && insertedRange) {
+    return replayEditRecord(edit, 'conflict', insertedRange, ['current-inserted-symbol-content-mismatch']);
+  }
   const anchor = findInsertionAnchorSymbol(edit, context.currentSymbols);
   const range = insertionRange(edit, anchor, context.currentSourceText);
   if (range) return replayEditRecord(edit, 'applied', range, [anchor ? 'current-insertion-anchor' : `current-${edit.insertionMode}`]);
@@ -97,6 +110,8 @@ function replayEditRecord(edit, status, range, reasonCodes) {
     sourceIdentityHash: edit.sourceIdentityHash,
     editContentHash: edit.editContentHash,
     editKind: edit.editKind,
+    editOrder: edit.editOrder,
+    sourceRangeKind: edit.sourceRangeKind,
     sourcePath: edit.targetSourcePath ?? edit.sourcePath,
     symbolName: edit.targetSymbolName ?? edit.symbolName,
     symbolKind: edit.targetSymbolKind ?? edit.symbolKind,
@@ -143,12 +158,21 @@ function insertionRange(edit, anchor, sourceText) {
   if (!anchorRange) return undefined;
   if (edit.insertionMode === 'before') return { start: anchorRange.start, end: anchorRange.start };
   if (edit.insertionMode === 'after') {
-    const offset = sourceText[anchorRange.end] === '\n' ? anchorRange.end + 1 : anchorRange.end;
-    return { start: offset, end: offset };
+    return { start: afterLineOffset(sourceText, anchorRange.end), end: afterLineOffset(sourceText, anchorRange.end) };
   }
   return undefined;
 }
 
+function currentSymbolEditRange(edit, symbolRange, sourceText) {
+  if (!symbolRange) return undefined;
+  if (edit.sourceRangeKind === 'body-content') return bodyContentRange(sourceText, symbolRange);
+  return symbolRange;
+}
+
+function currentSymbolRangeLabel(edit) {
+  return edit.sourceRangeKind === 'body-content' ? 'current-symbol-body' : 'current-symbol-anchor';
+}
+
 function replayStatus(reasonCodes, edits, projection) {
   if (reasonCodes.some((reason) => reason !== 'current-source-hash-mismatch')) return 'blocked';
   if (!edits.length && !(projection.edits ?? []).length) return 'evidence-only';
@@ -189,10 +213,25 @@ function replayOutputSource(status, sourceText, edits) {
   if (status === 'already-applied') return sourceText;
   if (status !== 'accepted-clean') return undefined;
   return edits.filter((edit) => edit.status === 'applied')
-    .sort((left, right) => right.start - left.start)
+    .sort(replaySourceEditSort)
     .reduce((text, edit) => text.slice(0, edit.start) + editReplacement(edit, edits) + text.slice(edit.end), sourceText);
 }
 
+function replaySourceEditSort(left, right) {
+  return right.start - left.start || right.end - left.end || (right.editOrder ?? 0) - (left.editOrder ?? 0);
+}
+
+function projectionEditWithOrder(edit, index) {
+  return {
+    ...edit,
+    editOrder: typeof edit.editOrder === 'number'
+      ? edit.editOrder
+      : typeof edit.order === 'number'
+        ? edit.order
+        : index
+  };
+}
+
 function editReplacement(edit, edits) {
   return edits.find((candidate) => candidate.operationId === edit.operationId)?.replacementText ?? '';
 }
@@ -205,19 +244,12 @@ function baseReasonCodes(projection, currentSourceText) {
   ]);
 }
 
-function spanOffsets(sourceText, span) {
-  if (typeof sourceText !== 'string' || !span) return undefined;
-  if (typeof span.start === 'number' && typeof span.end === 'number' && span.end >= span.start) return { start: span.start, end: span.end };
-  if (typeof span.startLine !== 'number') return undefined;
-  const starts = [0];
-  for (let index = 0; index < sourceText.length; index += 1) if (sourceText[index] === '\n') starts.push(index + 1);
-  const startLine = Math.max(1, span.startLine);
-  const endLine = Math.max(startLine, typeof span.endLine === 'number' ? span.endLine : startLine);
-  const lineStart = starts[startLine - 1];
-  const endLineStart = starts[endLine - 1];
-  if (lineStart === undefined || endLineStart === undefined) return undefined;
-  const lineEnd = starts[endLine] === undefined ? sourceText.length : starts[endLine] - 1;
-  return { start: lineStart + Math.max(0, (span.startColumn ?? 1) - 1), end: endLineStart + (span.endColumn === undefined ? lineEnd - endLineStart : Math.max(0, span.endColumn - 1)) };
+function sameRange(left, right) {
+  return left?.start === right?.start && left?.end === right?.end;
+}
+
+function rangesOverlap(left, right) {
+  return Boolean(left && right && left.start < right.end && right.start < left.end);
 }
 
 function isJavaScriptLike(language) { return language === 'javascript' || language === 'typescript'; }

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

@@ -14,16 +14,20 @@ export function createSemanticEditBundleAdmission(input = {}, options = {}) {
   const scripts = array(input.semanticEditScripts ?? input.scripts ?? input.semanticEditScript);
   const projections = array(input.semanticEditProjections ?? input.projections ?? input.semanticEditProjection);
   const replays = array(input.semanticEditReplays ?? input.replays ?? input.semanticEditReplay);
-  const summary = summarizeSemanticEditBundle(scripts, projections, replays);
-  const status = input.status ?? options.status ?? semanticEditBundleStatus(summary);
+  const evidence = evidenceRecords(input, options);
+  const summary = summarizeSemanticEditBundle(scripts, projections, replays, evidence);
+  const computedStatus = semanticEditBundleStatus(summary);
+  const status = safeStatus(input.status ?? options.status, computedStatus, summary);
   const readiness = normalizeSemanticMergeReadiness(input.readiness ?? options.readiness ?? readinessForStatus(status))
     ?? input.readiness ?? options.readiness ?? readinessForStatus(status);
+  const positiveAutoApplyCandidate = status === 'ready' && hasPositiveAutoMergeProof(summary);
+  const computedReviewRequired = !['ready', 'already-applied', 'none'].includes(status) || (status === 'ready' && !positiveAutoApplyCandidate);
   return compactRecord({
     status,
-    action: input.action ?? options.action ?? actionForStatus(status),
+    action: safeAction(input.action ?? options.action, status, positiveAutoApplyCandidate),
     readiness,
-    reviewRequired: input.reviewRequired ?? !['ready', 'already-applied', 'none'].includes(status),
-    autoApplyCandidate: input.autoApplyCandidate ?? status === 'ready',
+    reviewRequired: input.reviewRequired === true || computedReviewRequired,
+    autoApplyCandidate: input.autoApplyCandidate === false ? false : positiveAutoApplyCandidate,
     autoMergeClaim: false,
     semanticEquivalenceClaim: false,
     reasonCodes: uniqueStrings([
@@ -31,7 +35,7 @@ export function createSemanticEditBundleAdmission(input = {}, options = {}) {
       ...strings(options.reasonCodes),
       ...summary.reasonCodes,
       ...derivedReasonCodes(summary, status)
-    ]),
+    ].filter(Boolean)),
     sourcePaths: summary.sourcePaths,
     scriptIds: summary.scriptIds,
     projectionIds: summary.projectionIds,
@@ -41,7 +45,7 @@ export function createSemanticEditBundleAdmission(input = {}, options = {}) {
   });
 }
 
-function summarizeSemanticEditBundle(scripts, projections, replays) {
+function summarizeSemanticEditBundle(scripts, projections, replays, evidence) {
   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);
@@ -49,11 +53,14 @@ function summarizeSemanticEditBundle(scripts, projections, replays) {
   const projectionStatuses = uniqueStrings(strings(projectionStatusEntries));
   const replayStatuses = uniqueStrings(strings(replayStatusEntries));
   const replayActions = uniqueStrings(strings(replays.map((replay) => replay.admission?.action)));
+  const evidenceSummary = summarizeEvidence(evidence);
   return {
     scripts: scripts.length,
     projections: projections.length,
     replays: replays.length,
     files: sourcePaths(scripts, projections, replays).length,
+    portableScripts: scripts.filter((script) => script.admission?.status === 'auto-merge-candidate').length,
+    portableProjections: projections.filter((projection) => projection.status === 'projected' && projection.admission?.status === 'auto-merge-candidate').length,
     acceptedClean: replays.filter((replay) => replay.status === 'accepted-clean').length,
     alreadyApplied: replays.filter((replay) => replay.status === 'already-applied').length,
     conflicts: countStatuses(scriptStatusEntries, replayStatusEntries, ['conflict']),
@@ -70,30 +77,43 @@ function summarizeSemanticEditBundle(scripts, projections, replays) {
     scriptIds: uniqueStrings(scripts.map((script) => script.id)),
     projectionIds: uniqueStrings(projections.map((projection) => projection.id)),
     replayIds: uniqueStrings(replays.map((replay) => replay.id)),
+    evidenceIds: evidenceSummary.evidenceIds,
+    passedTestEvidence: evidenceSummary.passed,
+    failedTestEvidence: evidenceSummary.failed,
+    conflictEvidence: evidenceSummary.conflict,
+    staleEvidence: evidenceSummary.stale,
     reasonCodes: uniqueStrings([
       ...scripts.flatMap((script) => strings(script.admission?.reasonCodes)),
       ...projections.flatMap((projection) => strings(projection.admission?.reasonCodes)),
-      ...replays.flatMap((replay) => strings(replay.admission?.reasonCodes))
+      ...replays.flatMap((replay) => strings(replay.admission?.reasonCodes)),
+      ...evidenceSummary.reasonCodes
     ])
   };
 }
 
 function semanticEditBundleStatus(summary) {
   const total = summary.scripts + summary.projections + summary.replays;
+  if (summary.blocked || summary.projectionBlocked || summary.failedTestEvidence) return 'blocked';
+  if (summary.conflicts || summary.conflictEvidence) return 'conflict';
+  if (summary.stale || summary.staleEvidence) return 'stale';
   if (total === 0) return 'none';
-  if (summary.blocked || summary.projectionBlocked) return 'blocked';
-  if (summary.conflicts) return 'conflict';
-  if (summary.stale) return 'stale';
   if (!summary.replays || summary.needsReview) return 'needs-review';
   if (summary.acceptedClean === 0 && summary.alreadyApplied === summary.replays) return 'already-applied';
-  return summary.acceptedClean + summary.alreadyApplied === summary.replays ? 'ready' : 'needs-review';
+  return hasPositiveAutoMergeProof(summary) ? 'ready' : 'needs-review';
 }
 
 function derivedReasonCodes(summary, status) {
   return [
     summary.scripts && !summary.projections ? 'semantic-edit-projection-missing' : undefined,
     (summary.scripts || summary.projections) && !summary.replays ? 'semantic-edit-replay-missing' : undefined,
+    summary.scripts && summary.portableScripts !== summary.scripts ? 'semantic-edit-script-not-portable' : undefined,
+    summary.projections && summary.portableProjections !== summary.projections ? 'semantic-edit-projection-not-portable' : undefined,
+    summary.acceptedClean && !summary.passedTestEvidence ? 'semantic-edit-tests-passed-evidence-missing' : undefined,
+    summary.failedTestEvidence ? 'semantic-edit-tests-failed' : undefined,
+    summary.conflictEvidence ? 'semantic-edit-conflict-evidence' : undefined,
+    summary.staleEvidence ? 'semantic-edit-stale-evidence' : undefined,
     status === 'ready' ? 'semantic-edit-replay-accepted-clean' : undefined,
+    status === 'ready' ? 'semantic-edit-positive-auto-merge-proof' : undefined,
     status === 'already-applied' ? 'semantic-edit-replay-already-applied' : undefined,
     status === 'blocked' ? 'semantic-edit-blocked' : undefined,
     status === 'conflict' ? 'semantic-edit-conflict' : undefined,
@@ -101,6 +121,19 @@ function derivedReasonCodes(summary, status) {
   ];
 }
 
+function hasPositiveAutoMergeProof(summary) {
+  return summary.acceptedClean > 0 &&
+    summary.acceptedClean + summary.alreadyApplied === summary.replays &&
+    summary.scripts > 0 &&
+    summary.projections > 0 &&
+    summary.portableScripts === summary.scripts &&
+    summary.portableProjections === summary.projections &&
+    summary.passedTestEvidence > 0 &&
+    summary.failedTestEvidence === 0 &&
+    summary.conflictEvidence === 0 &&
+    summary.staleEvidence === 0;
+}
+
 function readinessForStatus(status) {
   if (['ready', 'already-applied'].includes(status)) return 'ready';
   if (['blocked', 'conflict'].includes(status)) return 'blocked';
@@ -116,6 +149,20 @@ function actionForStatus(status) {
   return 'review';
 }
 
+function safeStatus(requested, computed, summary) {
+  if (!requested) return computed;
+  if (requested === 'ready' && !hasPositiveAutoMergeProof(summary)) return computed;
+  if (requested === 'already-applied' && computed !== 'already-applied') return computed;
+  if (['blocked', 'conflict', 'stale'].includes(requested)) return requested;
+  return computed;
+}
+
+function safeAction(requested, status, positiveAutoApplyCandidate) {
+  if (requested === 'admit' && !positiveAutoApplyCandidate) return actionForStatus(status);
+  if (requested === 'skip' && status !== 'already-applied') return actionForStatus(status);
+  return requested ?? actionForStatus(status);
+}
+
 function sourcePaths(scripts, projections, replays) {
   return uniqueStrings(strings([
     ...scripts.map((script) => script.sourcePath),
@@ -132,6 +179,42 @@ function countStatuses(...args) {
   return statuses.filter((status) => needles.has(status)).length;
 }
 
+function evidenceRecords(...sources) {
+  return sources.flatMap((source) => [
+    ...array(source?.evidence),
+    ...array(source?.testEvidence),
+    ...array(source?.testResults),
+    ...array(source?.gateEvidence),
+    ...array(source?.proofEvidence)
+  ]).filter(Boolean);
+}
+
+function summarizeEvidence(evidence) {
+  const testLike = evidence.filter(isAutoMergeTestEvidence);
+  const conflict = evidence.filter((record) => evidenceStatus(record, ['conflict', 'conflicted']) || record?.metadata?.conflict === true || strings(record?.reasonCodes ?? record?.reasons).some((reason) => reason.toLowerCase().includes('conflict')));
+  const stale = evidence.filter((record) => evidenceStatus(record, ['stale']) || record?.metadata?.stale === true || strings(record?.reasonCodes ?? record?.reasons).some((reason) => reason.toLowerCase().includes('stale')));
+  const failed = testLike.filter((record) => evidenceStatus(record, ['failed', 'failure', 'error', 'blocked', 'rejected']));
+  const passed = testLike.filter((record) => evidenceStatus(record, ['passed', 'ok', 'success', 'succeeded', 'accepted', 'verified']));
+  return {
+    evidenceIds: uniqueStrings(evidence.map((record) => record.id)),
+    passed: passed.length,
+    failed: failed.length,
+    conflict: conflict.length,
+    stale: stale.length,
+    reasonCodes: uniqueStrings(evidence.flatMap((record) => strings(record.reasonCodes ?? record.reasons)))
+  };
+}
+
+function isAutoMergeTestEvidence(record) {
+  const kind = String(record?.kind ?? record?.type ?? '').toLowerCase();
+  return ['test', 'tests', 'proof', 'gate', 'verification', 'check'].includes(kind);
+}
+
+function evidenceStatus(record, statuses) {
+  const status = String(record?.status ?? record?.outcome ?? '').toLowerCase();
+  return statuses.includes(status);
+}
+
 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/semanticEditBundleIndex.js

@@ -15,16 +15,16 @@ 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)]),
-    semanticEditReplayCurrentHashes: uniqueStrings([...strings(source.semanticEditReplayCurrentHashes), ...strings(index.semanticEditReplayCurrentHashes), ...replays.map((replay) => replay.currentHash)]),
-    semanticEditReplayOutputHashes: uniqueStrings([...strings(source.semanticEditReplayOutputHashes), ...strings(index.semanticEditReplayOutputHashes), ...replays.map((replay) => replay.outputHash)]),
-    semanticEditKeys: uniqueStrings([...strings(source.semanticEditKeys), ...strings(index.semanticEditKeys), ...operations.map((operation) => operation.semanticKey), ...edits.map((edit) => edit.semanticKey), ...replayEdits.map((edit) => edit.semanticKey)]),
-    semanticIdentityHashes: uniqueStrings([...strings(source.semanticIdentityHashes), ...strings(index.semanticIdentityHashes), ...operations.map((operation) => operation.semanticIdentityHash), ...edits.map((edit) => edit.semanticIdentityHash), ...replayEdits.map((edit) => edit.semanticIdentityHash)]),
-    sourceIdentityHashes: uniqueStrings([...strings(source.sourceIdentityHashes), ...strings(index.sourceIdentityHashes), ...operations.map((operation) => operation.sourceIdentityHash), ...edits.map((edit) => edit.sourceIdentityHash), ...replayEdits.map((edit) => edit.sourceIdentityHash)]),
-    operationContentHashes: uniqueStrings([...strings(source.operationContentHashes), ...strings(index.operationContentHashes), ...operations.map((operation) => operation.operationContentHash), ...edits.map((edit) => edit.operationContentHash)]),
-    editContentHashes: uniqueStrings([...strings(source.editContentHashes), ...strings(index.editContentHashes), ...edits.map((edit) => edit.editContentHash), ...replayEdits.map((edit) => edit.editContentHash)]),
-    anchorKeys: uniqueStrings([...operations.map((operation) => operation.anchor?.key), ...edits.map((edit) => edit.anchorKey)]),
-    conflictKeys: uniqueStrings([...operations.map((operation) => operation.anchor?.conflictKey), ...edits.map((edit) => edit.conflictKey)]),
-    projectedSourcePaths: uniqueStrings([...projections.map((projection) => projection.sourcePath), ...edits.flatMap((edit) => [edit.sourcePath, edit.targetSourcePath]), ...replays.map((replay) => replay.sourcePath), ...replayEdits.map((edit) => edit.sourcePath)])
+    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)]),
+    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)]),
+    operationContentHashes: uniqueStrings([...strings(source.operationContentHashes), ...strings(index.operationContentHashes), ...strings(summary.operationContentHashes), ...operations.map((operation) => operation.operationContentHash), ...edits.map((edit) => edit.operationContentHash), ...replayEdits.map((edit) => edit.operationContentHash)]),
+    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)])
   };
 }
 
@@ -36,9 +36,15 @@ export function semanticEditSummary(index) {
     replayIds: index.semanticEditReplayIds,
     replayStatuses: index.semanticEditReplayStatuses,
     replayActions: index.semanticEditReplayActions,
+    replayCurrentHashes: index.semanticEditReplayCurrentHashes,
+    replayOutputHashes: index.semanticEditReplayOutputHashes,
     semanticEditKeys: index.semanticEditKeys,
+    semanticIdentityHashes: index.semanticIdentityHashes,
+    sourceIdentityHashes: index.sourceIdentityHashes,
     operationContentHashes: index.operationContentHashes,
     editContentHashes: index.editContentHashes,
+    anchorKeys: index.anchorKeys,
+    conflictKeys: index.conflictKeys,
     projectedSourcePaths: index.projectedSourcePaths,
     replayEditCount: index.semanticEditReplayEditCount
   });

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

@@ -0,0 +1,204 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+
+export function projectionCoveredContainerOperationIds(operations, workerSourceText) {
+  if (typeof workerSourceText !== 'string') return new Set();
+  const result = new Set();
+  for (const operation of operations ?? []) {
+    if (!isProjectionCoverableContainer(operation)) continue;
+    if (workerContainerCoveredByInsertedChildren(operation, operations, workerSourceText)) result.add(operation.id);
+  }
+  return result;
+}
+
+export function spanOffsets(sourceText, span) {
+  if (typeof sourceText !== 'string' || !span) return undefined;
+  if (typeof span.start === 'number' && typeof span.end === 'number' && span.end >= span.start) {
+    return { start: span.start, end: span.end };
+  }
+  if (typeof span.startLine !== 'number') return undefined;
+  const lineStarts = [0];
+  for (let index = 0; index < sourceText.length; index += 1) if (sourceText[index] === '\n') lineStarts.push(index + 1);
+  const startLine = Math.max(1, span.startLine);
+  const endLine = Math.max(startLine, typeof span.endLine === 'number' ? span.endLine : startLine);
+  const start = lineStarts[startLine - 1];
+  const endLineStart = lineStarts[endLine - 1];
+  if (start === undefined || endLineStart === undefined) return undefined;
+  const startColumn = Math.max(1, span.startColumn ?? 1) - 1;
+  const lineEnd = lineStarts[endLine] === undefined ? sourceText.length : lineStarts[endLine] - 1;
+  const endColumn = span.endColumn === undefined ? lineEnd - endLineStart : Math.max(1, span.endColumn) - 1;
+  return { start: start + startColumn, end: endLineStart + endColumn };
+}
+
+export function scopedBodyReplacement(operation, headSourceText, workerSourceText, headOffsets, workerOffsets) {
+  if (!isBodyReplacement(operation)) return undefined;
+  const head = bodyContentRange(headSourceText, headOffsets);
+  const worker = bodyContentRange(workerSourceText, workerOffsets);
+  if (!head || !worker) return undefined;
+  const headPrefix = headSourceText.slice(headOffsets.start, head.start);
+  const workerPrefix = workerSourceText.slice(workerOffsets.start, worker.start);
+  const headSuffix = headSourceText.slice(head.end, headOffsets.end);
+  const workerSuffix = workerSourceText.slice(worker.end, workerOffsets.end);
+  if (headPrefix !== workerPrefix || headSuffix !== workerSuffix) return undefined;
+  return { sourceRangeKind: 'body-content', head, worker };
+}
+
+export function bodyContentRange(sourceText, range) {
+  const pairs = bracePairs(sourceText, range);
+  const close = trailingBodyCloseOffset(sourceText, range);
+  const pair = close === undefined ? undefined : pairs.find((candidate) => candidate.close === close);
+  return pair ? { start: pair.open + 1, end: pair.close } : undefined;
+}
+
+export function insertionOffset(sourceText, insertion) {
+  if (typeof sourceText !== 'string') return { ok: false, reasonCodes: ['missing-head-source-text'] };
+  const mode = insertion?.mode;
+  if (mode === 'file-start') return { ok: true, offset: 0 };
+  if (mode === 'file-end') return { ok: true, offset: sourceText.length };
+  const range = spanOffsets(sourceText, insertion?.headSpan);
+  if (!range) return { ok: false, reasonCodes: ['insertion-anchor-not-resolvable'] };
+  if (mode === 'before') return { ok: true, offset: range.start };
+  if (mode === 'after') return { ok: true, offset: afterLineOffset(sourceText, range.end) };
+  return { ok: false, reasonCodes: ['insertion-mode-unsupported'] };
+}
+
+export function removalRange(sourceText, span) {
+  const range = { ...span };
+  if (range.end < sourceText.length && sourceText[range.end] === '\n') range.end += 1;
+  else if (range.start > 0 && sourceText[range.start - 1] === '\n') range.start -= 1;
+  return range;
+}
+
+export function insertionReplacement(text, sourceText, offset) {
+  let replacement = String(text ?? '');
+  if (offset > 0 && sourceText[offset - 1] !== '\n') replacement = `\n${replacement}`;
+  if (offset < sourceText.length && !replacement.endsWith('\n')) replacement += '\n';
+  if (offset === sourceText.length && sourceText && !sourceText.endsWith('\n')) replacement = `\n${replacement}`;
+  if (offset === sourceText.length && !replacement.endsWith('\n')) replacement += '\n';
+  return replacement;
+}
+
+export function afterLineOffset(sourceText, offset) {
+  return sourceText[offset] === '\n' ? offset + 1 : offset;
+}
+
+function isProjectionCoverableContainer(operation) {
+  if (['portable', 'already-applied', 'covered'].includes(operation.status)) return false;
+  if (operation.changeKind !== 'modified') return false;
+  if (!operation.spans?.worker || !operation.hashes?.baseTextHash) return false;
+  const kind = String(operation.anchor?.regionKind ?? operation.regionKind ?? '');
+  return kind === 'type' || kind === 'config' || kind === 'content' || kind === 'route' || kind === 'property';
+}
+
+function workerContainerCoveredByInsertedChildren(container, operations, workerSourceText) {
+  const containerWorker = spanOffsets(workerSourceText, container.spans?.worker);
+  if (!containerWorker) return false;
+  const childRanges = (operations ?? [])
+    .filter((operation) => operation.id !== container.id)
+    .filter((operation) => operation.changeKind === 'added' || String(operation.kind ?? '').startsWith('add'))
+    .filter((operation) => ['portable', 'already-applied'].includes(operation.status))
+    .map((operation) => spanOffsets(workerSourceText, operation.spans?.worker))
+    .filter((range) => containedRange(range, containerWorker))
+    .map((range) => insertionRemovalRange(workerSourceText, range, containerWorker));
+  if (!childRanges.length) return false;
+  const stripped = childRanges
+    .sort((left, right) => right.start - left.start || right.end - left.end)
+    .reduce((text, range) => text.slice(0, range.start - containerWorker.start) + text.slice(range.end - containerWorker.start), workerSourceText.slice(containerWorker.start, containerWorker.end));
+  return hashSemanticValue(stripped) === container.hashes.baseTextHash;
+}
+
+function containedRange(inner, outer) {
+  return Boolean(inner && outer && outer.start <= inner.start && inner.end <= outer.end);
+}
+
+function insertionRemovalRange(sourceText, span, container) {
+  const range = { ...span };
+  if (range.end < container.end && sourceText[range.end] === '\n') range.end += 1;
+  else if (range.start > container.start && sourceText[range.start - 1] === '\n') range.start -= 1;
+  return range;
+}
+
+function isBodyReplacement(operation) {
+  return operation.changeKind === 'modified' && (operation.kind === 'replaceBody' || operation.anchor?.regionKind === 'body');
+}
+
+function trailingBodyCloseOffset(sourceText, range) {
+  if (typeof sourceText !== 'string' || !range) return undefined;
+  let index = range.end - 1;
+  index = previousCodeOffset(sourceText, index, range.start);
+  if (sourceText[index] === ';' || sourceText[index] === ',') {
+    index -= 1;
+    index = previousCodeOffset(sourceText, index, range.start);
+  }
+  return sourceText[index] === '}' ? index : undefined;
+}
+
+function previousCodeOffset(sourceText, index, minIndex) {
+  let cursor = index;
+  while (cursor >= minIndex) {
+    while (cursor >= minIndex && /\s/.test(sourceText[cursor])) cursor -= 1;
+    const blockStart = sourceText.lastIndexOf('/*', cursor);
+    if (sourceText[cursor] === '/' && sourceText[cursor - 1] === '*' && blockStart >= minIndex) {
+      cursor = blockStart - 1;
+      continue;
+    }
+    const lineStart = Math.max(minIndex, sourceText.lastIndexOf('\n', cursor) + 1);
+    const lineComment = sourceText.lastIndexOf('//', cursor);
+    if (lineComment >= lineStart) {
+      cursor = lineComment - 1;
+      continue;
+    }
+    return cursor;
+  }
+  return cursor;
+}
+
+function bracePairs(sourceText, range) {
+  if (typeof sourceText !== 'string' || !range || range.end <= range.start) return [];
+  const stack = [];
+  const pairs = [];
+  let quote;
+  let escaped = false;
+  let lineComment = false;
+  let blockComment = false;
+  for (let index = range.start; index < range.end; index += 1) {
+    const char = sourceText[index];
+    const next = sourceText[index + 1];
+    if (lineComment) {
+      if (char === '\n' || char === '\r') lineComment = false;
+      continue;
+    }
+    if (blockComment) {
+      if (char === '*' && next === '/') {
+        blockComment = false;
+        index += 1;
+      }
+      continue;
+    }
+    if (quote) {
+      if (escaped) escaped = false;
+      else if (char === '\\') escaped = true;
+      else if (char === quote) quote = undefined;
+      continue;
+    }
+    if (char === '/' && next === '/') {
+      lineComment = true;
+      index += 1;
+      continue;
+    }
+    if (char === '/' && next === '*') {
+      blockComment = true;
+      index += 1;
+      continue;
+    }
+    if (char === '\'' || char === '"' || char === '`') {
+      quote = char;
+      continue;
+    }
+    if (char === '{') stack.push(index);
+    else if (char === '}') {
+      const open = stack.pop();
+      if (open !== undefined) pairs.push({ open, close: index });
+    }
+  }
+  return pairs;
+}