@solidjs/start 1.2.0 → 2.0.0-alpha.0

package/dist/{runtime/server-handler.js → server/server-functions-handler.js}

@@ -1,18 +1,14 @@
-/// <reference types="vinxi/types/server" />
+import { getServerFnById } from "solidstart:server-fn-manifest";
 import { parseSetCookie } from "cookie-es";
-import { crossSerializeStream, fromJSON, getCrossReferenceHeader } from "seroval";
-// @ts-ignore
-import { CustomEventPlugin, DOMExceptionPlugin, EventPlugin, FormDataPlugin, HeadersPlugin, ReadableStreamPlugin, RequestPlugin, ResponsePlugin, URLPlugin, URLSearchParamsPlugin } from "seroval-plugins/web";
+import { parseCookies } from "h3";
+import { crossSerializeStream, fromJSON, getCrossReferenceHeader, } from "seroval";
+import { CustomEventPlugin, DOMExceptionPlugin, EventPlugin, FormDataPlugin, HeadersPlugin, ReadableStreamPlugin, RequestPlugin, ResponsePlugin, URLPlugin, URLSearchParamsPlugin, } from "seroval-plugins/web";
 import { sharedConfig } from "solid-js";
 import { renderToString } from "solid-js/web";
 import { provideRequestEvent } from "solid-js/web/storage";
-import { eventHandler, parseCookies, setHeader, setResponseStatus } from "vinxi/http";
-import invariant from "vinxi/lib/invariant";
-import { cloneEvent, getFetchEvent, mergeResponseHeaders } from "../server/fetchEvent";
-import { getExpectedRedirectStatus } from "../server/handler";
-import { createPageEvent } from "../server/pageEvent";
-// @ts-ignore
-import serverFnManifest from "solidstart:server-fn-manifest";
+import { getFetchEvent, mergeResponseHeaders } from "./fetchEvent.js";
+import { createPageEvent } from "./handler.js";
+import { getExpectedRedirectStatus } from "./util.js";
 function createChunk(data) {
     const encodeData = new TextEncoder().encode(data);
     const bytes = encodeData.length;
@@ -39,7 +35,7 @@ function serializeToStream(id, value) {
                     RequestPlugin,
                     ResponsePlugin,
                     URLSearchParamsPlugin,
-                    URLPlugin
+                    URLPlugin,
                 ],
                 onSerialize(data, initial) {
                     controller.enqueue(createChunk(initial ? `(${getCrossReferenceHeader(id)},${data})` : data));
@@ -49,52 +45,32 @@ function serializeToStream(id, value) {
                 },
                 onError(error) {
                     controller.error(error);
-                }
+                },
             });
-        }
+        },
     });
 }
