rwsdk 1.2.4-test.20260428112212 → 1.2.5

package/dist/runtime/render/assembleDocument.js

@@ -17,6 +17,6 @@ export const assembleDocument = ({ requestInfo, pageElement, shouldSSR, }) => {
     };
     const Document = requestInfo.rw.Document;
     return (_jsxs(Document, { ...requestInfo, children: [_jsx("script", { nonce: requestInfo.rw.nonce, dangerouslySetInnerHTML: {
-                    __html: `globalThis.__RWSDK_CONTEXT = ${JSON.stringify(clientContext)};if(!globalThis.__webpack_require__){globalThis.__webpack_require__=function(id){throw new Error("rwsdk: __webpack_require__ called before client init for: "+id)};globalThis.__webpack_require__.u=function(){}}`,
+                    __html: `globalThis.__RWSDK_CONTEXT = ${JSON.stringify(clientContext)}`,
                 } }), _jsx(Stylesheets, { requestInfo: requestInfo }), _jsx(Preloads, { requestInfo: requestInfo }), _jsx("div", { id: "hydrate-root", children: pageElement })] }));
 };

package/dist/runtime/render/renderDocumentHtmlStream.js

@@ -20,7 +20,7 @@ export const renderDocumentHtmlStream = async ({ rscPayloadStream, Document, req
     };
     // Create the outer document with a marker for injection
     const documentElement = (_jsxs(Document, { ...requestInfo, children: [_jsx("script", { nonce: requestInfo.rw.nonce, dangerouslySetInnerHTML: {
-                    __html: `globalThis.__RWSDK_CONTEXT = ${JSON.stringify(clientContext)};if(!globalThis.__webpack_require__){globalThis.__webpack_require__=function(id){throw new Error("rwsdk: __webpack_require__ called before client init for: "+id)};globalThis.__webpack_require__.u=function(){}}`,
+                    __html: `globalThis.__RWSDK_CONTEXT = ${JSON.stringify(clientContext)}`,
                 } }), _jsx(Stylesheets, { requestInfo: requestInfo }), _jsx(Preloads, { requestInfo: requestInfo }), _jsx("div", { id: "hydrate-root", children: _jsx("div", { id: "rwsdk-app-start" }) })] }));
     const outerHtmlStream = await renderHtmlStream({
         node: documentElement,

package/dist/runtime/render/stylesheets.js

@@ -23,20 +23,6 @@ const findCssForModule = (scriptId, manifest) => {
                 css.add(href);
             }
         }
-        // context(justinvdm, 2026-04-23): Rolldown associates CSS with the
-        // chunk that imports the CSS file, which may be a dynamic import target
-        // rather than the entry chunk. Walk both static and dynamic imports to
-        // find CSS from transitive dependencies.
-        if (entry.imports) {
-            for (const importId of entry.imports) {
-                inner(importId);
-            }
-        }
-        if (entry.dynamicImports) {
-            for (const importId of entry.dynamicImports) {
-                inner(importId);
-            }
-        }
     };
     inner(scriptId);
     return Array.from(css);
@@ -51,13 +37,5 @@ export const Stylesheets = async ({ requestInfo, }) => {
             allStylesheets.add(toAbsoluteHref(entry));
         }
     }
-    for (const [, entry] of Object.entries(manifest)) {
-        if (entry.isEntry) {
-            const css = findCssForModule(entry.src ?? "", manifest);
-            for (const href of css) {
-                allStylesheets.add(toAbsoluteHref(href));
-            }
-        }
-    }
     return (_jsx(_Fragment, { children: Array.from(allStylesheets).map((href) => (_jsx("link", { rel: "stylesheet", href: href, precedence: "first" }, href))) }));
 };

package/dist/vite/buildApp.mjs

