@openrewrite/rewrite 8.91.3 → 8.91.4

package/dist/javascript/tsconfig.d.ts

@@ -0,0 +1,32 @@
+import ts from "typescript";
+export interface ResolvedTsConfig {
+    /**
+     * Absolute path of the config file the options came from. Undefined when no project
+     * config applied, in which case {@link options} are the parser's defaults.
+     */
+    readonly configFilePath?: string;
+    readonly options: ts.CompilerOptions;
+}
+/**
+ * Finds the config file governing each file and merges its resolution options over a set of
+ * parser defaults, so that type-aware recipes see the same modules `tsc` would.
+ */
+export declare class TsConfigResolver {
+    private readonly defaults;
+    private readonly configByDir;
+    private readonly optionsByConfig;
+    private readonly root?;
+    /**
+     * @param defaults Options to fall back on, and to merge a project config over.
+     * @param relativeTo Root of the project being parsed, bounding the search. Without one,
+     *   walking up from the process working directory picks up whatever config sits above it.
+     */
+    constructor(defaults: ts.CompilerOptions, relativeTo?: string);
+    forFile(filePath: string): ResolvedTsConfig;
+    /** The nearest config file at or below the project root, searching upwards. */
+    private findConfig;
+    private optionsFor;
+    /** Undefined where the config cannot be read, leaving the caller on its defaults. */
+    private merge;
+}
+//# sourceMappingURL=tsconfig.d.ts.map

package/dist/javascript/tsconfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tsconfig.d.ts","sourceRoot":"","sources":["../../src/javascript/tsconfig.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,MAAM,YAAY,CAAC;AA+B5B,MAAM,WAAW,gBAAgB;IAC7B;;;OAGG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,OAAO,EAAE,EAAE,CAAC,eAAe,CAAC;CACxC;AAED;;;GAGG;AACH,qBAAa,gBAAgB;IAUb,OAAO,CAAC,QAAQ,CAAC,QAAQ;IATrC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAyC;IACrE,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAqD;IACrF,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAS;IAE/B;;;;OAIG;gBAC0B,QAAQ,EAAE,EAAE,CAAC,eAAe,EAAE,UAAU,CAAC,EAAE,MAAM;IAI9E,OAAO,CAAC,QAAQ,EAAE,MAAM,GAAG,gBAAgB;IAM3C,+EAA+E;IAC/E,OAAO,CAAC,UAAU;IA+BlB,OAAO,CAAC,UAAU;IAOlB,qFAAqF;IACrF,OAAO,CAAC,KAAK;CAmChB"}

package/dist/javascript/tsconfig.js

