@solidjs/start 2.0.0-alpha.2 → 2.0.0-beta.0

package/CHANGELOG.md

@@ -1,5 +1,40 @@
 # @solidjs/start
 
+## 2.0.0-beta.0
+
+### Minor Changes
+
+- 0a9fdc3: fix cloudflare
+
+### Patch Changes
+
+- 0c95804: Fix URL to path conversion in manifest resolver
+- 6011e5a: Fixed changes in route files resulting in a reload instead of hot module replace. Reloads now only are triggered when adding or removing routes.
+- 8fb81e6: Fixed niche edge cases in the server functions dead code removal (DCE) logic:
+  - Server functions only referenced in event handlers (e.g. `onClick`) now aren't considered unused and work properly.
+  - Unused variables in server functions no longer lead to compilation errors.
+- 8d12d6a: Fixed tailwind class changes not getting applied via HMR in filesystem routes.
+- ec1b82b: Included Vite 8 in the peer dependency range.
+
+## 2.0.0-alpha.3
+
+### Minor Changes
+
+- 798b285: Updated dependencies.
+- f6f0452: seroval json mode
+- d4be1b6: Add new directives plugin with shorter function IDs and inner declaration support
+- b9c4ade: feat: add `env:*` runtime environment variables support
+
+### Patch Changes
+
+- ff9607c: import DevEnvironment and Rollup as type from vite
+- 6da636b: The server function directives runtime is now internally accessed via package.json exports instead of relative paths, fixing inconsistencies in the file resolution. Also the server functions file inclusion/exclusion patterns can now be configured in the start plugin options via `serverFunctions`.
+- 2885905: fix: clone request headers in single-flight to avoid mutating immutable headers
+- abe3979: reload ssr server when new route files are created in dev
+- 7c288f6: Sanitize Location header value in streaming redirect script
+- 6c83886: update seroval to 1.5.4
+- 9d5d783: Add support for Vite 8 asset manifest loading
+
 ## 2.0.0-alpha.2
 
 ### Minor Changes

package/dist/config/constants.d.ts

@@ -5,12 +5,12 @@ export declare const VIRTUAL_MODULES: {
     readonly getClientManifest: "solid-start:get-client-manifest";
     readonly getManifest: "solid-start:get-manifest";
     readonly middleware: "solid-start:middleware";
-    readonly serverFnManifest: "solidstart:server-fn-manifest";
+    readonly serverFnManifest: "solid-start:server-fn-manifest";
     readonly clientEntry: "solid-start:client-entry";
     readonly serverEntry: "solid-start:server-entry";
     readonly app: "solid-start:app";
 };
 export declare const VITE_ENVIRONMENTS: {
-    client: string;
-    server: string;
+    client: "client";
+    server: "ssr";
 };

package/dist/config/constants.js

