rwsdk 1.4.1 → 1.5.0

package/dist/vite/directiveModulesDevPlugin.mjs

@@ -42,6 +42,91 @@ export const directiveModulesDevPlugin = ({ clientFiles, serverFiles, projectRoo
         client: VENDOR_CLIENT_BARREL_PATH,
         server: VENDOR_SERVER_BARREL_PATH,
     });
+    const appBarrelPaths = [APP_CLIENT_BARREL_PATH, APP_SERVER_BARREL_PATH];
+    const slugifyOptimizeEntry = (id) => id.replaceAll("/", "_").replaceAll(".", "__");
+    const VENDOR_CLIENT_BARREL_OPTIMIZED_ID = slugifyOptimizeEntry(VENDOR_CLIENT_BARREL_EXPORT_PATH);
+    const VENDOR_SERVER_BARREL_OPTIMIZED_ID = slugifyOptimizeEntry(VENDOR_SERVER_BARREL_EXPORT_PATH);
+    const escapeRegExp = (s) => s.replace(/[\\^$*+?.()|[\]{}]/g, "\\$&");
+    const appBarrelFilter = new RegExp(`(${appBarrelPaths.map(escapeRegExp).join("|")})$`);
+    const BARREL_PREFIX = "\0rwsdk-app-barrel:";
+    const createAppBarrelBlockerPlugin = () => ({
+        name: "rwsdk:app-barrel-blocker",
+        async resolveId(id) {
+            await scanPromise;
+            // Handle stable vendor barrel specifiers by redirecting them to
+            // the in-memory temp barrel files. This lets Vite rewrite the
+            // specifier to its optimized dependency bundle while still serving
+            // our generated content.
+            const isClientBarrelPath = id === VENDOR_CLIENT_BARREL_EXPORT_PATH ||
+                id === VENDOR_CLIENT_BARREL_OPTIMIZED_ID ||
+                id === SDK_VENDOR_CLIENT_BARREL_PATH ||
+                id.endsWith("/__vendor_client_barrel.dev-virtual.js");
+            const isServerBarrelPath = id === VENDOR_SERVER_BARREL_EXPORT_PATH ||
+                id === VENDOR_SERVER_BARREL_OPTIMIZED_ID ||
+                id === SDK_VENDOR_SERVER_BARREL_PATH ||
+                id.endsWith("/__vendor_server_barrel.dev-virtual.js");
+            if (isClientBarrelPath) {
+                return VENDOR_CLIENT_BARREL_PATH;
+            }
+            if (isServerBarrelPath) {
+                return VENDOR_SERVER_BARREL_PATH;
+            }
+            // Handle app barrel files
+            if (appBarrelFilter.test(id)) {
+                return `${BARREL_PREFIX}${id}`;
+            }
+            // 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 (id.startsWith("/") &&
+                (id.includes("/src/") || id.includes("/generated/")) &&
+                !id.includes("node_modules")) {
+                return id;
+            }
+        },
+        load(id) {
+            // Handle vendor barrels
+            if (id === VENDOR_CLIENT_BARREL_PATH ||
+                id === VENDOR_SERVER_BARREL_PATH) {
+                const isServerBarrel = id.includes("server-barrel");
+                const files = isServerBarrel ? serverFiles : clientFiles;
+                return generateVendorBarrelContent(files, projectRootDir);
+            }
+            // Handle app barrels
+            if (id.startsWith(BARREL_PREFIX)) {
+                const barrelPath = id.slice(BARREL_PREFIX.length);
+                const isServerBarrel = barrelPath.includes("app-server-barrel");
+                const files = isServerBarrel ? serverFiles : clientFiles;
+                return generateAppBarrelContent(files, projectRootDir);
+            }
+        },
+    });
+    const addUnique = (items, value) => {
+        if (!items.includes(value)) {
+            items.push(value);
+        }
+    };
+    const configureOptimizeDeps = (envName, env) => {
+        env.optimizeDeps ??= {};
+        env.optimizeDeps.include ??= [];
+        addUnique(env.optimizeDeps.include, VENDOR_CLIENT_BARREL_EXPORT_PATH);
+        addUnique(env.optimizeDeps.include, VENDOR_SERVER_BARREL_EXPORT_PATH);
+        const entries = (env.optimizeDeps.entries = castArray(env.optimizeDeps.entries ?? []));
+        addUnique(entries, VENDOR_CLIENT_BARREL_EXPORT_PATH);
+        addUnique(entries, VENDOR_SERVER_BARREL_EXPORT_PATH);
+        if (envName === "client" || envName === "ssr") {
+            addUnique(entries, APP_CLIENT_BARREL_PATH);
+        }
+        else if (envName === "worker") {
+            addUnique(entries, APP_SERVER_BARREL_PATH);
+        }
+        env.optimizeDeps.rolldownOptions ??= {};
+        env.optimizeDeps.rolldownOptions.plugins ??= [];
+        if (!env.optimizeDeps.rolldownOptions.plugins.some((plugin) => plugin.name === "rwsdk:app-barrel-blocker")) {
+            env.optimizeDeps.rolldownOptions.plugins.unshift(createAppBarrelBlockerPlugin());
+        }
+    };
     return {
         name: "rwsdk:directive-modules-dev",
         enforce: "pre",
@@ -105,109 +190,7 @@ export const directiveModulesDevPlugin = ({ clientFiles, serverFiles, projectRoo
             mkdirSync(path.dirname(VENDOR_SERVER_BARREL_PATH), { recursive: true });
             writeFileSync(VENDOR_SERVER_BARREL_PATH, "");
             for (const [envName, env] of Object.entries(config.environments || {})) {
-                env.optimizeDeps ??= {};
-                env.optimizeDeps.include ??= [];
-                env.optimizeDeps.include.push(VENDOR_CLIENT_BARREL_EXPORT_PATH, VENDOR_SERVER_BARREL_EXPORT_PATH);
-                const entries = (env.optimizeDeps.entries = castArray(env.optimizeDeps.entries ?? []));
-                entries.push(VENDOR_CLIENT_BARREL_EXPORT_PATH, VENDOR_SERVER_BARREL_EXPORT_PATH);
-                if (envName === "client" || envName === "ssr") {
-                    entries.push(APP_CLIENT_BARREL_PATH);
-                }
-                else if (envName === "worker") {
-                    entries.push(APP_SERVER_BARREL_PATH);
-                }
-                env.optimizeDeps.esbuildOptions ??= {};
-                env.optimizeDeps.esbuildOptions.plugins ??= [];
-                env.optimizeDeps.esbuildOptions.plugins.unshift({
-                    name: "rwsdk:app-barrel-blocker",
-                    setup(build) {
-                        const appBarrelPaths = [
-                            APP_CLIENT_BARREL_PATH,
-                            APP_SERVER_BARREL_PATH,
-                        ];
-                        const vendorBarrelPaths = [
-                            VENDOR_CLIENT_BARREL_PATH,
-                            VENDOR_SERVER_BARREL_PATH,
-                        ];
-                        const barrelPaths = [...appBarrelPaths, ...vendorBarrelPaths];
-                        const escapeRegExp = (s) => s.replace(/[\\^$*+?.()|[\]{}]/g, "\\$&");
-                        const barrelFilter = new RegExp(`(${barrelPaths.map(escapeRegExp).join("|")})$`);
-                        build.onResolve({ filter: /.*/ }, async (args) => {
-                            // Block all resolutions until the scan is complete.
-                            await scanPromise;
-                            // Handle stable vendor barrel specifiers by redirecting them to
-                            // the in-memory temp barrel files. This lets Vite rewrite the
-                            // specifier to its optimized dependency bundle while still serving
-                            // our generated content.
-                            const isClientBarrelPath = args.path === VENDOR_CLIENT_BARREL_EXPORT_PATH ||
-                                args.path === SDK_VENDOR_CLIENT_BARREL_PATH ||
-                                args.path.endsWith("/__vendor_client_barrel.dev-virtual.js");
-                            const isServerBarrelPath = args.path === VENDOR_SERVER_BARREL_EXPORT_PATH ||
-                                args.path === SDK_VENDOR_SERVER_BARREL_PATH ||
-                                args.path.endsWith("/__vendor_server_barrel.dev-virtual.js");
-                            if (isClientBarrelPath) {
-                                return {
-                                    path: VENDOR_CLIENT_BARREL_PATH,
-                                    namespace: "rwsdk-barrel-ns",
-                                };
-                            }
-                            if (isServerBarrelPath) {
-                                return {
-                                    path: VENDOR_SERVER_BARREL_PATH,
-                                    namespace: "rwsdk-barrel-ns",
-                                };
-                            }
-                            // Handle barrel files (app + vendor)
-                            if (barrelFilter.test(args.path)) {
-                                return {
-                                    path: args.path,
-                                    namespace: "rwsdk-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: /__vendor_(client|server)_barrel\.dev-virtual\.js$/ }, async (args) => {
-                            await scanPromise;
-                            const isServerBarrel = args.path.includes("server-barrel");
-                            const files = isServerBarrel ? serverFiles : clientFiles;
-                            return {
-                                contents: generateVendorBarrelContent(files, projectRootDir),
-                                loader: "js",
-                            };
-                        });
-                        build.onLoad({ filter: /.*/, namespace: "rwsdk-barrel-ns" }, (args) => {
-                            const isServerBarrel = args.path.includes("server-barrel");
-                            const isVendorBarrel = args.path.includes("vendor");
-                            if (isVendorBarrel) {
-                                const files = isServerBarrel ? serverFiles : clientFiles;
-                                const content = generateVendorBarrelContent(files, projectRootDir);
-                                return {
-                                    contents: content,
-                                    loader: "js",
-                                };
-                            }
-                            const files = isServerBarrel ? serverFiles : clientFiles;
-                            const content = generateAppBarrelContent(files, projectRootDir);
-                            return {
-                                contents: content,
-                                loader: "js",
-                            };
-                        });
-                    },
-                });
+                configureOptimizeDeps(envName, env);
             }
         },
     };

package/dist/vite/directivesFilteringPlugin.mjs

@@ -1,32 +1,73 @@
 import debug from "debug";
 import { normalizeModulePath } from "../lib/normalizeModulePath.mjs";
 const log = debug("rwsdk:vite:directives-filtering-plugin");
+function filterDirectiveModules({ clientFiles, serverFiles, projectRootDir, includedModules, }) {
+    process.env.VERBOSE &&
+        log("Directive modules before filtering: client=%O, server=%O", Array.from(clientFiles), Array.from(serverFiles));
+    for (const files of [clientFiles, serverFiles]) {
+        for (const id of files) {
+            const absoluteId = normalizeModulePath(id, projectRootDir, {
+                absolute: true,
+            });
+            if (!includedModules.has(absoluteId)) {
+                files.delete(id);
+            }
+        }
+    }
+    process.env.VERBOSE &&
+        log("Client/server files after filtering: client=%O, server=%O", Array.from(clientFiles), Array.from(serverFiles));
+}
 export const directivesFilteringPlugin = ({ clientFiles, serverFiles, projectRootDir, }) => {
     return {
         name: "rwsdk:directives-filtering",
         enforce: "post",
-        async buildEnd() {
+        buildEnd() {
             if (this.environment.name !== "worker" ||
                 process.env.RWSDK_BUILD_PASS !== "worker") {
                 return;
             }
             log("Filtering directive modules after worker build...");
-            process.env.VERBOSE &&
-                log("Directive modules before filtering: client=%O, server=%O", Array.from(clientFiles), Array.from(serverFiles));
-            [clientFiles, serverFiles].forEach((files) => {
-                for (const id of files) {
-                    const absoluteId = normalizeModulePath(id, projectRootDir, {
-                        absolute: true,
-                    });
-                    const info = this.getModuleInfo(absoluteId);
-                    if (!info ||
-                        (typeof info.isIncluded !== "undefined" && !info.isIncluded)) {
-                        files.delete(id);
+            const includedModules = new Set();
+            for (const id of this.getModuleIds()) {
+                const info = this.getModuleInfo(id);
+                if (info && info.isIncluded !== false) {
+                    includedModules.add(id);
+                }
+            }
+            filterDirectiveModules({
+                clientFiles,
+                serverFiles,
+                projectRootDir,
+                includedModules,
+            });
+        },
+        generateBundle(_options, bundle) {
+            if (this.environment.name !== "worker" ||
+                process.env.RWSDK_BUILD_PASS !== "worker") {
+                return;
+            }
+            log("Filtering directive modules from bundle output...");
+            // context(justinvdm, 2026-05-13): Rolldown (Vite 8+) does not expose
+            // ModuleInfo.isIncluded. Instead, we inspect the final output chunks.
+            // A module whose renderedLength is 0 (or missing) was tree-shaken to
+            // empty and should be removed from the directive sets.
+            const includedModules = new Set();
+            for (const output of Object.values(bundle)) {
+                if (output.type !== "chunk") {
+                    continue;
+                }
+                for (const [moduleId, renderedModule] of Object.entries(output.modules)) {
+                    if (renderedModule.renderedLength > 0) {
+                        includedModules.add(moduleId);
                     }
                 }
+            }
+            filterDirectiveModules({
+                clientFiles,
+                serverFiles,
+                projectRootDir,
+                includedModules,
             });
-            process.env.VERBOSE &&
-                log("Client/server files after filtering: client=%O, server=%O", Array.from(clientFiles), Array.from(serverFiles));
         },
     };
 };

package/dist/vite/directivesPlugin.mjs

@@ -2,6 +2,7 @@ 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");
@@ -92,100 +93,56 @@ export const directivesPlugin = ({ projectRootDir, clientFiles, serverFiles, })
                 return;
             }
             process.env.VERBOSE && log("Configuring environment: env=%s", env);
-            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",
-                                    };
-                                }
-                            }
+            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;
                         }
-                        let code;
-                        try {
-                            code = await fs.readFile(args.path, "utf-8");
+                        else {
+                            return { code: "", moduleType: "js" };
                         }
-                        catch {
-                            process.env.VERBOSE &&
-                                log("Failed to read file: %s, environment=%s", args.path, env);
+                    }
+                    else if (serverFiles.has(normalizedPath)) {
+                        if (env === "worker") {
                             return undefined;
                         }
-                        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),
-                            };
-                        }
-                        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),
-                            };
+                        else if (env === "ssr" || env === "client") {
+                            return { code: "", moduleType: "js" };
                         }
