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

package/dist/config/manifest.js

@@ -1,12 +1,17 @@
 import fs from "node:fs";
 import path from "node:path";
-import { version as viteVersion } from "vite";
+import { createFilter, version as viteVersion } from "vite";
 import { fileURLToPath } from "node:url";
 import { findStylesInModuleGraph } from "../server/collect-styles.js";
 import { VIRTUAL_MODULES } from "./constants.js";
 import { wrapId } from "./vite-utils.js";
+const DEFAULT_STYLE_EXCLUDE = /node_modules/;
+export function createStyleFilter(options) {
+    return createFilter(options?.include || [], options?.exclude || DEFAULT_STYLE_EXCLUDE);
+}
 export function manifest(start) {
     let devServer = undefined;
+    const styleFilter = createStyleFilter(start.css?.filter);
     return {
         name: "solid-start:manifest-plugin",
         enforce: "pre",
@@ -28,6 +33,18 @@ export function manifest(start) {
                     return await this.resolve(start.middleware);
                 return `\0${VIRTUAL_MODULES.middleware}`;
             }
+            if (id === VIRTUAL_MODULES.serovalPlugins) {
+                const plugins = start.serialization?.plugins;
+                if (plugins)
+                    return await this.resolve(plugins);
+                return `\0${VIRTUAL_MODULES.serovalPlugins}`;
+            }
+            if (id === VIRTUAL_MODULES.serverFnErrorHandler) {
+                const onError = start.serverFunctions?.onError;
+                if (onError)
+                    return await this.resolve(onError);
+                return `\0${VIRTUAL_MODULES.serverFnErrorHandler}`;
+            }
         },
         async load(id) {
             if (id === `\0${VIRTUAL_MODULES.clientViteManifest}`) {
@@ -40,7 +57,7 @@ export function manifest(start) {
                     if (!entry)
                         throw new Error("No client entry found");
                     let rawManifest;
-                    const viteMajor = parseInt(viteVersion.split('.')[0], 10);
+                    const viteMajor = parseInt(viteVersion.split(".")[0], 10);
                     const manifestKey = Object.keys(globalThis.START_CLIENT_BUNDLE).find(k => k.endsWith("manifest.json"));
                     if (manifestKey && viteMajor < 8) {
                         const manifestAsset = globalThis.START_CLIENT_BUNDLE[manifestKey];
@@ -53,7 +70,8 @@ export function manifest(start) {
                             if (devServer?.environments?.client?.config?.build?.outDir) {
                                 outDir = devServer.environments.client.config.build.outDir;
                             }
-                            else if (this.environment?.config?.build?.outDir && this.environment?.config?.consumer === "client") {
+                            else if (this.environment?.config?.build?.outDir &&
+                                this.environment?.config?.consumer === "client") {
                                 outDir = this.environment.config.build.outDir;
                             }
                             else if (globalThis.START_CLIENT_OUT_DIR) {
@@ -75,6 +93,10 @@ export function manifest(start) {
             }
             else if (id === `\0${VIRTUAL_MODULES.middleware}`)
                 return "export default {};";
+            else if (id === `\0${VIRTUAL_MODULES.serovalPlugins}`)
+                return "export default [];";
+            else if (id === `\0${VIRTUAL_MODULES.serverFnErrorHandler}`)
+                return "export default undefined;";
             else if (id.startsWith("/@manifest")) {
                 if (this.environment.mode !== "dev")
                     throw new Error("@manifest queries are only allowed in dev");
@@ -91,7 +113,7 @@ export function manifest(start) {
                     // Client env does not have css dependencies in mod.transformResult
                     // Aalways use ssr env instead, to prevent hydration mismatches
                     const env = devServer.environments["ssr"];
-                    const styles = await findStylesInModuleGraph(env, id);
+                    const styles = await findStylesInModuleGraph(env, id, styleFilter);
                     const cssAssets = Object.entries(styles).map(([key, value]) => `{
 						tag: "style",
 						attrs: {

package/dist/directives/remove-unused-variables.js

@@ -8,10 +8,22 @@ function isInvalidForRemoval(path) {
     // This one is for destructured variables
     let target = path;
     if (isPathValid(path, t.isVariableDeclarator)) {
-        target = path.get('id');
+        target = path.get("id");
     }
     return isPathValid(target, t.isObjectPattern) || isPathValid(target, t.isArrayPattern);
 }
+function countValidImport(node) {
+    if (node.importKind === "type") {
+        return 0;
+    }
+    let count = 0;
+    for (const specifier of node.specifiers) {
+        if (specifier.type !== "ImportSpecifier" || specifier.importKind === "value") {
+            count += 1;
+        }
+    }
+    return count;
+}
 export function removeUnusedVariables(program) {
     // TODO(Alexis):
     // This implementation is simple but slow
@@ -34,7 +46,7 @@ export function removeUnusedVariables(program) {
                             if (binding.references === 0 && !binding.path.removed) {
                                 const parent = binding.path.parentPath;
                                 if (isPathValid(parent, t.isImportDeclaration)) {
-                                    if (parent.node.specifiers.length === 1) {
+                                    if (countValidImport(parent.node) <= 1) {
                                         parent.remove();
                                     }
                                     else {
@@ -42,7 +54,7 @@ export function removeUnusedVariables(program) {
                                     }
                                     dirty = true;
                                 }
-                                else if (!(isInvalidForRemoval(binding.path))) {
+                                else if (!isInvalidForRemoval(binding.path)) {
                                     binding.path.remove();
                                     dirty = true;
                                 }

package/dist/directives/xxhash32.js

@@ -34,7 +34,7 @@ function toUtf8(text) {
  * @param seed - optional seed (32-bit unsigned);
  */
 export default function xxHash32(buffer, seed = 0) {
-    buffer = typeof buffer === 'string' ? toUtf8(buffer) : buffer;
+    buffer = typeof buffer === "string" ? toUtf8(buffer) : buffer;
     const b = buffer;
     /*
       Step 1. Initialize internal accumulators
@@ -144,9 +144,7 @@ export default function xxHash32(buffer, seed = 0) {
         const laneP = laneN0 * PRIME32_3 + ((laneN1 * PRIME32_3) << 16);
         acc = (acc + laneP) & 0xffffffff;
         acc = (acc << 17) | (acc >>> 15);
-        acc =
-            ((acc & 0xffff) * PRIME32_4 + (((acc >>> 16) * PRIME32_4) << 16)) &
-                0xffffffff;
+        acc = ((acc & 0xffff) * PRIME32_4 + (((acc >>> 16) * PRIME32_4) << 16)) & 0xffffffff;
     }
     /*
           ```
@@ -162,9 +160,7 @@ export default function xxHash32(buffer, seed = 0) {
         const lane = b[offset];
         acc += lane * PRIME32_5;
         acc = (acc << 11) | (acc >>> 21);
-        acc =
-            ((acc & 0xffff) * PRIME32_1 + (((acc >>> 16) * PRIME32_1) << 16)) &
-                0xffffffff;
+        acc = ((acc & 0xffff) * PRIME32_1 + (((acc >>> 16) * PRIME32_1) << 16)) & 0xffffffff;
     }
     /*
           Step 6. Final mix (avalanche)
@@ -180,13 +176,9 @@ export default function xxHash32(buffer, seed = 0) {
           ```
       */
     acc ^= acc >>> 15;
-    acc =
-        (((acc & 0xffff) * PRIME32_2) & 0xffffffff) +
-            (((acc >>> 16) * PRIME32_2) << 16);
+    acc = (((acc & 0xffff) * PRIME32_2) & 0xffffffff) + (((acc >>> 16) * PRIME32_2) << 16);
     acc ^= acc >>> 13;
-    acc =
-        (((acc & 0xffff) * PRIME32_3) & 0xffffffff) +
-            (((acc >>> 16) * PRIME32_3) << 16);
+    acc = (((acc & 0xffff) * PRIME32_3) & 0xffffffff) + (((acc >>> 16) * PRIME32_3) << 16);
     acc ^= acc >>> 16;
     // turn any negatives back into a positive number;
     return acc < 0 ? acc + 4294967296 : acc;

package/dist/fns/client.js

@@ -1,10 +1,11 @@
+import { pushRequest, pushResponse } from "../shared/dev-toolbar/functions/tracker.js";
 import { 
 // serializeToJSONStream,
 serializeToJSONString, } from "./serialization.js";
-import { BODY_FORMAT_KEY, BodyFormat, extractBody, getHeadersAndBody, } from "./shared.js";
+import { BODY_FORMAT_KEY, BodyFormat, extractBody, getHeadersAndBody } from "./shared.js";
 let INSTANCE = 0;
-function createRequest(base, id, instance, options) {
-    return fetch(base, {
+async function createRequest(base, id, instance, options) {
+    const request = new Request(base, {
         method: "POST",
         ...options,
         headers: {
@@ -13,6 +14,14 @@ function createRequest(base, id, instance, options) {
             "X-Server-Instance": instance,
         },
     });
+    if (import.meta.env.DEV) {
+        pushRequest(id, instance, request.clone());
+    }
+    const response = await fetch(request);
+    if (import.meta.env.DEV) {
+        pushResponse(id, instance, response.clone());
+    }
+    return response;
 }
 async function initializeResponse(base, id, instance, options, args) {
     // No args, skip serialization
@@ -63,8 +72,8 @@ async function fetchServerFunction(base, id, options, args) {
         return response;
     }
     const result = await extractBody(instance, true, response.clone());
-    if (response.headers.has("X-Error")) {
-        throw result;
+    if (response.headers.has("X-Error") || response.status >= 500) {
+        throw result ?? new Error(`Server function call failed with status ${response.status}`);
     }
     return result;
 }

package/dist/fns/error-handler.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Handles whatever a server function threw, before it reaches the client. Use
+ * it to type the default export of the module named by the
+ * `serverFunctions.onError` option in `vite.config.ts`.
+ *
+ * The handler may be asynchronous. SolidStart awaits its return value before
+ * sending the error to the client. If the handler throws or rejects, SolidStart
+ * sends the original thrown value instead.
+ *
+ * @param thrown The value the server function threw. This is a `Response` when
+ * the server function threw control flow such as a `redirect()`.
+ * @returns `undefined` (or `null`) to send `thrown` unchanged, a `Response` to
+ * preserve control flow, any other replacement value, or a promise resolving
+ * to any of those values.
+ *
+ * @example
+ * ```ts
+ * // src/server-fn-error.ts
+ * import type { ServerFunctionErrorHandler } from "@solidjs/start/server";
+ * import { captureException } from "./your-monitoring-client";
+ *
+ * const onServerFunctionError: ServerFunctionErrorHandler = thrown => {
+ *   // redirect() throws a Response, so returning it preserves that control flow.
+ *   if (thrown instanceof Response) return thrown;
+ *
+ *   captureException(thrown); // or console.error, or any reporter
+ *   return new Error("Something went wrong");
+ * };
+ *
+ * export default onServerFunctionError;
+ * ```
+ */
+export type ServerFunctionErrorHandler = (thrown: unknown) => unknown;
+export declare function applyServerFunctionErrorHandler(thrown: unknown): Promise<unknown>;

package/dist/fns/error-handler.js

@@ -0,0 +1,10 @@
+import onServerFunctionError from "solid-start:server-fn-error-handler";
+export async function applyServerFunctionErrorHandler(thrown) {
+    try {
+        const replacement = await onServerFunctionError?.(thrown);
+        return replacement ?? thrown;
+    }
+    catch {
+        return thrown;
+    }
+}

package/dist/fns/handler.d.ts

@@ -2,4 +2,4 @@ import { type H3Event } from "h3";
 import "solid-start:server-fn-manifest";
 import type { FetchEvent } from "../server/types.ts";
 export declare function handleServerFunction(h3Event: H3Event): Promise<unknown>;
-export declare function createSingleFlightHeaders(sourceEvent: FetchEvent): Headers;
+export declare function createSingleFlightHeaders(sourceEvent: FetchEvent, result?: unknown): Headers;

package/dist/fns/handler.js

@@ -17,6 +17,7 @@ import { deserializeFromJSONString, serializeToJSONStream, serializeToJSStream,
 import { BODY_FORMAT_KEY, BodyFormat, extractBody, getHeadersAndBody } from "./shared.js";
 import "solid-start:server-fn-manifest";
 import { getServerFunction, hasServerFunction } from "./registration.js";
+import { applyServerFunctionErrorHandler } from "./error-handler.js";
 import { getExpectedRedirectStatus } from "../server/util.js";
 export async function handleServerFunction(h3Event) {
     const event = getFetchEvent(h3Event);
@@ -109,7 +110,7 @@ export async function handleServerFunction(h3Event) {
         }
         // handle no JS success case
         if (!instance)
-            return handleNoJS(result, request, parsed);
+            return await handleNoJS(result, request, parsed);
         const body = getHeadersAndBody(result);
         if (body) {
             return new Response(body.body, {
@@ -121,10 +122,10 @@ export async function handleServerFunction(h3Event) {
             h3Event.res.headers.set("content-type", "text/javascript");
             return serializeToJSStream(instance, result);
         }
-        h3Event.res.headers.set("content-type", "text/plain");
         return serializeToJSONStream(result);
     }
     catch (x) {
+        x = await applyServerFunctionErrorHandler(x);
         if (x instanceof Response) {
             if (singleFlight && instance) {
                 x = await handleSingleFlight(event, x);
@@ -147,7 +148,7 @@ export async function handleServerFunction(h3Event) {
             h3Event.res.headers.set("X-Error", toHeaderValue(error));
         }
         else {
-            x = handleNoJS(x, request, parsed, true);
+            x = await handleNoJS(x, request, parsed, true);
         }
         if (instance) {
             const body = getHeadersAndBody(x);
@@ -166,7 +167,6 @@ export async function handleServerFunction(h3Event) {
                 h3Event.res.headers.set("content-type", "text/javascript");
                 return serializeToJSStream(instance, x);
             }
-            h3Event.res.headers.set("content-type", "text/plain");
             return serializeToJSONStream(x);
         }
         return x;
@@ -183,7 +183,20 @@ function toHeaderValue(value) {
         return "true";
     }
 }
-function handleNoJS(result, request, parsed, thrown) {
+function getRefererLocation(request, url) {
+    const referer = request.headers.get("referer");
+    try {
+        if (referer)
+            return new URL(referer).toString();
+    }
+    catch {
+        // fall through to the app root below
+    }
+    // no usable referer (e.g. a no-referrer policy): the app root still beats
+    // leaving the browser sitting on the server function endpoint
+    return new URL(import.meta.env.BASE_URL, url.origin).toString();
+}
+async function handleNoJS(result, request, parsed, thrown) {
     const url = new URL(request.url);
     const isError = result instanceof Error;
     let statusCode = 302;
@@ -194,10 +207,19 @@ function handleNoJS(result, request, parsed, thrown) {
             headers.set(`Location`, new URL(result.headers.get("Location"), url.origin + import.meta.env.BASE_URL).toString());
             statusCode = getExpectedRedirectStatus(result);
         }
+        else {
+            // responses that carry a value rather than a destination (json(), reload())
+            // still have to send the browser back to the page the form came from
+            headers.set("Location", getRefererLocation(request, url));
+        }
+        // the body is dropped from the redirect, so don't advertise its type
+        headers.delete("Content-Type");
+        // mirror the JS path: the flash cookie carries the value, not the Response
+        result = result.customBody ? await result.customBody() : null;
     }
     else
         headers = new Headers({
-            Location: new URL(request.headers.get("referer")).toString(),
+            Location: getRefererLocation(request, url),
         });
     if (result) {
         headers.append("Set-Cookie", `flash=${encodeURIComponent(JSON.stringify({
@@ -205,7 +227,9 @@ function handleNoJS(result, request, parsed, thrown) {
             result: isError ? result.message : result,
             thrown: thrown,
             error: isError,
-            input: [...parsed.slice(0, -1), [...parsed[parsed.length - 1].entries()]],
+            input: parsed.length
+                ? [...parsed.slice(0, -1), [...parsed[parsed.length - 1].entries()]]
+                : [],
         }))}; Secure; HttpOnly;`);
     }
     return new Response(null, {
@@ -214,13 +238,19 @@ function handleNoJS(result, request, parsed, thrown) {
     });
 }
 let App;
-export function createSingleFlightHeaders(sourceEvent) {
+export function createSingleFlightHeaders(sourceEvent, result) {
     // cookie handling logic is pretty simplistic so this might be imperfect
     // unclear if h3 internals are available on all platforms but we need a way to
     // update request headers on the underlying H3 event.
     const headers = new Headers(sourceEvent.request.headers);
     const cookies = parseCookies(sourceEvent.nativeEvent);
     const SetCookies = sourceEvent.response.headers.getSetCookie();
+    // cookies attached to the returned/thrown response (eg. `redirect(to, { headers })`)
+    // haven't been merged onto the event response yet, but a browser round trip would
+    // have sent them back with the next request, so apply them here too. They come after
+    // the ones on the event response, so they win on conflict.
+    if (result instanceof Response)
+        SetCookies.push(...result.headers.getSetCookie());
     headers.delete("cookie");
     // let useH3Internals = false;
     // if (sourceEvent.nativeEvent.node?.req) {
@@ -230,7 +260,12 @@ export function createSingleFlightHeaders(sourceEvent) {
     SetCookies.forEach(cookie => {
         if (!cookie)
             return;
-        const { maxAge, expires, name, value } = parseSetCookie(cookie);
+        // `parseSetCookie` returns undefined for forbidden cookie names and for
+        // cookies with an empty name and value.
+        const parsed = parseSetCookie(cookie);
+        if (!parsed)
+            return;
+        const { maxAge, expires, name, value } = parsed;
         if (maxAge != null && maxAge <= 0) {
             delete cookies[name];
             return;
@@ -259,7 +294,7 @@ async function handleSingleFlight(sourceEvent, result) {
     }
     const event = { ...sourceEvent };
     event.request = new Request(url, {
-        headers: createSingleFlightHeaders(sourceEvent),
+        headers: createSingleFlightHeaders(sourceEvent, result),
     });
     return await provideRequestEvent(event, async () => {
         await createPageEvent(event);

package/dist/fns/plugins.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Re-exports Seroval's plugin authoring API for use with the
+ * `serialization.plugins` option in `vite.config.ts`.
+ *
+ * Importing from here rather than depending on `seroval` directly keeps plugin
+ * authors on the exact Seroval version SolidStart serializes with. A mismatched
+ * version would not fail the build: it would produce plugin nodes the other end
+ * of the wire can't interpret.
+ *
+ * @see https://github.com/solidjs/solid-start/issues/1474
+ *
+ * @example
+ * ```ts
+ * // src/seroval-plugins.ts
+ * import { createPlugin } from "@solidjs/start/serialization";
+ * import { ObjectId } from "mongodb";
+ *
+ * const ObjectIdPlugin = createPlugin<ObjectId, { hex: any }>({
+ *   tag: "app/ObjectId",
+ *   test: value => value instanceof ObjectId,
+ *   parse: {
+ *     sync: (value, ctx) => ({ hex: ctx.parse(value.toHexString()) }),
+ *     async: async (value, ctx) => ({ hex: await ctx.parse(value.toHexString()) }),
+ *     stream: (value, ctx) => ({ hex: ctx.parse(value.toHexString()) }),
+ *   },
+ *   serialize: (node, ctx) => `globalThis.ObjectId(${ctx.serialize(node.hex)})`,
+ *   deserialize: (node, ctx) => new ObjectId(ctx.deserialize(node.hex) as string),
+ * });
+ *
+ * export default [ObjectIdPlugin];
+ * ```
+ */
+export { createPlugin, OpaqueReference } from "seroval";
+export type { AsyncParsePluginContext, DeserializePluginContext, Plugin, PluginData, PluginInfo, SerializePluginContext, SerovalNode, StreamParsePluginContext, SyncParsePluginContext, } from "seroval";

package/dist/fns/plugins.js

@@ -0,0 +1,33 @@
+/**
+ * Re-exports Seroval's plugin authoring API for use with the
+ * `serialization.plugins` option in `vite.config.ts`.
+ *
+ * Importing from here rather than depending on `seroval` directly keeps plugin
+ * authors on the exact Seroval version SolidStart serializes with. A mismatched
+ * version would not fail the build: it would produce plugin nodes the other end
+ * of the wire can't interpret.
+ *
+ * @see https://github.com/solidjs/solid-start/issues/1474
+ *
+ * @example
+ * ```ts
+ * // src/seroval-plugins.ts
+ * import { createPlugin } from "@solidjs/start/serialization";
+ * import { ObjectId } from "mongodb";
+ *
+ * const ObjectIdPlugin = createPlugin<ObjectId, { hex: any }>({
+ *   tag: "app/ObjectId",
+ *   test: value => value instanceof ObjectId,
+ *   parse: {
+ *     sync: (value, ctx) => ({ hex: ctx.parse(value.toHexString()) }),
+ *     async: async (value, ctx) => ({ hex: await ctx.parse(value.toHexString()) }),
+ *     stream: (value, ctx) => ({ hex: ctx.parse(value.toHexString()) }),
+ *   },
+ *   serialize: (node, ctx) => `globalThis.ObjectId(${ctx.serialize(node.hex)})`,
+ *   deserialize: (node, ctx) => new ObjectId(ctx.deserialize(node.hex) as string),
+ * });
+ *
+ * export default [ObjectIdPlugin];
+ * ```
+ */
+export { createPlugin, OpaqueReference } from "seroval";

package/dist/fns/serialization.d.ts

@@ -1,5 +1,20 @@
 export declare function serializeToJSStream(id: string, value: any): ReadableStream<any>;
 export declare function serializeToJSONStream(value: any): ReadableStream<any>;
+export declare class SerovalChunkReader {
+    reader: ReadableStreamDefaultReader<Uint8Array>;
+    buffer: Uint8Array;
+    done: boolean;
+    constructor(stream: ReadableStream<Uint8Array>);
+    readChunk(): Promise<void>;
+    next(): Promise<{
+        done: true;
+        value: undefined;
+    } | {
+        done: false;
+        value: string;
+    }>;
+    drain(interpret: (chunk: string) => void): Promise<void>;
+}
 export declare function serializeToJSONString(value: any): Promise<string>;
 export declare function deserializeFromJSONString(json: string): Promise<unknown>;
 export declare function deserializeJSONStream(response: Response | Request): Promise<unknown>;

package/dist/fns/serialization.js

@@ -1,6 +1,6 @@
 import { crossSerializeStream, deserialize, Feature, fromCrossJSON, getCrossReferenceHeader, toCrossJSONStream, } from "seroval";
 import { AbortSignalPlugin, CustomEventPlugin, DOMExceptionPlugin, EventPlugin, FormDataPlugin, HeadersPlugin, ReadableStreamPlugin, RequestPlugin, ResponsePlugin, URLPlugin, URLSearchParamsPlugin, } from "seroval-plugins/web";
-// TODO(Alexis): if we can, allow providing an option to extend these.
+import userPlugins from "solid-start:seroval-plugins";
 const DEFAULT_PLUGINS = [
     AbortSignalPlugin,
     CustomEventPlugin,
@@ -14,8 +14,37 @@ const DEFAULT_PLUGINS = [
     URLSearchParamsPlugin,
     URLPlugin,
 ];
+/**
+ * Plugins from `serialization.plugins` are appended rather than prepended:
+ * seroval picks the first plugin whose `test()` passes, so the built-ins win
+ * and a loose user `test()` can't take over `Request`/`FormData`/`URL`.
+ *
+ * The same list has to be used on both ends of a server function, which is why
+ * this comes from a virtual module bundled into the client and the server
+ * rather than a runtime option.
+ */
+const PLUGINS = [...DEFAULT_PLUGINS, ...userPlugins];
 const MAX_SERIALIZATION_DEPTH_LIMIT = 64;
 const DISABLED_FEATURES = Feature.RegExp;
+/**
+ * An error thrown by a server function is serialized and rethrown on the
+ * client, and seroval includes `Error.prototype.stack` by default. In
+ * production that leaks server file paths, internal function names and the
+ * shape of the deployment to anyone who can trigger a throw, so strip it.
+ * Development keeps the stack: that's where it's actually useful, and the
+ * paths it exposes are the developer's own.
+ *
+ * Only applied when writing; parsing leaves `DISABLED_FEATURES` alone so an
+ * incoming payload that does carry a stack still deserializes.
+ */
+const SERIALIZE_DISABLED_FEATURES = import.meta.env.PROD
+    ? DISABLED_FEATURES | Feature.ErrorPrototypeStack
+    : DISABLED_FEATURES;
+/**
+ * `crossSerializeStream` historically ran with every feature enabled, so only
+ * add the stack removal here rather than the full serialize set.
+ */
+const JS_SERIALIZE_DISABLED_FEATURES = import.meta.env.PROD ? Feature.ErrorPrototypeStack : 0;
 /**
  * Alexis:
  *
@@ -47,7 +76,8 @@ export function serializeToJSStream(id, value) {
         start(controller) {
             crossSerializeStream(value, {
                 scopeId: id,
-                plugins: DEFAULT_PLUGINS,
+                disabledFeatures: JS_SERIALIZE_DISABLED_FEATURES,
+                plugins: PLUGINS,
                 onSerialize(data, initial) {
                     controller.enqueue(createChunk(initial ? `(${getCrossReferenceHeader(id)},${data})` : data));
                 },
@@ -65,9 +95,9 @@ export function serializeToJSONStream(value) {
     return new ReadableStream({
         start(controller) {
             toCrossJSONStream(value, {
-                disabledFeatures: DISABLED_FEATURES,
+                disabledFeatures: SERIALIZE_DISABLED_FEATURES,
                 depthLimit: MAX_SERIALIZATION_DEPTH_LIMIT,
-                plugins: DEFAULT_PLUGINS,
+                plugins: PLUGINS,
                 onParse(node) {
                     controller.enqueue(createChunk(JSON.stringify(node)));
                 },
@@ -81,7 +111,7 @@ export function serializeToJSONStream(value) {
         },
     });
 }
-class SerovalChunkReader {
+export class SerovalChunkReader {
     reader;
     buffer;
     done;
@@ -180,7 +210,7 @@ export async function deserializeJSONStream(response) {
                 refs,
                 disabledFeatures: DISABLED_FEATURES,
                 depthLimit: MAX_SERIALIZATION_DEPTH_LIMIT,
-                plugins: DEFAULT_PLUGINS,
+                plugins: PLUGINS,
             });
             return value;
         }

package/dist/server/assets/render.jsx

@@ -9,6 +9,6 @@ const assetMap = {
     noscript: (props) => (<noscript {...props.attrs}>{props.children}</noscript>),
 };
 export function renderAsset(asset, nonce) {
-    let { tag, attrs: { key, ...attrs } = { key: undefined }, children, } = asset;
+    let { tag, attrs: { key, ...attrs } = { key: undefined }, children } = asset;
     return assetMap[tag]({ attrs: { ...attrs, nonce }, key, children });
 }

package/dist/server/collect-styles.d.ts

@@ -1,3 +1,5 @@
 import type { DevEnvironment } from "vite";
+type StyleFilter = (id: string) => boolean;
 export declare const isCssModulesFile: (file: string) => boolean;
-export declare function findStylesInModuleGraph(vite: DevEnvironment, id: string): Promise<Record<string, any>>;
+export declare function findStylesInModuleGraph(vite: DevEnvironment, id: string, filter: StyleFilter): Promise<Record<string, any>>;
+export {};

package/dist/server/collect-styles.js

@@ -8,13 +8,16 @@ async function getViteModuleNode(vite, file, importer) {
     }
     catch (err) { }
 }
-async function findModuleDependencies(vite, file, deps, crawledFiles = new Set(), importer) {
+async function findModuleDependencies(vite, file, deps, filter, crawledFiles = new Set(), importer) {
     crawledFiles.add(file);
     const module = await getViteModuleNode(vite, file, importer);
     if (!module?.id || deps.has(module))
         return;
     deps.add(module);
-    if (module.url.endsWith(".css") || module.url.includes("node_modules"))
+    if (module.url.endsWith(".css"))
+        return;
+    // Apply user-config file filters only to real files (virtual modules should always be included)
+    if (module.file && !module.id.startsWith("\0") && !filter(module.file))
         return;
     if (!module.transformResult) {
         await vite.transformRequest(module.id).catch(() => { });
@@ -28,7 +31,7 @@ async function findModuleDependencies(vite, file, deps, crawledFiles = new Set()
         if (crawledFiles.has(dep)) {
             continue;
         }
-        await findModuleDependencies(vite, dep, deps, crawledFiles, module.id);
+        await findModuleDependencies(vite, dep, deps, filter, crawledFiles, module.id);
     }
 }
 // Vite doesn't expose these so we just copy the list for now
@@ -38,11 +41,11 @@ const cssFileRegExp = /\.(css|less|sass|scss|styl|stylus|pcss|postcss|sss)$/;
 const cssModulesRegExp = new RegExp(`\\.module${cssFileRegExp.source}`);
 const isCssFile = (file) => cssFileRegExp.test(file);
 export const isCssModulesFile = (file) => cssModulesRegExp.test(file);
-export async function findStylesInModuleGraph(vite, id) {
+export async function findStylesInModuleGraph(vite, id, filter) {
     const absolute = path.resolve(process.cwd(), id);
     const dependencies = new Set();
     try {
-        await findModuleDependencies(vite, absolute, dependencies);
+        await findModuleDependencies(vite, absolute, dependencies, filter);
     }
     catch (e) {
         console.error(e);

package/dist/server/handler.d.ts

@@ -1,6 +1,5 @@
-import { H3 } from "h3/generic";
 import type { JSX } from "solid-js";
-import type { FetchEvent, HandlerOptions, PageEvent } from "./types.ts";
-export declare function createBaseHandler(createPageEvent: (e: FetchEvent) => Promise<PageEvent>, fn: (context: PageEvent) => JSX.Element, options?: HandlerOptions | ((context: PageEvent) => HandlerOptions | Promise<HandlerOptions>)): H3;
-export declare function createHandler(fn: (context: PageEvent) => JSX.Element, options?: HandlerOptions | ((context: PageEvent) => HandlerOptions | Promise<HandlerOptions>)): H3;
+import type { FetchEvent, HandlerOptions, PageEvent, StartHandler } from "./types.ts";
+export declare function createBaseHandler(createPageEvent: (e: FetchEvent) => Promise<PageEvent>, fn: (context: PageEvent) => JSX.Element, options?: HandlerOptions | ((context: PageEvent) => HandlerOptions | Promise<HandlerOptions>), routerLoad?: (event: FetchEvent) => Promise<void>): StartHandler;
+export declare function createHandler(fn: (context: PageEvent) => JSX.Element, options?: HandlerOptions | ((context: PageEvent) => HandlerOptions | Promise<HandlerOptions>), routerLoad?: (event: FetchEvent) => Promise<void>): StartHandler;
 export declare function createPageEvent(ctx: FetchEvent): Promise<PageEvent>;