@shapeshift-labs/frontier-lang-compiler 0.2.133 → 0.2.135

package/README.md

@@ -194,7 +194,12 @@ generic semantic edit script path. The fallback admits the merge only after the
 script is an auto-merge candidate, the source projection succeeds, replay on
 current head is `accepted-clean`, and replay on the projected source is
 `already-applied`. Same-anchor head edits, stale anchors, and non-body conflicts
-remain blocked for review.
+remain blocked for review. The same fallback composes with declared unordered
+member-addition regions, so a verified body edit can still merge alongside safe
+interface, type, class, or object member additions. Existing class/object method
+or property body edits inside the declared member region are preserved for
+semantic replay while added members are neutralized; object member additions are
+re-emitted with safe commas when both sides add final properties.
 
 Project-level JS/TS safe merges compose the same file-level gates across a
 base/worker/head file set. They preserve head-only files, admit worker-only

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

@@ -6,6 +6,7 @@ import {
   normalizeKind,
   normalizeMemberText,
   parseMembers,
+  removePreparedMemberAdditions,
   uniqueStrings
 } from './js-ts-semantic-merge-parse.js';
 import { mergeResult } from './js-ts-safe-member-merge-result.js';
@@ -43,7 +44,8 @@ function analyzeJsTsSafeMemberAdditions(input = {}) {
 function neutralizeJsTsSafeMemberMergeSources(input = {}) {
   const analysis = analyzeJsTsSafeMemberAdditions({
     ...input,
-    allowNonPolicySourceChanges: true
+    allowNonPolicySourceChanges: true,
+    allowExistingMemberChanges: true
   });
   if (analysis.reasonCodes.length) {
     return {
@@ -56,8 +58,8 @@ function neutralizeJsTsSafeMemberMergeSources(input = {}) {
     ok: true,
     analysis,
     baseSourceText: analysis.baseSourceText,
-    workerSourceText: canonicalizeSourceBodies(analysis.workerSourceText, analysis.preparedRegions, 'worker'),
-    headSourceText: canonicalizeSourceBodies(analysis.headSourceText, analysis.preparedRegions, 'head')
+    workerSourceText: removePreparedMemberAdditions(analysis.workerSourceText, analysis.preparedRegions, 'worker'),
+    headSourceText: removePreparedMemberAdditions(analysis.headSourceText, analysis.preparedRegions, 'head')
   };
 }
 
@@ -81,7 +83,7 @@ function prepareJsTsSafeMemberAdditions(input = {}) {
     reasonCodes.push(...policyReasons);
     if (policyReasons.length) continue;
     if (typeof baseSourceText !== 'string' || typeof workerSourceText !== 'string' || typeof headSourceText !== 'string') continue;
-    const prepared = prepareRegion({ region, baseSourceText, workerSourceText, headSourceText });
+    const prepared = prepareRegion({ region, baseSourceText, workerSourceText, headSourceText, allowExistingMemberChanges: input.allowExistingMemberChanges });
     reasonCodes.push(...prepared.reasonCodes);
     if (prepared.ok) preparedRegions.push(prepared.value);
   }
@@ -163,8 +165,8 @@ function prepareRegion(input) {
   const baseByKey = membersByKey(baseMembers.members);
   const workerByKey = membersByKey(workerMembers.members);
   const headByKey = membersByKey(headMembers.members);
-  reasonCodes.push(...existingMemberReasons(input.region, 'worker', baseMembers.members, workerMembers.members, workerByKey));
-  reasonCodes.push(...existingMemberReasons(input.region, 'head', baseMembers.members, headMembers.members, headByKey));
+  reasonCodes.push(...existingMemberReasons(input.region, 'worker', baseMembers.members, workerMembers.members, workerByKey, input.allowExistingMemberChanges));
+  reasonCodes.push(...existingMemberReasons(input.region, 'head', baseMembers.members, headMembers.members, headByKey, input.allowExistingMemberChanges));
   const workerAddedKeys = workerMembers.members.map((member) => member.key).filter((key) => !baseByKey.has(key));
   const headAddedKeys = headMembers.members.map((member) => member.key).filter((key) => !baseByKey.has(key));
   reasonCodes.push(...duplicateAddedReasons(input.region, workerAddedKeys, workerByKey, headByKey));
@@ -212,7 +214,7 @@ function duplicateReasons(region, side, members) {
   });
 }
 
-function existingMemberReasons(region, side, baseMembers, sideMembers, sideByKey) {
+function existingMemberReasons(region, side, baseMembers, sideMembers, sideByKey, allowExistingMemberChanges) {
   const reasonCodes = [];
   const sideBaseOrder = sideMembers.map((member) => member.key).filter((key) => baseMembers.some((baseMember) => baseMember.key === key));
   const baseOrder = baseMembers.map((member) => member.key);
@@ -225,7 +227,7 @@ function existingMemberReasons(region, side, baseMembers, sideMembers, sideByKey
       reasonCodes.push(regionReason(region, `existing-member-removed:${side}:${baseMember.key}`));
       continue;
     }
-    if (normalizeMemberText(sideMember.text) !== normalizeMemberText(baseMember.text)) {
+    if (!allowExistingMemberChanges && normalizeMemberText(sideMember.text, normalizeKind(region.kind)) !== normalizeMemberText(baseMember.text, normalizeKind(region.kind))) {
       reasonCodes.push(regionReason(region, `existing-member-changed:${side}:${baseMember.key}`));
     }
   }

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

@@ -25,12 +25,16 @@ function safeMergeJsTsSource(input = {}) {
     return composedBlockedResult(input, 'member-analysis', memberNeutralization.result, memberNeutralization.analysis);
   }
 
-  const topLevelResult = safeMergeJsTsImportsAndDeclarations({
+  const topLevelInput = {
     ...input,
     baseSourceText: memberNeutralization.baseSourceText,
     workerSourceText: memberNeutralization.workerSourceText,
     headSourceText: memberNeutralization.headSourceText
-  });
+  };
+  const topLevelLedgerResult = safeMergeJsTsImportsAndDeclarations(topLevelInput);
+  const topLevelResult = topLevelLedgerResult.status === JsTsSafeMergeStatuses.merged
+    ? topLevelLedgerResult
+    : semanticEditFallbackResult(topLevelInput, topLevelLedgerResult);
   if (topLevelResult.status !== JsTsSafeMergeStatuses.merged) {
     return composedBlockedResult(input, 'top-level', topLevelResult, memberNeutralization.analysis);
   }
@@ -61,7 +65,7 @@ function safeMergeJsTsSource(input = {}) {
     metadata: {
       ...topLevelResult.metadata,
       composed: {
-        phases: ['top-level', 'member'],
+        phases: composedPhaseList(topLevelResult),
         memberRegions: memberNeutralization.analysis.preparedRegions.map((region) => ({
           kind: region.kind,
           name: region.name,
@@ -78,6 +82,13 @@ function safeMergeJsTsSource(input = {}) {
   };
 }
 
+function composedPhaseList(topLevelResult) {
+  const topLevelPhases = topLevelResult.metadata?.composed?.phases;
+  if (Array.isArray(topLevelPhases) && topLevelPhases.length) return [...topLevelPhases, 'member'];
+  const topLevelPhase = topLevelResult.metadata?.composed?.phase;
+  return topLevelPhase ? [topLevelPhase, 'member'] : ['top-level', 'member'];
+}
+
 function hasMemberMergePolicy(input) {
   const policy = input.policy ?? input.mergePolicy ?? input;
   const regions = Array.isArray(policy)
@@ -119,14 +130,20 @@ function composedBlockedResult(input, phase, result, memberAnalysis) {
       gatesPassed: result.gates?.filter((gate) => gate.status === 'passed').length ?? 0,
       memberRegions: memberAnalysis?.preparedRegions?.length ?? 0,
       memberAdditions: 0,
+      semanticEditOperations: result.summary?.semanticEditOperations,
+      semanticEditAppliedOperations: result.summary?.semanticEditAppliedOperations,
+      semanticEditReplayStatus: result.summary?.semanticEditReplayStatus,
       composedPhases: phase === 'top-level' ? 2 : 1
     },
     metadata: {
       composed: {
         phase,
-        sourceKind: result.kind
+        sourceKind: result.kind,
+        topLevelPhase: result.metadata?.composed?.phase,
+        topLevelPhases: result.metadata?.composed?.phases
       }
-    }
+    },
+    semanticArtifacts: result.semanticArtifacts
   };
 }
 

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

@@ -12,6 +12,20 @@ function canonicalizeSourceBodies(sourceText, preparedRegions, side) {
   return output;
 }
 
+function removePreparedMemberAdditions(sourceText, preparedRegions, side) {
+  let output = sourceText;
+  const replacements = preparedRegions
+    .map((region) => ({
+      range: region[side],
+      replacement: removeMembersFromBody(region[side].body, region[`${side}AddedMembers`] ?? [], region.kind)
+    }))
+    .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;
+}
+
 function applyMemberAdditions(headSourceText, preparedRegions) {
   return applyPreparedMemberAdditions(headSourceText, preparedRegions, ['worker']).sourceText;
 }
@@ -28,7 +42,7 @@ function applyPreparedMemberAdditions(sourceText, preparedRegions, sides = ['wor
       }
       const members = sides.flatMap((side) => region[`${side}AddedMembers`] ?? []);
       if (!members.length) return undefined;
-      return { range: match.value, replacement: appendMembersToBody(match.value.body, members) };
+      return { range: match.value, replacement: appendMembersToBody(match.value.body, members, region.kind) };
     })
     .filter(Boolean)
     .sort((left, right) => right.range.bodyStart - left.range.bodyStart);
@@ -38,32 +52,50 @@ function applyPreparedMemberAdditions(sourceText, preparedRegions, sides = ['wor
   return { sourceText: output, reasonCodes: uniqueStrings(reasonCodes) };
 }
 
-function appendMembersToBody(body, members) {
+function appendMembersToBody(body, members, kind) {
   if (!members.length) return body;
   const indent = inferMemberIndent(body) ?? inferMemberIndent(members.map((member) => member.text).join('\n')) ?? '  ';
-  const addedText = members.map((member) => normalizeMemberForInsertion(member.text, indent)).join('\n');
+  const addedText = members.map((member, index) => normalizeMemberForInsertion(member.text, indent, kind, index < members.length - 1)).join('\n');
   const trailing = body.match(/\s*$/)?.[0] ?? '';
   const before = body.slice(0, body.length - trailing.length);
   if (!before.trim()) {
     const closingIndent = trailing.includes('\n') ? trailing.slice(trailing.lastIndexOf('\n') + 1) : '';
     return `\n${addedText}\n${closingIndent}`;
   }
-  return `${before}${before.endsWith('\n') ? '' : '\n'}${addedText}${trailing.includes('\n') ? trailing : `\n${trailing}`}`;
+  const appendableBefore = appendReadyBody(before, kind);
+  return `${appendableBefore}${appendableBefore.endsWith('\n') ? '' : '\n'}${addedText}${trailing.includes('\n') ? trailing : `\n${trailing}`}`;
 }
 
 function inferMemberIndent(text) {
   return String(text ?? '').match(/\n([ \t]*)\S/)?.[1];
 }
 
-function normalizeMemberForInsertion(text, indent) {
+function normalizeMemberForInsertion(text, indent, kind, needsDelimiter) {
   const lines = String(text ?? '').replace(/\r\n/g, '\n').replace(/\r/g, '\n').split('\n');
   while (lines.length && !lines[0].trim()) lines.shift();
   while (lines.length && !lines[lines.length - 1].trim()) lines.pop();
   const commonIndent = minimumIndent(lines);
-  return lines.map((line) => {
+  const normalized = lines.map((line) => {
     const normalized = commonIndent ? line.slice(Math.min(commonIndent, leadingWhitespace(line))) : line;
     return normalized.trim() ? `${indent}${normalized}` : normalized;
   }).join('\n');
+  if (kind !== 'object' || !needsDelimiter || /,\s*$/.test(normalized)) return normalized;
+  return `${normalized},`;
+}
+
+function appendReadyBody(before, kind) {
+  if (kind !== 'object' || !before.trim() || /,\s*$/.test(before)) return before;
+  return `${before.replace(/\s*$/, '')},`;
+}
+
+function removeMembersFromBody(body, members, kind) {
+  let output = body;
+  for (const member of [...members].sort((left, right) => right.start - left.start || right.end - left.end)) {
+    output = `${output.slice(0, member.start)}${output.slice(member.end)}`;
+  }
+  if (kind !== 'object') return output;
+  const trailing = String(body ?? '').match(/\s*$/)?.[0] ?? '';
+  return output.replace(/,\s*$/, trailing);
 }
 
 function minimumIndent(lines) {
@@ -78,5 +110,6 @@ function leadingWhitespace(line) {
 export {
   applyMemberAdditions,
   applyPreparedMemberAdditions,
-  canonicalizeSourceBodies
+  canonicalizeSourceBodies,
+  removePreparedMemberAdditions
 };

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

@@ -1,11 +1,14 @@
-function normalizeMemberText(text) {
-  return String(text ?? '')
+function normalizeMemberText(text, kind) {
+  const normalized = String(text ?? '')
     .replace(/\r\n/g, '\n')
     .replace(/\r/g, '\n')
     .split('\n')
     .map((line) => line.trimEnd())
     .join('\n')
     .trim();
+  if (kind === 'object') return normalized.replace(/,\s*$/, '');
+  if (kind === 'interface' || kind === 'type' || kind === 'class') return normalized.replace(/;\s*$/, '');
+  return normalized;
 }
 
 function uniqueStrings(values) {

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

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

package/package.json

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