-async function handleServerFunction(h3Event) {
+export async function handleServerFunction(h3Event) {
     const event = getFetchEvent(h3Event);
     const request = event.request;
     const serverReference = request.headers.get("X-Server-Id");
     const instance = request.headers.get("X-Server-Instance");
     const singleFlight = request.headers.has("X-Single-Flight");
     const url = new URL(request.url);
-    let functionId, name;
+    let functionId;
     if (serverReference) {
-        invariant(typeof serverReference === "string", "Invalid server function");
-        [functionId, name] = serverReference.split("#");
+        // invariant(typeof serverReference === "string", "Invalid server function");
+        [functionId] = serverReference.split("#");
     }
     else {
         functionId = url.searchParams.get("id");
-        name = url.searchParams.get("name");
-        if (!functionId || !name) {
+        if (!functionId) {
             return process.env.NODE_ENV === "development"
                 ? new Response("Server function not found", { status: 404 })
                 : new Response(null, { status: 404 });
         }
     }
-    const serverFnInfo = serverFnManifest[functionId];
-    let fnModule;
-    if (!serverFnInfo) {
-        return process.env.NODE_ENV === "development"
-            ? new Response("Server function not found", { status: 404 })
-            : new Response(null, { status: 404 });
-    }
-    if (process.env.NODE_ENV === "development") {
-        // In dev, we use Vinxi to get the "server" server-side router
-        // Then we use that router's devServer.ssrLoadModule to get the serverFn
-        // This code comes from:
-        // https://github.com/TanStack/router/blob/266f5cc863cd1a99809d1af2669e58b6b6db9a67/packages/start-server-functions-handler/src/index.tsx#L83-L87
-        fnModule = await globalThis.app
-            .getRouter("server-fns")
-            .internals.devServer.ssrLoadModule(serverFnInfo.extractedFilename);
-    }
-    else {
-        fnModule = await serverFnInfo.importer();
-    }
-    const serverFunction = fnModule[serverFnInfo.functionName];
+    const serverFunction = await getServerFnById(functionId);
     let parsed = [];
     // grab bound arguments from url when no JS
     if (!instance || h3Event.method === "GET") {
@@ -113,41 +89,22 @@ async function handleServerFunction(h3Event) {
                         RequestPlugin,
                         ResponsePlugin,
                         URLSearchParamsPlugin,
-                        URLPlugin
-                    ]
+                        URLPlugin,
+                    ],
                 })
-                : json).forEach((arg) => parsed.push(arg));
+                : json).forEach((arg) => {
+                parsed.push(arg);
+            });
         }
     }
     if (h3Event.method === "POST") {
         const contentType = request.headers.get("content-type");
-        const h3Request = h3Event.node.req;
-        // This should never be the case in "proper" Nitro presets since node.req has to be IncomingMessage,
-        // But the new azure-functions preset for some reason uses a ReadableStream in node.req (#1521)
-        const isReadableStream = h3Request instanceof ReadableStream;
-        const hasReadableStream = h3Request.body instanceof ReadableStream;
-        const isH3EventBodyStreamLocked = (isReadableStream && h3Request.locked) ||
-            (hasReadableStream && h3Request.body.locked);
-        const requestBody = isReadableStream ? h3Request : h3Request.body;
         if (contentType?.startsWith("multipart/form-data") ||
             contentType?.startsWith("application/x-www-form-urlencoded")) {
-            // workaround for https://github.com/unjs/nitro/issues/1721
-            // (issue only in edge runtimes and netlify preset)
-            parsed.push(await (isH3EventBodyStreamLocked
-                ? request
-                : new Request(request, { ...request, body: requestBody })).formData());
-            // what should work when #1721 is fixed
-            // parsed.push(await request.formData);
+            parsed.push(await event.request.formData());
         }
         else if (contentType?.startsWith("application/json")) {
-            // workaround for https://github.com/unjs/nitro/issues/1721
-            // (issue only in edge runtimes and netlify preset)
-            const tmpReq = isH3EventBodyStreamLocked
-                ? request
-                : new Request(request, { ...request, body: requestBody });
-            // what should work when #1721 is fixed
-            // just use request.json() here
-            parsed = fromJSON(await tmpReq.json(), {
+            parsed = fromJSON(await event.request.json(), {
                 plugins: [
                     CustomEventPlugin,
                     DOMExceptionPlugin,
@@ -158,17 +115,17 @@ async function handleServerFunction(h3Event) {
                     RequestPlugin,
                     ResponsePlugin,
                     URLSearchParamsPlugin,
-                    URLPlugin
-                ]
+                    URLPlugin,
+                ],
             });
         }
     }
     try {
         let result = await provideRequestEvent(event, async () => {
-            /* @ts-ignore */
+            /* @ts-expect-error */
             sharedConfig.context = { event };
             event.locals.serverFunctionMeta = {
-                id: functionId + "#" + name
+                id: functionId
             };
             return serverFunction(...parsed);
         });
@@ -185,7 +142,7 @@ async function handleServerFunction(h3Event) {
                     mergeResponseHeaders(h3Event, result.headers);
                 // forward non-redirect statuses
                 if (result.status && (result.status < 300 || result.status >= 400))
-                    setResponseStatus(h3Event, result.status);
+                    h3Event.res.status = result.status;
                 if (result.customBody) {
                     result = await result.customBody();
                 }
@@ -196,7 +153,7 @@ async function handleServerFunction(h3Event) {
         // handle no JS success case
         if (!instance)
             return handleNoJS(result, request, parsed);
-        setHeader(h3Event, "content-type", "text/javascript");
+        h3Event.res.headers.set("content-type", "text/javascript");
         return serializeToStream(instance, result);
     }
     catch (x) {
@@ -208,24 +165,25 @@ 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))
-                setResponseStatus(h3Event, x.status);
+            if (x.status &&
+                (!instance || x.status < 300 || x.status >= 400))
+                h3Event.res.status = x.status;
             if (x.customBody) {
                 x = x.customBody();
             }
-            else if (x.body == undefined)
+            else if (x.body === undefined)
                 x = null;
-            setHeader(h3Event, "X-Error", "true");
+            h3Event.res.headers.set("X-Error", "true");
         }
         else if (instance) {
             const error = x instanceof Error ? x.message : typeof x === "string" ? x : "true";
-            setHeader(h3Event, "X-Error", error.replace(/[\r\n]+/g, ""));
+            h3Event.res.headers.set("X-Error", error.replace(/[\r\n]+/g, ""));
         }
         else {
             x = handleNoJS(x, request, parsed, true);
         }
         if (instance) {
-            setHeader(h3Event, "content-type", "text/javascript");
+            h3Event.res.headers.set("content-type", "text/javascript");
             return serializeToStream(instance, x);
         }
         return x;
@@ -239,24 +197,29 @@ function handleNoJS(result, request, parsed, thrown) {
     if (result instanceof Response) {
         headers = new Headers(result.headers);
         if (result.headers.has("Location")) {
-            headers.set(`Location`, new URL(result.headers.get("Location"), url.origin + import.meta.env.SERVER_BASE_URL).toString());
+            headers.set(`Location`, new URL(result.headers.get("Location"), url.origin + import.meta.env.BASE_URL).toString());
             statusCode = getExpectedRedirectStatus(result);
         }
     }
     else
-        headers = new Headers({ Location: new URL(request.headers.get("referer")).toString() });
+        headers = new Headers({
+            Location: new URL(request.headers.get("referer")).toString(),
+        });
     if (result) {
         headers.append("Set-Cookie", `flash=${encodeURIComponent(JSON.stringify({
             url: url.pathname + url.search,
             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, {
         status: statusCode,
-        headers
+        headers,
     });
 }
 let App;
@@ -264,16 +227,16 @@ function createSingleFlightHeaders(sourceEvent) {
     // cookie handling logic is pretty simplistic so this might be imperfect
     // unclear if h3 internals are available on all platforms but we need a way to
     // update request headers on the underlying H3 event.
-    const headers = new Headers(sourceEvent.request.headers);
+    const headers = sourceEvent.request.headers;
     const cookies = parseCookies(sourceEvent.nativeEvent);
     const SetCookies = sourceEvent.response.headers.getSetCookie();
     headers.delete("cookie");
-    let useH3Internals = false;
-    if (sourceEvent.nativeEvent.node?.req) {
-        useH3Internals = true;
-        sourceEvent.nativeEvent.node.req.headers.cookie = "";
-    }
-    SetCookies.forEach(cookie => {
+    // let useH3Internals = false;
+    // if (sourceEvent.nativeEvent.node?.req) {
+    // 	useH3Internals = true;
+    // 	sourceEvent.nativeEvent.node.req.headers.cookie = "";
+    // }
+    SetCookies.forEach((cookie) => {
         if (!cookie)
             return;
         const { maxAge, expires, name, value } = parseSetCookie(cookie);
@@ -289,7 +252,8 @@ function createSingleFlightHeaders(sourceEvent) {
     });
     Object.entries(cookies).forEach(([key, value]) => {
         headers.append("cookie", `${key}=${value}`);
-        useH3Internals && (sourceEvent.nativeEvent.node.req.headers.cookie += `${key}=${value};`);
+        // useH3Internals &&
+        // 	(sourceEvent.nativeEvent.node.req.headers.cookie += `${key}=${value};`);
     });
     return headers;
 }
@@ -300,21 +264,23 @@ async function handleSingleFlight(sourceEvent, result) {
         if (result.headers.has("X-Revalidate"))
             revalidate = result.headers.get("X-Revalidate").split(",");
         if (result.headers.has("Location"))
-            url = new URL(result.headers.get("Location"), new URL(sourceEvent.request.url).origin + import.meta.env.SERVER_BASE_URL).toString();
+            url = new URL(result.headers.get("Location"), new URL(sourceEvent.request.url).origin +
+                import.meta.env.BASE_URL).toString();
     }
-    const event = cloneEvent(sourceEvent);
-    event.request = new Request(url, { headers: createSingleFlightHeaders(sourceEvent) });
+    const event = { ...sourceEvent };
+    event.request = new Request(url, {
+        headers: createSingleFlightHeaders(sourceEvent),
+    });
     return await provideRequestEvent(event, async () => {
         await createPageEvent(event);
-        /* @ts-ignore */
-        App || (App = (await import("#start/app")).default);
-        /* @ts-ignore */
+        App || (App = (await import("solid-start:app")).default);
+        /* @ts-expect-error */
         event.router.dataOnly = revalidate || true;
-        /* @ts-ignore */
+        /* @ts-expect-error */
         event.router.previousUrl = sourceEvent.request.headers.get("referer");
         try {
             renderToString(() => {
-                /* @ts-ignore */
+                /* @ts-expect-error */
                 sharedConfig.context.event = event;
                 App();
             });
@@ -322,7 +288,7 @@ async function handleSingleFlight(sourceEvent, result) {
         catch (e) {
             console.log(e);
         }
-        /* @ts-ignore */
+        /* @ts-expect-error */
         const body = event.router.data;
         if (!body)
             return result;
@@ -347,4 +313,3 @@ async function handleSingleFlight(sourceEvent, result) {
         return result;
     });
 }
-export default eventHandler(handleServerFunction);

package/dist/server/server-runtime.d.ts

@@ -0,0 +1,3 @@
+import { type Component } from "solid-js";
+export declare function createServerReference(id: string): (...args: any[]) => Promise<any>;
+export declare function createClientReference(Component: Component<any>, id: string): Component<any>;

package/dist/{runtime → server}/server-runtime.js

@@ -1,6 +1,5 @@
 import { deserialize, toJSONAsync } from "seroval";
 import { CustomEventPlugin, DOMExceptionPlugin, EventPlugin, FormDataPlugin, HeadersPlugin, ReadableStreamPlugin, RequestPlugin, ResponsePlugin, URLPlugin, URLSearchParamsPlugin } from "seroval-plugins/web";
-import { createIslandReference } from "../server/islands/index";
 class SerovalChunkReader {
     reader;
     buffer;
@@ -44,9 +43,6 @@ class SerovalChunkReader {
         // deserialize the data
         const head = new TextDecoder().decode(this.buffer.subarray(1, 11));
         const bytes = Number.parseInt(head, 16); // ;0x00000000;
-        if (Number.isNaN(bytes)) {
-            throw new Error(`Malformed server function stream header: ${head}`);
-        }
         // Check if the buffer has enough bytes to be parsed
         while (bytes > this.buffer.length - 12) {
             // If it's not enough, and the reader is done
@@ -160,18 +156,21 @@ async function fetchServerFunction(base, id, options, args) {
     }
     return result;
 }
-export function createServerReference(fn, id, name) {
-    const baseURL = import.meta.env.SERVER_BASE_URL;
+export function createServerReference(id) {
+    let baseURL = import.meta.env.BASE_URL ?? "/";
+    if (!baseURL.endsWith("/"))
+        baseURL += "/";
+    const fn = (...args) => fetchServerFunction(`${baseURL}_server`, id, {}, args);
     return new Proxy(fn, {
         get(target, prop, receiver) {
             if (prop === "url") {
-                return `${baseURL}/_server?id=${encodeURIComponent(id)}&name=${encodeURIComponent(name)}`;
+                return `${baseURL}_server?id=${encodeURIComponent(id)}`;
             }
             if (prop === "GET") {
                 return receiver.withOptions({ method: "GET" });
             }
             if (prop === "withOptions") {
-                const url = `${baseURL}/_server/?id=${encodeURIComponent(id)}&name=${encodeURIComponent(name)}`;
+                const url = `${baseURL}_server?id=${encodeURIComponent(id)}`;
                 return (options) => {
                     const fn = async (...args) => {
                         const encodeArgs = options.method && options.method.toUpperCase() === "GET";
@@ -180,7 +179,7 @@ export function createServerReference(fn, id, name) {
                                 (args.length
                                     ? `&args=${encodeURIComponent(JSON.stringify(await Promise.resolve(toJSONAsync(args, { plugins }))))}`
                                     : "")
-                            : `${baseURL}/_server`, `${id}#${name}`, options, encodeArgs ? [] : args);
+                            : `${baseURL}_server`, id, options, encodeArgs ? [] : args);
                     };
                     fn.url = url;
                     return fn;
@@ -188,14 +187,8 @@ export function createServerReference(fn, id, name) {
             }
             return target[prop];
         },
-        apply(target, thisArg, args) {
-            return fetchServerFunction(`${baseURL}/_server`, `${id}#${name}`, {}, args);
-        }
     });
 }