@@ -5,7 +5,7 @@ export const VIRTUAL_MODULES = {
     getClientManifest: "solid-start:get-client-manifest",
     getManifest: "solid-start:get-manifest",
     middleware: "solid-start:middleware",
-    serverFnManifest: "solidstart:server-fn-manifest",
+    serverFnManifest: "solid-start:server-fn-manifest",
     clientEntry: "solid-start:client-entry",
     serverEntry: "solid-start:server-entry",
     app: "solid-start:app",

package/dist/config/dev-server.js

@@ -1,3 +1,11 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
 import { NodeRequest, sendNodeResponse } from "srvx/node";
 import { isRunnableDevEnvironment, } from "vite";
 import { VITE_ENVIRONMENTS } from "./constants.js";
@@ -10,7 +18,7 @@ export function devServer() {
                     server.middlewares.use(async (req, res) => {
                         res.setHeader("content-encoding", "identity");
                         const webReq = new NodeRequest({ req, res });
-                        const def = await import(process.cwd() + "/dist/server/entry-server.js");
+                        const def = await import(__rewriteRelativeImportExtension(process.cwd() + "/dist/server/entry-server.js", true));
                         sendNodeResponse(res, await def.default.fetch(webReq));
                     });
                 };

package/dist/config/env.d.ts

@@ -0,0 +1,19 @@
+import { type Plugin } from "vite";
+declare const LOADERS: {
+    node: string;
+    "cloudflare-workers": string;
+    "netlify-edge": string;
+};
+export interface EnvPluginOptions {
+    server?: {
+        runtime?: keyof typeof LOADERS | (string & {});
+        load?: (mode: string) => Record<string, string>;
+        prefix?: string;
+    };
+    client?: {
+        load?: (mode: string) => Record<string, string>;
+        prefix?: string;
+    };
+}
+export declare function envPlugin(options?: EnvPluginOptions): Plugin;
+export {};

package/dist/config/env.js

@@ -0,0 +1,81 @@
+import { loadEnv } from "vite";
+const LOADERS = {
+    node: `export default key => process.env[key];`,
+    "cloudflare-workers": `import { env } from 'cloudflare:workers';export default key => env[key];`,
+    "netlify-edge": `export default key => Netlify.env.get(key);`,
+};
+const SERVER_ENV = "env:server";
+const CLIENT_ENV = "env:client";
+const SERVER_RUNTIME_ENV = `${SERVER_ENV}/runtime`;
+const SERVER_RUNTIME_LOADER = `${SERVER_RUNTIME_ENV}/loader`;
+const DEFAULT_SERVER_PREFIX = "SERVER_";
+const DEFAULT_CLIENT_PREFIX = "CLIENT_";
+const SERVER_ONLY_MODULE = `throw new Error('Attempt to load server-only environment variables in client runtime.');`;
+const SERVER_RUNTIME_CODE = `import load from '${SERVER_RUNTIME_LOADER}';
+
+export default new Proxy({}, {
+  get(_, key) {
+    return load(key);
+  },
+})`;
+function convertObjectToModule(object) {
+    let result = "";
+    for (const key in object) {
+        result += `export const ${key} = ${JSON.stringify(object[key])};`;
+    }
+    return result;
+}
+export function envPlugin(options) {
+    const currentOptions = options ?? {};
+    let env;
+    const serverPrefix = currentOptions.server?.prefix ?? DEFAULT_SERVER_PREFIX;
+    const clientPrefix = currentOptions.client?.prefix ?? DEFAULT_CLIENT_PREFIX;
+    const runtime = options?.server?.runtime ?? "node";
+    const runtimeCode = runtime in LOADERS ? LOADERS[runtime] : runtime;
+    return {
+        name: "solid-start:env",
+        enforce: "pre",
+        configResolved(config) {
+            env = config.mode !== "production" ? "development" : "production";
+        },
+        resolveId(id) {
+            if (id === SERVER_ENV ||
+                id === CLIENT_ENV ||
+                id === SERVER_RUNTIME_ENV ||
+                id === SERVER_RUNTIME_LOADER) {
+                return id;
+            }
+            return undefined;
+        },
+        load(id, opts) {
+            if (id === SERVER_ENV) {
+                if (!opts?.ssr) {
+                    return SERVER_ONLY_MODULE;
+                }
+                const vars = currentOptions.server?.load
+                    ? currentOptions.server.load(env)
+                    : loadEnv(env, '.', serverPrefix);
+                return convertObjectToModule(vars);
+            }
+            if (id === CLIENT_ENV) {
+                const vars = currentOptions.client?.load
+                    ? currentOptions.client.load(env)
+                    : loadEnv(env, '.', clientPrefix);
+                return convertObjectToModule(vars);
+            }
+            if (id === SERVER_RUNTIME_LOADER) {
+                if (!opts?.ssr) {
+                    return SERVER_ONLY_MODULE;
+                }
+                return runtimeCode;
+            }
+            if (id === SERVER_RUNTIME_ENV) {
+                if (!opts?.ssr) {
+                    return SERVER_ONLY_MODULE;
+                }
+                return SERVER_RUNTIME_CODE;
+            }
+            return undefined;
+        },
+    };
+}

package/dist/config/fs-routes/fs-watcher.js

@@ -1,3 +1,5 @@
+import { debounce } from "../../utils/debounce.js";
+import { VITE_ENVIRONMENTS } from "../constants.js";
 import { moduleId } from "./index.js";
 function setupWatcher(watcher, routes) {
     watcher.on("unlink", path => routes.removeRoute(path));
@@ -5,44 +7,46 @@ function setupWatcher(watcher, routes) {
     watcher.on("change", path => routes.updateRoute(path));
 }
 function createRoutesReloader(server, routes, environment) {
-    routes.addEventListener("reload", handleRoutesReload);
-    return () => routes.removeEventListener("reload", handleRoutesReload);
-    function handleRoutesReload() {
-        if (environment === "ssr") {
-            // Handle server environment HMR reload
-            const serverEnv = server.environments.server;
-            if (serverEnv && serverEnv.moduleGraph) {
-                const mod = serverEnv.moduleGraph.getModuleById(moduleId);
-                if (mod) {
-                    const seen = new Set();
-                    serverEnv.moduleGraph.invalidateModule(mod, seen);
-                }
-            }
+    const devEnv = server.environments[environment];
+    if (!devEnv?.moduleGraph)
+        return;
+    /**
+     * Debounce catches multiple route changes in a row
+     * Short timeout for inexpensive invalidations
+     */
+    const invalidateModule = debounce((mod) => {
+        devEnv.moduleGraph.invalidateModule(mod);
+    }, 0);
+    /**
+     * Long debounce timeout for expensive reloads
+     */
+    const reloadModule = debounce((mod) => {
+        devEnv.reloadModule(mod);
+    }, 200);
+    return routes.on("reload", function handleRoutesReload(evt) {
+        const mod = devEnv.moduleGraph.getModuleById(moduleId);
+        if (!mod) {
+            devEnv.hot.send({ type: "full-reload" });
+            return;
         }
-        else {
-            // Handle client environment HMR reload
-            const { moduleGraph } = server;
-            const mod = moduleGraph.getModuleById(moduleId);
-            if (mod) {
-                const seen = new Set();
-                moduleGraph.invalidateModule(mod, seen);
-                server.reloadModule(mod);
-            }
+        if (environment === VITE_ENVIRONMENTS.client && evt.detail.type !== "update") {
+            // Client has to be reloaded when routes are added or removed
+            reloadModule(mod);
         }
-        if (!server.hot) {
-            server.ws.send({ type: "full-reload" });
+        else {
+            invalidateModule(mod);
         }
-    }
+    });
 }
 export const fileSystemWatcher = (routers) => {
     const plugin = {
         name: "fs-watcher",
         async configureServer(server) {
-            Object.keys(routers).forEach(environment => {
-                const router = globalThis.ROUTERS[environment];
+            for (const environment of [VITE_ENVIRONMENTS.server, VITE_ENVIRONMENTS.client]) {
+                const router = routers[environment];
                 setupWatcher(server.watcher, router);
                 createRoutesReloader(server, router, environment);
-            });
+            }
         },
     };
     return plugin;

package/dist/config/fs-routes/index.js

@@ -43,8 +43,8 @@ export function fsRoutes({ routers }) {
                         const buildId = `${v.src}?${v.pick.map((p) => `pick=${p}`).join("&")}`;
                         return {
                             src: relative(root, buildId),
-                            build: isBuild ? `_$() => import(/* @vite-ignore */ '${buildId}')$_` : undefined,
-                            import: `_$() => import(/* @vite-ignore */ '${buildId}')$_`,
+                            build: isBuild ? `_$() => import('${buildId}')$_` : undefined,
+                            import: `_$() => import('${buildId}')$_`,
                         };
                     }
                     return v;

package/dist/config/fs-routes/router.d.ts

@@ -10,6 +10,10 @@ type Route = {
 } & Record<string, any>;
 export declare function cleanPath(src: string, config: FileSystemRouterConfig): string;
 export declare function analyzeModule(src: string): readonly [imports: readonly import("es-module-lexer").ImportSpecifier[], exports: readonly import("es-module-lexer").ExportSpecifier[], facade: boolean, hasModuleSyntax: boolean];
+type RouterEvent = CustomEvent<{
+    route: string;
+    type: "update" | "remove" | "add";
+}>;
 export declare class BaseFileSystemRouter extends EventTarget {
     routes: Route[];
     config: FileSystemRouterConfig;
@@ -27,11 +31,12 @@ export declare class BaseFileSystemRouter extends EventTarget {
      * To be attached by vite plugin to the vite dev server
      */
     update: undefined;
-    _addRoute(route: Route): void;
+    _addRoute(route: Route): boolean;
     addRoute(src: string): Promise<void>;
-    reload(route: string): void;
-    updateRoute(src: string): Promise<void>;
+    reload(route: string, type: "update" | "remove" | "add"): void;
+    updateRoute(src_: string): Promise<void>;
     removeRoute(src: string): void;
+    on(type: string, cb: (evt: RouterEvent) => void): () => void;
     buildRoutesPromise?: Promise<any[]>;
     getRoutes(): Promise<Route[]>;
 }

package/dist/config/fs-routes/router.js

@@ -1,9 +1,9 @@
 import { init, parse } from "es-module-lexer";
 import esbuild from "esbuild";
 import fg from "fast-glob";
-import fs from "fs";
+import fs from "node:fs";
 import micromatch from "micromatch";
-import { posix } from "path";
+import { posix } from "node:path";
 import { pathToRegexp } from "path-to-regexp";
 import { normalizePath } from "vite";
 export { pathToRegexp };
@@ -71,8 +71,11 @@ export class BaseFileSystemRouter extends EventTarget {
      */
     update = undefined;
     _addRoute(route) {
-        this.routes = this.routes.filter(r => r.path !== route.path);
+        const idx = this.routes.findIndex(r => r.path === route.path);
+        if (idx >= 0)
+            this.routes.splice(idx, 1);
         this.routes.push(route);
+        return idx >= 0;
     }
     async addRoute(src) {
         src = normalizePath(src);
@@ -81,7 +84,7 @@ export class BaseFileSystemRouter extends EventTarget {
                 const route = this.toRoute(src);
                 if (route) {
                     this._addRoute(route);
-                    this.reload(route.path);
+                    this.reload(route.path, "add");
                 }
             }
             catch (e) {
@@ -89,22 +92,25 @@ export class BaseFileSystemRouter extends EventTarget {
             }
         }
     }
-    reload(route) {
-        this.dispatchEvent(new Event("reload", {
-            // @ts-ignore
+    reload(route, type) {
+        this.dispatchEvent(new CustomEvent("reload", {
             detail: {
                 route,
+                type,
             },
         }));
     }
-    async updateRoute(src) {
-        src = normalizePath(src);
+    async updateRoute(src_) {
+        const src = normalizePath(src_);
         if (this.isRoute(src)) {
             try {
                 const route = this.toRoute(src);
                 if (route) {
-                    this._addRoute(route);
-                    this.reload(route.path);
+                    const updated = this._addRoute(route);
+                    this.reload(route.path, updated ? "update" : "add");
+                }
+                else {
+                    this.removeRoute(src_);
                 }
             }
             catch (e) {
@@ -120,10 +126,17 @@ export class BaseFileSystemRouter extends EventTarget {
             if (path === undefined) {
                 return;
             }
-            this.routes = this.routes.filter(r => r.path !== path);
-            this.dispatchEvent(new Event("reload", {}));
+            const idx = this.routes.findIndex(r => r.path === path);
+            if (idx === -1)
+                return;
+            this.routes.splice(idx, 1);
+            this.reload(path, "remove");
         }
     }
+    on(type, cb) {
+        this.addEventListener(type, cb);
+        return () => this.removeEventListener(type, cb);
+    }
     buildRoutesPromise;
     async getRoutes() {
         if (!this.buildRoutesPromise) {

package/dist/config/fs-routes/tree-shake.js

@@ -260,9 +260,6 @@ function treeShakeTransform({ types: t }) {
     };
 }
 export function treeShake() {
-    let config;
-    const cache = {};
-    let server;
     async function transform(id, code) {
         const [path, queryString] = id.split("?");
         const query = new URLSearchParams(queryString);
@@ -286,44 +283,6 @@ export function treeShake() {
     return {
         name: "tree-shake",
         enforce: "pre",
-        configResolved(resolvedConfig) {
-            config = resolvedConfig;
-        },
-        configureServer(s) {
-            server = s;
-        },
-        async handleHotUpdate(ctx) {
-            if (cache[ctx.file]) {
-                const mods = [];
-                const newCode = await ctx.read();
-                for (const [id, code] of Object.entries(cache[ctx.file])) {
-                    const transformed = await transform(id, newCode);
-                    if (!transformed)
-                        continue;
-                    const { code: transformedCode } = transformed;
-                    if (transformedCode !== code) {
-                        const mod = server.moduleGraph.getModuleById(id);
-                        if (mod)
-                            mods.push(mod);
-                    }
-                    cache[ctx.file] ??= {};
-                    cache[ctx.file][id] = transformedCode;
-                    // server.moduleGraph.setModuleSource(id, code);
-                }
-                return mods;
-            }
-            // 	const mods = [];
-            // 	[...server.moduleGraph.urlToModuleMap.entries()].forEach(([url, m]) => {
-            // 		if (m.file === ctx.file && m.id.includes("pick=")) {
-            // 			if (!m.id.includes("pick=loader")) {
-            // 				mods.push(m);
-            // 			}
-            // 		}
-            // 	});
-            // 	return mods;
-            // 	// this.router.updateRoute(ctx.path);
-            // }
-        },
         async transform(code, id) {
             const [path, queryString] = id.split("?");
             if (!path)
@@ -336,8 +295,6 @@ export function treeShake() {
                 const transformed = await transform(id, code);
                 if (!transformed?.code)
                     return;
-                cache[path] ??= {};
-                cache[path][id] = transformed.code;
                 return {
                     code: transformed.code,
                     map: transformed.map,

package/dist/config/index.d.ts

@@ -1,10 +1,25 @@
-import { type PluginOption } from "vite";
+import type { PluginOption } from "vite";
 import { type Options as SolidOptions } from "vite-plugin-solid";
+import { type ServerFunctionsOptions } from "../directives/index.ts";
+import { type EnvPluginOptions } from "./env.ts";
 export interface SolidStartOptions {
     solid?: Partial<SolidOptions>;
     ssr?: boolean;
     routeDir?: string;
     extensions?: string[];
     middleware?: string;
+    serialization?: {
+        /**
+         * The serialization mode to use for server functions/actions.
+         * The "js" mode uses a custom binary format that is more efficient than JSON, but requires a custom deserializer (with `eval()`) on the client.
+         * A strong CSP should block `eval()` executions, which would prevent the "js" mode from working.
+         * The "json" mode uses JSON for serialization, which is less efficient but can be deserialized with `JSON.parse` on the client.
+         *
+         * @default "json"
+         */
+        mode?: "js" | "json";
+    };
+    env?: EnvPluginOptions;
+    serverFunctions?: Pick<ServerFunctionsOptions, "filter">;
 }
 export declare function solidStart(options?: SolidStartOptions): Array<PluginOption>;

package/dist/config/index.js

@@ -1,12 +1,11 @@
-import { TanStackServerFnPlugin } from "@tanstack/server-functions-plugin";
 import { defu } from "defu";
 import { globSync } from "node:fs";
 import { extname, isAbsolute, join } from "node:path";
-import { fileURLToPath } from "node:url";
-import { normalizePath } from "vite";
 import solid from "vite-plugin-solid";
+import { serverFunctionsPlugin } from "../directives/index.js";
 import { DEFAULT_EXTENSIONS, VIRTUAL_MODULES, VITE_ENVIRONMENTS } from "./constants.js";
 import { devServer } from "./dev-server.js";
+import { envPlugin } from "./env.js";
 import { SolidStartClientFileRouter, SolidStartServerFileRouter } from "./fs-router.js";
 import { fsRoutes } from "./fs-routes/index.js";
 import lazy from "./lazy.js";
@@ -38,6 +37,18 @@ export function solidStart(options) {
         server: `${start.appRoot}/entry-server${entryExtension}`,
     };
     return [
+        // TODO (Alexis): check if the comment below is still relevant
+        //
+        // Must be placed after fsRoutes, as treeShake will remove the
+        // server fn exports added in by this plugin
+        serverFunctionsPlugin({
+            manifest: VIRTUAL_MODULES.serverFnManifest,
+            runtime: {
+                server: '@solidjs/start/fns/server',
+                client: '@solidjs/start/fns/client',
+            },
+            filter: options?.serverFunctions?.filter,
+        }),
         {
             name: "solid-start:config",
             enforce: "pre",
@@ -67,6 +78,16 @@ export function solidStart(options) {
                 return {
                     appType: "custom",
                     build: { assetsDir: "_build/assets" },
+                    optimizeDeps: {
+                        // Suppress TS errors from Vite 7 types when configuring Vite 8's Rolldown
+                        ...{
+                            rolldownOptions: {
+                                transform: {
+                                    jsx: "react",
+                                },
+                            },
+                        },
+                    },
                     environments: {
                         [VITE_ENVIRONMENTS.client]: {
                             consumer: "client",
@@ -109,6 +130,9 @@ export function solidStart(options) {
                                 }
                                 : {}),
                         },
+                        // Depending on the package manager and dependency structure Vite externalizes @solidjs/start
+                        // This makes sure that @solidjs/start goes through the Vite build process
+                        noExternal: ["@solidjs/start"],
                     },
                     define: {
                         "import.meta.env.MANIFEST": `globalThis.MANIFEST`,
@@ -118,6 +142,7 @@ export function solidStart(options) {
                         "import.meta.env.START_APP_ENTRY": JSON.stringify(appEntryPath),
                         "import.meta.env.START_CLIENT_ENTRY": JSON.stringify(handlers.client),
                         "import.meta.env.START_DEV_OVERLAY": JSON.stringify(start.devOverlay),
+                        "import.meta.env.SEROVAL_MODE": JSON.stringify(start.serialization?.mode || "json"),
                     },
                     builder: {
                         sharedPlugins: true,
@@ -152,33 +177,7 @@ export function solidStart(options) {
             },
         }),
         lazy(),
-        // Must be placed after fsRoutes, as treeShake will remove the
-        // server fn exports added in by this plugin
-        TanStackServerFnPlugin({
-            // This is the ID that will be available to look up and import
-            // our server function manifest and resolve its module
-            manifestVirtualImportId: VIRTUAL_MODULES.serverFnManifest,
-            directive: "use server",
-            callers: [
-                {
-                    envConsumer: "client",
-                    envName: VITE_ENVIRONMENTS.client,
-                    getRuntimeCode: () => `import { createServerReference } from "${normalizePath(fileURLToPath(new URL("../server/server-runtime", import.meta.url)))}"`,
-                    replacer: opts => `createServerReference('${opts.functionId}')`,
-                },
-                {
-                    envConsumer: "server",
-                    envName: VITE_ENVIRONMENTS.server,
-                    getRuntimeCode: () => `import { createServerReference } from '${normalizePath(fileURLToPath(new URL("../server/server-fns-runtime", import.meta.url)))}'`,
-                    replacer: opts => `createServerReference(${opts.fn}, '${opts.functionId}')`,
-                },
-            ],
-            provider: {
-                envName: VITE_ENVIRONMENTS.server,
-                getRuntimeCode: () => `import { createServerReference } from '${normalizePath(fileURLToPath(new URL("../server/server-fns-runtime", import.meta.url)))}'`,
-                replacer: opts => `createServerReference(${opts.fn}, '${opts.functionId}')`,
-            },
-        }),
+        envPlugin(options?.env),
         {
             name: "solid-start:virtual-modules",
             async resolveId(id) {
@@ -203,8 +202,9 @@ export function solidStart(options) {
         {
             name: "solid-start:capture-client-bundle",
             enforce: "post",
-            generateBundle(_options, bundle) {
+            generateBundle(options, bundle) {
                 globalThis.START_CLIENT_BUNDLE = bundle;
+                globalThis.START_CLIENT_OUT_DIR = options.dir;
             },
         },
         devServer(),

package/dist/config/lazy.js

@@ -1,7 +1,7 @@
 import babel from "@babel/core";
 import * as t from "@babel/types";
-import { sep as osSep } from "path";
-import { basename, relative, sep } from "path/posix";
+import { sep as osSep } from "node:path";
+import { basename, relative, sep } from "node:path/posix";
 import { VITE_ENVIRONMENTS } from "./constants.js";
 const idTransform = (id) => {
     return {
@@ -77,6 +77,8 @@ const lazy = () => {
             // Therefore we skip, if the src doesn't have any import
             if (src.indexOf("import") === -1)
                 return;
+            if (id.includes("entry-server"))
+                return;
             const plugins = [];
             const hasDefaultExport = src.indexOf("export default") !== -1;
             if (hasDefaultExport) {