rwsdk 0.0.85 → 0.0.86

package/README.md

@@ -7,7 +7,7 @@
   </a>
 
   <h1>A React Framework for <a href="https://www.cloudflare.com/">Cloudflare</a>.</h1>
-  
+
   <p><b>It begins as a Vite plugin that unlocks SSR, React Server Components, Server Functions, and realtime features.</b></p>
 
 <a href="https://rwsdk.com"><img alt="Redwood Inc. logo" src="https://img.shields.io/badge/MADE%20BY%20Redwood%20Inc.-000000.svg?style=for-the-badge&logo=Redwood&labelColor=000"></a>
@@ -37,13 +37,13 @@ It features:
 Start a new project:
 
 ```bash
-npx degit redwoodjs/sdk/starters/standard <project-name>
+npx create-rwsdk my-project-name
 ```
 
 Install dependencies:
 
 ```bash
-cd <project-name>
+cd my-project-name
 pnpm install
 ```
 

package/dist/runtime/entries/no-react-server.js

@@ -0,0 +1,2 @@
+"use strict";
+throw new Error("rwsdk: 'react-server' is not supported in this environment");

package/dist/runtime/entries/react-server-only.js

@@ -0,0 +1,2 @@
+"use strict";
+throw new Error("rwsdk: 'react-server' import condition needs to be used in this environment");

package/dist/runtime/entries/ssr.d.ts

@@ -0,0 +1 @@
+export * from "../register/ssr";

package/dist/runtime/entries/ssr.js

@@ -0,0 +1 @@
+export * from "../register/ssr";

package/dist/runtime/imports/ssr.d.ts

@@ -0,0 +1,5 @@
+export declare const ssrLoadModule: ((id: string) => Promise<any>) & import("lodash").MemoizedFunction;
+export declare const ssrGetModuleExport: (id: string) => Promise<any>;
+export declare const ssrWebpackRequire: ((id: string) => Promise<{
+    [x: string]: any;
+}>) & import("lodash").MemoizedFunction;

package/dist/runtime/imports/ssr.js

@@ -0,0 +1,20 @@
+import memoize from "lodash/memoize";
+export const ssrLoadModule = memoize(async (id) => {
+    const { useClientLookup } = await import("virtual:use-client-lookup");
+    const moduleFn = useClientLookup[id];
+    if (!moduleFn) {
+        throw new Error(`No module found for '${id}' in module lookup for "use client" directive`);
+    }
+    return await moduleFn();
+});
+export const ssrGetModuleExport = async (id) => {
+    const [file, name] = id.split("#");
+    const module = await ssrLoadModule(file);
+    return module[name];
+};
+// context(justinvdm, 2 Dec 2024): re memoize(): React relies on the same promise instance being returned for the same id
+export const ssrWebpackRequire = memoize(async (id) => {
+    const [file, name] = id.split("#");
+    const module = await ssrLoadModule(file);
+    return { [id]: module[name] };
+});

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

@@ -1,12 +1,17 @@
-import type React from "react";
+import React from "react";
 import { RequestInfo } from "../requestInfo/types";
 export type DocumentProps = RequestInfo & {
     children: React.ReactNode;
 };
+export type LayoutProps = {
+    children?: React.ReactNode;
+    requestInfo?: RequestInfo;
+};
 export type RwContext = {
     nonce: string;
     Document: React.FC<DocumentProps>;
     rscPayload: boolean;
+    layouts?: React.FC<LayoutProps>[];
 };
 export type RouteMiddleware = (requestInfo: RequestInfo) => Response | Promise<Response> | void | Promise<void> | Promise<Response | void>;
 type RouteFunction = (requestInfo: RequestInfo) => Response | Promise<Response>;