@@ -0,0 +1,205 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TsConfigResolver = void 0;
+/*
+ * Copyright 2025 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.
+ */
+const typescript_1 = __importDefault(require("typescript"));
+const path = __importStar(require("path"));
+/**
+ * What a project gets to decide: where a module specifier resolves to, and which ambient
+ * declarations are in scope. The shape of the types themselves stays with the parser — `target`
+ * and `lib` bound the global scope, `strict` adds a `null` to every nullable type — which pins
+ * the widest view it can rather than the one a project compiles against.
+ */
+const RESOLUTION_OPTIONS = [
+    "baseUrl",
+    "paths",
+    // Internal companion to `paths`: the directory its entries resolve against.
+    "pathsBasePath",
+    "rootDirs",
+    "types",
+    "typeRoots",
+    "moduleResolution",
+    "moduleSuffixes",
+    "customConditions",
+    "resolvePackageJsonExports",
+    "resolvePackageJsonImports",
+    "resolveJsonModule",
+];
+/**
+ * Config file names in precedence order. TypeScript reads jsconfig.json for JavaScript
+ * projects, which is where a JS-only codebase states its `paths`.
+ */
+const CONFIG_FILE_NAMES = ["tsconfig.json", "jsconfig.json"];
+/**
+ * Finds the config file governing each file and merges its resolution options over a set of
+ * parser defaults, so that type-aware recipes see the same modules `tsc` would.
+ */
+class TsConfigResolver {
+    /**
+     * @param defaults Options to fall back on, and to merge a project config over.
+     * @param relativeTo Root of the project being parsed, bounding the search. Without one,
+     *   walking up from the process working directory picks up whatever config sits above it.
+     */
+    constructor(defaults, relativeTo) {
+        this.defaults = defaults;
+        this.configByDir = new Map();
+        this.optionsByConfig = new Map();
+        this.root = relativeTo ? path.resolve(relativeTo) : undefined;
+    }
+    forFile(filePath) {
+        const configFilePath = this.findConfig(path.dirname(path.resolve(filePath)));
+        const options = configFilePath === undefined ? undefined : this.optionsFor(configFilePath);
+        return options === undefined ? { options: this.defaults } : { configFilePath, options };
+    }
+    /** The nearest config file at or below the project root, searching upwards. */
+    findConfig(from) {
+        if (!this.root || !isAtOrUnder(from, this.root)) {
+            return undefined;
+        }
+        const searched = [];
+        const memoize = (found) => {
+            for (const dir of searched) {
+                this.configByDir.set(dir, found);
+            }
+            return found;
+        };
+        for (let dir = from;; dir = path.dirname(dir)) {
+            if (this.configByDir.has(dir)) {
+                return memoize(this.configByDir.get(dir));
+            }
+            searched.push(dir);
+            for (const configFileName of CONFIG_FILE_NAMES) {
+                const candidate = path.join(dir, configFileName);
+                if (typescript_1.default.sys.fileExists(candidate)) {
+                    return memoize(candidate);
+                }
+            }
+            if (dir === this.root || path.dirname(dir) === dir) {
+                return memoize(undefined);
+            }
+        }
+    }
+    optionsFor(configFilePath) {
+        if (!this.optionsByConfig.has(configFilePath)) {
+            this.optionsByConfig.set(configFilePath, this.merge(configFilePath));
+        }
+        return this.optionsByConfig.get(configFilePath);
+    }
+    /** Undefined where the config cannot be read, leaving the caller on its defaults. */
+    merge(configFilePath) {
+        let projectOptions;
+        try {
+            const { config, error } = typescript_1.default.readConfigFile(configFilePath, typescript_1.default.sys.readFile);
+            if (error || !config) {
+                return undefined;
+            }
+            // `readDirectory` answers empty because only `options` is read here; left to `ts.sys` it
+            // walks the whole tree under the config to build a file list, once per config found.
+            const parseConfigHost = Object.assign(Object.assign({}, typescript_1.default.sys), { readDirectory: () => [] });
+            projectOptions = typescript_1.default.parseJsonConfigFileContent(config, parseConfigHost, path.dirname(configFilePath), undefined, configFilePath).options;
+        }
+        catch (_a) {
+            return undefined;
+        }
+        // A project's `baseUrl` stands alone, including where it states none: `baseUrl` takes
+        // precedence over `pathsBasePath`, so a default rooted at the repository would resolve a
+        // nested project's `paths` against the wrong directory.
+        const _b = this.defaults, { baseUrl: _ } = _b, defaults = __rest(_b, ["baseUrl"]);
+        const resolution = {};
+        for (const option of RESOLUTION_OPTIONS) {
+            if (projectOptions[option] !== undefined) {
+                resolution[option] = projectOptions[option];
+            }
+        }
+        if (resolution.moduleResolution === undefined) {
+            const paired = pairedModuleResolution(projectOptions);
+            if (paired !== undefined) {
+                resolution.moduleResolution = paired;
+            }
+        }
+        return Object.assign(Object.assign({}, defaults), resolution);
+    }
+}
+exports.TsConfigResolver = TsConfigResolver;
+/**
+ * The resolution TypeScript infers for a project that states only its `module`. Only the
+ * inference is adopted, since a module kind such as `node16` classifies files as CJS or ESM,
+ * and an ESM-only import from a CJS file is then the error TS1479, costing the file its LST.
+ * `Classic` is declined as well, searching no `node_modules`, so the default stands in.
+ */
+function pairedModuleResolution(projectOptions) {
+    const infer = typescript_1.default
+        .getEmitModuleResolutionKind;
+    if (projectOptions.module === undefined || !infer) {
+        return undefined;
+    }
+    const inferred = infer(projectOptions);
+    return inferred === typescript_1.default.ModuleResolutionKind.Classic ? undefined : inferred;
+}
+function isAtOrUnder(dir, root) {
+    const relative = path.relative(root, dir);
+    return relative === "" ||
+        (relative !== ".." && !relative.startsWith(".." + path.sep) && !path.isAbsolute(relative));
+}
+//# sourceMappingURL=tsconfig.js.map