-export function createClientReference(Component, id, name) {
-    if (typeof Component === "function") {
-        return createIslandReference(Component, id, name);
-    }
+export function createClientReference(Component, id) {
     return Component;
 }

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

@@ -1,5 +1,5 @@
 import type { Component } from "solid-js";
-import type { DocumentComponentProps } from "../types";
+import type { DocumentComponentProps } from "../types.ts";
 /**
  *
  * Read more: https://docs.solidjs.com/solid-start/reference/server/start-server

package/dist/server/spa/StartServer.jsx

@@ -1,6 +1,7 @@
 import { NoHydration, getRequestEvent, ssr } from "solid-js/web";
-import { TopErrorBoundary } from "../../shared/ErrorBoundary";
-import { renderAsset } from "../renderAsset";
+import { getSsrManifest } from "../manifest/ssr-manifest.js";
+import { TopErrorBoundary } from "../../shared/ErrorBoundary.jsx";
+import { useAssets } from "../assets/index.js";
 const docType = ssr("<!DOCTYPE html>");
 /**
  *
@@ -10,16 +11,13 @@ export function StartServer(props) {
     const context = getRequestEvent();
     // @ts-ignore
     const nonce = context.nonce;
+    useAssets(context.assets, nonce);
     return (<NoHydration>
       {docType}
       <TopErrorBoundary>
-        <props.document assets={<>{context.assets.map((m) => renderAsset(m))}</>} scripts={nonce ? (<>
-                <script nonce={nonce} innerHTML={`window.manifest = ${JSON.stringify(context.manifest)}`}/>
-                <script type="module" src={import.meta.env.MANIFEST["client"].inputs[import.meta.env.MANIFEST["client"].handler].output.path}/>
-              </>) : (<>
-                <script innerHTML={`window.manifest = ${JSON.stringify(context.manifest)}`}/>
-                <script type="module" src={import.meta.env.MANIFEST["client"].inputs[import.meta.env.MANIFEST["client"].handler].output.path}/>
-              </>)}/>
+        <props.document scripts={<>
+              <script type="module" src={getSsrManifest("client").path(import.meta.env.START_CLIENT_ENTRY)}/>
+            </>}/>
       </TopErrorBoundary>
     </NoHydration>);
 }

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

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

package/dist/server/spa/handler.js

@@ -1,22 +1,20 @@
-import { createBaseHandler } from "../handler";
+import { createBaseHandler } from "../handler.js";
+import { getSsrManifest } from "../manifest/ssr-manifest.js";
 /**
  *
  * Read more: https://docs.solidjs.com/solid-start/reference/server/create-handler
  */
-export function createHandler(fn, options, routerLoad) {
-    return createBaseHandler(fn, createPageEvent, options, routerLoad);
+export function createHandler(fn, options) {
+    return createBaseHandler(createPageEvent, fn, options);
 }
-export async function createPageEvent(ctx) {
-    const clientManifest = import.meta.env.MANIFEST["client"];
+async function createPageEvent(ctx) {
+    const manifest = getSsrManifest("ssr");
     const pageEvent = Object.assign(ctx, {
-        manifest: await clientManifest.json(),
-        assets: [...(await clientManifest.inputs[clientManifest.handler].assets())],
+        manifest: "json" in manifest ? await manifest.json() : {},
+        assets: await manifest.getAssets(import.meta.env.START_CLIENT_ENTRY),
         routes: [],
         complete: false,
-        // prevUrl: "",
-        // mutation: false,
-        // $type: FETCH_EVENT,
-        $islands: new Set()
+        $islands: new Set(),
     });
     return pageEvent;
 }

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

@@ -1,3 +1,4 @@
-export * from "../types";
-export { StartServer } from "./StartServer";
-export { createHandler } from "./handler";
+export { default as lazy } from "../../shared/lazy.ts";
+export * from "../types.ts";
+export { StartServer } from "./StartServer.tsx";
+export { createHandler } from "./handler.ts";

package/dist/server/spa/index.jsx

@@ -1,4 +1,5 @@
 // @refresh skip
-export * from "../types";
-export { StartServer } from "./StartServer";
-export { createHandler } from "./handler";
+export { default as lazy } from "../../shared/lazy.js";
+export * from "../types.js";
+export { StartServer } from "./StartServer.jsx";
+export { createHandler } from "./handler.js";

package/dist/server/types.d.ts

@@ -1,8 +1,8 @@
+import type { H3Event } from "h3";
 import type { JSX } from "solid-js";
-import { RequestEvent } from "solid-js/web";
-import { HTTPEvent } from "vinxi/http";
+import type { RequestEvent } from "solid-js/web";
 export type DocumentComponentProps = {
-    assets: JSX.Element;
+    assets?: JSX.Element;
     scripts: JSX.Element;
     children?: JSX.Element;
 };
@@ -50,23 +50,21 @@ export interface FetchEvent {
     response: ResponseStub;
     clientAddress?: string;
     locals: App.RequestEventLocals;
-    nativeEvent: HTTPEvent;
+    nativeEvent: H3Event;
 }
 export interface PageEvent extends RequestEvent {
-    manifest: any;
-    assets: any;
+    assets: any[];
     routes: any[];
     $islands: Set<string>;
     complete: boolean;
+    nonce?: string;
 }
 export interface APIEvent extends FetchEvent {
     params: {
         [key: string]: string;
     };
 }
-export interface APIHandler {
-    (event: APIEvent): Promise<any>;
-}
+export type APIHandler = (event: APIEvent) => Promise<any>;
 export interface ServerFunctionMeta {
     id: string;
 }

package/dist/server/util.d.ts

@@ -0,0 +1,2 @@
+import type { ResponseStub } from "./types.ts";
+export declare function getExpectedRedirectStatus(response: ResponseStub): number;

package/dist/server/util.js

@@ -0,0 +1,8 @@
+// according to https://developer.mozilla.org/en-US/docs/Web/HTTP/Status#redirection_messages
+const validRedirectStatuses = new Set([301, 302, 303, 307, 308]);
+export function getExpectedRedirectStatus(response) {
+    if (response.status && validRedirectStatuses.has(response.status)) {
+        return response.status;
+    }
+    return 302;
+}

package/dist/shared/ErrorBoundary.jsx

@@ -1,8 +1,8 @@
 // @refresh skip
 import { ErrorBoundary as DefaultErrorBoundary, catchError } from "solid-js";
 import { isServer } from "solid-js/web";
-import { HttpStatusCode } from "./HttpStatusCode";
-import { DevOverlay } from "./dev-overlay";
+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) => {

package/dist/shared/HttpHeader.jsx

@@ -1,6 +1,7 @@
 // @refresh skip
 import { onCleanup } from "solid-js";
 import { getRequestEvent, isServer } from "solid-js/web";
+import { appendHeader, setHeader } from "../http/index.js";
 /**
  *
  * Read more: https://docs.solidjs.com/solid-start/reference/server/http-header
@@ -9,10 +10,11 @@ export const HttpHeader = isServer
     ? (props) => {
         const event = getRequestEvent();
         if (props.append)
-            event.response.headers.append(props.name, props.value);
+            appendHeader(props.name, props.value);
         else
-            event.response.headers.set(props.name, props.value);
+            setHeader(props.name, props.value);
         onCleanup(() => {
+            // @ts-expect-error
             if (event.nativeEvent.handled || event.complete)
                 return;
             const value = event.response.headers.get(props.name);

package/dist/shared/{HttpStatusCode.jsx → HttpStatusCode.js}

@@ -10,7 +10,9 @@ export const HttpStatusCode = isServer
         const event = getRequestEvent();
         event.response.status = props.code;
         event.response.statusText = props.text;
-        onCleanup(() => !event.nativeEvent.handled && !event.complete && (event.response.status = 200));
+        onCleanup(() => 
+        // !event.nativeEvent.handled &&
+        !event.complete && (event.response.status = 200));
         return null;
     }
     : (_props) => null;

package/dist/shared/dev-overlay/DevOverlayDialog.d.ts

@@ -1,5 +1,5 @@
-import type { JSX } from 'solid-js';
-import './styles.css';
+import type { JSX } from "solid-js";
+import "./styles.css";
 export declare function classNames(...classes: (string | boolean | undefined)[]): string;
 interface DevOverlayDialogProps {
     errors: any[];