@shapeshift-labs/frontier-lang-compiler 0.2.121 → 0.2.122

package/README.md

@@ -286,6 +286,12 @@ re-export, export-star, local export, `export default`, and TypeScript
 `importedName`, `exportedName`, `isTypeOnly`, and public-contract metadata into
 the semantic index and project symbol graph.
 
+`safeMergeJsTsProject` stays synchronous. When a caller already has parser-backed
+native import results for merged output files, pass them as `outputProjectImports`
+with `includeOutputProjectSymbolGraph`. The graph builder matches supplied
+imports by `sourcePath` and `sourceHash`, uses them for output graph artifacts,
+and falls back to the lightweight scanner for missing or stale files.
+
 High-risk native features also have explicit evidence policies. These policies are advisory in this package: they tell a swarm or admission queue what evidence is missing without silently changing the existing readiness classification.
 
 ```js

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

@@ -7,6 +7,7 @@ import type {
   JsTsSafeMergeSummary
 } from './js-ts-safe-merge.js';
 import type { JsTsSafeMemberMergePolicy, JsTsSafeMemberMergePolicyRegion } from './js-ts-safe-member-merge.js';
+import type { NativeSourceImportResult } from './import-adapter-core.js';
 import type { NativeProjectImportResult, NativeProjectSymbolGraphSummary } from './native-project.js';
 import type { NativeProjectModuleResolutionOptions } from './native-project-module-resolution.js';
 
@@ -45,6 +46,11 @@ export type JsTsProjectSafeMergeFileMap =
   | ReadonlyMap<string, string>
   | readonly { readonly sourcePath?: string; readonly path?: string; readonly sourceText?: string; readonly text?: string }[];
 
+export type JsTsProjectSafeMergeOutputProjectImports =
+  | readonly NativeSourceImportResult[]
+  | ReadonlyMap<string, NativeSourceImportResult>
+  | Readonly<Record<string, NativeSourceImportResult>>;
+
 export interface JsTsProjectSafeMergeInput {
   readonly id?: string;
   readonly language?: FrontierSourceLanguage | string;
@@ -56,6 +62,7 @@ export interface JsTsProjectSafeMergeInput {
   readonly allowFileAdditions?: boolean;
   readonly allowFileDeletes?: boolean;
   readonly includeOutputProjectSymbolGraph?: boolean;
+  readonly outputProjectImports?: JsTsProjectSafeMergeOutputProjectImports;
   readonly moduleResolution?: NativeProjectModuleResolutionOptions;
   readonly tsconfig?: NativeProjectModuleResolutionOptions;
   readonly workerChangeSetId?: string;
@@ -126,6 +133,7 @@ export interface JsTsProjectSafeMergeResult {
     readonly mergedFiles: number;
     readonly blockedFiles: number;
     readonly outputFiles: number;
+    readonly projectGraphConflicts: number;
     readonly semanticArtifactFiles: number;
     readonly operations: Readonly<Record<string, number>>;
   };

package/dist/declarations/native-project.d.ts

@@ -182,13 +182,16 @@ export interface NativeProjectSymbolGraphSummary {
   readonly remainingFields: readonly NativeProjectSymbolGraphRemainingField[];
 }
 
+export interface NativeProjectSourcePreservationSummary { readonly total: number; readonly exactSourceAvailable: number; readonly sourceBytes: number; readonly tokens: number; readonly trivia: number; readonly directives: number; readonly truncated: boolean; readonly ids: readonly string[]; }
+
 export interface NativeProjectImportResultMetadata extends Record<string, unknown> {
-  readonly importResultContract?: NativeImportResultContract;
-  readonly projectAdmission?: NativeProjectImportAdmission;
-  readonly semanticMergeAdmission?: NativeProjectImportAdmission;
-  readonly nativeImportLossSummary?: NativeImportLossSummary;
-  readonly semanticMergeReadiness?: SemanticMergeReadiness;
+  readonly sourceCount?: number; readonly sourcePaths?: readonly string[];
+  readonly importResultContract?: NativeImportResultContract; readonly projectAdmission?: NativeProjectImportAdmission;
+  readonly semanticMergeAdmission?: NativeProjectImportAdmission; readonly nativeImportLossSummary?: NativeImportLossSummary;
+  readonly sourcePreservationSummary?: NativeProjectSourcePreservationSummary; readonly semanticMergeReadiness?: SemanticMergeReadiness;
   readonly readinessReasons?: readonly string[];
+  readonly regionSummary?: NativeImportRegionSummary; readonly sourceMapSummary?: NativeImportSourceMapSummary;
+  readonly adapterCoverageSummary?: NativeImportAdapterCoverageContract;
   readonly projectSymbolGraph?: NativeProjectSymbolGraphSummary;
 }
 

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

@@ -244,24 +244,17 @@ function publicContractRegionForDeclaration(declaration, ownershipRegion, module
 
 function reExportIdentityForDeclaration(declaration, input, documentId, relationId, ownershipRegion, moduleEdge) {
   if (!moduleEdge?.isReExport && !declaration.reExport) return undefined;
+  const bindingCount = Number(declaration.nativeNode?.metadata?.bindingCount ?? declaration.metadata?.bindingCount ?? 0);
+  if (declaration.symbolKind === 'module' && !declaration.exportStar && !declaration.metadata?.exportStar && bindingCount > 1) return undefined;
+  const identityId = hashSemanticValue([relationId, declaration.symbolId, declaration.exportedName ?? declaration.metadata?.exportedName, declaration.importedName ?? declaration.metadata?.importedName, declaration.localName ?? declaration.metadata?.localName]);
+  const stableId = bindingCount > 1 ? idFragment(identityId) : idFragment(relationId);
   return compactRecord({
-    kind: 'frontier.lang.reExportIdentity',
-    version: 1,
-    id: `reexport_${idFragment(relationId)}`,
-    sourceDocumentId: documentId,
-    sourcePath: input.sourcePath,
-    sourceHash: input.sourceHash,
-    moduleSpecifier: moduleEdge?.moduleSpecifier,
-    exportedName: declaration.exportedName ?? declaration.metadata?.exportedName,
-    importedName: declaration.importedName ?? declaration.metadata?.importedName,
-    localName: declaration.localName ?? declaration.metadata?.localName,
-    namespace: declaration.namespace ?? declaration.metadata?.namespace,
-    isTypeOnly: declaration.isTypeOnly ?? declaration.metadata?.isTypeOnly ?? declaration.metadata?.typeOnly,
-    exportStar: declaration.exportStar ?? declaration.metadata?.exportStar,
-    symbolId: declaration.symbolId,
-    relationId,
-    ownershipRegionId: ownershipRegion.id,
-    ownershipRegionKey: ownershipRegion.key,
+    kind: 'frontier.lang.reExportIdentity', version: 1, id: `reexport_${stableId}`, sourceDocumentId: documentId,
+    sourcePath: input.sourcePath, sourceHash: input.sourceHash, moduleSpecifier: moduleEdge?.moduleSpecifier,
+    exportedName: declaration.exportedName ?? declaration.metadata?.exportedName, importedName: declaration.importedName ?? declaration.metadata?.importedName,
+    localName: declaration.localName ?? declaration.metadata?.localName, namespace: declaration.namespace ?? declaration.metadata?.namespace,
+    isTypeOnly: declaration.isTypeOnly ?? declaration.metadata?.isTypeOnly ?? declaration.metadata?.typeOnly, exportStar: declaration.exportStar ?? declaration.metadata?.exportStar,
+    symbolId: declaration.symbolId, relationId, ownershipRegionId: ownershipRegion.id, ownershipRegionKey: ownershipRegion.key,
     publicContract: true
   });
 }

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

@@ -59,6 +59,7 @@ function createJsTsSafeMergeSemanticArtifacts(input = {}, merge = {}) {
     id: `js_ts_safe_merge_replay_${idFragment(id)}`,
     projection,
     currentSourceText: headSourceText,
+    currentSourceHash: headReplaySourceHash(input),
     currentSourcePath: sourcePath,
     language
   });
@@ -66,6 +67,7 @@ function createJsTsSafeMergeSemanticArtifacts(input = {}, merge = {}) {
     id: `js_ts_safe_merge_replay_already_applied_${idFragment(id)}`,
     projection,
     currentSourceText: mergedSourceText,
+    currentSourceHash: projection.projectedHash,
     currentSourcePath: sourcePath,
     language
   });
@@ -74,6 +76,8 @@ function createJsTsSafeMergeSemanticArtifacts(input = {}, merge = {}) {
   const status = !blocked && replayReady && alreadyAppliedReady ? 'verified' : 'blocked';
   const finalReasonCodes = uniqueStrings([
     ...reasonCodes,
+    ...(replayReady ? [] : replay.admission?.reasonCodes ?? replay.summary?.reasonCodes ?? []),
+    ...(alreadyAppliedReady ? [] : alreadyAppliedReplay.admission?.reasonCodes ?? alreadyAppliedReplay.summary?.reasonCodes ?? []),
     replayReady ? undefined : `semantic-replay-${replay.status}`,
     alreadyAppliedReady ? undefined : `semantic-replay-already-applied-${alreadyAppliedReplay.status}`
   ]);
@@ -263,4 +267,12 @@ function countBy(values, keyFor) {
   return result;
 }
 
+function headReplaySourceHash(input) {
+  return nativeSemanticHash(input.currentSourceHash) ?? nativeSemanticHash(input.headHash);
+}
+
+function nativeSemanticHash(value) {
+  return typeof value === 'string' && /^fnv1a32:[0-9a-f]+$/i.test(value) ? value : undefined;
+}
+
 export { createJsTsSafeMergeSemanticArtifacts };

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

@@ -0,0 +1,45 @@
+import { compactRecord } from './js-ts-safe-merge-context.js';
+
+function outputProjectGraphConflicts(projectSymbolGraph) {
+  const importEdges = Array.isArray(projectSymbolGraph?.importEdges) ? projectSymbolGraph.importEdges : [];
+  const groups = new Map();
+  for (const edge of importEdges) {
+    if (!isMissingProjectImportEdge(edge)) continue;
+    const key = [edge.sourcePath, edge.moduleSpecifier, edge.resolutionKind, edge.resolvedModulePath].join('\u0000');
+    const group = groups.get(key) ?? [];
+    group.push(edge);
+    groups.set(key, group);
+  }
+  return [...groups.values()].map(projectGraphMissingImportConflict);
+}
+
+function projectGraphMissingImportConflict(group) {
+  const edge = group[0] ?? {};
+  return {
+    code: 'project-output-module-unresolved',
+    gateId: 'project-symbol-graph',
+    message: `Output project graph contains unresolved ${edge.resolutionKind ?? 'missing'} import ${JSON.stringify(edge.moduleSpecifier ?? edge.resolvedModulePath ?? 'unknown')}.`,
+    sourcePath: edge.sourcePath,
+    details: compactRecord({
+      reasonCode: 'project-output-module-unresolved',
+      conflictKey: `project-module#${edge.sourcePath ?? 'unknown'}#${edge.moduleSpecifier ?? edge.resolvedModulePath ?? 'unknown'}`,
+      sourcePath: edge.sourcePath,
+      moduleSpecifier: edge.moduleSpecifier,
+      resolutionKind: edge.resolutionKind,
+      resolvedModulePath: edge.resolvedModulePath,
+      edgeIds: uniqueStrings(group.map((record) => record.id)),
+      importKinds: uniqueStrings(group.map((record) => record.importKind)),
+      importedNames: uniqueStrings(group.map((record) => record.importedName))
+    })
+  };
+}
+
+function isMissingProjectImportEdge(edge) {
+  return typeof edge?.resolutionKind === 'string' && edge.resolutionKind.endsWith('-missing');
+}
+
+function uniqueStrings(values) {
+  return [...new Set(values.filter((value) => typeof value === 'string' && value.length > 0))];
+}
+
+export { outputProjectGraphConflicts };

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

