rwsdk 1.0.0-beta.14 → 1.0.0-beta.16

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.14",
+  "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",