@solidjs/start 0.5.9 → 0.6.0

package/config/index.d.ts

@@ -1,24 +1,19 @@
-import { AppOptions } from "vinxi";
-import { InlineConfig } from "vite";
+import type { AppOptions } from "vinxi";
+import type { CustomizableConfig } from "vinxi/dist/types/lib/vite-dev";
 import type { Options } from "vite-plugin-solid";
 
+type SolidStartInlineConfig = {
+  ssr?: boolean;
+  solid?: Options;
+  extensions?: string[];
+  server?: AppOptions["server"];
+  appRoot?: string;
+  middleware?: string;
+  islands?: boolean;
+  devOverlay?:  boolean;
+  vite?:
+    | CustomizableConfig
+    | ((options: { router: "server" | "client" | "server-function" }) => CustomizableConfig);
+};
 
-type SolidStartInlineConfig = Omit<InlineConfig, "router"> & {
-    start?: {
-        /**
-         * true: streaming mode
-         * false: csr only
-         * async: ssr is in async mode
-         * sync: ssr is in sync mode
-         */
-        ssr?: boolean | "async" | "sync",
-        solid?: Options,
-        extensions?: string[],
-        server?: AppOptions['server'],
-        appRoot?: string,
-        middleware?: string,
-        islands?: boolean
-    }
-}
-
-export declare function defineConfig(baseConfig?: SolidStartInlineConfig)
+export declare function defineConfig(baseConfig?: SolidStartInlineConfig): any;

package/config/index.js

