rwsdk 0.2.0-alpha.9 → 0.3.0

package/dist/vite/directivesPlugin.mjs

@@ -28,36 +28,12 @@ const getLoader = (filePath) => {
 export const directivesPlugin = ({ projectRootDir, clientFiles, serverFiles, }) => {
     let devServer;
     let isAfterFirstResponse = false;
-    const addModule = (kind, environment, id) => {
-        const files = kind === "client" ? clientFiles : serverFiles;
-        const rawId = id.split("?")[0];
-        const resolvedId = normalizeModulePath(rawId, projectRootDir);
-        const fullPath = normalizeModulePath(rawId, projectRootDir, {
-            absolute: true,
-        });
-        const isNodeModule = id.includes("node_modules");
-        const hadFile = files.has(id);
-        log("Adding %s module to %s and invalidating cache: id=%s", kind, files, resolvedId);
-        files.add(resolvedId);
-        if (devServer && isNodeModule) {
-            const lookupModule = kind === "client"
-                ? "virtual:use-client-lookup"
-                : "virtual:use-server-lookup";
-            log("Registering missing import for %s module resolvedId=%s in environment %s, fullPath=%s", kind, resolvedId, environment, fullPath);
-            devServer.environments[environment].depsOptimizer?.registerMissingImport(resolvedId, fullPath);
-            if (isAfterFirstResponse && !hadFile) {
-                log("Invalidating cache for lookup module %s after adding module id=%s", lookupModule, id);
-            }
-        }
-    };
-    const addClientModule = (environment, id) => {
-        addModule("client", environment, id);
-    };
-    const addServerModule = (environment, id) => {
-        addModule("server", environment, id);
-    };
+    let isBuild = false;
     return {
         name: "rwsdk:rsc-directives",
+        configResolved(config) {
+            isBuild = config.command === "build";
+        },
         configureServer(server) {
             devServer = server;
             devServer.middlewares.use((_req, res, next) => {
@@ -76,33 +52,42 @@ export const directivesPlugin = ({ projectRootDir, clientFiles, serverFiles, })
             });
         },
         async transform(code, id) {
-            process.env.VERBOSE &&
-                log("Transform called for id=%s, environment=%s", id, this.environment.name);
+            if (isBuild &&
+                this.environment?.name === "worker" &&
+                process.env.RWSDK_BUILD_PASS !== "worker") {
+                return;
+            }
             const normalizedId = normalizeModulePath(id, projectRootDir);
             const clientResult = await transformClientComponents(code, normalizedId, {
                 environmentName: this.environment.name,
                 clientFiles,
-                addClientModule,
             });
             if (clientResult) {
-                log("Client component transformation successful for id=%s", id);
+                process.env.VERBOSE &&
+                    log("Client component transformation successful for id=%s", id);
                 return {
                     code: clientResult.code,
                     map: clientResult.map,
                 };
             }
-            const serverResult = transformServerFunctions(code, normalizedId, this.environment.name, serverFiles, addServerModule);
+            const serverResult = transformServerFunctions(code, normalizedId, this.environment.name, serverFiles);
             if (serverResult) {
-                log("Server function transformation successful for id=%s", id);
+                process.env.VERBOSE &&
+                    log("Server function transformation successful for id=%s", id);
                 return {
                     code: serverResult.code,
                     map: serverResult.map,
                 };
             }
-            process.env.VERBOSE && log("No transformation applied for id=%s", id);
+            // Removed: too noisy even in verbose mode
         },
         configEnvironment(env, config) {
-            log("Configuring environment: env=%s", env);
+            if (isBuild &&
+                env === "worker" &&
+                process.env.RWSDK_BUILD_PASS !== "worker") {
+                return;
+            }
+            process.env.VERBOSE && log("Configuring environment: env=%s", env);
             config.optimizeDeps ??= {};
             config.optimizeDeps.esbuildOptions ??= {};
             config.optimizeDeps.esbuildOptions.plugins ??= [];
@@ -120,7 +105,6 @@ export const directivesPlugin = ({ projectRootDir, clientFiles, serverFiles, })
                         // dependency discovery, so we can skip transform work
                         // and use heuristics instead - see below inside if block
                         if (!args.path.includes("node_modules")) {
-                            log("Esbuild onLoad found app code, path=%s", args.path);
                             if (clientFiles.has(normalizedPath)) {
                                 // context(justinvdm,2025-06-15): If this is a client file:
                                 // * for ssr and client envs we can skip so esbuild looks at the
@@ -171,10 +155,10 @@ export const directivesPlugin = ({ projectRootDir, clientFiles, serverFiles, })
                             environmentName: env,
                             clientFiles,
                             isEsbuild: true,
-                            addClientModule,
                         });
                         if (clientResult) {
-                            log("Esbuild client component transformation successful for environment=%s, path=%s", env, args.path);
+                            process.env.VERBOSE &&
+                                log("Esbuild client component transformation successful for environment=%s, path=%s", env, args.path);
                             process.env.VERBOSE &&
                                 log("Esbuild client component transformation for environment=%s, path=%s, code: %j", env, args.path, clientResult.code);
                             return {
@@ -182,9 +166,10 @@ export const directivesPlugin = ({ projectRootDir, clientFiles, serverFiles, })
                                 loader: getLoader(args.path),
                             };
                         }
-                        const serverResult = transformServerFunctions(code, normalizedPath, env, serverFiles, addServerModule);
+                        const serverResult = transformServerFunctions(code, normalizedPath, env, serverFiles);
                         if (serverResult) {
-                            log("Esbuild server function transformation successful for environment=%s, path=%s", env, args.path);
+                            process.env.VERBOSE &&
+                                log("Esbuild server function transformation successful for environment=%s, path=%s", env, args.path);
                             return {
                                 contents: serverResult.code,
                                 loader: getLoader(args.path),
@@ -195,7 +180,8 @@ export const directivesPlugin = ({ projectRootDir, clientFiles, serverFiles, })
                     });
                 },
             });
-            log("Environment configuration complete for env=%s", env);
+            process.env.VERBOSE &&
+                log("Environment configuration complete for env=%s", env);
         },
     };
 };

