@solidjs/start 2.0.0-alpha.2 → 2.0.0-alpha.3

package/dist/fns/serialization.js

@@ -0,0 +1,208 @@
+import { crossSerializeStream, deserialize, Feature, fromCrossJSON, getCrossReferenceHeader, toCrossJSONStream, } from "seroval";
+import { AbortSignalPlugin, CustomEventPlugin, DOMExceptionPlugin, EventPlugin, FormDataPlugin, HeadersPlugin, ReadableStreamPlugin, RequestPlugin, ResponsePlugin, URLPlugin, URLSearchParamsPlugin, } from "seroval-plugins/web";
+// TODO(Alexis): if we can, allow providing an option to extend these.
+const DEFAULT_PLUGINS = [
+    AbortSignalPlugin,
+    CustomEventPlugin,
+    DOMExceptionPlugin,
+    EventPlugin,
+    FormDataPlugin,
+    HeadersPlugin,
+    ReadableStreamPlugin,
+    RequestPlugin,
+    ResponsePlugin,
+    URLSearchParamsPlugin,
+    URLPlugin,
+];
+const MAX_SERIALIZATION_DEPTH_LIMIT = 64;
+const DISABLED_FEATURES = Feature.RegExp;
+/**
+ * Alexis:
+ *
+ * A "chunk" is a piece of data emitted by the streaming serializer.
+ * Each chunk is represented by a 32-bit value (encoded in hexadecimal),
+ * followed by the encoded string (8-bit representation). This format
+ * is important so we know how much of the chunk being streamed we
+ * are expecting before parsing the entire string data.
+ *
+ * This is sort of a bootleg "multipart/form-data" except it's bad at
+ * handling File/Blob LOL
+ *
+ * The format is as follows:
+ * ;0xFFFFFFFF;<string data>
+ */
+function createChunk(data) {
+    const encodeData = new TextEncoder().encode(data);
+    const bytes = encodeData.length;
+    const baseHex = bytes.toString(16);
+    const totalHex = "00000000".substring(0, 8 - baseHex.length) + baseHex; // 32-bit
+    const head = new TextEncoder().encode(`;0x${totalHex};`);
+    const chunk = new Uint8Array(12 + bytes);
+    chunk.set(head);
+    chunk.set(encodeData, 12);
+    return chunk;
+}
+export function serializeToJSStream(id, value) {
+    return new ReadableStream({
+        start(controller) {
+            crossSerializeStream(value, {
+                scopeId: id,
+                plugins: DEFAULT_PLUGINS,
+                onSerialize(data, initial) {
+                    controller.enqueue(createChunk(initial ? `(${getCrossReferenceHeader(id)},${data})` : data));
+                },
+                onDone() {
+                    controller.close();
+                },
+                onError(error) {
+                    controller.error(error);
+                },
+            });
+        },
+    });
+}
+export function serializeToJSONStream(value) {
+    return new ReadableStream({
+        start(controller) {
+            toCrossJSONStream(value, {
+                disabledFeatures: DISABLED_FEATURES,
+                depthLimit: MAX_SERIALIZATION_DEPTH_LIMIT,
+                plugins: DEFAULT_PLUGINS,
+                onParse(node) {
+                    controller.enqueue(createChunk(JSON.stringify(node)));
+                },
+                onDone() {
+                    controller.close();
+                },
+                onError(error) {
+                    controller.error(error);
+                },
+            });
+        },
+    });
+}
+class SerovalChunkReader {
+    reader;
+    buffer;
+    done;
+    constructor(stream) {
+        this.reader = stream.getReader();
+        this.buffer = new Uint8Array(0);
+        this.done = false;
+    }
+    async readChunk() {
+        // if there's no chunk, read again
+        const chunk = await this.reader.read();
+        if (!chunk.done) {
+            // repopulate the buffer
+            const newBuffer = new Uint8Array(this.buffer.length + chunk.value.length);
+            newBuffer.set(this.buffer);
+            newBuffer.set(chunk.value, this.buffer.length);
+            this.buffer = newBuffer;
+        }
+        else {
+            this.done = true;
+        }
+    }
+    async next() {
+        // Check if the buffer is empty
+        if (this.buffer.length === 0) {
+            // if we are already done...
+            if (this.done) {
+                return {
+                    done: true,
+                    value: undefined,
+                };
+            }
+            // Otherwise, read a new chunk
+            await this.readChunk();
+            return await this.next();
+        }
+        // Read the "byte header"
+        // The byte header tells us how big the expected data is
+        // so we know how much data we should wait before we
+        // 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.");
+        }
+        // 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
+            // then the chunk is invalid.
+            if (this.done) {
+                throw new Error("Malformed server function stream.");
+            }
+            // Otherwise, we read more chunks
+            await this.readChunk();
+        }
+        // Extract the exact chunk as defined by the byte header
+        const partial = new TextDecoder().decode(this.buffer.subarray(12, 12 + bytes));
+        // The rest goes to the buffer
+        this.buffer = this.buffer.subarray(12 + bytes);
+        // Deserialize the chunk
+        return {
+            done: false,
+            value: partial,
+        };
+    }
+    async drain(interpret) {
+        while (true) {
+            const result = await this.next();
+            if (result.done) {
+                break;
+            }
+            else {
+                interpret(result.value);
+            }
+        }
+    }
+}
+export async function serializeToJSONString(value) {
+    const response = new Response(serializeToJSONStream(value));
+    return await response.text();
+}
+export async function deserializeFromJSONString(json) {
+    const blob = new Response(json);
+    return await deserializeJSONStream(blob);
+}
+export async function deserializeJSONStream(response) {
+    if (!response.body) {
+        throw new Error("missing body");
+    }
+    const reader = new SerovalChunkReader(response.body);
+    const result = await reader.next();
+    if (!result.done) {
+        const refs = new Map();
+        function interpretChunk(chunk) {
+            const value = fromCrossJSON(JSON.parse(chunk), {
+                refs,
+                disabledFeatures: DISABLED_FEATURES,
+                depthLimit: MAX_SERIALIZATION_DEPTH_LIMIT,
+                plugins: DEFAULT_PLUGINS,
+            });
+            return value;
+        }
+        void reader.drain(interpretChunk);
+        return interpretChunk(result.value);
+    }
+    return undefined;
+}
+export async function deserializeJSStream(id, response) {
+    if (!response.body) {
+        throw new Error("missing body");
+    }
+    const reader = new SerovalChunkReader(response.body);
+    const result = await reader.next();
+    if (!result.done) {
+        reader.drain(deserialize).then(() => {
+            // @ts-ignore
+            delete $R[id];
+        }, () => {
+            // no-op
+        });
+        return deserialize(result.value);
+    }
+    return undefined;
+}

