rwsdk 1.5.6 → 1.5.7

package/dist/vite/createDirectiveLookupPlugin.d.mts

@@ -1,9 +1,11 @@
 import { Plugin } from "vite";
-export declare function generateLookupMap({ files, isDev, kind, exportName, }: {
+export declare function generateLookupMap({ files, isDev, kind, exportName, optimizeDepsExclude, projectRootDir, }: {
     files: Set<string>;
     isDev: boolean;
     kind: "client" | "server";
     exportName: string;
+    optimizeDepsExclude?: string[];
+    projectRootDir?: string;
 }): {
     code: string;
     map: import("magic-string").SourceMap;

package/dist/vite/createDirectiveLookupPlugin.mjs

@@ -1,14 +1,17 @@
 import debug from "debug";
 import MagicString from "magic-string";
 import path from "path";
-import { addOptimizeDepsPlugin } from "./addOptimizeDepsPlugin.mjs";
 import { VENDOR_CLIENT_BARREL_EXPORT_PATH, VENDOR_SERVER_BARREL_EXPORT_PATH, } from "../lib/constants.mjs";
-export function generateLookupMap({ files, isDev, kind, exportName, }) {
+import { addOptimizeDepsPlugin } from "./addOptimizeDepsPlugin.mjs";
+import { getOptimizeDepsExcludePatternsByEnv, isExcludedFromOptimization, resolveOptimizeDepsExcludesByEnv, } from "./resolveOptimizeDepsExcludes.mjs";
+export function generateLookupMap({ files, isDev, kind, exportName, optimizeDepsExclude, projectRootDir, }) {
+    const excludedRoots = optimizeDepsExclude ?? [];
     const s = new MagicString(`
 export const ${exportName} = {
   ${Array.from(files)
         .map((file) => {
-        if (file.includes("node_modules") && isDev) {
+        const excluded = isExcludedFromOptimization(file, excludedRoots, projectRootDir);
+        if (file.includes("node_modules") && isDev && !excluded) {
             const barrelPath = kind === "client"
                 ? VENDOR_CLIENT_BARREL_EXPORT_PATH
                 : VENDOR_SERVER_BARREL_EXPORT_PATH;
@@ -35,11 +38,17 @@ export const createDirectiveLookupPlugin = async ({ projectRootDir, files, confi
     const log = debug(debugNamespace);
     let isDev = false;
     let devServer;
+    let optimizeDepsExclude = [];
+    let excludedRootsByEnv = {};
     log("Initializing %s plugin with projectRootDir=%s", config.pluginName, projectRootDir);
     return {
         name: `rwsdk:${config.pluginName}`,
-        config(_, { command, isPreview }) {
+        config(config, { command, isPreview }) {
             isDev = !isPreview && command === "serve";
+            optimizeDepsExclude = [
+                ...new Set(Object.values(getOptimizeDepsExcludePatternsByEnv(config)).flat()),
+            ];
+            excludedRootsByEnv = resolveOptimizeDepsExcludesByEnv(getOptimizeDepsExcludePatternsByEnv(config), projectRootDir);
             log("Development mode: %s", isDev);
         },
         configureServer(server) {
@@ -147,11 +156,21 @@ export const createDirectiveLookupPlugin = async ({ projectRootDir, files, confi
                 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 lookupExcludedRoots = config.kind === "server"
+                    ? [...(excludedRootsByEnv.worker ?? [])]
+                    : [
+                        ...new Set([
+                            ...(excludedRootsByEnv.client ?? []),
+                            ...(excludedRootsByEnv.ssr ?? []),
+                        ]),
+                    ];
                 return generateLookupMap({
                     files,
                     isDev,
                     kind: config.kind,
                     exportName: config.exportName,
+                    optimizeDepsExclude: lookupExcludedRoots,
+                    projectRootDir,
                 });
             }
         },

package/dist/vite/createDirectiveLookupPlugin.test.mjs

@@ -37,4 +37,16 @@ describe("generateLookupMap", () => {
         });
         expect(result.code).toContain(`"node_modules/lib-a/index.js": () => import("node_modules/lib-a/index.js")`);
     });
+    it("should source-serve files under optimizeDeps.exclude roots in dev", () => {
+        const result = generateLookupMap({
+            files,
+            isDev: true,
+            kind: "client",
+            exportName: "clientLookup",
+            optimizeDepsExclude: ["/project/node_modules/lib-a"],
+            projectRootDir: "/project",
+        });
+        expect(result.code).toContain(`"node_modules/lib-a/index.js": () => import("node_modules/lib-a/index.js")`);
+        expect(result.code).not.toContain(`"node_modules/lib-a/index.js": () => import("${VENDOR_CLIENT_BARREL_EXPORT_PATH}")`);
+    });
 });

package/dist/vite/directiveModulesDevPlugin.d.mts

@@ -1,7 +1,7 @@
 import { Plugin } from "vite";
 import { ConfigurableEsbuildOptions } from "./runDirectivesScan.mjs";
-export declare const generateVendorBarrelContent: (files: Set<string>, projectRootDir: string) => string;
-export declare const generateAppBarrelContent: (files: Set<string>, projectRootDir: string) => string;
+export declare const generateVendorBarrelContent: (files: Set<string>, projectRootDir: string, excludedRoots?: string[]) => string;
+export declare const generateAppBarrelContent: (files: Set<string>, projectRootDir: string, excludedRoots?: string[]) => string;
 export declare const directiveModulesDevPlugin: ({ clientFiles, serverFiles, projectRootDir, workerEntryPathname, esbuildOptions, }: {
     clientFiles: Set<string>;
     serverFiles: Set<string>;

package/dist/vite/directiveModulesDevPlugin.mjs

@@ -4,25 +4,29 @@ import path from "path";
 import { VENDOR_CLIENT_BARREL_PATH as SDK_VENDOR_CLIENT_BARREL_PATH, VENDOR_SERVER_BARREL_PATH as SDK_VENDOR_SERVER_BARREL_PATH, VENDOR_CLIENT_BARREL_EXPORT_PATH, VENDOR_SERVER_BARREL_EXPORT_PATH, } from "../lib/constants.mjs";
 import { normalizeModulePath } from "../lib/normalizeModulePath.mjs";
 import { setVendorBarrelPaths } from "./barrelPaths.mjs";
+import { getOptimizeDepsExcludePatternsByEnv, isExcludedFromOptimization, resolveOptimizeDepsExcludesByEnv, } from "./resolveOptimizeDepsExcludes.mjs";
 import { runDirectivesScan, } from "./runDirectivesScan.mjs";
-export const generateVendorBarrelContent = (files, projectRootDir) => {
+export const generateVendorBarrelContent = (files, projectRootDir, excludedRoots = []) => {
     const imports = [...files]
-        .filter((file) => file.includes("node_modules"))
+        .filter((file) => file.includes("node_modules") &&
+        !isExcludedFromOptimization(file, excludedRoots, projectRootDir))
         .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"))
+            .filter((file) => file.includes("node_modules") &&
+            !isExcludedFromOptimization(file, excludedRoots, projectRootDir))
             .map((file, i) => `  '${normalizeModulePath(file, projectRootDir)}': M${i},`)
             .join("\n") +
         "\n};";
     return `${imports}\n\n${exports}`;
 };
-export const generateAppBarrelContent = (files, projectRootDir) => {
+export const generateAppBarrelContent = (files, projectRootDir, excludedRoots = []) => {
     return [...files]
-        .filter((file) => !file.includes("node_modules"))
+        .filter((file) => !file.includes("node_modules") ||
+        isExcludedFromOptimization(file, excludedRoots, projectRootDir))
         .map((file) => {
         const resolvedPath = normalizeModulePath(file, projectRootDir, {
             absolute: true,
@@ -34,6 +38,9 @@ export const generateAppBarrelContent = (files, projectRootDir) => {
 export const directiveModulesDevPlugin = ({ clientFiles, serverFiles, projectRootDir, workerEntryPathname, esbuildOptions, }) => {
     const { promise: scanPromise, resolve: resolveScanPromise, reject: rejectScanPromise, } = Promise.withResolvers();
     const tempDir = mkdtempSync(path.join(realpathSync(os.tmpdir()), "rwsdk-"));
+    let excludedRootsByEnv = {};
+    let clientBarrelExcludedRoots = [];
+    let serverBarrelExcludedRoots = [];
     const APP_CLIENT_BARREL_PATH = path.join(tempDir, "app-client-barrel.js");
     const APP_SERVER_BARREL_PATH = path.join(tempDir, "app-server-barrel.js");
     const VENDOR_CLIENT_BARREL_PATH = path.join(tempDir, "vendor-client-barrel.js");
@@ -49,7 +56,7 @@ export const directiveModulesDevPlugin = ({ clientFiles, serverFiles, projectRoo
     const escapeRegExp = (s) => s.replace(/[\\^$*+?.()|[\]{}]/g, "\\$&");
     const appBarrelFilter = new RegExp(`(${appBarrelPaths.map(escapeRegExp).join("|")})$`);
     const BARREL_PREFIX = "\0rwsdk-app-barrel:";
-    const createAppBarrelBlockerPlugin = () => ({
+    const createAppBarrelBlockerPlugin = (clientExcludedRoots, serverExcludedRoots) => ({
         name: "rwsdk:app-barrel-blocker",
         async resolveId(id) {
             await scanPromise;
@@ -91,14 +98,14 @@ export const directiveModulesDevPlugin = ({ clientFiles, serverFiles, projectRoo
                 id === VENDOR_SERVER_BARREL_PATH) {
                 const isServerBarrel = id.includes("server-barrel");
                 const files = isServerBarrel ? serverFiles : clientFiles;
-                return generateVendorBarrelContent(files, projectRootDir);
+                return generateVendorBarrelContent(files, projectRootDir, isServerBarrel ? serverExcludedRoots : clientExcludedRoots);
             }
             // Handle app barrels
             if (id.startsWith(BARREL_PREFIX)) {
                 const barrelPath = id.slice(BARREL_PREFIX.length);
                 const isServerBarrel = barrelPath.includes("app-server-barrel");
                 const files = isServerBarrel ? serverFiles : clientFiles;
-                return generateAppBarrelContent(files, projectRootDir);
+                return generateAppBarrelContent(files, projectRootDir, isServerBarrel ? serverExcludedRoots : clientExcludedRoots);
             }
         },
     });
@@ -107,7 +114,7 @@ export const directiveModulesDevPlugin = ({ clientFiles, serverFiles, projectRoo
             items.push(value);
         }
     };
-    const configureOptimizeDeps = (envName, env) => {
+    const configureOptimizeDeps = (envName, env, clientExcludedRoots, serverExcludedRoots) => {
         env.optimizeDeps ??= {};
         env.optimizeDeps.include ??= [];
         addUnique(env.optimizeDeps.include, VENDOR_CLIENT_BARREL_EXPORT_PATH);
@@ -124,7 +131,7 @@ export const directiveModulesDevPlugin = ({ clientFiles, serverFiles, projectRoo
         env.optimizeDeps.rolldownOptions ??= {};
         env.optimizeDeps.rolldownOptions.plugins ??= [];
         if (!env.optimizeDeps.rolldownOptions.plugins.some((plugin) => plugin.name === "rwsdk:app-barrel-blocker")) {
-            env.optimizeDeps.rolldownOptions.plugins.unshift(createAppBarrelBlockerPlugin());
+            env.optimizeDeps.rolldownOptions.plugins.unshift(createAppBarrelBlockerPlugin(clientExcludedRoots, serverExcludedRoots));
         }
     };
     return {
@@ -136,10 +143,10 @@ export const directiveModulesDevPlugin = ({ clientFiles, serverFiles, projectRoo
             const isServerBarrel = id === VENDOR_SERVER_BARREL_EXPORT_PATH ||
                 id === SDK_VENDOR_SERVER_BARREL_PATH;
             if (isClientBarrel) {
-                return generateVendorBarrelContent(clientFiles, projectRootDir);
+                return generateVendorBarrelContent(clientFiles, projectRootDir, clientBarrelExcludedRoots);
             }
             if (isServerBarrel) {
-                return generateVendorBarrelContent(serverFiles, projectRootDir);
+                return generateVendorBarrelContent(serverFiles, projectRootDir, serverBarrelExcludedRoots);
             }
             return null;
         },
@@ -164,8 +171,8 @@ export const directiveModulesDevPlugin = ({ clientFiles, serverFiles, projectRoo
                 esbuildOptions,
             })
                 .then(() => {
-                writeFileSync(VENDOR_CLIENT_BARREL_PATH, generateVendorBarrelContent(clientFiles, projectRootDir));
-                writeFileSync(VENDOR_SERVER_BARREL_PATH, generateVendorBarrelContent(serverFiles, projectRootDir));
+                writeFileSync(VENDOR_CLIENT_BARREL_PATH, generateVendorBarrelContent(clientFiles, projectRootDir, clientBarrelExcludedRoots));
+                writeFileSync(VENDOR_SERVER_BARREL_PATH, generateVendorBarrelContent(serverFiles, projectRootDir, serverBarrelExcludedRoots));
                 resolveScanPromise();
             })
                 .catch((error) => {
@@ -177,6 +184,20 @@ export const directiveModulesDevPlugin = ({ clientFiles, serverFiles, projectRoo
             });
         },
         configResolved(config) {
+            // context(chrisvdm, 2026-07-02): This hook must stay synchronous. Vite 7
+            // does not await async configResolved hooks before running later plugins,
+            // including the SDK's Vite 7 compat shim that translates
+            // optimizeDeps.rolldownOptions.plugins into esbuild plugins. If we add
+            // our app-barrel-blocker plugin after that shim has run, the optimizer
+            // never sees it and the dev vendor barrel stays empty.
+            excludedRootsByEnv = resolveOptimizeDepsExcludesByEnv(getOptimizeDepsExcludePatternsByEnv(config), projectRootDir);
+            clientBarrelExcludedRoots = [
+                ...new Set([
+                    ...(excludedRootsByEnv.client ?? []),
+                    ...(excludedRootsByEnv.ssr ?? []),
+                ]),
+            ];
+            serverBarrelExcludedRoots = [...(excludedRootsByEnv.worker ?? [])];
             if (config.command !== "serve") {
                 resolveScanPromise();
                 return;
@@ -190,7 +211,7 @@ export const directiveModulesDevPlugin = ({ clientFiles, serverFiles, projectRoo
             mkdirSync(path.dirname(VENDOR_SERVER_BARREL_PATH), { recursive: true });
             writeFileSync(VENDOR_SERVER_BARREL_PATH, "");
             for (const [envName, env] of Object.entries(config.environments || {})) {
-                configureOptimizeDeps(envName, env);
+                configureOptimizeDeps(envName, env, clientBarrelExcludedRoots, serverBarrelExcludedRoots);
             }
         },
     };

package/dist/vite/directiveModulesDevPlugin.test.mjs

@@ -29,6 +29,21 @@ export default {
             const content = generateVendorBarrelContent(files, projectRootDir);
             expect(content).toEqual("\n\nexport default {\n\n};");
         });
+        it("should exclude files under optimizeDeps.exclude roots", () => {
+            const files = new Set([
+                "node_modules/lib-a/index.js",
+                "node_modules/lib-b/component.tsx",
+            ]);
+            const excludedRoots = [`${projectRootDir}/node_modules/lib-a`];
+            const content = generateVendorBarrelContent(files, projectRootDir, excludedRoots);
+            const expected = `import * as M0 from '${projectRootDir}/node_modules/lib-b/component.tsx';
+
+export default {
+  '/node_modules/lib-b/component.tsx': M0,
+};`;
+            expect(content).toEqual(expected);
+            expect(content).not.toContain("lib-a");
+        });
     });
     describe("generateAppBarrelContent", () => {
         it("should generate correct content for app files", () => {
@@ -55,5 +70,44 @@ import "${projectRootDir}/src/component.tsx";`;
             const content = generateAppBarrelContent(files, projectRootDir);
             expect(content).toEqual("");
         });
+        it("should include excluded node_modules files in the app barrel", () => {
+            const files = new Set([
+                "src/app.js",
+                "node_modules/lib-a/index.js",
+                "src/component.tsx",
+            ]);
+            const excludedRoots = [`${projectRootDir}/node_modules/lib-a`];
+            const content = generateAppBarrelContent(files, projectRootDir, excludedRoots);
+            const expected = `import "${projectRootDir}/src/app.js";
+import "${projectRootDir}/node_modules/lib-a/index.js";
+import "${projectRootDir}/src/component.tsx";`;
+            expect(content).toEqual(expected);
+        });
+        it("should include excluded Vite-style /node_modules files in the app barrel", () => {
+            const files = new Set([
+                "/src/app.js",
+                "/node_modules/lib-a/index.js",
+                "/src/component.tsx",
+            ]);
+            const excludedRoots = [`${projectRootDir}/node_modules/lib-a`];
+            const content = generateAppBarrelContent(files, projectRootDir, excludedRoots);
+            const expected = `import "${projectRootDir}/src/app.js";
+import "${projectRootDir}/node_modules/lib-a/index.js";
+import "${projectRootDir}/src/component.tsx";`;
+            expect(content).toEqual(expected);
+        });
+        it("should keep transitive node_modules files in the vendor barrel unless they are also excluded", () => {
+            const files = new Set([
+                "/node_modules/lib-a/index.js",
+                "/node_modules/lib-a-utils/index.js",
+            ]);
+            const excludedRoots = [`${projectRootDir}/node_modules/lib-a`];
+            const vendorContent = generateVendorBarrelContent(files, projectRootDir, excludedRoots);
+            expect(vendorContent).toContain("lib-a-utils");
+            expect(vendorContent).not.toContain("lib-a/index");
+            const appContent = generateAppBarrelContent(files, projectRootDir, excludedRoots);
+            expect(appContent).toContain("lib-a/index");
+            expect(appContent).not.toContain("lib-a-utils");
+        });
     });
 });

