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

package/dist/declarations/semantic-patch-bundle-composition.d.ts

@@ -0,0 +1,62 @@
+import type { EvidenceRecord, FrontierSourceLanguage } from '@shapeshift-labs/frontier-lang-kernel';
+import type { SemanticEditProjection, SemanticEditReplay } from './semantic-edit-script.js';
+import type { SemanticPatchBundleRecord } from './semantic-patch-bundle.js';
+import type { CompareSemanticPatchBundleRecordsOptions, SemanticPatchBundleOverlapRecord } from './semantic-patch-bundle-overlaps.js';
+
+export type SemanticPatchBundleCompositionStatus = 'verified' | 'blocked' | string;
+
+export interface ComposeSemanticPatchBundleProjectionsInput {
+  readonly id?: string;
+  readonly sourcePath?: string;
+  readonly language?: FrontierSourceLanguage | string;
+  readonly currentSourceText?: string;
+  readonly headSourceText?: string;
+  readonly bundles?: readonly SemanticPatchBundleRecord[] | SemanticPatchBundleRecord;
+  readonly semanticPatchBundles?: readonly SemanticPatchBundleRecord[] | SemanticPatchBundleRecord;
+  readonly projections?: readonly SemanticEditProjection[] | SemanticEditProjection;
+  readonly semanticEditProjections?: readonly SemanticEditProjection[] | SemanticEditProjection;
+  readonly overlapOptions?: CompareSemanticPatchBundleRecordsOptions;
+  readonly parser?: unknown;
+}
+
+export interface SemanticPatchBundleComposition {
+  readonly kind: 'frontier.lang.semanticPatchBundleComposition';
+  readonly version: 1;
+  readonly schema: 'frontier.lang.semanticPatchBundleComposition.v1';
+  readonly id: string;
+  readonly hash: string;
+  readonly status: SemanticPatchBundleCompositionStatus;
+  readonly sourcePath?: string;
+  readonly language?: FrontierSourceLanguage | string;
+  readonly bundleIds: readonly string[];
+  readonly projectionIds: readonly string[];
+  readonly currentHash?: string;
+  readonly outputHash?: string;
+  readonly outputSourceText?: string;
+  readonly replays: readonly SemanticEditReplay[];
+  readonly verificationReplays: readonly SemanticEditReplay[];
+  readonly overlapRecords: readonly SemanticPatchBundleOverlapRecord[];
+  readonly admission: {
+    readonly status: 'auto-merge-candidate' | 'blocked' | string;
+    readonly action: 'apply' | 'human-review' | string;
+    readonly reviewRequired: boolean;
+    readonly autoApplyCandidate: boolean;
+    readonly autoMergeClaim: false;
+    readonly semanticEquivalenceClaim: false;
+    readonly reasonCodes: readonly string[];
+  };
+  readonly summary: {
+    readonly bundles: number;
+    readonly projections: number;
+    readonly replays: number;
+    readonly verificationReplays: number;
+    readonly appliedEdits: number;
+    readonly overlapRecords: number;
+    readonly blockedOverlaps: number;
+  };
+  readonly evidence: readonly EvidenceRecord[];
+}
+
+export declare function composeSemanticPatchBundleProjections(
+  input?: ComposeSemanticPatchBundleProjectionsInput
+): SemanticPatchBundleComposition;

package/dist/index.d.ts

@@ -24,6 +24,7 @@ export * from './declarations/semantic-edit-bundle.js';
 export * from './declarations/semantic-patch-bundle-index.js';
 export * from './declarations/semantic-patch-bundle.js';
 export * from './declarations/semantic-patch-bundle-overlaps.js';
+export * from './declarations/semantic-patch-bundle-composition.js';
 export * from './declarations/semantic-transform-identity.js';
 export * from './declarations/bidirectional-target-change.js';
 export * from './declarations/bidirectional-target-change-source-edit.js';

package/dist/index.js

@@ -72,6 +72,7 @@ export { queryProjectionReadinessMatrix } from './internal/index-impl/queryProje
 export { createSemanticPatchBundleRecord, querySemanticPatchBundleRecords, SemanticPatchBundleAdmissionStatuses } from './internal/index-impl/semanticPatchBundleRecords.js';
 export { createSemanticEditBundleAdmission, SemanticEditBundleAdmissionStatuses } from './internal/index-impl/semanticEditBundleAdmission.js';
 export { compareSemanticPatchBundleRecords, querySemanticPatchBundleOverlaps, SemanticPatchBundleOverlapKinds, SemanticPatchBundleOverlapStatuses } from './internal/index-impl/semanticPatchBundleOverlaps.js';
+export { composeSemanticPatchBundleProjections } from './internal/index-impl/semanticPatchBundleComposition.js';
 export { createSemanticTransformIdentityRecord, deriveSemanticTransformIdentityRecords, semanticTransformIdentityFields } from './internal/index-impl/semanticTransformIdentityRecords.js';
 export { createSemanticMergeCandidateAdmissionRecord, decorateSemanticMergeCandidateForAdmission, querySemanticMergeCandidateAdmissionOverlaps, SemanticMergeCandidateProjectionRisks, semanticMergeCandidateReadinessSortKey, sortSemanticMergeCandidateAdmissionRecords } from './internal/index-impl/semanticMergeCandidateRecords.js';
 export { querySemanticMergeConflictClasses, SemanticMergeConflictClasses, semanticMergeConflictRiskScore, sortSemanticMergeCandidatesByConflictRisk, summarizeSemanticMergeConflicts } from './internal/index-impl/semanticMergeConflicts.js';

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

