rwsdk 1.0.0-beta.30 → 1.0.0-beta.30-test.20251120210809

package/dist/runtime/entries/no-react-server-ssr-bridge.js

@@ -0,0 +1,2 @@
+"use strict";
+throw new Error("rwsdk: SSR bridge was resolved with 'react-server' condition. This is a bug - the SSR bridge should be intercepted by the esbuild plugin before reaching package.json exports. Please report this issue.");

package/dist/runtime/requestInfo/worker.d.ts

@@ -2,7 +2,6 @@ import { DefaultAppContext, RequestInfo } from "./types";
 type DefaultRequestInfo = RequestInfo<DefaultAppContext>;
 export declare const requestInfo: DefaultRequestInfo;
 export declare function getRequestInfo(): RequestInfo;
-export declare function waitForRequestInfo(): Promise<DefaultRequestInfo>;
 export declare function runWithRequestInfo<Result>(nextRequestInfo: DefaultRequestInfo, fn: () => Result): Result;
 export declare function runWithRequestInfoOverrides<Result>(overrides: Partial<DefaultRequestInfo>, fn: () => Result): Result;
 export {};

package/dist/runtime/requestInfo/worker.js

@@ -1,6 +1,5 @@
 import { AsyncLocalStorage } from "async_hooks";
 import { defineRwState } from "rwsdk/__state";
-const requestInfoDeferred = defineRwState("requestInfoDeferred", () => Promise.withResolvers());
 const requestInfoStore = defineRwState("requestInfoStore", () => new AsyncLocalStorage());
 const requestInfoBase = {};
 const REQUEST_INFO_KEYS = ["request", "params", "ctx", "rw", "cf", "response"];
@@ -22,15 +21,8 @@ export function getRequestInfo() {
     }
     return store;
 }
-export function waitForRequestInfo() {
-    return requestInfoDeferred.promise;
-}
 export function runWithRequestInfo(nextRequestInfo, fn) {
-    const runWithRequestInfoFn = () => {
-        requestInfoDeferred.resolve(nextRequestInfo);
-        return fn();
-    };
-    return requestInfoStore.run(nextRequestInfo, runWithRequestInfoFn);
+    return requestInfoStore.run(nextRequestInfo, fn);
 }
 export function runWithRequestInfoOverrides(overrides, fn) {
     const requestInfo = requestInfoStore.getStore();

package/dist/vite/cloudflarePreInitPlugin.d.mts

@@ -0,0 +1,11 @@
+import type { Plugin } from "vite";
+/**
+ * Plugin that performs initialization workarounds that must run before
+ * the Cloudflare plugin's `configureServer` hook executes.
+ *
+ * Cloudflare plugin v1.15.0 executes the worker entry file during
+ * `configureServer` to detect exports, which triggers SSR code evaluation
+ * before normal server initialization completes. This plugin ensures
+ * required systems are initialized beforehand.
+ */
+export declare const cloudflarePreInitPlugin: () => Plugin;

package/dist/vite/cloudflarePreInitPlugin.mjs

@@ -0,0 +1,40 @@
+/**
+ * Plugin that performs initialization workarounds that must run before
+ * the Cloudflare plugin's `configureServer` hook executes.
+ *
+ * Cloudflare plugin v1.15.0 executes the worker entry file during
+ * `configureServer` to detect exports, which triggers SSR code evaluation
+ * before normal server initialization completes. This plugin ensures
+ * required systems are initialized beforehand.
+ */
+export const cloudflarePreInitPlugin = () => {
+    return {
+        name: "rwsdk:cloudflare-pre-init",
+        // context(justinvdm, 20 Jan 2025): This plugin must run before the
+        // Cloudflare plugin's `configureServer` hook. The Cloudflare plugin
+        // executes the worker entry file during `configureServer` to detect
+        // exports, and blocks the rest of the configureServer plugins until the
+        // request is complete. We must initialize required systems (SSR dependency
+        // optimizer + our own plugins to them, as well as CSS plugin's moduleCache)
+        // before this happens to prevent errors.
+        enforce: "pre",
+        async configureServer(server) {
+            // context(justinvdm, 20 Jan 2025): Initialize SSR dependency optimizer before
+            // Cloudflare plugin triggers SSR code evaluation. This ensures 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();
+            }
+            // context(justinvdm, 20 Jan 2025): Initialize CSS plugin's shared moduleCache
+            // before CSS modules are processed. The Cloudflare plugin's export detection
+            // can trigger CSS module processing in the SSR environment during `configureServer`,
+            // which happens before `initServer` runs. Vite's CSS plugin uses a shared
+            // `moduleCache` that is initialized in the client environment's `buildStart` hook.
+            // By calling `buildStart` here (which is idempotent), we ensure the CSS plugin's
+            // cache is initialized before CSS modules are processed, preventing "Cannot read
+            // properties of undefined (reading 'set')" errors.
+            await server.environments.client.pluginContainer.buildStart();
+        },
+    };
+};

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

