@solidjs/start 2.0.0-beta.9 → 2.0.0-rc.2

package/CHANGELOG.md

@@ -1,5 +1,42 @@
 # @solidjs/start
 
+## 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
+
+- 02e561e: Expose experimental `decorateHandler` and `decorateMiddleware` helpers from
+  `@solidjs/start/server` for providing Solid's request context to custom h3 handlers and
+  middleware.
+
+### Patch Changes
+
+- f66b5a9: fix: keep non-picked route exports that picked exports reference instead of deleting their bindings, so API handlers can call helpers exported from the same file (#2100); also fixes picked exports declared via `export { ... }` specifiers being dropped (#1659)
+- 1763296: fix: run `onBeforeResponse` middleware in declared order (#2131)
+
+  Applications that reversed their `onBeforeResponse` arrays as a workaround should restore the intended declaration order.
+
+- cd98e7d: Fix API route matching when `server.baseURL` is configured.
+
+## 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

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,19 @@ 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) {
+            const { filename } = parseIdQuery(id);
             const isServer = this.environment.config.consumer === "server";
-            if (id === SERVER_ENV) {
+            if (filename === SERVER_ENV) {
                 if (!isServer) {
                     return SERVER_ONLY_MODULE;
                 }
@@ -58,19 +61,19 @@ 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 (filename === SERVER_RUNTIME_LOADER) {
                 if (!isServer) {
                     return SERVER_ONLY_MODULE;
                 }
                 return runtimeCode;
             }
-            if (id === SERVER_RUNTIME_ENV) {
+            if (filename === SERVER_RUNTIME_ENV) {
                 if (!isServer) {
                     return SERVER_ONLY_MODULE;
                 }

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

@@ -20,13 +20,28 @@ function treeShakeTransform({ types: t }) {
         }
         return path.node.id && path.node.id.type === "Identifier" ? path.get("id") : null;
     }
-    function isIdentifierReferenced(ident) {
+    function isTypeOnlyReference(path) {
+        return path.getAncestry().some(parent => {
+            if (parent.isTSType())
+                return true;
+            if (parent.isExportNamedDeclaration())
+                return parent.node.exportKind === "type";
+            if (parent.isExportSpecifier())
+                return parent.node.exportKind === "type";
+            return false;
+        });
+    }
+    function runtimeReferences(binding) {
+        return binding.referencePaths.filter(ref => !isTypeOnlyReference(ref));
+    }
+    function isIdentifierReferenced(ident, includeTypes = false) {
         const b = ident.scope.getBinding(ident.node.name);
-        if (b?.referenced) {
+        if (b) {
+            const references = b.constantViolations.concat(includeTypes ? b.referencePaths : runtimeReferences(b));
+            if (!references.length)
+                return false;
             if (b.path.type === "FunctionDeclaration") {
-                return !b.constantViolations
-                    .concat(b.referencePaths)
-                    .every(ref => ref.findParent(p => p === b.path));
+                return !references.every(ref => ref.findParent(p => p === b.path));
             }
             return true;
         }
@@ -34,13 +49,13 @@ function treeShakeTransform({ types: t }) {
     }
     function markFunction(path, state) {
         const ident = getIdentifier(path);
-        if (ident && ident.node && isIdentifierReferenced(ident)) {
+        if (ident && ident.node && isIdentifierReferenced(ident, true)) {
             state.refs.add(ident);
         }
     }
     function markImport(path, state) {
         const local = path.get("local");
-        if (isIdentifierReferenced(local)) {
+        if (isIdentifierReferenced(local, true)) {
             state.refs.add(local);
         }
     }
@@ -49,12 +64,13 @@ function treeShakeTransform({ types: t }) {
             Program: {
                 enter(path, state) {
                     state.refs = new Set();
+                    state.candidates = new Set();
                     state.done = false;
                     path.traverse({
                         VariableDeclarator(variablePath, variableState) {
                             if (variablePath.node.id.type === "Identifier") {
                                 const local = variablePath.get("id");
-                                if (isIdentifierReferenced(local)) {
+                                if (isIdentifierReferenced(local, true)) {
                                     variableState.refs.add(local);
                                 }
                             }
@@ -69,7 +85,7 @@ function treeShakeTransform({ types: t }) {
                                             : (() => {
                                                 throw new Error("invariant");
                                             })());
-                                    if (isIdentifierReferenced(local)) {
+                                    if (isIdentifierReferenced(local, true)) {
                                         variableState.refs.add(local);
                                     }
                                 });
@@ -88,29 +104,41 @@ function treeShakeTransform({ types: t }) {
                                     else {
                                         return;
                                     }
-                                    if (isIdentifierReferenced(local)) {
+                                    if (isIdentifierReferenced(local, true)) {
                                         variableState.refs.add(local);
                                     }
                                 });
                             }
                         },
                         ExportDefaultDeclaration(exportNamedPath) {
-                            // if opts.keep is true, we don't remove the routeData export
                             if (state.opts.pick && !state.opts.pick.includes("default")) {
-                                exportNamedPath.remove();
+                                const decl = exportNamedPath.node.declaration;
+                                // A named function/class declaration creates a module-scope
+                                // binding that picked exports may reference, so only strip
+                                // the `export default`; the sweep below removes the
+                                // declaration again if nothing references it.
+                                if ((t.isFunctionDeclaration(decl) || t.isClassDeclaration(decl)) && decl.id) {
+                                    const [newPath] = exportNamedPath.replaceWith(decl);
+                                    const id = newPath.get("id");
+                                    state.refs.add(id);
+                                    state.candidates.add(id);
+                                }
+                                else {
+                                    exportNamedPath.remove();
+                                }
                             }
                         },
                         ExportNamedDeclaration(exportNamedPath) {
-                            // if opts.keep is false, we don't remove the routeData export
+                            // No pick list means nothing gets pruned.
                             if (!state.opts.pick) {
                                 return;
                             }
                             const specifiers = exportNamedPath.get("specifiers");
                             if (specifiers.length) {
                                 specifiers.forEach(s => {
-                                    if (t.isIdentifier(s.node.exported)
-                                        ? s.node.exported.name
-                                        : state.opts.pick.includes(s.node.exported.value)) {
+                                    const exported = s.node.exported;
+                                    const exportedName = t.isIdentifier(exported) ? exported.name : exported.value;
+                                    if (!state.opts.pick.includes(exportedName)) {
                                         s.remove();
                                     }
                                 });
@@ -124,24 +152,51 @@ function treeShakeTransform({ types: t }) {
                                 return;
                             }
                             switch (decl.node.type) {
-                                case "FunctionDeclaration": {
+                                case "FunctionDeclaration":
+                                case "ClassDeclaration": {
                                     const name = decl.node.id?.name;
                                     if (name && state.opts.pick && !state.opts.pick.includes(name)) {
-                                        exportNamedPath.remove();
+                                        // Keep the declaration in module scope since picked
+                                        // exports may reference it; the sweep below removes it
+                                        // again if unreferenced.
+                                        const [newPath] = exportNamedPath.replaceWith(decl.node);
+                                        const id = newPath.get("id");
+                                        state.refs.add(id);
+                                        state.candidates.add(id);
                                     }
                                     break;
                                 }
                                 case "VariableDeclaration": {
-                                    const inner = decl.get("declarations");
-                                    inner.forEach(d => {
-                                        if (d.node.id.type !== "Identifier") {
-                                            return;
-                                        }
-                                        const name = d.node.id.name;
-                                        if (state.opts.pick && !state.opts.pick.includes(name)) {
-                                            d.remove();
-                                        }
+                                    const declNode = decl.node;
+                                    // Destructuring declarators are conservatively treated as
+                                    // picked (matching the previous behavior of leaving them
+                                    // untouched).
+                                    const isPicked = (d) => d.id.type !== "Identifier" || state.opts.pick.includes(d.id.name);
+                                    if (declNode.declarations.every(isPicked)) {
+                                        break;
+                                    }
+                                    // Split into one declaration per declarator (preserving
+                                    // evaluation order) and export only the picked ones.
+                                    // Unpicked bindings are kept since picked exports may
+                                    // reference them; the sweep below removes them again if
+                                    // unreferenced.
+                                    const statements = declNode.declarations.map(d => {
+                                        const single = t.variableDeclaration(declNode.kind, [d]);
+                                        single.declare = declNode.declare;
+                                        return isPicked(d) ? t.exportNamedDeclaration(single, []) : single;
                                     });
+                                    const newPaths = exportNamedPath.replaceWithMultiple(statements);
+                                    for (const p of newPaths) {
+                                        if (!p.isVariableDeclaration())
+                                            continue;
+                                        for (const d of p.get("declarations")) {
+                                            if (d.node.id.type === "Identifier") {
+                                                const id = d.get("id");
+                                                state.refs.add(id);
+                                                state.candidates.add(id);
+                                            }
+                                        }
+                                    }
                                     break;
                                 }
                                 default: {
@@ -152,6 +207,8 @@ function treeShakeTransform({ types: t }) {
                         FunctionDeclaration: markFunction,
                         FunctionExpression: markFunction,
                         ArrowFunctionExpression: markFunction,
+                        ClassDeclaration: markFunction,
+                        ClassExpression: markFunction,
                         ImportSpecifier: markImport,
                         ImportDefaultSpecifier: markImport,
                         ImportNamespaceSpecifier: markImport,
@@ -163,11 +220,95 @@ function treeShakeTransform({ types: t }) {
                             }
                         },
                     }, state);
+                    // References alone cannot distinguish live bindings from dead cycles.
+                    // Build a graph of localized exports and retain only those reachable
+                    // from runtime code outside that graph.
+                    path.scope.crawl();
+                    const tracked = new Map();
+                    const candidateOwners = new Map();
+                    const addOwner = (owners, binding, owner) => {
+                        const paths = owners.get(binding) ?? new Set();
+                        paths.add(owner);
+                        owners.set(binding, paths);
+                    };
+                    for (const identifier of state.refs) {
+                        if (identifier.node?.type !== "Identifier" || !identifier.parentPath)
+                            continue;
+                        const binding = identifier.scope.getBinding(identifier.node.name);
+                        if (binding)
+                            addOwner(tracked, binding, identifier.parentPath);
+                    }
+                    for (const identifier of state.candidates) {
+                        if (!identifier.parentPath)
+                            continue;
+                        const binding = identifier.scope.getBinding(identifier.node.name);
+                        if (!binding)
+                            continue;
+                        addOwner(tracked, binding, identifier.parentPath);
+                        addOwner(candidateOwners, binding, identifier.parentPath);
+                    }
+                    const dependencies = new Map();
+                    const live = new Set();
+                    for (const [binding, owners] of tracked) {
+                        dependencies.set(binding, new Set());
+                        if ([...owners].some(owner => owner.findParent(parent => parent.isExportNamedDeclaration() || parent.isExportDefaultDeclaration()))) {
+                            live.add(binding);
+                        }
+                    }
+                    const ownerBindings = new Map();
+                    for (const [binding, owners] of tracked) {
+                        for (const owner of owners) {
+                            ownerBindings.set(owner, binding);
+                        }
+                    }
+                    const owningBinding = (reference) => {
+                        const owner = reference.find(parent => ownerBindings.has(parent));
+                        return owner && ownerBindings.get(owner);
+                    };
+                    for (const target of tracked.keys()) {
+                        const references = target.constantViolations.concat(runtimeReferences(target));
+                        for (const reference of references) {
+                            const source = owningBinding(reference);
+                            if (source)
+                                dependencies.get(source)?.add(target);
+                            else
+                                live.add(target);
+                        }
+                    }
+                    const pending = [...live];
+                    while (pending.length) {
+                        const source = pending.pop();
+                        for (const dependency of dependencies.get(source) ?? []) {
+                            if (live.has(dependency))
+                                continue;
+                            live.add(dependency);
+                            pending.push(dependency);
+                        }
+                    }
+                    const deadCandidates = new Set([...candidateOwners.keys()].filter(candidate => !live.has(candidate)));
+                    path.traverse({
+                        VariableDeclarator(variablePath) {
+                            if (variablePath.node.id.type !== "Identifier")
+                                return;
+                            const binding = variablePath.scope.getBinding(variablePath.node.id.name);
+                            if (binding && deadCandidates.has(binding))
+                                variablePath.remove();
+                        },
+                    });
+                    for (const [candidate, owners] of candidateOwners) {
+                        if (!deadCandidates.has(candidate))
+                            continue;
+                        for (const owner of owners) {
+                            if (!owner.removed && !owner.isVariableDeclarator())
+                                owner.remove();
+                        }
+                    }
                     const refs = state.refs;
+                    const refNodes = new Set([...refs].map(ref => ref.node));
                     let count = 0;
                     const sweepFunction = (sweepPath) => {
                         const ident = getIdentifier(sweepPath);
-                        if (ident && ident.node && refs.has(ident) && !isIdentifierReferenced(ident)) {
+                        if (ident && ident.node && refNodes.has(ident.node) && !isIdentifierReferenced(ident)) {
                             ++count;
                             if (t.isAssignmentExpression(sweepPath.parentPath) ||
                                 t.isVariableDeclarator(sweepPath.parentPath)) {
@@ -180,7 +321,7 @@ function treeShakeTransform({ types: t }) {
                     };
                     function sweepImport(sweepPath) {
                         const local = sweepPath.get("local");
-                        if (refs.has(local) && !isIdentifierReferenced(local)) {
+                        if (refNodes.has(local.node) && !isIdentifierReferenced(local)) {
                             ++count;
                             sweepPath.remove();
                             if (sweepPath.parent.specifiers.length === 0) {
@@ -195,7 +336,7 @@ function treeShakeTransform({ types: t }) {
                             VariableDeclarator(variablePath) {
                                 if (variablePath.node.id.type === "Identifier") {
                                     const local = variablePath.get("id");
-                                    if (refs.has(local) && !isIdentifierReferenced(local)) {
+                                    if (refNodes.has(local.node) && !isIdentifierReferenced(local)) {
                                         ++count;
                                         variablePath.remove();
                                     }
@@ -212,7 +353,7 @@ function treeShakeTransform({ types: t }) {
                                                 : (() => {
                                                     throw new Error("invariant");
                                                 })());
-                                        if (refs.has(local) && !isIdentifierReferenced(local)) {
+                                        if (refNodes.has(local.node) && !isIdentifierReferenced(local)) {
                                             ++count;
                                             p.remove();
                                         }
@@ -236,7 +377,7 @@ function treeShakeTransform({ types: t }) {
                                         else {
                                             return;
                                         }
-                                        if (refs.has(local) && !isIdentifierReferenced(local)) {
+                                        if (refNodes.has(local.node) && !isIdentifierReferenced(local)) {
                                             ++count;
                                             e.remove();
                                         }
@@ -249,6 +390,8 @@ function treeShakeTransform({ types: t }) {
                             FunctionDeclaration: sweepFunction,
                             FunctionExpression: sweepFunction,
                             ArrowFunctionExpression: sweepFunction,
+                            ClassDeclaration: sweepFunction,
+                            ClassExpression: sweepFunction,
                             ImportSpecifier: sweepImport,
                             ImportDefaultSpecifier: sweepImport,
                             ImportNamespaceSpecifier: sweepImport,

package/dist/config/index.js

@@ -1,6 +1,6 @@
 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";
@@ -61,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()) {
@@ -149,7 +152,9 @@ 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.SERVER_BASE_URL": JSON.stringify(config.server?.baseURL ?? ""),
                         "import.meta.env.SEROVAL_MODE": JSON.stringify(start.serialization?.mode || "json"),
                     },
                     builder: {

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,15 @@ function createRequest(base, id, instance, options) {
             "X-Server-Instance": instance,
         },
     });
+    if (import.meta.env.DEV) {
+        console.log(pushRequest);
+        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

package/dist/fns/handler.js

@@ -121,7 +121,6 @@ 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) {
@@ -133,7 +132,8 @@ export async function handleServerFunction(h3Event) {
             if (x.headers)
                 mergeResponseHeaders(h3Event, x.headers);
             // forward non-redirect statuses
-            if (x.status && (!instance || x.status < 300 || x.status >= 400))
+            if (x.status &&
+                (!instance || x.status < 300 || x.status >= 400))
                 h3Event.res.status = x.status;
             if (x.customBody) {
                 x = await x.customBody();
@@ -144,7 +144,7 @@ export async function handleServerFunction(h3Event) {
         }
         else if (instance) {
             const error = x instanceof Error ? x.message : typeof x === "string" ? x : "true";
-            h3Event.res.headers.set("X-Error", error.replace(/[\r\n]+/g, ""));
+            h3Event.res.headers.set("X-Error", toHeaderValue(error));
         }
         else {
             x = handleNoJS(x, request, parsed, true);
@@ -158,7 +158,7 @@ export async function handleServerFunction(h3Event) {
                     headers.set("X-Error", errorHeader);
                 }
                 return new Response(body.body, {
-                    headers: body.headers,
+                    headers,
                 });
             }
             h3Event.res.headers.set(BODY_FORMAT_KEY, BodyFormat.Seroval);
@@ -166,12 +166,22 @@ 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;
     }
 }
+// header values must be ByteString-safe (no chars > 0xFF), otherwise Headers.set throws
+function toHeaderValue(value) {
+    const stripped = value.replace(/[\r\n]+/g, "");
+    try {
+        return /[^\x00-\xFF]/.test(stripped) ? encodeURIComponent(stripped) : stripped;
+    }
+    catch {
+        // encodeURIComponent throws on lone surrogates
+        return "true";
+    }
+}
 function handleNoJS(result, request, parsed, thrown) {
     const url = new URL(request.url);
     const isError = result instanceof Error;
@@ -194,7 +204,10 @@ 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.slice(0, -1),
+                [...parsed[parsed.length - 1].entries()],
+            ],
         }))}; Secure; HttpOnly;`);
     }
     return new Response(null, {
@@ -216,7 +229,7 @@ export function createSingleFlightHeaders(sourceEvent) {
     // 	useH3Internals = true;
     // 	sourceEvent.nativeEvent.node.req.headers.cookie = "";
     // }
-    SetCookies.forEach(cookie => {
+    SetCookies.forEach((cookie) => {
         if (!cookie)
             return;
         const { maxAge, expires, name, value } = parseSetCookie(cookie);

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

@@ -81,7 +81,7 @@ export function serializeToJSONStream(value) {
         },
     });
 }
-class SerovalChunkReader {
+export class SerovalChunkReader {
     reader;
     buffer;
     done;

package/dist/middleware/index.js

@@ -54,7 +54,10 @@ export function createMiddleware(args) {
         mw.push(wrapResponseMiddleware(args.onBeforeResponse));
     }
     else if (Array.isArray(args.onBeforeResponse)) {
-        mw.push(...args.onBeforeResponse.map(wrapResponseMiddleware));
+        // h3 middleware compose onion-style: logic after `await next()` unwinds
+        // innermost-first (reverse registration order). Register the wrappers
+        // reversed so onBeforeResponse functions run in their declared order.
+        mw.push(...args.onBeforeResponse.map(wrapResponseMiddleware).reverse());
     }
     return mw;
 }

package/dist/server/StartServer.jsx

@@ -19,7 +19,7 @@ export function StartServer(props) {
       <TopErrorBoundary>
         <props.document assets={<HydrationScript />} scripts={<>
               <PatchVirtualDevStyles nonce={nonce}/>
-              <script type="module" nonce={nonce} async src={getSsrManifest("client").path(import.meta.env.START_CLIENT_ENTRY)}/>
+              <script type="module" nonce={nonce} async src={getSsrManifest("client").path(import.meta.env.START_CLIENT_ENTRY_URL)}/>
             </>}>
           {!import.meta.env.START_ISLANDS ? (<Hydration>
               <ErrorBoundary>

package/dist/server/fetchEvent.d.ts

@@ -3,5 +3,15 @@ import type { FetchEvent } from "./types.ts";
 export declare function createFetchEvent(event: H3Event): FetchEvent;
 export declare function getFetchEvent(h3Event: H3Event): FetchEvent;
 export declare function mergeResponseHeaders(h3Event: H3Event, headers: Headers): void;
+/**
+ * Wrap an h3 event handler so Solid's request context is available while it runs.
+ *
+ * @experimental
+ */
 export declare const decorateHandler: <T extends EventHandler>(fn: T) => T;
+/**
+ * Wrap h3 middleware so Solid's request context is available while it runs.
+ *
+ * @experimental
+ */
 export declare const decorateMiddleware: <T extends Middleware>(fn: T) => T;