-                        process.env.VERBOSE &&
-                            log("Esbuild no transformation applied for environment=%s, path=%s", env, 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 };
+                    }
                 },
             });
-            process.env.VERBOSE &&
-                log("Environment configuration complete for env=%s", env);
         },
     };
 };

package/dist/vite/knownDepsResolverPlugin.mjs

@@ -91,44 +91,34 @@ 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 createEsbuildResolverPlugin(envName, mappings) {
+    function createResolverPlugin(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, resolved] of mappings) {
+        for (const [original] of mappings) {
             const slugified = original.replace(/\//g, "_").replace(/\./g, "__");
             slugifiedToOriginal.set(slugified, original);
         }
         return {
-            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(args.path, envName, projectRootDir);
+            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);
                     }
-                    // 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,
-                        };
+                }
+                if (!resolved) {
+                    resolved = resolveKnownImport(id, envName, projectRootDir);
+                }
+                if (resolved) {
+                    if (id === "react-server-dom-webpack/client.edge") {
+                        return;
                     }
-                });
+                    return resolved;
+                }
             },
         };
     }
@@ -152,17 +142,20 @@ export const knownDepsResolverPlugin = ({ projectRootDir, }) => {
                         config.environments[envName] = {};
                     }
                     const envConfig = config.environments[envName];
