rwsdk 1.0.0-beta.4 → 1.0.0-beta.41

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 }) => {
@@ -55,6 +56,7 @@ export const configPlugin = ({ silent, projectRootDir, workerEntryPathname, clie
             build: {
                 outDir: resolve(projectRootDir, "dist", "worker"),
                 emitAssets: true,
+                ssrManifest: true,
                 emptyOutDir: false,
                 ssr: true,
             },
@@ -93,6 +95,7 @@ export const configPlugin = ({ silent, projectRootDir, workerEntryPathname, clie
                             "rwsdk/constants",
                             "rwsdk/debug",
                             "rwsdk/realtime/client",
+                            "rwsdk/router",
                             "rwsdk/turnstile",
                         ],
                         entries: [],
@@ -161,22 +164,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) {
@@ -97,9 +101,12 @@ export const createDirectiveLookupPlugin = async ({ projectRootDir, files, confi
                 log("Skipping optimizeDeps and aliasing for environment: %s", env);
             }
         },
-        resolveId(source) {
-            // Skip during directive scanning to avoid performance issues
-            if (process.env.RWSDK_DIRECTIVE_SCAN_ACTIVE) {
+        resolveId(source, _importer, options) {
+            // Skip during our directive scanning to avoid performance issues
+            // context(justinvdm, 20 Jan 2025): We check options.custom?.rwsdk?.directiveScan to distinguish
+            // between our directive scan (which should skip) and external calls like Cloudflare's early
+            // dispatch (which should be handled normally).
+            if (options?.custom?.rwsdk?.directiveScan === true) {
                 return;
             }
             if (source !== `${config.virtualModuleName}.js`) {
@@ -140,10 +147,6 @@ export const createDirectiveLookupPlugin = async ({ projectRootDir, files, confi
             return source;
         },
         async load(id) {
-            // Skip during directive scanning to avoid performance issues
-            if (process.env.RWSDK_DIRECTIVE_SCAN_ACTIVE) {
-                return;
-            }
             if (id === config.virtualModuleName + ".js") {
                 log("Loading %s module with %d files", config.virtualModuleName, files.size);
                 const environment = this.environment?.name || "client";

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/diagnosticAssetGraphPlugin.d.mts

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

package/dist/vite/diagnosticAssetGraphPlugin.mjs

@@ -0,0 +1,41 @@
+export const diagnosticAssetGraphPlugin = ({ rootDir, }) => ({
+    name: "rwsdk:diagnostic-asset-graph",
+    apply: "build",
+    async buildEnd() {
+        if (this.environment.name === "worker" &&
+            process.env.RWSDK_BUILD_PASS === "worker") {
+            console.log("\n=== Asset Graph Diagnostic ===");
+            const moduleIds = Array.from(this.getModuleIds());
+            console.log(`Total modules: ${moduleIds.length}`);
+            const urlImportedModules = new Set();
+            const publicAssets = new Set();
+            for (const moduleId of moduleIds) {
+                const moduleInfo = this.getModuleInfo(moduleId);
+                if (moduleInfo) {
+                    const isImportedByUrl = moduleInfo.importers.some((importer) => importer.includes("?url")) || moduleId.includes("?url");
+                    if (isImportedByUrl) {
+                        urlImportedModules.add(moduleId);
+                        console.log(`\nModule imported with ?url: ${moduleId}`);
+                        console.log(`  Importers: ${moduleInfo.importers.join(", ")}`);
+                        if (moduleInfo.importedIds) {
+                            console.log(`  Imports: ${moduleInfo.importedIds.join(", ")}`);
+                            for (const importedId of moduleInfo.importedIds) {
+                                publicAssets.add(importedId);
+                            }
+                        }
+                    }
+                    if (moduleInfo.importers.some((importer) => importer.includes("Document.tsx"))) {
+                        console.log(`\nModule imported by Document.tsx: ${moduleId}`);
+                        console.log(`  Importers: ${moduleInfo.importers.join(", ")}`);
+                        if (moduleInfo.importedIds) {
+                            console.log(`  Imports: ${moduleInfo.importedIds.join(", ")}`);
+                        }
+                    }
+                }
+            }
+            console.log(`\nTotal modules imported with ?url: ${urlImportedModules.size}`);
+            console.log(`Total transitive dependencies: ${publicAssets.size}`);
+            console.log("\n=== End Asset Graph Diagnostic ===\n");
+        }
+    },
+});

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
@@ -52,10 +56,6 @@ export const directivesPlugin = ({ projectRootDir, clientFiles, serverFiles, })
             });
         },
         async transform(code, id) {
-            // Skip during directive scanning to avoid performance issues
-            if (process.env.RWSDK_DIRECTIVE_SCAN_ACTIVE) {
-                return;
-            }
             if (isBuild &&
                 this.environment?.name === "worker" &&
                 process.env.RWSDK_BUILD_PASS !== "worker") {

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/injectVitePreamblePlugin.mjs

@@ -4,10 +4,6 @@ export const injectVitePreamble = ({ clientEntryPoints, projectRootDir, }) => ({
     name: "rwsdk:inject-vite-preamble",
     apply: "serve",
     transform(code, id) {
-        // Skip during directive scanning to avoid performance issues
-        if (process.env.RWSDK_DIRECTIVE_SCAN_ACTIVE) {
-            return;
-        }
         if (this.environment.name !== "client") {
             return;
         }

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,7 +135,6 @@ export const knownDepsResolverPlugin = ({ projectRootDir, }) => {
     return [
         {
             name: "rwsdk:known-dependencies-resolver:config",
-            enforce: "post",
             config(config, { command }) {
                 isBuild = command === "build";
                 log("Configuring plugin for command=%s", command);
@@ -173,9 +178,12 @@ export const knownDepsResolverPlugin = ({ projectRootDir, }) => {
         {
             name: "rwsdk:known-dependencies-resolver:resolveId",
             enforce: "pre",
-            async resolveId(id, importer) {
-                // Skip during directive scanning to avoid performance issues
-                if (process.env.RWSDK_DIRECTIVE_SCAN_ACTIVE) {
+            async resolveId(id, importer, options) {
+                // Skip during our directive scanning to avoid performance issues
+                // context(justinvdm, 20 Jan 2025): We check options.custom?.rwsdk?.directiveScan to distinguish
+                // between our directive scan (which should skip) and external calls like Cloudflare's early
+                // dispatch (which should be handled normally).
+                if (options?.custom?.rwsdk?.directiveScan === true) {
                     return;
                 }
                 if (!isBuild) {

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,44 @@
-import { $sh } from "../lib/$.mjs";
+import fs from "fs-extra";
+import path from "node:path";
 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");
+            if (!(await fs.pathExists(sourceDir))) {
+                return;
+            }
+            const ssrManifestPath = path.join(rootDir, "dist", "worker", ".vite", "ssr-manifest.json");
+            if (!(await fs.pathExists(ssrManifestPath))) {
+                return;
+            }
+            const manifestContent = await fs.readFile(ssrManifestPath, "utf-8");
+            const ssrManifest = JSON.parse(manifestContent);
+            const publicAssets = new Set();
+            for (const [moduleId, assetPaths] of Object.entries(ssrManifest)) {
+                if (moduleId.includes("?url")) {
+                    for (const assetPath of assetPaths) {
+                        const assetFileName = path.basename(assetPath);
+                        publicAssets.add(assetFileName);
+                    }
+                }
+            }
+            const allFiles = await fs.readdir(sourceDir);
+            const filesToMove = allFiles.filter((file) => !file.endsWith(".js") &&
+                !file.endsWith(".map") &&
+                publicAssets.has(file));
+            if (filesToMove.length > 0) {
+                await fs.ensureDir(destDir);
+                for (const file of filesToMove) {
+                    const sourceFile = path.join(sourceDir, file);
+                    const destFile = path.join(destDir, file);
+                    await fs.move(sourceFile, destFile, { overwrite: true });
+                }
+            }
+            await fs.remove(ssrManifestPath);
         }
     },
 });