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

package/README.md

@@ -170,7 +170,7 @@ 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
-ledger spans, import specifier reordering, computed keys, duplicate exported
+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
 reason-code or gate values so distributed swarm evidence can point at a stable

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

@@ -102,6 +102,7 @@ export interface JsTsSafeMergeAdmission {
 
 export interface JsTsSafeMergeSummary {
   readonly importSpecifierAdditions: number;
+  readonly importDeclarationAdditions: number;
   readonly topLevelDeclarationAdditions: number;
   readonly changedExistingDeclarations: number;
   readonly conflicts: number;

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

@@ -1,10 +1,13 @@
 import { JsTsSafeMergeConflictCodes, JsTsSafeMergeGateIds } from './js-ts-safe-merge-constants.js';
 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 { validateNewImportDeclarations } from './js-ts-safe-merge-new-import-validation.js';
 
 export function analyzeVariantLedger(base, variant, baseIndex, side, context) {
   const projectedBaseKeys = [];
   const addedEntries = [];
+  const newImportEntries = [];
   const importAdditions = new Map();
   const baseKeys = new Set(baseIndex.orderedKeys);
 
@@ -12,13 +15,7 @@ export function analyzeVariantLedger(base, variant, baseIndex, side, context) {
     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() }
-        });
+        newImportEntries.push(entry);
       } else {
         addedEntries.push(entry);
       }
@@ -72,6 +69,7 @@ export function analyzeVariantLedger(base, variant, baseIndex, side, context) {
   return {
     side,
     addedEntries,
+    newImportEntries,
     importAdditions,
     baseKeys
   };
@@ -105,34 +103,27 @@ function analyzeImportStatementChange(baseEntry, variantEntry, side, context) {
 
   const baseSpecifiers = baseImport.specifiers;
   const variantSpecifiers = variantImport.specifiers;
-  if (variantSpecifiers.length < baseSpecifiers.length) {
+  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 }
+      details: {
+        key: baseEntry.key,
+        missing: missingBaseSpecifiers.map((specifier) => specifier.canonical)
+      }
     });
     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);
