@solidjs/start 2.0.0-beta.0 → 2.0.0-beta.10

package/dist/fns/handler.js

@@ -1,3 +1,11 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
 import { parseSetCookie } from "cookie-es";
 import { parseCookies } from "h3";
 import { sharedConfig } from "solid-js";
@@ -6,9 +14,9 @@ import { provideRequestEvent } from "solid-js/web/storage";
 import { getFetchEvent, mergeResponseHeaders } from "../server/fetchEvent.js";
 import { createPageEvent } from "../server/handler.js";
 import { deserializeFromJSONString, serializeToJSONStream, serializeToJSStream, } from "./serialization.js";
-import { BODY_FORMAT_KEY, BodyFormat, extractBody, getHeadersAndBody, } from "./shared.js";
+import { BODY_FORMAT_KEY, BodyFormat, extractBody, getHeadersAndBody } from "./shared.js";
 import "solid-start:server-fn-manifest";
-import { getServerFunction } from "./registration.js";
+import { getServerFunction, hasServerFunction } from "./registration.js";
 import { getExpectedRedirectStatus } from "../server/util.js";
 export async function handleServerFunction(h3Event) {
     const event = getFetchEvent(h3Event);
@@ -30,6 +38,23 @@ export async function handleServerFunction(h3Event) {
                 : new Response(null, { status: 404 });
         }
     }
+    if (import.meta.env.DEV && !hasServerFunction(functionId)) {
+        // The module that owns this function has not been evaluated in the server
+        // environment yet (e.g. the route was reached by client-side navigation, so
+        // it was only ever loaded in the browser). Ask the dev server to resolve the
+        // function id back to its owning module and import it, which registers it.
+        // Resolved by the "solid-start:server-functions/preload" plugin.
+        try {
+            // the /@id/ prefix routes the request through the plugin container so the
+            // virtual module can be resolved (bare ids get node-resolved by the runner)
+            await import(__rewriteRelativeImportExtension(
+            /* @vite-ignore */ `/@id/solid-start:server-fn-lookup?id=${encodeURIComponent(functionId)}`, true));
+        }
+        catch (error) {
+            // fall through to getServerFunction, which reports the missing function
+            console.error("[solid-start] server function lookup failed:", error);
+        }
+    }
     const serverFunction = getServerFunction(functionId);
     let parsed = [];
     // grab bound arguments from url when no JS
@@ -119,7 +144,7 @@ export async function handleServerFunction(h3Event) {
         }
         else if (instance) {
             const error = x instanceof Error ? x.message : typeof x === "string" ? x : "true";
-            h3Event.res.headers.set("X-Error", error.replace(/[\r\n]+/g, ""));
+            h3Event.res.headers.set("X-Error", toHeaderValue(error));
         }
         else {
             x = handleNoJS(x, request, parsed, true);
@@ -133,7 +158,7 @@ export async function handleServerFunction(h3Event) {
                     headers.set("X-Error", errorHeader);
                 }
                 return new Response(body.body, {
-                    headers: body.headers,
+                    headers,
                 });
             }
             h3Event.res.headers.set(BODY_FORMAT_KEY, BodyFormat.Seroval);
@@ -147,6 +172,17 @@ export async function handleServerFunction(h3Event) {
         return x;
     }
 }
