@shapeshift-labs/frontier-lang-compiler 0.2.145 → 0.2.147

package/dist/internal/index-impl/syntaxDeclaration.js

@@ -15,6 +15,29 @@ export function syntaxDeclaration(node, nativeNodeId, input) {
   if (kind === 'ClassDeclaration') return namedDeclaration(input, nativeNodeId, node.id, 'class');
   if (kind === 'TSInterfaceDeclaration' || kind === 'InterfaceDeclaration') return namedDeclaration(input, nativeNodeId, node.id, 'interface');
   if (kind === 'TSTypeAliasDeclaration' || kind === 'TypeAliasDeclaration') return namedDeclaration(input, nativeNodeId, node.id, 'type');
+  if (kind === 'TSModuleDeclaration' || kind === 'ModuleDeclaration') return syntaxModuleDeclaration(input, nativeNodeId, node);
   if (kind === 'VariableDeclarator') return namedDeclaration(input, nativeNodeId, node.id, 'variable');
   return undefined;
 }
+
+function syntaxModuleDeclaration(input, nativeNodeId, node) {
+  const name = syntaxName(node.id ?? node.name);
+  if (!name) return undefined;
+  return {
+    ...declarationRecord(input, nativeNodeId, name, 'module', 'definition'),
+    metadata: {
+      scan: 'syntax-module-declaration',
+      moduleName: name,
+      namespace: name
+    }
+  };
+}
+
+function syntaxName(node) {
+  if (!node) return undefined;
+  if (typeof node === 'string') return node;
+  if (typeof node.name === 'string') return node.name;
+  if (typeof node.value === 'string') return node.value;
+  if (typeof node.text === 'string') return node.text;
+  return undefined;
+}

package/dist/internal/index-impl/typeScriptDeclaration.js

@@ -14,6 +14,7 @@ export function typeScriptDeclaration(node, kind, nativeNodeId, input, options =
   if (kind === 'ClassDeclaration') return declarationWithExports(enrich(namedDeclaration(input, nativeNodeId, node.name, 'class')), exportedEntries, enrich, node);
   if (kind === 'InterfaceDeclaration') return declarationWithExports(enrich(namedDeclaration(input, nativeNodeId, node.name, 'interface')), exportedEntries, enrich, node);
   if (kind === 'TypeAliasDeclaration' || kind === 'EnumDeclaration') return declarationWithExports(enrich(namedDeclaration(input, nativeNodeId, node.name, 'type')), exportedEntries, enrich, node);
+  if (kind === 'ModuleDeclaration') return declarationWithExports(enrich(moduleDeclaration(input, nativeNodeId, node), node.name ?? node), exportedEntries, enrich, node);
   if (kind === 'VariableDeclaration') return enrich(namedDeclaration(input, nativeNodeId, node.name, 'variable'));
   if (kind === 'MethodDeclaration' || kind === 'MethodSignature') return enrich(namedDeclaration(input, nativeNodeId, node.name, 'method'));
   return undefined;
@@ -25,6 +26,19 @@ function declarationWithExports(declaration, exportedEntries, enrich, node) {
   return exports.length ? [declaration, ...exports] : declaration;
 }
 
+function moduleDeclaration(input, nativeNodeId, node) {
+  const name = stringFromTsExpression(node.name);
+  if (!name) return undefined;
+  return {
+    ...declarationRecord(input, nativeNodeId, name, 'module', 'definition'),
+    metadata: compactRecord({
+      scan: 'typescript-module-declaration',
+      moduleName: name,
+      namespace: name
+    })
+  };
+}
+
 function enrichTypeScriptDeclaration(node, symbolNode, declaration, input, options) {
   if (!declaration) return declaration;
   const checker = options.typeChecker ?? options.checker ?? options.program?.getTypeChecker?.();

package/dist/internal/index-impl/typeScriptExportedDeclarationEntries.js

@@ -92,6 +92,7 @@ function exportedSymbolKind(kind) {
   if (kind === 'ClassDeclaration') return 'class';
   if (kind === 'InterfaceDeclaration') return 'interface';
   if (kind === 'TypeAliasDeclaration' || kind === 'EnumDeclaration') return 'type';
+  if (kind === 'ModuleDeclaration') return 'module';
   return undefined;
 }
 

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,148 @@
+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'] };
+  }
+
+  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 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,82 @@
+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);
+  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: []
+  };
+}
+
+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/dist/js-ts-safe-project-merge-graph.js

