rwsdk 0.2.0-alpha.8 → 0.2.0

package/dist/runtime/worker.js

@@ -169,7 +169,7 @@ export const defineApp = (routes) => {
                 if (e instanceof Response) {
                     return e;
                 }
-                console.error("Unhandled error", e);
+                console.error("rwsdk: Received an unhandled error:\n\n%s", e);
                 throw e;
             }
         },

package/dist/scripts/debug-sync.mjs

@@ -7,6 +7,9 @@ import chokidar from "chokidar";
 import { lock } from "proper-lockfile";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const getPackageManagerInfo = (targetDir) => {
+    if (existsSync(path.join(targetDir, "bun.lock"))) {
+        return { name: "bun", lockFile: "bun.lock", command: "add" };
+    }
     const pnpmResult = {
         name: "pnpm",
         lockFile: "pnpm-lock.yaml",
@@ -24,15 +27,67 @@ const getPackageManagerInfo = (targetDir) => {
     }
     return pnpmResult;
 };
+const cleanupViteEntries = async (targetDir) => {
+    const nodeModulesDir = path.join(targetDir, "node_modules");
+    if (!existsSync(nodeModulesDir)) {
+        return;
+    }
+    try {
+        const entries = await fs.readdir(nodeModulesDir);
+        const viteEntries = entries.filter((entry) => entry.startsWith(".vite"));
+        for (const entry of viteEntries) {
+            const entryPath = path.join(nodeModulesDir, entry);
+            try {
+                const stat = await fs.lstat(entryPath);
+                if (!stat.isSymbolicLink()) {
+                    console.log(`Removing vite cache entry: ${entry}`);
+                    await fs.rm(entryPath, { recursive: true, force: true });
+                }
+                else {
+                    console.log(`Skipping symlinked vite cache entry: ${entry}`);
+                }
+            }
+            catch {
+                // If we can't stat it, try to remove it
+                console.log(`Removing vite cache entry: ${entry}`);
+                await fs.rm(entryPath, { recursive: true, force: true });
+            }
+        }
+    }
+    catch (error) {
+        console.log(`Failed to cleanup vite cache entries: ${error}`);
+    }
+};
 const performFullSync = async (sdkDir, targetDir) => {
     const sdkPackageJsonPath = path.join(sdkDir, "package.json");
     let originalSdkPackageJson = null;
     let tarballPath = "";
     let tarballName = "";
+    // Clean up vite cache
+    await cleanupViteEntries(targetDir);
     try {
+        try {
+            originalSdkPackageJson = await fs.readFile(sdkPackageJsonPath, "utf-8");
+            const packageJson = JSON.parse(originalSdkPackageJson);
+            const originalVersion = packageJson.version;
+            const timestamp = new Date()
+                .toISOString()
+                .replace(/[-:T.]/g, "")
+                .slice(0, 14);
+            const newVersion = `${originalVersion}+build.${timestamp}`;
+            console.log(`Temporarily setting version to ${newVersion}`);
+            packageJson.version = newVersion;
+            await fs.writeFile(sdkPackageJsonPath, JSON.stringify(packageJson, null, 2));
+        }
+        catch (e) {
+            console.warn("Could not modify package.json version, proceeding without it.");
+            originalSdkPackageJson = null; // don't restore if we failed to modify
+        }
         console.log("📦 Packing SDK...");
-        const packResult = await $({ cwd: sdkDir }) `npm pack`;
-        tarballName = packResult.stdout?.trim() ?? "";
+        const packResult = await $({ cwd: sdkDir }) `npm pack --json`;
+        const json = JSON.parse(packResult.stdout || "[]");
+        const packInfo = Array.isArray(json) ? json[0] : undefined;
+        tarballName = (packInfo && (packInfo.filename || packInfo.name)) || "";
         if (!tarballName) {
             console.error("❌ Failed to get tarball name from npm pack.");
             return;
@@ -49,6 +104,29 @@ const performFullSync = async (sdkDir, targetDir) => {
             .readFile(lockfilePath, "utf-8")
             .catch(() => null);
         try {
+            // For bun, we need to remove the existing dependency from package.json
+            // before adding the tarball to avoid a dependency loop error.
+            if (pm.name === "bun" && originalPackageJson) {
+                try {
+                    const targetPackageJson = JSON.parse(originalPackageJson);
+                    let modified = false;
+                    if (targetPackageJson.dependencies?.rwsdk) {
+                        delete targetPackageJson.dependencies.rwsdk;
+                        modified = true;
+                    }
+                    if (targetPackageJson.devDependencies?.rwsdk) {
+                        delete targetPackageJson.devDependencies.rwsdk;
+                        modified = true;
+                    }
+                    if (modified) {
+                        console.log("Temporarily removing rwsdk from target package.json to prevent dependency loop with bun.");
+                        await fs.writeFile(packageJsonPath, JSON.stringify(targetPackageJson, null, 2));
+                    }
+                }
+                catch (e) {
+                    console.warn("Could not modify target package.json, proceeding anyway.");
+                }
+            }
             const cmd = pm.name;
             const args = [pm.command];
             if (pm.name === "yarn") {
@@ -86,19 +164,63 @@ const performFullSync = async (sdkDir, targetDir) => {
         }
     }
 };
-const performFastSync = async (sdkDir, targetDir) => {
-    console.log("⚡️ No dependency changes, performing fast sync...");
-    const sdkPackageJson = JSON.parse(await fs.readFile(path.join(sdkDir, "package.json"), "utf-8"));
-    const filesToSync = sdkPackageJson.files || [];
-    for (const file of filesToSync) {
-        const source = path.join(sdkDir, file);
-        const destination = path.join(targetDir, "node_modules/rwsdk", file);
-        if (existsSync(source)) {
-            await fs.cp(source, destination, { recursive: true, force: true });
+const syncFilesWithRsyncOrFs = async (sdkDir, destDir, filesEntries) => {
+    const sources = filesEntries.map((p) => path.join(sdkDir, p));
+    // Always include package.json in sync
+    const pkgJsonPath = path.join(sdkDir, "package.json");
+    sources.push(pkgJsonPath);
+    await fs.mkdir(destDir, { recursive: true });
+    // Try rsync across all sources in one shot
+    try {
+        if (sources.length > 0) {
+            const rsyncArgs = [
+                "-a",
+                "--delete",
+                "--omit-dir-times",
+                "--no-perms",
+                "--no-owner",
+                "--no-group",
+                ...sources,
+                destDir + path.sep,
+            ];
+            await $({ stdio: "inherit" })("rsync", rsyncArgs);
+            return;
+        }
+    }
+    catch {
+        // fall through to fs fallback
+    }
+    console.log("Rsync failed, falling back to fs");
+    // Fallback: destructive copy using Node fs to mirror content
+    await fs.rm(destDir, { recursive: true, force: true });
+    await fs.mkdir(destDir, { recursive: true });
+    for (const src of sources) {
+        const rel = path.relative(sdkDir, src);
+        const dst = path.join(destDir, rel);
+        await fs.mkdir(path.dirname(dst), { recursive: true });
+        try {
+            const stat = await fs.lstat(src);
+            if (stat.isDirectory()) {
+                await fs.cp(src, dst, { recursive: true, force: true });
+            }
+            else {
+                await fs.copyFile(src, dst);
+            }
+        }
+        catch {
+            await fs.cp(src, dst, { recursive: true, force: true }).catch(() => { });
         }
     }
-    // Always copy package.json
-    await fs.copyFile(path.join(sdkDir, "package.json"), path.join(targetDir, "node_modules/rwsdk/package.json"));
+};
+const performFastSync = async (sdkDir, targetDir) => {
+    console.log("⚡️ No dependency changes, performing fast sync...");
+    // Clean up vite cache
+    await cleanupViteEntries(targetDir);
+    const nodeModulesPkgDir = path.join(targetDir, "node_modules", "rwsdk");
+    // Copy directories/files declared in package.json#files (plus package.json)
+    const filesToSync = JSON.parse(await fs.readFile(path.join(sdkDir, "package.json"), "utf-8"))
+        .files || [];
+    await syncFilesWithRsyncOrFs(sdkDir, nodeModulesPkgDir, filesToSync);
 };
 const areDependenciesEqual = (deps1, deps2) => {
     // Simple string comparison for this use case is sufficient
@@ -120,13 +242,8 @@ const performSync = async (sdkDir, targetDir) => {
     if (existsSync(installedSdkPackageJsonPath)) {
         const sdkPackageJsonContent = await fs.readFile(sdkPackageJsonPath, "utf-8");
         const installedSdkPackageJsonContent = await fs.readFile(installedSdkPackageJsonPath, "utf-8");
-        const sdkPkg = JSON.parse(sdkPackageJsonContent);
-        const installedPkg = JSON.parse(installedSdkPackageJsonContent);
-        if (areDependenciesEqual(sdkPkg.dependencies, installedPkg.dependencies) &&
-            areDependenciesEqual(sdkPkg.devDependencies, installedPkg.devDependencies) &&
-            areDependenciesEqual(sdkPkg.peerDependencies, installedPkg.peerDependencies)) {
-            packageJsonChanged = false;
-        }
+        packageJsonChanged =
+            sdkPackageJsonContent !== installedSdkPackageJsonContent;
     }
     if (packageJsonChanged) {
         console.log("📦 package.json changed, performing full sync...");
@@ -198,20 +315,19 @@ export const debugSync = async (opts) => {
         cwd: sdkDir,
     });
     let syncing = false;
-    // todo(justinvdm, 2025-07-22): Figure out wtf makes the full sync
-    // cause chokidar to find out about package.json after sync has resolved
-    let expectingFileChanges = Boolean(process.env.RWSDK_FORCE_FULL_SYNC);
-    watcher.on("all", async (_event, filePath) => {
-        if (syncing || filePath.endsWith(".tgz")) {
-            return;
-        }
-        if (expectingFileChanges && process.env.RWSDK_FORCE_FULL_SYNC) {
-            expectingFileChanges = false;
+    let pendingResync = false;
+    const triggerResync = async (reason) => {
+        if (syncing) {
+            pendingResync = true;
             return;
         }
         syncing = true;
-        expectingFileChanges = true;
-        console.log(`\nDetected change, re-syncing... (file: ${filePath})`);
+        if (reason) {
+            console.log(`\nDetected change, re-syncing... (file: ${reason})`);
+        }
+        else {
+            console.log(`\nDetected change, re-syncing...`);
+        }
         if (childProc && !childProc.killed) {
             console.log("Stopping running process...");
             childProc.kill();
@@ -220,7 +336,6 @@ export const debugSync = async (opts) => {
             });
         }
         try {
-            watcher.unwatch(filesToWatch);
             await performSync(sdkDir, targetDir);
             runWatchedCommand();
         }
@@ -230,8 +345,19 @@ export const debugSync = async (opts) => {
         }
         finally {
             syncing = false;
-            watcher.add(filesToWatch);
         }
+        if (pendingResync) {
+            pendingResync = false;
+            // Coalesce any rapid additional events into a single follow-up sync
+            await new Promise((r) => setTimeout(r, 50));
+            return triggerResync();
+        }
+    };
+    watcher.on("all", async (_event, filePath) => {
+        if (filePath.endsWith(".tgz")) {
+            return;
+        }
+        await triggerResync(filePath);
     });
     const cleanup = async () => {
         console.log("\nCleaning up...");

package/dist/scripts/worker-run.mjs

@@ -16,13 +16,18 @@ export const runWorkerScript = async (relativeScriptPath) => {
         console.error("Error: Script path is required");
         console.log("\nUsage:");
         console.log("  npm run worker:run <script-path>");
-        console.log("\nExample:");
-        console.log("  npm run worker:run src/scripts/seed.ts\n");
+        console.log("\nOptions:");
+        console.log("  RWSDK_WRANGLER_CONFIG      Environment variable for config path");
+        console.log("\nExamples:");
+        console.log("  npm run worker:run src/scripts/seed.ts");
+        console.log("  RWSDK_WRANGLER_CONFIG=custom.toml npm run worker:run src/scripts/seed.ts\n");
         process.exit(1);
     }
     const scriptPath = resolve(process.cwd(), relativeScriptPath);
     debug("Running worker script: %s", scriptPath);
-    const workerConfigPath = await findWranglerConfig(process.cwd());
+    const workerConfigPath = process.env.RWSDK_WRANGLER_CONFIG
+        ? resolve(process.cwd(), process.env.RWSDK_WRANGLER_CONFIG)
+        : await findWranglerConfig(process.cwd());
     debug("Using wrangler config: %s", workerConfigPath);
     const workerConfig = unstable_readConfig({
         config: workerConfigPath,

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/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/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,28 +42,41 @@ 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);
@@ -71,39 +85,45 @@ function resolveEnvImportMappings(env) {
     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),
+    ]));
+    function createEsbuildResolverPlugin(envName, mappings) {
+        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);
+                    let resolved = mappings.get(args.path);
+                    if (!resolved) {
+                        resolved = resolveReactImport(args.path, envName, projectRootDir);
+                    }
+                    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);
+                    }
+                });
+            },
+        };
+    }
     return [
         {
             name: "rwsdk:react-conditions-resolver:config",
@@ -125,7 +145,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 ??= {};
@@ -166,7 +186,10 @@ export const reactConditionsResolverPlugin = () => {
                         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);
                     return resolved;

package/dist/vite/redwoodPlugin.d.mts

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

package/dist/vite/redwoodPlugin.mjs

@@ -3,6 +3,7 @@ import { unstable_readConfig } from "wrangler";
 import { cloudflare } from "@cloudflare/vite-plugin";
 import { devServerConstantPlugin } from "./devServerConstant.mjs";
 import { hasOwnCloudflareVitePlugin } from "./hasOwnCloudflareVitePlugin.mjs";
+import { hasOwnReactVitePlugin } from "./hasOwnReactVitePlugin.mjs";
 import reactPlugin from "@vitejs/plugin-react";
 import tsconfigPaths from "vite-tsconfig-paths";
 import { transformJsxScriptTagsPlugin } from "./transformJsxScriptTagsPlugin.mjs";
@@ -32,7 +33,10 @@ const determineWorkerEntryPathname = async (projectRootDir, workerConfigPath, op
 };
 export const redwoodPlugin = async (options = {}) => {
     const projectRootDir = process.cwd();
-    const workerConfigPath = options.configPath ?? (await findWranglerConfig(projectRootDir));
+    const workerConfigPath = options.configPath ??
+        (process.env.RWSDK_WRANGLER_CONFIG
+            ? resolve(projectRootDir, process.env.RWSDK_WRANGLER_CONFIG)
+            : await findWranglerConfig(projectRootDir));
     const workerEntryPathname = await determineWorkerEntryPathname(projectRootDir, workerConfigPath, options);
     const clientEntryPathnames = (Array.isArray(options.entry?.client)
         ? options.entry.client
@@ -41,6 +45,8 @@ export const redwoodPlugin = async (options = {}) => {
     const serverFiles = new Set();
     const shouldIncludeCloudflarePlugin = options.includeCloudflarePlugin ??
         !(await hasOwnCloudflareVitePlugin({ rootProjectDir: projectRootDir }));
+    const shouldIncludeReactPlugin = options.includeReactPlugin ??
+        !(await hasOwnReactVitePlugin({ rootProjectDir: projectRootDir }));
     // context(justinvdm, 31 Mar 2025): We assume that if there is no .wrangler directory,
     // then this is fresh install, and we run `npm run dev:init` here.
     if (process.env.RWSDK_WORKER_RUN !== "1" &&
@@ -68,7 +74,7 @@ export const redwoodPlugin = async (options = {}) => {
             serverFiles,
             projectRootDir,
         }),
-        reactConditionsResolverPlugin(),
+        reactConditionsResolverPlugin({ projectRootDir }),
         tsconfigPaths({ root: projectRootDir }),
         shouldIncludeCloudflarePlugin
             ? cloudflare({
@@ -83,7 +89,7 @@ export const redwoodPlugin = async (options = {}) => {
             viteEnvironment: { name: "worker" },
             workerEntryPathname,
         }),
-        reactPlugin(),
+        shouldIncludeReactPlugin ? reactPlugin() : [],
         directivesPlugin({
             projectRootDir,
             clientFiles,