package/dist/javascript/tsconfig.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tsconfig.js","sourceRoot":"","sources":["../../src/javascript/tsconfig.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;;;;;;;;;;;;;GAcG;AACH,4DAA4B;AAC5B,2CAA6B;AAE7B;;;;;GAKG;AACH,MAAM,kBAAkB,GAAa;IACjC,SAAS;IACT,OAAO;IACP,4EAA4E;IAC5E,eAAe;IACf,UAAU;IACV,OAAO;IACP,WAAW;IACX,kBAAkB;IAClB,gBAAgB;IAChB,kBAAkB;IAClB,2BAA2B;IAC3B,2BAA2B;IAC3B,mBAAmB;CACtB,CAAC;AAEF;;;GAGG;AACH,MAAM,iBAAiB,GAAG,CAAC,eAAe,EAAE,eAAe,CAAC,CAAC;AAW7D;;;GAGG;AACH,MAAa,gBAAgB;IAKzB;;;;OAIG;IACH,YAA6B,QAA4B,EAAE,UAAmB;QAAjD,aAAQ,GAAR,QAAQ,CAAoB;QATxC,gBAAW,GAAG,IAAI,GAAG,EAA8B,CAAC;QACpD,oBAAe,GAAG,IAAI,GAAG,EAA0C,CAAC;QASjF,IAAI,CAAC,IAAI,GAAG,UAAU,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;IAClE,CAAC;IAED,OAAO,CAAC,QAAgB;QACpB,MAAM,cAAc,GAAG,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;QAC7E,MAAM,OAAO,GAAG,cAAc,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,cAAc,CAAC,CAAC;QAC3F,OAAO,OAAO,KAAK,SAAS,CAAC,CAAC,CAAC,EAAC,OAAO,EAAE,IAAI,CAAC,QAAQ,EAAC,CAAC,CAAC,CAAC,EAAC,cAAc,EAAE,OAAO,EAAC,CAAC;IACxF,CAAC;IAED,+EAA+E;IACvE,UAAU,CAAC,IAAY;QAC3B,IAAI,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,WAAW,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;YAC9C,OAAO,SAAS,CAAC;QACrB,CAAC;QAED,MAAM,QAAQ,GAAa,EAAE,CAAC;QAC9B,MAAM,OAAO,GAAG,CAAC,KAAyB,EAAE,EAAE;YAC1C,KAAK,MAAM,GAAG,IAAI,QAAQ,EAAE,CAAC;gBACzB,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;YACrC,CAAC;YACD,OAAO,KAAK,CAAC;QACjB,CAAC,CAAC;QAEF,KAAK,IAAI,GAAG,GAAG,IAAI,GAAI,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC;YAC7C,IAAI,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;gBAC5B,OAAO,OAAO,CAAC,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC;YAC9C,CAAC;YACD,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;YAEnB,KAAK,MAAM,cAAc,IAAI,iBAAiB,EAAE,CAAC;gBAC7C,MAAM,SAAS,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,cAAc,CAAC,CAAC;gBACjD,IAAI,oBAAE,CAAC,GAAG,CAAC,UAAU,CAAC,SAAS,CAAC,EAAE,CAAC;oBAC/B,OAAO,OAAO,CAAC,SAAS,CAAC,CAAC;gBAC9B,CAAC;YACL,CAAC;YACD,IAAI,GAAG,KAAK,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,GAAG,EAAE,CAAC;gBACjD,OAAO,OAAO,CAAC,SAAS,CAAC,CAAC;YAC9B,CAAC;QACL,CAAC;IACL,CAAC;IAEO,UAAU,CAAC,cAAsB;QACrC,IAAI,CAAC,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,cAAc,CAAC,EAAE,CAAC;YAC5C,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,cAAc,EAAE,IAAI,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC,CAAC;QACzE,CAAC;QACD,OAAO,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC;IACpD,CAAC;IAED,qFAAqF;IAC7E,KAAK,CAAC,cAAsB;QAChC,IAAI,cAAkC,CAAC;QACvC,IAAI,CAAC;YACD,MAAM,EAAC,MAAM,EAAE,KAAK,EAAC,GAAG,oBAAE,CAAC,cAAc,CAAC,cAAc,EAAE,oBAAE,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;YAC3E,IAAI,KAAK,IAAI,CAAC,MAAM,EAAE,CAAC;gBACnB,OAAO,SAAS,CAAC;YACrB,CAAC;YACD,yFAAyF;YACzF,qFAAqF;YACrF,MAAM,eAAe,mCAA2B,oBAAE,CAAC,GAAG,KAAE,aAAa,EAAE,GAAG,EAAE,CAAC,EAAE,GAAC,CAAC;YACjF,cAAc,GAAG,oBAAE,CAAC,0BAA0B,CAC1C,MAAM,EAAE,eAAe,EAAE,IAAI,CAAC,OAAO,CAAC,cAAc,CAAC,EAAE,SAAS,EAAE,cAAc,CAAC,CAAC,OAAO,CAAC;QAClG,CAAC;QAAC,WAAM,CAAC;YACL,OAAO,SAAS,CAAC;QACrB,CAAC;QAED,sFAAsF;QACtF,yFAAyF;QACzF,wDAAwD;QACxD,MAAM,KAA4B,IAAI,CAAC,QAAQ,EAAzC,EAAC,OAAO,EAAE,CAAC,OAA8B,EAAzB,QAAQ,cAAxB,WAAyB,CAAgB,CAAC;QAEhD,MAAM,UAAU,GAAuB,EAAE,CAAC;QAC1C,KAAK,MAAM,MAAM,IAAI,kBAAkB,EAAE,CAAC;YACtC,IAAI,cAAc,CAAC,MAAM,CAAC,KAAK,SAAS,EAAE,CAAC;gBACvC,UAAU,CAAC,MAAM,CAAC,GAAG,cAAc,CAAC,MAAM,CAAC,CAAC;YAChD,CAAC;QACL,CAAC;QACD,IAAI,UAAU,CAAC,gBAAgB,KAAK,SAAS,EAAE,CAAC;YAC5C,MAAM,MAAM,GAAG,sBAAsB,CAAC,cAAc,CAAC,CAAC;YACtD,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;gBACvB,UAAU,CAAC,gBAAgB,GAAG,MAAM,CAAC;YACzC,CAAC;QACL,CAAC;QACD,uCAAW,QAAQ,GAAK,UAAU,EAAE;IACxC,CAAC;CACJ;AA/FD,4CA+FC;AAED;;;;;GAKG;AACH,SAAS,sBAAsB,CAAC,cAAkC;IAC9D,MAAM,KAAK,GAAI,oBAAqG;SAC/G,2BAA2B,CAAC;IACjC,IAAI,cAAc,CAAC,MAAM,KAAK,SAAS,IAAI,CAAC,KAAK,EAAE,CAAC;QAChD,OAAO,SAAS,CAAC;IACrB,CAAC;IACD,MAAM,QAAQ,GAAG,KAAK,CAAC,cAAc,CAAC,CAAC;IACvC,OAAO,QAAQ,KAAK,oBAAE,CAAC,oBAAoB,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,QAAQ,CAAC;AAC/E,CAAC;AAED,SAAS,WAAW,CAAC,GAAW,EAAE,IAAY;IAC1C,MAAM,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;IAC1C,OAAO,QAAQ,KAAK,EAAE;QAClB,CAAC,QAAQ,KAAK,IAAI,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,CAAC;AACnG,CAAC"}

