@solidjs/start 1.2.1 → 2.0.0-alpha.1

package/dist/http/index.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/index.d.ts

@@ -1,5 +1,5 @@
-export { default as clientOnly } from "./shared/clientOnly";
-export { GET } from "./shared/GET";
-export { HttpHeader } from "./shared/HttpHeader";
-export { HttpStatusCode } from "./shared/HttpStatusCode";
-export { getServerFunctionMeta } from "./shared/serverFunction";
+export { default as clientOnly } from "./shared/clientOnly.ts";
+export { GET } from "./shared/GET.ts";
+export { HttpHeader } from "./shared/HttpHeader.tsx";
+export { HttpStatusCode } from "./shared/HttpStatusCode.ts";
+export { getServerFunctionMeta } from "./shared/serverFunction.ts";

package/dist/index.jsx

@@ -1,6 +1,6 @@
 // @refresh skip
-export { default as clientOnly } from "./shared/clientOnly";
-export { GET } from "./shared/GET";
-export { HttpHeader } from "./shared/HttpHeader";
-export { HttpStatusCode } from "./shared/HttpStatusCode";
-export { getServerFunctionMeta } from "./shared/serverFunction";
+export { default as clientOnly } from "./shared/clientOnly.js";
+export { GET } from "./shared/GET.js";
+export { HttpHeader } from "./shared/HttpHeader.jsx";
+export { HttpStatusCode } from "./shared/HttpStatusCode.js";
+export { getServerFunctionMeta } from "./shared/serverFunction.js";

package/dist/middleware/index.d.ts

@@ -1,4 +1,5 @@
-import type { FetchEvent } from "../server/types";
+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}. */
 export type MiddlewareFn = (event: FetchEvent) => Promise<unknown> | unknown;
 /** This composes an array of Exchanges into a single ExchangeIO function */
@@ -8,11 +9,10 @@ type ResponseMiddlewareResponseParam = {
     body?: Awaited<EventHandlerResponse>;
 };
 export type ResponseMiddleware = (event: FetchEvent, response: ResponseMiddlewareResponseParam) => Response | Promise<Response> | void | Promise<void>;
-export declare function createMiddleware({ onRequest, onBeforeResponse }: {
+export declare function createMiddleware(args: {
+    /** @deprecated Use H3 `Middleware` */
     onRequest?: RequestMiddleware | RequestMiddleware[] | undefined;
+    /** @deprecated Use H3 `Middleware` */
     onBeforeResponse?: ResponseMiddleware | ResponseMiddleware[] | undefined;
-}): {
-    onRequest?: import("vinxi/http")._RequestMiddleware | import("vinxi/http")._RequestMiddleware[] | undefined;
-    onBeforeResponse?: import("vinxi/http")._ResponseMiddleware | import("vinxi/http")._ResponseMiddleware[] | undefined;
-};
+} | Middleware[]): Middleware[];
 export {};

package/dist/middleware/index.js

@@ -0,0 +1,39 @@
+// @refresh skip
+import { getFetchEvent } from "../server/fetchEvent.js";
+function wrapRequestMiddleware(onRequest) {
+    return async (h3Event) => {
+        const fetchEvent = getFetchEvent(h3Event);
+        const response = await onRequest(fetchEvent);
+        if (response)
+            return response;
+    };
+}
+function wrapResponseMiddleware(onBeforeResponse) {
+    return async (h3Event, next) => {
+        const resp = await next();
+        const fetchEvent = getFetchEvent(h3Event);
+        const mwResponse = await onBeforeResponse(fetchEvent, {
+            body: resp?.body,
+        });
+        if (mwResponse)
+            return mwResponse;
+    };
+}
+export function createMiddleware(args) {
+    if (Array.isArray(args))
+        return args;
+    const mw = [];
+    if (typeof args.onRequest === "function") {
+        mw.push(wrapRequestMiddleware(args.onRequest));
+    }
+    else if (Array.isArray(args.onRequest)) {
+        mw.push(...args.onRequest.map(wrapRequestMiddleware));
+    }
+    if (typeof args.onBeforeResponse === "function") {
+        mw.push(wrapResponseMiddleware(args.onBeforeResponse));
+    }
+    else if (Array.isArray(args.onBeforeResponse)) {
+        mw.push(...args.onBeforeResponse.map(wrapResponseMiddleware));
+    }
+    return mw;
+}

