@openrewrite/rewrite 8.93.0 → 8.93.2

package/src/javascript/package-json-parser.ts

@@ -24,11 +24,12 @@ import {
     PackageManager,
     readNpmrcConfigs
 } from "./node-resolution-result";
+import {createNodeRuntimeMarker, NodeRuntime} from "./node-runtime";
 import * as fs from "fs";
 import * as fsp from "fs/promises";
 import * as path from "path";
 import * as YAML from "yaml";
-import {getLockFileDetectionConfig, runList} from "./package-manager";
+import {getLockFileDetectionConfig, getLockFileName, runList, runVersion} from "./package-manager";
 import picomatch from "picomatch";
 import {DEFAULT_DIR_EXCLUSIONS, walkDirs} from "../path-utils";
 
@@ -76,6 +77,9 @@ export class PackageJsonParser extends Parser {
     private readonly jsonParser: JsonParser;
     private readonly skipDependencyResolution: boolean;
 
+    /** The NodeRuntime of each project root, by package manager and root directory, for the parser's lifetime */
+    private readonly runtimes = new Map<string, NodeRuntime>();
+
     /** Fields to copy from package.json that contain dependency maps */
     private static readonly DEPENDENCY_FIELDS = [
         'dependencies',
@@ -166,18 +170,50 @@ export class PackageJsonParser extends Parser {
                 markersByDir.set(dir, await this.createMarker(input, dir));
             }
             const marker = markersByDir.get(dir)!;
+            const runtime = this.nodeRuntime(dir, marker?.packageManager);
+
+            // Attach the markers to the JSON document: every one gets the NodeRuntime of its project
+            yield {
+                ...jsonDoc,
+                markers: {
+                    ...jsonDoc.markers,
+                    markers: [...jsonDoc.markers.markers, ...(marker ? [marker] : []), runtime]
+                }
+            };
+        }
+    }
 
