@shapeshift-labs/frontier-lang-compiler 0.2.97 → 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

@@ -13,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);
@@ -35,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: {
@@ -66,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 = [];
@@ -99,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 = [];
@@ -241,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}`;

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/package.json

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