@solidjs/start 1.1.7 → 2.0.0-alpha.0

package/dist/config/index.js

@@ -0,0 +1,217 @@
+import { TanStackServerFnPlugin } from "@tanstack/server-functions-plugin";
+import { defu } from "defu";
+import { globSync } from "node:fs";
+import { extname, isAbsolute, join, normalize } from "node:path";
+import { fileURLToPath } from "node:url";
+import solid from "vite-plugin-solid";
+import { DEFAULT_EXTENSIONS, VIRTUAL_MODULES, VITE_ENVIRONMENTS } from "./constants.js";
+import { devServer } from "./dev-server.js";
+import { SolidStartClientFileRouter, SolidStartServerFileRouter } from "./fs-router.js";
+import { fsRoutes } from "./fs-routes/index.js";
+import lazy from "./lazy.js";
+import { manifest } from "./manifest.js";
+import { parseIdQuery } from "./utils.js";
+const absolute = (path, root) => path ? (isAbsolute(path) ? path : join(root, path)) : path;
+export function solidStart(options) {
+    const start = defu(options ?? {}, {
+        appRoot: "./src",
+        routeDir: "./routes",
+        ssr: true,
+        devOverlay: true,
+        experimental: {
+            islands: false
+        },
+        solid: {},
+        extensions: []
+    });
+    const extensions = [...DEFAULT_EXTENSIONS, ...(start.extensions || [])];
+    const routeDir = join(start.appRoot, start.routeDir);
+    const root = process.cwd();
+    const appEntryPath = globSync(join(root, start.appRoot, "app.{j,t}sx"))[0];
+    if (!appEntryPath) {
+        throw new Error(`Could not find an app jsx/tsx entry in ${start.appRoot}.`);
+    }
+    const entryExtension = extname(appEntryPath);
+    const handlers = {
+        client: `${start.appRoot}/entry-client${entryExtension}`,
+        server: `${start.appRoot}/entry-server${entryExtension}`
+    };
+    return [
+        {
+            name: "solid-start:config",
+            enforce: "pre",
+            configEnvironment(name) {
+                return {
+                    define: {
+                        "import.meta.env.SSR": JSON.stringify(name === VITE_ENVIRONMENTS.server)
+                    },
+                    resolve: {
+                        // remove when https://github.com/solidjs/vite-plugin-solid/pull/228 is released
+                        externalConditions: ["solid", "node"]
+                    }
+                };
+            },
+            async config(_, env) {
+                const clientInput = [handlers.client];
+                if (env.command === "build") {
+                    const clientRouter = globalThis.ROUTERS.client;
+                    for (const route of await clientRouter.getRoutes()) {
+                        for (const [key, value] of Object.entries(route)) {
+                            if (value && key.startsWith("$") && !key.startsWith("$$")) {
+                                function toRouteId(route) {
+                                    return `${route.src}?${route.pick.map((p) => `pick=${p}`).join("&")}`;
+                                }
+                                clientInput.push(toRouteId(value));
+                            }
+                        }
+                    }
+                }
+                return {
+                    appType: "custom",
+                    build: { assetsDir: "_build/assets" },
+                    environments: {
+                        [VITE_ENVIRONMENTS.client]: {
+                            consumer: "client",
+                            build: {
+                                write: true,
+                                manifest: true,
+                                outDir: "dist/client",
+                                rollupOptions: {
+                                    input: clientInput,
+                                    treeshake: true,
+                                    preserveEntrySignatures: "exports-only"
+                                }
+                            }
+                        },
+                        [VITE_ENVIRONMENTS.server]: {
+                            consumer: "server",
+                            build: {
+                                ssr: true,
+                                write: true,
+                                manifest: true,
+                                copyPublicDir: false,
+                                rollupOptions: {
+                                    input: "~/entry-server.tsx"
+                                },
+                                outDir: "dist/server",
+                                commonjsOptions: {
+                                    include: [/node_modules/]
+                                }
+                            }
+                        }
+                    },
+                    resolve: {
+                        alias: {
+                            "@solidjs/start/server/entry": handlers.server,
+                            "~": join(process.cwd(), start.appRoot),
+                            ...(!start.ssr
+                                ? {
+                                    "@solidjs/start/server": "@solidjs/start/server/spa",
+                                    "@solidjs/start/client": "@solidjs/start/client/spa"
+                                }
+                                : {})
+                        }
+                    },
+                    define: {
+                        "import.meta.env.MANIFEST": `globalThis.MANIFEST`,
+                        "import.meta.env.START_SSR": JSON.stringify(start.ssr),
+                        "import.meta.env.START_APP_ENTRY": `"${appEntryPath}"`,
+                        "import.meta.env.START_CLIENT_ENTRY": `"${handlers.client}"`,
+                        "import.meta.env.START_DEV_OVERLAY": JSON.stringify(start.devOverlay)
+                    },
+                    builder: {
+                        sharedPlugins: true,
+                        async buildApp(builder) {
+                            const client = builder.environments[VITE_ENVIRONMENTS.client];
+                            const server = builder.environments[VITE_ENVIRONMENTS.server];
+                            if (!client)
+                                throw new Error("Client environment not found");
+                            if (!server)
+                                throw new Error("SSR environment not found");
+                            if (!client.isBuilt)
+                                await builder.build(client);
+                            if (!server.isBuilt)
+                                await builder.build(server);
+                        }
+                    }
+                };
+            }
+        },
+        manifest(start),
+        fsRoutes({
+            routers: {
+                client: new SolidStartClientFileRouter({
+                    dir: absolute(routeDir, root),
+                    extensions
+                }),
+                ssr: new SolidStartServerFileRouter({
+                    dir: absolute(routeDir, root),
+                    extensions,
+                    dataOnly: !start.ssr
+                })
+            }
+        }),
+        lazy(),
+        // Must be placed after fsRoutes, as treeShake will remove the
+        // server fn exports added in by this plugin
+        TanStackServerFnPlugin({
+            // This is the ID that will be available to look up and import
+            // our server function manifest and resolve its module
+            manifestVirtualImportId: VIRTUAL_MODULES.serverFnManifest,
+            directive: "use server",
+            callers: [
+                {
+                    envConsumer: "client",
+                    envName: VITE_ENVIRONMENTS.client,
+                    getRuntimeCode: () => `import { createServerReference } from "${normalize(fileURLToPath(new URL("../server/server-runtime", import.meta.url)))}"`,
+                    replacer: opts => `createServerReference('${opts.functionId}')`
+                },
+                {
+                    envConsumer: "server",
+                    envName: VITE_ENVIRONMENTS.server,
+                    getRuntimeCode: () => `import { createServerReference } from '${normalize(fileURLToPath(new URL("../server/server-fns-runtime", import.meta.url)))}'`,
+                    replacer: opts => `createServerReference(${opts.fn}, '${opts.functionId}')`
+                }
+            ],
+            provider: {
+                envName: VITE_ENVIRONMENTS.server,
+                getRuntimeCode: () => `import { createServerReference } from '${normalize(fileURLToPath(new URL("../server/server-fns-runtime", import.meta.url)))}'`,
+                replacer: opts => `createServerReference(${opts.fn}, '${opts.functionId}')`
+            }
+        }),
+        {
+            name: "solid-start:virtual-modules",
+            async resolveId(id) {
+                const { filename, query } = parseIdQuery(id);
+                let base;
+                if (filename === VIRTUAL_MODULES.clientEntry)
+                    base = handlers.client;
+                if (filename === VIRTUAL_MODULES.serverEntry)
+                    base = handlers.server;
+                if (filename === VIRTUAL_MODULES.app)
+                    base = appEntryPath;
+                if (base) {
+                    let id = (await this.resolve(base))?.id;
+                    if (!id)
+                        return;
+                    if (query.size > 0)
+                        id += `?${query.toString()}`;
+                    return id;
+                }
+            }
+        },
+        {
+            name: "solid-start:capture-client-bundle",
+            enforce: "post",
+            generateBundle(_options, bundle) {
+                globalThis.START_CLIENT_BUNDLE = bundle;
+            }
+        },
+        devServer(),
+        solid({
+            ...start.solid,
+            ssr: true,
+            extensions: extensions.map(ext => `.${ext}`)
+        })
+    ];
+}

