@shapeshift-labs/frontier-lang-compiler 0.2.130 → 0.2.131

package/README.md

@@ -169,7 +169,7 @@ The JS/TS semantic merge smoke corpus lives at
 small and dependency-free. They cover accepted projection/replay cases, exact
 source preservation, generated/source-map boundaries, safe import/declaration
 merges, safe unordered member merges, composed top-level/member safe merges,
-and rejected unsafe cases such as stale
+existing import binding-shape additions, and rejected unsafe cases such as stale
 ledger spans, import specifier removals, computed keys, duplicate exported
 names, duplicate object members, decorators, overload anchors, and same-anchor
 edit conflicts. Fixture failures include the fixture id and the actual
@@ -182,7 +182,8 @@ JS/TS ledger-approved head-to-merged source edits into a semantic edit script,
 projection, replay, and already-applied replay. This is intentionally different
 from asking the generic three-way edit classifier to bless every JS/TS case:
 simultaneous import specifier additions are safe only because the JS/TS ledger
-gates proved independent additions, stable anchors, and source replay. The
+gates proved independent additions, compatible import binding expansions,
+stable anchors, and source replay. The
 artifacts keep `autoMergeClaim: false` and `semanticEquivalenceClaim: false`,
 but give coordinators machine-readable proof that the projected source matches
 the merge output and that applying the same projection again is a no-op.

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

@@ -2,17 +2,27 @@ import { JsTsSafeMergeConflictCodes, JsTsSafeMergeGateIds } from './js-ts-safe-m
 import { addConflict, arraysEqual, sameStatementText } from './js-ts-safe-merge-context.js';
 import { validateCrossSideExportStarAdditions } from './js-ts-safe-merge-export-star-validation.js';
 import { importEntryBindings, mergedNewImportBindings } from './js-ts-safe-merge-import-entry-utils.js';
