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

package/dist/vite/ssrBridgePlugin.mjs

@@ -1,6 +1,7 @@
 import debug from "debug";
 import MagicString from "magic-string";
 import { INTERMEDIATE_SSR_BRIDGE_PATH } from "../lib/constants.mjs";
+import { externalModulesSet } from "./constants.mjs";
 import { findSsrImportCallSites } from "./findSsrSpecifiers.mjs";
 const log = debug("rwsdk:vite:ssr-bridge-plugin");
 export const VIRTUAL_SSR_PREFIX = "virtual:rwsdk:ssr:";
@@ -10,9 +11,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,11 +72,20 @@ 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;
             }
+            // context(justinvdm, 19 Nov 2025):
+            // Ensure platform-specific modules are always treated as external in the
+            // SSR environment. This is critical for builds, where we produce a
+            // standalone SSR bundle. Without this, Vite might try to bundle these
+            // virtual modules or fail to resolve them.
+            if (this.environment.name === "ssr" && externalModulesSet.has(id)) {
+                log("SSR environment: marking %s as external", id);
+                return { id, external: true };
+            }
             if (isDev) {
                 // context(justinvdm, 27 May 2025): In dev, we need to dynamically load
                 // SSR modules, so we return the virtual id so that the dynamic loading
@@ -107,46 +140,101 @@ 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;
+                                // If the import is for a known external module, we must leave it
+                                // as a bare specifier. Rewriting it with any prefix (`/@id/` or
+                                // our virtual one) will break Vite's default externalization.
+                                if (externalModulesSet.has(normalized)) {
+                                    const replacement = `import("${normalized}")`;
+                                    s.overwrite(site.start, site.end, replacement);
+                                    continue;
+                                }
+                                // 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/ssrBridgeWrapPlugin.d.mts

@@ -0,0 +1,2 @@
+import type { Plugin } from "vite";
+export declare const ssrBridgeWrapPlugin: () => Plugin;

package/dist/vite/ssrBridgeWrapPlugin.mjs

@@ -0,0 +1,85 @@
+import { Lang, parse as sgParse } from "@ast-grep/napi";
+import debug from "debug";
+import MagicString from "magic-string";
+const log = debug("rwsdk:vite:ssr-bridge-wrap");
+export const ssrBridgeWrapPlugin = () => {
+    return {
+        name: "rwsdk:ssr-bridge-wrap",
+        apply: "build",
+        renderChunk(code, chunk) {
+            try {
+                if (!chunk.fileName.endsWith("ssr_bridge.js")) {
+                    return null;
+                }
+                const s = new MagicString(code);
+                // Use AST parsing to find actual import statements (not in comments)
+                const root = sgParse(Lang.JavaScript, code);
+                // Find all import statements using AST patterns
+                const importPatterns = [
+                    'import { $$$ } from "$MODULE"',
+                    "import { $$$ } from '$MODULE'",
+                    'import $DEFAULT from "$MODULE"',
+                    "import $DEFAULT from '$MODULE'",
+                    'import * as $NS from "$MODULE"',
+                    "import * as $NS from '$MODULE'",
+                    'import "$MODULE"',
+                    "import '$MODULE'",
+                ];
+                let lastImportEnd = -1;
+                for (const pattern of importPatterns) {
+                    const matches = root.root().findAll(pattern);
+                    for (const match of matches) {
+                        const range = match.range();
+                        if (range.end.index > lastImportEnd) {
+                            lastImportEnd = range.end.index;
+                        }
+                    }
+                }
+                // Find the export statement using AST
+                const exportPatterns = [
+                    "export { $$$ }",
+                    'export { $$$ } from "$MODULE"',
+                    "export { $$$ } from '$MODULE'",
+                ];
+                let exportStart = -1;
+                let exportEnd = -1;
+                for (const pattern of exportPatterns) {
+                    const matches = root.root().findAll(pattern);
+                    for (const match of matches) {
+                        const range = match.range();
+                        // Check if this export contains our target symbols
+                        const text = match.text();
+                        if (text.includes("renderHtmlStream") &&
+                            text.includes("ssrLoadModule") &&
+                            text.includes("ssrWebpackRequire")) {
+                            exportStart = range.start.index;
+                            exportEnd = range.end.index;
+                            break;
+                        }
+                    }
+                    if (exportStart !== -1)
+                        break;
+                }
+                const banner = `export const { renderHtmlStream, ssrLoadModule, ssrWebpackRequire, ssrGetModuleExport, createThenableFromReadableStream } = (function() {`;
+                const footer = `return { renderHtmlStream, ssrLoadModule, ssrWebpackRequire, ssrGetModuleExport, createThenableFromReadableStream };\n})();`;
+                // Insert banner after the last import (or at the beginning if no imports)
+                const insertIndex = lastImportEnd === -1 ? 0 : lastImportEnd;
+                s.appendLeft(insertIndex, banner + "\n");
+                // Append footer at the end
+                s.append(footer);
+                // Remove the original export statement if found
+                if (exportStart !== -1 && exportEnd !== -1) {
+                    s.remove(exportStart, exportEnd);
+                }
+                return {
+                    code: s.toString(),
+                    map: s.generateMap(),
+                };
+            }
+            catch (e) {
+                console.error("Error in ssrBridgeWrapPlugin:", e);
+                throw e;
+            }
+        },
+    };
+};

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.3",
+  "version": "1.0.0-beta.30",
   "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",
@@ -54,7 +58,8 @@
     },
     "./router": {
       "types": "./dist/runtime/entries/router.d.ts",
-      "default": "./dist/runtime/entries/router.js"
+      "workerd": "./dist/runtime/entries/router.js",
+      "default": "./dist/runtime/entries/routerClient.js"
     },
     "./auth": {
       "types": "./dist/runtime/entries/auth.d.ts",
@@ -99,6 +104,14 @@
     "./realtime/durableObject": {
       "types": "./dist/runtime/lib/realtime/durableObject.d.ts",
       "default": "./dist/runtime/lib/realtime/durableObject.js"
+    },
+    "./use-synced-state/client": {
+      "types": "./dist/use-synced-state/client.d.ts",
+      "default": "./dist/use-synced-state/client.js"
+    },
+    "./use-synced-state/worker": {
+      "types": "./dist/use-synced-state/worker.d.ts",
+      "default": "./dist/use-synced-state/worker.js"
     }
   },
   "keywords": [
@@ -139,18 +152,22 @@
     "@puppeteer/browsers": "~2.10.0",
     "@types/decompress": "~4.2.7",
     "@types/fs-extra": "~11.0.4",
+    "@types/glob": "^8.1.0",
     "@types/react": "~19.1.2",
     "@types/react-dom": "~19.1.2",
     "@types/react-is": "~19.0.0",
     "@vitejs/plugin-react": "~5.0.0",
+    "capnweb": "~0.2.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",
-    "glob": "~11.0.1",
+    "get-port": "^7.1.0",
+    "glob": "~11.1.0",
     "ignore": "~7.0.4",
     "jsonc-parser": "~3.3.1",
     "kysely": "~0.28.2",
@@ -166,14 +183,13 @@
     "ts-morph": "~27.0.0",
     "unique-names-generator": "~4.7.1",
     "vibe-rules": "~0.3.0",
-    "vite-tsconfig-paths": "~5.1.4",
-    "decompress": "~4.2.1"
+    "vite-tsconfig-paths": "~5.1.4"
   },
   "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 +205,7 @@
     "semver": "~7.7.1",
     "tsx": "~4.20.0",
     "typescript": "~5.9.0",
-    "vite": "7.1.6",
+    "vite": "~7.2.0",
     "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,
-                        };
-                    });
-                },
-            });
-        },
-    };
-};