@solidjs/start 1.1.7 → 2.0.0-alpha.0

package/dist/{router → server}/routes.d.ts

@@ -1,3 +1,4 @@
+import type { FetchEvent } from "./types.ts";
 interface Route {
     path: string;
     id: string;
@@ -11,17 +12,12 @@ interface Route {
     $PATCH?: any;
     $DELETE?: any;
 }
-declare module "vinxi/routes" {
-    interface Register {
-        route: {
-            path: string;
-            children?: Route[];
-        };
-    }
-}
 export declare const pageRoutes: Route[];
 export declare function matchAPIRoute(path: string, method: string): {
-    handler: any;
-    params: Record<string, any> | undefined;
+    params?: Record<string, any>;
+    handler: {
+        import: () => Promise<Record<string, (e: FetchEvent) => Promise<any>>>;
+    };
+    isPage: boolean;
 } | undefined;
 export {};

package/dist/{router → server}/routes.js

@@ -1,16 +1,17 @@
+// @ts-expect-error
+import fileRoutes from "solid-start:routes";
 import { createRouter } from "radix3";
-import fileRoutes from "vinxi/routes";
-export const pageRoutes = defineRoutes(fileRoutes.filter(o => o.page));
+export const pageRoutes = defineRoutes(fileRoutes.filter((o) => o.page));
 function defineRoutes(fileRoutes) {
     function processRoute(routes, route, id, full) {
-        const parentRoute = Object.values(routes).find(o => {
+        const parentRoute = Object.values(routes).find((o) => {
             return id.startsWith(o.id + "/");
         });
         if (!parentRoute) {
             routes.push({
                 ...route,
                 id,
-                path: id.replace(/\([^)/]+\)/g, "").replace(/\/+/g, "/")
+                path: id.replace(/\([^)/]+\)/g, "").replace(/\/+/g, "/"),
             });
             return routes;
         }
@@ -23,36 +24,16 @@ function defineRoutes(fileRoutes) {
         return processRoute(prevRoutes, route, route.path, route.path);
     }, []);
 }
-export function matchAPIRoute(path, method) {
-    const match = router.lookup(path);
-    if (match && match.route) {
-        const handler = method === "HEAD" ? match.route["$HEAD"] || match.route["$GET"] : match.route[`$${method}`];
-        if (handler === undefined)
-            return;
-        return {
-            handler,
-            params: match.params
-        };
-    }
-}
-function containsHTTP(route) {
-    return (route["$HEAD"] ||
-        route["$GET"] ||
-        route["$POST"] ||
-        route["$PUT"] ||
-        route["$PATCH"] ||
-        route["$DELETE"]);
-}
 const router = createRouter({
     routes: fileRoutes.reduce((memo, route) => {
         if (!containsHTTP(route))
             return memo;
-        let path = route.path
+        const path = route.path
             .replace(/\([^)/]+\)/g, "")
             .replace(/\/+/g, "/")
             .replace(/\*([^/]*)/g, (_, m) => `**:${m}`)
             .split("/")
-            .map(s => (s.startsWith(":") || s.startsWith("*") ? s : encodeURIComponent(s)))
+            .map((s) => s.startsWith(":") || s.startsWith("*") ? s : encodeURIComponent(s))
             .join("/");
         if (/:[^/]*\?/g.test(path)) {
             throw new Error(`Optional parameters are not supported in API routes: ${path}`);
@@ -62,5 +43,32 @@ const router = createRouter({
         }
         memo[path] = { route };
         return memo;
-    }, {})
+    }, {}),
 });
+function containsHTTP(route) {
+    return (route["$HEAD"] ||
+        route["$GET"] ||
+        route["$POST"] ||
+        route["$PUT"] ||
+        route["$PATCH"] ||
+        route["$DELETE"]);
+}
+export function matchAPIRoute(path, method) {
+    const match = router.lookup(path);
+    if (match && match.route) {
+        const route = match.route;
+        // Find the appropriate handler for the HTTP method
+        const handler = method === "HEAD" ? route.$HEAD || route.$GET : route[`$${method}`];
+        if (handler === undefined)
+            return;
+        // Check if this is a page route
+        const isPage = route.page === true && route.$component !== undefined;
+        // Return comprehensive route information
+        return {
+            handler,
+            params: match.params,
+            isPage,
+        };
+    }
+    return undefined;
+}

package/dist/{runtime → server}/server-fns-runtime.d.ts

@@ -1 +1 @@
-export declare function createServerReference(fn: Function, id: string, name: string): Function;
+export declare function createServerReference(fn: Function, id: string): Function;

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

@@ -1,14 +1,15 @@
 import { getRequestEvent } from "solid-js/web";
 import { provideRequestEvent } from "solid-js/web/storage";
-import { cloneEvent } from "../server/fetchEvent";
-export function createServerReference(fn, id, name) {
+export function createServerReference(fn, id) {
     if (typeof fn !== "function")
         throw new Error("Export from a 'use server' module must be a function");
-    const baseURL = import.meta.env.SERVER_BASE_URL;
+    let baseURL = import.meta.env.BASE_URL ?? "/";
+    if (!baseURL.endsWith("/"))
+        baseURL += "/";
     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;
@@ -18,9 +19,9 @@ export function createServerReference(fn, id, name) {
             const ogEvt = getRequestEvent();
             if (!ogEvt)
                 throw new Error("Cannot call server function outside of a request");
-            const evt = cloneEvent(ogEvt);
+            const evt = { ...ogEvt };
             evt.locals.serverFunctionMeta = {
-                id: id + "#" + name,
+                id
             };
             evt.serverOnly = true;
             return provideRequestEvent(evt, () => {

package/dist/server/server-functions-handler.d.ts

@@ -0,0 +1,2 @@
+import { type H3Event } from "h3";
+export declare function handleServerFunction(h3Event: H3Event): Promise<unknown>;

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

@@ -1,17 +1,14 @@
-/// <reference types="vinxi/types/server" />
-import { crossSerializeStream, fromJSON, getCrossReferenceHeader } from "seroval";
-// @ts-ignore
-import { CustomEventPlugin, DOMExceptionPlugin, EventPlugin, FormDataPlugin, HeadersPlugin, ReadableStreamPlugin, RequestPlugin, ResponsePlugin, URLPlugin, URLSearchParamsPlugin } from "seroval-plugins/web";
+import { getServerFnById } from "solidstart:server-fn-manifest";
+import { parseSetCookie } from "cookie-es";
+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;
@@ -38,7 +35,7 @@ function serializeToStream(id, value) {
                     RequestPlugin,
                     ResponsePlugin,
                     URLSearchParamsPlugin,
-                    URLPlugin
+                    URLPlugin,
                 ],
                 onSerialize(data, initial) {
                     controller.enqueue(createChunk(initial ? `(${getCrossReferenceHeader(id)},${data})` : data));
@@ -48,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") {
@@ -112,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,
@@ -157,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);
         });
@@ -184,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();
                 }
@@ -195,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) {
@@ -207,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;
@@ -238,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;
@@ -263,25 +227,33 @@ 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 keyValue = cookie.split(";")[0];
-        const [key, value] = keyValue.split("=");
-        key && value && (cookies[key] = value);
+        const { maxAge, expires, name, value } = parseSetCookie(cookie);
+        if (maxAge != null && maxAge <= 0) {
+            delete cookies[name];
+            return;
+        }
+        if (expires != null && expires.getTime() <= Date.now()) {
+            delete cookies[name];
+            return;
+        }
+        cookies[name] = value;
     });
     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;
 }
@@ -292,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();
             });
@@ -314,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;
@@ -339,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;