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

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # @solidjs/start
 
+## 2.0.0-rc.3
+
+### Patch Changes
+
+- d9018d6: fix(types): add missing properties to `SolidStartOptions` and expose them via Vite plugin configuration
+- e26cef0: Fix TS2883/TS2742 when emitting declarations for `entry-server.tsx`. `createHandler` now returns `StartHandler`, a type owned by `@solidjs/start`, instead of h3's `H3`, so the inferred type of `export default createHandler(...)` no longer has to be named through a nested `node_modules/@solidjs/start/node_modules/h3` path.
+- 7c8dbe6: keep TypeScript namespace members in route files during production builds
+- b3c7aaf: Update `h3` to `2.0.1-rc.26`.
+- b3c7aaf: Fixed event response status and headers set during server-side rendering with deferred async resources, not being applied on the outgoing response.
+
+## 2.0.0-rc.2
+
+### Minor Changes
+
+- eeff49a: add new dev toolbar
+
+### Patch Changes
+
+- bd8cb01: Update srvx to version 0.12.0.
+- 4e98ac0: Restore the optional `routerLoad` third argument to `createHandler`, which primes custom routers (e.g. TanStack Router) on the server before SSR rendering. It was accidentally dropped in the v2 rewrite.
+
 ## 2.0.0-rc.1
 
 ### Minor Changes
@@ -144,6 +165,7 @@
 - 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/fs-routes/tree-shake.js