@@ -63,29 +63,14 @@ export async function buildApp({ builder, clientEntryPoints, clientFiles, server
     clientEnv.config.build ??= {};
     clientEnv.config.build.rollupOptions ??= {};
     const clientEntryPointsArray = Array.from(clientEntryPoints);
-    // context(justinvdm, 2026-04-23): Vite 7's Rollup tolerated a missing
-    // src/client.tsx default input (silent empty bundle). Vite 8's Rolldown
-    // raises [UNRESOLVED_ENTRY] / [INVALID_OPTION] when input doesn't resolve
-    // or is empty. Only fall back to the default if the file actually exists,
-    // and skip the client build entirely if there's nothing to build.
-    let runClientBuild = true;
     if (clientEntryPointsArray.length === 0) {
-        const defaultClientEntry = resolve(projectRootDir, "src/client.tsx");
-        if (existsSync(defaultClientEntry)) {
-            log("No client entry points discovered, using default: src/client.tsx");
-            clientEnv.config.build.rollupOptions.input = ["src/client.tsx"];
-        }
-        else {
-            log("No client entry points discovered and src/client.tsx not present; skipping client build");
-            runClientBuild = false;
-        }
+        log("No client entry points discovered, using default: src/client.tsx");
+        clientEnv.config.build.rollupOptions.input = ["src/client.tsx"];
     }
     else {
         clientEnv.config.build.rollupOptions.input = clientEntryPointsArray;
     }
-    if (runClientBuild) {
-        await builder.build(clientEnv);
-    }
+    await builder.build(clientEnv);
     console.log("Linking worker build...");
     process.env.RWSDK_BUILD_PASS = "linker";
     // Re-configure the worker environment for the linking pass

package/dist/vite/configPlugin.mjs

@@ -45,13 +45,11 @@ export const configPlugin = ({ silent, projectRootDir, workerEntryPathname, clie
                 ],
                 exclude: [],
                 entries: [workerEntryPathname],
-                rolldownOptions: {
-                    transform: {
-                        jsx: "react-jsx",
-                        define: {
-                            "process.env.NODE_ENV": JSON.stringify(mode),
-                            "__webpack_require__": "globalThis.__webpack_require__",
-                        },
+                esbuildOptions: {
+                    jsx: "automatic",
+                    jsxImportSource: "react",
+                    define: {
+                        "process.env.NODE_ENV": JSON.stringify(mode),
                     },
                 },
             },
@@ -67,9 +65,6 @@ export const configPlugin = ({ silent, projectRootDir, workerEntryPathname, clie
             appType: "custom",
             mode,
             logLevel: silent ? "silent" : "info",
-            resolve: {
-                tsconfigPaths: true,
-            },
             build: {
                 minify: mode !== "development",
                 sourcemap: true,
@@ -104,13 +99,12 @@ export const configPlugin = ({ silent, projectRootDir, workerEntryPathname, clie
                             "rwsdk/turnstile",
                         ],
                         entries: [],
-                        rolldownOptions: {
-                            transform: {
-                                jsx: "react-jsx",
-                                define: {
-                                    "process.env.NODE_ENV": JSON.stringify(mode),
-                                    "__webpack_require__": "globalThis.__webpack_require__",
-                                },
+                        esbuildOptions: {
+                            jsx: "automatic",
+                            jsxImportSource: "react",
+                            plugins: [],
+                            define: {
+                                "process.env.NODE_ENV": JSON.stringify(mode),
                             },
                         },
                     },
@@ -142,13 +136,12 @@ export const configPlugin = ({ silent, projectRootDir, workerEntryPathname, clie
                             "rwsdk/realtime/durableObject",
                             "rwsdk/realtime/worker",
                         ],
-                        rolldownOptions: {
-                            transform: {
-                                jsx: "react-jsx",
-                                define: {
-                                    "process.env.NODE_ENV": JSON.stringify(mode),
-                                    "__webpack_require__": "globalThis.__webpack_require__",
-                                },
+                        esbuildOptions: {
+                            jsx: "automatic",
+                            jsxImportSource: "react",
+                            plugins: [],
+                            define: {
+                                "process.env.NODE_ENV": JSON.stringify(mode),
                             },
                         },
                     },

package/dist/vite/createDirectiveLookupPlugin.mjs

@@ -1,7 +1,6 @@
 import debug from "debug";
 import MagicString from "magic-string";
 import path from "path";
-import { addOptimizeDepsPlugin } from "./addOptimizeDepsPlugin.mjs";
 import { VENDOR_CLIENT_BARREL_EXPORT_PATH, VENDOR_SERVER_BARREL_EXPORT_PATH, } from "../lib/constants.mjs";
 export function generateLookupMap({ files, isDev, kind, exportName, }) {
     const s = new MagicString(`
@@ -56,27 +55,32 @@ export const createDirectiveLookupPlugin = async ({ projectRootDir, files, confi
                 return;
             }
             log("Configuring environment: env=%s", env);
-            const escapedVirtualModuleName = config.virtualModuleName.replace(/[-\/\\^$*+?.()|[\]{}]/g, "\\$&");
-            const escapedPrefixedModuleName = `/@id/${config.virtualModuleName}`.replace(/[-\/\\^$*+?.()|[\]{}]/g, "\\$&");
-            const lookupFilter = new RegExp(`^(${escapedVirtualModuleName}|${escapedPrefixedModuleName})\\.js$`);
-            addOptimizeDepsPlugin(viteConfig, {
+            viteConfig.optimizeDeps ??= {};
+            viteConfig.optimizeDeps.esbuildOptions ??= {};
+            viteConfig.optimizeDeps.esbuildOptions.plugins ??= [];
+            viteConfig.optimizeDeps.esbuildOptions.plugins.push({
                 name: `rwsdk:${config.pluginName}`,
-                resolveId(id) {
-                    if (lookupFilter.test(id)) {
+                setup(build) {
+                    log("Setting up esbuild plugin for %s", config.virtualModuleName);
+                    // Handle both direct virtual module name and /@id/ prefixed version
+                    const escapedVirtualModuleName = config.virtualModuleName.replace(/[-\/\\^$*+?.()|[\]{}]/g, "\\$&");
+                    const escapedPrefixedModuleName = `/@id/${config.virtualModuleName}`.replace(/[-\/\\^$*+?.()|[\]{}]/g, "\\$&");
+                    build.onResolve({
+                        filter: new RegExp(`^(${escapedVirtualModuleName}|${escapedPrefixedModuleName})\\.js$`),
+                    }, () => {
                         process.env.VERBOSE &&
-                            log("Marking %s as external", config.virtualModuleName);
+                            log("Esbuild onResolve: marking %s as external", config.virtualModuleName);
                         return {
-                            id: `${config.virtualModuleName}.js`,
+                            path: `${config.virtualModuleName}.js`,
                             external: true,
                         };
-                    }
+                    });
                 },
             });
             const shouldOptimizeForEnv = !config.optimizeForEnvironments ||
                 config.optimizeForEnvironments.includes(env);
             if (shouldOptimizeForEnv) {
                 log("Applying optimizeDeps and aliasing for environment: %s", env);
-                viteConfig.optimizeDeps ??= {};
                 viteConfig.optimizeDeps.include ??= [];
                 for (const file of files) {
                     if (file.includes("node_modules")) {

package/dist/vite/directiveModulesDevPlugin.mjs

@@ -99,36 +99,52 @@ export const directiveModulesDevPlugin = ({ clientFiles, serverFiles, projectRoo
                 else if (envName === "worker") {
                     entries.push(APP_SERVER_BARREL_PATH);
                 }
-                const appBarrelPaths = [
-                    APP_CLIENT_BARREL_PATH,
-                    APP_SERVER_BARREL_PATH,
-                ];
-                const appBarrelFilter = new RegExp(`(${appBarrelPaths
-                    .map((p) => p.replace(/\\/g, "\\\\"))
-                    .join("|")})$`);
-                const BARREL_PREFIX = "\0rwsdk-app-barrel:";
-                env.optimizeDeps.rolldownOptions ??= {};
-                env.optimizeDeps.rolldownOptions.plugins ??= [];
-                env.optimizeDeps.rolldownOptions.plugins.unshift({
+                env.optimizeDeps.esbuildOptions ??= {};
+                env.optimizeDeps.esbuildOptions.plugins ??= [];
+                env.optimizeDeps.esbuildOptions.plugins.unshift({
                     name: "rwsdk:app-barrel-blocker",
-                    async resolveId(id) {
-                        await scanPromise;
-                        if (appBarrelFilter.test(id)) {
-                            return `${BARREL_PREFIX}${id}`;
-                        }
-                        if (id.startsWith("/") &&
-                            (id.includes("/src/") || id.includes("/generated/")) &&
-                            !id.includes("node_modules")) {
-                            return id;
-                        }
-                    },
-                    load(id) {
-                        if (id.startsWith(BARREL_PREFIX)) {
-                            const barrelPath = id.slice(BARREL_PREFIX.length);
-                            const isServerBarrel = barrelPath.includes("app-server-barrel");
+                    setup(build) {
+                        const appBarrelPaths = [
+                            APP_CLIENT_BARREL_PATH,
+                            APP_SERVER_BARREL_PATH,
+                        ];
+                        const appBarrelFilter = new RegExp(`(${appBarrelPaths
+                            .map((p) => p.replace(/\\/g, "\\\\"))
+                            .join("|")})$`);
+                        build.onResolve({ filter: /.*/ }, async (args) => {
+                            // Block all resolutions until the scan is complete.
+                            await scanPromise;
+                            // Handle app barrel files
+                            if (appBarrelFilter.test(args.path)) {
+                                return {
+                                    path: args.path,
+                                    namespace: "rwsdk-app-barrel-ns",
+                                };
+                            }
+                            // context(justinvdm, 11 Sep 2025): Prevent Vite from
+                            // externalizing our application files. If we don't, paths
+                            // imported in our application barrel files will be marked as
+                            // external, and thus not scanned for dependencies.
+                            if (args.path.startsWith("/") &&
+                                (args.path.includes("/src/") ||
+                                    args.path.includes("/generated/")) &&
+                                !args.path.includes("node_modules")) {
+                                // By returning a result, we claim the module and prevent vite:dep-scan
+                                // from marking it as external.
+                                return {
+                                    path: args.path,
+                                };
+                            }
+                        });
+                        build.onLoad({ filter: /.*/, namespace: "rwsdk-app-barrel-ns" }, (args) => {
+                            const isServerBarrel = args.path.includes("app-server-barrel");
                             const files = isServerBarrel ? serverFiles : clientFiles;
-                            return generateAppBarrelContent(files, projectRootDir);
-                        }
+                            const content = generateAppBarrelContent(files, projectRootDir);
+                            return {
+                                contents: content,
+                                loader: "js",
+                            };
+                        });
                     },
                 });
             }

package/dist/vite/directivesFilteringPlugin.mjs

@@ -19,9 +19,6 @@ export const directivesFilteringPlugin = ({ clientFiles, serverFiles, projectRoo
                         absolute: true,
                     });
                     const info = this.getModuleInfo(absoluteId);
-                    // context(justinvdm, 2026-04-23): Rollup exposes `isIncluded` on
-                    // ModuleInfo; Rolldown (Vite 8) does not. Treat absent as "included"
-                    // so we only delete on an explicit `false` from Rollup.
                     if (!info ||
                         (typeof info.isIncluded !== "undefined" && !info.isIncluded)) {
                         files.delete(id);

package/dist/vite/directivesPlugin.mjs

@@ -2,7 +2,6 @@ import debug from "debug";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { normalizeModulePath } from "../lib/normalizeModulePath.mjs";
-import { addOptimizeDepsPlugin } from "./addOptimizeDepsPlugin.mjs";
 import { transformClientComponents } from "./transformClientComponents.mjs";
 import { transformServerFunctions } from "./transformServerFunctions.mjs";
 const log = debug("rwsdk:vite:rsc-directives-plugin");
@@ -93,56 +92,100 @@ export const directivesPlugin = ({ projectRootDir, clientFiles, serverFiles, })
                 return;
             }
             process.env.VERBOSE && log("Configuring environment: env=%s", env);
-            const directivesFileFilter = /\.(js|ts|jsx|tsx|mts|mjs|cjs)$/;
-            async function handleDirectivesLoad(filePath) {
-                const normalizedPath = normalizeModulePath(filePath, projectRootDir);
-                if (!filePath.includes("node_modules")) {
-                    if (clientFiles.has(normalizedPath)) {
-                        if (env === "client" || env === "ssr") {
-                            return undefined;
+            config.optimizeDeps ??= {};
+            config.optimizeDeps.esbuildOptions ??= {};
+            config.optimizeDeps.esbuildOptions.plugins ??= [];
+            config.optimizeDeps.esbuildOptions.plugins.push({
+                name: "rsc-directives-esbuild-transform",
+                setup(build) {
+                    log("Setting up esbuild plugin for environment: %s", env);
+                    build.onLoad({ filter: /\.(js|ts|jsx|tsx|mts|mjs|cjs)$/ }, async (args) => {
+                        process.env.VERBOSE &&
+                            log("Esbuild onLoad called for environment=%s, path=%s", env, args.path);
+                        const normalizedPath = normalizeModulePath(args.path, projectRootDir);
+                        // context(justinvdm,2025-06-15): If we're in app code,
+                        // we will be doing the transform work in the vite plugin hooks,
+                        // the only reason we're in esbuild land for app code is for
+                        // dependency discovery, so we can skip transform work
+                        // and use heuristics instead - see below inside if block
+                        if (!args.path.includes("node_modules")) {
+                            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
+                                // original source code to discovery dependencies
+                                // * for worker env, the transform would have just created
+                                // references and dropped all imports, so we can just return empty code
+                                if (env === "client" || env === "ssr") {
+                                    log("Esbuild onLoad skipping client module in app code for client or ssr env, path=%s", args.path);
+                                    return undefined;
+                                }
+                                else {
+                                    log("Esbuild onLoad returning empty code for server module in app code for worker env, path=%s to bypass esbuild dependency discovery", args.path);
+                                    return {
+                                        contents: "",
+                                        loader: "js",
+                                    };
+                                }
+                            }
+                            else if (serverFiles.has(normalizedPath)) {
+                                // context(justinvdm,2025-06-15): If this is a server file:
+                                // * for worker env, we can skip so esbuild looks at the
+                                // original source code to discovery dependencies
+                                // * for ssr and client envs, the transform would have just created
+                                // references and dropped all imports, so we can just return empty code
+                                if (env === "worker") {
+                                    log("Esbuild onLoad skipping server module in app code for worker env, path=%s", args.path);
+                                    return undefined;
+                                }
+                                else if (env === "ssr" || env === "client") {
+                                    log("Esbuild onLoad returning empty code for server module in app code for ssr or client env, path=%s", args.path);
+                                    return {
+                                        contents: "",
+                                        loader: "js",
+                                    };
+                                }
+                            }
                         }
-                        else {
-                            return { code: "", moduleType: "js" };
+                        let code;
+                        try {
+                            code = await fs.readFile(args.path, "utf-8");
                         }
-                    }
-                    else if (serverFiles.has(normalizedPath)) {
-                        if (env === "worker") {
+                        catch {
+                            process.env.VERBOSE &&
+                                log("Failed to read file: %s, environment=%s", args.path, env);
                             return undefined;
                         }
-                        else if (env === "ssr" || env === "client") {
-                            return { code: "", moduleType: "js" };
+                        const clientResult = await transformClientComponents(code, normalizedPath, {
+                            environmentName: env,
+                            clientFiles,
+                            isEsbuild: true,
+                        });
+                        if (clientResult) {
+                            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 {
+                                contents: clientResult.code,
+                                loader: getLoader(args.path),
+                            };
                         }
-                    }
-                }
-                let code;
-                try {
-                    code = await fs.readFile(filePath, "utf-8");
-                }
-                catch {
-                    return undefined;
-                }
-                const clientResult = await transformClientComponents(code, normalizedPath, { environmentName: env, clientFiles, isEsbuild: true });
-                if (clientResult) {
-                    return { code: clientResult.code, moduleType: getLoader(filePath) };
-                }
-                const serverResult = transformServerFunctions(code, normalizedPath, env, serverFiles);
-                if (serverResult) {
-                    return { code: serverResult.code, moduleType: getLoader(filePath) };
-                }
-                return undefined;
-            }
-            addOptimizeDepsPlugin(config, {
-                name: "rsc-directives-transform",
-                async load(id) {
-                    if (!directivesFileFilter.test(id)) {
-                        return;
-                    }
-                    const result = await handleDirectivesLoad(id);
-                    if (result) {
-                        return { code: result.code, moduleType: result.moduleType };
-                    }
+                        const serverResult = transformServerFunctions(code, normalizedPath, env, serverFiles);
+                        if (serverResult) {
+                            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),
+                            };
+                        }
+                        process.env.VERBOSE &&
+                            log("Esbuild no transformation applied for environment=%s, path=%s", env, args.path);
+                    });
                 },
             });
+            process.env.VERBOSE &&
+                log("Environment configuration complete for env=%s", env);
         },
     };
 };

package/dist/vite/knownDepsResolverPlugin.mjs

@@ -91,34 +91,44 @@ export const knownDepsResolverPlugin = ({ 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("Known dependencies resolver configured with %d total mappings across %d environments", totalMappings, Object.keys(ENV_IMPORT_MAPPINGS).length);
-    function createResolverPlugin(envName, mappings) {
+    function createEsbuildResolverPlugin(envName, mappings) {
         if (!mappings) {
             return null;
         }
+        // Create reverse mapping from slugified names to original imports
+        // Vite converts "react-dom/server.edge" -> "react-dom_server__edge"
+        // Pattern: / becomes _, . becomes __
         const slugifiedToOriginal = new Map();
-        for (const [original] of mappings) {
+        for (const [original, resolved] of mappings) {
             const slugified = original.replace(/\//g, "_").replace(/\./g, "__");
             slugifiedToOriginal.set(slugified, original);
         }
         return {
-            name: `rwsdk:known-dependencies-resolver-${envName}`,
-            resolveId(id) {
-                let resolved = mappings.get(id);
-                if (!resolved) {
-                    const originalImport = slugifiedToOriginal.get(id);
-                    if (originalImport) {
-                        resolved = mappings.get(originalImport);
+            name: `rwsdk:known-dependencies-resolver-esbuild-${envName}`,
+            setup(build) {
+                build.onResolve({ filter: /.*/ }, (args) => {
+                    let resolved = mappings.get(args.path);
+                    // If not found, check if it's a slugified version
+                    if (!resolved) {
+                        const originalImport = slugifiedToOriginal.get(args.path);
+                        if (originalImport) {
+                            resolved = mappings.get(originalImport);
+                        }
                     }
-                }
-                if (!resolved) {
-                    resolved = resolveKnownImport(id, envName, projectRootDir);
-                }
-                if (resolved) {
-                    if (id === "react-server-dom-webpack/client.edge") {
-                        return;
+                    if (!resolved) {
+                        resolved = resolveKnownImport(args.path, envName, projectRootDir);
                     }
-                    return resolved;
-                }
+                    // Resolve for both entry points (importer === '') and regular imports
+                    // Entry points come from optimizeDeps.include and are critical to intercept
+                    if (resolved) {
+                        if (args.path === "react-server-dom-webpack/client.edge") {
+                            return;
+                        }
+                        return {
+                            path: resolved,
+                        };
+                    }
+                });
             },
         };
     }
@@ -142,20 +152,17 @@ export const knownDepsResolverPlugin = ({ projectRootDir, }) => {
                         config.environments[envName] = {};
                     }
                     const envConfig = config.environments[envName];
-                    if (mappings) {
+                    const esbuildPlugin = createEsbuildResolverPlugin(envName, mappings);
+                    if (esbuildPlugin && mappings) {
                         envConfig.optimizeDeps ??= {};
-                        envConfig.optimizeDeps.rolldownOptions ??= {};
-                        envConfig.optimizeDeps.rolldownOptions.transform ??= {};
-                        envConfig.optimizeDeps.rolldownOptions.transform.define ??= {};
-                        envConfig.optimizeDeps.rolldownOptions.transform.define["process.env.NODE_ENV"] = JSON.stringify(process.env.NODE_ENV);
-                        envConfig.optimizeDeps.rolldownOptions.plugins ??= [];
-                        const plugin = createResolverPlugin(envName, mappings);
-                        if (plugin) {
-                            envConfig.optimizeDeps.rolldownOptions.plugins.push(plugin);
-                        }
+                        envConfig.optimizeDeps.esbuildOptions ??= {};
+                        envConfig.optimizeDeps.esbuildOptions.define ??= {};
+                        envConfig.optimizeDeps.esbuildOptions.define["process.env.NODE_ENV"] = JSON.stringify(process.env.NODE_ENV);
+                        envConfig.optimizeDeps.esbuildOptions.plugins ??= [];
+                        envConfig.optimizeDeps.esbuildOptions.plugins.push(esbuildPlugin);
                         envConfig.optimizeDeps.include ??= [];
                         envConfig.optimizeDeps.include.push(...predefinedImports);
-                        log("Added optimizeDeps plugin and includes for environment: %s", envName);
+                        log("Added esbuild plugin and optimizeDeps includes for environment: %s", envName);
                     }
                     const aliases = ensureAliasArray(envConfig);
                     for (const [find, replacement] of mappings) {

package/dist/vite/linkerPlugin.mjs

@@ -9,7 +9,7 @@ export function linkWorkerBundle({ code, manifestContent, projectRootDir, base,
     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);
+    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)) {

package/dist/vite/prismaPlugin.mjs

@@ -1,5 +1,4 @@
 import { resolve } from "node:path";
-import { addOptimizeDepsPlugin } from "./addOptimizeDepsPlugin.mjs";
 import { checkPrismaStatus } from "./checkIsUsingPrisma.mjs";
 import { ensureAliasArray } from "./ensureAliasArray.mjs";
 import { invalidateCacheIfPrismaClientChanged } from "./invalidateCacheIfPrismaClientChanged.mjs";
@@ -22,13 +21,17 @@ export const prismaPlugin = async ({ projectRootDir, }) => {
                 return;
             }
             const wasmPath = resolve(projectRootDir, "node_modules/.prisma/client/wasm.js");
-            const prismaFilter = /^.prisma\/client\/default/;
-            addOptimizeDepsPlugin(config, {
+            config.optimizeDeps ??= {};
+            config.optimizeDeps.esbuildOptions ??= {};
+            config.optimizeDeps.esbuildOptions.plugins ??= [];
+            config.optimizeDeps.esbuildOptions.plugins.push({
                 name: "rwsdk:prisma",
-                resolveId(id) {
-                    if (prismaFilter.test(id)) {
-                        return wasmPath;
-                    }
+                setup(build) {
+                    build.onResolve({ filter: /^.prisma\/client\/default/ }, async () => {
+                        return {
+                            path: wasmPath,
+                        };
+                    });
                 },
             });
             ensureAliasArray(config).push({

package/dist/vite/redwoodPlugin.mjs

@@ -6,6 +6,7 @@ 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 { pathExists } from "fs-extra";
 import { $ } from "../lib/$.mjs";
 import { findWranglerConfig } from "../lib/findWranglerConfig.mjs";
@@ -111,6 +112,7 @@ export const redwoodPlugin = async (options = {}) => {
         }),
         knownDepsResolverPlugin({ projectRootDir }),
         cloudflarePreInitPlugin(),
+        tsconfigPaths({ root: projectRootDir }),
         shouldIncludeCloudflarePlugin
             ? cloudflare({
                 viteEnvironment: { name: "worker" },

package/dist/vite/ssrBridgePlugin.mjs

@@ -1,7 +1,6 @@
 import debug from "debug";
 import MagicString from "magic-string";
 import { INTERMEDIATE_SSR_BRIDGE_PATH } from "../lib/constants.mjs";
-import { addOptimizeDepsPlugin } from "./addOptimizeDepsPlugin.mjs";
 import { externalModulesSet } from "./constants.mjs";
 import { findSsrImportCallSites } from "./findSsrSpecifiers.mjs";
 const log = debug("rwsdk:vite:ssr-bridge-plugin");
@@ -50,18 +49,31 @@ export const ssrBridgePlugin = ({ clientFiles, serverFiles, }) => {
         configEnvironment(env, config) {
             log("Configuring environment: env=%s", env);
             if (env === "worker") {
+                // Configure esbuild to mark rwsdk/__ssr paths as external for worker environment
+                log("Configuring esbuild options for worker environment");
                 config.optimizeDeps ??= {};
+                config.optimizeDeps.esbuildOptions ??= {};
+                config.optimizeDeps.esbuildOptions.plugins ??= [];
                 config.optimizeDeps.include ??= [];
-                addOptimizeDepsPlugin(config, {
+                config.optimizeDeps.esbuildOptions.plugins.push({
                     name: "rwsdk-ssr-external",
-                    resolveId(id) {
-                        if (id === "rwsdk/__ssr_bridge" ||
-                            id.startsWith(VIRTUAL_SSR_PREFIX)) {
-                            log("Marking as external: %s", id);
-                            return { id, external: true };
-                        }
+                    setup(build) {
+                        log("Setting up esbuild plugin to mark rwsdk/__ssr paths as external for worker");
+                        build.onResolve({ filter: /.*$/ }, (args) => {
+                            process.env.VERBOSE &&
+                                log("Esbuild onResolve called for path=%s, args=%O", args.path, args);
+                            if (args.path === "rwsdk/__ssr_bridge" ||
+                                args.path.startsWith(VIRTUAL_SSR_PREFIX)) {
+                                log("Marking as external: %s", args.path);
+                                return {
+                                    path: args.path,
+                                    external: true,
+                                };
+                            }
+                        });
                     },
                 });
+                log("Worker environment esbuild configuration complete");
             }
         },
         async resolveId(id, importer, options) {

package/dist/vite/statePlugin.mjs

@@ -1,7 +1,6 @@
 import debug from "debug";
 import fs from "node:fs/promises";
 import { RW_STATE_EXPORT_PATH } from "../lib/constants.mjs";
-import { addOptimizeDepsPlugin } from "./addOptimizeDepsPlugin.mjs";
 import { maybeResolveEnvImport } from "./envResolvers.mjs";
 const log = debug("rwsdk:vite:state-plugin");
 const VIRTUAL_STATE_PREFIX = "virtual:rwsdk:state:";
@@ -23,14 +22,22 @@ export const statePlugin = ({ projectRootDir, }) => {
         },
         configEnvironment(env, config) {
             if (env === "worker") {
-                const stateFilter = new RegExp(`^(${RW_STATE_EXPORT_PATH}|${VIRTUAL_STATE_PREFIX}.*)$`);
-                addOptimizeDepsPlugin(config, {
+                config.optimizeDeps ??= {};
+                config.optimizeDeps.esbuildOptions ??= {};
+                config.optimizeDeps.esbuildOptions.plugins ??= [];
+                config.optimizeDeps.esbuildOptions.plugins.push({
                     name: "rwsdk-state-external",
-                    resolveId(id) {
-                        if (stateFilter.test(id)) {
-                            log("Marking as external: %s", id);
-                            return { id, external: true };
-                        }
+                    setup(build) {
+                        build.onResolve({
+                            // context(justinvdm, 13 Oct 2025): Vite dep optimizer slugifies the export path
+                            filter: new RegExp(`^(${RW_STATE_EXPORT_PATH}|${VIRTUAL_STATE_PREFIX}.*)$`),
+                        }, (args) => {
+                            log("Marking as external: %s", args.path);
+                            return {
+                                path: args.path,
+                                external: true,
+                            };
+                        });
                     },
                 });
             }

package/dist/vite/transformJsxScriptTagsPlugin.mjs

@@ -105,9 +105,9 @@ export async function transformJsxScriptTagsCode(code, clientEntryPoints, manife
         .forEach((callExpr) => {
         const expression = callExpr.getExpression();
         const expressionText = expression.getText();
-        if (!expressionText.endsWith("jsx") &&
-            !expressionText.endsWith("jsxs") &&
-            !expressionText.endsWith("jsxDEV")) {
+        if (expressionText !== "jsx" &&
+            expressionText !== "jsxs" &&
+            expressionText !== "jsxDEV") {
             return;
         }
         const args = callExpr.getArguments();

package/dist/vite/vitePreamblePlugin.d.mts

@@ -1,2 +1,153 @@
-import type { Plugin } from "vite";
-export declare const vitePreamblePlugin: () => Plugin;
+import type { ResolvedConfig } from "vite";
+export declare const vitePreamblePlugin: () => {
+    configResolved(config: ResolvedConfig): void;
+    hotUpdate?: import("rollup").ObjectHook<(this: import("rollup").MinimalPluginContext & {
+        environment: import("vite").DevEnvironment;
+    }, options: import("vite").HotUpdateOptions) => Array<import("vite").EnvironmentModuleNode> | void | Promise<Array<import("vite").EnvironmentModuleNode> | void>>;
+    resolveId?: import("rollup").ObjectHook<(this: import("rollup").PluginContext, source: string, importer: string | undefined, options: {
+        attributes: Record<string, string>;
+        custom?: import("rollup").CustomPluginOptions;
+        ssr?: boolean | undefined;
+        isEntry: boolean;
+    }) => Promise<import("rollup").ResolveIdResult> | import("rollup").ResolveIdResult, {
+        filter?: {
+            id?: RegExp | RegExp[] | {
+                include?: RegExp | RegExp[] | undefined;
+                exclude?: RegExp | RegExp[] | undefined;
+            };
+        };
+    }>;
+    load?: import("rollup").ObjectHook<(this: import("rollup").PluginContext, id: string, options?: {
+        ssr?: boolean | undefined;
+    }) => Promise<import("rollup").LoadResult> | import("rollup").LoadResult, {
+        filter?: {
+            id?: string | RegExp | (string | RegExp)[] | {
+                include?: string | RegExp | (string | RegExp)[] | undefined;
+                exclude?: string | RegExp | (string | RegExp)[] | undefined;
+            };
+        };
+    }>;
+    transform?: import("rollup").ObjectHook<(this: import("rollup").TransformPluginContext, code: string, id: string, options?: {
+        ssr?: boolean | undefined;
+    }) => Promise<import("rollup").TransformResult> | import("rollup").TransformResult, {
+        filter?: {
+            id?: string | RegExp | (string | RegExp)[] | {
+                include?: string | RegExp | (string | RegExp)[] | undefined;
+                exclude?: string | RegExp | (string | RegExp)[] | undefined;
+            };
+            code?: string | RegExp | (string | RegExp)[] | {
+                include?: string | RegExp | (string | RegExp)[] | undefined;
+                exclude?: string | RegExp | (string | RegExp)[] | undefined;
+            };
+        };
+    }>;
+    sharedDuringBuild?: boolean;
+    perEnvironmentStartEndDuringDev?: boolean;
+    perEnvironmentWatchChangeDuringDev?: boolean;
+    enforce?: "pre" | "post";
+    apply?: "serve" | "build" | ((this: void, config: import("vite").UserConfig, env: import("vite").ConfigEnv) => boolean);
+    applyToEnvironment?: (environment: {
+        name: string;
+        getTopLevelConfig(): ResolvedConfig;
+        config: ResolvedConfig & {
+            define?: Record<string, any>;
+            resolve: Required<import("vite").ResolveOptions>;
+            consumer: "client" | "server";
+            keepProcessEnv?: boolean;
+            optimizeDeps: import("vite").DepOptimizationOptions;
+            dev: import("vite").ResolvedDevEnvironmentOptions;
+            build: import("vite").ResolvedBuildEnvironmentOptions;
+            plugins: readonly import("vite").Plugin[];
+        };
+        logger: import("vite").Logger;
+    }) => boolean | Promise<boolean> | import("vite").PluginOption;
+    config?: import("rollup").ObjectHook<(this: import("vite").ConfigPluginContext, config: import("vite").UserConfig, env: import("vite").ConfigEnv) => Omit<import("vite").UserConfig, "plugins"> | null | void | Promise<Omit<import("vite").UserConfig, "plugins"> | null | void>>;
+    configEnvironment?: import("rollup").ObjectHook<(this: import("vite").ConfigPluginContext, name: string, config: import("vite").EnvironmentOptions, env: import("vite").ConfigEnv & {
+        isSsrTargetWebworker?: boolean;
+    }) => import("vite").EnvironmentOptions | null | void | Promise<import("vite").EnvironmentOptions | null | void>>;
+    configureServer?: import("rollup").ObjectHook<import("vite").ServerHook>;
+    configurePreviewServer?: import("rollup").ObjectHook<import("vite").PreviewServerHook>;
+    transformIndexHtml?: import("vite").IndexHtmlTransform;
+    buildApp?: import("rollup").ObjectHook<import("vite").BuildAppHook>;
+    handleHotUpdate?: import("rollup").ObjectHook<(this: import("vite").MinimalPluginContextWithoutEnvironment, ctx: import("vite").HmrContext) => Array<import("vite").ModuleNode> | void | Promise<Array<import("vite").ModuleNode> | void>>;
+    api?: any;
+    cacheKey?: string | undefined;
+    name: string;
+    version?: string | undefined;
+    renderError?: import("rollup").ObjectHook<(this: import("rollup").PluginContext, error?: Error | undefined) => void | Promise<void>, {
+        sequential?: boolean;
+    }> | undefined;
+    augmentChunkHash?: import("rollup").ObjectHook<(this: import("rollup").PluginContext, chunk: import("rollup").RenderedChunk) => string | void, {}> | undefined;
+    generateBundle?: import("rollup").ObjectHook<(this: import("rollup").PluginContext, options: import("rollup").NormalizedOutputOptions, bundle: import("rollup").OutputBundle, isWrite: boolean) => void | Promise<void>, {}> | undefined;
+    outputOptions?: import("rollup").ObjectHook<(this: import("rollup").PluginContext, options: import("rollup").OutputOptions) => import("rollup").OutputOptions | import("rollup").NullValue, {}> | undefined;
+    renderChunk?: import("rollup").ObjectHook<(this: import("rollup").PluginContext, code: string, chunk: import("rollup").RenderedChunk, options: import("rollup").NormalizedOutputOptions, meta: {
+        chunks: Record<string, import("rollup").RenderedChunk>;
+    }) => string | {
+        code: string;
+        map?: import("rollup").SourceMapInput;
+    } | import("rollup").NullValue | Promise<string | {
+        code: string;
+        map?: import("rollup").SourceMapInput;
+    } | import("rollup").NullValue>, {}> | undefined;
+    renderDynamicImport?: import("rollup").ObjectHook<(this: import("rollup").PluginContext, options: {
+        customResolution: string | null;
+        format: import("rollup").InternalModuleFormat;
+        moduleId: string;
+        targetModuleId: string | null;
+        chunk: import("rollup").PreRenderedChunkWithFileName;
+        targetChunk: import("rollup").PreRenderedChunkWithFileName | null;
+        getTargetChunkImports: () => import("rollup").DynamicImportTargetChunk[] | null;
+        targetModuleAttributes: Record<string, string>;
+    }) => {
+        left: string;
+        right: string;
+    } | import("rollup").NullValue, {}> | undefined;
+    renderStart?: import("rollup").ObjectHook<(this: import("rollup").PluginContext, outputOptions: import("rollup").NormalizedOutputOptions, inputOptions: import("rollup").NormalizedInputOptions) => void | Promise<void>, {
+        sequential?: boolean;
+    }> | undefined;
+    resolveFileUrl?: import("rollup").ObjectHook<import("rollup").ResolveFileUrlHook, {}> | undefined;
+    resolveImportMeta?: import("rollup").ObjectHook<import("rollup").ResolveImportMetaHook, {}> | undefined;
+    writeBundle?: import("rollup").ObjectHook<(this: import("rollup").PluginContext, options: import("rollup").NormalizedOutputOptions, bundle: import("rollup").OutputBundle) => void | Promise<void>, {
+        sequential?: boolean;
+    }> | undefined;
+    footer?: import("rollup").ObjectHook<import("rollup").AddonHook, {}> | undefined;
+    banner?: import("rollup").ObjectHook<import("rollup").AddonHook, {}> | undefined;
+    intro?: import("rollup").ObjectHook<import("rollup").AddonHook, {}> | undefined;
+    outro?: import("rollup").ObjectHook<import("rollup").AddonHook, {}> | undefined;
+    buildEnd?: import("rollup").ObjectHook<(this: import("rollup").PluginContext, error?: Error | undefined) => void | Promise<void>, {
+        sequential?: boolean;
+    }> | undefined;
+    buildStart?: import("rollup").ObjectHook<(this: import("rollup").PluginContext, options: import("rollup").NormalizedInputOptions) => void | Promise<void>, {
+        sequential?: boolean;
+    }> | undefined;
+    closeBundle?: import("rollup").ObjectHook<(this: import("rollup").PluginContext, error?: Error | undefined) => void | Promise<void>, {
+        sequential?: boolean;
+    }> | undefined;
+    closeWatcher?: import("rollup").ObjectHook<(this: import("rollup").PluginContext) => void | Promise<void>, {
+        sequential?: boolean;
+    }> | undefined;
+    moduleParsed?: import("rollup").ObjectHook<(this: import("rollup").PluginContext, info: import("rollup").ModuleInfo) => void | Promise<void>, {
+        sequential?: boolean;
+    }> | undefined;
+    onLog?: import("rollup").ObjectHook<(this: import("rollup").MinimalPluginContext, level: import("rollup").LogLevel, log: import("rollup").RollupLog) => boolean | import("rollup").NullValue, {}> | undefined;
+    options?: import("rollup").ObjectHook<(this: import("rollup").MinimalPluginContext, options: import("rollup").InputOptions) => import("rollup").InputOptions | import("rollup").NullValue | Promise<import("rollup").InputOptions | import("rollup").NullValue>, {}> | undefined;
+    resolveDynamicImport?: import("rollup").ObjectHook<(this: import("rollup").PluginContext, specifier: string | import("rollup").AstNode, importer: string, options: {
+        attributes: Record<string, string>;
+        importerAttributes: Record<string, string>;
+    }) => import("rollup").ResolveIdResult | Promise<import("rollup").ResolveIdResult>, {}> | undefined;
+    shouldTransformCachedModule?: import("rollup").ObjectHook<(this: import("rollup").PluginContext, options: {
+        ast: import("rollup").ProgramNode;
+        attributes: Record<string, string>;
+        code: string;
+        id: string;
+        meta: import("rollup").CustomPluginOptions;
+        moduleSideEffects: boolean | "no-treeshake";
+        resolvedSources: import("rollup").ResolvedIdMap;
+        syntheticNamedExports: boolean | string;
+    }) => boolean | import("rollup").NullValue | Promise<boolean | import("rollup").NullValue>, {}> | undefined;
+    watchChange?: import("rollup").ObjectHook<(this: import("rollup").PluginContext, id: string, change: {
+        event: import("rollup").ChangeEvent;
+    }) => void | Promise<void>, {
+        sequential?: boolean;
+    }> | undefined;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rwsdk",
-  "version": "1.2.4-test.20260428112212",
+  "version": "1.2.5",
   "description": "Build fast, server-driven webapps on Cloudflare with SSR, RSC, and realtime",
   "type": "module",
   "bin": {
@@ -154,7 +154,7 @@
   "license": "MIT",
   "dependencies": {
     "@ast-grep/napi": "~0.42.1",
-    "@cloudflare/workers-types": "~4.20260405.1",
+    "@cloudflare/workers-types": "~4.20260426.1",
     "@mdx-js/mdx": "~3.1.1",
     "@puppeteer/browsers": "~2.13.0",
     "@types/decompress": "~4.2.7",
@@ -163,12 +163,12 @@
     "@types/react": "~19.2.14",
     "@types/react-dom": "~19.2.3",
     "@types/react-is": "~19.2.0",
-    "@vitejs/plugin-react": "~6.0.1",
+    "@vitejs/plugin-react": "~5.1.4",
     "chokidar": "~5.0.0",
     "debug": "~4.4.3",
     "decompress": "~4.2.1",
-    "enhanced-resolve": "~5.20.1",
-    "eventsource-parser": "~3.0.6",
+    "enhanced-resolve": "~5.21.0",
+    "eventsource-parser": "~3.0.8",
     "execa": "~9.6.1",
     "find-up": "~8.0.0",
     "fs-extra": "~11.3.4",
@@ -176,20 +176,21 @@
     "glob": "~13.0.6",
     "ignore": "~7.0.5",
     "jsonc-parser": "~3.3.1",
-    "kysely": "~0.28.15",
+    "kysely": "~0.28.16",
     "kysely-do": "~0.0.1-rc.1",
     "lodash": "~4.18.1",
     "magic-string": "~0.30.21",
     "picocolors": "~1.1.1",
     "proper-lockfile": "~4.1.2",
-    "puppeteer-core": "~24.38.0",
-    "react-is": "~19.2.4",
+    "puppeteer-core": "~24.42.0",
+    "react-is": "~19.2.5",
     "rsc-html-stream": "~0.0.7",
     "server-only": "^0.0.1",
     "tmp-promise": "~3.0.3",
-    "ts-morph": "~27.0.2",
+    "ts-morph": "~28.0.0",
     "unique-names-generator": "~4.7.1",
-    "vibe-rules": "~0.3.91"
+    "vibe-rules": "~0.3.91",
+    "vite-tsconfig-paths": "~6.1.1"
   },
   "peerDependencies": {
     "@cloudflare/vite-plugin": "^1.26.1",
@@ -197,7 +198,7 @@
     "react": ">=19.2.0-0 <19.3.0 || >=19.3.0-0 <20.0.0",
     "react-dom": ">=19.2.0-0 <19.3.0 || >=19.3.0-0 <20.0.0",
     "react-server-dom-webpack": ">=19.2.0-0 <19.3.0 || >=19.3.0-0 <20.0.0",
-    "vite": "^6.2.6 || 7.x || 8.x",
+    "vite": "^6.2.6 || 7.x",
     "wrangler": "^4.77.0"
   },
   "peerDependenciesMeta": {
@@ -207,19 +208,19 @@
   },
   "packageManager": "pnpm@10.31.0",
   "devDependencies": {
-    "@cloudflare/vite-plugin": "1.31.0",
-    "wrangler": "^4.80.0",
+    "@cloudflare/vite-plugin": "1.33.2",
+    "wrangler": "^4.85.0",
     "capnweb": "~0.5.0",
     "@types/debug": "~4.1.13",
     "@types/js-beautify": "~1.14.3",
     "@types/lodash": "~4.17.24",
-    "@types/node": "~25.3.5",
+    "@types/node": "~25.6.0",
     "@types/proper-lockfile": "~4.1.4",
     "js-beautify": "~1.15.4",
     "semver": "~7.7.4",
     "tsx": "~4.21.0",
-    "typescript": "~6.0.2",
-    "vite": "~8.0.9",
-    "vitest": "~4.1.2"
+    "typescript": "~6.0.3",
+    "vite": "~7.3.2",
+    "vitest": "~4.1.5"
   }
 }

package/dist/vite/addOptimizeDepsPlugin.d.mts

@@ -1,10 +0,0 @@
-import type { EnvironmentOptions } from "vite";
-interface OptimizeDepsPlugin {
-    name: string;
-    resolveId?: (id: string, importer: string | undefined, opts: {
-        kind: string;
-    }) => any;
-    load?: (id: string) => any;
-}
-export declare function addOptimizeDepsPlugin(config: EnvironmentOptions, plugin: OptimizeDepsPlugin): void;
-export {};

package/dist/vite/addOptimizeDepsPlugin.mjs

@@ -1,6 +0,0 @@
-export function addOptimizeDepsPlugin(config, plugin) {
-    config.optimizeDeps ??= {};
-    config.optimizeDeps.rolldownOptions ??= {};
-    config.optimizeDeps.rolldownOptions.plugins ??= [];
-    config.optimizeDeps.rolldownOptions.plugins.push(plugin);
-}