@shapeshift-labs/frontier-lang-compiler 0.2.146 → 0.2.148

package/dist/js-ts-safe-merge-independent-deletion-artifacts.js

@@ -0,0 +1,112 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import {
+  independentTopLevelDeletionOperation,
+  independentTopLevelDeletionProjection,
+  independentTopLevelDeletionReplay,
+  independentTopLevelDeletionScript
+} from './js-ts-safe-merge-independent-deletion-records.js';
+import { idFragment, uniqueStrings } from './native-import-utils.js';
+
+function createIndependentTopLevelDeletionArtifacts(input, topLevelResult, deletionPlan) {
+  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 operationId = `js_ts_independent_top_level_delete_${idFragment([id, deletionPlan.deletedEntry.key].join(':'))}`;
+  const operation = independentTopLevelDeletionOperation({ id, operationId, language, sourcePath, deletionPlan, input });
+  const script = independentTopLevelDeletionScript({ id, language, sourcePath, operation, input });
+  const projection = independentTopLevelDeletionProjection({ id, language, sourcePath, operation, script, deletionPlan, input });
+  const replay = independentTopLevelDeletionReplay({
+    id: `${id}_semantic_edit_replay`,
+    language,
+    sourcePath,
+    operation,
+    projection,
+    deletionPlan,
+    currentSourceText: input.headSourceText,
+    status: 'accepted-clean',
+    editStatus: 'applied',
+    reasonCodes: ['head-anchor-matches-base', 'independent-top-level-deletion'],
+    outputSourceText: deletionPlan.mergedSourceText
+  });
+  const alreadyAppliedReplay = independentTopLevelDeletionReplay({
+    id: `${id}_semantic_edit_already_applied`,
+    language,
+    sourcePath,
+    operation,
+    projection,
+    deletionPlan,
+    currentSourceText: deletionPlan.mergedSourceText,
+    status: 'already-applied',
+    editStatus: 'already-applied',
+    reasonCodes: ['independent-top-level-deletion-already-applied'],
+    outputSourceText: deletionPlan.mergedSourceText
+  });
+  const status = projection.status === 'projected'
+    && replay.status === 'accepted-clean'
+    && replay.outputSourceText === deletionPlan.mergedSourceText
+    && alreadyAppliedReplay.status === 'already-applied'
+    ? 'verified'
+    : 'blocked';
+  const reasonCodes = status === 'verified'
+    ? []
+    : uniqueStrings([
+      ...(projection.admission?.reasonCodes ?? []),
+      ...(replay.admission?.reasonCodes ?? []),
+      ...(alreadyAppliedReplay.admission?.reasonCodes ?? [])
+    ]);
+  const core = {
+    kind: 'frontier.lang.jsTsSafeMergeSemanticArtifacts',
+    version: 1,
+    schema: 'frontier.lang.jsTsSafeMergeSemanticArtifacts.v1',
+    id: `js_ts_safe_merge_semantic_edit_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
+    },
+    summary: {
+      operations: script.summary.operations,
+      edits: projection.edits.length,
+      replayStatus: replay.status,
+      alreadyAppliedReplayStatus: alreadyAppliedReplay.status,
+      projectedSourceMatchesMerged: projection.sourceText === deletionPlan.mergedSourceText,
+      replayOutputMatchesMerged: replay.outputSourceText === deletionPlan.mergedSourceText
+    },
+    evidence: [{
+      id: `evidence_${idFragment(id)}_independent_top_level_deletion`,
+      kind: 'js-ts-independent-top-level-deletion-replay',
+      status: status === 'verified' ? 'passed' : 'needs-review',
+      path: sourcePath,
+      summary: status === 'verified'
+        ? 'JS/TS independent top-level deletion replay verified 1 operation.'
+        : `JS/TS independent top-level deletion requires review: ${reasonCodes.join(', ')}.`,
+      metadata: {
+        autoMergeClaim: false,
+        semanticEquivalenceClaim: false,
+        deletedKey: deletionPlan.deletedEntry.key,
+        originalReasonCodes: topLevelResult.admission?.reasonCodes ?? []
+      }
+    }],
+    metadata: {
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      source: 'independent-top-level-deletion-fallback',
+      originalReasonCodes: topLevelResult.admission?.reasonCodes ?? [],
+      deletion: deletionPlan.summary
+    }
+  };
+  return { ...core, hash: hashSemanticValue(core) };
+}
+
+export { createIndependentTopLevelDeletionArtifacts };

package/dist/js-ts-safe-merge-independent-deletion-fallback.js

@@ -0,0 +1,53 @@
+import { JsTsSafeMergeStatuses } from './js-ts-safe-merge-constants.js';
+import { createIndependentTopLevelDeletionArtifacts } from './js-ts-safe-merge-independent-deletion-artifacts.js';
+import { createIndependentTopLevelDeletionPlan } from './js-ts-safe-merge-independent-deletion-plan.js';
+import { semanticEditGates } from './js-ts-safe-merge-semantic-edit-gates.js';
+
+function independentTopLevelDeletionFallbackResult(input, topLevelResult) {
+  const deletionPlan = createIndependentTopLevelDeletionPlan(input, topLevelResult);
+  if (!deletionPlan.ok) return undefined;
+  const artifacts = createIndependentTopLevelDeletionArtifacts(input, topLevelResult, deletionPlan);
+  if (artifacts.status !== 'verified') return undefined;
+  const gates = semanticEditGates(artifacts);
+  return {
+    ...topLevelResult,
+    id: String(input.id ?? topLevelResult.id ?? 'js_ts_safe_merge'),
+    status: JsTsSafeMergeStatuses.merged,
+    mergedSourceText: deletionPlan.mergedSourceText,
+    outputSourceText: deletionPlan.mergedSourceText,
+    conflicts: [],
+    gates,
+    admission: {
+      status: 'auto-merge-candidate',
+      action: 'apply',
+      reviewRequired: false,
+      autoApplyCandidate: true,
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      reasonCodes: []
+    },
+    summary: {
+      ...topLevelResult.summary,
+      changedExistingDeclarations: 0,
+      conflicts: 0,
+      gatesPassed: gates.filter((gateRecord) => gateRecord.status === 'passed').length,
+      topLevelDeclarationDeletions: 1,
+      semanticEditOperations: artifacts.script.summary.operations,
+      semanticEditAppliedOperations: artifacts.replay.summary.applied,
+      semanticEditReplayStatus: artifacts.replay.status,
+      composedPhases: 2
+    },
+    metadata: {
+      ...topLevelResult.metadata,
+      composed: {
+        phase: 'independent-top-level-deletion-fallback',
+        phases: ['top-level-ledger', 'independent-top-level-deletion'],
+        originalReasonCodes: topLevelResult.admission?.reasonCodes ?? [],
+        deletion: deletionPlan.summary
+      }
+    },
+    semanticArtifacts: artifacts
+  };
+}
+
+export { independentTopLevelDeletionFallbackResult };

package/dist/js-ts-safe-merge-independent-deletion-plan.js

@@ -0,0 +1,156 @@
+import { JsTsSafeMergeConflictCodes } from './js-ts-safe-merge-constants.js';
+import { sameStatementText } from './js-ts-safe-merge-context.js';
+import { scanJsTsTopLevelLedger } from './js-ts-safe-merge-ledger.js';
+import { uniqueStrings } from './native-import-utils.js';
+
+function createIndependentTopLevelDeletionPlan(input, topLevelResult) {
+  const originalReasonCodes = topLevelResult?.admission?.reasonCodes ?? [];
+  if (!originalReasonCodes.includes(JsTsSafeMergeConflictCodes.topLevelOrderChanged)) {
+    return { ok: false, reasonCodes: ['top-level-order-not-deletion-shaped'] };
+  }
+  const allowedOriginalReasonCodes = new Set([
+    JsTsSafeMergeConflictCodes.topLevelOrderChanged,
+    JsTsSafeMergeConflictCodes.changedExistingDeclaration,
+    JsTsSafeMergeConflictCodes.typeAliasConflict
+  ]);
+  if (originalReasonCodes.some((reason) => !allowedOriginalReasonCodes.has(reason))) {
+    return { ok: false, reasonCodes: ['top-level-deletion-has-unsafe-original-conflict'] };
+  }
+  if (typeof input.baseSourceText !== 'string'
+    || typeof input.workerSourceText !== 'string'
+    || typeof input.headSourceText !== 'string') {
+    return { ok: false, reasonCodes: ['missing-source-text'] };
+  }
+
+  const context = quietDeletionLedgerContext(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: uniqueStrings(context.conflicts.map((conflict) => conflict.code)) };
+  }
+
+  const duplicateLedgerReason = firstDuplicateLedgerReason(base, worker, head);
+  if (duplicateLedgerReason) return { ok: false, reasonCodes: [duplicateLedgerReason] };
+
+  const baseByKey = entriesByKey(base.entries);
+  const workerByKey = entriesByKey(worker.entries);
+  const headByKey = entriesByKey(head.entries);
+  const baseKeys = base.entries.map((entry) => entry.key);
+  const missingWorkerBaseEntries = base.entries.filter((entry) => !workerByKey.has(entry.key));
+  const deletedWorkerEntries = missingWorkerBaseEntries.filter((entry) => entry.kind !== 'import');
+  const workerAddedEntries = worker.entries.filter((entry) => !baseByKey.has(entry.key));
+  if (missingWorkerBaseEntries.length !== 1
+    || deletedWorkerEntries.length !== 1
+    || workerAddedEntries.length !== 0) {
+    return { ok: false, reasonCodes: ['worker-top-level-deletion-not-isolated'] };
+  }
+
+  const deletedEntry = deletedWorkerEntries[0];
+  if (deletedEntry.kind !== 'declaration' || deletedEntry.declarationInfo?.exported === true) {
+    return { ok: false, reasonCodes: ['exported-or-unsupported-top-level-deletion'] };
+  }
+  if (isUnsupportedTopLevelDeletion(deletedEntry)) {
+    return { ok: false, reasonCodes: ['unsupported-top-level-deletion-declaration'] };
+  }
+
+  const expectedWorkerKeys = base.entries
+    .filter((entry) => entry.key !== deletedEntry.key)
+    .map((entry) => entry.key);
+  if (!sameStringList(worker.entries.map((entry) => entry.key), expectedWorkerKeys)) {
+    return { ok: false, reasonCodes: ['worker-top-level-deletion-order-changed'] };
+  }
+  for (const baseEntry of base.entries) {
+    if (baseEntry.key === deletedEntry.key) continue;
+    const workerEntry = workerByKey.get(baseEntry.key);
+    if (!workerEntry || !sameStatementText(workerEntry.text, baseEntry.text)) {
+      return { ok: false, reasonCodes: [`worker-changed-nondeleted-entry:${baseEntry.key}`] };
+    }
+  }
+
+  const headProjectedBaseKeys = head.entries
+    .filter((entry) => baseByKey.has(entry.key))
+    .map((entry) => entry.key);
+  if (!sameStringList(headProjectedBaseKeys, baseKeys)) {
+    return { ok: false, reasonCodes: ['head-base-order-or-presence-changed'] };
+  }
+
+  const headEntry = headByKey.get(deletedEntry.key);
+  if (!headEntry) return { ok: false, reasonCodes: [`head-anchor-missing:${deletedEntry.key}`] };
+  if (!sameStatementText(headEntry.text, deletedEntry.text)) {
+    return { ok: false, reasonCodes: [`head-anchor-changed-since-base:${deletedEntry.key}`] };
+  }
+
+  const edit = deleteEntryEdit(input.headSourceText, headEntry);
+  const deletedText = input.headSourceText.slice(edit.start, edit.end);
+  const mergedSourceText = applySourceEdits(input.headSourceText, [edit]);
+  return {
+    ok: true,
+    base,
+    worker,
+    head,
+    deletedEntry,
+    headEntry,
+    edit,
+    deletedText,
+    mergedSourceText,
+    summary: {
+      key: deletedEntry.key,
+      name: deletedEntry.names?.[0],
+      declarationKind: deletedEntry.declarationInfo?.declarationKind,
+      exported: false,
+      reasonCodes: ['head-anchor-matches-base', 'independent-top-level-deletion']
+    }
+  };
+}
+
+function quietDeletionLedgerContext(input) {
+  return {
+    id: String(input.id ?? 'js_ts_safe_merge'),
+    sourcePath: input.sourcePath,
+    language: input.language ?? 'typescript',
+    conflicts: [],
+    blockedGateIds: new Set(),
+    gateReasonCodes: new Map()
+  };
+}
+
+function firstDuplicateLedgerReason(...ledgers) {
+  for (const ledger of ledgers) {
+    const seen = new Set();
+    for (const entry of ledger.entries) {
+      if (seen.has(entry.key)) return `duplicate-ledger-key:${ledger.label}:${entry.key}`;
+      seen.add(entry.key);
+    }
+  }
+  return undefined;
+}
+
+function entriesByKey(entries) {
+  return new Map(entries.map((entry) => [entry.key, entry]));
+}
+
+function isUnsupportedTopLevelDeletion(entry) {
+  if (entry.declarationInfo?.declarationKind === 'module') return true;
+  return /^\s*(?:export\s+)?declare\b/.test(entry.text ?? '');
+}
+
+function sameStringList(left, right) {
+  return left.length === right.length && left.every((value, index) => value === right[index]);
+}
+
+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 = /^[\t ]*$/.test(sourceText.slice(lineStart, entry.start)) ? lineStart : entry.start;
+  return { start, end, 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);
+}
+
+export { createIndependentTopLevelDeletionPlan };

package/dist/js-ts-safe-merge-independent-deletion-records.js

@@ -0,0 +1,251 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import { idFragment } from './native-import-utils.js';
+
+function independentTopLevelDeletionOperation(input) {
+  const entry = input.deletionPlan.deletedEntry;
+  const name = entry.names?.[0] ?? entry.key;
+  const symbolKind = entry.declarationInfo?.declarationKind ?? 'declaration';
+  const anchorKey = `source#${input.sourcePath}#declaration#${name}`;
+  const operation = {
+    id: input.operationId,
+    kind: 'jsTsRemoveTopLevelDeclaration',
+    changeKind: 'removed',
+    anchor: {
+      key: anchorKey,
+      conflictKey: `declaration:${entry.key}`,
+      regionId: anchorKey,
+      regionKind: 'declaration',
+      granularity: 'js-ts-ledger-entry',
+      language: input.language,
+      sourcePath: input.sourcePath,
+      symbolId: anchorKey,
+      symbolName: name,
+      symbolKind,
+      sourceSpan: { start: input.deletionPlan.headEntry.start, end: input.deletionPlan.headEntry.end }
+    },
+    spans: {
+      base: { start: entry.start, end: entry.end },
+      head: { start: input.deletionPlan.headEntry.start, end: input.deletionPlan.headEntry.end }
+    },
+    hashes: {
+      baseSourceHash: input.input.baseHash,
+      workerSourceHash: input.input.workerHash,
+      headSourceHash: input.input.headHash,
+      baseTextHash: hashSemanticValue(entry.text),
+      headTextHash: hashSemanticValue(input.deletionPlan.headEntry.text),
+      workerTextHash: hashSemanticValue('')
+    },
+    status: 'portable',
+    readiness: 'ready',
+    confidence: 1,
+    reasonCodes: ['head-anchor-matches-base', 'independent-top-level-deletion'],
+    evidenceIds: [`evidence_${idFragment(input.id)}_independent_top_level_deletion`],
+    metadata: {
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      ledgerKey: entry.key,
+      exported: false
+    }
+  };
+  return { ...operation, operationContentHash: hashSemanticValue(operation) };
+}
+
+function independentTopLevelDeletionScript(input) {
+  const core = {
+    kind: 'frontier.lang.semanticEditScript',
+    version: 1,
+    schema: 'frontier.lang.semanticEditScript.v1',
+    id: `${input.id}_semantic_edit`,
+    stableId: `semantic_edit_script_${idFragment([input.id, input.operation.operationContentHash].join(':'))}`,
+    language: input.language,
+    sourcePath: input.sourcePath,
+    baseHash: input.input.baseHash,
+    workerHash: input.input.workerHash,
+    headHash: input.input.headHash,
+    operations: [input.operation],
+    summary: {
+      operations: 1,
+      byStatus: { portable: 1 },
+      byKind: { jsTsRemoveTopLevelDeclaration: 1 },
+      portable: 1,
+      alreadyApplied: 0,
+      needsPort: 0,
+      conflicts: 0,
+      stale: 0,
+      blocked: 0,
+      candidates: 0,
+      autoMergeCandidates: 1,
+      operationContentHashes: [input.operation.operationContentHash]
+    },
+    admission: {
+      status: 'auto-merge-candidate',
+      action: 'run-gates-and-apply',
+      reviewRequired: false,
+      autoApplyCandidate: true,
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      reasonCodes: input.operation.reasonCodes,
+      conflictKeys: [input.operation.anchor.conflictKey],
+      evidenceIds: input.operation.evidenceIds
+    },
+    evidence: [{
+      id: `evidence_${idFragment(input.id)}_independent_top_level_deletion_script`,
+      kind: 'semantic-edit-script',
+      status: 'passed',
+      path: input.sourcePath,
+      summary: 'Created independent top-level deletion script with 1 operation.',
+      metadata: {
+        autoMergeClaim: false,
+        semanticEquivalenceClaim: false
+      }
+    }],
+    metadata: {
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      source: 'independent-top-level-deletion-fallback'
+    }
+  };
+  return { ...core, hash: hashSemanticValue(core) };
+}
+
+function independentTopLevelDeletionProjection(input) {
+  const editContentHash = hashSemanticValue({
+    operationId: input.operation.id,
+    deletedText: input.deletionPlan.deletedText,
+    replacementText: ''
+  });
+  const edit = {
+    operationId: input.operation.id,
+    status: 'applied',
+    kind: input.operation.kind,
+    editKind: 'delete',
+    changeKind: 'removed',
+    anchorKey: input.operation.anchor.key,
+    conflictKey: input.operation.anchor.conflictKey,
+    regionId: input.operation.anchor.regionId,
+    regionKind: input.operation.anchor.regionKind,
+    sourcePath: input.sourcePath,
+    symbolId: input.operation.anchor.symbolId,
+    symbolName: input.operation.anchor.symbolName,
+    symbolKind: input.operation.anchor.symbolKind,
+    operationContentHash: input.operation.operationContentHash,
+    editContentHash,
+    headStart: input.deletionPlan.edit.start,
+    headEnd: input.deletionPlan.edit.end,
+    editOrder: 0,
+    deletedBytes: input.deletionPlan.deletedText.length,
+    replacementBytes: 0,
+    deletedTextHash: hashSemanticValue(input.deletionPlan.deletedText),
+    replacementTextHash: hashSemanticValue(''),
+    deletedTextLineEndingStableHash: lineEndingStableTextHash(input.deletionPlan.deletedText),
+    replacementTextLineEndingStableHash: lineEndingStableTextHash(''),
+    replacementText: ''
+  };
+  const core = {
+    kind: 'frontier.lang.semanticEditProjection',
+    version: 1,
+    id: `${input.id}_semantic_edit_projection`,
+    scriptId: input.script.id,
+    status: 'projected',
+    sourcePath: input.sourcePath,
+    language: input.language,
+    baseHash: input.input.baseHash,
+    workerHash: input.input.workerHash,
+    headHash: input.input.headHash,
+    projectedHash: hashSemanticValue(input.deletionPlan.mergedSourceText),
+    appliedOperations: [input.operation.id],
+    skippedOperations: [],
+    edits: [edit],
+    sourceText: input.deletionPlan.mergedSourceText,
+    admission: {
+      status: 'auto-merge-candidate',
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      reasonCodes: []
+    },
+    metadata: {
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      source: 'independent-top-level-deletion-fallback'
+    }
+  };
+  return { ...core, hash: hashSemanticValue(core) };
+}
+
+function independentTopLevelDeletionReplay(input) {
+  const applied = input.editStatus === 'applied';
+  const edit = {
+    operationId: input.operation.id,
+    editKind: 'delete',
+    editOrder: 0,
+    sourcePath: input.sourcePath,
+    symbolName: input.operation.anchor.symbolName,
+    symbolKind: input.operation.anchor.symbolKind,
+    status: input.editStatus,
+    start: applied ? input.deletionPlan.edit.start : undefined,
+    end: applied ? input.deletionPlan.edit.end : undefined,
+    replacementBytes: 0,
+    replacementText: '',
+    reasonCodes: input.reasonCodes
+  };
+  const core = {
+    kind: 'frontier.lang.semanticEditReplay',
+    version: 1,
+    schema: 'frontier.lang.semanticEditReplay.v1',
+    id: input.id,
+    projectionId: input.projection.id,
+    scriptId: input.projection.scriptId,
+    sourcePath: input.sourcePath,
+    language: input.language,
+    currentHash: hashSemanticValue(input.currentSourceText),
+    projectedHash: input.projection.projectedHash,
+    outputHash: hashSemanticValue(input.outputSourceText),
+    status: input.status,
+    edits: [edit],
+    appliedOperations: applied ? [input.operation.id] : [],
+    skippedOperations: applied ? [] : [input.operation.id],
+    admission: {
+      status: input.status,
+      action: applied ? 'apply' : 'skip',
+      reviewRequired: false,
+      autoApplyCandidate: applied,
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      reasonCodes: []
+    },
+    outputSourceText: input.outputSourceText,
+    summary: {
+      edits: 1,
+      applied: applied ? 1 : 0,
+      alreadyApplied: applied ? 0 : 1,
+      conflicts: 0,
+      stale: 0,
+      blocked: 0,
+      reasonCodes: []
+    },
+    metadata: {
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      source: 'independent-top-level-deletion-fallback'
+    }
+  };
+  return { ...core, hash: hashSemanticValue(core) };
+}
+
+function lineEndingStableTextHash(value) {
+  const normalized = lineEndingStableText(value);
+  return normalized === undefined ? undefined : hashSemanticValue(normalized);
+}
+
+function lineEndingStableText(value) {
+  if (typeof value !== 'string') return undefined;
+  const normalized = value.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+  return normalized.length > 1 && normalized.endsWith('\n') ? normalized.slice(0, -1) : normalized;
+}
+
+export {
+  independentTopLevelDeletionOperation,
+  independentTopLevelDeletionProjection,
+  independentTopLevelDeletionReplay,
+  independentTopLevelDeletionScript
+};

package/dist/js-ts-safe-merge-semantic-edit-already-applied.js

@@ -0,0 +1,127 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import { uniqueStrings } from './native-import-utils.js';
+
+function normalizeAlreadyAppliedDeleteReplay(input) {
+  if (!isProjectedDeleteAlreadyAppliedReplay(input)) return input.alreadyAppliedReplay;
+  const { hash: _hash, ...alreadyAppliedReplay } = input.alreadyAppliedReplay;
+  const normalizedEdits = input.alreadyAppliedReplay.edits.map((edit) => alreadyAppliedDeleteEdit(edit));
+  const reasonCodes = uniqueStrings(normalizedEdits.flatMap((edit) => edit.reasonCodes ?? []));
+  const core = {
+    ...alreadyAppliedReplay,
+    currentHash: input.projection.projectedHash,
+    outputHash: input.projection.projectedHash,
+    status: 'already-applied',
+    edits: normalizedEdits,
+    appliedOperations: [],
+    skippedOperations: normalizedEdits.map((edit) => edit.operationId).filter(Boolean),
+    diagnostics: [],
+    admission: {
+      status: 'already-applied',
+      action: 'skip',
+      reviewRequired: false,
+      autoApplyCandidate: false,
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      reasonCodes
+    },
+    outputSourceText: input.projection.sourceText,
+    summary: {
+      edits: normalizedEdits.length,
+      applied: 0,
+      alreadyApplied: normalizedEdits.length,
+      conflicts: 0,
+      stale: 0,
+      blocked: 0,
+      reasonCodes
+    },
+    metadata: {
+      ...input.alreadyAppliedReplay.metadata,
+      normalizedAlreadyAppliedReplay: 'projected-delete-anchor-absent'
+    }
+  };
+  return { ...core, hash: hashSemanticValue(core) };
+}
+
+function isProjectedDeleteAlreadyAppliedReplay(input) {
+  if (input.projection?.status !== 'projected') return false;
+  if (input.replay?.status !== 'accepted-clean') return false;
+  if (input.replay.outputSourceText !== input.projection.sourceText) return false;
+  const replay = input.alreadyAppliedReplay;
+  if (replay?.status !== 'stale') return false;
+  if (replay.currentHash !== input.projection.projectedHash) return false;
+  const edits = replay.edits ?? [];
+  if (!edits.length) return false;
+  const appliedDeleteIds = new Set((input.replay.edits ?? [])
+    .filter((edit) => edit.status === 'applied' && edit.editKind === 'delete')
+    .map((edit) => edit.operationId));
+  const projectionDeleteIds = new Set((input.projection.edits ?? [])
+    .filter((edit) => edit.editKind === 'delete')
+    .map((edit) => edit.operationId));
+  const staleDeletes = edits.filter(isProjectedDeleteMissingAnchor);
+  if (hasUnsafeProjectedDeleteCompanions(input, staleDeletes)) return false;
+  return staleDeletes.length > 0
+    && edits.every((edit) => edit.status === 'already-applied' || isProjectedDeleteMissingAnchor(edit))
+    && staleDeletes.every((edit) => appliedDeleteIds.has(edit.operationId) && projectionDeleteIds.has(edit.operationId));
+}
+
+function isProjectedDeleteMissingAnchor(edit) {
+  return edit.editKind === 'delete'
+    && edit.status === 'stale'
+    && (edit.reasonCodes ?? []).includes('current-symbol-anchor-missing');
+}
+
+function alreadyAppliedDeleteEdit(edit) {
+  if (!isProjectedDeleteMissingAnchor(edit)) return edit;
+  return {
+    ...edit,
+    status: 'already-applied',
+    reasonCodes: ['projected-delete-anchor-absent'],
+    diagnostics: []
+  };
+}
+
+function hasUnsafeProjectedDeleteCompanions(input, staleDeletes) {
+  const projectionEdits = input.projection?.edits ?? [];
+  if (!projectionEdits.length || !staleDeletes.length) return false;
+  const projectionDeleteById = new Map(projectionEdits
+    .filter((edit) => edit.editKind === 'delete')
+    .map((edit) => [edit.operationId, edit]));
+  for (const staleDelete of staleDeletes) {
+    const projectedDelete = projectionDeleteById.get(staleDelete.operationId);
+    const scope = memberBodyDeleteScope(projectedDelete ?? staleDelete);
+    if (!scope) continue;
+    const companions = projectionEdits.filter((edit) => (
+      edit.operationId !== staleDelete.operationId
+        && edit.editKind !== 'delete'
+        && symbolContainerName(edit.symbolName) === scope.container
+    ));
+    if (!companions.length) return true;
+    const bodyInserts = companions.filter((edit) => (
+      edit.editKind === 'insert'
+        && edit.regionKind === scope.regionKind
+        && edit.symbolKind === scope.symbolKind
+    ));
+    if (bodyInserts.length === 0) return true;
+    if (companions.some((edit) => !bodyInserts.includes(edit))) return true;
+  }
+  return false;
+}
+
+function memberBodyDeleteScope(edit) {
+  if (edit?.editKind !== 'delete' || edit?.regionKind !== 'body') return undefined;
+  const container = symbolContainerName(edit.symbolName);
+  if (!container) return undefined;
+  return {
+    container,
+    regionKind: edit.regionKind,
+    symbolKind: edit.symbolKind
+  };
+}
+
+function symbolContainerName(symbolName) {
+  const normalized = String(symbolName ?? '').split(':controlFlow:')[0];
+  const separator = normalized.lastIndexOf('.');
+  return separator === -1 ? undefined : normalized.slice(0, separator);
+}
+
+export { normalizeAlreadyAppliedDeleteReplay };

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

@@ -3,12 +3,15 @@ import { createSemanticEditScript } from './internal/index-impl/semanticEditScri
 import { projectSemanticEditScriptToSource } from './internal/index-impl/projectSemanticEditScriptToSource.js';
 import { replaySemanticEditProjection } from './internal/index-impl/replaySemanticEditProjection.js';
 import { JsTsSafeMergeStatuses } from './js-ts-safe-merge-constants.js';
+import { independentTopLevelDeletionFallbackResult } from './js-ts-safe-merge-independent-deletion-fallback.js';
+import { normalizeAlreadyAppliedDeleteReplay } from './js-ts-safe-merge-semantic-edit-already-applied.js';
 import {
   semanticFallbackChangedExistingDeclarations,
   semanticFallbackConflictCode,
   semanticFallbackPhase,
   shouldTrySemanticEditFallback
 } from './js-ts-safe-merge-semantic-edit-fallback-utils.js';
+import { semanticEditGates } from './js-ts-safe-merge-semantic-edit-gates.js';
 import {
   createStagedDeclarationAlreadyAppliedReplay,
   createStagedDeclarationProjection,
@@ -19,6 +22,8 @@ import { createSourceShapeSemanticFallbackResult } from './js-ts-safe-merge-sour
 import { idFragment, uniqueStrings } from './native-import-utils.js';
 
 function semanticEditFallbackResult(input, topLevelResult) {
+  const independentDeletionResult = independentTopLevelDeletionFallbackResult(input, topLevelResult);
+  if (independentDeletionResult) return independentDeletionResult;
   if (!shouldTrySemanticEditFallback(topLevelResult)) return topLevelResult;
   const stagedFallback = createStagedTopLevelSemanticFallback(input, topLevelResult);
   const candidates = semanticFallbackCandidates(stagedFallback);
@@ -132,14 +137,18 @@ function createSemanticEditFallbackArtifacts(input, topLevelResult, stagedFallba
       });
     const alreadyAppliedReplay = stagedDeclarationProjection
       ? createStagedDeclarationAlreadyAppliedReplay({ id, projection, sourcePath, language })
-      : replaySemanticEditProjection({
-        id: `${id}_semantic_edit_already_applied`,
+      : normalizeAlreadyAppliedDeleteReplay({
         projection,
-        currentSourceText: projection.sourceText,
-        currentSourcePath: sourcePath,
-        currentSourceHash: projection.projectedHash,
-        language,
-        parser: input.parser
+        replay,
+        alreadyAppliedReplay: replaySemanticEditProjection({
+          id: `${id}_semantic_edit_already_applied`,
+          projection,
+          currentSourceText: projection.sourceText,
+          currentSourcePath: sourcePath,
+          currentSourceHash: projection.projectedHash,
+          language,
+          parser: input.parser
+        })
       });
     return semanticEditArtifacts({
       id,
@@ -301,19 +310,4 @@ function semanticEditFallbackBlockedResult(input, topLevelResult, artifacts) {
   };
 }
 
-function semanticEditGates(artifacts) {
-  return [
-    gate('semantic-edit-script', artifacts.script?.admission?.status === 'auto-merge-candidate', artifacts.script?.admission?.reasonCodes),
-    gate('semantic-edit-projection', artifacts.projection?.status === 'projected', artifacts.projection?.admission?.reasonCodes),
-    gate('semantic-edit-replay', artifacts.replay?.status === 'accepted-clean', artifacts.replay?.admission?.reasonCodes),
-    gate('semantic-edit-already-applied', artifacts.alreadyAppliedReplay?.status === 'already-applied', artifacts.alreadyAppliedReplay?.admission?.reasonCodes)
-  ];
-}
-
-function gate(id, passed, reasonCodes = []) {
-  return { id, status: passed ? 'passed' : 'blocked', reasonCodes: passed ? [] : uniqueStrings(reasonCodes) };
-}
-
-export {
-  semanticEditFallbackResult
-};
+export { semanticEditFallbackResult };

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

@@ -0,0 +1,16 @@
+import { uniqueStrings } from './native-import-utils.js';
+
+function semanticEditGates(artifacts) {
+  return [
+    gate('semantic-edit-script', artifacts.script?.admission?.status === 'auto-merge-candidate', artifacts.script?.admission?.reasonCodes),
+    gate('semantic-edit-projection', artifacts.projection?.status === 'projected', artifacts.projection?.admission?.reasonCodes),
+    gate('semantic-edit-replay', artifacts.replay?.status === 'accepted-clean', artifacts.replay?.admission?.reasonCodes),
+    gate('semantic-edit-already-applied', artifacts.alreadyAppliedReplay?.status === 'already-applied', artifacts.alreadyAppliedReplay?.admission?.reasonCodes)
+  ];
+}
+
+function gate(id, passed, reasonCodes = []) {
+  return { id, status: passed ? 'passed' : 'blocked', reasonCodes: passed ? [] : uniqueStrings(reasonCodes) };
+}
+
+export { semanticEditGates };

package/package.json

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