rwsdk 1.0.0-beta.3 → 1.0.0-beta.30-test.20251119220440

package/dist/vite/buildApp.mjs

@@ -1,5 +1,8 @@
 import debug from "debug";
-import { resolve } from "node:path";
+import { existsSync } from "node:fs";
+import { mkdir, rm, writeFile } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import { INTERMEDIATES_OUTPUT_DIR } from "../lib/constants.mjs";
 import { runDirectivesScan } from "./runDirectivesScan.mjs";
 const log = debug("rwsdk:vite:build-app");
 /**
@@ -10,7 +13,36 @@ const log = debug("rwsdk:vite:build-app");
  * @see docs/architecture/productionBuildProcess.md
  */
 export async function buildApp({ builder, clientEntryPoints, clientFiles, serverFiles, projectRootDir, workerEntryPathname, }) {
+    await rm(resolve(projectRootDir, "dist"), { recursive: true, force: true });
     const workerEnv = builder.environments.worker;
+    // Run a pre-scan build pass to allow plugins to set up and generate code
+    // before scanning.
+    console.log("Running plugin setup pass...");
+    process.env.RWSDK_BUILD_PASS = "plugin-setup";
+    const tempEntryPath = resolve(INTERMEDIATES_OUTPUT_DIR, "temp-entry.js");
+    try {
+        if (!existsSync(dirname(tempEntryPath))) {
+            await mkdir(dirname(tempEntryPath), { recursive: true });
+        }
+        await writeFile(tempEntryPath, "");
+        const originalWorkerBuildConfig = workerEnv.config.build;
+        workerEnv.config.build = {
+            ...originalWorkerBuildConfig,
+            write: false,
+            rollupOptions: {
+                ...originalWorkerBuildConfig?.rollupOptions,
+                input: {
+                    index: tempEntryPath,
+                },
+            },
+        };
+        await builder.build(workerEnv);
+        // Restore the original config
+        workerEnv.config.build = originalWorkerBuildConfig;
+    }
+    finally {
+        await rm(tempEntryPath, { force: true });
+    }
     await runDirectivesScan({
         rootConfig: builder.config,
         environments: builder.environments,
@@ -18,7 +50,7 @@ export async function buildApp({ builder, clientEntryPoints, clientFiles, server
         serverFiles,
         entries: [workerEntryPathname],
     });
-    console.log("Building worker to discover used client components...");
+    console.log("Building worker...");
     process.env.RWSDK_BUILD_PASS = "worker";
     await builder.build(workerEnv);
     log("Used client files after worker build & filtering: %O", Array.from(clientFiles));

package/dist/vite/configPlugin.mjs

@@ -3,6 +3,7 @@ import path, { resolve } from "node:path";
 import { INTERMEDIATE_SSR_BRIDGE_PATH } from "../lib/constants.mjs";
 import { buildApp } from "./buildApp.mjs";
 import { externalModules } from "./constants.mjs";
+import { ssrBridgeWrapPlugin } from "./ssrBridgeWrapPlugin.mjs";
 export const configPlugin = ({ silent, projectRootDir, workerEntryPathname, clientFiles, serverFiles, clientEntryPoints, }) => ({
     name: "rwsdk:config",
     config: async (_, { command }) => {
@@ -93,6 +94,7 @@ export const configPlugin = ({ silent, projectRootDir, workerEntryPathname, clie
                             "rwsdk/constants",
                             "rwsdk/debug",
                             "rwsdk/realtime/client",
+                            "rwsdk/router",
                             "rwsdk/turnstile",
                         ],
                         entries: [],
@@ -161,22 +163,14 @@ export const configPlugin = ({ silent, projectRootDir, workerEntryPathname, clie
                                 // causes a redeclaration error. To solve this, we wrap the SSR
                                 // bundle in an exporting IIFE. This creates a scope boundary,
                                 // preventing symbol collisions while producing a valid,
-                                // tree-shakeable ES module. The inline plugin below removes the
-                                // original `export` statement from the bundle to prevent syntax
-                                // errors.
+                                // tree-shakeable ES module.
+                                //
+                                // context(justinvdm, 19 Nov 2025): We use a custom plugin
+                                // (ssrBridgeWrapPlugin) to intelligently inject the IIFE *after*
+                                // any top-level external imports, ensuring they remain valid.
                                 inlineDynamicImports: true,
-                                banner: `export const { renderHtmlStream, ssrLoadModule, ssrWebpackRequire, ssrGetModuleExport, createThenableFromReadableStream } = (function() {`,
-                                footer: `return { renderHtmlStream, ssrLoadModule, ssrWebpackRequire, ssrGetModuleExport, createThenableFromReadableStream };\n})();`,
                             },
-                            plugins: [
-                                {
-                                    name: "rwsdk:ssr-bridge-exports",
-                                    renderChunk(code) {
-                                        // Remove the original export statement as it's now handled by the banner/footer
-                                        return code.replace(/export\s*{[^}]+};?/, "");
-                                    },
-                                },
-                            ],
+                            plugins: [ssrBridgeWrapPlugin()],
                         },
                     },
                 },

package/dist/vite/constants.d.mts

@@ -1,2 +1,3 @@
 export declare const cloudflareBuiltInModules: string[];
 export declare const externalModules: string[];
+export declare const externalModulesSet: Set<string>;

package/dist/vite/constants.mjs

@@ -10,3 +10,4 @@ export const externalModules = [
     ...builtinModules,
     ...builtinModules.map((m) => `node:${m}`),
 ];
+export const externalModulesSet = new Set(externalModules);

package/dist/vite/createDirectiveLookupPlugin.mjs

@@ -42,6 +42,10 @@ export const createDirectiveLookupPlugin = async ({ projectRootDir, files, confi
             log("Development mode: %s", isDev);
         },
         configureServer(server) {
+            // context(justinvdm, 19 Nov 2025): This hook simply saves a reference
+            // to the dev server instance for use in other hooks. Unlike plugins that
+            // must run before the Cloudflare plugin to prevent startup deadlocks,
+            // its execution order is not critical, so `enforce: 'pre'` is not needed.
             devServer = server;
         },
         configEnvironment(env, viteConfig) {

package/dist/vite/devServerTimingPlugin.mjs

@@ -6,6 +6,10 @@ export const devServerTimingPlugin = () => {
     return {
         name: "rwsdk:dev-server-timing",
         configureServer(server) {
+            // context(justinvdm, 19 Nov 2025): This hook adds a middleware for
+            // logging the time to first response. Unlike other plugins that must
+            // run before the Cloudflare plugin to prevent startup deadlocks, its
+            // execution order is not critical, so `enforce: 'pre'` is not needed.
             server.middlewares.use((_req, res, next) => {
                 if (!hasLoggedFirstResponse) {
                     res.on("finish", () => {

package/dist/vite/directiveModulesDevPlugin.mjs

@@ -37,8 +37,16 @@ export const directiveModulesDevPlugin = ({ clientFiles, serverFiles, projectRoo
     const APP_SERVER_BARREL_PATH = path.join(tempDir, "app-server-barrel.js");
     return {
         name: "rwsdk:directive-modules-dev",
+        enforce: "pre",
         configureServer(server) {
-            if (!process.env.VITE_IS_DEV_SERVER || process.env.RWSDK_WORKER_RUN) {
+            // context(justinvdm, 19 Nov 2025): We must run this hook before the
+            // Cloudflare plugin's `configureServer` hook. The Cloudflare plugin makes
+            // a request back to the dev server to determine worker exports, which
+            // triggers Vite's dependency optimizer. Our esbuild plugin for the
+            // optimizer blocks on `scanPromise`. By running this first with `enforce: 'pre'`,
+            // we ensure our scan is kicked off before the Cloudflare plugin can trigger
+            // the optimizer, preventing a deadlock.
+            if (!process.env.VITE_IS_DEV_SERVER) {
                 resolveScanPromise();
                 return;
             }

package/dist/vite/directivesPlugin.mjs

@@ -35,6 +35,10 @@ export const directivesPlugin = ({ projectRootDir, clientFiles, serverFiles, })
             isBuild = config.command === "build";
         },
         configureServer(server) {
+            // context(justinvdm, 19 Nov 2025): This hook adds a middleware to track
+            // when the first server response has finished. Unlike plugins that must
+            // run before the Cloudflare plugin to prevent startup deadlocks, its
+            // execution order is not critical, so `enforce: 'pre'` is not needed.
             devServer = server;
             devServer.middlewares.use((_req, res, next) => {
                 // context(justinvdm, 15 Jun 2025): We want to watch for new client and server modules

package/dist/vite/envResolvers.d.mts

@@ -0,0 +1,11 @@
+import enhancedResolve from "enhanced-resolve";
+export declare const ENV_RESOLVERS: {
+    ssr: enhancedResolve.ResolveFunction;
+    worker: enhancedResolve.ResolveFunction;
+    client: enhancedResolve.ResolveFunction;
+};
+export declare const maybeResolveEnvImport: ({ id, envName, projectRootDir, }: {
+    id: string;
+    envName: keyof typeof ENV_RESOLVERS;
+    projectRootDir: string;
+}) => string | undefined;

package/dist/vite/envResolvers.mjs

@@ -0,0 +1,20 @@
+import enhancedResolve from "enhanced-resolve";
+export const ENV_RESOLVERS = {
+    ssr: enhancedResolve.create.sync({
+        conditionNames: ["workerd", "worker", "edge", "default"],
+    }),
+    worker: enhancedResolve.create.sync({
+        conditionNames: ["react-server", "workerd", "worker", "edge", "default"],
+    }),
+    client: enhancedResolve.create.sync({
+        conditionNames: ["browser", "default"],
+    }),
+};
+export const maybeResolveEnvImport = ({ id, envName, projectRootDir, }) => {
+    try {
+        return ENV_RESOLVERS[envName](projectRootDir, id) || undefined;
+    }
+    catch (error) {
+        return undefined;
+    }
+};

package/dist/vite/getViteEsbuild.mjs

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

package/dist/vite/hmrStabilityPlugin.d.mts

@@ -0,0 +1,2 @@
+import { type Plugin } from "vite";
+export declare function hmrStabilityPlugin(): Plugin;

package/dist/vite/hmrStabilityPlugin.mjs

@@ -0,0 +1,73 @@
+import debug from "debug";
+const log = debug("rws-vite-plugin:hmr-stability");
+let stabilityPromise = null;
+let stabilityResolver = null;
+let debounceTimer = null;
+const DEBOUNCE_MS = 500;
+function startWaitingForStability() {
+    if (!stabilityPromise) {
+        log("Starting to wait for server stability...");
+        stabilityPromise = new Promise((resolve) => {
+            stabilityResolver = resolve;
+        });
+        // Start the timer. If it fires, we're stable.
+        debounceTimer = setTimeout(finishWaiting, DEBOUNCE_MS);
+    }
+}
+function activityDetected() {
+    if (stabilityPromise) {
+        // If we're waiting for stability, reset the timer.
+        log("Activity detected, resetting stability timer.");
+        if (debounceTimer)
+            clearTimeout(debounceTimer);
+        debounceTimer = setTimeout(finishWaiting, DEBOUNCE_MS);
+    }
+}
+function finishWaiting() {
+    if (stabilityResolver) {
+        log("Server appears stable. Resolving promise.");
+        stabilityResolver();
+    }
+    stabilityPromise = null;
+    stabilityResolver = null;
+    debounceTimer = null;
+}
+export function hmrStabilityPlugin() {
+    return {
+        name: "rws-vite-plugin:hmr-stability",
+        // Monitor server activity
+        transform() {
+            activityDetected();
+            return null;
+        },
+        configureServer(server) {
+            // context(justinvdm, 19 Nov 2025): This hook adds an error handling
+            // middleware for stale dependency errors. It runs in a returned function,
+            // which intentionally places it late in the middleware stack. Unlike
+            // other plugins that must run before the Cloudflare plugin to prevent
+            // startup deadlocks, its timing is not critical, so `enforce: 'pre'`
+            // is not needed.
+            return () => {
+                server.middlewares.use(async function rwsdkStaleBundleErrorHandler(err, req, res, next) {
+                    if (err &&
+                        typeof err.message === "string" &&
+                        err.message.includes("new version of the pre-bundle")) {
+                        log("Caught stale pre-bundle error. Waiting for server to stabilize...");
+                        startWaitingForStability();
+                        await stabilityPromise;
+                        log("Server stabilized. Sending full-reload and redirecting.");
+                        // Signal the client to do a full page reload.
+                        server.environments.client.hot.send({
+                            type: "full-reload",
+                        });
+                        // No need to wait further here, the stability promise handled it.
+                        res.writeHead(307, { Location: req.url });
+                        res.end();
+                        return;
+                    }
+                    next(err);
+                });
+            };
+        },
+    };
+}

package/dist/vite/knownDepsResolverPlugin.d.mts

@@ -1,15 +1,9 @@
-import enhancedResolve from "enhanced-resolve";
 import { Plugin } from "vite";
 export declare const ENV_PREDEFINED_IMPORTS: {
     worker: string[];
     ssr: string[];
     client: string[];
 };
-export declare const ENV_RESOLVERS: {
-    ssr: enhancedResolve.ResolveFunction;
-    worker: enhancedResolve.ResolveFunction;
-    client: enhancedResolve.ResolveFunction;
-};
 export declare const knownDepsResolverPlugin: ({ projectRootDir, }: {
     projectRootDir: string;
 }) => Plugin[];

package/dist/vite/knownDepsResolverPlugin.mjs

@@ -1,7 +1,7 @@
 import debug from "debug";
-import enhancedResolve from "enhanced-resolve";
 import { ROOT_DIR } from "../lib/constants.mjs";
 import { ensureAliasArray } from "./ensureAliasArray.mjs";
+import { ENV_RESOLVERS } from "./envResolvers.mjs";
 const log = debug("rwsdk:vite:known-deps-resolver-plugin");
 const KNOWN_PREFIXES = [
     "react",
@@ -36,17 +36,6 @@ export const ENV_PREDEFINED_IMPORTS = {
         "react-server-dom-webpack/client.edge",
     ],
 };
-export const ENV_RESOLVERS = {
-    ssr: enhancedResolve.create.sync({
-        conditionNames: ["workerd", "worker", "edge", "default"],
-    }),
-    worker: enhancedResolve.create.sync({
-        conditionNames: ["react-server", "workerd", "worker", "edge", "default"],
-    }),
-    client: enhancedResolve.create.sync({
-        conditionNames: ["browser", "default"],
-    }),
-};
 function resolveKnownImport(id, envName, projectRootDir, isPrefixedImport = false) {
     if (!isPrefixedImport) {
         const isKnownImport = KNOWN_PREFIXES.some((prefix) => id === prefix || id.startsWith(`${prefix}/`));
@@ -106,15 +95,32 @@ export const knownDepsResolverPlugin = ({ projectRootDir, }) => {
         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) {
+            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);
                     }
-                    if (resolved && args.importer !== "") {
+                    // 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;
                         }
@@ -129,11 +135,23 @@ export const knownDepsResolverPlugin = ({ projectRootDir, }) => {
     return [
         {
             name: "rwsdk:known-dependencies-resolver:config",
-            enforce: "post",
+            enforce: "pre",
             config(config, { command }) {
                 isBuild = command === "build";
                 log("Configuring plugin for command=%s", command);
             },
+            async configureServer(server) {
+                // context(justinvdm, 19 Nov 2025): This hook must run before the
+                // Cloudflare plugin's `configureServer` hook, so we use `enforce: 'pre'`.
+                // The Cloudflare plugin's hook executes the worker entry file to discover
+                // its exports. This can trigger the evaluation of SSR code. We must initialize
+                // the SSR dependency optimizer *before* that happens to ensure that any
+                // dependencies in `optimizeDeps.include` (like `react-dom/server.edge`)
+                // are correctly registered before they are discovered lazily.
+                if (server.environments.ssr?.depsOptimizer) {
+                    await server.environments.ssr.depsOptimizer.init();
+                }
+            },
             configResolved(config) {
                 log("Setting up resolve aliases and optimizeDeps for each environment");
                 // Set up aliases and optimizeDeps for each environment

package/dist/vite/linkerPlugin.d.mts

@@ -1,8 +1,9 @@
 import type { Plugin } from "vite";
-export declare function linkWorkerBundle({ code, manifestContent, projectRootDir, }: {
+export declare function linkWorkerBundle({ code, manifestContent, projectRootDir, base, }: {
     code: string;
     manifestContent: string;
     projectRootDir: string;
+    base?: string;
 }): {
     code: string;
     map: null;

package/dist/vite/linkerPlugin.mjs

@@ -4,19 +4,22 @@ import path from "node:path";
 import { CLIENT_MANIFEST_RELATIVE_PATH } from "../lib/constants.mjs";
 import { normalizeModulePath } from "../lib/normalizeModulePath.mjs";
 const log = debug("rwsdk:vite:linker-plugin");
-export function linkWorkerBundle({ code, manifestContent, projectRootDir, }) {
+export function linkWorkerBundle({ code, manifestContent, projectRootDir, base, }) {
     let newCode = code;
     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)) {
         const normalizedKey = normalizeModulePath(key, projectRootDir, {
             isViteStyle: false,
         });
-        newCode = newCode.replaceAll(`rwsdk_asset:${normalizedKey}`, `/${value.file}`);
+        // If base is provided, prepend it with the final hashed path.
+        // Base is assumed to have a trailing "/".
+        const assetPath = (base ? base : "/") + value.file;
+        newCode = newCode.replaceAll(`rwsdk_asset:${normalizedKey}`, assetPath);
     }
     // 3. Deprefix any remaining placeholders that were not in the manifest.
     // This handles public assets that don't go through the bundler.
@@ -28,8 +31,12 @@ export function linkWorkerBundle({ code, manifestContent, projectRootDir, }) {
     };
 }
 export const linkerPlugin = ({ projectRootDir, }) => {
+    let config;
     return {
         name: "rwsdk:linker",
+        configResolved(resolvedConfig) {
+            config = resolvedConfig;
+        },
         async renderChunk(code) {
             if (this.environment.name !== "worker" ||
                 process.env.RWSDK_BUILD_PASS !== "linker") {
@@ -41,6 +48,7 @@ export const linkerPlugin = ({ projectRootDir, }) => {
                 code,
                 manifestContent,
                 projectRootDir,
+                base: config.base,
             });
             log("Final worker chunk rendered");
             return result;

package/dist/vite/linkerPlugin.test.mjs

@@ -29,6 +29,21 @@ describe("linkWorkerBundle", () => {
         expect(result.code).toContain(`const stylesheet = "/assets/styles.123.css";`);
         expect(result.code).toContain(`const logo = "/assets/logo.abc.svg";`);
     });
+    it("should replace asset placeholder with a base + hashed paths from the manifest if base is provided", () => {
+        const code = `
+      const stylesheet = "rwsdk_asset:/src/styles.css";
+      const logo = "rwsdk_asset:/src/logo.svg";
+    `;
+        const base = "/base/";
+        const result = linkWorkerBundle({
+            code,
+            manifestContent,
+            projectRootDir,
+            base,
+        });
+        expect(result.code).toContain(`const stylesheet = "/base/assets/styles.123.css";`);
+        expect(result.code).toContain(`const logo = "/base/assets/logo.abc.svg";`);
+    });
     it("should deprefix remaining asset placeholders not in the manifest", () => {
         const code = `const publicImg = "rwsdk_asset:/images/photo.jpg";`;
         const result = linkWorkerBundle({

package/dist/vite/miniflareHMRPlugin.mjs

@@ -33,29 +33,15 @@ export const hasEntryAsAncestor = ({ module, entryFile, seen = new Set(), }) =>
     }
     return false;
 };
-const isInUseClientGraph = ({ file, clientFiles, server, }) => {
-    const id = normalizeModulePath(file, server.config.root);
-    if (clientFiles.has(id)) {
-        return true;
-    }
-    const modules = server.environments.client.moduleGraph.getModulesByFile(file);
-    if (!modules) {
-        return false;
-    }
-    for (const m of modules) {
-        for (const importer of m.importers) {
-            if (importer.file &&
-                isInUseClientGraph({ file: importer.file, clientFiles, server })) {
-                return true;
-            }
-        }
-    }
-    return false;
-};
 export const miniflareHMRPlugin = (givenOptions) => [
     {
         name: "rwsdk:miniflare-hmr",
         configureServer(server) {
+            // context(justinvdm, 19 Nov 2025): This hook sets up an error handler
+            // middleware. It runs in a returned function, which intentionally
+            // places it late in the middleware stack. Unlike plugins that must
+            // run before the Cloudflare plugin to prevent startup deadlocks, its
+            // timing is not critical, so `enforce: 'pre'` is not needed.
             return () => {
                 server.middlewares.use(function rwsdkDevServerErrorHandler(err, _req, _res, next) {
                     if (err) {
@@ -93,15 +79,6 @@ export const miniflareHMRPlugin = (givenOptions) => [
             }
             if (this.environment.name === "ssr") {
                 log("SSR update, invalidating recursively", ctx.file);
-                const isUseClientUpdate = isInUseClientGraph({
-                    file: ctx.file,
-                    clientFiles,
-                    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));
@@ -166,21 +143,12 @@ export const miniflareHMRPlugin = (givenOptions) => [
                         }
                     }
                 }
-                const isUseClientUpdate = isInUseClientGraph({
-                    file: ctx.file,
-                    clientFiles,
-                    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
             // => Notify for custom RSC-based HMR update, then short circuit HMR
             if (isWorkerUpdate && this.environment.name === environment) {
+                invalidateModule(ctx.server, environment, ctx.file);
                 const shortName = getShortName(ctx.file, ctx.server.config.root);
                 this.environment.logger.info(`${colors.green(`worker update`)} ${colors.dim(shortName)}`, {
                     clear: true,

package/dist/vite/moveStaticAssetsPlugin.mjs

@@ -1,13 +1,23 @@
-import { $sh } from "../lib/$.mjs";
+import path from "node:path";
+import fs from "fs-extra";
+import { glob } from "glob";
 export const moveStaticAssetsPlugin = ({ rootDir, }) => ({
     name: "rwsdk:move-static-assets",
     apply: "build",
     async closeBundle() {
         if (this.environment.name === "worker" &&
             process.env.RWSDK_BUILD_PASS === "linker") {
-            await $sh({
-                cwd: rootDir,
-            }) `mv dist/worker/assets/*.css dist/client/assets/ || true`;
+            const sourceDir = path.join(rootDir, "dist", "worker", "assets");
+            const destDir = path.join(rootDir, "dist", "client", "assets");
+            const cssFiles = await glob("*.css", { cwd: sourceDir });
+            if (cssFiles.length > 0) {
+                await fs.ensureDir(destDir);
+                for (const file of cssFiles) {
+                    const sourceFile = path.join(sourceDir, file);
+                    const destFile = path.join(destDir, file);
+                    await fs.move(sourceFile, destFile, { overwrite: true });
+                }
+            }
         }
     },
 });

package/dist/vite/redwoodPlugin.mjs

@@ -18,12 +18,13 @@ import { directivesPlugin } from "./directivesPlugin.mjs";
 import { injectVitePreamble } from "./injectVitePreamblePlugin.mjs";
 import { knownDepsResolverPlugin } from "./knownDepsResolverPlugin.mjs";
 import { linkerPlugin } from "./linkerPlugin.mjs";
-import { manifestPlugin } from "./manifestPlugin.mjs";
 import { miniflareHMRPlugin } from "./miniflareHMRPlugin.mjs";
 import { moveStaticAssetsPlugin } from "./moveStaticAssetsPlugin.mjs";
 import { prismaPlugin } from "./prismaPlugin.mjs";
 import { resolveForcedPaths } from "./resolveForcedPaths.mjs";
 import { ssrBridgePlugin } from "./ssrBridgePlugin.mjs";
+import { staleDepRetryPlugin } from "./staleDepRetryPlugin.mjs";
+import { statePlugin } from "./statePlugin.mjs";
 import { transformJsxScriptTagsPlugin } from "./transformJsxScriptTagsPlugin.mjs";
 import { useClientLookupPlugin } from "./useClientLookupPlugin.mjs";
 import { useServerLookupPlugin } from "./useServerLookupPlugin.mjs";
@@ -74,17 +75,15 @@ export const redwoodPlugin = async (options = {}) => {
     // 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" &&
-        process.env.RWSDK_DEPLOY !== "1" &&
+        process.env.NODE_ENV !== "production" &&
         !(await pathExists(resolve(projectRootDir, ".wrangler"))) &&
         (await hasPkgScript(projectRootDir, "dev:init"))) {
         console.log("🚀 Project has no .wrangler directory yet, assuming fresh install: running `npm run dev:init`...");
-        await $({
-            // context(justinvdm, 01 Apr 2025): We want to avoid interactive migration y/n prompt, so we ignore stdin
-            // as a signal to operate in no-tty mode
-            stdio: ["ignore", "inherit", "inherit"],
-        }) `npm run dev:init`;
+        await $ `npm run dev:init`;
     }
     return [
+        staleDepRetryPlugin(),
+        statePlugin({ projectRootDir }),
         devServerTimingPlugin(),
         devServerConstantPlugin(),
         directiveModulesDevPlugin({
@@ -144,9 +143,6 @@ export const redwoodPlugin = async (options = {}) => {
             clientEntryPoints,
             projectRootDir,
         }),
-        manifestPlugin({
-            projectRootDir,
-        }),
         moveStaticAssetsPlugin({ rootDir: projectRootDir }),
         prismaPlugin({ projectRootDir }),
         linkerPlugin({ projectRootDir }),