package/dist/config/lazy.d.ts

@@ -0,0 +1,3 @@
+import type { PluginOption } from "vite";
+declare const lazy: () => PluginOption;
+export default lazy;

package/dist/config/lazy.js

@@ -0,0 +1,82 @@
+import babel from "@babel/core";
+import * as t from "@babel/types";
+import { sep as osSep } from "path";
+import { basename, relative, sep } from "path/posix";
+import { VITE_ENVIRONMENTS } from "./constants.js";
+const idTransform = (id) => {
+    return {
+        visitor: {
+            Program(path) {
+                path.node.body.unshift(t.exportNamedDeclaration(t.variableDeclaration("const", [
+                    t.variableDeclarator(t.identifier("id$$"), t.stringLiteral(id))
+                ])));
+            }
+        }
+    };
+};
+const importTransform = () => {
+    return {
+        visitor: {
+            ImportDeclaration(path) {
+                if (path.node.source.value !== "solid-js")
+                    return;
+                path.traverse({
+                    ImportSpecifier(subPath) {
+                        if (subPath.node.local.name !== "lazy")
+                            return;
+                        subPath.remove();
+                        path.insertAfter(t.importDeclaration([t.importSpecifier(t.identifier("lazy"), t.identifier("lazy"))], t.stringLiteral("@solidjs/start/server")));
+                    }
+                });
+            }
+        }
+    };
+};
+const fileEndingRegex = /(ts|js)x(\?.*)?$/;
+const lazy = () => {
+    const cwd = process.cwd().replaceAll(osSep, sep);
+    return {
+        name: "solid-lazy-css",
+        enforce: "pre",
+        applyToEnvironment(env) {
+            return env.name === VITE_ENVIRONMENTS.server;
+        },
+        async transform(src, id) {
+            if (!id.match(fileEndingRegex))
+                return;
+            // The transformed files either import "lazy" or css files
+            // Therefore we skip, if the src doesn't have any import
+            if (src.indexOf("import") === -1)
+                return;
+            const plugins = [];
+            const hasDefaultExport = src.indexOf("export default") !== -1;
+            if (hasDefaultExport) {
+                const localId = relative(cwd, id);
+                plugins.push(idTransform(localId));
+            }
+            const hasLazy = src.indexOf("lazy(") !== -1;
+            if (hasLazy)
+                plugins.push(importTransform());
+            if (!plugins.length) {
+                return;
+            }
+            const transformed = await babel.transformAsync(src, {
+                plugins,
+                parserOpts: {
+                    plugins: ["jsx", "typescript"]
+                },
+                filename: basename(id),
+                ast: false,
+                sourceMaps: true,
+                configFile: false,
+                babelrc: false,
+                sourceFileName: id
+            });
+            if (!transformed?.code)
+                return;
+            const { code, map } = transformed;
+            return { code, map };
+        }
+    };
+};
+export default lazy;