@@ -133,6 +133,11 @@ function treeShakeTransform({ types: t }) {
                             if (!state.opts.pick) {
                                 return;
                             }
+                            // Only module-level exports are route exports; `export` inside a
+                            // TS namespace/module block is unrelated to the pick list.
+                            if (!exportNamedPath.parentPath.isProgram()) {
+                                return;
+                            }
                             const specifiers = exportNamedPath.get("specifiers");
                             if (specifiers.length) {
                                 specifiers.forEach(s => {

package/dist/config/index.d.ts

@@ -2,24 +2,99 @@ import type { PluginOption } from "vite";
 import { type Options as SolidOptions } from "vite-plugin-solid";
 import { type ServerFunctionsOptions } from "../directives/index.ts";
 import { type EnvPluginOptions } from "./env.ts";
+/**
+ * Configuration options for SolidStart. (previously in `app.config.ts`)
+ *
+ * @see https://docs.solidjs.com/solid-start/v2/migrating-from-v1#move-framework-configuration-into-viteconfigts
+ */
 export interface SolidStartOptions {
+    /**
+     * Path to the root of the application (where `app.tsx` / `app.jsx` lives).
+     *
+     * @default "./src"
+     */
+    appRoot?: string;
+    /**
+     * Options forwarded to `vite-plugin-solid`.
+     *
+     * @see https://github.com/solidjs/vite-plugin-solid#api
+     */
     solid?: Partial<SolidOptions>;
+    /**
+     * Enable or disable server-side rendering.
+     *
+     * - `true` — SSR (default)
+     * - `false` — client-side rendering only (SPA mode)
+     *
+     * @default true
+     */
     ssr?: boolean;
+    /**
+     * Show the SolidStart development overlay (error overlay, etc.) in development.
+     *
+     * @default true
+     */
+    devOverlay?: boolean;
+    /**
+     * Experimental features.
+     */
+    experimental?: {
+        /**
+         * Enable islands architecture mode.
+         *
+         * Currently fixed to `false` (not yet fully supported).
+         *
+         * @default false
+         */
+        islands?: false;
+    };
+    /**
+     * Directory containing file-system routes, relative to {@link appRoot}.
+     *
+     * @default "./routes"
+     */
     routeDir?: string;
+    /**
+     * File extensions that should be treated as routes.
+     *
+     * @default ["js", "jsx", "ts", "tsx"]
+     */
     extensions?: string[];
+    /**
+     * Path to an optional middleware module.
+     *
+     * The module should export a middleware created with `createMiddleware`
+     * from `@solidjs/start/middleware`.
+     *
+     * @example "src/middleware/index.ts"
+     */
     middleware?: string;
+    /**
+     * Serialization settings for server-function / action payloads
+     * that cross the server-client boundary.
+     */
     serialization?: {
         /**
          * The serialization mode to use for server functions/actions.
-         * The "js" mode uses a custom binary format that is more efficient than JSON, but requires a custom deserializer (with `eval()`) on the client.
-         * A strong CSP should block `eval()` executions, which would prevent the "js" mode from working.
-         * The "json" mode uses JSON for serialization, which is less efficient but can be deserialized with `JSON.parse` on the client.
+         *
+         * - `"js"` — Uses a custom binary format (Seroval) that is more efficient
+         *   than JSON, but requires a custom deserializer (with `eval()`) on the client.
+         *   A strong CSP that blocks `eval()` will prevent this mode from working.
+         * - `"json"` — Uses JSON for serialization. Less efficient / larger payloads,
+         *   but can be deserialized with `JSON.parse` on the client and is CSP-friendly.
          *
          * @default "json"
          */
         mode?: "js" | "json";
     };
+    /**
+     * Configures plugin behavior per build environment
+     */
     env?: EnvPluginOptions;
+    /**
+     * Options controlling which files are processed as server functions
+     * (inclusion / exclusion filters for the `"use server"` transform).
+     */
     serverFunctions?: Pick<ServerFunctionsOptions, "filter">;
 }
 export declare function solidStart(options?: SolidStartOptions): Array<PluginOption>;

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();
@@ -166,7 +166,6 @@ export async function handleServerFunction(h3Event) {
                 h3Event.res.headers.set("content-type", "text/javascript");
                 return serializeToJSStream(instance, x);
             }
-            h3Event.res.headers.set("content-type", "text/plain");
             return serializeToJSONStream(x);
         }
         return x;
@@ -205,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, {
@@ -227,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/server/handler.d.ts

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

package/dist/server/handler.js

@@ -1,5 +1,5 @@
 import middleware from "solid-start:middleware";
-import { defineHandler, getCookie, H3, redirect, setCookie } from "h3/generic";
+import { defineHandler, getCookie, H3, iterable, redirect, setCookie, } from "h3/generic";
 import { sharedConfig } from "solid-js";
 import { getRequestEvent, renderToStream, renderToString } from "solid-js/web";
 import { createRoutes } from "../router.jsx";
@@ -11,7 +11,7 @@ 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 = {}) {
+export function createBaseHandler(createPageEvent, fn, options = {}, routerLoad) {
     const handler = defineHandler({
         middleware: middleware.length ? middleware.map(decorateMiddleware) : undefined,
         handler: decorateHandler(async (e) => {
@@ -19,12 +19,7 @@ export function createBaseHandler(createPageEvent, fn, options = {}) {
             const url = new URL(event.request.url);
             const pathname = stripBaseUrl(url.pathname);
             if (pathname.startsWith(SERVER_FN_BASE)) {
-                const serverFnResponse = await handleServerFunction(e);
-                if (serverFnResponse instanceof Response)
-                    return produceResponseWithEventHeaders(serverFnResponse);
-                return new Response(serverFnResponse, {
-                    headers: e.res.headers,
-                });
+                return await handleServerFunction(e);
             }
             const match = matchAPIRoute(pathname, event.request.method);
             if (match) {
@@ -36,8 +31,6 @@ export function createBaseHandler(createPageEvent, fn, options = {}) {
                     sharedConfig.context = { event };
                     const res = await fn(event);
                     if (res !== undefined) {
-                        if (res instanceof Response)
-                            return produceResponseWithEventHeaders(res);
                         return res;
                     }
                     if (event.request.method !== "GET") {
@@ -47,6 +40,8 @@ export function createBaseHandler(createPageEvent, fn, options = {}) {
                         return;
                 }
             }
+            if (routerLoad)
+                await routerLoad(event);
             const context = await createPageEvent(event);
             const resolvedOptions = typeof options === "function" ? await options(context) : { ...options };
             const mode = resolvedOptions.mode || "stream";
@@ -94,18 +89,17 @@ export function createBaseHandler(createPageEvent, fn, options = {}) {
             }
             if (mode === "async")
                 return await stream;
-            delete stream.then;
             // h3 expects a standard web ReadableStream across runtimes. The adapter
             // also tolerates cancellation while Solid finishes outstanding work.
-            return toWebReadableStream(stream);
+            return iterable(toWebReadableStream(stream));
         }),
     });
     const app = new H3();
     app.use(handler);
     return app;
 }
-export function createHandler(fn, options = {}) {
-    return createBaseHandler(createPageEvent, fn, options);
+export function createHandler(fn, options = {}, routerLoad) {
+    return createBaseHandler(createPageEvent, fn, options, routerLoad);
 }
 export async function createPageEvent(ctx) {
     ctx.response.headers.set("Content-Type", "text/html");
@@ -180,38 +174,6 @@ function handleStreamCompleteRedirect(context) {
         to && write(`<script>window.location=${JSON.stringify(to).replace(/</g, "\\u003c")}</script>`);
     };
 }
-function produceResponseWithEventHeaders(res) {
-    const event = getRequestEvent();
-    let ret = res;
-    // Response.redirect returns an immutable value, so we clone on any redirect just in case
-    if (300 <= res.status && res.status < 400) {
-        const cookies = res.headers.getSetCookie?.() ?? [];
-        const headers = new Headers();
-        res.headers.forEach((value, key) => {
-            if (key.toLowerCase() !== "set-cookie") {
-                headers.set(key, value);
-            }
-        });
-        for (const cookie of cookies) {
-            headers.append("Set-Cookie", cookie);
-        }
-        ret = new Response(res.body, {
-            status: res.status,
-            statusText: res.statusText,
-            headers,
-        });
-    }
-    const eventCookies = event.response.headers.getSetCookie?.() ?? [];
-    for (const cookie of eventCookies) {
-        ret.headers.append("Set-Cookie", cookie);
-    }
-    for (const [name, value] of event.response.headers) {
-        if (name.toLowerCase() !== "set-cookie") {
-            ret.headers.set(name, value);
-        }
-    }
-    return ret;
-}
 function stripBaseUrl(path) {
     const base = import.meta.env.SERVER_BASE_URL || import.meta.env.BASE_URL || "/";
     return stripPathBase(path, base);

package/dist/server/index.d.ts

@@ -3,7 +3,7 @@ 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";
+export type { APIEvent, APIHandler, Asset, ContextMatches, DocumentComponentProps, FetchEvent, HandlerOptions, PageEvent, ResponseStub, ServerFunctionMeta, StartHandler, } from "./types.ts";
 /**
  * Checks if user has set a redirect status in the response.
  * If not, falls back to the 302 (temporary redirect)

package/dist/server/spa/handler.d.ts

@@ -1,8 +1,7 @@
-import type { H3 } from "h3/generic";
 import type { JSX } from "solid-js";
-import type { HandlerOptions, PageEvent } from "../types.ts";
+import type { FetchEvent, HandlerOptions, PageEvent, StartHandler } from "../types.ts";
 /**
  *
  * Read more: https://docs.solidjs.com/solid-start/reference/server/create-handler
  */
-export declare function createHandler(fn: (context: PageEvent) => JSX.Element, options?: HandlerOptions | ((context: PageEvent) => HandlerOptions)): H3;
+export declare function createHandler(fn: (context: PageEvent) => JSX.Element, options?: HandlerOptions | ((context: PageEvent) => HandlerOptions), routerLoad?: (event: FetchEvent) => Promise<void>): StartHandler;

package/dist/server/spa/handler.js

@@ -4,8 +4,8 @@ import { getSsrManifest } from "../manifest/ssr-manifest.js";
  *
  * Read more: https://docs.solidjs.com/solid-start/reference/server/create-handler
  */
-export function createHandler(fn, options) {
-    return createBaseHandler(createPageEvent, fn, options);
+export function createHandler(fn, options, routerLoad) {
+    return createBaseHandler(createPageEvent, fn, options, routerLoad);
 }
 async function createPageEvent(ctx) {
     const manifest = getSsrManifest("ssr");

package/dist/server/types.d.ts

@@ -1,6 +1,17 @@
-import type { H3Event } from "h3";
+import type { H3, H3Event } from "h3";
 import type { JSX } from "solid-js";
 import type { RequestEvent } from "solid-js/web";
+/**
+ * The h3 app instance returned by `createHandler`.
+ *
+ * Structurally identical to h3's `H3`, but declared here so that `export default
+ * createHandler(...)` in `entry-server.tsx` can be named through `@solidjs/start`.
+ * Referring to `H3` directly makes TypeScript emit a reference to h3's internal
+ * `H3$1` class, which is not portable when h3 is nested inside
+ * `node_modules/@solidjs/start/node_modules` (TS2742 / TS2883).
+ */
+export interface StartHandler extends H3 {
+}
 export type DocumentComponentProps = {
     assets?: JSX.Element;
     scripts: JSX.Element;

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

@@ -5,5 +5,5 @@ type PipeableStream = {
     }): void;
 };
 /** Convert Solid's streaming SSR result into a cancellation-safe web stream. */
-export declare function toWebReadableStream(stream: PipeableStream): ReadableStream<Uint8Array>;
+export declare function toWebReadableStream(stream: PipeableStream): ReadableStream<Uint8Array<ArrayBufferLike>>;
 export {};

package/dist/server/web-stream.js

@@ -6,8 +6,11 @@ export function toWebReadableStream(stream) {
         start(controller) {
             stream.pipe({
                 write(payload) {
-                    if (active)
-                        controller.enqueue(encoder.encode(payload));
+                    if (!active)
+                        return;
+                    // Encoding string to Uint8Array makes sure that
+                    // the stream can be consumed as Response body
+                    controller.enqueue(encoder.encode(payload));
                 },
                 end() {
                     if (!active)

package/dist/shared/ErrorBoundary.jsx

@@ -1,10 +1,10 @@
 // @refresh skip
-import { ErrorBoundary as DefaultErrorBoundary, catchError } from "solid-js";
+import { catchError, ErrorBoundary as DefaultErrorBoundary } from "solid-js";
 import { isServer } from "solid-js/web";
+import { DevToolbar } from "./dev-toolbar/index.jsx";
 import { HttpStatusCode } from "./HttpStatusCode.js";
-import { DevOverlay } from "./dev-overlay/index.jsx";
 export const ErrorBoundary = import.meta.env.DEV && import.meta.env.START_DEV_OVERLAY
-    ? (props) => <DevOverlay>{props.children}</DevOverlay>
+    ? (props) => <DevToolbar>{props.children}</DevToolbar>
     : (props) => {
         const message = isServer
             ? "500 | Internal Server Error"

package/dist/shared/{dev-overlay → dev-toolbar/error-viewer}/CodeView.jsx

@@ -51,12 +51,12 @@ export function CodeView(props) {
             for (let i = 0, len = lines.length; i < len; i++) {
                 const el = lines[i];
                 if (props.line - minLine() - 1 === i) {
-                    el.dataset.startDevOverlayErrorLine = '';
+                    el.dataset.startErrorViewerErrorLine = '';
                 }
             }
         }
     });
-    return (<div ref={ref} data-start-dev-overlay-code-view style={{
-            "--dev-overlay-code-view-start": minLine() + 1,
+    return (<div ref={ref} data-start-error-viewer-code-view style={{
+            "--error-viewer-code-view-start": minLine() + 1,
         }}/>);
 }

package/dist/shared/{dev-overlay/DevOverlayDialog.d.ts → dev-toolbar/error-viewer/index.d.ts}

@@ -1,9 +1,10 @@
 import type { JSX } from "solid-js";
 import "./styles.css";
 export declare function classNames(...classes: (string | boolean | undefined)[]): string;
-interface DevOverlayDialogProps {
+interface ErrorViewerProps {
+    show?: boolean;
     errors: any[];
     resetError: () => void;
 }
-export default function DevOverlayDialog(props: DevOverlayDialogProps): JSX.Element;
+export default function ErrorViewer(props: ErrorViewerProps): JSX.Element;
 export {};