package/dist/vite/getViteEsbuild.d.mts

@@ -0,0 +1 @@
+export declare function getViteEsbuild(projectRootDir: string): Promise<any>;

package/dist/vite/getViteEsbuild.mjs

@@ -0,0 +1,12 @@
+import path from "node:path";
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+export async function getViteEsbuild(projectRootDir) {
+    const vitePath = require.resolve("vite/package.json", {
+        paths: [projectRootDir],
+    });
+    const viteDir = path.dirname(vitePath);
+    const esbuildPath = require.resolve("esbuild", { paths: [viteDir] });
+    const esbuildModule = await import(esbuildPath);
+    return esbuildModule.default || esbuildModule;
+}

package/dist/vite/hasOwnReactVitePlugin.d.mts

@@ -0,0 +1,3 @@
+export declare function hasOwnReactVitePlugin({ rootProjectDir, }: {
+    rootProjectDir: string;
+}): Promise<boolean>;

package/dist/vite/hasOwnReactVitePlugin.mjs

@@ -0,0 +1,14 @@
+import { readFile } from "fs/promises";
+import path from "path";
+export async function hasOwnReactVitePlugin({ rootProjectDir, }) {
+    const packageJsonPath = path.join(rootProjectDir, "package.json");
+    try {
+        const packageJson = JSON.parse(await readFile(packageJsonPath, "utf-8"));
+        return !!(packageJson.dependencies?.["@vitejs/plugin-react"] ||
+            packageJson.devDependencies?.["@vitejs/plugin-react"]);
+    }
+    catch (error) {
+        console.error("Error reading package.json:", error);
+        return false;
+    }
+}

package/dist/vite/injectVitePreamblePlugin.d.mts

@@ -1,4 +1,5 @@
 import { type Plugin } from "vite";