@@ -1,6 +1,7 @@
 import { idFragment } from './native-import-utils.js';
 import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
 import { compactRecord } from './js-ts-safe-merge-context.js';
+import { augmentProjectSymbolGraphPublicContracts } from './js-ts-safe-project-merge-public-contracts.js';
 import { createNativeProjectImportResult } from './internal/index-impl/createNativeProjectImportResult.js';
 import { importNativeSource } from './internal/index-impl/importNativeSource.js';
 import {
@@ -92,22 +93,26 @@ function createProjectGraphStageArtifacts(input, files, mergeId, stageName, stag
       ...(stageName === 'output' ? { outputProjectImportSource: projectGraphImportSource } : {})
     }
   }, imports);
-  const edgeLimitConflicts = projectGraphEdgeLimitConflicts(limits, stageName, projectImport.projectSymbolGraph);
+  const projectSymbolGraph = augmentProjectSymbolGraphPublicContracts(projectImport.projectSymbolGraph, files, input, stageName);
+  const stageProjectImport = projectSymbolGraph === projectImport.projectSymbolGraph
+    ? projectImport
+    : attachProjectSymbolGraph(projectImport, projectSymbolGraph);
+  const edgeLimitConflicts = projectGraphEdgeLimitConflicts(limits, stageName, projectSymbolGraph);
   const serialized = projectGraphSerializedLimitConflict(limits, stageName, {
-    projectImport,
-    projectSymbolGraph: projectImport.projectSymbolGraph
+    projectImport: stageProjectImport,
+    projectSymbolGraph
   });
   const limitConflicts = [...edgeLimitConflicts, serialized.conflict].filter(Boolean);
   if (limitConflicts.length) {
-    return limitedProjectGraphStage(stageName, projectGraphImportSource, sourceStats, projectImport.projectSymbolGraph, limitConflicts, serialized.serializedBytes);
+    return limitedProjectGraphStage(stageName, projectGraphImportSource, sourceStats, projectSymbolGraph, limitConflicts, serialized.serializedBytes);
   }
   return {
     kind: 'frontier.lang.jsTsProjectGraphStage',
     version: 1,
     stage: stageName,
-    projectImport,
-    projectSymbolGraph: projectImport.projectSymbolGraph,
-    summary: projectGraphStageSummary(stageName, projectImport.projectSymbolGraph, projectGraphImportSource, sourceStats, serialized.serializedBytes, [])
+    projectImport: stageProjectImport,
+    projectSymbolGraph,
+    summary: projectGraphStageSummary(stageName, projectSymbolGraph, projectGraphImportSource, sourceStats, serialized.serializedBytes, [])
   };
 }
 
@@ -215,6 +220,24 @@ function stageFile(file, sourceText, input) {
   });
 }
 
+function attachProjectSymbolGraph(projectImport, projectSymbolGraph) {
+  return {
+    ...projectImport,
+    projectSymbolGraph,
+    semanticIndex: projectImport.semanticIndex ? {
+      ...projectImport.semanticIndex,
+      metadata: {
+        ...projectImport.semanticIndex.metadata,
+        projectSymbolGraph
+      }
+    } : projectImport.semanticIndex,
+    metadata: {
+      ...projectImport.metadata,
+      projectSymbolGraph
+    }
+  };
+}
+
 function hashText(sourceText) {
   return hashSemanticValue(sourceText);
 }

package/dist/js-ts-safe-project-merge-public-contracts.js

