elysia 2.0.0-exp.42 → 2.0.0-exp.44

package/dist/adapter/bun/index.d.ts

@@ -1,7 +1,7 @@
 import { AnyElysia } from "../../base.js";
 import { ElysiaAdapterOptions } from "../types.js";
 //#region src/adapter/bun/index.d.ts
-declare function collectStaticRoutes(app: AnyElysia): readonly [Record<string, Record<string, Response>>, Promise<void>[]] | undefined;
+declare function collectStaticRoutes(app: AnyElysia): readonly [Record<string, Record<string, Response>>, readonly []] | undefined;
 declare const BunAdapter: ElysiaAdapterOptions;
 //#endregion
 export { BunAdapter, collectStaticRoutes };

package/dist/adapter/bun/index.js

@@ -3,34 +3,42 @@ const require_adapter_index = require('../index.js');
 const require_constants = require('../../constants.js');
 const require_utils = require('../../utils.js');
 const require_adapter_web_standard_index = require('../web-standard/index.js');
+const require_generation = require('../../generation.js');
 const require_compile_handler_index = require('../../compile/handler/index.js');
-const require_memory = require('../../memory.js');
+const require_route_table = require('../../route-table.js');
 const require_ws_route = require('../../ws/route.js');
 
 //#region src/adapter/bun/index.ts
