elysia 2.0.0-beta.1 → 2.0.0-beta.3

package/dist/adapter/utils.d.ts

@@ -1,6 +1,6 @@
 import { BaseCookie } from "../cookie/types.js";
-import { StatusMap } from "../constants.js";
 import { ElysiaFile } from "../universal/file.js";
+import { StatusMap } from "../constants.js";
 import { HTTPHeaders } from "../types.js";
 import { Context } from "../context.js";
 //#region src/adapter/utils.d.ts
@@ -14,7 +14,7 @@ declare function responseToSetHeaders(response: Response, set?: Context['set']):
   cookie?: Record<string, BaseCookie>;
 } | {
   headers: any;
-  status: number | "Not Found" | "Continue" | "Switching Protocols" | "Processing" | "Early Hints" | "OK" | "Created" | "Accepted" | "Non-Authoritative Information" | "No Content" | "Reset Content" | "Partial Content" | "Multi-Status" | "Already Reported" | "Multiple Choices" | "Moved Permanently" | "Found" | "See Other" | "Not Modified" | "Temporary Redirect" | "Permanent Redirect" | "Bad Request" | "Unauthorized" | "Payment Required" | "Forbidden" | "Method Not Allowed" | "Not Acceptable" | "Proxy Authentication Required" | "Request Timeout" | "Conflict" | "Gone" | "Length Required" | "Precondition Failed" | "Payload Too Large" | "URI Too Long" | "Unsupported Media Type" | "Range Not Satisfiable" | "Expectation Failed" | "I'm a teapot" | "Enhance Your Calm" | "Misdirected Request" | "Unprocessable Content" | "Locked" | "Failed Dependency" | "Too Early" | "Upgrade Required" | "Precondition Required" | "Too Many Requests" | "Request Header Fields Too Large" | "Unavailable For Legal Reasons" | "Internal Server Error" | "Not Implemented" | "Bad Gateway" | "Service Unavailable" | "Gateway Timeout" | "HTTP Version Not Supported" | "Variant Also Negotiates" | "Insufficient Storage" | "Loop Detected" | "Not Extended" | "Network Authentication Required";
+  status: number | "Continue" | "Switching Protocols" | "Processing" | "Early Hints" | "OK" | "Created" | "Accepted" | "Non-Authoritative Information" | "No Content" | "Reset Content" | "Partial Content" | "Multi-Status" | "Already Reported" | "Multiple Choices" | "Moved Permanently" | "Found" | "See Other" | "Not Modified" | "Temporary Redirect" | "Permanent Redirect" | "Bad Request" | "Unauthorized" | "Payment Required" | "Forbidden" | "Not Found" | "Method Not Allowed" | "Not Acceptable" | "Proxy Authentication Required" | "Request Timeout" | "Conflict" | "Gone" | "Length Required" | "Precondition Failed" | "Payload Too Large" | "URI Too Long" | "Unsupported Media Type" | "Range Not Satisfiable" | "Expectation Failed" | "I'm a teapot" | "Enhance Your Calm" | "Misdirected Request" | "Unprocessable Content" | "Locked" | "Failed Dependency" | "Too Early" | "Upgrade Required" | "Precondition Required" | "Too Many Requests" | "Request Header Fields Too Large" | "Unavailable For Legal Reasons" | "Internal Server Error" | "Not Implemented" | "Bad Gateway" | "Service Unavailable" | "Gateway Timeout" | "HTTP Version Not Supported" | "Variant Also Negotiates" | "Insufficient Storage" | "Loop Detected" | "Not Extended" | "Network Authentication Required";
 };
 interface CreateHandlerParameter {
   mapResponse(response: unknown, set: Context['set'], request?: Request, owned?: boolean): Response;

package/dist/adapter/utils.js

@@ -14,7 +14,7 @@ function materializeSetHeaders(set) {
 	if (headers["\0"] !== headers) return headers;
 	return set.headers = Object.assign(require_utils.nullObject(), headers);
 }
-const sseFormat = (data) => `data: ${data}\n\n`;
+const sseFormat = (data) => require_utils.sseData(data) + "\n";
 const identityFormat = (data) => data;
 const textEncoder = new TextEncoder();
 const encodeChunk = (s) => textEncoder.encode(s);
@@ -284,7 +284,7 @@ function handleSet(set) {
 	const proto = Object.getPrototypeOf(set.headers);
 	if (proto !== null && proto !== Object.prototype) {
 		const flat = Object.create(null);
-		for (const key in set.headers) flat[key] = set.headers[key];
+		for (const key of Object.keys(set.headers)) flat[key] = set.headers[key];
 		set.headers = flat;
 	}
 	if (set.cookie && require_utils.isNotEmpty(set.cookie)) {
@@ -311,7 +311,7 @@ function applySetHeaders(target, setHeaders, present) {
 		for (const key of setHeaders.keys()) if (key !== setCookie && !present.has(key)) target.set(key, setHeaders.get(key) ?? "");
 	} else {
 		let cookies;
-		for (const key in setHeaders) if (key === setCookie) {
+		for (const key of Object.keys(setHeaders)) if (key === setCookie) {
 			const cookie = setHeaders[key];
 			cookies ??= target.getSetCookie();
 			if (!cookies.includes(cookie)) {

package/dist/adapter/utils.mjs

@@ -1,6 +1,6 @@
 import { hasHeaderShorthand, isBun } from "../universal/constants.mjs";
 import { StatusMap } from "../constants.mjs";
-import { isByteStream, isNotEmpty, nullObject } from "../utils.mjs";
+import { isByteStream, isNotEmpty, nullObject, sseData } from "../utils.mjs";
 import { skipClone } from "./skip-clone.mjs";
 import { serializeCookie } from "../cookie/serialize.mjs";
 import { isBorrowedResponse } from "./response-ownership.mjs";
@@ -13,7 +13,7 @@ function materializeSetHeaders(set) {
 	if (headers["\0"] !== headers) return headers;
 	return set.headers = Object.assign(nullObject(), headers);
 }
-const sseFormat = (data) => `data: ${data}\n\n`;
+const sseFormat = (data) => sseData(data) + "\n";
 const identityFormat = (data) => data;
 const textEncoder = new TextEncoder();
 const encodeChunk = (s) => textEncoder.encode(s);
@@ -283,7 +283,7 @@ function handleSet(set) {
 	const proto = Object.getPrototypeOf(set.headers);
 	if (proto !== null && proto !== Object.prototype) {
 		const flat = Object.create(null);
-		for (const key in set.headers) flat[key] = set.headers[key];
+		for (const key of Object.keys(set.headers)) flat[key] = set.headers[key];
 		set.headers = flat;
 	}
 	if (set.cookie && isNotEmpty(set.cookie)) {
@@ -310,7 +310,7 @@ function applySetHeaders(target, setHeaders, present) {
 		for (const key of setHeaders.keys()) if (key !== setCookie && !present.has(key)) target.set(key, setHeaders.get(key) ?? "");
 	} else {
 		let cookies;
-		for (const key in setHeaders) if (key === setCookie) {
+		for (const key of Object.keys(setHeaders)) if (key === setCookie) {
 			const cookie = setHeaders[key];
 			cookies ??= target.getSetCookie();
 			if (!cookies.includes(cookie)) {

package/dist/adapter/web-standard/handler.js

@@ -5,6 +5,7 @@ const require_utils = require('../../utils.js');
 const require_error = require('../../error.js');
 const require_adapter_default_headers = require('../default-headers.js');
 const require_adapter_utils = require('../utils.js');
+const require_cookie_cookie = require('../../cookie/cookie.js');
 
 //#region src/adapter/web-standard/handler.ts
 const textPlainInit = { headers: { "content-type": "text/plain" } };
@@ -21,16 +22,22 @@ function handleElysiaFile(file, set = { headers: require_utils.nullObject() }, r
 	});
 	return require_adapter_utils.handleFile(file.value, set, request);
 }
+function responseTag(response) {
+	if (response == null) return;
+	const constructor = Object.getPrototypeOf(response)?.constructor;
+	if (typeof constructor !== "function") return typeof response.next === "function" ? "" : void 0;
+	return constructor.name;
+}
 function mapResponseWithSet(response, set, request, owned) {
 	require_adapter_utils.handleSet(set);
 	const headers = set.headers;
-	switch (response?.constructor?.name) {
+	switch (responseTag(response)) {
 		case "String":
 			if (!require_universal_constants.isBun && !headers["content-type"]) require_adapter_utils.materializeSetHeaders(set)["content-type"] = "text/plain";
 			return new Response(response, set);
 		case "Array": return Response.json(response, set);
+		case "ElysiaForm": return new Response(require_utils.formToFormData(response), set);
 		case "Object":
-			if (response["~ely-form"]) return new Response(require_utils.formToFormData(response), set);
 			if (typeof response?.next === "function") return handleStream(response, set, request, void 0, owned);
 			return Response.json(response, set);
 		case "Number":
@@ -66,12 +73,11 @@ function mapResponse(response, set, request, owned) {
 }
 const textHeaders = require_universal_constants.isBun ? void 0 : textPlainInit;
 function mapCompactResponse(response, request, owned) {
-	switch (response?.constructor?.name) {
+	switch (responseTag(response)) {
 		case "String": return new Response(response, textHeaders);
 		case "Array": return Response.json(response);
-		case "Object":
-			if (response["~ely-form"]) return new Response(require_utils.formToFormData(response));
-			return Response.json(response);
+		case "ElysiaForm": return new Response(require_utils.formToFormData(response));
+		case "Object": return Response.json(response);
 		case "Number":
 		case "Boolean": return new Response(typeof response === "boolean" ? response ? "true" : "false" : response.toString());
 		case "ElysiaFile": return handleElysiaFile(response, void 0, request);
@@ -126,11 +132,12 @@ function mapFallback(response, set, request, owned = false) {
 		headers: response.headers ? { ...response.headers } : {}
 	}, request, owned);
 	if (response instanceof require_universal_file.ElysiaFile) return handleElysiaFile(response, void 0, request);
+	if (require_utils.isElysiaForm(response)) return new Response(require_utils.formToFormData(response), set);
 	if (typeof response?.next === "function" || response instanceof ReadableStream) return handleStream(response, set, request, void 0, owned);
 	if (typeof response?.then === "function") return response.then((x) => set ? mapResponse(x, set, request, owned) : mapCompactResponse(x, request, owned));
 	if (Array.isArray(response)) return Response.json(response);
 	if (typeof response?.toResponse === "function") return set ? mapResponse(response.toResponse(), set, request, owned) : mapCompactResponse(response.toResponse(), request, owned);
-	if (response?.constructor?.name === "Cookie" && response.jar) return new Response(response.value, set);
+	if (responseTag(response) === "Cookie" && require_cookie_cookie.Cookie.isCookie(response)) return set ? mapResponse(response.value, set, request, owned) : mapCompactResponse(response.value, request, owned);
 	return new Response(response, set);
 }
 const handleResponse = require_adapter_utils.createResponseHandler({

package/dist/adapter/web-standard/handler.mjs

@@ -1,9 +1,10 @@
 import { isBun } from "../../universal/constants.mjs";
 import { ElysiaFile, mime } from "../../universal/file.mjs";
-import { formToFormData, isNotEmpty, nullObject } from "../../utils.mjs";
+import { formToFormData, isElysiaForm, isNotEmpty, nullObject } from "../../utils.mjs";
 import { ElysiaStatus, PROBLEM_JSON, internalServerErrorBody } from "../../error.mjs";
 import { defaultHeaders } from "../default-headers.mjs";
 import { createResponseHandler, createStreamHandler, handleFile, handleSet, materializeSetHeaders } from "../utils.mjs";
+import { Cookie } from "../../cookie/cookie.mjs";
 
 //#region src/adapter/web-standard/handler.ts
 const textPlainInit = { headers: { "content-type": "text/plain" } };
@@ -20,16 +21,22 @@ function handleElysiaFile(file, set = { headers: nullObject() }, request) {
 	});
 	return handleFile(file.value, set, request);
 }
+function responseTag(response) {
+	if (response == null) return;
+	const constructor = Object.getPrototypeOf(response)?.constructor;
+	if (typeof constructor !== "function") return typeof response.next === "function" ? "" : void 0;
+	return constructor.name;
+}
 function mapResponseWithSet(response, set, request, owned) {
 	handleSet(set);
 	const headers = set.headers;
-	switch (response?.constructor?.name) {
+	switch (responseTag(response)) {
 		case "String":
 			if (!isBun && !headers["content-type"]) materializeSetHeaders(set)["content-type"] = "text/plain";
 			return new Response(response, set);
 		case "Array": return Response.json(response, set);
+		case "ElysiaForm": return new Response(formToFormData(response), set);
 		case "Object":
-			if (response["~ely-form"]) return new Response(formToFormData(response), set);
 			if (typeof response?.next === "function") return handleStream(response, set, request, void 0, owned);
 			return Response.json(response, set);
 		case "Number":
@@ -65,12 +72,11 @@ function mapResponse(response, set, request, owned) {
 }
 const textHeaders = isBun ? void 0 : textPlainInit;
 function mapCompactResponse(response, request, owned) {
-	switch (response?.constructor?.name) {
+	switch (responseTag(response)) {
 		case "String": return new Response(response, textHeaders);
 		case "Array": return Response.json(response);
-		case "Object":
-			if (response["~ely-form"]) return new Response(formToFormData(response));
-			return Response.json(response);
+		case "ElysiaForm": return new Response(formToFormData(response));
+		case "Object": return Response.json(response);
 		case "Number":
 		case "Boolean": return new Response(typeof response === "boolean" ? response ? "true" : "false" : response.toString());
 		case "ElysiaFile": return handleElysiaFile(response, void 0, request);
@@ -125,11 +131,12 @@ function mapFallback(response, set, request, owned = false) {
 		headers: response.headers ? { ...response.headers } : {}
 	}, request, owned);
 	if (response instanceof ElysiaFile) return handleElysiaFile(response, void 0, request);
+	if (isElysiaForm(response)) return new Response(formToFormData(response), set);
 	if (typeof response?.next === "function" || response instanceof ReadableStream) return handleStream(response, set, request, void 0, owned);
 	if (typeof response?.then === "function") return response.then((x) => set ? mapResponse(x, set, request, owned) : mapCompactResponse(x, request, owned));
 	if (Array.isArray(response)) return Response.json(response);
 	if (typeof response?.toResponse === "function") return set ? mapResponse(response.toResponse(), set, request, owned) : mapCompactResponse(response.toResponse(), request, owned);
-	if (response?.constructor?.name === "Cookie" && response.jar) return new Response(response.value, set);
+	if (responseTag(response) === "Cookie" && Cookie.isCookie(response)) return set ? mapResponse(response.value, set, request, owned) : mapCompactResponse(response.value, request, owned);
 	return new Response(response, set);
 }
 const handleResponse = createResponseHandler({

package/dist/base.d.ts

@@ -1,8 +1,8 @@
-import { ElysiaStatus } from "./error.js";
 import { TraceCapability, TraceHandler } from "./trace.js";
 import { ListenCallback, Serve, Server } from "./universal/server.js";
-import { AddRoute, AddWSRoute, AfterHandler, AfterResponseHandler, AnyErrorConstructor, AnyLocalHook, BodyHandler, CompiledHandler, CreateEden, DefaultEphemeral, DefaultMetadata, DefaultSingleton, DefinitionBase, DocumentDecoration, ElysiaConfig, ElysiaHandlerToResponseSchemaAmbiguous, EphemeralType, ErrorDefinitionEntry, ErrorHandler, EventScope, ExcludeElysiaResponse, ExtractErrorFromHandle, GlobalHookReturn, GracefulHandler, GuardHookSingleton, GuardLocalHook, HTTPMethod, HistoryEntry, HookContextSchema, HookContextSingleton, InlineHandler, InlineHandlerNonMacro, InputSchema, InputSchemaKey, InternalRoute, IntersectIfObjectSchema, JoinPath, LocalHook, LocalHookReturn, Macro, MacroSchemaChannel, MacroToContext, MacroToProperty, MapResponse, MaybeArray, MaybePromise, MergeElysiaInstances, MergeSchema, MergeScopedSchemas, MetadataBase, NonResolvableMacroKey, ObjectMacroDefs, OptionalHandler, PluginHookReturn, PreHandler, Prettify, PublicRoute, ResolveRouteErrors, RouteBase, ScopedHookReturn, ScopedMapDeriveReturn, SingletonBase, StaticMapAliases, TransformHandler, UnionResponseStatus, UnwrapRoute, WrapFn } from "./types.js";
 import { ChainNode } from "./utils.js";
+import { AddRoute, AddWSRoute, AfterHandler, AfterResponseHandler, AnyErrorConstructor, AnyLocalHook, BodyHandler, CompiledHandler, CreateEden, DefaultEphemeral, DefaultMetadata, DefaultSingleton, DefinitionBase, DocumentDecoration, ElysiaConfig, ElysiaHandlerToResponseSchemaAmbiguous, EphemeralType, ErrorDefinitionEntry, ErrorHandler, EventScope, ExcludeElysiaResponse, ExtractErrorFromHandle, GlobalHookReturn, GracefulHandler, GuardHookSingleton, GuardLocalHook, HTTPMethod, HistoryEntry, HookContextSchema, HookContextSingleton, InlineHandler, InlineHandlerNonMacro, InputSchema, InputSchemaKey, InternalRoute, IntersectIfObjectSchema, JoinPath, LocalHook, LocalHookReturn, Macro, MacroSchemaChannel, MacroToContext, MacroToProperty, MapResponse, MaybeArray, MaybePromise, MergeElysiaInstances, MergeSchema, MergeScopedSchemas, MetadataBase, NonResolvableMacroKey, ObjectMacroDefs, OptionalHandler, PluginHookReturn, PreHandler, Prettify, PublicRoute, ResolveRouteErrors, RouteBase, ScopedHookReturn, ScopedMapDeriveReturn, SingletonBase, StaticMapAliases, TransformHandler, UnionResponseStatus, UnwrapRoute, WrapFn } from "./types.js";
+import { ElysiaStatus } from "./error.js";
 import { Context, ErrorContext, LifecycleContext } from "./context.js";
 import { AnySchema } from "./type/types.js";
 import { AotFingerprint, CompilerSession, ProgramId } from "./compile/aot.js";
@@ -66,7 +66,7 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
   '~hasDynamicWS'?: boolean;
   '~hasTrace'?: boolean;
   '~finalizeError'?: (context: Context, error: Error) => MaybePromise<Response>;
-  '~programId': ProgramId;
+  get ['~programId'](): ProgramId;
   '~aotFingerprint'?: AotFingerprint;
   '~compilerSession'?: CompilerSession;
   '~generation'?: Generation;
@@ -559,7 +559,7 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
     parser: Metadata['parser'];
     response: Metadata['response'];
   }, Routes, Ephemeral, Volatile>;
-  '~applyMacro'(input: Partial<AnyLocalHook>, toApply?: Partial<AnyLocalHook>, iteration?: number, seen?: Set<string | Partial<any>>): Partial<AnyLocalHook>;
+  '~applyMacro'(input: Partial<AnyLocalHook>, toApply?: Partial<AnyLocalHook>, iteration?: number, seen?: Set<string | Partial<any>>, insertions?: Map<string, number>): Partial<AnyLocalHook>;
   /**
    * Merge a plugin instance
    */
@@ -864,11 +864,26 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
    * on the config and triggers a fresh build of the fetch handler).
    */
   compile(): this;
-  handler(index: number, immediate?: boolean | undefined, route?: InternalRoute, precomputedStatic?: Response, aliases?: StaticMapAliases, table?: RouteTable): CompiledHandler;
+  handler(index: number, immediate?: boolean, route?: InternalRoute, precomputedStatic?: Response, aliases?: StaticMapAliases, table?: RouteTable): CompiledHandler;
   ['~newGeneration'](): this;
   get fetch(): (request: Request, ...rest: any[]) => MaybePromise<Response>;
   get handle(): (url: string | Request, options?: RequestInit) => Promise<Response>;
   listen(options: string | number | Partial<Serve>, callback?: ListenCallback): this;
+  /**
+   * Add a higher order function over Elysia.fetch
+   *
+   * @example
+   * ```ts
+   * const ctx = new AsyncLocalStorage<{ counter: number }>()
+   *
+   * new Elysia()
+   *	.wrap(
+   *		(fetch) => (request) =>
+   *			ctx.run({ counter: 0 }, () => fetch(request))
+   *	)
+   *	.get('/', () => ctx.getStore())
+   * ```
+   */
   wrap<T extends (...params: any) => MaybePromise<Response> = (request: Request, ...rest: any[]) => MaybePromise<Response>>(callback: WrapFn<T>): this;
   /**
    * ### cleanup | Life cycle event

package/dist/base.js

@@ -19,6 +19,29 @@ memoirist = require_runtime.__toESM(memoirist);
 const useNodesBuffer = [];
 const emptyHistory = Object.freeze([]);
 const canRegisterLoose = (path, isDynamic) => !isDynamic && (path.length === 0 || path.charCodeAt(path.length - 1) === 47);
+/**
+* Every key a single route must answer to, in registration order.
+*
+* `registerLoose` is the caller's call, not this helper's: HTTP gates it on
+* `canRegisterLoose` because its lookup retries the trailing slash, while WS
+* has no such retry and must own both directions outright
+*/
+const expandPaths = (path, needsEncode, registerLoose, explicit) => {
+	const variants = [path];
+	if (needsEncode) {
+		const encoded = encodeURI(path);
+		if (encoded !== path) variants.push(encoded);
+	}
+	if (!registerLoose) return variants;
+	const paths = [];
+	for (let v = 0; v < variants.length; v++) {
+		const p = variants[v];
+		paths.push(p);
+		const loose = require_utils.getLoosePath(p);
+		if (loose !== p && !explicit?.has(loose)) paths.push(loose);
+	}
+	return paths;
+};
 var Elysia = class Elysia {
 	#hasPlugin;
 	#hasGlobal;
@@ -80,11 +103,14 @@ var Elysia = class Elysia {
 	#jitRoute;
 	#jitStatic;
 	#jitAliases;
+	get ["~programId"]() {
+		return this;
+	}
 	constructor(config) {
 		/**
 		* ! Don't tune
 		*
-		* Interesting JSC internal: These `= undefined` are load-bearing
+		* Interesting JSC internal: These `= undefined` shouldn't be removed
 		*
 		* Inline slots live inside the object cell, so JSC must pick their
 		* count at allocation before any initializer runs
@@ -102,7 +128,8 @@ var Elysia = class Elysia {
 		* Don't omitted field either for monomorphic access
 		*
 		* @see test/memory/instance-footprint.test.ts
-		* Est. Overflow 37 -> 21 = butterfly 64 -> 32 slots = 738B -> 450B/instance
+		* Est. overflow 37 -> 21 = butterfly 64 -> 32 slots = 738B -> 450B;
+		* reusing the app as its program identity brings the current cell to ~386B.
 		**/
 		this["~config"] = config;
 		this["~ext"] = void 0;
@@ -122,7 +149,6 @@ var Elysia = class Elysia {
 		this["~introspect"] = void 0;
 		this["~scopeChild"] = void 0;
 		this["~scopeChildren"] = void 0;
-		this["~programId"] = require_compile_aot.createProgramId();
 		if (config) {
 			const { prefix, name, seed, adapter } = config;
 			this["~Prefix"] = prefix ? prefix.charCodeAt(0) === 47 ? prefix : `/${prefix}` : void 0;
@@ -502,7 +528,7 @@ var Elysia = class Elysia {
 		require_utils.invalidateMacroEpoch();
 		return this;
 	}
-	"~applyMacro"(input, toApply = input, iteration = 0, seen = /* @__PURE__ */ new Set()) {
+	"~applyMacro"(input, toApply = input, iteration = 0, seen = /* @__PURE__ */ new Set(), insertions = /* @__PURE__ */ new Map()) {
 		if (iteration >= 16) return input;
 		const macro = this["~ext"]?.macro;
 		if (!macro) return input;
@@ -547,7 +573,7 @@ var Elysia = class Elysia {
 					continue;
 				}
 				if (k in macro) {
-					this["~applyMacro"](input, { [k]: v }, iteration + 1, seen);
+					this["~applyMacro"](input, { [k]: v }, iteration + 1, seen, insertions);
 					delete input[key];
 					continue;
 				}
@@ -568,19 +594,20 @@ var Elysia = class Elysia {
 					delete input[key];
 					continue;
 				}
-				if (k in input) {
-					if (require_utils.eventProperties.has(k) || k === "derive") {
-						const macroFns = Array.isArray(v) ? v : [v];
-						const existing = Array.isArray(input[k]) ? input[k] : [input[k]];
-						const merged = [];
-						const seen = /* @__PURE__ */ new Set();
-						for (const fn of macroFns) if (!existing.includes(fn) && !seen.has(fn)) {
-							seen.add(fn);
-							merged.push(fn);
-						}
-						for (const fn of existing) if (!seen.has(fn)) merged.push(fn);
-						input[k] = merged;
-					} else if (Array.isArray(input[k])) {
+				if (require_utils.eventProperties.has(k) || k === "derive") {
+					const incoming = Array.isArray(v) ? v : [v];
+					const existing = k in input ? Array.isArray(input[k]) ? input[k] : [input[k]] : [];
+					const added = [];
+					for (const fn of incoming) if (!existing.includes(fn) && !added.includes(fn)) added.push(fn);
+					const at = insertions.get(k) ?? 0;
+					input[k] = [
+						...existing.slice(0, at),
+						...added,
+						...existing.slice(at)
+					];
+					insertions.set(k, at + added.length);
+				} else if (k in input) {
+					if (Array.isArray(input[k])) {
 						if (Array.isArray(v)) {
 							for (const item of v) if (!input[k].some((e) => e === item)) input[k].unshift(item);
 						} else if (!input[k].some((item) => item === v)) input[k].unshift(v);
@@ -1182,10 +1209,10 @@ var Elysia = class Elysia {
 		this.fetch;
 		return this;
 	}
-	handler(index, immediate = this["~config"]?.precompile, route, precomputedStatic, aliases, table) {
+	handler(index, immediate, route, precomputedStatic, aliases, table) {
 		if (this.#compiled?.[index]) return this.#compiled[index];
 		const compiled = this.#compiled ??= new Array(table?.length ?? this["~routes"].length);
-		if (immediate) {
+		if (immediate ?? this["~config"]?.precompile) {
 			const row = route ?? (table ? require_route_table.routeRow(table, index) : this["~routes"][index]);
 			let handler;
 			try {
@@ -1413,7 +1440,10 @@ var Elysia = class Elysia {
 		const appChain = this["~hookChain"];
 		if (this["~ext"]?.macro || this["~scopeChildren"] || appChain !== void 0 && appChain.refs) for (let i = 0; i < length; i++) this.#assertRouteModelRefs(require_route_table.routeRow(table, i), method[i]);
 		else for (let i = 0; i < length; i++) if (this.#routeMayHaveModelRef(table, i)) this.#assertRouteModelRefs(require_route_table.routeRow(table, i), method[i]);
-		if (length) require_compile_aot.Compiled.claim(this["~programId"], this["~aotFingerprint"] = require_compile_aot.createAotFingerprint());
+		if (length) {
+			const programId = this["~programId"];
+			if (!require_compile_aot.Compiled.claim(programId, this["~aotFingerprint"] = require_compile_aot.createAotFingerprint())) require_compile_aot.Compiled.assertUncontested(programId);
+		}
 		const isLoose = this["~config"]?.strictPath !== true;
 		let explicitPaths;
 		if (isLoose && table.hasLoose) {
@@ -1439,17 +1469,17 @@ var Elysia = class Elysia {
 				const handler = ws[0];
 				const options = ws[1];
 				if (wsConfig === void 0 && wsCap.options) wsConfig = wsCap.options;
+				const wsNeedsEncode = (routeFlags & require_route_table.RouteFlag.Encode) !== 0;
 				if ((routeFlags & require_route_table.RouteFlag.Dynamic) !== 0) {
-					(this["~router"] ??= new memoirist.default({ loosePath: isLoose })).add("WS", routePath, handler);
+					const wsRouter = this["~router"] ??= new memoirist.default({ loosePath: isLoose });
+					const wsPaths = expandPaths(routePath, wsNeedsEncode, false, void 0);
+					for (let v = 0; v < wsPaths.length; v++) wsRouter.add("WS", wsPaths[v], handler);
 					this["~hasDynamicWS"] = true;
 				} else {
 					this.#initMap();
 					const wsMap = this["~map"]["WS"] ??= require_utils.nullObject();
-					wsMap[routePath] = handler;
-					if (isLoose) {
-						const loose = require_utils.getLoosePath(routePath);
-						if (loose !== routePath && !explicitPaths?.get("WS")?.has(loose)) wsMap[loose] = handler;
-					}
+					const wsPaths = expandPaths(routePath, wsNeedsEncode, isLoose, isLoose ? explicitPaths?.get("WS") : void 0);
+					for (let v = 0; v < wsPaths.length; v++) wsMap[wsPaths[v]] = handler;
 				}
 				if (options && require_utils.isNotEmpty(options)) {
 					wsConfig ??= require_utils.nullObject();
@@ -1460,26 +1490,12 @@ var Elysia = class Elysia {
 			const isDynamic = (routeFlags & require_route_table.RouteFlag.Dynamic) !== 0;
 			const needsEncode = (routeFlags & require_route_table.RouteFlag.Encode) !== 0;
 			const registerLoose = isLoose && canRegisterLoose(routePath, isDynamic);
-			const explicitMain = registerLoose ? explicitPaths?.get(routeMethod) : void 0;
 			if (!isDynamic && !needsEncode && !registerLoose) {
 				const map = methods[routeMethod] ??= require_utils.nullObject();
 				map[routePath] = this.handler(i, precompile, void 0, void 0, void 0, table);
 				continue;
 			}
-			const variants = [routePath];
-			if (needsEncode) {
-				const encoded = encodeURI(routePath);
-				if (encoded !== routePath) variants.push(encoded);
-			}
-			const paths = [];
-			for (let v = 0; v < variants.length; v++) {
-				const p = variants[v];
-				paths.push(p);
-				if (registerLoose) {
-					const loose = require_utils.getLoosePath(p);
-					if (loose !== p && !explicitMain?.has(loose)) paths.push(loose);
-				}
-			}
+			const paths = expandPaths(routePath, needsEncode, registerLoose, registerLoose ? explicitPaths?.get(routeMethod) : void 0);
 			if (isDynamic) {
 				const router = this["~router"] ??= new memoirist.default({ loosePath: isLoose });
 				const handler = this.handler(i, precompile, void 0, void 0, void 0, table);
@@ -1511,6 +1527,21 @@ var Elysia = class Elysia {
 		if (!require_compile_aot.Capture.isAotBuildEnv()) listen(this, options, callback);
 		return this;
 	}
+	/**
+	* Add a higher order function over Elysia.fetch
+	*
+	* @example
+	* ```ts
+	* const ctx = new AsyncLocalStorage<{ counter: number }>()
+	*
+	* new Elysia()
+	*	.wrap(
+	*		(fetch) => (request) =>
+	*			ctx.run({ counter: 0 }, () => fetch(request))
+	*	)
+	*	.get('/', () => ctx.getStore())
+	* ```
+	*/
 	wrap(callback) {
 		this.#assertMutable("wrap");
 		if (this.#fetchFn && !this.#pending) console.warn("[Elysia] .wrap() was called after the fetch handler was built");