@solidjs/start 2.0.0-beta.7 → 2.0.0-beta.9

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # @solidjs/start
 
+## 2.0.0-beta.9
+
+### Minor Changes
+
+- f3e84ec: Add support for `server-only` and `client-only` modules
+
+### Patch Changes
+
+- a8a2328: fix: mark `@solidjs/start/http` and `@solidjs/start/middleware` as `server-only` so importing them from client-reachable code fails loudly at dev/build time, instead of silently shipping them to the browser where they crashed hydration and broke unrelated actions/forms with no diagnostic (#2068)
+
+## 2.0.0-beta.8
+
+### Patch Changes
+
+- ecc02be: fix: resolve server functions in dev when their route was reached through client-side navigation before its module was evaluated on the server
+- 85b24b2: Use per-environment Vite plugin hook APIs for forward compatibility with Vite 9.
+
 ## 2.0.0-beta.7
 
 ### Patch Changes

package/dist/config/boundary-modules.d.ts

@@ -0,0 +1,14 @@
+import type { Plugin } from "vite";
+/**
+ * Supports `server-only` and `client-only` marker modules (#2162): importing
+ * `server-only` from a client module (or `client-only` from a server module)
+ * fails at resolve time; in the allowed environment the marker resolves to an
+ * empty module.
+ *
+ * Start's own server-only entry points (`@solidjs/start/http`,
+ * `@solidjs/start/middleware`) import `server-only` themselves, so pulling
+ * them into the client bundle fails loudly instead of shipping server code to
+ * the browser, where it crashed hydration and broke unrelated actions/forms
+ * with no diagnostic (https://github.com/solidjs/solid-start/issues/2068).
+ */
+export declare function boundaryModules(): Plugin;

package/dist/config/boundary-modules.js

@@ -0,0 +1,41 @@
+const VIRTUAL_ID = "\0solid-start:boundary-modules:id";
+/**
+ * Supports `server-only` and `client-only` marker modules (#2162): importing
+ * `server-only` from a client module (or `client-only` from a server module)
+ * fails at resolve time; in the allowed environment the marker resolves to an
+ * empty module.
+ *
+ * Start's own server-only entry points (`@solidjs/start/http`,
+ * `@solidjs/start/middleware`) import `server-only` themselves, so pulling
+ * them into the client bundle fails loudly instead of shipping server code to
+ * the browser, where it crashed hydration and broke unrelated actions/forms
+ * with no diagnostic (https://github.com/solidjs/solid-start/issues/2068).
+ */
+export function boundaryModules() {
+    return {
+        name: "solid-start:boundary-modules",
+        enforce: "pre",
+        resolveId(id, importer, { ssr }) {
+            if (id === "server-only") {
+                if (!ssr)
+                    this.error(`Attempt to import 'server-only' in a client module: ${importer}. ` +
+                        `Code that uses this module must run only on the server: mark it with ` +
+                        `"use server", or make sure it is only imported by server code.`);
+            }
+            else if (id === "client-only") {
+                if (ssr)
+                    this.error(`Attempt to import 'client-only' in a server module: ${importer}. ` +
+                        `Code that uses this module must run only in the browser: make sure it ` +
+                        `is only imported by client code (e.g. wrap components with clientOnly()).`);
+            }
+            else {
+                return null;
+            }
+            return VIRTUAL_ID;
+        },
+        load(id) {
+            if (id === VIRTUAL_ID)
+                return "export {}";
+        },
+    };
+}

package/dist/config/env.js

@@ -47,9 +47,10 @@ export function envPlugin(options) {
             }
             return undefined;
         },
