@solidjs/start 2.0.0-rc.1 → 2.0.0-rc.10

package/CHANGELOG.md

@@ -1,5 +1,128 @@
 # @solidjs/start
 
+## 2.0.0-rc.10
+
+### Minor Changes
+
+- 3f2b7a7: The file filter logic used for CSS crawling in development can now be configured with the vite plugin option `css.filter` analog to `serverFunctions.filter`:
+
+  ```ts
+  solidStart({
+    css: {
+      filter: {
+        // Exclude all node_modules except "my-dependency" with a flat node_modules layout
+        exclude: "node_modules/!(my-dependency)/**/*",
+      },
+    },
+  });
+  ```
+
+### Patch Changes
+
+- 6581877: Fixed shared chunk css not being server rendered in production (Vite 8 regression).
+- 37d4488: Migrate the built-in Vite configuration from the deprecated `rollupOptions` alias to `rolldownOptions`.
+- 3f2b7a7: Fixed css from files with url sensitive characters such as `+` not being server-rendered.
+
+## 2.0.0-rc.9
+
+### Patch Changes
+
+- 8eef552: Remove type-only import remnants from client server-function transforms so they do not retain server-only dependency chains.
+
+## 2.0.0-rc.8
+
+### Patch Changes
+
+- 3573985: Await asynchronous `serverFunctions.onError` handlers before serializing server function errors.
+  Preserve the original error if the handler throws or rejects.
+
+## 2.0.0-rc.7
+
+### Patch Changes
+
+- 87d73e1: chore: bump seroval to v1.6.0
+
+## 2.0.0-rc.6
+
+### Minor Changes
+
+- bac24b2: Add a `serverFunctions.onError` option naming a module that observes and replaces what a server function threw, before it is serialized into the response
+
+### Patch Changes
+
+- 27c2877: Remove leftover debug `console.log` calls from the server functions inspector, which logged on every server function request in dev.
+- f15724b: Declare `@solidjs/router` as an optional peer dependency constrained to `>=0.16.0 <2.0.0-0`. Router v2 is expected to target Solid v2, so installing it alongside `@solidjs/start` v2 now surfaces a peer warning instead of silently producing an incompatible pairing. The peer is marked optional, so apps that do not use the router are unaffected.
+- 5c8612f: Apply cookies set on a returned or thrown response during single flight mutations. `redirect(to, { headers: { "Set-Cookie": ... } })` previously only reached the browser: the single flight re-render of the redirect target still ran with the old request cookies, so queries reading that cookie saw stale values. Those cookies are now merged into the request the re-render sees, matching what a browser round trip would have sent.
+- 83122ed: Reject server function calls when the response is a 5xx without an X-Error header, instead of resolving with the parsed error body
+
+## 2.0.0-rc.5
+
+### Minor Changes
+
+- 4c803e5: Add `serialization.plugins` to configure custom Seroval plugins for server functions.
+
+  Values Seroval has no built-in support for (Mongo's `ObjectId`, Prisma's `Decimal`, `Temporal`, and other custom classes) previously threw when returned from or passed to a server function. Point the new option at a module whose default export is an array of plugins:
+
+  ```ts
+  // vite.config.ts
+  solidStart({
+    serialization: {
+      plugins: "src/seroval-plugins.ts",
+    },
+  });
+  ```
+
+  ```ts
+  // src/seroval-plugins.ts
+  import { createPlugin } from "@solidjs/start/serialization";
+  ```
+
+  The module is bundled into both the client and the server so both ends of a server function agree on the format, so it must not import server-only code. SolidStart's built-in plugins keep precedence. Only server-function and action payloads are affected; the SSR hydration payload is serialized by `solid-js/web`.
+
+  Also adds a `@solidjs/start/serialization` entrypoint re-exporting Seroval's `createPlugin`, `OpaqueReference`, and plugin types, so plugin authors stay on the same Seroval version SolidStart serializes with.
+
+### Patch Changes
+
+- e117d91: Route module ids now end in the source extension, so ecosystem plugins apply inside `src/routes`.
+
+  Route files are imported through an id carrying the picked exports in the query (`routes/api.ts?pick=GET`), which left the id ending in the export name. Plugins whose filter is anchored on the file extension (`/\.[cm]?[jt]sx?$/`, the default for `unplugin-auto-import`, `unplugin-macros` and others) silently skipped every route file. The id now ends with a `lang.<ext>` marker, the same convention Vue SFCs use for `?vue&type=script&lang.ts`. Chunk filenames are unchanged.
+
+- d8f1ea8: Apply the configured `nonce` to the two script tags that were still missing it, so a strict `script-src` CSP no longer needs `unsafe-inline`:
+  - The client-side redirect that streaming mode emits after the shell has already flushed (`<script>window.location=...</script>`) now carries the nonce.
+  - The SPA entry script tag now carries the nonce, matching the SSR entry script.
+
+- 27fca88: Fix actions returning `json()` or `reload()` leaving no-JS form submissions stranded on the `/_server` endpoint. These responses carry a value rather than a destination, so the redirect issued for progressive-enhancement submissions had no `Location` header. It now falls back to the submitting page, and the response value is unwrapped into the flash cookie so `useSubmission().result` matches the JS path.
+- 75debc3: Scope the built-in `~` alias to the app package, so files in other workspace packages can map `~` to their own root through an importer-aware plugin such as `vite-tsconfig-paths`. In stylesheets and asset URLs (CSS `@import`, `url()`, `new URL(..., import.meta.url)`) `~` still always means the app root, since Vite resolves those without running plugins.
+
+## 2.0.0-rc.4
+
+### Patch Changes
+
+- b6dfaac: Updated dependencies, including `cookie-es` to 3, `shiki` to 4, `srvx` to 0.12.4, `oxc-parser` to 0.141 and `seroval` to 1.5.6. `parseSetCookie` now returns `undefined` for cookies with a forbidden name or an empty name and value, and those cookies are no longer forwarded to nested server function requests.
+- 02cd41e: Stop the dev toolbar from reporting benign `ResizeObserver loop` notifications as application errors. Browsers dispatch these as window `error` events carrying no error object, so the toolbar was capturing the raw `ErrorEvent` and force-opening the error panel over the app on every resize.
+- d3c2af2: Don't send server error stack traces to the client in production builds. When a server function throws, the error is serialized and rethrown on the client, and seroval included `Error.prototype.stack` by default, leaking server file paths and internal function names. Stacks are still serialized in development.
+
+## 2.0.0-rc.3
+
+### Patch Changes
+
+- d9018d6: fix(types): add missing properties to `SolidStartOptions` and expose them via Vite plugin configuration
+- e26cef0: Fix TS2883/TS2742 when emitting declarations for `entry-server.tsx`. `createHandler` now returns `StartHandler`, a type owned by `@solidjs/start`, instead of h3's `H3`, so the inferred type of `export default createHandler(...)` no longer has to be named through a nested `node_modules/@solidjs/start/node_modules/h3` path.
+- 7c8dbe6: keep TypeScript namespace members in route files during production builds
+- b3c7aaf: Update `h3` to `2.0.1-rc.26`.
+- b3c7aaf: Fixed event response status and headers set during server-side rendering with deferred async resources, not being applied on the outgoing response.
+
+## 2.0.0-rc.2
+
+### Minor Changes
+
+- eeff49a: add new dev toolbar
+
+### Patch Changes
+
+- bd8cb01: Update srvx to version 0.12.0.
+- 4e98ac0: Restore the optional `routerLoad` third argument to `createHandler`, which primes custom routers (e.g. TanStack Router) on the server before SSR rendering. It was accidentally dropped in the v2 rewrite.
+
 ## 2.0.0-rc.1
 
 ### Minor Changes

