@openrewrite/rewrite 8.88.0 → 8.88.2

package/src/javascript/package-exported-types.ts

@@ -0,0 +1,351 @@
+/*
+ * Copyright 2026 the original author or authors.
+ * <p>
+ * Licensed under the Moderne Source Available License (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * <p>
+ * https://docs.moderne.io/licensing/moderne-source-available-license
+ * <p>
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import ts from "typescript";
+import * as path from "path";
+import {Type} from "../java";
+import {JavaScriptTypeMapping} from "./type-mapping";
+
+// Free functions are not exported-type entries; only nominal types (and value modules, which are
+// descended into for nested types) qualify.
+const TYPE_SYMBOL_FLAGS =
+    ts.SymbolFlags.Class |
+    ts.SymbolFlags.Interface |
+    ts.SymbolFlags.Enum |
+    ts.SymbolFlags.TypeAlias |
+    ts.SymbolFlags.ValueModule;
+
+/**
+ * Enumerate the OWN public exported types of one or more npm packages into the engine's
+ * {@link Type} model. The JS analog of the C# {@code AssemblyTypeEnumerator.Enumerate}:
+ * a {@code ts.Program} is rooted at each package's declaration entry, the {@code references}
+ * closure supplies node_modules resolution, and the types each own package exports are
+ * mapped with full members and methods. Types reached transitively come back shallow.
+ *
+ * @param ownArtifacts package directories whose public types should be defined (full bodies)
+ * @param references node_modules roots / sibling packages used only for symbol resolution
+ */
+export function exportedTypes(ownArtifacts: string[], references: string[]): Type.FullyQualified[] {
+    const entries: string[] = [];
+    for (const artifact of ownArtifacts) {
+        const entry = declarationFileEntry(artifact) ?? resolvePackageEntry(artifact);
+        if (entry) {
+            entries.push(path.normalize(entry));
+        }
+    }
+    if (entries.length === 0) {
+        return [];
+    }
+
+    const compilerOptions: ts.CompilerOptions = {
+        target: ts.ScriptTarget.Latest,
+        module: ts.ModuleKind.CommonJS,
+        moduleResolution: ts.ModuleResolutionKind.Node10,
+        noEmit: true,
+        allowJs: true,
+        checkJs: false,
+        esModuleInterop: true,
+        allowSyntheticDefaultImports: true,
+        skipLibCheck: true,
+        forceConsistentCasingInFileNames: false,
+    };
+
+    const host = ts.createCompilerHost(compilerOptions);
+    // Default node resolution from each file's on-disk location, falling back to the
+    // explicit reference roots when a dependency isn't co-located with the own package.
+    host.resolveModuleNameLiterals = (moduleLiterals, containingFile) =>
+        moduleLiterals.map(literal => {
+            let resolved = ts.resolveModuleName(literal.text, containingFile, compilerOptions, host);
+            if (!resolved.resolvedModule) {
+                for (const ref of references) {
+                    const probe = ts.resolveModuleName(literal.text, path.join(ref, "__probe__.ts"), compilerOptions, host);
+                    if (probe.resolvedModule) {
+                        resolved = probe;
+                        break;
+                    }
+                }
+            }
+            return resolved;
+        });
+
+    const program = ts.createProgram(entries, compilerOptions, host);
+    const checker = program.getTypeChecker();
+    const typeMapping = new JavaScriptTypeMapping(checker);
+
+    // Lowest arity wins for a given FQN, mirroring the C# byFqn dedup.
+    const byFqn = new Map<string, Type.Class>();
+    const collect = (cls: Type.Class): void => {
+        const fqn = cls.fullyQualifiedName;
+        if (!fqn || fqn === "unknown" || fqn === "<unknown>" || fqn === Type.FUNCTION_TYPE_NAME) {
+            return;
+        }
+        const existing = byFqn.get(fqn);
+        if (!existing || arity(cls) < arity(existing)) {
+            byFqn.set(fqn, cls);
+        }
+    };
+
+    const mapSymbols = (symbols: ts.Symbol[]): void => {
+        for (const symbol of symbols) {
+            // Isolate per-symbol mapping: one throwing export must not abort the coordinate.
+            try {
+                const declNodes = classLikeDeclarations(symbol);
+                if (declNodes.length > 0) {
+                    const cls = typeMapping.declarationType(declNodes[0]);
+                    if (Type.isClass(cls)) {
+                        // Walk every declaration so merged interfaces / class+namespace merges keep
+                        // all their methods; populateMethods dedups by signature across the calls.
+                        for (const declNode of declNodes) {
+                            populateMethods(typeMapping, declNode, cls);
+                        }
+                        collect(cls);
+                    }
+                } else {
+                    // Type aliases / namespaces: keep only those that resolve to a nominal class.
+                    const mapped = typeMapping.exportedType(symbol);
+                    if (Type.isClass(mapped)) {
+                        collect(mapped);
+                    }
+                }
+            } catch (e) {
+                console.warn(`exportedTypes: skipping export '${symbol.getName()}': ${e}`);
+            }
+        }
+    };
+
+    for (const entry of entries) {
+        const sourceFile = program.getSourceFile(entry);
+        if (!sourceFile) {
+            continue;
+        }
+        if (ts.isExternalModule(sourceFile)) {
+            const moduleSymbol = checker.getSymbolAtLocation(sourceFile) ?? (sourceFile as { symbol?: ts.Symbol }).symbol;
+            if (moduleSymbol) {
+                mapSymbols(enumerateTypeSymbols(checker, moduleSymbol));
+            }
+            continue;
+        }
+        // A global script (lib.*.d.ts / ambient .d.ts): globals live in global scope, not on a
+        // module symbol. Enumerate top-level ambient declarations + `declare module` ambients.
+        mapSymbols(globalTypeSymbols(checker, sourceFile));
+        for (const ambient of checker.getAmbientModules()) {
+            if (ambient.declarations?.some(d => d.getSourceFile() === sourceFile)) {
+                mapSymbols(enumerateTypeSymbols(checker, ambient));
+            }
+        }
+    }
+
+    return [...byFqn.values()];
+}
+
+function arity(cls: Type.Class): number {
+    return cls.typeParameters?.length ?? 0;
+}
+
+/** A TypeScript declaration/source FILE (e.g. a `lib.*.d.ts` of ambient globals), used directly as a program entry. */
+function declarationFileEntry(artifact: string): string | undefined {
+    return ts.sys.fileExists(artifact) && /\.[cm]?tsx?$/.test(artifact) ? artifact : undefined;
+}
+
+/** Top-level ambient type declarations of a script (non-module) file — a `lib.*.d.ts`'s globals; namespaces descended for nested types. */
+function globalTypeSymbols(checker: ts.TypeChecker, sourceFile: ts.SourceFile): ts.Symbol[] {
+    const out: ts.Symbol[] = [];
+    const seen = new Set<ts.Symbol>();
+    const push = (name: ts.Node | undefined): void => {
+        const symbol = name ? checker.getSymbolAtLocation(name) : undefined;
+        if (symbol && !seen.has(symbol)) {
+            seen.add(symbol);
+            out.push(symbol);
+        }
+    };
+    const visit = (node: ts.Node): void => {
+        if (ts.isInterfaceDeclaration(node) || ts.isClassDeclaration(node) ||
+            ts.isEnumDeclaration(node) || ts.isTypeAliasDeclaration(node)) {
+            push(node.name);
+        } else if (ts.isModuleDeclaration(node)) {
+            push(node.name);
+            if (node.body && ts.isModuleBlock(node.body)) {
+                node.body.statements.forEach(visit);
+            }
+        }
+    };
+    sourceFile.statements.forEach(visit);
+    return out;
+}
+
+/**
+ * Resolve a package directory to its declaration entry: the package.json `types`/`typings`
+ * field, else the `exports["."]` types condition (modern packages declare types only there),
+ * else a top-level `index.d.ts` (then `index.ts`).
+ */
+function resolvePackageEntry(dir: string): string | undefined {
+    const packageJson = path.join(dir, "package.json");
+    if (ts.sys.fileExists(packageJson)) {
+        try {
+            const pkg = JSON.parse(ts.sys.readFile(packageJson) || "{}");
+            const typesField: unknown = pkg.types ?? pkg.typings;
+            const candidate = typeof typesField === "string"
+                ? typesField
+                : exportsTypesEntry(pkg.exports);
+            if (typeof candidate === "string") {
+                const resolved = path.resolve(dir, candidate);
+                if (ts.sys.fileExists(resolved)) {
+                    return resolved;
+                }
+                if (ts.sys.fileExists(resolved + ".d.ts")) {
+                    return resolved + ".d.ts";
+                }
+            }
+        } catch {
+            // Malformed package.json; fall through to conventional entry points.
+        }
+    }
+    for (const candidate of ["index.d.ts", "index.ts", "index.tsx"]) {
+        const resolved = path.join(dir, candidate);
+        if (ts.sys.fileExists(resolved)) {
+            return resolved;
+        }
+    }
+    return undefined;
+}
+
+/** The declaration file for the package's `.` subpath from its `exports` map, if any. */
+function exportsTypesEntry(exports: unknown): string | undefined {
+    if (typeof exports === "string") {
+        return typesFromCondition(exports);
+    }
+    if (!exports || typeof exports !== "object") {
+        return undefined;
+    }
+    const map = exports as Record<string, unknown>;
+    // `exports["."]`, or the whole object when it is condition-only sugar (no subpath keys).
+    const dot = "." in map
+        ? map["."]
+        : (Object.keys(map).some(k => k.startsWith(".")) ? undefined : map);
+    return dot === undefined ? undefined : typesFromCondition(dot);
+}
+
+/**
+ * Pull a declaration file out of an `exports` condition value: an explicit `types` condition,
+ * else the `types` nested under `import`/`require`/`default`. A bare target string is a runtime
+ * (JS) entry, not types, unless it is itself a declaration file.
+ */
+function typesFromCondition(entry: unknown): string | undefined {
+    if (typeof entry === "string") {
+        return /\.d\.[cm]?ts$/.test(entry) ? entry : undefined;
+    }
+    if (!entry || typeof entry !== "object") {
+        return undefined;
+    }
+    const o = entry as Record<string, unknown>;
+    if (typeof o.types === "string") {
+        return o.types;
+    }
+    const nestedTypes = typesFromCondition(o.types);
+    if (nestedTypes) {
+        return nestedTypes;
+    }
+    for (const cond of ["import", "require", "default"]) {
+        const nested = typesFromCondition(o[cond]);
+        if (nested) {
+            return nested;
+        }
+    }
+    return undefined;
+}
+
+/**
+ * The exported symbols of a module that name a type, resolving aliases and descending one
+ * level into re-exported namespaces (e.g. `export = SomeNamespace`) to reach nested types.
+ */
+function enumerateTypeSymbols(checker: ts.TypeChecker, moduleSymbol: ts.Symbol): ts.Symbol[] {
+    const out: ts.Symbol[] = [];
+    const seen = new Set<ts.Symbol>();
+    const queue: ts.Symbol[] = [...moduleExports(checker, moduleSymbol)];
+    while (queue.length > 0) {
+        let symbol = queue.shift()!;
+        if (symbol.flags & ts.SymbolFlags.Alias) {
+            symbol = checker.getAliasedSymbol(symbol);
+        }
+        if (seen.has(symbol)) {
+            continue;
+        }
+        seen.add(symbol);
+        if (symbol.flags & TYPE_SYMBOL_FLAGS) {
+            out.push(symbol);
+        }
+        if (symbol.flags & (ts.SymbolFlags.ValueModule | ts.SymbolFlags.NamespaceModule)) {
+            for (const nested of moduleExports(checker, symbol)) {
+                queue.push(nested);
+            }
+        }
+    }
+    return out;
+}
+
+function moduleExports(checker: ts.TypeChecker, symbol: ts.Symbol): ts.Symbol[] {
+    try {
+        return checker.getExportsOfModule(symbol);
+    } catch {
+        const members: ts.Symbol[] = [];
+        symbol.exports?.forEach(s => members.push(s));
+        return members;
+    }
+}
+
+// All class/interface/enum declarations of a symbol. Returns more than one for declaration
+// merging (e.g. two `interface Req {...}` blocks, or a class merged with a namespace).
+function classLikeDeclarations(
+    symbol: ts.Symbol
+): Array<ts.ClassDeclaration | ts.InterfaceDeclaration | ts.EnumDeclaration> {
+    const out: Array<ts.ClassDeclaration | ts.InterfaceDeclaration | ts.EnumDeclaration> = [];
+    for (const declaration of symbol.declarations ?? []) {
+        if (ts.isClassDeclaration(declaration) || ts.isInterfaceDeclaration(declaration) || ts.isEnumDeclaration(declaration)) {
+            out.push(declaration);
+        }
+    }
+    return out;
+}
+
+/**
+ * Populate `classType.methods`, which the normal mapping path leaves empty. Scoped to the
+ * enumerator so parser output is unchanged: walk the declaration's method/constructor nodes,
+ * map each via the public {@link JavaScriptTypeMapping.methodType}, and dedup by signature.
+ */
+function populateMethods(
+    typeMapping: JavaScriptTypeMapping,
+    node: ts.ClassDeclaration | ts.InterfaceDeclaration | ts.EnumDeclaration,
+    classType: Type.Class
+): void {
+    if (!ts.isClassDeclaration(node) && !ts.isInterfaceDeclaration(node)) {
+        return;
+    }
+    const seen = new Set<string>(classType.methods.map(m => Type.signature(m)));
+    for (const member of node.members) {
+        if (ts.isMethodDeclaration(member) || ts.isMethodSignature(member) || ts.isConstructorDeclaration(member)) {
+            const method = typeMapping.methodType(member);
+            if (!method) {
+                continue;
+            }
+            method.declaringType = classType;
+            const sig = Type.signature(method);
+            if (seen.has(sig)) {
+                continue;
+            }
+            seen.add(sig);
+            classType.methods.push(method);
+        }
+    }
+}