+  const additions = variantSpecifiers.filter((specifier) => !baseSpecifiersByCanonical.has(specifier.canonical));
   if (additions.length === 0 && !sameStatementText(baseEntry.text, variantEntry.text)) {
+    const baseCanonicalOrder = baseSpecifiers.map((specifier) => specifier.canonical);
+    const variantCanonicalOrder = variantSpecifiers.map((specifier) => specifier.canonical);
+    if (!arraysEqual(baseCanonicalOrder, variantCanonicalOrder)) return [];
     addConflict(context, {
       code: JsTsSafeMergeConflictCodes.importFormattingChanged,
       gateId: JsTsSafeMergeGateIds.independentImportSpecifiers,
@@ -159,6 +150,7 @@ export function validateIndependentAdditions(base, workerPlan, headPlan, context
   }
   validateAddedEntryNames(workerPlan, declarationNames, context);
   validateAddedEntryNames(headPlan, declarationNames, context);
+  validateNewImportDeclarations(workerPlan, headPlan, context);
   validateCrossSideAddedNames(workerPlan, headPlan, context);
   validateCrossSideExportStarAdditions(workerPlan, headPlan, context);
   validateCrossSideImportAdditions(workerPlan, headPlan, context);
@@ -264,12 +256,7 @@ function validateMergedImportAndDeclarationNames(base, workerPlan, headPlan, con
       ...(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
-    ]) {
+    for (const specifier of [...importEntryBindings(entry), ...additions]) {
       if (importLocalNames.has(specifier.localName)) {
         addConflict(context, {
           code: JsTsSafeMergeConflictCodes.duplicateName,
@@ -289,4 +276,15 @@ function validateMergedImportAndDeclarationNames(base, workerPlan, headPlan, con
       importLocalNames.add(specifier.localName);
     }
   }
+  for (const specifier of mergedNewImportBindings(workerPlan, headPlan)) {
+    if (importLocalNames.has(specifier.localName) || topLevelBindingNames.has(specifier.localName)) {
+      addConflict(context, {
+        code: JsTsSafeMergeConflictCodes.duplicateName,
+        gateId: JsTsSafeMergeGateIds.uniqueNames,
+        message: 'Merged new imports would duplicate an existing binding name.',
+        details: { localName: specifier.localName, specifier: specifier.canonical, importKey: specifier.importKey }
+      });
+    }
+    importLocalNames.add(specifier.localName);
+  }
 }

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

@@ -106,6 +106,7 @@ function composedBlockedResult(input, phase, result, memberAnalysis) {
     },
     summary: {
       importSpecifierAdditions: 0,
+      importDeclarationAdditions: 0,
       topLevelDeclarationAdditions: 0,
       changedExistingDeclarations: result.summary?.changedExistingDeclarations ?? 0,
       conflicts: result.conflicts?.length ?? result.summary?.conflicts ?? 0,

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

@@ -35,6 +35,7 @@ export function blockedResult(context, ledgers = {}) {
     },
     summary: {
       importSpecifierAdditions: 0,
+      importDeclarationAdditions: 0,
       topLevelDeclarationAdditions: 0,
       changedExistingDeclarations: context.conflicts.filter((conflict) => conflict.code === JsTsSafeMergeConflictCodes.changedExistingDeclaration).length,
       conflicts: context.conflicts.length,

package/dist/js-ts-safe-merge-import-entry-utils.js

@@ -0,0 +1,40 @@
+import { importSpecifierCanonical } from './js-ts-safe-merge-ledger.js';
+
+export function importEntryBindings(entry) {
+  const importInfo = entry?.importInfo;
+  if (!importInfo || importInfo.sideEffectOnly) return [];
+  return [
+    ...(importInfo.defaultLocalName ? [{
+      localName: importInfo.defaultLocalName,
+      importedName: 'default',
+      typeOnly: importInfo.typeOnly,
+      canonical: `default:${importInfo.defaultLocalName}`
+    }] : []),
+    ...(importInfo.namespaceLocalName ? [{
+      localName: importInfo.namespaceLocalName,
+      importedName: '*',
+      typeOnly: importInfo.typeOnly,
+      canonical: `namespace:${importInfo.namespaceLocalName}`
+    }] : []),
+    ...importInfo.specifiers.map((specifier) => ({
+      localName: specifier.localName,
+      importedName: specifier.importedName,
+      typeOnly: specifier.typeOnly,
+      canonical: importSpecifierCanonical(specifier)
+    }))
+  ];
+}
+
+export function mergedNewImportBindings(workerPlan, headPlan) {
+  const seen = new Set();
+  const bindings = [];
+  for (const entry of [...(workerPlan.newImportEntries ?? []), ...(headPlan.newImportEntries ?? [])]) {
+    for (const binding of importEntryBindings(entry)) {
+      const key = `${entry.key}:${binding.canonical}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      bindings.push({ ...binding, importKey: entry.key });
+    }
+  }
+  return bindings;
+}

package/dist/js-ts-safe-merge-new-import-validation.js

@@ -0,0 +1,50 @@
+import { JsTsSafeMergeConflictCodes, JsTsSafeMergeGateIds } from './js-ts-safe-merge-constants.js';
+import { addConflict } from './js-ts-safe-merge-context.js';
+import { mergedNewImportBindings } from './js-ts-safe-merge-import-entry-utils.js';
+
+export function validateNewImportDeclarations(workerPlan, headPlan, context) {
+  validateNoNewSideEffectImports(workerPlan, context);
+  validateNoNewSideEffectImports(headPlan, context);
+  validateCrossSideNewImportBindings(workerPlan, headPlan, context);
+}
+
+function validateNoNewSideEffectImports(plan, context) {
+  for (const entry of plan.newImportEntries ?? []) {
+    if (!entry.importInfo?.sideEffectOnly) continue;
+    addConflict(context, {
+      code: JsTsSafeMergeConflictCodes.sideEffectImportReorder,
+      gateId: JsTsSafeMergeGateIds.preserveBaseOrder,
+      side: plan.side,
+      message: `${plan.side} source adds a side-effect import; new side-effect ordering requires human review.`,
+      details: {
+        reasonCode: 'new-side-effect-import',
+        key: entry.key,
+        statement: entry.text.trim()
+      }
+    });
+  }
+}
+
+function validateCrossSideNewImportBindings(workerPlan, headPlan, context) {
+  const ownersByLocalName = new Map();
+  for (const binding of mergedNewImportBindings(workerPlan, headPlan)) {
+    const owner = ownersByLocalName.get(binding.localName);
+    if (!owner) {
+      ownersByLocalName.set(binding.localName, binding);
+      continue;
+    }
+    addConflict(context, {
+      code: JsTsSafeMergeConflictCodes.duplicateName,
+      gateId: JsTsSafeMergeGateIds.uniqueNames,
+      side: 'worker',
+      message: 'Worker and head add new imports with duplicate local binding names.',
+      details: {
+        localName: binding.localName,
+        firstImportKey: owner.importKey,
+        secondImportKey: binding.importKey,
+        firstSpecifier: owner.canonical,
+        secondSpecifier: binding.canonical
+      }
+    });
+  }
+}

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

@@ -5,6 +5,7 @@ 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;
   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) ?? [];
@@ -29,10 +30,49 @@ export function createSourceMergePlan(base, worker, head, workerPlan, headPlan,
     });
   }
 
-  const insertionGroups = variantInsertionGroups(worker, workerPlan.baseKeys, 'worker', context);
-  const headInsertionGroups = variantInsertionGroups(head, headPlan.baseKeys, 'head', context);
-  const headInsertionGroupsByAnchor = new Map(headInsertionGroups.map((group) => [insertionGroupKey(group), group]));
+  const importInsertionGroups = variantInsertionGroups(worker, workerPlan.baseKeys, 'worker', context, {
+    includeEntry: (entry) => entry.kind === 'import',
+    label: 'import'
+  });
+  const headImportInsertionGroups = variantInsertionGroups(head, headPlan.baseKeys, 'head', context, {
+    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);
+    if (!anchor) {
+      addConflict(context, {
+        code: JsTsSafeMergeConflictCodes.insertionAnchorMissing,
+        gateId: JsTsSafeMergeGateIds.resolvedInsertionAnchors,
+        side: 'head',
+        message: 'Head source is missing an import insertion anchor.',
+        details: { anchorKey: group.anchorKey, mode: group.mode }
+      });
+      continue;
+    }
+    const headGroup = headImportGroupsByAnchor.get(insertionGroupKey(group));
+    const insertionSpan = declarationInsertionSpan(head.sourceText, anchor, group.mode, headGroup);
+    const entries = mergedImportEntries(group.entries, headGroup?.entries ?? []);
+    edits.push({
+      kind: 'insert-imports',
+      start: insertionSpan.start,
+      end: insertionSpan.end,
+      text: importInsertionText(entries, detectLineEnding(head.sourceText))
+    });
+    importDeclarationAdditions += group.entries.length;
+  }
+
+  const insertionGroups = variantInsertionGroups(worker, workerPlan.baseKeys, 'worker', context, {
+    includeEntry: (entry) => entry.kind !== 'import',
+    label: 'declaration'
+  });
+  const headInsertionGroups = variantInsertionGroups(head, headPlan.baseKeys, 'head', context, {
+    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);
@@ -46,7 +86,7 @@ export function createSourceMergePlan(base, worker, head, workerPlan, headPlan,
       });
       continue;
     }
-    const headGroup = headInsertionGroupsByAnchor.get(insertionGroupKey(group));
+    const headGroup = headDeclarationGroupsByAnchor.get(insertionGroupKey(group));
     const insertionSpan = declarationInsertionSpan(head.sourceText, anchor, group.mode, headGroup);
     const entries = mergedDeclarationEntries(group.entries, headGroup?.entries ?? []);
     edits.push({
@@ -61,21 +101,23 @@ export function createSourceMergePlan(base, worker, head, workerPlan, headPlan,
   return {
     edits,
     importSpecifierAdditions,
+    importDeclarationAdditions,
     topLevelDeclarationAdditions
   };
 }
 
-function variantInsertionGroups(variant, baseKeys, side, context) {
+function variantInsertionGroups(variant, baseKeys, side, context, options = {}) {
+  const includeEntry = options.includeEntry ?? (() => true);
   const groups = [];
   let index = 0;
   while (index < variant.entries.length) {
     const entry = variant.entries[index];
-    if (baseKeys.has(entry.key)) {
+    if (baseKeys.has(entry.key) || !includeEntry(entry)) {
       index += 1;
       continue;
     }
     const start = index;
-    while (index < variant.entries.length && !baseKeys.has(variant.entries[index].key)) index += 1;
+    while (index < variant.entries.length && !baseKeys.has(variant.entries[index].key) && includeEntry(variant.entries[index])) index += 1;
     const entries = variant.entries.slice(start, index);
     const previousBase = findPreviousBaseEntry(variant.entries, start, baseKeys);
     const nextBase = findNextBaseEntry(variant.entries, index, baseKeys);
@@ -84,7 +126,7 @@ function variantInsertionGroups(variant, baseKeys, side, context) {
         code: JsTsSafeMergeConflictCodes.ambiguousInsertionPoint,
         gateId: JsTsSafeMergeGateIds.resolvedInsertionAnchors,
         side,
-        message: `${side} additions have no stable base declaration or import anchor.`,
+        message: `${side} ${options.label ?? 'additions'} additions have no stable base declaration or import anchor.`,
         details: { entries: entries.map((item) => item.names?.[0] ?? item.key) }
       });
       continue;
@@ -133,6 +175,7 @@ function mergedImportSpecifiers(baseSpecifiers, workerAdditions, headAdditions)
 }
 
 function renderImportStatement(importInfo, specifiers) {
+  if (importInfo.sideEffectOnly) return `import ${importInfo.quote}${importInfo.moduleSpecifier}${importInfo.quote};`;
   const clause = [];
   if (importInfo.defaultLocalName) clause.push(importInfo.defaultLocalName);
   if (importInfo.namespaceLocalName) clause.push(`* as ${importInfo.namespaceLocalName}`);
@@ -141,6 +184,41 @@ function renderImportStatement(importInfo, specifiers) {
   return `import ${importType}${clause.join(', ')} from ${importInfo.quote}${importInfo.moduleSpecifier}${importInfo.quote};`;
 }
 
+function importInsertionText(entries, lineEnding) {
+  return entries
+    .map((entry) => normalizeLineEndings(entry.text.trimEnd(), lineEnding))
+    .map((text) => text.endsWith(lineEnding) ? text : `${text}${lineEnding}`)
+    .join('');
+}
+
+function mergedImportEntries(workerEntries, headEntries) {
+  const entriesByKey = new Map();
+  for (const entry of [...headEntries, ...workerEntries]) {
+    const existing = entriesByKey.get(entry.key);
+    if (!existing) {
+      entriesByKey.set(entry.key, { ...entry, importInfo: { ...entry.importInfo, specifiers: [...entry.importInfo.specifiers] } });
+      continue;
+    }
+    existing.importInfo.specifiers = mergedNewImportSpecifiers(existing.importInfo.specifiers, entry.importInfo.specifiers);
+    existing.text = renderImportStatement(existing.importInfo, existing.importInfo.specifiers);
+  }
+  return [...entriesByKey.values()].sort(compareImportEntries);
+}
+
+function mergedNewImportSpecifiers(left, right) {
+  const byCanonical = new Map();
+  for (const specifier of [...left, ...right]) byCanonical.set(specifier.canonical, specifier);
+  return [...byCanonical.values()].sort((a, b) => a.canonical.localeCompare(b.canonical));
+}
+
+function compareImportEntries(left, right) {
+  const moduleOrder = left.importInfo.moduleSpecifier.localeCompare(right.importInfo.moduleSpecifier);
+  if (moduleOrder !== 0) return moduleOrder;
+  const typeOrder = Number(Boolean(left.importInfo.typeOnly)) - Number(Boolean(right.importInfo.typeOnly));
+  if (typeOrder !== 0) return typeOrder;
+  return left.key.localeCompare(right.key);
+}
+
 function declarationInsertionText(entries, lineEnding) {
   return entries
     .map((entry) => normalizeLineEndings(entry.text.trimEnd(), lineEnding))

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

@@ -1,6 +1,7 @@
 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';
 
 function createOperationsFromLedgers(context) {
   const headByKey = new Map(context.head.entries.map((entry) => [entry.key, entry]));
@@ -108,8 +109,8 @@ function insertionAnchorForMergedEntry(entry, index, context) {
   if (previous) return {
     mode: 'after',
     anchorKey: previous.key,
-    anchorSymbolName: entryName(previous),
-    anchorSymbolKind: entrySymbolKind(previous),
+    anchorSymbolName: insertionAnchorName(previous),
+    anchorSymbolKind: insertionAnchorKind(previous),
     headSpan: spanForEntry(previous),
     sourcePath: context.sourcePath
   };
@@ -117,8 +118,8 @@ function insertionAnchorForMergedEntry(entry, index, context) {
   if (next) return {
     mode: 'before',
     anchorKey: next.key,
-    anchorSymbolName: entryName(next),
-    anchorSymbolKind: entrySymbolKind(next),
+    anchorSymbolName: insertionAnchorName(next),
+    anchorSymbolKind: insertionAnchorKind(next),
     headSpan: spanForEntry(next),
     sourcePath: context.sourcePath
   };
@@ -162,7 +163,7 @@ function entryAnchor(entry, sourcePath, language) {
 }
 
 function entryName(entry) {
-  if (entry.kind === 'import') return entry.importInfo?.moduleSpecifier;
+  if (entry.kind === 'import') return importEntryBindings(entry)[0]?.localName ?? entry.importInfo?.moduleSpecifier;
   return entry.names?.join('|') ?? entry.key;
 }
 
@@ -171,6 +172,16 @@ function entrySymbolKind(entry) {
   return entry.declarationInfo?.declarationKind ?? entry.kind;
 }
 
+function insertionAnchorName(entry) {
+  if (entry.kind === 'import') return entry.importInfo?.moduleSpecifier;
+  return entryName(entry);
+}
+
+function insertionAnchorKind(entry) {
+  if (entry.kind === 'import') return 'module';
+  return entrySymbolKind(entry);
+}
+
 function spanForEntry(entry) {
   return { start: entry.start, end: entry.end };
 }

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

@@ -85,6 +85,7 @@ export function safeMergeJsTsImportsAndDeclarations(input = {}) {
     },
     summary: {
       importSpecifierAdditions: mergePlan.importSpecifierAdditions,
+      importDeclarationAdditions: mergePlan.importDeclarationAdditions,
       topLevelDeclarationAdditions: mergePlan.topLevelDeclarationAdditions,
       changedExistingDeclarations: 0,
       conflicts: 0,

package/package.json

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