@shapeshift-labs/frontier-lang-compiler 0.2.116 → 0.2.118

package/README.md

@@ -238,6 +238,35 @@ console.log(project.outputProjectSymbolGraph.importEdges[0].packageName); // "@p
 console.log(project.outputProjectSymbolGraph.importEdges[0].packageExportCondition); // "import"
 ```
 
+NodeNext-style JS extension specifiers can resolve to supplied TS source files.
+For example, `import './runtime.js'` can resolve to `src/runtime.ts` when that is
+the available project document. Graph edges record `resolutionPathVariant` as
+`"extension-substitution"` so coordinators can distinguish exact source matches
+from source-extension substitutions during stale checks and merge admission.
+
+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,

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,10 +107,10 @@ 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 resolutionPathVariant?: 'exact' | 'extension-substitution' | 'extensionless' | 'index' | 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;

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

@@ -240,9 +240,13 @@ function moduleEdgeRecord(relation, moduleEdgeByRelation, symbolsById, documents
     resolvedModulePath: resolution?.path,
     targetDocumentId: resolution?.documentId,
     resolutionKind: resolution?.kind,
+    resolutionPathVariant: resolution?.resolutionPathVariant,
     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),

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

@@ -0,0 +1,52 @@
+export function modulePathCandidates(path) {
+  const normalized = String(path ?? '');
+  return uniqueCandidates([
+    candidate(normalized, 'exact'),
+    ...extensionSubstitutionCandidates(normalized),
+    ...extensionlessCandidates(normalized),
+    ...indexCandidates(normalized)
+  ]);
+}
+
+function extensionSubstitutionCandidates(path) {
+  const entries = [
+    ['.js', ['.ts', '.tsx', '.d.ts', '.jsx']],
+    ['.jsx', ['.tsx', '.ts', '.d.ts']],
+    ['.mjs', ['.mts', '.ts', '.d.mts']],
+    ['.cjs', ['.cts', '.ts', '.d.cts']]
+  ];
+  for (const [from, targets] of entries) {
+    if (!path.endsWith(from)) continue;
+    const base = path.slice(0, -from.length);
+    return targets.map((target) => candidate(`${base}${target}`, 'extension-substitution'));
+  }
+  return [];
+}
+
+function extensionlessCandidates(path) {
+  if (hasKnownExtension(path)) return [];
+  return ['.js', '.ts', '.tsx', '.jsx', '.mjs', '.mts', '.cjs', '.cts', '.d.ts']
+    .map((extension) => candidate(`${path}${extension}`, 'extensionless'));
+}
+
+function indexCandidates(path) {
+  return ['.js', '.ts', '.tsx', '.jsx', '.mjs', '.mts', '.cjs', '.cts', '.d.ts']
+    .map((extension) => candidate(`${path}/index${extension}`, 'index'));
+}
+
+function hasKnownExtension(path) {
+  return /\.(?:[cm]?[jt]sx?|d\.[cm]?ts)$/.test(path);
+}
+
+function candidate(path, variant) {
+  return { path, variant };
+}
+
+function uniqueCandidates(candidates) {
+  const seen = new Set();
+  return candidates.filter((entry) => {
+    if (!entry.path || seen.has(entry.path)) return false;
+    seen.add(entry.path);
+    return true;
+  });
+}

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

@@ -1,3 +1,5 @@
+import { modulePathCandidates } from './projectSymbolGraphModulePathCandidates.js';
+
 export function resolveRelativeProjectModule(sourcePath, moduleSpecifier, documentsByPath) {
   if (!sourcePath || !moduleSpecifier || !moduleSpecifier.startsWith('.')) return undefined;
   const base = sourcePath.includes('/') ? sourcePath.slice(0, sourcePath.lastIndexOf('/')) : '';
@@ -6,6 +8,7 @@ export function resolveRelativeProjectModule(sourcePath, moduleSpecifier, docume
   return {
     path: target?.path ?? unresolvedPath,
     documentId: target?.id,
+    resolutionPathVariant: target?.resolutionPathVariant,
     kind: target ? 'relative-source' : 'relative-missing'
   };
 }
@@ -13,6 +16,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);
 }
 
@@ -68,12 +72,38 @@ function resolveConfiguredProjectModule(moduleSpecifier, documentsByPath, module
   for (const candidate of candidates) {
     const target = moduleTargetDocument(candidate.path, documentsByPath);
     const packageFields = packageResolutionFields(candidate, packageInfo);
-    if (target) return { path: target.path, documentId: target.id, kind: `${candidate.kind}-source`, ...packageFields };
+    if (target) return { path: target.path, documentId: target.id, resolutionPathVariant: target.resolutionPathVariant, kind: `${candidate.kind}-source`, ...packageFields };
     firstMissing ??= { path: candidate.path, kind: `${candidate.kind}-missing`, ...packageFields };
   }
   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, resolutionPathVariant: resolved.resolutionPathVariant, 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 ?? '');
@@ -136,6 +166,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);
@@ -172,16 +227,12 @@ function packageFallbackTargets(options, subpath) {
 
 function moduleTargetDocument(path, documentsByPath) {
   for (const candidate of modulePathCandidates(path)) {
-    const document = documentsByPath.get(candidate);
-    if (document) return document;
+    const document = documentsByPath.get(candidate.path);
+    if (document) return { ...document, resolutionPathVariant: candidate.variant };
   }
   return undefined;
 }
 
-function modulePathCandidates(path) {
-  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) {
   const name = edge.importedName ?? edge.localName ?? edge.exportedName;
   if (!name || name === '*') return undefined;
@@ -229,7 +280,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
   };
 }
 
@@ -250,3 +304,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/package.json

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