@shapeshift-labs/frontier-lang-compiler 0.2.138 → 0.2.140

package/README.md

@@ -200,6 +200,11 @@ 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.
+If staged whole-declaration replay cannot verify because head changed a sibling
+member inside the same declaration, `safeMergeJsTsSource` retries the direct
+semantic edit projection and admits the merge only when replay still verifies
+cleanly. That direct retry can project onto the staged top-level merge output,
+so safe import/declaration additions are preserved alongside the sibling edit.
 
 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-merge-semantic-edit-fallback-utils.js

@@ -0,0 +1,41 @@
+import { JsTsSafeMergeConflictCodes } from './js-ts-safe-merge-constants.js';
+
+const semanticFallbackConflictCodes = new Set([
+  JsTsSafeMergeConflictCodes.changedExistingDeclaration,
+  JsTsSafeMergeConflictCodes.typeAliasConflict
+]);
+
+function shouldTrySemanticEditFallback(result) {
+  const conflicts = result.conflicts ?? [];
+  return conflicts.length > 0 && conflicts.every((conflict) => semanticFallbackConflictCodes.has(conflict.code));
+}
+
+function semanticFallbackConflictCode(result) {
+  return result.conflicts?.find((conflict) => semanticFallbackConflictCodes.has(conflict.code))?.code
+    ?? JsTsSafeMergeConflictCodes.changedExistingDeclaration;
+}
+
+function semanticFallbackChangedExistingDeclarations(topLevelResult, resultBase, stagedFallback) {
+  const conflictCount = (topLevelResult.conflicts ?? [])
+    .filter((conflict) => semanticFallbackConflictCodes.has(conflict.code)).length;
+  return Math.max(
+    topLevelResult.summary?.changedExistingDeclarations ?? 0,
+    resultBase?.summary?.changedExistingDeclarations ?? 0,
+    stagedFallback?.neutralization?.summary?.workerChangedExistingDeclarations ?? 0,
+    conflictCount
+  );
+}
+
+function semanticFallbackPhase(fallback) {
+  if (!fallback) return 'semantic-edit-fallback';
+  return fallback.projectionMode === 'direct'
+    ? 'staged-top-level-direct-semantic-edit-fallback'
+    : 'staged-top-level-semantic-edit-fallback';
+}
+
+export {
+  semanticFallbackChangedExistingDeclarations,
+  semanticFallbackConflictCode,
+  semanticFallbackPhase,
+  shouldTrySemanticEditFallback
+};

package/dist/js-ts-safe-merge-semantic-edit-fallback.js

@@ -2,7 +2,13 @@ import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
 import { createSemanticEditScript } from './internal/index-impl/semanticEditScripts.js';
 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 { JsTsSafeMergeStatuses } from './js-ts-safe-merge-constants.js';