package/src/javascript/type-mapping.ts

@@ -197,6 +197,22 @@ export class JavaScriptTypeMapping {
         return classType;
     }
 
+    /**
+     * Map an exported symbol (type alias, namespace, function, ...) to its {@link Type} via the
+     * symbol's declared or value type. Enumerator-only entry point ({@code exportedTypes}) for
+     * exports that are not class/interface/enum declarations; those go through {@link declarationType}.
+     */
+    exportedType(symbol: ts.Symbol): Type | undefined {
+        const target = symbol.flags & ts.SymbolFlags.Alias ? this.checker.getAliasedSymbol(symbol) : symbol;
+        let type: ts.Type | undefined;
+        if (target.flags & (ts.SymbolFlags.Class | ts.SymbolFlags.Interface | ts.SymbolFlags.Enum | ts.SymbolFlags.TypeAlias | ts.SymbolFlags.ValueModule)) {
+            type = this.checker.getDeclaredTypeOfSymbol(target);
+        } else if (target.valueDeclaration) {
+            type = this.checker.getTypeOfSymbolAtLocation(target, target.valueDeclaration);
+        }
+        return type ? this.getType(type) : undefined;
+    }
+
     private getType(type: ts.Type): Type {
         // Check for error types first - these indicate type-checking failures
         // and should not be processed further

package/src/rpc/queue.ts

@@ -130,6 +130,30 @@ export class RpcSendQueue {
         return result;
     }
 
+    /**
+     * Send a bare list (no enclosing object) and return the complete batch terminated by
+     * END_OF_OBJECT. Used by self-contained responses like DependencyTypes, where the peer
+     * drains one list of ref-deduplicated elements rather than a tree.
+     */
+    async generateList<T>(after: T[] | undefined,
+                          id: (value: T) => any,
+                          onChange: (value: T) => Promise<any>): Promise<RpcObjectData[]> {
+        await this.sendList(after, undefined, id, onChange);
+        return this.finish();
+    }
+
+    /**
+     * Terminate a hand-composed batch: append END_OF_OBJECT and return the accumulated data,
+     * resetting the queue. Lets a caller emit several {@link sendList}s into one stream that the
+     * peer drains as consecutive lists (e.g. DependencyTypes sends its FQN list then its type list).
+     */
+    finish(): RpcObjectData[] {
+        const result = this.q;
+        result.push({state: RpcObjectState.END_OF_OBJECT});
+        this.q = [];
+        return result;
+    }
+
     private put(d: RpcObjectData): void {
         if (this.trace) {
             d.trace = trace("Sender");
@@ -163,6 +187,12 @@ export class RpcSendQueue {
                 await this.add(after, onChange);
             } else if (after === undefined) {
                 this.put({state: RpcObjectState.DELETE});
+            } else if (isRef(after)) {
+                // A ref-deduplicated slot is resolved by the receiver against a persistent cache whose
+                // instance may be aliased by any number of other slots and source files. A CHANGE would
+                // be applied to that shared instance in place, corrupting every alias, so the new value
+                // is re-added instead; the refs map collapses repeats of it into ref-only ADDs.
+                await this.add(after, onChange);
             } else {
                 let afterCodec = onChange ? undefined : RpcCodecs.forInstance(after, this.sourceFileType);
                 this.put({state: RpcObjectState.CHANGE, value: onChange || afterCodec ? undefined : after});
@@ -191,12 +221,16 @@ export class RpcSendQueue {
                     const aBefore = before?.[beforePos];
                     if (aBefore === anAfter) {
                         this.put({state: RpcObjectState.NO_CHANGE});
-                    } else if (anAfter !== undefined && this.typesAreDifferent(anAfter, aBefore)) {
-                        // Type changed - treat as ADD
+                    } else if (anAfter !== undefined && (isRef(anAfter) || this.typesAreDifferent(anAfter, aBefore))) {
+                        // Type changed - treat as ADD. Ref-deduplicated items are also always
+                        // re-added rather than CHANGEd (see send()).
                         await this.add(anAfter, onChangeRun);
                     } else {
-                        this.put({state: RpcObjectState.CHANGE});
-                        await this.doChange(anAfter, aBefore, onChangeRun, RpcCodecs.forInstance(anAfter, this.sourceFileType));
+                        const afterCodec = onChangeRun ? undefined : RpcCodecs.forInstance(anAfter, this.sourceFileType);
+                        // Without an onChange callback or codec, no property messages follow, so the
+                        // value must travel inline (as in send()) or the receiver keeps the stale element
+                        this.put({state: RpcObjectState.CHANGE, value: onChangeRun || afterCodec ? undefined : anAfter});
+                        await this.doChange(anAfter, aBefore, onChangeRun, afterCodec);
                     }
                 }
             }

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

@@ -0,0 +1,128 @@
+/*
+ * Copyright 2026 the original author or authors.
+ * <p>
+ * Licensed under the Moderne Source Available License (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * <p>
+ * https://docs.moderne.io/licensing/moderne-source-available-license
+ * <p>
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import * as rpc from "vscode-jsonrpc/node";
+import * as fs from "fs";
+import * as path from "path";
+import {RpcObjectData, RpcSendQueue} from "../queue";
+import {ReferenceMap, asRef} from "../../reference";
+import {JavaSender} from "../../java/rpc";
+import {Type} from "../../java";
+import {withMetrics} from "./metrics";
+import {lastParsedProject} from "./last-parsed-project";
+
+const JAVA_TYPE_CLASS = "org.openrewrite.java.tree.JavaType$Class";
+
+type ExportedTypes = typeof import("../../javascript/package-exported-types.js")["exportedTypes"];
+
+/**
+ * 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.
+ */
+export class DependencyTypes {
+    constructor(private readonly name: string,
+                private readonly version?: string | null) {
+    }
+
+    static handle(connection: rpc.MessageConnection, batchSize: number, metricsCsv?: string): void {
+        // Keyed by coordinate: holds the remaining slices of an in-flight
+        // response across the client's repeated pulls. Evicted once fully drained.
+        const pending = new Map<string, RpcObjectData[]>();
+
+        connection.onRequest(
+            new rpc.RequestType<DependencyTypes, RpcObjectData[], Error>("DependencyTypes"),
+            withMetrics<DependencyTypes, RpcObjectData[]>(
+                "DependencyTypes",
+                metricsCsv,
+                (context) => async (request) => {
+                    const version = request.version ?? null;
+                    context.target = version ? `${request.name}@${version}` : request.name;
+
+                    const key = JSON.stringify([request.name, version]);
+                    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 q = new RpcSendQueue(new ReferenceMap(), JAVA_TYPE_CLASS, false);
+                        const sender = new JavaSender();
+                        // FQNs this dependency defines, sent before the types so the caller can tell
+                        // defined types from references up front, then the types themselves.
+                        await q.sendList(types.map(t => Type.FullyQualified.getFullyQualifiedName(t)), undefined, s => s);
+                        await q.sendList(
+                            types.map(t => asRef(t)),
+                            undefined,
+                            t => Type.signature(t),
+                            async t => {
+                                await sender.visitType(t, q);
+                            }
+                        );
+                        pending.set(key, q.finish());
+                    }
+
+                    const data = pending.get(key)!;
+                    const batch = data.splice(0, batchSize);
+                    if (data.length === 0) {
+                        pending.delete(key);
+                    }
+                    return batch;
+                }
+            )
+        );
+    }
+}
+
+function projectNodeModules(): string {
+    const project = lastParsedProject();
+    if (!project) {
+        throw new Error("No project has been parsed yet; cannot resolve a dependency coordinate");
+    }
+    return path.join(project, "node_modules");
+}
+
+/** 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();
+    const pkgDir = path.join(nodeModules, ...name.split("/"));
+    if (!fs.existsSync(pkgDir)) {
+        throw new Error(`Package '${name}' is not installed under ${nodeModules}`);
+    }
+    const types = exportedTypes([pkgDir], []);
+    if (types.length > 0) {
+        return types;
+    }
+    // @scope/pkg -> @types/scope__pkg
+    const typesDir = path.join(nodeModules, "@types",
+        name.startsWith("@") ? name.slice(1).replace("/", "__") : name);
+    return fs.existsSync(typesDir) ? exportedTypes([typesDir], []) : types;
+}
+
+/** A runtime declaration file (e.g. lib.dom.d.ts): the project's installed TypeScript first, else the engine's own. */
+function runtimeLibFile(name: string): string {
+    for (const lib of [
+        path.join(projectNodeModules(), "typescript", "lib", `${name}.d.ts`),
+        path.join(path.dirname(require.resolve("typescript")), `${name}.d.ts`),
+    ]) {
+        if (fs.existsSync(lib)) {
+            return lib;
+        }
+    }
+    throw new Error(`No TypeScript declaration file for '${name}'`);
+}

package/src/rpc/request/index.ts

@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+export * from "./dependency-types";
 export * from "./generate";
 export * from "./get-object";
 export * from "./get-marketplace";

package/src/rpc/request/last-parsed-project.ts

@@ -0,0 +1,27 @@
+/*
+ * Copyright 2026 the original author or authors.
+ * <p>
+ * Licensed under the Moderne Source Available License (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * <p>
+ * https://docs.moderne.io/licensing/moderne-source-available-license
+ * <p>
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ParseProject records the most recently parsed project here; DependencyTypes
+// resolves npm coordinates against its node_modules tree.
+let projectDir: string | undefined;
+
+export function setLastParsedProject(dir: string): void {
+    projectDir = dir;
+}
+
+export function lastParsedProject(): string | undefined {
+    return projectDir;
+}

package/src/rpc/request/parse-project.ts

@@ -21,6 +21,7 @@ import {SourceFile} from "../../tree";
 import {Parsers} from "../../parser";
 import {withMetrics} from "./metrics";
 import {replaceMarkerByKind} from "../../markers";
+import {setLastParsedProject} from "./last-parsed-project";
 
 /**
  * Response item with object ID and source file type for proper deserialization.
@@ -74,6 +75,7 @@ export class ParseProject {
                     const {DEFAULT_EXCLUSIONS, ProjectParser} = await import("../../javascript/index.js");
 
                     const projectPath = path.resolve(request.projectPath);
+                    setLastParsedProject(projectPath);
                     const exclusions = request.exclusions ?? DEFAULT_EXCLUSIONS;
                     // Use relativeTo if specified, otherwise default to projectPath
                     const relativeTo = request.relativeTo ? path.resolve(request.relativeTo) : projectPath;

package/src/rpc/rewrite-rpc.ts

@@ -19,6 +19,7 @@ import {Cursor, isSourceFile, isTree, rootCursor, SourceFile, Tree} from "../tre
 import {Recipe} from "../recipe";
 import {SnowflakeId} from "@akashrajpurohit/snowflake-id";
 import {
+    DependencyTypes,
     Generate,
     GenerateResponse,
     GetObject,
@@ -142,6 +143,7 @@ export class RewriteRpc {
         PrepareRecipe.handle(this.connection, marketplace, preparedRecipes, options.metricsCsv);
         Parse.handle(this.connection, this.localObjects, options.metricsCsv);
         ParseProject.handle(this.connection, this.localObjects, options.metricsCsv);
+        DependencyTypes.handle(this.connection, options?.batchSize || 1000, options.metricsCsv);
         Print.handle(this.connection, getObject, options.logger, options.metricsCsv);
         InstallRecipes.handle(this.connection, options.recipeInstallDir ?? ".rewrite", marketplace, recipeOrigin, options.logger, options.metricsCsv);