@@ -17,6 +22,7 @@ export type Route = RouteMiddleware | RouteDefinition | Array<Route>;
 export type RouteDefinition = {
     path: string;
     handler: RouteHandler;
+    layouts?: React.FC<LayoutProps>[];
 };
 export declare function matchPath(routePath: string, requestPath: string): RequestInfo["params"] | null;
 export declare function defineRoutes(routes: Route[]): {
@@ -31,7 +37,8 @@ export declare function defineRoutes(routes: Route[]): {
 };
 export declare function route(path: string, handler: RouteHandler): RouteDefinition;
 export declare function index(handler: RouteHandler): RouteDefinition;
-export declare function prefix(prefix: string, routes: ReturnType<typeof route>[]): RouteDefinition[];
+export declare function prefix(prefixPath: string, routes: Route[]): Route[];
+export declare function layout(LayoutComponent: React.FC<LayoutProps>, routes: Route[]): Route[];
 export declare function render(Document: React.FC<DocumentProps>, routes: Route[], 
 /**
  * @param options - Configuration options for rendering.

package/dist/runtime/lib/router.js

@@ -1,3 +1,4 @@
+import React from "react";
 import { isValidElementType } from "react-is";
 export function matchPath(routePath, requestPath) {
     // Check for invalid pattern: multiple colons in a segment (e.g., /:param1:param2/)
@@ -82,7 +83,7 @@ export function defineRoutes(routes) {
                 }
                 const params = matchPath(route.path, path);
                 if (params) {
-                    match = { params, handler: route.handler };
+                    match = { params, handler: route.handler, layouts: route.layouts };
                     break;
                 }
             }
@@ -90,12 +91,14 @@ export function defineRoutes(routes) {
                 // todo(peterp, 2025-01-28): Allow the user to define their own "not found" route.
                 return new Response("Not Found", { status: 404 });
             }
-            let { params, handler } = match;
+            let { params, handler, layouts } = match;
             return runWithRequestInfoOverrides({ params }, async () => {
                 const handlers = Array.isArray(handler) ? handler : [handler];
                 for (const h of handlers) {
                     if (isRouteComponent(h)) {
-                        return await renderPage(getRequestInfo(), h, onError);
+                        const requestInfo = getRequestInfo();
+                        const WrappedComponent = wrapWithLayouts(h, layouts || [], requestInfo);
+                        return await renderPage(requestInfo, WrappedComponent, onError);
                     }
                     else {
                         const r = await h(getRequestInfo());
@@ -124,11 +127,56 @@ export function route(path, handler) {
 export function index(handler) {
     return route("/", handler);
 }
-export function prefix(prefix, routes) {
+export function prefix(prefixPath, routes) {
     return routes.map((r) => {
+        if (typeof r === "function") {
+            // Pass through middleware as-is
+            return r;
+        }
+        if (Array.isArray(r)) {
+            // Recursively process nested route arrays
+            return prefix(prefixPath, r);
+        }
+        // For RouteDefinition objects, update the path and preserve layouts
         return {
-            path: prefix + r.path,
+            path: prefixPath + r.path,
             handler: r.handler,
+            ...(r.layouts && { layouts: r.layouts }),
+        };
+    });
+}
+function wrapWithLayouts(Component, layouts = [], requestInfo) {
+    if (layouts.length === 0) {
+        return Component;
+    }
+    // Create nested layout structure - layouts[0] should be outermost, so use reduceRight
+    return layouts.reduceRight((WrappedComponent, Layout) => {
+        const Wrapped = (props) => {
+            const isClientComponent = Object.prototype.hasOwnProperty.call(Layout, "$$isClientReference");
+            return React.createElement(Layout, {
+                children: React.createElement(WrappedComponent, props),
+                // Only pass requestInfo to server components to avoid serialization issues
+                ...(isClientComponent ? {} : { requestInfo }),
+            });
+        };
+        return Wrapped;
+    }, Component);
+}
+export function layout(LayoutComponent, routes) {
+    // Attach layouts directly to route definitions
+    return routes.map((route) => {
+        if (typeof route === "function") {
+            // Pass through middleware as-is
+            return route;
+        }
+        if (Array.isArray(route)) {
+            // Recursively process nested route arrays
+            return layout(LayoutComponent, route);
+        }
+        // For RouteDefinition objects, prepend the layout so outer layouts come first
+        return {
+            ...route,
+            layouts: [LayoutComponent, ...(route.layouts || [])],
         };
     });
 }

package/dist/runtime/register/ssr.d.ts

@@ -0,0 +1,2 @@
+export declare const createServerReference: (id: string, name: string) => any;
+export declare const registeredServerFunctions: Map<string, Function>;

package/dist/runtime/register/ssr.js

@@ -0,0 +1,13 @@
+import { createServerReference as baseCreateServerReference } from "react-server-dom-webpack/client.edge";
+const ssrCallServer = (id, args) => {
+    const action = registeredServerFunctions.get(id);
+    if (!action) {
+        throw new Error(`Server function ${id} not found`);
+    }
+    return action(args);
+};
+export const createServerReference = (id, name) => {
+    id = id + "#" + name;
+    return baseCreateServerReference(id, ssrCallServer);
+};
+export const registeredServerFunctions = new Map();

package/dist/runtime/render/renderRscThenableToHtmlStream.d.ts

@@ -0,0 +1,7 @@
+import { type DocumentProps } from "../lib/router";
+import { type RequestInfo } from "../requestInfo/types";
+export declare const renderRscThenableToHtmlStream: ({ thenable, Document, requestInfo, }: {
+    thenable: any;
+    Document: React.FC<DocumentProps>;
+    requestInfo: RequestInfo;
+}) => Promise<import("react-dom/server").ReactDOMServerReadableStream>;

package/dist/runtime/render/renderRscThenableToHtmlStream.js

@@ -0,0 +1,11 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { use } from "react";
+import { renderToReadableStream } from "react-dom/server.edge";
+export const renderRscThenableToHtmlStream = async ({ thenable, Document, requestInfo, }) => {
+    const Component = () => {
+        return (_jsx(Document, { ...requestInfo, children: use(thenable).node }));
+    };
+    return await renderToReadableStream(_jsx(Component, {}), {
+        nonce: requestInfo.rw.nonce,
+    });
+};

package/dist/runtime/ssrBridge.d.ts

@@ -0,0 +1,3 @@
+export { renderRscThenableToHtmlStream } from "./render/renderRscThenableToHtmlStream";
+export { registeredServerFunctions } from "./register/ssr";
+export { ssrLoadModule, ssrGetModuleExport, ssrWebpackRequire, } from "./imports/ssr";

package/dist/runtime/ssrBridge.js

@@ -0,0 +1,12 @@
+// context(justinvdm, 28 May 2025): This is the "bridge" between the RSC side
+// and and the SSR side, both run inside the same runtime environment. We have
+// this separation so that they can each be processed with their own respective
+// import conditions and bundling logic
+//
+// **NOTE:** Any time we need to import from SSR side in RSC side, we need to
+// import it through this bridge module, using the bare import path
+// `rwsdk/__ssr_bridge`. We have bundler logic (ssrBridgePlugin) that looks out
+// for imports to it.
+export { renderRscThenableToHtmlStream } from "./render/renderRscThenableToHtmlStream";
+export { registeredServerFunctions } from "./register/ssr";
+export { ssrLoadModule, ssrGetModuleExport, ssrWebpackRequire, } from "./imports/ssr";

package/dist/vite/normalizeModulePath.d.mts

@@ -0,0 +1 @@
+export declare const normalizeModulePath: (projectRootDir: string, modulePath: string) => string;

package/dist/vite/normalizeModulePath.mjs

@@ -0,0 +1,2 @@
+import path from "node:path";
+export const normalizeModulePath = (projectRootDir, modulePath) => "/" + path.relative(projectRootDir, modulePath);

package/dist/vite/rscDirectivesPlugin.d.mts

@@ -0,0 +1,5 @@
+import { Plugin } from "vite";
+export declare const rscDirectivesPlugin: ({ projectRootDir, clientFiles, }: {
+    projectRootDir: string;
+    clientFiles: Set<string>;
+}) => Plugin;

package/dist/vite/rscDirectivesPlugin.mjs

@@ -0,0 +1,81 @@
+import debug from "debug";
+import { transformClientComponents } from "./transformClientComponents.mjs";
+import { transformServerFunctions } from "./transformServerFunctions.mjs";
+import { normalizeModulePath } from "./normalizeModulePath.mjs";
+const log = debug("rwsdk:vite:rsc-directives-plugin");
+const verboseLog = debug("verbose:rwsdk:vite:rsc-directives-plugin");
+export const rscDirectivesPlugin = ({ projectRootDir, clientFiles, }) => ({
+    name: "rwsdk:rsc-directives",
+    async transform(code, id) {
+        verboseLog("Transform called for id=%s, environment=%s", id, this.environment.name);
+        const clientResult = await transformClientComponents(code, id, {
+            environmentName: this.environment.name,
+            clientFiles,
+            projectRootDir,
+        });
+        if (clientResult) {
+            log("Client component transformation successful for id=%s", id);
+            return {
+                code: clientResult.code,
+                map: clientResult.map,
+            };
+        }
+        const serverResult = transformServerFunctions(code, normalizeModulePath(projectRootDir, id), this.environment.name);
+        if (serverResult) {
+            log("Server function transformation successful for id=%s", id);
+            return {
+                code: serverResult.code,
+                map: serverResult.map,
+            };
+        }
+        verboseLog("No transformation applied for id=%s", id);
+    },
+    configEnvironment(env, config) {
+        log("Configuring environment: env=%s", env);
+        config.optimizeDeps ??= {};
+        config.optimizeDeps.esbuildOptions ??= {};
+        config.optimizeDeps.esbuildOptions.plugins ??= [];
+        config.optimizeDeps.esbuildOptions.plugins.push({
+            name: "rsc-directives-esbuild-transform",
+            setup(build) {
+                log("Setting up esbuild plugin for environment: %s", env);
+                build.onLoad({ filter: /.*\.js$/ }, async (args) => {
+                    verboseLog("Esbuild onLoad called for path=%s", args.path);
+                    const fs = await import("node:fs/promises");
+                    const path = await import("node:path");
+                    let code;
+                    try {
+                        code = await fs.readFile(args.path, "utf-8");
+                    }
+                    catch {
+                        verboseLog("Failed to read file: %s", args.path);
+                        return;
+                    }
+                    const clientResult = await transformClientComponents(code, args.path, {
+                        environmentName: env,
+                        clientFiles,
+                        isEsbuild: true,
+                        projectRootDir,
+                    });
+                    if (clientResult) {
+                        log("Esbuild client component transformation successful for path=%s", args.path);
+                        return {
+                            contents: clientResult.code,
+                            loader: path.extname(args.path).slice(1),
+                        };
+                    }
+                    const serverResult = transformServerFunctions(code, normalizeModulePath(projectRootDir, args.path), env);
+                    if (serverResult) {
+                        log("Esbuild server function transformation successful for path=%s", args.path);
+                        return {
+                            contents: serverResult.code,
+                            loader: path.extname(args.path).slice(1),
+                        };
+                    }
+                    verboseLog("Esbuild no transformation applied for path=%s", args.path);
+                });
+            },
+        });
+        log("Environment configuration complete for env=%s", env);
+    },
+});

package/dist/vite/ssrBridgePlugin.d.mts

@@ -0,0 +1,5 @@
+import type { Plugin } from "vite";
+export declare const VIRTUAL_SSR_PREFIX = "virtual:rwsdk:ssr:";
+export declare const ssrBridgePlugin: ({ projectRootDir, }: {
+    projectRootDir: string;
+}) => Plugin;

package/dist/vite/ssrBridgePlugin.mjs

@@ -0,0 +1,114 @@
+import path from "node:path";
+import debug from "debug";
+import { DIST_DIR } from "../lib/constants.mjs";
+const log = debug("rwsdk:vite:ssr-bridge-plugin");
+const verboseLog = debug("verbose:rwsdk:vite:ssr-bridge-plugin");
+export const VIRTUAL_SSR_PREFIX = "virtual:rwsdk:ssr:";
+export const ssrBridgePlugin = ({ projectRootDir, }) => {
+    const distSsrBridgePath = path.resolve(DIST_DIR, "ssrBridge.js");
+    log("Initializing SSR bridge plugin with distSsrBridgePath=%s", distSsrBridgePath);
+    let devServer;
+    let isDev = false;
+    const ssrBridgePlugin = {
+        name: "rwsdk:ssr-bridge",
+        enforce: "pre",
+        configureServer(server) {
+            devServer = server;
+            log("Configured dev server");
+        },
+        config(_, { command, isPreview }) {
+            isDev = !isPreview && command === "serve";
+            log("Config: command=%s, isPreview=%s, isDev=%s", command, isPreview, isDev);
+        },
+        configEnvironment(env, config) {
+            log("Configuring environment: env=%s", env);
+            if (env === "worker" || env === "ssr") {
+                // Configure esbuild to mark rwsdk/__ssr paths as external for worker environment
+                log("Configuring esbuild options for worker environment");
+                config.optimizeDeps ??= {};
+                config.optimizeDeps.esbuildOptions ??= {};
+                config.optimizeDeps.esbuildOptions.plugins ??= [];
+                config.optimizeDeps.include ??= [];
+                config.optimizeDeps.esbuildOptions.plugins.push({
+                    name: "rwsdk-ssr-external",
+                    setup(build) {
+                        log("Setting up esbuild plugin to mark rwsdk/__ssr paths as external for worker");
+                        build.onResolve({ filter: /.*$/ }, (args) => {
+                            verboseLog("Esbuild onResolve called for path=%s, args=%O", args.path, args);
+                            if (args.path === "rwsdk/__ssr_bridge") {
+                                log("Marking as external: %s", args.path);
+                                return {
+                                    path: args.path,
+                                    external: true,
+                                };
+                            }
+                        });
+                    },
+                });
+                log("Worker environment esbuild configuration complete");
+            }
+        },
+        async resolveId(id) {
+            verboseLog("Resolving id=%s, environment=%s, isDev=%s", id, this.environment?.name, isDev);
+            if (isDev) {
+                // context(justinvdm, 27 May 2025): In dev, we need to dynamically load
+                // SSR modules, so we return the virtual id so that the dynamic loading
+                // can happen in load()
+                if (id.startsWith(VIRTUAL_SSR_PREFIX)) {
+                    log("Returning virtual SSR id for dev: %s", id);
+                    return id;
+                }
+                // context(justinvdm, 28 May 2025): The SSR bridge module is a special case -
+                // it is the entry point for all SSR modules, so to trigger the
+                // same dynamic loading logic as other SSR modules (as the case above),
+                // we return a virtual id
+                if (id === "rwsdk/__ssr_bridge" && this.environment.name === "worker") {
+                    const virtualId = `${VIRTUAL_SSR_PREFIX}${id}`;
+                    log("Bridge module case (dev): id=%s matches rwsdk/__ssr_bridge in worker environment, returning virtual id=%s", id, virtualId);
+                    return virtualId;
+                }
+            }
+            else {
+                // context(justinvdm, 27 May 2025): In builds, since all SSR import chains
+                // originate at SSR bridge module, we return the path to the already built
+                // SSR bridge bundle - SSR env builds it, worker build tries to resolve it
+                // here and uses it
+                if (id === "rwsdk/__ssr_bridge" && this.environment.name === "worker") {
+                    log("Bridge module case (build): id=%s matches rwsdk/__ssr_bridge in worker environment, returning distSsrBridgePath=%s", id, distSsrBridgePath);
+                    return distSsrBridgePath;
+                }
+            }
+            verboseLog("No resolution for id=%s", id);
+        },
+        async load(id) {
+            verboseLog("Loading id=%s, isDev=%s, environment=%s", id, isDev, this.environment.name);
+            if (id.startsWith(VIRTUAL_SSR_PREFIX) &&
+                this.environment.name === "worker") {
+                const realId = id.slice(VIRTUAL_SSR_PREFIX.length);
+                log("Virtual SSR module load: id=%s, realId=%s", id, realId);
+                if (isDev) {
+                    log("Dev mode: warming up and fetching SSR module for realPath=%s", realId);
+                    await devServer?.environments.ssr.warmupRequest(realId);
+                    const result = await devServer?.environments.ssr.fetchModule(realId);
+                    if (!result) {
+                        return;
+                    }
+                    const code = "code" in result ? result.code : undefined;
+                    log("Fetched SSR module code length: %d", code?.length || 0);
+                    // context(justinvdm, 27 May 2025): Prefix all imports in SSR modules so that they're separate in module graph from non-SSR
+                    const transformedCode = `
+;(async function(__vite_ssr_import__, __vite_ssr_dynamic_import__) {${code}})(
+  (id) => __vite_ssr_import__('/@id/${VIRTUAL_SSR_PREFIX}'+id),
+  (id) => __vite_ssr_dynamic_import__('/@id/${VIRTUAL_SSR_PREFIX}'+id),
+);
+`;
+                    log("Transformed SSR module code length: %d", transformedCode.length);
+                    log("Transformed SSR module code: %s", transformedCode);
+                    return transformedCode;
+                }
+            }
+            verboseLog("No load handling for id=%s", id);
+        },
+    };
+    return ssrBridgePlugin;
+};

package/dist/vite/transformClientComponents.d.mts

@@ -1,11 +1,12 @@
+interface TransformContext {
+    environmentName: string;
+    clientFiles?: Set<string>;
+    isEsbuild?: boolean;
+    projectRootDir: string;
+}
 interface TransformResult {
     code: string;
     map?: any;
 }
-interface TransformEnv {
-    environmentName: string;
-    topLevelRoot?: string;
-    isEsbuild?: boolean;
-}
-export declare function transformClientComponents(code: string, id: string, env: TransformEnv): Promise<TransformResult | undefined>;
-export type { TransformResult, TransformEnv };
+export declare function transformClientComponents(code: string, id: string, ctx: TransformContext): Promise<TransformResult | undefined>;
+export type { TransformContext, TransformResult };

package/dist/vite/transformClientComponents.mjs

@@ -1,15 +1,17 @@
 import { Project, SyntaxKind, Node } from "ts-morph";
-import MagicString from "magic-string";
 import debug from "debug";
-import { ensureSSRNamespace } from "./virtualizedSSRPlugin.mjs";
-const logVite = debug("rwsdk:transform-client-components:vite");
-const logEsbuild = debug("rwsdk:transform-client-components:esbuild");
-export async function transformClientComponents(code, id, env) {
-    const log = env.isEsbuild ? logEsbuild : logVite;
-    log("Called transformClientComponents for id: id=%s, env: %O", id, env);
+import { normalizeModulePath } from "./normalizeModulePath.mjs";
+const logVite = debug("rwsdk:vite:transform-client-components:vite");
+const logEsbuild = debug("rwsdk:vite:transform-client-components:esbuild");
+const verboseLogVite = debug("verbose:rwsdk:vite:transform-client-components:vite");
+const verboseLogEsbuild = debug("verbose:rwsdk:vite:transform-client-components:esbuild");
+export async function transformClientComponents(code, id, ctx) {
+    const log = ctx.isEsbuild ? logEsbuild : logVite;
+    const verboseLog = ctx.isEsbuild ? verboseLogEsbuild : verboseLogVite;
+    log("Called transformClientComponents for id: id=%s, ctx: %O", id, ctx);
     // 1. Skip if not in worker environment
-    if (env.environmentName !== "worker") {
-        log("Skipping: not in worker environment (%s)", env.environmentName);
+    if (ctx.environmentName !== "worker" && ctx.environmentName !== "ssr") {
+        log("Skipping: not in worker environment (%s)", ctx.environmentName);
         return;
     }
     // 2. Only transform files that start with 'use client'
@@ -18,13 +20,12 @@ export async function transformClientComponents(code, id, env) {
         cleanCode.startsWith("'use client'");
     if (!hasUseClient) {
         log("Skipping: no 'use client' directive in id=%s", id);
-        if (process.env.VERBOSE) {
-            log(":VERBOSE: Returning code unchanged for id=%s:\n%s", id, code);
-        }
+        verboseLog(":VERBOSE: Returning code unchanged for id=%s:\n%s", id, code);
         return;
     }
     log("Processing 'use client' module: id=%s", id);
-    // Use ts-morph to collect all export info in source order
+    ctx.clientFiles?.add(normalizeModulePath(ctx.projectRootDir, id));
+    // Use ts-morph to collect all export info and perform transformations
     const project = new Project({
         useInMemoryFileSystem: true,
         compilerOptions: {
@@ -46,7 +47,7 @@ export async function transformClientComponents(code, id, env) {
             exportInfos.push({ local, exported, isDefault, statementIdx });
         }
     }
-    // Walk through statements in order
+    // Walk through statements in order to collect export information
     const statements = sourceFile.getStatements();
     statements.forEach((stmt, idx) => {
         // export default function ...
@@ -108,64 +109,69 @@ export async function transformClientComponents(code, id, env) {
         }
     });
     // 3. SSR files: just remove the directive
-    if (id.startsWith("virtual:rwsdk:ssr")) {
-        log(":isEsbuild=%s: Handling SSR virtual module: %s", !!env.isEsbuild, id);
-        const s = new MagicString(code);
-        const directiveMatch = code.match(/^(\s*)(["'])use client\2/);
-        if (directiveMatch) {
-            const fullDirective = directiveMatch[0];
-            const directivePos = code.indexOf(fullDirective);
-            const directiveEnd = directivePos + fullDirective.length;
-            // If followed by a semicolon, include it in the removal
-            if (code[directiveEnd] === ";") {
-                s.remove(directivePos, directiveEnd + 1);
+    if (ctx.environmentName === "ssr") {
+        log(":isEsbuild=%s: Handling SSR virtual module: %s", !!ctx.isEsbuild, id);
+        // Remove 'use client' directive using ts-morph
+        sourceFile
+            .getDescendantsOfKind(SyntaxKind.StringLiteral)
+            .forEach((node) => {
+            if (node.getText() === "'use client'" ||
+                node.getText() === '"use client"') {
+                const parentExpr = node.getFirstAncestorByKind(SyntaxKind.ExpressionStatement);
+                if (parentExpr) {
+                    parentExpr.remove();
+                }
             }
-            else {
-                s.remove(directivePos, directiveEnd);
+        });
+        const emitOutput = sourceFile.getEmitOutput();
+        let sourceMap;
+        for (const outputFile of emitOutput.getOutputFiles()) {
+            if (outputFile.getFilePath().endsWith(".js.map")) {
+                sourceMap = JSON.parse(outputFile.getText());
             }
         }
-        const transformed = {
-            code: s.toString(),
-            map: s.generateMap({ hires: true }),
+        verboseLog(":VERBOSE: SSR transformed code for %s:\n%s", id, sourceFile.getFullText());
+        return {
+            code: sourceFile.getFullText(),
+            map: sourceMap,
         };
-        if (process.env.VERBOSE) {
-            log(":VERBOSE: SSR transformed code for %s:\n%s", id, transformed.code);
-        }
-        return transformed;
     }
     // 4. Non-SSR files: replace all implementation with registerClientReference logic
-    // Remove all original imports for non-SSR 'use client' files
-    // Only add the registerClientReference import
-    const ssrModuleId = ensureSSRNamespace(id);
-    const importLine = 'import { registerClientReference } from "rwsdk/worker";';
-    const ssrModuleImportLine = `import "${ssrModuleId}";`;
-    let resultLines = [];
-    resultLines.push(importLine);
-    resultLines.push(ssrModuleImportLine);
+    // Clear the source file and rebuild it
+    sourceFile.removeText();
+    // Add import declaration
+    sourceFile.addImportDeclaration({
+        moduleSpecifier: "rwsdk/worker",
+        namedImports: [{ name: "registerClientReference" }],
+    });
     // Add registerClientReference assignments for named exports in order
     for (const info of exportInfos) {
-        log(":isEsbuild=%s: Registering client reference for named export: %s as %s", !!env.isEsbuild, info.local, info.exported);
-        resultLines.push(`const ${info.local} = registerClientReference("${ssrModuleId}", "${info.exported}");`);
+        log(":isEsbuild=%s: Registering client reference for named export: %s as %s", !!ctx.isEsbuild, info.local, info.exported);
+        sourceFile.addStatements(`const ${info.local} = registerClientReference("${id}", "${info.exported}");`);
     }
     // Add grouped export statement for named exports (preserving order and alias)
     if (exportInfos.length > 0) {
         const exportNames = exportInfos.map((e) => e.local === e.exported ? e.local : `${e.local} as ${e.exported}`);
-        log(":isEsbuild=%s: Exporting named exports: %O", !!env.isEsbuild, exportNames);
-        resultLines.push(`export { ${exportNames.join(", ")} };`);
+        log(":isEsbuild=%s: Exporting named exports: %O", !!ctx.isEsbuild, exportNames);
+        sourceFile.addStatements(`export { ${exportNames.join(", ")} };`);
     }
     // Add default export if present
     if (defaultExportInfo) {
-        log(":isEsbuild=%s: Registering client reference for default export: %s", !!env.isEsbuild, defaultExportInfo.exported);
-        resultLines.push(`export default registerClientReference("${id}", "${defaultExportInfo.exported}");`);
+        log(":isEsbuild=%s: Registering client reference for default export: %s", !!ctx.isEsbuild, defaultExportInfo.exported);
+        sourceFile.addStatements(`export default registerClientReference("${id}", "${defaultExportInfo.exported}");`);
     }
-    // Join all lines with a blank line between each statement, and end with a single trailing newline
-    const finalResult = resultLines.join("\n");
-    log(":isEsbuild=%s: Final transformed code for %s:\n%s", !!env.isEsbuild, id, finalResult);
-    if (process.env.VERBOSE) {
-        log(":VERBOSE: Transformed code for %s:\n%s", id, finalResult + "\n");
+    const emitOutput = sourceFile.getEmitOutput();
+    let sourceMap;
+    for (const outputFile of emitOutput.getOutputFiles()) {
+        if (outputFile.getFilePath().endsWith(".js.map")) {
+            sourceMap = JSON.parse(outputFile.getText());
+        }
     }
+    const finalResult = sourceFile.getFullText();
+    log(":isEsbuild=%s: Final transformed code for %s:\n%s", !!ctx.isEsbuild, id, finalResult);
+    verboseLog(":VERBOSE: Transformed code for %s:\n%s", id, finalResult);
     return {
-        code: finalResult + "\n",
-        map: undefined,
+        code: finalResult,
+        map: sourceMap,
     };
 }

package/dist/vite/transformClientComponents.test.d.mts

@@ -0,0 +1 @@
+export {};

package/dist/vite/transformClientComponents.test.mjs

@@ -0,0 +1,261 @@
+import { describe, it, expect } from "vitest";
+import { transformClientComponents } from "./transformClientComponents.mjs";
+describe("transformClientComponents", () => {
+    async function transform(code) {
+        const result = await transformClientComponents(code, "/test/file.tsx", {
+            environmentName: "worker",
+            projectRootDir: "/test",
+        });
+        return result?.code;
+    }
+    it("transforms arrow function component", async () => {
+        expect((await transform(`"use client"
+
+export const Component = () => {
+  return jsx('div', { children: 'Hello' });
+}
+`)) ?? "").toEqual(`import { registerClientReference } from "rwsdk/worker";
+const Component = registerClientReference("/test/file.tsx", "Component");
+export { Component };
+`);
+    });
+    it("transforms async arrow function component", async () => {
+        expect((await transform(`"use client"
+
+export const Component = async () => {
+  return jsx('div', { children: 'Hello' });
+}
+  `)) ?? "").toEqual(`import { registerClientReference } from "rwsdk/worker";
+const Component = registerClientReference("/test/file.tsx", "Component");
+export { Component };
+`);
+    });
+    it("transforms function declaration component", async () => {
+        expect((await transform(`"use client"
+
+export function Component() {
+  return jsx('div', { children: 'Hello' });
+}`)) ?? "").toEqual(`import { registerClientReference } from "rwsdk/worker";
+const Component = registerClientReference("/test/file.tsx", "Component");
+export { Component };
+`);
+    });
+    it("transforms default export arrow function component", async () => {
+        expect((await transform(`"use client"
+
+export default () => {
+  return jsx('div', { children: 'Hello' });
+}`)) ?? "").toEqual(`import { registerClientReference } from "rwsdk/worker";
+export default registerClientReference("/test/file.tsx", "default");
+`);
+    });
+    it("transforms default export function declaration component", async () => {
+        expect((await transform(`"use client"
+
+export default function Component({ prop1, prop2 }) {
+  return jsx('div', { children: 'Hello' });
+}`)) ?? "").toEqual(`import { registerClientReference } from "rwsdk/worker";
+export default registerClientReference("/test/file.tsx", "default");
+`);
+    });
+    it("transforms mixed export styles (inline, grouped, and default)", async () => {
+        expect((await transform(`"use client"
+
+export const First = () => {
+  return jsx('div', { children: 'First' });
+}
+
+const Second = () => {
+  return jsx('div', { children: 'Second' });
+}
+
+function Third() {
+  return jsx('div', { children: 'Third' });
+}
+
+const Fourth = () => {
+  return jsx('div', { children: 'Fourth' });
+}
+
+export default function Main() {
+  return jsx('div', { children: 'Main' });
+}
+
+export { Second, Third }
+export { Fourth as AnotherName }`)) ?? "").toEqual(`import { registerClientReference } from "rwsdk/worker";
+const First = registerClientReference("/test/file.tsx", "First");
+const Second = registerClientReference("/test/file.tsx", "Second");
+const Third = registerClientReference("/test/file.tsx", "Third");
+const Fourth = registerClientReference("/test/file.tsx", "AnotherName");
+export { First, Second, Third, Fourth as AnotherName };
+export default registerClientReference("/test/file.tsx", "default");
+`);
+    });
+    it("transforms function declaration that is exported default separately", async () => {
+        expect((await transform(`
+"use client"
+
+function Component({ prop1, prop2 }) {
+  return jsx('div', { children: 'Hello' });
+}
+
+export default Component;`)) ?? "").toEqual(`import { registerClientReference } from "rwsdk/worker";
+export default registerClientReference("/test/file.tsx", "default");
+`);
+    });
+    it("Works in dev", async () => {
+        expect((await transform(`"use client"
+import { jsxDEV } from "react/jsx-dev-runtime";
+import { sendMessage } from "./functions";
+import { useState } from "react";
+import { consumeEventStream } from "rwsdk/client";
+
+export function Chat() {
+  const [message, setMessage] = useState("");
+  const [reply, setReply] = useState("");
+  const onClick = async () => {
+    setReply("");
+    (await sendMessage(message)).pipeTo(
+      consumeEventStream({
+        onChunk: (event) => {
+          setReply(
+            (prev) => prev + (event.data === "[DONE]" ? "" : JSON.parse(event.data).response)
+          );
+        }
+      })
+    );
+  };
+  return /* @__PURE__ */ jsxDEV("div", { children: [
+    /* @__PURE__ */ jsxDEV(
+      "input",
+      {
+        type: "text",
+        value: message,
+        placeholder: "Type a message...",
+        onChange: (e) => setMessage(e.target.value),
+        style: {
+          width: "80%",
+          padding: "10px",
+          marginRight: "8px",
+          borderRadius: "4px",
+          border: "1px solid #ccc"
+        }
+      },
+      void 0,
+      false,
+      {
+        fileName: "/Users/justin/rw/sdk/experiments/ai-stream/src/app/pages/Chat/Chat.tsx",
+        lineNumber: 28,
+        columnNumber: 7
+      },
+      this
+    ),
+    /* @__PURE__ */ jsxDEV(
+      "button",
+      {
+        onClick,
+        style: {
+          padding: "10px 20px",
+          borderRadius: "4px",
+          border: "none",
+          backgroundColor: "#007bff",
+          color: "white",
+          cursor: "pointer"
+        },
+        children: "Send"
+      },
+      void 0,
+      false,
+      {
+        fileName: "/Users/justin/rw/sdk/experiments/ai-stream/src/app/pages/Chat/Chat.tsx",
+        lineNumber: 41,
+        columnNumber: 7
+      },
+      this
+    ),
+    /* @__PURE__ */ jsxDEV("div", { children: reply }, void 0, false, {
+      fileName: "/Users/justin/rw/sdk/experiments/ai-stream/src/app/pages/Chat/Chat.tsx",
+      lineNumber: 54,
+      columnNumber: 7
+    }, this)
+  ] }, void 0, true, {
+    fileName: "/Users/justin/rw/sdk/experiments/ai-stream/src/app/pages/Chat/Chat.tsx",
+    lineNumber: 27,
+    columnNumber: 5
+  }, this);
+}
+`)) ?? "").toEqual(`import { registerClientReference } from "rwsdk/worker";
+const Chat = registerClientReference("/test/file.tsx", "Chat");
+export { Chat };
+`);
+    });
+    it("Does not transform when 'use client' is not directive", async () => {
+        expect(await transform(`const message = "use client";`)).toEqual(undefined);
+    });
+    it("properly handles export alias", async () => {
+        expect((await transform(`"use client"
+
+const MyComponent = () => {
+  return jsx('div', { children: 'Hello' });
+}
+
+export { MyComponent as CustomName }`)) ?? "").toEqual(`import { registerClientReference } from "rwsdk/worker";
+const MyComponent = registerClientReference("/test/file.tsx", "CustomName");
+export { MyComponent as CustomName };
+`);
+    });
+    it("correctly processes multiple component exports", async () => {
+        expect((await transform(`"use client"
+
+const First = () => jsx('div', { children: 'First' });
+const Second = () => jsx('div', { children: 'Second' });
+const Third = () => jsx('div', { children: 'Third' });
+
+export { First, Second, Third }`)) ?? "").toEqual(`import { registerClientReference } from "rwsdk/worker";
+const First = registerClientReference("/test/file.tsx", "First");
+const Second = registerClientReference("/test/file.tsx", "Second");
+const Third = registerClientReference("/test/file.tsx", "Third");
+export { First, Second, Third };
+`);
+    });
+    it("handles combination of JSX and non-JSX exports", async () => {
+        expect((await transform(`"use client"
+
+const Component = () => jsx('div', {});
+const data = { value: 42 };
+const helper = () => console.log('helper');
+
+export { Component, data, helper }`)) ?? "").toEqual(`import { registerClientReference } from "rwsdk/worker";
+const Component = registerClientReference("/test/file.tsx", "Component");
+const data = registerClientReference("/test/file.tsx", "data");
+const helper = registerClientReference("/test/file.tsx", "helper");
+export { Component, data, helper };
+`);
+    });
+});
+describe("transformClientComponents logic branches (from transformClientComponents.mts)", () => {
+    it("skips transformation if not in worker environment", async () => {
+        const code = '"use client"\nexport const foo = 1;';
+        const result = await transformClientComponents(code, "/test/file.tsx", {
+            environmentName: "browser",
+            projectRootDir: "/test",
+        });
+        expect(result).toBeUndefined();
+    });
+    it("returns code as-is if file does not start with 'use client'", async () => {
+        const code = "const foo = 1;";
+        const result = await transformClientComponents(code, "/test/file.tsx", {
+            environmentName: "worker",
+            projectRootDir: "/test",
+        });
+        expect(result).toBeUndefined();
+    });
+    it("removes directive but does not transform if not a virtual SSR file", async () => {
+        const code = '"use client"\nexport const foo = 1;';
+        const result = await transformClientComponents(code, "/test/file.tsx", {
+            environmentName: "ssr",
+            projectRootDir: "/test",
+        });
+        expect(result?.code).toEqual("export const foo = 1;");
+    });
+});

package/dist/vite/transformServerFunctions.d.mts

@@ -0,0 +1,8 @@
+import { SourceFile } from "ts-morph";
+interface TransformResult {
+    code: string;
+    map?: any;
+}
+export declare const findExportedFunctions: (sourceFile: SourceFile) => Set<string>;
+export declare const transformServerFunctions: (code: string, relativeId: string, environment: "client" | "worker" | "ssr") => TransformResult | undefined;
+export type { TransformResult };

package/dist/vite/transformServerFunctions.mjs

@@ -0,0 +1,199 @@
+import { Project, SyntaxKind, Node } from "ts-morph";
+import debug from "debug";
+const log = debug("rwsdk:vite:transform-server-functions");
+const verboseLog = debug("verbose:rwsdk:vite:transform-server-functions");
+export const findExportedFunctions = (sourceFile) => {
+    verboseLog("Finding exported functions in source file");
+    const exportedFunctions = new Set();
+    const exportAssignments = sourceFile.getDescendantsOfKind(SyntaxKind.ExportAssignment);
+    for (const e of exportAssignments) {
+        const name = e.getExpression().getText();
+        if (name === "default") {
+            continue;
+        }
+        exportedFunctions.add(name);
+        verboseLog("Found export assignment: %s", name);
+    }
+    const functionDeclarations = sourceFile.getDescendantsOfKind(SyntaxKind.FunctionDeclaration);
+    for (const func of functionDeclarations) {
+        if (func.hasModifier(SyntaxKind.ExportKeyword)) {
+            const name = func.getName();
+            if (name) {
+                exportedFunctions.add(name);
+                verboseLog("Found exported function declaration: %s", name);
+            }
+        }
+    }
+    const variableStatements = sourceFile.getDescendantsOfKind(SyntaxKind.VariableStatement);
+    for (const statement of variableStatements) {
+        if (statement.hasModifier(SyntaxKind.ExportKeyword)) {
+            const declarations = statement.getDeclarationList().getDeclarations();
+            for (const declaration of declarations) {
+                const initializer = declaration.getInitializer();
+                if (initializer && Node.isArrowFunction(initializer)) {
+                    const name = declaration.getName();
+                    if (name) {
+                        exportedFunctions.add(name);
+                        verboseLog("Found exported arrow function: %s", name);
+                    }
+                }
+            }
+        }
+    }
+    log("Found %d exported functions: %O", exportedFunctions.size, Array.from(exportedFunctions));
+    return exportedFunctions;
+};
+export const transformServerFunctions = (code, relativeId, environment) => {
+    verboseLog("Transform server functions called for relativeId=%s, environment=%s", relativeId, environment);
+    const project = new Project({
+        useInMemoryFileSystem: true,
+        compilerOptions: {
+            sourceMap: true,
+            target: 2,
+            module: 1,
+            jsx: 2,
+        },
+    });
+    const sourceFile = project.createSourceFile("temp.tsx", code);
+    const firstString = sourceFile.getFirstDescendantByKind(SyntaxKind.StringLiteral);
+    if (!firstString) {
+        verboseLog("No string literals found, skipping transformation for relativeId=%s", relativeId);
+        return;
+    }
+    if (firstString?.getText().indexOf("use server") === -1 &&
+        firstString?.getStart() !== sourceFile.getStart()) {
+        verboseLog("No 'use server' directive found at start, skipping transformation for relativeId=%s", relativeId);
+        return;
+    }
+    log("Processing 'use server' module: relativeId=%s, environment=%s", relativeId, environment);
+    if (firstString) {
+        const parent = firstString.getParent();
+        if (parent && Node.isExpressionStatement(parent)) {
+            parent.replaceWithText("");
+            verboseLog("Removed 'use server' directive from relativeId=%s", relativeId);
+        }
+    }
+    if (environment === "ssr") {
+        log("Transforming for SSR environment: relativeId=%s", relativeId);
+        const ssrSourceFile = project.createSourceFile("ssr.tsx", "");
+        ssrSourceFile.addImportDeclaration({
+            moduleSpecifier: "rwsdk/__ssr",
+            namedImports: ["createServerReference"],
+        });
+        const exports = findExportedFunctions(sourceFile);
+        for (const name of exports) {
+            ssrSourceFile.addVariableStatement({
+                isExported: true,
+                declarations: [
+                    {
+                        name: name,
+                        initializer: `createServerReference(${JSON.stringify(relativeId)}, ${JSON.stringify(name)})`,
+                    },
+                ],
+            });
+            log("Added SSR server reference for function: %s in relativeId=%s", name, relativeId);
+        }
+        const hadDefaultExport = !!sourceFile.getDefaultExportSymbol();
+        if (hadDefaultExport) {
+            ssrSourceFile.addExportAssignment({
+                expression: `createServerReference(${JSON.stringify(relativeId)}, "default")`,
+                isExportEquals: false,
+            });
+            log("Added SSR server reference for default export in relativeId=%s", relativeId);
+        }
+        const emitOutput = ssrSourceFile.getEmitOutput();
+        let sourceMap;
+        for (const outputFile of emitOutput.getOutputFiles()) {
+            if (outputFile.getFilePath().endsWith(".js.map")) {
+                sourceMap = JSON.parse(outputFile.getText());
+            }
+        }
+        log("SSR transformation complete for relativeId=%s", relativeId);
+        return {
+            code: ssrSourceFile.getFullText(),
+            map: sourceMap,
+        };
+    }
+    else if (environment === "worker") {
+        log("Transforming for worker environment: relativeId=%s", relativeId);
+        sourceFile.addImportDeclaration({
+            moduleSpecifier: "rwsdk/worker",
+            namedImports: ["registerServerReference"],
+        });
+        const defaultExportSymbol = sourceFile.getDefaultExportSymbol();
+        const defaultExportDecl = defaultExportSymbol?.getDeclarations()[0];
+        let hasDefaultExport = false;
+        if (defaultExportDecl && Node.isFunctionDeclaration(defaultExportDecl)) {
+            hasDefaultExport = true;
+            defaultExportDecl.setIsDefaultExport(false);
+            defaultExportDecl.rename("__defaultServerFunction__");
+            sourceFile.addExportAssignment({
+                expression: "__defaultServerFunction__",
+                isExportEquals: false,
+            });
+            sourceFile.addStatements(`registerServerReference(__defaultServerFunction__, ${JSON.stringify(relativeId)}, "default")`);
+            log("Registered worker server reference for default export in relativeId=%s", relativeId);
+        }
+        const exports = findExportedFunctions(sourceFile);
+        for (const name of exports) {
+            if (name === "__defaultServerFunction__")
+                continue;
+            sourceFile.addStatements(`registerServerReference(${name}, ${JSON.stringify(relativeId)}, ${JSON.stringify(name)})`);
+            log("Registered worker server reference for function: %s in relativeId=%s", name, relativeId);
+        }
+        const emitOutput = sourceFile.getEmitOutput();
+        let sourceMap;
+        for (const outputFile of emitOutput.getOutputFiles()) {
+            if (outputFile.getFilePath().endsWith(".js.map")) {
+                sourceMap = JSON.parse(outputFile.getText());
+            }
+        }
+        log("Worker transformation complete for relativeId=%s", relativeId);
+        return {
+            code: sourceFile.getFullText(),
+            map: sourceMap,
+        };
+    }
+    else if (environment === "client") {
+        log("Transforming for client environment: relativeId=%s", relativeId);
+        const clientSourceFile = project.createSourceFile("client.tsx", "");
+        clientSourceFile.addImportDeclaration({
+            moduleSpecifier: "rwsdk/client",
+            namedImports: ["createServerReference"],
+        });
+        const exports = findExportedFunctions(sourceFile);
+        for (const name of exports) {
+            clientSourceFile.addVariableStatement({
+                isExported: true,
+                declarations: [
+                    {
+                        name: name,
+                        initializer: `createServerReference(${JSON.stringify(relativeId)}, ${JSON.stringify(name)})`,
+                    },
+                ],
+            });
+            log("Added client server reference for function: %s in relativeId=%s", name, relativeId);
+        }
+        const hadDefaultExport = !!sourceFile.getDefaultExportSymbol();
+        if (hadDefaultExport) {
+            clientSourceFile.addExportAssignment({
+                expression: `createServerReference(${JSON.stringify(relativeId)}, "default")`,
+                isExportEquals: false,
+            });
+            log("Added client server reference for default export in relativeId=%s", relativeId);
+        }
+        const emitOutput = clientSourceFile.getEmitOutput();
+        let sourceMap;
+        for (const outputFile of emitOutput.getOutputFiles()) {
+            if (outputFile.getFilePath().endsWith(".js.map")) {
+                sourceMap = JSON.parse(outputFile.getText());
+            }
+        }
+        log("Client transformation complete for relativeId=%s", relativeId);
+        return {
+            code: clientSourceFile.getFullText(),
+            map: sourceMap,
+        };
+    }
+    verboseLog("No transformation applied for environment=%s, relativeId=%s", environment, relativeId);
+};

package/dist/vite/transformServerFunctions.test.d.mts

@@ -0,0 +1 @@
+export {};

package/dist/vite/transformServerFunctions.test.mjs

@@ -0,0 +1,105 @@
+import { describe, expect, it } from "vitest";
+import { transformServerFunctions } from "./transformServerFunctions.mjs";
+describe("useServerPlugin", () => {
+    let COMMENT_CODE = `
+// Comment
+"use server";
+
+export function sum() {
+  return 1 + 1;
+}
+`;
+    let MULTI_LINE_COMMENT_CODE = `
+// Multi-line
+// Comment
+"use server";
+
+export function sum() {
+  return 1 + 1
+}
+`;
+    let COMMENT_BLOCK_CODE = `
+/* Giant
+ * Comment
+ * Block
+ */
+"use server";
+
+export function sum() {
+  return 1 + 1
+}
+`;
+    let DEFAULT_EXPORT_CODE = `
+"use server";
+
+export default function sum() {
+  return 1 + 1;
+}
+`;
+    let DEFAULT_AND_NAMED_EXPORTS_CODE = `
+"use server";
+
+export function sum() {
+  return 1 + 1;
+}
+
+export default function sum() {
+  return 1 + 2;
+}
+`;
+    let NAMED_EXPORT_CODE = `
+"use server";
+
+export function sum() {
+  return 1 + 1
+}
+`;
+    let ARROW_FUNCTION_EXPORT_CODE = `
+"use server";
+
+export const sum = () => {
+  return 1 + 1
+}
+`;
+    let ASYNC_FUNCTION_EXPORT_CODE = `
+"use server";
+
+export async function sum() {
+  return 1 + 1
+}
+`;
+    let IGNORE_NON_FUNCTION_EXPORT_CODE = `
+"use server";
+
+export const a = "string";
+`;
+    const TEST_CASES = {
+        COMMENT_CODE,
+        MULTI_LINE_COMMENT_CODE,
+        COMMENT_BLOCK_CODE,
+        DEFAULT_EXPORT_CODE,
+        NAMED_EXPORT_CODE,
+        ARROW_FUNCTION_EXPORT_CODE,
+        ASYNC_FUNCTION_EXPORT_CODE,
+        IGNORE_NON_FUNCTION_EXPORT_CODE,
+        DEFAULT_AND_NAMED_EXPORTS_CODE,
+    };
+    describe("TRANSFORMS", () => {
+        for (const [key, CODE] of Object.entries(TEST_CASES)) {
+            describe(key, () => {
+                it(`CLIENT`, () => {
+                    const result = transformServerFunctions(CODE, "/test.tsx", "client");
+                    expect(result?.code).toMatchSnapshot();
+                });
+                it(`WORKER`, () => {
+                    const result = transformServerFunctions(CODE, "/test.tsx", "worker");
+                    expect(result?.code).toMatchSnapshot();
+                });
+                it(`SSR`, () => {
+                    const result = transformServerFunctions(CODE, "/test.tsx", "ssr");
+                    expect(result?.code).toMatchSnapshot();
+                });
+            });
+        }
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rwsdk",
-  "version": "0.0.85",
+  "version": "0.0.86",
   "description": "Build fast, server-driven webapps on Cloudflare with SSR, RSC, and realtime",
   "type": "module",
   "bin": {