rwsdk 0.1.16 → 0.1.17-test.20250715200658

package/dist/vite/configPlugin.mjs

@@ -0,0 +1,169 @@
+import path, { resolve } from "node:path";
+import { builtinModules } from "node:module";
+import enhancedResolve from "enhanced-resolve";
+import { SSR_BRIDGE_PATH } from "../lib/constants.mjs";
+// 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, clientEntryPathnames, workerEntryPathname, }) => ({
+    name: "rwsdk:config",
+    config: async (_) => {
+        const mode = process.env.NODE_ENV;
+        const baseConfig = {
+            appType: "custom",
+            mode,
+            logLevel: silent ? "silent" : "info",
+            build: {
+                minify: mode !== "development",
+                sourcemap: true,
+            },
+            define: {
+                "process.env.NODE_ENV": JSON.stringify(mode),
+            },
+            ssr: {
+                target: "webworker",
+            },
+            environments: {
+                client: {
+                    consumer: "client",
+                    build: {
+                        outDir: resolve(projectRootDir, "dist", "client"),
+                        manifest: true,
+                        rollupOptions: {
+                            input: clientEntryPathnames,
+                        },
+                    },
+                    define: {
+                        "import.meta.env.RWSDK_ENV": JSON.stringify("client"),
+                    },
+                    optimizeDeps: {
+                        noDiscovery: false,
+                        include: ["rwsdk/client"],
+                        esbuildOptions: {
+                            jsx: "automatic",
+                            jsxImportSource: "react",
+                            plugins: [],
+                            define: {
+                                "process.env.NODE_ENV": JSON.stringify(mode),
+                            },
+                        },
+                    },
+                    resolve: {
+                        conditions: ["browser", "module"],
+                    },
+                },
+                ssr: {
+                    resolve: {
+                        conditions: ["workerd", "module", "browser"],
+                        noExternal: true,
+                    },
+                    define: {
+                        "import.meta.env.RWSDK_ENV": JSON.stringify("ssr"),
+                    },
+                    optimizeDeps: {
+                        noDiscovery: false,
+                        entries: [workerEntryPathname],
+                        exclude: externalModules,
+                        include: ["rwsdk/__ssr", "rwsdk/__ssr_bridge"],
+                        esbuildOptions: {
+                            jsx: "automatic",
+                            jsxImportSource: "react",
+                            plugins: [],
+                            define: {
+                                "process.env.NODE_ENV": JSON.stringify(mode),
+                            },
+                        },
+                    },
+                    build: {
+                        lib: {
+                            entry: {
+                                [path.basename(SSR_BRIDGE_PATH, ".js")]: enhancedResolve.sync(projectRootDir, "rwsdk/__ssr_bridge"),
+                            },
+                            formats: ["es"],
+                            fileName: () => path.basename(SSR_BRIDGE_PATH),
+                        },
+                        outDir: path.dirname(SSR_BRIDGE_PATH),
+                    },
+                },
+                worker: {
+                    resolve: {
+                        conditions: [
+                            "workerd",
+                            "react-server",
+                            "module",
+                            // context(justinvdm, 11 Jun 2025): Some packages meant for cloudflare workers, yet
+                            // their deps have only node import conditions, e.g. `agents` package (meant for CF),
+                            // has `pkce-challenge` package as a dep, which has only node import conditions.
+                            // https://github.com/crouchcd/pkce-challenge/blob/master/package.json#L17
+                            //
+                            // @cloudflare/vite-plugin should take care of any relevant polyfills for deps with
+                            // node builtins imports that can be polyfilled though, so it is worth us including this condition here.
+                            // However, it does mean we will try to run packages meant for node that cannot be run on cloudflare workers.
+                            // That's the trade-off, but arguably worth it.
+                            "node",
+                        ],
+                        noExternal: true,
+                    },
+                    define: {
+                        "import.meta.env.RWSDK_ENV": JSON.stringify("worker"),
+                    },
+                    optimizeDeps: {
+                        noDiscovery: false,
+                        include: ["rwsdk/worker"],
+                        exclude: [],
+                        entries: [workerEntryPathname],
+                        esbuildOptions: {
+                            jsx: "automatic",
+                            jsxImportSource: "react",
+                            define: {
+                                "process.env.NODE_ENV": JSON.stringify(mode),
+                            },
+                        },
+                    },
+                    build: {
+                        outDir: resolve(projectRootDir, "dist", "worker"),
+                        emitAssets: true,
+                        ssr: true,
+                        rollupOptions: {
+                            output: {
+                                inlineDynamicImports: true,
+                            },
+                            input: {
+                                worker: workerEntryPathname,
+                            },
+                        },
+                    },
+                },
+            },
+            server: {
+                hmr: true,
+            },
+            builder: {
+                buildApp: async (builder) => {
+                    // note(justinvdm, 27 May 2025): **Ordering is important**:
+                    // * When building, client needs to be build first, so that we have a
+                    //   manifest file to map to when looking at asset references in JSX
+                    //   (e.g. Document.tsx)
+                    // * When bundling, the RSC build imports the SSR build - this way
+                    //   they each can have their own environments (e.g. with their own
+                    //   import conditions), while still having all worker-run code go
+                    //   through the processing done by `@cloudflare/vite-plugin`
+                    await builder.build(builder.environments["client"]);
+                    await builder.build(builder.environments["ssr"]);
+                    await builder.build(builder.environments["worker"]);
+                },
+            },
+        };
+        return baseConfig;
+    },
+});