+// header values must be ByteString-safe (no chars > 0xFF), otherwise Headers.set throws
+function toHeaderValue(value) {
+    const stripped = value.replace(/[\r\n]+/g, "");
+    try {
+        return /[^\x00-\xFF]/.test(stripped) ? encodeURIComponent(stripped) : stripped;
+    }
+    catch {
+        // encodeURIComponent throws on lone surrogates
+        return "true";
+    }
+}
 function handleNoJS(result, request, parsed, thrown) {
     const url = new URL(request.url);
     const isError = result instanceof Error;

package/dist/fns/registration.d.ts

@@ -1,2 +1,3 @@
 export declare function registerServerFunction<T extends any[], R>(id: string, callback: (...args: T) => Promise<R>): (...args: T) => Promise<R>;
-export declare function getServerFunction<T extends any[], R>(id: string): ((...args: T) => Promise<R>);
+export declare function hasServerFunction(id: string): boolean;
+export declare function getServerFunction<T extends any[], R>(id: string): (...args: T) => Promise<R>;

package/dist/fns/registration.js

@@ -3,10 +3,13 @@ export function registerServerFunction(id, callback) {
     REGISTRATIONS.set(id, callback);
     return callback;
 }
+export function hasServerFunction(id) {
+    return REGISTRATIONS.has(id);
+}
 export function getServerFunction(id) {
     const fn = REGISTRATIONS.get(id);
     if (fn) {
         return fn;
     }
-    throw new Error('invalid server function: ' + id);
+    throw new Error("invalid server function: " + id);
 }

package/dist/http/http.d.ts

@@ -0,0 +1,81 @@
+import type { H3Event, HTTPEvent, InferEventInput } from "h3";
+import * as h3 from "h3";
+declare function _setContext(event: H3Event, key: string, value: any): void;
+declare function _getContext(event: H3Event, key: string): unknown;
+export declare function getWebRequest(): Request;
+export declare const HTTPEventSymbol: unique symbol;
+export declare function isEvent(obj: any): obj is h3.H3Event | {
+    [HTTPEventSymbol]: h3.H3Event;
+};
+type Tail<T> = T extends [any, ...infer U] ? U : never;
+type PrependOverload<TOriginal extends (...args: Array<any>) => any, TOverload extends (...args: Array<any>) => any> = TOverload & TOriginal;
+type WrapFunction<TFn extends (...args: Array<any>) => any> = PrependOverload<TFn, (...args: Parameters<TFn> extends [h3.HTTPEvent<any> | h3.H3Event<any>, ...infer TArgs] ? TArgs : Parameters<TFn>) => ReturnType<TFn>>;
+type WrappedReadBody = <T, TEventInput = InferEventInput<"body", H3Event, T>>(...args: Tail<Parameters<typeof h3.readBody<T, H3Event, TEventInput>>>) => ReturnType<typeof h3.readBody<T, h3.H3Event, TEventInput>>;
+export declare const readBody: PrependOverload<typeof h3.readBody, WrappedReadBody>;
+type WrappedGetQuery = <T, TEventInput = Exclude<InferEventInput<"query", H3Event, T>, undefined>>(...args: Tail<Parameters<typeof h3.getQuery<T, H3Event, TEventInput>>>) => ReturnType<typeof h3.getQuery<T, H3Event, TEventInput>>;
+export declare const getQuery: PrependOverload<typeof h3.getQuery, WrappedGetQuery>;
+export declare const isMethod: WrapFunction<typeof h3.isMethod>;
+export declare const isPreflightRequest: WrapFunction<typeof h3.isPreflightRequest>;
+type WrappedGetValidatedQuery = <T extends HTTPEvent, TEventInput = InferEventInput<"query", H3Event, T>>(...args: Tail<Parameters<typeof h3.getValidatedQuery<T, H3Event, TEventInput>>>) => ReturnType<typeof h3.getValidatedQuery<T, H3Event, TEventInput>>;
+export declare const getValidatedQuery: PrependOverload<typeof h3.getValidatedQuery, WrappedGetValidatedQuery>;
+export declare const getRouterParams: WrapFunction<typeof h3.getRouterParams>;
+export declare const getRouterParam: WrapFunction<typeof h3.getRouterParam>;
+type WrappedGetValidatedRouterParams = <T extends HTTPEvent, TEventInput = InferEventInput<"routerParams", H3Event, T>>(...args: Tail<Parameters<typeof h3.getValidatedRouterParams<T, H3Event, TEventInput>>>) => ReturnType<typeof h3.getValidatedRouterParams<T, H3Event, TEventInput>>;
+export declare const getValidatedRouterParams: PrependOverload<typeof h3.getValidatedRouterParams, WrappedGetValidatedRouterParams>;
+export declare const assertMethod: WrapFunction<typeof h3.assertMethod>;
+export declare const getRequestHeaders: WrapFunction<typeof h3.getRequestHeaders>;
+export declare const getRequestHeader: WrapFunction<typeof h3.getRequestHeader>;
+export declare const getRequestURL: WrapFunction<typeof h3.getRequestURL>;
+export declare const getRequestHost: WrapFunction<typeof h3.getRequestHost>;
+export declare const getRequestProtocol: WrapFunction<typeof h3.getRequestProtocol>;
+export declare const getRequestIP: WrapFunction<typeof h3.getRequestIP>;
+export declare const setResponseStatus: (code?: number, text?: string) => void;
+export declare const getResponseStatus: () => number | undefined;
+export declare const getResponseStatusText: () => string | undefined;
+export declare const getResponseHeaders: () => {
+    [k: string]: string;
+};
+export declare const getResponseHeader: (name: string) => string | null;
+export declare const setResponseHeaders: (values: Record<string, string>) => void;
+export declare const setResponseHeader: (name: string, value: string | string[]) => void;
+export declare const appendResponseHeaders: (values: Record<string, string>) => void;
+export declare const appendResponseHeader: (name: string, value: string | string[]) => void;
+export declare const defaultContentType: (type: string) => void;
+export declare const proxyRequest: WrapFunction<typeof h3.proxyRequest>;
+export declare const fetchWithEvent: WrapFunction<typeof h3.fetchWithEvent>;
+export declare const getProxyRequestHeaders: WrapFunction<typeof h3.getProxyRequestHeaders>;
+export declare const parseCookies: WrapFunction<typeof h3.parseCookies>;
+export declare const getCookie: WrapFunction<typeof h3.getCookie>;
+export declare const setCookie: WrapFunction<typeof h3.setCookie>;
+export declare const deleteCookie: WrapFunction<typeof h3.deleteCookie>;
+type SessionDataT = Record<string, any>;
+type WrappedUseSession = <T extends SessionDataT>(...args: Tail<Parameters<typeof h3.useSession<T>>>) => ReturnType<typeof h3.useSession<T>>;
+export declare const useSession: WrappedUseSession;
+type WrappedGetSession = <T extends SessionDataT>(...args: Tail<Parameters<typeof h3.getSession<T>>>) => ReturnType<typeof h3.getSession<T>>;
+export declare const getSession: WrappedGetSession;
+type WrappedUpdateSession = <T extends SessionDataT>(...args: Tail<Parameters<typeof h3.updateSession<T>>>) => ReturnType<typeof h3.updateSession<T>>;
+export declare const updateSession: WrappedUpdateSession;
+type WrappedSealSession = <T extends SessionDataT>(...args: Tail<Parameters<typeof h3.sealSession<T>>>) => ReturnType<typeof h3.sealSession<T>>;
+export declare const sealSession: WrappedSealSession;
+export declare const unsealSession: WrapFunction<typeof h3.unsealSession>;
+export declare const clearSession: WrapFunction<typeof h3.clearSession>;
+export declare const handleCacheHeaders: WrapFunction<typeof h3.handleCacheHeaders>;
+export declare const handleCors: WrapFunction<typeof h3.handleCors>;
+export declare const appendCorsHeaders: WrapFunction<typeof h3.appendCorsHeaders>;
+export declare const appendCorsPreflightHeaders: WrapFunction<typeof h3.appendCorsPreflightHeaders>;
+export declare const appendHeader: typeof appendResponseHeader;
+export declare const appendHeaders: typeof appendResponseHeaders;
+export declare const setHeader: typeof setResponseHeader;
+export declare const setHeaders: typeof setResponseHeaders;
+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<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>;
+export declare const getContext: WrapFunction<typeof _getContext>;
+export declare const setContext: WrapFunction<typeof _setContext>;
+export declare const removeResponseHeader: (name: string) => void;
+export declare const clearResponseHeaders: (headerNames?: string[]) => void;
+export {};

package/dist/http/http.js

@@ -0,0 +1,129 @@
+import * as h3 from "h3";
+import { getRequestEvent } from "solid-js/web";
+function _setContext(event, key, value) {
+    event.context[key] = value;
+}
+function _getContext(event, key) {
+    return event.context[key];
+}
+function getEvent() {
+    return getRequestEvent().nativeEvent;
+}
+export function getWebRequest() {
+    return getEvent().req;
+}
+export const HTTPEventSymbol = Symbol("$HTTPEvent");
+export function isEvent(obj) {
+    return (typeof obj === "object" &&
+        (obj instanceof h3.H3Event ||
+            obj?.[HTTPEventSymbol] instanceof h3.H3Event ||
+            obj?.__is_event__ === true));
+    // Implement logic to check if obj is an H3Event
+}
+function createWrapperFunction(h3Function) {
+    return ((...args) => {
+        const event = args[0];
+        if (!isEvent(event)) {
+            args.unshift(getEvent());
+        }
+        else {
+            args[0] =
+                event instanceof h3.H3Event || event.__is_event__ ? event : event[HTTPEventSymbol];
+        }
+        return h3Function(...args);
+    });
+}
+export const readBody = createWrapperFunction(h3.readBody);
+export const getQuery = createWrapperFunction(h3.getQuery);
+export const isMethod = createWrapperFunction(h3.isMethod);
+export const isPreflightRequest = createWrapperFunction(h3.isPreflightRequest);
+export const getValidatedQuery = createWrapperFunction(h3.getValidatedQuery);
+export const getRouterParams = createWrapperFunction(h3.getRouterParams);
+export const getRouterParam = createWrapperFunction(h3.getRouterParam);
+export const getValidatedRouterParams = createWrapperFunction(h3.getValidatedRouterParams);
+export const assertMethod = createWrapperFunction(h3.assertMethod);
+export const getRequestHeaders = createWrapperFunction(h3.getRequestHeaders);
+export const getRequestHeader = createWrapperFunction(h3.getRequestHeader);
+export const getRequestURL = createWrapperFunction(h3.getRequestURL);
+export const getRequestHost = createWrapperFunction(h3.getRequestHost);
+export const getRequestProtocol = createWrapperFunction(h3.getRequestProtocol);
+export const getRequestIP = createWrapperFunction(h3.getRequestIP);
+export const setResponseStatus = (code, text) => {
+    const e = getEvent();
+    if (e.res.status !== undefined)
+        e.res.status = code;
+    if (e.res.statusText !== undefined)
+        e.res.statusText = text;
+};
+export const getResponseStatus = () => getEvent().res.status;
+export const getResponseStatusText = () => getEvent().res.statusText;
+export const getResponseHeaders = () => Object.fromEntries(getEvent().res.headers.entries());
+export const getResponseHeader = (name) => getEvent().res.headers.get(name);
+export const setResponseHeaders = (values) => {
+    const headers = getEvent().res.headers;
+    for (const [name, value] of Object.entries(values)) {
+        headers.set(name, value);
+    }
+};
+export const setResponseHeader = (name, value) => {
+    const headers = getEvent().res.headers;
+    (Array.isArray(value) ? value : [value]).forEach(value => {
+        headers.set(name, value);
+    });
+};
+export const appendResponseHeaders = (values) => {
+    const headers = getEvent().res.headers;
+    for (const [name, value] of Object.entries(values)) {
+        headers.append(name, value);
+    }
+};
+export const appendResponseHeader = (name, value) => {
+    const headers = getEvent().res.headers;
+    (Array.isArray(value) ? value : [value]).forEach(value => {
+        headers.append(name, value);
+    });
+};
+export const defaultContentType = (type) => getEvent().res.headers.set("content-type", type);
+export const proxyRequest = createWrapperFunction(h3.proxyRequest);
+export const fetchWithEvent = createWrapperFunction(h3.fetchWithEvent);
+export const getProxyRequestHeaders = createWrapperFunction(h3.getProxyRequestHeaders);
+export const parseCookies = createWrapperFunction(h3.parseCookies);
+export const getCookie = createWrapperFunction(h3.getCookie);
+export const setCookie = createWrapperFunction(h3.setCookie);
+export const deleteCookie = createWrapperFunction(h3.deleteCookie);
+export const useSession = createWrapperFunction(h3.useSession);
+export const getSession = createWrapperFunction(h3.getSession);
+export const updateSession = createWrapperFunction(h3.updateSession);
+export const sealSession = createWrapperFunction(h3.sealSession);
+export const unsealSession = createWrapperFunction(h3.unsealSession);
+export const clearSession = createWrapperFunction(h3.clearSession);
+export const handleCacheHeaders = createWrapperFunction(h3.handleCacheHeaders);
+export const handleCors = createWrapperFunction(h3.handleCors);
+export const appendCorsHeaders = createWrapperFunction(h3.appendCorsHeaders);
+export const appendCorsPreflightHeaders = createWrapperFunction(h3.appendCorsPreflightHeaders);
+export const appendHeader = appendResponseHeader;
+export const appendHeaders = appendResponseHeaders;
+export const setHeader = setResponseHeader;
+export const setHeaders = setResponseHeaders;
+export const getHeader = getRequestHeader;
+export const getHeaders = getRequestHeaders;
+export const getRequestFingerprint = createWrapperFunction(h3.getRequestFingerprint);
+export const getRequestWebStream = () => getEvent().req.body;
+export const readFormData = () => getEvent().req.formData();
+export const readValidatedBody = createWrapperFunction(h3.readValidatedBody);
+export const getContext = createWrapperFunction(_getContext);
+export const setContext = createWrapperFunction(_setContext);
+export const removeResponseHeader = (name) => getEvent().res.headers.delete(name);
+export const clearResponseHeaders = (headerNames) => {
+    const headers = getEvent().res.headers;
+    if (headerNames && headerNames.length > 0) {
+        for (const name of headerNames) {
+            headers.delete(name);
+        }
+    }
+    else {
+        for (const name of headers.keys()) {
+            headers.delete(name);
+        }
+    }
+};

package/dist/http/index.d.ts

@@ -1,81 +1,2 @@
-import type { H3Event, HTTPEvent, InferEventInput } from "h3";
-import * as h3 from "h3";
-declare function _setContext(event: H3Event, key: string, value: any): void;
-declare function _getContext(event: H3Event, key: string): unknown;
-export declare function getWebRequest(): Request;
-export declare const HTTPEventSymbol: unique symbol;
-export declare function isEvent(obj: any): obj is h3.H3Event | {
-    [HTTPEventSymbol]: h3.H3Event;
-};
-type Tail<T> = T extends [any, ...infer U] ? U : never;
-type PrependOverload<TOriginal extends (...args: Array<any>) => any, TOverload extends (...args: Array<any>) => any> = TOverload & TOriginal;
-type WrapFunction<TFn extends (...args: Array<any>) => any> = PrependOverload<TFn, (...args: Parameters<TFn> extends [h3.HTTPEvent<any> | h3.H3Event<any>, ...infer TArgs] ? TArgs : Parameters<TFn>) => ReturnType<TFn>>;
-type WrappedReadBody = <T, TEventInput = InferEventInput<"body", H3Event, T>>(...args: Tail<Parameters<typeof h3.readBody<T, H3Event, TEventInput>>>) => ReturnType<typeof h3.readBody<T, h3.H3Event, TEventInput>>;
-export declare const readBody: PrependOverload<typeof h3.readBody, WrappedReadBody>;
-type WrappedGetQuery = <T, TEventInput = Exclude<InferEventInput<"query", H3Event, T>, undefined>>(...args: Tail<Parameters<typeof h3.getQuery<T, H3Event, TEventInput>>>) => ReturnType<typeof h3.getQuery<T, H3Event, TEventInput>>;
-export declare const getQuery: PrependOverload<typeof h3.getQuery, WrappedGetQuery>;
-export declare const isMethod: WrapFunction<typeof h3.isMethod>;
-export declare const isPreflightRequest: WrapFunction<typeof h3.isPreflightRequest>;
-type WrappedGetValidatedQuery = <T extends HTTPEvent, TEventInput = InferEventInput<"query", H3Event, T>>(...args: Tail<Parameters<typeof h3.getValidatedQuery<T, H3Event, TEventInput>>>) => ReturnType<typeof h3.getValidatedQuery<T, H3Event, TEventInput>>;
-export declare const getValidatedQuery: PrependOverload<typeof h3.getValidatedQuery, WrappedGetValidatedQuery>;
-export declare const getRouterParams: WrapFunction<typeof h3.getRouterParams>;
-export declare const getRouterParam: WrapFunction<typeof h3.getRouterParam>;
-type WrappedGetValidatedRouterParams = <T extends HTTPEvent, TEventInput = InferEventInput<"routerParams", H3Event, T>>(...args: Tail<Parameters<typeof h3.getValidatedRouterParams<T, H3Event, TEventInput>>>) => ReturnType<typeof h3.getValidatedRouterParams<T, H3Event, TEventInput>>;
-export declare const getValidatedRouterParams: PrependOverload<typeof h3.getValidatedRouterParams, WrappedGetValidatedRouterParams>;
-export declare const assertMethod: WrapFunction<typeof h3.assertMethod>;
-export declare const getRequestHeaders: WrapFunction<typeof h3.getRequestHeaders>;
-export declare const getRequestHeader: WrapFunction<typeof h3.getRequestHeader>;
-export declare const getRequestURL: WrapFunction<typeof h3.getRequestURL>;
-export declare const getRequestHost: WrapFunction<typeof h3.getRequestHost>;
-export declare const getRequestProtocol: WrapFunction<typeof h3.getRequestProtocol>;
-export declare const getRequestIP: WrapFunction<typeof h3.getRequestIP>;
-export declare const setResponseStatus: (code?: number, text?: string) => void;
-export declare const getResponseStatus: () => number | undefined;
-export declare const getResponseStatusText: () => string | undefined;
-export declare const getResponseHeaders: () => {
-    [k: string]: string;
-};
-export declare const getResponseHeader: (name: string) => string | null;
-export declare const setResponseHeaders: (values: Record<string, string>) => void;
-export declare const setResponseHeader: (name: string, value: string | string[]) => void;
-export declare const appendResponseHeaders: (values: Record<string, string>) => void;
-export declare const appendResponseHeader: (name: string, value: string | string[]) => void;
-export declare const defaultContentType: (type: string) => void;
-export declare const proxyRequest: WrapFunction<typeof h3.proxyRequest>;
-export declare const fetchWithEvent: WrapFunction<typeof h3.fetchWithEvent>;
-export declare const getProxyRequestHeaders: WrapFunction<typeof h3.getProxyRequestHeaders>;
-export declare const parseCookies: WrapFunction<typeof h3.parseCookies>;
-export declare const getCookie: WrapFunction<typeof h3.getCookie>;
-export declare const setCookie: WrapFunction<typeof h3.setCookie>;
-export declare const deleteCookie: WrapFunction<typeof h3.deleteCookie>;
-type SessionDataT = Record<string, any>;
-type WrappedUseSession = <T extends SessionDataT>(...args: Tail<Parameters<typeof h3.useSession<T>>>) => ReturnType<typeof h3.useSession<T>>;
-export declare const useSession: WrappedUseSession;
-type WrappedGetSession = <T extends SessionDataT>(...args: Tail<Parameters<typeof h3.getSession<T>>>) => ReturnType<typeof h3.getSession<T>>;
-export declare const getSession: WrappedGetSession;
-type WrappedUpdateSession = <T extends SessionDataT>(...args: Tail<Parameters<typeof h3.updateSession<T>>>) => ReturnType<typeof h3.updateSession<T>>;
-export declare const updateSession: WrappedUpdateSession;
-type WrappedSealSession = <T extends SessionDataT>(...args: Tail<Parameters<typeof h3.sealSession<T>>>) => ReturnType<typeof h3.sealSession<T>>;
-export declare const sealSession: WrappedSealSession;
-export declare const unsealSession: WrapFunction<typeof h3.unsealSession>;
-export declare const clearSession: WrapFunction<typeof h3.clearSession>;
-export declare const handleCacheHeaders: WrapFunction<typeof h3.handleCacheHeaders>;
-export declare const handleCors: WrapFunction<typeof h3.handleCors>;
-export declare const appendCorsHeaders: WrapFunction<typeof h3.appendCorsHeaders>;
-export declare const appendCorsPreflightHeaders: WrapFunction<typeof h3.appendCorsPreflightHeaders>;
-export declare const appendHeader: (name: string, value: string | string[]) => void;
-export declare const appendHeaders: (values: Record<string, string>) => void;
-export declare const setHeader: (name: string, value: string | string[]) => void;
-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<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>;
-export declare const getContext: WrapFunction<typeof _getContext>;
-export declare const setContext: WrapFunction<typeof _setContext>;
-export declare const removeResponseHeader: (name: string) => void;
-export declare const clearResponseHeaders: (headerNames?: string[]) => void;
-export {};
+import "server-only";
+export * from "./http.ts";

package/dist/http/index.js

@@ -1,129 +1,6 @@
-import * as h3 from "h3";
-import { getRequestEvent } from "solid-js/web";
-function _setContext(event, key, value) {
-    event.context[key] = value;
-}
-function _getContext(event, key) {
-    return event.context[key];
-}
-function getEvent() {
-    return getRequestEvent().nativeEvent;
-}
-export function getWebRequest() {
-    return getEvent().req;
-}
-export const HTTPEventSymbol = Symbol("$HTTPEvent");
-export function isEvent(obj) {
-    return (typeof obj === "object" &&
-        (obj instanceof h3.H3Event ||
-            obj?.[HTTPEventSymbol] instanceof h3.H3Event ||
-            obj?.__is_event__ === true));
-    // Implement logic to check if obj is an H3Event
-}
-function createWrapperFunction(h3Function) {
-    return ((...args) => {
-        const event = args[0];
-        if (!isEvent(event)) {
-            args.unshift(getEvent());
-        }
-        else {
-            args[0] =
-                event instanceof h3.H3Event || event.__is_event__ ? event : event[HTTPEventSymbol];
-        }
-        return h3Function(...args);
-    });
-}
-export const readBody = createWrapperFunction(h3.readBody);
-export const getQuery = createWrapperFunction(h3.getQuery);
-export const isMethod = createWrapperFunction(h3.isMethod);
-export const isPreflightRequest = createWrapperFunction(h3.isPreflightRequest);
-export const getValidatedQuery = createWrapperFunction(h3.getValidatedQuery);
-export const getRouterParams = createWrapperFunction(h3.getRouterParams);
-export const getRouterParam = createWrapperFunction(h3.getRouterParam);
-export const getValidatedRouterParams = createWrapperFunction(h3.getValidatedRouterParams);
-export const assertMethod = createWrapperFunction(h3.assertMethod);
-export const getRequestHeaders = createWrapperFunction(h3.getRequestHeaders);
-export const getRequestHeader = createWrapperFunction(h3.getRequestHeader);
-export const getRequestURL = createWrapperFunction(h3.getRequestURL);
-export const getRequestHost = createWrapperFunction(h3.getRequestHost);
-export const getRequestProtocol = createWrapperFunction(h3.getRequestProtocol);
-export const getRequestIP = createWrapperFunction(h3.getRequestIP);
-export const setResponseStatus = (code, text) => {
-    const e = getEvent();
-    if (e.res.status !== undefined)
-        e.res.status = code;
-    if (e.res.statusText !== undefined)
-        e.res.statusText = text;
-};
-export const getResponseStatus = () => getEvent().res.status;
-export const getResponseStatusText = () => getEvent().res.statusText;
-export const getResponseHeaders = () => Object.fromEntries(getEvent().res.headers.entries());
-export const getResponseHeader = (name) => getEvent().res.headers.get(name);
-export const setResponseHeaders = (values) => {
-    const headers = getEvent().res.headers;
-    for (const [name, value] of Object.entries(values)) {
-        headers.set(name, value);
-    }
-};
-export const setResponseHeader = (name, value) => {
-    const headers = getEvent().res.headers;
-    (Array.isArray(value) ? value : [value]).forEach(value => {
-        headers.set(name, value);
-    });
-};
-export const appendResponseHeaders = (values) => {
-    const headers = getEvent().res.headers;
-    for (const [name, value] of Object.entries(values)) {
-        headers.append(name, value);
-    }
-};
-export const appendResponseHeader = (name, value) => {
-    const headers = getEvent().res.headers;
-    (Array.isArray(value) ? value : [value]).forEach(value => {
-        headers.append(name, value);
-    });
-};
-export const defaultContentType = (type) => getEvent().res.headers.set("content-type", type);
-export const proxyRequest = createWrapperFunction(h3.proxyRequest);
-export const fetchWithEvent = createWrapperFunction(h3.fetchWithEvent);
-export const getProxyRequestHeaders = createWrapperFunction(h3.getProxyRequestHeaders);
-export const parseCookies = createWrapperFunction(h3.parseCookies);
-export const getCookie = createWrapperFunction(h3.getCookie);
-export const setCookie = createWrapperFunction(h3.setCookie);
-export const deleteCookie = createWrapperFunction(h3.deleteCookie);
-export const useSession = createWrapperFunction(h3.useSession);
-export const getSession = createWrapperFunction(h3.getSession);
-export const updateSession = createWrapperFunction(h3.updateSession);
-export const sealSession = createWrapperFunction(h3.sealSession);
-export const unsealSession = createWrapperFunction(h3.unsealSession);
-export const clearSession = createWrapperFunction(h3.clearSession);
-export const handleCacheHeaders = createWrapperFunction(h3.handleCacheHeaders);
-export const handleCors = createWrapperFunction(h3.handleCors);
-export const appendCorsHeaders = createWrapperFunction(h3.appendCorsHeaders);
-export const appendCorsPreflightHeaders = createWrapperFunction(h3.appendCorsPreflightHeaders);
-export const appendHeader = appendResponseHeader;
-export const appendHeaders = appendResponseHeaders;
-export const setHeader = setResponseHeader;
-export const setHeaders = setResponseHeaders;
-export const getHeader = getRequestHeader;
-export const getHeaders = getRequestHeaders;
-export const getRequestFingerprint = createWrapperFunction(h3.getRequestFingerprint);
-export const getRequestWebStream = () => getEvent().req.body;
-export const readFormData = () => getEvent().req.formData();
-export const readValidatedBody = createWrapperFunction(h3.readValidatedBody);
-export const getContext = createWrapperFunction(_getContext);
-export const setContext = createWrapperFunction(_setContext);
-export const removeResponseHeader = (name) => getEvent().res.headers.delete(name);
-export const clearResponseHeaders = (headerNames) => {
-    const headers = getEvent().res.headers;
-    if (headerNames && headerNames.length > 0) {
-        for (const name of headerNames) {
-            headers.delete(name);
-        }
-    }
-    else {
-        for (const name of headers.keys()) {
-            headers.delete(name);
-        }
-    }
-};
+// The public `@solidjs/start/http` entry is server-only: importing it from
+// client-reachable code fails at resolve time (#2068). Internal isomorphic
+// code (e.g. `<HttpHeader>`) imports `./http.ts` directly, since it only
+// touches these helpers behind an `isServer` check.
+import "server-only";
+export * from "./http.js";

package/dist/middleware/index.d.ts

@@ -1,3 +1,4 @@
+import "server-only";
 import type { Middleware } from "h3";
 import type { FetchEvent } from "../server/types.ts";
 /** Function responsible for receiving an observable [operation]{@link Operation} and returning a [result]{@link OperationResult}. */

package/dist/middleware/index.js

@@ -1,4 +1,5 @@
 // @refresh skip
+import "server-only";
 import { getFetchEvent } from "../server/fetchEvent.js";
 function wrapRequestMiddleware(onRequest) {
     return async (h3Event) => {

package/dist/server/StartServer.jsx

@@ -19,7 +19,7 @@ export function StartServer(props) {
       <TopErrorBoundary>
         <props.document assets={<HydrationScript />} scripts={<>
               <PatchVirtualDevStyles nonce={nonce}/>
-              <script type="module" nonce={nonce} async src={getSsrManifest("client").path(import.meta.env.START_CLIENT_ENTRY)}/>
+              <script type="module" nonce={nonce} async src={getSsrManifest("client").path(import.meta.env.START_CLIENT_ENTRY_URL)}/>
             </>}>
           {!import.meta.env.START_ISLANDS ? (<Hydration>
               <ErrorBoundary>

package/dist/server/handler.d.ts

@@ -1,64 +1,6 @@
-import { type H3Event } from "h3/generic";
+import { H3 } from "h3/generic";
 import type { JSX } from "solid-js";
 import type { FetchEvent, HandlerOptions, PageEvent } from "./types.ts";
-export declare function createBaseHandler(createPageEvent: (e: FetchEvent) => Promise<PageEvent>, fn: (context: PageEvent) => JSX.Element, options?: HandlerOptions | ((context: PageEvent) => HandlerOptions | Promise<HandlerOptions>)): {
-    "~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 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 createPageEvent(ctx: FetchEvent): Promise<PageEvent>;