package/dist/{router/FileRoutes.js → router.jsx}

@@ -1,20 +1,19 @@
+import { lazy } from "solid-js";
 import { getRequestEvent, isServer } from "solid-js/web";
-import lazyRoute from "./lazyRoute";
-import { pageRoutes as routeConfigs } from "./routes";
+import { pageRoutes as routeConfigs } from "./server/routes.js";
+const components = {};
 export function createRoutes() {
     function createRoute(route) {
+        const component = route.$component && (components[route.$component.src] ??= lazy(route.$component.import));
         return {
             ...route,
             ...(route.$$route ? route.$$route.require().route : undefined),
             info: {
                 ...(route.$$route ? route.$$route.require().route.info : {}),
-                filesystem: true
+                filesystem: true,
             },
-            component: route.$component &&
-                lazyRoute(route.$component, import.meta.env.START_ISLANDS
-                    ? import.meta.env.MANIFEST["ssr"]
-                    : import.meta.env.MANIFEST["client"], import.meta.env.MANIFEST["ssr"]),
-            children: route.children ? route.children.map(createRoute) : undefined
+            component,
+            children: route.children ? route.children.map(createRoute) : undefined,
         };
     }
     const routes = routeConfigs.map(createRoute);

package/dist/server/StartServer.d.ts

@@ -1,9 +1,9 @@
-import type { Component, JSX } from "solid-js";
-import type { DocumentComponentProps } from "./types";
+import type { Component } from "solid-js";
+import type { DocumentComponentProps } from "./types.ts";
 /**
  *
  * Read more: https://docs.solidjs.com/solid-start/reference/server/start-server
  */
 export declare function StartServer(props: {
     document: Component<DocumentComponentProps>;
-}): JSX.Element;
+}): import("solid-js").JSX.Element;

package/dist/server/StartServer.jsx

@@ -1,27 +1,9 @@
-// @refresh skip
-// @ts-ignore
-import App from "#start/app";
-import { Hydration, HydrationScript, NoHydration, getRequestEvent, ssr, useAssets } from "solid-js/web";
-import { ErrorBoundary, TopErrorBoundary } from "../shared/ErrorBoundary";
-import { renderAsset } from "./renderAsset";
+import { Hydration, HydrationScript, NoHydration, getRequestEvent, ssr } from "solid-js/web";
+import App from "solid-start:app";
+import { ErrorBoundary, TopErrorBoundary } from "../shared/ErrorBoundary.jsx";
+import { useAssets } from "./assets/index.js";
+import { getSsrManifest } from "./manifest/ssr-manifest.js";
 const docType = ssr("<!DOCTYPE html>");
