rwsdk 1.0.0-beta.15 → 1.0.0-beta.16

package/dist/lib/constants.d.mts

@@ -7,5 +7,6 @@ export declare const VENDOR_CLIENT_BARREL_PATH: string;
 export declare const VENDOR_SERVER_BARREL_PATH: string;
 export declare const VENDOR_CLIENT_BARREL_EXPORT_PATH = "rwsdk/__vendor_client_barrel";
 export declare const VENDOR_SERVER_BARREL_EXPORT_PATH = "rwsdk/__vendor_server_barrel";
+export declare const RW_STATE_EXPORT_PATH = "rwsdk/__state";
 export declare const INTERMEDIATE_SSR_BRIDGE_PATH: string;
 export declare const CLIENT_MANIFEST_RELATIVE_PATH: string;

package/dist/lib/constants.mjs

@@ -9,5 +9,6 @@ export const VENDOR_CLIENT_BARREL_PATH = path.resolve(INTERMEDIATES_OUTPUT_DIR,
 export const VENDOR_SERVER_BARREL_PATH = path.resolve(INTERMEDIATES_OUTPUT_DIR, "rwsdk-vendor-server-barrel.js");
 export const VENDOR_CLIENT_BARREL_EXPORT_PATH = "rwsdk/__vendor_client_barrel";
 export const VENDOR_SERVER_BARREL_EXPORT_PATH = "rwsdk/__vendor_server_barrel";
+export const RW_STATE_EXPORT_PATH = "rwsdk/__state";
 export const INTERMEDIATE_SSR_BRIDGE_PATH = resolve(INTERMEDIATES_OUTPUT_DIR, "ssr", "ssr_bridge.js");
 export const CLIENT_MANIFEST_RELATIVE_PATH = resolve("dist", "client", ".vite", "manifest.json");

package/dist/lib/e2e/constants.d.mts

@@ -1,4 +1,5 @@
-export declare const IS_DEBUG_MODE: string | boolean;
+export declare const IS_CI: boolean;
+export declare const IS_DEBUG_MODE: boolean;
 export declare const SETUP_PLAYGROUND_ENV_TIMEOUT: number;
 export declare const DEPLOYMENT_TIMEOUT: number;
 export declare const DEPLOYMENT_MIN_TRIES: number;

package/dist/lib/e2e/constants.mjs

@@ -1,6 +1,13 @@
+export const IS_CI = !!((process.env.CI && !process.env.NOT_CI) ||
+    process.env.GITHUB_ACTIONS ||
+    process.env.GITLAB_CI ||
+    process.env.CIRCLECI ||
+    process.env.TRAVIS ||
+    process.env.JENKINS_URL ||
+    process.env.NETLIFY);
 export const IS_DEBUG_MODE = process.env.RWSDK_E2E_DEBUG
-    ? process.env.RWSDK_E2E_DEBUG
-    : !process.env.CI;
+    ? process.env.RWSDK_E2E_DEBUG === "true"
+    : !IS_CI;
 export const SETUP_PLAYGROUND_ENV_TIMEOUT = process.env
     .RWSDK_SETUP_PLAYGROUND_ENV_TIMEOUT
     ? parseInt(process.env.RWSDK_SETUP_PLAYGROUND_ENV_TIMEOUT, 10)

package/dist/lib/e2e/dev.mjs

@@ -109,7 +109,6 @@ export async function runDevServer(packageManager = "pnpm", cwd) {
         // Listen for all output to get the URL
         const handleOutput = (data, source) => {
             const output = data.toString();
-            console.log(output);
             allOutput += output; // Accumulate all output
             log("Received output from %s: %s", source, output.replace(/\n/g, "\\n"));
             if (!url) {

package/dist/lib/e2e/environment.mjs

@@ -1,3 +1,4 @@
+import { createHash } from "crypto";
 import debug from "debug";
 import { copy, pathExists } from "fs-extra";
 import ignore from "ignore";
@@ -8,12 +9,25 @@ import { basename, join, relative, resolve } from "path";
 import tmp from "tmp-promise";
 import { $ } from "../../lib/$.mjs";
 import { ROOT_DIR } from "../constants.mjs";
-import { INSTALL_DEPENDENCIES_RETRIES } from "./constants.mjs";
+import { INSTALL_DEPENDENCIES_RETRIES, IS_CI } from "./constants.mjs";
 import { retry } from "./retry.mjs";
 const log = debug("rwsdk:e2e:environment");
+const IS_CACHE_ENABLED = process.env.RWSDK_E2E_CACHE
+    ? process.env.RWSDK_E2E_CACHE === "1"
+    : !IS_CI;
+if (IS_CACHE_ENABLED) {
+    log("E2E test caching is enabled.");
+}
 const getTempDir = async () => {
     return tmp.dir({ unsafeCleanup: true });
 };
+function slugify(str) {
+    return str
+        .toLowerCase()
+        .replace(/[^a-z0-9-]/g, "-")
+        .replace(/--+/g, "-")
+        .replace(/^-|-$/g, "");
+}
 const createSdkTarball = async () => {
     const existingTarballPath = process.env.RWSKD_SMOKE_TEST_TARBALL_PATH;
     if (existingTarballPath) {
@@ -28,15 +42,27 @@ const createSdkTarball = async () => {
             }, // No-op cleanup
         };
     }
-    const packResult = await $({ cwd: ROOT_DIR, stdio: "pipe" }) `npm pack`;
-    const tarballName = packResult.stdout?.trim();
-    const tarballPath = path.join(ROOT_DIR, tarballName);
-    log(`📦 Created tarball: ${tarballPath}`);
+    // Create a temporary directory to receive the tarball, ensuring a stable path.
+    const tempDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), "rwsdk-tarball-"));
+    await $({
+        cwd: ROOT_DIR,
+        stdio: "pipe",
+    }) `npm pack --pack-destination=${tempDir}`;
+    // We need to determine the tarball's name, as it's version-dependent.
+    // Running `npm pack --dry-run` gives us the filename without creating a file.
+    const packDryRun = await $({
+        cwd: ROOT_DIR,
+        stdio: "pipe",
+    }) `npm pack --dry-run`;
+    const tarballName = packDryRun.stdout?.trim();
+    const tarballPath = path.join(tempDir, tarballName);
+    if (!fs.existsSync(tarballPath)) {
+        throw new Error(`Tarball was not created in the expected location: ${tarballPath}`);
+    }
+    log(`📦 Created tarball in stable temp location: ${tarballPath}`);
     const cleanupTarball = async () => {
-        if (fs.existsSync(tarballPath)) {
-            log(`🧹 Cleaning up tarball: ${tarballPath}`);
-            await fs.promises.rm(tarballPath, { force: true });
-        }
+        log(`🧹 Cleaning up tarball directory: ${tempDir}`);
+        await fs.promises.rm(tempDir, { recursive: true, force: true });
     };
     return { tarballPath, cleanupTarball };
 };