@@ -8,9 +8,18 @@ function createJsTsProjectSafeMergeGraphArtifacts(input, outputFiles, mergeId) {
     language: file.language ?? input.language ?? languageForPath(file.sourcePath),
     sourcePath: file.sourcePath,
     sourceText: file.sourceText,
+    sourceHash: file.sourceHash,
     metadata: { semanticImportExpected: true, projectSafeMergeOutput: true }
   }));
-  const imports = sources.map((source) => importNativeSource(source));
+  const suppliedImports = normalizeOutputProjectImports(input.outputProjectImports);
+  const importSelections = sources.map((source) => {
+    const suppliedImport = matchingOutputProjectImport(source, suppliedImports);
+    return {
+      importResult: suppliedImport ?? importNativeSource(source),
+      sourceKind: suppliedImport ? 'supplied-output-project-import' : 'lightweight-output-project-scan'
+    };
+  });
+  const imports = importSelections.map((selection) => selection.importResult);
   const projectImport = createNativeProjectImportResult({
     id: `${mergeId}_output_project_import`,
     projectRoot: input.projectRoot,
@@ -18,7 +27,12 @@ function createJsTsProjectSafeMergeGraphArtifacts(input, outputFiles, mergeId) {
     sources,
     metadata: {
       projectSafeMergeId: mergeId,
-      outputProjectSymbolGraph: true
+      outputProjectSymbolGraph: true,
+      outputProjectImportSource: {
+        suppliedImports: suppliedImports.length,
+        matchedSuppliedImports: importSelections.filter((selection) => selection.sourceKind === 'supplied-output-project-import').length,
+        scannerFallbackImports: importSelections.filter((selection) => selection.sourceKind === 'lightweight-output-project-scan').length
+      }
     }
   }, imports);
   return {
@@ -27,10 +41,55 @@ function createJsTsProjectSafeMergeGraphArtifacts(input, outputFiles, mergeId) {
   };
 }
 
+function normalizeOutputProjectImports(value) {
+  if (!value) return [];
+  if (Array.isArray(value)) return value.filter(Boolean);
+  if (value instanceof Map) return [...value.values()].filter(Boolean);
+  if (typeof value === 'object') return Object.values(value).filter(Boolean);
+  return [];
+}
+
+function matchingOutputProjectImport(source, imports) {
+  const sourcePath = String(source.sourcePath ?? '');
+  const sourceHash = String(source.sourceHash ?? '');
+  return imports.find((importResult) => {
+    const importSourcePath = sourcePathForImport(importResult);
+    if (importSourcePath && sourcePath && importSourcePath !== sourcePath) return false;
+    const importSourceHash = sourceHashForImport(importResult);
+    if (importSourceHash && sourceHash && importSourceHash !== sourceHash) return false;
+    return importSourcePath === sourcePath || importSourceHash === sourceHash;
+  });
+}
+
+function sourcePathForImport(importResult) {
+  return firstString(
+    importResult?.sourcePath,
+    importResult?.nativeSource?.sourcePath,
+    importResult?.nativeAst?.sourcePath,
+    importResult?.semanticIndex?.documents?.[0]?.path
+  );
+}
+
+function sourceHashForImport(importResult) {
+  return firstString(
+    importResult?.sourceHash,
+    importResult?.nativeSource?.sourceHash,
+    importResult?.nativeAst?.sourceHash,
+    importResult?.semanticIndex?.documents?.[0]?.sourceHash
+  );
+}
+
 function languageForPath(sourcePath) {
   const path = String(sourcePath ?? '').toLowerCase();
   if (path.endsWith('.js') || path.endsWith('.jsx') || path.endsWith('.mjs') || path.endsWith('.cjs')) return 'javascript';
   return 'typescript';
 }
 
+function firstString(...values) {
+  for (const value of values) {
+    if (value !== undefined && value !== null && String(value)) return String(value);
+  }
+  return undefined;
+}
+
 export { createJsTsProjectSafeMergeGraphArtifacts };

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

@@ -2,13 +2,13 @@ import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
 import { safeMergeJsTsSource } from './js-ts-safe-merge-composed.js';
 import { compactRecord } from './js-ts-safe-merge-context.js';
 import { createJsTsProjectSafeMergeGraphArtifacts } from './js-ts-safe-project-merge-graph.js';
+import { outputProjectGraphConflicts } from './js-ts-safe-project-merge-graph-conflicts.js';
 
 function safeMergeJsTsProject(input = {}) {
   const id = String(input.id ?? 'js_ts_project_safe_merge');
   const files = normalizeProjectFiles(input);
   const fileResults = files.map((file) => mergeProjectFile(file, input, id));
   const blockedFiles = fileResults.filter((file) => file.status === 'blocked');
-  const status = blockedFiles.length ? 'blocked' : 'merged';
   const outputFiles = fileResults
     .filter((file) => typeof file.outputSourceText === 'string')
     .map((file) => compactRecord({
@@ -18,10 +18,19 @@ function safeMergeJsTsProject(input = {}) {
       sourceHash: file.outputHash,
       operation: file.operation
     }));
-  const reasonCodes = uniqueStrings(blockedFiles.flatMap((file) => file.admission.reasonCodes));
-  const graphArtifacts = status === 'merged' && input.includeOutputProjectSymbolGraph
+  const graphArtifacts = blockedFiles.length === 0 && input.includeOutputProjectSymbolGraph
     ? createJsTsProjectSafeMergeGraphArtifacts(input, outputFiles, id)
     : undefined;
+  const graphConflicts = outputProjectGraphConflicts(graphArtifacts?.projectSymbolGraph);
+  const status = blockedFiles.length || graphConflicts.length ? 'blocked' : 'merged';
+  const reasonCodes = uniqueStrings([
+    ...blockedFiles.flatMap((file) => file.admission.reasonCodes),
+    ...graphConflicts.map((conflict) => conflict.code)
+  ]);
+  const conflictKeys = uniqueStrings([
+    ...fileResults.flatMap((file) => file.conflictKeys),
+    ...graphConflicts.map((conflict) => conflict.details?.conflictKey)
+  ]);
   const core = {
     kind: 'frontier.lang.jsTsProjectSafeMerge',
     version: 1,
@@ -32,7 +41,7 @@ function safeMergeJsTsProject(input = {}) {
     outputFiles,
     outputProjectImport: graphArtifacts?.projectImport,
     outputProjectSymbolGraph: graphArtifacts?.projectSymbolGraph,
-    conflicts: fileResults.flatMap((file) => file.conflicts),
+    conflicts: [...fileResults.flatMap((file) => file.conflicts), ...graphConflicts],
     admission: {
       status: status === 'merged' ? 'auto-merge-candidate' : 'blocked',
       action: status === 'merged' ? 'apply-project' : 'human-review',
@@ -41,15 +50,16 @@ function safeMergeJsTsProject(input = {}) {
       autoMergeClaim: false,
       semanticEquivalenceClaim: false,
       reasonCodes,
-      conflictKeys: uniqueStrings(fileResults.flatMap((file) => file.conflictKeys))
+      conflictKeys
     },
-    summary: projectSummary(fileResults),
+    summary: projectSummary(fileResults, graphConflicts),
     metadata: compactRecord({
       workerChangeSetId: input.workerChangeSetId,
       headChangeSetId: input.headChangeSetId,
       projectRoot: input.projectRoot,
       filesInput: Array.isArray(input.files) ? 'records' : 'maps',
       outputProjectSymbolGraph: Boolean(graphArtifacts?.projectSymbolGraph),
+      projectGraphConflicts: graphConflicts.length || undefined,
       autoMergeClaim: false,
       semanticEquivalenceClaim: false
     })
@@ -235,7 +245,7 @@ function sourceLedgersForFile(input, sourcePath) {
   return undefined;
 }
 
-function projectSummary(files) {
+function projectSummary(files, graphConflicts = []) {
   const byOperation = {};
   for (const file of files) byOperation[file.operation] = (byOperation[file.operation] ?? 0) + 1;
   return {
@@ -243,6 +253,7 @@ function projectSummary(files) {
     mergedFiles: files.filter((file) => file.status === 'merged').length,
     blockedFiles: files.filter((file) => file.status === 'blocked').length,
     outputFiles: files.filter((file) => typeof file.outputSourceText === 'string').length,
+    projectGraphConflicts: graphConflicts.length,
     semanticArtifactFiles: files.filter((file) => file.semanticArtifacts).length,
     operations: byOperation
   };

package/package.json

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