@shapeshift-labs/frontier-lang-compiler 0.2.104 → 0.2.106

package/dist/js-ts-safe-merge-semantic-artifact-ledger.js

@@ -0,0 +1,197 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import { idFragment } from './native-import-utils.js';
+import { detectLineEnding, normalizeLineEndings } from './js-ts-safe-merge-context.js';
+
+function createOperationsFromLedgers(context) {
+  const headByKey = new Map(context.head.entries.map((entry) => [entry.key, entry]));
+  return context.merged.entries.flatMap((entry, index) => {
+    const headEntry = headByKey.get(entry.key);
+    if (headEntry) {
+      if (sameEntryText(headEntry.text, entry.text)) return [];
+      return [operationRecord({
+        ...context,
+        index,
+        kind: entry.kind === 'import' ? 'jsTsReplaceImport' : 'jsTsReplaceDeclaration',
+        changeKind: 'modified',
+        entry,
+        headEntry,
+        insertion: undefined,
+        currentText: headEntry.text,
+        replacementText: entry.text
+      })];
+    }
+    return [operationRecord({
+      ...context,
+      index,
+      kind: entry.kind === 'import' ? 'jsTsInsertImport' : 'jsTsInsertDeclaration',
+      changeKind: 'added',
+      entry,
+      headEntry: undefined,
+      insertion: insertionAnchorForMergedEntry(entry, index, context),
+      currentText: '',
+      replacementText: insertionText(entry.text, context.head.sourceText)
+    })];
+  });
+}
+
+function operationRecord(input) {
+  const anchor = entryAnchor(input.entry, input.sourcePath, input.language);
+  const operation = {
+    id: `js_ts_safe_merge_op_${idFragment([input.id, input.index, input.entry.key].join(':'))}`,
+    kind: input.kind,
+    changeKind: input.changeKind,
+    anchor,
+    insertion: input.insertion,
+    spans: {
+      head: input.headEntry ? spanForEntry(input.headEntry) : undefined,
+      worker: spanForEntry(input.entry)
+    },
+    hashes: {
+      baseSourceHash: input.input.baseHash,
+      workerSourceHash: input.input.workerHash,
+      headSourceHash: input.input.headHash,
+      headTextHash: hashSemanticValue(input.currentText),
+      workerTextHash: hashSemanticValue(input.replacementText)
+    },
+    status: 'portable',
+    readiness: 'ready',
+    confidence: 1,
+    reasonCodes: ['js-ts-safe-merge-gates-passed', 'js-ts-ledger-source-edit'],
+    evidenceIds: [`evidence_${idFragment(input.id)}_js_ts_safe_merge_semantic_replay`],
+    metadata: {
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      ledgerKey: input.entry.key
+    }
+  };
+  return { ...operation, operationContentHash: hashSemanticValue(operation) };
+}
+
+function sourceEditForOperation(operation, order, headSourceText, mergedSourceText) {
+  const headStart = operation.spans.head?.start ?? insertionOffsetFromAnchor(operation.insertion, headSourceText);
+  const headEnd = operation.spans.head?.end ?? headStart;
+  const workerStart = operation.spans.worker?.start ?? 0;
+  const workerEnd = operation.spans.worker?.end ?? workerStart;
+  const current = headSourceText.slice(headStart, headEnd);
+  const replacementSpanText = mergedSourceText.slice(workerStart, workerEnd);
+  const replacement = operation.changeKind === 'added'
+    ? insertionText(replacementSpanText, headSourceText)
+    : replacementSpanText;
+  return {
+    operationId: operation.id,
+    order,
+    kind: operation.kind,
+    editKind: operation.changeKind === 'added' ? 'insert' : 'replace',
+    changeKind: operation.changeKind,
+    anchorKey: operation.anchor.key,
+    conflictKey: operation.anchor.conflictKey,
+    regionId: operation.anchor.regionId,
+    regionKind: operation.anchor.regionKind,
+    sourcePath: operation.anchor.sourcePath,
+    symbolId: operation.anchor.symbolId,
+    symbolName: operation.anchor.symbolName,
+    symbolKind: operation.anchor.symbolKind,
+    operationContentHash: operation.operationContentHash,
+    insertion: operation.insertion,
+    start: headStart,
+    end: headEnd,
+    workerStart,
+    workerEnd,
+    current,
+    replacement,
+    replacementSpanText
+  };
+}
+
+function insertionAnchorForMergedEntry(entry, index, context) {
+  const previous = nearestHeadEntry(context.merged.entries, context.head.entries, index, -1);
+  if (previous) return {
+    mode: 'after',
+    anchorKey: previous.key,
+    anchorSymbolName: entryName(previous),
+    anchorSymbolKind: entrySymbolKind(previous),
+    headSpan: spanForEntry(previous),
+    sourcePath: context.sourcePath
+  };
+  const next = nearestHeadEntry(context.merged.entries, context.head.entries, index, 1);
+  if (next) return {
+    mode: 'before',
+    anchorKey: next.key,
+    anchorSymbolName: entryName(next),
+    anchorSymbolKind: entrySymbolKind(next),
+    headSpan: spanForEntry(next),
+    sourcePath: context.sourcePath
+  };
+  return { mode: 'file-end', sourcePath: context.sourcePath };
+}
+
+function nearestHeadEntry(mergedEntries, headEntries, startIndex, step) {
+  const headByKey = new Map(headEntries.map((entry) => [entry.key, entry]));
+  for (let index = startIndex + step; index >= 0 && index < mergedEntries.length; index += step) {
+    const headEntry = headByKey.get(mergedEntries[index].key);
+    if (headEntry) return headEntry;
+  }
+  return undefined;
+}
+
+function insertionOffsetFromAnchor(insertion, sourceText) {
+  if (insertion?.mode === 'file-start') return 0;
+  if (insertion?.mode === 'file-end') return sourceText.length;
+  const span = insertion?.headSpan;
+  if (!span) return sourceText.length;
+  if (insertion.mode === 'before') return lineStartOffset(sourceText, span.start);
+  return lineEndOffset(sourceText, span.end);
+}
+
+function entryAnchor(entry, sourcePath, language) {
+  const name = entryName(entry);
+  const key = `source#${sourcePath ?? 'unknown'}#${entry.kind}#${name ?? entry.key}`;
+  return {
+    key,
+    conflictKey: key,
+    regionId: key,
+    regionKind: entry.kind === 'import' ? 'import' : 'declaration',
+    granularity: 'js-ts-ledger-entry',
+    language,
+    sourcePath,
+    symbolId: key,
+    symbolName: name,
+    symbolKind: entrySymbolKind(entry),
+    sourceSpan: spanForEntry(entry)
+  };
+}
+
+function entryName(entry) {
+  if (entry.kind === 'import') return entry.importInfo?.moduleSpecifier;
+  return entry.names?.join('|') ?? entry.key;
+}
+
+function entrySymbolKind(entry) {
+  if (entry.kind === 'import') return 'import';
+  return entry.declarationInfo?.declarationKind ?? entry.kind;
+}
+
+function spanForEntry(entry) {
+  return { start: entry.start, end: entry.end };
+}
+
+function insertionText(text, sourceText) {
+  const lineEnding = detectLineEnding(sourceText);
+  const normalized = normalizeLineEndings(String(text ?? '').trimEnd(), lineEnding);
+  return normalized.endsWith(lineEnding) ? normalized : `${normalized}${lineEnding}`;
+}
+
+function sameEntryText(left, right) {
+  return normalizeLineEndings(String(left ?? '').trim(), '\n') === normalizeLineEndings(String(right ?? '').trim(), '\n');
+}
+
+function lineStartOffset(sourceText, offset) {
+  return sourceText.lastIndexOf('\n', Math.max(0, offset - 1)) + 1;
+}
+
+function lineEndOffset(sourceText, offset) {
+  const lineEnd = sourceText.indexOf('\n', offset);
+  return lineEnd === -1 ? sourceText.length : lineEnd + 1;
+}
+
+export { createOperationsFromLedgers, sourceEditForOperation };

