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

package/CHANGELOG.md

@@ -1,5 +1,31 @@
 # @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
@@ -118,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/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/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;

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;

package/dist/server/fetchEvent.js

@@ -22,5 +22,15 @@ export function mergeResponseHeaders(h3Event, headers) {
         h3Event.res.headers.append(key, value);
     }
 }
+/**
+ * Wrap an h3 event handler so Solid's request context is available while it runs.
+ *
+ * @experimental
+ */
 export const decorateHandler = (fn) => (event => provideRequestEvent(getFetchEvent(event), () => fn(event)));
+/**
+ * Wrap h3 middleware so Solid's request context is available while it runs.
+ *
+ * @experimental
+ */
 export const decorateMiddleware = (fn) => ((event, next) => provideRequestEvent(getFetchEvent(event), () => fn(event, next)));

package/dist/server/handler.js

@@ -8,6 +8,8 @@ import { getSsrManifest } from "./manifest/ssr-manifest.js";
 import { matchAPIRoute } from "./routes.js";
 import { handleServerFunction } from "../fns/handler.js";
 import { getExpectedRedirectStatus } from "./util.js";
+import { toWebReadableStream } from "./web-stream.js";
+import { stripPathBase } from "./strip-path-base.js";
 const SERVER_FN_BASE = "/_server";
 export function createBaseHandler(createPageEvent, fn, options = {}) {
     const handler = defineHandler({
@@ -93,14 +95,9 @@ export function createBaseHandler(createPageEvent, fn, options = {}) {
             if (mode === "async")
                 return await stream;
             delete stream.then;
-            // using TransformStream in dev can cause solid-start-dev-server to crash
-            // when stream is cancelled
-            if (globalThis.USING_SOLID_START_DEV_SERVER)
-                return stream;
-            // returning stream directly breaks cloudflare workers
-            const { writable, readable } = new TransformStream();
-            stream.pipeTo(writable);
-            return readable;
+            // h3 expects a standard web ReadableStream across runtimes. The adapter
+            // also tolerates cancellation while Solid finishes outstanding work.
+            return toWebReadableStream(stream);
         }),
     });
     const app = new H3();
@@ -216,7 +213,6 @@ function produceResponseWithEventHeaders(res) {
     return ret;
 }
 function stripBaseUrl(path) {
-    if (import.meta.env.BASE_URL === "/" || import.meta.env.BASE_URL === "")
-        return path;
-    return path.slice(import.meta.env.BASE_URL.length);
+    const base = import.meta.env.SERVER_BASE_URL || import.meta.env.BASE_URL || "/";
+    return stripPathBase(path, base);
 }

package/dist/server/index.d.ts

@@ -1,6 +1,7 @@
 export { default as lazy } from "../shared/lazy.ts";
 export { getServerFunctionMeta } from "../shared/serverFunction.ts";
 export { StartServer } from "./StartServer.tsx";
+export { decorateHandler, decorateMiddleware } from "./fetchEvent.ts";
 export { createHandler } from "./handler.ts";
 export type { APIEvent, APIHandler, Asset, ContextMatches, DocumentComponentProps, FetchEvent, HandlerOptions, PageEvent, ResponseStub, ServerFunctionMeta, } from "./types.ts";
 /**

package/dist/server/index.jsx

@@ -1,6 +1,7 @@
 export { default as lazy } from "../shared/lazy.js";
 export { getServerFunctionMeta } from "../shared/serverFunction.js";
 export { StartServer } from "./StartServer.jsx";
+export { decorateHandler, decorateMiddleware } from "./fetchEvent.js";
 export { createHandler } from "./handler.js";
 /**
  * Checks if user has set a redirect status in the response.

package/dist/server/spa/StartServer.jsx

@@ -18,7 +18,7 @@ export function StartServer(props) {
       <TopErrorBoundary>
         <props.document scripts={<>
               <PatchVirtualDevStyles nonce={nonce}/>
-              <script type="module" src={getSsrManifest("client").path(import.meta.env.START_CLIENT_ENTRY)}/>
+              <script type="module" src={getSsrManifest("client").path(import.meta.env.START_CLIENT_ENTRY_URL)}/>
             </>}/>
       </TopErrorBoundary>
     </NoHydration>);

package/dist/server/strip-path-base.d.ts

@@ -0,0 +1 @@
+export declare function stripPathBase(path: string, base: string): string;

package/dist/server/strip-path-base.js

@@ -0,0 +1,10 @@
+export function stripPathBase(path, base) {
+    if (!base || base === "/")
+        return path;
+    const normalizedBase = base.endsWith("/") ? base.slice(0, -1) : base;
+    if (path === normalizedBase)
+        return "/";
+    if (path.startsWith(`${normalizedBase}/`))
+        return path.slice(normalizedBase.length);
+    return path;
+}

package/dist/server/web-stream.d.ts

@@ -0,0 +1,9 @@
+type PipeableStream = {
+    pipe(writable: {
+        write(payload: string): void;
+        end(): void;
+    }): void;
+};
+/** Convert Solid's streaming SSR result into a cancellation-safe web stream. */
+export declare function toWebReadableStream(stream: PipeableStream): ReadableStream<Uint8Array>;
+export {};