-                    const esbuildPlugin = createEsbuildResolverPlugin(envName, mappings);
-                    if (esbuildPlugin && mappings) {
+                    if (mappings) {
                         envConfig.optimizeDeps ??= {};
-                        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.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.include ??= [];
                         envConfig.optimizeDeps.include.push(...predefinedImports);
-                        log("Added esbuild plugin and optimizeDeps includes for environment: %s", envName);
+                        log("Added optimizeDeps plugin and 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,4 +1,5 @@
 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";
@@ -21,17 +22,13 @@ export const prismaPlugin = async ({ projectRootDir, }) => {
                 return;
             }
             const wasmPath = resolve(projectRootDir, "node_modules/.prisma/client/wasm.js");
-            config.optimizeDeps ??= {};
-            config.optimizeDeps.esbuildOptions ??= {};
-            config.optimizeDeps.esbuildOptions.plugins ??= [];
-            config.optimizeDeps.esbuildOptions.plugins.push({
+            const prismaFilter = /^.prisma\/client\/default/;
+            addOptimizeDepsPlugin(config, {
                 name: "rwsdk:prisma",
-                setup(build) {
-                    build.onResolve({ filter: /^.prisma\/client\/default/ }, async () => {
-                        return {
-                            path: wasmPath,
-                        };
-                    });
+                resolveId(id) {
+                    if (prismaFilter.test(id)) {
+                        return wasmPath;
+                    }
                 },
             });
             ensureAliasArray(config).push({

package/dist/vite/redwoodPlugin.mjs

@@ -6,12 +6,12 @@ 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";
 import { hasPkgScript } from "../lib/hasPkgScript.mjs";
 import { cloudflarePreInitPlugin } from "./cloudflarePreInitPlugin.mjs";
+import { compatTransform } from "./viteCompat.mjs";
 import { configPlugin } from "./configPlugin.mjs";
 import { devServerTimingPlugin } from "./devServerTimingPlugin.mjs";
 import { directiveModulesDevPlugin } from "./directiveModulesDevPlugin.mjs";
@@ -84,7 +84,7 @@ export const redwoodPlugin = async (options = {}) => {
         console.log("🚀 Project has no .wrangler directory yet, assuming fresh install: running `npm run dev:init`...");
         await $ `npm run dev:init`;
     }
-    return [
+    const pluginResults = await Promise.all([
         staleDepRetryPlugin(),
         statePlugin({ projectRootDir }),
         devServerTimingPlugin(),
@@ -112,7 +112,6 @@ export const redwoodPlugin = async (options = {}) => {
         }),
         knownDepsResolverPlugin({ projectRootDir }),
         cloudflarePreInitPlugin(),
-        tsconfigPaths({ root: projectRootDir }),
         shouldIncludeCloudflarePlugin
             ? cloudflare({
                 viteEnvironment: { name: "worker" },
@@ -158,5 +157,7 @@ export const redwoodPlugin = async (options = {}) => {
             serverFiles,
             projectRootDir,
         }),
-    ];
+    ]);
+    const flattenedPlugins = pluginResults.flat().filter((plugin) => plugin != null);
+    return compatTransform(flattenedPlugins);
 };

package/dist/vite/runDirectivesScan.mjs

@@ -99,7 +99,7 @@ export const runDirectivesScan = async ({ rootConfig, environments, clientFiles,
             return contents;
         };
         const esbuild = await getViteEsbuild(rootConfig.root);
-        const input = initialEntries ?? environments.worker.config.build.rollupOptions?.input;
+        const input = initialEntries ?? environments.worker.config.build.rolldownOptions?.input;
         let entries;
         if (Array.isArray(input)) {
             entries = input;