package/dist/js-ts-safe-merge-semantic-artifacts.js

@@ -0,0 +1,266 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import { idFragment, uniqueStrings } from './native-import-utils.js';
+import { replaySemanticEditProjection } from './internal/index-impl/replaySemanticEditProjection.js';
+import { projectionEditRecord } from './internal/index-impl/semanticEditProjectionRecord.js';
+import { applySourceEdits, dedupeSourceEdits, validateSourceEdits } from './internal/index-impl/semanticSourceEditDedupe.js';
+import { createMergeContext } from './js-ts-safe-merge-context.js';
+import { scanJsTsTopLevelLedger } from './js-ts-safe-merge-ledger.js';
+import { createOperationsFromLedgers, sourceEditForOperation } from './js-ts-safe-merge-semantic-artifact-ledger.js';
+
+function createJsTsSafeMergeSemanticArtifacts(input = {}, merge = {}) {
+  const headSourceText = input.headSourceText;
+  const mergedSourceText = merge.mergedSourceText ?? merge.outputSourceText;
+  const language = input.language ?? merge.language ?? 'typescript';
+  const sourcePath = input.sourcePath ?? merge.sourcePath ?? 'inline.js';
+  const id = String(input.id ?? merge.id ?? 'js_ts_safe_merge');
+  const baseReasonCodes = [];
+  if (typeof headSourceText !== 'string') baseReasonCodes.push('missing-head-source-text');
+  if (typeof mergedSourceText !== 'string') baseReasonCodes.push('missing-merged-source-text');
+  if (baseReasonCodes.length) return blockedArtifacts({ id, language, sourcePath, reasonCodes: baseReasonCodes, merge });
+
+  const ledgerContext = createMergeContext({ ...input, id: `${id}_semantic_artifacts`, language, sourcePath });
+  const head = scanJsTsTopLevelLedger(headSourceText, 'head', ledgerContext);
+  const merged = scanJsTsTopLevelLedger(mergedSourceText, 'merged', ledgerContext);
+  if (ledgerContext.conflicts.length) {
+    return blockedArtifacts({
+      id,
+      language,
+      sourcePath,
+      reasonCodes: uniqueStrings(ledgerContext.conflicts.map((conflict) => conflict.code)),
+      merge,
+      ledgers: { head, merged }
+    });
+  }
+
+  const operations = createOperationsFromLedgers({ id, language, sourcePath, head, merged, input, merge });
+  const rawEdits = operations.map((operation, order) => sourceEditForOperation(operation, order, headSourceText, mergedSourceText));
+  const deduped = dedupeSourceEdits(rawEdits);
+  const reasonCodes = uniqueStrings([
+    ...validateSourceEdits(deduped.edits),
+    ...deduped.skippedOperationIds.map((operationId) => `source-edit-deduped:${operationId}`)
+  ]);
+  const sourceText = reasonCodes.length ? undefined : applySourceEdits(headSourceText, deduped.edits);
+  if (sourceText !== mergedSourceText) reasonCodes.push('projected-source-mismatch');
+  const blocked = reasonCodes.length > 0;
+  const script = createScript({ id, language, sourcePath, input, merge, operations, blocked, reasonCodes });
+  const projection = createProjection({
+    id,
+    language,
+    sourcePath,
+    input,
+    merge,
+    script,
+    edits: blocked ? [] : deduped.edits,
+    skippedOperationIds: deduped.skippedOperationIds,
+    sourceText: blocked ? undefined : sourceText,
+    reasonCodes
+  });
+  const replay = replaySemanticEditProjection({
+    id: `js_ts_safe_merge_replay_${idFragment(id)}`,
+    projection,
+    currentSourceText: headSourceText,
+    currentSourcePath: sourcePath,
+    language
+  });
+  const alreadyAppliedReplay = replaySemanticEditProjection({
+    id: `js_ts_safe_merge_replay_already_applied_${idFragment(id)}`,
+    projection,
+    currentSourceText: mergedSourceText,
+    currentSourcePath: sourcePath,
+    language
+  });
+  const replayReady = replay.status === 'accepted-clean' && replay.outputSourceText === mergedSourceText;
+  const alreadyAppliedReady = alreadyAppliedReplay.status === 'already-applied';
+  const status = !blocked && replayReady && alreadyAppliedReady ? 'verified' : 'blocked';
+  const finalReasonCodes = uniqueStrings([
+    ...reasonCodes,
+    replayReady ? undefined : `semantic-replay-${replay.status}`,
+    alreadyAppliedReady ? undefined : `semantic-replay-already-applied-${alreadyAppliedReplay.status}`
+  ]);
+  const core = {
+    kind: 'frontier.lang.jsTsSafeMergeSemanticArtifacts',
+    version: 1,
+    schema: 'frontier.lang.jsTsSafeMergeSemanticArtifacts.v1',
+    id: `js_ts_safe_merge_semantic_artifacts_${idFragment(id)}`,
+    sourcePath,
+    language,
+    status,
+    script,
+    projection,
+    replay,
+    alreadyAppliedReplay,
+    admission: {
+      status: status === 'verified' ? 'auto-merge-candidate' : 'blocked',
+      action: status === 'verified' ? 'apply' : 'human-review',
+      reviewRequired: status !== 'verified',
+      autoApplyCandidate: status === 'verified',
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      reasonCodes: finalReasonCodes
+    },
+    summary: {
+      operations: operations.length,
+      edits: projection.edits.length,
+      replayStatus: replay.status,
+      alreadyAppliedReplayStatus: alreadyAppliedReplay.status,
+      projectedSourceMatchesMerged: projection.sourceText === mergedSourceText,
+      replayOutputMatchesMerged: replay.outputSourceText === mergedSourceText
+    },
+    evidence: [{
+      id: `evidence_${idFragment(id)}_js_ts_safe_merge_semantic_replay`,
+      kind: 'js-ts-safe-merge-semantic-replay',
+      status: status === 'verified' ? 'passed' : 'needs-review',
+      path: sourcePath,
+      summary: status === 'verified'
+        ? `JS/TS safe merge replay verified ${operations.length} semantic source edit(s).`
+        : `JS/TS safe merge semantic replay requires review: ${finalReasonCodes.join(', ')}.`,
+      metadata: {
+        scriptId: script.id,
+        projectionId: projection.id,
+        replayId: replay.id,
+        alreadyAppliedReplayId: alreadyAppliedReplay.id,
+        autoMergeClaim: false,
+        semanticEquivalenceClaim: false
+      }
+    }],
+    metadata: {
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      source: 'js-ts-safe-merge-ledger',
+      mergeGateIds: (merge.gates ?? []).map((gate) => gate.id)
+    }
+  };
+  return { ...core, hash: hashSemanticValue(core) };
+}
+
+function createScript(input) {
+  const statuses = countBy(input.operations, (operation) => operation.status);
+  const kinds = countBy(input.operations, (operation) => operation.kind);
+  const reasonCodes = uniqueStrings(input.reasonCodes);
+  const core = {
+    kind: 'frontier.lang.semanticEditScript',
+    version: 1,
+    schema: 'frontier.lang.semanticEditScript.v1',
+    id: `js_ts_safe_merge_script_${idFragment(input.id)}`,
+    stableId: `js_ts_safe_merge_script_${idFragment([input.id, input.merge.mergedSourceText].join(':'))}`,
+    language: input.language,
+    sourcePath: input.sourcePath,
+    baseHash: input.input.baseHash,
+    workerHash: input.input.workerHash,
+    headHash: input.input.headHash,
+    workerChangeSetId: input.input.workerChangeSetId,
+    headChangeSetId: input.input.headChangeSetId,
+    operations: input.operations,
+    summary: {
+      operations: input.operations.length,
+      byStatus: statuses,
+      byKind: kinds,
+      portable: statuses.portable ?? 0,
+      alreadyApplied: 0,
+      needsPort: 0,
+      conflicts: 0,
+      stale: 0,
+      blocked: input.blocked ? input.operations.length : 0,
+      candidates: 0,
+      autoMergeCandidates: input.blocked ? 0 : input.operations.length,
+      operationContentHashes: input.operations.map((operation) => operation.operationContentHash)
+    },
+    admission: {
+      status: input.blocked ? 'blocked' : 'auto-merge-candidate',
+      action: input.blocked ? 'block' : 'run-gates-and-apply',
+      reviewRequired: input.blocked,
+      autoApplyCandidate: !input.blocked,
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      reasonCodes,
+      conflictKeys: input.operations.map((operation) => operation.anchor.conflictKey),
+      evidenceIds: input.operations.flatMap((operation) => operation.evidenceIds ?? [])
+    },
+    evidence: [],
+    metadata: {
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      source: 'js-ts-safe-merge-ledger'
+    }
+  };
+  return { ...core, hash: hashSemanticValue(core) };
+}
+
+function createProjection(input) {
+  const blocked = input.reasonCodes.length > 0;
+  const edits = blocked ? [] : input.edits.map(projectionEditRecord);
+  const core = {
+    kind: 'frontier.lang.semanticEditProjection',
+    version: 1,
+    id: `js_ts_safe_merge_projection_${idFragment(input.id)}`,
+    scriptId: input.script.id,
+    status: blocked ? 'blocked' : 'projected',
+    sourcePath: input.sourcePath,
+    language: input.language,
+    baseHash: input.input.baseHash,
+    workerHash: input.input.workerHash,
+    headHash: input.input.headHash,
+    projectedHash: input.sourceText === undefined ? undefined : hashSemanticValue(input.sourceText),
+    appliedOperations: edits.map((edit) => edit.operationId).filter(Boolean),
+    skippedOperations: blocked ? input.script.operations.map((operation) => operation.id) : input.skippedOperationIds,
+    edits,
+    sourceText: input.sourceText,
+    admission: {
+      status: blocked ? 'blocked' : 'auto-merge-candidate',
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      reasonCodes: uniqueStrings(input.reasonCodes)
+    },
+    metadata: {
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      source: 'js-ts-safe-merge-ledger'
+    }
+  };
+  return { ...core, hash: hashSemanticValue(core) };
+}
+
+function blockedArtifacts(input) {
+  const core = {
+    kind: 'frontier.lang.jsTsSafeMergeSemanticArtifacts',
+    version: 1,
+    schema: 'frontier.lang.jsTsSafeMergeSemanticArtifacts.v1',
+    id: `js_ts_safe_merge_semantic_artifacts_${idFragment(input.id)}`,
+    sourcePath: input.sourcePath,
+    language: input.language,
+    status: 'blocked',
+    admission: {
+      status: 'blocked',
+      action: 'human-review',
+      reviewRequired: true,
+      autoApplyCandidate: false,
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      reasonCodes: uniqueStrings(input.reasonCodes)
+    },
+    summary: {
+      operations: 0,
+      edits: 0,
+      projectedSourceMatchesMerged: false,
+      replayOutputMatchesMerged: false
+    },
+    evidence: [],
+    metadata: {
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      source: 'js-ts-safe-merge-ledger'
+    }
+  };
+  return { ...core, hash: hashSemanticValue(core) };
+}
+
+function countBy(values, keyFor) {
+  const result = {};
+  for (const value of values) {
+    const key = keyFor(value);
+    result[key] = (result[key] ?? 0) + 1;
+  }
+  return result;
+}
+
+export { createJsTsSafeMergeSemanticArtifacts };

