@shapeshift-labs/frontier-lang-compiler 0.2.96 → 0.2.98

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

@@ -10,6 +10,7 @@ export type SemanticEditScriptOperationStatus =
   | 'candidate'
   | 'portable'
   | 'already-applied'
+  | 'covered'
   | 'needs-port'
   | 'conflict'
   | 'stale'
@@ -82,6 +83,7 @@ export interface SemanticEditScriptSummary {
   readonly conflicts: number;
   readonly stale: number;
   readonly blocked: number;
+  readonly covered?: number;
   readonly candidates: number;
   readonly autoMergeCandidates: number;
   readonly semanticKeys?: readonly 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,7 +13,12 @@ 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 = [];
+  const coveredOperationIds = [];
   for (const [index, operation] of (script.operations ?? []).entries()) {
+    if (operation.status === 'covered') {
+      coveredOperationIds.push(operation.id);
+      continue;
+    }
     const edit = sourceEditForOperation(operation, workerSourceText, headSourceText, index);
     if (edit.ok) edits.push(edit.value);
     else reasonCodes.push(...edit.reasonCodes);
@@ -34,7 +40,7 @@ export function projectSemanticEditScriptToSource(input = {}) {
     headHash: script.headHash,
     projectedHash: sourceText === undefined ? undefined : hashSemanticValue(sourceText),
     appliedOperations: blocked ? [] : deduped.edits.map((edit) => edit.operationId),
-    skippedOperations: blocked ? (script.operations ?? []).map((operation) => operation.id) : deduped.skippedOperationIds,
+    skippedOperations: blocked ? (script.operations ?? []).map((operation) => operation.id) : uniqueStrings([...coveredOperationIds, ...deduped.skippedOperationIds]),
     edits: blocked ? [] : deduped.edits.map(projectionEditRecord),
     sourceText,
     admission: {
@@ -65,6 +71,9 @@ function sourceEditForOperation(operation, workerSourceText, headSourceText, ord
   if (operation.changeKind === 'added' || String(operation.kind ?? '').startsWith('add')) {
     return insertionEditForOperation(operation, identity, workerSourceText, headSourceText, order);
   }
+  if (operation.changeKind === 'removed' || String(operation.kind ?? '').startsWith('remove')) {
+    return removalEditForOperation(operation, identity, headSourceText, order);
+  }
   const workerOffsets = spanOffsets(workerSourceText, operation.spans?.worker);
   const headOffsets = spanOffsets(headSourceText, operation.spans?.head ?? operation.spans?.base ?? operation.anchor?.sourceSpan);
   const reasons = [];
@@ -98,6 +107,33 @@ function sourceEditForOperation(operation, workerSourceText, headSourceText, ord
   };
 }
 
+function removalEditForOperation(operation, identity, headSourceText, order) {
+  const headOffsets = spanOffsets(headSourceText, operation.spans?.head ?? operation.spans?.base ?? operation.anchor?.sourceSpan);
+  const reasons = [];
+  if (!headOffsets) reasons.push(`head-span-not-resolvable:${operation.id}`);
+  if (reasons.length) return { ok: false, reasonCodes: reasons };
+  const rawCurrent = headSourceText.slice(headOffsets.start, headOffsets.end);
+  const expectedHeadHash = operation.hashes?.headTextHash ?? operation.hashes?.baseTextHash;
+  if (expectedHeadHash && hashSemanticValue(rawCurrent) !== expectedHeadHash) {
+    reasons.push(`head-span-hash-mismatch:${operation.id}`);
+  }
+  if (reasons.length) return { ok: false, reasonCodes: reasons };
+  const range = removalRange(headSourceText, headOffsets);
+  return {
+    ok: true,
+    value: {
+      operationId: operation.id,
+      order,
+      ...identity,
+      editKind: 'delete',
+      start: range.start,
+      end: range.end,
+      current: headSourceText.slice(range.start, range.end),
+      replacement: ''
+    }
+  };
+}
+
 function insertionEditForOperation(operation, identity, workerSourceText, headSourceText, order) {
   const workerOffsets = spanOffsets(workerSourceText, operation.spans?.worker);
   const reasons = [];
@@ -207,44 +243,6 @@ function semanticEditIdentity(operation) {
   });
 }
 
-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);
-}
-
-function dedupeSourceEdits(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 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 projectedSourcePath(script, edits) {
   return edits.map((edit) => edit.sourcePath).find(Boolean) ?? script.sourcePath;
 }
@@ -278,6 +276,13 @@ function insertionOffset(sourceText, insertion) {
   return { ok: false, reasonCodes: ['insertion-mode-unsupported'] };
 }
 
+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;
+}
+
 function insertionReplacement(text, sourceText, offset) {
   let replacement = String(text ?? '');
   if (offset > 0 && sourceText[offset - 1] !== '\n') replacement = `\n${replacement}`;
@@ -291,23 +296,6 @@ function afterLineOffset(sourceText, offset) {
   return sourceText[offset] === '\n' ? offset + 1 : offset;
 }
 
-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 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;
-}
-
 function compactRecord(value) {
   return Object.fromEntries(Object.entries(value ?? {}).filter(([, entry]) => entry !== undefined && (!Array.isArray(entry) || entry.length > 0)));
 }

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

@@ -0,0 +1,141 @@
+import { uniqueStrings } from '../../native-import-utils.js';
+import { nativeImportSourceText } from './nativeImportSourceText.js';
+
+export function markCoveredSemanticEditOperations(operations, context) {
+  const sourceText = {
+    base: nativeImportSourceText(context.base),
+    worker: nativeImportSourceText(context.worker)
+  };
+  return (operations ?? []).map((operation) => {
+    const coveredBy = coveredByChildOperations(operation, operations, sourceText);
+    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']),
+      evidenceIds: uniqueStrings(operation.evidenceIds ?? []),
+      metadata: {
+        ...(operation.metadata ?? {}),
+        coveredByOperationIds: coveredBy.map((child) => child.id)
+      }
+    };
+  });
+}
+
+function coveredByChildOperations(container, operations, sourceText) {
+  if (!isCoverableContainer(container)) return [];
+  const containerBase = spanOffsets(sourceText.base, container.spans?.base);
+  const containerWorker = spanOffsets(sourceText.worker, container.spans?.worker);
+  if (!containerBase || !containerWorker) return [];
+  const childEdits = (operations ?? [])
+    .filter((operation) => operation.id !== container.id)
+    .map((operation) => childEdit(operation, sourceText, containerBase))
+    .filter(Boolean);
+  if (!childEdits.length) return [];
+  const baseText = sourceText.base.slice(containerBase.start, containerBase.end);
+  const workerText = sourceText.worker.slice(containerWorker.start, containerWorker.end);
+  return applyLocalEdits(baseText, childEdits) === workerText ? childEdits.map((edit) => edit.operation) : [];
+}
+
+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';
+}
+
+function childEdit(operation, sourceText, containerBase) {
+  if (!['portable', 'already-applied'].includes(operation.status)) return undefined;
+  if (operation.changeKind === 'modified') return replacementChildEdit(operation, sourceText, containerBase);
+  if (operation.changeKind === 'added') return insertionChildEdit(operation, sourceText, containerBase);
+  if (operation.changeKind === 'removed') return removalChildEdit(operation, sourceText, containerBase);
+  return undefined;
+}
+
+function replacementChildEdit(operation, sourceText, containerBase) {
+  const base = spanOffsets(sourceText.base, operation.spans?.base);
+  const worker = spanOffsets(sourceText.worker, operation.spans?.worker);
+  if (!contained(base, containerBase) || !worker) return undefined;
+  return {
+    operation,
+    start: base.start - containerBase.start,
+    end: base.end - containerBase.start,
+    replacement: sourceText.worker.slice(worker.start, worker.end)
+  };
+}
+
+function insertionChildEdit(operation, sourceText, containerBase) {
+  const worker = spanOffsets(sourceText.worker, operation.spans?.worker);
+  const offset = insertionOffset(sourceText.base, operation.insertion, containerBase);
+  if (!worker || offset === undefined) return undefined;
+  const baseText = sourceText.base.slice(containerBase.start, containerBase.end);
+  const replacement = insertionReplacement(sourceText.worker.slice(worker.start, worker.end), baseText, offset);
+  return { operation, start: offset, end: offset, replacement };
+}
+
+function removalChildEdit(operation, sourceText, containerBase) {
+  const base = spanOffsets(sourceText.base, operation.spans?.base);
+  if (!contained(base, containerBase)) return undefined;
+  const range = removalRange(sourceText.base, base, containerBase);
+  return { operation, start: range.start - containerBase.start, end: range.end - containerBase.start, replacement: '' };
+}
+
+function insertionOffset(sourceText, insertion, containerBase) {
+  const mode = insertion?.mode;
+  if (mode === 'file-start') return 0;
+  if (mode === 'file-end') return containerBase.end - containerBase.start;
+  const span = spanOffsets(sourceText, insertion?.baseSpan ?? insertion?.headSpan);
+  if (!contained(span, containerBase)) return undefined;
+  if (mode === 'before') return span.start - containerBase.start;
+  if (mode === 'after') return afterLineOffset(sourceText, span.end) - containerBase.start;
+  return undefined;
+}
+
+function applyLocalEdits(sourceText, edits) {
+  return edits
+    .sort((left, right) => right.start - left.start || right.end - left.end)
+    .reduce((text, edit) => text.slice(0, edit.start) + edit.replacement + text.slice(edit.end), sourceText);
+}
+
+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 };
+}
+
+function contained(inner, outer) {
+  return Boolean(inner && outer && outer.start <= inner.start && inner.end <= outer.end);
+}
+
+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 removalRange(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 afterLineOffset(sourceText, offset) {
+  return sourceText[offset] === '\n' ? offset + 1 : offset;
+}

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

@@ -43,6 +43,7 @@ export function summarizeSemanticEditOperations(operations) {
     conflicts: byStatus.conflict ?? 0,
     stale: byStatus.stale ?? 0,
     blocked: byStatus.blocked ?? 0,
+    covered: byStatus.covered ?? 0,
     candidates: byStatus.candidate ?? 0,
     autoMergeCandidates: (byStatus.portable ?? 0) + (byStatus['already-applied'] ?? 0),
     semanticKeys: uniqueStrings(operations.map((operation) => operation.semanticKey).filter(Boolean)),

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

@@ -13,6 +13,7 @@ import {
   summarizeSemanticEditOperations
 } from './semanticEditScriptClassification.js';
 import { semanticEditInsertionAnchor } from './semanticEditInsertionAnchors.js';
+import { markCoveredSemanticEditOperations } from './semanticEditOperationCoverage.js';
 import { sourceTextForSpan } from './sourceTextForSpan.js';
 import { semanticEditIdentityFields, semanticEditOperationContentHash } from './semanticEditIdentityRecords.js';
 
@@ -52,7 +53,10 @@ export function createSemanticEditScript(input = {}, options = {}) {
     metadata: { source: 'createSemanticEditScript' }
   }) : undefined;
   const context = createEditContext({ base, worker, head, workerChangeSet, headChangeSet, headLineage });
-  const operations = workerChangeSet.changedRegions.map((region, index) => semanticEditOperation(region, index, context, input));
+  const operations = markCoveredSemanticEditOperations(
+    workerChangeSet.changedRegions.map((region, index) => semanticEditOperation(region, index, context, input)),
+    context
+  );
   const summary = summarizeSemanticEditOperations(operations);
   const admission = semanticEditAdmission({ operations, summary, head, workerChangeSet, headChangeSet, input });
   const evidence = semanticEditEvidence({ input, language, sourcePath, workerChangeSet, headChangeSet, headLineage, summary, admission });
@@ -169,7 +173,7 @@ function semanticEditOperation(region, index, context, input) {
   const identityRecord = semanticEditIdentityRecord({ kind, region, anchor });
   const identity = semanticEditIdentityFields(identityRecord);
   return compactRecord({
-    id: `semantic_edit_op_${idFragment([input.id ?? 'semantic_edit', anchorKey, index].join(':'))}`,
+    id: `semantic_edit_op_${idFragment([index, anchorKey, input.id ?? 'semantic_edit'].join(':'))}`,
     kind,
     changeKind: region.changeKind,
     anchor,

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.96",
+  "version": "0.2.98",
   "description": "Compiler facade for Frontier Lang source documents and language projection adapters.",
   "type": "module",
   "main": "./dist/index.js",