rwsdk 1.0.0-beta.3 → 1.0.0-beta.30

package/dist/vite/buildApp.mjs

@@ -1,5 +1,8 @@
 import debug from "debug";
-import { resolve } from "node:path";
+import { existsSync } from "node:fs";
+import { mkdir, rm, writeFile } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import { INTERMEDIATES_OUTPUT_DIR } from "../lib/constants.mjs";
 import { runDirectivesScan } from "./runDirectivesScan.mjs";
 const log = debug("rwsdk:vite:build-app");
 /**
@@ -10,7 +13,36 @@ const log = debug("rwsdk:vite:build-app");
  * @see docs/architecture/productionBuildProcess.md
  */
 export async function buildApp({ builder, clientEntryPoints, clientFiles, serverFiles, projectRootDir, workerEntryPathname, }) {
+    await rm(resolve(projectRootDir, "dist"), { recursive: true, force: true });
     const workerEnv = builder.environments.worker;
+    // Run a pre-scan build pass to allow plugins to set up and generate code
+    // before scanning.
+    console.log("Running plugin setup pass...");
+    process.env.RWSDK_BUILD_PASS = "plugin-setup";
+    const tempEntryPath = resolve(INTERMEDIATES_OUTPUT_DIR, "temp-entry.js");
+    try {
+        if (!existsSync(dirname(tempEntryPath))) {
+            await mkdir(dirname(tempEntryPath), { recursive: true });
+        }
+        await writeFile(tempEntryPath, "");
+        const originalWorkerBuildConfig = workerEnv.config.build;
+        workerEnv.config.build = {
+            ...originalWorkerBuildConfig,
+            write: false,
+            rollupOptions: {
+                ...originalWorkerBuildConfig?.rollupOptions,
+                input: {
+                    index: tempEntryPath,
+                },
+            },
+        };
+        await builder.build(workerEnv);
+        // Restore the original config
+        workerEnv.config.build = originalWorkerBuildConfig;
+    }
+    finally {
+        await rm(tempEntryPath, { force: true });
+    }
     await runDirectivesScan({
         rootConfig: builder.config,
         environments: builder.environments,
@@ -18,7 +50,7 @@ export async function buildApp({ builder, clientEntryPoints, clientFiles, server
         serverFiles,
         entries: [workerEntryPathname],
     });
-    console.log("Building worker to discover used client components...");
+    console.log("Building worker...");
     process.env.RWSDK_BUILD_PASS = "worker";
     await builder.build(workerEnv);
     log("Used client files after worker build & filtering: %O", Array.from(clientFiles));

package/dist/vite/configPlugin.mjs

@@ -3,6 +3,7 @@ import path, { resolve } from "node:path";
 import { INTERMEDIATE_SSR_BRIDGE_PATH } from "../lib/constants.mjs";
 import { buildApp } from "./buildApp.mjs";
 import { externalModules } from "./constants.mjs";
+import { ssrBridgeWrapPlugin } from "./ssrBridgeWrapPlugin.mjs";
 export const configPlugin = ({ silent, projectRootDir, workerEntryPathname, clientFiles, serverFiles, clientEntryPoints, }) => ({
     name: "rwsdk:config",
     config: async (_, { command }) => {
@@ -93,6 +94,7 @@ export const configPlugin = ({ silent, projectRootDir, workerEntryPathname, clie
                             "rwsdk/constants",
                             "rwsdk/debug",
                             "rwsdk/realtime/client",
+                            "rwsdk/router",
                             "rwsdk/turnstile",
                         ],
                         entries: [],
@@ -161,22 +163,14 @@ export const configPlugin = ({ silent, projectRootDir, workerEntryPathname, clie
                                 // causes a redeclaration error. To solve this, we wrap the SSR
                                 // bundle in an exporting IIFE. This creates a scope boundary,
                                 // preventing symbol collisions while producing a valid,
-                                // tree-shakeable ES module. The inline plugin below removes the
-                                // original `export` statement from the bundle to prevent syntax
-                                // errors.
+                                // tree-shakeable ES module.
+                                //
+                                // context(justinvdm, 19 Nov 2025): We use a custom plugin
+                                // (ssrBridgeWrapPlugin) to intelligently inject the IIFE *after*
+                                // any top-level external imports, ensuring they remain valid.
                                 inlineDynamicImports: true,
-                                banner: `export const { renderHtmlStream, ssrLoadModule, ssrWebpackRequire, ssrGetModuleExport, createThenableFromReadableStream } = (function() {`,
-                                footer: `return { renderHtmlStream, ssrLoadModule, ssrWebpackRequire, ssrGetModuleExport, createThenableFromReadableStream };\n})();`,
                             },
-                            plugins: [
-                                {
-                                    name: "rwsdk:ssr-bridge-exports",
-                                    renderChunk(code) {
-                                        // Remove the original export statement as it's now handled by the banner/footer
-                                        return code.replace(/export\s*{[^}]+};?/, "");
-                                    },
-                                },
-                            ],
+                            plugins: [ssrBridgeWrapPlugin()],
                         },
                     },
                 },

package/dist/vite/constants.d.mts

@@ -1,2 +1,3 @@
 export declare const cloudflareBuiltInModules: string[];
 export declare const externalModules: string[];
+export declare const externalModulesSet: Set<string>;

package/dist/vite/constants.mjs

@@ -10,3 +10,4 @@ export const externalModules = [
     ...builtinModules,
     ...builtinModules.map((m) => `node:${m}`),
 ];
+export const externalModulesSet = new Set(externalModules);

package/dist/vite/directiveModulesDevPlugin.mjs

@@ -38,7 +38,7 @@ export const directiveModulesDevPlugin = ({ clientFiles, serverFiles, projectRoo
     return {
         name: "rwsdk:directive-modules-dev",
         configureServer(server) {
-            if (!process.env.VITE_IS_DEV_SERVER || process.env.RWSDK_WORKER_RUN) {
+            if (!process.env.VITE_IS_DEV_SERVER) {
                 resolveScanPromise();
                 return;
             }

package/dist/vite/envResolvers.d.mts

@@ -0,0 +1,11 @@
+import enhancedResolve from "enhanced-resolve";
+export declare const ENV_RESOLVERS: {
+    ssr: enhancedResolve.ResolveFunction;
+    worker: enhancedResolve.ResolveFunction;
+    client: enhancedResolve.ResolveFunction;
+};
+export declare const maybeResolveEnvImport: ({ id, envName, projectRootDir, }: {
+    id: string;
+    envName: keyof typeof ENV_RESOLVERS;
+    projectRootDir: string;
+}) => string | undefined;

package/dist/vite/envResolvers.mjs

@@ -0,0 +1,20 @@
+import enhancedResolve from "enhanced-resolve";
+export const ENV_RESOLVERS = {
+    ssr: enhancedResolve.create.sync({
+        conditionNames: ["workerd", "worker", "edge", "default"],
+    }),
+    worker: enhancedResolve.create.sync({
+        conditionNames: ["react-server", "workerd", "worker", "edge", "default"],
+    }),
+    client: enhancedResolve.create.sync({
+        conditionNames: ["browser", "default"],
+    }),
+};
+export const maybeResolveEnvImport = ({ id, envName, projectRootDir, }) => {
+    try {
+        return ENV_RESOLVERS[envName](projectRootDir, id) || undefined;
+    }
+    catch (error) {
+        return undefined;
+    }
+};

package/dist/vite/getViteEsbuild.mjs

@@ -1,5 +1,6 @@
 import { createRequire } from "node:module";
 import path from "node:path";
+import { pathToFileURL } from "node:url";
 const require = createRequire(import.meta.url);
 export async function getViteEsbuild(projectRootDir) {
     const vitePath = require.resolve("vite/package.json", {
@@ -7,6 +8,6 @@ export async function getViteEsbuild(projectRootDir) {
     });
     const viteDir = path.dirname(vitePath);
     const esbuildPath = require.resolve("esbuild", { paths: [viteDir] });
-    const esbuildModule = await import(esbuildPath);
+    const esbuildModule = await import(pathToFileURL(esbuildPath).href);
     return esbuildModule.default || esbuildModule;
 }

package/dist/vite/hmrStabilityPlugin.d.mts

@@ -0,0 +1,2 @@
+import { type Plugin } from "vite";
+export declare function hmrStabilityPlugin(): Plugin;

package/dist/vite/hmrStabilityPlugin.mjs

@@ -0,0 +1,68 @@
+import debug from "debug";
+const log = debug("rws-vite-plugin:hmr-stability");
+let stabilityPromise = null;
+let stabilityResolver = null;
+let debounceTimer = null;
+const DEBOUNCE_MS = 500;
+function startWaitingForStability() {
+    if (!stabilityPromise) {
+        log("Starting to wait for server stability...");
+        stabilityPromise = new Promise((resolve) => {
+            stabilityResolver = resolve;
+        });
+        // Start the timer. If it fires, we're stable.
+        debounceTimer = setTimeout(finishWaiting, DEBOUNCE_MS);
+    }
+}
+function activityDetected() {
+    if (stabilityPromise) {
+        // If we're waiting for stability, reset the timer.
+        log("Activity detected, resetting stability timer.");
+        if (debounceTimer)
+            clearTimeout(debounceTimer);
+        debounceTimer = setTimeout(finishWaiting, DEBOUNCE_MS);
+    }
+}
+function finishWaiting() {
+    if (stabilityResolver) {
+        log("Server appears stable. Resolving promise.");
+        stabilityResolver();
+    }
+    stabilityPromise = null;
+    stabilityResolver = null;
+    debounceTimer = null;
+}
+export function hmrStabilityPlugin() {
+    return {
+        name: "rws-vite-plugin:hmr-stability",
+        // Monitor server activity
+        transform() {
+            activityDetected();
+            return null;
+        },
+        configureServer(server) {
+            // Return a function to ensure our middleware is placed after internal middlewares
+            return () => {
+                server.middlewares.use(async function rwsdkStaleBundleErrorHandler(err, req, res, next) {
+                    if (err &&
+                        typeof err.message === "string" &&
+                        err.message.includes("new version of the pre-bundle")) {
+                        log("Caught stale pre-bundle error. Waiting for server to stabilize...");
+                        startWaitingForStability();
+                        await stabilityPromise;
+                        log("Server stabilized. Sending full-reload and redirecting.");
+                        // Signal the client to do a full page reload.
+                        server.environments.client.hot.send({
+                            type: "full-reload",
+                        });
+                        // No need to wait further here, the stability promise handled it.
+                        res.writeHead(307, { Location: req.url });
+                        res.end();
+                        return;
+                    }
+                    next(err);
+                });
+            };
+        },
+    };
+}

package/dist/vite/knownDepsResolverPlugin.d.mts

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

package/dist/vite/knownDepsResolverPlugin.mjs

@@ -1,7 +1,7 @@
 import debug from "debug";
-import enhancedResolve from "enhanced-resolve";
 import { ROOT_DIR } from "../lib/constants.mjs";
 import { ensureAliasArray } from "./ensureAliasArray.mjs";
+import { ENV_RESOLVERS } from "./envResolvers.mjs";
 const log = debug("rwsdk:vite:known-deps-resolver-plugin");
 const KNOWN_PREFIXES = [
     "react",
@@ -36,17 +36,6 @@ export const ENV_PREDEFINED_IMPORTS = {
         "react-server-dom-webpack/client.edge",
     ],
 };
-export const ENV_RESOLVERS = {
-    ssr: enhancedResolve.create.sync({
-        conditionNames: ["workerd", "worker", "edge", "default"],
-    }),
-    worker: enhancedResolve.create.sync({
-        conditionNames: ["react-server", "workerd", "worker", "edge", "default"],
-    }),
-    client: enhancedResolve.create.sync({
-        conditionNames: ["browser", "default"],
-    }),
-};
 function resolveKnownImport(id, envName, projectRootDir, isPrefixedImport = false) {
     if (!isPrefixedImport) {
         const isKnownImport = KNOWN_PREFIXES.some((prefix) => id === prefix || id.startsWith(`${prefix}/`));

package/dist/vite/linkerPlugin.d.mts

@@ -1,8 +1,9 @@
 import type { Plugin } from "vite";
-export declare function linkWorkerBundle({ code, manifestContent, projectRootDir, }: {
+export declare function linkWorkerBundle({ code, manifestContent, projectRootDir, base, }: {
     code: string;
     manifestContent: string;
     projectRootDir: string;
+    base?: string;
 }): {
     code: string;
     map: null;

package/dist/vite/linkerPlugin.mjs

@@ -4,19 +4,22 @@ import path from "node:path";
 import { CLIENT_MANIFEST_RELATIVE_PATH } from "../lib/constants.mjs";
 import { normalizeModulePath } from "../lib/normalizeModulePath.mjs";
 const log = debug("rwsdk:vite:linker-plugin");
-export function linkWorkerBundle({ code, manifestContent, projectRootDir, }) {
+export function linkWorkerBundle({ code, manifestContent, projectRootDir, base, }) {
     let newCode = code;
     const manifest = JSON.parse(manifestContent);
     // 1. Replace the manifest placeholder with the actual manifest content.
     log("Injecting manifest into worker bundle");
-    newCode = newCode.replace('"__RWSDK_MANIFEST_PLACEHOLDER__"', manifestContent);
+    newCode = newCode.replace(/['"]__RWSDK_MANIFEST_PLACEHOLDER__['"]/, manifestContent);
     // 2. Replace asset placeholders with their final hashed paths.
     log("Replacing asset placeholders in final worker bundle");
     for (const [key, value] of Object.entries(manifest)) {
         const normalizedKey = normalizeModulePath(key, projectRootDir, {
             isViteStyle: false,
         });
-        newCode = newCode.replaceAll(`rwsdk_asset:${normalizedKey}`, `/${value.file}`);
+        // If base is provided, prepend it with the final hashed path.
+        // Base is assumed to have a trailing "/".
+        const assetPath = (base ? base : "/") + value.file;
+        newCode = newCode.replaceAll(`rwsdk_asset:${normalizedKey}`, assetPath);
     }
     // 3. Deprefix any remaining placeholders that were not in the manifest.
     // This handles public assets that don't go through the bundler.
@@ -28,8 +31,12 @@ export function linkWorkerBundle({ code, manifestContent, projectRootDir, }) {
     };
 }
 export const linkerPlugin = ({ projectRootDir, }) => {
+    let config;
     return {
         name: "rwsdk:linker",
+        configResolved(resolvedConfig) {
+            config = resolvedConfig;
+        },
         async renderChunk(code) {
             if (this.environment.name !== "worker" ||
                 process.env.RWSDK_BUILD_PASS !== "linker") {
@@ -41,6 +48,7 @@ export const linkerPlugin = ({ projectRootDir, }) => {
                 code,
                 manifestContent,
                 projectRootDir,
+                base: config.base,
             });
             log("Final worker chunk rendered");
             return result;

package/dist/vite/linkerPlugin.test.mjs

@@ -29,6 +29,21 @@ describe("linkWorkerBundle", () => {
         expect(result.code).toContain(`const stylesheet = "/assets/styles.123.css";`);
         expect(result.code).toContain(`const logo = "/assets/logo.abc.svg";`);
     });
+    it("should replace asset placeholder with a base + hashed paths from the manifest if base is provided", () => {
+        const code = `
+      const stylesheet = "rwsdk_asset:/src/styles.css";
+      const logo = "rwsdk_asset:/src/logo.svg";
+    `;
+        const base = "/base/";
+        const result = linkWorkerBundle({
+            code,
+            manifestContent,
+            projectRootDir,
+            base,
+        });
+        expect(result.code).toContain(`const stylesheet = "/base/assets/styles.123.css";`);
+        expect(result.code).toContain(`const logo = "/base/assets/logo.abc.svg";`);
+    });
     it("should deprefix remaining asset placeholders not in the manifest", () => {
         const code = `const publicImg = "rwsdk_asset:/images/photo.jpg";`;
         const result = linkWorkerBundle({

package/dist/vite/miniflareHMRPlugin.mjs

@@ -33,25 +33,6 @@ export const hasEntryAsAncestor = ({ module, entryFile, seen = new Set(), }) =>
     }
     return false;
 };
-const isInUseClientGraph = ({ file, clientFiles, server, }) => {
-    const id = normalizeModulePath(file, server.config.root);
-    if (clientFiles.has(id)) {
-        return true;
-    }
-    const modules = server.environments.client.moduleGraph.getModulesByFile(file);
-    if (!modules) {
-        return false;
-    }
-    for (const m of modules) {
-        for (const importer of m.importers) {
-            if (importer.file &&
-                isInUseClientGraph({ file: importer.file, clientFiles, server })) {
-                return true;
-            }
-        }
-    }
-    return false;
-};
 export const miniflareHMRPlugin = (givenOptions) => [
     {
         name: "rwsdk:miniflare-hmr",
@@ -93,15 +74,6 @@ export const miniflareHMRPlugin = (givenOptions) => [
             }
             if (this.environment.name === "ssr") {
                 log("SSR update, invalidating recursively", ctx.file);
-                const isUseClientUpdate = isInUseClientGraph({
-                    file: ctx.file,
-                    clientFiles,
-                    server: ctx.server,
-                });
-                if (!isUseClientUpdate) {
-                    log("hmr: not a use client update, short circuiting");
-                    return [];
-                }
                 invalidateModule(ctx.server, "ssr", ctx.file);
                 invalidateModule(ctx.server, environment, VIRTUAL_SSR_PREFIX +
                     normalizeModulePath(ctx.file, givenOptions.rootDir));
@@ -166,21 +138,12 @@ export const miniflareHMRPlugin = (givenOptions) => [
                         }
                     }
                 }
-                const isUseClientUpdate = isInUseClientGraph({
-                    file: ctx.file,
-                    clientFiles,
-                    server: ctx.server,
-                });
-                if (!isUseClientUpdate && !ctx.file.endsWith(".css")) {
-                    log("hmr: not a use client update and not css, short circuiting");
-                    return [];
-                }
-                log("hmr: returning client modules for hmr");
                 return ctx.modules;
             }
             // The worker needs an update, and the hot check is for the worker environment
             // => Notify for custom RSC-based HMR update, then short circuit HMR
             if (isWorkerUpdate && this.environment.name === environment) {
+                invalidateModule(ctx.server, environment, ctx.file);
                 const shortName = getShortName(ctx.file, ctx.server.config.root);
                 this.environment.logger.info(`${colors.green(`worker update`)} ${colors.dim(shortName)}`, {
                     clear: true,

package/dist/vite/moveStaticAssetsPlugin.mjs

@@ -1,13 +1,23 @@
-import { $sh } from "../lib/$.mjs";
+import path from "node:path";
+import fs from "fs-extra";
+import { glob } from "glob";
 export const moveStaticAssetsPlugin = ({ rootDir, }) => ({
     name: "rwsdk:move-static-assets",
     apply: "build",
     async closeBundle() {
         if (this.environment.name === "worker" &&
             process.env.RWSDK_BUILD_PASS === "linker") {
-            await $sh({
-                cwd: rootDir,
-            }) `mv dist/worker/assets/*.css dist/client/assets/ || true`;
+            const sourceDir = path.join(rootDir, "dist", "worker", "assets");
+            const destDir = path.join(rootDir, "dist", "client", "assets");
+            const cssFiles = await glob("*.css", { cwd: sourceDir });
+            if (cssFiles.length > 0) {
+                await fs.ensureDir(destDir);
+                for (const file of cssFiles) {
+                    const sourceFile = path.join(sourceDir, file);
+                    const destFile = path.join(destDir, file);
+                    await fs.move(sourceFile, destFile, { overwrite: true });
+                }
+            }
         }
     },
 });

package/dist/vite/redwoodPlugin.mjs

@@ -18,12 +18,13 @@ 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 { staleDepRetryPlugin } from "./staleDepRetryPlugin.mjs";
+import { statePlugin } from "./statePlugin.mjs";
 import { transformJsxScriptTagsPlugin } from "./transformJsxScriptTagsPlugin.mjs";
 import { useClientLookupPlugin } from "./useClientLookupPlugin.mjs";
 import { useServerLookupPlugin } from "./useServerLookupPlugin.mjs";
@@ -74,17 +75,15 @@ export const redwoodPlugin = async (options = {}) => {
     // context(justinvdm, 31 Mar 2025): We assume that if there is no .wrangler directory,
     // then this is fresh install, and we run `npm run dev:init` here.
     if (process.env.RWSDK_WORKER_RUN !== "1" &&
-        process.env.RWSDK_DEPLOY !== "1" &&
+        process.env.NODE_ENV !== "production" &&
         !(await pathExists(resolve(projectRootDir, ".wrangler"))) &&
         (await hasPkgScript(projectRootDir, "dev:init"))) {
         console.log("🚀 Project has no .wrangler directory yet, assuming fresh install: running `npm run dev:init`...");
-        await $({
-            // context(justinvdm, 01 Apr 2025): We want to avoid interactive migration y/n prompt, so we ignore stdin
-            // as a signal to operate in no-tty mode
-            stdio: ["ignore", "inherit", "inherit"],
-        }) `npm run dev:init`;
+        await $ `npm run dev:init`;
     }
     return [
+        staleDepRetryPlugin(),
+        statePlugin({ projectRootDir }),
         devServerTimingPlugin(),
         devServerConstantPlugin(),
         directiveModulesDevPlugin({
@@ -144,9 +143,6 @@ export const redwoodPlugin = async (options = {}) => {
             clientEntryPoints,
             projectRootDir,
         }),
-        manifestPlugin({
-            projectRootDir,
-        }),
         moveStaticAssetsPlugin({ rootDir: projectRootDir }),
         prismaPlugin({ projectRootDir }),
         linkerPlugin({ projectRootDir }),

package/dist/vite/runDirectivesScan.mjs

@@ -1,6 +1,7 @@
 // @ts-ignore
 import { compile } from "@mdx-js/mdx";
 import debug from "debug";
+import { glob } from "glob";
 import fsp from "node:fs/promises";
 import path from "node:path";
 import { INTERMEDIATES_OUTPUT_DIR } from "../lib/constants.mjs";
@@ -17,6 +18,39 @@ const isObject = (value) => Object.prototype.toString.call(value) === "[object O
 // https://github.com/vitejs/vite/blob/main/packages/vite/src/node/utils.ts
 const externalRE = /^(https?:)?\/\//;
 const isExternalUrl = (url) => externalRE.test(url);
+async function findDirectiveRoots({ root, readFileWithCache, directiveCheckCache, }) {
+    const srcDir = path.resolve(root, "src");
+    const files = await glob("**/*.{ts,tsx,js,jsx,mjs,mts,cjs,cts,mdx}", {
+        cwd: srcDir,
+        absolute: true,
+    });
+    const directiveFiles = new Set();
+    for (const file of files) {
+        if (directiveCheckCache.has(file)) {
+            if (directiveCheckCache.get(file)) {
+                directiveFiles.add(file);
+            }
+            continue;
+        }
+        try {
+            const content = await readFileWithCache(file);
+            const hasClient = hasDirective(content, "use client");
+            const hasServer = hasDirective(content, "use server");
+            const hasAnyDirective = hasClient || hasServer;
+            directiveCheckCache.set(file, hasAnyDirective);
+            if (hasAnyDirective) {
+                directiveFiles.add(file);
+            }
+        }
+        catch (e) {
+            log("Could not read file during pre-scan, skipping:", file);
+            // Cache the failure to avoid re-reading a problematic file
+            directiveCheckCache.set(file, false);
+        }
+    }
+    log("Pre-scan found directive files:", Array.from(directiveFiles));
+    return directiveFiles;
+}
 export async function resolveModuleWithEnvironment({ path, importer, importerEnv, clientResolver, workerResolver, }) {
     const resolver = importerEnv === "client" ? clientResolver : workerResolver;
     return new Promise((resolvePromise) => {
@@ -56,6 +90,16 @@ export const runDirectivesScan = async ({ rootConfig, environments, clientFiles,
     // Set environment variable to indicate scanning is in progress
     process.env.RWSDK_DIRECTIVE_SCAN_ACTIVE = "true";
     try {
+        const fileContentCache = new Map();
+        const directiveCheckCache = new Map();
+        const readFileWithCache = async (path) => {
+            if (fileContentCache.has(path)) {
+                return fileContentCache.get(path);
+            }
+            const contents = await fsp.readFile(path, "utf-8");
+            fileContentCache.set(path, contents);
+            return contents;
+        };
         const esbuild = await getViteEsbuild(rootConfig.root);
         const input = initialEntries ?? environments.worker.config.build.rollupOptions?.input;
         let entries;
@@ -78,19 +122,19 @@ export const runDirectivesScan = async ({ rootConfig, environments, clientFiles,
         // Filter out virtual modules since they can't be scanned by esbuild
         const realEntries = entries.filter((entry) => !entry.includes("virtual:"));
         const absoluteEntries = realEntries.map((entry) => path.resolve(rootConfig.root, entry));
-        log("Starting directives scan for worker environment with entries:", absoluteEntries);
+        const applicationDirectiveFiles = await findDirectiveRoots({
+            root: rootConfig.root,
+            readFileWithCache,
+            directiveCheckCache,
+        });
+        const combinedEntries = new Set([
+            ...absoluteEntries,
+            ...applicationDirectiveFiles,
+        ]);
+        log("Starting directives scan with combined entries:", Array.from(combinedEntries));
         const workerResolver = createViteAwareResolver(rootConfig, environments.worker);
         const clientResolver = createViteAwareResolver(rootConfig, environments.client);
         const moduleEnvironments = new Map();
-        const fileContentCache = new Map();
-        const readFileWithCache = async (path) => {
-            if (fileContentCache.has(path)) {
-                return fileContentCache.get(path);
-            }
-            const contents = await fsp.readFile(path, "utf-8");
-            fileContentCache.set(path, contents);
-            return contents;
-        };
         const esbuildScanPlugin = {
             name: "rwsdk:esbuild-scan-plugin",
             setup(build) {
@@ -166,11 +210,11 @@ export const runDirectivesScan = async ({ rootConfig, environments, clientFiles,
                 });
                 build.onLoad({ filter: /\.(m|c)?[jt]sx?$|\.mdx$/ }, async (args) => {
                     log("onLoad called for:", args.path);
-                    if (!args.path.startsWith("/") ||
+                    if (!path.isAbsolute(args.path) ||
                         args.path.includes("virtual:") ||
                         isExternalUrl(args.path)) {
                         log("Skipping file due to filter:", args.path, {
-                            startsWithSlash: args.path.startsWith("/"),
+                            isAbsolute: path.isAbsolute(args.path),
                             hasVirtual: args.path.includes("virtual:"),
                             isExternal: isExternalUrl(args.path),
                         });
@@ -232,7 +276,7 @@ export const runDirectivesScan = async ({ rootConfig, environments, clientFiles,
             },
         };
         await esbuild.build({
-            entryPoints: absoluteEntries,
+            entryPoints: Array.from(combinedEntries),
             bundle: true,
             write: false,
             outdir: path.join(INTERMEDIATES_OUTPUT_DIR, "directive-scan"),
@@ -254,7 +298,8 @@ export const runDirectivesScan = async ({ rootConfig, environments, clientFiles,
     }
 };
 const deferredLog = (message) => {
+    const doLog = process.env.RWSDK_WORKER_RUN ? log : console.log;
     setTimeout(() => {
-        console.log(message);
+        doLog(message);
     }, 500);
 };