@openrewrite/rewrite 8.63.0 → 8.63.2

package/src/json/visitor.ts

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import {mapAsync} from "../util";
+import {mapAsync, updateIfChanged} from "../util";
 import {produceAsync, TreeVisitor, ValidImmerRecipeReturnType} from "../visitor";
 import {SourceFile} from "../tree";
 import {isJson, Json} from "./tree";
@@ -25,49 +25,74 @@ export class JsonVisitor<P> extends TreeVisitor<Json, P> {
     }
 
     protected async visitArray(array: Json.Array, p: P): Promise<Json | undefined> {
-        return this.produceJson<Json.Array>(array, p, async draft => {
-            draft.values = await mapAsync(array.values, value => this.visitRightPadded(value, p));
-        })
+        const updates: any = {
+            prefix: await this.visitSpace(array.prefix, p),
+            markers: await this.visitMarkers(array.markers, p),
+            values: await mapAsync(array.values, value => this.visitRightPadded(value, p))
+        };
+        return updateIfChanged(array, updates);
     }
 
     protected async visitDocument(document: Json.Document, p: P): Promise<Json | undefined> {
-        return this.produceJson<Json.Document>(document, p, async draft => {
-            draft.value = await this.visitDefined(document.value, p);
-            draft.eof = await this.visitSpace(document.eof, p);
-        })
+        const updates: any = {
+            prefix: await this.visitSpace(document.prefix, p),
+            markers: await this.visitMarkers(document.markers, p),
+            value: await this.visitDefined(document.value, p),
+            eof: await this.visitSpace(document.eof, p)
+        };
+        return updateIfChanged(document, updates);
     }
 
     protected async visitEmpty(empty: Json.Empty, p: P): Promise<Json | undefined> {
-        return this.produceJson(empty, p)
+        const updates: any = {
+            prefix: await this.visitSpace(empty.prefix, p),
+            markers: await this.visitMarkers(empty.markers, p)
+        };
+        return updateIfChanged(empty, updates);
     }
 
     protected async visitIdentifier(identifier: Json.Identifier, p: P): Promise<Json | undefined> {
-        return this.produceJson(identifier, p)
+        const updates: any = {
+            prefix: await this.visitSpace(identifier.prefix, p),
+            markers: await this.visitMarkers(identifier.markers, p)
+        };
+        return updateIfChanged(identifier, updates);
     }
 
     protected async visitLiteral(literal: Json.Literal, p: P): Promise<Json | undefined> {
-        return this.produceJson(literal, p)
+        const updates: any = {
+            prefix: await this.visitSpace(literal.prefix, p),
+            markers: await this.visitMarkers(literal.markers, p)
+        };
+        return updateIfChanged(literal, updates);
     }
 
     protected async visitMember(member: Json.Member, p: P): Promise<Json | undefined> {
-        return this.produceJson<Json.Member>(member, p, async draft => {
-            draft.key = (await this.visitRightPadded(member.key, p))!;
-            draft.value = await this.visitDefined(member.value, p);
-        });
+        const updates: any = {
+            prefix: await this.visitSpace(member.prefix, p),
+            markers: await this.visitMarkers(member.markers, p),
+            key: (await this.visitRightPadded(member.key, p))!,
+            value: await this.visitDefined(member.value, p)
+        };
+        return updateIfChanged(member, updates);
     }
 
     protected async visitObject(jsonObject: Json.Object, p: P): Promise<Json | undefined> {
-        return this.produceJson<Json.Object>(jsonObject, p, async draft => {
-            draft.members = await mapAsync(jsonObject.members, member => this.visitRightPadded(member, p));
-        });
+        const updates: any = {
+            prefix: await this.visitSpace(jsonObject.prefix, p),
+            markers: await this.visitMarkers(jsonObject.markers, p),
+            members: await mapAsync(jsonObject.members, member => this.visitRightPadded(member, p))
+        };
+        return updateIfChanged(jsonObject, updates);
     }
 
     public async visitRightPadded<T extends Json>(right: Json.RightPadded<T>, p: P):
         Promise<Json.RightPadded<T> | undefined> {
-        return produceAsync<Json.RightPadded<T>>(right, async draft => {
-            draft.element = await this.visitDefined(right.element, p);
-            draft.after = await this.visitSpace(right.after, p)
-        });
+        const updates: any = {
+            element: await this.visitDefined(right.element, p),
+            after: await this.visitSpace(right.after, p)
+        };
+        return updateIfChanged(right, updates);
     }
 
     public async visitSpace(space: Json.Space, p: P): Promise<Json.Space> {

package/src/rpc/queue.ts

@@ -13,11 +13,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import * as rpc from "vscode-jsonrpc/node";
 import {emptyMarkers, Markers} from "../markers";
 import {saveTrace, trace} from "./trace";
 import {createDraft, finishDraft} from "immer";
 import {isRef, ReferenceMap} from "../reference";
-import {Writable} from "node:stream";
 
 /**
  * Interface representing an RPC codec that defines methods
@@ -261,7 +261,8 @@ export class RpcReceiveQueue {
     constructor(private readonly refs: Map<number, any>,
                 private readonly sourceFileType: string | undefined,
                 private readonly pull: () => Promise<RpcObjectData[]>,
-                private readonly logFile?: Writable) {
+                private readonly logger: rpc.Logger | undefined,
+                private readonly trace: boolean) {
     }
 
     async take(): Promise<RpcObjectData> {
@@ -276,7 +277,7 @@ export class RpcReceiveQueue {
             markers = emptyMarkers;
         }
         return this.receive(markers, async m => {
-            return saveTrace(this.logFile, async () => {
+            return saveTrace(this.trace, async () => {
                 const draft = createDraft(markers!);
                 draft.id = await this.receive(m.id);
                 draft.markers = (await this.receiveList(m.markers))!;
@@ -289,9 +290,9 @@ export class RpcReceiveQueue {
         before: T | undefined,
         onChange?: (before: T) => T | Promise<T | undefined> | undefined
     ): Promise<T> {
-        return saveTrace(this.logFile, async () => {
+        return saveTrace(this.trace, async () => {
             const message = await this.take();
-            this.traceMessage(message);
+            RpcObjectData.logTrace(message, this.trace, this.logger);
             let ref: number | undefined;
             switch (message.state) {
                 case RpcObjectState.NO_CHANGE:
@@ -353,9 +354,9 @@ export class RpcReceiveQueue {
         before: T[] | undefined,
         onChange?: (before: T) => T | Promise<T | undefined> | undefined
     ): Promise<T[] | undefined> {
-        return saveTrace(this.logFile, async () => {
+        return saveTrace(this.trace, async () => {
             const message = await this.take();
-            this.traceMessage(message);
+            RpcObjectData.logTrace(message, this.trace, this.logger);
             switch (message.state) {
                 case RpcObjectState.NO_CHANGE:
                     return before;
@@ -385,16 +386,6 @@ export class RpcReceiveQueue {
         });
     }
 
-    private traceMessage(message: RpcObjectData) {
-        if (this.logFile && message.trace) {
-            const sendTrace = message.trace;
-            delete message.trace;
-            this.logFile.write(`${JSON.stringify(message)}\n`);
-            this.logFile.write(`  ${sendTrace}\n`);
-            this.logFile.write(`  ${trace("Receiver")}\n`);
-        }
-    }
-
     private newObj<T>(type: string): T {
         return {
             kind: type
@@ -413,6 +404,18 @@ export interface RpcObjectData {
     trace?: string
 }
 
+export namespace RpcObjectData {
+    export function logTrace(message: RpcObjectData, enabled: boolean, logger: rpc.Logger | undefined): void {
+        if (enabled && logger && message.trace) {
+            const sendTrace = message.trace;
+            delete message.trace;
+            logger.info(`${JSON.stringify(message)}`);
+            logger.info(`  ${sendTrace || 'No sender trace'}`);
+            logger.info(`  ${trace("Receiver") || 'No receiver trace'}`);
+        }
+    }
+}
+
 export enum RpcObjectState {
     NO_CHANGE = "NO_CHANGE",
     ADD = "ADD",

package/src/rpc/request/generate.ts

@@ -34,33 +34,39 @@ export class Generate {
                   recipeCursors: WeakMap<Recipe, Cursor>,
                   getObject: (id: string) => any,
                   metricsCsv?: string): void {
-        const target = { target: '' };
-        connection.onRequest(new rpc.RequestType<Generate, GenerateResponse, Error>("Generate"), withMetrics<Generate, GenerateResponse>("Generate", target, metricsCsv)(async (request) => {
-            target.target = request.id;
-            const recipe = preparedRecipes.get(request.id);
-            const response = {
-                ids: [],
-                sourceFileTypes: []
-            } as GenerateResponse;
+        connection.onRequest(
+            new rpc.RequestType<Generate, GenerateResponse, Error>("Generate"),
+            withMetrics<Generate, GenerateResponse>(
+                "Generate",
+                metricsCsv,
+                (context) => async (request) => {
+                    context.target = request.id;
+                    const recipe = preparedRecipes.get(request.id);
+                    const response = {
+                        ids: [],
+                        sourceFileTypes: []
+                    } as GenerateResponse;
 
-            if (recipe && recipe instanceof ScanningRecipe) {
-                let cursor = recipeCursors.get(recipe);
-                if (!cursor) {
-                    cursor = rootCursor();
-                    recipeCursors.set(recipe, cursor);
-                }
-                const ctx = getObject(request.p) as ExecutionContext;
-                const acc = recipe.accumulator(cursor, ctx);
-                const generated = await recipe.generate(acc, ctx)
+                    if (recipe && recipe instanceof ScanningRecipe) {
+                        let cursor = recipeCursors.get(recipe);
+                        if (!cursor) {
+                            cursor = rootCursor();
+                            recipeCursors.set(recipe, cursor);
+                        }
+                        const ctx = getObject(request.p) as ExecutionContext;
+                        const acc = recipe.accumulator(cursor, ctx);
+                        const generated = await recipe.generate(acc, ctx)
 
-                for (const g of generated) {
-                    localObjects.set(g.id.toString(), g);
-                    response.ids.push(g.id.toString());
-                    response.sourceFileTypes.push(g.kind);
-                }
+                        for (const g of generated) {
+                            localObjects.set(g.id.toString(), g);
+                            response.ids.push(g.id.toString());
+                            response.sourceFileTypes.push(g.kind);
+                        }
 
-            }
-            return response;
-        }));
+                    }
+                    return response;
+                }
+            )
+        );
     }
 }

package/src/rpc/request/get-languages.ts

@@ -3,15 +3,23 @@ import {withMetrics0} from "./metrics";
 
 export class GetLanguages {
     static handle(connection: rpc.MessageConnection, metricsCsv?: string): void {
-        const target = {target: ''};
-        connection.onRequest(new rpc.RequestType0<string[], Error>("GetLanguages"), withMetrics0<string[]>("GetLanguages", target, metricsCsv)(async () => {
-            // Include all languages you want this server to support receiving from a remote peer
-            return [
-                "org.openrewrite.text.PlainText",
-                "org.openrewrite.json.tree.Json$Document",
-                "org.openrewrite.java.tree.J$CompilationUnit",
-                "org.openrewrite.javascript.tree.JS$CompilationUnit",
-            ];
-        }));
+        connection.onRequest(
+            new rpc.RequestType0<string[], Error>("GetLanguages"),
+            withMetrics0<string[]>(
+                "GetLanguages",
+                metricsCsv,
+                (context) => async () => {
+                    // Include all languages you want this server to support receiving from a remote peer
+                    const languages = [
+                        "org.openrewrite.text.PlainText",
+                        "org.openrewrite.json.tree.Json$Document",
+                        "org.openrewrite.java.tree.J$CompilationUnit",
+                        "org.openrewrite.javascript.tree.JS$CompilationUnit",
+                    ];
+                    context.target = '';
+                    return languages;
+                }
+            )
+        );
     }
 }

package/src/rpc/request/get-object.ts

@@ -16,7 +16,7 @@
 import * as rpc from "vscode-jsonrpc/node";
 import {RpcObjectData, RpcObjectState, RpcSendQueue} from "../queue";
 import {ReferenceMap} from "../../reference";
-import {withMetrics, extractSourcePath} from "./metrics";
+import {extractSourcePath, withMetrics} from "./metrics";
 
 export class GetObject {
     constructor(private readonly id: string,
@@ -29,49 +29,57 @@ export class GetObject {
         localObjects: Map<string, any | ((input: string) => any)>,
         localRefs: ReferenceMap,
         batchSize: number,
-        trace: boolean,
-        metricsCsv?: string
+        trace: () => boolean,
+        metricsCsv?: string,
     ): void {
         const pendingData = new Map<string, RpcObjectData[]>();
-        const target = { target: '' };
 
-        connection.onRequest(new rpc.RequestType<GetObject, any, Error>("GetObject"), withMetrics<GetObject, any>("GetObject", target, metricsCsv)(async request => {
-            let objId = request.id;
-            if (!localObjects.has(objId)) {
-                return [
-                    {state: RpcObjectState.DELETE},
-                    {state: RpcObjectState.END_OF_OBJECT}
-                ];
-            }
+        connection.onRequest(
+            new rpc.RequestType<GetObject, any, Error>("GetObject"),
+            withMetrics<GetObject, any>(
+                "GetObject",
+                metricsCsv,
+                (context) => async request => {
+                    const objId = request.id;
+                    if (!localObjects.has(objId)) {
+                        context.target = '';
+                        return [
+                            {state: RpcObjectState.DELETE},
+                            {state: RpcObjectState.END_OF_OBJECT}
+                        ];
+                    }
 
-            let objectOrGenerator = localObjects.get(objId)!;
-            if (typeof objectOrGenerator === 'function') {
-                let obj = await objectOrGenerator(objId);
-                localObjects.set(objId, obj);
-            }
+                    const objectOrGenerator = localObjects.get(objId)!;
+                    if (typeof objectOrGenerator === 'function') {
+                        const obj = await objectOrGenerator(objId);
+                        localObjects.set(objId, obj);
+                    }
 
-            const obj = localObjects.get(objId);
-            target.target = extractSourcePath(obj);
+                    const obj = localObjects.get(objId);
+                    context.target = extractSourcePath(obj);
 
-            let allData = pendingData.get(objId);
-            if (!allData) {
-                const after = obj;
-                const before = remoteObjects.get(objId);
+                    let allData = pendingData.get(objId);
+                    if (!allData) {
+                        const after = obj;
+                        const before = remoteObjects.get(objId);
 
-                allData = await new RpcSendQueue(localRefs, request.sourceFileType, trace).generate(after, before);
-                pendingData.set(objId, allData);
+                        allData = await new RpcSendQueue(localRefs, request.sourceFileType, trace())
+                            .generate(after, before);
+                        pendingData.set(objId, allData);
 
-                remoteObjects.set(objId, after);
-            }
+                        remoteObjects.set(objId, after);
+                    }
 
-            const batch = allData.splice(0, batchSize);
+                    const batch = allData.splice(0, batchSize);
 
-            // If we've sent all data, remove from pending
-            if (allData.length === 0) {
-                pendingData.delete(objId);
-            }
+                    // If we've sent all data, remove from pending
+                    if (allData.length === 0) {
+                        pendingData.delete(objId);
+                    }
 
-            return batch;
-        }));
+                    return batch;
+                }
+            )
+        );
     }
 }

package/src/rpc/request/get-recipes.ts

@@ -19,13 +19,20 @@ import {withMetrics0} from "./metrics";
 
 export class GetRecipes {
     static handle(connection: rpc.MessageConnection, registry: RecipeRegistry, metricsCsv?: string): void {
-        const target = { target: '' };
-        connection.onRequest(new rpc.RequestType0<({ name: string } & RecipeDescriptor)[], Error>("GetRecipes"), withMetrics0<({ name: string } & RecipeDescriptor)[]>("GetRecipes", target, metricsCsv)(async () => {
-            const recipes = [];
-            for (const [_name, recipe] of registry.all.entries()) {
-                recipes.push(await new recipe().descriptor());
-            }
-            return recipes;
-        }));
+        connection.onRequest(
+            new rpc.RequestType0<({ name: string } & RecipeDescriptor)[], Error>("GetRecipes"),
+            withMetrics0<({ name: string } & RecipeDescriptor)[]>(
+                "GetRecipes",
+                metricsCsv,
+                (context) => async () => {
+                    const recipes = [];
+                    for (const [_name, recipe] of registry.all.entries()) {
+                        recipes.push(await new recipe().descriptor());
+                    }
+                    context.target = '';
+                    return recipes;
+                }
+            )
+        );
     }
 }

package/src/rpc/request/index.ts

@@ -20,3 +20,4 @@ export * from "./parse";
 export * from "./prepare-recipe";
 export * from "./print";
 export * from "./visit";
+export * from "./trace-get-object";

package/src/rpc/request/install-recipes.ts

@@ -17,7 +17,7 @@ import * as rpc from "vscode-jsonrpc/node";
 import {RecipeRegistry} from "../../recipe";
 import * as path from "path";
 import * as fs from "fs";
-import {spawn, ChildProcess} from "child_process";
+import {spawn} from "child_process";
 import {withMetrics} from "./metrics";
 
 export interface InstallRecipesResponse {
@@ -70,94 +70,111 @@ export class InstallRecipes {
 
     static handle(connection: rpc.MessageConnection, installDir: string, registry: RecipeRegistry,
                   logger?: rpc.Logger, metricsCsv?: string): void {
-        const target = { target: '' };
-        connection.onRequest(new rpc.RequestType<InstallRecipes, InstallRecipesResponse, Error>("InstallRecipes"), withMetrics<InstallRecipes, InstallRecipesResponse>("InstallRecipes", target, metricsCsv)(async (request) => {
-            target.target = typeof request.recipes === "object" ? request.recipes.packageName : request.recipes;
-            const beforeInstall = registry.all.size;
-            let resolvedPath;
-            let recipesName = request.recipes;
-
-            if (typeof request.recipes === "object") {
-                const recipePackage = request.recipes;
-                const absoluteInstallDir = path.isAbsolute(installDir) ? installDir : path.join(process.cwd(), installDir);
-
-                // Ensure directory exists
-                if (!fs.existsSync(absoluteInstallDir)) {
-                    fs.mkdirSync(absoluteInstallDir, {recursive: true});
-                }
-
-                // Check if package.json exists, if not create one
-                const packageJsonPath = path.join(absoluteInstallDir, "package.json");
-                if (!fs.existsSync(packageJsonPath)) {
-                    // Create a minimal package.json with a custom name
-                    const packageJson = {
-                        name: "openrewrite-recipes",
-                        version: "1.0.0",
-                        description: "OpenRewrite recipe marketplace",
-                        private: true
-                    };
-                    fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
-                    if (logger) {
-                        logger.info("Created package.json for recipe dependencies");
+        connection.onRequest(
+            new rpc.RequestType<InstallRecipes, InstallRecipesResponse, Error>("InstallRecipes"),
+            withMetrics<InstallRecipes, InstallRecipesResponse>(
+                "InstallRecipes",
+                metricsCsv,
+                (context) => async (request) => {
+                    context.target = typeof request.recipes === "object" ? request.recipes.packageName : request.recipes;
+                    const beforeInstall = registry.all.size;
+                    let resolvedPath;
+                    let recipesName = request.recipes;
+
+                    if (typeof request.recipes === "object") {
+                        const recipePackage = request.recipes;
+                        const absoluteInstallDir = path.isAbsolute(installDir) ? installDir : path.join(process.cwd(), installDir);
+
+                        // Ensure directory exists
+                        if (!fs.existsSync(absoluteInstallDir)) {
+                            fs.mkdirSync(absoluteInstallDir, {recursive: true});
+                        }
+
+                        // Check if package.json exists, if not create one
+                        const packageJsonPath = path.join(absoluteInstallDir, "package.json");
+                        if (!fs.existsSync(packageJsonPath)) {
+                            // Create a minimal package.json with a custom name
+                            const packageJson = {
+                                name: "openrewrite-recipes",
+                                version: "1.0.0",
+                                description: "OpenRewrite recipe marketplace",
+                                private: true
+                            };
+                            fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
+                            if (logger) {
+                                logger.info("Created package.json for recipe dependencies");
+                            }
+                        }
+
+                        // Rather than using npm on PATH, use `node_cli.js`.
+                        // https://stackoverflow.com/questions/15957529/can-i-install-a-npm-package-from-javascript-running-in-node-js
+                        const packageSpec = recipePackage.packageName + (recipePackage.version ? `@${recipePackage.version}` : "");
+                        await spawnNpmCommand("npm", ["install", packageSpec, "--no-fund"], absoluteInstallDir, logger);
+                        resolvedPath = require.resolve(path.join(absoluteInstallDir, "node_modules", recipePackage.packageName));
+                        recipesName = request.recipes.packageName;
+                    } else {
+                        resolvedPath = request.recipes;
                     }
-                }
 
-                // Rather than using npm on PATH, use `node_cli.js`.
-                // https://stackoverflow.com/questions/15957529/can-i-install-a-npm-package-from-javascript-running-in-node-js
-                const packageSpec = recipePackage.packageName + (recipePackage.version ? `@${recipePackage.version}` : "");
-                await spawnNpmCommand("npm", ["install", packageSpec, "--no-fund"], absoluteInstallDir, logger);
-                resolvedPath = require.resolve(path.join(absoluteInstallDir, "node_modules", recipePackage.packageName));
-                recipesName = request.recipes.packageName;
-            } else {
-                resolvedPath = request.recipes;
-            }
+                    let recipeModule;
+                    try {
+                        setupSharedDependencies(resolvedPath);
+                        recipeModule = require(resolvedPath);
+                    } catch (e: any) {
+                        throw new Error(`Failed to load recipe module from ${resolvedPath}: ${e.stack}`);
+                    }
 
-            let recipeModule;
-            try {
-                setupSharedDependencies(resolvedPath);
-                recipeModule = require(resolvedPath);
-            } catch (e: any) {
-                throw new Error(`Failed to load recipe module from ${resolvedPath}: ${e.stack}`);
-            }
+                    if (typeof recipeModule.activate === "function") {
+                        // noinspection JSVoidFunctionReturnValueUsed
+                        const activatePromise = recipeModule.activate(registry);
+                        // noinspection SuspiciousTypeOfGuard
+                        if (activatePromise instanceof Promise) {
+                            await activatePromise;
+                        }
+                    } else {
+                        throw new Error(`${recipesName} does not export an 'activate' function`);
+                    }
 
-            if (typeof recipeModule.activate === "function") {
-                // noinspection JSVoidFunctionReturnValueUsed
-                const activatePromise = recipeModule.activate(registry);
-                // noinspection SuspiciousTypeOfGuard
-                if (activatePromise instanceof Promise) {
-                    await activatePromise;
+                    return {recipesInstalled: registry.all.size - beforeInstall};
                 }
-            } else {
-                throw new Error(`${recipesName} does not export an 'activate' function`);
-            }
-
-            return {recipesInstalled: registry.all.size - beforeInstall};
-        }));
+            )
+        );
     }
 }
 
+/**
+ * Ensures dynamically loaded modules share the same class instances as the host
+ * by mapping require.cache entries. This prevents instanceof failures when the
+ * same package is installed in multiple node_modules directories.
+ */
 function setupSharedDependencies(targetModulePath: string) {
-    const sharedDeps = [
-        '@openrewrite/rewrite',
-        'vscode-jsonrpc',
-    ];
-
-    sharedDeps.forEach(dep => {
-        try {
-            // Get your already-loaded version
-            const yourDepPath = require.resolve(dep);
-            const yourModule = require.cache[yourDepPath];
-
-            if (yourModule) {
-                // Find where the target would look for this dependency
-                const targetDir = path.dirname(targetModulePath);
-                const targetDepPath = require.resolve(dep, {paths: [targetDir]});
-
-                // Make the target use your cached version
-                require.cache[targetDepPath] = yourModule;
+    const sharedDeps = ['@openrewrite/rewrite', 'vscode-jsonrpc'];
+    const targetDir = path.dirname(targetModulePath);
+
+    sharedDeps.forEach(depName => {
+        const depPattern = path.sep + 'node_modules' + path.sep + depName.replace('/', path.sep);
+
+        for (const cachedPath of Object.keys(require.cache)) {
+            if (!cachedPath.includes(depPattern)) continue;
+
+            try {
+                // Extract subpath: /path/node_modules/@pkg/dist/tree.js -> dist/tree.js
+                const pkgIndex = cachedPath.indexOf(depPattern);
+                let subpath = cachedPath.substring(pkgIndex + depPattern.length)
+                    .replace(/^[/\\]/, '')           // Remove leading slash
+                    .replace(/\.(js|ts)$/, '')        // Remove extension
+                    .replace(/^dist[/\\]/, '')        // Remove dist/ prefix if present
+                    .replace(/[/\\]index$/, '');      // Remove /index suffix
+
+                // Build require path: @pkg or @pkg/subpath
+                const requirePath = subpath ? `${depName}/${subpath}` : depName;
+
+                // Resolve from target's perspective and map cache
+                const targetDepPath = require.resolve(requirePath, {paths: [targetDir]});
+                require.cache[targetDepPath] = require.cache[cachedPath];
+            } catch (e) {
+                // Target can't resolve this path, skip
             }
-        } catch (e) {
-            // Module not found or not resolvable, skip
         }
     });
 }