@@ -0,0 +1,117 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import { compactRecord } from './js-ts-safe-merge-context.js';
+import { findContainer, normalizeKind, normalizeMemberText, parseMembers } from './js-ts-semantic-merge-parse.js';
+import { idFragment } from './native-import-utils.js';
+
+function augmentProjectSymbolGraphPublicContracts(projectSymbolGraph, files, input, stageName) {
+  const existingRegions = Array.isArray(projectSymbolGraph?.publicContractRegions) ? projectSymbolGraph.publicContractRegions : [];
+  const seenKeys = new Set(existingRegions.map((region) => region?.key).filter(Boolean));
+  const syntheticRegions = [];
+  for (const file of files) {
+    syntheticRegions.push(...syntheticPublicContractRegions(file, input, stageName, seenKeys));
+  }
+  if (!syntheticRegions.length) return projectSymbolGraph;
+  return {
+    ...projectSymbolGraph,
+    publicContractRegions: [...existingRegions, ...syntheticRegions]
+  };
+}
+
+function syntheticPublicContractRegions(file, input, stageName, seenKeys) {
+  if (typeof file?.sourceText !== 'string' || !file.sourcePath) return [];
+  const records = [];
+  for (const region of publicContractPolicyRegionsForPath(input, file.sourcePath)) {
+    const kind = normalizeKind(region?.kind);
+    if (!['interface', 'type', 'class'].includes(kind) || typeof region?.name !== 'string') continue;
+    const container = findContainer(file.sourceText, region);
+    if (container.reasonCodes.length || !isExportedContainer(file.sourceText, container.value)) continue;
+    const members = parseMembers(container.value.body, kind);
+    if (members.reasonCodes.length) continue;
+    const key = `source#${file.sourcePath}#export#${region.name}`;
+    if (seenKeys.has(key)) continue;
+    seenKeys.add(key);
+    records.push(syntheticPublicContractRegion(file, input, stageName, kind, region.name, key, members.members));
+  }
+  return records;
+}
+
+function syntheticPublicContractRegion(file, input, stageName, kind, name, key, members) {
+  const language = file.language ?? input.language ?? languageForPath(file.sourcePath);
+  const memberRecords = members.map((member) => compactRecord({
+    key: member.key,
+    memberKind: member.memberKind,
+    signature: normalizeMemberText(member.text, kind)
+  }));
+  const signatureHash = hashSemanticValue({
+    kind: 'frontier.lang.syntheticPublicContractSignature',
+    language,
+    sourcePath: file.sourcePath,
+    symbolName: name,
+    sourceKind: kind,
+    members: memberRecords
+  });
+  const contractHash = hashSemanticValue({
+    kind: 'frontier.lang.syntheticPublicContractRegionHash',
+    language,
+    sourcePath: file.sourcePath,
+    key,
+    symbolName: name,
+    symbolKind: 'export',
+    apiSurfaceKind: 'module-export',
+    exportedName: name,
+    edgeKind: 'export',
+    signatureHash
+  });
+  return compactRecord({
+    id: `region_${idFragment(stageName)}_${idFragment(key)}`,
+    key,
+    regionKind: 'export',
+    granularity: 'symbol',
+    language,
+    sourcePath: file.sourcePath,
+    sourceHash: file.sourceHash,
+    symbolId: `symbol:${language}:export:${idFragment(name)}`,
+    symbolName: name,
+    symbolKind: 'export',
+    publicContract: true,
+    exportedName: name,
+    edgeKind: 'export',
+    apiSurfaceKind: 'module-export',
+    signatureHash,
+    contractHash,
+    metadata: {
+      source: 'js-ts-safe-project-merge-policy',
+      projectGraphStage: stageName,
+      sourceKind: kind,
+      memberKeys: memberRecords.map((member) => member.key)
+    }
+  });
+}
+
+function publicContractPolicyRegionsForPath(input, sourcePath) {
+  const policy = input.policyByPath?.[sourcePath]
+    ?? input.mergePolicyByPath?.[sourcePath]
+    ?? input.policy
+    ?? input.mergePolicy;
+  const regions = Array.isArray(policy)
+    ? policy
+    : policy?.unorderedRegions
+      ?? policy?.unorderedMemberRegions
+      ?? policy?.safeList
+      ?? policy?.safeMembers
+      ?? [];
+  return Array.isArray(regions) ? regions : [];
+}
+
+function isExportedContainer(sourceText, container) {
+  if (!container) return false;
+  return /^\s*export\b/.test(sourceText.slice(container.start, container.openStart));
+}
+
+function languageForPath(sourcePath) {
+  const path = String(sourcePath ?? '').toLowerCase();
+  if (path.endsWith('.js') || path.endsWith('.jsx') || path.endsWith('.mjs') || path.endsWith('.cjs')) return 'javascript';
+  return 'typescript';
+}
+
+export { augmentProjectSymbolGraphPublicContracts };

package/package.json

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