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

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

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