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

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";
@@ -18,12 +19,13 @@ import { directivesPlugin } from "./directivesPlugin.mjs";
 import { injectVitePreamble } from "./injectVitePreamblePlugin.mjs";
 import { knownDepsResolverPlugin } from "./knownDepsResolverPlugin.mjs";
 import { linkerPlugin } from "./linkerPlugin.mjs";
-import { manifestPlugin } from "./manifestPlugin.mjs";
 import { miniflareHMRPlugin } from "./miniflareHMRPlugin.mjs";
 import { moveStaticAssetsPlugin } from "./moveStaticAssetsPlugin.mjs";
 import { prismaPlugin } from "./prismaPlugin.mjs";
 import { resolveForcedPaths } from "./resolveForcedPaths.mjs";
 import { ssrBridgePlugin } from "./ssrBridgePlugin.mjs";
+import { staleDepRetryPlugin } from "./staleDepRetryPlugin.mjs";
+import { statePlugin } from "./statePlugin.mjs";
 import { transformJsxScriptTagsPlugin } from "./transformJsxScriptTagsPlugin.mjs";
 import { useClientLookupPlugin } from "./useClientLookupPlugin.mjs";
 import { useServerLookupPlugin } from "./useServerLookupPlugin.mjs";
@@ -74,17 +76,15 @@ export const redwoodPlugin = async (options = {}) => {
     // context(justinvdm, 31 Mar 2025): We assume that if there is no .wrangler directory,
     // then this is fresh install, and we run `npm run dev:init` here.
     if (process.env.RWSDK_WORKER_RUN !== "1" &&
-        process.env.RWSDK_DEPLOY !== "1" &&
+        process.env.NODE_ENV !== "production" &&
         !(await pathExists(resolve(projectRootDir, ".wrangler"))) &&
         (await hasPkgScript(projectRootDir, "dev:init"))) {
         console.log("🚀 Project has no .wrangler directory yet, assuming fresh install: running `npm run dev:init`...");
-        await $({
-            // context(justinvdm, 01 Apr 2025): We want to avoid interactive migration y/n prompt, so we ignore stdin
-            // as a signal to operate in no-tty mode
-            stdio: ["ignore", "inherit", "inherit"],
-        }) `npm run dev:init`;
+        await $ `npm run dev:init`;
     }
     return [
+        staleDepRetryPlugin(),
+        statePlugin({ projectRootDir }),
         devServerTimingPlugin(),
         devServerConstantPlugin(),
         directiveModulesDevPlugin({
@@ -107,6 +107,7 @@ export const redwoodPlugin = async (options = {}) => {
             projectRootDir,
         }),
         knownDepsResolverPlugin({ projectRootDir }),
+        cloudflarePreInitPlugin(),
         tsconfigPaths({ root: projectRootDir }),
         shouldIncludeCloudflarePlugin
             ? cloudflare({
@@ -144,9 +145,6 @@ export const redwoodPlugin = async (options = {}) => {
             clientEntryPoints,
             projectRootDir,
         }),
-        manifestPlugin({
-            projectRootDir,
-        }),
         moveStaticAssetsPlugin({ rootDir: projectRootDir }),
         prismaPlugin({ projectRootDir }),
         linkerPlugin({ projectRootDir }),

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) => {
@@ -53,9 +87,17 @@ 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();
+        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 +120,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) {
@@ -153,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);
@@ -166,11 +221,11 @@ export const runDirectivesScan = async ({ rootConfig, environments, clientFiles,
                 });
                 build.onLoad({ filter: /\.(m|c)?[jt]sx?$|\.mdx$/ }, async (args) => {
                     log("onLoad called for:", args.path);
-                    if (!args.path.startsWith("/") ||
+                    if (!path.isAbsolute(args.path) ||
                         args.path.includes("virtual:") ||
                         isExternalUrl(args.path)) {
                         log("Skipping file due to filter:", args.path, {
-                            startsWithSlash: args.path.startsWith("/"),
+                            isAbsolute: path.isAbsolute(args.path),
                             hasVirtual: args.path.includes("virtual:"),
                             isExternal: isExternalUrl(args.path),
                         });
@@ -232,7 +287,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"),
@@ -246,15 +301,14 @@ 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));
     }
 };
 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

@@ -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,36 @@ export const ssrBridgePlugin = ({ clientFiles, serverFiles, }) => {
     const ssrBridgePlugin = {
         name: "rwsdk:ssr-bridge",
         enforce: "pre",
-        async configureServer(server) {
+        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;
+            // 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 +76,24 @@ export const ssrBridgePlugin = ({ clientFiles, serverFiles, }) => {
                 log("Worker environment esbuild configuration complete");
             }
         },
-        async resolveId(id) {
-            // 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):
+            // 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
@@ -100,53 +141,104 @@ 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);
-                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,74 @@
+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) {
+            // context(justinvdm, 19 Nov 2025): This hook adds an error handling
+            // middleware for stale dependency errors. It runs in a returned function,
+            // which intentionally places it late in the middleware stack. Unlike
+            // other plugins that must run before the Cloudflare plugin to prevent
+            // startup deadlocks, its timing is not critical, so `enforce: 'pre'`
+            // is not needed.
+            return () => {
+                server.middlewares.use(async function rwsdkStaleBundleErrorHandler(err, req, res, next) {
+                    if (err &&
+                        typeof err.message === "string" &&
+                        err.message.includes("new version of the pre-bundle")) {
+                        log("Caught stale pre-bundle error. Waiting for server to stabilize...");
+                        startWaitingForStability();
+                        await stabilityPromise;
+                        log("Server stabilized. Sending full-reload and redirecting.");
+                        // Signal the client to do a full page reload.
+                        server.environments.client.hot.send({
+                            type: "full-reload",
+                        });
+                        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;