package/dist/vite/resolveOptimizeDepsExcludes.d.mts

@@ -0,0 +1,53 @@
+type OptimizeDepsConfig = {
+    optimizeDeps?: {
+        exclude?: string[];
+    };
+    environments?: Record<string, {
+        optimizeDeps?: {
+            exclude?: string[];
+        };
+    }>;
+};
+/**
+ * Collect `optimizeDeps.exclude` patterns from the root config and from every
+ * environment config into a single, deduplicated list.
+ */
+export declare function getOptimizeDepsExcludePatterns(config: OptimizeDepsConfig): string[];
+/**
+ * Collect `optimizeDeps.exclude` patterns grouped by Vite environment.
+ *
+ * Root-level excludes apply to every environment. Per-environment excludes
+ * apply only to that environment. When no environments are configured (e.g.
+ * Vite 7), the known RedwoodSDK environments (`client`, `ssr`, `worker`) are
+ * populated with the root-level patterns.
+ */
+export declare function getOptimizeDepsExcludePatternsByEnv(config: OptimizeDepsConfig): Record<string, string[]>;
+/**
+ * Resolve per-environment `optimizeDeps.exclude` patterns into absolute
+ * filesystem roots. Each environment is resolved with the environment-aware
+ * resolver that matches its execution context.
+ */
+export declare function resolveOptimizeDepsExcludesByEnv(patternsByEnv: Record<string, string[]>, projectRootDir: string): Record<string, string[]>;
+/**
+ * Resolve entries from Vite's `optimizeDeps.exclude` into absolute filesystem
+ * roots that can be matched against discovered directive files.
+ *
+ * Supports:
+ * - Bare package names (`my-ui-lib`)
+ * - Scoped packages (`@scope/pkg`)
+ * - Package subpaths (`my-ui-lib/components`)
+ * - Relative paths (`./packages/my-ui-lib`)
+ * - Absolute paths
+ *
+ * Symlinked packages (e.g. `file:./packages/my-ui-lib`) are resolved to their
+ * real location on disk, so source files are matched even though the import
+ * specifier goes through `node_modules`.
+ *
+ * Each pattern is resolved through RedwoodSDK's environment-aware resolvers so
+ * that packages with environment-specific exports are located correctly for the
+ * client, SSR, and worker environments. The resolved roots from all
+ * environments are unioned together.
+ */
+export declare function resolveOptimizeDepsExcludes(excludes: string[], projectRootDir: string): string[];
+export declare function isExcludedFromOptimization(file: string, excludedRoots: string[], projectRootDir?: string): boolean;
+export {};