-            // Attach the marker to the JSON document
-            if (marker) {
-                yield {
-                    ...jsonDoc,
-                    markers: {
-                        ...jsonDoc.markers,
-                        markers: [...jsonDoc.markers.markers, marker]
-                    }
-                };
-            } else {
-                yield jsonDoc;
+    /**
+     * The NodeRuntime of the project whose package.json is in `dir`, one instance per project root: the directory of
+     * the lock the parser found `packageManager` by, else `dir`. That package manager's `--version` is asked there,
+     * once per package manager and root directory; without one, as when dependency resolution is skipped, none is.
+     */
+    private nodeRuntime(dir: string, packageManager?: PackageManager): NodeRuntime {
+        const absoluteDir = path.resolve(this.relativeTo ?? '', dir);
+        const root = packageManager === undefined ? absoluteDir : this.projectRoot(absoluteDir, packageManager);
+        const key = `${packageManager ?? ''}:${root}`;
+        let runtime = this.runtimes.get(key);
+        if (!runtime) {
+            runtime = createNodeRuntimeMarker(packageManager,
+                packageManager === undefined ? undefined : runVersion(packageManager, root));
+            this.runtimes.set(key, runtime);
+        }
+        return runtime;
+    }
+
+    /**
+     * The nearest directory from `dir` up to relativeTo that holds `packageManager`'s lock, as the lock file walk
+     * finds it; `dir` where none does.
+     */
+    private projectRoot(dir: string, packageManager: PackageManager): string {
+        const lockFile = getLockFileName(packageManager);
+        const stop = this.relativeTo ? path.resolve(this.relativeTo) : undefined;
+        for (let current = dir; ; current = path.dirname(current)) {
+            if (fs.existsSync(path.join(current, lockFile))) {
+                return current;
+            }
+            if (current === stop || path.dirname(current) === current) {
+                return dir;
             }
         }
     }
@@ -343,6 +379,9 @@ export class PackageJsonParser extends Parser {
                     continue;
                 }
 
+                // a pattern without wildcards names the directory itself
+                candidates.push(absoluteBaseDir);
+
                 // Use walkDirs with appropriate depth limit
                 const dirs = await walkDirs(absoluteBaseDir, {
                     maxDepth: hasRecursive ? undefined : 0,
@@ -353,7 +392,7 @@ export class PackageJsonParser extends Parser {
             }
         }
 
-        return candidates;
+        return [...new Set(candidates)];
     }
 
     /**
@@ -429,29 +468,41 @@ export class PackageJsonParser extends Parser {
     ): Promise<{ content: PackageLockContent; packageManager: PackageManager } | undefined> {
         // Normalize paths for comparison
         const normalizedRoot = rootDir ? path.resolve(rootDir) : undefined;
-        let currentDir = path.resolve(startDir);
 
-        // Walk up the directory tree looking for a lock file
+        // Each directory from startDir up, stopping at rootDir (or the filesystem root)
+        const dirs: string[] = [];
+        let currentDir = path.resolve(startDir);
         while (true) {
-            const result = await this.tryReadLockFile(currentDir);
-            if (result) {
-                return result;
-            }
-
-            // If we've reached rootDir, stop walking (don't go above it)
+            dirs.push(currentDir);
             if (normalizedRoot && currentDir === normalizedRoot) {
                 break;
             }
-
-            // Check if we've reached the filesystem root
             const parentDir = path.dirname(currentDir);
             if (parentDir === currentDir) {
                 break;
             }
-
             currentDir = parentDir;
         }
 
+        // A lock file names the package manager, wherever it is on the way up. An installed
+        // workspace member has node_modules of its own and no lock: its workspace's lock, above it,
+        // says which package manager installed them.
+        for (const dir of dirs) {
+            const result = await this.tryReadLockFile(dir);
+            if (result) {
+                return result;
+            }
+        }
+
+        // Fallback: node_modules without a lock file anywhere above (e.g., symlinked from another
+        // workspace). Walk them for resolved dependency information, and assume npm.
+        for (const dir of dirs) {
+            const parsed = await this.walkNodeModules(dir);
+            if (parsed) {
+                return { content: parsed, packageManager: PackageManager.Npm };
+            }
+        }
+
         return undefined;
     }
 
@@ -504,14 +555,6 @@ export class PackageJsonParser extends Parser {
             }
         }
 
-        // Fallback: if node_modules exists but no lock file was found (e.g., symlinked from another workspace),
-        // walk node_modules to get resolved dependency information
-        const parsed = await this.walkNodeModules(dir);
-        if (parsed) {
-            // Assume npm as the default package manager when only node_modules exists
-            return { content: parsed, packageManager: PackageManager.Npm };
-        }
-
         return undefined;
     }
 

package/src/javascript/package-manager.ts

@@ -52,6 +52,9 @@ interface PackageManagerConfig {
 
     /** Command to list dependencies in JSON format (if supported) */
     listCommand?: string[];
+
+    /** Command that prints the release of the package manager that runs where it is run */
+    versionCommand: string[];
 }
 
 /**
@@ -69,6 +72,7 @@ const PACKAGE_MANAGER_CONFIGS: Record<PackageManager, PackageManagerConfig> = {
         installLockOnlyCommand: ['npm', 'install', '--package-lock-only', '--ignore-scripts', '--legacy-peer-deps'],
         installCommand: ['npm', 'install', '--ignore-scripts', '--legacy-peer-deps'],
         listCommand: ['npm', 'list', '--json', '--all'],
+        versionCommand: ['npm', '--version'],
     },
     [PackageManager.YarnClassic]: {
         lockFile: 'yarn.lock',
@@ -76,6 +80,7 @@ const PACKAGE_MANAGER_CONFIGS: Record<PackageManager, PackageManagerConfig> = {
         installLockOnlyCommand: ['yarn', 'install', '--ignore-scripts'],
         installCommand: ['yarn', 'install', '--ignore-scripts'],
         listCommand: ['yarn', 'list', '--json'],
+        versionCommand: ['yarn', '--version'],
     },
     [PackageManager.YarnBerry]: {
         lockFile: 'yarn.lock',
@@ -83,6 +88,7 @@ const PACKAGE_MANAGER_CONFIGS: Record<PackageManager, PackageManagerConfig> = {
         installLockOnlyCommand: ['yarn', 'install', '--mode', 'skip-build'],
         installCommand: ['yarn', 'install', '--mode', 'skip-build'],
         listCommand: ['yarn', 'info', '--all', '--json'],
+        versionCommand: ['yarn', '--version'],
     },
     [PackageManager.Pnpm]: {
         lockFile: 'pnpm-lock.yaml',
@@ -92,12 +98,14 @@ const PACKAGE_MANAGER_CONFIGS: Record<PackageManager, PackageManagerConfig> = {
         installLockOnlyCommand: ['pnpm', 'install', '--lockfile-only', '--ignore-scripts', '--no-strict-peer-dependencies'],
         installCommand: ['pnpm', 'install', '--ignore-scripts', '--no-strict-peer-dependencies'],
         listCommand: ['pnpm', 'list', '--json', '--depth=Infinity'],
+        versionCommand: ['pnpm', '--version'],
     },
     [PackageManager.Bun]: {
         lockFile: 'bun.lock',
         // Bun doesn't have a lock-only mode; --ignore-scripts prevents lifecycle scripts
         installLockOnlyCommand: ['bun', 'install', '--ignore-scripts'],
         installCommand: ['bun', 'install', '--ignore-scripts'],
+        versionCommand: ['bun', '--version'],
     },
 };
 
@@ -310,6 +318,46 @@ export function runList(pm: PackageManager, cwd: string, timeout: number = 30000
     return result.stdout;
 }
 
+/**
+ * A release as a package manager's `--version` prints it: `major.minor.patch`, with a prerelease or build or both.
+ */
+const RELEASE = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
+
+/**
+ * What the package manager's `--version` answers, run in `cwd`: in the project's root directory, the release that
+ * would install the project on this machine, since Yarn and pnpm decide there which release runs (`yarnPath`,
+ * corepack, pnpm's own switching).
+ *
+ * It runs as the parser's other package manager commands do, with `COREPACK_ENABLE_DOWNLOAD_PROMPT=0`, no input and
+ * a short timeout, so it never prompts and never throws.
+ *
+ * @param pm The package manager to ask
+ * @param cwd The project's root directory
+ * @param timeout Timeout in milliseconds
+ * @returns The trimmed answer, or undefined when the package manager is not installed, fails, or answers something
+ *          that is no version
+ */
+export function runVersion(pm: PackageManager, cwd: string, timeout: number = 10000): string | undefined {
+    const [cmd, ...args] = PACKAGE_MANAGER_CONFIGS[pm].versionCommand;
+    try {
+        const result = spawnSync(getPlatformCommand(cmd), args, {
+            cwd,
+            encoding: 'utf-8',
+            stdio: ['ignore', 'pipe', 'pipe'],
+            timeout,
+            env: {...process.env, COREPACK_ENABLE_DOWNLOAD_PROMPT: '0'},
+            ...(os.platform() === 'win32' ? { shell: true } : {})
+        });
+        if (result.error || result.status !== 0 || typeof result.stdout !== 'string') {
+            return undefined;
+        }
+        const answer = result.stdout.trim();
+        return RELEASE.test(answer) ? answer : undefined;
+    } catch {
+        return undefined;
+    }
+}
+
 /**
  * Result of running install in a temporary directory.
  */

