rwsdk 1.4.1 → 1.5.0

package/dist/lib/e2e/environment.d.mts

@@ -5,7 +5,7 @@ export declare function getDirectoryHash(directory: string): Promise<string>;
 /**
  * Copy project to a temporary directory with a unique name
  */
-export declare function copyProjectToTempDir(projectDir: string, resourceUniqueKey: string, packageManager?: PackageManager, monorepoRoot?: string, installDependenciesRetries?: number): Promise<{
+export declare function copyProjectToTempDir(projectDir: string, resourceUniqueKey: string, packageManager?: PackageManager, monorepoRoot?: string, installDependenciesRetries?: number, viteVersion?: number): Promise<{
     tempDir: tmp.DirectoryResult;
     targetDir: string;
     workerName: string;

package/dist/lib/e2e/environment.mjs

@@ -136,7 +136,7 @@ const setTarballDependency = async (targetDir, tarballName) => {
 /**
  * Copy project to a temporary directory with a unique name
  */
-export async function copyProjectToTempDir(projectDir, resourceUniqueKey, packageManager, monorepoRoot, installDependenciesRetries) {
+export async function copyProjectToTempDir(projectDir, resourceUniqueKey, packageManager, monorepoRoot, installDependenciesRetries, viteVersion) {
     const { tarballPath, cleanupTarball } = await createSdkTarball();
     try {
         log("Creating temporary directory for project");
@@ -249,6 +249,33 @@ export async function copyProjectToTempDir(projectDir, resourceUniqueKey, packag
             log("Created .yarnrc with cache-folder for yarn-classic");
         }
         await setTarballDependency(targetDir, tarballFilename);
+        if (viteVersion === 7) {
+            log("Patching package.json for Vite 7 compatibility");
+            const pkgJsonPath = join(targetDir, "package.json");
+            const pkgJson = JSON.parse(await fs.promises.readFile(pkgJsonPath, "utf-8"));
+            pkgJson.devDependencies ??= {};
+            pkgJson.devDependencies.vite = "~7.3.5";
+            pkgJson.devDependencies["@vitejs/plugin-react"] = "~5.1.4";
+            await fs.promises.writeFile(pkgJsonPath, JSON.stringify(pkgJson, null, 2));
+            const viteConfigExtensions = [".mts", ".ts", ".js", ".mjs", ".cjs"];
+            let viteConfigPath;
+            for (const ext of viteConfigExtensions) {
+                const candidate = join(targetDir, `vite.config${ext}`);
+                if (await pathExists(candidate)) {
+                    viteConfigPath = candidate;
+                    break;
+                }
+            }
+            if (viteConfigPath) {
+                log("Patching %s to include @vitejs/plugin-react", basename(viteConfigPath));
+                let viteConfig = await fs.promises.readFile(viteConfigPath, "utf-8");
+                if (!viteConfig.includes("@vitejs/plugin-react")) {
+                    viteConfig = `import react from "@vitejs/plugin-react";\n${viteConfig}`;
+                    viteConfig = viteConfig.replace(/plugins:\s*\[/, "plugins: [\n    react(),");
+                    await fs.promises.writeFile(viteConfigPath, viteConfig);
+                }
+            }
+        }
         // Install dependencies in the target directory
         const installDir = monorepoRoot ? tempCopyRoot : targetDir;
         await retry(() => installDependencies(installDir, packageManager, projectDir, monorepoRoot), {

package/dist/lib/e2e/tarball.d.mts

@@ -2,6 +2,7 @@ interface SetupTarballOptions {
     projectDir: string;
     monorepoRoot?: string;
     packageManager?: "pnpm" | "npm" | "yarn" | "yarn-classic";
+    viteVersion?: number;
 }
 interface TarballEnvironment {
     targetDir: string;
@@ -10,5 +11,5 @@ interface TarballEnvironment {
 /**
  * Creates a tarball-based test environment similar to the release script approach
  */
-export declare function setupTarballEnvironment({ projectDir, monorepoRoot, packageManager, }: SetupTarballOptions): Promise<TarballEnvironment>;
+export declare function setupTarballEnvironment({ projectDir, monorepoRoot, packageManager, viteVersion, }: SetupTarballOptions): Promise<TarballEnvironment>;
 export {};

package/dist/lib/e2e/tarball.mjs

@@ -65,7 +65,7 @@ async function copyWranglerCache(targetDir, sdkRoot) {
 /**
  * Creates a tarball-based test environment similar to the release script approach
  */
-export async function setupTarballEnvironment({ projectDir, monorepoRoot, packageManager = "pnpm", }) {
+export async function setupTarballEnvironment({ projectDir, monorepoRoot, packageManager = "pnpm", viteVersion, }) {
     log(`🚀 Setting up tarball environment for ${projectDir}`);
     // Generate a resource unique key for this test run
     // Use just the hash to keep worker names short (under Cloudflare's 54 char limit)
@@ -75,7 +75,7 @@ export async function setupTarballEnvironment({ projectDir, monorepoRoot, packag
         .substring(0, 8);
     const resourceUniqueKey = hash;
     try {
-        const { tempDir, targetDir } = await copyProjectToTempDir(projectDir, resourceUniqueKey, packageManager, monorepoRoot);
+        const { tempDir, targetDir } = await copyProjectToTempDir(projectDir, resourceUniqueKey, packageManager, monorepoRoot, undefined, viteVersion);
         // Copy wrangler cache to improve deployment performance
         const sdkRoot = ROOT_DIR;
         await copyWranglerCache(targetDir, sdkRoot);

package/dist/lib/e2e/testHarness.d.mts

@@ -45,6 +45,11 @@ export interface SetupPlaygroundEnvironmentOptions {
      * @default true
      */
     autoStartDevServer?: boolean;
+    /**
+     * Major Vite version to test against. When set to 7, the test project
+     * is patched to use Vite 7 + @vitejs/plugin-react 5.
+     */
+    viteVersion?: number;
 }
 /**
  * A Vitest hook that sets up a playground environment for a test file.

package/dist/lib/e2e/testHarness.mjs

@@ -109,9 +109,13 @@ function getPlaygroundDirFromImportMeta(importMetaUrl) {
  * This ensures that tests run in a clean, isolated environment.
  */
 export function setupPlaygroundEnvironment(options) {
-    const { sourceProjectDir, monorepoRoot, dev = true, deploy = true, autoStartDevServer = true, } = typeof options === "string"
+    const { sourceProjectDir, monorepoRoot, dev = true, deploy = true, autoStartDevServer = true, viteVersion: explicitViteVersion, } = typeof options === "string"
         ? { sourceProjectDir: options, autoStartDevServer: true }
         : options;
+    const envViteVersion = process.env.RWSDK_VITE_VERSION
+        ? Number(process.env.RWSDK_VITE_VERSION)
+        : undefined;
+    const viteVersion = explicitViteVersion ?? envViteVersion;
     ensureHooksRegistered();
     beforeAll(async () => {
         let projectDir;
@@ -132,6 +136,7 @@ export function setupPlaygroundEnvironment(options) {
                 projectDir,
                 monorepoRoot,
                 packageManager: process.env.PACKAGE_MANAGER || "pnpm",
+                viteVersion,
             });
             globalDevPlaygroundEnv = {
                 projectDir: devEnv.targetDir,
@@ -156,6 +161,7 @@ export function setupPlaygroundEnvironment(options) {
                 projectDir,
                 monorepoRoot,
                 packageManager: process.env.PACKAGE_MANAGER || "pnpm",
+                viteVersion,
             });
             globalDeployPlaygroundEnv = {
                 projectDir: deployEnv.targetDir,

package/dist/lib/smokeTests/environment.mjs

@@ -11,6 +11,7 @@ export async function setupTestEnvironment(options = {}) {
     const tarballEnv = await setupTarballEnvironment({
         projectDir: options.projectDir,
         packageManager: options.packageManager,
+        viteVersion: options.viteVersion,
     });
     const resources = {
         tempDirCleanup: tarballEnv.cleanup,

package/dist/lib/smokeTests/types.d.mts

@@ -26,6 +26,7 @@ export interface SmokeTestOptions {
     skipHmr?: boolean;
     skipStyleTests?: boolean;
     packageManager?: PackageManager;
+    viteVersion?: number;
 }
 export interface TestResources {
     tempDirCleanup?: () => Promise<void>;

package/dist/runtime/render/assembleDocument.js

@@ -17,6 +17,6 @@ export const assembleDocument = ({ requestInfo, pageElement, shouldSSR, }) => {
     };
     const Document = requestInfo.rw.Document;
     return (_jsxs(Document, { ...requestInfo, children: [_jsx("script", { nonce: requestInfo.rw.nonce, dangerouslySetInnerHTML: {
-                    __html: `globalThis.__RWSDK_CONTEXT = ${JSON.stringify(clientContext)}`,
+                    __html: `globalThis.__RWSDK_CONTEXT = ${JSON.stringify(clientContext)};if(!globalThis.__webpack_require__){globalThis.__webpack_require__=function(id){throw new Error("rwsdk: __webpack_require__ called before client init for: "+id)};globalThis.__webpack_require__.u=function(){}}`,
                 } }), _jsx(Stylesheets, { requestInfo: requestInfo }), _jsx(Preloads, { requestInfo: requestInfo }), _jsx("div", { id: "hydrate-root", children: pageElement })] }));
 };

package/dist/runtime/render/renderDocumentHtmlStream.js

@@ -20,7 +20,7 @@ export const renderDocumentHtmlStream = async ({ rscPayloadStream, Document, req
     };
     // Create the outer document with a marker for injection
     const documentElement = (_jsxs(Document, { ...requestInfo, children: [_jsx("script", { nonce: requestInfo.rw.nonce, dangerouslySetInnerHTML: {
-                    __html: `globalThis.__RWSDK_CONTEXT = ${JSON.stringify(clientContext)}`,
+                    __html: `globalThis.__RWSDK_CONTEXT = ${JSON.stringify(clientContext)};if(!globalThis.__webpack_require__){globalThis.__webpack_require__=function(id){throw new Error("rwsdk: __webpack_require__ called before client init for: "+id)};globalThis.__webpack_require__.u=function(){}}`,
                 } }), _jsx(Stylesheets, { requestInfo: requestInfo }), _jsx(Preloads, { requestInfo: requestInfo }), _jsx("div", { id: "hydrate-root", children: _jsx("div", { id: "rwsdk-app-start" }) })] }));
     const outerHtmlStream = await renderHtmlStream({
         node: documentElement,

package/dist/runtime/render/stylesheets.js

@@ -23,6 +23,20 @@ const findCssForModule = (scriptId, manifest) => {
                 css.add(href);
             }
         }
+        // context(justinvdm, 2026-04-23): Rolldown associates CSS with the
+        // chunk that imports the CSS file, which may be a dynamic import target
+        // rather than the entry chunk. Walk both static and dynamic imports to
+        // find CSS from transitive dependencies.
+        if (entry.imports) {
+            for (const importId of entry.imports) {
+                inner(importId);
+            }
+        }
+        if (entry.dynamicImports) {
+            for (const importId of entry.dynamicImports) {
+                inner(importId);
+            }
+        }
     };
     inner(scriptId);
     return Array.from(css);
@@ -37,5 +51,13 @@ export const Stylesheets = async ({ requestInfo, }) => {
             allStylesheets.add(toAbsoluteHref(entry));
         }
     }
+    for (const [, entry] of Object.entries(manifest)) {
+        if (entry.isEntry) {
+            const css = findCssForModule(entry.src ?? "", manifest);
+            for (const href of css) {
+                allStylesheets.add(toAbsoluteHref(href));
+            }
+        }
+    }
     return (_jsx(_Fragment, { children: Array.from(allStylesheets).map((href) => (_jsx("link", { rel: "stylesheet", href: href, precedence: "first" }, href))) }));
 };

package/dist/scripts/smoke-test.mjs

@@ -77,6 +77,13 @@ if (fileURLToPath(import.meta.url) === process.argv[1]) {
         else if (arg === "--realtime") {
             options.realtime = true;
         }
+        else if (arg.startsWith("--vite-version=")) {
+            const version = parseInt(arg.substring(15), 10);
+            if (Number.isNaN(version) || version <= 0) {
+                throw new Error(`Invalid Vite version: ${arg}`);
+            }
+            options.viteVersion = version;
+        }
         else if (arg === "--help" || arg === "-h") {
             // Display help text
             console.log(`
@@ -99,6 +106,7 @@ Options:
   --bail                  Stop on first test failure
   --copy-project          Copy the project to the artifacts directory
   --realtime              Only run realtime smoke tests, skip initial tests
+  --vite-version=VERSION  Major Vite version to test against (default: current, e.g. --vite-version=7)
   --help                  Show this help message
 `);
             process.exit(0);

package/dist/vite/addOptimizeDepsPlugin.d.mts

@@ -0,0 +1,10 @@
+import type { EnvironmentOptions } from "vite";
+interface OptimizeDepsPlugin {
+    name: string;
+    resolveId?: (id: string, importer: string | undefined, opts: {
+        kind: string;
+    }) => any;
+    load?: (id: string) => any;
+}
+export declare function addOptimizeDepsPlugin(config: EnvironmentOptions, plugin: OptimizeDepsPlugin): void;
+export {};

package/dist/vite/addOptimizeDepsPlugin.mjs

@@ -0,0 +1,6 @@
+export function addOptimizeDepsPlugin(config, plugin) {
+    config.optimizeDeps ??= {};
+    config.optimizeDeps.rolldownOptions ??= {};
+    config.optimizeDeps.rolldownOptions.plugins ??= [];
+    config.optimizeDeps.rolldownOptions.plugins.push(plugin);
+}

package/dist/vite/buildApp.mjs

@@ -25,20 +25,20 @@ export async function buildApp({ builder, clientEntryPoints, clientFiles, server
             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,
-                },
-            },
+        // context(justinvdm, 2026-05-13): Mutate the resolved build config in
+        // place rather than replacing the build object. Creating a new object
+        // loses Vite's rolldownOptions compat proxy, so we save and restore
+        // individual properties instead.
+        const originalWrite = workerEnv.config.build.write;
+        const originalInput = workerEnv.config.build.rolldownOptions.input;
+        workerEnv.config.build.write = false;
+        workerEnv.config.build.rolldownOptions.input = {
+            index: tempEntryPath,
         };
         await builder.build(workerEnv);
         // Restore the original config
-        workerEnv.config.build = originalWorkerBuildConfig;
+        workerEnv.config.build.write = originalWrite;
+        workerEnv.config.build.rolldownOptions.input = originalInput;
     }
     finally {
         await rm(tempEntryPath, { force: true });
@@ -51,6 +51,19 @@ export async function buildApp({ builder, clientEntryPoints, clientFiles, server
         entries: [workerEntryPathname],
         esbuildOptions,
     });
+    // context(justinvdm, 2026-05-13): In Vite 8 (Rolldown), the worker build
+    // fragments into hundreds of tiny chunks by default. Disabling code
+    // splitting forces a single consolidated intermediate worker file, matching
+    // the architecture's expectation of an intermediate `worker.js` and
+    // preventing leftover artifacts from cluttering the final output.
+    workerEnv.config.build.rolldownOptions.output ??= {};
+    if (Array.isArray(workerEnv.config.build.rolldownOptions.output)) {
+        workerEnv.config.build.rolldownOptions.output.forEach((o) => (o.codeSplitting = false));
+    }
+    else {
+        workerEnv.config.build.rolldownOptions.output.codeSplitting =
+            false;
+    }
     console.log("Building worker...");
     process.env.RWSDK_BUILD_PASS = "worker";
     await builder.build(workerEnv);
@@ -61,14 +74,14 @@ export async function buildApp({ builder, clientEntryPoints, clientFiles, server
     console.log("Building client...");
     const clientEnv = builder.environments["client"];
     clientEnv.config.build ??= {};
-    clientEnv.config.build.rollupOptions ??= {};
+    clientEnv.config.build.rolldownOptions ??= {};
     const clientEntryPointsArray = Array.from(clientEntryPoints);
     if (clientEntryPointsArray.length === 0) {
         log("No client entry points discovered, using default: src/client.tsx");
-        clientEnv.config.build.rollupOptions.input = ["src/client.tsx"];
+        clientEnv.config.build.rolldownOptions.input = ["src/client.tsx"];
     }
     else {
-        clientEnv.config.build.rollupOptions.input = clientEntryPointsArray;
+        clientEnv.config.build.rolldownOptions.input = clientEntryPointsArray;
     }
     await builder.build(clientEnv);
     console.log("Linking worker build...");
@@ -82,10 +95,36 @@ export async function buildApp({ builder, clientEntryPoints, clientFiles, server
     // directly. Instead, we re-point the original entry to the intermediate
     // worker bundle from the first pass. This allows the linker pass to re-use
     // the same plugin-driven configuration while bundling the final worker.
-    workerConfig.build.rollupOptions.input = {
+    workerConfig.build.rolldownOptions.input = {
         index: resolve(projectRootDir, "dist", "worker", "index.js"),
     };
+    // context(justinvdm, 2026-05-13): In Vite 8 (Rolldown), the linker pass
+    // was producing hundreds of tiny chunks instead of a single consolidated
+    // worker bundle. Setting codeSplitting:false forces all code (including
+    // dynamic imports from the intermediate worker artifact) into the entry
+    // chunk, restoring the single-file worker output the architecture expects.
+    workerConfig.build.rolldownOptions.output ??= {};
+    if (Array.isArray(workerConfig.build.rolldownOptions.output)) {
+        workerConfig.build.rolldownOptions.output.forEach((o) => (o.codeSplitting = false));
+    }
+    else {
+        workerConfig.build.rolldownOptions.output.codeSplitting = false;
+    }
     await builder.build(workerEnv);
+    // Remove first-pass JS artifacts that are now inlined into the final worker
+    // bundle. Without this cleanup, ~480 leftover chunks from the first pass
+    // clutter dist/worker/assets/ and inflate deployment file counts.
+    const workerAssetsDir = resolve(projectRootDir, "dist", "worker", "assets");
+    try {
+        for (const entry of await readdir(workerAssetsDir)) {
+            if (entry.endsWith(".js") || entry.endsWith(".js.map")) {
+                await rm(join(workerAssetsDir, entry), { force: true });
+            }
+        }
+    }
+    catch {
+        // Directory may not exist (e.g. if the app has no worker assets)
+    }
     console.log("Build complete!");
     // context(zshannon, 16 Mar 2026): Nest client output under base subdirectory
     // for Cloudflare's assets module, which maps URL paths directly to file paths.

package/dist/vite/configPlugin.mjs

@@ -50,11 +50,13 @@ export const configPlugin = ({ silent, projectRootDir, workerEntryPathname, clie
                 ],
                 exclude: [],
                 entries: [workerEntryPathname],
-                esbuildOptions: {
-                    jsx: "automatic",
-                    jsxImportSource: "react",
-                    define: {
-                        "process.env.NODE_ENV": JSON.stringify(mode),
+                rolldownOptions: {
+                    transform: {
+                        jsx: "react-jsx",
+                        define: {
+                            "process.env.NODE_ENV": JSON.stringify(mode),
+                            "__webpack_require__": "globalThis.__webpack_require__",
+                        },
                     },
                 },
             },
@@ -70,6 +72,9 @@ export const configPlugin = ({ silent, projectRootDir, workerEntryPathname, clie
             appType: "custom",
             mode,
             logLevel: silent ? "silent" : "info",
+            resolve: {
+                tsconfigPaths: true,
+            },
             build: {
                 minify: mode !== "development",
                 sourcemap,
@@ -86,7 +91,7 @@ export const configPlugin = ({ silent, projectRootDir, workerEntryPathname, clie
                     build: {
                         outDir: resolve(projectRootDir, "dist", "client"),
                         manifest: true,
-                        rollupOptions: {
+                        rolldownOptions: {
                             input: [],
                         },
                     },
@@ -105,12 +110,13 @@ export const configPlugin = ({ silent, projectRootDir, workerEntryPathname, clie
                             "rwsdk/use-synced-state/client",
                         ],
                         entries: [],
-                        esbuildOptions: {
-                            jsx: "automatic",
-                            jsxImportSource: "react",
-                            plugins: [],
-                            define: {
-                                "process.env.NODE_ENV": JSON.stringify(mode),
+                        rolldownOptions: {
+                            transform: {
+                                jsx: "react-jsx",
+                                define: {
+                                    "process.env.NODE_ENV": JSON.stringify(mode),
+                                    "__webpack_require__": "globalThis.__webpack_require__",
+                                },
                             },
                         },
                     },
@@ -143,12 +149,13 @@ export const configPlugin = ({ silent, projectRootDir, workerEntryPathname, clie
                             "rwsdk/realtime/worker",
                             "rwsdk/use-synced-state/client",
                         ],
-                        esbuildOptions: {
-                            jsx: "automatic",
-                            jsxImportSource: "react",
-                            plugins: [],
-                            define: {
-                                "process.env.NODE_ENV": JSON.stringify(mode),
+                        rolldownOptions: {
+                            transform: {
+                                jsx: "react-jsx",
+                                define: {
+                                    "process.env.NODE_ENV": JSON.stringify(mode),
+                                    "__webpack_require__": "globalThis.__webpack_require__",
+                                },
                             },
                         },
                     },
@@ -161,7 +168,7 @@ export const configPlugin = ({ silent, projectRootDir, workerEntryPathname, clie
                             fileName: () => path.basename(INTERMEDIATE_SSR_BRIDGE_PATH),
                         },
                         outDir: path.dirname(INTERMEDIATE_SSR_BRIDGE_PATH),
-                        rollupOptions: {
+                        rolldownOptions: {
                             output: {
                                 // context(justinvdm, 15 Sep 2025): The SSR bundle is a
                                 // pre-compiled artifact. When the linker pass bundles it into
@@ -176,7 +183,7 @@ export const configPlugin = ({ silent, projectRootDir, workerEntryPathname, clie
                                 // 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,
+                                codeSplitting: false,
                             },
                             plugins: [ssrBridgeWrapPlugin()],
                         },

package/dist/vite/createDirectiveLookupPlugin.mjs

@@ -1,6 +1,7 @@
 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, }) {
     const s = new MagicString(`
@@ -55,32 +56,27 @@ export const createDirectiveLookupPlugin = async ({ projectRootDir, files, confi
                 return;
             }
             log("Configuring environment: env=%s", env);
-            viteConfig.optimizeDeps ??= {};
-            viteConfig.optimizeDeps.esbuildOptions ??= {};
-            viteConfig.optimizeDeps.esbuildOptions.plugins ??= [];
-            viteConfig.optimizeDeps.esbuildOptions.plugins.push({
+            const escapedVirtualModuleName = config.virtualModuleName.replace(/[-\/\\^$*+?.()|[\]{}]/g, "\\$&");
+            const escapedPrefixedModuleName = `/@id/${config.virtualModuleName}`.replace(/[-\/\\^$*+?.()|[\]{}]/g, "\\$&");
+            const lookupFilter = new RegExp(`^(${escapedVirtualModuleName}|${escapedPrefixedModuleName})\\.js$`);
+            addOptimizeDepsPlugin(viteConfig, {
                 name: `rwsdk:${config.pluginName}`,
-                setup(build) {
-                    log("Setting up esbuild plugin for %s", config.virtualModuleName);
-                    // Handle both direct virtual module name and /@id/ prefixed version
-                    const escapedVirtualModuleName = config.virtualModuleName.replace(/[-\/\\^$*+?.()|[\]{}]/g, "\\$&");
-                    const escapedPrefixedModuleName = `/@id/${config.virtualModuleName}`.replace(/[-\/\\^$*+?.()|[\]{}]/g, "\\$&");
-                    build.onResolve({
-                        filter: new RegExp(`^(${escapedVirtualModuleName}|${escapedPrefixedModuleName})\\.js$`),
-                    }, () => {
+                resolveId(id) {
+                    if (lookupFilter.test(id)) {
                         process.env.VERBOSE &&
-                            log("Esbuild onResolve: marking %s as external", config.virtualModuleName);
+                            log("Marking %s as external", config.virtualModuleName);
                         return {
-                            path: `${config.virtualModuleName}.js`,
+                            id: `${config.virtualModuleName}.js`,
                             external: true,
                         };
-                    });
+                    }
                 },
             });
             const shouldOptimizeForEnv = !config.optimizeForEnvironments ||
                 config.optimizeForEnvironments.includes(env);
             if (shouldOptimizeForEnv) {
                 log("Applying optimizeDeps and aliasing for environment: %s", env);
+                viteConfig.optimizeDeps ??= {};
                 viteConfig.optimizeDeps.include ??= [];
                 for (const file of files) {
                     if (file.includes("node_modules")) {