package/dist/config/manifest.d.ts

@@ -0,0 +1,3 @@
+import { type PluginOption } from "vite";
+import { type SolidStartOptions } from "./index.ts";
+export declare function manifest(start: SolidStartOptions): PluginOption;

package/dist/config/manifest.js

@@ -0,0 +1,74 @@
+import { findStylesInModuleGraph } from "../server/collect-styles.js";
+import { VIRTUAL_MODULES } from "./constants.js";
+export function manifest(start) {
+    let devServer = undefined;
+    return {
+        name: "solid-start:manifest-plugin",
+        enforce: "pre",
+        configureServer(server) {
+            devServer = server;
+        },
+        async resolveId(id) {
+            if (id === VIRTUAL_MODULES.clientViteManifest)
+                return `\0${VIRTUAL_MODULES.clientViteManifest}`;
+            if (id === VIRTUAL_MODULES.getClientManifest)
+                return this.resolve(new URL("../server/manifest/client-manifest", import.meta.url).pathname);
+            if (id === VIRTUAL_MODULES.getManifest) {
+                return this.environment.config.consumer === "client"
+                    ? this.resolve(new URL("../server/manifest/client-manifest", import.meta.url).pathname)
+                    : this.resolve(new URL("../server/manifest/ssr-manifest", import.meta.url).pathname);
+            }
+            if (id === VIRTUAL_MODULES.middleware) {
+                if (start.middleware)
+                    return await this.resolve(start.middleware);
+                return `\0${VIRTUAL_MODULES.middleware}`;
+            }
+        },
+        async load(id) {
+            if (id === `\0${VIRTUAL_MODULES.clientViteManifest}`) {
+                let clientViteManifest;
+                if (this.environment.config.command === "serve") {
+                    clientViteManifest = {};
+                }
+                else {
+                    const entry = Object.values(globalThis.START_CLIENT_BUNDLE).find(v => "isEntry" in v && v.isEntry);
+                    if (!entry)
+                        throw new Error("No client entry found");
+                    clientViteManifest = JSON.parse(globalThis.START_CLIENT_BUNDLE[".vite/manifest.json"].source);
+                }
+                return `export const clientViteManifest = ${JSON.stringify(clientViteManifest)};`;
+            }
+            else if (id === `\0${VIRTUAL_MODULES.middleware}`)
+                return "export default {};";
+            else if (id.startsWith("/@manifest")) {
+                if (this.environment.mode !== "dev")
+                    throw new Error("@manifest queries are only allowed in dev");
+                const [path, query] = id.split("?");
+                const target = id.split("/")[2];
+                const params = new URLSearchParams(query);
+                if (!path || !query)
+                    return;
+                if (path.endsWith("assets")) {
+                    const id = params.get("id");
+                    if (!id) {
+                        throw new Error("Missing id to get assets.");
+                    }
+                    // Client env does not have css dependencies in mod.transformResult
+                    // Aalways use ssr env instead, to prevent hydration mismatches
+                    const env = devServer.environments["ssr"];
+                    const styles = await findStylesInModuleGraph(env, id);
+                    const cssAssets = Object.entries(styles).map(([key, value]) => `{
+						tag: "style",
+						attrs: {
+							type: "text/css",
+							"data-vite-dev-id": "${key}",
+							"data-vite-ref": "0",
+						},
+						children: () => import("${value}?inline").then(mod => mod.default),
+					}`);
+                    return `export default [${cssAssets.join(",")}]`;
+                }
+            }
+        }
+    };
+}

