rwsdk 0.2.0 → 0.3.0

package/dist/vite/configPlugin.mjs

@@ -1,7 +1,10 @@
 import path, { resolve } from "node:path";
 import { builtinModules } from "node:module";
 import enhancedResolve from "enhanced-resolve";
-import { SSR_BRIDGE_PATH } from "../lib/constants.mjs";
+import debug from "debug";
+import { INTERMEDIATE_SSR_BRIDGE_PATH } from "../lib/constants.mjs";
+import { buildApp } from "./buildApp.mjs";
+const log = debug("rwsdk:vite:config");
 // port(justinvdm, 09 Jun 2025):
 // https://github.com/cloudflare/workers-sdk/blob/d533f5ee7da69c205d8d5e2a5f264d2370fc612b/packages/vite-plugin-cloudflare/src/cloudflare-environment.ts#L123-L128
 export const cloudflareBuiltInModules = [
@@ -15,10 +18,60 @@ export const externalModules = [
     ...builtinModules,
     ...builtinModules.map((m) => `node:${m}`),
 ];
-export const configPlugin = ({ silent, projectRootDir, clientEntryPathnames, workerEntryPathname, }) => ({
+export const configPlugin = ({ silent, projectRootDir, workerEntryPathname, clientFiles, serverFiles, clientEntryPoints, }) => ({
     name: "rwsdk:config",
     config: async (_) => {
         const mode = process.env.NODE_ENV;
+        const workerConfig = {
+            resolve: {
+                conditions: [
+                    "workerd",
+                    "react-server",
+                    "module",
+                    // context(justinvdm, 11 Jun 2025): Some packages meant for cloudflare workers, yet
+                    // their deps have only node import conditions, e.g. `agents` package (meant for CF),
+                    // has `pkce-challenge` package as a dep, which has only node import conditions.
+                    // https://github.com/crouchcd/pkce-challenge/blob/master/package.json#L17
+                    //
+                    // @cloudflare/vite-plugin should take care of any relevant polyfills for deps with
+                    // node builtins imports that can be polyfilled though, so it is worth us including this condition here.
+                    // However, it does mean we will try to run packages meant for node that cannot be run on cloudflare workers.
+                    // That's the trade-off, but arguably worth it.
+                    "node",
+                ],
+                noExternal: true,
+            },
+            define: {
+                "import.meta.env.RWSDK_ENV": JSON.stringify("worker"),
+            },
+            optimizeDeps: {
+                noDiscovery: false,
+                include: ["rwsdk/worker"],
+                exclude: [],
+                entries: [workerEntryPathname],
+                esbuildOptions: {
+                    jsx: "automatic",
+                    jsxImportSource: "react",
+                    define: {
+                        "process.env.NODE_ENV": JSON.stringify(mode),
+                    },
+                },
+            },
+            build: {
+                outDir: resolve(projectRootDir, "dist", "worker"),
+                emitAssets: true,
+                emptyOutDir: false,
+                ssr: true,
+                rollupOptions: {
+                    output: {
+                        inlineDynamicImports: true,
+                    },
+                    input: {
+                        worker: workerEntryPathname,
+                    },
+                },
+            },
+        };
         const baseConfig = {
             appType: "custom",
             mode,
@@ -40,7 +93,7 @@ export const configPlugin = ({ silent, projectRootDir, clientEntryPathnames, wor
                         outDir: resolve(projectRootDir, "dist", "client"),
                         manifest: true,
                         rollupOptions: {
-                            input: clientEntryPathnames,
+                            input: [],
                         },
                     },
                     define: {
@@ -49,6 +102,7 @@ export const configPlugin = ({ silent, projectRootDir, clientEntryPathnames, wor
                     optimizeDeps: {
                         noDiscovery: false,
                         include: ["rwsdk/client"],
+                        entries: [],
                         esbuildOptions: {
                             jsx: "automatic",
                             jsxImportSource: "react",
@@ -87,80 +141,33 @@ export const configPlugin = ({ silent, projectRootDir, clientEntryPathnames, wor
                     build: {
                         lib: {
                             entry: {
-                                [path.basename(SSR_BRIDGE_PATH, ".js")]: enhancedResolve.sync(projectRootDir, "rwsdk/__ssr_bridge"),
+                                [path.basename(INTERMEDIATE_SSR_BRIDGE_PATH, ".js")]: enhancedResolve.sync(projectRootDir, "rwsdk/__ssr_bridge"),
                             },
                             formats: ["es"],
-                            fileName: () => path.basename(SSR_BRIDGE_PATH),
+                            fileName: () => path.basename(INTERMEDIATE_SSR_BRIDGE_PATH),
                         },
-                        outDir: path.dirname(SSR_BRIDGE_PATH),
-                    },
-                },
-                worker: {
-                    resolve: {
-                        conditions: [
-                            "workerd",
-                            "react-server",
-                            "module",
-                            // context(justinvdm, 11 Jun 2025): Some packages meant for cloudflare workers, yet
-                            // their deps have only node import conditions, e.g. `agents` package (meant for CF),
-                            // has `pkce-challenge` package as a dep, which has only node import conditions.
-                            // https://github.com/crouchcd/pkce-challenge/blob/master/package.json#L17
-                            //
-                            // @cloudflare/vite-plugin should take care of any relevant polyfills for deps with
-                            // node builtins imports that can be polyfilled though, so it is worth us including this condition here.
-                            // However, it does mean we will try to run packages meant for node that cannot be run on cloudflare workers.
-                            // That's the trade-off, but arguably worth it.
-                            "node",
-                        ],
-                        noExternal: true,
-                    },
-                    define: {
-                        "import.meta.env.RWSDK_ENV": JSON.stringify("worker"),
-                    },
-                    optimizeDeps: {
-                        noDiscovery: false,
-                        include: ["rwsdk/worker"],
-                        exclude: [],
-                        entries: [workerEntryPathname],
-                        esbuildOptions: {
-                            jsx: "automatic",
-                            jsxImportSource: "react",
-                            define: {
-                                "process.env.NODE_ENV": JSON.stringify(mode),
-                            },
-                        },
-                    },
-                    build: {
-                        outDir: resolve(projectRootDir, "dist", "worker"),
-                        emitAssets: true,
-                        ssr: true,
+                        outDir: path.dirname(INTERMEDIATE_SSR_BRIDGE_PATH),
                         rollupOptions: {
                             output: {
                                 inlineDynamicImports: true,
                             },
-                            input: {
-                                worker: workerEntryPathname,
-                            },
                         },
                     },
                 },
+                worker: workerConfig,
             },
             server: {
                 hmr: true,
             },
             builder: {
-                buildApp: async (builder) => {
-                    // note(justinvdm, 27 May 2025): **Ordering is important**:
-                    // * When building, client needs to be build first, so that we have a
-                    //   manifest file to map to when looking at asset references in JSX
-                    //   (e.g. Document.tsx)
-                    // * When bundling, the RSC build imports the SSR build - this way
-                    //   they each can have their own environments (e.g. with their own
-                    //   import conditions), while still having all worker-run code go
-                    //   through the processing done by `@cloudflare/vite-plugin`
-                    await builder.build(builder.environments["client"]);
-                    await builder.build(builder.environments["ssr"]);
-                    await builder.build(builder.environments["worker"]);
+                async buildApp(builder) {
+                    await buildApp({
+                        builder,
+                        projectRootDir,
+                        clientEntryPoints,
+                        clientFiles,
+                        serverFiles,
+                    });
                 },
             },
         };

package/dist/vite/createDirectiveLookupPlugin.d.mts

@@ -7,12 +7,6 @@ interface DirectiveLookupConfig {
     pluginName: string;
     optimizeForEnvironments?: string[];
 }
-export declare const findFilesContainingDirective: ({ projectRootDir, files, directive, debugNamespace, }: {
-    projectRootDir: string;
-    files: Set<string>;
-    directive: string;
-    debugNamespace: string;
-}) => Promise<void>;
 export declare const createDirectiveLookupPlugin: ({ projectRootDir, files, config, }: {
     projectRootDir: string;
     files: Set<string>;

package/dist/vite/createDirectiveLookupPlugin.mjs

@@ -1,125 +1,12 @@
 import MagicString from "magic-string";
 import path from "path";
-import { readFile } from "fs/promises";
 import debug from "debug";
-import { normalizeModulePath } from "../lib/normalizeModulePath.mjs";
-import { pathExists } from "fs-extra";
-import { stat } from "fs/promises";
-import { getSrcPaths } from "../lib/getSrcPaths.js";
-import { hasDirective } from "./hasDirective.mjs";
-export const findFilesContainingDirective = async ({ projectRootDir, files, directive, debugNamespace, }) => {
-    const log = debug(debugNamespace);
-    log("Starting search for '%s' files in projectRootDir=%s", directive, projectRootDir);
-    const filesToScan = await getSrcPaths(projectRootDir);
-    log("Found %d files to scan for '%s' directive", filesToScan.length, directive);
-    for (const file of filesToScan) {
-        try {
-            const stats = await stat(file);
-            if (!stats.isFile()) {
-                process.env.VERBOSE && log("Skipping %s (not a file)", file);
-                continue;
-            }
-            process.env.VERBOSE && log("Scanning file: %s", file);
-            const content = await readFile(file, "utf-8");
-            if (hasDirective(content, directive)) {
-                const normalizedPath = normalizeModulePath(file, projectRootDir);
-                log("Found '%s' directive in file: %s -> %s", directive, file, normalizedPath);
-                files.add(normalizedPath);
-            }
-        }
-        catch (error) {
-            console.error(`Error reading file ${file}:`, error);
-        }
-    }
-    log("Completed scan. Found %d %s files total", files.size, directive);
-    process.env.VERBOSE &&
-        log("Found files for %s: %j", directive, Array.from(files));
-};
-const resolveOptimizedDep = async (projectRootDir, id, environment, debugNamespace) => {
-    const log = debug(debugNamespace);
-    try {
-        const depsDir = environment === "client" ? "deps" : `deps_${environment}`;
-        const nodeModulesDepsDirPath = path.join("node_modules", ".vite", depsDir);
-        const depsDirPath = path.join(projectRootDir, nodeModulesDepsDirPath);
-        const manifestPath = path.join(depsDirPath, "_metadata.json");
-        log("Checking for manifest at: %s", manifestPath);
-        const manifestExists = await pathExists(manifestPath);
-        if (!manifestExists) {
-            log("Manifest not found at %s", manifestPath);
-            return undefined;
-        }
-        const manifestContent = await readFile(manifestPath, "utf-8");
-        const manifest = JSON.parse(manifestContent);
-        if (manifest.optimized && manifest.optimized[id]) {
-            const optimizedFile = manifest.optimized[id].file;
-            const optimizedPath = path.join("/", nodeModulesDepsDirPath, optimizedFile);
-            log("Found optimized dependency: filePath=%s, optimizedPath=%s", id, optimizedPath);
-            return optimizedPath;
-        }
-        process.env.VERBOSE &&
-            log("File not found in optimized dependencies: id=%s", id);
-        return undefined;
-    }
-    catch (error) {
-        process.env.VERBOSE &&
-            log("Error resolving optimized dependency for id=%s: %s", id, error);
-        return undefined;
-    }
-};
-const addOptimizedDepsEntries = async ({ projectRootDir, directive, environment, debugNamespace, files, }) => {
-    const log = debug(debugNamespace);
-    try {
-        const depsDir = environment === "client" ? "deps" : `deps_${environment}`;
-        const depsDirPath = path.join(projectRootDir, "node_modules", ".vite", depsDir);
-        const manifestPath = path.join(depsDirPath, "_metadata.json");
-        process.env.VERBOSE && log("Checking for manifest at: %s", manifestPath);
-        const manifestExists = await pathExists(manifestPath);
-        if (!manifestExists) {
-            process.env.VERBOSE && log("Manifest not found at %s", manifestPath);
-            return;
-        }
-        const manifestContent = await readFile(manifestPath, "utf-8");
-        const manifest = JSON.parse(manifestContent);
-        for (const entryId of Object.keys(manifest.optimized)) {
-            if (entryId.startsWith("/node_modules/")) {
-                const srcPath = manifest.optimized[entryId].src;
-                const resolvedSrcPath = path.resolve(projectRootDir, "node_modules", ".vite", "deps", srcPath);
-                let contents;
-                try {
-                    contents = await readFile(resolvedSrcPath, "utf-8");
-                }
-                catch (error) {
-                    process.env.VERBOSE &&
-                        log("Error reading file %s: %s", resolvedSrcPath, error);
-                    continue;
-                }
-                if (hasDirective(contents, directive)) {
-                    log("Adding optimized entry to files: %s", entryId);
-                    files.add(entryId);
-                }
-                else {
-                    log("Skipping optimized entry %s because it does not contain the '%s' directive", entryId, directive);
-                }
-            }
-        }
-    }
-    catch (error) {
-        process.env.VERBOSE &&
-            log("Error adding optimized deps entries: %s", error);
-    }
-};
 export const createDirectiveLookupPlugin = async ({ projectRootDir, files, config, }) => {
     const debugNamespace = `rwsdk:vite:${config.pluginName}`;
     const log = debug(debugNamespace);
     let isDev = false;
-    log("Initializing %s plugin with projectRootDir=%s", config.pluginName, projectRootDir);
-    await findFilesContainingDirective({
-        projectRootDir,
-        files,
-        directive: config.directive,
-        debugNamespace,
-    });
     let devServer;
+    log("Initializing %s plugin with projectRootDir=%s", config.pluginName, projectRootDir);
     return {
         name: `rwsdk:${config.pluginName}`,
         config(_, { command, isPreview }) {
@@ -129,16 +16,13 @@ export const createDirectiveLookupPlugin = async ({ projectRootDir, files, confi
         configureServer(server) {
             devServer = server;
         },
-        async configEnvironment(env, viteConfig) {
+        configEnvironment(env, viteConfig) {
+            if (!isDev &&
+                process.env.RWSDK_BUILD_PASS &&
+                process.env.RWSDK_BUILD_PASS !== "worker") {
+                return;
+            }
             log("Configuring environment: env=%s", env);
-            // Add optimized deps entries that match our pattern
-            await addOptimizedDepsEntries({
-                projectRootDir,
-                files,
-                directive: config.directive,
-                environment: env,
-                debugNamespace,
-            });
             viteConfig.optimizeDeps ??= {};
             viteConfig.optimizeDeps.esbuildOptions ??= {};
             viteConfig.optimizeDeps.esbuildOptions.plugins ??= [];
@@ -150,7 +34,7 @@ export const createDirectiveLookupPlugin = async ({ projectRootDir, files, confi
                     const escapedVirtualModuleName = config.virtualModuleName.replace(/[-\/\\^$*+?.()|[\]{}]/g, "\\$&");
                     const escapedPrefixedModuleName = `/@id/${config.virtualModuleName}`.replace(/[-\/\\^$*+?.()|[\]{}]/g, "\\$&");
                     build.onResolve({
-                        filter: new RegExp(`^(${escapedVirtualModuleName}|${escapedPrefixedModuleName})\.js$`),
+                        filter: new RegExp(`^(${escapedVirtualModuleName}|${escapedPrefixedModuleName})\\.js$`),
                     }, () => {
                         process.env.VERBOSE &&
                             log("Esbuild onResolve: marking %s as external", config.virtualModuleName);
@@ -167,6 +51,9 @@ export const createDirectiveLookupPlugin = async ({ projectRootDir, files, confi
                 log("Applying optimizeDeps and aliasing for environment: %s", env);
                 viteConfig.optimizeDeps.include ??= [];
                 for (const file of files) {
+                    if (file.includes("node_modules")) {
+                        continue;
+                    }
                     const actualFilePath = path.join(projectRootDir, file);
                     process.env.VERBOSE &&
                         log("Adding to optimizeDeps.entries: %s", actualFilePath);
@@ -183,36 +70,66 @@ export const createDirectiveLookupPlugin = async ({ projectRootDir, files, confi
             }
         },
         resolveId(source) {
-            process.env.VERBOSE && log("Resolving id=%s", source);
-            if (source === `${config.virtualModuleName}.js`) {
-                log("Resolving %s module", config.virtualModuleName);
-                // context(justinvdm, 16 Jun 2025): Include .js extension
-                // so it goes through vite processing chain
-                return source;
+            if (source !== `${config.virtualModuleName}.js`) {
+                return null;
             }
-            process.env.VERBOSE && log("No resolution for id=%s", source);
+            // context(justinvdm, 3 Sep 2025): This logic determines *when* to
+            // generate and bundle the lookup map. By conditionally externalizing it,
+            // we ensure the map is only created after tree-shaking is complete and
+            // that it's correctly shared between the SSR and final worker builds.
+            log("Resolving %s module", config.virtualModuleName);
+            const envName = this.environment?.name;
+            // 1. Worker Pass -> externalize
+            if (isDev &&
+                envName === "worker" &&
+                process.env.RWSDK_BUILD_PASS === "worker") {
+                // context(justinvdm, 3 Sep 2025): We externalize the lookup during the
+                // first worker pass. This defers its bundling until after the
+                // directivesFilteringPlugin has had a chance to run and tree-shake
+                // the list of client/server files.
+                log("Marking as external for worker pass");
+                return { id: source, external: true };
+            }
+            // 2. SSR Pass -> externalize
+            if (isDev && envName === "ssr") {
+                // context(justinvdm, 3 Sep 2025): We also externalize during the SSR
+                // build. This ensures that both the worker and SSR artifacts refer to
+                // the same virtual module, which will be resolved into a single, shared
+                // lookup map during the final linker pass.
+                log("Marking as external for ssr pass");
+                return { id: source, external: true };
+            }
+            // 3. Client Pass & 4. Linker Pass -> resolve and bundle
+            // context(justinvdm, 3 Sep 2025): For the client build, the dev server,
+            // and the final linker pass, we resolve the module ID with a null-byte
+            // prefix. This signals to Vite/Rollup that this is a virtual module
+            // whose content should be provided by the `load` hook, bundling it in.
+            log("Resolving for bundling");
+            return source;
         },
         async load(id) {
-            process.env.VERBOSE && log("Loading id=%s", id);
             if (id === config.virtualModuleName + ".js") {
                 log("Loading %s module with %d files", config.virtualModuleName, files.size);
                 const environment = this.environment?.name || "client";
                 log("Current environment: %s, isDev: %s", environment, isDev);
-                const optimizedDeps = {};
-                if (isDev && devServer) {
-                    for (const file of files) {
-                        const resolvedPath = await resolveOptimizedDep(projectRootDir, file, environment, debugNamespace);
-                        if (resolvedPath) {
-                            optimizedDeps[file] = resolvedPath;
-                        }
-                    }
-                }
                 const s = new MagicString(`
 export const ${config.exportName} = {
   ${Array.from(files)
-                    .map((file) => `
-  "${file}": () => import("${optimizedDeps[file] ?? file}"),
-`)
+                    .map((file) => {
+                    if (file.includes("node_modules") && isDev) {
+                        const barrelPath = config.kind === "client"
+                            ? "rwsdk/__client_barrel"
+                            : "rwsdk/__server_barrel";
+                        return `
+  "${file}": () => import("${barrelPath}").then(m => m.default["${file}"]),
+`;
+                    }
+                    else {
+                        return `
+  "${file}": () => import("${file}"),
+`;
+                    }
+                })
                     .join("")}
 };
 `);
@@ -225,7 +142,6 @@ export const ${config.exportName} = {
                     map,
                 };
             }
-            process.env.VERBOSE && log("No load handling for id=%s", id);
         },
     };
 };

package/dist/vite/directiveModulesDevPlugin.d.mts

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

package/dist/vite/directiveModulesDevPlugin.mjs

@@ -0,0 +1,62 @@
+import path from "node:path";
+import { writeFileSync, mkdirSync } from "node:fs";
+import { normalizeModulePath } from "../lib/normalizeModulePath.mjs";
+import { runDirectivesScan } from "./runDirectivesScan.mjs";
+import { CLIENT_BARREL_PATH } from "../lib/constants.mjs";
+import { SERVER_BARREL_PATH } from "../lib/constants.mjs";
+export const VIRTUAL_CLIENT_BARREL_ID = "virtual:rwsdk:client-module-barrel";
+export const VIRTUAL_SERVER_BARREL_ID = "virtual:rwsdk:server-module-barrel";
+const CLIENT_BARREL_EXPORT_PATH = "rwsdk/__client_barrel";
+const SERVER_BARREL_EXPORT_PATH = "rwsdk/__server_barrel";
+const generateBarrelContent = (files, projectRootDir) => {
+    const imports = [...files]
+        .filter((file) => file.includes("node_modules"))
+        .map((file, i) => `import * as M${i} from '${normalizeModulePath(file, projectRootDir, {
+        absolute: true,
+    })}';`)
+        .join("\n");
+    const exports = "export default {\n" +
+        [...files]
+            .filter((file) => file.includes("node_modules"))
+            .map((file, i) => `  '${normalizeModulePath(file, projectRootDir)}': M${i},`)
+            .join("\n") +
+        "\n};";
+    return `${imports}\n\n${exports}`;
+};
+export const directiveModulesDevPlugin = ({ clientFiles, serverFiles, projectRootDir, }) => {
+    return {
+        name: "rwsdk:directive-modules-dev",
+        enforce: "pre",
+        async configResolved(config) {
+            if (config.command !== "serve") {
+                return;
+            }
+            const workerEnv = config.environments["worker"];
+            if (workerEnv) {
+                await runDirectivesScan({
+                    rootConfig: config,
+                    envName: "worker",
+                    clientFiles,
+                    serverFiles,
+                });
+            }
+            // Generate the barrel content and write it to the dummy files.
+            // We can do this now because our scan is complete.
+            const clientBarrelContent = generateBarrelContent(clientFiles, projectRootDir);
+            const serverBarrelContent = generateBarrelContent(serverFiles, projectRootDir);
+            mkdirSync(path.dirname(CLIENT_BARREL_PATH), { recursive: true });
+            writeFileSync(CLIENT_BARREL_PATH, clientBarrelContent);
+            mkdirSync(path.dirname(SERVER_BARREL_PATH), { recursive: true });
+            writeFileSync(SERVER_BARREL_PATH, serverBarrelContent);
+            for (const [envName, env] of Object.entries(config.environments)) {
+                if (envName === "client" || envName === "ssr") {
+                    env.optimizeDeps.include = [
+                        ...(env.optimizeDeps.include || []),
+                        CLIENT_BARREL_EXPORT_PATH,
+                        SERVER_BARREL_EXPORT_PATH,
+                    ];
+                }
+            }
+        },
+    };
+};

package/dist/vite/directivesFilteringPlugin.d.mts

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

package/dist/vite/directivesFilteringPlugin.mjs

@@ -0,0 +1,31 @@
+import debug from "debug";
+import { normalizeModulePath } from "../lib/normalizeModulePath.mjs";
+const log = debug("rwsdk:vite:directives-filtering-plugin");
+export const directivesFilteringPlugin = ({ clientFiles, serverFiles, projectRootDir, }) => {
+    return {
+        name: "rwsdk:directives-filtering",
+        enforce: "post",
+        async buildEnd() {
+            if (this.environment.name !== "worker" ||
+                process.env.RWSDK_BUILD_PASS !== "worker") {
+                return;
+            }
+            log("Filtering directive modules after worker build...");
+            process.env.VERBOSE &&
+                log("Directive modules before filtering: client=%O, server=%O", Array.from(clientFiles), Array.from(serverFiles));
+            [clientFiles, serverFiles].forEach((files) => {
+                for (const id of files) {
+                    const absoluteId = normalizeModulePath(id, projectRootDir, {
+                        absolute: true,
+                    });
+                    const info = this.getModuleInfo(absoluteId);
+                    if (!info?.isIncluded) {
+                        files.delete(id);
+                    }
+                }
+            });
+            process.env.VERBOSE &&
+                log("Client/server files after filtering: client=%O, server=%O", Array.from(clientFiles), Array.from(serverFiles));
+        },
+    };
+};