package/dist/vite/resolveOptimizeDepsExcludes.mjs

@@ -0,0 +1,201 @@
+import fs from "node:fs";
+import path from "node:path";
+import { normalizePath } from "vite";
+import { ENV_RESOLVERS, maybeResolveEnvImport } from "./envResolvers.mjs";
+const BARE_SPECIFIER_RE = /^(?:@[^/]+\/)?[^/]+/;
+function normalizePathSeparators(p) {
+    return normalizePath(p.replace(/\\/g, "/"));
+}
+function getResolverForEnv(envName) {
+    return envName in ENV_RESOLVERS ? envName : "client";
+}
+function resolveExcludeRoot(entry, projectRootDir, envName) {
+    projectRootDir = normalizePathSeparators(path.resolve(projectRootDir));
+    entry = normalizePathSeparators(entry);
+    // Absolute filesystem path: keep it but resolve symlinks.
+    if (path.isAbsolute(entry)) {
+        try {
+            return normalizePathSeparators(fs.realpathSync(entry));
+        }
+        catch {
+            return entry;
+        }
+    }
+    // Relative path: resolve from the project root.
+    if (entry.startsWith("./") || entry.startsWith("../")) {
+        const resolved = normalizePathSeparators(path.resolve(projectRootDir, entry));
+        try {
+            return normalizePathSeparators(fs.realpathSync(resolved));
+        }
+        catch {
+            return resolved;
+        }
+    }
+    // Bare specifier (package, scoped package, or package subpath).
+    const match = entry.match(BARE_SPECIFIER_RE);
+    if (match) {
+        const pkg = match[0];
+        const subpath = entry.slice(pkg.length);
+        const pkgJsonPath = maybeResolveEnvImport({
+            id: `${pkg}/package.json`,
+            envName,
+            projectRootDir,
+        });
+        if (!pkgJsonPath) {
+            return undefined;
+        }
+        const pkgRoot = normalizePathSeparators(path.dirname(pkgJsonPath));
+        const resolvedRoot = subpath
+            ? normalizePathSeparators(path.join(pkgRoot, subpath))
+            : pkgRoot;
+        try {
+            return normalizePathSeparators(fs.realpathSync(resolvedRoot));
+        }
+        catch {
+            return resolvedRoot;
+        }
+    }
+    // Anything else is treated as root-relative.
+    return normalizePathSeparators(path.join(projectRootDir, entry));
+}
+/**
+ * Collect `optimizeDeps.exclude` patterns from the root config and from every
+ * environment config into a single, deduplicated list.
+ */
+export function getOptimizeDepsExcludePatterns(config) {
+    const patterns = new Set();
+    for (const entry of config.optimizeDeps?.exclude ?? []) {
+        if (entry) {
+            patterns.add(entry);
+        }
+    }
+    for (const env of Object.values(config.environments ?? {})) {
+        for (const entry of env?.optimizeDeps?.exclude ?? []) {
+            if (entry) {
+                patterns.add(entry);
+            }
+        }
+    }
+    return [...patterns];
+}
+/**
+ * Collect `optimizeDeps.exclude` patterns grouped by Vite environment.
+ *
+ * Root-level excludes apply to every environment. Per-environment excludes
+ * apply only to that environment. When no environments are configured (e.g.
+ * Vite 7), the known RedwoodSDK environments (`client`, `ssr`, `worker`) are
+ * populated with the root-level patterns.
+ */
+export function getOptimizeDepsExcludePatternsByEnv(config) {
+    const rootPatterns = config.optimizeDeps?.exclude ?? [];
+    const environments = config.environments ?? {};
+    const patternsByEnv = {};
+    for (const envName of Object.keys(environments)) {
+        patternsByEnv[envName] = [...rootPatterns];
+    }
+    // Fallback for non-environmental configs.
+    if (Object.keys(patternsByEnv).length === 0) {
+        for (const envName of Object.keys(ENV_RESOLVERS)) {
+            patternsByEnv[envName] = [...rootPatterns];
+        }
+    }
+    for (const [envName, env] of Object.entries(environments)) {
+        for (const entry of env?.optimizeDeps?.exclude ?? []) {
+            if (entry) {
+                patternsByEnv[envName].push(entry);
+            }
+        }
+    }
+    return patternsByEnv;
+}
+function resolveOptimizeDepsExcludesForEnv(excludes, projectRootDir, envName) {
+    const roots = new Set();
+    for (const entry of excludes) {
+        if (!entry) {
+            continue;
+        }
+        const root = resolveExcludeRoot(entry, projectRootDir, envName);
+        if (root) {
+            roots.add(root);
+            continue;
+        }
+        // If the environment resolver couldn't locate the package, fall back to a
+        // node_modules path so the exclusion still has a chance to match.
+        const match = entry.match(BARE_SPECIFIER_RE);
+        if (match) {
+            roots.add(normalizePathSeparators(path.join(projectRootDir, "node_modules", entry)));
+        }
+    }
+    return [...roots];
+}
+/**
+ * Resolve per-environment `optimizeDeps.exclude` patterns into absolute
+ * filesystem roots. Each environment is resolved with the environment-aware
+ * resolver that matches its execution context.
+ */
+export function resolveOptimizeDepsExcludesByEnv(patternsByEnv, projectRootDir) {
+    const rootsByEnv = {};
+    for (const [envName, patterns] of Object.entries(patternsByEnv)) {
+        rootsByEnv[envName] = resolveOptimizeDepsExcludesForEnv(patterns, projectRootDir, getResolverForEnv(envName));
+    }
+    return rootsByEnv;
+}
+/**
+ * Resolve entries from Vite's `optimizeDeps.exclude` into absolute filesystem
+ * roots that can be matched against discovered directive files.
+ *
+ * Supports:
+ * - Bare package names (`my-ui-lib`)
+ * - Scoped packages (`@scope/pkg`)
+ * - Package subpaths (`my-ui-lib/components`)
+ * - Relative paths (`./packages/my-ui-lib`)
+ * - Absolute paths
+ *
+ * Symlinked packages (e.g. `file:./packages/my-ui-lib`) are resolved to their
+ * real location on disk, so source files are matched even though the import
+ * specifier goes through `node_modules`.
+ *
+ * Each pattern is resolved through RedwoodSDK's environment-aware resolvers so
+ * that packages with environment-specific exports are located correctly for the
+ * client, SSR, and worker environments. The resolved roots from all
+ * environments are unioned together.
+ */
+export function resolveOptimizeDepsExcludes(excludes, projectRootDir) {
+    const envNames = Object.keys(ENV_RESOLVERS);
+    const roots = new Set();
+    for (const envName of envNames) {
+        for (const root of resolveOptimizeDepsExcludesForEnv(excludes, projectRootDir, envName)) {
+            roots.add(root);
+        }
+    }
+    return [...roots];
+}
+export function isExcludedFromOptimization(file, excludedRoots, projectRootDir) {
+    const normalizedFile = normalizePathSeparators(file);
+    const candidates = new Set();
+    candidates.add(normalizedFile);
+    if (projectRootDir) {
+        const root = normalizePathSeparators(path.resolve(projectRootDir));
+        // If the file isn't already an absolute path inside the project root, also
+        // try resolving it from the project root. This covers both relative paths
+        // and Vite-style project-relative paths such as `/node_modules/foo/index.js`,
+        // which is how files inside the project root are represented after
+        // `normalizeModulePath`. We keep the original candidate too so external
+        // absolute paths (e.g. symlinked monorepo packages) still match their own
+        // excluded roots even if resolving from the project root produces a bogus
+        // path.
+        if (normalizedFile !== root && !normalizedFile.startsWith(root + "/")) {
+            const relativePart = normalizedFile.startsWith("/")
+                ? normalizedFile.slice(1)
+                : normalizedFile;
+            candidates.add(normalizePathSeparators(path.resolve(root, relativePart)));
+        }
+    }
+    return excludedRoots.some((excludedRoot) => {
+        const normalizedExcludedRoot = normalizePathSeparators(excludedRoot);
+        const prefix = normalizedExcludedRoot.endsWith("/")
+            ? normalizedExcludedRoot
+            : normalizedExcludedRoot + "/";
+        return Array.from(candidates).some((candidate) => candidate === normalizedExcludedRoot || candidate.startsWith(prefix));
+    });
+}

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

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

