@shapeshift-labs/frontier-lang-compiler 0.2.112 → 0.2.114

package/README.md

@@ -213,6 +213,35 @@ When `includeOutputProjectSymbolGraph` is enabled, the same
 `moduleResolution` shape is used for output graph artifacts. Resolution is
 runtime-neutral: `baseUrl`, `paths`, `aliases`, and `compilerOptions.paths`
 are matched against the supplied project files, not the host filesystem.
+Bare package imports also get explicit package identity. If `packages` is
+provided, package export maps can resolve back to supplied workspace sources
+and record the selected export condition:
+
+```js
+const project = safeMergeJsTsProject({
+  includeOutputProjectSymbolGraph: true,
+  moduleResolution: {
+    packages: {
+      '@pkg/core': {
+        root: 'packages/core',
+        exports: { './utils': { import: './src/utils.ts', default: './dist/utils.js' } }
+      }
+    },
+    packageExportConditions: ['import', 'default']
+  },
+  baseFiles,
+  workerFiles,
+  headFiles
+});
+
+console.log(project.outputProjectSymbolGraph.importEdges[0].packageName); // "@pkg/core"
+console.log(project.outputProjectSymbolGraph.importEdges[0].packageExportCondition); // "import"
+```
+
+Named re-export identities also include symbol links when the project graph has
+enough evidence. For `export { thing as renamedThing } from './thing.js'`,
+`reExportIdentities[]` records the source module, imported/exported names,
+`originSymbolId`, `exportedSymbolId`, and `localSymbolId`.
 
 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.
 

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

@@ -1,9 +1,26 @@
 export type NativeProjectModuleResolutionPaths = Readonly<Record<string, readonly string[] | string>>;