-function matchRoute(matches, routes, matched = []) {
-    for (let i = 0; i < routes.length; i++) {
-        const segment = routes[i];
-        if (segment.path !== matches[0].path)
-            continue;
-        let next = [...matched, segment];
-        if (segment.children) {
-            const nextMatches = matches.slice(1);
-            if (nextMatches.length === 0)
-                continue;
-            next = matchRoute(nextMatches, segment.children, next);
-            if (!next)
-                continue;
-        }
-        return next;
-    }
-}
 /**
  *
  * Read more: https://docs.solidjs.com/solid-start/reference/server/start-server
@@ -30,49 +12,13 @@ export function StartServer(props) {
     const context = getRequestEvent();
     // @ts-ignore
     const nonce = context.nonce;
-    let assets = [];
-    Promise.resolve().then(async () => {
-        let assetPromises = [];
-        // @ts-ignore
-        if (context.router && context.router.matches) {
-            // @ts-ignore
-            const matches = [...context.router.matches];
-            while (matches.length && (!matches[0].info || !matches[0].info.filesystem))
-                matches.shift();
-            const matched = matches.length && matchRoute(matches, context.routes);
-            if (matched) {
-                const inputs = import.meta.env.MANIFEST[import.meta.env.START_ISLANDS ? "ssr" : "client"]
-                    .inputs;
-                for (let i = 0; i < matched.length; i++) {
-                    const segment = matched[i];
-                    const part = inputs[segment["$component"].src];
-                    assetPromises.push(part.assets());
-                }
-            }
-            else if (import.meta.env.DEV)
-                console.warn("No route matched for preloading js assets");
-        }
-        assets = await Promise.all(assetPromises).then(a => 
-        // dedupe assets
-        [...new Map(a.flat().map(item => [item.attrs.key, item])).values()].filter(asset => import.meta.env.START_ISLANDS
-            ? false
-            : asset.attrs.rel === "modulepreload" &&
-                !context.assets.find((a) => a.attrs.key === asset.attrs.key)));
-    });
-    useAssets(() => (assets.length ? assets.map(m => renderAsset(m)) : undefined));
+    useAssets(context.assets, nonce);
     return (<NoHydration>
       {docType}
       <TopErrorBoundary>
-        <props.document assets={<>
-              <HydrationScript />
-              {context.assets.map((m) => renderAsset(m, nonce))}
-            </>} scripts={nonce ? (<>
-                <script nonce={nonce} innerHTML={`window.manifest = ${JSON.stringify(context.manifest)}`}/>
-                <script type="module" nonce={nonce} async src={import.meta.env.MANIFEST["client"].inputs[import.meta.env.MANIFEST["client"].handler].output.path}/>
-              </>) : (<>
-                <script innerHTML={`window.manifest = ${JSON.stringify(context.manifest)}`}/>
-                <script type="module" async src={import.meta.env.MANIFEST["client"].inputs[import.meta.env.MANIFEST["client"].handler].output.path}/>
-              </>)}>
+        <props.document assets={<HydrationScript />} scripts={<>
+              <script type="module" nonce={nonce} async src={getSsrManifest("client").path(import.meta.env.START_CLIENT_ENTRY)}/>
+            </>}>
           {!import.meta.env.START_ISLANDS ? (<Hydration>
               <ErrorBoundary>
                 <App />

package/dist/server/assets/index.d.ts

@@ -0,0 +1,2 @@
+import { type Asset } from "./render.tsx";
+export declare const useAssets: (assets: Asset[], nonce?: string) => void;

package/dist/server/assets/index.js

@@ -0,0 +1,52 @@
+import { onCleanup, sharedConfig } from "solid-js";
+import { getRequestEvent, useAssets as useAssets_ } from "solid-js/web";
+import { renderAsset } from "./render.jsx";
+const REGISTRY = Symbol("assetRegistry");
+const NOOP = () => "";
+const keyAttrs = ["href", "rel", "data-vite-dev-id"];
+const getEntity = (registry, asset) => {
+    let key = asset.tag;
+    for (const k of keyAttrs) {
+        if (!(k in asset.attrs))
+            continue;
+        key += `[${k}='${asset.attrs[k]}']`;
+    }
+    const entity = (registry[key] ??= {
+        key,
+        consumers: 0,
+    });
+    return entity;
+};
+export const useAssets = (assets, nonce) => {
+    if (!assets.length)
+        return;
+    const registry = (getRequestEvent().locals[REGISTRY] ??= {});
+    const ssrRequestAssets = sharedConfig.context?.assets;
+    const cssKeys = [];
+    for (const asset of assets) {
+        const entity = getEntity(registry, asset);
+        const isCSSLink = asset.tag === "link" && asset.attrs.rel === "stylesheet";
+        const isCSS = isCSSLink || asset.tag === "style";
+        if (isCSS) {
+            cssKeys.push(entity.key);
+        }
+        entity.consumers++;
+        if (entity.consumers > 1)
+            continue;
+        // Mounting logic
+        useAssets_(() => renderAsset(asset, nonce));
+        entity.ssrIdx = ssrRequestAssets.length - 1;
+    }
+    onCleanup(() => {
+        for (const key of cssKeys) {
+            const entity = registry[key];
+            entity.consumers--;
+            if (entity.consumers != 0) {
+                continue;
+            }
+            // Ideally this logic should be implemented directly in dom-expressions
+            ssrRequestAssets.splice(entity.ssrIdx, 1, NOOP);
+            delete registry[key];
+        }
+    });
+};

package/dist/server/assets/render.d.ts

@@ -0,0 +1,19 @@
+import type { JSX } from "solid-js";
+export declare function renderAsset(asset: Asset, nonce?: string): any;
+export type Asset = {
+    tag: "style";
+    attrs: JSX.StyleHTMLAttributes<HTMLStyleElement> & {
+        key?: string;
+    };
+    children?: JSX.Element;
+} | {
+    tag: "script";
+    attrs: JSX.ScriptHTMLAttributes<HTMLScriptElement> & {
+        key?: string;
+    };
+} | {
+    tag: "link";
+    attrs: JSX.LinkHTMLAttributes<HTMLLinkElement> & {
+        key?: string;
+    };
+};

package/dist/server/{renderAsset.jsx → assets/render.jsx}

@@ -9,6 +9,6 @@ const assetMap = {
     noscript: (props) => (<noscript {...props.attrs}>{props.children}</noscript>),
 };
 export function renderAsset(asset, nonce) {
-    let { tag, attrs: { key, ...attrs } = { key: undefined }, children } = asset;
+    let { tag, attrs: { key, ...attrs } = { key: undefined }, children, } = asset;
     return assetMap[tag]({ attrs: { ...attrs, nonce }, key, children });
 }

package/dist/server/collect-styles.d.ts

@@ -0,0 +1,3 @@
+import type { DevEnvironment } from "vite";
+export declare const isCssModulesFile: (file: string) => boolean;
+export declare function findStylesInModuleGraph(vite: DevEnvironment, id: string): Promise<Record<string, any>>;

package/dist/server/collect-styles.js

@@ -0,0 +1,69 @@
+import path from "node:path";
+import { resolve } from "pathe";
+async function getViteModuleNode(vite, file) {
+    let nodePath = file;
+    let node = vite.moduleGraph.getModuleById(file);
+    if (!node) {
+        const resolvedId = await vite.pluginContainer.resolveId(file, undefined);
+        if (!resolvedId)
+            return;
+        nodePath = resolvedId.id;
+        node = vite.moduleGraph.getModuleById(file);
+    }
+    if (!node) {
+        nodePath = resolve(nodePath);
+        node = await vite.moduleGraph.getModuleByUrl(file);
+    }
+    if (!node) {
+        await vite.moduleGraph.ensureEntryFromUrl(nodePath, false);
+        node = vite.moduleGraph.getModuleById(nodePath);
+    }
+    return node;
+}
+async function findModuleDependencies(vite, file, deps, crawledFiles = new Set()) {
+    crawledFiles.add(file);
+    const module = await getViteModuleNode(vite, file);
+    if (!module?.id || deps.has(module))
+        return;
+    deps.add(module);
+    if (module.url.endsWith(".css") || module.url.includes("node_modules"))
+        return;
+    if (!module.transformResult) {
+        await vite.transformRequest(module.id).catch(() => { });
+    }
+    if (!module.transformResult?.deps)
+        return;
+    // Relying on module.transformResult.deps instead of module.importedModules because:
+    // transformResult properly separates imports into deps and dynamicDeps, importedModules doesn't
+    // Style crawling has to skip dynamic imports as such modules load their styles themselves
+    for (const dep of module.transformResult.deps) {
+        if (crawledFiles.has(dep)) {
+            continue;
+        }
+        await findModuleDependencies(vite, dep, deps, crawledFiles);
+    }
+}
+// Vite doesn't expose these so we just copy the list for now
+// https://github.com/vitejs/vite/blob/d6bde8b03d433778aaed62afc2be0630c8131908/packages/vite/src/node/constants.ts#L49C23-L50
+const cssFileRegExp = /\.(css|less|sass|scss|styl|stylus|pcss|postcss|sss)$/;
+// https://github.com/vitejs/vite/blob/d6bde8b03d433778aaed62afc2be0630c8131908/packages/vite/src/node/plugins/css.ts#L160
+const cssModulesRegExp = new RegExp(`\\.module${cssFileRegExp.source}`);
+const isCssFile = (file) => cssFileRegExp.test(file);
+export const isCssModulesFile = (file) => cssModulesRegExp.test(file);
+export async function findStylesInModuleGraph(vite, id) {
+    const absolute = path.resolve(process.cwd(), id);
+    const dependencies = new Set();
+    try {
+        await findModuleDependencies(vite, absolute, dependencies);
+    }
+    catch (e) {
+        console.error(e);
+    }
+    const styles = {};
+    for (const dep of dependencies) {
+        if (dep.id && isCssFile(dep.url)) {
+            styles[dep.id] = dep.url;
+        }
+    }
+    return styles;
+}

package/dist/server/fetchEvent.d.ts

@@ -1,6 +1,7 @@
-import { H3Event } from "vinxi/http";
-import type { FetchEvent } from "./types";
+import { type EventHandler, type H3Event, type Middleware } from "h3";
+import type { FetchEvent } from "./types.ts";
 export declare function createFetchEvent(event: H3Event): FetchEvent;
-export declare function cloneEvent<T extends FetchEvent>(fetchEvent: T): T;
 export declare function getFetchEvent(h3Event: H3Event): FetchEvent;
 export declare function mergeResponseHeaders(h3Event: H3Event, headers: Headers): void;
+export declare const decorateHandler: <T extends EventHandler>(fn: T) => T;
+export declare const decorateMiddleware: <T extends Middleware>(fn: T) => T;

package/dist/server/fetchEvent.js

@@ -1,88 +1,26 @@
-import { appendResponseHeader, getRequestIP, getResponseHeader, getResponseHeaders, getResponseStatus, getResponseStatusText, getWebRequest, removeResponseHeader, setResponseHeader, setResponseStatus } from "vinxi/http";
-const fetchEventContext = "solidFetchEvent";
+import { getRequestIP } from "h3";
+import { provideRequestEvent } from "solid-js/web/storage";
+const FETCH_EVENT_CONTEXT = "solidFetchEvent";
 export function createFetchEvent(event) {
     return {
-        request: getWebRequest(event),
-        response: createResponseStub(event),
+        request: event.req,
+        response: event.res,
         clientAddress: getRequestIP(event),
         locals: {},
-        nativeEvent: event
-    };
-}
-export function cloneEvent(fetchEvent) {
-    return {
-        ...fetchEvent
+        nativeEvent: event,
     };
 }
 export function getFetchEvent(h3Event) {
-    if (!h3Event.context[fetchEventContext]) {
+    if (!h3Event.context[FETCH_EVENT_CONTEXT]) {
         const fetchEvent = createFetchEvent(h3Event);
-        h3Event.context[fetchEventContext] = fetchEvent;
+        h3Event.context[FETCH_EVENT_CONTEXT] = fetchEvent;
     }
-    return h3Event.context[fetchEventContext];
+    return h3Event.context[FETCH_EVENT_CONTEXT];
 }
 export function mergeResponseHeaders(h3Event, headers) {
     for (const [key, value] of headers.entries()) {
-        appendResponseHeader(h3Event, key, value);
-    }
-}
-class HeaderProxy {
-    event;
-    constructor(event) {
-        this.event = event;
-    }
-    get(key) {
-        const h = getResponseHeader(this.event, key);
-        return Array.isArray(h) ? h.join(", ") : h || null;
-    }
-    has(key) {
-        return this.get(key) !== null;
-    }
-    set(key, value) {
-        return setResponseHeader(this.event, key, value);
-    }
-    delete(key) {
-        return removeResponseHeader(this.event, key);
-    }
-    append(key, value) {
-        appendResponseHeader(this.event, key, value);
+        h3Event.res.headers.append(key, value);
     }
-    getSetCookie() {
-        const cookies = getResponseHeader(this.event, "Set-Cookie");
-        return Array.isArray(cookies) ? cookies : [cookies];
-    }
-    forEach(fn) {
-        return Object.entries(getResponseHeaders(this.event)).forEach(([key, value]) => fn(Array.isArray(value) ? value.join(", ") : value, key, this));
-    }
-    entries() {
-        return Object.entries(getResponseHeaders(this.event))
-            .map(([key, value]) => [key, Array.isArray(value) ? value.join(", ") : value])[Symbol.iterator]();
-    }
-    keys() {
-        return Object.keys(getResponseHeaders(this.event))[Symbol.iterator]();
-    }
-    values() {
-        return Object.values(getResponseHeaders(this.event))
-            .map(value => (Array.isArray(value) ? value.join(", ") : value))[Symbol.iterator]();
-    }
-    [Symbol.iterator]() {
-        return this.entries()[Symbol.iterator]();
-    }
-}
-function createResponseStub(event) {
-    return {
-        get status() {
-            return getResponseStatus(event);
-        },
-        set status(v) {
-            setResponseStatus(event, v);
-        },
-        get statusText() {
-            return getResponseStatusText(event);
-        },
-        set statusText(v) {
-            setResponseStatus(event, getResponseStatus(event), v);
-        },
-        headers: new HeaderProxy(event)
-    };
 }
+export const decorateHandler = (fn) => (event => provideRequestEvent(getFetchEvent(event), () => fn(event)));
+export const decorateMiddleware = (fn) => ((event, next) => provideRequestEvent(getFetchEvent(event), () => fn(event, next)));