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

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/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,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

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/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,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/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/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;

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/package.json

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