@monoes/monograph 1.1.0 → 1.2.1

package/src/graph/resolve/dynamic-imports.ts

@@ -0,0 +1,102 @@
+// Resolve import() calls into structured import entries.
+
+export type DynamicImportPattern =
+  | { kind: 'string'; value: string }
+  | { kind: 'template'; prefix: string; suffix: string }
+  | { kind: 'expression' };
+
+export interface DynamicImportInfo {
+  pattern: DynamicImportPattern;
+  importedNames: string[];   // destructured: `const { a } = await import('./x')` → ['a']
+  namespaceLocal?: string;   // `const ns = await import('./x')` → 'ns'
+  isSideEffect: boolean;
+  line: number;
+}
+
+export interface ResolvedDynamicImport {
+  source: DynamicImportInfo;
+  resolvedPaths: string[];   // matched file paths
+  isGlob: boolean;
+}
+
+/** Parse dynamic import calls from source text. */
+export function parseDynamicImports(source: string): DynamicImportInfo[] {
+  const results: DynamicImportInfo[] = [];
+  const lines = source.split('\n');
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (!line.includes('import(')) continue;
+
+    // Template literal: import(`./routes/${name}`)
+    const tmplM = /import\(`([^`]*)\$\{[^}]+\}([^`]*)`\)/.exec(line);
+    if (tmplM) {
+      results.push({
+        pattern: { kind: 'template', prefix: tmplM[1], suffix: tmplM[2] },
+        importedNames: [],
+        isSideEffect: true,
+        line: i + 1,
+      });
+      continue;
+    }
+
+    // String literal: import('./foo')
+    const strM = /import\(\s*['"`]([^'"`]+)['"`]\s*\)/.exec(line);
+    if (!strM) continue;
+
+    const path = strM[1];
+
+    // Destructured await: const { a, b } = await import('./x')
+    const destructM = /const\s+\{([^}]+)\}\s*=\s*await\s+import/.exec(line);
+    if (destructM) {
+      const names = destructM[1].split(',').map(s => s.trim().split(/\s+as\s+/)[0].trim()).filter(Boolean);
+      results.push({ pattern: { kind: 'string', value: path }, importedNames: names, isSideEffect: false, line: i + 1 });
+      continue;
+    }
+
+    // Namespace: const ns = await import('./x')
+    const nsM = /const\s+([a-zA-Z_$][\w$]*)\s*=\s*await\s+import/.exec(line);
+    if (nsM) {
+      results.push({ pattern: { kind: 'string', value: path }, importedNames: [], namespaceLocal: nsM[1], isSideEffect: false, line: i + 1 });
+      continue;
+    }
+
+    // Bare side-effect: await import('./x') or import('./x').then(...)
+    results.push({ pattern: { kind: 'string', value: path }, importedNames: [], isSideEffect: true, line: i + 1 });
+  }
+
+  return results;
+}
+
+/** Expand a template-literal import to a glob pattern. */
+export function templateToGlob(prefix: string, suffix: string): string {
+  return `${prefix}*${suffix}`;
+}
+
+/** Match a glob pattern against a list of file paths (simple prefix+suffix matching). */
+export function matchGlob(pattern: string, files: string[]): string[] {
+  const [pre, suf = ''] = pattern.split('*');
+  return files.filter(f => f.includes(pre) && (suf === '' || f.endsWith(suf)));
+}
+
+/** Resolve a single dynamic import info against a list of known file paths. */
+export function resolveSingleDynamicImport(
+  info: DynamicImportInfo,
+  allFiles: string[],
+  currentDir: string,
+): ResolvedDynamicImport {
+  if (info.pattern.kind === 'expression') {
+    return { source: info, resolvedPaths: [], isGlob: false };
+  }
+  if (info.pattern.kind === 'template') {
+    const glob = templateToGlob(
+      currentDir + '/' + info.pattern.prefix,
+      info.pattern.suffix,
+    );
+    return { source: info, resolvedPaths: matchGlob(glob, allFiles), isGlob: true };
+  }
+  // String literal
+  const target = info.pattern.value;
+  const resolved = allFiles.find(f => f.endsWith(target.replace(/^\.\//, '/'))) ?? target;
+  return { source: info, resolvedPaths: [resolved], isGlob: false };
+}

package/src/graph/resolve/fallbacks.ts

@@ -0,0 +1,79 @@
+import * as path from 'node:path';
+import type { ResolveContext, ResolveResult, FileId, DynamicImportPattern, DiscoveredFile } from './types.js';
+import { OUTPUT_DIRS } from './types.js';
+import { extractPackageNameFromNodeModulesPath } from './path-info.js';
+
+export function trySourceFallback(canonical: string, pathToId: Map<string, FileId>): FileId | null {
+  const normalized = canonical.replace(/\\/g, '/');
+  for (const outDir of OUTPUT_DIRS) {
+    const pattern = `/${outDir}/`;
+    if (normalized.includes(pattern)) {
+      const sourcePath = normalized.replace(pattern, '/src/');
+      const id = pathToId.get(sourcePath);
+      if (id !== undefined) return id;
+    }
+  }
+  return null;
+}
+
+export function tryPnpmWorkspaceFallback(
+  canonical: string,
+  pathToId: Map<string, FileId>,
+  workspaceRoots: Map<string, string>,
+): FileId | null {
+  const normalized = canonical.replace(/\\/g, '/');
+  const pnpmStore = 'node_modules/.pnpm/';
+  const idx = normalized.indexOf(pnpmStore);
+  if (idx === -1) return null;
+  const afterStore = normalized.slice(idx + pnpmStore.length);
+  const nodeModulesIdx = afterStore.indexOf('/node_modules/');
+  if (nodeModulesIdx === -1) return null;
+  const subpath = afterStore.slice(nodeModulesIdx + '/node_modules/'.length);
+  for (const [, wsRoot] of workspaceRoots) {
+    const candidate = path.join(wsRoot, 'node_modules', subpath);
+    const id = pathToId.get(candidate);
+    if (id !== undefined) return id;
+  }
+  return null;
+}
+
+export function tryWorkspacePackageFallback(
+  ctx: ResolveContext,
+  specifier: string,
+): ResolveResult | null {
+  for (const [pkgName, wsRoot] of ctx.workspaceRoots) {
+    if (specifier === pkgName || specifier.startsWith(pkgName + '/')) {
+      const subpath = specifier.slice(pkgName.length);
+      const candidate = path.join(wsRoot, subpath || 'index');
+      const id = ctx.pathToId.get(candidate);
+      if (id !== undefined) return { kind: 'InternalModule', fileId: id };
+    }
+  }
+  return null;
+}
+
+export function makeGlobFromPattern(pattern: DynamicImportPattern): string {
+  return pattern.pattern
+    .replace(/\$\{[^}]+\}/g, '*')
+    .replace(/\+/g, '*')
+    .replace(/\(\?:[^)]+\)/g, '*');
+}
+
+export function tryScssIncludePathFallback(
+  ctx: ResolveContext,
+  _fromFile: string,
+  specifier: string,
+  fromStyle: boolean,
+): ResolveResult | null {
+  if (!fromStyle) return null;
+  for (const includePath of ctx.scssIncludePaths) {
+    const candidate = path.join(includePath, specifier);
+    const id = ctx.pathToId.get(candidate);
+    if (id !== undefined) return { kind: 'InternalModule', fileId: id };
+    for (const ext of ['.scss', '.sass', '.css']) {
+      const withExt = ctx.pathToId.get(candidate + ext);
+      if (withExt !== undefined) return { kind: 'InternalModule', fileId: withExt };
+    }
+  }
+  return null;
+}

package/src/graph/resolve/index.ts

@@ -0,0 +1,68 @@
+import type { ResolveContext, ResolvedModule, DiscoveredFile, WorkspaceInfo, FileId } from './types.js';
+import { makeResolvedModule } from './types.js';
+import { resolveStaticImports } from './static-imports.js';
+import { resolveReExports } from './re-exports.js';
+import { applySpecifierUpgrades } from './upgrades.js';
+import { extractPackageNameFromNodeModulesPath } from './path-info.js';
+
+export * from './types.js';
+export * from './path-info.js';
+export * from './specifier.js';
+export * from './static-imports.js';
+export * from './require-imports.js';
+export * from './re-exports.js';
+export * from './fallbacks.js';
+export * from './react-native.js';
+export * from './upgrades.js';
+
+export interface ModuleInfo {
+  fileId: FileId;
+  path: string;
+  imports: Array<{ specifier: string; isDynamic?: boolean; isTypeOnly?: boolean }>;
+  reExports: Array<{ specifier: string; isTypeOnly?: boolean }>;
+  hasCjsExports?: boolean;
+}
+
+export function resolveAllImports(
+  modules: ModuleInfo[],
+  files: DiscoveredFile[],
+  workspaces: WorkspaceInfo[],
+  activePlugins: string[],
+  pathAliases: Array<[string, string]>,
+  scssIncludePaths: string[],
+  root: string,
+  extraConditions: string[],
+): ResolvedModule[] {
+  const pathToId = new Map<string, FileId>(files.map(f => [f.path, f.fileId]));
+  const rawPathToId = new Map<string, FileId>(
+    files.filter(f => f.canonicalPath).map(f => [f.canonicalPath!, f.fileId])
+  );
+  const workspaceRoots = new Map<string, string>(
+    workspaces.filter(w => w.name).map(w => [w.name!, w.root])
+  );
+
+  const ctx: ResolveContext = {
+    pathToId,
+    rawPathToId,
+    workspaceRoots,
+    pathAliases,
+    scssIncludePaths,
+    root,
+    tsconfigWarned: new Set(),
+    activePlugins,
+    extraConditions,
+  };
+
+  const resolved = modules.map(mod => {
+    const rm = makeResolvedModule(mod.fileId, mod.path);
+    rm.resolvedImports = resolveStaticImports(ctx, mod.path, mod.imports);
+    rm.resolvedReExports = resolveReExports(ctx, mod.path, mod.reExports);
+    rm.hasCjsExports = mod.hasCjsExports ?? false;
+    return rm;
+  });
+
+  applySpecifierUpgrades(resolved);
+  return resolved;
+}
+
+export { extractPackageNameFromNodeModulesPath };

package/src/graph/resolve/path-info.ts

@@ -0,0 +1,41 @@
+const PATH_ALIAS_PREFIXES = ['@/', '~/', '#', '@@/'];
+const PASCAL_SCOPE_RE = /^@[A-Z]/;
+const PACKAGE_NAME_RE = /^(@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/i;
+
+export function isPathAlias(specifier: string): boolean {
+  for (const prefix of PATH_ALIAS_PREFIXES) {
+    if (specifier.startsWith(prefix)) return true;
+  }
+  return PASCAL_SCOPE_RE.test(specifier);
+}
+
+export function isBareSpecifier(specifier: string): boolean {
+  if (specifier.startsWith('.') || specifier.startsWith('/')) return false;
+  if (specifier.startsWith('node:') || specifier.startsWith('bun:')) return false;
+  if (/^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(specifier)) return false;
+  return true;
+}
+
+export function isValidPackageName(name: string): boolean {
+  return PACKAGE_NAME_RE.test(name);
+}
+
+export function extractPackageName(specifier: string): string {
+  if (specifier.startsWith('@')) {
+    const parts = specifier.split('/');
+    return parts.length >= 2 ? `${parts[0]}/${parts[1]}` : specifier;
+  }
+  return specifier.split('/')[0];
+}
+
+export function extractPackageNameFromNodeModulesPath(path: string): string | null {
+  const normalized = path.replace(/\\/g, '/');
+  const idx = normalized.lastIndexOf('node_modules/');
+  if (idx === -1) return null;
+  const after = normalized.slice(idx + 'node_modules/'.length);
+  if (after.startsWith('@')) {
+    const parts = after.split('/');
+    return parts.length >= 2 ? `${parts[0]}/${parts[1]}` : null;
+  }
+  return after.split('/')[0] || null;
+}

package/src/graph/resolve/re-exports.ts

@@ -0,0 +1,14 @@
+import type { ResolveContext, ResolvedReExport, ReExportInfo } from './types.js';
+import { resolveSpecifier, isStyleFile } from './specifier.js';
+
+export function resolveReExports(
+  ctx: ResolveContext,
+  filePath: string,
+  reExports: ReExportInfo[],
+): ResolvedReExport[] {
+  const fromStyle = isStyleFile(filePath);
+  return reExports.map(info => ({
+    info,
+    target: resolveSpecifier(ctx, filePath, info.specifier, fromStyle),
+  }));
+}

package/src/graph/resolve/react-native.ts

@@ -0,0 +1,27 @@
+const REACT_NATIVE_PLUGINS = ['react-native', 'expo', '@react-native'];
+const BASE_EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'];
+const RN_SUFFIXES = ['.native', '.ios', '.android', '.web'];
+const BASE_CONDITIONS = ['import', 'require', 'default'];
+const RN_CONDITIONS = ['react-native', 'browser', 'module'];
+
+export function hasReactNativePlugin(activePlugins: string[]): boolean {
+  return activePlugins.some(p => REACT_NATIVE_PLUGINS.some(rn => p.includes(rn)));
+}
+
+export function buildExtensions(activePlugins: string[]): string[] {
+  if (!hasReactNativePlugin(activePlugins)) return BASE_EXTENSIONS;
+  const rnExts: string[] = [];
+  for (const suffix of RN_SUFFIXES) {
+    for (const ext of ['.ts', '.tsx', '.js', '.jsx']) {
+      rnExts.push(suffix + ext);
+    }
+  }
+  return [...rnExts, ...BASE_EXTENSIONS];
+}
+
+export function buildConditionNames(activePlugins: string[], extraConditions: string[]): string[] {
+  const conditions = [...BASE_CONDITIONS];
+  if (hasReactNativePlugin(activePlugins)) conditions.unshift(...RN_CONDITIONS);
+  conditions.push(...extraConditions);
+  return [...new Set(conditions)];
+}

package/src/graph/resolve/require-imports.ts

@@ -0,0 +1,18 @@
+import type { ResolveContext, ResolvedImport, ImportInfo } from './types.js';
+import { resolveSpecifier } from './specifier.js';
+
+export interface RequireCallInfo {
+  specifier: string;
+  span?: { start: number; end: number };
+}
+
+export function resolveRequireImports(
+  ctx: ResolveContext,
+  filePath: string,
+  requireCalls: RequireCallInfo[],
+): ResolvedImport[] {
+  return requireCalls.map(req => {
+    const info: ImportInfo = { specifier: req.specifier, isDynamic: true, span: req.span };
+    return { info, target: resolveSpecifier(ctx, filePath, req.specifier, false) };
+  });
+}

package/src/graph/resolve/specifier.ts

@@ -0,0 +1,120 @@
+import * as path from 'node:path';
+import * as fs from 'node:fs';
+import type { ResolveContext, ResolveResult, FileId } from './types.js';
+import { extractPackageNameFromNodeModulesPath } from './path-info.js';
+
+const STYLE_EXTS = new Set(['.css', '.scss', '.sass', '.less', '.styl']);
+const JS_TS_EXTS = new Set(['.ts', '.tsx', '.mts', '.cts', '.js', '.jsx', '.mjs', '.cjs']);
+
+export function isStyleFile(filePath: string): boolean {
+  return STYLE_EXTS.has(path.extname(filePath).toLowerCase());
+}
+
+export function isJsTsExtension(filePath: string): boolean {
+  return JS_TS_EXTS.has(path.extname(filePath).toLowerCase());
+}
+
+export function isPlainCssFile(filePath: string): boolean {
+  return path.extname(filePath).toLowerCase() === '.css';
+}
+
+export function isBareStyleSubpath(specifier: string): boolean {
+  return !specifier.startsWith('.') && STYLE_EXTS.has(path.extname(specifier).toLowerCase());
+}
+
+export function pathAliasPatternMatches(pattern: string, specifier: string): boolean {
+  if (pattern.endsWith('*')) {
+    return specifier.startsWith(pattern.slice(0, -1));
+  }
+  return specifier === pattern;
+}
+
+export function matchesNearestTsconfigPathAlias(root: string, fromFile: string, specifier: string): boolean {
+  const tsconfigPath = nearestTsconfigPath(root, fromFile);
+  if (!tsconfigPath) return false;
+  try {
+    const raw = fs.readFileSync(tsconfigPath, 'utf8');
+    const json = JSON.parse(stripJsonComments(raw));
+    const paths: Record<string, string[]> = json?.compilerOptions?.paths ?? {};
+    return Object.keys(paths).some(p => pathAliasPatternMatches(p, specifier));
+  } catch {
+    return false;
+  }
+}
+
+export function nearestTsconfigPath(root: string, fromFile: string): string | null {
+  let dir = path.dirname(fromFile);
+  while (dir.startsWith(root)) {
+    const candidate = path.join(dir, 'tsconfig.json');
+    if (fs.existsSync(candidate)) return candidate;
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+
+export function resolveSpecifier(
+  ctx: ResolveContext,
+  fromFile: string,
+  specifier: string,
+  fromStyle: boolean,
+): ResolveResult {
+  if (specifier.startsWith('.') || specifier.startsWith('/')) {
+    const resolved = resolveRelative(ctx, fromFile, specifier);
+    if (resolved) return resolved;
+    if (fromStyle) {
+      const scss = tryScssPartialFallback(ctx, fromFile, specifier);
+      if (scss) return scss;
+    }
+    return { kind: 'Unresolvable', specifier };
+  }
+
+  for (const [pattern, target] of ctx.pathAliases) {
+    if (pathAliasPatternMatches(pattern, specifier)) {
+      const mapped = specifier.replace(pattern.replace('*', ''), target.replace('*', ''));
+      const r = resolveRelative(ctx, ctx.root, mapped);
+      if (r) return r;
+    }
+  }
+
+  const pkg = extractPackageNameFromNodeModulesPath(specifier) ?? specifier.split('/')[0];
+  return { kind: 'NpmPackage', name: pkg };
+}
+
+function resolveRelative(ctx: ResolveContext, fromFile: string, specifier: string): ResolveResult | null {
+  const fromDir = path.dirname(fromFile);
+  const base = path.resolve(fromDir, specifier);
+
+  const directId = ctx.pathToId.get(base) ?? ctx.rawPathToId.get(base);
+  if (directId !== undefined) return { kind: 'InternalModule', fileId: directId };
+
+  const exts = ['.ts', '.tsx', '.mts', '.cts', '.js', '.jsx', '.mjs', '.cjs'];
+  for (const ext of exts) {
+    const id = ctx.pathToId.get(base + ext) ?? ctx.rawPathToId.get(base + ext);
+    if (id !== undefined) return { kind: 'InternalModule', fileId: id };
+  }
+
+  for (const ext of exts) {
+    const id = ctx.pathToId.get(path.join(base, 'index' + ext));
+    if (id !== undefined) return { kind: 'InternalModule', fileId: id };
+  }
+
+  return null;
+}
+
+function tryScssPartialFallback(ctx: ResolveContext, fromFile: string, specifier: string): ResolveResult | null {
+  const fromDir = path.dirname(fromFile);
+  const base = path.resolve(fromDir, specifier);
+  const dir = path.dirname(base);
+  const name = '_' + path.basename(base);
+  for (const ext of ['.scss', '.sass', '.css']) {
+    const id = ctx.pathToId.get(path.join(dir, name + ext));
+    if (id !== undefined) return { kind: 'InternalModule', fileId: id };
+  }
+  return null;
+}
+
+function stripJsonComments(s: string): string {
+  return s.replace(/\/\/[^\n]*/g, '').replace(/\/\*[\s\S]*?\*\//g, '');
+}

package/src/graph/resolve/static-imports.ts

@@ -0,0 +1,14 @@
+import type { ResolveContext, ResolvedImport, ImportInfo } from './types.js';
+import { resolveSpecifier, isStyleFile } from './specifier.js';
+
+export function resolveStaticImports(
+  ctx: ResolveContext,
+  filePath: string,
+  imports: ImportInfo[],
+): ResolvedImport[] {
+  const fromStyle = isStyleFile(filePath);
+  return imports.map(info => ({
+    info,
+    target: resolveSpecifier(ctx, filePath, info.specifier, fromStyle),
+  }));
+}

package/src/graph/resolve/types.ts

@@ -0,0 +1,108 @@
+export type FileId = number;
+
+export type ResolveResult =
+  | { kind: 'InternalModule'; fileId: FileId }
+  | { kind: 'ExternalFile'; path: string }
+  | { kind: 'NpmPackage'; name: string }
+  | { kind: 'Unresolvable'; specifier: string };
+
+export interface ImportInfo {
+  specifier: string;
+  isDynamic?: boolean;
+  isTypeOnly?: boolean;
+  span?: { start: number; end: number };
+}
+
+export interface ReExportInfo {
+  specifier: string;
+  isTypeOnly?: boolean;
+}
+
+export interface ResolvedImport {
+  info: ImportInfo;
+  target: ResolveResult;
+}
+
+export interface ResolvedReExport {
+  info: ReExportInfo;
+  target: ResolveResult;
+}
+
+export interface DynamicImportPattern {
+  pattern: string;
+  fromFile: string;
+}
+
+export interface ResolvedModule {
+  fileId: FileId;
+  path: string;
+  resolvedImports: ResolvedImport[];
+  resolvedReExports: ResolvedReExport[];
+  resolvedDynamicImports: ResolvedImport[];
+  resolvedDynamicPatterns: Array<[DynamicImportPattern, FileId[]]>;
+  unusedImportBindings: Set<string>;
+  typeReferencedImportBindings: string[];
+  valueReferencedImportBindings: string[];
+  hasCjsExports: boolean;
+}
+
+export interface CanonicalFallback {
+  files: DiscoveredFile[];
+  map: Map<string, FileId> | null;
+}
+
+export interface DiscoveredFile {
+  path: string;
+  fileId: FileId;
+  canonicalPath?: string;
+}
+
+export interface WorkspaceInfo {
+  root: string;
+  name?: string;
+}
+
+export interface ResolveContext {
+  pathToId: Map<string, FileId>;
+  rawPathToId: Map<string, FileId>;
+  workspaceRoots: Map<string, string>;
+  pathAliases: Array<[string, string]>;
+  scssIncludePaths: string[];
+  root: string;
+  canonicalFallback?: CanonicalFallback;
+  tsconfigWarned: Set<string>;
+  activePlugins: string[];
+  extraConditions: string[];
+}
+
+export const OUTPUT_DIRS = ['dist', 'build', 'out', 'esm', 'cjs', '.next', '.nuxt', '.svelte-kit'] as const;
+
+export const SOURCE_EXTS = ['ts', 'tsx', 'mts', 'cts', 'js', 'jsx', 'mjs', 'cjs'] as const;
+
+export const RN_PLATFORM_PREFIXES = ['.web', '.ios', '.android', '.native'] as const;
+
+export function getOrBuildCanonicalMap(fallback: CanonicalFallback): Map<string, FileId> {
+  if (!fallback.map) {
+    fallback.map = new Map(
+      fallback.files
+        .filter(f => f.canonicalPath)
+        .map(f => [f.canonicalPath!, f.fileId])
+    );
+  }
+  return fallback.map;
+}
+
+export function makeResolvedModule(fileId: FileId, path: string): ResolvedModule {
+  return {
+    fileId,
+    path,
+    resolvedImports: [],
+    resolvedReExports: [],
+    resolvedDynamicImports: [],
+    resolvedDynamicPatterns: [],
+    unusedImportBindings: new Set(),
+    typeReferencedImportBindings: [],
+    valueReferencedImportBindings: [],
+    hasCjsExports: false,
+  };
+}

package/src/graph/resolve/upgrades.ts

@@ -0,0 +1,32 @@
+import type { ResolvedModule } from './types.js';
+
+export function applySpecifierUpgrades(resolved: ResolvedModule[]): void {
+  const internalBySpecifier = new Map<string, number>();
+
+  for (const mod of resolved) {
+    for (const ri of mod.resolvedImports) {
+      if (ri.target.kind === 'InternalModule') {
+        internalBySpecifier.set(ri.info.specifier, ri.target.fileId);
+      }
+    }
+  }
+
+  for (const mod of resolved) {
+    for (const ri of mod.resolvedImports) {
+      if (ri.target.kind === 'NpmPackage') {
+        const internalId = internalBySpecifier.get(ri.info.specifier);
+        if (internalId !== undefined) {
+          ri.target = { kind: 'InternalModule', fileId: internalId };
+        }
+      }
+    }
+    for (const rr of mod.resolvedReExports) {
+      if (rr.target.kind === 'NpmPackage') {
+        const internalId = internalBySpecifier.get(rr.info.specifier);
+        if (internalId !== undefined) {
+          rr.target = { kind: 'InternalModule', fileId: internalId };
+        }
+      }
+    }
+  }
+}