rwsdk 1.0.0-beta.2-test.20250930092748 → 1.0.0-beta.20

package/dist/vite/runDirectivesScan.mjs

@@ -1,6 +1,7 @@
 // @ts-ignore
 import { compile } from "@mdx-js/mdx";
 import debug from "debug";
+import { glob } from "glob";
 import fsp from "node:fs/promises";
 import path from "node:path";
 import { INTERMEDIATES_OUTPUT_DIR } from "../lib/constants.mjs";
@@ -17,6 +18,39 @@ const isObject = (value) => Object.prototype.toString.call(value) === "[object O
 // https://github.com/vitejs/vite/blob/main/packages/vite/src/node/utils.ts
 const externalRE = /^(https?:)?\/\//;
 const isExternalUrl = (url) => externalRE.test(url);
+async function findDirectiveRoots({ root, readFileWithCache, directiveCheckCache, }) {
+    const srcDir = path.resolve(root, "src");
+    const files = await glob("**/*.{ts,tsx,js,jsx,mjs,mts,cjs,cts,mdx}", {
+        cwd: srcDir,
+        absolute: true,
+    });
+    const directiveFiles = new Set();
+    for (const file of files) {
+        if (directiveCheckCache.has(file)) {
+            if (directiveCheckCache.get(file)) {
+                directiveFiles.add(file);
+            }
+            continue;
+        }
+        try {
+            const content = await readFileWithCache(file);
+            const hasClient = hasDirective(content, "use client");
+            const hasServer = hasDirective(content, "use server");
+            const hasAnyDirective = hasClient || hasServer;
+            directiveCheckCache.set(file, hasAnyDirective);
+            if (hasAnyDirective) {
+                directiveFiles.add(file);
+            }
+        }
+        catch (e) {
+            log("Could not read file during pre-scan, skipping:", file);
+            // Cache the failure to avoid re-reading a problematic file
+            directiveCheckCache.set(file, false);
+        }
+    }
+    log("Pre-scan found directive files:", Array.from(directiveFiles));
+    return directiveFiles;
+}
 export async function resolveModuleWithEnvironment({ path, importer, importerEnv, clientResolver, workerResolver, }) {
     const resolver = importerEnv === "client" ? clientResolver : workerResolver;
     return new Promise((resolvePromise) => {
@@ -56,6 +90,16 @@ export const runDirectivesScan = async ({ rootConfig, environments, clientFiles,
     // Set environment variable to indicate scanning is in progress
     process.env.RWSDK_DIRECTIVE_SCAN_ACTIVE = "true";
     try {
+        const fileContentCache = new Map();
+        const directiveCheckCache = new Map();
+        const readFileWithCache = async (path) => {
+            if (fileContentCache.has(path)) {
+                return fileContentCache.get(path);
+            }
+            const contents = await fsp.readFile(path, "utf-8");
+            fileContentCache.set(path, contents);
+            return contents;
+        };
         const esbuild = await getViteEsbuild(rootConfig.root);
         const input = initialEntries ?? environments.worker.config.build.rollupOptions?.input;
         let entries;
@@ -78,19 +122,19 @@ export const runDirectivesScan = async ({ rootConfig, environments, clientFiles,
         // Filter out virtual modules since they can't be scanned by esbuild
         const realEntries = entries.filter((entry) => !entry.includes("virtual:"));
         const absoluteEntries = realEntries.map((entry) => path.resolve(rootConfig.root, entry));
-        log("Starting directives scan for worker environment with entries:", absoluteEntries);
+        const applicationDirectiveFiles = await findDirectiveRoots({
+            root: rootConfig.root,
+            readFileWithCache,
+            directiveCheckCache,
+        });
+        const combinedEntries = new Set([
+            ...absoluteEntries,
+            ...applicationDirectiveFiles,
+        ]);
+        log("Starting directives scan with combined entries:", Array.from(combinedEntries));
         const workerResolver = createViteAwareResolver(rootConfig, environments.worker);
         const clientResolver = createViteAwareResolver(rootConfig, environments.client);
         const moduleEnvironments = new Map();
-        const fileContentCache = new Map();
-        const readFileWithCache = async (path) => {
-            if (fileContentCache.has(path)) {
-                return fileContentCache.get(path);
-            }
-            const contents = await fsp.readFile(path, "utf-8");
-            fileContentCache.set(path, contents);
-            return contents;
-        };
         const esbuildScanPlugin = {
             name: "rwsdk:esbuild-scan-plugin",
             setup(build) {
@@ -232,7 +276,7 @@ export const runDirectivesScan = async ({ rootConfig, environments, clientFiles,
             },
         };
         await esbuild.build({
-            entryPoints: absoluteEntries,
+            entryPoints: Array.from(combinedEntries),
             bundle: true,
             write: false,
             outdir: path.join(INTERMEDIATES_OUTPUT_DIR, "directive-scan"),
@@ -254,7 +298,8 @@ export const runDirectivesScan = async ({ rootConfig, environments, clientFiles,
     }
 };
 const deferredLog = (message) => {
+    const doLog = process.env.RWSDK_WORKER_RUN ? log : console.log;
     setTimeout(() => {
-        console.log(message);
+        doLog(message);
     }, 500);
 };

package/dist/vite/ssrBridgePlugin.mjs

@@ -10,9 +10,32 @@ export const ssrBridgePlugin = ({ clientFiles, serverFiles, }) => {
     const ssrBridgePlugin = {
         name: "rwsdk:ssr-bridge",
         enforce: "pre",
-        async configureServer(server) {
+        configureServer(server) {
             devServer = server;
+            const ssrHot = server.environments.ssr.hot;
+            const originalSsrHotSend = ssrHot.send;
+            // Chain the SSR's full reload behaviour to the worker
+            ssrHot.send = (...args) => {
+                if (typeof args[0] === "object" && args[0].type === "full-reload") {
+                    for (const envName of ["worker", "ssr"]) {
+                        const moduleGraph = server.environments[envName].moduleGraph;
+                        moduleGraph.invalidateAll();
+                    }
+                    log("SSR full-reload detected, propagating to worker");
+                    // context(justinvdm, 21 Oct 2025): By sending the full-reload event
+                    // to the worker, we ensure that the worker's module runner cache is
+                    // invalidated, as it would have been if this were a full-reload event
+                    // from the worker.
+                    server.environments.worker.hot.send.apply(server.environments.worker.hot, args);
+                }
+                return originalSsrHotSend.apply(ssrHot, args);
+            };
             log("Configured dev server");
+            const originalRun = devServer.environments.ssr.depsOptimizer?.run;
+            devServer.environments.ssr.depsOptimizer.run = async () => {
+                originalRun();
+                devServer.environments.worker.depsOptimizer.run();
+            };
         },
         config(_, { command, isPreview }) {
             isDev = !isPreview && command === "serve";
@@ -48,7 +71,7 @@ export const ssrBridgePlugin = ({ clientFiles, serverFiles, }) => {
                 log("Worker environment esbuild configuration complete");
             }
         },
-        async resolveId(id) {
+        async resolveId(id, importer) {
             // Skip during directive scanning to avoid performance issues
             if (process.env.RWSDK_DIRECTIVE_SCAN_ACTIVE) {
                 return;
@@ -107,46 +130,93 @@ export const ssrBridgePlugin = ({ clientFiles, serverFiles, }) => {
             if (id.startsWith(VIRTUAL_SSR_PREFIX) &&
                 this.environment.name === "worker") {
                 const realId = id.slice(VIRTUAL_SSR_PREFIX.length);
-                const idForFetch = realId.endsWith(".css.js")
+                let idForFetch = realId.endsWith(".css.js")
                     ? realId.slice(0, -3)
                     : realId;
                 log("Virtual SSR module load: id=%s, realId=%s, idForFetch=%s", id, realId, idForFetch);
                 if (isDev) {
-                    log("Dev mode: fetching SSR module for realPath=%s", idForFetch);
-                    const result = await devServer?.environments.ssr.fetchModule(idForFetch);
-                    process.env.VERBOSE &&
-                        log("Fetch module result: id=%s, result=%O", idForFetch, result);
-                    const code = "code" in result ? result.code : undefined;
-                    if (idForFetch.endsWith(".css") &&
-                        !idForFetch.endsWith(".module.css")) {
-                        process.env.VERBOSE &&
-                            log("Plain CSS file, returning empty module for %s", idForFetch);
-                        return "export default {};";
+                    // from the SSR environment, which is crucial for things like server
+                    // components.
+                    try {
+                        const ssrOptimizer = devServer.environments.ssr.depsOptimizer;
+                        // context(justinvdm, 20 Oct 2025): This is the fix for the stale
+                        // dependency issue. The root cause is the "unhashed-to-hashed"
+                        // transition. Our worker code imports a clean ID
+                        // (`rwsdk/__ssr_bridge`), but we expect to fetch the hashed,
+                        // optimized version from the SSR environment. When a re-optimization
+                        // happens, Vite's `fetchModule` (running in the SSR env) finds a
+                        // "ghost node" in its module graph for the clean ID and incorrectly
+                        // re-uses its stale, hashed `id` property.
+                        //
+                        // To fix this, we manually resolve the hashed path here, before
+                        // asking the SSR env to process the module. We look into the SSR
+                        // optimizer's metadata to find the correct, up-to-date hash and
+                        // construct the path ourselves. This ensures the SSR env is
+                        // always working with the correct, versioned ID, bypassing the
+                        // faulty ghost node lookup.
+                        if (ssrOptimizer &&
+                            Object.prototype.hasOwnProperty.call(ssrOptimizer.metadata.optimized, realId)) {
+                            const depInfo = ssrOptimizer.metadata.optimized[realId];
+                            idForFetch = ssrOptimizer.getOptimizedDepId(depInfo);
+                            log("Manually resolved %s to hashed path for fetchModule: %s", realId, idForFetch);
+                        }
+                        log("Virtual SSR module load: id=%s, realId=%s, idForFetch=%s", id, realId, idForFetch);
+                        log("Dev mode: fetching SSR module for realPath=%s", idForFetch);
+                        // We use `fetchModule` with `cached: false` as a safeguard. Since
+                        // we're in a `load` hook, we know the worker-side cache for this
+                        // virtual module is stale. `cached: false` ensures that we also
+                        // bypass any potentially stale transform result in the SSR
+                        // environment's cache, guaranteeing we get the freshest possible
+                        // code.
+                        const result = await devServer.environments.ssr.fetchModule(idForFetch, undefined, { cached: false });
+                        if ("code" in result) {
+                            log("Fetched SSR module code length: %d", result.code?.length || 0);
+                            const code = result.code;
+                            if (idForFetch.endsWith(".css") &&
+                                !idForFetch.endsWith(".module.css")) {
+                                process.env.VERBOSE &&
+                                    log("Plain CSS file, returning empty module for %s", idForFetch);
+                                return "export default {};";
+                            }
+                            const s = new MagicString(code || "");
+                            const callsites = findSsrImportCallSites(idForFetch, code || "", log);
+                            for (const site of callsites) {
+                                const normalized = site.specifier.startsWith("/@id/")
+                                    ? site.specifier.slice("/@id/".length)
+                                    : site.specifier;
+                                // context(justinvdm, 11 Aug 2025):
+                                // - We replace __vite_ssr_import__ and __vite_ssr_dynamic_import__
+                                //   with import() calls so that the module graph can be built
+                                //   correctly (vite looks for imports and import()s to build module
+                                //   graph)
+                                // - We prepend /@id/$VIRTUAL_SSR_PREFIX to the specifier so that we
+                                //   can stay within the SSR subgraph of the worker module graph
+                                const replacement = `import("/@id/${VIRTUAL_SSR_PREFIX}${normalized}")`;
+                                s.overwrite(site.start, site.end, replacement);
+                            }
+                            const out = s.toString();
+                            process.env.VERBOSE &&
+                                log("Transformed SSR module code for realId=%s: %s", realId, out);
+                            return {
+                                code: out,
+                                map: null, // Sourcemaps are handled by fetchModule's inlining
+                            };
+                        }
+                        else {
+                            // This case can be hit if the module is already cached. We may
+                            // need to handle this more gracefully, but for now we'll just
+                            // return an empty module.
+                            log("SSR module %s was already cached. Returning empty.", idForFetch);
+                            return "export default {}";
+                        }
                     }
-                    log("Fetched SSR module code length: %d", code?.length || 0);
-                    const s = new MagicString(code || "");
-                    const callsites = findSsrImportCallSites(idForFetch, code || "", log);
-                    for (const site of callsites) {
-                        const normalized = site.specifier.startsWith("/@id/")
-                            ? site.specifier.slice("/@id/".length)
-                            : site.specifier;
-                        // context(justinvdm, 11 Aug 2025):
-                        // - We replace __vite_ssr_import__ and __vite_ssr_dynamic_import__
-                        //   with import() calls so that the module graph can be built
-                        //   correctly (vite looks for imports and import()s to build module
-                        //   graph)
-                        // - We prepend /@id/$VIRTUAL_SSR_PREFIX to the specifier so that we
-                        //   can stay within the SSR subgraph of the worker module graph
-                        const replacement = `import("/@id/${VIRTUAL_SSR_PREFIX}${normalized}")`;
-                        s.overwrite(site.start, site.end, replacement);
+                    catch (e) {
+                        log("Error fetching SSR module for realPath=%s: %s", id, e);
+                        throw e;
                     }
-                    const out = s.toString();
-                    log("Transformed SSR module code length: %d", out.length);
-                    process.env.VERBOSE &&
-                        log("Transformed SSR module code for realId=%s: %s", realId, out);
-                    return out;
                 }
             }
+            return;
         },
     };
     return ssrBridgePlugin;

package/dist/vite/staleDepRetryPlugin.d.mts

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

package/dist/vite/staleDepRetryPlugin.mjs

@@ -0,0 +1,69 @@
+import debug from "debug";
+const log = debug("rwsdk:vite:stale-dep-retry-plugin");
+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 staleDepRetryPlugin() {
+    return {
+        name: "rws-vite-plugin:stale-dep-retry",
+        apply: "serve",
+        // Monitor server activity by tapping into the transform hook. This is a
+        // reliable indicator that Vite is busy processing modules.
+        transform() {
+            activityDetected();
+            return null;
+        },
+        configureServer(server) {
+            // Return a function to ensure our middleware is placed after internal middlewares
+            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",
+                        });
+                        res.writeHead(307, { Location: req.originalUrl || req.url });
+                        res.end();
+                        return;
+                    }
+                    next(err);
+                });
+            };
+        },
+    };
+}

package/dist/vite/statePlugin.d.mts

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

package/dist/vite/statePlugin.mjs

@@ -0,0 +1,62 @@
+import debug from "debug";
+import fs from "node:fs/promises";
+import { RW_STATE_EXPORT_PATH } from "../lib/constants.mjs";
+import { maybeResolveEnvImport } from "./envResolvers.mjs";
+const log = debug("rwsdk:vite:state-plugin");
+const VIRTUAL_STATE_PREFIX = "virtual:rwsdk:state:";
+export const statePlugin = ({ projectRootDir, }) => {
+    let isDev = false;
+    const stateModulePath = maybeResolveEnvImport({
+        id: RW_STATE_EXPORT_PATH,
+        envName: "worker",
+        projectRootDir,
+    });
+    if (!stateModulePath) {
+        throw new Error(`[rwsdk] State module path not found for project root: ${projectRootDir}. This is likely a bug in RedwoodSDK. Please report this issue at https://github.com/redwoodjs/sdk/issues/new`);
+    }
+    return {
+        name: "rwsdk:state",
+        enforce: "pre",
+        config(_, { command, isPreview }) {
+            isDev = !isPreview && command === "serve";
+        },
+        configEnvironment(env, config) {
+            if (env === "worker") {
+                config.optimizeDeps ??= {};
+                config.optimizeDeps.esbuildOptions ??= {};
+                config.optimizeDeps.esbuildOptions.plugins ??= [];
+                config.optimizeDeps.esbuildOptions.plugins.push({
+                    name: "rwsdk-state-external",
+                    setup(build) {
+                        build.onResolve({
+                            // context(justinvdm, 13 Oct 2025): Vite dep optimizer slugifies the export path
+                            filter: new RegExp(`^(${RW_STATE_EXPORT_PATH}|${VIRTUAL_STATE_PREFIX}.*)$`),
+                        }, (args) => {
+                            log("Marking as external: %s", args.path);
+                            return {
+                                path: args.path,
+                                external: true,
+                            };
+                        });
+                    },
+                });
+            }
+        },
+        resolveId(id) {
+            if (id === RW_STATE_EXPORT_PATH) {
+                if (isDev && this.environment.name === "worker") {
+                    return `${VIRTUAL_STATE_PREFIX}${id}`;
+                }
+                else {
+                    return stateModulePath;
+                }
+            }
+        },
+        async load(id) {
+            if (id.startsWith(VIRTUAL_STATE_PREFIX)) {
+                log("Loading virtual state module from %s", stateModulePath);
+                return await fs.readFile(stateModulePath, "utf-8");
+            }
+        },
+    };
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rwsdk",
-  "version": "1.0.0-beta.2-test.20250930092748",
+  "version": "1.0.0-beta.20",
   "description": "Build fast, server-driven webapps on Cloudflare with SSR, RSC, and realtime",
   "type": "module",
   "bin": {
@@ -36,6 +36,10 @@
       "types": "./dist/runtime/entries/client.d.ts",
       "default": "./dist/runtime/entries/client.js"
     },
+    "./__state": {
+      "types": "./dist/runtime/state.d.ts",
+      "default": "./dist/runtime/state.js"
+    },
     "./__ssr": {
       "react-server": "./dist/runtime/entries/no-react-server.js",
       "types": "./dist/runtime/entries/ssr.d.ts",
@@ -145,11 +149,13 @@
     "@vitejs/plugin-react": "~5.0.0",
     "chokidar": "~4.0.0",
     "debug": "~4.4.0",
+    "decompress": "~4.2.1",
     "enhanced-resolve": "~5.18.1",
     "eventsource-parser": "~3.0.0",
     "execa": "~9.6.0",
     "find-up": "~8.0.0",
     "fs-extra": "~11.3.0",
+    "get-port": "^7.1.0",
     "glob": "~11.0.1",
     "ignore": "~7.0.4",
     "jsonc-parser": "~3.3.1",
@@ -167,13 +173,13 @@
     "unique-names-generator": "~4.7.1",
     "vibe-rules": "~0.3.0",
     "vite-tsconfig-paths": "~5.1.4",
-    "decompress": "~4.2.1"
+    "@types/glob": "^8.1.0"
   },
   "peerDependencies": {
-    "@cloudflare/vite-plugin": "^1.12.4",
-    "react": ">=19.2.0-canary-3fb190f7-20250908 <20.0.0",
-    "react-dom": ">=19.2.0-canary-3fb190f7-20250908 <20.0.0",
-    "react-server-dom-webpack": ">=19.2.0-canary-3fb190f7-20250908 <20.0.0",
+    "@cloudflare/vite-plugin": "^1.13.10",
+    "react": ">=19.2.0-0 <19.3.0 || >=19.3.0-0 <20.0.0",
+    "react-dom": ">=19.2.0-0 <19.3.0 || >=19.3.0-0 <20.0.0",
+    "react-server-dom-webpack": ">=19.2.0-0 <19.3.0 || >=19.3.0-0 <20.0.0",
     "vite": "^6.2.6 || 7.x",
     "wrangler": "^4.35.0"
   },
@@ -189,7 +195,7 @@
     "semver": "~7.7.1",
     "tsx": "~4.20.0",
     "typescript": "~5.9.0",
-    "vite": "7.1.6",
+    "vite": "~7.1.9",
     "vitest": "~3.2.0"
   }
 }

package/dist/vite/manifestPlugin.d.mts

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

package/dist/vite/manifestPlugin.mjs

@@ -1,63 +0,0 @@
-import debug from "debug";
-const log = debug("rwsdk:vite:manifest-plugin");
-const virtualModuleId = "virtual:rwsdk:manifest.js";
-const resolvedVirtualModuleId = "\0" + virtualModuleId;
-export const manifestPlugin = ({ projectRootDir, }) => {
-    let isBuild = false;
-    return {
-        name: "rwsdk:vite:manifest-plugin",
-        enforce: "pre",
-        configResolved(config) {
-            isBuild = config.command === "build";
-        },
-        resolveId(id) {
-            // Skip during directive scanning to avoid performance issues
-            if (process.env.RWSDK_DIRECTIVE_SCAN_ACTIVE) {
-                return;
-            }
-            if (id === virtualModuleId) {
-                return resolvedVirtualModuleId;
-            }
-        },
-        async load(id) {
-            // Skip during directive scanning to avoid performance issues
-            if (process.env.RWSDK_DIRECTIVE_SCAN_ACTIVE) {
-                return;
-            }
-            if (id === resolvedVirtualModuleId) {
-                if (isBuild) {
-                    // context(justinvdm, 28 Aug 2025): During the build, we don't have
-                    // the manifest yet. We insert a placeholder that the linker plugin
-                    // will replace in the final phase.
-                    log("Returning manifest placeholder for build");
-                    return `export default "__RWSDK_MANIFEST_PLACEHOLDER__"`;
-                }
-                // In dev, we can return an empty object.
-                log("Not a build, returning empty manifest");
-                return `export default {}`;
-            }
-        },
-        configEnvironment(name, config) {
-            if (name !== "worker" && name !== "ssr") {
-                return;
-            }
-            log("Configuring environment: name=%s", name);
-            config.optimizeDeps ??= {};
-            config.optimizeDeps.esbuildOptions ??= {};
-            config.optimizeDeps.esbuildOptions.plugins ??= [];
-            config.optimizeDeps.esbuildOptions.plugins.push({
-                name: "rwsdk:manifest:esbuild",
-                setup(build) {
-                    log("Setting up esbuild plugin for environment: %s", name);
-                    build.onResolve({ filter: /^virtual:rwsdk:manifest\.js$/ }, () => {
-                        log("Resolving virtual manifest module in esbuild");
-                        return {
-                            path: "virtual:rwsdk:manifest.js",
-                            external: true,
-                        };
-                    });
-                },
-            });
-        },
-    };
-};