-export declare const injectVitePreamble: ({ clientEntryPathnames, }: {
-    clientEntryPathnames: string[];
+export declare const injectVitePreamble: ({ clientEntryPoints, projectRootDir, }: {
+    clientEntryPoints: Set<string>;
+    projectRootDir: string;
 }) => Plugin;

package/dist/vite/injectVitePreamblePlugin.mjs

@@ -1,12 +1,14 @@
 import MagicString from "magic-string";
-export const injectVitePreamble = ({ clientEntryPathnames, }) => ({
+import { normalizeModulePath } from "../lib/normalizeModulePath.mjs";
+export const injectVitePreamble = ({ clientEntryPoints, projectRootDir, }) => ({
     name: "rwsdk:inject-vite-preamble",
     apply: "serve",
     transform(code, id) {
         if (this.environment.name !== "client") {
             return;
         }
-        if (!clientEntryPathnames.includes(id)) {
+        const normalizedId = normalizeModulePath(id, projectRootDir);
+        if (!clientEntryPoints.has(normalizedId)) {
             return;
         }
         // Only inject preamble in development mode

package/dist/vite/linkerPlugin.d.mts

@@ -0,0 +1,4 @@
+import type { Plugin } from "vite";
+export declare const linkerPlugin: ({ projectRootDir, }: {
+    projectRootDir: string;
+}) => Plugin;

package/dist/vite/linkerPlugin.mjs

@@ -0,0 +1,41 @@
+import path from "node:path";
+import fsp from "node:fs/promises";
+import { CLIENT_MANIFEST_RELATIVE_PATH } from "../lib/constants.mjs";
+import debug from "debug";
+import { normalizeModulePath } from "../lib/normalizeModulePath.mjs";
+const log = debug("rwsdk:vite:linker-plugin");
+export const linkerPlugin = ({ projectRootDir, }) => {
+    return {
+        name: "rwsdk:linker",
+        async renderChunk(code) {
+            if (this.environment.name !== "worker" ||
+                process.env.RWSDK_BUILD_PASS !== "linker") {
+                return null;
+            }
+            log("Rendering final worker chunk");
+            let newCode = code;
+            // Read the manifest from the filesystem.
+            const manifestContent = await fsp.readFile(path.resolve(projectRootDir, CLIENT_MANIFEST_RELATIVE_PATH), "utf-8");
+            const manifest = JSON.parse(manifestContent);
+            // 1. Replace the manifest placeholder with the actual manifest content.
+            log("Injecting manifest into worker bundle");
+            newCode = newCode.replace('"__RWSDK_MANIFEST_PLACEHOLDER__"', manifestContent);
+            // 2. Replace asset placeholders with their final hashed paths.
+            log("Replacing asset placeholders in final worker bundle");
+            for (const [key, value] of Object.entries(manifest)) {
+                const normalizedKey = normalizeModulePath(key, projectRootDir, {
+                    isViteStyle: false,
+                });
+                newCode = newCode.replaceAll(`rwsdk_asset:${normalizedKey}`, `/${value.file}`);
+            }
+            // 3. Deprefix any remaining placeholders that were not in the manifest.
+            // This handles public assets that don't go through the bundler.
+            log("Deprefixing remaining asset placeholders");
+            newCode = newCode.replaceAll("rwsdk_asset:", "");
+            return {
+                code: newCode,
+                map: null,
+            };
+        },
+    };
+};

package/dist/vite/manifestPlugin.d.mts

@@ -1,4 +1,4 @@
 import { type Plugin } from "vite";
-export declare const manifestPlugin: ({ manifestPath, }: {
-    manifestPath: string;
+export declare const manifestPlugin: ({ projectRootDir, }: {
+    projectRootDir: string;
 }) => Plugin;

package/dist/vite/manifestPlugin.mjs

@@ -1,57 +1,32 @@
-import { readFile } from "node:fs/promises";
 import debug from "debug";
-import { normalizeModulePath } from "../lib/normalizeModulePath.mjs";
 const log = debug("rwsdk:vite:manifest-plugin");
 const virtualModuleId = "virtual:rwsdk:manifest.js";
 const resolvedVirtualModuleId = "\0" + virtualModuleId;
-export const manifestPlugin = ({ manifestPath, }) => {
+export const manifestPlugin = ({ projectRootDir, }) => {
     let isBuild = false;
-    let root;
     return {
-        name: "rwsdk:manifest",
+        name: "rwsdk:vite:manifest-plugin",
+        enforce: "pre",
         configResolved(config) {
-            log("Config resolved, command=%s", config.command);
             isBuild = config.command === "build";
-            root = config.root;
         },
         resolveId(id) {
             if (id === virtualModuleId) {
-                process.env.VERBOSE && log("Resolving virtual module id=%s", id);
                 return resolvedVirtualModuleId;
             }
         },
         async load(id) {
             if (id === resolvedVirtualModuleId) {
-                process.env.VERBOSE && log("Loading virtual module id=%s", id);
-                if (!isBuild) {
-                    process.env.VERBOSE && log("Not a build, returning empty manifest");
-                    return `export default {}`;
+                if (isBuild) {
+                    // context(justinvdm, 28 Aug 2025): During the build, we don't have
+                    // the manifest yet. We insert a placeholder that the linker plugin
+                    // will replace in the final phase.
+                    log("Returning manifest placeholder for build");
+                    return `export default "__RWSDK_MANIFEST_PLACEHOLDER__"`;
                 }
-                log("Reading manifest from %s", manifestPath);
-                const manifestContent = await readFile(manifestPath, "utf-8");
-                const manifest = JSON.parse(manifestContent);
-                const normalizedManifest = {};
-                for (const key in manifest) {
-                    const normalizedKey = normalizeModulePath(key, root, {
-                        isViteStyle: false,
-                    });
-                    const entry = manifest[key];
-                    delete manifest[key];
-                    normalizedManifest[normalizedKey] = entry;
-                    entry.file = normalizeModulePath(entry.file, root, {
-                        isViteStyle: false,
-                    });
-                    const normalizedCss = [];
-                    if (entry.css) {
-                        for (const css of entry.css) {
-                            normalizedCss.push(normalizeModulePath(css, root, {
-                                isViteStyle: false,
-                            }));
-                        }
-                        entry.css = normalizedCss;
-                    }
-                }
-                return `export default ${JSON.stringify(normalizedManifest)}`;
+                // In dev, we can return an empty object.
+                log("Not a build, returning empty manifest");
+                return `export default {}`;
             }
         },
         configEnvironment(name, config) {

package/dist/vite/miniflareHMRPlugin.mjs

@@ -66,6 +66,9 @@ export const miniflareHMRPlugin = (givenOptions) => [
             };
         },
         async hotUpdate(ctx) {
+            if (ctx.file.includes(".wrangler")) {
+                return;
+            }
             if (hasErrored) {
                 const shortName = getShortName(ctx.file, ctx.server.config.root);
                 this.environment.logger.info(`${colors.cyan(`attempting to recover from error`)}: update to ${colors.dim(shortName)}`, {
@@ -77,6 +80,7 @@ export const miniflareHMRPlugin = (givenOptions) => [
                     type: "full-reload",
                     path: "*",
                 });
+                log("hmr: Full reload after error");
                 return [];
             }
             const { clientFiles, serverFiles, viteEnvironment: { name: environment }, workerEntryPathname: entry, } = givenOptions;
@@ -84,6 +88,7 @@ export const miniflareHMRPlugin = (givenOptions) => [
                 log(`Hot update: (env=${this.environment.name}) ${ctx.file}\nModule graph:\n\n${dumpFullModuleGraph(ctx.server, this.environment.name)}`);
             }
             if (!isJsFile(ctx.file) && !ctx.file.endsWith(".css")) {
+                log(`hmr: not a js file, skipping`);
                 return;
             }
             if (this.environment.name === "ssr") {
@@ -94,14 +99,17 @@ export const miniflareHMRPlugin = (givenOptions) => [
                     server: ctx.server,
                 });
                 if (!isUseClientUpdate) {
+                    log("hmr: not a use client update, short circuiting");
                     return [];
                 }
                 invalidateModule(ctx.server, "ssr", ctx.file);
                 invalidateModule(ctx.server, environment, VIRTUAL_SSR_PREFIX +
                     normalizeModulePath(ctx.file, givenOptions.rootDir));
+                log("hmr: invalidated ssr module");
                 return [];
             }
             if (!["client", environment].includes(this.environment.name)) {
+                log(`hmr: incorrect env, skipping (env=${this.environment.name}, worker env=${environment})`);
                 return [];
             }
             const hasClientDirective = await hasDirective(ctx.file, "use client");
@@ -165,8 +173,10 @@ export const miniflareHMRPlugin = (givenOptions) => [
                     server: ctx.server,
                 });
                 if (!isUseClientUpdate && !ctx.file.endsWith(".css")) {
+                    log("hmr: not a use client update and not css, short circuiting");
                     return [];
                 }
+                log("hmr: returning client modules for hmr");
                 return ctx.modules;
             }
             // The worker needs an update, and the hot check is for the worker environment
@@ -184,8 +194,12 @@ export const miniflareHMRPlugin = (givenOptions) => [
                 if (m) {
                     invalidateModule(ctx.server, environment, m);
                 }
-                const virtualSSRModule = ctx.server.environments[environment].moduleGraph.idToModuleMap.get(VIRTUAL_SSR_PREFIX +
-                    normalizeModulePath(ctx.file, givenOptions.rootDir));
+                let virtualSSRModuleId = VIRTUAL_SSR_PREFIX +
+                    normalizeModulePath(ctx.file, givenOptions.rootDir);
+                if (ctx.file.endsWith(".css")) {
+                    virtualSSRModuleId += ".js";
+                }
+                const virtualSSRModule = ctx.server.environments[environment].moduleGraph.idToModuleMap.get(virtualSSRModuleId);
                 if (virtualSSRModule) {
                     invalidateModule(ctx.server, environment, virtualSSRModule);
                 }
@@ -196,6 +210,7 @@ export const miniflareHMRPlugin = (givenOptions) => [
                         file: ctx.file,
                     },
                 });
+                log("hmr: sent rsc update");
                 return [];
             }
         },

package/dist/vite/moveStaticAssetsPlugin.mjs

@@ -3,7 +3,8 @@ export const moveStaticAssetsPlugin = ({ rootDir, }) => ({
     name: "rwsdk:move-static-assets",
     apply: "build",
     async closeBundle() {
-        if (this.environment.name === "worker") {
+        if (this.environment.name === "worker" &&
+            process.env.RWSDK_BUILD_PASS === "linker") {
             await $sh({
                 cwd: rootDir,
             }) `mv dist/worker/assets/*.css dist/client/assets/ || true`;

package/dist/vite/prismaPlugin.mjs

@@ -17,7 +17,7 @@ export const prismaPlugin = async ({ projectRootDir, }) => {
     return {
         name: "rwsdk:prisma",
         configEnvironment(name, config) {
-            if (name !== "worker") {
+            if (name !== "worker" || !process.env.VITE_IS_DEV_SERVER) {
                 return;
             }
             const wasmPath = resolve(projectRootDir, "node_modules/.prisma/client/wasm.js");

package/dist/vite/reactConditionsResolverPlugin.d.mts

@@ -10,7 +10,6 @@ export declare const ENV_RESOLVERS: {
     worker: enhancedResolve.ResolveFunction;
     client: enhancedResolve.ResolveFunction;
 };
-export declare const ENV_IMPORT_MAPPINGS: {
-    [k: string]: Map<string, string>;
-};
-export declare const reactConditionsResolverPlugin: () => Plugin[];
+export declare const reactConditionsResolverPlugin: ({ projectRootDir, }: {
+    projectRootDir: string;
+}) => Plugin[];

package/dist/vite/reactConditionsResolverPlugin.mjs

@@ -3,6 +3,7 @@ import { ROOT_DIR } from "../lib/constants.mjs";
 import enhancedResolve from "enhanced-resolve";
 import { ensureAliasArray } from "./ensureAliasArray.mjs";
 const log = debug("rwsdk:vite:react-conditions-resolver-plugin");
+const REACT_PREFIXES = ["react", "react-dom", "react-server-dom-webpack"];
 export const ENV_REACT_IMPORTS = {
     worker: [
         "react",
@@ -41,69 +42,85 @@ export const ENV_RESOLVERS = {
         conditionNames: ["browser", "default"],
     }),
 };
-export const ENV_IMPORT_MAPPINGS = Object.fromEntries(Object.keys(ENV_RESOLVERS).map((env) => [
-    env,
-    resolveEnvImportMappings(env),
-]));
-function resolveEnvImportMappings(env) {
-    process.env.VERBOSE &&
-        log("Resolving environment import mappings for env=%s", env);
-    const mappings = new Map();
-    const reactImports = ENV_REACT_IMPORTS[env];
-    for (const importRequest of reactImports) {
+function resolveReactImport(id, envName, projectRootDir, isReactImportKnown = false) {
+    if (!isReactImportKnown) {
+        const isReactImport = REACT_PREFIXES.some((prefix) => id === prefix || id.startsWith(`${prefix}/`));
+        if (!isReactImport) {
+            return undefined;
+        }
+    }
+    let resolved;
+    try {
+        resolved = ENV_RESOLVERS[envName](projectRootDir, id) || undefined;
+        process.env.VERBOSE &&
+            log("Successfully resolved %s to %s for env=%s from project root", id, resolved, envName);
+    }
+    catch {
         process.env.VERBOSE &&
-            log("Resolving import request=%s for env=%s", importRequest, env);
-        let resolved = false;
+            log("Failed to resolve %s for env=%s from project root, trying ROOT_DIR", id, envName);
         try {
-            resolved = ENV_RESOLVERS[env](ROOT_DIR, importRequest);
+            resolved = ENV_RESOLVERS[envName](ROOT_DIR, id) || undefined;
             process.env.VERBOSE &&
-                log("Successfully resolved %s to %s for env=%s", importRequest, resolved, env);
+                log("Successfully resolved %s to %s for env=%s from rwsdk root", id, resolved, envName);
         }
         catch {
             process.env.VERBOSE &&
-                log("Failed to resolve %s for env=%s", importRequest, env);
+                log("Failed to resolve %s for env=%s", id, envName);
         }
+    }
+    return resolved;
+}
+function resolveEnvImportMappings(env, projectRootDir) {
+    process.env.VERBOSE &&
+        log("Resolving environment import mappings for env=%s", env);
+    const mappings = new Map();
+    const reactImports = ENV_REACT_IMPORTS[env];
+    for (const importRequest of reactImports) {
+        const resolved = resolveReactImport(importRequest, env, projectRootDir, true);
         if (resolved) {
             mappings.set(importRequest, resolved);
-            log("Added mapping for %s -> %s in env=%s", importRequest, resolved, env);
+            process.env.VERBOSE &&
+                log("Added mapping for %s -> %s in env=%s", importRequest, resolved, env);
         }
     }
-    log("Environment import mappings complete for env=%s: %d mappings", env, mappings.size);
+    process.env.VERBOSE &&
+        log("Environment import mappings complete for env=%s: %d mappings", env, mappings.size);
     return mappings;
 }
-function createEsbuildResolverPlugin(envName) {
-    const mappings = ENV_IMPORT_MAPPINGS[envName];
-    if (!mappings) {
-        return null;
-    }
-    return {
-        name: `rwsdk:react-conditions-resolver-esbuild-${envName}`,
-        setup(build) {
-            build.onResolve({ filter: /.*/ }, (args) => {
-                process.env.VERBOSE &&
-                    log("ESBuild resolving %s for env=%s, args=%O", args.path, envName, args);
-                const resolved = mappings.get(args.path);
-                if (resolved && args.importer !== "") {
-                    process.env.VERBOSE &&
-                        log("ESBuild resolving %s -> %s for env=%s", args.path, resolved, envName);
-                    if (args.path === "react-server-dom-webpack/client.edge") {
-                        return;
-                    }
-                    return {
-                        path: resolved,
-                    };
-                }
-                else {
-                    process.env.VERBOSE &&
-                        log("ESBuild no resolution found for %s for env=%s", args.path, envName);
-                }
-            });
-        },
-    };
-}
-export const reactConditionsResolverPlugin = () => {
+export const reactConditionsResolverPlugin = ({ projectRootDir, }) => {
     log("Initializing react conditions resolver plugin");
     let isBuild = false;
+    const ENV_IMPORT_MAPPINGS = Object.fromEntries(Object.keys(ENV_RESOLVERS).map((env) => [
+        env,
+        resolveEnvImportMappings(env, projectRootDir),
+    ]));
+    // Log a clean summary instead of all the individual mappings
+    const totalMappings = Object.values(ENV_IMPORT_MAPPINGS).reduce((sum, mappings) => sum + mappings.size, 0);
+    log("React conditions resolver configured with %d total mappings across %d environments", totalMappings, Object.keys(ENV_IMPORT_MAPPINGS).length);
+    function createEsbuildResolverPlugin(envName, mappings) {
+        if (!mappings) {
+            return null;
+        }
+        return {
+            name: `rwsdk:react-conditions-resolver-esbuild-${envName}`,
+            setup(build) {
+                build.onResolve({ filter: /.*/ }, (args) => {
+                    let resolved = mappings.get(args.path);
+                    if (!resolved) {
+                        resolved = resolveReactImport(args.path, envName, projectRootDir);
+                    }
+                    if (resolved && args.importer !== "") {
+                        if (args.path === "react-server-dom-webpack/client.edge") {
+                            return;
+                        }
+                        return {
+                            path: resolved,
+                        };
+                    }
+                });
+            },
+        };
+    }
     return [
         {
             name: "rwsdk:react-conditions-resolver:config",
@@ -125,7 +142,7 @@ export const reactConditionsResolverPlugin = () => {
                         config.environments[envName] = {};
                     }
                     const envConfig = config.environments[envName];
-                    const esbuildPlugin = createEsbuildResolverPlugin(envName);
+                    const esbuildPlugin = createEsbuildResolverPlugin(envName, mappings);
                     if (esbuildPlugin && mappings) {
                         envConfig.optimizeDeps ??= {};
                         envConfig.optimizeDeps.esbuildOptions ??= {};
@@ -141,7 +158,8 @@ export const reactConditionsResolverPlugin = () => {
                     for (const [find, replacement] of mappings) {
                         const findRegex = new RegExp(`^${find.replace(/[-\/\\^$*+?.()|[\]{}]/g, "\\$&")}$`);
                         aliases.push({ find: findRegex, replacement });
-                        log("Added alias for env=%s: %s -> %s", envName, find, replacement);
+                        process.env.VERBOSE &&
+                            log("Added alias for env=%s: %s -> %s", envName, find, replacement);
                     }
                     log("Environment %s configured with %d aliases and %d optimizeDeps includes", envName, mappings.size, reactImports.length);
                 }
@@ -158,21 +176,21 @@ export const reactConditionsResolverPlugin = () => {
                 if (!envName) {
                     return;
                 }
-                process.env.VERBOSE &&
-                    log("Resolving id=%s, environment=%s, importer=%s", id, envName, importer);
                 const mappings = ENV_IMPORT_MAPPINGS[envName];
                 if (!mappings) {
                     process.env.VERBOSE &&
                         log("No mappings found for environment: %s", envName);
                     return;
                 }
-                const resolved = mappings.get(id);
+                let resolved = mappings.get(id);
+                if (!resolved) {
+                    resolved = resolveReactImport(id, envName, projectRootDir);
+                }
                 if (resolved) {
-                    log("Resolved %s -> %s for env=%s", id, resolved, envName);
+                    process.env.VERBOSE &&
+                        log("Resolved %s -> %s for env=%s", id, resolved, envName);
                     return resolved;
                 }
-                process.env.VERBOSE &&
-                    log("No resolution found for id=%s in env=%s", id, envName);
             },
         },
     ];

package/dist/vite/redwoodPlugin.d.mts

@@ -3,9 +3,9 @@ export type RedwoodPluginOptions = {
     silent?: boolean;
     rootDir?: string;
     includeCloudflarePlugin?: boolean;
+    includeReactPlugin?: boolean;
     configPath?: string;
     entry?: {
-        client?: string | string[];
         worker?: string;
     };
 };