@shapeshift-labs/frontier-lang-compiler 0.2.103 → 0.2.105

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

@@ -0,0 +1,265 @@
+import {
+  applyMemberAdditions,
+  applyPreparedMemberAdditions,
+  canonicalizeSourceBodies,
+  findContainer,
+  normalizeKind,
+  normalizeMemberText,
+  parseMembers,
+  uniqueStrings
+} from './js-ts-semantic-merge-parse.js';
+import { mergeResult } from './js-ts-safe-member-merge-result.js';
+
+const NonSemanticRegionKinds = new Set(['property', 'type', 'config', 'content']);
+const OrderSensitiveRegionKinds = new Set(['body', 'call', 'controlFlow', 'effect', 'import', 'mutation', 'route']);
+
+function safeMergeJsTsMembers(input = {}) {
+  return mergeJsTsSafeMemberAdditions(input);
+}
+
+function mergeJsTsSafeMemberAdditions(input = {}) {
+  const analysis = analyzeJsTsSafeMemberAdditions(input);
+  const uniqueReasons = uniqueStrings(analysis.reasonCodes);
+  if (uniqueReasons.length) {
+    return mergeResult('rejected', undefined, uniqueReasons, analysis.preparedRegions, input, analysis.explicitPolicy);
+  }
+  const sourceText = applyMemberAdditions(analysis.headSourceText, analysis.preparedRegions);
+  return mergeResult('merged', sourceText, [], analysis.preparedRegions, input, analysis.explicitPolicy);
+}
+
+function analyzeJsTsSafeMemberAdditions(input = {}) {
+  const analysis = prepareJsTsSafeMemberAdditions(input);
+  const reasonCodes = [...analysis.reasonCodes];
+  if (!input.allowNonPolicySourceChanges) {
+    reasonCodes.push(...nonPolicySourceChangeReasons(analysis));
+  }
+  return {
+    ...analysis,
+    reasonCodes: uniqueStrings(reasonCodes),
+    ok: reasonCodes.length === 0
+  };
+}
+
+function neutralizeJsTsSafeMemberMergeSources(input = {}) {
+  const analysis = analyzeJsTsSafeMemberAdditions({
+    ...input,
+    allowNonPolicySourceChanges: true
+  });
+  if (analysis.reasonCodes.length) {
+    return {
+      ok: false,
+      analysis,
+      result: mergeResult('rejected', undefined, analysis.reasonCodes, analysis.preparedRegions, input, analysis.explicitPolicy)
+    };
+  }
+  return {
+    ok: true,
+    analysis,
+    baseSourceText: analysis.baseSourceText,
+    workerSourceText: canonicalizeSourceBodies(analysis.workerSourceText, analysis.preparedRegions, 'worker'),
+    headSourceText: canonicalizeSourceBodies(analysis.headSourceText, analysis.preparedRegions, 'head')
+  };
+}
+
+function applyJsTsPreparedMemberAdditions(sourceText, preparedRegions, sides) {
+  return applyPreparedMemberAdditions(sourceText, preparedRegions, sides);
+}
+
+function prepareJsTsSafeMemberAdditions(input = {}) {
+  const baseSourceText = input.baseSourceText;
+  const workerSourceText = input.workerSourceText;
+  const headSourceText = input.headSourceText;
+  const reasonCodes = [];
+  if (typeof baseSourceText !== 'string') reasonCodes.push('missing-base-source-text');
+  if (typeof workerSourceText !== 'string') reasonCodes.push('missing-worker-source-text');
+  if (typeof headSourceText !== 'string') reasonCodes.push('missing-head-source-text');
+  const policyRegions = normalizePolicyRegions(input.policy ?? input.mergePolicy ?? input);
+  if (!policyRegions.length) reasonCodes.push('missing-unordered-region-policy');
+  const preparedRegions = [];
+  for (const region of policyRegions) {
+    const policyReasons = validatePolicyRegion(region);
+    reasonCodes.push(...policyReasons);
+    if (policyReasons.length) continue;
+    if (typeof baseSourceText !== 'string' || typeof workerSourceText !== 'string' || typeof headSourceText !== 'string') continue;
+    const prepared = prepareRegion({ region, baseSourceText, workerSourceText, headSourceText });
+    reasonCodes.push(...prepared.reasonCodes);
+    if (prepared.ok) preparedRegions.push(prepared.value);
+  }
+  const explicitPolicy = policyRegions.length > 0;
+  return {
+    baseSourceText,
+    workerSourceText,
+    headSourceText,
+    reasonCodes: uniqueStrings(reasonCodes),
+    preparedRegions,
+    explicitPolicy
+  };
+}
+
+function nonPolicySourceChangeReasons(analysis) {
+  const reasonCodes = [];
+  const { baseSourceText, workerSourceText, headSourceText, preparedRegions } = analysis;
+  if (typeof baseSourceText === 'string' && typeof workerSourceText === 'string' && preparedRegions.length) {
+    const canonicalWorker = canonicalizeSourceBodies(workerSourceText, preparedRegions, 'worker');
+    if (canonicalWorker !== baseSourceText) reasonCodes.push('non-policy-source-change:worker');
+  }
+  if (typeof baseSourceText === 'string' && typeof headSourceText === 'string' && preparedRegions.length) {
+    const canonicalHead = canonicalizeSourceBodies(headSourceText, preparedRegions, 'head');
+    if (canonicalHead !== baseSourceText) reasonCodes.push('non-policy-source-change:head');
+  }
+  return reasonCodes;
+}
+
+function normalizePolicyRegions(policy) {
+  const direct = Array.isArray(policy) ? policy : undefined;
+  const regions = direct
+    ?? policy?.unorderedRegions
+    ?? policy?.unorderedMemberRegions
+    ?? policy?.safeList
+    ?? policy?.safeMembers
+    ?? [];
+  return Array.isArray(regions) ? regions : [];
+}
+
+function validatePolicyRegion(region) {
+  const reasonCodes = [];
+  const kind = normalizeKind(region?.kind);
+  if (!kind || !['interface', 'type', 'class', 'object'].includes(kind)) reasonCodes.push('unsupported-region-kind');
+  if (!region?.name || typeof region.name !== 'string') reasonCodes.push('missing-region-name');
+  if (!regionDeclaresNonSemanticOrder(region)) reasonCodes.push('region-not-declared-non-semantic');
+  const regionKind = region?.regionKind;
+  if (regionKind && OrderSensitiveRegionKinds.has(regionKind)) reasonCodes.push(`order-sensitive-region-kind:${regionKind}`);
+  if (kind === 'object' && (!regionKind || !NonSemanticRegionKinds.has(regionKind))) reasonCodes.push('object-region-kind-not-safe-listed');
+  return reasonCodes;
+}
+
+function regionDeclaresNonSemanticOrder(region) {
+  return region?.order === 'non-semantic'
+    || region?.ordering === 'non-semantic'
+    || region?.nonSemanticOrder === true
+    || region?.orderSensitive === false;
+}
+
+function prepareRegion(input) {
+  const kind = normalizeKind(input.region.kind);
+  const base = findContainer(input.baseSourceText, input.region);
+  const worker = findContainer(input.workerSourceText, input.region);
+  const head = findContainer(input.headSourceText, input.region);
+  const reasonCodes = [];
+  for (const [side, match] of [['base', base], ['worker', worker], ['head', head]]) {
+    if (match.reasonCodes.length) reasonCodes.push(...match.reasonCodes.map((reason) => `${reason}:${side}:${kind}:${input.region.name}`));
+  }
+  if (reasonCodes.length) return { ok: false, reasonCodes };
+  const baseMembers = parseMembers(base.value.body, kind);
+  const workerMembers = parseMembers(worker.value.body, kind);
+  const headMembers = parseMembers(head.value.body, kind);
+  reasonCodes.push(...regionParseReasons(input.region, 'base', baseMembers));
+  reasonCodes.push(...regionParseReasons(input.region, 'worker', workerMembers));
+  reasonCodes.push(...regionParseReasons(input.region, 'head', headMembers));
+  reasonCodes.push(...duplicateReasons(input.region, 'base', baseMembers.members));
+  reasonCodes.push(...duplicateReasons(input.region, 'worker', workerMembers.members));
+  reasonCodes.push(...duplicateReasons(input.region, 'head', headMembers.members));
+  if (reasonCodes.length) return { ok: false, reasonCodes };
+  const baseByKey = membersByKey(baseMembers.members);
+  const workerByKey = membersByKey(workerMembers.members);
+  const headByKey = membersByKey(headMembers.members);
+  reasonCodes.push(...existingMemberReasons(input.region, 'worker', baseMembers.members, workerMembers.members, workerByKey));
+  reasonCodes.push(...existingMemberReasons(input.region, 'head', baseMembers.members, headMembers.members, headByKey));
+  const workerAddedKeys = workerMembers.members.map((member) => member.key).filter((key) => !baseByKey.has(key));
+  const headAddedKeys = headMembers.members.map((member) => member.key).filter((key) => !baseByKey.has(key));
+  reasonCodes.push(...duplicateAddedReasons(input.region, workerAddedKeys, workerByKey, headByKey));
+  if (reasonCodes.length) return { ok: false, reasonCodes };
+  return {
+    ok: true,
+    reasonCodes: [],
+    value: {
+      policy: input.region,
+      kind,
+      name: input.region.name,
+      base: base.value,
+      worker: worker.value,
+      head: head.value,
+      baseMembers: baseMembers.members,
+      workerMembers: workerMembers.members,
+      headMembers: headMembers.members,
+      workerAddedKeys,
+      headAddedKeys,
+      workerAddedMembers: workerMembers.members.filter((member) => workerAddedKeys.includes(member.key)),
+      headAddedMembers: headMembers.members.filter((member) => headAddedKeys.includes(member.key))
+    }
+  };
+}
+
+function regionParseReasons(region, side, parsed) {
+  return parsed.reasonCodes.map((reason) => regionReason(region, `${reason}:${side}`));
+}
+
+function duplicateReasons(region, side, members) {
+  const seen = new Map();
+  const duplicateGroups = new Map();
+  for (const member of members) {
+    const group = seen.get(member.key);
+    if (group) {
+      group.push(member);
+      duplicateGroups.set(member.key, group);
+    } else {
+      seen.set(member.key, [member]);
+    }
+  }
+  return [...duplicateGroups].map(([key, group]) => {
+    const reason = group.some(isOverloadLikeMember) ? `overload-collision:${side}:${key}` : `duplicate-key:${side}:${key}`;
+    return regionReason(region, reason);
+  });
+}
+
+function existingMemberReasons(region, side, baseMembers, sideMembers, sideByKey) {
+  const reasonCodes = [];
+  const sideBaseOrder = sideMembers.map((member) => member.key).filter((key) => baseMembers.some((baseMember) => baseMember.key === key));
+  const baseOrder = baseMembers.map((member) => member.key);
+  if (sideBaseOrder.join('\u0000') !== baseOrder.join('\u0000')) {
+    reasonCodes.push(regionReason(region, `existing-member-order-changed:${side}`));
+  }
+  for (const baseMember of baseMembers) {
+    const sideMember = sideByKey.get(baseMember.key);
+    if (!sideMember) {
+      reasonCodes.push(regionReason(region, `existing-member-removed:${side}:${baseMember.key}`));
+      continue;
+    }
+    if (normalizeMemberText(sideMember.text) !== normalizeMemberText(baseMember.text)) {
+      reasonCodes.push(regionReason(region, `existing-member-changed:${side}:${baseMember.key}`));
+    }
+  }
+  return reasonCodes;
+}
+
+function duplicateAddedReasons(region, workerAddedKeys, workerByKey, headByKey) {
+  const duplicateAddedKeys = workerAddedKeys.filter((key) => headByKey.has(key));
+  return duplicateAddedKeys.map((key) => {
+    const workerMember = workerByKey.get(key);
+    const headMember = headByKey.get(key);
+    const reason = isOverloadLikeMember(workerMember) || isOverloadLikeMember(headMember)
+      ? `overload-collision:worker-head:${key}`
+      : `duplicate-added-key:${key}`;
+    return regionReason(region, reason);
+  });
+}
+
+function isOverloadLikeMember(member) {
+  return member?.memberKind === 'method' || member?.memberKind === 'constructor';
+}
+
+function membersByKey(members) {
+  return new Map(members.map((member) => [member.key, member]));
+}
+
+function regionReason(region, reason) {
+  return `${reason}:${normalizeKind(region.kind)}:${region.name}`;
+}
+
+export {
+  analyzeJsTsSafeMemberAdditions,
+  applyJsTsPreparedMemberAdditions,
+  mergeJsTsSafeMemberAdditions,
+  neutralizeJsTsSafeMemberMergeSources,
+  safeMergeJsTsMembers
+};

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