package/dist/config/app-root-alias.d.ts

@@ -0,0 +1,7 @@
+import { type Plugin } from "vite";
+/**
+ * Provides SolidStart's `~` app-root alias without claiming module imports made
+ * by other workspace packages. Those packages may map `~` to their own root
+ * through an importer-aware resolver such as vite-tsconfig-paths.
+ */
+export declare function appRootAlias(projectRoot: string, appRoot: string): Plugin;

package/dist/config/app-root-alias.js

@@ -0,0 +1,58 @@
+import { existsSync } from "node:fs";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import { normalizePath } from "vite";
+/**
+ * `~/app.css`, `~/logo.svg`, ... but not `~/lib/api.ts` or `~/components/Counter`.
+ *
+ * CSS `@import`, `url()`, preprocessor imports and `new URL(..., import.meta.url)`
+ * are resolved by internal Vite resolvers that only run the alias plugin, never
+ * user plugins, so those ids can never reach `resolveId` below. Keeping non-module
+ * ids on a plain alias preserves `~` in stylesheets and asset URLs, where it always
+ * means the app root.
+ */
+const NON_MODULE_ID = /^~\/([^?#]*\.(?![cm]?[jt]sx?(?:[?#]|$))[^./?#]+(?:[?#].*)?)$/;
+/**
+ * Provides SolidStart's `~` app-root alias without claiming module imports made
+ * by other workspace packages. Those packages may map `~` to their own root
+ * through an importer-aware resolver such as vite-tsconfig-paths.
+ */
+export function appRootAlias(projectRoot, appRoot) {
+    const appDir = normalizePath(resolve(projectRoot, appRoot));
+    const packageRoots = new Map();
+    /** Nearest directory at or above `directory` that holds a `package.json`. */
+    function packageRoot(directory) {
+        if (!packageRoots.has(directory)) {
+            const parent = dirname(directory);
+            packageRoots.set(directory, existsSync(join(directory, "package.json"))
+                ? directory
+                : parent === directory
+                    ? undefined
+                    : packageRoot(parent));
+        }
+        return packageRoots.get(directory);
+    }
+    const appPackage = packageRoot(appDir);
+    /** True only when the importer demonstrably belongs to another package. */
+    function isForeignImporter(importer) {
+        const file = normalizePath(importer.replace(/[?#].*$/s, ""));
+        if (!isAbsolute(file))
+            return false;
+        const owner = packageRoot(dirname(file));
+        return owner !== undefined && owner !== appPackage;
+    }
+    return {
+        name: "solid-start:app-root-alias",
+        enforce: "pre",
+        config() {
+            return { resolve: { alias: [{ find: NON_MODULE_ID, replacement: `${appDir}/$1` }] } };
+        },
+        async resolveId(id, importer, options) {
+            if (id !== "~" && !id.startsWith("~/"))
+                return null;
+            if (importer && isForeignImporter(importer))
+                return null;
+            const target = join(appDir, id.slice(1));
+            return (await this.resolve(target, importer, { ...options, skipSelf: true })) ?? target;
+        },
+    };
+}

package/dist/config/constants.d.ts

@@ -5,7 +5,9 @@ export declare const VIRTUAL_MODULES: {
     readonly getClientManifest: "solid-start:get-client-manifest";
     readonly getManifest: "solid-start:get-manifest";
     readonly middleware: "solid-start:middleware";
+    readonly serovalPlugins: "solid-start:seroval-plugins";
     readonly serverFnManifest: "solid-start:server-fn-manifest";
+    readonly serverFnErrorHandler: "solid-start:server-fn-error-handler";
     readonly clientEntry: "solid-start:client-entry";
     readonly serverEntry: "solid-start:server-entry";
     readonly app: "solid-start:app";

package/dist/config/constants.js

@@ -5,7 +5,9 @@ export const VIRTUAL_MODULES = {
     getClientManifest: "solid-start:get-client-manifest",
     getManifest: "solid-start:get-manifest",
     middleware: "solid-start:middleware",
+    serovalPlugins: "solid-start:seroval-plugins",
     serverFnManifest: "solid-start:server-fn-manifest",
+    serverFnErrorHandler: "solid-start:server-fn-error-handler",
     clientEntry: "solid-start:client-entry",
     serverEntry: "solid-start:server-entry",
     app: "solid-start:app",

package/dist/config/env.js

@@ -58,13 +58,13 @@ export function envPlugin(options) {
                 }
                 const vars = currentOptions.server?.load
                     ? currentOptions.server.load(env)
-                    : loadEnv(env, '.', serverPrefix);
+                    : loadEnv(env, ".", serverPrefix);
                 return convertObjectToModule(vars);
             }
             if (filename === CLIENT_ENV) {
                 const vars = currentOptions.client?.load
                     ? currentOptions.client.load(env)
-                    : loadEnv(env, '.', clientPrefix);
+                    : loadEnv(env, ".", clientPrefix);
                 return convertObjectToModule(vars);
             }
             if (filename === SERVER_RUNTIME_LOADER) {

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

@@ -1,6 +1,6 @@
 import { relative } from "node:path";
 import { fileSystemWatcher } from "./fs-watcher.js";
-import { treeShake } from "./tree-shake.js";
+import { toPickId, treeShake } from "./tree-shake.js";
 export const moduleId = "solid-start:routes";
 export function fsRoutes({ routers }) {
     globalThis.ROUTERS = routers;
@@ -24,7 +24,7 @@ export function fsRoutes({ routers }) {
                     if (v === undefined)
                         return undefined;
                     if (k.startsWith("$$")) {
-                        const buildId = `${v.src}?${v.pick.map((p) => `pick=${p}`).join("&")}`;
+                        const buildId = toPickId(v.src, v.pick);
                         /**
                          * @type {{ [key: string]: string }}
                          */
@@ -40,7 +40,7 @@ export function fsRoutes({ routers }) {
                         };
                     }
                     else if (k.startsWith("$")) {
-                        const buildId = `${v.src}?${v.pick.map((p) => `pick=${p}`).join("&")}`;
+                        const buildId = toPickId(v.src, v.pick);
                         return {
                             src: relative(root, buildId),
                             build: isBuild ? `_$() => import('${buildId}')$_` : undefined,

package/dist/config/fs-routes/tree-shake.d.ts

@@ -1,2 +1,29 @@
 import type { Plugin } from "vite";
+/**
+ * Builds the module id used to import a subset of a route file's exports.
+ *
+ * The `pick` list has to live in the query so that the same file can be
+ * instantiated once per export subset (the client picks `default`/`$css`,
+ * the server picks its HTTP handlers). That query would otherwise leave the
+ * id ending in `?pick=GET`, which silently excludes route files from any
+ * plugin whose filter is anchored on the file extension -- a very common
+ * default, e.g. unplugin-macros' `/\.[cm]?[jt]sx?$/`.
+ *
+ * The trailing `lang.<ext>` marker is the same convention Vue SFCs use
+ * (`?vue&type=script&lang.ts`) and puts a real extension back at the end of
+ * the id, so those filters match again.
+ *
+ * @see https://github.com/solidjs/solid-start/issues/1918
+ */
+export declare function toPickId(src: string, pick: string[]): string;
+/**
+ * Rolldown's default chunk name sanitizer, plus a pass that drops the
+ * `?pick=...&lang` tail so route chunks keep the short, stable filenames they
+ * had before the `lang` marker was introduced (`index-<hash>.js`, not
+ * `index.tsx_pick_default_pick__css_lang-<hash>.js`). Client chunk filenames
+ * are public URLs, so this is not purely cosmetic.
+ *
+ * @see https://github.com/rollup/rollup/blob/master/src/utils/sanitizeFileName.ts
+ */
+export declare function sanitizeChunkFileName(name: string): string;
 export declare function treeShake(): Plugin;

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

@@ -1,7 +1,52 @@
 // All credit for this work goes to the amazing Next.js team.
 // https://github.com/vercel/next.js/blob/canary/packages/next/build/babel/plugins/next-ssg-transform.ts
 // This is adapted to work with routeData functions. It can be run in two modes, one which preserves the routeData and the Component in the same file, and one which creates a
-import { basename } from "pathe";
+import { basename, extname } from "pathe";
+const PICKABLE_EXTENSIONS = ["js", "jsx", "ts", "tsx"];
+/**
+ * Builds the module id used to import a subset of a route file's exports.
+ *
+ * The `pick` list has to live in the query so that the same file can be
+ * instantiated once per export subset (the client picks `default`/`$css`,
+ * the server picks its HTTP handlers). That query would otherwise leave the
+ * id ending in `?pick=GET`, which silently excludes route files from any
+ * plugin whose filter is anchored on the file extension -- a very common
+ * default, e.g. unplugin-macros' `/\.[cm]?[jt]sx?$/`.
+ *
+ * The trailing `lang.<ext>` marker is the same convention Vue SFCs use
+ * (`?vue&type=script&lang.ts`) and puts a real extension back at the end of
+ * the id, so those filters match again.
+ *
+ * @see https://github.com/solidjs/solid-start/issues/1918
+ */
+export function toPickId(src, pick) {
+    const query = pick.map(p => `pick=${p}`).join("&");
+    const ext = extname(src).slice(1);
+    return PICKABLE_EXTENSIONS.includes(ext) ? `${src}?${query}&lang.${ext}` : `${src}?${query}`;
+}
+/**
+ * Matches the tail that {@link toPickId} appends, as it appears in a chunk
+ * name. Rolldown derives a chunk name from the module id by taking the
+ * basename minus its extension, so `index.tsx?pick=default&pick=$css&lang.tsx`
+ * arrives here as `index.tsx?pick=default&pick=$css&lang`.
+ */
+const PICK_CHUNK_NAME_RE = /\.[cm]?[jt]sx?\?pick=[^?]*&lang$/;
+const INVALID_CHAR_RE = /[\u0000-\u001F"#$&*+,:;<=>?[\]^`{|}\u007F]/g;
+const DRIVE_LETTER_RE = /^[a-z]:/i;
+/**
+ * Rolldown's default chunk name sanitizer, plus a pass that drops the
+ * `?pick=...&lang` tail so route chunks keep the short, stable filenames they
+ * had before the `lang` marker was introduced (`index-<hash>.js`, not
+ * `index.tsx_pick_default_pick__css_lang-<hash>.js`). Client chunk filenames
+ * are public URLs, so this is not purely cosmetic.
+ *
+ * @see https://github.com/rollup/rollup/blob/master/src/utils/sanitizeFileName.ts
+ */
+export function sanitizeChunkFileName(name) {
+    const stripped = name.replace(PICK_CHUNK_NAME_RE, "");
+    const driveLetter = DRIVE_LETTER_RE.exec(stripped)?.[0] ?? "";
+    return driveLetter + stripped.slice(driveLetter.length).replace(INVALID_CHAR_RE, "_");
+}
 function treeShakeTransform({ types: t }) {
     function getIdentifier(path) {
         const parentPath = path.parentPath;
@@ -133,6 +178,11 @@ function treeShakeTransform({ types: t }) {
                             if (!state.opts.pick) {
                                 return;
                             }
+                            // Only module-level exports are route exports; `export` inside a
+                            // TS namespace/module block is unrelated to the pick list.
+                            if (!exportNamedPath.parentPath.isProgram()) {
+                                return;
+                            }
                             const specifiers = exportNamedPath.get("specifiers");
                             if (specifiers.length) {
                                 specifiers.forEach(s => {

package/dist/config/index.d.ts

@@ -1,25 +1,174 @@
-import type { PluginOption } from "vite";
+import type { PluginOption, FilterPattern } from "vite";
 import { type Options as SolidOptions } from "vite-plugin-solid";
 import { type ServerFunctionsOptions } from "../directives/index.ts";
 import { type EnvPluginOptions } from "./env.ts";
+/**
+ * Configuration options for SolidStart. (previously in `app.config.ts`)
+ *
+ * @see https://docs.solidjs.com/solid-start/v2/migrating-from-v1#move-framework-configuration-into-viteconfigts
+ */
 export interface SolidStartOptions {
+    /**
+     * Path to the root of the application (where `app.tsx` / `app.jsx` lives).
+     *
+     * @default "./src"
+     */
+    appRoot?: string;
+    /**
+     * Options related to the css crawling logic
+     */
+    css?: {
+        /**
+         * Filter files included during css crawling in development.
+         */
+        filter?: {
+            include?: FilterPattern;
+            exclude?: FilterPattern;
+        };
+    };
+    /**
+     * Options forwarded to `vite-plugin-solid`.
+     *
+     * @see https://github.com/solidjs/vite-plugin-solid#api
+     */
     solid?: Partial<SolidOptions>;
+    /**
+     * Enable or disable server-side rendering.
+     *
+     * - `true` — SSR (default)
+     * - `false` — client-side rendering only (SPA mode)
+     *
+     * @default true
+     */
     ssr?: boolean;
+    /**
+     * Show the SolidStart development overlay (error overlay, etc.) in development.
+     *
+     * @default true
+     */
+    devOverlay?: boolean;
+    /**
+     * Experimental features.
+     */
+    experimental?: {
+        /**
+         * Enable islands architecture mode.
+         *
+         * Currently fixed to `false` (not yet fully supported).
+         *
+         * @default false
+         */
+        islands?: false;
+    };
+    /**
+     * Directory containing file-system routes, relative to {@link appRoot}.
+     *
+     * @default "./routes"
+     */
     routeDir?: string;
+    /**
+     * File extensions that should be treated as routes.
+     *
+     * @default ["js", "jsx", "ts", "tsx"]
+     */
     extensions?: string[];
+    /**
+     * Path to an optional middleware module.
+     *
+     * The module should export a middleware created with `createMiddleware`
+     * from `@solidjs/start/middleware`.
+     *
+     * @example "src/middleware/index.ts"
+     */
     middleware?: string;
+    /**
+     * Serialization settings for server-function / action payloads
+     * that cross the server-client boundary.
+     */
     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.
+         *
+         * - `"js"` — Uses a custom binary format (Seroval) that is more efficient
+         *   than JSON, but requires a custom deserializer (with `eval()`) on the client.
+         *   A strong CSP that blocks `eval()` will prevent this mode from working.
+         * - `"json"` — Uses JSON for serialization. Less efficient / larger payloads,
+         *   but can be deserialized with `JSON.parse` on the client and is CSP-friendly.
          *
          * @default "json"
          */
         mode?: "js" | "json";
+        /**
+         * Path to a module whose default export is an array of custom Seroval
+         * plugins, used to serialize values Seroval doesn't understand natively
+         * (ORM id types, decimals, `Temporal`, and other custom classes).
+         *
+         * Build plugins with `createPlugin` from `seroval`. The module is bundled
+         * into both the client and the server so that both ends of a server
+         * function agree on the format, so it must not import server-only code.
+         *
+         * SolidStart's built-in plugins take precedence: Seroval uses the first
+         * plugin whose `test()` passes, and these are appended after the built-ins.
+         *
+         * A plugin's `deserialize` rebuilds the value under {@link mode} `"json"`.
+         * `serialize` is only used by `mode: "js"`, where the payload is evaluated
+         * on the client and may therefore reference globals only, not the plugin
+         * module's own imports.
+         *
+         * Only applies to server-function and action payloads. The SSR hydration
+         * payload is serialized by `solid-js/web` and is unaffected.
+         *
+         * @example "src/seroval-plugins.ts"
+         */
+        plugins?: string;
     };
+    /**
+     * Configures plugin behavior per build environment
+     */
     env?: EnvPluginOptions;
-    serverFunctions?: Pick<ServerFunctionsOptions, "filter">;
+    /**
+     * Options for server functions: which files the `"use server"` transform
+     * processes (inclusion / exclusion filters), and what happens when a server
+     * function throws.
+     */
+    serverFunctions?: Pick<ServerFunctionsOptions, "filter"> & {
+        /**
+         * Path to a module whose default export handles whatever a server function
+         * throws, before it reaches the client. Use it to report failures to a
+         * monitoring service, or to replace an error carrying internal detail with
+         * one that is safe to send.
+         *
+         * Only server function calls made over the network run through it. A
+         * server function called during rendering runs in process and throws
+         * straight to its caller, and errors from API routes never reach it
+         * either.
+         *
+         * The handler may be asynchronous. SolidStart awaits its return value
+         * before serializing the response, allowing a monitoring service to flush
+         * first. The resolved value decides what the client sees:
+         *
+         * - `undefined` (or `null`) sends what was thrown, unchanged.
+         * - A `Response` is passed through unchanged, which keeps a thrown
+         *   `redirect()` working.
+         * - Any other value is sent in place of what was thrown, and the client
+         *   call rejects with it.
+         * - If the handler throws or rejects, what the server function threw is
+         *   sent unchanged.
+         *
+         * Control flow reaches the export the same way errors do, so a handler
+         * that replaces everything it sees turns redirects into errors.
+         *
+         * Whatever is sent gets serialized to the client along with its own
+         * properties, so an error meant to be safe to expose must not carry
+         * internal detail.
+         *
+         * Type the export as `ServerFunctionErrorHandler` from
+         * `@solidjs/start/server`. The module is bundled into the server only, so
+         * it may import server-only code such as a monitoring SDK.
+         *
+         * @example "src/server-fn-error.ts"
+         */
+        onError?: string;
+    };
 }
 export declare function solidStart(options?: SolidStartOptions): Array<PluginOption>;

package/dist/config/index.js

@@ -3,12 +3,14 @@ import { globSync } from "node:fs";
 import { basename, extname, isAbsolute, join } from "node:path";
 import solid from "vite-plugin-solid";
 import { serverFunctionsPlugin } from "../directives/index.js";
+import { appRootAlias } from "./app-root-alias.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";
 import { SolidStartClientFileRouter, SolidStartServerFileRouter } from "./fs-router.js";
 import { fsRoutes } from "./fs-routes/index.js";
+import { sanitizeChunkFileName, toPickId } from "./fs-routes/tree-shake.js";
 import lazy from "./lazy.js";
 import { manifest } from "./manifest.js";
 import { parseIdQuery } from "./utils.js";
@@ -71,17 +73,23 @@ export function solidStart(options) {
                     for (const route of await clientRouter.getRoutes()) {
                         for (const [key, value] of Object.entries(route)) {
                             if (value && key.startsWith("$") && !key.startsWith("$$")) {
-                                function toRouteId(route) {
-                                    return `${route.src}?${route.pick.map((p) => `pick=${p}`).join("&")}`;
-                                }
-                                clientInput.push(toRouteId(value));
+                                clientInput.push(toPickId(value.src, value.pick));
                             }
                         }
                     }
                 }
                 return {
                     appType: "custom",
-                    build: { assetsDir: "_build/assets" },
+                    build: {
+                        assetsDir: "_build/assets",
+                        rolldownOptions: {
+                            output: {
+                                // Keeps route chunks named after their file rather than after
+                                // the `?pick=...` id that addresses them. See toPickId.
+                                sanitizeFileName: sanitizeChunkFileName,
+                            },
+                        },
+                    },
                     optimizeDeps: {
                         // Suppress TS errors from Vite 7 types when configuring Vite 8's Rolldown
                         ...{
@@ -99,7 +107,7 @@ export function solidStart(options) {
                                 write: true,
                                 manifest: true,
                                 outDir: "dist/client",
-                                rollupOptions: {
+                                rolldownOptions: {
                                     input: clientInput,
                                     treeshake: true,
                                     preserveEntrySignatures: "exports-only",
@@ -113,7 +121,7 @@ export function solidStart(options) {
                                 write: true,
                                 manifest: true,
                                 copyPublicDir: false,
-                                rollupOptions: {
+                                rolldownOptions: {
                                     input: handlers.server,
                                 },
                                 outDir: "dist/server",
@@ -126,7 +134,6 @@ export function solidStart(options) {
                     resolve: {
                         alias: {
                             "@solidjs/start/server/entry": handlers.server,
-                            "~": join(process.cwd(), start.appRoot),
                             ...(!start.ssr
                                 ? {
                                     "@solidjs/start/server": "@solidjs/start/server/spa",
@@ -175,6 +182,7 @@ export function solidStart(options) {
                 };
             },
         },
+        appRootAlias(root, start.appRoot),
         manifest(start),
         fsRoutes({
             routers: {

package/dist/config/lazy.js

@@ -58,12 +58,17 @@ const lazy = () => {
             if (this.environment.name !== VITE_ENVIRONMENTS.client)
                 return;
             for (const chunk of Object.values(bundle)) {
-                if (chunk.type !== "chunk" || !chunk.isDynamicEntry || chunk.facadeModuleId)
+                if (chunk.type !== "chunk" || chunk.facadeModuleId)
+                    continue;
+                if (!chunk.viteMetadata?.importedCss.size)
+                    continue;
+                const moduleIds = chunk.moduleIds.filter(id => !id.endsWith("css"));
+                if (moduleIds.length <= 1)
                     continue;
                 // Has to follow Vites implementation:
                 // https://github.com/vitejs/vite/blob/4be37a8389c67873880f826b01fe40137e1c29a7/packages/vite/src/node/plugins/manifest.ts#L179
                 const chunkName = `_${basename(chunk.fileName)}`;
-                for (const id of chunk.moduleIds) {
+                for (const id of moduleIds) {
                     sharedChunkNames[id] = chunkName;
                 }
             }

package/dist/config/manifest.d.ts

@@ -1,3 +1,6 @@
 import { type PluginOption } from "vite";
 import { type SolidStartOptions } from "./index.ts";
+type StyleFilterOptions = NonNullable<SolidStartOptions["css"]>["filter"];
+export declare function createStyleFilter(options?: StyleFilterOptions): (id: unknown) => boolean;
 export declare function manifest(start: SolidStartOptions): PluginOption;
+export {};