+export type NativeProjectPackageExportTarget = string | readonly string[] | NativeProjectPackageConditionalExports;
+export type NativeProjectPackageExports = NativeProjectPackageExportTarget | Readonly<Record<string, NativeProjectPackageExportTarget>>;
+
+export interface NativeProjectPackageConditionalExports {
+  readonly [condition: string]: NativeProjectPackageExportTarget;
+}
+
+export interface NativeProjectPackageResolutionOptions {
+  readonly root?: string;
+  readonly sourceRoot?: string;
+  readonly main?: string;
+  readonly types?: string;
+  readonly exports?: NativeProjectPackageExports;
+}
 
 export interface NativeProjectModuleResolutionOptions {
   readonly baseUrl?: string;
   readonly paths?: NativeProjectModuleResolutionPaths;
   readonly aliases?: NativeProjectModuleResolutionPaths;
+  readonly packages?: Readonly<Record<string, NativeProjectPackageResolutionOptions>>;
+  readonly conditions?: readonly string[];
+  readonly packageExportConditions?: readonly string[];
   readonly compilerOptions?: {
     readonly baseUrl?: string;
     readonly paths?: NativeProjectModuleResolutionPaths;

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

@@ -79,8 +79,6 @@ export interface ImportNativeProjectOptions {
 }
 
 export type NativeProjectSymbolGraphRemainingField =
-  | 'moduleEdges[].packageName'
-  | 'moduleEdges[].packageExportCondition'
   | 'reExportIdentities[].originSymbolId'
   | 'reExportIdentities[].exportedSymbolId'
   | 'reExportIdentities[].localSymbolId'
@@ -112,13 +110,15 @@ export interface NativeProjectSymbolGraphModuleEdgeRecord {
   readonly resolvedModulePath?: string;
   readonly targetDocumentId?: string;
   readonly resolvedTargetSymbolId?: string;
-  readonly resolutionKind?: 'relative-source' | 'relative-missing' | 'alias-source' | 'alias-missing' | 'path-alias-source' | 'path-alias-missing' | 'base-url-source' | 'base-url-missing' | string;
+  readonly resolutionKind?: 'relative-source' | 'relative-missing' | 'alias-source' | 'alias-missing' | 'path-alias-source' | 'path-alias-missing' | 'base-url-source' | 'base-url-missing' | 'package-source' | 'package-missing' | 'package-external' | string;
+  readonly packageName?: string;
+  readonly packageSubpath?: string;
+  readonly packageExportCondition?: string;
   readonly importKind?: string;
   readonly exportKind?: string;
   readonly importedName?: string;
   readonly exportedName?: string;
-  readonly localName?: string;
-  readonly namespace?: string;
+  readonly localName?: string; readonly namespace?: string;
   readonly isTypeOnly?: boolean;
   readonly isReExport?: boolean;
   readonly publicContract?: boolean;
@@ -138,10 +138,10 @@ export interface NativeProjectSymbolGraphReExportIdentityRecord {
   readonly localName?: string;
   readonly namespace?: string;
   readonly isTypeOnly?: boolean;
-  readonly symbolId?: string;
+  readonly symbolId?: string; readonly originSymbolId?: string;
+  readonly exportedSymbolId?: string; readonly localSymbolId?: string;
   readonly relationId?: string;
-  readonly ownershipRegionId?: string;
-  readonly ownershipRegionKey?: string;
+  readonly ownershipRegionId?: string; readonly ownershipRegionKey?: string;
   readonly publicContract?: boolean;
   readonly factId?: string;
 }

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

@@ -1,6 +1,7 @@
 import{idFragment,uniqueByEvidenceId,uniqueByLossId,uniqueStrings}from'../../native-import-utils.js';import{createDocument,createPatch,createUniversalAstEnvelope}from'@shapeshift-labs/frontier-lang-kernel';
 import{createNativeImportResultContract}from'./createNativeImportResultContract.js';import{createProjectImportAdmissionRecord}from'./createProjectImportAdmissionRecord.js';import{mergeSemanticIndexes}from'./mergeSemanticIndexes.js';import{summarizeNativeImportLosses}from'./summarizeNativeImportLosses.js';import{summarizeProjectSourcePreservation}from'./summarizeProjectSourcePreservation.js';
-import{createProjectModuleSymbolResolver,resolveProjectModule}from'./projectSymbolGraphModuleResolution.js';
+import{createProjectDocumentExportSymbolResolver,createProjectModuleSymbolResolver,resolveProjectModule}from'./projectSymbolGraphModuleResolution.js';
+import{isReExportImportEdge,reExportIdentityInputFromEdge,reExportIdentityRecord}from'./projectSymbolGraphReExports.js';
 export function createNativeProjectImportResult(input, imports) {
   const idPart = idFragment(input.id ?? input.projectRoot ?? 'native_project');
   const nodes = {};
@@ -141,8 +142,6 @@ export function createNativeProjectImportResult(input, imports) {
 }
 
 const PROJECT_SYMBOL_GRAPH_REMAINING_FIELDS = Object.freeze([
-  'moduleEdges[].packageName',
-  'moduleEdges[].packageExportCondition',
   'reExportIdentities[].originSymbolId',
   'reExportIdentities[].exportedSymbolId',
   'reExportIdentities[].localSymbolId',
@@ -158,6 +157,7 @@ function createProjectSymbolGraphSummary(semanticIndex, imports, input) {
   const documentsByPath = new Map(documents.filter((document) => document.path).map((document) => [document.path, document]));
   const moduleResolution = input.moduleResolution ?? input.tsconfig;
   const resolveTargetSymbolId = createProjectModuleSymbolResolver(semanticIndex?.symbols ?? [], documents);
+  const resolveDocumentExportSymbolId = createProjectDocumentExportSymbolResolver(semanticIndex?.symbols ?? [], documents);
   const facts = semanticIndex?.facts ?? [];
   const moduleEdgeFacts = facts.filter((fact) => fact.predicate === 'moduleEdge');
   const moduleEdgeByRelation = new Map(moduleEdgeFacts.map((fact) => [fact.subjectId, fact]));
@@ -168,22 +168,17 @@ function createProjectSymbolGraphSummary(semanticIndex, imports, input) {
   const exportEdges = relations
     .filter((relation) => relation.predicate === 'exports')
     .map((relation) => moduleEdgeRecord(relation, moduleEdgeByRelation, symbolsById, documentsById, documentsByPath, moduleResolution, resolveTargetSymbolId));
+  const moduleEdgeById = new Map([...importEdges, ...exportEdges].map((edge) => [edge.id, edge]));
   const reExportIdentities = uniqueRecords([
     ...facts
       .filter((fact) => fact.predicate === 'reExportIdentity' && fact.value)
-      .map((fact) => ({ ...objectValue(fact.value), factId: fact.id })),
+      .map((fact) => reExportIdentityRecord(objectValue(fact.value), moduleEdgeById.get(objectValue(fact.value).relationId ?? fact.objectId), resolveDocumentExportSymbolId, { factId: fact.id })),
     ...exportEdges
       .filter((edge) => edge.isReExport)
-      .map((edge) => compactRecord({
-        id: `reexport_${idFragment(edge.id)}`,
-        sourceDocumentId: edge.sourceDocumentId,
-        sourcePath: edge.sourcePath,
-        sourceHash: edge.sourceHash,
-        moduleSpecifier: edge.moduleSpecifier,
-        symbolId: edge.targetSymbolId,
-        relationId: edge.id,
-        publicContract: edge.publicContract
-      }))
+      .map((edge) => reExportIdentityRecord(reExportIdentityInputFromEdge(edge, `reexport_${idFragment(edge.id)}`), edge, resolveDocumentExportSymbolId)),
+    ...importEdges
+      .filter((edge) => isReExportImportEdge(edge))
+      .map((edge) => reExportIdentityRecord(reExportIdentityInputFromEdge(edge, `reexport_${idFragment(edge.id)}`), edge, resolveDocumentExportSymbolId))
   ]);
   const publicContractRegions = uniqueRecords(facts
     .filter((fact) => fact.predicate === 'publicContractRegion' && fact.value)
@@ -244,6 +239,9 @@ function moduleEdgeRecord(relation, moduleEdgeByRelation, symbolsById, documents
     resolvedModulePath: resolution?.path,
     targetDocumentId: resolution?.documentId,
     resolutionKind: resolution?.kind,
+    packageName: resolution?.packageName,
+    packageSubpath: resolution?.packageSubpath,
+    packageExportCondition: resolution?.packageExportCondition,
     importKind: firstString(moduleEdge.importKind, value.importKind, symbolMetadata.importKind),
     exportKind: firstString(moduleEdge.exportKind, value.exportKind, symbolMetadata.exportKind),
     importedName: firstString(moduleEdge.importedName, value.importedName, symbolMetadata.importedName),

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

@@ -17,14 +17,7 @@ export function resolveProjectModule(sourcePath, moduleSpecifier, documentsByPat
 }
 
 export function createProjectModuleSymbolResolver(symbols, documents) {
-  const documentsByPath = new Map(documents.filter((document) => document.path).map((document) => [document.path, document]));
-  const exportedByDocumentAndName = new Map();
-  for (const symbol of symbols ?? []) {
-    if (symbol?.kind !== 'export' || !symbol.name) continue;
-    const document = documentsByPath.get(symbol.definitionSpan?.path);
-    if (!document) continue;
-    exportedByDocumentAndName.set(symbolKey(document.id, symbol.name), symbol);
-  }
+  const exportedByDocumentAndName = projectExportSymbolMap(symbols, documents);
   return function resolveProjectModuleSymbol(edge) {
     if (!edge?.targetDocumentId) return undefined;
     const targetName = targetExportName(edge);
@@ -33,23 +26,45 @@ export function createProjectModuleSymbolResolver(symbols, documents) {
   };
 }
 
+export function createProjectDocumentExportSymbolResolver(symbols, documents) {
+  const exportedByDocumentAndName = projectExportSymbolMap(symbols, documents);
+  return function resolveDocumentExportSymbol(documentId, name) {
+    if (!documentId || !name) return undefined;
+    return exportedByDocumentAndName.get(symbolKey(documentId, name))?.id;
+  };
+}
+
+function projectExportSymbolMap(symbols, documents) {
+  const documentsByPath = new Map(documents.filter((document) => document.path).map((document) => [document.path, document]));
+  const exportedByDocumentAndName = new Map();
+  for (const symbol of symbols ?? []) {
+    if (symbol?.kind !== 'export' || !symbol.name) continue;
+    const document = documentsByPath.get(symbol.definitionSpan?.path);
+    if (document) exportedByDocumentAndName.set(symbolKey(document.id, symbol.name), symbol);
+  }
+  return exportedByDocumentAndName;
+}
+
 function resolveConfiguredProjectModule(moduleSpecifier, documentsByPath, moduleResolution) {
-  const candidates = configuredModuleCandidates(moduleSpecifier, moduleResolution);
+  const packageInfo = packageSpecifierInfo(moduleSpecifier);
+  const candidates = configuredModuleCandidates(moduleSpecifier, moduleResolution, packageInfo);
   let firstMissing;
   for (const candidate of candidates) {
     const target = moduleTargetDocument(candidate.path, documentsByPath);
-    if (target) return { path: target.path, documentId: target.id, kind: `${candidate.kind}-source` };
-    firstMissing ??= { path: candidate.path, kind: `${candidate.kind}-missing` };
+    const packageFields = packageResolutionFields(candidate, packageInfo);
+    if (target) return { path: target.path, documentId: target.id, kind: `${candidate.kind}-source`, ...packageFields };
+    firstMissing ??= { path: candidate.path, kind: `${candidate.kind}-missing`, ...packageFields };
   }
-  return firstMissing;
+  return firstMissing ?? (packageInfo ? { kind: 'package-external', ...packageInfo } : undefined);
 }
 
-function configuredModuleCandidates(moduleSpecifier, moduleResolution = {}) {
+function configuredModuleCandidates(moduleSpecifier, moduleResolution = {}, packageInfo) {
   const compilerOptions = moduleResolution.compilerOptions ?? {};
   const baseUrl = normalizeProjectPath(moduleResolution.baseUrl ?? compilerOptions.baseUrl ?? '');
   return uniquePaths([
     ...aliasCandidates(moduleSpecifier, moduleResolution.aliases, 'alias', baseUrl),
     ...aliasCandidates(moduleSpecifier, moduleResolution.paths ?? compilerOptions.paths, 'path-alias', baseUrl),
+    ...packageCandidates(packageInfo, moduleResolution),
     ...baseUrlCandidates(moduleSpecifier, baseUrl)
   ]);
 }
@@ -71,6 +86,74 @@ function baseUrlCandidates(moduleSpecifier, baseUrl) {
   return [{ kind: 'base-url', path: normalizeProjectPath(joinProjectPath(baseUrl, moduleSpecifier)) }];
 }
 
+function packageCandidates(packageInfo, moduleResolution = {}) {
+  if (!packageInfo) return [];
+  const options = moduleResolution.packages?.[packageInfo.packageName];
+  if (!options) return [];
+  const root = normalizeProjectPath(options.root ?? '');
+  const subpath = packageInfo.packageSubpath === '.' ? '' : packageInfo.packageSubpath.slice(2);
+  return uniquePaths([
+    ...packageExportCandidates(packageInfo, options, moduleResolution).map((candidate) => ({
+      ...candidate,
+      path: normalizeProjectPath(joinProjectPath(root, candidate.path))
+    })),
+    ...packageFallbackTargets(options, subpath).map((path) => ({
+      kind: 'package',
+      path: normalizeProjectPath(joinProjectPath(root, path)),
+      ...packageInfo
+    }))
+  ]);
+}
+
+function packageExportCandidates(packageInfo, options, moduleResolution) {
+  const targets = packageExportTargets(options.exports, packageInfo.packageSubpath, packageConditions(moduleResolution));
+  return targets.map((target) => ({
+    kind: 'package',
+    path: target.path,
+    packageExportCondition: target.condition,
+    ...packageInfo
+  }));
+}
+
+function packageExportTargets(exportsValue, subpath, conditions) {
+  if (!exportsValue) return [];
+  return exportTargetsForValue(exportMapValue(exportsValue, subpath), conditions);
+}
+
+function exportMapValue(exportsValue, subpath) {
+  if (!isRecord(exportsValue) || !Object.keys(exportsValue).some((key) => key.startsWith('.'))) return subpath === '.' ? exportsValue : undefined;
+  return exportsValue[subpath] ?? patternExportMapValue(exportsValue, subpath);
+}
+
+function patternExportMapValue(exportsValue, subpath) {
+  for (const [pattern, target] of Object.entries(exportsValue)) {
+    const capture = patternCapture(subpath, pattern);
+    if (capture !== undefined) return replaceExportTargetCapture(target, capture);
+  }
+  return undefined;
+}
+
+function replaceExportTargetCapture(target, capture) {
+  if (typeof target === 'string') return target.replace('*', capture);
+  if (Array.isArray(target)) return target.map((entry) => replaceExportTargetCapture(entry, capture));
+  if (!isRecord(target)) return target;
+  return Object.fromEntries(Object.entries(target).map(([key, value]) => [key, replaceExportTargetCapture(value, capture)]));
+}
+
+function exportTargetsForValue(value, conditions, condition) {
+  if (!value) return [];
+  if (typeof value === 'string') return [{ path: value, condition }];
+  if (Array.isArray(value)) return value.flatMap((entry) => exportTargetsForValue(entry, conditions, condition));
+  if (!isRecord(value)) return [];
+  return conditions.flatMap((key) => exportTargetsForValue(value[key], conditions, key));
+}
+
+function packageFallbackTargets(options, subpath) {
+  const sourceRoot = normalizeProjectPath(options.sourceRoot ?? 'src');
+  if (subpath) return [joinProjectPath(sourceRoot, subpath), subpath];
+  return [options.types, options.main, joinProjectPath(sourceRoot, 'index')].filter(Boolean);
+}
+
 function moduleTargetDocument(path, documentsByPath) {
   for (const candidate of modulePathCandidates(path)) {
     const document = documentsByPath.get(candidate);
@@ -80,7 +163,7 @@ function moduleTargetDocument(path, documentsByPath) {
 }
 
 function modulePathCandidates(path) {
-  return [path, `${path}.js`, `${path}.ts`, `${path}.tsx`, `${path}.jsx`, `${path}/index.js`, `${path}/index.ts`];
+  return [path, `${path}.js`, `${path}.ts`, `${path}.tsx`, `${path}.jsx`, `${path}.d.ts`, `${path}/index.js`, `${path}/index.ts`, `${path}/index.d.ts`];
 }
 
 function targetExportName(edge) {
@@ -114,6 +197,34 @@ function joinProjectPath(left, right) {
   return left ? `${left}/${right}` : String(right);
 }
 
+function packageSpecifierInfo(moduleSpecifier) {
+  if (!moduleSpecifier || String(moduleSpecifier).startsWith('#')) return undefined;
+  const parts = String(moduleSpecifier).split('/');
+  if (!parts[0] || parts[0] === '.' || parts[0] === '..') return undefined;
+  const scoped = parts[0].startsWith('@');
+  if (scoped && parts.length < 2) return undefined;
+  const packageName = scoped ? `${parts[0]}/${parts[1]}` : parts[0];
+  const rest = parts.slice(scoped ? 2 : 1).join('/');
+  return { packageName, packageSubpath: rest ? `./${rest}` : '.' };
+}
+
+function packageResolutionFields(candidate, packageInfo) {
+  if (!candidate.packageName && candidate.kind !== 'package') return {};
+  return {
+    packageName: candidate.packageName ?? packageInfo?.packageName,
+    packageSubpath: candidate.packageSubpath ?? packageInfo?.packageSubpath,
+    packageExportCondition: candidate.packageExportCondition
+  };
+}
+
+function packageConditions(moduleResolution = {}) {
+  return moduleResolution.packageExportConditions ?? moduleResolution.conditions ?? ['types', 'import', 'module', 'require', 'default'];
+}
+
+function isRecord(value) {
+  return value && typeof value === 'object' && !Array.isArray(value);
+}
+
 function normalizeProjectPath(path) {
   const parts = [];
   for (const part of String(path).split('/')) {

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

@@ -0,0 +1,43 @@
+export function reExportIdentityRecord(identity, edge, resolveDocumentExportSymbolId, extra = {}) {
+  const exportedName = firstString(identity.exportedName, edge?.exportedName, edge?.importedName === '*' ? undefined : (edge?.exportedName ?? edge?.importedName));
+  const importedName = firstString(identity.importedName, edge?.importedName);
+  const localName = firstString(identity.localName, edge?.localName, exportedName);
+  return compactRecord({
+    ...identity,
+    exportedName,
+    importedName,
+    localName,
+    originSymbolId: firstString(identity.originSymbolId, edge?.resolvedTargetSymbolId),
+    exportedSymbolId: firstString(identity.exportedSymbolId, resolveDocumentExportSymbolId(edge?.sourceDocumentId, exportedName), edge?.predicate === 'exports' ? edge?.targetSymbolId : undefined),
+    localSymbolId: firstString(identity.localSymbolId, edge?.targetSymbolId),
+    ...extra
+  });
+}
+
+export function isReExportImportEdge(edge) {
+  return edge.importKind === 'reexport' || edge.importKind === 'namespace-reexport';
+}
+
+export function reExportIdentityInputFromEdge(edge, id) {
+  return compactRecord({
+    id,
+    sourceDocumentId: edge.sourceDocumentId,
+    sourcePath: edge.sourcePath,
+    sourceHash: edge.sourceHash,
+    moduleSpecifier: edge.moduleSpecifier,
+    symbolId: edge.targetSymbolId,
+    relationId: edge.id,
+    publicContract: edge.publicContract
+  });
+}
+
+function compactRecord(record) {
+  return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined));
+}
+
+function firstString(...values) {
+  for (const value of values) {
+    if (value !== undefined && value !== null && String(value)) return String(value);
+  }
+  return undefined;
+}

package/package.json

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