-        load(id, opts) {
+        load(id) {
+            const isServer = this.environment.config.consumer === "server";
             if (id === SERVER_ENV) {
-                if (!opts?.ssr) {
+                if (!isServer) {
                     return SERVER_ONLY_MODULE;
                 }
                 const vars = currentOptions.server?.load
@@ -64,13 +65,13 @@ export function envPlugin(options) {
                 return convertObjectToModule(vars);
             }
             if (id === SERVER_RUNTIME_LOADER) {
-                if (!opts?.ssr) {
+                if (!isServer) {
                     return SERVER_ONLY_MODULE;
                 }
                 return runtimeCode;
             }
             if (id === SERVER_RUNTIME_ENV) {
-                if (!opts?.ssr) {
+                if (!isServer) {
                     return SERVER_ONLY_MODULE;
                 }
                 return SERVER_RUNTIME_CODE;

package/dist/config/index.js

@@ -3,6 +3,7 @@ import { globSync } from "node:fs";
 import { extname, isAbsolute, join } from "node:path";
 import solid from "vite-plugin-solid";
 import { serverFunctionsPlugin } from "../directives/index.js";
+import { boundaryModules } from "./boundary-modules.js";
 import { DEFAULT_EXTENSIONS, VIRTUAL_MODULES, VITE_ENVIRONMENTS } from "./constants.js";
 import { devServer } from "./dev-server.js";
 import { envPlugin } from "./env.js";
@@ -185,6 +186,29 @@ export function solidStart(options) {
         }),
         lazy(),
         envPlugin(options?.env),
+        boundaryModules(),
+        {
+            name: "solid-start:boundary-modules",
+            enforce: "pre",
+            resolveId(id, importer, { ssr }) {
+                if (id === "server-only") {
+                    if (!ssr)
+                        this.error(`Attempt to import 'server-only' in a client module: ${importer}`);
+                }
+                else if (id === "client-only") {
+                    if (ssr)
+                        this.error(`Attempt to import 'client-only' in a server module: ${importer}`);
+                }
+                else {
+                    return null;
+                }
+                return "\0solid-start:boundary-modules:id";
+            },
+            load(id) {
+                if (id === "\0solid-start:boundary-modules:id")
+                    return "export {}";
+            },
+        },
         {
             name: "solid-start:virtual-modules",
             async resolveId(id) {

package/dist/directives/index.js

@@ -1,8 +1,14 @@
 import { createFilter, } from "vite";
+import fg from "fast-glob";
 import { compile } from "./compile.js";
+import xxHash32 from "./xxhash32.js";
 const DEFAULT_INCLUDE = "src/**/*.{jsx,tsx,ts,js,mjs,cjs}";
 const DEFAULT_EXCLUDE = "node_modules/**/*.{jsx,tsx,ts,js,mjs,cjs}";
 const DIRECTIVE = "use server";
+// Dev-only virtual module used by fns/handler.ts to lazily resolve a server
+// function id back to its owning module when the function was never evaluated
+// in the server environment (e.g. its route was only client-side navigated to).
+const LOOKUP_ID = "solid-start:server-fn-lookup";
 function createManifest() {
     return {
         server: new Set(),
@@ -63,8 +69,11 @@ function invalidateModule(moduleGraph, path) {
 function invalidateModules(server, result, manifest) {
     if (server) {
         if (result.invalidPreload) {
-            invalidateModule(server.environments.client.moduleGraph, manifest);
-            invalidateModule(server.environments.ssr.moduleGraph, manifest);
+            // Environments are not limited to "client"/"ssr": plugins like nitro
+            // render in their own environment (e.g. "nitro"), so invalidate everywhere.
+            for (const environment of Object.values(server.environments)) {
+                invalidateModule(environment.moduleGraph, manifest);
+            }
         }
     }
 }
@@ -125,24 +134,47 @@ export function serverFunctionsPlugin(options) {
                 if (source === options.manifest) {
                     return { id: options.manifest, moduleSideEffects: true };
                 }
+                if (source.startsWith(LOOKUP_ID)) {
+                    return { id: source, moduleSideEffects: true };
+                }
                 return null;
             },
-            async load(id, opts) {
-                const mode = opts?.ssr ? "server" : "client";
+            async load(id) {
+                const mode = this.environment.config.consumer;
                 if (id === options.manifest) {
                     const current = new Debouncer(() => [...manifest[mode]].map(entry => `import "${entry}";`).join("\n"));
                     preload[mode] = current;
                     const result = await current.promise.reference;
                     return result;
                 }
+                if (id.startsWith(LOOKUP_ID)) {
+                    if (this.environment.mode !== "dev") {
+                        throw new Error(`${LOOKUP_ID} is only available in dev`);
+                    }
+                    const functionId = new URLSearchParams(id.slice(LOOKUP_ID.length + 1)).get("id");
+                    // dev function ids are `${xxHash32(file)}-${count}-${name}`
+                    const hash = functionId?.split("-")[0];
+                    if (!hash)
+                        return "export {};";
+                    // Look through the files already discovered by the transform first;
+                    // fall back to scanning the project so a function is found even when
+                    // the browser kept a chunk from before a dev server restart.
+                    let files = [...manifest.server].filter(file => xxHash32(file).toString(16) === hash);
+                    if (files.length === 0) {
+                        files = fg
+                            .sync(DEFAULT_INCLUDE, { cwd: this.environment.config.root, absolute: true })
+                            .filter(file => filter(file) && xxHash32(file).toString(16) === hash);
+                    }
+                    return files.map(file => `import ${JSON.stringify(file)};`).join("\n") || "export {};";
+                }
                 return null;
             },
         },
         {
             name: "solid-start:server-functions/compiler",
-            enforce: 'pre',
-            async transform(code, fileId, opts) {
-                const mode = opts?.ssr ? "server" : "client";
+            enforce: "pre",
+            async transform(code, fileId) {
+                const mode = this.environment.config.consumer;
                 const [id] = fileId.split("?");
                 if (!filter(id)) {
                     return null;

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

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: 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 {};
+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/shared/HttpHeader.jsx

@@ -1,7 +1,7 @@
 // @refresh skip
 import { onCleanup } from "solid-js";
 import { getRequestEvent, isServer } from "solid-js/web";
-import { appendHeader, setHeader } from "../http/index.js";
+import { appendHeader, setHeader } from "../http/http.js";
 /**
  *
  * Read more: https://docs.solidjs.com/solid-start/reference/server/http-header

package/env.d.ts

@@ -7,3 +7,15 @@ declare namespace App {
     [key: string | symbol]: any;
   }
 }
+
+/**
+ * Import `server-only` to ensure this module is never bundled for the client.
+ * Importing it in a client module will throw a build error.
+ */
+declare module "server-only" {}
+
+/**
+ * Import `client-only` to ensure this module is never bundled for the server.
+ * Importing it in a server module will throw a build error.
+ */
+declare module "client-only" {}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidjs/start",
-  "version": "2.0.0-beta.7",
+  "version": "2.0.0-beta.9",
   "type": "module",
   "files": [
     "dist",
@@ -66,13 +66,14 @@
     "vitest": "^4.1.0"
   },
   "peerDependencies": {
-    "vite": "^8"
+    "vite": "^8 || ^9"
   },
   "scripts": {
     "build": "pnpm validate-imports && tsc && node scripts/build.js",
     "dev": "tsc --watch",
     "test": "vitest",
     "test:ci": "vitest run",
+    "typecheck": "tsc --noEmit",
     "typecheck:dist": "pnpm build && pnpx @arethetypeswrong/cli --pack . --profile esm-only",
     "validate-imports": "node scripts/validate-imports.js"
   }