package/dist/server/web-stream.js

@@ -0,0 +1,26 @@
+/** Convert Solid's streaming SSR result into a cancellation-safe web stream. */
+export function toWebReadableStream(stream) {
+    const encoder = new TextEncoder();
+    let active = true;
+    return new ReadableStream({
+        start(controller) {
+            stream.pipe({
+                write(payload) {
+                    if (active)
+                        controller.enqueue(encoder.encode(payload));
+                },
+                end() {
+                    if (!active)
+                        return;
+                    active = false;
+                    controller.close();
+                },
+            });
+        },
+        cancel() {
+            // Solid may still resolve Suspense resources after the response is
+            // cancelled. Ignore those writes and let Solid finish its cleanup.
+            active = false;
+        },
+    });
+}

package/dist/shared/dev-overlay/createStackFrame.js

@@ -1,8 +1,20 @@
 import { createMemo, createResource } from "solid-js";
 import getSourceMap from "./get-source-map.js";
+const HTTP_URL_REGEX = /^https?:\/\//;
+const LEADING_SLASH_REGEX = /^\/+/;
+// Frames from an SSR error carry filesystem paths (or file:// URLs) rather
+// than the http URL the module is served from. Their positions are already
+// mapped back to the original source by the Vite module runner, unlike
+// client frames whose positions refer to the compiled module.
+function isServerSource(path) {
+    return !HTTP_URL_REGEX.test(path);
+}
 function getActualFileSource(path) {
     if (path.startsWith("file://")) {
-        return "/_build/@fs" + path.substring("file://".length);
+        return "/@fs/" + path.substring("file://".length).replace(LEADING_SLASH_REGEX, "");
+    }
+    if (isServerSource(path)) {
+        return "/@fs/" + path.replace(LEADING_SLASH_REGEX, "");
     }
     return path;
 }
@@ -16,16 +28,18 @@ export function createStackFrame(stackframe, isCompiled) {
         if (!source.fileName) {
             return null;
         }
-        const response = await fetch(getActualFileSource(source.fileName));
+        const url = getActualFileSource(source.fileName);
+        const response = await fetch(url);
         if (!response.ok) {
             return null;
         }
         const content = await response.text();
-        const sourceMap = await getSourceMap(source.fileName, content);
+        const sourceMap = await getSourceMap(url, content);
         return {
             source,
             content,
             sourceMap,
+            isServer: isServerSource(source.fileName),
         };
     });
     const info = createMemo(() => {
@@ -33,16 +47,36 @@ export function createStackFrame(stackframe, isCompiled) {
         if (!current) {
             return undefined;
         }
-        const { source, content, sourceMap } = current;
+        const { source, content, sourceMap, isServer } = current;
         if (!isCompiled() && source.line && source.column && sourceMap) {
-            const result = sourceMap.originalPositionFor({
-                line: source.line,
-                column: source.column,
-            });
-            return {
-                ...result,
-                content: sourceMap.sourceContentFor(result.source),
-            };
+            if (isServer) {
+                // The position is already original; only the original content needs
+                // to be pulled out of the source map.
+                const originalContent = sourceMap.sources.length
+                    ? sourceMap.sourceContentFor(sourceMap.sources[0], true)
+                    : null;
+                if (originalContent) {
+                    return {
+                        source: source.fileName,
+                        line: source.line,
+                        column: source.column,
+                        name: source.functionName,
+                        content: originalContent,
+                    };
+                }
+            }
+            else {
+                const result = sourceMap.originalPositionFor({
+                    line: source.line,
+                    column: source.column,
+                });
+                if (result.source) {
+                    return {
+                        ...result,
+                        content: sourceMap.sourceContentFor(result.source, true),
+                    };
+                }
+            }
         }
         return {
             source: source.fileName,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidjs/start",
-  "version": "2.0.0-beta.9",
+  "version": "2.0.0-rc.1",
   "type": "module",
   "files": [
     "dist",