@@ -38,11 +38,12 @@ function solidStartServerFsRouter(config) {
 }
 
 export function defineConfig(baseConfig = {}) {
-  let { plugins = [], start = {}, ...userConfig } = baseConfig;
+  let { vite = {}, ...start } = baseConfig;
   const extensions = [...DEFAULT_EXTENSIONS, ...(start.extensions || [])];
   start = defu(start, {
     appRoot: "./src",
     ssr: true,
+    devOverlay: true,
     islands: false,
     solid: {},
     server: {
@@ -71,8 +72,8 @@ export function defineConfig(baseConfig = {}) {
       {
         name: "public",
         type: "static",
-        dir: "./public",
-        base: "/"
+        base: "/",
+        dir: "./public"
       },
       {
         name: "ssr",
@@ -85,51 +86,57 @@ export function defineConfig(baseConfig = {}) {
         routes: solidStartServerFsRouter({ dir: `${start.appRoot}/routes`, extensions }),
         extensions,
         target: "server",
-        plugins: async () => [
-          config("user", {
-            ...userConfig,
-            optimizeDeps: {
-              ...(userConfig.optimizeDeps || {}),
-              include: [
-                ...(userConfig.optimizeDeps?.include || []),
-                "@solidjs/start > source-map-js",
-                "@solidjs/start > error-stack-parser"
-              ]
-            }
-          }),
-          ...(typeof plugins === "function" ? [...(await plugins())] : plugins),
-
-          serverTransform({
-            runtime: normalize(fileURLToPath(new URL("./server-fns-runtime.ts", import.meta.url)))
-          }),
-          start.islands ? serverComponents.server() : null,
-          solid({ ...start.solid, ssr: true, extensions: extensions.map(ext => `.${ext}`) }),
-          config("app-server", {
-            resolve: {
-              alias: {
-                "#start/app": join(process.cwd(), start.appRoot, `app${entryExtension}`),
-                "~": join(process.cwd(), start.appRoot),
-                ...(!start.ssr
-                  ? {
-                      "@solidjs/start/server": "@solidjs/start/server/spa"
-                    }
-                  : {}),
-                ...userConfig.resolve?.alias
+        plugins: async () => {
+          const userConfig = typeof vite === "function" ? await vite({ router: "server" }) : { ...vite };
+          const plugins = userConfig.plugins || [];
+          delete userConfig.plugins;
+          return [
+            config("user", {
+              ...userConfig,
+              optimizeDeps: {
+                ...(userConfig.optimizeDeps || {}),
+                include: [
+                  ...(userConfig.optimizeDeps?.include || []),
+                  "@solidjs/start > source-map-js",
+                  "@solidjs/start > error-stack-parser"
+                ]
               }
-            },
-            cacheDir: "node_modules/.vinxi/server",
-            define: {
-              "import.meta.env.START_ISLANDS": JSON.stringify(start.islands),
-              "import.meta.env.SSR": JSON.stringify(true),
-              "import.meta.env.START_SSR": JSON.stringify(start.ssr),
-              ...userConfig.define
-            }
-          })
-        ]
+            }),
+            ...plugins,
+            serverTransform({
+              runtime: normalize(fileURLToPath(new URL("./server-fns-runtime.ts", import.meta.url)))
+            }),
+            start.islands ? serverComponents.server() : null,
+            solid({ ...start.solid, ssr: true, extensions: extensions.map(ext => `.${ext}`) }),
+            config("app-server", {
+              resolve: {
+                alias: {
+                  "#start/app": join(process.cwd(), start.appRoot, `app${entryExtension}`),
+                  "~": join(process.cwd(), start.appRoot),
+                  ...(!start.ssr
+                    ? {
+                        "@solidjs/start/server": "@solidjs/start/server/spa"
+                      }
+                    : {}),
+                  ...userConfig.resolve?.alias
+                }
+              },
+              cacheDir: "node_modules/.vinxi/server",
+              define: {
+                "import.meta.env.START_ISLANDS": JSON.stringify(start.islands),
+                "import.meta.env.SSR": JSON.stringify(true),
+                "import.meta.env.START_SSR": JSON.stringify(start.ssr),
+                "import.meta.env.START_DEV_OVERLAY": JSON.stringify(start.devOverlay),
+                ...userConfig.define
+              }
+            })
+          ];
+        }
       },
       {
         name: "client",
         type: "client",
+        base: "/_build",
         handler: `${start.appRoot}/entry-client${entryExtension}`,
         ...(start.islands
           ? {}
@@ -138,53 +145,58 @@ export function defineConfig(baseConfig = {}) {
             }),
         extensions,
         target: "browser",
-        plugins: async () => [
-          config("user", {
-            ...userConfig,
-            optimizeDeps: {
-              ...(userConfig.optimizeDeps || {}),
-              include: [
-                ...(userConfig.optimizeDeps?.include || []),
-                "@solidjs/start > source-map-js",
-                "@solidjs/start > error-stack-parser"
-              ]
-            }
-          }),
-          ...(typeof plugins === "function" ? [...(await plugins())] : plugins),
-          serverFunctions.client({
-            runtime: normalize(fileURLToPath(new URL("./server-runtime.ts", import.meta.url)))
-          }),
-          start.islands ? serverComponents.client() : null,
-          solid({ ...start.solid, ssr: start.ssr, extensions: extensions.map(ext => `.${ext}`) }),
-          config("app-client", {
-            resolve: {
-              alias: {
-                "#start/app": join(process.cwd(), start.appRoot, `app${entryExtension}`),
-                "~": join(process.cwd(), start.appRoot),
-                ...(start.islands
-                  ? {
-                      "@solidjs/start/client": "@solidjs/start/client/islands"
-                    }
-                  : {}),
-                ...(!start.ssr
-                  ? {
-                      "@solidjs/start/client": "@solidjs/start/client/spa"
-                    }
-                  : {}),
-                ...userConfig.resolve?.alias
+        plugins: async () => {
+          const userConfig = typeof vite === "function" ? await vite({ router: "client" }) : { ...vite };
+          const plugins = userConfig.plugins || [];
+          delete userConfig.plugins;
+          return [
+            config("user", {
+              ...userConfig,
+              optimizeDeps: {
+                ...(userConfig.optimizeDeps || {}),
+                include: [
+                  ...(userConfig.optimizeDeps?.include || []),
+                  "@solidjs/start > source-map-js",
+                  "@solidjs/start > error-stack-parser"
+                ]
+              }
+            }),
+            ...plugins,
+            serverFunctions.client({
+              runtime: normalize(fileURLToPath(new URL("./server-runtime.ts", import.meta.url)))
+            }),
+            start.islands ? serverComponents.client() : null,
+            solid({ ...start.solid, ssr: start.ssr, extensions: extensions.map(ext => `.${ext}`) }),
+            config("app-client", {
+              resolve: {
+                alias: {
+                  "#start/app": join(process.cwd(), start.appRoot, `app${entryExtension}`),
+                  "~": join(process.cwd(), start.appRoot),
+                  ...(start.islands
+                    ? {
+                        "@solidjs/start/client": "@solidjs/start/client/islands"
+                      }
+                    : {}),
+                  ...(!start.ssr
+                    ? {
+                        "@solidjs/start/client": "@solidjs/start/client/spa"
+                      }
+                    : {}),
+                  ...userConfig.resolve?.alias
+                }
+              },
+              cacheDir: "node_modules/.vinxi/client",
+              define: {
+                "import.meta.env.START_ISLANDS": JSON.stringify(start.islands),
+                "import.meta.env.SSR": JSON.stringify(false),
+                "import.meta.env.START_SSR": JSON.stringify(start.ssr),
+                "import.meta.env.START_DEV_OVERLAY": JSON.stringify(start.devOverlay),
+                "import.meta.env.SERVER_BASE_URL": JSON.stringify(server?.baseURL ?? ""),
+                ...userConfig.define
               }
-            },
-            cacheDir: "node_modules/.vinxi/client",
-            define: {
-              "import.meta.env.START_ISLANDS": JSON.stringify(start.islands),
-              "import.meta.env.SSR": JSON.stringify(false),
-              "import.meta.env.START_SSR": JSON.stringify(start.ssr),
-              "import.meta.env.SERVER_BASE_URL": JSON.stringify(server?.baseURL ?? ""),
-              ...userConfig.define
-            }
-          })
-        ],
-        base: "/_build"
+            })
+          ];
+        }
       },
 
       {
@@ -192,48 +204,54 @@ export function defineConfig(baseConfig = {}) {
         type: "http",
         base: "/_server",
         handler: normalize(fileURLToPath(new URL("./server-handler.ts", import.meta.url))),
+        middleware: start.middleware,
         target: "server",
         routes: solidStartServerFsRouter({ dir: `${start.appRoot}/routes`, extensions }),
-        plugins: async () => [
-          config("user", {
-            ...userConfig,
-            optimizeDeps: {
-              ...(userConfig.optimizeDeps || {}),
-              include: [
-                ...(userConfig.optimizeDeps?.include || []),
-                "@solidjs/start > source-map-js",
-                "@solidjs/start > error-stack-parser"
-              ]
-            },
-            cacheDir: "node_modules/.vinxi/server-fns"
-          }),
-          ...(typeof plugins === "function" ? [...(await plugins())] : plugins),
-          serverFunctionServer({
-            runtime: normalize(fileURLToPath(new URL("./server-fns-runtime.ts", import.meta.url)))
-          }),
-          solid({ ...start.solid, ssr: true, extensions: extensions.map(ext => `.${ext}`) }),
-          config("app-server", {
-            resolve: {
-              alias: {
-                "#start/app": join(process.cwd(), start.appRoot, `app${entryExtension}`),
-                "~": join(process.cwd(), start.appRoot),
-                ...(!start.ssr
-                  ? {
-                      "@solidjs/start/server": "@solidjs/start/server/spa"
-                    }
-                  : {}),
-                ...userConfig.resolve?.alias
+        plugins: async () => {
+          const userConfig = typeof vite === "function" ? await vite({ router: "server-function" }) : { ...vite };
+          const plugins = userConfig.plugins || [];
+          delete userConfig.plugins;
+          return [
+            config("user", {
+              ...userConfig,
+              optimizeDeps: {
+                ...(userConfig.optimizeDeps || {}),
+                include: [
+                  ...(userConfig.optimizeDeps?.include || []),
+                  "@solidjs/start > source-map-js",
+                  "@solidjs/start > error-stack-parser"
+                ]
+              },
+              cacheDir: "node_modules/.vinxi/server-fns"
+            }),
+            ...plugins,
+            serverFunctionServer({
+              runtime: normalize(fileURLToPath(new URL("./server-fns-runtime.ts", import.meta.url)))
+            }),
+            solid({ ...start.solid, ssr: true, extensions: extensions.map(ext => `.${ext}`) }),
+            config("app-server", {
+              resolve: {
+                alias: {
+                  "#start/app": join(process.cwd(), start.appRoot, `app${entryExtension}`),
+                  "~": join(process.cwd(), start.appRoot),
+                  ...(!start.ssr
+                    ? {
+                        "@solidjs/start/server": "@solidjs/start/server/spa"
+                      }
+                    : {}),
+                  ...userConfig.resolve?.alias
+                }
+              },
+              define: {
+                "import.meta.env.START_ISLANDS": JSON.stringify(start.islands),
+                "import.meta.env.SSR": JSON.stringify(true),
+                "import.meta.env.START_SSR": JSON.stringify(start.ssr),
+                "import.meta.env.START_DEV_OVERLAY": JSON.stringify(start.devOverlay),
+                ...userConfig.define
               }
-            },
-            define: {
-              "import.meta.env.START_ISLANDS": JSON.stringify(start.islands),
-              "import.meta.env.SSR": JSON.stringify(true),
-              "import.meta.env.START_SSR": JSON.stringify(start.ssr),
-              ...userConfig.define
-            }
-          })
-        ],
-        middleware: start.middleware
+            })
+          ];
+        }
       }
     ]
   });

package/config/server-fns-runtime.ts

@@ -8,7 +8,7 @@ export function createServerReference(fn: Function, id: string, name: string) {
   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)}&name=${encodeURIComponent(name)}`;
       }
       if (prop === "GET") return receiver;
     },

package/config/server-handler.ts

@@ -150,11 +150,17 @@ async function handleServerFunction(h3Event: H3Event) {
     // handle no JS success case
     if (!instance) {
       const isError = result instanceof Error;
-      const refererUrl = new URL(request.headers.get("referer")!);
+      let redirectUrl = new URL(request.headers.get("referer")!).toString();
+      if (result instanceof Response && result.headers.has("Location")) {
+        redirectUrl = new URL(
+          result.headers.get("Location")!,
+          new URL(request.url).origin + import.meta.env.SERVER_BASE_URL
+        ).toString();
+      }
       return new Response(null, {
         status: 302,
         headers: {
-          Location: refererUrl.toString(),
+          Location: redirectUrl,
           ...(result
             ? {
                 "Set-Cookie": `flash=${JSON.stringify({
@@ -172,18 +178,25 @@ async function handleServerFunction(h3Event: H3Event) {
     return serializeToStream(instance, result);
   } catch (x) {
     if (x instanceof Response) {
-      if (x.status === 302 && !instance) setResponseStatus(h3Event, 302);
+      if (singleFlight && instance) {
+        x = await handleSingleFlight(event, x);
+      }
+      if ((x as any).status === 302 && !instance) setResponseStatus(h3Event, 302);
       // forward headers
-      if (x.headers) mergeResponseHeaders(h3Event, x.headers);
+      if ((x as any).headers) mergeResponseHeaders(h3Event, (x as any).headers);
       if ((x as any).customBody) {
         x = (x as any).customBody();
-      } else if (x.body == undefined) x = null;
+      } else if ((x as any).body == undefined) x = null;
+      if (instance) {
+        setHeader(h3Event, "content-type", "text/javascript");
+        return serializeToStream(instance, x);
+      }
     }
     return x;
   }
 }
 
-async function handleSingleFlight(sourceEvent: FetchEvent, result: any) {
+async function handleSingleFlight(sourceEvent: FetchEvent, result: any): Promise<Response> {
   let revalidate: string[];
   let url = new URL(sourceEvent.request.headers.get("referer")!).toString();
   if (result instanceof Response) {

package/config/server-runtime.ts

@@ -190,25 +190,26 @@ export function createServerReference(fn: Function, id: string, name: string) {
   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)}&name=${encodeURIComponent(name)}`;
       }
       if (prop === "GET") {
         return receiver.withOptions({ method: "GET" });
       }
       if (prop === "withOptions") {
+        const url = `${baseURL}/_server/?id=${encodeURIComponent(id)}&name=${encodeURIComponent(name)}`
         return (options: RequestInit) => {
           const fn = (...args: any[]) => {
             const encodeArgs = options.method && options.method.toUpperCase() === "GET";
             return fetchServerFunction(
               encodeArgs
-                ? receiver.url + (args.length ? `&args=${JSON.stringify(args)}` : "")
+                ? url + (args.length ? `&args=${JSON.stringify(args)}` : "")
                 : `${baseURL}/_server`,
               `${id}#${name}`,
               options,
               encodeArgs ? [] : args
             );
           };
-          fn.url = receiver.url;
+          fn.url = url;
           return fn;
         };
       }

package/env.d.ts

@@ -13,11 +13,8 @@ interface ImportMetaEnv extends Record<`VITE_${string}`, any>, SolidStartMetaEnv
 }
 
 interface SolidStartMetaEnv {
-  START_ISLANDS_ROUTER: string;
-  START_INDEX_HTML: string;
-  START_ENTRY_CLIENT: string;
   START_SSR: string;
   START_ISLANDS: string;
-  START_ENTRY_SERVER: string;
-  DEBUG: string;
+  START_DEV_OVERLAY: string;
+  SERVER_BASE_URL: string;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidjs/start",
-  "version": "0.5.9",
+  "version": "0.6.0",
   "type": "module",
   "author": "Ryan Carniato",
   "publishConfig": {
@@ -30,25 +30,25 @@
       ".": [
         "./shared/index.tsx"
       ],
-      "./middleware": [
+      "middleware": [
         "./middleware/index.ts"
       ],
-      "./server": [
+      "server": [
         "./server/index.tsx"
       ],
-      "./client": [
+      "client": [
         "./client/index.tsx"
       ]
     }
   },
   "devDependencies": {
     "solid-js": "^1.8.15",
-    "vinxi": "^0.2.1"
+    "vinxi": "^0.3.4"
   },
   "dependencies": {
-    "@vinxi/plugin-directives": "^0.2.0",
-    "@vinxi/server-components": "^0.2.0",
-    "@vinxi/server-functions": "^0.2.1",
+    "@vinxi/plugin-directives": "^0.3.0",
+    "@vinxi/server-components": "^0.3.0",
+    "@vinxi/server-functions": "^0.3.0",
     "defu": "^6.1.2",
     "error-stack-parser": "^2.1.4",
     "html-to-image": "^1.11.11",

package/server/StartServer.tsx

@@ -32,6 +32,8 @@ function matchRoute(matches: any[], routes: any[], matched = []): any[] | undefi
 
 export function StartServer(props: { document: Component<DocumentComponentProps> }) {
   const context = getRequestEvent() as PageEvent;
+  // @ts-ignore
+  const nonce = context.nonce;
 
   let assets: Asset[] = [];
   Promise.resolve().then(async () => {
@@ -39,15 +41,14 @@ export function StartServer(props: { document: Component<DocumentComponentProps>
     if (context.router && context.router.matches) {
       // @ts-ignore
       const matches = [...context.router.matches];
-      while (matches.length && (!matches[0].info || !matches[0].info.filesystem))
-        matches.shift();
+      while (matches.length && (!matches[0].info || !matches[0].info.filesystem)) matches.shift();
       const matched = matches.length && matchRoute(matches, context.routes);
       if (matched) {
         for (let i = 0; i < matched.length; i++) {
           const segment = matched[i];
           const part = import.meta.env.MANIFEST[import.meta.env.START_ISLANDS ? "ssr" : "client"]!
             .inputs[segment["$component"].src]!;
-          const asset = await part.assets() as any;
+          const asset = (await part.assets()) as any;
           assets.push.apply(assets, asset);
         }
       } else console.warn("No route matched for preloading js assets");
@@ -74,18 +75,37 @@ export function StartServer(props: { document: Component<DocumentComponentProps>
           </>
         }
         scripts={
-          <>
-            <script innerHTML={`window.manifest = ${JSON.stringify(context.manifest)}`} />
-            <script
-              type="module"
-              async
-              src={
-                import.meta.env.MANIFEST["client"]!.inputs[
-                  import.meta.env.MANIFEST["client"]!.handler
-                ]!.output.path
-              }
-            />
-          </>
+          nonce ? (
+            <>
+              <script
+                nonce={nonce}
+                innerHTML={`window.manifest = ${JSON.stringify(context.manifest)}`}
+              />
+              <script
+                type="module"
+                nonce={nonce}
+                async
+                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"
+                async
+                src={
+                  import.meta.env.MANIFEST["client"]!.inputs[
+                    import.meta.env.MANIFEST["client"]!.handler
+                  ]!.output.path
+                }
+              />
+            </>
+          )
         }
       >
         {!import.meta.env.START_ISLANDS ? (

package/server/fetchEvent.ts

@@ -1,6 +1,5 @@
 import {
   H3Event,
-  HTTPEvent,
   HTTPEventSymbol,
   appendResponseHeader,
   getRequestIP,
@@ -45,7 +44,7 @@ export function getFetchEvent(h3Event: H3Event): FetchEvent {
   return (h3Event as any)[fetchEventSymbol];
 }
 
-export function mergeResponseHeaders(h3Event: HTTPEvent, headers: Headers) {
+export function mergeResponseHeaders(h3Event: H3Event, headers: Headers) {
   for (const [key, value] of headers.entries()) {
     setHeader(h3Event, key, value);
   }

package/server/handler.ts

@@ -2,7 +2,6 @@ import { sharedConfig } from "solid-js";
 import { renderToStream, renderToString } from "solid-js/web";
 import { provideRequestEvent } from "solid-js/web/storage";
 import {
-  EventHandlerObject,
   EventHandlerRequest,
   H3Event,
   eventHandler,
@@ -13,27 +12,16 @@ import {
 import { matchAPIRoute } from "../shared/routes";
 import { getFetchEvent } from "./fetchEvent";
 import { createPageEvent } from "./pageEvent";
-import type { APIEvent, FetchEvent, PageEvent } from "./types";
+import type { APIEvent, FetchEvent, HandlerOptions, PageEvent } from "./types";
 
 export function createBaseHandler(
   fn: (context: PageEvent) => unknown,
-  options: {
-    nonce?: string;
-    renderId?: string;
-    timeoutMs?: number;
-    onCompleteAll?: (options: { write: (v: any) => void }) => void;
-    onCompleteShell?: (options: { write: (v: any) => void }) => void;
-    createPageEvent?: (event: FetchEvent) => Promise<PageEvent>;
-    onRequest?: EventHandlerObject["onRequest"];
-    onBeforeResponse?: EventHandlerObject["onBeforeResponse"];
-  } = {}
+  createPageEvent: (event: FetchEvent) => Promise<PageEvent>,
+  options: HandlerOptions | ((context: PageEvent) => HandlerOptions | Promise<HandlerOptions>) = {}
 ) {
   return eventHandler({
-    onRequest: options.onRequest,
-    onBeforeResponse: options.onBeforeResponse,
     handler: (e: H3Event<EventHandlerRequest>) => {
       const event = getFetchEvent(e);
-      const mode = import.meta.env.START_SSR;
 
       return provideRequestEvent(event, async () => {
         // api
@@ -55,7 +43,11 @@ export function createBaseHandler(
 
         // render
         const context = await createPageEvent(event);
-        if (mode === "sync") {
+        if (typeof options === "function") options = await options(context);
+        const mode = options.mode || "stream";
+        // @ts-ignore
+        if (options.nonce) context.nonce = options.nonce;
+        if (mode === "sync" || !import.meta.env.START_SSR) {
           const html = renderToString(() => {
             (sharedConfig.context as any).event = context;
             return fn(context);
@@ -115,7 +107,7 @@ function handleStreamCompleteRedirect(context: PageEvent) {
 
 export function createHandler(
   fn: (context: PageEvent) => unknown,
-  options: Parameters<typeof createBaseHandler>[1] = {}
+  options?: HandlerOptions | ((context: PageEvent) => HandlerOptions | Promise<HandlerOptions>)
 ) {
-  return createBaseHandler(fn, { ...options, createPageEvent });
+  return createBaseHandler(fn, createPageEvent, options);
 }

package/server/spa/StartServer.tsx

@@ -8,29 +8,44 @@ const docType = ssr("<!DOCTYPE html>");
 
 export function StartServer(props: { document: Component<DocumentComponentProps> }) {
   const context = getRequestEvent() as PageEvent;
+  // @ts-ignore
+  const nonce = context.nonce;
   return (
     <NoHydration>
       {docType as unknown as any}
       <props.document
-        assets={
-          <>
-            {context.assets.map((m: any) => renderAsset(m))}
-          </>
-        }
+        assets={<>{context.assets.map((m: any) => renderAsset(m))}</>}
         scripts={
-          <>
-            <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
-              }
-            />
-          </>
+          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>
+      />
     </NoHydration>
   );
 }

package/server/spa/handler.ts

@@ -1,11 +1,11 @@
 import { createBaseHandler } from "../handler";
-import { FetchEvent, PageEvent } from "../types";
+import { FetchEvent, HandlerOptions, PageEvent } from "../types";
 
 export function createHandler(
   fn: (context: PageEvent) => unknown,
-  options?: { nonce?: string; renderId?: string; timeoutMs?: number }
+  options?: HandlerOptions | ((context: PageEvent) => HandlerOptions)
 ) {
-  return createBaseHandler(fn, { ...options, createPageEvent });
+  return createBaseHandler(fn, createPageEvent, options);
 }
 
 export async function createPageEvent(ctx: FetchEvent) {

package/server/types.ts

@@ -22,6 +22,14 @@ export type Asset = {
   attrs: JSX.LinkHTMLAttributes<HTMLLinkElement> & { key?: string };
 };
 
+export type HandlerOptions = {
+  mode?: "sync" | "async" | "stream";
+  nonce?: string;
+  renderId?: string;
+  onCompleteAll?: (options: { write: (v: any) => void }) => void;
+  onCompleteShell?: (options: { write: (v: any) => void }) => void;
+};
+
 export type ContextMatches = {
   originalPath: string;
   pattern: string;

package/shared/ErrorBoundary.tsx

@@ -1,13 +1,22 @@
 import { ErrorBoundary as DefaultErrorBoundary, type ParentProps } from "solid-js";
+import { isServer } from "solid-js/web";
 import { HttpStatusCode } from "./HttpStatusCode";
 import { DevOverlay } from "./dev-overlay";
 
 export function ErrorBoundary(props: ParentProps) {
-  if (import.meta.env.DEV) {
+  if (import.meta.env.DEV && import.meta.env.START_DEV_OVERLAY) {
     return <DevOverlay>{props.children}</DevOverlay>;
   }
+  const message = isServer ? "500 | Internal Server Error" : "Error | Uncaught Client Exception";
   return (
-    <DefaultErrorBoundary fallback={<HttpStatusCode code={500} />}>
+    <DefaultErrorBoundary
+      fallback={
+        <>
+          <span style="font-size:1.5em;text-align:center;position:fixed;left:0px;bottom:55%;width:100%;">{message}</span>
+          <HttpStatusCode code={500} />
+        </>
+      }
+    >
       {props.children}
     </DefaultErrorBoundary>
   );