@shapeshift-labs/frontier-lang-compiler 0.2.134 → 0.2.136

package/README.md

@@ -196,7 +196,10 @@ 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. 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.
+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-semantic-edit-fallback.js

@@ -3,16 +3,25 @@ import { createSemanticEditScript } from './internal/index-impl/semanticEditScri
 import { projectSemanticEditScriptToSource } from './internal/index-impl/projectSemanticEditScriptToSource.js';
 import { replaySemanticEditProjection } from './internal/index-impl/replaySemanticEditProjection.js';
 import { JsTsSafeMergeConflictCodes, JsTsSafeMergeStatuses } from './js-ts-safe-merge-constants.js';
+import {
+  createStagedDeclarationAlreadyAppliedReplay,
+  createStagedDeclarationProjection,
+  createStagedDeclarationReplayRecord
+} from './js-ts-safe-merge-staged-declaration-replay.js';
+import { createStagedTopLevelSemanticFallback } from './js-ts-safe-merge-staged-top-level-fallback.js';
 import { idFragment, uniqueStrings } from './native-import-utils.js';
 
 function semanticEditFallbackResult(input, topLevelResult) {
   if (!shouldTrySemanticEditFallback(topLevelResult)) return topLevelResult;
-  const artifacts = createSemanticEditFallbackArtifacts(input, topLevelResult);
+  const stagedFallback = createStagedTopLevelSemanticFallback(input, topLevelResult);
+  const artifacts = createSemanticEditFallbackArtifacts(input, topLevelResult, stagedFallback);
   if (artifacts.status !== 'verified') return semanticEditFallbackBlockedResult(input, topLevelResult, artifacts);
+  const resultBase = stagedFallback?.stagedTopLevelResult ?? topLevelResult;
   const mergedSourceText = artifacts.projection.sourceText;
   const gates = semanticEditGates(artifacts);
   return {
-    ...topLevelResult,
+    ...resultBase,
+    id: String(input.id ?? resultBase.id ?? topLevelResult.id),
     status: JsTsSafeMergeStatuses.merged,
     mergedSourceText,
     outputSourceText: mergedSourceText,
@@ -28,7 +37,8 @@ function semanticEditFallbackResult(input, topLevelResult) {
       reasonCodes: []
     },
     summary: {
-      ...topLevelResult.summary,
+      ...resultBase.summary,
+      changedExistingDeclarations: topLevelResult.summary?.changedExistingDeclarations ?? resultBase.summary?.changedExistingDeclarations ?? 0,
       conflicts: 0,
       gatesPassed: gates.filter((gate) => gate.status === 'passed').length,
       semanticEditOperations: artifacts.script.summary.operations,
@@ -37,11 +47,13 @@ function semanticEditFallbackResult(input, topLevelResult) {
       composedPhases: 2
     },
     metadata: {
-      ...topLevelResult.metadata,
+      ...resultBase.metadata,
       composed: {
-        phase: 'semantic-edit-fallback',
-        phases: ['top-level-ledger', 'semantic-edit'],
-        originalReasonCodes: topLevelResult.admission?.reasonCodes ?? []
+        phase: stagedFallback ? 'staged-top-level-semantic-edit-fallback' : 'semantic-edit-fallback',
+        phases: stagedFallback ? ['top-level-neutralization', 'top-level-ledger', 'semantic-edit'] : ['top-level-ledger', 'semantic-edit'],
+        originalReasonCodes: topLevelResult.admission?.reasonCodes ?? [],
+        stagedTopLevelSummary: stagedFallback?.stagedTopLevelResult?.summary,
+        neutralization: stagedFallback?.neutralization?.summary
       }
     },
     semanticArtifacts: artifacts
@@ -53,42 +65,53 @@ function shouldTrySemanticEditFallback(result) {
   return conflicts.length > 0 && conflicts.every((conflict) => conflict.code === JsTsSafeMergeConflictCodes.changedExistingDeclaration);
 }
 
-function createSemanticEditFallbackArtifacts(input, topLevelResult) {
+function createSemanticEditFallbackArtifacts(input, topLevelResult, stagedFallback) {
   try {
     const id = String(input.id ?? topLevelResult.id ?? 'js_ts_safe_merge');
     const language = input.language ?? topLevelResult.language ?? 'typescript';
     const sourcePath = input.sourcePath ?? topLevelResult.sourcePath ?? 'inline.ts';
+    const scriptInput = stagedFallback?.scriptInput ?? input;
+    const projectionHeadSourceText = stagedFallback?.projectionHeadSourceText ?? input.headSourceText;
+    const replayCurrentSourceText = stagedFallback?.replayCurrentSourceText ?? input.headSourceText;
     const script = createSemanticEditScript({
-      ...input,
+      ...scriptInput,
       id: `${id}_semantic_edit`,
       language,
       sourcePath
     });
-    const projection = projectSemanticEditScriptToSource({
-      id: `${id}_semantic_edit_projection`,
-      script,
-      workerSourceText: input.workerSourceText,
-      headSourceText: input.headSourceText,
-      headSourcePath: sourcePath,
-      parser: input.parser
-    });
-    const replay = replaySemanticEditProjection({
-      id: `${id}_semantic_edit_replay`,
-      projection,
-      currentSourceText: input.headSourceText,
-      currentSourcePath: sourcePath,
-      language,
-      parser: input.parser
-    });
-    const alreadyAppliedReplay = replaySemanticEditProjection({
-      id: `${id}_semantic_edit_already_applied`,
-      projection,
-      currentSourceText: projection.sourceText,
-      currentSourcePath: sourcePath,
-      currentSourceHash: projection.projectedHash,
-      language,
-      parser: input.parser
-    });
+    const projection = stagedFallback
+      ? createStagedDeclarationProjection({ id, script, sourcePath, language, stagedFallback })
+      : projectSemanticEditScriptToSource({
+        id: `${id}_semantic_edit_projection`,
+        script,
+        workerSourceText: scriptInput.workerSourceText,
+        headSourceText: projectionHeadSourceText,
+        headSourcePath: sourcePath,
+        parser: input.parser,
+        metadata: stagedFallback?.metadata
+      });
+    const replay = stagedFallback
+      ? createStagedDeclarationReplayRecord({ id, projection, sourcePath, language, stagedFallback, replayCurrentSourceText })
+      : replaySemanticEditProjection({
+        id: `${id}_semantic_edit_replay`,
+        projection,
+        currentSourceText: replayCurrentSourceText,
+        currentSourcePath: sourcePath,
+        language,
+        parser: input.parser,
+        metadata: stagedFallback?.metadata
+      });
+    const alreadyAppliedReplay = stagedFallback
+      ? createStagedDeclarationAlreadyAppliedReplay({ id, projection, sourcePath, language })
+      : replaySemanticEditProjection({
+        id: `${id}_semantic_edit_already_applied`,
+        projection,
+        currentSourceText: projection.sourceText,
+        currentSourcePath: sourcePath,
+        currentSourceHash: projection.projectedHash,
+        language,
+        parser: input.parser
+      });
     return semanticEditArtifacts({
       id,
       language,
@@ -97,7 +120,8 @@ function createSemanticEditFallbackArtifacts(input, topLevelResult) {
       projection,
       replay,
       alreadyAppliedReplay,
-      topLevelResult
+      topLevelResult,
+      stagedFallback
     });
   } catch (error) {
     return blockedSemanticEditArtifacts(input, topLevelResult, ['semantic-edit-fallback-error'], error);
@@ -148,8 +172,10 @@ function semanticEditArtifacts(input) {
     metadata: {
       autoMergeClaim: false,
       semanticEquivalenceClaim: false,
-      source: 'js-ts-semantic-edit-fallback',
-      originalReasonCodes: input.topLevelResult.admission?.reasonCodes ?? []
+      source: input.stagedFallback ? 'js-ts-staged-top-level-semantic-edit-fallback' : 'js-ts-semantic-edit-fallback',
+      originalReasonCodes: input.topLevelResult.admission?.reasonCodes ?? [],
+      stagedTopLevelSummary: input.stagedFallback?.stagedTopLevelResult?.summary,
+      neutralization: input.stagedFallback?.neutralization?.summary
     }
   };
   return { ...core, hash: hashSemanticValue(core) };

package/dist/js-ts-safe-merge-staged-declaration-replay.js

@@ -0,0 +1,200 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import { idFragment, uniqueStrings } from './native-import-utils.js';
+
+function createStagedDeclarationProjection(input) {
+  const replay = input.stagedFallback.declarationReplay;
+  const reasonCodes = uniqueStrings(replay.reasonCodes);
+  const blocked = reasonCodes.length > 0;
+  const sourceText = blocked ? undefined : replay.outputSourceText;
+  const edits = blocked ? [] : replay.edits.map((edit, index) => stagedDeclarationProjectionEdit(edit, index, input));
+  const core = {
+    kind: 'frontier.lang.semanticEditProjection',
+    version: 1,
+    id: `${input.id}_semantic_edit_projection`,
+    scriptId: input.script.id,
+    status: blocked ? 'blocked' : 'projected',
+    sourcePath: input.sourcePath,
+    language: input.language,
+    baseHash: input.script.baseHash,
+    workerHash: input.script.workerHash,
+    headHash: input.script.headHash,
+    projectedHash: sourceText === undefined ? undefined : hashSemanticValue(sourceText),
+    appliedOperations: edits.map((edit) => edit.operationId),
+    skippedOperations: blocked ? (input.script.operations ?? []).map((operation) => operation.id) : [],
+    edits,
+    sourceText,
+    admission: {
+      status: blocked ? 'blocked' : 'auto-merge-candidate',
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      reasonCodes
+    },
+    metadata: {
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      source: 'js-ts-staged-declaration-replay',
+      ...input.stagedFallback.metadata
+    }
+  };
+  return { ...core, hash: hashSemanticValue(core) };
+}
+
+function stagedDeclarationProjectionEdit(edit, index, input) {
+  const operationId = `staged_declaration_replay_${idFragment([input.id, edit.key, index].join(':'))}`;
+  const replacementText = edit.replacementText;
+  const deletedText = edit.currentText;
+  return {
+    operationId,
+    status: 'applied',
+    kind: 'replaceDeclaration',
+    editKind: 'replace',
+    changeKind: 'modified',
+    anchorKey: edit.key,
+    conflictKey: `declaration:${edit.key}`,
+    regionKind: 'declaration',
+    sourcePath: input.sourcePath,
+    symbolName: edit.names?.[0],
+    symbolKind: edit.declarationKind,
+    editContentHash: hashSemanticValue({ operationId, replacementText, deletedText }),
+    headStart: edit.start,
+    headEnd: edit.end,
+    editOrder: index,
+    deletedBytes: deletedText.length,
+    replacementBytes: replacementText.length,
+    deletedTextHash: hashSemanticValue(deletedText),
+    replacementTextHash: hashSemanticValue(replacementText),
+    replacementText
+  };
+}
+
+function createStagedDeclarationReplayRecord(input) {
+  const projectionReady = input.projection.status === 'projected';
+  const outputSourceText = projectionReady ? input.projection.sourceText : undefined;
+  const edits = projectionReady ? input.projection.edits.map((edit) => ({
+    operationId: edit.operationId,
+    editKind: edit.editKind,
+    editOrder: edit.editOrder,
+    sourcePath: edit.sourcePath,
+    symbolName: edit.symbolName,
+    symbolKind: edit.symbolKind,
+    status: 'applied',
+    start: edit.headStart,
+    end: edit.headEnd,
+    replacementBytes: edit.replacementBytes,
+    replacementText: edit.replacementText,
+    reasonCodes: ['staged-declaration-replay']
+  })) : [];
+  const status = projectionReady ? 'accepted-clean' : 'blocked';
+  const reasonCodes = projectionReady ? [] : input.projection.admission.reasonCodes;
+  const core = {
+    kind: 'frontier.lang.semanticEditReplay',
+    version: 1,
+    schema: 'frontier.lang.semanticEditReplay.v1',
+    id: `${input.id}_semantic_edit_replay`,
+    projectionId: input.projection.id,
+    scriptId: input.projection.scriptId,
+    sourcePath: input.sourcePath,
+    language: input.language,
+    currentHash: hashSemanticValue(input.replayCurrentSourceText),
+    projectedHash: input.projection.projectedHash,
+    outputHash: outputSourceText === undefined ? undefined : hashSemanticValue(outputSourceText),
+    status,
+    edits,
+    appliedOperations: edits.map((edit) => edit.operationId),
+    skippedOperations: [],
+    admission: {
+      status,
+      action: projectionReady ? 'apply' : 'block',
+      reviewRequired: !projectionReady,
+      autoApplyCandidate: projectionReady,
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      reasonCodes
+    },
+    outputSourceText,
+    summary: {
+      edits: edits.length,
+      applied: edits.length,
+      alreadyApplied: 0,
+      conflicts: 0,
+      stale: 0,
+      blocked: projectionReady ? 0 : 1,
+      reasonCodes
+    },
+    metadata: {
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      source: 'js-ts-staged-declaration-replay',
+      ...input.stagedFallback.metadata
+    }
+  };
+  return { ...core, hash: hashSemanticValue(core) };
+}
+
+function createStagedDeclarationAlreadyAppliedReplay(input) {
+  const projectionReady = input.projection.status === 'projected';
+  const edits = projectionReady ? input.projection.edits.map((edit) => ({
+    operationId: edit.operationId,
+    editKind: edit.editKind,
+    editOrder: edit.editOrder,
+    sourcePath: edit.sourcePath,
+    symbolName: edit.symbolName,
+    symbolKind: edit.symbolKind,
+    status: 'already-applied',
+    start: edit.headStart,
+    end: edit.headStart + edit.replacementBytes,
+    replacementBytes: edit.replacementBytes,
+    replacementText: edit.replacementText,
+    reasonCodes: ['staged-declaration-already-applied']
+  })) : [];
+  const status = projectionReady ? 'already-applied' : 'blocked';
+  const reasonCodes = projectionReady ? [] : input.projection.admission.reasonCodes;
+  const core = {
+    kind: 'frontier.lang.semanticEditReplay',
+    version: 1,
+    schema: 'frontier.lang.semanticEditReplay.v1',
+    id: `${input.id}_semantic_edit_already_applied`,
+    projectionId: input.projection.id,
+    scriptId: input.projection.scriptId,
+    sourcePath: input.sourcePath,
+    language: input.language,
+    currentHash: input.projection.projectedHash,
+    projectedHash: input.projection.projectedHash,
+    outputHash: input.projection.projectedHash,
+    status,
+    edits,
+    appliedOperations: [],
+    skippedOperations: edits.map((edit) => edit.operationId),
+    admission: {
+      status,
+      action: projectionReady ? 'skip' : 'block',
+      reviewRequired: !projectionReady,
+      autoApplyCandidate: false,
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      reasonCodes
+    },
+    outputSourceText: input.projection.sourceText,
+    summary: {
+      edits: edits.length,
+      applied: 0,
+      alreadyApplied: edits.length,
+      conflicts: 0,
+      stale: 0,
+      blocked: projectionReady ? 0 : 1,
+      reasonCodes
+    },
+    metadata: {
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      source: 'js-ts-staged-declaration-replay'
+    }
+  };
+  return { ...core, hash: hashSemanticValue(core) };
+}
+
+export {
+  createStagedDeclarationAlreadyAppliedReplay,
+  createStagedDeclarationProjection,
+  createStagedDeclarationReplayRecord
+};

package/dist/js-ts-safe-merge-staged-top-level-fallback.js

@@ -0,0 +1,52 @@
+import { safeMergeJsTsImportsAndDeclarations } from './js-ts-safe-merge.js';
+import { JsTsSafeMergeStatuses } from './js-ts-safe-merge-constants.js';
+import { createJsTsChangedDeclarationReplay, neutralizeJsTsSafeTopLevelMergeSources } from './js-ts-safe-merge-top-level-neutralization.js';
+
+function createStagedTopLevelSemanticFallback(input, topLevelResult) {
+  const neutralization = neutralizeJsTsSafeTopLevelMergeSources(input);
+  if (!neutralization.ok) return undefined;
+  const stagedTopLevelResult = safeMergeJsTsImportsAndDeclarations({
+    ...input,
+    baseSourceText: neutralization.baseSourceText,
+    workerSourceText: neutralization.topLevelWorkerSourceText,
+    headSourceText: neutralization.topLevelHeadSourceText
+  });
+  if (stagedTopLevelResult.status !== JsTsSafeMergeStatuses.merged) return undefined;
+  const safeTopLevelChanges = safeTopLevelChangeCount(stagedTopLevelResult.summary);
+  const declarationReplay = createJsTsChangedDeclarationReplay(input, neutralization, stagedTopLevelResult.mergedSourceText);
+  const workerDeclarationChanges = neutralization.summary.workerChangedExistingDeclarations ?? 0;
+  if (safeTopLevelChanges === 0 && workerDeclarationChanges === 0) return undefined;
+  return {
+    neutralization,
+    declarationReplay,
+    stagedTopLevelResult,
+    scriptInput: {
+      ...input,
+      workerSourceText: neutralization.semanticWorkerSourceText,
+      headSourceText: neutralization.semanticHeadSourceText,
+      workerSourceHash: undefined,
+      headSourceHash: undefined
+    },
+    projectionHeadSourceText: stagedTopLevelResult.mergedSourceText,
+    replayCurrentSourceText: stagedTopLevelResult.mergedSourceText,
+    metadata: {
+      stagedTopLevelSummary: stagedTopLevelResult.summary,
+      declarationReplay: {
+        edits: declarationReplay.edits.length,
+        reasonCodes: declarationReplay.reasonCodes
+      },
+      neutralization: neutralization.summary,
+      originalReasonCodes: topLevelResult.admission?.reasonCodes ?? []
+    }
+  };
+}
+
+function safeTopLevelChangeCount(summary = {}) {
+  return (summary.importSpecifierAdditions ?? 0)
+    + (summary.importDeclarationAdditions ?? 0)
+    + (summary.topLevelDeclarationAdditions ?? 0);
+}
+
+export {
+  createStagedTopLevelSemanticFallback
+};

package/dist/js-ts-safe-merge-top-level-neutralization.js

@@ -0,0 +1,190 @@
+import { findCompatibleBaseImportEntry, findSameImportTargetBaseEntry } from './js-ts-safe-merge-import-shape.js';
+import { scanJsTsTopLevelLedger } from './js-ts-safe-merge-ledger.js';
+import { sameStatementText } from './js-ts-safe-merge-context.js';
+
+function neutralizeJsTsSafeTopLevelMergeSources(input = {}) {
+  if (typeof input.baseSourceText !== 'string'
+    || typeof input.workerSourceText !== 'string'
+    || typeof input.headSourceText !== 'string') {
+    return { ok: false, reasonCodes: ['missing-source-text'] };
+  }
+
+  const context = quietLedgerContext(input);
+  const base = scanJsTsTopLevelLedger(input.baseSourceText, 'base', context);
+  const worker = scanJsTsTopLevelLedger(input.workerSourceText, 'worker', context);
+  const head = scanJsTsTopLevelLedger(input.headSourceText, 'head', context);
+  if (context.conflicts.length) {
+    return { ok: false, reasonCodes: context.conflicts.map((conflict) => conflict.code) };
+  }
+
+  const baseEntries = base.entries;
+  const topLevelWorker = neutralizeChangedExistingDeclarations(input.workerSourceText, worker, baseEntries);
+  const topLevelHead = neutralizeChangedExistingDeclarations(input.headSourceText, head, baseEntries);
+  const semanticWorker = neutralizeSafeTopLevelAdditions(input.workerSourceText, worker, baseEntries);
+  const semanticHead = neutralizeSafeTopLevelAdditions(input.headSourceText, head, baseEntries);
+
+  return {
+    ok: true,
+    base,
+    worker,
+    head,
+    baseSourceText: input.baseSourceText,
+    topLevelWorkerSourceText: topLevelWorker.sourceText,
+    topLevelHeadSourceText: topLevelHead.sourceText,
+    semanticWorkerSourceText: semanticWorker.sourceText,
+    semanticHeadSourceText: semanticHead.sourceText,
+    summary: {
+      workerChangedExistingDeclarations: topLevelWorker.changedExistingDeclarations,
+      headChangedExistingDeclarations: topLevelHead.changedExistingDeclarations,
+      workerNeutralizedSafeTopLevelChanges: semanticWorker.neutralizedSafeTopLevelChanges,
+      headNeutralizedSafeTopLevelChanges: semanticHead.neutralizedSafeTopLevelChanges
+    }
+  };
+}
+
+function createJsTsChangedDeclarationReplay(input = {}, neutralization, currentSourceText) {
+  if (!neutralization?.ok || typeof currentSourceText !== 'string') {
+    return { ok: false, reasonCodes: ['missing-neutralized-current-source'], edits: [] };
+  }
+  const context = quietLedgerContext(input);
+  const current = scanJsTsTopLevelLedger(currentSourceText, 'current', context);
+  if (context.conflicts.length) {
+    return { ok: false, reasonCodes: context.conflicts.map((conflict) => conflict.code), edits: [] };
+  }
+
+  const baseEntries = neutralization.base.entries;
+  const workerMatches = matchedEntriesByBaseKey(neutralization.worker, baseEntries);
+  const headMatches = matchedEntriesByBaseKey(neutralization.head, baseEntries);
+  const currentMatches = matchedEntriesByBaseKey(current, baseEntries);
+  const edits = [];
+  const reasonCodes = [];
+  for (const baseEntry of baseEntries) {
+    if (baseEntry.kind === 'import') continue;
+    const workerEntry = workerMatches.get(baseEntry.key);
+    if (!workerEntry || sameStatementText(workerEntry.text, baseEntry.text)) continue;
+    const headEntry = headMatches.get(baseEntry.key);
+    const currentEntry = currentMatches.get(baseEntry.key);
+    if (!headEntry || !sameStatementText(headEntry.text, baseEntry.text)) {
+      reasonCodes.push(`head-anchor-changed-since-base:${baseEntry.key}`);
+      continue;
+    }
+    if (!currentEntry || !sameStatementText(currentEntry.text, baseEntry.text)) {
+      reasonCodes.push(`current-anchor-changed-since-base:${baseEntry.key}`);
+      continue;
+    }
+    edits.push({
+      key: baseEntry.key,
+      names: workerEntry.names ?? baseEntry.names ?? [],
+      declarationKind: workerEntry.declarationInfo?.declarationKind ?? baseEntry.declarationInfo?.declarationKind,
+      start: currentEntry.start,
+      end: currentEntry.end,
+      currentText: currentEntry.text,
+      replacementText: workerEntry.text
+    });
+  }
+  return {
+    ok: reasonCodes.length === 0,
+    reasonCodes,
+    edits,
+    outputSourceText: reasonCodes.length ? undefined : applySourceEdits(
+      currentSourceText,
+      edits.map((edit) => ({ start: edit.start, end: edit.end, text: edit.replacementText }))
+    )
+  };
+}
+
+function neutralizeChangedExistingDeclarations(sourceText, ledger, baseEntries) {
+  const usedBaseKeys = new Set();
+  const edits = [];
+  let changedExistingDeclarations = 0;
+  for (const entry of ledger.entries) {
+    const baseEntry = findBaseEntry(entry, baseEntries, usedBaseKeys);
+    if (!baseEntry) continue;
+    usedBaseKeys.add(baseEntry.key);
+    if (entry.kind === 'import' || sameStatementText(entry.text, baseEntry.text)) continue;
+    edits.push({ start: entry.start, end: entry.end, text: baseEntry.text });
+    changedExistingDeclarations += 1;
+  }
+  return {
+    sourceText: applySourceEdits(sourceText, edits),
+    changedExistingDeclarations
+  };
+}
+
+function neutralizeSafeTopLevelAdditions(sourceText, ledger, baseEntries) {
+  const usedBaseKeys = new Set();
+  const edits = [];
+  let neutralizedSafeTopLevelChanges = 0;
+  for (const entry of ledger.entries) {
+    const baseEntry = findBaseEntry(entry, baseEntries, usedBaseKeys);
+    if (!baseEntry) {
+      edits.push(deleteEntryEdit(sourceText, entry));
+      neutralizedSafeTopLevelChanges += 1;
+      continue;
+    }
+    usedBaseKeys.add(baseEntry.key);
+    if (entry.kind !== 'import' || sameStatementText(entry.text, baseEntry.text)) continue;
+    edits.push({ start: entry.start, end: entry.end, text: baseEntry.text });
+    neutralizedSafeTopLevelChanges += 1;
+  }
+  return {
+    sourceText: applySourceEdits(sourceText, edits),
+    neutralizedSafeTopLevelChanges
+  };
+}
+
+function findBaseEntry(entry, baseEntries, usedBaseKeys) {
+  if (!entry) return undefined;
+  const direct = baseEntries.find((candidate) => candidate.key === entry.key && !usedBaseKeys.has(candidate.key));
+  if (direct) return direct;
+  return entry.kind === 'import'
+    ? findCompatibleBaseImportEntry(entry, baseEntries, usedBaseKeys)
+      ?? findSameImportTargetBaseEntry(entry, baseEntries, usedBaseKeys)
+    : undefined;
+}
+
+function matchedEntriesByBaseKey(ledger, baseEntries) {
+  const usedBaseKeys = new Set();
+  const matches = new Map();
+  for (const entry of ledger.entries) {
+    const baseEntry = findBaseEntry(entry, baseEntries, usedBaseKeys);
+    if (!baseEntry) continue;
+    usedBaseKeys.add(baseEntry.key);
+    matches.set(baseEntry.key, entry);
+  }
+  return matches;
+}
+
+function deleteEntryEdit(sourceText, entry) {
+  const lineEnd = sourceText.indexOf('\n', entry.end);
+  const end = lineEnd === -1 ? entry.end : lineEnd + 1;
+  const lineStart = sourceText.lastIndexOf('\n', Math.max(0, entry.start - 1)) + 1;
+  const start = onlyWhitespace(sourceText.slice(lineStart, entry.start)) ? lineStart : entry.start;
+  return { start, end, text: '' };
+}
+
+function onlyWhitespace(text) {
+  return /^[\t ]*$/.test(text);
+}
+
+function applySourceEdits(sourceText, edits) {
+  return [...edits]
+    .sort((left, right) => right.start - left.start || right.end - left.end)
+    .reduce((current, edit) => `${current.slice(0, edit.start)}${edit.text}${current.slice(edit.end)}`, sourceText);
+}
+
+function quietLedgerContext(input) {
+  return {
+    id: String(input.id ?? 'js_ts_safe_merge'),
+    sourcePath: input.sourcePath,
+    language: input.language ?? 'typescript',
+    conflicts: [],
+    blockedGateIds: new Set(),
+    gateReasonCodes: new Map()
+  };
+}
+
+export {
+  createJsTsChangedDeclarationReplay,
+  neutralizeJsTsSafeTopLevelMergeSources
+};

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