package/dist/js-ts-safe-merge.js

@@ -8,6 +8,7 @@ import {
 } from './js-ts-safe-merge-constants.js';
 import { indexBaseLedger, scanJsTsTopLevelLedger, validateLedgerUniqueness } from './js-ts-safe-merge-ledger.js';
 import { applySourceMergePlan, createSourceMergePlan } from './js-ts-safe-merge-plan.js';
+import { createJsTsSafeMergeSemanticArtifacts } from './js-ts-safe-merge-semantic-artifacts.js';
 
 export { JsTsSafeMergeConflictCodes, JsTsSafeMergeGateIds, JsTsSafeMergeStatuses };
 
@@ -61,7 +62,7 @@ export function safeMergeJsTsImportsAndDeclarations(input = {}) {
   if (!context.conflicts.length) validateLedgerUniqueness(merged, context);
   if (context.conflicts.length) return blockedResult(context, { base, worker, head, merged });
 
-  return {
+  const result = {
     kind: 'frontier.lang.jsTsSafeMerge',
     version: 1,
     schema: 'frontier.lang.jsTsSafeMerge.v1',
@@ -99,6 +100,10 @@ export function safeMergeJsTsImportsAndDeclarations(input = {}) {
       currentSourceHash: input.currentSourceHash
     })
   };
+  return {
+    ...result,
+    semanticArtifacts: createJsTsSafeMergeSemanticArtifacts(input, result)
+  };
 }
 
 function validateStaleSourceHashes(input, context) {

package/dist/js-ts-semantic-merge-member-source.js

@@ -1,3 +1,6 @@
+import { findContainer } from './js-ts-semantic-merge-member-containers.js';
+import { uniqueStrings } from './js-ts-semantic-merge-member-utils.js';
+
 function canonicalizeSourceBodies(sourceText, preparedRegions, side) {
   let output = sourceText;
   const replacements = preparedRegions
@@ -10,15 +13,29 @@ function canonicalizeSourceBodies(sourceText, preparedRegions, side) {
 }
 
 function applyMemberAdditions(headSourceText, preparedRegions) {
-  let output = headSourceText;
+  return applyPreparedMemberAdditions(headSourceText, preparedRegions, ['worker']).sourceText;
+}
+
+function applyPreparedMemberAdditions(sourceText, preparedRegions, sides = ['worker']) {
+  let output = sourceText;
+  const reasonCodes = [];
   const replacements = preparedRegions
-    .filter((region) => region.workerAddedMembers.length)
-    .map((region) => ({ range: region.head, replacement: appendMembersToBody(region.head.body, region.workerAddedMembers) }))
+    .map((region) => {
+      const match = findContainer(sourceText, region.policy);
+      if (match.reasonCodes.length) {
+        reasonCodes.push(...match.reasonCodes.map((reason) => `target-${reason}:${region.kind}:${region.name}`));
+        return undefined;
+      }
+      const members = sides.flatMap((side) => region[`${side}AddedMembers`] ?? []);
+      if (!members.length) return undefined;
+      return { range: match.value, replacement: appendMembersToBody(match.value.body, members) };
+    })
+    .filter(Boolean)
     .sort((left, right) => right.range.bodyStart - left.range.bodyStart);
   for (const { range, replacement } of replacements) {
     output = `${output.slice(0, range.bodyStart)}${replacement}${output.slice(range.bodyEnd)}`;
   }
-  return output;
+  return { sourceText: output, reasonCodes: uniqueStrings(reasonCodes) };
 }
 
 function appendMembersToBody(body, members) {
@@ -60,5 +77,6 @@ function leadingWhitespace(line) {
 
 export {
   applyMemberAdditions,
+  applyPreparedMemberAdditions,
   canonicalizeSourceBodies
 };

package/dist/js-ts-semantic-merge-parse.js

@@ -7,6 +7,7 @@ export {
 } from './js-ts-semantic-merge-member-segments.js';
 export {
   applyMemberAdditions,
+  applyPreparedMemberAdditions,
   canonicalizeSourceBodies
 } from './js-ts-semantic-merge-member-source.js';
 export {

package/dist/js-ts-semantic-merge.js

@@ -4,6 +4,9 @@ export {
   JsTsSafeMergeStatuses,
   safeMergeJsTsImportsAndDeclarations
 } from './js-ts-safe-merge.js';
+export {
+  safeMergeJsTsSource
+} from './js-ts-safe-merge-composed.js';
 export {
   mergeJsTsSafeMemberAdditions,
   safeMergeJsTsMembers

package/package.json

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