package/dist/config/utils.d.ts

@@ -0,0 +1,4 @@
+export declare function parseIdQuery(id: string): {
+    filename: string;
+    query: URLSearchParams;
+};

package/dist/config/utils.js

@@ -0,0 +1,6 @@
+export function parseIdQuery(id) {
+    if (!id.includes("?"))
+        return { filename: id, query: new URLSearchParams() };
+    const [filename, rawQuery] = id.split(`?`, 2);
+    return { filename, query: new URLSearchParams(rawQuery) };
+}

package/dist/config/vite-utils.d.ts

@@ -0,0 +1,16 @@
+import { DevEnvironment, Rollup } from "vite";
+export declare function cleanUrl(url: string): string;
+export declare const FS_PREFIX = "/@fs/";
+export declare const VALID_ID_PREFIX = "/@id/";
+export declare const NULL_BYTE_PLACEHOLDER = "__x00__";
+export declare function normalizeResolvedIdToUrl(environment: DevEnvironment, url: string, resolved: Rollup.PartialResolvedId): string;
+export declare function wrapId(id: string): string;
+export declare function unwrapId(id: string): string;
+export declare function normalizeViteImportAnalysisUrl(environment: DevEnvironment, id: string): string;
+export declare function withTrailingSlash(path: string): string;
+export declare function splitFileAndPostfix(path: string): {
+    file: string;
+    postfix: string;
+};
+export declare function slash(p: string): string;
+export declare function injectQuery(url: string, queryToInject: string): string;

