@shapeshift-labs/frontier-lang-compiler 0.2.115 → 0.2.117

package/README.md

@@ -238,12 +238,38 @@ console.log(project.outputProjectSymbolGraph.importEdges[0].packageName); // "@p
 console.log(project.outputProjectSymbolGraph.importEdges[0].packageExportCondition); // "import"
 ```
 
+Package `imports` maps are also modeled for `#internal` specifiers. Top-level
+`moduleResolution.imports` applies from `packageRoot`/`root`, while
+`packages[name].imports` applies to the nearest configured package root. Graph
+edges record `packageImportKey`, `packageImportCondition`, and
+`packageImportTarget` so merge admission can distinguish private aliases from
+external or unresolved imports:
+
+```js
+const project = safeMergeJsTsProject({
+  includeOutputProjectSymbolGraph: true,
+  moduleResolution: {
+    imports: { '#internal/*': { import: './src/internal/*.ts', default: './src/internal/*.js' } },
+    packageExportConditions: ['import', 'default']
+  },
+  baseFiles,
+  workerFiles,
+  headFiles
+});
+
+console.log(project.outputProjectSymbolGraph.importEdges[0].resolutionKind); // "package-import-source"
+console.log(project.outputProjectSymbolGraph.importEdges[0].packageImportKey); // "#internal/*"
+```
+
 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`.
 Public contract regions include `apiSurfaceKind`, `signatureHash`, and
 `contractHash`, giving merge admission a stable API surface fingerprint.
+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.
 
 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,6 +1,7 @@
 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 type NativeProjectPackageImports = Readonly<Record<string, NativeProjectPackageExportTarget>>;
 
 export interface NativeProjectPackageConditionalExports {
   readonly [condition: string]: NativeProjectPackageExportTarget;
@@ -12,12 +13,17 @@ export interface NativeProjectPackageResolutionOptions {
   readonly main?: string;
   readonly types?: string;
   readonly exports?: NativeProjectPackageExports;
+  readonly imports?: NativeProjectPackageImports;
 }
 
 export interface NativeProjectModuleResolutionOptions {
+  readonly root?: string;
+  readonly packageRoot?: string;
   readonly baseUrl?: string;
   readonly paths?: NativeProjectModuleResolutionPaths;
   readonly aliases?: NativeProjectModuleResolutionPaths;
+  readonly imports?: NativeProjectPackageImports;
+  readonly packageImports?: NativeProjectPackageImports;
   readonly packages?: Readonly<Record<string, NativeProjectPackageResolutionOptions>>;
   readonly conditions?: readonly string[];
   readonly packageExportConditions?: readonly string[];

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

@@ -107,16 +107,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' | 'package-source' | 'package-missing' | 'package-external' | string;
-  readonly packageName?: string;
-  readonly packageSubpath?: string;
-  readonly packageExportCondition?: 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' | 'package-import-source' | 'package-import-missing' | 'package-import-external' | string;
+  readonly packageName?: string; readonly packageSubpath?: string; readonly packageExportCondition?: string;
+  readonly packageImportKey?: string; readonly packageImportCondition?: string; readonly packageImportTarget?: string;
   readonly importKind?: string;
   readonly exportKind?: string;
   readonly importedName?: string;
   readonly exportedName?: string;
   readonly localName?: string; readonly namespace?: string;
-  readonly isTypeOnly?: boolean;
+  readonly exportStar?: boolean; readonly isTypeOnly?: boolean;
   readonly isReExport?: boolean;
   readonly publicContract?: boolean;
   readonly evidenceIds?: readonly string[];
@@ -133,8 +132,8 @@ export interface NativeProjectSymbolGraphReExportIdentityRecord {
   readonly exportedName?: string;
   readonly importedName?: string;
   readonly localName?: string;
-  readonly namespace?: string;
-  readonly isTypeOnly?: boolean;
+  readonly namespace?: string; readonly isTypeOnly?: boolean;
+  readonly isExportStar?: boolean;
   readonly symbolId?: string; readonly originSymbolId?: string;
   readonly exportedSymbolId?: string; readonly localSymbolId?: string;
   readonly relationId?: string;

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

@@ -1,8 +1,8 @@
 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{createProjectDocumentExportSymbolResolver,createProjectModuleSymbolResolver,resolveProjectModule}from'./projectSymbolGraphModuleResolution.js';
+import{createProjectDocumentExportSymbolResolver,createProjectDocumentExportSymbolsResolver,createProjectModuleSymbolResolver,resolveProjectModule}from'./projectSymbolGraphModuleResolution.js';
 import{publicContractRegionRecord}from'./projectSymbolGraphPublicContracts.js';
-import{isReExportImportEdge,reExportIdentityInputFromEdge,reExportIdentityRecord}from'./projectSymbolGraphReExports.js';
+import{exportStarReExportIdentityRecords,isReExportImportEdge,reExportIdentityInputFromEdge,reExportIdentityRecord}from'./projectSymbolGraphReExports.js';
 export function createNativeProjectImportResult(input, imports) {
   const idPart = idFragment(input.id ?? input.projectRoot ?? 'native_project');
   const nodes = {};
@@ -156,6 +156,7 @@ function createProjectSymbolGraphSummary(semanticIndex, imports, input) {
   const moduleResolution = input.moduleResolution ?? input.tsconfig;
   const resolveTargetSymbolId = createProjectModuleSymbolResolver(semanticIndex?.symbols ?? [], documents);
   const resolveDocumentExportSymbolId = createProjectDocumentExportSymbolResolver(semanticIndex?.symbols ?? [], documents);
+  const resolveDocumentExportSymbols = createProjectDocumentExportSymbolsResolver(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]));
@@ -176,7 +177,9 @@ function createProjectSymbolGraphSummary(semanticIndex, imports, input) {
       .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))
+      .flatMap((edge) => edge.exportStar
+        ? exportStarReExportIdentityRecords(edge, resolveDocumentExportSymbols(edge.targetDocumentId))
+        : [reExportIdentityRecord(reExportIdentityInputFromEdge(edge, `reexport_${idFragment(edge.id)}`), edge, resolveDocumentExportSymbolId)])
   ]);
   const publicContractRegions = uniqueRecords(facts
     .filter((fact) => fact.predicate === 'publicContractRegion' && fact.value)
@@ -240,14 +243,18 @@ function moduleEdgeRecord(relation, moduleEdgeByRelation, symbolsById, documents
     packageName: resolution?.packageName,
     packageSubpath: resolution?.packageSubpath,
     packageExportCondition: resolution?.packageExportCondition,
+    packageImportKey: resolution?.packageImportKey,
+    packageImportCondition: resolution?.packageImportCondition,
+    packageImportTarget: resolution?.packageImportTarget,
     importKind: firstString(moduleEdge.importKind, value.importKind, symbolMetadata.importKind),
     exportKind: firstString(moduleEdge.exportKind, value.exportKind, symbolMetadata.exportKind),
     importedName: firstString(moduleEdge.importedName, value.importedName, symbolMetadata.importedName),
     exportedName: firstString(moduleEdge.exportedName, value.exportedName, symbolMetadata.exportedName),
     localName: firstString(moduleEdge.localName, value.localName, symbolMetadata.localName),
     namespace: firstString(moduleEdge.namespace, value.namespace, symbolMetadata.namespace),
+    exportStar: firstBoolean(moduleEdge.exportStar, value.exportStar, symbolMetadata.exportStar),
     isTypeOnly: firstBoolean(moduleEdge.isTypeOnly, value.isTypeOnly),
-    isReExport: firstBoolean(moduleEdge.isReExport, value.isReExport) ?? (relation.predicate === 'exports' && Boolean(moduleSpecifier)),
+    isReExport: firstBoolean(moduleEdge.isReExport, value.isReExport, symbolMetadata.reexport) ?? (relation.predicate === 'exports' && Boolean(moduleSpecifier)),
     publicContract: firstBoolean(moduleEdge.publicContract, value.publicContract, metadata.publicContract),
     evidenceIds: uniqueStrings([...(relation.evidenceIds ?? []), ...(fact?.evidenceIds ?? [])])
   };

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

@@ -13,6 +13,7 @@ export function resolveRelativeProjectModule(sourcePath, moduleSpecifier, docume
 export function resolveProjectModule(sourcePath, moduleSpecifier, documentsByPath, moduleResolution) {
   if (!sourcePath || !moduleSpecifier) return undefined;
   if (String(moduleSpecifier).startsWith('.')) return resolveRelativeProjectModule(sourcePath, moduleSpecifier, documentsByPath);
+  if (String(moduleSpecifier).startsWith('#')) return resolvePackageImportProjectModule(sourcePath, moduleSpecifier, documentsByPath, moduleResolution);
   return resolveConfiguredProjectModule(moduleSpecifier, documentsByPath, moduleResolution);
 }
 
@@ -34,6 +35,22 @@ export function createProjectDocumentExportSymbolResolver(symbols, documents) {
   };
 }
 
+export function createProjectDocumentExportSymbolsResolver(symbols, documents) {
+  const documentsByPath = new Map(documents.filter((document) => document.path).map((document) => [document.path, document]));
+  const exportsByDocumentId = new Map();
+  for (const symbol of symbols ?? []) {
+    if (symbol?.kind !== 'export' || !symbol.name) continue;
+    const document = documentsByPath.get(symbol.definitionSpan?.path);
+    if (!document) continue;
+    const exports = exportsByDocumentId.get(document.id) ?? [];
+    exports.push(symbol);
+    exportsByDocumentId.set(document.id, exports);
+  }
+  return function resolveDocumentExports(documentId) {
+    return exportsByDocumentId.get(documentId) ?? [];
+  };
+}
+
 function projectExportSymbolMap(symbols, documents) {
   const documentsByPath = new Map(documents.filter((document) => document.path).map((document) => [document.path, document]));
   const exportedByDocumentAndName = new Map();
@@ -58,6 +75,32 @@ function resolveConfiguredProjectModule(moduleSpecifier, documentsByPath, module
   return firstMissing ?? (packageInfo ? { kind: 'package-external', ...packageInfo } : undefined);
 }
 
+function resolvePackageImportProjectModule(sourcePath, moduleSpecifier, documentsByPath, moduleResolution = {}) {
+  const packageContext = packageImportContext(sourcePath, moduleResolution);
+  const importsValue = packageContext.imports;
+  if (!importsValue) return { kind: 'package-import-external', packageImportKey: moduleSpecifier };
+  const match = packageImportMapValue(importsValue, moduleSpecifier);
+  if (!match) return { kind: 'package-import-external', packageImportKey: moduleSpecifier };
+  let firstMissing;
+  for (const target of exportTargetsForValue(match.value, packageConditions(moduleResolution))) {
+    const packageImportTarget = target.path;
+    if (!packageImportTarget || !String(packageImportTarget).startsWith('.')) {
+      return { kind: 'package-import-external', packageImportKey: match.key, packageImportCondition: target.condition, packageImportTarget };
+    }
+    const candidatePath = normalizeProjectPath(joinProjectPath(packageContext.root, packageImportTarget));
+    const resolved = moduleTargetDocument(candidatePath, documentsByPath);
+    const record = {
+      packageImportKey: match.key,
+      packageImportCondition: target.condition,
+      packageImportTarget,
+      packageName: packageContext.packageName
+    };
+    if (resolved) return { path: resolved.path, documentId: resolved.id, kind: 'package-import-source', ...record };
+    firstMissing ??= { path: candidatePath, kind: 'package-import-missing', ...record };
+  }
+  return firstMissing ?? { kind: 'package-import-external', packageImportKey: match.key };
+}
+
 function configuredModuleCandidates(moduleSpecifier, moduleResolution = {}, packageInfo) {
   const compilerOptions = moduleResolution.compilerOptions ?? {};
   const baseUrl = normalizeProjectPath(moduleResolution.baseUrl ?? compilerOptions.baseUrl ?? '');
@@ -120,6 +163,31 @@ function packageExportTargets(exportsValue, subpath, conditions) {
   return exportTargetsForValue(exportMapValue(exportsValue, subpath), conditions);
 }
 
+function packageImportMapValue(importsValue, moduleSpecifier) {
+  if (!isRecord(importsValue)) return undefined;
+  if (Object.prototype.hasOwnProperty.call(importsValue, moduleSpecifier)) return { key: moduleSpecifier, value: importsValue[moduleSpecifier] };
+  for (const [pattern, value] of Object.entries(importsValue)) {
+    const capture = patternCapture(moduleSpecifier, pattern);
+    if (capture !== undefined) return { key: pattern, value: replaceExportTargetCapture(value, capture) };
+  }
+  return undefined;
+}
+
+function packageImportContext(sourcePath, moduleResolution = {}) {
+  const packages = Object.entries(moduleResolution.packages ?? {})
+    .map(([packageName, options]) => ({
+      packageName,
+      root: normalizeProjectPath(options.root ?? ''),
+      imports: options.imports
+    }))
+    .filter((entry) => entry.imports && pathInsideRoot(sourcePath, entry.root))
+    .sort((left, right) => right.root.length - left.root.length);
+  return packages[0] ?? {
+    root: normalizeProjectPath(moduleResolution.packageRoot ?? moduleResolution.root ?? ''),
+    imports: moduleResolution.imports ?? moduleResolution.packageImports
+  };
+}
+
 function exportMapValue(exportsValue, subpath) {
   if (!isRecord(exportsValue) || !Object.keys(exportsValue).some((key) => key.startsWith('.'))) return subpath === '.' ? exportsValue : undefined;
   return exportsValue[subpath] ?? patternExportMapValue(exportsValue, subpath);
@@ -213,7 +281,10 @@ function packageResolutionFields(candidate, packageInfo) {
   return {
     packageName: candidate.packageName ?? packageInfo?.packageName,
     packageSubpath: candidate.packageSubpath ?? packageInfo?.packageSubpath,
-    packageExportCondition: candidate.packageExportCondition
+    packageExportCondition: candidate.packageExportCondition,
+    packageImportKey: candidate.packageImportKey,
+    packageImportCondition: candidate.packageImportCondition,
+    packageImportTarget: candidate.packageImportTarget
   };
 }
 
@@ -234,3 +305,9 @@ function normalizeProjectPath(path) {
   }
   return parts.join('/');
 }
+
+function pathInsideRoot(sourcePath, root) {
+  if (!root) return true;
+  const normalized = normalizeProjectPath(sourcePath);
+  return normalized === root || normalized.startsWith(`${root}/`);
+}

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

@@ -15,7 +15,7 @@ export function reExportIdentityRecord(identity, edge, resolveDocumentExportSymb
 }
 
 export function isReExportImportEdge(edge) {
-  return edge.importKind === 'reexport' || edge.importKind === 'namespace-reexport';
+  return edge.importKind === 'reexport' || edge.importKind === 'namespace-reexport' || edge.exportStar === true;
 }
 
 export function reExportIdentityInputFromEdge(edge, id) {
@@ -31,6 +31,32 @@ export function reExportIdentityInputFromEdge(edge, id) {
   });
 }
 
+export function exportStarReExportIdentityRecords(edge, targetExports) {
+  if (!edge?.exportStar || !edge.targetDocumentId) return [];
+  return targetExports
+    .filter((symbol) => symbol.name && symbol.name !== 'default')
+    .map((symbol) => compactRecord({
+      id: `reexport_star_${idFragment(edge.id)}_${idFragment(symbol.id)}`,
+      sourceDocumentId: edge.sourceDocumentId,
+      sourcePath: edge.sourcePath,
+      sourceHash: edge.sourceHash,
+      moduleSpecifier: edge.moduleSpecifier,
+      symbolId: edge.targetSymbolId,
+      relationId: edge.id,
+      importedName: symbol.name,
+      exportedName: symbol.name,
+      originSymbolId: symbol.id,
+      exportedSymbolId: symbol.id,
+      localSymbolId: edge.targetSymbolId,
+      isExportStar: true,
+      publicContract: edge.publicContract
+    }));
+}
+
+function idFragment(value) {
+  return String(value ?? '').toLowerCase().replace(/[^a-z0-9]+/g, '_').replace(/^_+|_+$/g, '').slice(0, 80) || 'id';
+}
+
 function compactRecord(record) {
   return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined));
 }

package/package.json

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