+const nativeStaticMethods = new Set([
+	"GET",
+	"POST",
+	"PUT",
+	"DELETE",
+	"PATCH",
+	"HEAD",
+	"OPTIONS"
+]);
 function collectStaticRoutes(app) {
 	if (app["~config"]?.nativeStaticResponse === false) return;
 	app.fetch;
-	const fetchLevelHook = require_utils.flattenChain(app["~hookChain"]);
-	if (fetchLevelHook?.request?.length || fetchLevelHook?.trace?.length || app["~ext"]?.hoc?.length) return;
-	const history = app["~routes"];
-	if (!history?.length) return;
+	const frozenRoot = require_generation.frozenRootOf(app);
+	const fetchLevelHook = require_utils.flattenChain(frozenRoot["~hookChain"]);
+	if (fetchLevelHook?.request?.length || fetchLevelHook?.trace?.length || frozenRoot["~ext"]?.hoc?.length) return;
+	const table = app["~generation"]?.routeTable ?? app["~routeTable"];
+	const length = table?.length ?? 0;
+	if (!table || !length) return;
+	const methods = table.method;
+	const paths = table.path;
 	const ready = require_utils.nullObject();
-	const pending = [];
-	const strictPath = app["~config"]?.strictPath === true;
+	const strictPath = frozenRoot["~config"]?.strictPath === true;
 	const seen = /* @__PURE__ */ new Map();
-	for (let i = 0; i < history.length; i++) {
-		const route = history[i];
-		const method = route[0];
-		seen.set(method + " " + route[1], i);
-	}
+	for (let i = 0; i < length; i++) seen.set(methods[i] + " " + paths[i], i);
 	let explicitPaths;
 	if (!strictPath) {
 		explicitPaths = /* @__PURE__ */ new Map();
-		for (let i = 0; i < history.length; i++) {
-			const route = history[i];
-			const method = route[0];
-			const path = route[1];
+		for (let i = 0; i < length; i++) {
+			const method = methods[i];
+			const path = paths[i];
 			let set = explicitPaths.get(method);
 			if (!set) explicitPaths.set(method, set = /* @__PURE__ */ new Set());
 			set.add(path);
@@ -42,20 +50,15 @@ function collectStaticRoutes(app) {
 	}
 	const add = (method, path, value) => {
 		if (require_constants.needEncodeRegex.test(path)) path = encodeURI(path);
-		if (value instanceof Promise) pending.push(value.then((resolved) => {
-			if (resolved instanceof Response) (ready[path] ??= require_utils.nullObject())[method] = resolved;
-		}, (err) => {
-			console.error(`[Elysia] Static route ${method} ${path} failed to resolve:`, err);
-		}));
-		else (ready[path] ??= require_utils.nullObject())[method] = value;
+		(ready[path] ??= require_utils.nullObject())[method] = value;
 	};
-	for (let i = 0; i < history.length; i++) {
-		const route = history[i];
-		if (route[0] === "WS") continue;
-		const method = route[0];
-		const path = route[1];
+	for (let i = 0; i < length; i++) {
+		const method = methods[i];
+		if (method === "WS") continue;
+		const path = paths[i];
 		if (seen.get(method + " " + path) !== i) continue;
-		const value = require_compile_handler_index.buildNativeStaticResponse(route, app);
+		if (!nativeStaticMethods.has(method)) continue;
+		const value = require_compile_handler_index.buildNativeStaticResponse(require_route_table.routeRow(table, i), app);
 		if (!value) continue;
 		add(method, path, value);
 		if (!strictPath && !require_constants.isDynamicRegex.test(path)) {
@@ -63,8 +66,8 @@ function collectStaticRoutes(app) {
 			if (loose !== path && !explicitPaths?.get(method)?.has(loose)) add(method, loose, value);
 		}
 	}
-	if (!Object.keys(ready).length && !pending.length) return;
-	return [ready, pending];
+	if (!Object.keys(ready).length) return;
+	return [ready, []];
 }
 const BunAdapter = require_adapter_index.createAdapter({
 	name: "bun",
@@ -84,58 +87,104 @@ const BunAdapter = require_adapter_index.createAdapter({
 			..._config,
 			..._options
 		} : _options;
-		const server = app.server = Bun.serve(serve);
 		const onSetup = app["~ext"]?.setup;
-		let setupReady;
-		if (onSetup) {
+		const needsGate = app.pending || !!onSetup?.length;
+		let ready;
+		const build = () => {
+			const fetch = app.fetch;
+			let routes;
+			try {
+				routes = collectStaticRoutes(app);
+			} catch (error) {
+				console.warn("[Elysia] Native static promotion was skipped:", error);
+			}
+			const hasWs = app["~hasWS"];
+			let websocket;
+			if (hasWs) {
+				const defaultConfig = require_generation.frozenRootOf(app)["~config"]?.websocket;
+				websocket = defaultConfig ? Object.assign(require_ws_route.buildGlobalWSHandler(), defaultConfig) : require_ws_route.buildGlobalWSHandler();
+			}
+			return {
+				fetch,
+				routes,
+				websocket
+			};
+		};
+		let built;
+		if (!needsGate) built = build();
+		if (needsGate) serve.fetch = (request, server) => ready.then(() => app.fetch(request, server));
+		else serve.fetch = built.fetch;
+		const server = app.server = Bun.serve(serve);
+		const reload = () => {
+			try {
+				server.reload(serve);
+			} catch (error) {
+				if (!serve.routes) throw error;
+				delete serve.routes;
+				console.warn("[Elysia] Native static promotion was skipped:", error);
+				try {
+					server.reload(serve);
+				} catch (fallbackError) {
+					console.error("[Elysia] Failed to reload Bun server:", fallbackError);
+					throw fallbackError;
+				}
+			}
+		};
+		const setup = () => {
+			const onSetup = app["~ext"]?.setup;
+			if (!onSetup) return;
 			let pendingSetups;
 			for (let i = 0; i < onSetup.length; i++) {
 				const result = onSetup[i](app);
 				if (result && typeof result.then === "function") (pendingSetups ??= []).push(result);
 			}
-			if (pendingSetups) setupReady = Promise.all(pendingSetups);
-		}
-		const hasWs = app["~hasWS"];
-		if (!hasWs) {
-			if (callback) if (setupReady) setupReady.then(() => callback(app.server));
-			else callback(app.server);
-		}
-		queueMicrotask(() => {
+			if (pendingSetups) return Promise.all(pendingSetups);
+		};
+		const rollback = (error) => {
 			if (app.server !== server) return;
-			if (!app.pending) serve.fetch = app.fetch;
-			const buildWebSocket = () => {
-				const defaultConfig = app["~config"]?.websocket;
-				serve.websocket = defaultConfig ? Object.assign(require_ws_route.buildGlobalWSHandler(), defaultConfig) : require_ws_route.buildGlobalWSHandler();
-			};
-			if (hasWs) buildWebSocket();
-			const collectRoutes = () => {
-				const staticRoutes = collectStaticRoutes(app);
-				if (!staticRoutes) return;
-				if (staticRoutes[1].length) return Promise.all(staticRoutes[1]).then(() => {
-					if (app.server !== server) return;
-					serve.routes = staticRoutes[0];
-					app.server.reload(serve);
-				});
-				if (Object.keys(staticRoutes[0]).length) serve.routes = staticRoutes[0];
-			};
-			if (app.pending) {
-				app.server.reload(serve);
-				const reloadAfterModules = () => {
-					if (app.server !== server) return;
-					serve.fetch = app.fetch;
-					if (hasWs || app["~hasWS"]) buildWebSocket();
-					collectRoutes();
-					app.server.reload(serve);
-				};
-				app.modules.then(reloadAfterModules, reloadAfterModules);
-			} else {
-				collectRoutes();
-				app.server.reload(serve);
+			try {
+				server.stop(true);
+			} catch (stopError) {
+				console.error(stopError);
+			} finally {
+				app.server = void 0;
 			}
-			require_memory.flushMemory();
-			if (hasWs && callback) if (setupReady) setupReady.then(() => callback(app.server));
-			else callback(app.server);
-		});
+			const cleanup = app["~ext"]?.cleanup;
+			if (cleanup) for (let i = cleanup.length - 1; i >= 0; i--) try {
+				const result = cleanup[i](app);
+				if (result && typeof result.then === "function") Promise.resolve(result).catch(console.error);
+			} catch (cleanupError) {
+				console.error(cleanupError);
+			}
+			return error;
+		};
+		const publish = () => {
+			if (app.server !== server) return;
+			built ??= build();
+			serve.fetch = built.fetch;
+			if (built.websocket) serve.websocket = built.websocket;
+			if (built.routes) serve.routes = built.routes[0];
+			if (needsGate || built.websocket || built.routes) reload();
+			if (callback) callback(server);
+		};
+		const start = () => {
+			if (app.server !== server) return;
+			const setupReady = setup();
+			if (setupReady && typeof setupReady.then === "function") return Promise.resolve(setupReady).then(publish);
+			publish();
+		};
+		try {
+			if (app.pending) ready = app.modules.then(start);
+			else {
+				const result = start();
+				if (result && typeof result.then === "function") ready = result;
+				else if (needsGate) ready = Promise.resolve();
+			}
+			ready?.catch(rollback);
+		} catch (error) {
+			rollback(error);
+			throw error;
+		}
 	}
 });
 

package/dist/adapter/bun/index.mjs

@@ -2,34 +2,42 @@ import { createAdapter } from "../index.mjs";
 import { isDynamicRegex, needEncodeRegex } from "../../constants.mjs";
 import { flattenChain, getLoosePath, nullObject } from "../../utils.mjs";
 import { WebStandardAdapter } from "../web-standard/index.mjs";
+import { frozenRootOf } from "../../generation.mjs";
 import { buildNativeStaticResponse } from "../../compile/handler/index.mjs";
-import { flushMemory } from "../../memory.mjs";
+import { routeRow } from "../../route-table.mjs";
 import { buildGlobalWSHandler } from "../../ws/route.mjs";
 
 //#region src/adapter/bun/index.ts
+const nativeStaticMethods = new Set([
+	"GET",
+	"POST",
+	"PUT",
+	"DELETE",
+	"PATCH",
+	"HEAD",
+	"OPTIONS"
+]);
 function collectStaticRoutes(app) {
 	if (app["~config"]?.nativeStaticResponse === false) return;
 	app.fetch;
-	const fetchLevelHook = flattenChain(app["~hookChain"]);
-	if (fetchLevelHook?.request?.length || fetchLevelHook?.trace?.length || app["~ext"]?.hoc?.length) return;
-	const history = app["~routes"];
-	if (!history?.length) return;
+	const frozenRoot = frozenRootOf(app);
+	const fetchLevelHook = flattenChain(frozenRoot["~hookChain"]);
+	if (fetchLevelHook?.request?.length || fetchLevelHook?.trace?.length || frozenRoot["~ext"]?.hoc?.length) return;
+	const table = app["~generation"]?.routeTable ?? app["~routeTable"];
+	const length = table?.length ?? 0;
+	if (!table || !length) return;
+	const methods = table.method;
+	const paths = table.path;
 	const ready = nullObject();
-	const pending = [];
-	const strictPath = app["~config"]?.strictPath === true;
+	const strictPath = frozenRoot["~config"]?.strictPath === true;
 	const seen = /* @__PURE__ */ new Map();
-	for (let i = 0; i < history.length; i++) {
-		const route = history[i];
-		const method = route[0];
-		seen.set(method + " " + route[1], i);
-	}
+	for (let i = 0; i < length; i++) seen.set(methods[i] + " " + paths[i], i);
 	let explicitPaths;
 	if (!strictPath) {
 		explicitPaths = /* @__PURE__ */ new Map();
-		for (let i = 0; i < history.length; i++) {
-			const route = history[i];
-			const method = route[0];
-			const path = route[1];
+		for (let i = 0; i < length; i++) {
+			const method = methods[i];
+			const path = paths[i];
 			let set = explicitPaths.get(method);
 			if (!set) explicitPaths.set(method, set = /* @__PURE__ */ new Set());
 			set.add(path);
@@ -41,20 +49,15 @@ function collectStaticRoutes(app) {
 	}
 	const add = (method, path, value) => {
 		if (needEncodeRegex.test(path)) path = encodeURI(path);
-		if (value instanceof Promise) pending.push(value.then((resolved) => {
-			if (resolved instanceof Response) (ready[path] ??= nullObject())[method] = resolved;
-		}, (err) => {
-			console.error(`[Elysia] Static route ${method} ${path} failed to resolve:`, err);
-		}));
-		else (ready[path] ??= nullObject())[method] = value;
+		(ready[path] ??= nullObject())[method] = value;
 	};
-	for (let i = 0; i < history.length; i++) {
-		const route = history[i];
-		if (route[0] === "WS") continue;
-		const method = route[0];
-		const path = route[1];
+	for (let i = 0; i < length; i++) {
+		const method = methods[i];
+		if (method === "WS") continue;
+		const path = paths[i];
 		if (seen.get(method + " " + path) !== i) continue;
-		const value = buildNativeStaticResponse(route, app);
+		if (!nativeStaticMethods.has(method)) continue;
+		const value = buildNativeStaticResponse(routeRow(table, i), app);
 		if (!value) continue;
 		add(method, path, value);
 		if (!strictPath && !isDynamicRegex.test(path)) {
@@ -62,8 +65,8 @@ function collectStaticRoutes(app) {
 			if (loose !== path && !explicitPaths?.get(method)?.has(loose)) add(method, loose, value);
 		}
 	}
-	if (!Object.keys(ready).length && !pending.length) return;
-	return [ready, pending];
+	if (!Object.keys(ready).length) return;
+	return [ready, []];
 }
 const BunAdapter = createAdapter({
 	name: "bun",
@@ -83,58 +86,104 @@ const BunAdapter = createAdapter({
 			..._config,
 			..._options
 		} : _options;
-		const server = app.server = Bun.serve(serve);
 		const onSetup = app["~ext"]?.setup;
-		let setupReady;
-		if (onSetup) {
+		const needsGate = app.pending || !!onSetup?.length;
+		let ready;
+		const build = () => {
+			const fetch = app.fetch;
+			let routes;
+			try {
+				routes = collectStaticRoutes(app);
+			} catch (error) {
+				console.warn("[Elysia] Native static promotion was skipped:", error);
+			}
+			const hasWs = app["~hasWS"];
+			let websocket;
+			if (hasWs) {
+				const defaultConfig = frozenRootOf(app)["~config"]?.websocket;
+				websocket = defaultConfig ? Object.assign(buildGlobalWSHandler(), defaultConfig) : buildGlobalWSHandler();
+			}
+			return {
+				fetch,
+				routes,
+				websocket
+			};
+		};
+		let built;
+		if (!needsGate) built = build();
+		if (needsGate) serve.fetch = (request, server) => ready.then(() => app.fetch(request, server));
+		else serve.fetch = built.fetch;
+		const server = app.server = Bun.serve(serve);
+		const reload = () => {
+			try {
+				server.reload(serve);
+			} catch (error) {
+				if (!serve.routes) throw error;
+				delete serve.routes;
+				console.warn("[Elysia] Native static promotion was skipped:", error);
+				try {
+					server.reload(serve);
+				} catch (fallbackError) {
+					console.error("[Elysia] Failed to reload Bun server:", fallbackError);
+					throw fallbackError;
+				}
+			}
+		};
+		const setup = () => {
+			const onSetup = app["~ext"]?.setup;
+			if (!onSetup) return;
 			let pendingSetups;
 			for (let i = 0; i < onSetup.length; i++) {
 				const result = onSetup[i](app);
 				if (result && typeof result.then === "function") (pendingSetups ??= []).push(result);
 			}
-			if (pendingSetups) setupReady = Promise.all(pendingSetups);
-		}
-		const hasWs = app["~hasWS"];
-		if (!hasWs) {
-			if (callback) if (setupReady) setupReady.then(() => callback(app.server));
-			else callback(app.server);
-		}
-		queueMicrotask(() => {
+			if (pendingSetups) return Promise.all(pendingSetups);
+		};
+		const rollback = (error) => {
 			if (app.server !== server) return;
-			if (!app.pending) serve.fetch = app.fetch;
-			const buildWebSocket = () => {
-				const defaultConfig = app["~config"]?.websocket;
-				serve.websocket = defaultConfig ? Object.assign(buildGlobalWSHandler(), defaultConfig) : buildGlobalWSHandler();
-			};
-			if (hasWs) buildWebSocket();
-			const collectRoutes = () => {
-				const staticRoutes = collectStaticRoutes(app);
-				if (!staticRoutes) return;
-				if (staticRoutes[1].length) return Promise.all(staticRoutes[1]).then(() => {
-					if (app.server !== server) return;
-					serve.routes = staticRoutes[0];
-					app.server.reload(serve);
-				});
-				if (Object.keys(staticRoutes[0]).length) serve.routes = staticRoutes[0];
-			};
-			if (app.pending) {
-				app.server.reload(serve);
-				const reloadAfterModules = () => {
-					if (app.server !== server) return;
-					serve.fetch = app.fetch;
-					if (hasWs || app["~hasWS"]) buildWebSocket();
-					collectRoutes();
-					app.server.reload(serve);
-				};
-				app.modules.then(reloadAfterModules, reloadAfterModules);
-			} else {
-				collectRoutes();
-				app.server.reload(serve);
+			try {
+				server.stop(true);
+			} catch (stopError) {
+				console.error(stopError);
+			} finally {
+				app.server = void 0;
 			}
-			flushMemory();
-			if (hasWs && callback) if (setupReady) setupReady.then(() => callback(app.server));
-			else callback(app.server);
-		});
+			const cleanup = app["~ext"]?.cleanup;
+			if (cleanup) for (let i = cleanup.length - 1; i >= 0; i--) try {
+				const result = cleanup[i](app);
+				if (result && typeof result.then === "function") Promise.resolve(result).catch(console.error);
+			} catch (cleanupError) {
+				console.error(cleanupError);
+			}
+			return error;
+		};
+		const publish = () => {
+			if (app.server !== server) return;
+			built ??= build();
+			serve.fetch = built.fetch;
+			if (built.websocket) serve.websocket = built.websocket;
+			if (built.routes) serve.routes = built.routes[0];
+			if (needsGate || built.websocket || built.routes) reload();
+			if (callback) callback(server);
+		};
+		const start = () => {
+			if (app.server !== server) return;
+			const setupReady = setup();
+			if (setupReady && typeof setupReady.then === "function") return Promise.resolve(setupReady).then(publish);
+			publish();
+		};
+		try {
+			if (app.pending) ready = app.modules.then(start);
+			else {
+				const result = start();
+				if (result && typeof result.then === "function") ready = result;
+				else if (needsGate) ready = Promise.resolve();
+			}
+			ready?.catch(rollback);
+		} catch (error) {
+			rollback(error);
+			throw error;
+		}
 	}
 });
 

package/dist/adapter/default-headers.d.ts

@@ -0,0 +1,4 @@
+//#region src/adapter/default-headers.d.ts
+declare const defaultHeaders = "\0";
+//#endregion
+export { defaultHeaders };

package/dist/adapter/default-headers.js

@@ -0,0 +1,7 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+//#region src/adapter/default-headers.ts
+const defaultHeaders = "\0";
+
+//#endregion
+exports.defaultHeaders = defaultHeaders;

package/dist/adapter/default-headers.mjs

@@ -0,0 +1,5 @@
+//#region src/adapter/default-headers.ts
+const defaultHeaders = "\0";
+
+//#endregion
+export { defaultHeaders };

package/dist/adapter/types.d.ts

@@ -1,5 +1,5 @@
 import { ListenCallback, Serve } from "../universal/server.js";
-import { AnyLocalHook, MaybePromise } from "../types.js";
+import { MaybePromise } from "../types.js";
 import { Context } from "../context.js";
 import { AnyElysia } from "../base.js";
 
@@ -30,58 +30,25 @@ interface ElysiaAdapterOptions {
    */
   websocket?: boolean;
   listen?(app: AnyElysia, options: string | number | Partial<Serve>, callback?: ListenCallback): void;
-  /**
-   * Stop server from serving
-   *
-   * ---
-   * @example
-   * ```typescript
-   * app.stop()
-   * ```
-   *
-   * @example
-   * ```typescript
-   * app.stop(true) // Abruptly any requests inflight
-   * ```
-   */
-  stop?(app: AnyElysia, closeActiveConnections?: boolean): Promise<void>;
   parse: {
     json: (context: Context) => MaybePromise<Record<keyof any, undefined> | unknown[]>;
     text: (context: Context) => MaybePromise<string>;
     urlencoded: (context: Context) => MaybePromise<Record<string, string | string[]>>;
     arrayBuffer: (context: Context) => MaybePromise<ArrayBuffer>;
     formData: (context: Context) => MaybePromise<Record<string, unknown>>;
-    default: (context: Context, contentType: string) => MaybePromise<any>;
+    default: (context: Context, contentType: string, normalized?: boolean) => MaybePromise<any>;
   };
   response: {
     /**
      * Map return response on every case
      */
-    map(response: unknown, set: Context['set'], ...params: unknown[]): unknown;
+    map(response: unknown, set: Context['set'], ...params: unknown[]): unknown; /** Support immutable shared default headers. */
+    supportsDefaultHeaderSink?: true;
     /**
      * Map response without cookie, status or headers
      */
     compact?(response: unknown, ...params: unknown[]): unknown;
-    /**
-     * Compile inline to value
-     *
-     * @example
-     * ```ts
-     * Elysia().get('/', 'static')
-     * ```
-     */
-    static?(handle: unknown, hooks: AnyLocalHook, setHeaders?: Context['set']['headers'], ...params: unknown[]): (() => unknown) | undefined;
-    /**
-     * If the runtime support cloning response
-     *
-     * eg. Bun.serve({ static })
-     */
-    nativeStatic?(handle: unknown, hooks: AnyLocalHook, set?: Context['set']): (() => MaybePromise<Response>) | undefined;
   };
-  /**
-   * override Elysia's default fetch function
-   */
-  fetch?(app: AnyElysia): (request: Request) => MaybePromise<Response>;
 }
 //#endregion
 export { ElysiaAdapterOptions };

package/dist/adapter/utils.d.ts

@@ -1,9 +1,11 @@
+import { BaseCookie } from "../cookie/types.js";
 import { StatusMap } from "../constants.js";
 import { ElysiaFile } from "../universal/file.js";
-import { BaseCookie } from "../cookie/types.js";
 import { HTTPHeaders } from "../types.js";
 import { Context } from "../context.js";
 //#region src/adapter/utils.d.ts
+declare function materializeSetHeaders(set: Context['set']): any;
+declare function normalizeContentType(contentType: string): string;
 declare function handleFile(response: File | Blob | ElysiaFile, set?: Context['set'], request?: Request, size?: number): Response;
 declare function parseSetCookies(headers: Headers, setCookie: string[]): Headers;
 declare function responseToSetHeaders(response: Response, set?: Context['set']): {
@@ -45,4 +47,4 @@ declare function createResponseHandler(handler: CreateHandlerParameter): (respon
  */
 declare function tee<T>(source: AsyncIterable<T>, branches?: number, cap?: number, capBytes?: number): AsyncIterableIterator<T>[];
 //#endregion
-export { createResponseHandler, createStreamHandler, handleFile, handleSet, parseSetCookies, responseToSetHeaders, streamResponse, tee };
+export { createResponseHandler, createStreamHandler, handleFile, handleSet, materializeSetHeaders, normalizeContentType, parseSetCookies, responseToSetHeaders, streamResponse, tee };

package/dist/adapter/utils.js

@@ -4,13 +4,24 @@ const require_constants = require('../constants.js');
 const require_utils = require('../utils.js');
 const require_adapter_skip_clone = require('./skip-clone.js');
 const require_cookie_serialize = require('../cookie/serialize.js');
+const require_adapter_default_headers = require('./default-headers.js');
 
 //#region src/adapter/utils.ts
 const setCookie = "set-cookie";
+function materializeSetHeaders(set) {
+	const headers = set.headers;
+	if (headers["\0"] !== headers) return headers;
+	return set.headers = Object.assign(require_utils.nullObject(), headers);
+}
 const sseFormat = (data) => `data: ${data}\n\n`;
 const identityFormat = (data) => data;
 const textEncoder = new TextEncoder();
 const encodeChunk = (s) => textEncoder.encode(s);
+function normalizeContentType(contentType) {
+	if (contentType === "application/json") return contentType;
+	const end = contentType.indexOf(";");
+	return (end === -1 ? contentType : contentType.slice(0, end)).trim().toLowerCase();
+}
 function handleFile(response, set, request, size = response.size) {
 	if (!require_universal_constants.isBun && response instanceof Promise) return response.then((res) => handleFile(res, set, request, size));
 	const rangeHeader = request?.headers.get("range");
@@ -92,6 +103,7 @@ function parseSetCookies(headers, setCookie) {
 }
 function responseToSetHeaders(response, set) {
 	if (set && set.headers instanceof Headers) normalizeHeaders(set);
+	if (set) materializeSetHeaders(set);
 	if (set?.headers) {
 		if (response) if (require_universal_constants.hasHeaderShorthand) Object.assign(set.headers, response.headers.toJSON());
 		else for (const [key, value] of response.headers.entries()) set.headers[key] = value;
@@ -148,6 +160,7 @@ function createStreamHandler({ mapResponse, mapCompactResponse }) {
 		const isSSE = !skipFormat && (init?.value?.sse ?? generator?.sse ?? (set?.headers instanceof Headers ? set.headers.get("content-type")?.startsWith("text/event-stream") : set?.headers["content-type"]?.startsWith("text/event-stream")));
 		const format = isSSE ? sseFormat : identityFormat;
 		const contentType = isSSE ? "text/event-stream" : init?.value && typeof init?.value === "object" ? ArrayBuffer.isView(init.value) ? "application/octet-stream" : "application/json" : "text/plain";
+		if (set) materializeSetHeaders(set);
 		const headers = set?.headers;
 		if (headers instanceof Headers) {
 			if (!headers.has("transfer-encoding")) headers.set("transfer-encoding", "chunked");
@@ -259,6 +272,7 @@ function handleSet(set) {
 		set.headers = flat;
 	}
 	if (set.cookie && require_utils.isNotEmpty(set.cookie)) {
+		materializeSetHeaders(set);
 		const cookie = require_cookie_serialize.serializeCookie(set.cookie);
 		if (cookie) {
 			const existing = set.headers[setCookie];
@@ -513,6 +527,8 @@ exports.createResponseHandler = createResponseHandler;
 exports.createStreamHandler = createStreamHandler;
 exports.handleFile = handleFile;
 exports.handleSet = handleSet;
+exports.materializeSetHeaders = materializeSetHeaders;
+exports.normalizeContentType = normalizeContentType;
 exports.parseSetCookies = parseSetCookies;
 exports.responseToSetHeaders = responseToSetHeaders;
 exports.streamResponse = streamResponse;