@shapeshift-labs/frontier-lang-compiler 0.2.95 → 0.2.97

package/dist/declarations/semantic-edit-script.d.ts

@@ -28,39 +28,32 @@ export interface SemanticEditScriptOperation {
   readonly kind: string;
   readonly changeKind?: string;
   readonly anchor: {
-    readonly key?: string;
-    readonly conflictKey?: string;
-    readonly regionId?: string;
-    readonly regionKind?: string;
-    readonly granularity?: string;
+    readonly key?: string; readonly conflictKey?: string; readonly regionId?: string;
+    readonly regionKind?: string; readonly granularity?: string;
     readonly language?: FrontierSourceLanguage | string;
-    readonly sourcePath?: string;
-    readonly symbolId?: string;
-    readonly symbolName?: string;
-    readonly symbolKind?: string;
+    readonly sourcePath?: string; readonly symbolId?: string; readonly symbolName?: string; readonly symbolKind?: string;
     readonly sourceSpan?: SourceSpan;
   };
+  readonly insertion?: {
+    readonly mode?: 'before' | 'after' | 'file-start' | 'file-end' | string;
+    readonly anchorKey?: string; readonly anchorSymbolId?: string; readonly anchorSymbolName?: string; readonly anchorSymbolKind?: string;
+    readonly baseSpan?: SourceSpan; readonly workerAnchorSpan?: SourceSpan; readonly headSpan?: SourceSpan; readonly sourcePath?: string;
+    readonly insertedSymbolId?: string; readonly insertedSymbolName?: string; readonly insertedSymbolKind?: string;
+    readonly insertedSourceSpan?: SourceSpan; readonly insertedSourcePath?: string;
+    readonly reasonCodes?: readonly string[];
+  };
   readonly semanticKey?: string;
   readonly semanticIdentityHash?: string;
   readonly sourceIdentityHash?: string;
   readonly operationContentHash?: string;
   readonly spans?: {
-    readonly base?: SourceSpan;
-    readonly worker?: SourceSpan;
-    readonly head?: SourceSpan;
+    readonly base?: SourceSpan; readonly worker?: SourceSpan; readonly head?: SourceSpan;
   };
   readonly hashes?: {
-    readonly baseSourceHash?: string;
-    readonly workerSourceHash?: string;
-    readonly headSourceHash?: string;
-    readonly baseSpanHash?: string;
-    readonly workerSpanHash?: string;
-    readonly headSpanHash?: string;
-    readonly baseTextHash?: string;
-    readonly workerTextHash?: string;
-    readonly headTextHash?: string;
-    readonly beforeSignatureHash?: string;
-    readonly afterSignatureHash?: string;
+    readonly baseSourceHash?: string; readonly workerSourceHash?: string; readonly headSourceHash?: string;
+    readonly baseSpanHash?: string; readonly workerSpanHash?: string; readonly headSpanHash?: string;
+    readonly baseTextHash?: string; readonly workerTextHash?: string; readonly headTextHash?: string;
+    readonly beforeSignatureHash?: string; readonly afterSignatureHash?: string;
   };
   readonly status: SemanticEditScriptOperationStatus;
   readonly reanchor?: {
@@ -135,6 +128,7 @@ export interface SemanticEditProjectionEdit {
   readonly operationId?: string;
   readonly status: 'applied' | 'already-applied';
   readonly kind?: string;
+  readonly editKind?: 'replace' | 'insert' | string;
   readonly changeKind?: string;
   readonly anchorKey?: string;
   readonly conflictKey?: string;
@@ -162,6 +156,11 @@ export interface SemanticEditProjectionEdit {
   readonly replacementBytes: number;
   readonly deletedTextHash?: string;
   readonly replacementTextHash?: string;
+  readonly replacementSpanTextHash?: string;
+  readonly insertionMode?: string;
+  readonly insertionAnchorKey?: string;
+  readonly insertionAnchorSymbolName?: string;
+  readonly insertionAnchorSymbolKind?: string;
   readonly replacementText?: string;
 }
 
@@ -206,6 +205,7 @@ export interface SemanticEditReplayEdit {
   readonly semanticIdentityHash?: string;
   readonly sourceIdentityHash?: string;
   readonly editContentHash?: string;
+  readonly editKind?: 'replace' | 'insert' | string;
   readonly sourcePath?: string;
   readonly symbolName?: string;
   readonly symbolKind?: string;

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

@@ -1,6 +1,7 @@
 import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
 import { idFragment, uniqueStrings } from '../../native-import-utils.js';
 import { semanticEditIdentityFields } from './semanticEditIdentityRecords.js';
+import { applySourceEdits, dedupeSourceEdits, validateSourceEdits } from './semanticSourceEditDedupe.js';
 
 export function projectSemanticEditScriptToSource(input = {}) {
   const script = input.script;
@@ -12,13 +13,15 @@ export function projectSemanticEditScriptToSource(input = {}) {
   if (typeof workerSourceText !== 'string') reasonCodes.push('missing-worker-source-text');
   if (typeof headSourceText !== 'string') reasonCodes.push('missing-head-source-text');
   const edits = [];
-  for (const operation of script.operations ?? []) {
-    const edit = sourceEditForOperation(operation, workerSourceText, headSourceText);
+  for (const [index, operation] of (script.operations ?? []).entries()) {
+    const edit = sourceEditForOperation(operation, workerSourceText, headSourceText, index);
     if (edit.ok) edits.push(edit.value);
     else reasonCodes.push(...edit.reasonCodes);
   }
+  const deduped = dedupeSourceEdits(edits);
+  reasonCodes.push(...validateSourceEdits(deduped.edits));
   const blocked = reasonCodes.length > 0;
-  const sourceText = blocked ? undefined : applySourceEdits(headSourceText, edits);
+  const sourceText = blocked ? undefined : applySourceEdits(headSourceText, deduped.edits);
   const core = {
     kind: 'frontier.lang.semanticEditProjection',
     version: 1,
@@ -31,9 +34,9 @@ export function projectSemanticEditScriptToSource(input = {}) {
     workerHash: script.workerHash,
     headHash: script.headHash,
     projectedHash: sourceText === undefined ? undefined : hashSemanticValue(sourceText),
-    appliedOperations: blocked ? [] : edits.map((edit) => edit.operationId),
-    skippedOperations: blocked ? (script.operations ?? []).map((operation) => operation.id) : [],
-    edits: blocked ? [] : edits.map(projectionEditRecord),
+    appliedOperations: blocked ? [] : deduped.edits.map((edit) => edit.operationId),
+    skippedOperations: blocked ? (script.operations ?? []).map((operation) => operation.id) : deduped.skippedOperationIds,
+    edits: blocked ? [] : deduped.edits.map(projectionEditRecord),
     sourceText,
     admission: {
       status: blocked ? 'blocked' : 'auto-merge-candidate',
@@ -45,20 +48,24 @@ export function projectSemanticEditScriptToSource(input = {}) {
       autoMergeClaim: false,
       semanticEquivalenceClaim: false,
       editCount: edits.length,
-      appliedEditCount: edits.filter((edit) => !edit.alreadyApplied).length,
-      alreadyAppliedEditCount: edits.filter((edit) => edit.alreadyApplied).length,
+      appliedEditCount: deduped.edits.filter((edit) => !edit.alreadyApplied).length,
+      alreadyAppliedEditCount: deduped.edits.filter((edit) => edit.alreadyApplied).length,
+      dedupedEditCount: deduped.skippedOperationIds.length,
       ...input.metadata
     })
   };
   return { ...core, hash: hashSemanticValue(core) };
 }
 
-function sourceEditForOperation(operation, workerSourceText, headSourceText) {
+function sourceEditForOperation(operation, workerSourceText, headSourceText, order) {
   const identity = projectionIdentity(operation);
   if (operation.status === 'already-applied') {
-    return { ok: true, value: { ...identity, operationId: operation.id, start: 0, end: 0, replacement: '', current: '', alreadyApplied: true } };
+    return { ok: true, value: { ...identity, operationId: operation.id, order, start: 0, end: 0, replacement: '', current: '', alreadyApplied: true } };
   }
   if (operation.status !== 'portable') return { ok: false, reasonCodes: [`operation-not-portable:${operation.id}`] };
+  if (operation.changeKind === 'added' || String(operation.kind ?? '').startsWith('add')) {
+    return insertionEditForOperation(operation, identity, workerSourceText, headSourceText, order);
+  }
   const workerOffsets = spanOffsets(workerSourceText, operation.spans?.worker);
   const headOffsets = spanOffsets(headSourceText, operation.spans?.head ?? operation.spans?.base ?? operation.anchor?.sourceSpan);
   const reasons = [];
@@ -79,7 +86,9 @@ function sourceEditForOperation(operation, workerSourceText, headSourceText) {
     ok: true,
     value: {
       operationId: operation.id,
+      order,
       ...identity,
+      editKind: 'replace',
       start: headOffsets.start,
       end: headOffsets.end,
       workerStart: workerOffsets.start,
@@ -90,6 +99,37 @@ function sourceEditForOperation(operation, workerSourceText, headSourceText) {
   };
 }
 
+function insertionEditForOperation(operation, identity, workerSourceText, headSourceText, order) {
+  const workerOffsets = spanOffsets(workerSourceText, operation.spans?.worker);
+  const reasons = [];
+  if (!workerOffsets) reasons.push(`worker-span-not-resolvable:${operation.id}`);
+  const insertion = insertionOffset(headSourceText, operation.insertion);
+  if (!insertion.ok) reasons.push(...insertion.reasonCodes.map((reason) => `${reason}:${operation.id}`));
+  if (reasons.length) return { ok: false, reasonCodes: reasons };
+  const spanText = workerSourceText.slice(workerOffsets.start, workerOffsets.end);
+  if (operation.hashes?.workerTextHash && hashSemanticValue(spanText) !== operation.hashes.workerTextHash) {
+    reasons.push(`worker-span-hash-mismatch:${operation.id}`);
+  }
+  if (reasons.length) return { ok: false, reasonCodes: reasons };
+  return {
+    ok: true,
+    value: {
+      operationId: operation.id,
+      order,
+      ...identity,
+      editKind: 'insert',
+      insertion: operation.insertion,
+      start: insertion.offset,
+      end: insertion.offset,
+      workerStart: workerOffsets.start,
+      workerEnd: workerOffsets.end,
+      replacement: insertionReplacement(spanText, headSourceText, insertion.offset),
+      replacementSpanText: spanText,
+      current: ''
+    }
+  };
+}
+
 function projectionIdentity(operation) {
   const identity = semanticEditIdentity(operation);
   return { ...identity, sourcePath: operation.reanchor?.toSourcePath ?? identity.sourcePath };
@@ -103,6 +143,7 @@ function projectionEditRecord(edit) {
     operationId: edit.operationId,
     status: edit.alreadyApplied ? 'already-applied' : 'applied',
     kind: edit.kind,
+    editKind: edit.editKind,
     changeKind: edit.changeKind,
     anchorKey: edit.anchorKey,
     conflictKey: edit.conflictKey,
@@ -133,6 +174,11 @@ function projectionEditRecord(edit) {
     replacementBytes: edit.replacement.length,
     deletedTextHash,
     replacementTextHash,
+    replacementSpanTextHash: hashSemanticValue(edit.replacementSpanText ?? edit.replacement),
+    insertionMode: edit.insertion?.mode,
+    insertionAnchorKey: edit.insertion?.anchorKey,
+    insertionAnchorSymbolName: edit.insertion?.anchorSymbolName,
+    insertionAnchorSymbolKind: edit.insertion?.anchorSymbolKind,
     replacementText: edit.replacement
   });
 }
@@ -162,12 +208,6 @@ function semanticEditIdentity(operation) {
   });
 }
 
-function applySourceEdits(sourceText, edits) {
-  return edits.filter((edit) => !edit.alreadyApplied)
-    .sort((left, right) => right.start - left.start)
-    .reduce((text, edit) => text.slice(0, edit.start) + edit.replacement + text.slice(edit.end), sourceText);
-}
-
 function projectedSourcePath(script, edits) {
   return edits.map((edit) => edit.sourcePath).find(Boolean) ?? script.sourcePath;
 }
@@ -189,6 +229,31 @@ function spanOffsets(sourceText, span) {
   return { start: start + startColumn, end: endLineStart + endColumn };
 }
 
+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'] };
+}
+
+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;
+}
+
+function afterLineOffset(sourceText, offset) {
+  return sourceText[offset] === '\n' ? offset + 1 : offset;
+}
+
 function compactRecord(value) {
   return Object.fromEntries(Object.entries(value ?? {}).filter(([, entry]) => entry !== undefined && (!Array.isArray(entry) || entry.length > 0)));
 }

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

@@ -53,6 +53,7 @@ export function replaySemanticEditProjection(input = {}) {
 function replayProjectionEdit(edit, context) {
   if (edit.status === 'already-applied') return replayEditRecord(edit, 'already-applied', undefined, ['projection-edit-already-applied']);
   if (typeof edit.replacementText !== 'string') return replayEditRecord(edit, 'blocked', undefined, ['missing-replacement-text']);
+  if (edit.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 symbol = findCurrentSymbol(edit, context.currentSymbols);
@@ -64,13 +65,27 @@ function replayProjectionEdit(edit, context) {
   ]);
 }
 
+function replayInsertionEdit(edit, context) {
+  const inserted = findCurrentSymbol(edit, context.currentSymbols);
+  const insertedRange = spanOffsets(context.currentSourceText, inserted?.sourceSpan);
+  const already = checkRange(edit, insertedRange, context.currentSourceText, 'current-inserted-symbol');
+  if (already?.status === 'already-applied') return replayEditRecord(edit, 'already-applied', already.range, [already.reason]);
+  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}`]);
+  return replayEditRecord(edit, anchor ? 'conflict' : 'stale', undefined, [
+    anchor ? 'current-insertion-anchor-unusable' : 'current-insertion-anchor-missing'
+  ]);
+}
+
 function checkRange(edit, range, sourceText, label) {
   if (!range || range.end < range.start) return undefined;
   const current = sourceText.slice(range.start, range.end);
   const currentHash = hashSemanticValue(current);
-  if (edit.deletedTextHash && currentHash === edit.deletedTextHash) return { status: 'applied', range, reason: `${label}-matches-deleted` };
+  if (edit.replacementSpanTextHash && currentHash === edit.replacementSpanTextHash) return { status: 'already-applied', range, reason: `${label}-matches-replacement-span` };
   if (edit.replacementTextHash && currentHash === edit.replacementTextHash) return { status: 'already-applied', range, reason: `${label}-matches-replacement` };
   if (current === edit.replacementText) return { status: 'already-applied', range, reason: `${label}-matches-replacement-text` };
+  if (edit.deletedTextHash && currentHash === edit.deletedTextHash) return { status: 'applied', range, reason: `${label}-matches-deleted` };
   return undefined;
 }
 
@@ -81,6 +96,7 @@ function replayEditRecord(edit, status, range, reasonCodes) {
     semanticIdentityHash: edit.semanticIdentityHash,
     sourceIdentityHash: edit.sourceIdentityHash,
     editContentHash: edit.editContentHash,
+    editKind: edit.editKind,
     sourcePath: edit.targetSourcePath ?? edit.sourcePath,
     symbolName: edit.targetSymbolName ?? edit.symbolName,
     symbolKind: edit.targetSymbolKind ?? edit.symbolKind,
@@ -115,6 +131,24 @@ function findCurrentSymbol(edit, symbols) {
   return symbols.find((symbol) => symbol.name === name && (!kind || symbol.kind === kind));
 }
 
+function findInsertionAnchorSymbol(edit, symbols) {
+  return symbols.find((symbol) => [symbol.ownershipKey, symbol.key, symbol.id].some((key) => key && key === edit.insertionAnchorKey))
+    ?? symbols.find((symbol) => symbol.name === edit.insertionAnchorSymbolName && (!edit.insertionAnchorSymbolKind || symbol.kind === edit.insertionAnchorSymbolKind));
+}
+
+function insertionRange(edit, 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 anchorRange = spanOffsets(sourceText, anchor?.sourceSpan);
+  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 undefined;
+}
+
 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';

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

@@ -0,0 +1,108 @@
+export function semanticEditInsertionAnchor(region, context) {
+  if (region.changeKind !== 'added') return undefined;
+  const workerSymbol = symbolForRegion(context.workerSymbols, region);
+  if (!workerSymbol?.sourceSpan) return fallbackInsertion(region, context, 'worker-symbol-span-missing');
+  const workers = uniqueSymbols(context.workerSymbols)
+    .filter((symbol) => symbol.id !== workerSymbol.id && symbol.key !== workerSymbol.key)
+    .filter((symbol) => hasSymbol(context.baseSymbols, symbol));
+  const before = nearestBefore(workers, workerSymbol);
+  const after = nearestAfter(workers, workerSymbol);
+  const anchor = before
+    ? insertionFromSymbol('after', before, context, 'nearest-previous-base-symbol')
+    : after
+      ? insertionFromSymbol('before', after, context, 'nearest-next-base-symbol')
+      : fallbackInsertion(region, context, 'no-neighbor-base-symbol');
+  return compactRecord({
+    ...anchor,
+    insertedSymbolId: workerSymbol.id,
+    insertedSymbolName: workerSymbol.name,
+    insertedSymbolKind: workerSymbol.kind,
+    insertedSourceSpan: workerSymbol.sourceSpan,
+    insertedSourcePath: workerSymbol.sourcePath
+  });
+}
+
+function insertionFromSymbol(mode, symbol, context, reasonCode) {
+  const headSymbol = symbolForExisting(context.headSymbols, symbol);
+  return compactRecord({
+    mode,
+    anchorKey: symbol.key ?? symbol.ownershipKey ?? symbol.id,
+    anchorSymbolId: symbol.id,
+    anchorSymbolName: symbol.name,
+    anchorSymbolKind: symbol.kind,
+    baseSpan: symbolForExisting(context.baseSymbols, symbol)?.sourceSpan,
+    workerAnchorSpan: symbol.sourceSpan,
+    headSpan: headSymbol?.sourceSpan,
+    sourcePath: headSymbol?.sourcePath ?? symbol.sourcePath,
+    reasonCodes: [headSymbol ? reasonCode : `${reasonCode}:head-anchor-missing`]
+  });
+}
+
+function fallbackInsertion(region, context, reasonCode) {
+  const mode = region.regionKind === 'import' ? 'file-start' : 'file-end';
+  return compactRecord({
+    mode,
+    sourcePath: region.sourcePath ?? context.workerChangeSet.sourcePath,
+    reasonCodes: [reasonCode, `fallback-${mode}`]
+  });
+}
+
+function nearestBefore(symbols, target) {
+  return symbols
+    .filter((symbol) => spanEndLine(symbol.sourceSpan) <= spanStartLine(target.sourceSpan))
+    .sort((left, right) => spanEndLine(right.sourceSpan) - spanEndLine(left.sourceSpan))[0];
+}
+
+function nearestAfter(symbols, target) {
+  return symbols
+    .filter((symbol) => spanStartLine(symbol.sourceSpan) >= spanEndLine(target.sourceSpan))
+    .sort((left, right) => spanStartLine(left.sourceSpan) - spanStartLine(right.sourceSpan))[0];
+}
+
+function symbolForRegion(symbols, region) {
+  return symbolForKeys(symbols, [region.key, region.symbolId, region.symbolName].filter(Boolean));
+}
+
+function symbolForExisting(symbols, symbol) {
+  return symbolForKeys(symbols, symbolKeys(symbol));
+}
+
+function hasSymbol(symbols, symbol) {
+  return Boolean(symbolForExisting(symbols, symbol));
+}
+
+function symbolForKeys(symbols, keys) {
+  for (const key of keys) {
+    const symbol = symbols.get(key);
+    if (symbol) return symbol;
+  }
+  return undefined;
+}
+
+function uniqueSymbols(symbols) {
+  const seen = new Set();
+  const result = [];
+  for (const symbol of symbols.values()) {
+    const key = symbol.id ?? `${symbol.key}:${symbol.name}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    result.push(symbol);
+  }
+  return result;
+}
+
+function symbolKeys(symbol) {
+  return [symbol.key, symbol.ownershipKey, symbol.id, symbol.name].filter(Boolean);
+}
+
+function spanStartLine(span) {
+  return typeof span?.startLine === 'number' ? span.startLine : Number.MAX_SAFE_INTEGER;
+}
+
+function spanEndLine(span) {
+  return typeof span?.endLine === 'number' ? span.endLine : spanStartLine(span);
+}
+
+function compactRecord(value) {
+  return Object.fromEntries(Object.entries(value ?? {}).filter(([, entry]) => entry !== undefined && (!Array.isArray(entry) || entry.length > 0)));
+}

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

@@ -12,6 +12,7 @@ import {
   semanticEditAdmission,
   summarizeSemanticEditOperations
 } from './semanticEditScriptClassification.js';
+import { semanticEditInsertionAnchor } from './semanticEditInsertionAnchors.js';
 import { sourceTextForSpan } from './sourceTextForSpan.js';
 import { semanticEditIdentityFields, semanticEditOperationContentHash } from './semanticEditIdentityRecords.js';
 
@@ -168,10 +169,11 @@ function semanticEditOperation(region, index, context, input) {
   const identityRecord = semanticEditIdentityRecord({ kind, region, anchor });
   const identity = semanticEditIdentityFields(identityRecord);
   return compactRecord({
-    id: `semantic_edit_op_${idFragment(firstString(input.id, anchorKey, index))}`,
+    id: `semantic_edit_op_${idFragment([input.id ?? 'semantic_edit', anchorKey, index].join(':'))}`,
     kind,
     changeKind: region.changeKind,
     anchor,
+    insertion: semanticEditInsertionAnchor(region, context),
     ...identity,
     spans: compactRecord({
       base: baseSymbol?.sourceSpan ?? region.metadata?.changedRegionProjection?.before?.sourceSpan,

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

@@ -0,0 +1,99 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import { uniqueStrings } from '../../native-import-utils.js';
+
+export function applySourceEdits(sourceText, edits) {
+  return edits.filter((edit) => !edit.alreadyApplied)
+    .sort(sourceEditSort)
+    .reduce((text, edit) => text.slice(0, edit.start) + edit.replacement + text.slice(edit.end), sourceText);
+}
+
+export function dedupeSourceEdits(edits) {
+  const exact = dedupeExactInsertions(edits);
+  const covered = removeCoveredContainerReplacements(exact.edits);
+  return {
+    edits: covered.edits,
+    skippedOperationIds: [...exact.skippedOperationIds, ...covered.skippedOperationIds]
+  };
+}
+
+export function validateSourceEdits(edits) {
+  const reasons = [];
+  const ordered = edits.filter((edit) => !edit.alreadyApplied).sort((left, right) => left.start - right.start || left.end - right.end);
+  for (let index = 1; index < ordered.length; index += 1) {
+    const previous = ordered[index - 1];
+    const current = ordered[index];
+    if (editsOverlap(previous, current)) reasons.push(`source-edit-overlap:${previous.operationId}:${current.operationId}`);
+  }
+  return uniqueStrings(reasons);
+}
+
+function dedupeExactInsertions(edits) {
+  const seen = new Map();
+  const result = [];
+  const skippedOperationIds = [];
+  for (const edit of edits) {
+    const key = duplicateEditKey(edit);
+    if (key && seen.has(key)) {
+      skippedOperationIds.push(edit.operationId);
+      continue;
+    }
+    if (key) seen.set(key, edit.operationId);
+    result.push(edit);
+  }
+  return { edits: result, skippedOperationIds };
+}
+
+function removeCoveredContainerReplacements(edits) {
+  const skippedOperationIds = [];
+  const result = [];
+  for (const edit of edits) {
+    if (containerReplacementCoveredByInsertions(edit, edits)) {
+      skippedOperationIds.push(edit.operationId);
+      continue;
+    }
+    result.push(edit);
+  }
+  return { edits: result, skippedOperationIds };
+}
+
+function containerReplacementCoveredByInsertions(edit, edits) {
+  if (edit.editKind !== 'replace' || edit.alreadyApplied) return false;
+  const insertions = containedInsertions(edit, edits);
+  if (!insertions.length) return false;
+  const localEdits = insertions.map((insertion) => ({
+    ...insertion,
+    start: insertion.start - edit.start,
+    end: insertion.end - edit.start
+  }));
+  return applySourceEdits(edit.current, localEdits) === edit.replacement;
+}
+
+function containedInsertions(container, edits) {
+  return edits
+    .filter((edit) => edit.editKind === 'insert' && !edit.alreadyApplied)
+    .filter((edit) => edit.operationId !== container.operationId)
+    .filter((edit) => container.start <= edit.start && edit.end <= container.end)
+    .sort((left, right) => left.start - right.start || (left.order ?? 0) - (right.order ?? 0));
+}
+
+function duplicateEditKey(edit) {
+  if (edit.editKind !== 'insert') return undefined;
+  return [
+    'insert',
+    edit.start,
+    edit.end,
+    edit.insertion?.mode,
+    edit.insertion?.anchorKey,
+    hashSemanticValue(edit.replacementSpanText ?? edit.replacement)
+  ].join(':');
+}
+
+function sourceEditSort(left, right) {
+  return right.start - left.start || right.end - left.end || (right.order ?? 0) - (left.order ?? 0);
+}
+
+function editsOverlap(left, right) {
+  if (left.start === left.end) return right.start < left.start && left.start < right.end;
+  if (right.start === right.end) return left.start < right.start && right.start < left.end;
+  return left.start < right.end && right.start < left.end;
+}

package/dist/native-region-scanner-js.js

@@ -160,11 +160,16 @@ function jsDeclarationWithSourceSpan(input, declaration, lines) {
       startLine,
       endLine,
       startColumn: declaration.span?.startColumn ?? 1,
-      endColumn: declaration.span?.endColumn ?? endLineText.length + 1
+      endColumn: declarationEndColumn(declaration, startLine, endLine, endLineText)
     }
   };
 }
 
+function declarationEndColumn(declaration, startLine, endLine, endLineText) {
+  if (endLine !== startLine) return endLineText.length + 1;
+  return declaration.span?.endColumn ?? endLineText.length + 1;
+}
+
 function jsBalancedDeclarationEndLine(input, lines, startLine) {
   const state = { inBlockComment: false, inTemplateString: false };
   let depth = 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shapeshift-labs/frontier-lang-compiler",
-  "version": "0.2.95",
+  "version": "0.2.97",
   "description": "Compiler facade for Frontier Lang source documents and language projection adapters.",
   "type": "module",
   "main": "./dist/index.js",