package/src/javascript/parser.ts

@@ -89,6 +89,25 @@ type WithInvalidSyntaxSlots<T> = T & {
     modifiers?: ts.NodeArray<ts.ModifierLike>;
 };
 
+interface CompiledProject {
+    readonly program: ts.Program;
+    readonly typeMapping: JavaScriptTypeMapping;
+}
+
+/**
+ * The inputs of one parse that a single tsconfig governs, or that none does.
+ */
+interface Project {
+    /** Path of the governing config file, empty where there is none. */
+    readonly key: string;
+    readonly options: ts.CompilerOptions;
+    readonly rootNames: SourcePath[];
+    /** How many of the inputs are still to be mapped. */
+    unmapped: number;
+    /** Present from the first input mapped until the last. */
+    compiled?: CompiledProject;
+}
+
 export class JavaScriptParser extends Parser {
 
     private readonly tsConfig: TsConfigResolver;
@@ -216,8 +235,8 @@ export class JavaScriptParser extends Parser {
 
     override async* parse(...inputs: ParserInput[]): AsyncGenerator<SourceFile> {
         const inputFiles = new Map<SourcePath, ParserInput>();
-        const projectOf = new Map<SourcePath, string>();
-        const projects = new Map<string, { options: ts.CompilerOptions, rootNames: SourcePath[] }>();
+        const projectOf = new Map<SourcePath, Project>();
+        const projects = new Map<string, Project>();
 
         // Populate inputFiles map and remove from cache if necessary
         for (const input of inputs) {
@@ -236,12 +255,13 @@ export class JavaScriptParser extends Parser {
         for (const normalizedSourcePath of inputFiles.keys()) {
             const {configFilePath, options} = this.tsConfig.forFile(normalizedSourcePath);
             const projectKey = configFilePath ?? "";
-            projectOf.set(normalizedSourcePath, projectKey);
             let project = projects.get(projectKey);
             if (!project) {
-                projects.set(projectKey, project = {options, rootNames: []});
+                projects.set(projectKey, project = {key: projectKey, options, rootNames: [], unmapped: 0});
             }
             project.rootNames.push(normalizedSourcePath);
+            project.unmapped++;
+            projectOf.set(normalizedSourcePath, project);
         }
 
         // Module resolution probes a directory before the files in it, so a directory holding
@@ -253,53 +273,74 @@ export class JavaScriptParser extends Parser {
             }
         }
 
-        const compiled = new Map<string, { program: ts.Program, typeMapping: JavaScriptTypeMapping }>();
-        for (const [projectKey, {options, rootNames}] of projects) {
-            // TypeScript carries the previous program's bound files forward when the root paths match,
-            // so a parser held across parses of one path costs a fraction of a freshly built one.
-            const program = ts.createProgram(rootNames, options,
-                this.createCompilerHost(options, inputFiles, inputDirectories), this.oldPrograms.get(projectKey));
-            this.oldPrograms.set(projectKey, program);
-
-            // A JavaScriptTypeMapping deduplicates by `ts.Type.id`, which is only unique within
-            // the TypeChecker that issued it, so each program needs its own.
-            compiled.set(projectKey, {program, typeMapping: new JavaScriptTypeMapping(program.getTypeChecker(), this.relativeTo)});
-        }
+        // Each project's program holds its own copy of the standard library and of every dependency
+        // it reaches, a multiple of the sources it is built for. A repository of many projects cannot
+        // afford them all at once, so only one that is alone in its parse is kept for the next.
+        const carryForward = projects.size === 1;
 
         for (const [sourcePath, input] of inputFiles) {
-            const {program, typeMapping} = compiled.get(projectOf.get(sourcePath)!)!;
-            const filePath = parserInputFile(input);
-            const sourceFile = program.getSourceFile(filePath);
-            if (!sourceFile) {
-                yield this.error(input, new Error('Parser returned undefined'));
-                continue;
-            }
+            // Mapped by a call rather than inline: what a generator holds at a `yield` stays reachable
+            // until it is resumed, and here that would be the program of a project already finished.
+            yield await this.parseInput(input, projectOf.get(sourcePath)!, carryForward, inputFiles, inputDirectories);
+        }
+    }
 
-            if (hasFlowAnnotation(sourceFile)) {
-                yield this.error(input, new FlowSyntaxNotSupportedError("Flow syntax not supported"));
-                continue;
-            }
+    private async parseInput(input: ParserInput, project: Project, carryForward: boolean,
+                             inputFiles: Map<SourcePath, ParserInput>,
+                             inputDirectories: Set<string>): Promise<SourceFile> {
+        // Built when the first of a project's inputs comes up and let go with its last, so that the
+        // programs alive at any one time are those of the projects still being worked through.
+        const {program, typeMapping} = project.compiled ??=
+            this.compile(project, carryForward, inputFiles, inputDirectories);
+        if (--project.unmapped === 0) {
+            project.compiled = undefined;
+        }
 
-            const syntaxErrors = checkSyntaxErrors(program, sourceFile);
-            if (syntaxErrors.length > 0) {
-                let errors = syntaxErrors.map(e => `${e[0]} [${e[1]}]`).join('; ');
-                yield this.error(input, new SyntaxError(`Compiler error(s): ${errors}`));
-                continue;
-            }
+        const filePath = parserInputFile(input);
+        const sourceFile = program.getSourceFile(filePath);
+        if (!sourceFile) {
+            return this.error(input, new Error('Parser returned undefined'));
+        }
 
-            try {
-                yield await this.requirePrintEqualsInput(produce(
-                    new JavaScriptParserVisitor(sourceFile, this.relativePath(input), typeMapping)
-                        .visit(sourceFile) as SourceFile,
-                    draft => {
-                        if (this.styles) {
-                            draft.markers = this.styles.reduce((m, s) => replaceMarkerByKind(m, s), draft.markers);
-                        }
-                    }), input, escapeLoneSurrogates(sourceFile.getFullText()));
-            } catch (error) {
-                yield this.error(input, error instanceof Error ? error : new Error('Parser threw unknown error: ' + error));
-            }
+        if (hasFlowAnnotation(sourceFile)) {
+            return this.error(input, new FlowSyntaxNotSupportedError("Flow syntax not supported"));
+        }
+
+        const syntaxErrors = checkSyntaxErrors(program, sourceFile);
+        if (syntaxErrors.length > 0) {
+            let errors = syntaxErrors.map(e => `${e[0]} [${e[1]}]`).join('; ');
+            return this.error(input, new SyntaxError(`Compiler error(s): ${errors}`));
+        }
+
+        try {
+            return await this.requirePrintEqualsInput(produce(
+                new JavaScriptParserVisitor(sourceFile, this.relativePath(input), typeMapping)
+                    .visit(sourceFile) as SourceFile,
+                draft => {
+                    if (this.styles) {
+                        draft.markers = this.styles.reduce((m, s) => replaceMarkerByKind(m, s), draft.markers);
+                    }
+                }), input, escapeLoneSurrogates(sourceFile.getFullText()));
+        } catch (error) {
+            return this.error(input, error instanceof Error ? error : new Error('Parser threw unknown error: ' + error));
+        }
+    }
+
+    private compile(project: Project, carryForward: boolean, inputFiles: Map<SourcePath, ParserInput>,
+                    inputDirectories: Set<string>): CompiledProject {
+        // TypeScript carries the previous program's bound files forward when the root paths match,
+        // so a parser held across parses of one path costs a fraction of a freshly built one.
+        const program = ts.createProgram(project.rootNames, project.options,
+            this.createCompilerHost(project.options, inputFiles, inputDirectories), this.oldPrograms.get(project.key));
+        if (carryForward) {
+            this.oldPrograms.set(project.key, program);
+        } else {
+            this.oldPrograms.delete(project.key);
         }
+
+        // A JavaScriptTypeMapping deduplicates by `ts.Type.id`, which is only unique within
+        // the TypeChecker that issued it, so each program needs its own.
+        return {program, typeMapping: new JavaScriptTypeMapping(program.getTypeChecker(), this.relativeTo)};
     }
 
     private createCompilerHost(compilerOptions: ts.CompilerOptions, inputFiles: Map<SourcePath, ParserInput>,

package/src/rpc/message-encoder.ts

@@ -91,31 +91,54 @@ export function* jsonFragments(value: unknown): Generator<string> {
     yield JSON.stringify(value) as string;
 }
 
+/**
+ * Streams {@link jsonFragments} into Buffers so that no more than one flush window is a JS string
+ * at a time, raising the outbound ceiling from V8's String.kMaxLength to Node's Buffer.MAX_LENGTH.
+ * Content-Length still needs the whole body up front, so this is a ceiling raise and not true
+ * streaming.
+ *
+ * Exported because {@link chunkedJsonEncoder} reaches it only above the cap: a test of the walk has
+ * to call it directly.
+ */
+export function encodeFragmented(msg: unknown, charset: BufferEncoding): Buffer {
+    const buffers: Buffer[] = [];
+    let pending = "";
+    for (const fragment of jsonFragments(msg)) {
+        pending += fragment;
+        if (pending.length >= FLUSH_THRESHOLD) {
+            buffers.push(Buffer.from(pending, charset));
+            pending = "";
+        }
+    }
+    if (pending.length > 0) {
+        buffers.push(Buffer.from(pending, charset));
+    }
+    return Buffer.concat(buffers);
+}
+
 /**
  * A drop-in replacement for vscode-jsonrpc's default `application/json` content-type encoder that
- * serializes a message to UTF-8 bytes without ever materializing the whole document as a single JS
- * string. The default encoder does {@code Buffer.from(JSON.stringify(msg))}; a large enough
- * PrepareRecipe response (a deep recipe tree) overflows V8's single-string limit and throws
- * "RangeError: Invalid string length", hanging the RPC call. Streaming the
- * fragments into a Buffer raises the ceiling to Node's Buffer.MAX_LENGTH (multiple GB) while
- * producing byte-identical output. (True unbounded streaming needs chunked framing — Content-Length
- * still requires the whole body up front — so this is a ceiling raise, not a removal.)
+ * keeps a message serializable past V8's single-string limit. The default encoder does {@code
+ * Buffer.from(JSON.stringify(msg))}; a large enough PrepareRecipe response (a deep recipe tree)
+ * overflows that limit and throws "RangeError: Invalid string length", hanging the RPC call.
+ *
+ * Below the limit it takes the default's own single-string path: {@link encodeFragmented} would
+ * assemble exactly that string anyway, at a yield per scalar, key and structural token to get
+ * there — ~5x slower on a thousand-element batch. Only a message that cannot be one string pays
+ * for the walk, as {@link chunkedJsonDecoder} does inbound.
  */
 export const chunkedJsonEncoder: JsonRpcContentTypeEncoder = {
     name: "application/json",
     encode(msg: Message, options: { charset: BufferEncoding }): Promise<Uint8Array> {
-        const buffers: Buffer[] = [];
-        let pending = "";
-        for (const fragment of jsonFragments(msg)) {
-            pending += fragment;
-            if (pending.length >= FLUSH_THRESHOLD) {
-                buffers.push(Buffer.from(pending, options.charset));
-                pending = "";
+        try {
+            return Promise.resolve(Buffer.from(JSON.stringify(msg), options.charset));
+        } catch (err) {
+            // A cycle or a bigint is a TypeError the walk cannot serialize either — and would meet
+            // by recursing until the stack ended. Only the string limit is worth a second attempt.
+            if (!(err instanceof RangeError)) {
+                return Promise.reject(err);
             }
         }
-        if (pending.length > 0) {
-            buffers.push(Buffer.from(pending, options.charset));
-        }
-        return Promise.resolve(Buffer.concat(buffers));
+        return Promise.resolve(encodeFragmented(msg, options.charset));
     }
 };

package/src/rpc/request/dependency-types.ts

@@ -29,14 +29,15 @@ type ExportedTypes = typeof import("../../javascript/package-exported-types.js")
 
 /**
  * Handle a DependencyTypes request: resolve one dependency, named by its npm coordinate, against
- * the most recently parsed project's node_modules, enumerate its public types, and stream them
- * back terminated by END_OF_OBJECT. Built once, returned in {@code batchSize} slices across the
- * client's repeated pulls. A {@code null} version names a TypeScript runtime declaration file
- * (e.g. {@code lib.dom}) instead of an installed package.
+ * the node_modules of {@code path} or else of the most recently parsed project, enumerate its
+ * public types, and stream them back terminated by END_OF_OBJECT. Built once, returned in
+ * {@code batchSize} slices across the client's repeated pulls. A {@code null} version names a
+ * TypeScript runtime declaration file (e.g. {@code lib.dom}) instead of an installed package.
  */
 export class DependencyTypes {
     constructor(private readonly name: string,
-                private readonly version?: string | null) {
+                private readonly version?: string | null,
+                private readonly path?: string | null) {
     }
 
     static handle(connection: rpc.MessageConnection, batchSize: number, metricsCsv?: string): void {
@@ -51,15 +52,17 @@ export class DependencyTypes {
                 metricsCsv,
                 (context) => async (request) => {
                     const version = request.version ?? null;
+                    const projectDir = request.path ?? null;
                     context.target = version ? `${request.name}@${version}` : request.name;
 
-                    const key = JSON.stringify([request.name, version]);
+                    const key = JSON.stringify([request.name, version, projectDir]);
                     if (!pending.has(key)) {
                         // Dynamic import to break the circular dependency with the javascript module.
                         const {exportedTypes} = await import("../../javascript/package-exported-types.js");
-                        const types = version !== null
-                            ? packageTypes(request.name, exportedTypes)
-                            : exportedTypes([runtimeLibFile(request.name)], []);
+                        const types = version === null
+                            ? exportedTypes([runtimeLibFile(request.name)], [])
+                            : packageTypes(request.name, exportedTypes,
+                                projectDir === null ? projectNodeModules() : path.join(projectDir, "node_modules"));
 
                         const q = new RpcSendQueue(new ReferenceMap(), JAVA_TYPE_CLASS, false);
                         const sender = new JavaSender();
@@ -98,8 +101,7 @@ function projectNodeModules(): string {
 }
 
 /** The installed package's own types, falling back to its DefinitelyTyped package when it ships none. */
-function packageTypes(name: string, exportedTypes: ExportedTypes): Type.FullyQualified[] {
-    const nodeModules = projectNodeModules();
+function packageTypes(name: string, exportedTypes: ExportedTypes, nodeModules: string): Type.FullyQualified[] {
     const pkgDir = path.join(nodeModules, ...name.split("/"));
     if (!fs.existsSync(pkgDir)) {
         throw new Error(`Package '${name}' is not installed under ${nodeModules}`);