package/dist/rewrite-javascript-version.txt

@@ -1 +1 @@
-8.91.3
+8.91.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openrewrite/rewrite",
-  "version": "8.91.3",
+  "version": "8.91.4",
   "license": "Moderne Source Available License",
   "description": "OpenRewrite JavaScript.",
   "repository": {

package/src/javascript/parser.ts

@@ -46,6 +46,7 @@ import {
     TextSpan
 } from "./parser-utils";
 import {JavaScriptTypeMapping} from "./type-mapping";
+import {TsConfigResolver} from "./tsconfig";
 import {create as produce} from "mutative";
 import ComputedPropertyName = JS.ComputedPropertyName;
 import Attribute = JSX.Attribute;
@@ -90,9 +91,9 @@ type WithInvalidSyntaxSlots<T> = T & {
 
 export class JavaScriptParser extends Parser {
 
-    private readonly compilerOptions: ts.CompilerOptions;
+    private readonly tsConfig: TsConfigResolver;
     private readonly styles?: NamedStyles[];
-    private oldProgram?: ts.Program;
+    private readonly oldPrograms = new Map<string, ts.Program>();
     private readonly sourceFileCache?: Map<string, ts.SourceFile>;
 
     constructor(
@@ -105,7 +106,7 @@ export class JavaScriptParser extends Parser {
         }: JavaScriptParserOptions = {},
     ) {
         super({ctx, relativeTo});
-        this.compilerOptions = {
+        const defaultCompilerOptions: ts.CompilerOptions = {
             target: ts.ScriptTarget.Latest,
             // Bundler matches `exports` conditions leniently, so packages that publish types only under
             // an `import` condition resolve; it pairs with `preserve`, which `commonjs` cannot (TS5095).
@@ -132,6 +133,7 @@ export class JavaScriptParser extends Parser {
             types: types ?? ["*"],
             baseUrl: relativeTo || process.cwd()
         };
+        this.tsConfig = new TsConfigResolver(defaultCompilerOptions, relativeTo);
         this.styles = styles;
         this.sourceFileCache = sourceFileCache;
     }
@@ -208,12 +210,14 @@ export class JavaScriptParser extends Parser {
     // noinspection JSUnusedGlobalSymbols
     reset(): this {
         this.sourceFileCache && this.sourceFileCache.clear();
-        this.oldProgram = undefined;
+        this.oldPrograms.clear();
         return this;
     }
 
     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[] }>();
 
         // Populate inputFiles map and remove from cache if necessary
         for (const input of inputs) {
@@ -228,8 +232,79 @@ export class JavaScriptParser extends Parser {
             this.sourceFileCache && this.sourceFileCache.delete(normalizedSourcePath);
         }
 
-        // Create a new CompilerHost within parseInputs
-        const host = ts.createCompilerHost(this.compilerOptions);
+        // Packages in a monorepo each configure their own module resolution.
+        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: []});
+            }
+            project.rootNames.push(normalizedSourcePath);
+        }
+
+        // Module resolution probes a directory before the files in it, so a directory holding
+        // nothing but in-memory inputs has to answer too, or those inputs are unreachable.
+        const inputDirectories = new Set<string>();
+        for (const sourcePath of inputFiles.keys()) {
+            for (let dir = path.dirname(sourcePath); !inputDirectories.has(dir); dir = path.dirname(dir)) {
+                inputDirectories.add(dir);
+            }
+        }
+
+        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)});
+        }
+
+        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;
+            }
+
+            if (hasFlowAnnotation(sourceFile)) {
+                yield this.error(input, new FlowSyntaxNotSupportedError("Flow syntax not supported"));
+                continue;
+            }
+
+            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;
+            }
+
+            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));
+            }
+        }
+    }
+
+    private createCompilerHost(compilerOptions: ts.CompilerOptions, inputFiles: Map<SourcePath, ParserInput>,
+                               inputDirectories: Set<string>): ts.CompilerHost {
+        const host = ts.createCompilerHost(compilerOptions);
 
         // Set the current directory for module resolution
         if (this.relativeTo) {
@@ -240,8 +315,13 @@ export class JavaScriptParser extends Parser {
         // Override getSourceFile
         host.getSourceFile = (fileName, languageVersion, onError) => {
             const normalizedFileName = path.normalize(fileName);
+            // A file's module format is baked in when it is created and follows from the requesting
+            // project's `moduleResolution`, so it belongs in the key of a cache several projects share.
+            const cacheKey = typeof languageVersion === 'number' ?
+                normalizedFileName :
+                `${languageVersion.impliedNodeFormat ?? ''}\0${normalizedFileName}`;
             // Check if the SourceFile is in the cache
-            let sourceFile = this.sourceFileCache && this.sourceFileCache.get(normalizedFileName);
+            let sourceFile = this.sourceFileCache && this.sourceFileCache.get(cacheKey);
             if (sourceFile) {
                 return sourceFile;
             }
@@ -276,7 +356,7 @@ export class JavaScriptParser extends Parser {
                 sourceFile = ts.createSourceFile(normalizedFileName, sourceText, sourceFileOptions, true, scriptKind);
                 // Cache the SourceFile if it's a dependency
                 if (!input && this.sourceFileCache) {
-                    this.sourceFileCache.set(normalizedFileName, sourceFile);
+                    this.sourceFileCache.set(cacheKey, sourceFile);
                 }
                 return sourceFile;
             }
@@ -291,6 +371,11 @@ export class JavaScriptParser extends Parser {
             return inputFiles.has(normalizedFileName) || ts.sys.fileExists(normalizedFileName);
         };
 
+        host.directoryExists = (directoryName) => {
+            const normalizedDirectoryName = path.normalize(directoryName);
+            return inputDirectories.has(normalizedDirectoryName) || ts.sys.directoryExists(normalizedDirectoryName);
+        };
+
         // Override readFile
         host.readFile = (fileName) => {
             const normalizedFileName = path.normalize(fileName);
@@ -301,7 +386,7 @@ export class JavaScriptParser extends Parser {
         // Custom module resolution to handle in-memory imports
         // This is required because TypeScript's default module resolution looks for files on disk,
         // but our source files only exist in memory (in the inputFiles map)
-        host.resolveModuleNameLiterals = (moduleLiterals, containingFile) => {
+        host.resolveModuleNameLiterals = (moduleLiterals, containingFile, _redirectedReference, _options, containingSourceFile) => {
             const resolvedModules: ts.ResolvedModuleWithFailedLookupLocations[] = [];
             const normalizedFileName = path.normalize(containingFile);
             const containingDir = path.dirname(normalizedFileName);
@@ -341,12 +426,18 @@ export class JavaScriptParser extends Parser {
                     }
                 }
 
-                // Fall back to TypeScript's default resolution for node_modules and absolute paths
+                // Fall back to TypeScript's default resolution for node_modules and absolute paths.
+                // Passing the usage location's mode keeps export conditions tied to the module kind
+                // pinned above, so every project reads the same branch of a dual package whatever
+                // `moduleResolution` it states.
                 const result = ts.resolveModuleName(
                     moduleName,
                     normalizedFileName,
-                    this.compilerOptions,
-                    host
+                    compilerOptions,
+                    host,
+                    undefined,
+                    undefined,
+                    ts.getModeForUsageLocation(containingSourceFile, moduleLiteral, compilerOptions)
                 );
 
                 resolvedModules.push(result);
@@ -354,52 +445,7 @@ export class JavaScriptParser extends Parser {
             return resolvedModules;
         };
 
-        // 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([...inputFiles.keys()], this.compilerOptions, host, this.oldProgram);
-
-        // Update the oldProgram reference
-        this.oldProgram = program;
-
-        // Create a single JavaScriptTypeMapping instance to be shared across all files in this parse batch.
-        // This ensures that TypeScript types with the same type.id map to the same Type instance,
-        // preventing duplicate Type.Class, Type.Parameterized, etc. instances.
-        const typeChecker = program.getTypeChecker();
-        const typeMapping = new JavaScriptTypeMapping(typeChecker, this.relativeTo);
-
-        for (const input of inputFiles.values()) {
-            const filePath = parserInputFile(input);
-            const sourceFile = program.getSourceFile(filePath);
-            if (!sourceFile) {
-                yield this.error(input, new Error('Parser returned undefined'));
-                continue;
-            }
-
-            if (hasFlowAnnotation(sourceFile)) {
-                yield this.error(input, new FlowSyntaxNotSupportedError("Flow syntax not supported"));
-                continue;
-            }
-
-            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;
-            }
-
-            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));
-            }
-        }
+        return host;
     }
 }