rwsdk 1.0.0-alpha.9 → 1.0.0-beta.1

package/dist/vite/findSsrSpecifiers.test.mjs

@@ -1,4 +1,4 @@
-import { describe, it, expect } from "vitest";
+import { describe, expect, it } from "vitest";
 import { findSsrImportCallSites } from "./findSsrSpecifiers.mjs";
 describe("findSsrImportCallSites", () => {
     it("should find __vite_ssr_import__ with double quotes", () => {

package/dist/vite/getViteEsbuild.mjs

@@ -1,5 +1,5 @@
-import path from "node:path";
 import { createRequire } from "node:module";
+import path from "node:path";
 const require = createRequire(import.meta.url);
 export async function getViteEsbuild(projectRootDir) {
     const vitePath = require.resolve("vite/package.json", {

package/dist/vite/hasDirective.test.mjs

@@ -1,4 +1,4 @@
-import { describe, it, expect } from "vitest";
+import { describe, expect, it } from "vitest";
 import { hasDirective } from "./hasDirective.mjs";
 describe("hasDirective", () => {
     it('should find "use client" directive', () => {

package/dist/vite/index.d.mts

@@ -1 +1 @@
-export { type RedwoodPluginOptions, redwoodPlugin as redwood, } from "./redwoodPlugin.mjs";
+export { redwoodPlugin as redwood, type RedwoodPluginOptions, } from "./redwoodPlugin.mjs";

package/dist/vite/invalidateCacheIfPrismaClientChanged.mjs

@@ -1,6 +1,6 @@
-import { resolve } from "node:path";
-import { remove, pathExists } from "fs-extra";
+import { pathExists, remove } from "fs-extra";
 import { stat } from "node:fs/promises";
+import { resolve } from "node:path";
 export const invalidateCacheIfPrismaClientChanged = async ({ projectRootDir, }) => {
     const viteDepsCachePath = resolve(projectRootDir, "node_modules", ".vite", `deps_worker`, `@prisma_client.js`);
     // Get mtimes for comparison

package/dist/vite/isJsFile.test.mjs

@@ -1,4 +1,4 @@
-import { describe, it, expect } from "vitest";
+import { describe, expect, it } from "vitest";
 import { isJsFile } from "./isJsFile.mjs";
 describe("isJsFile", () => {
     const matchingExtensions = [

package/dist/vite/{reactConditionsResolverPlugin.d.mts → knownDepsResolverPlugin.d.mts}

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

package/dist/vite/{reactConditionsResolverPlugin.mjs → knownDepsResolverPlugin.mjs}

@@ -1,10 +1,15 @@
 import debug from "debug";
-import { ROOT_DIR } from "../lib/constants.mjs";
 import enhancedResolve from "enhanced-resolve";
+import { ROOT_DIR } from "../lib/constants.mjs";
 import { ensureAliasArray } from "./ensureAliasArray.mjs";
-const log = debug("rwsdk:vite:react-conditions-resolver-plugin");
-const REACT_PREFIXES = ["react", "react-dom", "react-server-dom-webpack"];
-export const ENV_REACT_IMPORTS = {
+const log = debug("rwsdk:vite:known-deps-resolver-plugin");
+const KNOWN_PREFIXES = [
+    "react",
+    "react-dom",
+    "react-server-dom-webpack",
+    "rwsdk",
+];
+export const ENV_PREDEFINED_IMPORTS = {
     worker: [
         "react",
         "react-dom",
@@ -42,10 +47,10 @@ export const ENV_RESOLVERS = {
         conditionNames: ["browser", "default"],
     }),
 };
-function resolveReactImport(id, envName, projectRootDir, isReactImportKnown = false) {
-    if (!isReactImportKnown) {
-        const isReactImport = REACT_PREFIXES.some((prefix) => id === prefix || id.startsWith(`${prefix}/`));
-        if (!isReactImport) {
+function resolveKnownImport(id, envName, projectRootDir, isPrefixedImport = false) {
+    if (!isPrefixedImport) {
+        const isKnownImport = KNOWN_PREFIXES.some((prefix) => id === prefix || id.startsWith(`${prefix}/`));
+        if (!isKnownImport) {
             return undefined;
         }
     }
@@ -70,13 +75,13 @@ function resolveReactImport(id, envName, projectRootDir, isReactImportKnown = fa
     }
     return resolved;
 }
-function resolveEnvImportMappings(env, projectRootDir) {
+function resolvePredefinedEnvImportMappings(env, projectRootDir) {
     process.env.VERBOSE &&
         log("Resolving environment import mappings for env=%s", env);
     const mappings = new Map();
-    const reactImports = ENV_REACT_IMPORTS[env];
-    for (const importRequest of reactImports) {
-        const resolved = resolveReactImport(importRequest, env, projectRootDir, true);
+    const predefinedImports = ENV_PREDEFINED_IMPORTS[env];
+    for (const importRequest of predefinedImports) {
+        const resolved = resolveKnownImport(importRequest, env, projectRootDir, true);
         if (resolved) {
             mappings.set(importRequest, resolved);
             process.env.VERBOSE &&
@@ -87,27 +92,27 @@ function resolveEnvImportMappings(env, projectRootDir) {
         log("Environment import mappings complete for env=%s: %d mappings", env, mappings.size);
     return mappings;
 }
-export const reactConditionsResolverPlugin = ({ projectRootDir, }) => {
-    log("Initializing react conditions resolver plugin");
+export const knownDepsResolverPlugin = ({ projectRootDir, }) => {
+    log("Initializing known dependencies resolver plugin");
     let isBuild = false;
     const ENV_IMPORT_MAPPINGS = Object.fromEntries(Object.keys(ENV_RESOLVERS).map((env) => [
         env,
-        resolveEnvImportMappings(env, projectRootDir),
+        resolvePredefinedEnvImportMappings(env, projectRootDir),
     ]));
     // Log a clean summary instead of all the individual mappings
     const totalMappings = Object.values(ENV_IMPORT_MAPPINGS).reduce((sum, mappings) => sum + mappings.size, 0);
-    log("React conditions resolver configured with %d total mappings across %d environments", totalMappings, Object.keys(ENV_IMPORT_MAPPINGS).length);
+    log("Known dependencies resolver configured with %d total mappings across %d environments", totalMappings, Object.keys(ENV_IMPORT_MAPPINGS).length);
     function createEsbuildResolverPlugin(envName, mappings) {
         if (!mappings) {
             return null;
         }
         return {
-            name: `rwsdk:react-conditions-resolver-esbuild-${envName}`,
+            name: `rwsdk:known-dependencies-resolver-esbuild-${envName}`,
             setup(build) {
                 build.onResolve({ filter: /.*/ }, (args) => {
                     let resolved = mappings.get(args.path);
                     if (!resolved) {
-                        resolved = resolveReactImport(args.path, envName, projectRootDir);
+                        resolved = resolveKnownImport(args.path, envName, projectRootDir);
                     }
                     if (resolved && args.importer !== "") {
                         if (args.path === "react-server-dom-webpack/client.edge") {
@@ -123,7 +128,7 @@ export const reactConditionsResolverPlugin = ({ projectRootDir, }) => {
     }
     return [
         {
-            name: "rwsdk:react-conditions-resolver:config",
+            name: "rwsdk:known-dependencies-resolver:config",
             enforce: "post",
             config(config, { command }) {
                 isBuild = command === "build";
@@ -133,7 +138,7 @@ export const reactConditionsResolverPlugin = ({ projectRootDir, }) => {
                 log("Setting up resolve aliases and optimizeDeps for each environment");
                 // Set up aliases and optimizeDeps for each environment
                 for (const [envName, mappings] of Object.entries(ENV_IMPORT_MAPPINGS)) {
-                    const reactImports = ENV_REACT_IMPORTS[envName];
+                    const predefinedImports = ENV_PREDEFINED_IMPORTS[envName];
                     // Ensure environment config exists
                     if (!config.environments) {
                         config.environments = {};
@@ -151,7 +156,7 @@ export const reactConditionsResolverPlugin = ({ projectRootDir, }) => {
                         envConfig.optimizeDeps.esbuildOptions.plugins ??= [];
                         envConfig.optimizeDeps.esbuildOptions.plugins.push(esbuildPlugin);
                         envConfig.optimizeDeps.include ??= [];
-                        envConfig.optimizeDeps.include.push(...reactImports);
+                        envConfig.optimizeDeps.include.push(...predefinedImports);
                         log("Added esbuild plugin and optimizeDeps includes for environment: %s", envName);
                     }
                     const aliases = ensureAliasArray(envConfig);
@@ -161,12 +166,12 @@ export const reactConditionsResolverPlugin = ({ projectRootDir, }) => {
                         process.env.VERBOSE &&
                             log("Added alias for env=%s: %s -> %s", envName, find, replacement);
                     }
-                    log("Environment %s configured with %d aliases and %d optimizeDeps includes", envName, mappings.size, reactImports.length);
+                    log("Environment %s configured with %d aliases and %d optimizeDeps includes", envName, mappings.size, predefinedImports.length);
                 }
             },
         },
         {
-            name: "rwsdk:react-conditions-resolver:resolveId",
+            name: "rwsdk:known-dependencies-resolver:resolveId",
             enforce: "pre",
             async resolveId(id, importer) {
                 // Skip during directive scanning to avoid performance issues
@@ -188,7 +193,7 @@ export const reactConditionsResolverPlugin = ({ projectRootDir, }) => {
                 }
                 let resolved = mappings.get(id);
                 if (!resolved) {
-                    resolved = resolveReactImport(id, envName, projectRootDir);
+                    resolved = resolveKnownImport(id, envName, projectRootDir);
                 }
                 if (resolved) {
                     process.env.VERBOSE &&

package/dist/vite/linkerPlugin.mjs

@@ -1,7 +1,7 @@
-import path from "node:path";
+import debug from "debug";
 import fsp from "node:fs/promises";
+import path from "node:path";
 import { CLIENT_MANIFEST_RELATIVE_PATH } from "../lib/constants.mjs";
-import debug from "debug";
 import { normalizeModulePath } from "../lib/normalizeModulePath.mjs";
 const log = debug("rwsdk:vite:linker-plugin");
 export function linkWorkerBundle({ code, manifestContent, projectRootDir, }) {

package/dist/vite/linkerPlugin.test.mjs

@@ -1,4 +1,4 @@
-import { describe, it, expect } from "vitest";
+import { describe, expect, it } from "vitest";
 import { linkWorkerBundle } from "./linkerPlugin.mjs";
 describe("linkWorkerBundle", () => {
     const projectRootDir = "/test/project";

package/dist/vite/miniflareHMRPlugin.mjs

@@ -1,13 +1,13 @@
+import debug from "debug";
+import { readFile } from "node:fs/promises";
 import { resolve } from "node:path";
 import colors from "picocolors";
-import { readFile } from "node:fs/promises";
-import debug from "debug";
-import { VIRTUAL_SSR_PREFIX } from "./ssrBridgePlugin.mjs";
+import { getShortName } from "../lib/getShortName.mjs";
 import { normalizeModulePath } from "../lib/normalizeModulePath.mjs";
 import { hasDirective as sourceHasDirective } from "./hasDirective.mjs";
-import { isJsFile } from "./isJsFile.mjs";
 import { invalidateModule } from "./invalidateModule.mjs";
-import { getShortName } from "../lib/getShortName.mjs";
+import { isJsFile } from "./isJsFile.mjs";
+import { VIRTUAL_SSR_PREFIX } from "./ssrBridgePlugin.mjs";
 const log = debug("rwsdk:vite:hmr-plugin");
 let hasErrored = false;
 const hasDirective = async (filepath, directive) => {

package/dist/vite/miniflareHMRPlugin.test.mjs

@@ -1,4 +1,4 @@
-import { describe, it, expect } from "vitest";
+import { describe, expect, it } from "vitest";
 import { hasEntryAsAncestor } from "./miniflareHMRPlugin.mjs";
 const createModule = (file) => ({
     file,

package/dist/vite/prismaPlugin.mjs

@@ -1,7 +1,7 @@
 import { resolve } from "node:path";
-import { invalidateCacheIfPrismaClientChanged } from "./invalidateCacheIfPrismaClientChanged.mjs";
 import { checkPrismaStatus } from "./checkIsUsingPrisma.mjs";
 import { ensureAliasArray } from "./ensureAliasArray.mjs";
+import { invalidateCacheIfPrismaClientChanged } from "./invalidateCacheIfPrismaClientChanged.mjs";
 export const prismaPlugin = async ({ projectRootDir, }) => {
     if (!checkPrismaStatus({ projectRootDir }).isUsingPrisma) {
         return;

package/dist/vite/redwoodPlugin.d.mts

@@ -6,6 +6,8 @@ export type RedwoodPluginOptions = {
     includeCloudflarePlugin?: boolean;
     includeReactPlugin?: boolean;
     configPath?: string;
+    forceClientPaths?: string[];
+    forceServerPaths?: string[];
     entry?: {
         worker?: string;
     };

package/dist/vite/redwoodPlugin.mjs

@@ -1,32 +1,33 @@
+import { cloudflare } from "@cloudflare/vite-plugin";
 import { resolve } from "node:path";
 import { unstable_readConfig } from "wrangler";
-import { cloudflare } from "@cloudflare/vite-plugin";
 import { devServerConstantPlugin } from "./devServerConstant.mjs";
 import { hasOwnCloudflareVitePlugin } from "./hasOwnCloudflareVitePlugin.mjs";
 import { hasOwnReactVitePlugin } from "./hasOwnReactVitePlugin.mjs";
 import reactPlugin from "@vitejs/plugin-react";
 import tsconfigPaths from "vite-tsconfig-paths";
-import { transformJsxScriptTagsPlugin } from "./transformJsxScriptTagsPlugin.mjs";
-import { directivesPlugin } from "./directivesPlugin.mjs";
-import { useClientLookupPlugin } from "./useClientLookupPlugin.mjs";
-import { useServerLookupPlugin } from "./useServerLookupPlugin.mjs";
-import { miniflareHMRPlugin } from "./miniflareHMRPlugin.mjs";
-import { moveStaticAssetsPlugin } from "./moveStaticAssetsPlugin.mjs";
-import { configPlugin } from "./configPlugin.mjs";
+import { pathExists } from "fs-extra";
 import { $ } from "../lib/$.mjs";
-import { reactConditionsResolverPlugin } from "./reactConditionsResolverPlugin.mjs";
 import { findWranglerConfig } from "../lib/findWranglerConfig.mjs";
-import { pathExists } from "fs-extra";
-import { injectVitePreamble } from "./injectVitePreamblePlugin.mjs";
-import { vitePreamblePlugin } from "./vitePreamblePlugin.mjs";
-import { prismaPlugin } from "./prismaPlugin.mjs";
-import { ssrBridgePlugin } from "./ssrBridgePlugin.mjs";
 import { hasPkgScript } from "../lib/hasPkgScript.mjs";
+import { configPlugin } from "./configPlugin.mjs";
 import { devServerTimingPlugin } from "./devServerTimingPlugin.mjs";
-import { manifestPlugin } from "./manifestPlugin.mjs";
-import { linkerPlugin } from "./linkerPlugin.mjs";
 import { directiveModulesDevPlugin } from "./directiveModulesDevPlugin.mjs";
 import { directivesFilteringPlugin } from "./directivesFilteringPlugin.mjs";
+import { directivesPlugin } from "./directivesPlugin.mjs";
+import { injectVitePreamble } from "./injectVitePreamblePlugin.mjs";
+import { knownDepsResolverPlugin } from "./knownDepsResolverPlugin.mjs";
+import { linkerPlugin } from "./linkerPlugin.mjs";
+import { manifestPlugin } from "./manifestPlugin.mjs";
+import { miniflareHMRPlugin } from "./miniflareHMRPlugin.mjs";
+import { moveStaticAssetsPlugin } from "./moveStaticAssetsPlugin.mjs";
+import { prismaPlugin } from "./prismaPlugin.mjs";
+import { resolveForcedPaths } from "./resolveForcedPaths.mjs";
+import { ssrBridgePlugin } from "./ssrBridgePlugin.mjs";
+import { transformJsxScriptTagsPlugin } from "./transformJsxScriptTagsPlugin.mjs";
+import { useClientLookupPlugin } from "./useClientLookupPlugin.mjs";
+import { useServerLookupPlugin } from "./useServerLookupPlugin.mjs";
+import { vitePreamblePlugin } from "./vitePreamblePlugin.mjs";
 export const determineWorkerEntryPathname = async ({ projectRootDir, workerConfigPath, options, readConfig = unstable_readConfig, }) => {
     if (options.entry?.worker) {
         return resolve(projectRootDir, options.entry.worker);
@@ -39,6 +40,24 @@ const serverFiles = new Set();
 const clientEntryPoints = new Set();
 export const redwoodPlugin = async (options = {}) => {
     const projectRootDir = process.cwd();
+    if (options.forceClientPaths) {
+        const clientPaths = await resolveForcedPaths({
+            patterns: options.forceClientPaths,
+            projectRootDir,
+        });
+        for (const p of clientPaths) {
+            clientFiles.add(p);
+        }
+    }
+    if (options.forceServerPaths) {
+        const serverPaths = await resolveForcedPaths({
+            patterns: options.forceServerPaths,
+            projectRootDir,
+        });
+        for (const p of serverPaths) {
+            serverFiles.add(p);
+        }
+    }
     const workerConfigPath = options.configPath ??
         (process.env.RWSDK_WRANGLER_CONFIG
             ? resolve(projectRootDir, process.env.RWSDK_WRANGLER_CONFIG)
@@ -87,7 +106,7 @@ export const redwoodPlugin = async (options = {}) => {
             serverFiles,
             projectRootDir,
         }),
-        reactConditionsResolverPlugin({ projectRootDir }),
+        knownDepsResolverPlugin({ projectRootDir }),
         tsconfigPaths({ root: projectRootDir }),
         shouldIncludeCloudflarePlugin
             ? cloudflare({

package/dist/vite/redwoodPlugin.test.mjs

@@ -1,6 +1,6 @@
-import { describe, it, expect } from "vitest";
-import { determineWorkerEntryPathname } from "./redwoodPlugin.mjs";
 import path from "node:path";
+import { describe, expect, it } from "vitest";
+import { determineWorkerEntryPathname } from "./redwoodPlugin.mjs";
 describe("determineWorkerEntryPathname", () => {
     const projectRootDir = "/test/project";
     it("should use the entry path from options if provided", async () => {

package/dist/vite/resolveForcedPaths.d.mts

@@ -0,0 +1,4 @@
+export declare function resolveForcedPaths({ patterns, projectRootDir, }: {
+    patterns: string[];
+    projectRootDir: string;
+}): Promise<string[]>;

package/dist/vite/resolveForcedPaths.mjs

@@ -0,0 +1,9 @@
+import { glob } from "glob";
+import { normalizeModulePath } from "../lib/normalizeModulePath.mjs";
+export async function resolveForcedPaths({ patterns, projectRootDir, }) {
+    return (await glob(patterns, {
+        cwd: projectRootDir,
+        absolute: true,
+        realpath: true,
+    })).map((filepath) => normalizeModulePath(filepath, projectRootDir));
+}

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

@@ -1,12 +1,14 @@
+// @ts-ignore
+import { compile } from "@mdx-js/mdx";
+import debug from "debug";
 import fsp from "node:fs/promises";
-import { hasDirective } from "./hasDirective.mjs";
 import path from "node:path";
-import debug from "debug";
-import { getViteEsbuild } from "./getViteEsbuild.mjs";
-import { normalizeModulePath } from "../lib/normalizeModulePath.mjs";
 import { INTERMEDIATES_OUTPUT_DIR } from "../lib/constants.mjs";
+import { normalizeModulePath } from "../lib/normalizeModulePath.mjs";
 import { externalModules } from "./constants.mjs";
 import { createViteAwareResolver } from "./createViteAwareResolver.mjs";
+import { getViteEsbuild } from "./getViteEsbuild.mjs";
+import { hasDirective } from "./hasDirective.mjs";
 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 +52,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 +96,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 +164,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,25 +177,52 @@ 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.
-                        moduleEnvironments.set(args.path, moduleEnv);
-                        log("Set environment for", args.path, "to", moduleEnv);
+                        const realPath = await fsp.realpath(args.path);
+                        moduleEnvironments.set(realPath, moduleEnv);
+                        log("Set environment for", realPath, "to", moduleEnv);
                         // Finally, populate the output sets if the file has a directive.
                         if (isClient) {
-                            log("Discovered 'use client' in:", args.path);
-                            clientFiles.add(normalizeModulePath(args.path, rootConfig.root));
+                            log("Discovered 'use client' in:", realPath);
+                            clientFiles.add(normalizeModulePath(realPath, rootConfig.root));
                         }
                         if (isServer) {
-                            log("Discovered 'use server' in:", args.path);
-                            serverFiles.add(normalizeModulePath(args.path, rootConfig.root));
+                            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);
@@ -219,6 +248,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/dist/vite/runDirectivesScan.test.mjs

@@ -1,5 +1,5 @@
-import { describe, it, expect, vi } from "vitest";
-import { resolveModuleWithEnvironment, classifyModule, } from "./runDirectivesScan.mjs";
+import { describe, expect, it, vi } from "vitest";
+import { classifyModule, resolveModuleWithEnvironment, } from "./runDirectivesScan.mjs";
 describe("runDirectivesScan helpers", () => {
     describe("resolveModuleWithEnvironment", () => {
         it("should use the client resolver when importerEnv is 'client'", async () => {

package/dist/vite/ssrBridgePlugin.mjs

@@ -1,7 +1,7 @@
 import debug from "debug";
-import { findSsrImportCallSites } from "./findSsrSpecifiers.mjs";
-import { INTERMEDIATE_SSR_BRIDGE_PATH } from "../lib/constants.mjs";
 import MagicString from "magic-string";
+import { INTERMEDIATE_SSR_BRIDGE_PATH } from "../lib/constants.mjs";
+import { findSsrImportCallSites } from "./findSsrSpecifiers.mjs";
 const log = debug("rwsdk:vite:ssr-bridge-plugin");
 export const VIRTUAL_SSR_PREFIX = "virtual:rwsdk:ssr:";
 export const ssrBridgePlugin = ({ clientFiles, serverFiles, }) => {
@@ -34,7 +34,8 @@ export const ssrBridgePlugin = ({ clientFiles, serverFiles, }) => {
                         build.onResolve({ filter: /.*$/ }, (args) => {
                             process.env.VERBOSE &&
                                 log("Esbuild onResolve called for path=%s, args=%O", args.path, args);
-                            if (args.path === "rwsdk/__ssr_bridge") {
+                            if (args.path === "rwsdk/__ssr_bridge" ||
+                                args.path.startsWith(VIRTUAL_SSR_PREFIX)) {
                                 log("Marking as external: %s", args.path);
                                 return {
                                     path: args.path,
@@ -77,6 +78,12 @@ export const ssrBridgePlugin = ({ clientFiles, serverFiles, }) => {
             }
             else {
                 // In build mode, the behavior depends on the build pass
+                if (id.startsWith(VIRTUAL_SSR_PREFIX)) {
+                    if (this.environment.name === "worker") {
+                        log("Virtual SSR module case (build-worker pass): resolving to external");
+                        return { id, external: true };
+                    }
+                }
                 if (id === "rwsdk/__ssr_bridge" && this.environment.name === "worker") {
                     if (process.env.RWSDK_BUILD_PASS === "worker") {
                         // First pass: resolve to a temporary, external path

package/dist/vite/transformClientComponents.mjs

@@ -1,11 +1,12 @@
-import MagicString from "magic-string";
 import debug from "debug";
-import { hasDirective } from "./hasDirective.mjs";
+import MagicString from "magic-string";
 import { findExports } from "./findSpecifiers.mjs";
+import { hasDirective } from "./hasDirective.mjs";
 const logVite = debug("rwsdk:vite:transform-client-components:vite");
 const logEsbuild = debug("rwsdk:vite:transform-client-components:esbuild");
 export async function transformClientComponents(code, normalizedId, ctx) {
-    if (!hasDirective(code, "use client")) {
+    if (!ctx.clientFiles?.has(normalizedId) &&
+        !hasDirective(code, "use client")) {
         return;
     }
     const log = ctx.isEsbuild ? logEsbuild : logVite;
@@ -76,13 +77,14 @@ export async function transformClientComponents(code, normalizedId, ctx) {
     // 4. Non-SSR files: replace all implementation with registerClientReference logic
     // Generate completely new code for worker/client environments
     const s = new MagicString("");
-    // Add import declaration
+    s.append('import { ssrLoadModule } from "rwsdk/__ssr_bridge";\n');
     s.append('import { registerClientReference } from "rwsdk/worker";\n');
+    s.append(`const SSRModule = await ssrLoadModule("${normalizedId}");\n`);
     // Compute unique computed local names first
     const computedLocalNames = new Map(processedExports.map((info) => [getComputedLocalName(info), info]));
     // Add registerClientReference assignments for unique names
     for (const [computedLocalName, correspondingInfo] of computedLocalNames) {
-        s.append(`const ${computedLocalName} = registerClientReference("${normalizedId}", "${correspondingInfo.exported}");\n`);
+        s.append(`const ${computedLocalName} = registerClientReference(SSRModule, "${normalizedId}", "${correspondingInfo.exported}");\n`);
     }
     // Add grouped export statement for named exports (preserving order and alias)
     if (processedExports.length > 0) {
@@ -94,7 +96,7 @@ export async function transformClientComponents(code, normalizedId, ctx) {
     // Add default export if present
     if (defaultExportInfo) {
         log(":isEsbuild=%s: Registering client reference for default export: %s", !!ctx.isEsbuild, defaultExportInfo.exported);
-        s.append(`export default registerClientReference("${normalizedId}", "${defaultExportInfo.exported}");\n`);
+        s.append(`export default registerClientReference(SSRModule, "${normalizedId}", "${defaultExportInfo.exported}");\n`);
     }
     const sourceMap = s.generateMap({
         source: normalizedId,