rwsdk 0.3.0 → 0.3.2

package/dist/vite/buildApp.mjs

@@ -10,14 +10,14 @@ const log = debug("rwsdk:vite:build-app");
  * @see docs/architecture/productionBuildProcess.md
  */
 export async function buildApp({ builder, clientEntryPoints, clientFiles, serverFiles, projectRootDir, }) {
+    const workerEnv = builder.environments.worker;
     await runDirectivesScan({
         rootConfig: builder.config,
-        envName: "worker",
+        environment: workerEnv,
         clientFiles,
         serverFiles,
     });
     console.log("Building worker to discover used client components...");
-    const workerEnv = builder.environments.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.d.mts

@@ -1,6 +1,4 @@
 import { Plugin } from "vite";
-export declare const cloudflareBuiltInModules: string[];
-export declare const externalModules: string[];
 export declare const configPlugin: ({ silent, projectRootDir, workerEntryPathname, clientFiles, serverFiles, clientEntryPoints, }: {
     silent: boolean;
     projectRootDir: string;

package/dist/vite/configPlugin.mjs

@@ -1,23 +1,10 @@
 import path, { resolve } from "node:path";
-import { builtinModules } from "node:module";
 import enhancedResolve from "enhanced-resolve";
 import debug from "debug";
 import { INTERMEDIATE_SSR_BRIDGE_PATH } from "../lib/constants.mjs";
 import { buildApp } from "./buildApp.mjs";
+import { externalModules } from "./constants.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 = [
-    "cloudflare:email",
-    "cloudflare:sockets",
-    "cloudflare:workers",
-    "cloudflare:workflows",
-];
-export const externalModules = [
-    ...cloudflareBuiltInModules,
-    ...builtinModules,
-    ...builtinModules.map((m) => `node:${m}`),
-];
 export const configPlugin = ({ silent, projectRootDir, workerEntryPathname, clientFiles, serverFiles, clientEntryPoints, }) => ({
     name: "rwsdk:config",
     config: async (_) => {

package/dist/vite/constants.d.mts

@@ -0,0 +1,2 @@
+export declare const cloudflareBuiltInModules: string[];
+export declare const externalModules: string[];

package/dist/vite/constants.mjs

@@ -0,0 +1,12 @@
+import { builtinModules } from "node:module";
+export const cloudflareBuiltInModules = [
+    "cloudflare:email",
+    "cloudflare:sockets",
+    "cloudflare:workers",
+    "cloudflare:workflows",
+];
+export const externalModules = [
+    ...cloudflareBuiltInModules,
+    ...builtinModules,
+    ...builtinModules.map((m) => `node:${m}`),
+];

package/dist/vite/createDirectiveLookupPlugin.mjs

@@ -70,6 +70,10 @@ export const createDirectiveLookupPlugin = async ({ projectRootDir, files, confi
             }
         },
         resolveId(source) {
+            // Skip during directive scanning to avoid performance issues
+            if (process.env.RWSDK_DIRECTIVE_SCAN_ACTIVE) {
+                return;
+            }
             if (source !== `${config.virtualModuleName}.js`) {
                 return null;
             }
@@ -108,6 +112,10 @@ export const createDirectiveLookupPlugin = async ({ projectRootDir, files, confi
             return source;
         },
         async load(id) {
+            // Skip during directive scanning to avoid performance issues
+            if (process.env.RWSDK_DIRECTIVE_SCAN_ACTIVE) {
+                return;
+            }
             if (id === config.virtualModuleName + ".js") {
                 log("Loading %s module with %d files", config.virtualModuleName, files.size);
                 const environment = this.environment?.name || "client";

package/dist/vite/createViteAwareResolver.d.mts

@@ -0,0 +1,4 @@
+import resolve, { ResolveOptions } from "enhanced-resolve";
+import { ResolvedConfig } from "vite";
+export declare const mapViteResolveToEnhancedResolveOptions: (viteConfig: ResolvedConfig, envName: string) => ResolveOptions;
+export declare const createViteAwareResolver: (viteConfig: ResolvedConfig, envName: string, environment?: any) => resolve.ResolveFunctionAsync;

package/dist/vite/createViteAwareResolver.mjs

@@ -0,0 +1,257 @@
+import resolve from "enhanced-resolve";
+import fs from "fs";
+import path from "path";
+import createDebug from "debug";
+import { normalizeModulePath } from "../lib/normalizeModulePath.mjs";
+const debug = createDebug("rwsdk:vite:enhanced-resolve-plugin");
+// Enhanced-resolve plugin that wraps Vite plugin resolution
+class VitePluginResolverPlugin {
+    constructor(environment, source = "resolve", target = "resolved") {
+        this.environment = environment;
+        this.source = source;
+        this.target = target;
+        // Create an enhanced-resolve instance for the plugin context
+        const baseOptions = mapViteResolveToEnhancedResolveOptions(this.environment.config, this.environment.name);
+        this.enhancedResolver = resolve.create(baseOptions);
+    }
+    apply(resolver) {
+        const target = resolver.ensureHook(this.target);
+        resolver
+            .getHook(this.source)
+            .tapAsync("VitePluginResolverPlugin", (request, resolveContext, callback) => {
+            const plugins = this.environment?.plugins;
+            if (!plugins) {
+                return callback();
+            }
+            // Create a plugin context with enhanced-resolve-based resolve method
+            const pluginContext = {
+                environment: this.environment,
+                resolve: async (id, importer) => {
+                    return new Promise((resolve) => {
+                        this.enhancedResolver({}, importer || this.environment.config.root, id, {}, (err, result) => {
+                            if (!err && result) {
+                                debug("Context resolve: %s -> %s", id, result);
+                                resolve({ id: result });
+                            }
+                            else {
+                                debug("Context resolve failed for %s: %s", id, err?.message || "not found");
+                                resolve(null);
+                            }
+                        });
+                    });
+                },
+            };
+            debug("Trying to resolve %s from %s", request.request, request.path);
+            // This function encapsulates the logic to process Vite plugins for a given request.
+            const runPluginProcessing = async (currentRequest) => {
+                debug("Available plugins:", plugins.map((p) => p.name));
+                for (const plugin of plugins) {
+                    const resolveIdHandler = plugin.resolveId;
+                    if (!resolveIdHandler)
+                        continue;
+                    let handlerFn;
+                    let shouldApplyFilter = false;
+                    let filter = null;
+                    if (typeof resolveIdHandler === "function") {
+                        handlerFn = resolveIdHandler;
+                    }
+                    else if (typeof resolveIdHandler === "object" &&
+                        typeof resolveIdHandler.handler === "function") {
+                        handlerFn = resolveIdHandler.handler;
+                        shouldApplyFilter = true;
+                        filter = resolveIdHandler.filter;
+                    }
+                    if (!handlerFn)
+                        continue;
+                    if (shouldApplyFilter && filter?.id) {
+                        const idFilter = filter.id;
+                        let shouldSkip = false;
+                        if (idFilter instanceof RegExp) {
+                            shouldSkip = !idFilter.test(currentRequest.request);
+                        }
+                        else if (Array.isArray(idFilter)) {
+                            // Handle array of filters - matches if ANY filter matches
+                            shouldSkip = !idFilter.some((f) => f instanceof RegExp
+                                ? f.test(currentRequest.request)
+                                : f === currentRequest.request);
+                        }
+                        else if (typeof idFilter === "string") {
+                            shouldSkip = idFilter !== currentRequest.request;
+                        }
+                        else if (typeof idFilter === "object" && idFilter !== null) {
+                            // Handle include/exclude object pattern
+                            const { include, exclude } = idFilter;
+                            let matches = true;
+                            // Check include patterns (if any)
+                            if (include) {
+                                const includePatterns = Array.isArray(include)
+                                    ? include
+                                    : [include];
+                                matches = includePatterns.some((pattern) => pattern instanceof RegExp
+                                    ? pattern.test(currentRequest.request)
+                                    : pattern === currentRequest.request);
+                            }
+                            // Check exclude patterns (if any) - exclude overrides include
+                            if (matches && exclude) {
+                                const excludePatterns = Array.isArray(exclude)
+                                    ? exclude
+                                    : [exclude];
+                                const isExcluded = excludePatterns.some((pattern) => pattern instanceof RegExp
+                                    ? pattern.test(currentRequest.request)
+                                    : pattern === currentRequest.request);
+                                matches = !isExcluded;
+                            }
+                            shouldSkip = !matches;
+                        }
+                        if (shouldSkip) {
+                            debug("Skipping plugin '%s' due to filter mismatch for '%s'", plugin.name, currentRequest.request);
+                            continue;
+                        }
+                    }
+                    try {
+                        debug("Calling plugin '%s' for '%s'", plugin.name, currentRequest.request);
+                        const result = await handlerFn.call(pluginContext, currentRequest.request, currentRequest.path, { scan: true });
+                        debug("Plugin '%s' returned:", plugin.name, result);
+                        if (!result)
+                            continue;
+                        const resolvedId = typeof result === "string" ? result : result.id;
+                        if (resolvedId && resolvedId !== currentRequest.request) {
+                            debug("Plugin '%s' resolved '%s' -> '%s'", plugin.name, currentRequest.request, resolvedId);
+                            return callback(null, {
+                                ...currentRequest,
+                                path: resolvedId,
+                            });
+                        }
+                        else if (resolvedId === currentRequest.request) {
+                            debug("Plugin '%s' returned unchanged ID, continuing to next plugin", plugin.name);
+                        }
+                    }
+                    catch (e) {
+                        debug("Plugin '%s' failed while resolving '%s': %s", plugin.name, currentRequest.request, e.message);
+                    }
+                }
+                // If no plugin resolves, fall back to enhanced-resolve's default behavior
+                debug("No Vite plugin resolved '%s', falling back.", currentRequest.request);
+                // For absolute paths, check if the file exists
+                if (path.isAbsolute(currentRequest.request)) {
+                    try {
+                        if (fs.existsSync(currentRequest.request)) {
+                            debug("File exists, resolving to: %s", currentRequest.request);
+                            return callback(null, {
+                                ...currentRequest,
+                                path: currentRequest.request,
+                            });
+                        }
+                    }
+                    catch (e) {
+                        debug("Error checking file existence: %s", e.message);
+                    }
+                }
+                callback();
+            };
+            // For relative imports, normalize them to absolute paths first
+            if (request.request.startsWith("../") ||
+                request.request.startsWith("./")) {
+                try {
+                    // Use path.dirname to get the directory of the importer file
+                    const importerDir = path.dirname(request.path);
+                    const absolutePath = normalizeModulePath(request.request, importerDir, { absolute: true });
+                    debug("Absolutified %s -> %s", request.request, absolutePath);
+                    const absoluteRequest = { ...request, request: absolutePath };
+                    runPluginProcessing(absoluteRequest).catch((e) => {
+                        debug("Error in plugin processing: %s", e.message);
+                        callback();
+                    });
+                }
+                catch (e) {
+                    debug("Failed to absolutify %s: %s", request.request, e.message);
+                    callback();
+                }
+            }
+            else {
+                // For non-relative imports, process them directly
+                runPluginProcessing(request).catch((e) => {
+                    debug("Error in plugin processing: %s", e.message);
+                    callback();
+                });
+            }
+        });
+    }
+}
+const mapAlias = (alias) => {
+    const mappedAlias = {};
+    if (Array.isArray(alias)) {
+        // Handle array format: { find: string | RegExp, replacement: string }
+        for (const { find, replacement } of alias) {
+            if (find instanceof RegExp) {
+                // For RegExp, use the source as-is
+                mappedAlias[find.source] = replacement;
+            }
+            else {
+                // For string aliases, use them as-is without modification
+                mappedAlias[find] = replacement;
+            }
+        }
+    }
+    else {
+        // Handle object format: { [find: string]: replacement }
+        for (const [find, replacement] of Object.entries(alias)) {
+            // Use the alias key as-is without modification
+            mappedAlias[find] = replacement;
+        }
+    }
+    return mappedAlias;
+};
+export const mapViteResolveToEnhancedResolveOptions = (viteConfig, envName) => {
+    const env = viteConfig.environments[envName];
+    if (!env) {
+        throw new Error(`Could not find environment configuration for "${envName}".`);
+    }
+    const envResolveOptions = (env.resolve || {});
+    // Merge root config aliases with environment-specific aliases
+    const mergedAlias = {
+        ...(viteConfig.resolve?.alias ? mapAlias(viteConfig.resolve.alias) : {}),
+        ...(envResolveOptions.alias ? mapAlias(envResolveOptions.alias) : {}),
+    };
+    // Use comprehensive extensions list similar to Vite's defaults
+    const extensions = envResolveOptions.extensions || [
+        ".mjs",
+        ".js",
+        ".mts",
+        ".ts",
+        ".jsx",
+        ".tsx",
+        ".json",
+    ];
+    const baseOptions = {
+        // File system is required by enhanced-resolve.
+        fileSystem: fs,
+        // Map Vite's resolve options to enhanced-resolve's options.
+        alias: Object.keys(mergedAlias).length > 0 ? mergedAlias : undefined,
+        conditionNames: envResolveOptions.conditions,
+        mainFields: envResolveOptions.mainFields,
+        extensions,
+        symlinks: envResolveOptions.preserveSymlinks,
+        // Add default node modules resolution.
+        modules: ["node_modules"],
+        roots: [viteConfig.root],
+    };
+    return baseOptions;
+};
+export const createViteAwareResolver = (viteConfig, envName, environment) => {
+    const baseOptions = mapViteResolveToEnhancedResolveOptions(viteConfig, envName);
+    // Add Vite plugin resolver if environment is provided
+    const plugins = environment
+        ? [new VitePluginResolverPlugin(environment)]
+        : [];
+    const enhancedResolveOptions = {
+        ...baseOptions,
+        plugins,
+    };
+    debug("Creating enhanced-resolve with options:", {
+        extensions: enhancedResolveOptions.extensions,
+        alias: enhancedResolveOptions.alias,
+        roots: enhancedResolveOptions.roots,
+    });
+    return resolve.create(enhancedResolveOptions);
+};

package/dist/vite/directiveModulesDevPlugin.mjs

@@ -1,9 +1,8 @@
-import path from "node:path";
+import path from "path";
 import { writeFileSync, mkdirSync } from "node:fs";
 import { normalizeModulePath } from "../lib/normalizeModulePath.mjs";
+import { CLIENT_BARREL_PATH, SERVER_BARREL_PATH } from "../lib/constants.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";
@@ -24,38 +23,64 @@ const generateBarrelContent = (files, projectRootDir) => {
     return `${imports}\n\n${exports}`;
 };
 export const directiveModulesDevPlugin = ({ clientFiles, serverFiles, projectRootDir, }) => {
+    let scanPromise = null;
     return {
         name: "rwsdk:directive-modules-dev",
-        enforce: "pre",
-        async configResolved(config) {
-            if (config.command !== "serve") {
+        configureServer(server) {
+            if (!process.env.VITE_IS_DEV_SERVER || process.env.RWSDK_WORKER_RUN) {
                 return;
             }
-            const workerEnv = config.environments["worker"];
-            if (workerEnv) {
-                await runDirectivesScan({
-                    rootConfig: config,
-                    envName: "worker",
-                    clientFiles,
-                    serverFiles,
-                });
+            // Start the directive scan as soon as the server is configured.
+            // We don't await it here, allowing Vite to continue its startup.
+            scanPromise = runDirectivesScan({
+                rootConfig: server.config,
+                environment: server.environments.worker,
+                clientFiles,
+                serverFiles,
+            }).then(() => {
+                // After the scan is complete, write the barrel files.
+                const clientBarrelContent = generateBarrelContent(clientFiles, projectRootDir);
+                writeFileSync(CLIENT_BARREL_PATH, clientBarrelContent);
+                const serverBarrelContent = generateBarrelContent(serverFiles, projectRootDir);
+                writeFileSync(SERVER_BARREL_PATH, serverBarrelContent);
+            });
+            // context(justinvdm, 4 Sep 2025): Add middleware to block incoming
+            // requests until the scan is complete. This gives us a single hook for
+            // preventing app code being processed by vite until the scan is complete.
+            // This improves perceived startup time by not blocking Vite's optimizer.
+            server.middlewares.use(async (_req, _res, next) => {
+                if (scanPromise) {
+                    await scanPromise;
+                }
+                next();
+            });
+        },
+        configResolved(config) {
+            if (config.command !== "serve") {
+                return;
             }
-            // 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);
+            // Create dummy files to give esbuild a real path to resolve.
             mkdirSync(path.dirname(CLIENT_BARREL_PATH), { recursive: true });
-            writeFileSync(CLIENT_BARREL_PATH, clientBarrelContent);
+            writeFileSync(CLIENT_BARREL_PATH, "");
             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,
-                    ];
-                }
+            writeFileSync(SERVER_BARREL_PATH, "");
+            for (const [envName, env] of Object.entries(config.environments || {})) {
+                env.optimizeDeps ??= {};
+                env.optimizeDeps.include ??= [];
+                env.optimizeDeps.include.push(CLIENT_BARREL_EXPORT_PATH, SERVER_BARREL_EXPORT_PATH);
+                env.optimizeDeps.esbuildOptions ??= {};
+                env.optimizeDeps.esbuildOptions.plugins ??= [];
+                env.optimizeDeps.esbuildOptions.plugins.push({
+                    name: "rwsdk:block-optimizer-for-scan",
+                    setup(build) {
+                        build.onStart(async () => {
+                            // context(justinvdm, 4 Sep 2025): We await the scan promise
+                            // here because we want to block the optimizer until the scan is
+                            // complete.
+                            await scanPromise;
+                        });
+                    },
+                });
             }
         },
     };

package/dist/vite/directivesPlugin.mjs

@@ -52,6 +52,10 @@ export const directivesPlugin = ({ projectRootDir, clientFiles, serverFiles, })
             });
         },
         async transform(code, id) {
+            // Skip during directive scanning to avoid performance issues
+            if (process.env.RWSDK_DIRECTIVE_SCAN_ACTIVE) {
+                return;
+            }
             if (isBuild &&
                 this.environment?.name === "worker" &&
                 process.env.RWSDK_BUILD_PASS !== "worker") {

package/dist/vite/injectVitePreamblePlugin.mjs

@@ -4,6 +4,10 @@ export const injectVitePreamble = ({ clientEntryPoints, projectRootDir, }) => ({
     name: "rwsdk:inject-vite-preamble",
     apply: "serve",
     transform(code, id) {
+        // Skip during directive scanning to avoid performance issues
+        if (process.env.RWSDK_DIRECTIVE_SCAN_ACTIVE) {
+            return;
+        }
         if (this.environment.name !== "client") {
             return;
         }

package/dist/vite/manifestPlugin.mjs

@@ -11,11 +11,19 @@ export const manifestPlugin = ({ projectRootDir, }) => {
             isBuild = config.command === "build";
         },
         resolveId(id) {
+            // Skip during directive scanning to avoid performance issues
+            if (process.env.RWSDK_DIRECTIVE_SCAN_ACTIVE) {
+                return;
+            }
             if (id === virtualModuleId) {
                 return resolvedVirtualModuleId;
             }
         },
         async load(id) {
+            // Skip during directive scanning to avoid performance issues
+            if (process.env.RWSDK_DIRECTIVE_SCAN_ACTIVE) {
+                return;
+            }
             if (id === resolvedVirtualModuleId) {
                 if (isBuild) {
                     // context(justinvdm, 28 Aug 2025): During the build, we don't have

package/dist/vite/reactConditionsResolverPlugin.mjs

@@ -169,6 +169,10 @@ export const reactConditionsResolverPlugin = ({ projectRootDir, }) => {
             name: "rwsdk:react-conditions-resolver:resolveId",
             enforce: "pre",
             async resolveId(id, importer) {
+                // Skip during directive scanning to avoid performance issues
+                if (process.env.RWSDK_DIRECTIVE_SCAN_ACTIVE) {
+                    return;
+                }
                 if (!isBuild) {
                     return;
                 }

package/dist/vite/redwoodPlugin.mjs

@@ -63,12 +63,12 @@ export const redwoodPlugin = async (options = {}) => {
     }
     return [
         devServerTimingPlugin(),
+        devServerConstantPlugin(),
         directiveModulesDevPlugin({
             clientFiles,
             serverFiles,
             projectRootDir,
         }),
-        devServerConstantPlugin(),
         configPlugin({
             silent: options.silent ?? false,
             projectRootDir,

package/dist/vite/runDirectivesScan.d.mts

@@ -1,7 +1,7 @@
-import { ResolvedConfig } from "vite";
-export declare function runDirectivesScan({ rootConfig, envName, clientFiles, serverFiles, }: {
+import { Environment, ResolvedConfig } from "vite";
+export declare const runDirectivesScan: ({ rootConfig, environment, clientFiles, serverFiles, }: {
     rootConfig: ResolvedConfig;
-    envName: string;
+    environment: Environment;
     clientFiles: Set<string>;
     serverFiles: Set<string>;
-}): Promise<any>;
+}) => Promise<void>;

package/dist/vite/runDirectivesScan.mjs

@@ -2,9 +2,10 @@ import fsp from "node:fs/promises";
 import { hasDirective } from "./hasDirective.mjs";
 import path from "node:path";
 import debug from "debug";
-import { ensureAliasArray } from "./ensureAliasArray.mjs";
 import { getViteEsbuild } from "./getViteEsbuild.mjs";
 import { normalizeModulePath } from "../lib/normalizeModulePath.mjs";
+import { externalModules } from "./constants.mjs";
+import { createViteAwareResolver } from "./createViteAwareResolver.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
@@ -13,140 +14,143 @@ 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);
-function createEsbuildScanPlugin({ clientFiles, serverFiles, aliases, projectRootDir, }) {
-    return {
-        name: "rwsdk:esbuild-scan-plugin",
-        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 specialQueryFilter = /[?&](?:url|raw|worker|sharedworker|inline)\b/;
-            // This regex is used to identify if a path has any file extension.
-            const hasExtensionRegex = /\.[^/]+$/;
-            build.onResolve({ filter: specialQueryFilter }, (args) => {
-                log("Externalizing special query:", args.path);
-                return { external: true };
+export const runDirectivesScan = async ({ rootConfig, environment, clientFiles, serverFiles, }) => {
+    console.log("\n🔍 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 {
+        const esbuild = await getViteEsbuild(rootConfig.root);
+        const input = environment.config.build.rollupOptions?.input;
+        let entries;
+        if (Array.isArray(input)) {
+            entries = input;
+        }
+        else if (typeof input === "string") {
+            entries = [input];
+        }
+        else if (isObject(input)) {
+            entries = Object.values(input);
+        }
+        else {
+            entries = [];
+        }
+        if (entries.length === 0) {
+            log("No entries found for directives scan in environment '%s', skipping.", environment.name);
+            return;
+        }
+        const absoluteEntries = entries.map((entry) => path.resolve(rootConfig.root, entry));
+        log("Starting directives scan for environment '%s' with entries:", environment.name, absoluteEntries);
+        // Use enhanced-resolve with Vite plugin integration for full compatibility
+        const resolver = createViteAwareResolver(rootConfig, environment.name, environment);
+        const resolveId = async (id, importer) => {
+            return new Promise((resolve) => {
+                resolver({}, importer || rootConfig.root, id, {}, (err, result) => {
+                    if (!err && result) {
+                        resolve({ id: result });
+                    }
+                    else {
+                        if (err) {
+                            // Handle specific enhanced-resolve errors gracefully
+                            const errorMessage = err.message || String(err);
+                            if (errorMessage.includes("Package path . is not exported")) {
+                                log("Package exports error for %s, marking as external", id);
+                            }
+                            else {
+                                log("Resolution failed for %s: %s", id, errorMessage);
+                            }
+                        }
+                        resolve(null);
+                    }
+                });
             });
-            build.onResolve({ filter: /.*/, namespace: "file" }, (args) => {
-                // Externalize if the path has an extension AND that extension is not a
-                // script extension. Extensionless paths are assumed to be scripts and
-                // are allowed to pass through for resolution.
-                if (hasExtensionRegex.test(args.path) &&
-                    !scriptFilter.test(args.path)) {
-                    log("Externalizing non-script import:", args.path);
+        };
+        const esbuildScanPlugin = {
+            name: "rwsdk:esbuild-scan-plugin",
+            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 specialQueryFilter = /[?&](?:url|raw|worker|sharedworker|inline)\b/;
+                // This regex is used to identify if a path has any file extension.
+                const hasExtensionRegex = /\.[^/]+$/;
+                build.onResolve({ filter: specialQueryFilter }, (args) => {
+                    log("Externalizing special query:", args.path);
                     return { external: true };
-                }
-            });
-            build.onResolve({ filter: /.*/ }, async (args) => {
-                // Prevent infinite recursion.
-                if (args.pluginData?.rwsdkScanResolver) {
-                    return null;
-                }
-                // 1. First, try to resolve aliases.
-                for (const { find, replacement } of aliases) {
-                    const findPattern = find instanceof RegExp ? find : new RegExp(`^${find}(\\/.*)?$`);
-                    if (findPattern.test(args.path)) {
-                        const newPath = args.path.replace(findPattern, (_match, rest) => {
-                            // `rest` is the captured group `(\\/.*)?` from the regex.
-                            return replacement + (rest || "");
-                        });
-                        const resolved = await build.resolve(newPath, {
-                            importer: args.importer,
-                            resolveDir: args.resolveDir,
-                            kind: args.kind,
-                            pluginData: { rwsdkScanResolver: true },
-                        });
-                        if (resolved.errors.length === 0) {
-                            return resolved;
-                        }
-                        log("Could not resolve aliased path '%s' (from '%s'). Marking as external. Errors: %s", newPath, args.path, resolved.errors.map((e) => e.text).join(", "));
+                });
+                build.onResolve({ filter: /.*/, namespace: "file" }, (args) => {
+                    // Externalize if the path has an extension AND that extension is not a
+                    // script extension. Extensionless paths are assumed to be scripts and
+                    // are allowed to pass through for resolution.
+                    if (hasExtensionRegex.test(args.path) &&
+                        !scriptFilter.test(args.path)) {
+                        log("Externalizing non-script import:", args.path);
                         return { external: true };
                     }
-                }
-                // 2. If no alias matches, try esbuild's default resolver.
-                const resolved = await build.resolve(args.path, {
-                    importer: args.importer,
-                    resolveDir: args.resolveDir,
-                    kind: args.kind,
-                    pluginData: { rwsdkScanResolver: true },
                 });
-                // If it fails, mark as external but don't crash.
-                if (resolved.errors.length > 0) {
-                    log("Could not resolve '%s'. Marking as external. Errors: %s", args.path, resolved.errors.map((e) => e.text).join(", "));
+                build.onResolve({ filter: /.*/ }, async (args) => {
+                    if (externalModules.includes(args.path)) {
+                        return { external: true };
+                    }
+                    log("onResolve called for:", args.path, "from:", args.importer);
+                    const resolved = await resolveId(args.path, args.importer);
+                    log("Resolution result:", resolved);
+                    const resolvedPath = resolved?.id;
+                    if (resolvedPath && path.isAbsolute(resolvedPath)) {
+                        // Normalize the path for esbuild compatibility
+                        const normalizedPath = normalizeModulePath(resolvedPath, rootConfig.root, { absolute: true });
+                        log("Normalized path:", normalizedPath);
+                        return { path: normalizedPath };
+                    }
+                    log("Marking as external:", args.path, "resolved to:", resolvedPath);
                     return { external: true };
-                }
-                return resolved;
-            });
-            build.onLoad({ filter: /\.(m|c)?[jt]sx?$/ }, async (args) => {
-                if (!args.path.startsWith("/") ||
-                    args.path.includes("virtual:") ||
-                    isExternalUrl(args.path)) {
-                    return null;
-                }
-                try {
-                    const contents = await fsp.readFile(args.path, "utf-8");
-                    if (hasDirective(contents, "use client")) {
-                        log("Discovered 'use client' in:", args.path);
-                        clientFiles.add(normalizeModulePath(args.path, projectRootDir));
+                });
+                build.onLoad({ filter: /\.(m|c)?[jt]sx?$/ }, async (args) => {
+                    log("onLoad called for:", args.path);
+                    if (!args.path.startsWith("/") ||
+                        args.path.includes("virtual:") ||
+                        isExternalUrl(args.path)) {
+                        log("Skipping file due to filter:", args.path, {
+                            startsWithSlash: args.path.startsWith("/"),
+                            hasVirtual: args.path.includes("virtual:"),
+                            isExternal: isExternalUrl(args.path),
+                        });
+                        return null;
                     }
-                    if (hasDirective(contents, "use server")) {
-                        log("Discovered 'use server' in:", args.path);
-                        serverFiles.add(normalizeModulePath(args.path, projectRootDir));
+                    try {
+                        const contents = await fsp.readFile(args.path, "utf-8");
+                        if (hasDirective(contents, "use client")) {
+                            log("Discovered 'use client' in:", args.path);
+                            clientFiles.add(normalizeModulePath(args.path, rootConfig.root));
+                        }
+                        if (hasDirective(contents, "use server")) {
+                            log("Discovered 'use server' in:", args.path);
+                            serverFiles.add(normalizeModulePath(args.path, rootConfig.root));
+                        }
+                        return { contents, loader: "default" };
                     }
-                    return { contents, loader: "default" };
-                }
-                catch (e) {
-                    log("Could not read file during scan, skipping:", args.path, e);
-                    return null;
-                }
-            });
-        },
-    };
-}
-export async function runDirectivesScan({ rootConfig, envName, clientFiles, serverFiles, }) {
-    const esbuild = await getViteEsbuild(rootConfig.root);
-    const env = rootConfig.environments[envName];
-    const input = env.build.rollupOptions?.input;
-    let entries;
-    if (Array.isArray(input)) {
-        entries = input;
-    }
-    else if (typeof input === "string") {
-        entries = [input];
-    }
-    else if (isObject(input)) {
-        entries = Object.values(input);
-    }
-    else {
-        entries = [];
-    }
-    if (entries.length === 0) {
-        log("No entries found for directives scan in environment '%s', skipping.", envName);
-        return;
-    }
-    const absoluteEntries = entries.map((entry) => path.resolve(rootConfig.root, entry));
-    log("Starting directives scan for environment '%s' with entries:", envName, absoluteEntries);
-    try {
-        const result = await esbuild.build({
+                    catch (e) {
+                        log("Could not read file during scan, skipping:", args.path, e);
+                        return null;
+                    }
+                });
+            },
+        };
+        await esbuild.build({
             entryPoints: absoluteEntries,
             bundle: true,
             write: false,
             platform: "node",
             format: "esm",
             logLevel: "silent",
-            metafile: true,
-            plugins: [
-                createEsbuildScanPlugin({
-                    clientFiles,
-                    serverFiles,
-                    aliases: ensureAliasArray(env),
-                    projectRootDir: rootConfig.root,
-                }),
-            ],
+            plugins: [esbuildScanPlugin],
         });
-        return result.metafile;
     }
     catch (e) {
-        throw new Error(`RWSDK directive scan failed:\n${e.message}`);
+        throw new Error(`RWSDK directive scan failed:\n${e.stack}`);
+    }
+    finally {
+        // Always clear the scanning flag when done
+        delete process.env.RWSDK_DIRECTIVE_SCAN_ACTIVE;
+        console.log("✅ Scan complete.");
     }
-}
+};

package/dist/vite/ssrBridgePlugin.mjs

@@ -48,6 +48,10 @@ export const ssrBridgePlugin = ({ clientFiles, serverFiles, }) => {
             }
         },
         async resolveId(id) {
+            // Skip during directive scanning to avoid performance issues
+            if (process.env.RWSDK_DIRECTIVE_SCAN_ACTIVE) {
+                return;
+            }
             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
@@ -89,6 +93,10 @@ export const ssrBridgePlugin = ({ clientFiles, serverFiles, }) => {
             }
         },
         async load(id) {
+            // Skip during directive scanning to avoid performance issues
+            if (process.env.RWSDK_DIRECTIVE_SCAN_ACTIVE) {
+                return;
+            }
             if (id.startsWith(VIRTUAL_SSR_PREFIX) &&
                 this.environment.name === "worker") {
                 const realId = id.slice(VIRTUAL_SSR_PREFIX.length);

package/dist/vite/transformJsxScriptTagsPlugin.mjs

@@ -319,6 +319,10 @@ export const transformJsxScriptTagsPlugin = ({ clientEntryPoints, projectRootDir
             isBuild = config.command === "build";
         },
         async transform(code, id) {
+            // Skip during directive scanning to avoid performance issues
+            if (process.env.RWSDK_DIRECTIVE_SCAN_ACTIVE) {
+                return;
+            }
             if (isBuild &&
                 this.environment?.name === "worker" &&
                 process.env.RWSDK_BUILD_PASS !== "worker") {

package/dist/vite/virtualPlugin.mjs

@@ -4,12 +4,20 @@ export const virtualPlugin = (name, load) => {
     return {
         name: `rwsdk:virtual-${name}`,
         resolveId(source, _importer, _options) {
+            // Skip during directive scanning to avoid performance issues
+            if (process.env.RWSDK_DIRECTIVE_SCAN_ACTIVE) {
+                return;
+            }
             if (source === name || source.startsWith(`${name}?`)) {
                 return `\0${source}`;
             }
             return;
         },
         load(id, options) {
+            // Skip during directive scanning to avoid performance issues
+            if (process.env.RWSDK_DIRECTIVE_SCAN_ACTIVE) {
+                return;
+            }
             if (id === `\0${name}` || id.startsWith(`\0${name}?`)) {
                 return load.apply(this, [id, options]);
             }

package/package.json

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