rwsdk 1.0.0-alpha.11 → 1.0.0-alpha.12

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

@@ -124,3 +124,9 @@ export declare namespace testDevAndDeploy {
  * This should be used before any user interaction is simulated.
  */
 export declare function waitForHydration(page: Page): Promise<void>;
+export declare function trackPageErrors(page: Page): {
+    get: () => {
+        consoleErrors: string[];
+        failedRequests: string[];
+    };
+};

package/dist/lib/e2e/testHarness.mjs

@@ -416,3 +416,22 @@ export async function waitForHydration(page) {
     // This is a pragmatic approach to ensure React has mounted.
     await new Promise((resolve) => setTimeout(resolve, HYDRATION_TIMEOUT));
 }
+export function trackPageErrors(page) {
+    const consoleErrors = [];
+    const failedRequests = [];
+    page.on("requestfailed", (request) => {
+        failedRequests.push(`${request.url()} | ${request.failure()?.errorText}`);
+    });
+    page.on("console", (msg) => {
+        if (msg.type() === "error") {
+            consoleErrors.push(msg.text());
+        }
+    });
+    return {
+        get: () => ({
+            // context(justinvdm, 25 Sep 2025): Filter out irrelevant 404s (e.g. favicon)
+            consoleErrors: consoleErrors.filter((e) => !e.includes("404")),
+            failedRequests,
+        }),
+    };
+}

package/dist/runtime/register/worker.js

@@ -9,6 +9,7 @@ export function registerServerReference(action, id, name) {
     // Note: We no longer need to register in a Map since we use virtual lookup
     return baseRegisterServerReference(action, id, name);
 }
+const isComponent = (target) => isValidElementType(target) && target?.toString().includes("jsx");
 export function registerClientReference(ssrModule, id, exportName) {
     const target = ssrModule[exportName] ?? {};
     if (isValidElementType(target)) {
@@ -31,7 +32,13 @@ export function registerClientReference(ssrModule, id, exportName) {
         }
         finalDescriptors.$$async = { value: true };
         finalDescriptors.$$isClientReference = { value: true };
-        return Object.defineProperties(() => null, finalDescriptors);
+        // context(justinvdm, 25 Sep 2025): We create a wrapper function to avoid
+        // getting the SSR component's property descriptors - otherwise
+        // this will take precedence over the client reference descriptors
+        const fn = typeof target === "function"
+            ? (...args) => target(...args)
+            : () => null;
+        return Object.defineProperties(fn, finalDescriptors);
     }
     // For non-components, return the target object directly for use in SSR.
     return target;

package/dist/vite/directiveModulesDevPlugin.mjs

@@ -84,7 +84,7 @@ export const directiveModulesDevPlugin = ({ clientFiles, serverFiles, projectRoo
                 env.optimizeDeps.include ??= [];
                 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") {
+                if (envName === "client" || envName === "ssr") {
                     entries.push(APP_CLIENT_BARREL_PATH);
                 }
                 else if (envName === "worker") {

package/dist/vite/runDirectivesScan.d.mts

@@ -17,11 +17,12 @@ export declare function classifyModule({ contents, inheritedEnv, }: {
     isClient: boolean;
     isServer: boolean;
 };
+export type EsbuildLoader = "js" | "jsx" | "ts" | "tsx" | "default";
 export declare const runDirectivesScan: ({ rootConfig, environments, clientFiles, serverFiles, entries: initialEntries, }: {
     rootConfig: ResolvedConfig;
     environments: Record<string, Environment>;
     clientFiles: Set<string>;
     serverFiles: Set<string>;
-    entries: string[];
+    entries?: string[];
 }) => Promise<void>;
 export {};

package/dist/vite/runDirectivesScan.mjs

@@ -7,6 +7,7 @@ import { normalizeModulePath } from "../lib/normalizeModulePath.mjs";
 import { INTERMEDIATES_OUTPUT_DIR } from "../lib/constants.mjs";
 import { externalModules } from "./constants.mjs";
 import { createViteAwareResolver } from "./createViteAwareResolver.mjs";
+import { compile } from "@mdx-js/mdx";
 const log = debug("rwsdk:vite:run-directives-scan");
 // Copied from Vite's source code.
 // https://github.com/vitejs/vite/blob/main/packages/vite/src/shared/utils.ts
@@ -50,7 +51,7 @@ export function classifyModule({ contents, inheritedEnv, }) {
     return { moduleEnv, isClient, isServer };
 }
 export const runDirectivesScan = async ({ rootConfig, environments, clientFiles, serverFiles, entries: initialEntries, }) => {
-    console.log("\n🔍 Scanning for 'use client' and 'use server' directives...");
+    deferredLog("\n… (rwsdk) Scanning for 'use client' and 'use server' directives...");
     // Set environment variable to indicate scanning is in progress
     process.env.RWSDK_DIRECTIVE_SCAN_ACTIVE = "true";
     try {
@@ -94,7 +95,7 @@ export const runDirectivesScan = async ({ rootConfig, environments, clientFiles,
             setup(build) {
                 // Match Vite's behavior by externalizing assets and special queries.
                 // This prevents esbuild from trying to bundle them, which would fail.
-                const scriptFilter = /\.(c|m)?[jt]sx?$/;
+                const scriptFilter = /\.(c|m)?[jt]sx?$|\.mdx$/;
                 const specialQueryFilter = /[?&](?:url|raw|worker|sharedworker|inline)\b/;
                 // This regex is used to identify if a path has any file extension.
                 const hasExtensionRegex = /\.[^/]+$/;
@@ -162,7 +163,7 @@ export const runDirectivesScan = async ({ rootConfig, environments, clientFiles,
                     log("Marking as external:", args.path, "resolved to:", resolvedPath);
                     return { external: true };
                 });
-                build.onLoad({ filter: /\.(m|c)?[jt]sx?$/ }, async (args) => {
+                build.onLoad({ filter: /\.(m|c)?[jt]sx?$|\.mdx$/ }, async (args) => {
                     log("onLoad called for:", args.path);
                     if (!args.path.startsWith("/") ||
                         args.path.includes("virtual:") ||
@@ -175,10 +176,10 @@ export const runDirectivesScan = async ({ rootConfig, environments, clientFiles,
                         return null;
                     }
                     try {
-                        const contents = await readFileWithCache(args.path);
+                        const originalContents = await readFileWithCache(args.path);
                         const inheritedEnv = args.pluginData?.inheritedEnv || "worker";
                         const { moduleEnv, isClient, isServer } = classifyModule({
-                            contents,
+                            contents: originalContents,
                             inheritedEnv,
                         });
                         // Store the definitive environment for this module, so it can be used when it becomes an importer.
@@ -194,7 +195,33 @@ export const runDirectivesScan = async ({ rootConfig, environments, clientFiles,
                             log("Discovered 'use server' in:", realPath);
                             serverFiles.add(normalizeModulePath(realPath, rootConfig.root));
                         }
-                        return { contents, loader: "default" };
+                        let code;
+                        let loader;
+                        if (args.path.endsWith(".mdx")) {
+                            const result = await compile(originalContents, {
+                                jsx: true,
+                                jsxImportSource: "react",
+                            });
+                            code = String(result.value);
+                            loader = "tsx";
+                        }
+                        else if (/\.(m|c)?tsx$/.test(args.path)) {
+                            code = originalContents;
+                            loader = "tsx";
+                        }
+                        else if (/\.(m|c)?ts$/.test(args.path)) {
+                            code = originalContents;
+                            loader = "ts";
+                        }
+                        else if (/\.(m|c)?jsx$/.test(args.path)) {
+                            code = originalContents;
+                            loader = "jsx";
+                        }
+                        else {
+                            code = originalContents;
+                            loader = "js";
+                        }
+                        return { contents: code, loader };
                     }
                     catch (e) {
                         log("Could not read file during scan, skipping:", args.path, e);
@@ -220,8 +247,13 @@ export const runDirectivesScan = async ({ rootConfig, environments, clientFiles,
     finally {
         // Always clear the scanning flag when done
         delete process.env.RWSDK_DIRECTIVE_SCAN_ACTIVE;
-        console.log("✅ Scan complete.");
+        deferredLog("✔ (rwsdk) Done scanning for 'use client' and 'use server' directives.");
         process.env.VERBOSE &&
             log("Client/server files after scanning: client=%O, server=%O", Array.from(clientFiles), Array.from(serverFiles));
     }
 };
+const deferredLog = (message) => {
+    setTimeout(() => {
+        console.log(message);
+    }, 500);
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rwsdk",
-  "version": "1.0.0-alpha.11",
+  "version": "1.0.0-alpha.12",
   "description": "Build fast, server-driven webapps on Cloudflare with SSR, RSC, and realtime",
   "type": "module",
   "bin": {
@@ -134,6 +134,7 @@
   "dependencies": {
     "@ast-grep/napi": "^0.38.5",
     "@cloudflare/workers-types": "^4.20250407.0",
+    "@mdx-js/mdx": "^3.1.1",
     "@puppeteer/browsers": "^2.8.0",
     "@types/fs-extra": "^11.0.4",
     "@types/react": "^19.1.2",