package/dist/vite/resolveOptimizeDepsExcludes.test.mjs

@@ -0,0 +1,120 @@
+import { describe, expect, it } from "vitest";
+import { getOptimizeDepsExcludePatterns, getOptimizeDepsExcludePatternsByEnv, isExcludedFromOptimization, resolveOptimizeDepsExcludes, resolveOptimizeDepsExcludesByEnv, } from "./resolveOptimizeDepsExcludes.mjs";
+describe("getOptimizeDepsExcludePatterns", () => {
+    it("should collect root-level excludes", () => {
+        const patterns = getOptimizeDepsExcludePatterns({
+            optimizeDeps: { exclude: ["foo", "bar"] },
+        });
+        expect(patterns).toEqual(["foo", "bar"]);
+    });
+    it("should collect per-environment excludes", () => {
+        const patterns = getOptimizeDepsExcludePatterns({
+            optimizeDeps: { exclude: ["foo"] },
+            environments: {
+                client: { optimizeDeps: { exclude: ["bar"] } },
+                worker: { optimizeDeps: { exclude: ["baz"] } },
+            },
+        });
+        expect(patterns).toEqual(expect.arrayContaining(["foo", "bar", "baz"]));
+        expect(patterns).toHaveLength(3);
+    });
+    it("should deduplicate excludes across root and environments", () => {
+        const patterns = getOptimizeDepsExcludePatterns({
+            optimizeDeps: { exclude: ["foo", "bar"] },
+            environments: {
+                client: { optimizeDeps: { exclude: ["bar", "baz"] } },
+            },
+        });
+        expect(patterns).toEqual(expect.arrayContaining(["foo", "bar", "baz"]));
+        expect(patterns).toHaveLength(3);
+    });
+});
+describe("getOptimizeDepsExcludePatternsByEnv", () => {
+    it("should apply root-level excludes to every environment", () => {
+        const patterns = getOptimizeDepsExcludePatternsByEnv({
+            optimizeDeps: { exclude: ["foo"] },
+            environments: {
+                client: { optimizeDeps: { exclude: [] } },
+                worker: { optimizeDeps: { exclude: ["bar"] } },
+            },
+        });
+        expect(patterns.client).toEqual(["foo"]);
+        expect(patterns.worker).toEqual(["foo", "bar"]);
+    });
+    it("should fall back to known environments when none are configured", () => {
+        const patterns = getOptimizeDepsExcludePatternsByEnv({
+            optimizeDeps: { exclude: ["foo"] },
+        });
+        expect(patterns.client).toEqual(["foo"]);
+        expect(patterns.ssr).toEqual(["foo"]);
+        expect(patterns.worker).toEqual(["foo"]);
+    });
+});
+describe("resolveOptimizeDepsExcludes", () => {
+    it("should resolve an installed package to its root", () => {
+        const roots = resolveOptimizeDepsExcludes(["glob"], process.cwd());
+        expect(roots.length).toBe(1);
+        expect(roots[0]).toMatch(/node_modules[\/\\]glob$/);
+    });
+    it("should resolve a scoped package to its root", () => {
+        const roots = resolveOptimizeDepsExcludes(["@cloudflare/vite-plugin"], process.cwd());
+        expect(roots.length).toBe(1);
+        expect(roots[0]).toMatch(/node_modules[\/\\]@cloudflare[\/\\]vite-plugin$/);
+    });
+    it("should resolve a package subpath to the subpath directory", () => {
+        const roots = resolveOptimizeDepsExcludes(["glob/dist"], process.cwd());
+        expect(roots.length).toBe(1);
+        expect(roots[0]).toMatch(/node_modules[\/\\]glob[\/\\]dist$/);
+    });
+    it("should resolve a relative path from the project root", () => {
+        const roots = resolveOptimizeDepsExcludes(["./sdk/src/vite"], process.cwd());
+        expect(roots.length).toBe(1);
+        expect(roots[0]).toMatch(/sdk[\/\\]src[\/\\]vite$/);
+    });
+    it("should fall back to node_modules path for unresolvable patterns", () => {
+        const roots = resolveOptimizeDepsExcludes(["this-package-does-not-exist"], process.cwd());
+        expect(roots.length).toBe(1);
+        expect(roots[0]).toMatch(/node_modules[\/\\]this-package-does-not-exist$/);
+    });
+});
+describe("resolveOptimizeDepsExcludesByEnv", () => {
+    it("should resolve per environment", () => {
+        const roots = resolveOptimizeDepsExcludesByEnv({
+            client: ["glob"],
+            worker: ["this-package-does-not-exist"],
+        }, process.cwd());
+        expect(roots.client).toHaveLength(1);
+        expect(roots.client[0]).toMatch(/node_modules[\/\\]glob$/);
+        expect(roots.worker).toHaveLength(1);
+        expect(roots.worker[0]).toMatch(/node_modules[\/\\]this-package-does-not-exist$/);
+    });
+});
+describe("isExcludedFromOptimization", () => {
+    it("should match files under an excluded root", () => {
+        expect(isExcludedFromOptimization("/project/node_modules/foo/index.js", [
+            "/project/node_modules/foo",
+        ])).toBe(true);
+    });
+    it("should not match files outside excluded roots", () => {
+        expect(isExcludedFromOptimization("/project/node_modules/bar/index.js", [
+            "/project/node_modules/foo",
+        ])).toBe(false);
+    });
+    it("should handle roots without trailing separators", () => {
+        expect(isExcludedFromOptimization("/project/node_modules/foo/index.js", [
+            "/project/node_modules/foo/",
+        ])).toBe(true);
+    });
+    it("should resolve root-relative files against the project root", () => {
+        expect(isExcludedFromOptimization("node_modules/foo/index.js", ["/project/node_modules/foo"], "/project")).toBe(true);
+    });
+    it("should match Vite-style project-relative paths", () => {
+        expect(isExcludedFromOptimization("/node_modules/foo/index.js", ["/project/node_modules/foo"], "/project")).toBe(true);
+    });
+    it("should still match external absolute paths that share no common root", () => {
+        expect(isExcludedFromOptimization("/Users/chris/other/lib/index.js", ["/Users/chris/other/lib"], "/Users/chris/project")).toBe(true);
+    });
+    it("should not match unrelated Vite-style paths", () => {
+        expect(isExcludedFromOptimization("/node_modules/bar/index.js", ["/project/node_modules/foo"], "/project")).toBe(false);
+    });
+});

package/package.json

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