package/dist/config/vite-utils.js

@@ -0,0 +1,81 @@
+import fs from "node:fs";
+import path from "node:path";
+const postfixRE = /[?#].*$/;
+export function cleanUrl(url) {
+    return url.replace(postfixRE, "");
+}
+export const FS_PREFIX = `/@fs/`;
+export const VALID_ID_PREFIX = `/@id/`;
+export const NULL_BYTE_PLACEHOLDER = `__x00__`;
+export function normalizeResolvedIdToUrl(environment, url, resolved) {
+    const root = environment.config.root;
+    const depsOptimizer = environment.depsOptimizer;
+    // normalize all imports into resolved URLs
+    // e.g. `import 'foo'` -> `import '/@fs/.../node_modules/foo/index.js'`
+    if (resolved.id.startsWith(withTrailingSlash(root))) {
+        // in root: infer short absolute path from root
+        url = resolved.id.slice(root.length);
+    }
+    else if (depsOptimizer?.isOptimizedDepFile(resolved.id) ||
+        // vite-plugin-react isn't following the leading \0 virtual module convention.
+        // This is a temporary hack to avoid expensive fs checks for React apps.
+        // We'll remove this as soon we're able to fix the react plugins.
+        (resolved.id !== "/@react-refresh" &&
+            path.isAbsolute(resolved.id) &&
+            fs.existsSync(cleanUrl(resolved.id)))) {
+        // an optimized deps may not yet exists in the filesystem, or
+        // a regular file exists but is out of root: rewrite to absolute /@fs/ paths
+        url = path.posix.join(FS_PREFIX, resolved.id);
+    }
+    else {
+        url = resolved.id;
+    }
+    // if the resolved id is not a valid browser import specifier,
+    // prefix it to make it valid. We will strip this before feeding it
+    // back into the transform pipeline
+    if (url[0] !== "." && url[0] !== "/") {
+        url = wrapId(resolved.id);
+    }
+    return url;
+}
+export function wrapId(id) {
+    return id.startsWith(VALID_ID_PREFIX)
+        ? id
+        : VALID_ID_PREFIX + id.replace("\0", NULL_BYTE_PLACEHOLDER);
+}
+export function unwrapId(id) {
+    return id.startsWith(VALID_ID_PREFIX)
+        ? id.slice(VALID_ID_PREFIX.length).replace(NULL_BYTE_PLACEHOLDER, "\0")
+        : id;
+}
+export function normalizeViteImportAnalysisUrl(environment, id) {
+    let url = normalizeResolvedIdToUrl(environment, id, { id });
+    // https://github.com/vitejs/vite/blob/c18ce868c4d70873406e9f7d1b2d0a03264d2168/packages/vite/src/node/plugins/importAnalysis.ts#L416
+    if (environment.config.consumer === "client") {
+        const mod = environment.moduleGraph.getModuleById(id);
+        if (mod && mod.lastHMRTimestamp > 0) {
+            url = injectQuery(url, `t=${mod.lastHMRTimestamp}`);
+        }
+    }
+    return url;
+}
+export function withTrailingSlash(path) {
+    if (path[path.length - 1] !== "/") {
+        return `${path}/`;
+    }
+    return path;
+}
+export function splitFileAndPostfix(path) {
+    const file = cleanUrl(path);
+    return { file, postfix: path.slice(file.length) };
+}
+const windowsSlashRE = /\\/g;
+export function slash(p) {
+    return p.replace(windowsSlashRE, "/");
+}
+const isWindows = typeof process !== "undefined" && process.platform === "win32";
+export function injectQuery(url, queryToInject) {
+    const { file, postfix } = splitFileAndPostfix(url);
+    const normalizedFile = isWindows ? slash(file) : file;
+    return `${normalizedFile}?${queryToInject}${postfix[0] === "?" ? `&${postfix.slice(1)}` : /* hash only */ postfix}`;
+}

package/dist/http/index.d.ts

@@ -0,0 +1,84 @@
+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<ArrayBufferLike>> | 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 {};