@solidjs/start 2.0.0-beta.0 → 2.0.0-beta.10

package/CHANGELOG.md

@@ -1,5 +1,76 @@
 # @solidjs/start
 
+## 2.0.0-beta.10
+
+### Patch Changes
+
+- 8af6304: Support for Vite 8.1 Experimental Bundled Dev Mode
+- 9d91484: fix: don't crash when a server function throws an error whose message contains non-latin1 characters. 
+- 068b64c: Return a cancellation-safe web `ReadableStream` for streaming SSR in development. Returning Solid's
+  raw stream only rendered on Node; Bun and Deno coerced it to `[object Object]`.
+
+## 2.0.0-beta.9
+
+### Minor Changes
+
+- f3e84ec: Add support for `server-only` and `client-only` modules
+
+### Patch Changes
+
+- a8a2328: fix: mark `@solidjs/start/http` and `@solidjs/start/middleware` as `server-only` so importing them from client-reachable code fails loudly at dev/build time, instead of silently shipping them to the browser where they crashed hydration and broke unrelated actions/forms with no diagnostic (#2068)
+
+## 2.0.0-beta.8
+
+### Patch Changes
+
+- ecc02be: fix: resolve server functions in dev when their route was reached through client-side navigation before its module was evaluated on the server
+- 85b24b2: Use per-environment Vite plugin hook APIs for forward compatibility with Vite 9.
+
+## 2.0.0-beta.7
+
+### Patch Changes
+
+- d2f0621: Support JavaScript projects whose app and client/server entries use `.jsx`.
+
+## 2.0.0-beta.6
+
+### Patch Changes
+
+- 25769f2: Fix Vite preview for non-HTML responses and projects whose server build uses an `.mjs`
+  entry.
+
+## 2.0.0-beta.5
+
+### Patch Changes
+
+- eb73dd5: Use `oxc-parser` to analyze filesystem route exports.
+
+## 2.0.0-beta.4
+
+### Patch Changes
+
+- 21fdb2c: Update `h3` to `2.0.1-rc.25`.
+
+## 2.0.0-beta.3
+
+### Patch Changes
+
+- 12dc2d3: Bundle `h3` and `cookie-es` into server builds to avoid resolving incompatible hoisted versions
+
+## 2.0.0-beta.2
+
+### Patch Changes
+
+- 3e961e0: Require Vite 8
+- 11907a2: Fix published package missing `dist/`: pnpm 11 respects `.gitignore` when packing a package without a `files` field, so `2.0.0-beta.1` was published without its build output. Add an explicit `files` field.
+
+## 2.0.0-beta.1
+
+### Patch Changes
+
+- ee1193a: Update srvx to maintain response compatibility with Nitro v3.
+- e263338: Fix `ERR_UNSUPPORTED_ESM_URL_SCHEME` when running `vite preview` on Windows
+
 ## 2.0.0-beta.0
 
 ### Minor Changes

package/dist/config/boundary-modules.d.ts

@@ -0,0 +1,14 @@
+import type { Plugin } from "vite";
+/**
+ * Supports `server-only` and `client-only` marker modules (#2162): importing
+ * `server-only` from a client module (or `client-only` from a server module)
+ * fails at resolve time; in the allowed environment the marker resolves to an
+ * empty module.
+ *
+ * Start's own server-only entry points (`@solidjs/start/http`,
+ * `@solidjs/start/middleware`) import `server-only` themselves, so pulling
+ * them into the client bundle fails loudly instead of shipping server code to
+ * the browser, where it crashed hydration and broke unrelated actions/forms
+ * with no diagnostic (https://github.com/solidjs/solid-start/issues/2068).
+ */
+export declare function boundaryModules(): Plugin;

package/dist/config/boundary-modules.js

@@ -0,0 +1,41 @@
+const VIRTUAL_ID = "\0solid-start:boundary-modules:id";
+/**
+ * Supports `server-only` and `client-only` marker modules (#2162): importing
+ * `server-only` from a client module (or `client-only` from a server module)
+ * fails at resolve time; in the allowed environment the marker resolves to an
+ * empty module.
+ *
+ * Start's own server-only entry points (`@solidjs/start/http`,
+ * `@solidjs/start/middleware`) import `server-only` themselves, so pulling
+ * them into the client bundle fails loudly instead of shipping server code to
+ * the browser, where it crashed hydration and broke unrelated actions/forms
+ * with no diagnostic (https://github.com/solidjs/solid-start/issues/2068).
+ */
+export function boundaryModules() {
+    return {
+        name: "solid-start:boundary-modules",
+        enforce: "pre",
+        resolveId(id, importer, { ssr }) {
+            if (id === "server-only") {
+                if (!ssr)
+                    this.error(`Attempt to import 'server-only' in a client module: ${importer}. ` +
+                        `Code that uses this module must run only on the server: mark it with ` +
+                        `"use server", or make sure it is only imported by server code.`);
+            }
+            else if (id === "client-only") {
+                if (ssr)
+                    this.error(`Attempt to import 'client-only' in a server module: ${importer}. ` +
+                        `Code that uses this module must run only in the browser: make sure it ` +
+                        `is only imported by client code (e.g. wrap components with clientOnly()).`);
+            }
+            else {
+                return null;
+            }
+            return VIRTUAL_ID;
+        },
+        load(id) {
+            if (id === VIRTUAL_ID)
+                return "export {}";
+        },
+    };
+}

package/dist/config/dev-server.d.ts

@@ -1,2 +1,4 @@
 import { type PluginOption } from "vite";
-export declare function devServer(): Array<PluginOption>;
+export declare function devServer(serverEntryPath: string): Array<PluginOption>;
+export declare function resolvePreviewServerEntry(root: string): string;
+export declare function isHtmlResponse(response: Response): boolean;

package/dist/config/dev-server.js

@@ -6,20 +6,27 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
     }
     return path;
 };
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
 import { NodeRequest, sendNodeResponse } from "srvx/node";
 import { isRunnableDevEnvironment, } from "vite";
 import { VITE_ENVIRONMENTS } from "./constants.js";