+import {
+  semanticFallbackChangedExistingDeclarations,
+  semanticFallbackConflictCode,
+  semanticFallbackPhase,
+  shouldTrySemanticEditFallback
+} from './js-ts-safe-merge-semantic-edit-fallback-utils.js';
 import {
   createStagedDeclarationAlreadyAppliedReplay,
   createStagedDeclarationProjection,
@@ -14,9 +20,26 @@ import { idFragment, uniqueStrings } from './native-import-utils.js';
 function semanticEditFallbackResult(input, topLevelResult) {
   if (!shouldTrySemanticEditFallback(topLevelResult)) return topLevelResult;
   const stagedFallback = createStagedTopLevelSemanticFallback(input, topLevelResult);
-  const artifacts = createSemanticEditFallbackArtifacts(input, topLevelResult, stagedFallback);
+  let selectedFallback = stagedFallback;
+  let artifacts = createSemanticEditFallbackArtifacts(input, topLevelResult, stagedFallback);
+  if (stagedFallback && artifacts.status !== 'verified') {
+    const directFallback = stagedFallback.directProjectionHeadSourceText && stagedFallback.safeTopLevelChanges > 0
+      ? { ...stagedFallback, projectionMode: 'direct' }
+      : undefined;
+    const directArtifacts = createSemanticEditFallbackArtifacts(input, topLevelResult, directFallback);
+    if (directArtifacts.status === 'verified') {
+      artifacts = directArtifacts;
+      selectedFallback = directFallback;
+    } else if (directFallback) {
+      const plainDirectArtifacts = createSemanticEditFallbackArtifacts(input, topLevelResult, undefined);
+      if (plainDirectArtifacts.status === 'verified') {
+        artifacts = plainDirectArtifacts;
+        selectedFallback = undefined;
+      }
+    }
+  }
   if (artifacts.status !== 'verified') return semanticEditFallbackBlockedResult(input, topLevelResult, artifacts);
-  const resultBase = stagedFallback?.stagedTopLevelResult ?? topLevelResult;
+  const resultBase = selectedFallback?.stagedTopLevelResult ?? topLevelResult;
   const mergedSourceText = artifacts.projection.sourceText;
   const gates = semanticEditGates(artifacts);
   return {
@@ -38,7 +61,7 @@ function semanticEditFallbackResult(input, topLevelResult) {
     },
     summary: {
       ...resultBase.summary,
-      changedExistingDeclarations: semanticFallbackChangedExistingDeclarations(topLevelResult, resultBase, stagedFallback),
+      changedExistingDeclarations: semanticFallbackChangedExistingDeclarations(topLevelResult, resultBase, selectedFallback),
       conflicts: 0,
       gatesPassed: gates.filter((gate) => gate.status === 'passed').length,
       semanticEditOperations: artifacts.script.summary.operations,
@@ -49,58 +72,37 @@ function semanticEditFallbackResult(input, topLevelResult) {
     metadata: {
       ...resultBase.metadata,
       composed: {
-        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'],
+        phase: semanticFallbackPhase(selectedFallback),
+        phases: selectedFallback ? ['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
+        stagedTopLevelSummary: selectedFallback?.stagedTopLevelResult?.summary,
+        neutralization: selectedFallback?.neutralization?.summary
       }
     },
     semanticArtifacts: artifacts
   };
 }
 
-function shouldTrySemanticEditFallback(result) {
-  const conflicts = result.conflicts ?? [];
-  return conflicts.length > 0 && conflicts.every((conflict) => semanticFallbackConflictCodes.has(conflict.code));
-}
-
-const semanticFallbackConflictCodes = new Set([
-  JsTsSafeMergeConflictCodes.changedExistingDeclaration,
-  JsTsSafeMergeConflictCodes.typeAliasConflict
-]);
-
-function semanticFallbackConflictCode(result) {
-  return result.conflicts?.find((conflict) => semanticFallbackConflictCodes.has(conflict.code))?.code
-    ?? JsTsSafeMergeConflictCodes.changedExistingDeclaration;
-}
-
-function semanticFallbackChangedExistingDeclarations(topLevelResult, resultBase, stagedFallback) {
-  const conflictCount = (topLevelResult.conflicts ?? [])
-    .filter((conflict) => semanticFallbackConflictCodes.has(conflict.code)).length;
-  return Math.max(
-    topLevelResult.summary?.changedExistingDeclarations ?? 0,
-    resultBase?.summary?.changedExistingDeclarations ?? 0,
-    stagedFallback?.neutralization?.summary?.workerChangedExistingDeclarations ?? 0,
-    conflictCount
-  );
-}
-
 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 stagedDeclarationProjection = stagedFallback && stagedFallback.projectionMode !== 'direct';
     const scriptInput = stagedFallback?.scriptInput ?? input;
-    const projectionHeadSourceText = stagedFallback?.projectionHeadSourceText ?? input.headSourceText;
-    const replayCurrentSourceText = stagedFallback?.replayCurrentSourceText ?? input.headSourceText;
+    const projectionHeadSourceText = stagedFallback?.projectionMode === 'direct'
+      ? stagedFallback.directProjectionHeadSourceText
+      : stagedFallback?.projectionHeadSourceText ?? input.headSourceText;
+    const replayCurrentSourceText = stagedFallback?.projectionMode === 'direct'
+      ? stagedFallback.directReplayCurrentSourceText
+      : stagedFallback?.replayCurrentSourceText ?? input.headSourceText;
     const script = createSemanticEditScript({
       ...scriptInput,
       id: `${id}_semantic_edit`,
       language,
       sourcePath
     });
-    const projection = stagedFallback
+    const projection = stagedDeclarationProjection
       ? createStagedDeclarationProjection({ id, script, sourcePath, language, stagedFallback })
       : projectSemanticEditScriptToSource({
         id: `${id}_semantic_edit_projection`,
@@ -111,7 +113,7 @@ function createSemanticEditFallbackArtifacts(input, topLevelResult, stagedFallba
         parser: input.parser,
         metadata: stagedFallback?.metadata
       });
-    const replay = stagedFallback
+    const replay = stagedDeclarationProjection
       ? createStagedDeclarationReplayRecord({ id, projection, sourcePath, language, stagedFallback, replayCurrentSourceText })
       : replaySemanticEditProjection({
         id: `${id}_semantic_edit_replay`,
@@ -122,7 +124,7 @@ function createSemanticEditFallbackArtifacts(input, topLevelResult, stagedFallba
         parser: input.parser,
         metadata: stagedFallback?.metadata
       });
-    const alreadyAppliedReplay = stagedFallback
+    const alreadyAppliedReplay = stagedDeclarationProjection
       ? createStagedDeclarationAlreadyAppliedReplay({ id, projection, sourcePath, language })
       : replaySemanticEditProjection({
         id: `${id}_semantic_edit_already_applied`,
@@ -193,7 +195,7 @@ function semanticEditArtifacts(input) {
     metadata: {
       autoMergeClaim: false,
       semanticEquivalenceClaim: false,
-      source: input.stagedFallback ? 'js-ts-staged-top-level-semantic-edit-fallback' : 'js-ts-semantic-edit-fallback',
+      source: input.stagedFallback ? semanticFallbackPhase(input.stagedFallback) : 'js-ts-semantic-edit-fallback',
       originalReasonCodes: input.topLevelResult.admission?.reasonCodes ?? [],
       stagedTopLevelSummary: input.stagedFallback?.stagedTopLevelResult?.summary,
       neutralization: input.stagedFallback?.neutralization?.summary

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

@@ -14,11 +14,13 @@ function createStagedTopLevelSemanticFallback(input, topLevelResult) {
   if (stagedTopLevelResult.status !== JsTsSafeMergeStatuses.merged) return undefined;
   const safeTopLevelChanges = safeTopLevelChangeCount(stagedTopLevelResult.summary);
   const declarationReplay = createJsTsChangedDeclarationReplay(input, neutralization, stagedTopLevelResult.mergedSourceText);
+  const directSemanticHeadReplay = createJsTsChangedDeclarationReplay(input, neutralization, stagedTopLevelResult.mergedSourceText, 'head');
   const workerDeclarationChanges = neutralization.summary.workerChangedExistingDeclarations ?? 0;
   if (safeTopLevelChanges === 0 && workerDeclarationChanges === 0) return undefined;
   return {
     neutralization,
     declarationReplay,
+    safeTopLevelChanges,
     stagedTopLevelResult,
     scriptInput: {
       ...input,
@@ -28,13 +30,19 @@ function createStagedTopLevelSemanticFallback(input, topLevelResult) {
       headSourceHash: undefined
     },
     projectionHeadSourceText: stagedTopLevelResult.mergedSourceText,
+    directProjectionHeadSourceText: directSemanticHeadReplay.outputSourceText,
     replayCurrentSourceText: stagedTopLevelResult.mergedSourceText,
+    directReplayCurrentSourceText: directSemanticHeadReplay.outputSourceText,
     metadata: {
       stagedTopLevelSummary: stagedTopLevelResult.summary,
       declarationReplay: {
         edits: declarationReplay.edits.length,
         reasonCodes: declarationReplay.reasonCodes
       },
+      directSemanticHeadReplay: {
+        edits: directSemanticHeadReplay.edits.length,
+        reasonCodes: directSemanticHeadReplay.reasonCodes
+      },
       neutralization: neutralization.summary,
       originalReasonCodes: topLevelResult.admission?.reasonCodes ?? []
     }

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

@@ -42,7 +42,7 @@ function neutralizeJsTsSafeTopLevelMergeSources(input = {}) {
   };
 }
 
-function createJsTsChangedDeclarationReplay(input = {}, neutralization, currentSourceText) {
+function createJsTsChangedDeclarationReplay(input = {}, neutralization, currentSourceText, side = 'worker') {
   if (!neutralization?.ok || typeof currentSourceText !== 'string') {
     return { ok: false, reasonCodes: ['missing-neutralized-current-source'], edits: [] };
   }
@@ -56,15 +56,17 @@ function createJsTsChangedDeclarationReplay(input = {}, neutralization, currentS
   const workerMatches = matchedEntriesByBaseKey(neutralization.worker, baseEntries);
   const headMatches = matchedEntriesByBaseKey(neutralization.head, baseEntries);
   const currentMatches = matchedEntriesByBaseKey(current, baseEntries);
+  const sourceMatches = side === 'head' ? headMatches : workerMatches;
+  const guardMatches = side === 'head' ? undefined : headMatches;
   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 sourceEntry = sourceMatches.get(baseEntry.key);
+    if (!sourceEntry || sameStatementText(sourceEntry.text, baseEntry.text)) continue;
     const currentEntry = currentMatches.get(baseEntry.key);
-    if (!headEntry || !sameStatementText(headEntry.text, baseEntry.text)) {
+    const guardEntry = guardMatches?.get(baseEntry.key);
+    if (guardMatches && (!guardEntry || !sameStatementText(guardEntry.text, baseEntry.text))) {
       reasonCodes.push(`head-anchor-changed-since-base:${baseEntry.key}`);
       continue;
     }
@@ -74,12 +76,12 @@ function createJsTsChangedDeclarationReplay(input = {}, neutralization, currentS
     }
     edits.push({
       key: baseEntry.key,
-      names: workerEntry.names ?? baseEntry.names ?? [],
-      declarationKind: workerEntry.declarationInfo?.declarationKind ?? baseEntry.declarationInfo?.declarationKind,
+      names: sourceEntry.names ?? baseEntry.names ?? [],
+      declarationKind: sourceEntry.declarationInfo?.declarationKind ?? baseEntry.declarationInfo?.declarationKind,
       start: currentEntry.start,
       end: currentEntry.end,
       currentText: currentEntry.text,
-      replacementText: workerEntry.text
+      replacementText: sourceEntry.text
     });
   }
   return {

package/package.json

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