package/dist/fns/server.d.ts

@@ -0,0 +1,7 @@
+interface Registration<T extends any[], R> {
+    id: string;
+    fn: (...args: T) => Promise<R>;
+}
+export declare function createServerReference<T extends any[], R>(id: string, fn: (...args: T) => Promise<R>): Registration<T, R>;
+export declare function cloneServerReference<T extends any[], R>({ id, fn }: Registration<T, R>): (...args: T) => Promise<R>;
+export {};

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

@@ -1,6 +1,12 @@
 import { getRequestEvent } from "solid-js/web";
 import { provideRequestEvent } from "solid-js/web/storage";
-export function createServerReference(fn, id) {
+import { registerServerFunction } from "./registration.js";
+export function createServerReference(id, fn) {
+    const registration = { id, fn };
+    registerServerFunction(id, fn);
+    return registration;
+}
+export function cloneServerReference({ id, fn }) {
     if (typeof fn !== "function")
         throw new Error("Export from a 'use server' module must be a function");
     let baseURL = import.meta.env.BASE_URL ?? "/";

package/dist/fns/shared.d.ts

@@ -0,0 +1,17 @@
+export declare const BODY_FORMAT_KEY = "X-Start-Type";
+export declare const BODY_FORMAL_FILE = "__START__";
+export declare const enum BodyFormat {
+    Seroval = "0",
+    String = "1",
+    FormData = "2",
+    URLSearchParams = "3",
+    Blob = "4",
+    File = "5",
+    ArrayBuffer = "6",
+    Uint8Array = "7"
+}
+export declare function getHeadersAndBody(body: any): {
+    headers?: HeadersInit;
+    body: BodyInit;
+} | undefined;
+export declare function extractBody(instance: string, client: boolean, source: Request | Response): Promise<unknown>;

package/dist/fns/shared.js

@@ -0,0 +1,105 @@
+import { deserializeJSONStream, deserializeJSStream } from "./serialization.js";
+export const BODY_FORMAT_KEY = "X-Start-Type";
+export const BODY_FORMAL_FILE = "__START__";
+export var BodyFormat;
+(function (BodyFormat) {
+    BodyFormat["Seroval"] = "0";
+    BodyFormat["String"] = "1";
+    BodyFormat["FormData"] = "2";
+    BodyFormat["URLSearchParams"] = "3";
+    BodyFormat["Blob"] = "4";
+    BodyFormat["File"] = "5";
+    BodyFormat["ArrayBuffer"] = "6";
+    BodyFormat["Uint8Array"] = "7";
+})(BodyFormat || (BodyFormat = {}));
+export function getHeadersAndBody(body) {
+    switch (true) {
+        case typeof body === "string":
+            return {
+                headers: {
+                    "Content-Type": "text/plain",
+                    [BODY_FORMAT_KEY]: BodyFormat.String,
+                },
+                body,
+            };
+        case body instanceof FormData:
+            return {
+                headers: {
+                    [BODY_FORMAT_KEY]: BodyFormat.FormData,
+                },
+                body,
+            };
+        case body instanceof URLSearchParams:
+            return {
+                headers: {
+                    "Content-Type": "application/x-www-form-urlencoded",
+                    [BODY_FORMAT_KEY]: BodyFormat.URLSearchParams,
+                },
+                body,
+            };
+        case body instanceof File: {
+            const formData = new FormData();
+            formData.append(BODY_FORMAL_FILE, body, body.name);
+            return {
+                headers: {
+                    [BODY_FORMAT_KEY]: BodyFormat.File,
+                },
+                body: formData,
+            };
+        }
+        case body instanceof Blob:
+            return {
+                headers: {
+                    [BODY_FORMAT_KEY]: BodyFormat.Blob,
+                },
+                body,
+            };
+        case body instanceof ArrayBuffer:
+            return {
+                headers: {
+                    [BODY_FORMAT_KEY]: BodyFormat.ArrayBuffer,
+                },
+                body,
+            };
+        case body instanceof Uint8Array:
+            return {
+                headers: {
+                    [BODY_FORMAT_KEY]: BodyFormat.Uint8Array,
+                },
+                body: new Uint8Array(body),
+            };
+        default:
+            return undefined;
+    }
+}
+export async function extractBody(instance, client, source) {
+    const contentType = source.headers.get("content-type");
+    const startType = source.headers.get(BODY_FORMAT_KEY);
+    const clone = source.clone();
+    switch (true) {
+        case startType === BodyFormat.Seroval:
+            if (client && import.meta.env.SEROVAL_MODE === "js") {
+                return await deserializeJSStream(instance, clone);
+            }
+            return await deserializeJSONStream(clone);
+        case startType === BodyFormat.String:
+            return await clone.text();
+        case startType === BodyFormat.File: {
+            const formData = await clone.formData();
+            return formData.get(BODY_FORMAL_FILE);
+        }
+        case startType === BodyFormat.FormData:
+        case contentType?.startsWith("multipart/form-data"):
+            return await clone.formData();
+        case startType === BodyFormat.URLSearchParams:
+        case contentType?.startsWith("application/x-www-form-urlencoded"):
+            return new URLSearchParams(await clone.text());
+        case startType === BodyFormat.Blob:
+            return await clone.blob();
+        case startType === BodyFormat.ArrayBuffer:
+            return await clone.arrayBuffer();
+        case startType === BodyFormat.Uint8Array:
+            return new Uint8Array(await clone.arrayBuffer());
+    }
+    return undefined;
+}

package/dist/http/index.d.ts

@@ -70,7 +70,7 @@ export declare const setHeaders: (values: Record<string, string>) => void;
 export declare const getHeader: WrapFunction<typeof h3.getRequestHeader>;
 export declare const getHeaders: WrapFunction<typeof h3.getRequestHeaders>;
 export declare const getRequestFingerprint: WrapFunction<typeof h3.getRequestFingerprint>;
-export declare const getRequestWebStream: () => ReadableStream<Uint8Array<ArrayBufferLike>> | null;
+export declare const getRequestWebStream: () => ReadableStream<Uint8Array<ArrayBuffer>> | null;
 export declare const readFormData: () => Promise<FormData>;
 type WrappedReadValidatedBody = <T extends HTTPEvent, TEventInput = InferEventInput<"body", H3Event, T>>(...args: Tail<Parameters<typeof h3.readValidatedBody<T, H3Event, TEventInput>>>) => ReturnType<typeof h3.readValidatedBody<T, H3Event, TEventInput>>;
 export declare const readValidatedBody: PrependOverload<typeof h3.readValidatedBody, WrappedReadValidatedBody>;

package/dist/middleware/index.d.ts

@@ -13,9 +13,26 @@ export type ResponseMiddleware = (event: FetchEvent, response: ResponseMiddlewar
  * Creates middleware for handling requests and responses.
  *
  * @see https://docs.solidjs.com/solid-start/reference/server/create-middleware
+/**
+ * Creates request/response middlewares via H3.
+ *
+ * Accepts an array of H3 {@link Middleware}
+ *
+ * @tip To run your middleware before response, `await next()` in your function block.
+ *@example
+ * const middleware = createMiddleware([
+ *   async (event, next) => {
+ *     const resp = await next();
+ *     if (resp instanceof Response) return resp;
+ *     return new Response("Not found", { status: 404 });
+ *   },
+ * ]);
+ *
  */
 export declare function createMiddleware(args: {
+    /** @deprecated Use H3 `Middleware` */
     onRequest?: RequestMiddleware | RequestMiddleware[] | undefined;
+    /** @deprecated Use H3 `Middleware` */
     onBeforeResponse?: ResponseMiddleware | ResponseMiddleware[] | undefined;
 } | Middleware[]): Middleware[];
 export {};

package/dist/middleware/index.js

@@ -23,6 +23,21 @@ function wrapResponseMiddleware(onBeforeResponse) {
  * Creates middleware for handling requests and responses.
  *
  * @see https://docs.solidjs.com/solid-start/reference/server/create-middleware
+/**
+ * Creates request/response middlewares via H3.
+ *
+ * Accepts an array of H3 {@link Middleware}
+ *
+ * @tip To run your middleware before response, `await next()` in your function block.
+ *@example
+ * const middleware = createMiddleware([
+ *   async (event, next) => {
+ *     const resp = await next();
+ *     if (resp instanceof Response) return resp;
+ *     return new Response("Not found", { status: 404 });
+ *   },
+ * ]);
+ *
  */
 export function createMiddleware(args) {
     if (Array.isArray(args))

package/dist/server/handler.d.ts

@@ -1,6 +1,64 @@
-import { H3 } from "h3";
+import { type H3Event } from "h3";
 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;
+export declare function createBaseHandler(createPageEvent: (e: FetchEvent) => Promise<PageEvent>, fn: (context: PageEvent) => JSX.Element, options?: HandlerOptions | ((context: PageEvent) => HandlerOptions | Promise<HandlerOptions>)): {
+    "~rou3": import("h3").RouterContext;
+    request(request: import("srvx").ServerRequest | URL | string, options?: RequestInit, context?: import("h3").H3EventContext): Response | Promise<Response>;
+    use(route: string, handler: import("h3").Middleware, opts?: import("h3").MiddlewareOptions): /*elided*/ any;
+    use(handler: import("h3").Middleware, opts?: import("h3").MiddlewareOptions): /*elided*/ any;
+    on(method: import("h3").HTTPMethod | Lowercase<import("h3").HTTPMethod> | "", route: string, handler: import("h3").HTTPHandler, opts?: import("h3").RouteOptions): /*elided*/ any;
+    register(plugin: import("h3").H3Plugin): /*elided*/ any;
+    mount(base: string, input: import("srvx").FetchHandler | {
+        fetch: import("srvx").FetchHandler;
+    } | /*elided*/ any): /*elided*/ any;
+    all(route: string, handler: import("h3").HTTPHandler, opts?: import("h3").RouteOptions): /*elided*/ any;
+    get(route: string, handler: import("h3").HTTPHandler, opts?: import("h3").RouteOptions): /*elided*/ any;
+    post(route: string, handler: import("h3").HTTPHandler, opts?: import("h3").RouteOptions): /*elided*/ any;
+    put(route: string, handler: import("h3").HTTPHandler, opts?: import("h3").RouteOptions): /*elided*/ any;
+    delete(route: string, handler: import("h3").HTTPHandler, opts?: import("h3").RouteOptions): /*elided*/ any;
+    patch(route: string, handler: import("h3").HTTPHandler, opts?: import("h3").RouteOptions): /*elided*/ any;
+    head(route: string, handler: import("h3").HTTPHandler, opts?: import("h3").RouteOptions): /*elided*/ any;
+    options(route: string, handler: import("h3").HTTPHandler, opts?: import("h3").RouteOptions): /*elided*/ any;
+    connect(route: string, handler: import("h3").HTTPHandler, opts?: import("h3").RouteOptions): /*elided*/ any;
+    trace(route: string, handler: import("h3").HTTPHandler, opts?: import("h3").RouteOptions): /*elided*/ any;
+    readonly config: import("h3").H3Config;
+    "~middleware": import("h3").Middleware[];
+    "~routes": import("h3").H3Route[];
+    fetch(_request: import("srvx").ServerRequest): Response | Promise<Response>;
+    handler(event: H3Event): unknown | Promise<unknown>;
+    "~request"(request: import("srvx").ServerRequest, context?: import("h3").H3EventContext): Response | Promise<Response>;
+    "~findRoute"(_event: H3Event): import("h3").MatchedRoute<import("h3").H3Route> | void;
+    "~getMiddleware"(event: H3Event, route: import("h3").MatchedRoute<import("h3").H3Route> | undefined): import("h3").Middleware[];
+    "~addRoute"(_route: import("h3").H3Route): void;
+};
+export declare function createHandler(fn: (context: PageEvent) => JSX.Element, options?: HandlerOptions | ((context: PageEvent) => HandlerOptions | Promise<HandlerOptions>)): {
+    "~rou3": import("h3").RouterContext;
+    request(request: import("srvx").ServerRequest | URL | string, options?: RequestInit, context?: import("h3").H3EventContext): Response | Promise<Response>;
+    use(route: string, handler: import("h3").Middleware, opts?: import("h3").MiddlewareOptions): /*elided*/ any;
+    use(handler: import("h3").Middleware, opts?: import("h3").MiddlewareOptions): /*elided*/ any;
+    on(method: import("h3").HTTPMethod | Lowercase<import("h3").HTTPMethod> | "", route: string, handler: import("h3").HTTPHandler, opts?: import("h3").RouteOptions): /*elided*/ any;
+    register(plugin: import("h3").H3Plugin): /*elided*/ any;
+    mount(base: string, input: import("srvx").FetchHandler | {
+        fetch: import("srvx").FetchHandler;
+    } | /*elided*/ any): /*elided*/ any;
+    all(route: string, handler: import("h3").HTTPHandler, opts?: import("h3").RouteOptions): /*elided*/ any;
+    get(route: string, handler: import("h3").HTTPHandler, opts?: import("h3").RouteOptions): /*elided*/ any;
+    post(route: string, handler: import("h3").HTTPHandler, opts?: import("h3").RouteOptions): /*elided*/ any;
+    put(route: string, handler: import("h3").HTTPHandler, opts?: import("h3").RouteOptions): /*elided*/ any;
+    delete(route: string, handler: import("h3").HTTPHandler, opts?: import("h3").RouteOptions): /*elided*/ any;
+    patch(route: string, handler: import("h3").HTTPHandler, opts?: import("h3").RouteOptions): /*elided*/ any;
+    head(route: string, handler: import("h3").HTTPHandler, opts?: import("h3").RouteOptions): /*elided*/ any;
+    options(route: string, handler: import("h3").HTTPHandler, opts?: import("h3").RouteOptions): /*elided*/ any;
+    connect(route: string, handler: import("h3").HTTPHandler, opts?: import("h3").RouteOptions): /*elided*/ any;
+    trace(route: string, handler: import("h3").HTTPHandler, opts?: import("h3").RouteOptions): /*elided*/ any;
+    readonly config: import("h3").H3Config;
+    "~middleware": import("h3").Middleware[];
+    "~routes": import("h3").H3Route[];
+    fetch(_request: import("srvx").ServerRequest): Response | Promise<Response>;
+    handler(event: H3Event): unknown | Promise<unknown>;
+    "~request"(request: import("srvx").ServerRequest, context?: import("h3").H3EventContext): Response | Promise<Response>;
+    "~findRoute"(_event: H3Event): import("h3").MatchedRoute<import("h3").H3Route> | void;
+    "~getMiddleware"(event: H3Event, route: import("h3").MatchedRoute<import("h3").H3Route> | undefined): import("h3").Middleware[];
+    "~addRoute"(_route: import("h3").H3Route): void;
+};
 export declare function createPageEvent(ctx: FetchEvent): Promise<PageEvent>;

package/dist/server/handler.js

@@ -6,7 +6,7 @@ import { createRoutes } from "../router.jsx";
 import { decorateHandler, decorateMiddleware } from "./fetchEvent.js";
 import { getSsrManifest } from "./manifest/ssr-manifest.js";
 import { matchAPIRoute } from "./routes.js";
-import { handleServerFunction } from "./server-functions-handler.js";
+import { handleServerFunction } from "../fns/handler.js";
 import { getExpectedRedirectStatus } from "./util.js";
 const SERVER_FN_BASE = "/_server";
 export function createBaseHandler(createPageEvent, fn, options = {}) {
@@ -28,20 +28,22 @@ export function createBaseHandler(createPageEvent, fn, options = {}) {
             if (match) {
                 const mod = await match.handler.import();
                 const fn = event.request.method === "HEAD" ? mod["HEAD"] || mod["GET"] : mod[event.request.method];
-                event.params = match.params || {};
-                // @ts-expect-error
-                sharedConfig.context = { event };
-                const res = await fn(event);
-                if (res !== undefined) {
-                    if (res instanceof Response)
-                        return produceResponseWithEventHeaders(res);
-                    return res;
+                if (typeof fn === "function") {
+                    event.params = match.params || {};
+                    // @ts-expect-error
+                    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") {
+                        throw new Error(`API handler for ${event.request.method} "${event.request.url}" did not return a response.`);
+                    }
+                    if (!match.isPage)
+                        return;
                 }
-                if (event.request.method !== "GET") {
-                    throw new Error(`API handler for ${event.request.method} "${event.request.url}" did not return a response.`);
-                }
-                if (!match.isPage)
-                    return;
             }
             const context = await createPageEvent(event);
             const resolvedOptions = typeof options === "function" ? await options(context) : { ...options };
@@ -178,7 +180,7 @@ function handleStreamCompleteRedirect(context) {
     return ({ write }) => {
         context.complete = true;
         const to = context.response && context.response.headers.get("Location");
-        to && write(`<script>window.location="${to}"</script>`);
+        to && write(`<script>window.location=${JSON.stringify(to).replace(/</g, "\\u003c")}</script>`);
     };
 }
 function produceResponseWithEventHeaders(res) {

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

@@ -4,4 +4,33 @@ 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) => JSX.Element, options?: HandlerOptions | ((context: PageEvent) => HandlerOptions)): import("h3").H3;
+export declare function createHandler(fn: (context: PageEvent) => JSX.Element, options?: HandlerOptions | ((context: PageEvent) => HandlerOptions)): {
+    "~rou3": import("h3").RouterContext;
+    request(request: import("srvx").ServerRequest | URL | string, options?: RequestInit, context?: import("h3").H3EventContext): Response | Promise<Response>;
+    use(route: string, handler: import("h3").Middleware, opts?: import("h3").MiddlewareOptions): /*elided*/ any;
+    use(handler: import("h3").Middleware, opts?: import("h3").MiddlewareOptions): /*elided*/ any;
+    on(method: import("h3").HTTPMethod | Lowercase<import("h3").HTTPMethod> | "", route: string, handler: import("h3").HTTPHandler, opts?: import("h3").RouteOptions): /*elided*/ any;
+    register(plugin: import("h3").H3Plugin): /*elided*/ any;
+    mount(base: string, input: import("srvx").FetchHandler | {
+        fetch: import("srvx").FetchHandler;
+    } | /*elided*/ any): /*elided*/ any;
+    all(route: string, handler: import("h3").HTTPHandler, opts?: import("h3").RouteOptions): /*elided*/ any;
+    get(route: string, handler: import("h3").HTTPHandler, opts?: import("h3").RouteOptions): /*elided*/ any;
+    post(route: string, handler: import("h3").HTTPHandler, opts?: import("h3").RouteOptions): /*elided*/ any;
+    put(route: string, handler: import("h3").HTTPHandler, opts?: import("h3").RouteOptions): /*elided*/ any;
+    delete(route: string, handler: import("h3").HTTPHandler, opts?: import("h3").RouteOptions): /*elided*/ any;
+    patch(route: string, handler: import("h3").HTTPHandler, opts?: import("h3").RouteOptions): /*elided*/ any;
+    head(route: string, handler: import("h3").HTTPHandler, opts?: import("h3").RouteOptions): /*elided*/ any;
+    options(route: string, handler: import("h3").HTTPHandler, opts?: import("h3").RouteOptions): /*elided*/ any;
+    connect(route: string, handler: import("h3").HTTPHandler, opts?: import("h3").RouteOptions): /*elided*/ any;
+    trace(route: string, handler: import("h3").HTTPHandler, opts?: import("h3").RouteOptions): /*elided*/ any;
+    readonly config: import("h3").H3Config;
+    "~middleware": import("h3").Middleware[];
+    "~routes": import("h3").H3Route[];
+    fetch(_request: import("srvx").ServerRequest): Response | Promise<Response>;
+    handler(event: import("h3").H3Event): unknown | Promise<unknown>;
+    "~request"(request: import("srvx").ServerRequest, context?: import("h3").H3EventContext): Response | Promise<Response>;
+    "~findRoute"(_event: import("h3").H3Event): import("h3").MatchedRoute<import("h3").H3Route> | void;
+    "~getMiddleware"(event: import("h3").H3Event, route: import("h3").MatchedRoute<import("h3").H3Route> | undefined): import("h3").Middleware[];
+    "~addRoute"(_route: import("h3").H3Route): void;
+};

package/dist/server/types.d.ts

@@ -64,7 +64,7 @@ export interface APIEvent extends FetchEvent {
         [key: string]: string;
     };
 }
-export type APIHandler = (event: APIEvent) => Promise<any>;
+export type APIHandler = (event: APIEvent) => any;
 export interface ServerFunctionMeta {
     id: string;
 }

package/dist/shared/dev-overlay/CodeView.jsx

@@ -1,13 +1,13 @@
 // @refresh skip
 import { getSingletonHighlighter } from "shiki";
 import { loadWasm } from "shiki/engine/oniguruma";
-import { createEffect, createResource } from "solid-js";
-import url from "shiki/onig.wasm?url";
 import langJS from "shiki/langs/javascript.mjs";
 import langJSX from "shiki/langs/jsx.mjs";
 import langTSX from "shiki/langs/tsx.mjs";
 import langTS from "shiki/langs/typescript.mjs";
+import url from "shiki/onig.wasm?url";
 import darkPlus from "shiki/themes/dark-plus.mjs";
+import { createEffect, createResource } from "solid-js";
 let HIGHLIGHTER;
 async function loadHighlighter() {
     if (!HIGHLIGHTER) {
@@ -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.classList.add("dev-overlay-error-line");
+                    el.dataset.startDevOverlayErrorLine = '';
                 }
             }
         }
     });
-    return (<div ref={ref} class="dev-overlay-code-view" style={{
+    return (<div ref={ref} data-start-dev-overlay-code-view style={{
             "--dev-overlay-code-view-start": minLine() + 1,
         }}/>);
 }