-export function devServer() {
+export function devServer(serverEntryPath) {
     return [
         {
             name: "solid-start-dev-server",
             configurePreviewServer(server) {
+                const serverEntryUrl = pathToFileURL(resolvePreviewServerEntry(server.config.root)).href;
                 return () => {
                     server.middlewares.use(async (req, res) => {
-                        res.setHeader("content-encoding", "identity");
                         const webReq = new NodeRequest({ req, res });
-                        const def = await import(__rewriteRelativeImportExtension(process.cwd() + "/dist/server/entry-server.js", true));
-                        sendNodeResponse(res, await def.default.fetch(webReq));
+                        const def = await import(__rewriteRelativeImportExtension(serverEntryUrl, true));
+                        const webRes = await def.default.fetch(webReq);
+                        if (isHtmlResponse(webRes)) {
+                            res.setHeader("content-encoding", "identity");
+                        }
+                        sendNodeResponse(res, webRes);
                     });
                 };
             },
@@ -47,7 +54,7 @@ export function devServer() {
                         }
                         const webReq = new NodeRequest({ req, res });
                         try {
-                            const serverEntry = await serverEnv.runner.import("./src/entry-server.tsx");
+                            const serverEntry = await serverEnv.runner.import(serverEntryPath);
                             const webRes = await serverEntry.default.fetch(webReq);
                             return sendNodeResponse(res, webRes);
                         }
@@ -92,6 +99,19 @@ export function devServer() {
         },
     ];
 }
+export function resolvePreviewServerEntry(root) {
+    const serverDirectory = join(root, "dist/server");
+    const serverEntry = ["js", "mjs"]
+        .map(extension => join(serverDirectory, `entry-server.${extension}`))
+        .find(existsSync);
+    if (!serverEntry) {
+        throw new Error(`Could not find the SolidStart server entry in ${serverDirectory}`);
+    }
+    return serverEntry;
+}
+export function isHtmlResponse(response) {
+    return response.headers.get("content-type")?.startsWith("text/html") ?? false;
+}
 /**
  * Removes Vite internal middleware
  *

package/dist/config/env.js

@@ -1,4 +1,5 @@
 import { loadEnv } from "vite";
+import { parseIdQuery } from "./utils.js";
 const LOADERS = {
     node: `export default key => process.env[key];`,
     "cloudflare-workers": `import { env } from 'cloudflare:workers';export default key => env[key];`,
@@ -39,17 +40,20 @@ export function envPlugin(options) {
             env = config.mode !== "production" ? "development" : "production";
         },
         resolveId(id) {
-            if (id === SERVER_ENV ||
-                id === CLIENT_ENV ||
-                id === SERVER_RUNTIME_ENV ||
-                id === SERVER_RUNTIME_LOADER) {
+            const { filename } = parseIdQuery(id);
+            if (filename === SERVER_ENV ||
+                filename === CLIENT_ENV ||
+                filename === SERVER_RUNTIME_ENV ||
+                filename === SERVER_RUNTIME_LOADER) {
                 return id;
             }
             return undefined;
         },
-        load(id, opts) {
-            if (id === SERVER_ENV) {
-                if (!opts?.ssr) {
+        load(id) {
+            const { filename } = parseIdQuery(id);
+            const isServer = this.environment.config.consumer === "server";
+            if (filename === SERVER_ENV) {
+                if (!isServer) {
                     return SERVER_ONLY_MODULE;
                 }
                 const vars = currentOptions.server?.load
@@ -57,20 +61,20 @@ export function envPlugin(options) {
                     : loadEnv(env, '.', serverPrefix);
                 return convertObjectToModule(vars);
             }
-            if (id === CLIENT_ENV) {
+            if (filename === 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) {
+            if (filename === SERVER_RUNTIME_LOADER) {
+                if (!isServer) {
                     return SERVER_ONLY_MODULE;
                 }
                 return runtimeCode;
             }
-            if (id === SERVER_RUNTIME_ENV) {
-                if (!opts?.ssr) {
+            if (filename === SERVER_RUNTIME_ENV) {
+                if (!isServer) {
                     return SERVER_ONLY_MODULE;
                 }
                 return SERVER_RUNTIME_CODE;

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

@@ -23,7 +23,6 @@ export declare class SolidStartServerFileRouter extends BaseFileSystemRouter {
     });
     toPath(src: string): string;
     toRoute(src: string): {
-        path: string;
         page: boolean;
         $component: {
             src: string;
@@ -33,5 +32,6 @@ export declare class SolidStartServerFileRouter extends BaseFileSystemRouter {
             src: string;
             pick: string[];
         } | undefined;
+        path: string;
     } | undefined;
 }

package/dist/config/fs-router.js

@@ -30,19 +30,17 @@ export class SolidStartClientFileRouter extends BaseFileSystemRouter {
                 // filePath: src
             };
         }
-        const [_, exports] = analyzeModule(src);
-        const hasDefault = !!exports.find(e => e.n === "default");
-        const hasRouteConfig = !!exports.find(e => e.n === "route");
+        const exports = analyzeModule(src);
+        const exportNames = exports.map(getExportName);
+        const localExportNames = exports.map(getLocalExportName).filter(name => name !== undefined);
+        const hasDefault = exportNames.includes("default");
+        const hasRouteConfig = exportNames.includes("route");
         if (hasDefault) {
             return {
                 page: true,
                 $component: {
                     src: src,
-                    pick: [
-                        ...exports.filter(e => e.n === e.ln && e.n !== "route").map(e => e.n),
-                        "default",
-                        "$css",
-                    ],
+                    pick: [...localExportNames.filter(name => name !== "route"), "default", "$css"],
                 },
                 $$route: hasRouteConfig
                     ? {
@@ -57,18 +55,27 @@ export class SolidStartClientFileRouter extends BaseFileSystemRouter {
     }
 }
 const HTTP_METHODS = ["HEAD", "GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS"];
+function getExportName(entry) {
+    return entry.exportName.name ?? "default";
+}
+function getLocalExportName(entry) {
+    const name = getExportName(entry);
+    if (name === "default")
+        return;
+    return name === (entry.localName.name ?? entry.importName.name ?? name) ? name : undefined;
+}
 function createHTTPHandlers(src, exports) {
     const handlers = {};
     for (const exp of exports) {
-        if (HTTP_METHODS.includes(exp.n)) {
-            handlers[`$${exp.n}`] = {
+        if (HTTP_METHODS.includes(exp)) {
+            handlers[`$${exp}`] = {
                 src: src,
-                pick: [exp.n],
+                pick: [exp],
             };
-            if (exp.n === "GET" && !exports.find(exp => exp.n === "HEAD")) {
+            if (exp === "GET" && !exports.includes("HEAD")) {
                 handlers.$HEAD = {
                     src: src,
-                    pick: [exp.n],
+                    pick: [exp],
                 };
             }
         }
@@ -108,10 +115,12 @@ export class SolidStartServerFileRouter extends BaseFileSystemRouter {
                 path,
             };
         }
-        const [_, exports] = analyzeModule(src);
-        const hasRouteConfig = exports.find(e => e.n === "route");
-        const hasDefault = !!exports.find(e => e.n === "default");
-        const hasAPIRoutes = !!exports.find(exp => HTTP_METHODS.includes(exp.n));
+        const exports = analyzeModule(src);
+        const exportNames = exports.map(getExportName);
+        const localExportNames = exports.map(getLocalExportName).filter(name => name !== undefined);
+        const hasRouteConfig = exportNames.includes("route");
+        const hasDefault = exportNames.includes("default");
+        const hasAPIRoutes = exportNames.some(name => HTTP_METHODS.includes(name));
         if (hasDefault || hasAPIRoutes) {
             return {
                 page: hasDefault,
@@ -119,9 +128,7 @@ export class SolidStartServerFileRouter extends BaseFileSystemRouter {
                     ? {
                         src: src,
                         pick: [
-                            ...exports
-                                .filter(e => e.n === e.ln && e.n !== "route" && !HTTP_METHODS.includes(e.n))
-                                .map(e => e.n),
+                            ...localExportNames.filter(name => name !== "route" && !HTTP_METHODS.includes(name)),
                             "default",
                             "$css",
                         ],
@@ -133,7 +140,7 @@ export class SolidStartServerFileRouter extends BaseFileSystemRouter {
                         pick: ["route"],
                     }
                     : undefined,
-                ...createHTTPHandlers(src, exports),
+                ...createHTTPHandlers(src, exportNames),
                 path,
             };
         }

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

@@ -1,3 +1,4 @@
+import { type StaticExportEntry } from "oxc-parser";
 import { pathToRegexp } from "path-to-regexp";
 export { pathToRegexp };
 export declare const glob: (path: string) => string[];
@@ -9,7 +10,7 @@ type Route = {
     path: string;
 } & 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];
+export declare function analyzeModule(src: string): StaticExportEntry[];
 type RouterEvent = CustomEvent<{
     route: string;
     type: "update" | "remove" | "add";

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

@@ -1,9 +1,8 @@
-import { init, parse } from "es-module-lexer";
-import esbuild from "esbuild";
 import fg from "fast-glob";
 import fs from "node:fs";
 import micromatch from "micromatch";
 import { posix } from "node:path";
+import { parseSync } from "oxc-parser";
 import { pathToRegexp } from "path-to-regexp";
 import { normalizePath } from "vite";
 export { pathToRegexp };
@@ -14,11 +13,11 @@ export function cleanPath(src, config) {
         .replace(new RegExp(`\.(${(config.extensions ?? []).join("|")})$`), "");
 }
 export function analyzeModule(src) {
-    return parse(esbuild.transformSync(fs.readFileSync(src, "utf-8"), {
-        jsx: "transform",
-        format: "esm",
-        loader: "tsx",
-    }).code, src);
+    const result = parseSync(src, fs.readFileSync(src, "utf-8"), { lang: "tsx" });
+    const error = result.errors[0];
+    if (error)
+        throw new SyntaxError(`Failed to parse ${src}:\n${error.codeframe || error.message}`);
+    return result.module.staticExports.flatMap(({ entries }) => entries.filter(entry => !entry.isType && entry.exportName.kind !== "None"));
 }
 export class BaseFileSystemRouter extends EventTarget {
     routes;
@@ -37,7 +36,6 @@ export class BaseFileSystemRouter extends EventTarget {
             `.{${this.config.extensions.join(",")}}`);
     }
     async buildRoutes() {
-        await init;
         for (var src of glob(this.glob())) {
             await this.addRoute(src);
         }
@@ -53,8 +51,8 @@ export class BaseFileSystemRouter extends EventTarget {
         let path = this.toPath(src);
         if (path === undefined)
             return;
-        const [_, exports] = analyzeModule(src);
-        if (!exports.find(e => e.n === "default")) {
+        const exports = analyzeModule(src);
+        if (!exports.find(entry => entry.exportName.kind === "Default")) {
             console.warn("No default export", src);
         }
         return {

package/dist/config/index.js

@@ -1,8 +1,9 @@
 import { defu } from "defu";
 import { globSync } from "node:fs";
-import { extname, isAbsolute, join } from "node:path";
+import { basename, extname, isAbsolute, join } from "node:path";
 import solid from "vite-plugin-solid";
 import { serverFunctionsPlugin } from "../directives/index.js";
+import { boundaryModules } from "./boundary-modules.js";
 import { DEFAULT_EXTENSIONS, VIRTUAL_MODULES, VITE_ENVIRONMENTS } from "./constants.js";
 import { devServer } from "./dev-server.js";
 import { envPlugin } from "./env.js";
@@ -44,8 +45,8 @@ export function solidStart(options) {
         serverFunctionsPlugin({
             manifest: VIRTUAL_MODULES.serverFnManifest,
             runtime: {
-                server: '@solidjs/start/fns/server',
-                client: '@solidjs/start/fns/client',
+                server: "@solidjs/start/fns/server",
+                client: "@solidjs/start/fns/client",
             },
             filter: options?.serverFunctions?.filter,
         }),
@@ -60,8 +61,11 @@ export function solidStart(options) {
                     },
                 };
             },
-            async config(_, env) {
+            async config(config, env) {
                 const clientInput = [handlers.client];
+                const clientEntryUrl = env.command === "serve" && config.experimental?.bundledDev
+                    ? `assets/${basename(handlers.client, entryExtension)}.js`
+                    : handlers.client;
                 if (env.command === "build") {
                     const clientRouter = globalThis.ROUTERS.client;
                     for (const route of await clientRouter.getRoutes()) {
@@ -110,7 +114,7 @@ export function solidStart(options) {
                                 manifest: true,
                                 copyPublicDir: false,
                                 rollupOptions: {
-                                    input: "~/entry-server.tsx",
+                                    input: handlers.server,
                                 },
                                 outDir: "dist/server",
                                 commonjsOptions: {
@@ -132,7 +136,14 @@ 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"],
+                        //
+                        // h3 and cookie-es must be bundled as well: if they stay external, the server build
+                        // emits bare imports that nitro later re-resolves from the project root, where package
+                        // managers like yarn may have hoisted the older major versions required by nitropack
+                        // and unstorage (h3 v1 / cookie-es v1) instead of the versions @solidjs/start needs
+                        // (see https://github.com/solidjs/solid-start/issues/2101
+                        // and https://github.com/solidjs/solid-start/issues/2178)
+                        noExternal: ["@solidjs/start", "h3", "cookie-es"],
                     },
                     define: {
                         "import.meta.env.MANIFEST": `globalThis.MANIFEST`,
@@ -141,6 +152,7 @@ export function solidStart(options) {
                         // esbuild receives a valid JS string literal for the define value
                         "import.meta.env.START_APP_ENTRY": JSON.stringify(appEntryPath),
                         "import.meta.env.START_CLIENT_ENTRY": JSON.stringify(handlers.client),
+                        "import.meta.env.START_CLIENT_ENTRY_URL": JSON.stringify(clientEntryUrl),
                         "import.meta.env.START_DEV_OVERLAY": JSON.stringify(start.devOverlay),
                         "import.meta.env.SEROVAL_MODE": JSON.stringify(start.serialization?.mode || "json"),
                     },
@@ -178,6 +190,29 @@ export function solidStart(options) {
         }),
         lazy(),
         envPlugin(options?.env),
+        boundaryModules(),
+        {
+            name: "solid-start:boundary-modules",
+            enforce: "pre",
+            resolveId(id, importer, { ssr }) {
+                if (id === "server-only") {
+                    if (!ssr)
+                        this.error(`Attempt to import 'server-only' in a client module: ${importer}`);
+                }
+                else if (id === "client-only") {
+                    if (ssr)
+                        this.error(`Attempt to import 'client-only' in a server module: ${importer}`);
+                }
+                else {
+                    return null;
+                }
+                return "\0solid-start:boundary-modules:id";
+            },
+            load(id) {
+                if (id === "\0solid-start:boundary-modules:id")
+                    return "export {}";
+            },
+        },
         {
             name: "solid-start:virtual-modules",
             async resolveId(id) {
@@ -207,7 +242,7 @@ export function solidStart(options) {
                 globalThis.START_CLIENT_OUT_DIR = options.dir;
             },
         },
-        devServer(),
+        devServer(handlers.server),
         solid({
             ...start.solid,
             ssr: true,

package/dist/directives/index.js

@@ -1,8 +1,14 @@
 import { createFilter, } from "vite";
+import fg from "fast-glob";
 import { compile } from "./compile.js";
+import xxHash32 from "./xxhash32.js";
 const DEFAULT_INCLUDE = "src/**/*.{jsx,tsx,ts,js,mjs,cjs}";
 const DEFAULT_EXCLUDE = "node_modules/**/*.{jsx,tsx,ts,js,mjs,cjs}";
 const DIRECTIVE = "use server";
+// Dev-only virtual module used by fns/handler.ts to lazily resolve a server
+// function id back to its owning module when the function was never evaluated
+// in the server environment (e.g. its route was only client-side navigated to).
+const LOOKUP_ID = "solid-start:server-fn-lookup";
 function createManifest() {
     return {
         server: new Set(),
@@ -63,8 +69,11 @@ function invalidateModule(moduleGraph, path) {
 function invalidateModules(server, result, manifest) {
     if (server) {
         if (result.invalidPreload) {
-            invalidateModule(server.environments.client.moduleGraph, manifest);
-            invalidateModule(server.environments.ssr.moduleGraph, manifest);
+            // Environments are not limited to "client"/"ssr": plugins like nitro
+            // render in their own environment (e.g. "nitro"), so invalidate everywhere.
+            for (const environment of Object.values(server.environments)) {
+                invalidateModule(environment.moduleGraph, manifest);
+            }
         }
     }
 }
@@ -125,24 +134,47 @@ export function serverFunctionsPlugin(options) {
                 if (source === options.manifest) {
                     return { id: options.manifest, moduleSideEffects: true };
                 }
+                if (source.startsWith(LOOKUP_ID)) {
+                    return { id: source, moduleSideEffects: true };
+                }
                 return null;
             },
-            async load(id, opts) {
-                const mode = opts?.ssr ? "server" : "client";
+            async load(id) {
+                const mode = this.environment.config.consumer;
                 if (id === options.manifest) {
                     const current = new Debouncer(() => [...manifest[mode]].map(entry => `import "${entry}";`).join("\n"));
                     preload[mode] = current;
                     const result = await current.promise.reference;
                     return result;
                 }
+                if (id.startsWith(LOOKUP_ID)) {
+                    if (this.environment.mode !== "dev") {
+                        throw new Error(`${LOOKUP_ID} is only available in dev`);
+                    }
+                    const functionId = new URLSearchParams(id.slice(LOOKUP_ID.length + 1)).get("id");
+                    // dev function ids are `${xxHash32(file)}-${count}-${name}`
+                    const hash = functionId?.split("-")[0];
+                    if (!hash)
+                        return "export {};";
+                    // Look through the files already discovered by the transform first;
+                    // fall back to scanning the project so a function is found even when
+                    // the browser kept a chunk from before a dev server restart.
+                    let files = [...manifest.server].filter(file => xxHash32(file).toString(16) === hash);
+                    if (files.length === 0) {
+                        files = fg
+                            .sync(DEFAULT_INCLUDE, { cwd: this.environment.config.root, absolute: true })
+                            .filter(file => filter(file) && xxHash32(file).toString(16) === hash);
+                    }
+                    return files.map(file => `import ${JSON.stringify(file)};`).join("\n") || "export {};";
+                }
                 return null;
             },
         },
         {
             name: "solid-start:server-functions/compiler",
-            enforce: 'pre',
-            async transform(code, fileId, opts) {
-                const mode = opts?.ssr ? "server" : "client";
+            enforce: "pre",
+            async transform(code, fileId) {
+                const mode = this.environment.config.consumer;
                 const [id] = fileId.split("?");
                 if (!filter(id)) {
                     return null;