@solidjs/start 2.0.0-beta.8 → 2.0.0-rc.1

package/CHANGELOG.md

@@ -1,5 +1,41 @@
 # @solidjs/start
 
+## 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
+
+- f3e84ec: Add support for `server-only` and `client-only` modules
+
+### Patch Changes
+
+- a8a2328: fix: mark `@solidjs/start/http` and `@solidjs/start/middleware` as `server-only` so importing them from client-reachable code fails loudly at dev/build time, instead of silently shipping them to the browser where they crashed hydration and broke unrelated actions/forms with no diagnostic (#2068)
+
 ## 2.0.0-beta.8
 
 ### Patch Changes
@@ -108,7 +144,6 @@
 - 8256190: Rework `@solidjs/start/env`
 - 6cbba24: Fix multiple Set-Cookie headers being lost on redirect responses
 - d4cc548: ## Bump Seroval
-
   - version `1.4.1`
 
 - dd40610: Handle base url in api routes

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

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

package/dist/config/boundary-modules.js

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

package/dist/config/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,8 +1,9 @@
 import { defu } from "defu";
 import { globSync } from "node:fs";
-import { extname, isAbsolute, join } from "node:path";
+import { basename, extname, isAbsolute, join } from "node:path";
 import solid from "vite-plugin-solid";
 import { serverFunctionsPlugin } from "../directives/index.js";
+import { boundaryModules } from "./boundary-modules.js";
 import { DEFAULT_EXTENSIONS, VIRTUAL_MODULES, VITE_ENVIRONMENTS } from "./constants.js";
 import { devServer } from "./dev-server.js";
 import { envPlugin } from "./env.js";
@@ -60,8 +61,11 @@ export function solidStart(options) {
                     },
                 };
             },
-            async config(_, env) {
+            async config(config, env) {
                 const clientInput = [handlers.client];
+                const clientEntryUrl = env.command === "serve" && config.experimental?.bundledDev
+                    ? `assets/${basename(handlers.client, entryExtension)}.js`
+                    : handlers.client;
                 if (env.command === "build") {
                     const clientRouter = globalThis.ROUTERS.client;
                     for (const route of await clientRouter.getRoutes()) {
@@ -148,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: {
@@ -185,6 +191,29 @@ export function solidStart(options) {
         }),
         lazy(),
         envPlugin(options?.env),
+        boundaryModules(),
+        {
+            name: "solid-start:boundary-modules",
+            enforce: "pre",
+            resolveId(id, importer, { ssr }) {
+                if (id === "server-only") {
+                    if (!ssr)
+                        this.error(`Attempt to import 'server-only' in a client module: ${importer}`);
+                }
+                else if (id === "client-only") {
+                    if (ssr)
+                        this.error(`Attempt to import 'client-only' in a server module: ${importer}`);
+                }
+                else {
+                    return null;
+                }
+                return "\0solid-start:boundary-modules:id";
+            },
+            load(id) {
+                if (id === "\0solid-start:boundary-modules:id")
+                    return "export {}";
+            },
+        },
         {
             name: "solid-start:virtual-modules",
             async resolveId(id) {

package/dist/fns/handler.js

@@ -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);
@@ -172,6 +172,17 @@ export async function handleServerFunction(h3Event) {
         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;