+import {
+  classifyImportExpansion,
+  findCompatibleBaseImportEntry,
+  findSameImportTargetBaseEntry
+} from './js-ts-safe-merge-import-shape.js';
 import { validateNewImportDeclarations } from './js-ts-safe-merge-new-import-validation.js';
 
 export function analyzeVariantLedger(base, variant, baseIndex, side, context) {
   const projectedBaseKeys = [];
+  const projectedBaseKeySet = new Set();
+  const matchedVariantKeys = new Set();
+  const baseKeyByVariantKey = new Map();
   const addedEntries = [];
   const newImportEntries = [];
   const importAdditions = new Map();
-  const baseKeys = new Set(baseIndex.orderedKeys);
+  const baseEntries = baseIndex.orderedKeys.map((key) => baseIndex.entriesByKey.get(key)).filter(Boolean);
 
   for (const entry of variant.entries) {
-    const baseEntry = baseIndex.entriesByKey.get(entry.key);
+    const baseEntry = baseIndex.entriesByKey.get(entry.key)
+      ?? findCompatibleBaseImportEntry(entry, baseEntries, projectedBaseKeySet)
+      ?? findSameImportTargetBaseEntry(entry, baseEntries, projectedBaseKeySet);
     if (!baseEntry) {
       if (entry.kind === 'import') {
         newImportEntries.push(entry);
@@ -21,7 +31,10 @@ export function analyzeVariantLedger(base, variant, baseIndex, side, context) {
       }
       continue;
     }
-    projectedBaseKeys.push(entry.key);
+    projectedBaseKeys.push(baseEntry.key);
+    projectedBaseKeySet.add(baseEntry.key);
+    matchedVariantKeys.add(entry.key);
+    baseKeyByVariantKey.set(entry.key, baseEntry.key);
     if (entry.kind !== baseEntry.kind) {
       addConflict(context, {
         code: JsTsSafeMergeConflictCodes.parserLedgerLoss,
@@ -34,7 +47,7 @@ export function analyzeVariantLedger(base, variant, baseIndex, side, context) {
     }
     if (entry.kind === 'import') {
       const additions = analyzeImportStatementChange(baseEntry, entry, side, context);
-      if (additions.length) importAdditions.set(entry.key, additions);
+      if (additions.length) importAdditions.set(baseEntry.key, additions);
     } else if (!sameStatementText(baseEntry.text, entry.text)) {
       const typeAliasConflict = baseEntry.declarationInfo?.declarationKind === 'type'
         || entry.declarationInfo?.declarationKind === 'type';
@@ -71,20 +84,22 @@ export function analyzeVariantLedger(base, variant, baseIndex, side, context) {
     addedEntries,
     newImportEntries,
     importAdditions,
-    baseKeys
+    matchedVariantKeys,
+    baseKeyByVariantKey
   };
 }
 
 function analyzeImportStatementChange(baseEntry, variantEntry, side, context) {
   const baseImport = baseEntry.importInfo;
   const variantImport = variantEntry.importInfo;
-  if (!sameImportShape(baseImport, variantImport)) {
+  const expansion = classifyImportExpansion(baseImport, variantImport);
+  if (!expansion.compatible) {
     addConflict(context, {
-      code: baseImport.sideEffectOnly ? JsTsSafeMergeConflictCodes.sideEffectImportReorder : JsTsSafeMergeConflictCodes.importShapeChanged,
-      gateId: JsTsSafeMergeGateIds.independentImportSpecifiers,
+      code: expansion.code,
+      gateId: expansion.gateId,
       side,
-      message: `${side} source changes an existing import shape instead of adding named specifiers.`,
-      details: { key: baseEntry.key }
+      message: expansion.message,
+      details: { key: baseEntry.key, ...expansion.details }
     });
     return [];
   }
@@ -104,22 +119,9 @@ function analyzeImportStatementChange(baseEntry, variantEntry, side, context) {
   const baseSpecifiers = baseImport.specifiers;
   const variantSpecifiers = variantImport.specifiers;
   const baseSpecifiersByCanonical = new Set(baseSpecifiers.map((specifier) => specifier.canonical));
-  const variantSpecifiersByCanonical = new Set(variantSpecifiers.map((specifier) => specifier.canonical));
-  const missingBaseSpecifiers = baseSpecifiers.filter((specifier) => !variantSpecifiersByCanonical.has(specifier.canonical));
-  if (missingBaseSpecifiers.length) {
-    addConflict(context, {
-      code: JsTsSafeMergeConflictCodes.importSpecifierRemoved,
-      gateId: JsTsSafeMergeGateIds.independentImportSpecifiers,
-      side,
-      message: `${side} source removes import specifiers.`,
-      details: {
-        key: baseEntry.key,
-        missing: missingBaseSpecifiers.map((specifier) => specifier.canonical)
-      }
-    });
-    return [];
-  }
   const additions = variantSpecifiers.filter((specifier) => !baseSpecifiersByCanonical.has(specifier.canonical));
+  if (expansion.defaultAddition) additions.unshift(expansion.defaultAddition);
+  if (expansion.namespaceAddition) additions.unshift(expansion.namespaceAddition);
   if (additions.length === 0 && !sameStatementText(baseEntry.text, variantEntry.text)) {
     const baseCanonicalOrder = baseSpecifiers.map((specifier) => specifier.canonical);
     const variantCanonicalOrder = variantSpecifiers.map((specifier) => specifier.canonical);
@@ -135,14 +137,6 @@ function analyzeImportStatementChange(baseEntry, variantEntry, side, context) {
   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')) {

package/dist/js-ts-safe-merge-import-shape.js

@@ -0,0 +1,102 @@
+import { JsTsSafeMergeConflictCodes, JsTsSafeMergeGateIds } from './js-ts-safe-merge-constants.js';
+
+function classifyImportExpansion(baseImport, variantImport) {
+  if (baseImport.moduleSpecifier !== variantImport.moduleSpecifier
+    || baseImport.typeOnly !== variantImport.typeOnly
+    || baseImport.sideEffectOnly !== variantImport.sideEffectOnly) {
+    return importShapeConflict('variant changes import module, type-only mode, or side-effect mode');
+  }
+  if (baseImport.sideEffectOnly) return { compatible: true };
+  if (baseImport.defaultLocalName && variantImport.defaultLocalName !== baseImport.defaultLocalName) {
+    return importShapeConflict('variant changes or removes an existing default import binding');
+  }
+  if (baseImport.namespaceLocalName && variantImport.namespaceLocalName !== baseImport.namespaceLocalName) {
+    return importShapeConflict('variant changes or removes an existing namespace import binding');
+  }
+  if (variantImport.namespaceLocalName && variantImport.specifiers.length > 0) {
+    return importShapeConflict('variant combines namespace and named import specifiers');
+  }
+  const variantSpecifiersByCanonical = new Set(variantImport.specifiers.map((specifier) => specifier.canonical));
+  const missingBaseSpecifiers = baseImport.specifiers.filter((specifier) => !variantSpecifiersByCanonical.has(specifier.canonical));
+  if (missingBaseSpecifiers.length) {
+    return {
+      compatible: false,
+      code: JsTsSafeMergeConflictCodes.importSpecifierRemoved,
+      gateId: JsTsSafeMergeGateIds.independentImportSpecifiers,
+      message: 'variant removes import specifiers.',
+      details: { missing: missingBaseSpecifiers.map((specifier) => specifier.canonical) }
+    };
+  }
+  return {
+    compatible: true,
+    defaultAddition: !baseImport.defaultLocalName && variantImport.defaultLocalName
+      ? importShapeAddition('default', variantImport.defaultLocalName, variantImport.typeOnly)
+      : undefined,
+    namespaceAddition: !baseImport.namespaceLocalName && variantImport.namespaceLocalName
+      ? importShapeAddition('namespace', variantImport.namespaceLocalName, variantImport.typeOnly)
+      : undefined
+  };
+}
+
+function findCompatibleBaseImportEntry(variantEntry, baseEntries, usedBaseKeys = new Set()) {
+  if (variantEntry?.kind !== 'import') return undefined;
+  const candidates = [];
+  for (const baseEntry of baseEntries) {
+    if (usedBaseKeys.has(baseEntry.key) || baseEntry.kind !== 'import') continue;
+    if (classifyImportExpansion(baseEntry.importInfo, variantEntry.importInfo).compatible) candidates.push(baseEntry);
+  }
+  return candidates.length === 1 ? candidates[0] : undefined;
+}
+
+function findSameImportTargetBaseEntry(variantEntry, baseEntries, usedBaseKeys = new Set()) {
+  if (variantEntry?.kind !== 'import') return undefined;
+  const candidates = [];
+  for (const baseEntry of baseEntries) {
+    if (usedBaseKeys.has(baseEntry.key) || baseEntry.kind !== 'import') continue;
+    if (sameImportTarget(baseEntry.importInfo, variantEntry.importInfo)) candidates.push(baseEntry);
+  }
+  return candidates.length === 1 ? candidates[0] : undefined;
+}
+
+function findCompatibleVariantImportEntry(baseEntry, variantEntries, usedVariantKeys = new Set()) {
+  if (baseEntry?.kind !== 'import') return undefined;
+  const candidates = [];
+  for (const variantEntry of variantEntries) {
+    if (usedVariantKeys.has(variantEntry.key) || variantEntry.kind !== 'import') continue;
+    if (classifyImportExpansion(baseEntry.importInfo, variantEntry.importInfo).compatible) candidates.push(variantEntry);
+  }
+  return candidates.length === 1 ? candidates[0] : undefined;
+}
+
+function sameImportTarget(left, right) {
+  return left.moduleSpecifier === right.moduleSpecifier
+    && left.typeOnly === right.typeOnly
+    && left.sideEffectOnly === right.sideEffectOnly;
+}
+
+function importShapeConflict(reasonCode) {
+  return {
+    compatible: false,
+    code: JsTsSafeMergeConflictCodes.importShapeChanged,
+    gateId: JsTsSafeMergeGateIds.independentImportSpecifiers,
+    message: 'variant changes an existing import shape instead of adding safe bindings.',
+    details: { reasonCode }
+  };
+}
+
+function importShapeAddition(kind, localName, typeOnly) {
+  return {
+    additionKind: kind,
+    importedName: kind === 'default' ? 'default' : '*',
+    localName,
+    typeOnly,
+    canonical: `${kind}:${localName}`
+  };
+}
+
+export {
+  classifyImportExpansion,
+  findCompatibleBaseImportEntry,
+  findSameImportTargetBaseEntry,
+  findCompatibleVariantImportEntry
+};

package/dist/js-ts-safe-merge-parse-declarations.js

@@ -61,6 +61,15 @@ function parseImportInfo(text) {
 }
 
 function parseImportClause(clause, options) {
+  const defaultAndNamespace = clause.match(/^([A-Za-z_$][\w$]*)\s*,\s*\*\s+as\s+([A-Za-z_$][\w$]*)$/);
+  if (defaultAndNamespace) {
+    return {
+      defaultLocalName: defaultAndNamespace[1],
+      namespaceLocalName: defaultAndNamespace[2],
+      specifiers: []
+    };
+  }
+
   const namespace = clause.match(/^\*\s+as\s+([A-Za-z_$][\w$]*)$/);
   if (namespace) {
     return {

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

@@ -1,17 +1,21 @@
 import { JsTsSafeMergeConflictCodes, JsTsSafeMergeGateIds } from './js-ts-safe-merge-constants.js';
 import { addConflict, detectLineEnding, normalizeLineEndings } from './js-ts-safe-merge-context.js';
+import { findCompatibleVariantImportEntry } from './js-ts-safe-merge-import-shape.js';
 import { importSpecifierCanonical } from './js-ts-safe-merge-ledger.js';
 
 export function createSourceMergePlan(base, worker, head, workerPlan, headPlan, context) {
   const edits = [];
   let importSpecifierAdditions = 0;
   let importDeclarationAdditions = 0;
+  const headEntriesByBaseKey = variantEntriesByBaseKey(head, headPlan);
+  const usedHeadImportKeys = new Set();
   for (const baseEntry of base.entries.filter((entry) => entry.kind === 'import')) {
     const workerAdditions = workerPlan.importAdditions.get(baseEntry.key) ?? [];
     const headAdditions = headPlan.importAdditions.get(baseEntry.key) ?? [];
     if (!workerAdditions.length && !headAdditions.length) continue;
     importSpecifierAdditions += workerAdditions.length + headAdditions.length;
-    const headEntry = head.entries.find((entry) => entry.key === baseEntry.key);
+    const headEntry = headEntriesByBaseKey.get(baseEntry.key)
+      ?? findCompatibleVariantImportEntry(baseEntry, head.entries, usedHeadImportKeys);
     if (!headEntry) {
       addConflict(context, {
         code: JsTsSafeMergeConflictCodes.insertionAnchorMissing,
@@ -22,26 +26,29 @@ export function createSourceMergePlan(base, worker, head, workerPlan, headPlan,
       });
       continue;
     }
+    usedHeadImportKeys.add(headEntry.key);
+    const importInfo = mergedImportInfo(baseEntry.importInfo, workerAdditions, headAdditions);
     edits.push({
       kind: 'replace-import',
       start: headEntry.start,
       end: headEntry.end,
-      text: renderImportStatement(baseEntry.importInfo, mergedImportSpecifiers(baseEntry.importInfo.specifiers, workerAdditions, headAdditions))
+      text: renderImportStatement(importInfo, importInfo.specifiers)
     });
   }
 
-  const importInsertionGroups = variantInsertionGroups(worker, workerPlan.baseKeys, 'worker', context, {
+  const importInsertionGroups = variantInsertionGroups(worker, workerPlan.matchedVariantKeys, 'worker', context, {
+    baseKeyByVariantKey: workerPlan.baseKeyByVariantKey,
     includeEntry: (entry) => entry.kind === 'import',
     label: 'import'
   });
-  const headImportInsertionGroups = variantInsertionGroups(head, headPlan.baseKeys, 'head', context, {
+  const headImportInsertionGroups = variantInsertionGroups(head, headPlan.matchedVariantKeys, 'head', context, {
+    baseKeyByVariantKey: headPlan.baseKeyByVariantKey,
     includeEntry: (entry) => entry.kind === 'import',
     label: 'import'
   });
   const headImportGroupsByAnchor = new Map(headImportInsertionGroups.map((group) => [insertionGroupKey(group), group]));
-  const headEntriesByKey = new Map(head.entries.map((entry) => [entry.key, entry]));
   for (const group of importInsertionGroups) {
-    const anchor = headEntriesByKey.get(group.anchorKey);
+    const anchor = headEntriesByBaseKey.get(group.anchorKey);
     if (!anchor) {
       addConflict(context, {
         code: JsTsSafeMergeConflictCodes.insertionAnchorMissing,
@@ -64,18 +71,20 @@ export function createSourceMergePlan(base, worker, head, workerPlan, headPlan,
     importDeclarationAdditions += group.entries.length;
   }
 
-  const insertionGroups = variantInsertionGroups(worker, workerPlan.baseKeys, 'worker', context, {
+  const insertionGroups = variantInsertionGroups(worker, workerPlan.matchedVariantKeys, 'worker', context, {
+    baseKeyByVariantKey: workerPlan.baseKeyByVariantKey,
     includeEntry: (entry) => entry.kind !== 'import',
     label: 'declaration'
   });
-  const headInsertionGroups = variantInsertionGroups(head, headPlan.baseKeys, 'head', context, {
+  const headInsertionGroups = variantInsertionGroups(head, headPlan.matchedVariantKeys, 'head', context, {
+    baseKeyByVariantKey: headPlan.baseKeyByVariantKey,
     includeEntry: (entry) => entry.kind !== 'import',
     label: 'declaration'
   });
   const headDeclarationGroupsByAnchor = new Map(headInsertionGroups.map((group) => [insertionGroupKey(group), group]));
   let topLevelDeclarationAdditions = 0;
   for (const group of insertionGroups) {
-    const anchor = headEntriesByKey.get(group.anchorKey);
+    const anchor = headEntriesByBaseKey.get(group.anchorKey);
     if (!anchor) {
       addConflict(context, {
         code: JsTsSafeMergeConflictCodes.insertionAnchorMissing,
@@ -108,6 +117,7 @@ export function createSourceMergePlan(base, worker, head, workerPlan, headPlan,
 
 function variantInsertionGroups(variant, baseKeys, side, context, options = {}) {
   const includeEntry = options.includeEntry ?? (() => true);
+  const baseKeyByVariantKey = options.baseKeyByVariantKey ?? new Map();
   const groups = [];
   let index = 0;
   while (index < variant.entries.length) {
@@ -132,12 +142,26 @@ function variantInsertionGroups(variant, baseKeys, side, context, options = {})
       continue;
     }
     groups.push(previousBase
-      ? { mode: 'after', anchorKey: previousBase.key, entries }
-      : { mode: 'before', anchorKey: nextBase.key, entries });
+      ? { mode: 'after', anchorKey: baseKeyForVariantEntry(previousBase, baseKeyByVariantKey), entries }
+      : { mode: 'before', anchorKey: baseKeyForVariantEntry(nextBase, baseKeyByVariantKey), entries });
   }
   return groups;
 }
 
+function variantEntriesByBaseKey(variant, plan) {
+  const entriesByKey = new Map(variant.entries.map((entry) => [entry.key, entry]));
+  const entriesByBaseKey = new Map();
+  for (const [variantKey, baseKey] of plan.baseKeyByVariantKey ?? []) {
+    const entry = entriesByKey.get(variantKey);
+    if (entry) entriesByBaseKey.set(baseKey, entry);
+  }
+  return entriesByBaseKey;
+}
+
+function baseKeyForVariantEntry(entry, baseKeyByVariantKey) {
+  return baseKeyByVariantKey.get(entry.key) ?? entry.key;
+}
+
 function insertionGroupKey(group) {
   return `${group.mode}:${group.anchorKey}`;
 }
@@ -165,7 +189,7 @@ export function applySourceMergePlan(sourceText, mergePlan) {
 function mergedImportSpecifiers(baseSpecifiers, workerAdditions, headAdditions) {
   const seen = new Set(baseSpecifiers.map((specifier) => specifier.canonical));
   const additions = [];
-  for (const specifier of [...workerAdditions, ...headAdditions]) {
+  for (const specifier of [...workerAdditions, ...headAdditions].filter((addition) => !addition.additionKind)) {
     if (seen.has(specifier.canonical)) continue;
     seen.add(specifier.canonical);
     additions.push(specifier);
@@ -174,6 +198,18 @@ function mergedImportSpecifiers(baseSpecifiers, workerAdditions, headAdditions)
   return [...baseSpecifiers, ...additions];
 }
 
+function mergedImportInfo(baseImportInfo, workerAdditions, headAdditions) {
+  const additions = [...workerAdditions, ...headAdditions];
+  const defaultAddition = additions.find((addition) => addition.additionKind === 'default');
+  const namespaceAddition = additions.find((addition) => addition.additionKind === 'namespace');
+  return {
+    ...baseImportInfo,
+    defaultLocalName: baseImportInfo.defaultLocalName ?? defaultAddition?.localName,
+    namespaceLocalName: baseImportInfo.namespaceLocalName ?? namespaceAddition?.localName,
+    specifiers: mergedImportSpecifiers(baseImportInfo.specifiers, workerAdditions, headAdditions)
+  };
+}
+
 function renderImportStatement(importInfo, specifiers) {
   if (importInfo.sideEffectOnly) return `import ${importInfo.quote}${importInfo.moduleSpecifier}${importInfo.quote};`;
   const clause = [];

package/dist/js-ts-safe-merge-semantic-artifact-ledger.js

@@ -2,12 +2,16 @@ import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
 import { idFragment } from './native-import-utils.js';
 import { detectLineEnding, normalizeLineEndings } from './js-ts-safe-merge-context.js';
 import { importEntryBindings } from './js-ts-safe-merge-import-entry-utils.js';
+import { findCompatibleBaseImportEntry } from './js-ts-safe-merge-import-shape.js';
 
 function createOperationsFromLedgers(context) {
   const headByKey = new Map(context.head.entries.map((entry) => [entry.key, entry]));
+  const usedHeadKeys = new Set();
   return context.merged.entries.flatMap((entry, index) => {
-    const headEntry = headByKey.get(entry.key);
+    const headEntry = headByKey.get(entry.key)
+      ?? findCompatibleBaseImportEntry(entry, context.head.entries, usedHeadKeys);
     if (headEntry) {
+      usedHeadKeys.add(headEntry.key);
       if (sameEntryText(headEntry.text, entry.text)) return [];
       return [operationRecord({
         ...context,
@@ -129,7 +133,8 @@ function insertionAnchorForMergedEntry(entry, index, context) {
 function nearestHeadEntry(mergedEntries, headEntries, startIndex, step) {
   const headByKey = new Map(headEntries.map((entry) => [entry.key, entry]));
   for (let index = startIndex + step; index >= 0 && index < mergedEntries.length; index += step) {
-    const headEntry = headByKey.get(mergedEntries[index].key);
+    const headEntry = headByKey.get(mergedEntries[index].key)
+      ?? findCompatibleBaseImportEntry(mergedEntries[index], headEntries);
     if (headEntry) return headEntry;
   }
   return undefined;

package/package.json

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