rwsdk 0.3.7 → 1.0.0-alpha.0

package/dist/lib/constants.d.mts

@@ -3,7 +3,9 @@ export declare const SRC_DIR: string;
 export declare const DIST_DIR: string;
 export declare const VITE_DIR: string;
 export declare const INTERMEDIATES_OUTPUT_DIR: string;
-export declare const CLIENT_BARREL_PATH: string;
-export declare const SERVER_BARREL_PATH: string;
+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 INTERMEDIATE_SSR_BRIDGE_PATH: string;
 export declare const CLIENT_MANIFEST_RELATIVE_PATH: string;

package/dist/lib/constants.mjs

@@ -1,11 +1,14 @@
 import { resolve } from "node:path";
+import path from "node:path";
 const __dirname = new URL(".", import.meta.url).pathname;
 export const ROOT_DIR = resolve(__dirname, "..", "..");
 export const SRC_DIR = resolve(ROOT_DIR, "src");
 export const DIST_DIR = resolve(ROOT_DIR, "dist");
 export const VITE_DIR = resolve(ROOT_DIR, "src", "vite");
 export const INTERMEDIATES_OUTPUT_DIR = resolve(DIST_DIR, "__intermediate_builds");
-export const CLIENT_BARREL_PATH = resolve(INTERMEDIATES_OUTPUT_DIR, "rwsdk-client-barrel.js");
-export const SERVER_BARREL_PATH = resolve(INTERMEDIATES_OUTPUT_DIR, "rwsdk-server-barrel.js");
+export const VENDOR_CLIENT_BARREL_PATH = path.resolve(INTERMEDIATES_OUTPUT_DIR, "rwsdk-vendor-client-barrel.js");
+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 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/smokeTests/development.mjs

@@ -82,14 +82,25 @@ export async function runDevServer(cwd) {
             env.NO_COLOR = "1";
             env.FORCE_COLOR = "0";
         }
