@shapeshift-labs/frontier-lang-compiler 0.2.139 → 0.2.141

package/README.md

@@ -203,7 +203,8 @@ re-emitted with safe commas when both sides add final properties.
 If staged whole-declaration replay cannot verify because head changed a sibling
 member inside the same declaration, `safeMergeJsTsSource` retries the direct
 semantic edit projection and admits the merge only when replay still verifies
-cleanly.
+cleanly. That direct retry can project onto the staged top-level merge output,
+so safe import/declaration additions are preserved alongside the sibling edit.
 
 Project-level JS/TS safe merges compose the same file-level gates across a
 base/worker/head file set. They preserve head-only files, admit worker-only
@@ -294,6 +295,9 @@ Public contract regions include `apiSurfaceKind`, `signatureHash`, and
 For `export * from './module.js'`, project graphs fan out re-export identities
 for each named export in the resolved target document and omit `default`, which
 matches JavaScript module semantics.
+Output graph admission can use those expanded identities to accept disjoint
+export-star additions while blocking incompatible duplicate exported names as
+`project-output-re-export-identity-conflict`.
 
 When using `createTypeScriptCompilerNativeImporterAdapter`,
 `createEstreeNativeImporterAdapter`, or `createBabelNativeImporterAdapter`,

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

@@ -0,0 +1,41 @@
+import { JsTsSafeMergeConflictCodes } from './js-ts-safe-merge-constants.js';
+
+const semanticFallbackConflictCodes = new Set([
+  JsTsSafeMergeConflictCodes.changedExistingDeclaration,
+  JsTsSafeMergeConflictCodes.typeAliasConflict
+]);
+
+function shouldTrySemanticEditFallback(result) {
+  const conflicts = result.conflicts ?? [];
+  return conflicts.length > 0 && conflicts.every((conflict) => semanticFallbackConflictCodes.has(conflict.code));
+}
+
+function semanticFallbackConflictCode(result) {
+  return result.conflicts?.find((conflict) => semanticFallbackConflictCodes.has(conflict.code))?.code
+    ?? JsTsSafeMergeConflictCodes.changedExistingDeclaration;
+}
+
+function semanticFallbackChangedExistingDeclarations(topLevelResult, resultBase, stagedFallback) {
+  const conflictCount = (topLevelResult.conflicts ?? [])
+    .filter((conflict) => semanticFallbackConflictCodes.has(conflict.code)).length;
+  return Math.max(
+    topLevelResult.summary?.changedExistingDeclarations ?? 0,
+    resultBase?.summary?.changedExistingDeclarations ?? 0,
+    stagedFallback?.neutralization?.summary?.workerChangedExistingDeclarations ?? 0,
+    conflictCount
+  );
+}
+
+function semanticFallbackPhase(fallback) {
+  if (!fallback) return 'semantic-edit-fallback';
+  return fallback.projectionMode === 'direct'
+    ? 'staged-top-level-direct-semantic-edit-fallback'
+    : 'staged-top-level-semantic-edit-fallback';
+}
+
+export {
+  semanticFallbackChangedExistingDeclarations,
+  semanticFallbackConflictCode,
+  semanticFallbackPhase,
+  shouldTrySemanticEditFallback
+};

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