package/dist/vite/createDirectiveLookupPlugin.d.mts

@@ -0,0 +1,21 @@
+import { Plugin } from "vite";
+interface DirectiveLookupConfig {
+    kind: "client" | "server";
+    directive: "use client" | "use server";
+    virtualModuleName: string;
+    exportName: string;
+    pluginName: string;
+    optimizeForEnvironments?: string[];
+}
+export declare const findFilesContainingDirective: ({ projectRootDir, files, directive, debugNamespace, }: {
+    projectRootDir: string;
+    files: Set<string>;
+    directive: string;
+    debugNamespace: string;
+}) => Promise<void>;
+export declare const createDirectiveLookupPlugin: ({ projectRootDir, files, config, }: {
+    projectRootDir: string;
+    files: Set<string>;
+    config: DirectiveLookupConfig;
+}) => Promise<Plugin>;
+export {};

package/dist/vite/createDirectiveLookupPlugin.mjs

@@ -0,0 +1,231 @@
+import MagicString from "magic-string";
+import path from "path";
+import { readFile } from "fs/promises";
+import debug from "debug";
+import { normalizeModulePath } from "./normalizeModulePath.mjs";
+import { pathExists } from "fs-extra";
+import { stat } from "fs/promises";
+import { getSrcPaths } from "../lib/getSrcPaths.js";
+import { hasDirective } from "./hasDirective.mjs";
+export const findFilesContainingDirective = async ({ projectRootDir, files, directive, debugNamespace, }) => {
+    const log = debug(debugNamespace);
+    log("Starting search for '%s' files in projectRootDir=%s", directive, projectRootDir);
+    const filesToScan = await getSrcPaths(projectRootDir);
+    log("Found %d files to scan for '%s' directive", filesToScan.length, directive);
+    for (const file of filesToScan) {
+        try {
+            const stats = await stat(file);
+            if (!stats.isFile()) {
+                process.env.VERBOSE && log("Skipping %s (not a file)", file);
+                continue;
+            }
+            process.env.VERBOSE && log("Scanning file: %s", file);
+            const content = await readFile(file, "utf-8");
+            if (hasDirective(content, directive)) {
+                const normalizedPath = normalizeModulePath(projectRootDir, file);
+                log("Found '%s' directive in file: %s -> %s", directive, file, normalizedPath);
+                files.add(normalizedPath);
+            }
+        }
+        catch (error) {
+            console.error(`Error reading file ${file}:`, error);
+        }
+    }
+    log("Completed scan. Found %d %s files total", files.size, directive);
+    process.env.VERBOSE &&
+        log("Found files for %s: %j", directive, Array.from(files));
+};
+const resolveOptimizedDep = async (projectRootDir, id, environment, debugNamespace) => {
+    const log = debug(debugNamespace);
+    try {
+        const depsDir = environment === "client" ? "deps" : `deps_${environment}`;
+        const nodeModulesDepsDirPath = path.join("node_modules", ".vite", depsDir);
+        const depsDirPath = path.join(projectRootDir, nodeModulesDepsDirPath);
+        const manifestPath = path.join(depsDirPath, "_metadata.json");
+        log("Checking for manifest at: %s", manifestPath);
+        const manifestExists = await pathExists(manifestPath);
+        if (!manifestExists) {
+            log("Manifest not found at %s", manifestPath);
+            return undefined;
+        }
+        const manifestContent = await readFile(manifestPath, "utf-8");
+        const manifest = JSON.parse(manifestContent);
+        if (manifest.optimized && manifest.optimized[id]) {
+            const optimizedFile = manifest.optimized[id].file;
+            const optimizedPath = path.join("/", nodeModulesDepsDirPath, optimizedFile);
+            log("Found optimized dependency: filePath=%s, optimizedPath=%s", id, optimizedPath);
+            return optimizedPath;
+        }
+        process.env.VERBOSE &&
+            log("File not found in optimized dependencies: id=%s", id);
+        return undefined;
+    }
+    catch (error) {
+        process.env.VERBOSE &&
+            log("Error resolving optimized dependency for id=%s: %s", id, error);
+        return undefined;
+    }
+};
+const addOptimizedDepsEntries = async ({ projectRootDir, directive, environment, debugNamespace, files, }) => {
+    const log = debug(debugNamespace);
+    try {
+        const depsDir = environment === "client" ? "deps" : `deps_${environment}`;
+        const depsDirPath = path.join(projectRootDir, "node_modules", ".vite", depsDir);
+        const manifestPath = path.join(depsDirPath, "_metadata.json");
+        process.env.VERBOSE && log("Checking for manifest at: %s", manifestPath);
+        const manifestExists = await pathExists(manifestPath);
+        if (!manifestExists) {
+            process.env.VERBOSE && log("Manifest not found at %s", manifestPath);
+            return;
+        }
+        const manifestContent = await readFile(manifestPath, "utf-8");
+        const manifest = JSON.parse(manifestContent);
+        for (const entryId of Object.keys(manifest.optimized)) {
+            if (entryId.startsWith("/node_modules/")) {
+                const srcPath = manifest.optimized[entryId].src;
+                const resolvedSrcPath = path.resolve(projectRootDir, "node_modules", ".vite", "deps", srcPath);
+                let contents;
+                try {
+                    contents = await readFile(resolvedSrcPath, "utf-8");
+                }
+                catch (error) {
+                    process.env.VERBOSE &&
+                        log("Error reading file %s: %s", resolvedSrcPath, error);
+                    continue;
+                }
+                if (hasDirective(contents, directive)) {
+                    log("Adding optimized entry to files: %s", entryId);
+                    files.add(entryId);
+                }
+                else {
+                    log("Skipping optimized entry %s because it does not contain the '%s' directive", entryId, directive);
+                }
+            }
+        }
+    }
+    catch (error) {
+        process.env.VERBOSE &&
+            log("Error adding optimized deps entries: %s", error);
+    }
+};
+export const createDirectiveLookupPlugin = async ({ projectRootDir, files, config, }) => {
+    const debugNamespace = `rwsdk:vite:${config.pluginName}`;
+    const log = debug(debugNamespace);
+    let isDev = false;
+    log("Initializing %s plugin with projectRootDir=%s", config.pluginName, projectRootDir);
+    await findFilesContainingDirective({
+        projectRootDir,
+        files,
+        directive: config.directive,
+        debugNamespace,
+    });
+    let devServer;
+    return {
+        name: `rwsdk:${config.pluginName}`,
+        config(_, { command, isPreview }) {
+            isDev = !isPreview && command === "serve";
+            log("Development mode: %s", isDev);
+        },
+        configureServer(server) {
+            devServer = server;
+        },
+        async configEnvironment(env, viteConfig) {
+            log("Configuring environment: env=%s", env);
+            // Add optimized deps entries that match our pattern
+            await addOptimizedDepsEntries({
+                projectRootDir,
+                files,
+                directive: config.directive,
+                environment: env,
+                debugNamespace,
+            });
+            viteConfig.optimizeDeps ??= {};
+            viteConfig.optimizeDeps.esbuildOptions ??= {};
+            viteConfig.optimizeDeps.esbuildOptions.plugins ??= [];
+            viteConfig.optimizeDeps.esbuildOptions.plugins.push({
+                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$`),
+                    }, () => {
+                        process.env.VERBOSE &&
+                            log("Esbuild onResolve: marking %s as external", config.virtualModuleName);
+                        return {
+                            path: `${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.include ??= [];
+                for (const file of files) {
+                    const actualFilePath = path.join(projectRootDir, file);
+                    process.env.VERBOSE &&
+                        log("Adding to optimizeDeps.entries: %s", actualFilePath);
+                    const entries = Array.isArray(viteConfig.optimizeDeps.entries)
+                        ? viteConfig.optimizeDeps.entries
+                        : [].concat(viteConfig.optimizeDeps.entries ?? []);
+                    viteConfig.optimizeDeps.entries = entries;
+                    entries.push(actualFilePath);
+                }
+                log("Environment configuration complete for env=%s", env);
+            }
+            else {
+                log("Skipping optimizeDeps and aliasing for environment: %s", env);
+            }
+        },
+        resolveId(source) {
+            process.env.VERBOSE && log("Resolving id=%s", source);
+            if (source === `${config.virtualModuleName}.js`) {
+                log("Resolving %s module", config.virtualModuleName);
+                // context(justinvdm, 16 Jun 2025): Include .js extension
+                // so it goes through vite processing chain
+                return source;
+            }
+            process.env.VERBOSE && log("No resolution for id=%s", source);
+        },
+        async load(id) {
+            process.env.VERBOSE && log("Loading id=%s", id);
+            if (id === config.virtualModuleName + ".js") {
+                log("Loading %s module with %d files", config.virtualModuleName, files.size);
+                const environment = this.environment?.name || "client";
+                log("Current environment: %s, isDev: %s", environment, isDev);
+                const optimizedDeps = {};
+                if (isDev && devServer) {
+                    for (const file of files) {
+                        const resolvedPath = await resolveOptimizedDep(projectRootDir, file, environment, debugNamespace);
+                        if (resolvedPath) {
+                            optimizedDeps[file] = resolvedPath;
+                        }
+                    }
+                }
+                const s = new MagicString(`
+export const ${config.exportName} = {
+  ${Array.from(files)
+                    .map((file) => `
+  "${file}": () => import("${optimizedDeps[file] ?? file}"),
+`)
+                    .join("")}
+};
+`);
+                const code = s.toString();
+                const map = s.generateMap();
+                log("Generated virtual module code length: %d", code.length);
+                process.env.VERBOSE && log("Generated virtual module code: %s", code);
+                return {
+                    code,
+                    map,
+                };
+            }
+            process.env.VERBOSE && log("No load handling for id=%s", id);
+        },
+    };
+};

package/dist/vite/devServerTimingPlugin.d.mts

@@ -0,0 +1,2 @@
+import { Plugin } from "vite";
+export declare const devServerTimingPlugin: () => Plugin;

package/dist/vite/devServerTimingPlugin.mjs

@@ -0,0 +1,24 @@
+import debug from "debug";
+const log = debug("rwsdk:vite:dev-server-timing-plugin");
+export const devServerTimingPlugin = () => {
+    const startTime = Date.now();
+    let hasLoggedFirstResponse = false;
+    return {
+        name: "rwsdk:dev-server-timing",
+        configureServer(server) {
+            server.middlewares.use((_req, res, next) => {
+                if (!hasLoggedFirstResponse) {
+                    res.on("finish", () => {
+                        if (!hasLoggedFirstResponse) {
+                            hasLoggedFirstResponse = true;
+                            const endTime = Date.now();
+                            const duration = endTime - startTime;
+                            log(`🚀 Dev server first response completed in ${duration}ms`);
+                        }
+                    });
+                }
+                next();
+            });
+        },
+    };
+};

package/dist/vite/directivesPlugin.d.mts

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

package/dist/vite/directivesPlugin.mjs

@@ -0,0 +1,200 @@
+import path from "node:path";
+import fs from "node:fs/promises";
+import debug from "debug";
+import { transformClientComponents } from "./transformClientComponents.mjs";
+import { transformServerFunctions } from "./transformServerFunctions.mjs";
+import { normalizeModulePath } from "./normalizeModulePath.mjs";
+const log = debug("rwsdk:vite:rsc-directives-plugin");
+const getLoader = (filePath) => {
+    const ext = path.extname(filePath).slice(1);
+    switch (ext) {
+        case "mjs":
+        case "cjs":
+            return "js";
+        case "mts":
+        case "cts":
+            return "ts";
+        case "jsx":
+            return "jsx";
+        case "tsx":
+            return "tsx";
+        case "ts":
+            return "ts";
+        case "js":
+        default:
+            return "js";
+    }
+};
+export const directivesPlugin = ({ projectRootDir, clientFiles, serverFiles, }) => {
+    let devServer;
+    let isAfterFirstResponse = false;
+    const addModule = (kind, environment, id) => {
+        const files = kind === "client" ? clientFiles : serverFiles;
+        const rawId = id.split("?")[0];
+        const resolvedId = rawId;
+        const relativePath = rawId.slice("/".length);
+        const fullPath = path.resolve(projectRootDir, relativePath);
+        const isNodeModule = id.includes("node_modules");
+        const hadFile = files.has(id);
+        log("Adding %s module to %s and invalidating cache: id=%s", kind, files, resolvedId);
+        files.add(resolvedId);
+        if (devServer && isNodeModule) {
+            const lookupModule = kind === "client"
+                ? "virtual:use-client-lookup"
+                : "virtual:use-server-lookup";
+            log("Registering missing import for %s module resolvedId=%s in environment %s, fullPath=%s", kind, resolvedId, environment, fullPath);
+            devServer.environments[environment].depsOptimizer?.registerMissingImport(resolvedId, fullPath);
+            if (isAfterFirstResponse && !hadFile) {
+                log("Invalidating cache for lookup module %s after adding module id=%s", lookupModule, id);
+            }
+        }
+    };
+    const addClientModule = (environment, id) => {
+        addModule("client", environment, id);
+    };
+    const addServerModule = (environment, id) => {
+        addModule("server", environment, id);
+    };
+    return {
+        name: "rwsdk:rsc-directives",
+        configureServer(server) {
+            devServer = server;
+            devServer.middlewares.use((_req, res, next) => {
+                // context(justinvdm, 15 Jun 2025): We want to watch for new client and server modules
+                // and invalidate their respective module lookups when this happens, but
+                // we only want to do this after the first render
+                if (!isAfterFirstResponse) {
+                    res.on("finish", () => {
+                        if (!isAfterFirstResponse) {
+                            isAfterFirstResponse = true;
+                            log("Dev server first response completed");
+                        }
+                    });
+                }
+                next();
+            });
+        },
+        async transform(code, id) {
+            process.env.VERBOSE &&
+                log("Transform called for id=%s, environment=%s", id, this.environment.name);
+            const normalizedId = normalizeModulePath(projectRootDir, id);
+            const clientResult = await transformClientComponents(code, normalizedId, {
+                environmentName: this.environment.name,
+                clientFiles,
+                addClientModule,
+            });
+            if (clientResult) {
+                log("Client component transformation successful for id=%s", id);
+                return {
+                    code: clientResult.code,
+                    map: clientResult.map,
+                };
+            }
+            const serverResult = transformServerFunctions(code, normalizedId, this.environment.name, serverFiles, addServerModule);
+            if (serverResult) {
+                log("Server function transformation successful for id=%s", id);
+                return {
+                    code: serverResult.code,
+                    map: serverResult.map,
+                };
+            }
+            process.env.VERBOSE && log("No transformation applied for id=%s", id);
+        },
+        configEnvironment(env, config) {
+            log("Configuring environment: env=%s", env);
+            config.optimizeDeps ??= {};
+            config.optimizeDeps.esbuildOptions ??= {};
+            config.optimizeDeps.esbuildOptions.plugins ??= [];
+            config.optimizeDeps.esbuildOptions.plugins.push({
+                name: "rsc-directives-esbuild-transform",
+                setup(build) {
+                    log("Setting up esbuild plugin for environment: %s", env);
+                    build.onLoad({ filter: /\.(js|ts|jsx|tsx|mts|mjs|cjs)$/ }, async (args) => {
+                        process.env.VERBOSE &&
+                            log("Esbuild onLoad called for environment=%s, path=%s", env, args.path);
+                        const normalizedPath = normalizeModulePath(projectRootDir, args.path);
+                        // context(justinvdm,2025-06-15): If we're in app code,
+                        // we will be doing the transform work in the vite plugin hooks,
+                        // the only reason we're in esbuild land for app code is for
+                        // dependency discovery, so we can skip transform work
+                        // and use heuristics instead - see below inside if block
+                        if (!args.path.includes("node_modules")) {
+                            log("Esbuild onLoad found app code, path=%s", args.path);
+                            if (clientFiles.has(normalizedPath)) {
+                                // context(justinvdm,2025-06-15): If this is a client file:
+                                // * for ssr and client envs we can skip so esbuild looks at the
+                                // original source code to discovery dependencies
+                                // * for worker env, the transform would have just created
+                                // references and dropped all imports, so we can just return empty code
+                                if (env === "client" || env === "ssr") {
+                                    log("Esbuild onLoad skipping client module in app code for client or ssr env, path=%s", args.path);
+                                    return undefined;
+                                }
+                                else {
+                                    log("Esbuild onLoad returning empty code for server module in app code for worker env, path=%s to bypass esbuild dependency discovery", args.path);
+                                    return {
+                                        contents: "",
+                                        loader: "js",
+                                    };
+                                }
+                            }
+                            else if (serverFiles.has(normalizedPath)) {
+                                // context(justinvdm,2025-06-15): If this is a server file:
+                                // * for worker env, we can skip so esbuild looks at the
+                                // original source code to discovery dependencies
+                                // * for ssr and client envs, the transform would have just created
+                                // references and dropped all imports, so we can just return empty code
+                                if (env === "worker") {
+                                    log("Esbuild onLoad skipping server module in app code for worker env, path=%s", args.path);
+                                    return undefined;
+                                }
+                                else if (env === "ssr" || env === "client") {
+                                    log("Esbuild onLoad returning empty code for server module in app code for ssr or client env, path=%s", args.path);
+                                    return {
+                                        contents: "",
+                                        loader: "js",
+                                    };
+                                }
+                            }
+                        }
+                        let code;
+                        try {
+                            code = await fs.readFile(args.path, "utf-8");
+                        }
+                        catch {
+                            process.env.VERBOSE &&
+                                log("Failed to read file: %s, environment=%s", args.path, env);
+                            return undefined;
+                        }
+                        const clientResult = await transformClientComponents(code, normalizedPath, {
+                            environmentName: env,
+                            clientFiles,
+                            isEsbuild: true,
+                            addClientModule,
+                        });
+                        if (clientResult) {
+                            log("Esbuild client component transformation successful for environment=%s, path=%s", env, args.path);
+                            process.env.VERBOSE &&
+                                log("Esbuild client component transformation for environment=%s, path=%s, code: %j", env, args.path, clientResult.code);
+                            return {
+                                contents: clientResult.code,
+                                loader: getLoader(args.path),
+                            };
+                        }
+                        const serverResult = transformServerFunctions(code, normalizedPath, env, serverFiles, addServerModule);
+                        if (serverResult) {
+                            log("Esbuild server function transformation successful for environment=%s, path=%s", env, args.path);
+                            return {
+                                contents: serverResult.code,
+                                loader: getLoader(args.path),
+                            };
+                        }
+                        process.env.VERBOSE &&
+                            log("Esbuild no transformation applied for environment=%s, path=%s", env, args.path);
+                    });
+                },
+            });
+            log("Environment configuration complete for env=%s", env);
+        },
+    };
+};

package/dist/vite/ensureAliasArray.d.mts

@@ -0,0 +1,2 @@
+import type { Alias, UserConfig } from "vite";
+export declare const ensureAliasArray: (config: UserConfig) => Alias[];