+        // Map package manager names to actual commands
+        const getPackageManagerCommand = (pm) => {
+            switch (pm) {
+                case "yarn-classic":
+                    return "yarn";
+                default:
+                    return pm;
+            }
+        };
+        const pm = getPackageManagerCommand(state.options.packageManager || "npm");
         // Use the provided cwd if available
         devProcess = $({
-            stdio: ["inherit", "pipe", "pipe"], // Pipe stderr again to check both streams
-            detached: true,
+            all: true,
+            detached: false, // Keep attached so we can access streams
             cleanup: false, // Don't auto-kill on exit
             cwd: cwd || process.cwd(), // Use provided directory or current directory
             env, // Pass the updated environment variables
-        }) `npm run dev`;
+            stdio: 'pipe', // Ensure streams are piped
+        }) `${pm} run dev`;
         devProcess.catch((error) => {
             if (!isErrorExpected) {
                 // Use fail() directly here to properly handle errors from the dev process
@@ -99,44 +110,67 @@ export async function runDevServer(cwd) {
         log("Development server process spawned in directory: %s", cwd || process.cwd());
         // Store chunks to parse the URL
         let url = "";
-        // Listen for stdout to get the URL
-        devProcess.stdout?.on("data", (data) => {
+        let allOutput = "";
+        // Listen for all output to get the URL
+        const handleOutput = (data, source) => {
             const output = data.toString();
             console.log(output);
-            // Try to extract the URL from the server output with a more flexible regex
-            // Allow for variable amounts of whitespace between "Local:" and the URL
-            // And handle ANSI color codes by using a more robust pattern
-            const localMatch = output.match(/Local:.*?(http:\/\/localhost:\d+)/);
-            if (localMatch && localMatch[1] && !url) {
-                url = localMatch[1];
-                log("Found development server URL: %s", url);
-            }
-            else if (output.includes("Local:") &&
-                output.includes("http://localhost:")) {
-                // Log near-match for debugging
-                log("Found potential URL pattern but regex didn't match. Content: %s", output);
-                // Try an alternative, more general pattern that's more resilient to ANSI codes
-                const altMatch = output.match(/localhost:(\d+)/i);
-                if (altMatch && altMatch[1] && !url) {
-                    url = `http://localhost:${altMatch[1]}`;
-                    log("Found development server URL with alternative pattern: %s", url);
+            allOutput += output; // Accumulate all output
+            log("Received output from %s: %s", source, output.replace(/\n/g, "\\n"));
+            if (!url) {
+                // Multiple patterns to catch different package manager outputs
+                const patterns = [
+                    // Standard Vite output: "Local:   http://localhost:5173/"
+                    /Local:\s*(?:\u001b\[\d+m)?(https?:\/\/localhost:\d+)/i,
+                    // Alternative Vite output: "➜  Local:   http://localhost:5173/"
+                    /[➜→]\s*Local:\s*(?:\u001b\[\d+m)?(https?:\/\/localhost:\d+)/i,
+                    // Unicode-safe arrow pattern
+                    /[\u27A1\u2192\u279C]\s*Local:\s*(?:\u001b\[\d+m)?(https?:\/\/localhost:\d+)/i,
+                    // Direct URL pattern: "http://localhost:5173"
+                    /(https?:\/\/localhost:\d+)/i,
+                    // Port-only pattern: "localhost:5173"
+                    /localhost:(\d+)/i,
+                    // Server ready messages
+                    /server.*ready.*localhost:(\d+)/i,
+                    /dev server.*localhost:(\d+)/i,
+                ];
+                for (const pattern of patterns) {
+                    const match = output.match(pattern);
+                    log("Testing pattern %s against output: %s", pattern.source, output.replace(/\n/g, "\\n"));
+                    if (match) {
+                        log("Pattern matched: %s, groups: %o", pattern.source, match);
+                        if (match[1] && match[1].startsWith("http")) {
+                            url = match[1];
+                            log("Found development server URL with pattern %s: %s", pattern.source, url);
+                            break;
+                        }
+                        else if (match[1] && /^\d+$/.test(match[1])) {
+                            url = `http://localhost:${match[1]}`;
+                            log("Found development server URL with port pattern %s: %s", pattern.source, url);
+                            break;
+                        }
+                    }
+                }
+                // Log potential matches for debugging
+                if (!url &&
+                    (output.includes("localhost") ||
+                        output.includes("Local") ||
+                        output.includes("server"))) {
+                    log("Potential URL pattern found but not matched: %s", output.trim());
                 }
             }
-        });
-        // Also listen for stderr to check for URL patterns there as well
-        devProcess.stderr?.on("data", (data) => {
-            const output = data.toString();
-            console.error(output); // Output error messages to console
-            // Check if we already found a URL
-            if (url)
-                return;
-            // Check for localhost URLs in stderr using the same resilient patterns as stdout
-            const urlMatch = output.match(/localhost:(\d+)/i);
-            if (urlMatch && urlMatch[1]) {
-                url = `http://localhost:${urlMatch[1]}`;
-                log("Found development server URL in stderr: %s", url);
-            }
-        });
+        };
+        // Listen to all possible output streams
+        log("Setting up stream listeners. Available streams: all=%s, stdout=%s, stderr=%s", !!devProcess.all, !!devProcess.stdout, !!devProcess.stderr);
+        devProcess.all?.on("data", (data) => handleOutput(data, "all"));
+        devProcess.stdout?.on("data", (data) => handleOutput(data, "stdout"));
+        devProcess.stderr?.on("data", (data) => handleOutput(data, "stderr"));
+        // Also try listening to the raw process output
+        if (devProcess.child) {
+            log("Setting up child process stream listeners");
+            devProcess.child.stdout?.on("data", (data) => handleOutput(data, "child.stdout"));
+            devProcess.child.stderr?.on("data", (data) => handleOutput(data, "child.stderr"));
+        }
         // Wait for URL with timeout
         const waitForUrl = async () => {
             const start = Date.now();
@@ -145,14 +179,40 @@ export async function runDevServer(cwd) {
                 if (url) {
                     return url;
                 }
+                // Fallback: check accumulated output if stream listeners aren't working
+                if (!url && allOutput) {
+                    log("Checking accumulated output for URL patterns: %s", allOutput.replace(/\n/g, "\\n"));
+                    const patterns = [
+                        /Local:\s*(?:\u001b\[\d+m)?(https?:\/\/localhost:\d+)/i,
+                        /[➜→]\s*Local:\s*(?:\u001b\[\d+m)?(https?:\/\/localhost:\d+)/i,
+                        /[\u27A1\u2192\u279C]\s*Local:\s*(?:\u001b\[\d+m)?(https?:\/\/localhost:\d+)/i,
+                        /(https?:\/\/localhost:\d+)/i,
+                        /localhost:(\d+)/i,
+                    ];
+                    for (const pattern of patterns) {
+                        const match = allOutput.match(pattern);
+                        if (match) {
+                            if (match[1] && match[1].startsWith("http")) {
+                                url = match[1];
+                                log("Found URL in accumulated output with pattern %s: %s", pattern.source, url);
+                                return url;
+                            }
+                            else if (match[1] && /^\d+$/.test(match[1])) {
+                                url = `http://localhost:${match[1]}`;
+                                log("Found URL in accumulated output with port pattern %s: %s", pattern.source, url);
+                                return url;
+                            }
+                        }
+                    }
+                }
                 // Check if the process is still running
                 if (devProcess.exitCode !== null) {
-                    log("ERROR: Development server process exited with code %d", devProcess.exitCode);
+                    log("ERROR: Development server process exited with code %d. Final output: %s", devProcess.exitCode, allOutput);
                     throw new Error(`Development server process exited with code ${devProcess.exitCode}`);
                 }
                 await setTimeout(500); // Check every 500ms
             }
-            log("ERROR: Timed out waiting for dev server URL");
+            log("ERROR: Timed out waiting for dev server URL. Final accumulated output: %s", allOutput);
             throw new Error("Timed out waiting for dev server URL");
         };
         // Wait for the URL

package/dist/lib/smokeTests/environment.d.mts

@@ -1,5 +1,5 @@
 import tmp from "tmp-promise";
-import { SmokeTestOptions, TestResources } from "./types.mjs";
+import { SmokeTestOptions, TestResources, PackageManager } from "./types.mjs";
 /**
  * Sets up the test environment, preparing any resources needed for testing
  */
@@ -7,7 +7,7 @@ export declare function setupTestEnvironment(options?: SmokeTestOptions): Promis
 /**
  * Copy project to a temporary directory with a unique name
  */
-export declare function copyProjectToTempDir(projectDir: string, sync: boolean | undefined, resourceUniqueKey: string): Promise<{
+export declare function copyProjectToTempDir(projectDir: string, sync: boolean | undefined, resourceUniqueKey: string, packageManager?: PackageManager): Promise<{
     tempDir: tmp.DirectoryResult;
     targetDir: string;
     workerName: string;

package/dist/lib/smokeTests/environment.mjs

@@ -44,7 +44,8 @@ export async function setupTestEnvironment(options = {}) {
         if (options.projectDir) {
             log("Project directory specified: %s", options.projectDir);
             const { tempDir, targetDir, workerName } = await copyProjectToTempDir(options.projectDir, options.sync !== false, // default to true if undefined
-            resourceUniqueKey);
+            resourceUniqueKey, // Pass in the existing resourceUniqueKey
+            options.packageManager);
             // Store cleanup function
             resources.tempDirCleanup = tempDir.cleanup;
             resources.workerName = workerName;
@@ -69,7 +70,7 @@ export async function setupTestEnvironment(options = {}) {
 /**
  * Copy project to a temporary directory with a unique name
  */
-export async function copyProjectToTempDir(projectDir, sync = true, resourceUniqueKey) {
+export async function copyProjectToTempDir(projectDir, sync = true, resourceUniqueKey, packageManager) {
     log("Creating temporary directory for project");
     // Create a temporary directory
     const tempDir = await tmp.dir({ unsafeCleanup: true });
@@ -115,8 +116,14 @@ export async function copyProjectToTempDir(projectDir, sync = true, resourceUniq
         },
     });
     log("Project copy completed successfully");
+    // For yarn, create .yarnrc.yml to disable PnP and use node_modules
+    if (packageManager === "yarn" || packageManager === "yarn-classic") {
+        const yarnrcPath = join(targetDir, ".yarnrc.yml");
+        await fs.writeFile(yarnrcPath, "nodeLinker: node-modules\n");
+        log("Created .yarnrc.yml to disable PnP for yarn");
+    }
     // Install dependencies in the target directory
-    await installDependencies(targetDir);
+    await installDependencies(targetDir, packageManager);
     // Sync SDK to the temp dir if requested
     if (sync) {
         console.log(`🔄 Syncing SDK to ${targetDir} after installing dependencies...`);
@@ -127,24 +134,31 @@ export async function copyProjectToTempDir(projectDir, sync = true, resourceUniq
 /**
  * Install project dependencies using pnpm
  */
-async function installDependencies(targetDir) {
-    console.log(`📦 Installing project dependencies in ${targetDir}...`);
+async function installDependencies(targetDir, packageManager = "pnpm") {
+    console.log(`📦 Installing project dependencies in ${targetDir} using ${packageManager}...`);
     try {
-        // Run pnpm install in the target directory
-        log("Running pnpm install");
-        const result = await $({
+        const installCommand = {
+            pnpm: ["pnpm", "install"],
+            npm: ["npm", "install"],
+            yarn: ["yarn", "install", "--immutable"],
+            "yarn-classic": ["yarn", "install", "--immutable"],
+        }[packageManager];
+        // Run install command in the target directory
+        log(`Running ${installCommand.join(" ")}`);
+        const [command, ...args] = installCommand;
+        const result = await $(command, args, {
             cwd: targetDir,
             stdio: "pipe", // Capture output
-        }) `pnpm install`;
+        });
         console.log("✅ Dependencies installed successfully");
         // Log installation details at debug level
         if (result.stdout) {
-            log("pnpm install output: %s", result.stdout);
+            log(`${packageManager} install output: %s`, result.stdout);
         }
     }
     catch (error) {
         log("ERROR: Failed to install dependencies: %O", error);
         console.error(`❌ Failed to install dependencies: ${error instanceof Error ? error.message : String(error)}`);
-        throw new Error(`Failed to install project dependencies. Please ensure the project can be installed with pnpm.`);
+        throw new Error(`Failed to install project dependencies. Please ensure the project can be installed with ${packageManager}.`);
     }
 }

package/dist/lib/smokeTests/types.d.mts

@@ -1,4 +1,5 @@
 import { WriteStream } from "fs";
+export type PackageManager = "pnpm" | "npm" | "yarn" | "yarn-classic";
 export interface SmokeTestResult {
     status: string;
     verificationPassed: boolean;
@@ -24,6 +25,7 @@ export interface SmokeTestOptions {
     realtime?: boolean;
     skipHmr?: boolean;
     skipStyleTests?: boolean;
+    packageManager?: PackageManager;
 }
 export interface TestResources {
     tempDirCleanup?: () => Promise<void>;

package/dist/runtime/lib/router.d.ts

@@ -17,6 +17,7 @@ export type RwContext = {
     databases: Map<string, Kysely<any>>;
     scriptsToBeLoaded: Set<string>;
     pageRouteResolved: PromiseWithResolvers<void> | undefined;
+    actionResult?: unknown;
 };
 export type RouteMiddleware<T extends RequestInfo = RequestInfo> = (requestInfo: T) => MaybePromise<React.JSX.Element | Response | void>;
 type RouteFunction<T extends RequestInfo = RequestInfo> = (requestInfo: T) => MaybePromise<Response>;
@@ -32,12 +33,13 @@ export type RouteDefinition<T extends RequestInfo = RequestInfo> = {
 export declare function matchPath<T extends RequestInfo = RequestInfo>(routePath: string, requestPath: string): T["params"] | null;
 export declare function defineRoutes<T extends RequestInfo = RequestInfo>(routes: Route<T>[]): {
     routes: Route<T>[];
-    handle: ({ request, renderPage, getRequestInfo, onError, runWithRequestInfoOverrides, }: {
+    handle: ({ request, renderPage, getRequestInfo, onError, runWithRequestInfoOverrides, rscActionHandler, }: {
         request: Request;
         renderPage: (requestInfo: T, Page: React.FC, onError: (error: unknown) => void) => Promise<Response>;
         getRequestInfo: () => T;
         onError: (error: unknown) => void;
         runWithRequestInfoOverrides: <Result>(overrides: Partial<T>, fn: () => Promise<Result>) => Promise<Result>;
+        rscActionHandler: (request: Request) => Promise<unknown>;
     }) => Response | Promise<Response>;
 };
 export declare function route<T extends RequestInfo = RequestInfo>(path: string, handler: RouteHandler<T>): RouteDefinition<T>;

package/dist/runtime/lib/router.js

@@ -64,49 +64,15 @@ export function defineRoutes(routes) {
     const flattenedRoutes = flattenRoutes(routes);
     return {
         routes: flattenedRoutes,
-        async handle({ request, renderPage, getRequestInfo, onError, runWithRequestInfoOverrides, }) {
+        async handle({ request, renderPage, getRequestInfo, onError, runWithRequestInfoOverrides, rscActionHandler, }) {
             const url = new URL(request.url);
             let path = url.pathname;
             // Must end with a trailing slash.
             if (path !== "/" && !path.endsWith("/")) {
                 path = path + "/";
             }
-            // Flow below; helpers are declared after the main flow for readability
-            // 1) Global middlewares: run any middleware functions encountered (Response short-circuits, element renders)
-            // 2) Route matching: skip non-matching route definitions; stop at first match
-            // 3) Route-specific middlewares: run middlewares attached to the matched route
-            // 4) Final component: render the matched route's final component (layouts apply only here)
-            for (const route of flattenedRoutes) {
-                // 1) Global middlewares (encountered before a match)
-                if (typeof route === "function") {
-                    const result = await route(getRequestInfo());
-                    const handled = await handleMiddlewareResult(result);
-                    if (handled) {
-                        return handled;
-                    }
-                    continue;
-                }
-                // 2) Route matching (skip if not matched)
-                const params = matchPath(route.path, path);
-                if (!params) {
-                    continue;
-                }
-                // Found a match: 3) route middlewares, then 4) final component, then stop
-                return await runWithRequestInfoOverrides({ params }, async () => {
-                    const { routeMiddlewares, componentHandler } = parseHandlers(route.handler);
-                    // 3) Route-specific middlewares
-                    const mwHandled = await handleRouteMiddlewares(routeMiddlewares);
-                    if (mwHandled) {
-                        return mwHandled;
-                    }
-                    // 4) Final component (always last item)
-                    return await handleRouteComponent(componentHandler, route.layouts || []);
-                });
-            }
-            // No route matched and no middleware handled the request
-            // todo(peterp, 2025-01-28): Allow the user to define their own "not found" route.
-            return new Response("Not Found", { status: 404 });
             // --- Helpers ---
+            // (Hoisted for readability)
             function parseHandlers(handler) {
                 const handlers = Array.isArray(handler) ? handler : [handler];
                 const routeMiddlewares = handlers.slice(0, Math.max(handlers.length - 1, 0));
@@ -130,38 +96,60 @@ export function defineRoutes(routes) {
                 }
                 return undefined;
             }
-            // Note: We no longer have separate global pass or match-only pass;
-            // the outer single pass above handles both behaviors correctly.
-            async function handleRouteMiddlewares(mws) {
-                for (const mw of mws) {
-                    const result = await mw(getRequestInfo());
-                    const handled = await handleMiddlewareResult(result);
-                    if (handled)
-                        return handled;
+            // --- Main flow ---
+            const globalMiddlewares = flattenedRoutes.filter((route) => typeof route === "function");
+            const routeDefinitions = flattenedRoutes.filter((route) => typeof route !== "function");
+            // 1. Run global middlewares
+            for (const middleware of globalMiddlewares) {
+                const result = await middleware(getRequestInfo());
+                const handled = await handleMiddlewareResult(result);
+                if (handled) {
+                    return handled;
                 }
-                return undefined;
             }
-            async function handleRouteComponent(component, layouts) {
-                if (isRouteComponent(component)) {
-                    const requestInfo = getRequestInfo();
-                    const WrappedComponent = wrapWithLayouts(wrapHandlerToThrowResponses(component), layouts, requestInfo);
-                    if (!isClientReference(component)) {
-                        // context(justinvdm, 31 Jul 2025): We now know we're dealing with a page route,
-                        // so we create a deferred so that we can signal when we're done determining whether
-                        // we're returning a response or a react element
-                        requestInfo.rw.pageRouteResolved = Promise.withResolvers();
-                    }
-                    return await renderPage(requestInfo, WrappedComponent, onError);
+            // 2. Handle RSC actions
+            if (url.searchParams.has("__rsc_action_id")) {
+                getRequestInfo().rw.actionResult = await rscActionHandler(request);
+            }
+            // 3. Match and handle routes
+            for (const route of routeDefinitions) {
+                const params = matchPath(route.path, path);
+                if (!params) {
+                    continue;
                 }
-                // If the last handler is not a component, handle as middleware result (no layouts)
-                const tailResult = await component(getRequestInfo());
-                const handledTail = await handleMiddlewareResult(tailResult);
-                if (handledTail)
-                    return handledTail;
-                return new Response("Response not returned from route handler", {
-                    status: 500,
+                // Found a match: run route-specific middlewares, then the final component
+                return await runWithRequestInfoOverrides({ params }, async () => {
+                    const { routeMiddlewares, componentHandler } = parseHandlers(route.handler);
+                    // 3a. Route-specific middlewares
+                    for (const mw of routeMiddlewares) {
+                        const result = await mw(getRequestInfo());
+                        const handled = await handleMiddlewareResult(result);
+                        if (handled) {
+                            return handled;
+                        }
+                    }
+                    // 3b. Final component/handler
+                    if (isRouteComponent(componentHandler)) {
+                        const requestInfo = getRequestInfo();
+                        const WrappedComponent = wrapWithLayouts(wrapHandlerToThrowResponses(componentHandler), route.layouts || [], requestInfo);
+                        if (!isClientReference(componentHandler)) {
+                            requestInfo.rw.pageRouteResolved = Promise.withResolvers();
+                        }
+                        return await renderPage(requestInfo, WrappedComponent, onError);
+                    }
+                    // Handle non-component final handler (e.g., returns new Response)
+                    const tailResult = await componentHandler(getRequestInfo());
+                    const handledTail = await handleMiddlewareResult(tailResult);
+                    if (handledTail) {
+                        return handledTail;
+                    }
+                    return new Response("Response not returned from route handler", {
+                        status: 500,
+                    });
                 });
             }
+            // No route matched
+            return new Response("Not Found", { status: 404 });
         },
     };
 }

package/dist/runtime/requestInfo/types.d.ts

@@ -12,4 +12,5 @@ export interface RequestInfo<Params = any, AppContext = DefaultAppContext> {
     response: ResponseInit & {
         headers: Headers;
     };
+    isAction: boolean;
 }

package/dist/runtime/worker.js

@@ -33,6 +33,7 @@ export const defineApp = (routes) => {
                 const url = new URL(request.url);
                 const isRSCRequest = url.searchParams.has("__rsc") ||
                     request.headers.get("accept")?.includes("text/x-component");
+                const isAction = url.searchParams.has("__rsc_action_id");
                 const userHeaders = new Headers();
                 const rw = {
                     Document: DefaultDocument,
@@ -55,6 +56,7 @@ export const defineApp = (routes) => {
                     ctx: {},
                     rw,
                     response: userResponseInit,
+                    isAction,
                 };
                 const createPageElement = (requestInfo, Page) => {
                     let pageElement;
@@ -77,11 +79,7 @@ export const defineApp = (routes) => {
                             status: 500,
                         });
                     }
-                    let actionResult = undefined;
-                    const isRSCActionHandler = url.searchParams.has("__rsc_action_id");
-                    if (isRSCActionHandler) {
-                        actionResult = await rscActionHandler(request);
-                    }
+                    const actionResult = requestInfo.rw.actionResult;
                     const pageElement = createPageElement(requestInfo, Page);
                     const { rscPayload: shouldInjectRSCPayload } = rw;
                     let rscPayloadStream = renderToRscStream({
@@ -131,6 +129,7 @@ export const defineApp = (routes) => {
                             getRequestInfo: getRequestInfo,
                             runWithRequestInfoOverrides,
                             onError: reject,
+                            rscActionHandler,
                         }));
                     }
                     catch (e) {

package/dist/scripts/debug-sync.mjs

@@ -111,7 +111,9 @@ const performFullSync = async (sdkDir, targetDir) => {
             const cmd = pm.name;
             const args = [pm.command];
             if (pm.name === "yarn") {
-                args.push(`file:${tarballPath}`);
+                // For modern yarn, disable PnP to avoid resolution issues with local tarballs
+                process.env.YARN_NODE_LINKER = "node-modules";
+                args.push(`rwsdk@file:${tarballPath}`);
             }
             else {
                 args.push(tarballPath);

package/dist/scripts/smoke-test.mjs

@@ -30,6 +30,7 @@ if (fileURLToPath(import.meta.url) === process.argv[1]) {
         realtime: false, // Default to false - don't just test realtime
         skipHmr: false, // Default to false - run HMR tests
         skipStyleTests: false,
+        packageManager: "pnpm", // Default to pnpm
         // sync: will be set below
     };
     // Log if we're in CI
@@ -94,6 +95,7 @@ Options:
   --skip-style-tests      Skip stylesheet-related tests
   --path=PATH             Project directory to test
   --artifact-dir=DIR      Directory to store test artifacts (default: .artifacts)
+  --package-manager=MGR   Package manager to use (pnpm, npm, yarn, yarn-classic; default: pnpm)
   --keep                  Keep temporary test directory after tests complete
   --no-headless           Run browser tests with GUI (not headless)
   --sync                  Force syncing SDK code to test project
@@ -112,6 +114,13 @@ Options:
         else if (arg.startsWith("--artifact-dir=")) {
             options.artifactDir = arg.substring(15);
         }
+        else if (arg.startsWith("--package-manager=")) {
+            const pm = arg.substring(18);
+            if (!["pnpm", "npm", "yarn", "yarn-classic"].includes(pm)) {
+                throw new Error(`Invalid package manager: ${pm}`);
+            }
+            options.packageManager = pm;
+        }
         else {
             // Throw error for unknown options instead of just warning
             log("Unknown option: %s", arg);

package/dist/vite/createDirectiveLookupPlugin.mjs

@@ -1,6 +1,7 @@
 import MagicString from "magic-string";
 import path from "path";
 import debug from "debug";
+import { VENDOR_CLIENT_BARREL_EXPORT_PATH, VENDOR_SERVER_BARREL_EXPORT_PATH, } from "../lib/constants.mjs";
 export const createDirectiveLookupPlugin = async ({ projectRootDir, files, config, }) => {
     const debugNamespace = `rwsdk:vite:${config.pluginName}`;
     const log = debug(debugNamespace);
@@ -126,8 +127,8 @@ export const ${config.exportName} = {
                     .map((file) => {
                     if (file.includes("node_modules") && isDev) {
                         const barrelPath = config.kind === "client"
-                            ? "rwsdk/__client_barrel"
-                            : "rwsdk/__server_barrel";
+                            ? VENDOR_CLIENT_BARREL_EXPORT_PATH
+                            : VENDOR_SERVER_BARREL_EXPORT_PATH;
                         return `
   "${file}": () => import("${barrelPath}").then(m => m.default["${file}"]),
 `;

package/dist/vite/directiveModulesDevPlugin.d.mts

@@ -1,6 +1,4 @@
 import { Plugin } from "vite";
-export declare const VIRTUAL_CLIENT_BARREL_ID = "virtual:rwsdk:client-module-barrel";
-export declare const VIRTUAL_SERVER_BARREL_ID = "virtual:rwsdk:server-module-barrel";
 export declare const directiveModulesDevPlugin: ({ clientFiles, serverFiles, projectRootDir, }: {
     clientFiles: Set<string>;
     serverFiles: Set<string>;

package/dist/vite/directiveModulesDevPlugin.mjs

@@ -1,13 +1,10 @@
 import path from "path";
-import { writeFileSync, mkdirSync } from "node:fs";
+import os from "os";
+import { writeFileSync, mkdirSync, mkdtempSync } from "node:fs";
 import { normalizeModulePath } from "../lib/normalizeModulePath.mjs";
-import { CLIENT_BARREL_PATH, SERVER_BARREL_PATH } from "../lib/constants.mjs";
+import { VENDOR_CLIENT_BARREL_PATH, VENDOR_SERVER_BARREL_PATH, VENDOR_CLIENT_BARREL_EXPORT_PATH, VENDOR_SERVER_BARREL_EXPORT_PATH, } from "../lib/constants.mjs";
 import { runDirectivesScan } from "./runDirectivesScan.mjs";
-export const VIRTUAL_CLIENT_BARREL_ID = "virtual:rwsdk:client-module-barrel";
-export const VIRTUAL_SERVER_BARREL_ID = "virtual:rwsdk:server-module-barrel";
-const CLIENT_BARREL_EXPORT_PATH = "rwsdk/__client_barrel";
-const SERVER_BARREL_EXPORT_PATH = "rwsdk/__server_barrel";
-const generateBarrelContent = (files, projectRootDir) => {
+const generateVendorBarrelContent = (files, projectRootDir) => {
     const imports = [...files]
         .filter((file) => file.includes("node_modules"))
         .map((file, i) => `import * as M${i} from '${normalizeModulePath(file, projectRootDir, {
@@ -22,36 +19,50 @@ const generateBarrelContent = (files, projectRootDir) => {
         "\n};";
     return `${imports}\n\n${exports}`;
 };
+const generateAppBarrelContent = (files, projectRootDir, barrelFilePath) => {
+    return [...files]
+        .filter((file) => !file.includes("node_modules"))
+        .map((file) => {
+        const resolvedPath = normalizeModulePath(file, projectRootDir, {
+            absolute: true,
+        });
+        return `import "${resolvedPath}";`;
+    })
+        .join("\n");
+};
 export const directiveModulesDevPlugin = ({ clientFiles, serverFiles, projectRootDir, }) => {
-    let scanPromise = null;
+    const { promise: scanPromise, resolve: resolveScanPromise } = Promise.withResolvers();
+    const tempDir = mkdtempSync(path.join(os.tmpdir(), "rwsdk-"));
+    const APP_CLIENT_BARREL_PATH = path.join(tempDir, "app-client-barrel.js");
+    const APP_SERVER_BARREL_PATH = path.join(tempDir, "app-server-barrel.js");
     return {
         name: "rwsdk:directive-modules-dev",
         configureServer(server) {
             if (!process.env.VITE_IS_DEV_SERVER || process.env.RWSDK_WORKER_RUN) {
+                resolveScanPromise();
                 return;
             }
-            // Start the directive scan as soon as the server is configured.
-            // We don't await it here, allowing Vite to continue its startup.
-            scanPromise = runDirectivesScan({
+            runDirectivesScan({
                 rootConfig: server.config,
                 environments: server.environments,
                 clientFiles,
                 serverFiles,
             }).then(() => {
-                // After the scan is complete, write the barrel files.
-                const clientBarrelContent = generateBarrelContent(clientFiles, projectRootDir);
-                writeFileSync(CLIENT_BARREL_PATH, clientBarrelContent);
-                const serverBarrelContent = generateBarrelContent(serverFiles, projectRootDir);
-                writeFileSync(SERVER_BARREL_PATH, serverBarrelContent);
+                // context(justinvdm, 11 Sep 2025): For vendor barrels, we write the
+                // files directly to disk after the scan. For app barrels, we use a
+                // more complex esbuild plugin to provide content in-memory. This is
+                // because app barrels require special handling to prevent Vite from
+                // marking application code as `external: true`. Vendor barrels do not
+                // have this requirement and a simpler, direct-write approach is more
+                // stable.
+                const vendorClientBarrelContent = generateVendorBarrelContent(clientFiles, projectRootDir);
+                writeFileSync(VENDOR_CLIENT_BARREL_PATH, vendorClientBarrelContent);
+                const vendorServerBarrelContent = generateVendorBarrelContent(serverFiles, projectRootDir);
+                writeFileSync(VENDOR_SERVER_BARREL_PATH, vendorServerBarrelContent);
+                resolveScanPromise();
             });
-            // context(justinvdm, 4 Sep 2025): Add middleware to block incoming
-            // requests until the scan is complete. This gives us a single hook for
-            // preventing app code being processed by vite until the scan is complete.
-            // This improves perceived startup time by not blocking Vite's optimizer.
             server.middlewares.use(async (_req, _res, next) => {
-                if (scanPromise) {
-                    await scanPromise;
-                }
+                await scanPromise;
                 next();
             });
         },
@@ -59,25 +70,70 @@ export const directiveModulesDevPlugin = ({ clientFiles, serverFiles, projectRoo
             if (config.command !== "serve") {
                 return;
             }
-            // Create dummy files to give esbuild a real path to resolve.
-            mkdirSync(path.dirname(CLIENT_BARREL_PATH), { recursive: true });
-            writeFileSync(CLIENT_BARREL_PATH, "");
-            mkdirSync(path.dirname(SERVER_BARREL_PATH), { recursive: true });
-            writeFileSync(SERVER_BARREL_PATH, "");
+            mkdirSync(path.dirname(APP_CLIENT_BARREL_PATH), { recursive: true });
+            writeFileSync(APP_CLIENT_BARREL_PATH, "");
+            mkdirSync(path.dirname(APP_SERVER_BARREL_PATH), { recursive: true });
+            writeFileSync(APP_SERVER_BARREL_PATH, "");
+            mkdirSync(path.dirname(VENDOR_CLIENT_BARREL_PATH), { recursive: true });
+            writeFileSync(VENDOR_CLIENT_BARREL_PATH, "");
+            mkdirSync(path.dirname(VENDOR_SERVER_BARREL_PATH), { recursive: true });
+            writeFileSync(VENDOR_SERVER_BARREL_PATH, "");
             for (const [envName, env] of Object.entries(config.environments || {})) {
                 env.optimizeDeps ??= {};
                 env.optimizeDeps.include ??= [];
-                env.optimizeDeps.include.push(CLIENT_BARREL_EXPORT_PATH, SERVER_BARREL_EXPORT_PATH);
+                const entries = (env.optimizeDeps.entries = castArray(env.optimizeDeps.entries ?? []));
+                env.optimizeDeps.include.push(VENDOR_CLIENT_BARREL_EXPORT_PATH, VENDOR_SERVER_BARREL_EXPORT_PATH);
+                if (envName === "client") {
+                    entries.push(APP_CLIENT_BARREL_PATH);
+                }
+                else if (envName === "worker") {
+                    entries.push(APP_SERVER_BARREL_PATH);
+                }
                 env.optimizeDeps.esbuildOptions ??= {};
                 env.optimizeDeps.esbuildOptions.plugins ??= [];
-                env.optimizeDeps.esbuildOptions.plugins.push({
-                    name: "rwsdk:block-optimizer-for-scan",
+                env.optimizeDeps.esbuildOptions.plugins.unshift({
+                    name: "rwsdk:app-barrel-blocker",
                     setup(build) {
-                        build.onStart(async () => {
-                            // context(justinvdm, 4 Sep 2025): We await the scan promise
-                            // here because we want to block the optimizer until the scan is
-                            // complete.
+                        const appBarrelPaths = [
+                            APP_CLIENT_BARREL_PATH,
+                            APP_SERVER_BARREL_PATH,
+                        ];
+                        const appBarrelFilter = new RegExp(`(${appBarrelPaths
+                            .map((p) => p.replace(/\\/g, "\\\\"))
+                            .join("|")})$`);
+                        build.onResolve({ filter: /.*/ }, async (args) => {
+                            // Block all resolutions until the scan is complete.
                             await scanPromise;
+                            // Handle app barrel files
+                            if (appBarrelFilter.test(args.path)) {
+                                return {
+                                    path: args.path,
+                                    namespace: "rwsdk-app-barrel-ns",
+                                };
+                            }
+                            // context(justinvdm, 11 Sep 2025): Prevent Vite from
+                            // externalizing our application files. If we don't, paths
+                            // imported in our application barrel files will be marked as
+                            // external, and thus not scanned for dependencies.
+                            if (args.path.startsWith("/") &&
+                                (args.path.includes("/src/") ||
+                                    args.path.includes("/generated/")) &&
+                                !args.path.includes("node_modules")) {
+                                // By returning a result, we claim the module and prevent vite:dep-scan
+                                // from marking it as external.
+                                return {
+                                    path: args.path,
+                                };
+                            }
+                        });
+                        build.onLoad({ filter: /.*/, namespace: "rwsdk-app-barrel-ns" }, (args) => {
+                            const isServerBarrel = args.path.includes("app-server-barrel");
+                            const files = isServerBarrel ? serverFiles : clientFiles;
+                            const content = generateAppBarrelContent(files, projectRootDir, args.path);
+                            return {
+                                contents: content,
+                                loader: "js",
+                            };
                         });
                     },
                 });
@@ -85,3 +141,6 @@ export const directiveModulesDevPlugin = ({ clientFiles, serverFiles, projectRoo
         },
     };
 };
+const castArray = (value) => {
+    return Array.isArray(value) ? value : [value];
+};

package/dist/vite/miniflareHMRPlugin.mjs

@@ -146,7 +146,6 @@ export const miniflareHMRPlugin = (givenOptions) => [
                 invalidateModule(ctx.server, environment, VIRTUAL_SSR_PREFIX + "/@id/virtual:use-server-lookup.js");
                 invalidateModule(ctx.server, environment, VIRTUAL_SSR_PREFIX + "virtual:use-server-lookup.js");
             }
-            // todo(justinvdm, 12 Dec 2024): Skip client references
             const modules = Array.from(ctx.server.environments[environment].moduleGraph.getModulesByFile(ctx.file) ?? []);
             const isWorkerUpdate = Boolean(modules);
             // The worker needs an update, but this is the client environment

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rwsdk",
-  "version": "0.3.7",
+  "version": "1.0.0-alpha.0",
   "description": "Build fast, server-driven webapps on Cloudflare with SSR, RSC, and realtime",
   "type": "module",
   "bin": {
@@ -45,11 +45,11 @@
       "types": "./dist/runtime/ssrBridge.d.ts",
       "default": "./dist/runtime/ssrBridge.js"
     },
-    "./__client_barrel": {
-      "default": "./dist/__intermediate_builds/rwsdk-client-barrel.js"
+    "./__vendor_client_barrel": {
+      "default": "./dist/__intermediate_builds/rwsdk-vendor-client-barrel.js"
     },
-    "./__server_barrel": {
-      "default": "./dist/__intermediate_builds/rwsdk-server-barrel.js"
+    "./__vendor_server_barrel": {
+      "default": "./dist/__intermediate_builds/rwsdk-vendor-server-barrel.js"
     },
     "./router": {
       "types": "./dist/runtime/entries/router.d.ts",