@@ -2,7 +2,13 @@ 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 { JsTsSafeMergeConflictCodes, JsTsSafeMergeStatuses } from './js-ts-safe-merge-constants.js';
+import { JsTsSafeMergeStatuses } from './js-ts-safe-merge-constants.js';
+import {
+  semanticFallbackChangedExistingDeclarations,
+  semanticFallbackConflictCode,
+  semanticFallbackPhase,
+  shouldTrySemanticEditFallback
+} from './js-ts-safe-merge-semantic-edit-fallback-utils.js';
 import {
   createStagedDeclarationAlreadyAppliedReplay,
   createStagedDeclarationProjection,
@@ -17,10 +23,19 @@ function semanticEditFallbackResult(input, topLevelResult) {
   let selectedFallback = stagedFallback;
   let artifacts = createSemanticEditFallbackArtifacts(input, topLevelResult, stagedFallback);
   if (stagedFallback && artifacts.status !== 'verified') {
-    const directArtifacts = createSemanticEditFallbackArtifacts(input, topLevelResult, undefined);
+    const directFallback = stagedFallback.directProjectionHeadSourceText && stagedFallback.safeTopLevelChanges > 0
+      ? { ...stagedFallback, projectionMode: 'direct' }
+      : undefined;
+    const directArtifacts = createSemanticEditFallbackArtifacts(input, topLevelResult, directFallback);
     if (directArtifacts.status === 'verified') {
       artifacts = directArtifacts;
-      selectedFallback = undefined;
+      selectedFallback = directFallback;
+    } else if (directFallback) {
+      const plainDirectArtifacts = createSemanticEditFallbackArtifacts(input, topLevelResult, undefined);
+      if (plainDirectArtifacts.status === 'verified') {
+        artifacts = plainDirectArtifacts;
+        selectedFallback = undefined;
+      }
     }
   }
   if (artifacts.status !== 'verified') return semanticEditFallbackBlockedResult(input, topLevelResult, artifacts);
@@ -57,7 +72,7 @@ function semanticEditFallbackResult(input, topLevelResult) {
     metadata: {
       ...resultBase.metadata,
       composed: {
-        phase: selectedFallback ? 'staged-top-level-semantic-edit-fallback' : 'semantic-edit-fallback',
+        phase: semanticFallbackPhase(selectedFallback),
         phases: selectedFallback ? ['top-level-neutralization', 'top-level-ledger', 'semantic-edit'] : ['top-level-ledger', 'semantic-edit'],
         originalReasonCodes: topLevelResult.admission?.reasonCodes ?? [],
         stagedTopLevelSummary: selectedFallback?.stagedTopLevelResult?.summary,
@@ -68,47 +83,26 @@ function semanticEditFallbackResult(input, topLevelResult) {
   };
 }
 
-function shouldTrySemanticEditFallback(result) {
-  const conflicts = result.conflicts ?? [];
-  return conflicts.length > 0 && conflicts.every((conflict) => semanticFallbackConflictCodes.has(conflict.code));
-}
-
-const semanticFallbackConflictCodes = new Set([
-  JsTsSafeMergeConflictCodes.changedExistingDeclaration,
-  JsTsSafeMergeConflictCodes.typeAliasConflict
-]);
-
-function semanticFallbackConflictCode(result) {
-  return result.conflicts?.find((conflict) => semanticFallbackConflictCodes.has(conflict.code))?.code
-    ?? JsTsSafeMergeConflictCodes.changedExistingDeclaration;
-}
-
-function semanticFallbackChangedExistingDeclarations(topLevelResult, resultBase, stagedFallback) {
-  const conflictCount = (topLevelResult.conflicts ?? [])
-    .filter((conflict) => semanticFallbackConflictCodes.has(conflict.code)).length;
-  return Math.max(
-    topLevelResult.summary?.changedExistingDeclarations ?? 0,
-    resultBase?.summary?.changedExistingDeclarations ?? 0,
-    stagedFallback?.neutralization?.summary?.workerChangedExistingDeclarations ?? 0,
-    conflictCount
-  );
-}
-
 function createSemanticEditFallbackArtifacts(input, topLevelResult, stagedFallback) {
   try {
     const id = String(input.id ?? topLevelResult.id ?? 'js_ts_safe_merge');
     const language = input.language ?? topLevelResult.language ?? 'typescript';
     const sourcePath = input.sourcePath ?? topLevelResult.sourcePath ?? 'inline.ts';
+    const stagedDeclarationProjection = stagedFallback && stagedFallback.projectionMode !== 'direct';
     const scriptInput = stagedFallback?.scriptInput ?? input;
-    const projectionHeadSourceText = stagedFallback?.projectionHeadSourceText ?? input.headSourceText;
-    const replayCurrentSourceText = stagedFallback?.replayCurrentSourceText ?? input.headSourceText;
+    const projectionHeadSourceText = stagedFallback?.projectionMode === 'direct'
+      ? stagedFallback.directProjectionHeadSourceText
+      : stagedFallback?.projectionHeadSourceText ?? input.headSourceText;
+    const replayCurrentSourceText = stagedFallback?.projectionMode === 'direct'
+      ? stagedFallback.directReplayCurrentSourceText
+      : stagedFallback?.replayCurrentSourceText ?? input.headSourceText;
     const script = createSemanticEditScript({
       ...scriptInput,
       id: `${id}_semantic_edit`,
       language,
       sourcePath
     });
-    const projection = stagedFallback
+    const projection = stagedDeclarationProjection
       ? createStagedDeclarationProjection({ id, script, sourcePath, language, stagedFallback })
       : projectSemanticEditScriptToSource({
         id: `${id}_semantic_edit_projection`,
@@ -119,7 +113,7 @@ function createSemanticEditFallbackArtifacts(input, topLevelResult, stagedFallba
         parser: input.parser,
         metadata: stagedFallback?.metadata
       });
-    const replay = stagedFallback
+    const replay = stagedDeclarationProjection
       ? createStagedDeclarationReplayRecord({ id, projection, sourcePath, language, stagedFallback, replayCurrentSourceText })
       : replaySemanticEditProjection({
         id: `${id}_semantic_edit_replay`,
@@ -130,7 +124,7 @@ function createSemanticEditFallbackArtifacts(input, topLevelResult, stagedFallba
         parser: input.parser,
         metadata: stagedFallback?.metadata
       });
-    const alreadyAppliedReplay = stagedFallback
+    const alreadyAppliedReplay = stagedDeclarationProjection
       ? createStagedDeclarationAlreadyAppliedReplay({ id, projection, sourcePath, language })
       : replaySemanticEditProjection({
         id: `${id}_semantic_edit_already_applied`,
@@ -201,7 +195,7 @@ function semanticEditArtifacts(input) {
     metadata: {
       autoMergeClaim: false,
       semanticEquivalenceClaim: false,
-      source: input.stagedFallback ? 'js-ts-staged-top-level-semantic-edit-fallback' : 'js-ts-semantic-edit-fallback',
+      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

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

@@ -14,11 +14,13 @@ function createStagedTopLevelSemanticFallback(input, topLevelResult) {
   if (stagedTopLevelResult.status !== JsTsSafeMergeStatuses.merged) return undefined;
   const safeTopLevelChanges = safeTopLevelChangeCount(stagedTopLevelResult.summary);
   const declarationReplay = createJsTsChangedDeclarationReplay(input, neutralization, stagedTopLevelResult.mergedSourceText);
+  const directSemanticHeadReplay = createJsTsChangedDeclarationReplay(input, neutralization, stagedTopLevelResult.mergedSourceText, 'head');
   const workerDeclarationChanges = neutralization.summary.workerChangedExistingDeclarations ?? 0;
   if (safeTopLevelChanges === 0 && workerDeclarationChanges === 0) return undefined;
   return {
     neutralization,
     declarationReplay,
+    safeTopLevelChanges,
     stagedTopLevelResult,
     scriptInput: {
       ...input,
@@ -28,13 +30,19 @@ function createStagedTopLevelSemanticFallback(input, topLevelResult) {
       headSourceHash: undefined
     },
     projectionHeadSourceText: stagedTopLevelResult.mergedSourceText,
+    directProjectionHeadSourceText: directSemanticHeadReplay.outputSourceText,
     replayCurrentSourceText: stagedTopLevelResult.mergedSourceText,
+    directReplayCurrentSourceText: directSemanticHeadReplay.outputSourceText,
     metadata: {
       stagedTopLevelSummary: stagedTopLevelResult.summary,
       declarationReplay: {
         edits: declarationReplay.edits.length,
         reasonCodes: declarationReplay.reasonCodes
       },
+      directSemanticHeadReplay: {
+        edits: directSemanticHeadReplay.edits.length,
+        reasonCodes: directSemanticHeadReplay.reasonCodes
+      },
       neutralization: neutralization.summary,
       originalReasonCodes: topLevelResult.admission?.reasonCodes ?? []
     }

package/dist/js-ts-safe-merge-top-level-neutralization.js

@@ -42,7 +42,7 @@ function neutralizeJsTsSafeTopLevelMergeSources(input = {}) {
   };
 }
 
-function createJsTsChangedDeclarationReplay(input = {}, neutralization, currentSourceText) {
+function createJsTsChangedDeclarationReplay(input = {}, neutralization, currentSourceText, side = 'worker') {
   if (!neutralization?.ok || typeof currentSourceText !== 'string') {
     return { ok: false, reasonCodes: ['missing-neutralized-current-source'], edits: [] };
   }
@@ -56,15 +56,17 @@ function createJsTsChangedDeclarationReplay(input = {}, neutralization, currentS
   const workerMatches = matchedEntriesByBaseKey(neutralization.worker, baseEntries);
   const headMatches = matchedEntriesByBaseKey(neutralization.head, baseEntries);
   const currentMatches = matchedEntriesByBaseKey(current, baseEntries);
+  const sourceMatches = side === 'head' ? headMatches : workerMatches;
+  const guardMatches = side === 'head' ? undefined : headMatches;
   const edits = [];
   const reasonCodes = [];
   for (const baseEntry of baseEntries) {
     if (baseEntry.kind === 'import') continue;
-    const workerEntry = workerMatches.get(baseEntry.key);
-    if (!workerEntry || sameStatementText(workerEntry.text, baseEntry.text)) continue;
-    const headEntry = headMatches.get(baseEntry.key);
+    const sourceEntry = sourceMatches.get(baseEntry.key);
+    if (!sourceEntry || sameStatementText(sourceEntry.text, baseEntry.text)) continue;
     const currentEntry = currentMatches.get(baseEntry.key);
-    if (!headEntry || !sameStatementText(headEntry.text, baseEntry.text)) {
+    const guardEntry = guardMatches?.get(baseEntry.key);
+    if (guardMatches && (!guardEntry || !sameStatementText(guardEntry.text, baseEntry.text))) {
       reasonCodes.push(`head-anchor-changed-since-base:${baseEntry.key}`);
       continue;
     }
@@ -74,12 +76,12 @@ function createJsTsChangedDeclarationReplay(input = {}, neutralization, currentS
     }
     edits.push({
       key: baseEntry.key,
-      names: workerEntry.names ?? baseEntry.names ?? [],
-      declarationKind: workerEntry.declarationInfo?.declarationKind ?? baseEntry.declarationInfo?.declarationKind,
+      names: sourceEntry.names ?? baseEntry.names ?? [],
+      declarationKind: sourceEntry.declarationInfo?.declarationKind ?? baseEntry.declarationInfo?.declarationKind,
       start: currentEntry.start,
       end: currentEntry.end,
       currentText: currentEntry.text,
-      replacementText: workerEntry.text
+      replacementText: sourceEntry.text
     });
   }
   return {

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

@@ -1,3 +1,4 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
 import { compactRecord } from './js-ts-safe-merge-context.js';
 import { projectGraphDeltaConflicts } from './js-ts-safe-project-merge-graph-delta-conflicts.js';
 
@@ -25,7 +26,8 @@ function outputProjectGraphConflicts(projectSymbolGraph) {
   return [
     ...limitConflicts,
     ...[...missingModuleGroups.values()].map(projectGraphMissingImportConflict),
-    ...[...missingSymbolGroups.values()].map(projectGraphMissingTargetConflict)
+    ...[...missingSymbolGroups.values()].map(projectGraphMissingTargetConflict),
+    ...duplicateReExportIdentityConflicts(projectSymbolGraph?.reExportIdentities)
   ];
 }
 
@@ -94,6 +96,83 @@ function projectImportTargetName(edge) {
   return String(name);
 }
 
+function duplicateReExportIdentityConflicts(records = []) {
+  const groups = new Map();
+  for (const record of records) {
+    const key = reExportIdentityKey(record);
+    if (!key) continue;
+    const group = groups.get(key) ?? [];
+    group.push(record);
+    groups.set(key, group);
+  }
+  return [...groups.entries()]
+    .filter(([, group]) => new Set(group.map(reExportIdentityFingerprint)).size > 1)
+    .map(([identityKey, group]) => projectGraphDuplicateReExportIdentityConflict(identityKey, group));
+}
+
+function projectGraphDuplicateReExportIdentityConflict(identityKey, group) {
+  const record = group[0] ?? {};
+  return {
+    code: 'project-output-re-export-identity-conflict',
+    gateId: 'project-symbol-graph',
+    message: `Output project graph exposes incompatible re-export identity ${JSON.stringify(identityKey)}.`,
+    sourcePath: record.sourcePath,
+    details: compactRecord({
+      reasonCode: 'project-output-re-export-identity-conflict',
+      conflictKey: `project-output-re-export-identity#${identityKey}`,
+      identityKey,
+      sourcePath: record.sourcePath,
+      exportedName: record.exportedName,
+      records: group.map(reExportIdentityDetails)
+    })
+  };
+}
+
+function reExportIdentityKey(record) {
+  return stableKey([
+    're-export-identity',
+    record?.sourcePath,
+    record?.exportedName ?? record?.localName ?? record?.namespace ?? (record?.exportStar || record?.isExportStar ? '*' : undefined)
+  ]);
+}
+
+function reExportIdentityFingerprint(record) {
+  return hashSemanticValue({
+    moduleSpecifier: record.moduleSpecifier,
+    exportedName: record.exportedName,
+    importedName: record.importedName,
+    localName: record.localName,
+    namespace: record.namespace,
+    isTypeOnly: record.isTypeOnly,
+    exportStar: record.exportStar,
+    isExportStar: record.isExportStar,
+    originSymbolId: record.originSymbolId,
+    exportedSymbolId: record.exportedSymbolId,
+    localSymbolId: record.localSymbolId
+  });
+}
+
+function reExportIdentityDetails(record) {
+  return compactRecord({
+    moduleSpecifier: record.moduleSpecifier,
+    exportedName: record.exportedName,
+    importedName: record.importedName,
+    localName: record.localName,
+    namespace: record.namespace,
+    isTypeOnly: record.isTypeOnly,
+    exportStar: record.exportStar,
+    isExportStar: record.isExportStar,
+    originSymbolId: record.originSymbolId,
+    exportedSymbolId: record.exportedSymbolId,
+    localSymbolId: record.localSymbolId
+  });
+}
+
+function stableKey(parts) {
+  const values = parts.map((part) => part === undefined || part === null ? '' : String(part));
+  return values.some(Boolean) ? values.join('#') : undefined;
+}
+
 function uniqueStrings(values) {
   return [...new Set(values.filter((value) => typeof value === 'string' && value.length > 0))];
 }

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

@@ -111,7 +111,7 @@ function mergeProjectFile(file, input, projectId) {
   const result = safeMergeJsTsSource({
     ...input,
     ...context,
-    deferReExportIdentityConflictsToProjectGraph: input.includeProjectGraphDelta === true,
+    deferReExportIdentityConflictsToProjectGraph: input.includeProjectGraphDelta === true || input.includeOutputProjectSymbolGraph === true,
     id: `${projectId}_${safeId(file.sourcePath)}`,
     baseSourceText: base,
     workerSourceText: worker,

package/package.json

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