@@ -59,7 +85,7 @@ export async function copyProjectToTempDir(projectDir, resourceUniqueKey, packag
         const sourceDir = monorepoRoot || projectDir;
         // Create unique project directory name
         const originalDirName = basename(sourceDir);
-        const workerName = `${originalDirName}-test-${resourceUniqueKey}`;
+        const workerName = `${slugify(originalDirName)}-test-${resourceUniqueKey}`;
         const tempCopyRoot = resolve(tempDir.path, workerName);
         // If it's a monorepo, the targetDir for commands is a subdirectory
         const targetDir = monorepoRoot
@@ -115,7 +141,9 @@ export async function copyProjectToTempDir(projectDir, resourceUniqueKey, packag
                 const workspaces = rwsdkWs.workspaces;
                 if (packageManager === "pnpm") {
                     const pnpmWsPath = join(tempCopyRoot, "pnpm-workspace.yaml");
-                    const pnpmWsConfig = `packages:\n${workspaces.map((w) => `  - '${w}'`).join("\n")}\n`;
+                    const pnpmWsConfig = `packages:\n${workspaces
+                        .map((w) => `  - '${w}'`)
+                        .join("\n")}\n`;
                     await fs.promises.writeFile(pnpmWsPath, pnpmWsConfig);
                     log("Created pnpm-workspace.yaml");
                 }
@@ -157,7 +185,7 @@ export async function copyProjectToTempDir(projectDir, resourceUniqueKey, packag
         await setTarballDependency(targetDir, tarballFilename);
         // Install dependencies in the target directory
         const installDir = monorepoRoot ? tempCopyRoot : targetDir;
-        await retry(() => installDependencies(installDir, packageManager), {
+        await retry(() => installDependencies(installDir, packageManager, projectDir, monorepoRoot), {
             retries: INSTALL_DEPENDENCIES_RETRIES,
             delay: 1000,
         });
@@ -168,7 +196,42 @@ export async function copyProjectToTempDir(projectDir, resourceUniqueKey, packag
         await cleanupTarball();
     }
 }
-async function installDependencies(targetDir, packageManager = "pnpm") {
+async function installDependencies(targetDir, packageManager = "pnpm", projectDir, monorepoRoot) {
+    if (IS_CACHE_ENABLED) {
+        // Generate a checksum of the SDK's dist directory to factor into the cache key
+        const { stdout: sdkDistChecksum } = await $("find . -type f | sort | md5sum", {
+            shell: true,
+            cwd: path.join(ROOT_DIR, "dist"),
+        });
+        const projectIdentifier = monorepoRoot
+            ? `${monorepoRoot}-${projectDir}`
+            : projectDir;
+        const projectHash = createHash("md5")
+            .update(`${projectIdentifier}-${sdkDistChecksum}`)
+            .digest("hex")
+            .substring(0, 8);
+        const cacheDirName = monorepoRoot
+            ? basename(monorepoRoot)
+            : basename(projectDir);
+        const cacheRoot = path.join(os.tmpdir(), "rwsdk-e2e-cache", `${cacheDirName}-${projectHash}`);
+        const nodeModulesCachePath = path.join(cacheRoot, "node_modules");
+        if (await pathExists(nodeModulesCachePath)) {
+            console.log(`✅ CACHE HIT for source "${projectIdentifier}": Found cached node_modules. Hard-linking from ${nodeModulesCachePath}`);
+            try {
+                // Use cp -al for a fast, hardlink-based copy
+                await $("cp", ["-al", nodeModulesCachePath, join(targetDir, "node_modules")], { stdio: "pipe" });
+                console.log(`✅ Hardlink copy created successfully.`);
+            }
+            catch (e) {
+                console.warn(`⚠️ Hardlink copy failed, falling back to full copy. Error: ${e.message}`);
+                // Fallback to a regular copy if hardlinking fails (e.g., cross-device)
+                await copy(nodeModulesCachePath, join(targetDir, "node_modules"));
+                console.log(`✅ Full copy created successfully.`);
+            }
+            return;
+        }
+        console.log(`ℹ️ CACHE MISS for source "${projectIdentifier}": No cached node_modules found at ${nodeModulesCachePath}. Proceeding with installation.`);
+    }
     console.log(`📦 Installing project dependencies in ${targetDir} using ${packageManager}...`);
     try {
         // Clean up any pre-existing node_modules and lockfiles
@@ -220,6 +283,33 @@ async function installDependencies(targetDir, packageManager = "pnpm") {
             },
         });
         console.log("✅ Dependencies installed successfully");
+        // After successful install, populate the cache if enabled
+        if (IS_CACHE_ENABLED) {
+            // Re-calculate cache path to be safe
+            const { stdout: sdkDistChecksum } = await $("find . -type f | sort | md5sum", {
+                shell: true,
+                cwd: path.join(ROOT_DIR, "dist"),
+            });
+            const projectIdentifier = monorepoRoot
+                ? `${monorepoRoot}-${projectDir}`
+                : projectDir;
+            const projectHash = createHash("md5")
+                .update(`${projectIdentifier}-${sdkDistChecksum}`)
+                .digest("hex")
+                .substring(0, 8);
+            const cacheDirName = monorepoRoot
+                ? basename(monorepoRoot)
+                : basename(projectDir);
+            const cacheRoot = path.join(os.tmpdir(), "rwsdk-e2e-cache", `${cacheDirName}-${projectHash}`);
+            const nodeModulesCachePath = path.join(cacheRoot, "node_modules");
+            console.log(`Caching node_modules to ${nodeModulesCachePath} for future runs...`);
+            // Ensure parent directory exists
+            await fs.promises.mkdir(path.dirname(nodeModulesCachePath), {
+                recursive: true,
+            });
+            await copy(join(targetDir, "node_modules"), nodeModulesCachePath);
+            console.log(`✅ node_modules cached successfully.`);
+        }
         // Log installation details at debug level
         if (result.stdout) {
             log(`${packageManager} install output: %s`, result.stdout);

package/dist/lib/e2e/poll.d.mts

@@ -4,5 +4,5 @@ export interface PollOptions {
     minTries: number;
     onRetry?: (error: unknown, tries: number) => void;
 }
-export declare function poll(fn: () => Promise<boolean>, options?: Partial<PollOptions>): Promise<void>;
+export declare function poll(fn: () => boolean | Promise<boolean>, options?: Partial<PollOptions>): Promise<void>;
 export declare function pollValue<T>(fn: () => Promise<T>, options?: Partial<PollOptions>): Promise<T>;

package/dist/lib/e2e/testHarness.d.mts

@@ -37,6 +37,11 @@ export interface SetupPlaygroundEnvironmentOptions {
      * @default true
      */
     deploy?: boolean;
+    /**
+     * Whether to automatically start the dev server.
+     * @default true
+     */
+    autoStartDevServer?: boolean;
 }
 /**
  * A Vitest hook that sets up a playground environment for a test file.
@@ -77,8 +82,6 @@ export declare function createDeployment(): {
  */
 export declare function runTestWithRetries(name: string, attemptFn: () => Promise<void>): Promise<void>;
 type SDKRunner = (name: string, testLogic: (context: {
-    createDevServer: () => Promise<DevServerInstance>;
-    createDeployment: () => Promise<DeploymentInstance>;
     browser: Browser;
     page: Page;
     projectDir: string;

package/dist/lib/e2e/testHarness.mjs

@@ -85,7 +85,9 @@ function getPlaygroundDirFromImportMeta(importMetaUrl) {
  * This ensures that tests run in a clean, isolated environment.
  */
 export function setupPlaygroundEnvironment(options) {
-    const { sourceProjectDir, monorepoRoot, dev = true, deploy = true, } = typeof options === "string" ? { sourceProjectDir: options } : options;
+    const { sourceProjectDir, monorepoRoot, dev = true, deploy = true, autoStartDevServer = true, } = typeof options === "string"
+        ? { sourceProjectDir: options, autoStartDevServer: true }
+        : options;
     ensureHooksRegistered();
     beforeAll(async () => {
         let projectDir;
@@ -111,14 +113,16 @@ export function setupPlaygroundEnvironment(options) {
                 projectDir: devEnv.targetDir,
                 cleanup: devEnv.cleanup,
             };
-            const devControl = createDevServer();
-            globalDevInstancePromise = devControl.start().then((instance) => {
-                globalDevInstance = instance;
-                return instance;
-            });
-            // Prevent unhandled promise rejections. The error will be handled inside
-            // the test's beforeEach hook where this promise is awaited.
-            globalDevInstancePromise.catch(() => { });
+            if (autoStartDevServer) {
+                const devControl = createDevServer();
+                globalDevInstancePromise = devControl.start().then((instance) => {
+                    globalDevInstance = instance;
+                    return instance;
+                });
+                // Prevent unhandled promise rejections. The error will be handled inside
+                // the test's beforeEach hook where this promise is awaited.
+                globalDevInstancePromise.catch(() => { });
+            }
         }
         else {
             globalDevPlaygroundEnv = null;

package/dist/runtime/requestInfo/worker.js

@@ -1,6 +1,7 @@
 import { AsyncLocalStorage } from "async_hooks";
-const requestInfoDeferred = Promise.withResolvers();
-const requestInfoStore = new AsyncLocalStorage();
+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"];
 REQUEST_INFO_KEYS.forEach((key) => {

package/dist/runtime/state.d.ts

@@ -0,0 +1,3 @@
+export declare function defineRwState<T>(key: string, initializer: () => T): T;
+export declare function getRwState<T>(key: string): T | undefined;
+export declare function setRwState<T>(key: string, value: T): void;

package/dist/runtime/state.js

@@ -0,0 +1,13 @@
+const state = {};
+export function defineRwState(key, initializer) {
+    if (!(key in state)) {
+        state[key] = initializer();
+    }
+    return state[key];
+}
+export function getRwState(key) {
+    return state[key];
+}
+export function setRwState(key, value) {
+    state[key] = value;
+}

package/dist/scripts/debug-sync.mjs

@@ -99,28 +99,20 @@ const findUp = async (names, startDir) => {
     return undefined;
 };
 const getMonorepoRoot = async (startDir) => {
-    try {
-        // `pnpm root` is the most reliable way to find the workspace root node_modules
-        const { stdout } = await $({
-            cwd: startDir,
-        }) `pnpm root`;
-        // pnpm root returns the node_modules path, so we go up one level
-        return path.resolve(stdout, "..");
-    }
-    catch (e) {
-        console.warn(`Could not determine pnpm root from ${startDir}. Falling back to file search.`);
-        const root = await findUp(["pnpm-workspace.yaml"], startDir);
-        if (root) {
-            return root;
-        }
-    }
-    console.warn("Could not find pnpm monorepo root. Using parent directory of target as fallback.");
-    return path.resolve(startDir, "..");
+    return await findUp(["pnpm-workspace.yaml"], startDir);
 };
 const areDependenciesEqual = (deps1, deps2) => {
     // Simple string comparison for this use case is sufficient
     return JSON.stringify(deps1 ?? {}) === JSON.stringify(deps2 ?? {});
 };
+const isPlaygroundExample = async (targetDir, monorepoRoot) => {
+    const pkgJson = JSON.parse(await fs.readFile(path.join(monorepoRoot, "package.json"), "utf-8"));
+    if (pkgJson.name === "rw-sdk-monorepo") {
+        const playgroundDir = path.join(monorepoRoot, "playground");
+        return targetDir.startsWith(playgroundDir);
+    }
+    return false;
+};
 const performFullSync = async (sdkDir, targetDir, monorepoRoot) => {
     console.log("📦 Performing full sync with tarball...");
     let tarballPath = "";
@@ -178,8 +170,14 @@ const performSync = async (sdkDir, targetDir) => {
     // Clean up vite cache in the target project
     await cleanupViteEntries(targetDir);
     const monorepoRoot = await getMonorepoRoot(targetDir);
+    const rootDir = monorepoRoot ?? targetDir;
     const projectName = path.basename(targetDir);
-    const installedSdkPackageJsonPath = path.join(monorepoRoot, "node_modules", `.rwsync_${projectName}`, "node_modules", "rwsdk", "package.json");
+    if (monorepoRoot && (await isPlaygroundExample(targetDir, monorepoRoot))) {
+        console.log("Playground example detected. Skipping file sync; workspace linking will be used.");
+        console.log("✅ Done syncing");
+        return;
+    }
+    const installedSdkPackageJsonPath = path.join(rootDir, "node_modules", `.rwsync_${projectName}`, "node_modules", "rwsdk", "package.json");
     let needsFullSync = false;
     if (!existsSync(installedSdkPackageJsonPath)) {
         console.log("No previous sync found, performing full sync.");
@@ -195,10 +193,10 @@ const performSync = async (sdkDir, targetDir) => {
         }
     }
     if (needsFullSync) {
-        await performFullSync(sdkDir, targetDir, monorepoRoot);
+        await performFullSync(sdkDir, targetDir, rootDir);
     }
     else {
-        await performFastSync(sdkDir, targetDir, monorepoRoot);
+        await performFastSync(sdkDir, targetDir, rootDir);
     }
     console.log("✅ Done syncing");
 };

package/dist/vite/envResolvers.d.mts

@@ -0,0 +1,11 @@
+import enhancedResolve from "enhanced-resolve";
+export declare const ENV_RESOLVERS: {
+    ssr: enhancedResolve.ResolveFunction;
+    worker: enhancedResolve.ResolveFunction;
+    client: enhancedResolve.ResolveFunction;
+};
+export declare const maybeResolveEnvImport: ({ id, envName, projectRootDir, }: {
+    id: string;
+    envName: keyof typeof ENV_RESOLVERS;
+    projectRootDir: string;
+}) => string | undefined;

package/dist/vite/envResolvers.mjs

@@ -0,0 +1,20 @@
+import enhancedResolve from "enhanced-resolve";
+export const ENV_RESOLVERS = {
+    ssr: enhancedResolve.create.sync({
+        conditionNames: ["workerd", "worker", "edge", "default"],
+    }),
+    worker: enhancedResolve.create.sync({
+        conditionNames: ["react-server", "workerd", "worker", "edge", "default"],
+    }),
+    client: enhancedResolve.create.sync({
+        conditionNames: ["browser", "default"],
+    }),
+};
+export const maybeResolveEnvImport = ({ id, envName, projectRootDir, }) => {
+    try {
+        return ENV_RESOLVERS[envName](projectRootDir, id) || undefined;
+    }
+    catch (error) {
+        return undefined;
+    }
+};

package/dist/vite/hmrStabilityPlugin.d.mts

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

package/dist/vite/hmrStabilityPlugin.mjs

@@ -0,0 +1,68 @@
+import debug from "debug";
+const log = debug("rws-vite-plugin:hmr-stability");
+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 hmrStabilityPlugin() {
+    return {
+        name: "rws-vite-plugin:hmr-stability",
+        // Monitor server activity
+        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",
+                        });
+                        // No need to wait further here, the stability promise handled it.
+                        res.writeHead(307, { Location: req.url });
+                        res.end();
+                        return;
+                    }
+                    next(err);
+                });
+            };
+        },
+    };
+}

package/dist/vite/knownDepsResolverPlugin.d.mts

@@ -1,15 +1,9 @@
-import enhancedResolve from "enhanced-resolve";
 import { Plugin } from "vite";
 export declare const ENV_PREDEFINED_IMPORTS: {
     worker: string[];
     ssr: string[];
     client: string[];
 };
-export declare const ENV_RESOLVERS: {
-    ssr: enhancedResolve.ResolveFunction;
-    worker: enhancedResolve.ResolveFunction;
-    client: enhancedResolve.ResolveFunction;
-};
 export declare const knownDepsResolverPlugin: ({ projectRootDir, }: {
     projectRootDir: string;
 }) => Plugin[];

package/dist/vite/knownDepsResolverPlugin.mjs

@@ -1,7 +1,7 @@
 import debug from "debug";
-import enhancedResolve from "enhanced-resolve";
 import { ROOT_DIR } from "../lib/constants.mjs";
 import { ensureAliasArray } from "./ensureAliasArray.mjs";
+import { ENV_RESOLVERS } from "./envResolvers.mjs";
 const log = debug("rwsdk:vite:known-deps-resolver-plugin");
 const KNOWN_PREFIXES = [
     "react",
@@ -36,17 +36,6 @@ export const ENV_PREDEFINED_IMPORTS = {
         "react-server-dom-webpack/client.edge",
     ],
 };
-export const ENV_RESOLVERS = {
-    ssr: enhancedResolve.create.sync({
-        conditionNames: ["workerd", "worker", "edge", "default"],
-    }),
-    worker: enhancedResolve.create.sync({
-        conditionNames: ["react-server", "workerd", "worker", "edge", "default"],
-    }),
-    client: enhancedResolve.create.sync({
-        conditionNames: ["browser", "default"],
-    }),
-};
 function resolveKnownImport(id, envName, projectRootDir, isPrefixedImport = false) {
     if (!isPrefixedImport) {
         const isKnownImport = KNOWN_PREFIXES.some((prefix) => id === prefix || id.startsWith(`${prefix}/`));

package/dist/vite/redwoodPlugin.mjs

@@ -23,6 +23,8 @@ 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";
@@ -77,13 +79,13 @@ export const redwoodPlugin = async (options = {}) => {
         !(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`;
+        // @ts-ignore
+        $.verbose = true;
+        await $ `npm run dev:init`;
     }
     return [
+        staleDepRetryPlugin(),
+        statePlugin({ projectRootDir }),
         devServerTimingPlugin(),
         devServerConstantPlugin(),
         directiveModulesDevPlugin({

package/dist/vite/ssrBridgePlugin.mjs

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

package/dist/vite/staleDepRetryPlugin.d.mts

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

package/dist/vite/staleDepRetryPlugin.mjs

@@ -0,0 +1,69 @@
+import debug from "debug";
+const log = debug("rwsdk:vite:stale-dep-retry-plugin");
+let stabilityPromise = null;
+let stabilityResolver = null;
+let debounceTimer = null;
+const DEBOUNCE_MS = 500;
+function startWaitingForStability() {
+    if (!stabilityPromise) {
+        log("Starting to wait for server stability...");
+        stabilityPromise = new Promise((resolve) => {
+            stabilityResolver = resolve;
+        });
+        // Start the timer. If it fires, we're stable.
+        debounceTimer = setTimeout(finishWaiting, DEBOUNCE_MS);
+    }
+}
+function activityDetected() {
+    if (stabilityPromise) {
+        // If we're waiting for stability, reset the timer.
+        log("Activity detected, resetting stability timer.");
+        if (debounceTimer)
+            clearTimeout(debounceTimer);
+        debounceTimer = setTimeout(finishWaiting, DEBOUNCE_MS);
+    }
+}
+function finishWaiting() {
+    if (stabilityResolver) {
+        log("Server appears stable. Resolving promise.");
+        stabilityResolver();
+    }
+    stabilityPromise = null;
+    stabilityResolver = null;
+    debounceTimer = null;
+}
+export function staleDepRetryPlugin() {
+    return {
+        name: "rws-vite-plugin:stale-dep-retry",
+        apply: "serve",
+        // Monitor server activity by tapping into the transform hook. This is a
+        // reliable indicator that Vite is busy processing modules.
+        transform() {
+            activityDetected();
+            return null;
+        },
+        configureServer(server) {
+            // Return a function to ensure our middleware is placed after internal middlewares
+            return () => {
+                server.middlewares.use(async function rwsdkStaleBundleErrorHandler(err, req, res, next) {
+                    if (err &&
+                        typeof err.message === "string" &&
+                        err.message.includes("new version of the pre-bundle")) {
+                        log("Caught stale pre-bundle error. Waiting for server to stabilize...");
+                        startWaitingForStability();
+                        await stabilityPromise;
+                        log("Server stabilized. Sending full-reload and redirecting.");
+                        // Signal the client to do a full page reload.
+                        server.environments.client.hot.send({
+                            type: "full-reload",
+                        });
+                        res.writeHead(307, { Location: req.originalUrl || req.url });
+                        res.end();
+                        return;
+                    }
+                    next(err);
+                });
+            };
+        },
+    };
+}

package/dist/vite/statePlugin.d.mts

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

package/dist/vite/statePlugin.mjs

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rwsdk",
-  "version": "1.0.0-beta.15",
+  "version": "1.0.0-beta.16",
   "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",