@@ -0,0 +1,166 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import { idFragment, uniqueStrings } from '../../native-import-utils.js';
+import { compareSemanticPatchBundleRecords } from './semanticPatchBundleOverlaps.js';
+import { replaySemanticEditProjection } from './replaySemanticEditProjection.js';
+
+function composeSemanticPatchBundleProjections(input = {}) {
+  const id = String(input.id ?? 'semantic_patch_bundle_composition');
+  const currentSourceText = input.currentSourceText ?? input.headSourceText;
+  const projections = array(input.projections ?? input.semanticEditProjections);
+  const bundles = array(input.bundles ?? input.semanticPatchBundles);
+  const sourcePath = input.sourcePath ?? projections.find((projection) => projection?.sourcePath)?.sourcePath;
+  const language = input.language ?? projections.find((projection) => projection?.language)?.language;
+  const reasonCodes = baseReasonCodes({ currentSourceText, projections, bundles });
+  const overlapRecords = bundleOverlapRecords(bundles, input.overlapOptions);
+  reasonCodes.push(...overlapRecords.flatMap((record) => record.admission.status === 'independent'
+    ? []
+    : [`bundle-overlap:${record.admission.status}`]));
+  const replays = reasonCodes.length ? [] : projections.map((projection, index) => replaySemanticEditProjection({
+    id: `${id}_replay_${index + 1}`,
+    projection,
+    currentSourceText,
+    currentSourcePath: sourcePath ?? projection.sourcePath,
+    language: language ?? projection.language,
+    parser: input.parser
+  }));
+  reasonCodes.push(...replayReasonCodes(replays));
+  const edits = reasonCodes.length ? [] : appliedReplayEdits(replays);
+  reasonCodes.push(...sourceEditOverlapReasons(edits));
+  const outputSourceText = reasonCodes.length ? undefined : applyReplayEdits(currentSourceText, edits);
+  const verificationReplays = outputSourceText === undefined ? [] : projections.map((projection, index) => replaySemanticEditProjection({
+    id: `${id}_already_applied_${index + 1}`,
+    projection,
+    currentSourceText: outputSourceText,
+    currentSourcePath: sourcePath ?? projection.sourcePath,
+    language: language ?? projection.language,
+    parser: input.parser
+  }));
+  reasonCodes.push(...verificationReasonCodes(verificationReplays));
+  const status = reasonCodes.length ? 'blocked' : 'verified';
+  const core = {
+    kind: 'frontier.lang.semanticPatchBundleComposition',
+    version: 1,
+    schema: 'frontier.lang.semanticPatchBundleComposition.v1',
+    id,
+    status,
+    sourcePath,
+    language,
+    bundleIds: bundles.map((bundle) => bundle?.id).filter(Boolean),
+    projectionIds: projections.map((projection) => projection?.id).filter(Boolean),
+    currentHash: typeof currentSourceText === 'string' ? hashSemanticValue(currentSourceText) : undefined,
+    outputHash: outputSourceText === undefined ? undefined : hashSemanticValue(outputSourceText),
+    outputSourceText,
+    replays,
+    verificationReplays,
+    overlapRecords,
+    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: uniqueStrings(reasonCodes)
+    },
+    summary: {
+      bundles: bundles.length,
+      projections: projections.length,
+      replays: replays.length,
+      verificationReplays: verificationReplays.length,
+      appliedEdits: edits.length,
+      overlapRecords: overlapRecords.length,
+      blockedOverlaps: overlapRecords.filter((record) => record.admission.status !== 'independent').length
+    },
+    evidence: [{
+      id: `evidence_${idFragment(id)}_semantic_patch_bundle_composition`,
+      kind: 'semantic-patch-bundle-composition',
+      status: status === 'verified' ? 'passed' : 'needs-review',
+      path: sourcePath,
+      summary: status === 'verified'
+        ? `Composed ${edits.length} replayed semantic edit(s) from ${projections.length} projection(s).`
+        : `Semantic patch bundle composition blocked: ${uniqueStrings(reasonCodes).join(', ')}.`,
+      metadata: {
+        bundleIds: bundles.map((bundle) => bundle?.id).filter(Boolean),
+        projectionIds: projections.map((projection) => projection?.id).filter(Boolean),
+        autoMergeClaim: false,
+        semanticEquivalenceClaim: false
+      }
+    }]
+  };
+  return { ...core, hash: hashSemanticValue(core) };
+}
+
+function baseReasonCodes(input) {
+  return uniqueStrings([
+    typeof input.currentSourceText === 'string' ? undefined : 'missing-current-source-text',
+    input.projections.length ? undefined : 'missing-semantic-edit-projections',
+    input.bundles.length && input.bundles.length !== input.projections.length ? 'bundle-projection-count-mismatch' : undefined,
+    ...input.projections.map((projection, index) => projection?.status === 'projected' ? undefined : `projection-not-projected:${index + 1}`)
+  ].filter(Boolean));
+}
+
+function bundleOverlapRecords(bundles, options = {}) {
+  const records = [];
+  for (let left = 0; left < bundles.length; left += 1) {
+    for (let right = left + 1; right < bundles.length; right += 1) {
+      records.push(compareSemanticPatchBundleRecords(bundles[left], bundles[right], options));
+    }
+  }
+  return records;
+}
+
+function replayReasonCodes(replays) {
+  return uniqueStrings(replays.flatMap((replay, index) => {
+    if (replay.status === 'accepted-clean' || replay.status === 'already-applied') return [];
+    return [`replay-not-clean:${index + 1}:${replay.status}`, ...(replay.admission?.reasonCodes ?? replay.summary?.reasonCodes ?? [])];
+  }));
+}
+
+function appliedReplayEdits(replays) {
+  return replays.flatMap((replay, replayIndex) => (replay.edits ?? [])
+    .filter((edit) => edit.status === 'applied')
+    .map((edit, editIndex) => ({
+      replayIndex,
+      editIndex,
+      operationId: edit.operationId,
+      start: edit.start,
+      end: edit.end,
+      replacementText: edit.replacementText
+    })));
+}
+
+function sourceEditOverlapReasons(edits) {
+  const reasons = [];
+  const ordered = edits.slice().sort((left, right) => left.start - right.start || left.end - right.end);
+  for (let index = 1; index < ordered.length; index += 1) {
+    const previous = ordered[index - 1];
+    const current = ordered[index];
+    if (sourceEditsOverlap(previous, current)) reasons.push(`composed-source-edit-overlap:${previous.operationId}:${current.operationId}`);
+  }
+  return uniqueStrings(reasons);
+}
+
+function applyReplayEdits(sourceText, edits) {
+  return edits.slice().sort((left, right) => right.start - left.start || right.end - left.end)
+    .reduce((text, edit) => text.slice(0, edit.start) + edit.replacementText + text.slice(edit.end), sourceText);
+}
+
+function verificationReasonCodes(replays) {
+  return uniqueStrings(replays.flatMap((replay, index) => {
+    if (replay.status === 'already-applied') return [];
+    return [`verification-replay-not-already-applied:${index + 1}:${replay.status}`, ...(replay.admission?.reasonCodes ?? [])];
+  }));
+}
+
+function sourceEditsOverlap(left, right) {
+  if (left.start === left.end) return right.start < left.start && left.start < right.end;
+  if (right.start === right.end) return left.start < right.start && right.start < left.end;
+  return left.start < right.end && right.start < left.end;
+}
+
+function array(value) {
+  if (value === undefined || value === null) return [];
+  return Array.isArray(value) ? value : [value];
+}
+
+export { composeSemanticPatchBundleProjections };

package/dist/js-ts-safe-merge-constants.js