@@ -37,7 +37,15 @@ 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) {
+            // 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/hmrStabilityPlugin.mjs

@@ -41,7 +41,12 @@ export function hmrStabilityPlugin() {
             return null;
         },
         configureServer(server) {
-            // Return a function to ensure our middleware is placed after internal middlewares
+            // 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 &&

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

@@ -95,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;
                         }
@@ -118,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);
@@ -162,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/miniflareHMRPlugin.mjs

@@ -37,6 +37,11 @@ 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) {

package/dist/vite/redwoodPlugin.mjs

@@ -10,6 +10,7 @@ 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 { configPlugin } from "./configPlugin.mjs";
 import { devServerTimingPlugin } from "./devServerTimingPlugin.mjs";
 import { directiveModulesDevPlugin } from "./directiveModulesDevPlugin.mjs";
@@ -106,6 +107,7 @@ export const redwoodPlugin = async (options = {}) => {
             projectRootDir,
         }),
         knownDepsResolverPlugin({ projectRootDir }),
+        cloudflarePreInitPlugin(),
         tsconfigPaths({ root: projectRootDir }),
         shouldIncludeCloudflarePlugin
             ? cloudflare({

package/dist/vite/runDirectivesScan.mjs

@@ -87,8 +87,6 @@ export function classifyModule({ contents, inheritedEnv, }) {
 }
 export const runDirectivesScan = async ({ rootConfig, environments, clientFiles, serverFiles, entries: initialEntries, }) => {
     deferredLog("\n… (rwsdk) Scanning for 'use client' and 'use server' directives...");
-    // 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();
@@ -197,6 +195,19 @@ export const runDirectivesScan = async ({ rootConfig, environments, clientFiles,
                     log("Resolution result:", resolved);
                     const resolvedPath = resolved?.id;
                     if (resolvedPath && path.isAbsolute(resolvedPath)) {
+                        try {
+                            const stats = await fsp.stat(resolvedPath);
+                            if (stats.isDirectory()) {
+                                log("Resolved path is a directory, marking as external to avoid scan error:", resolvedPath);
+                                return { external: true };
+                            }
+                        }
+                        catch (e) {
+                            // This can happen for virtual modules or special paths that don't
+                            // exist on the filesystem. We can safely externalize them.
+                            log("Could not stat resolved path, marking as external:", resolvedPath);
+                            return { external: true };
+                        }
                         // Normalize the path for esbuild compatibility
                         const normalizedPath = normalizeModulePath(resolvedPath, rootConfig.root, { absolute: true });
                         log("Normalized path:", normalizedPath);
@@ -290,8 +301,6 @@ export const runDirectivesScan = async ({ rootConfig, environments, clientFiles,
         throw new Error(`RWSDK directive scan failed:\n${e.stack}`);
     }
     finally {
-        // Always clear the scanning flag when done
-        delete process.env.RWSDK_DIRECTIVE_SCAN_ACTIVE;
         deferredLog("✔ (rwsdk) Done scanning for 'use client' and 'use server' directives.");
         process.env.VERBOSE &&
             log("Client/server files after scanning: client=%O, server=%O", Array.from(clientFiles), Array.from(serverFiles));

package/dist/vite/ssrBridgePlugin.mjs

@@ -12,6 +12,10 @@ export const ssrBridgePlugin = ({ clientFiles, serverFiles, }) => {
         name: "rwsdk:ssr-bridge",
         enforce: "pre",
         configureServer(server) {
+            // context(justinvdm, 19 Nov 2025): This plugin patches the dev server's
+            // HMR and optimizer behavior to coordinate the `ssr` and `worker`
+            // environments. It runs with `enforce: 'pre'` to ensure these patches
+            // are in place before other plugins start interacting with the server.
             devServer = server;
             const ssrHot = server.environments.ssr.hot;
             const originalSsrHotSend = ssrHot.send;
@@ -54,12 +58,14 @@ export const ssrBridgePlugin = ({ clientFiles, serverFiles, }) => {
                 config.optimizeDeps.esbuildOptions.plugins.push({
                     name: "rwsdk-ssr-external",
                     setup(build) {
+                        console.log("[TIMING] rwsdk-ssr-external.setup: START - Plugin setup function called");
                         log("Setting up esbuild plugin to mark rwsdk/__ssr paths as external for worker");
                         build.onResolve({ filter: /.*$/ }, (args) => {
                             process.env.VERBOSE &&
                                 log("Esbuild onResolve called for path=%s, args=%O", args.path, args);
                             if (args.path === "rwsdk/__ssr_bridge" ||
                                 args.path.startsWith(VIRTUAL_SSR_PREFIX)) {
+                                console.log(`[TIMING] rwsdk-ssr-external.onResolve: Intercepted ${args.path}`);
                                 log("Marking as external: %s", args.path);
                                 return {
                                     path: args.path,
@@ -67,14 +73,19 @@ export const ssrBridgePlugin = ({ clientFiles, serverFiles, }) => {
                                 };
                             }
                         });
+                        console.log("[TIMING] rwsdk-ssr-external.setup: COMPLETE - onResolve hook registered");
                     },
                 });
                 log("Worker environment esbuild configuration complete");
             }
         },
-        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). This prevents race conditions where external
+            // calls happen during directive scanning.
+            if (options?.custom?.rwsdk?.directiveScan === true) {
                 return;
             }
             // context(justinvdm, 19 Nov 2025):
@@ -133,10 +144,6 @@ export const ssrBridgePlugin = ({ clientFiles, serverFiles, }) => {
             }
         },
         async load(id) {
-            // Skip during directive scanning to avoid performance issues
-            if (process.env.RWSDK_DIRECTIVE_SCAN_ACTIVE) {
-                return;
-            }
             if (id.startsWith(VIRTUAL_SSR_PREFIX) &&
                 this.environment.name === "worker") {
                 const realId = id.slice(VIRTUAL_SSR_PREFIX.length);

package/dist/vite/staleDepRetryPlugin.mjs

@@ -43,7 +43,12 @@ export function staleDepRetryPlugin() {
             return null;
         },
         configureServer(server) {
-            // Return a function to ensure our middleware is placed after internal middlewares
+            // 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 &&

package/dist/vite/transformJsxScriptTagsPlugin.mjs

@@ -319,10 +319,6 @@ export const transformJsxScriptTagsPlugin = ({ clientEntryPoints, projectRootDir
             isBuild = config.command === "build";
         },
         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/virtualPlugin.mjs

@@ -3,9 +3,12 @@ export const virtualPlugin = (name, load) => {
     name = "virtual:" + name;
     return {
         name: `rwsdk:virtual-${name}`,
-        resolveId(source, _importer, _options) {
-            // 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 === name || source.startsWith(`${name}?`)) {
@@ -14,10 +17,6 @@ export const virtualPlugin = (name, load) => {
             return;
         },
         load(id, options) {
-            // Skip during directive scanning to avoid performance issues
-            if (process.env.RWSDK_DIRECTIVE_SCAN_ACTIVE) {
-                return;
-            }
             if (id === `\0${name}` || id.startsWith(`\0${name}?`)) {
                 return load.apply(this, [id, options]);
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rwsdk",
-  "version": "1.0.0-beta.30",
+  "version": "1.0.0-beta.30-test.20251120210809",
   "description": "Build fast, server-driven webapps on Cloudflare with SSR, RSC, and realtime",
   "type": "module",
   "bin": {