@@ -0,0 +1,279 @@
+import { JsTsSafeMergeConflictCodes, JsTsSafeMergeGateIds } from './js-ts-safe-merge-constants.js';
+import { addConflict, arraysEqual, sameStatementText } from './js-ts-safe-merge-context.js';
+
+export function analyzeVariantLedger(base, variant, baseIndex, side, context) {
+  const projectedBaseKeys = [];
+  const addedEntries = [];
+  const importAdditions = new Map();
+  const baseKeys = new Set(baseIndex.orderedKeys);
+
+  for (const entry of variant.entries) {
+    const baseEntry = baseIndex.entriesByKey.get(entry.key);
+    if (!baseEntry) {
+      if (entry.kind === 'import') {
+        addConflict(context, {
+          code: JsTsSafeMergeConflictCodes.newImportDeclaration,
+          gateId: JsTsSafeMergeGateIds.independentImportSpecifiers,
+          side,
+          message: `${side} source adds a new import declaration; only specifier additions to existing imports are accepted.`,
+          details: { key: entry.key, statement: entry.text.trim() }
+        });
+      } else {
+        addedEntries.push(entry);
+      }
+      continue;
+    }
+    projectedBaseKeys.push(entry.key);
+    if (entry.kind !== baseEntry.kind) {
+      addConflict(context, {
+        code: JsTsSafeMergeConflictCodes.parserLedgerLoss,
+        gateId: JsTsSafeMergeGateIds.parseLedger,
+        side,
+        message: `${side} source changes a base ledger entry kind.`,
+        details: { key: entry.key, baseKind: baseEntry.kind, sideKind: entry.kind }
+      });
+      continue;
+    }
+    if (entry.kind === 'import') {
+      const additions = analyzeImportStatementChange(baseEntry, entry, side, context);
+      if (additions.length) importAdditions.set(entry.key, additions);
+    } else if (!sameStatementText(baseEntry.text, entry.text)) {
+      const typeAliasConflict = baseEntry.declarationInfo?.declarationKind === 'type'
+        || entry.declarationInfo?.declarationKind === 'type';
+      addConflict(context, {
+        code: typeAliasConflict ? JsTsSafeMergeConflictCodes.typeAliasConflict : JsTsSafeMergeConflictCodes.changedExistingDeclaration,
+        gateId: JsTsSafeMergeGateIds.stableExistingDeclarations,
+        side,
+        message: typeAliasConflict
+          ? `${side} source changes an existing type alias body.`
+          : `${side} source changes an existing top-level declaration or export body.`,
+        details: { key: entry.key, name: entry.names?.[0], declarationKind: entry.declarationInfo?.declarationKind }
+      });
+    }
+  }
+
+  if (!arraysEqual(projectedBaseKeys, baseIndex.orderedKeys)) {
+    const code = base.entries.some((entry) => entry.kind === 'import' && entry.importInfo.sideEffectOnly)
+      ? JsTsSafeMergeConflictCodes.sideEffectImportReorder
+      : JsTsSafeMergeConflictCodes.topLevelOrderChanged;
+    addConflict(context, {
+      code,
+      gateId: JsTsSafeMergeGateIds.preserveBaseOrder,
+      side,
+      message: `${side} source changes the order or presence of base top-level entries.`,
+      details: {
+        expected: baseIndex.orderedKeys,
+        actual: projectedBaseKeys
+      }
+    });
+  }
+
+  return {
+    side,
+    addedEntries,
+    importAdditions,
+    baseKeys
+  };
+}
+
+function analyzeImportStatementChange(baseEntry, variantEntry, side, context) {
+  const baseImport = baseEntry.importInfo;
+  const variantImport = variantEntry.importInfo;
+  if (!sameImportShape(baseImport, variantImport)) {
+    addConflict(context, {
+      code: baseImport.sideEffectOnly ? JsTsSafeMergeConflictCodes.sideEffectImportReorder : JsTsSafeMergeConflictCodes.importShapeChanged,
+      gateId: JsTsSafeMergeGateIds.independentImportSpecifiers,
+      side,
+      message: `${side} source changes an existing import shape instead of adding named specifiers.`,
+      details: { key: baseEntry.key }
+    });
+    return [];
+  }
+  if (baseImport.sideEffectOnly) {
+    if (!sameStatementText(baseEntry.text, variantEntry.text)) {
+      addConflict(context, {
+        code: JsTsSafeMergeConflictCodes.sideEffectImportReorder,
+        gateId: JsTsSafeMergeGateIds.preserveBaseOrder,
+        side,
+        message: `${side} source changes a side-effect import.`,
+        details: { key: baseEntry.key }
+      });
+    }
+    return [];
+  }
+
+  const baseSpecifiers = baseImport.specifiers;
+  const variantSpecifiers = variantImport.specifiers;
+  if (variantSpecifiers.length < baseSpecifiers.length) {
+    addConflict(context, {
+      code: JsTsSafeMergeConflictCodes.importSpecifierRemoved,
+      gateId: JsTsSafeMergeGateIds.independentImportSpecifiers,
+      side,
+      message: `${side} source removes import specifiers.`,
+      details: { key: baseEntry.key }
+    });
+    return [];
+  }
+  for (let index = 0; index < baseSpecifiers.length; index += 1) {
+    if (variantSpecifiers[index]?.canonical !== baseSpecifiers[index].canonical) {
+      addConflict(context, {
+        code: JsTsSafeMergeConflictCodes.importSpecifierReordered,
+        gateId: JsTsSafeMergeGateIds.independentImportSpecifiers,
+        side,
+        message: `${side} source reorders or changes existing import specifiers.`,
+        details: {
+          key: baseEntry.key,
+          expected: baseSpecifiers.map((specifier) => specifier.canonical),
+          actual: variantSpecifiers.map((specifier) => specifier.canonical)
+        }
+      });
+      return [];
+    }
+  }
+  const additions = variantSpecifiers.slice(baseSpecifiers.length);
+  if (additions.length === 0 && !sameStatementText(baseEntry.text, variantEntry.text)) {
+    addConflict(context, {
+      code: JsTsSafeMergeConflictCodes.importFormattingChanged,
+      gateId: JsTsSafeMergeGateIds.independentImportSpecifiers,
+      side,
+      message: `${side} source changes import formatting without a specifier addition.`,
+      details: { key: baseEntry.key }
+    });
+  }
+  return additions;
+}
+
+function sameImportShape(left, right) {
+  return left.moduleSpecifier === right.moduleSpecifier
+    && left.typeOnly === right.typeOnly
+    && left.sideEffectOnly === right.sideEffectOnly
+    && left.defaultLocalName === right.defaultLocalName
+    && left.namespaceLocalName === right.namespaceLocalName;
+}
+
+export function validateIndependentAdditions(base, workerPlan, headPlan, context) {
+  const declarationNames = new Set();
+  for (const entry of base.entries.filter((item) => item.kind !== 'import')) {
+    for (const name of entry.names ?? []) declarationNames.add(`${entry.kind}:${name}`);
+  }
+  validateAddedEntryNames(workerPlan, declarationNames, context);
+  validateAddedEntryNames(headPlan, declarationNames, context);
+  validateCrossSideAddedNames(workerPlan, headPlan, context);
+  validateCrossSideImportAdditions(workerPlan, headPlan, context);
+  validateMergedImportAndDeclarationNames(base, workerPlan, headPlan, context);
+}
+
+function validateAddedEntryNames(plan, baseNames, context) {
+  for (const entry of plan.addedEntries) {
+    if (entry.kind !== 'declaration' && entry.kind !== 'export') {
+      addConflict(context, {
+        code: JsTsSafeMergeConflictCodes.parserLedgerLoss,
+        gateId: JsTsSafeMergeGateIds.independentTopLevelDeclarations,
+        side: plan.side,
+        message: `${plan.side} source adds an unsupported top-level entry.`,
+        details: { kind: entry.kind, statement: entry.text.trim() }
+      });
+      continue;
+    }
+    for (const name of entry.names ?? []) {
+      const nameKey = `${entry.kind}:${name}`;
+      if (baseNames.has(nameKey)) {
+        addConflict(context, {
+          code: JsTsSafeMergeConflictCodes.duplicateName,
+          gateId: JsTsSafeMergeGateIds.uniqueNames,
+          side: plan.side,
+          message: `${plan.side} source adds a duplicate top-level name.`,
+          details: { name, kind: entry.kind }
+        });
+      }
+    }
+  }
+}
+
+function validateCrossSideAddedNames(workerPlan, headPlan, context) {
+  const headEntriesByName = new Map();
+  for (const entry of headPlan.addedEntries) {
+    for (const name of entry.names ?? []) headEntriesByName.set(`${entry.kind}:${name}`, entry);
+  }
+  for (const entry of workerPlan.addedEntries) {
+    for (const name of entry.names ?? []) {
+      const nameKey = `${entry.kind}:${name}`;
+      const headEntry = headEntriesByName.get(nameKey);
+      if (headEntry) {
+        const typeAliasConflict = entry.declarationInfo?.declarationKind === 'type'
+          || headEntry.declarationInfo?.declarationKind === 'type';
+        addConflict(context, {
+          code: typeAliasConflict ? JsTsSafeMergeConflictCodes.typeAliasConflict : JsTsSafeMergeConflictCodes.duplicateName,
+          gateId: JsTsSafeMergeGateIds.uniqueNames,
+          side: 'worker',
+          message: typeAliasConflict
+            ? 'Worker and head add conflicting type aliases.'
+            : 'Worker and head add the same top-level name.',
+          details: { name, kind: entry.kind, workerDeclarationKind: entry.declarationInfo?.declarationKind, headDeclarationKind: headEntry.declarationInfo?.declarationKind }
+        });
+      }
+    }
+  }
+}
+
+function validateCrossSideImportAdditions(workerPlan, headPlan, context) {
+  for (const [key, workerAdditions] of workerPlan.importAdditions) {
+    const headAdditions = headPlan.importAdditions.get(key) ?? [];
+    const headLocalNames = new Set(headAdditions.map((specifier) => specifier.localName));
+    const headImportedNames = new Set(headAdditions.map((specifier) => `${specifier.typeOnly ? 'type:' : 'value:'}${specifier.importedName}`));
+    for (const specifier of workerAdditions) {
+      if (headLocalNames.has(specifier.localName) || headImportedNames.has(`${specifier.typeOnly ? 'type:' : 'value:'}${specifier.importedName}`)) {
+        addConflict(context, {
+          code: JsTsSafeMergeConflictCodes.duplicateName,
+          gateId: JsTsSafeMergeGateIds.uniqueNames,
+          side: 'worker',
+          message: 'Worker and head add duplicate import specifiers.',
+          details: { key, specifier: specifier.canonical }
+        });
+      }
+    }
+  }
+}
+
+function validateMergedImportAndDeclarationNames(base, workerPlan, headPlan, context) {
+  const topLevelBindingNames = new Set();
+  for (const entry of base.entries.filter((item) => item.kind !== 'import')) {
+    for (const name of entry.names ?? []) topLevelBindingNames.add(name);
+  }
+  for (const plan of [workerPlan, headPlan]) {
+    for (const entry of plan.addedEntries.filter((item) => item.kind !== 'import')) {
+      for (const name of entry.names ?? []) topLevelBindingNames.add(name);
+    }
+  }
+  const importLocalNames = new Set();
+  for (const entry of base.entries.filter((item) => item.kind === 'import')) {
+    const additions = [
+      ...(workerPlan.importAdditions.get(entry.key) ?? []),
+      ...(headPlan.importAdditions.get(entry.key) ?? [])
+    ];
+    for (const specifier of [
+      ...(entry.importInfo.defaultLocalName ? [{ localName: entry.importInfo.defaultLocalName, canonical: `default:${entry.importInfo.defaultLocalName}` }] : []),
+      ...(entry.importInfo.namespaceLocalName ? [{ localName: entry.importInfo.namespaceLocalName, canonical: `namespace:${entry.importInfo.namespaceLocalName}` }] : []),
+      ...entry.importInfo.specifiers,
+      ...additions
+    ]) {
+      if (importLocalNames.has(specifier.localName)) {
+        addConflict(context, {
+          code: JsTsSafeMergeConflictCodes.duplicateName,
+          gateId: JsTsSafeMergeGateIds.uniqueNames,
+          message: 'Merged imports would contain duplicate local names.',
+          details: { localName: specifier.localName, specifier: specifier.canonical }
+        });
+      }
+      if (topLevelBindingNames.has(specifier.localName)) {
+        addConflict(context, {
+          code: JsTsSafeMergeConflictCodes.duplicateName,
+          gateId: JsTsSafeMergeGateIds.uniqueNames,
+          message: 'Merged imports would duplicate a top-level declaration name.',
+          details: { localName: specifier.localName, specifier: specifier.canonical }
+        });
+      }
+      importLocalNames.add(specifier.localName);
+    }
+  }
+}