@@ -19,6 +19,7 @@ export const JsTsSafeMergeConflictCodes = Object.freeze({
   malformedSyntax: 'malformed-syntax',
   sideEffectImportReorder: 'side-effect-import-reorder',
   topLevelOrderChanged: 'top-level-order-changed',
+  topLevelRenamePublicExportContract: 'top-level-rename-public-export-contract',
   changedExistingDeclaration: 'changed-existing-declaration',
   typeAliasConflict: 'type-alias-conflict',
   importShapeChanged: 'import-shape-changed',

package/dist/js-ts-safe-merge-context.js

@@ -6,6 +6,7 @@ export function createMergeContext(input) {
     sourcePath: input.sourcePath,
     language: input.language ?? 'typescript',
     deferReExportIdentityConflictsToProjectGraph: input.deferReExportIdentityConflictsToProjectGraph === true,
+    deferTopLevelRenamePublicExportContractToProjectGraph: input.deferTopLevelRenamePublicExportContractToProjectGraph === true,
     conflicts: [],
     blockedGateIds: new Set(),
     gateReasonCodes: new Map()

package/dist/js-ts-safe-merge-jsx-attribute-fallback.js

@@ -0,0 +1,320 @@
+import { JsTsSafeMergeStatuses } from './js-ts-safe-merge-constants.js';
+import { createJsTsSafeMergeSemanticArtifacts } from './js-ts-safe-merge-semantic-artifacts.js';
+import { uniqueStrings } from './js-ts-safe-merge-context.js';
+import { semanticFallbackChangedExistingDeclarations } from './js-ts-safe-merge-semantic-edit-fallback-utils.js';
+
+function createJsxAttributeSemanticFallbackResult(input, topLevelResult, stagedFallback) {
+  const currentSourceText = stagedFallback?.directReplayCurrentSourceText
+    ?? stagedFallback?.replayCurrentSourceText
+    ?? input.headSourceText;
+  const merge = mergeJsxAttributeSources({
+    baseSourceText: input.baseSourceText,
+    workerSourceText: input.workerSourceText,
+    headSourceText: input.headSourceText,
+    currentSourceText
+  });
+  if (!merge.ok || merge.sourceText === currentSourceText) return undefined;
+  const resultBase = stagedFallback?.stagedTopLevelResult ?? topLevelResult;
+  const language = input.language ?? topLevelResult.language ?? 'tsx';
+  const sourcePath = input.sourcePath ?? topLevelResult.sourcePath ?? 'inline.tsx';
+  const id = String(input.id ?? topLevelResult.id ?? 'js_ts_safe_merge');
+  const artifacts = createJsTsSafeMergeSemanticArtifacts({
+    ...input,
+    id: `${id}_jsx_attribute`,
+    language,
+    sourcePath,
+    headSourceText: currentSourceText,
+    headHash: undefined,
+    currentSourceHash: undefined
+  }, {
+    ...resultBase,
+    id: `${String(input.id ?? resultBase.id ?? 'js_ts_safe_merge')}_jsx_attribute`,
+    language,
+    sourcePath,
+    mergedSourceText: merge.sourceText,
+    outputSourceText: merge.sourceText
+  });
+  if (artifacts.status !== 'verified') return undefined;
+  const gates = semanticArtifactGates(artifacts);
+  return {
+    ...resultBase,
+    id: String(input.id ?? resultBase.id ?? topLevelResult.id),
+    status: JsTsSafeMergeStatuses.merged,
+    mergedSourceText: merge.sourceText,
+    outputSourceText: merge.sourceText,
+    conflicts: [],
+    gates,
+    admission: {
+      status: 'auto-merge-candidate',
+      action: 'apply',
+      reviewRequired: false,
+      autoApplyCandidate: true,
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      reasonCodes: []
+    },
+    summary: {
+      ...resultBase.summary,
+      changedExistingDeclarations: semanticFallbackChangedExistingDeclarations(topLevelResult, resultBase, stagedFallback),
+      conflicts: 0,
+      gatesPassed: gates.filter((gate) => gate.status === 'passed').length,
+      semanticEditOperations: artifacts.script.summary.operations,
+      semanticEditAppliedOperations: artifacts.replay.summary.applied,
+      semanticEditReplayStatus: artifacts.replay.status,
+      jsxAttributeTags: merge.summary.tags,
+      jsxAttributeEdits: merge.summary.edits,
+      composedPhases: 2
+    },
+    metadata: {
+      ...resultBase.metadata,
+      composed: {
+        phase: stagedFallback
+          ? 'staged-top-level-jsx-attribute-semantic-fallback'
+          : 'jsx-attribute-semantic-fallback',
+        phases: stagedFallback
+          ? ['top-level-neutralization', 'top-level-ledger', 'jsx-attribute']
+          : ['top-level-ledger', 'jsx-attribute'],
+        originalReasonCodes: topLevelResult.admission?.reasonCodes ?? [],
+        stagedTopLevelSummary: stagedFallback?.stagedTopLevelResult?.summary,
+        neutralization: stagedFallback?.neutralization?.summary,
+        jsxAttributeFallback: merge.summary
+      }
+    },
+    semanticArtifacts: artifacts
+  };
+}
+
+function mergeJsxAttributeSources(input) {
+  if (![input.baseSourceText, input.workerSourceText, input.headSourceText, input.currentSourceText].every(isString)) {
+    return blocked('missing-source-text');
+  }
+  const parsed = ['base', 'worker', 'head', 'current'].map((side) => parseJsxTags(input[`${side}SourceText`]));
+  if (parsed.some((source) => source.reasonCodes.length)) return blocked('jsx-attribute-parse-blocked');
+  const [base, worker, head, current] = parsed;
+  const edits = [];
+  let changedTags = 0;
+  for (const baseTag of base.tags) {
+    const workerTag = worker.byKey.get(baseTag.key);
+    const headTag = head.byKey.get(baseTag.key);
+    const currentTag = current.byKey.get(baseTag.key);
+    if (!workerTag || !headTag || !currentTag) continue;
+    if (sameTagText(baseTag, workerTag)) continue;
+    const merged = mergeTagAttributes(baseTag, workerTag, headTag, currentTag);
+    if (merged.status === 'blocked') return blocked(...merged.reasonCodes);
+    for (const edit of merged.edits) edits.push(edit);
+    if (merged.edits.length) changedTags += 1;
+  }
+  if (!edits.length) return blocked('no-jsx-attribute-merge-candidate');
+  const sourceText = edits.sort((left, right) => right.start - left.start)
+    .reduce((text, edit) => text.slice(0, edit.start) + edit.replacement + text.slice(edit.end), input.currentSourceText);
+  return { ok: true, sourceText, summary: { tags: changedTags, edits: edits.length } };
+}
+
+function mergeTagAttributes(base, worker, head, current) {
+  if (![worker, head, current].every((tag) => tag.tagName === base.tagName)) return blockedTag('jsx-tag-name-changed');
+  const maps = [base, worker, head, current].map(attributeMap);
+  if (maps.some((map) => map.reasonCodes.length)) return blockedTag('jsx-attribute-duplicate-name');
+  if (![worker, head, current].every((tag) => sameAttributeNames(base, tag))) {
+    return blockedTag('jsx-attribute-shape-changed');
+  }
+  const [, workerAttrs, headAttrs, currentAttrs] = maps.map((map) => map.byName);
+  const edits = [];
+  for (const baseAttr of base.attributes) {
+    const workerAttr = workerAttrs.get(baseAttr.name);
+    const headAttr = headAttrs.get(baseAttr.name);
+    const currentAttr = currentAttrs.get(baseAttr.name);
+    const workerChanged = !sameAttrText(baseAttr, workerAttr);
+    const headChanged = !sameAttrText(baseAttr, headAttr);
+    if (workerChanged && headChanged && !sameAttrText(workerAttr, headAttr)) {
+      return blockedTag('jsx-attribute-conflict');
+    }
+    if (!sameAttrText(currentAttr, headAttr) && !sameAttrText(currentAttr, workerAttr)) {
+      return blockedTag('jsx-attribute-current-diverged');
+    }
+    if (workerChanged && !sameAttrText(currentAttr, workerAttr)) {
+      edits.push({ start: currentAttr.start, end: currentAttr.end, replacement: workerAttr.text });
+    }
+  }
+  return { status: 'merged', edits };
+}
+
+function parseJsxTags(sourceText) {
+  const tags = [];
+  const reasonCodes = [];
+  const ordinals = new Map();
+  let index = 0;
+  while (index < sourceText.length) {
+    const start = sourceText.indexOf('<', index);
+    if (start === -1) break;
+    const parsed = parseOpeningTag(sourceText, start);
+    if (!parsed) {
+      index = start + 1;
+      continue;
+    }
+    if (parsed.reasonCodes.length) reasonCodes.push(...parsed.reasonCodes);
+    const ordinal = (ordinals.get(parsed.tagName) ?? 0) + 1;
+    ordinals.set(parsed.tagName, ordinal);
+    tags.push({ ...parsed, key: `${parsed.tagName}#${ordinal}` });
+    index = parsed.end;
+  }
+  return { tags, byKey: new Map(tags.map((tag) => [tag.key, tag])), reasonCodes: uniqueStrings(reasonCodes) };
+}
+
+function parseOpeningTag(sourceText, start) {
+  const afterOpen = start + 1;
+  if (/[/!?>]/.test(sourceText[afterOpen] ?? '')) return undefined;
+  const nameMatch = /^[A-Za-z_$][\w$]*(?:[.:][A-Za-z_$][\w$]*|-[\w$]+)*/.exec(sourceText.slice(afterOpen));
+  if (!nameMatch) return undefined;
+  const tagName = nameMatch[0];
+  const nameEnd = afterOpen + tagName.length;
+  const end = openingTagEnd(sourceText, nameEnd);
+  if (end === undefined) return undefined;
+  const attributes = parseAttributes(sourceText, nameEnd, end - 1);
+  return {
+    tagName,
+    start,
+    end,
+    text: sourceText.slice(start, end),
+    attributes: attributes.values,
+    reasonCodes: attributes.reasonCodes
+  };
+}
+
+function parseAttributes(sourceText, start, end) {
+  const values = [];
+  const reasonCodes = [];
+  let cursor = start;
+  while (cursor < end) {
+    while (cursor < end && /\s/.test(sourceText[cursor])) cursor += 1;
+    if (sourceText[cursor] === '/') {
+      cursor += 1;
+      continue;
+    }
+    const attrStart = cursor;
+    const nameMatch = /^[A-Za-z_$][\w$:-]*/.exec(sourceText.slice(cursor, end));
+    if (!nameMatch) {
+      reasonCodes.push('jsx-attribute-token-unsupported');
+      break;
+    }
+    const name = nameMatch[0];
+    cursor += name.length;
+    while (cursor < end && /\s/.test(sourceText[cursor])) cursor += 1;
+    if (sourceText[cursor] === '=') {
+      cursor += 1;
+      while (cursor < end && /\s/.test(sourceText[cursor])) cursor += 1;
+      cursor = attributeValueEnd(sourceText, cursor, end);
+      if (cursor === undefined) return { values, reasonCodes: ['jsx-attribute-value-unterminated'] };
+    }
+    values.push({ name, start: attrStart, end: cursor, text: sourceText.slice(attrStart, cursor) });
+  }
+  return { values, reasonCodes: uniqueStrings(reasonCodes) };
+}
+
+function openingTagEnd(sourceText, start) {
+  let quote;
+  let escaped = false;
+  let braceDepth = 0;
+  for (let index = start; index < sourceText.length; index += 1) {
+    const char = sourceText[index];
+    if (quote) {
+      if (escaped) escaped = false;
+      else if (char === '\\') escaped = true;
+      else if (char === quote) quote = undefined;
+      continue;
+    }
+    if (char === '"' || char === '\'' || char === '`') quote = char;
+    else if (char === '{') braceDepth += 1;
+    else if (char === '}') braceDepth = Math.max(0, braceDepth - 1);
+    else if (char === '>' && braceDepth === 0) return index + 1;
+  }
+  return undefined;
+}
+
+function attributeValueEnd(sourceText, start, end) {
+  const first = sourceText[start];
+  if (first === '"' || first === '\'') return quotedValueEnd(sourceText, start, end, first);
+  if (first === '{') return bracedValueEnd(sourceText, start, end);
+  let cursor = start;
+  while (cursor < end && !/[\s/]/.test(sourceText[cursor])) cursor += 1;
+  return cursor;
+}
+
+function quotedValueEnd(sourceText, start, end, quote) {
+  let escaped = false;
+  for (let cursor = start + 1; cursor < end; cursor += 1) {
+    const char = sourceText[cursor];
+    if (escaped) escaped = false;
+    else if (char === '\\') escaped = true;
+    else if (char === quote) return cursor + 1;
+  }
+  return undefined;
+}
+
+function bracedValueEnd(sourceText, start, end) {
+  let depth = 0;
+  let quote;
+  let escaped = false;
+  for (let cursor = start; cursor < end; cursor += 1) {
+    const char = sourceText[cursor];
+    if (quote) {
+      if (escaped) escaped = false;
+      else if (char === '\\') escaped = true;
+      else if (char === quote) quote = undefined;
+      continue;
+    }
+    if (char === '"' || char === '\'' || char === '`') quote = char;
+    else if (char === '{') depth += 1;
+    else if (char === '}') {
+      depth -= 1;
+      if (depth === 0) return cursor + 1;
+    }
+  }
+  return undefined;
+}
+
+function attributeMap(tag) {
+  const byName = new Map();
+  const duplicateNames = [];
+  for (const attribute of tag.attributes) {
+    if (byName.has(attribute.name)) duplicateNames.push(attribute.name);
+    byName.set(attribute.name, attribute);
+  }
+  return { byName, reasonCodes: duplicateNames.length ? ['jsx-attribute-duplicate-name'] : [] };
+}
+
+function sameAttributeNames(left, right) {
+  return left.attributes.map((attr) => attr.name).join('\0') === right.attributes.map((attr) => attr.name).join('\0');
+}
+
+function sameTagText(left, right) {
+  return String(left?.text ?? '').trim() === String(right?.text ?? '').trim();
+}
+
+function sameAttrText(left, right) {
+  return String(left?.text ?? '').trim() === String(right?.text ?? '').trim();
+}
+
+function semanticArtifactGates(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) };
+}
+
+function blocked(...reasonCodes) {
+  return { ok: false, reasonCodes: uniqueStrings(reasonCodes) };
+}
+
+function blockedTag(...reasonCodes) {
+  return { status: 'blocked', reasonCodes: uniqueStrings(reasonCodes) };
+}
+
+function isString(value) { return typeof value === 'string'; }
+
+export { createJsxAttributeSemanticFallbackResult };

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

@@ -225,11 +225,13 @@ function renderImportStatement(importInfo, specifiers) {
   const clause = [];
   if (importInfo.defaultLocalName) clause.push(importInfo.defaultLocalName);
   if (importInfo.namespaceLocalName) clause.push(`* as ${importInfo.namespaceLocalName}`);
-  if (specifiers.length) clause.push(`{ ${specifiers.map(importSpecifierCanonical).join(', ')} }`);
+  if (specifiers.length) clause.push(`{ ${specifiers.map((specifier) => renderImportSpecifier(specifier, importInfo)).join(', ')} }`);
   const importType = importInfo.typeOnly ? 'type ' : '';
   return `import ${importType}${clause.join(', ')} from ${importInfo.quote}${importInfo.moduleSpecifier}${importInfo.quote};`;
 }
 
+const renderImportSpecifier = (specifier, importInfo) => importSpecifierCanonical(importInfo.typeOnly ? { ...specifier, typeOnly: false } : specifier);
+
 function importInsertionText(entries, lineEnding) {
   return entries
     .map((entry) => normalizeLineEndings(entry.text.trimEnd(), lineEnding))

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

@@ -0,0 +1,111 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import { semanticFallbackPhase } from './js-ts-safe-merge-semantic-edit-fallback-utils.js';
+import { idFragment, uniqueStrings } from './native-import-utils.js';
+
+function semanticEditArtifacts(input) {
+  const reasonCodes = semanticEditArtifactReasonCodes(input);
+  const status = reasonCodes.length ? 'blocked' : 'verified';
+  const core = {
+    kind: 'frontier.lang.jsTsSafeMergeSemanticArtifacts',
+    version: 1,
+    schema: 'frontier.lang.jsTsSafeMergeSemanticArtifacts.v1',
+    id: `js_ts_safe_merge_semantic_edit_artifacts_${idFragment(input.id)}`,
+    sourcePath: input.sourcePath,
+    language: input.language,
+    status,
+    script: input.script,
+    projection: input.projection,
+    replay: input.replay,
+    alreadyAppliedReplay: input.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: input.script.summary.operations,
+      edits: input.projection.edits.length,
+      replayStatus: input.replay.status,
+      alreadyAppliedReplayStatus: input.alreadyAppliedReplay.status,
+      projectedSourceMatchesMerged: input.projection.sourceText === input.replay.outputSourceText,
+      replayOutputMatchesMerged: input.replay.outputSourceText === input.projection.sourceText
+    },
+    evidence: [{
+      id: `evidence_${idFragment(input.id)}_js_ts_semantic_edit_replay`,
+      kind: 'js-ts-semantic-edit-replay',
+      status: status === 'verified' ? 'passed' : 'needs-review',
+      path: input.sourcePath,
+      summary: status === 'verified'
+        ? `JS/TS semantic edit replay verified ${input.script.summary.operations} operation(s).`
+        : `JS/TS semantic edit replay requires review: ${reasonCodes.join(', ')}.`
+    }],
+    metadata: {
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      source: input.stagedFallback ? semanticFallbackPhase(input.stagedFallback) : 'js-ts-semantic-edit-fallback',
+      originalReasonCodes: input.topLevelResult.admission?.reasonCodes ?? [],
+      stagedTopLevelSummary: input.stagedFallback?.stagedTopLevelResult?.summary,
+      neutralization: input.stagedFallback?.neutralization?.summary
+    }
+  };
+  return { ...core, hash: hashSemanticValue(core) };
+}
+
+function blockedSemanticEditArtifacts(input, topLevelResult, reasonCodes, error) {
+  const id = String(input.id ?? topLevelResult.id ?? 'js_ts_safe_merge');
+  const core = {
+    kind: 'frontier.lang.jsTsSafeMergeSemanticArtifacts',
+    version: 1,
+    schema: 'frontier.lang.jsTsSafeMergeSemanticArtifacts.v1',
+    id: `js_ts_safe_merge_semantic_edit_artifacts_${idFragment(id)}`,
+    sourcePath: input.sourcePath ?? topLevelResult.sourcePath,
+    language: input.language ?? topLevelResult.language ?? 'typescript',
+    status: 'blocked',
+    admission: {
+      status: 'blocked',
+      action: 'human-review',
+      reviewRequired: true,
+      autoApplyCandidate: false,
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      reasonCodes
+    },
+    summary: {
+      operations: 0,
+      edits: 0,
+      replayStatus: 'blocked',
+      alreadyAppliedReplayStatus: 'blocked',
+      projectedSourceMatchesMerged: false,
+      replayOutputMatchesMerged: false
+    },
+    metadata: {
+      source: 'js-ts-semantic-edit-fallback',
+      error: error?.message
+    }
+  };
+  return { ...core, hash: hashSemanticValue(core) };
+}
+
+function semanticEditArtifactReasonCodes(input) {
+  const scriptReady = input.script.admission.status === 'auto-merge-candidate';
+  const projectionReady = input.projection.status === 'projected';
+  const replayReady = input.replay.status === 'accepted-clean';
+  const alreadyAppliedReady = input.alreadyAppliedReplay.status === 'already-applied';
+  return uniqueStrings([
+    scriptReady ? undefined : `semantic-edit-script-${input.script.admission.status}`,
+    projectionReady ? undefined : `semantic-edit-projection-${input.projection.status}`,
+    replayReady ? undefined : `semantic-edit-replay-${input.replay.status}`,
+    input.replay.outputSourceText !== input.projection.sourceText ? 'semantic-edit-replay-output-mismatch' : undefined,
+    alreadyAppliedReady ? undefined : `semantic-edit-already-applied-${input.alreadyAppliedReplay.status}`,
+    ...(scriptReady ? [] : input.script.admission.reasonCodes),
+    ...(projectionReady ? [] : input.projection.admission.reasonCodes),
+    ...(replayReady ? [] : input.replay.admission.reasonCodes),
+    ...(alreadyAppliedReady ? [] : input.alreadyAppliedReplay.admission.reasonCodes)
+  ]);
+}
+
+export { blockedSemanticEditArtifacts, semanticEditArtifacts };

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

@@ -33,7 +33,18 @@ function semanticFallbackPhase(fallback) {
     : 'staged-top-level-semantic-edit-fallback';
 }
 
+function semanticFallbackCandidates(stagedFallback) {
+  if (!stagedFallback) return [undefined];
+  const headChanged = (stagedFallback.neutralization?.summary?.headChangedExistingDeclarations ?? 0) > 0;
+  const directFallback = stagedFallback.directProjectionHeadSourceText && (headChanged || stagedFallback.safeTopLevelChanges > 0)
+    ? { ...stagedFallback, projectionMode: 'direct' }
+    : undefined;
+  if (headChanged) return directFallback ? [directFallback, undefined] : [undefined];
+  return directFallback ? [stagedFallback, directFallback, undefined] : [stagedFallback];
+}
+
 export {
+  semanticFallbackCandidates,
   semanticFallbackChangedExistingDeclarations,
   semanticFallbackConflictCode,
   semanticFallbackPhase,

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

@@ -1,11 +1,12 @@
-import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
 import { createSemanticEditScript } from './internal/index-impl/semanticEditScripts.js';
 import { projectSemanticEditScriptToSource } from './internal/index-impl/projectSemanticEditScriptToSource.js';
 import { replaySemanticEditProjection } from './internal/index-impl/replaySemanticEditProjection.js';
 import { 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 { blockedSemanticEditArtifacts, semanticEditArtifacts } from './js-ts-safe-merge-semantic-edit-artifacts.js';
 import {
+  semanticFallbackCandidates,
   semanticFallbackChangedExistingDeclarations,
   semanticFallbackConflictCode,
   semanticFallbackPhase,
@@ -19,11 +20,31 @@ import {
 } from './js-ts-safe-merge-staged-declaration-replay.js';
 import { createStagedTopLevelSemanticFallback } from './js-ts-safe-merge-staged-top-level-fallback.js';
 import { createSourceShapeSemanticFallbackResult } from './js-ts-safe-merge-source-shape-fallbacks.js';
-import { idFragment, uniqueStrings } from './native-import-utils.js';
+import { analyzeTopLevelRenameAdmission } from './js-ts-safe-merge-top-level-rename-fallback.js';
+import { topLevelRenameBlockedResult } from './js-ts-safe-merge-top-level-rename-result.js';
 
 function semanticEditFallbackResult(input, topLevelResult) {
   const independentDeletionResult = independentTopLevelDeletionFallbackResult(input, topLevelResult);
   if (independentDeletionResult) return independentDeletionResult;
+  const topLevelRenameAdmission = analyzeTopLevelRenameAdmission(input, topLevelResult);
+  if (topLevelRenameAdmission?.status === 'blocked') {
+    if (shouldDeferTopLevelRenamePublicContract(input, topLevelRenameAdmission)) {
+      const deferredAdmission = deferredTopLevelRenameAdmission(topLevelRenameAdmission);
+      const artifacts = createSemanticEditFallbackArtifacts(input, topLevelResult);
+      if (artifacts.status !== 'verified') {
+        return semanticEditFallbackBlockedResult(input, topLevelResult, artifacts, deferredAdmission);
+      }
+      return semanticEditFallbackMergedResult(input, topLevelResult, undefined, artifacts, deferredAdmission);
+    }
+    return topLevelRenameBlockedResult(input, topLevelResult, topLevelRenameAdmission);
+  }
+  if (topLevelRenameAdmission?.status === 'candidate') {
+    const artifacts = createSemanticEditFallbackArtifacts(input, topLevelResult);
+    if (artifacts.status !== 'verified') {
+      return semanticEditFallbackBlockedResult(input, topLevelResult, artifacts, topLevelRenameAdmission);
+    }
+    return semanticEditFallbackMergedResult(input, topLevelResult, undefined, artifacts, topLevelRenameAdmission);
+  }
   if (!shouldTrySemanticEditFallback(topLevelResult)) return topLevelResult;
   const stagedFallback = createStagedTopLevelSemanticFallback(input, topLevelResult);
   const candidates = semanticFallbackCandidates(stagedFallback);
@@ -40,6 +61,10 @@ function semanticEditFallbackResult(input, topLevelResult) {
     if (sourceShapeResult) return sourceShapeResult;
     return semanticEditFallbackBlockedResult(input, topLevelResult, artifacts);
   }
+  return semanticEditFallbackMergedResult(input, topLevelResult, selectedFallback, artifacts);
+}
+
+function semanticEditFallbackMergedResult(input, topLevelResult, selectedFallback, artifacts, topLevelRenameAdmission) {
   const resultBase = selectedFallback?.stagedTopLevelResult ?? topLevelResult;
   const mergedSourceText = artifacts.projection.sourceText;
   const gates = semanticEditGates(artifacts);
@@ -68,32 +93,26 @@ function semanticEditFallbackResult(input, topLevelResult) {
       semanticEditOperations: artifacts.script.summary.operations,
       semanticEditAppliedOperations: artifacts.replay.summary.applied,
       semanticEditReplayStatus: artifacts.replay.status,
+      topLevelDeclarationRenames: topLevelRenameAdmission ? 1 : resultBase.summary?.topLevelDeclarationRenames,
       composedPhases: 2
     },
     metadata: {
       ...resultBase.metadata,
       composed: {
-        phase: semanticFallbackPhase(selectedFallback),
-        phases: selectedFallback ? ['top-level-neutralization', 'top-level-ledger', 'semantic-edit'] : ['top-level-ledger', 'semantic-edit'],
+        phase: topLevelRenameAdmission ? 'top-level-rename-semantic-edit-fallback' : semanticFallbackPhase(selectedFallback),
+        phases: topLevelRenameAdmission
+          ? ['top-level-rename-admission', 'semantic-edit']
+          : selectedFallback ? ['top-level-neutralization', 'top-level-ledger', 'semantic-edit'] : ['top-level-ledger', 'semantic-edit'],
         originalReasonCodes: topLevelResult.admission?.reasonCodes ?? [],
         stagedTopLevelSummary: selectedFallback?.stagedTopLevelResult?.summary,
-        neutralization: selectedFallback?.neutralization?.summary
+        neutralization: selectedFallback?.neutralization?.summary,
+        topLevelRenameAdmission: topLevelRenameAdmission?.summary
       }
     },
     semanticArtifacts: artifacts
   };
 }
 
-function semanticFallbackCandidates(stagedFallback) {
-  if (!stagedFallback) return [undefined];
-  const headChanged = (stagedFallback.neutralization?.summary?.headChangedExistingDeclarations ?? 0) > 0;
-  const directFallback = stagedFallback.directProjectionHeadSourceText && (headChanged || stagedFallback.safeTopLevelChanges > 0)
-    ? { ...stagedFallback, projectionMode: 'direct' }
-    : undefined;
-  if (headChanged) return directFallback ? [directFallback, undefined] : [undefined];
-  return directFallback ? [stagedFallback, directFallback, undefined] : [stagedFallback];
-}
-
 function createSemanticEditFallbackArtifacts(input, topLevelResult, stagedFallback) {
   try {
     const id = String(input.id ?? topLevelResult.id ?? 'js_ts_safe_merge');
@@ -166,112 +185,6 @@ function createSemanticEditFallbackArtifacts(input, topLevelResult, stagedFallba
   }
 }
 
-function semanticEditArtifacts(input) {
-  const reasonCodes = semanticEditArtifactReasonCodes(input);
-  const status = reasonCodes.length ? 'blocked' : 'verified';
-  const core = {
-    kind: 'frontier.lang.jsTsSafeMergeSemanticArtifacts',
-    version: 1,
-    schema: 'frontier.lang.jsTsSafeMergeSemanticArtifacts.v1',
-    id: `js_ts_safe_merge_semantic_edit_artifacts_${idFragment(input.id)}`,
-    sourcePath: input.sourcePath,
-    language: input.language,
-    status,
-    script: input.script,
-    projection: input.projection,
-    replay: input.replay,
-    alreadyAppliedReplay: input.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: input.script.summary.operations,
-      edits: input.projection.edits.length,
-      replayStatus: input.replay.status,
-      alreadyAppliedReplayStatus: input.alreadyAppliedReplay.status,
-      projectedSourceMatchesMerged: input.projection.sourceText === input.replay.outputSourceText,
-      replayOutputMatchesMerged: input.replay.outputSourceText === input.projection.sourceText
-    },
-    evidence: [{
-      id: `evidence_${idFragment(input.id)}_js_ts_semantic_edit_replay`,
-      kind: 'js-ts-semantic-edit-replay',
-      status: status === 'verified' ? 'passed' : 'needs-review',
-      path: input.sourcePath,
-      summary: status === 'verified'
-        ? `JS/TS semantic edit replay verified ${input.script.summary.operations} operation(s).`
-        : `JS/TS semantic edit replay requires review: ${reasonCodes.join(', ')}.`
-    }],
-    metadata: {
-      autoMergeClaim: false,
-      semanticEquivalenceClaim: false,
-      source: input.stagedFallback ? semanticFallbackPhase(input.stagedFallback) : 'js-ts-semantic-edit-fallback',
-      originalReasonCodes: input.topLevelResult.admission?.reasonCodes ?? [],
-      stagedTopLevelSummary: input.stagedFallback?.stagedTopLevelResult?.summary,
-      neutralization: input.stagedFallback?.neutralization?.summary
-    }
-  };
-  return { ...core, hash: hashSemanticValue(core) };
-}
-
-function semanticEditArtifactReasonCodes(input) {
-  const scriptReady = input.script.admission.status === 'auto-merge-candidate';
-  const projectionReady = input.projection.status === 'projected';
-  const replayReady = input.replay.status === 'accepted-clean';
-  const alreadyAppliedReady = input.alreadyAppliedReplay.status === 'already-applied';
-  return uniqueStrings([
-    scriptReady ? undefined : `semantic-edit-script-${input.script.admission.status}`,
-    projectionReady ? undefined : `semantic-edit-projection-${input.projection.status}`,
-    replayReady ? undefined : `semantic-edit-replay-${input.replay.status}`,
-    input.replay.outputSourceText !== input.projection.sourceText ? 'semantic-edit-replay-output-mismatch' : undefined,
-    alreadyAppliedReady ? undefined : `semantic-edit-already-applied-${input.alreadyAppliedReplay.status}`,
-    ...(scriptReady ? [] : input.script.admission.reasonCodes),
-    ...(projectionReady ? [] : input.projection.admission.reasonCodes),
-    ...(replayReady ? [] : input.replay.admission.reasonCodes),
-    ...(alreadyAppliedReady ? [] : input.alreadyAppliedReplay.admission.reasonCodes)
-  ]);
-}
-
-function blockedSemanticEditArtifacts(input, topLevelResult, reasonCodes, error) {
-  const id = String(input.id ?? topLevelResult.id ?? 'js_ts_safe_merge');
-  const core = {
-    kind: 'frontier.lang.jsTsSafeMergeSemanticArtifacts',
-    version: 1,
-    schema: 'frontier.lang.jsTsSafeMergeSemanticArtifacts.v1',
-    id: `js_ts_safe_merge_semantic_edit_artifacts_${idFragment(id)}`,
-    sourcePath: input.sourcePath ?? topLevelResult.sourcePath,
-    language: input.language ?? topLevelResult.language ?? 'typescript',
-    status: 'blocked',
-    admission: {
-      status: 'blocked',
-      action: 'human-review',
-      reviewRequired: true,
-      autoApplyCandidate: false,
-      autoMergeClaim: false,
-      semanticEquivalenceClaim: false,
-      reasonCodes
-    },
-    summary: {
-      operations: 0,
-      edits: 0,
-      replayStatus: 'blocked',
-      alreadyAppliedReplayStatus: 'blocked',
-      projectedSourceMatchesMerged: false,
-      replayOutputMatchesMerged: false
-    },
-    metadata: {
-      source: 'js-ts-semantic-edit-fallback',
-      error: error?.message
-    }
-  };
-  return { ...core, hash: hashSemanticValue(core) };
-}
-
 function semanticEditFallbackBlockedResult(input, topLevelResult, artifacts) {
   const reasonCodes = artifacts.admission.reasonCodes.length
     ? artifacts.admission.reasonCodes
@@ -310,4 +223,37 @@ function semanticEditFallbackBlockedResult(input, topLevelResult, artifacts) {
   };
 }
 
+function shouldDeferTopLevelRenamePublicContract(input, admission) {
+  return input.deferTopLevelRenamePublicExportContractToProjectGraph === true
+    && admission.reasonCodes?.length === 1
+    && admission.reasonCodes.includes('top-level-rename-public-export-contract')
+    && admission.summary?.exported !== true
+    && workerPreservesRenamedExportAlias(input.workerSourceText, admission.summary);
+}
+
+function deferredTopLevelRenameAdmission(admission) {
+  return {
+    ...admission,
+    status: 'candidate',
+    reasonCodes: ['top-level-rename-public-export-contract-deferred-to-project-graph'],
+    summary: {
+      ...admission.summary,
+      deferredToProjectGraph: true,
+      reasonCodes: ['top-level-rename-public-export-contract-deferred-to-project-graph']
+    }
+  };
+}
+
+function workerPreservesRenamedExportAlias(sourceText, summary) {
+  const fromName = summary?.fromName;
+  const toName = summary?.toName;
+  if (typeof sourceText !== 'string' || !fromName || !toName) return false;
+  const exportListPattern = new RegExp(`export\\s*\\{[^}]*\\b${escapeRegExp(toName)}\\s+as\\s+${escapeRegExp(fromName)}\\b[^}]*\\}`);
+  return exportListPattern.test(sourceText);
+}
+
+function escapeRegExp(value) {
+  return String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
 export { semanticEditFallbackResult };

package/dist/js-ts-safe-merge-source-shape-fallbacks.js

@@ -1,9 +1,11 @@
 import { createEnumMemberSemanticFallbackResult } from './js-ts-safe-merge-enum-member-fallback.js';
+import { createJsxAttributeSemanticFallbackResult } from './js-ts-safe-merge-jsx-attribute-fallback.js';
 import { createVariableDeclaratorSemanticFallbackResult } from './js-ts-safe-merge-variable-declarator-fallback.js';
 
 function createSourceShapeSemanticFallbackResult(input, topLevelResult, stagedFallback) {
   return createVariableDeclaratorSemanticFallbackResult(input, topLevelResult, stagedFallback)
-    ?? createEnumMemberSemanticFallbackResult(input, topLevelResult, stagedFallback);
+    ?? createEnumMemberSemanticFallbackResult(input, topLevelResult, stagedFallback)
+    ?? createJsxAttributeSemanticFallbackResult(input, topLevelResult, stagedFallback);
 }
 
 export { createSourceShapeSemanticFallbackResult };

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

@@ -0,0 +1,149 @@
+import { JsTsSafeMergeConflictCodes } from './js-ts-safe-merge-constants.js';
+import { createMergeContext, sameStatementText } from './js-ts-safe-merge-context.js';
+import { scanJsTsTopLevelLedger, validateLedgerUniqueness } from './js-ts-safe-merge-ledger.js';
+import { uniqueStrings } from './native-import-utils.js';
+
+const supportedRenameDeclarationKinds = new Set(['function', 'class', 'type']);
+
+function analyzeTopLevelRenameAdmission(input, topLevelResult) {
+  const originalReasonCodes = topLevelResult?.admission?.reasonCodes ?? [];
+  if (!originalReasonCodes.includes(JsTsSafeMergeConflictCodes.topLevelOrderChanged)) return undefined;
+  if (typeof input.baseSourceText !== 'string'
+    || typeof input.workerSourceText !== 'string'
+    || typeof input.headSourceText !== 'string') {
+    return undefined;
+  }
+
+  const context = createMergeContext(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) {
+    validateLedgerUniqueness(base, context);
+    validateLedgerUniqueness(worker, context);
+    validateLedgerUniqueness(head, context);
+  }
+  if (context.conflicts.length) return undefined;
+
+  const candidate = topLevelRenameCandidate(base, worker, head);
+  if (!candidate) return undefined;
+
+  const publicContractReasonCodes = publicContractRenameReasonCodes(base, worker, head, candidate);
+  if (publicContractReasonCodes.length) {
+    return {
+      status: 'blocked',
+      reasonCodes: publicContractReasonCodes,
+      summary: candidateSummary(candidate, publicContractReasonCodes),
+      ledgers: { base, worker, head }
+    };
+  }
+
+  return {
+    status: 'candidate',
+    reasonCodes: ['top-level-rename-source-shape-matches'],
+    summary: candidateSummary(candidate, ['top-level-rename-source-shape-matches']),
+    ledgers: { base, worker, head }
+  };
+}
+
+function topLevelRenameCandidate(base, worker, head) {
+  const baseByKey = entriesByKey(base.entries);
+  const workerByKey = entriesByKey(worker.entries);
+  const baseKeys = base.entries.map((entry) => entry.key);
+  const missingBaseDeclarations = base.entries
+    .filter((entry) => !workerByKey.has(entry.key))
+    .filter(isSupportedRenameDeclaration);
+  const addedWorkerDeclarations = worker.entries
+    .filter((entry) => !baseByKey.has(entry.key))
+    .filter(isSupportedRenameDeclaration);
+
+  if (missingBaseDeclarations.length !== 1 || addedWorkerDeclarations.length !== 1) return undefined;
+  const fromEntry = missingBaseDeclarations[0];
+  const toEntry = addedWorkerDeclarations[0];
+  const fromName = fromEntry.names?.[0];
+  const toName = toEntry.names?.[0];
+  if (!fromName || !toName || fromName === toName) return undefined;
+  if (fromEntry.declarationInfo?.declarationKind !== toEntry.declarationInfo?.declarationKind) return undefined;
+  if (!sameStatementText(renameDeclarationText(fromEntry.text, fromEntry.declarationInfo.declarationKind, fromName, toName), toEntry.text)) {
+    return undefined;
+  }
+
+  const workerProjectedBaseKeys = worker.entries.map((entry) => entry.key === toEntry.key ? fromEntry.key : entry.key);
+  if (!sameStringList(workerProjectedBaseKeys, baseKeys)) return undefined;
+  const headProjectedBaseKeys = head.entries
+    .filter((entry) => baseByKey.has(entry.key))
+    .map((entry) => entry.key);
+  if (!sameStringList(headProjectedBaseKeys, baseKeys)) return undefined;
+  if (head.entries.length !== base.entries.length) return undefined;
+
+  return {
+    fromEntry,
+    toEntry,
+    fromName,
+    toName,
+    declarationKind: fromEntry.declarationInfo.declarationKind
+  };
+}
+
+function isSupportedRenameDeclaration(entry) {
+  return entry?.kind === 'declaration'
+    && entry.names?.length === 1
+    && supportedRenameDeclarationKinds.has(entry.declarationInfo?.declarationKind)
+    && !entry.declarationInfo.defaultExport
+    && !/^\s*(?:export\s+)?declare\b/.test(entry.text ?? '');
+}
+
+function publicContractRenameReasonCodes(base, worker, head, candidate) {
+  const directExport = candidate.fromEntry.declarationInfo?.exported === true
+    || candidate.toEntry.declarationInfo?.exported === true;
+  const exportListMention = [base, worker, head]
+    .some((ledger) => ledger.entries
+      .some((entry) => entry.kind === 'export' && mentionsName(entry.text, candidate.fromName, candidate.toName)));
+  return directExport || exportListMention
+    ? [JsTsSafeMergeConflictCodes.topLevelRenamePublicExportContract]
+    : [];
+}
+
+function mentionsName(text, ...names) {
+  return names.some((name) => new RegExp(`\\b${escapeRegExp(name)}\\b`).test(text ?? ''));
+}
+
+function renameDeclarationText(text, declarationKind, fromName, toName) {
+  if (typeof text !== 'string') return undefined;
+  const escaped = escapeRegExp(fromName);
+  const replacement = `$1${toName}`;
+  if (declarationKind === 'function') {
+    return text.replace(new RegExp(`^((?:export\\s+)?(?:async\\s+)?function\\*?\\s+)${escaped}\\b`), replacement);
+  }
+  if (declarationKind === 'class') {
+    return text.replace(new RegExp(`^((?:export\\s+)?(?:abstract\\s+)?class\\s+)${escaped}\\b`), replacement);
+  }
+  if (declarationKind === 'type') {
+    return text.replace(new RegExp(`^((?:export\\s+)?type\\s+)${escaped}\\b`), replacement);
+  }
+  return undefined;
+}
+
+function candidateSummary(candidate, reasonCodes) {
+  return {
+    fromName: candidate.fromName,
+    toName: candidate.toName,
+    declarationKind: candidate.declarationKind,
+    exported: candidate.fromEntry.declarationInfo?.exported === true || candidate.toEntry.declarationInfo?.exported === true,
+    reasonCodes: uniqueStrings(reasonCodes)
+  };
+}
+
+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 escapeRegExp(value) {
+  return String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+export { analyzeTopLevelRenameAdmission };

package/dist/js-ts-safe-merge-top-level-rename-result.js

@@ -0,0 +1,44 @@
+import { JsTsSafeMergeConflictCodes, JsTsSafeMergeGateIds } from './js-ts-safe-merge-constants.js';
+import { uniqueStrings } from './native-import-utils.js';
+
+function topLevelRenameBlockedResult(input, topLevelResult, topLevelRenameAdmission) {
+  const reasonCodes = uniqueStrings([
+    ...(topLevelResult.admission?.reasonCodes ?? []),
+    ...(topLevelRenameAdmission.reasonCodes ?? [])
+  ]);
+  const conflict = {
+    code: JsTsSafeMergeConflictCodes.topLevelRenamePublicExportContract,
+    gateId: JsTsSafeMergeGateIds.stableExistingDeclarations,
+    message: 'Top-level rename changes a public export contract without project-level evidence.',
+    side: 'worker',
+    sourcePath: input.sourcePath ?? topLevelResult.sourcePath,
+    details: {
+      ...topLevelRenameAdmission.summary,
+      reasonCodes: topLevelRenameAdmission.reasonCodes
+    }
+  };
+  return {
+    ...topLevelResult,
+    conflicts: [...(topLevelResult.conflicts ?? []), conflict],
+    admission: {
+      status: 'blocked',
+      action: 'human-review',
+      reviewRequired: true,
+      autoApplyCandidate: false,
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      reasonCodes
+    },
+    summary: {
+      ...topLevelResult.summary,
+      conflicts: (topLevelResult.conflicts?.length ?? 0) + 1,
+      topLevelDeclarationRenames: 1
+    },
+    metadata: {
+      ...topLevelResult.metadata,
+      topLevelRenameAdmission: topLevelRenameAdmission.summary
+    }
+  };
+}
+
+export { topLevelRenameBlockedResult };

package/dist/js-ts-safe-project-merge-graph-conflicts.js

@@ -6,6 +6,7 @@ function outputProjectGraphConflicts(projectSymbolGraph) {
   const limitConflicts = Array.isArray(projectSymbolGraph?.limitConflicts) ? projectSymbolGraph.limitConflicts : [];
   projectSymbolGraph = projectSymbolGraph?.projectSymbolGraph ?? projectSymbolGraph;
   const importEdges = Array.isArray(projectSymbolGraph?.importEdges) ? projectSymbolGraph.importEdges : [];
+  const exportEdges = Array.isArray(projectSymbolGraph?.exportEdges) ? projectSymbolGraph.exportEdges : [];
   const missingModuleGroups = new Map();
   const missingSymbolGroups = new Map();
   for (const edge of importEdges) {
@@ -16,7 +17,7 @@ function outputProjectGraphConflicts(projectSymbolGraph) {
       missingModuleGroups.set(key, group);
       continue;
     }
-    if (isMissingProjectImportTargetEdge(edge)) {
+    if (isMissingProjectImportTargetEdge(edge, exportEdges)) {
       const key = [edge.sourcePath, edge.moduleSpecifier, projectImportTargetName(edge), edge.resolvedModulePath].join('\u0000');
       const group = missingSymbolGroups.get(key) ?? [];
       group.push(edge);
@@ -81,8 +82,11 @@ function isMissingProjectImportEdge(edge) {
   return typeof edge?.resolutionKind === 'string' && edge.resolutionKind.endsWith('-missing');
 }
 
-function isMissingProjectImportTargetEdge(edge) {
-  return hasResolvedProjectModule(edge) && Boolean(projectImportTargetName(edge)) && !edge.resolvedTargetSymbolId;
+function isMissingProjectImportTargetEdge(edge, exportEdges = []) {
+  return hasResolvedProjectModule(edge)
+    && Boolean(projectImportTargetName(edge))
+    && !edge.resolvedTargetSymbolId
+    && !commonJsRequireResolvedByExportAssignment(edge, exportEdges);
 }
 
 function hasResolvedProjectModule(edge) {
@@ -96,6 +100,23 @@ function projectImportTargetName(edge) {
   return String(name);
 }
 
+function commonJsRequireResolvedByExportAssignment(edge, exportEdges) {
+  if (edge?.importKind !== 'commonjs-require' || projectImportTargetName(edge) !== 'default') return false;
+  return exportEdges.some((exportEdge) => exportEdge?.exportKind === 'assignment'
+    && exportEdge.exportedName === 'module.exports'
+    && sameProjectDocument(edge, exportEdge));
+}
+
+function sameProjectDocument(importEdge, exportEdge) {
+  if (importEdge?.targetDocumentId && exportEdge?.sourceDocumentId) {
+    return importEdge.targetDocumentId === exportEdge.sourceDocumentId;
+  }
+  if (importEdge?.resolvedModulePath && exportEdge?.sourcePath) {
+    return importEdge.resolvedModulePath === exportEdge.sourcePath;
+  }
+  return false;
+}
+
 function duplicateReExportIdentityConflicts(records = []) {
   const groups = new Map();
   for (const record of records) {

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

@@ -112,6 +112,7 @@ function mergeProjectFile(file, input, projectId) {
     ...input,
     ...context,
     deferReExportIdentityConflictsToProjectGraph: input.includeProjectGraphDelta === true || input.includeOutputProjectSymbolGraph === true,
+    deferTopLevelRenamePublicExportContractToProjectGraph: input.includeProjectGraphDelta === true || input.includeOutputProjectSymbolGraph === true,
     id: `${projectId}_${safeId(file.sourcePath)}`,
     baseSourceText: base,
     workerSourceText: worker,
@@ -304,7 +305,6 @@ function blockedAdmission(reasonCode) {
 }
 
 function hashText(text) { return typeof text === 'string' ? hashSemanticValue(text) : undefined; }
-
 function stringOrUndefined(value) { return typeof value === 'string' ? value : undefined; }
 
 function safeId(value) {

package/package.json

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