elysia 2.0.0-beta.11 → 2.0.0-beta.13

package/dist/base.mjs

@@ -1,10 +1,10 @@
 import { isBun } from "./universal/constants.mjs";
 import { clonePlainDecorators, clonePlainDeep, coalesceSchemas, createErrorEventHandler, eventProperties, fnOrigin, fnv1a, getLoosePath, guardNonPlainLeaves, hookToGuard, invalidateMacroEpoch, isEmpty, isNotEmpty, isRecordNumber, joinPath, macroOrigin, mapDeriveEntry, mergeDeep, mergeResponse, nullObject, pushField, schemaProperties, serializeMacroSeed, throwLifecycleErrors } from "./utils.mjs";
-import { Ref } from "./type/bridge.mjs";
+import { Ref, warmTypebox } from "./type/bridge.mjs";
 import { isProduction } from "./universal/is-production.mjs";
 import { Capture, Compiled, beginCompilerSession, createAotFingerprint, endCompilerSession } from "./compile/aot.mjs";
 import { traceCapabilityRequired, wsCapabilityRequired } from "./generation.mjs";
-import { compileHandler, composeRouteHook, localMacroRoot, resolveLocalHook } from "./compile/handler/index.mjs";
+import { chainResolver, compileHandler, composeRouteHook, localMacroRoot, resolveLocalHook } from "./compile/handler/index.mjs";
 import { RouteFlag, buildRouteTable, routeRow } from "./route-table.mjs";
 import { BunAdapter } from "./adapter/bun/index.mjs";
 import { clearContextCache } from "./context.mjs";
@@ -42,6 +42,42 @@ const mergeExtCallbacks = (target, incoming) => {
 	index.indexedLength = target.length;
 };
 const canRegisterLoose = (path, isDynamic) => !isDynamic && (path.length === 0 || path.charCodeAt(path.length - 1) === 47);
+const isSchemaValue = (value) => {
+	if (value == null || typeof value === "string") return true;
+	if (typeof value !== "object" && typeof value !== "function") return false;
+	return "~kind" in value || "~standard" in value || "~elyAcl" in value || typeof value.Check === "function";
+};
+const hookKeys = new Set([
+	...schemaProperties,
+	...eventProperties,
+	"detail",
+	"tags"
+]);
+const hasHookKeys = (value) => {
+	for (const key in value) if (hookKeys.has(key)) return true;
+	return false;
+};
+const isPlainObject = (value) => {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+	const proto = Object.getPrototypeOf(value);
+	return proto === Object.prototype || proto === null;
+};
+const assertSchemaShape = (hook, where) => {
+	for (const key in hook) {
+		if (!schemaProperties.has(key)) continue;
+		const value = hook[key];
+		if (isSchemaValue(value)) continue;
+		if (key === "response" && isPlainObject(value)) {
+			let isStatusMap = true;
+			for (const status in value) if (status !== "default" && isNaN(+status) || !isSchemaValue(value[status])) {
+				isStatusMap = false;
+				break;
+			}
+			if (isStatusMap) continue;
+		}
+		throw new Error(`[Elysia] ${where}: "${key}" is not a schema — use t.Object({ ... })`);
+	}
+};
 /**
 * Every key a single route must answer to, in registration order.
 *
@@ -170,6 +206,11 @@ var Elysia = class Elysia {
 			if (adapter?.setup) this.#useFn(adapter.setup);
 		} else this["~Prefix"] = void 0;
 	}
+	/**
+	* Every registered route with its merged hooks.
+	* Development shares a frozen cache. Production rebuilds the list so its
+	* metadata can be released after startup.
+	*/
 	get routes() {
 		const generation = this["~generation"];
 		if (this.#isCacheable && this.cachedGeneration === generation && this.cachedEpoch === mutationEpoch && this.cachedRoutes !== void 0) return this.cachedRoutes;
@@ -189,7 +230,8 @@ var Elysia = class Elysia {
 				hooks: merged
 			};
 		});
-		if (this.#isCacheable) {
+		if (this.#isCacheable && !isProduction()) {
+			Object.freeze(routes);
 			this.#cacheRoutes(generation);
 			this.cachedRoutes = routes;
 		}
@@ -425,6 +467,7 @@ var Elysia = class Elysia {
 		return this;
 	}
 	#guard(scope, hook) {
+		if (hook) assertSchemaShape(hook, ".guard()");
 		hook = snapshotHookSchemas(hook);
 		hookToGuard(hook);
 		const trackFn = (fn) => {
@@ -537,13 +580,17 @@ var Elysia = class Elysia {
 		};
 		return this;
 	}
-	macro(macro) {
+	macro(macro, definition) {
 		this.#assertMutable("macro");
 		if (typeof macro === "function") throw new Error("use `.macro({ name: fn })` instead of `.macro(fn)`");
+		if (definition != null || typeof macro === "string") throw new Error("[Elysia] .macro(name, definition) was removed in 2.0 — use .macro({ [name]: definition })");
 		const m = this.#ensureMacroTable();
 		const baseline = this.macroBaseline;
 		for (const key in macro) {
-			if (typeof macro[key] === "object") macro[key] = hookToGuard(macro[key]);
+			if (typeof macro[key] === "object") {
+				if (macro[key]) assertSchemaShape(macro[key], `.macro(${key})`);
+				macro[key] = hookToGuard(macro[key]);
+			}
 			if (this.hash !== void 0 && !macroOrigin.has(macro[key])) macroOrigin.set(macro[key], this.hash);
 			if (baseline?.has(key) && key in m && m[key] !== macro[key]) throw new Error(`[Elysia] Macro "${key}" can be only define once`);
 		}
@@ -1044,6 +1091,8 @@ var Elysia = class Elysia {
 	#add(method, path, hookOrFn, fn, hasHook = fn !== void 0) {
 		if (this["~Prefix"]) path = joinPath(this["~Prefix"], path);
 		else if (path && path.charCodeAt(0) !== 47) path = "/" + path;
+		if (typeof hookOrFn === "function" && !hasHookKeys(hookOrFn) && isPlainObject(fn) && hasHookKeys(fn)) throw new Error(`[Elysia] .${method === "*" ? "all" : method.toLowerCase()}('${path}', handler, hook) is the 1.x order; Elysia 2 takes (path, hook, handler) — see the 2.0 migration guide`);
+		if (hasHook && hookOrFn) assertSchemaShape(hookOrFn, `${method} ${path}`);
 		const handler = hasHook ? fn : hookOrFn;
 		const hook = hasHook ? snapshotHookSchemas(hookOrFn) : void 0;
 		const appHook = this["~hookChain"];
@@ -1395,6 +1444,56 @@ var Elysia = class Elysia {
 		}
 		return false;
 	}
+	static #slotHasTypeBox(value, models, record) {
+		if (typeof value === "string") value = models?.[value];
+		if (!value || typeof value !== "object") return false;
+		if ("~kind" in value || "~elyAcl" in value) return true;
+		if (!record || "~standard" in value) return false;
+		for (const status in value) if (Elysia.#slotHasTypeBox(value[status], models)) return true;
+		return false;
+	}
+	static #hookHasTypeBox(h, models) {
+		if (!h || typeof h !== "object") return false;
+		for (const key in h) {
+			if (key === "schemas") {
+				const schemas = h[key];
+				if (Array.isArray(schemas)) {
+					for (let s = 0; s < schemas.length; s++) if (Elysia.#hookHasTypeBox(schemas[s], models)) return true;
+				}
+				continue;
+			}
+			if (schemaProperties.has(key) && Elysia.#slotHasTypeBox(h[key], models, key === "response")) return true;
+		}
+		return false;
+	}
+	static #chainHasTypeBox(node, models, seen, resolve) {
+		while (node) {
+			if (seen.has(node)) return false;
+			seen.add(node);
+			if ("added" in node) {
+				if (Elysia.#hookHasTypeBox(resolve ? resolve(node) : node.added, models)) return true;
+				node = node.parent;
+			} else {
+				if (Elysia.#chainHasTypeBox(node.combine, models, seen, resolve)) return true;
+				node = node.over;
+			}
+		}
+		return false;
+	}
+	/**
+	* Scan each route and its inherited hooks for TypeBox schemas.
+	* This may warm TypeBox after a closer schema overrides it, avoiding a full
+	* hook merge during build.
+	*/
+	#hasTypeBoxSchema(table) {
+		const models = this["~ext"]?.models;
+		const resolve = chainResolver(this);
+		const rootChain = this["~hookChain"];
+		const seen = /* @__PURE__ */ new Set();
+		const { localHook, appHook, inheritedChain, owner } = table;
+		for (let i = 0; i < table.length; i++) if (Elysia.#hookHasTypeBox(localHook[i], models) || Elysia.#chainHasTypeBox(appHook[i], models, seen, resolve) || Elysia.#chainHasTypeBox(inheritedChain[i], models, seen, resolve) || owner[i] !== this && Elysia.#chainHasTypeBox(rootChain, models, seen, resolve)) return true;
+		return false;
+	}
 	#routeMayHaveModelRef(table, i) {
 		const macroScope = table.macroScope?.get(i);
 		const owner = table.owner[i];
@@ -1548,6 +1647,9 @@ 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(routeRow(table, i), method[i]);
 		else for (let i = 0; i < length; i++) if (this.#routeMayHaveModelRef(table, i)) this.#assertRouteModelRefs(routeRow(table, i), method[i]);
+		if (length && this.#hasTypeBoxSchema(table)) try {
+			warmTypebox();
+		} catch {}
 		let markDuplicates = false;
 		if (length) {
 			const programId = this["~programId"];
@@ -1637,7 +1739,10 @@ var Elysia = class Elysia {
 	}
 	listen(options, callback) {
 		const listen = (this["~config"]?.adapter ?? (isBun ? BunAdapter : void 0))?.listen;
-		if (!listen) throw new Error("No adapter provided for listen()");
+		if (!listen) {
+			const deno = typeof Deno !== "undefined";
+			throw new Error(`[Elysia] listen() requires an adapter on ${deno ? "Deno" : typeof process === "undefined" ? "this runtime" : "Node.js"} — https://elysiajs.com/integrations/${deno ? "deno" : "node"}`);
+		}
 		if (!Capture.isAotBuildEnv()) listen(this, options, callback);
 		return this;
 	}

package/dist/compile/aot-capture.d.ts

@@ -1,24 +1,13 @@
-import { CaptureImpl, CapturedHandler, CapturedValidator, CompiledSnapshot } from "./aot.js";
+import { CapturedHandler, CapturedValidator, CompiledSnapshot } from "./aot.js";
 
 //#region src/compile/aot-capture.d.ts
-declare function resetCompactErrorWarnings(): void;
 declare function beginValidatorCapture(): void;
 declare function abortCapture(): void;
 declare function endValidatorCapture(): CapturedValidator[];
 declare function endHandlerCapture(): CapturedHandler[];
-/** @internal deterministic session/capture assertions. */
-declare const getCompilerSessionDiagnostics: () => {
-  active: boolean;
-  appAttached: boolean;
-  validators: number;
-  handlers: number;
-  sucrose: number;
-};
 /** @internal preserve registry around in-process AOT analysis */
 declare const snapshotCompiled: () => CompiledSnapshot;
 /** @internal restore registry after in-process AOT analysis */
 declare function restoreCompiled(snapshot: CompiledSnapshot): void;
-declare const impl: CaptureImpl;
-declare function installCaptureImpl(): void;
 //#endregion
-export { abortCapture, beginValidatorCapture, impl as captureImplementation, endHandlerCapture, endValidatorCapture, getCompilerSessionDiagnostics, installCaptureImpl, resetCompactErrorWarnings, restoreCompiled, snapshotCompiled };
+export { abortCapture, beginValidatorCapture, endHandlerCapture, endValidatorCapture, restoreCompiled, snapshotCompiled };

package/dist/compile/aot-capture.js

@@ -13,8 +13,8 @@ const require_type_validator_frozen_check = require('../type/validator/frozen-ch
 const require_type_validator_custom_error = require('../type/validator/custom-error.js');
 const require_type_validator_exact_mirror = require('../type/validator/exact-mirror.js');
 const require_type_validator_string_codec_aot = require('../type/validator/string-codec-aot.js');
-let typebox_schema = require("typebox/schema");
 let typebox_value = require("typebox/value");
+let typebox_schema = require("typebox/schema");
 
 //#region src/compile/aot-capture.ts
 function emptyContainers(node, depth) {
@@ -254,9 +254,6 @@ function captureCodecMirror(schema, aot, slot, sanitize, dir) {
 }
 const compactErrorWarned = /* @__PURE__ */ new Set();
 const isVerboseAotWarnings = () => !!require_universal_env.env.ELYSIA_AOT_VERBOSE;
-function resetCompactErrorWarnings() {
-	compactErrorWarned.clear();
-}
 function warnCompactErrorLoss(aot, slot) {
 	const key = `${aot.method}\0${aot.path}\0${slot}`;
 	if (compactErrorWarned.has(key)) return;
@@ -266,7 +263,7 @@ function warnCompactErrorLoss(aot, slot) {
 function flushCompactErrorWarnings() {
 	const total = compactErrorWarned.size;
 	if (total > 0 && !isVerboseAotWarnings()) console.warn(`[elysia-aot]: ${total} sealed validator slot${total === 1 ? "" : "s"} ${total === 1 ? "carries" : "carry"} a coercion/codec schema; 422 error details will be coarse (best-effort). Set ELYSIA_AOT_VERBOSE=1 for per-route detail.`);
-	resetCompactErrorWarnings();
+	compactErrorWarned.clear();
 }
 function captureBridgeFree(aot, slot, rawSchema) {
 	const captured = require_compile_aot.Capture.get({
@@ -333,44 +330,25 @@ function endHandlerCapture() {
 	}
 	return captured;
 }
-/** @internal deterministic session/capture assertions. */
-const getCompilerSessionDiagnostics = () => {
-	const session = require_compile_aot.CompilerState.session;
-	return {
-		active: session !== void 0,
-		appAttached: session?.app !== void 0,
-		validators: session?.capture?.size ?? 0,
-		handlers: session?.handlerCapture?.size ?? 0,
-		sucrose: session?.sucroseCache.size ?? 0
-	};
-};
 /** @internal preserve registry around in-process AOT analysis */
 const snapshotCompiled = () => require_compile_aot.CompilerState.registry;
 /** @internal restore registry after in-process AOT analysis */
 function restoreCompiled(snapshot) {
 	require_compile_aot.CompilerState.registry = snapshot;
 }
-const impl = {
+require_compile_aot.setCaptureImpl({
 	sourceOnlyValidator,
 	maybeCapture,
 	captureMirror,
 	captureCodecMirror,
 	captureBridgeFree
-};
-function installCaptureImpl() {
-	require_compile_aot.setCaptureImpl(impl);
-	require_compile_aot_emit.installReconstructImpl();
-}
-installCaptureImpl();
+});
+require_compile_aot_emit.installReconstructImpl();
 
 //#endregion
 exports.abortCapture = abortCapture;
 exports.beginValidatorCapture = beginValidatorCapture;
-exports.captureImplementation = impl;
 exports.endHandlerCapture = endHandlerCapture;
 exports.endValidatorCapture = endValidatorCapture;
-exports.getCompilerSessionDiagnostics = getCompilerSessionDiagnostics;
-exports.installCaptureImpl = installCaptureImpl;
-exports.resetCompactErrorWarnings = resetCompactErrorWarnings;
 exports.restoreCompiled = restoreCompiled;
 exports.snapshotCompiled = snapshotCompiled;

package/dist/compile/aot-capture.mjs

@@ -11,8 +11,8 @@ import { buildFrozenCheck } from "../type/validator/frozen-check.mjs";
 import { captureCustomErrors } from "../type/validator/custom-error.mjs";
 import { getExactMirror } from "../type/validator/exact-mirror.mjs";
 import { captureStringCodecEntries } from "../type/validator/string-codec-aot.mjs";
-import { Build, Compile } from "typebox/schema";
 import { Default } from "typebox/value";
+import { Build, Compile } from "typebox/schema";
 
 //#region src/compile/aot-capture.ts
 function emptyContainers(node, depth) {
@@ -252,9 +252,6 @@ function captureCodecMirror(schema, aot, slot, sanitize, dir) {
 }
 const compactErrorWarned = /* @__PURE__ */ new Set();
 const isVerboseAotWarnings = () => !!env.ELYSIA_AOT_VERBOSE;
-function resetCompactErrorWarnings() {
-	compactErrorWarned.clear();
-}
 function warnCompactErrorLoss(aot, slot) {
 	const key = `${aot.method}\0${aot.path}\0${slot}`;
 	if (compactErrorWarned.has(key)) return;
@@ -264,7 +261,7 @@ function warnCompactErrorLoss(aot, slot) {
 function flushCompactErrorWarnings() {
 	const total = compactErrorWarned.size;
 	if (total > 0 && !isVerboseAotWarnings()) console.warn(`[elysia-aot]: ${total} sealed validator slot${total === 1 ? "" : "s"} ${total === 1 ? "carries" : "carry"} a coercion/codec schema; 422 error details will be coarse (best-effort). Set ELYSIA_AOT_VERBOSE=1 for per-route detail.`);
-	resetCompactErrorWarnings();
+	compactErrorWarned.clear();
 }
 function captureBridgeFree(aot, slot, rawSchema) {
 	const captured = Capture.get({
@@ -331,35 +328,20 @@ function endHandlerCapture() {
 	}
 	return captured;
 }
-/** @internal deterministic session/capture assertions. */
-const getCompilerSessionDiagnostics = () => {
-	const session = CompilerState.session;
-	return {
-		active: session !== void 0,
-		appAttached: session?.app !== void 0,
-		validators: session?.capture?.size ?? 0,
-		handlers: session?.handlerCapture?.size ?? 0,
-		sucrose: session?.sucroseCache.size ?? 0
-	};
-};
 /** @internal preserve registry around in-process AOT analysis */
 const snapshotCompiled = () => CompilerState.registry;
 /** @internal restore registry after in-process AOT analysis */
 function restoreCompiled(snapshot) {
 	CompilerState.registry = snapshot;
 }
-const impl = {
+setCaptureImpl({
 	sourceOnlyValidator,
 	maybeCapture,
 	captureMirror,
 	captureCodecMirror,
 	captureBridgeFree
-};
-function installCaptureImpl() {
-	setCaptureImpl(impl);
-	installReconstructImpl();
-}
-installCaptureImpl();
+});
+installReconstructImpl();
 
 //#endregion
-export { abortCapture, beginValidatorCapture, impl as captureImplementation, endHandlerCapture, endValidatorCapture, getCompilerSessionDiagnostics, installCaptureImpl, resetCompactErrorWarnings, restoreCompiled, snapshotCompiled };
+export { abortCapture, beginValidatorCapture, endHandlerCapture, endValidatorCapture, restoreCompiled, snapshotCompiled };

package/dist/compile/aot-emit.js

@@ -28,7 +28,7 @@ function reconstructCheckCode(build) {
 	const { defs, value } = reconstructCheck(build);
 	return checkCode(defs, value);
 }
-const checkFactorySource = (identifier, code) => `function(${identifier}){${code}}`;
+const checkFactorySource = (identifier, code) => `(${identifier})=>{${code}}`;
 const handlerFactorySource = (alias, code) => `function(h${alias ? "," + alias : ""}){return ${code}}`;
 function externalsMatch(a, b) {
 	if (a.length !== b.length) return false;

package/dist/compile/aot-emit.mjs

@@ -27,7 +27,7 @@ function reconstructCheckCode(build) {
 	const { defs, value } = reconstructCheck(build);
 	return checkCode(defs, value);
 }
-const checkFactorySource = (identifier, code) => `function(${identifier}){${code}}`;
+const checkFactorySource = (identifier, code) => `(${identifier})=>{${code}}`;
 const handlerFactorySource = (alias, code) => `function(h${alias ? "," + alias : ""}){return ${code}}`;
 function externalsMatch(a, b) {
 	if (a.length !== b.length) return false;

package/dist/compile/aot.d.ts

@@ -1,6 +1,6 @@
 import { CoerceNode } from "../type/coerce-plan.js";
 //#region src/compile/aot.d.ts
-declare const AOT_MANIFEST_FORMAT = 3;
+declare const AOT_MANIFEST_FORMAT = 4;
 declare const AOT_ABI: string;
 interface AotFingerprint {
   abi: string;

package/dist/compile/aot.js

@@ -4,8 +4,8 @@ const require_universal_env = require('../universal/env.js');
 const require_package = require('../package.js');
 
 //#region src/compile/aot.ts
-const AOT_MANIFEST_FORMAT = 3;
-const AOT_ABI = `${require_package.version}:${3}`;
+const AOT_MANIFEST_FORMAT = 4;
+const AOT_ABI = `${require_package.version}:${4}`;
 const sharedAotFingerprint = Object.freeze({ abi: AOT_ABI });
 const createAotFingerprint = () => sharedAotFingerprint;
 let activeSession;

package/dist/compile/aot.mjs

@@ -3,8 +3,8 @@ import { env } from "../universal/env.mjs";
 import { version } from "../package.mjs";
 
 //#region src/compile/aot.ts
-const AOT_MANIFEST_FORMAT = 3;
-const AOT_ABI = `${version}:${3}`;
+const AOT_MANIFEST_FORMAT = 4;
+const AOT_ABI = `${version}:${4}`;
 const sharedAotFingerprint = Object.freeze({ abi: AOT_ABI });
 const createAotFingerprint = () => sharedAotFingerprint;
 let activeSession;

package/dist/compile/handler/descriptor.d.ts

@@ -1,11 +1,11 @@
 import { TraceEvent } from "../../trace.js";
 import { CompactBeforeHandlePrefix } from "../../utils.js";
 import { AnyLocalHook, MaybeArray } from "../../types.js";
-import { CompiledCookieConfig } from "../../cookie/config.js";
 import { AnyElysia } from "../../base.js";
 import { ElysiaAdapter } from "../../adapter/index.js";
 import { Sucrose } from "../../sucrose.js";
 import { RouteValidator } from "../../validator/route.js";
+import { CompiledCookieConfig } from "../../cookie/config.js";
 
 //#region src/compile/handler/descriptor.d.ts
 interface RouteDescriptor {
@@ -65,13 +65,9 @@ interface DescribeRouteInput {
  * Populated on each JIT compile, and read only by tests and introspection
  */
 declare const routeDescriptors: WeakMap<AnyElysia, Map<string, RouteDescriptor>>;
-declare function mayReturnIdentifier(fn: Function): boolean;
-declare const lifecycleMayReturnPromise: (handlers: MaybeArray<Function> | undefined, observed: boolean) => boolean;
-/**
- * Extracted from `buildNativeStaticResponse`'s for-in check so the native
- * static promotion predicate
- */
+declare const lifecycleMayReturnPromise: (handlers: MaybeArray<Function> | undefined) => boolean;
+/** Whether a hook can be skipped by a native static response. */
 declare function isEmptyPipelineHook(hook: AnyLocalHook | undefined): boolean;
 declare function describeRoute(input: DescribeRouteInput): RouteCompileState;
 //#endregion
-export { DescribeRouteInput, RouteCompileState, RouteDescriptor, describeRoute, isEmptyPipelineHook, lifecycleMayReturnPromise, mayReturnIdentifier, routeDescriptors };
+export { DescribeRouteInput, RouteCompileState, RouteDescriptor, describeRoute, isEmptyPipelineHook, lifecycleMayReturnPromise, routeDescriptors };

package/dist/compile/handler/descriptor.js

@@ -15,16 +15,7 @@ const require_sucrose = require('../../sucrose.js');
 */
 const routeDescriptors = /* @__PURE__ */ new WeakMap();
 const noTracePhases = /* @__PURE__ */ new Set();
-const matchReturnIdentifier = /(?:=>\s*|\breturn\s+)(?!(?:true|false|null|undefined|void|new|typeof|async|await|function|class)\b)[A-Za-z_$][\w$]*(?:\s*\.\s*[A-Za-z_$][\w$]*)*\s*(?![\w$([])/;
-const mayReturnIdentifierCache = /* @__PURE__ */ new WeakMap();
-function mayReturnIdentifier(fn) {
-	let result = mayReturnIdentifierCache.get(fn);
-	if (result !== void 0) return result;
-	result = matchReturnIdentifier.test(fn.toString());
-	mayReturnIdentifierCache.set(fn, result);
-	return result;
-}
-const lifecycleMayReturnPromise = (handlers, observed) => handlers ? Array.isArray(handlers) ? handlers.some((fn) => !require_compile_utils.isAsyncFunction(fn) && (require_compile_utils.mayReturnPromise(fn) || observed && mayReturnIdentifier(fn))) : !require_compile_utils.isAsyncFunction(handlers) && (require_compile_utils.mayReturnPromise(handlers) || observed && mayReturnIdentifier(handlers)) : false;
+const lifecycleMayReturnPromise = (handlers) => handlers ? Array.isArray(handlers) ? handlers.some(require_compile_utils.mayReturnPromise) : require_compile_utils.mayReturnPromise(handlers) : false;
 const compactPrefixInference = /* @__PURE__ */ new WeakMap();
 const compactPrefixAsync = /* @__PURE__ */ new WeakMap();
 const inferCompactPrefix = (prefix) => {
@@ -66,7 +57,7 @@ function compactPrefixForcesAsync(prefix) {
 		const item = pending[i];
 		for (let j = 0; !value && j < item.added.length; j++) {
 			const fn = item.added[j];
-			value = require_compile_utils.isAsyncFunction(fn) || !require_compile_utils.isAsyncFunction(fn) && (require_compile_utils.mayReturnPromise(fn) || mayReturnIdentifier(fn));
+			value = require_compile_utils.mayReturnPromise(fn);
 		}
 		compactPrefixAsync.set(item, value);
 	}
@@ -74,14 +65,11 @@ function compactPrefixForcesAsync(prefix) {
 }
 const isAsyncValidator = (vali) => vali?.isAsync ?? true;
 const mayReturnPromiseValidator = (vali) => vali?.mayReturnPromise === true;
-/**
-* Extracted from `buildNativeStaticResponse`'s for-in check so the native
-* static promotion predicate
-*/
+/** Whether a hook can be skipped by a native static response. */
 function isEmptyPipelineHook(hook) {
 	if (!hook) return true;
 	for (const key in hook) {
-		if (key === "detail" || key === "tags") continue;
+		if (key === "detail" || key === "tags" || key === "error") continue;
 		const value = hook[key];
 		if (value !== void 0 && value !== false && (!Array.isArray(value) || value.length)) return false;
 	}
@@ -137,11 +125,11 @@ function describeRoute(input) {
 		}
 	}
 	const handlerIsAsync = isHandleFunction && require_compile_utils.isAsyncFunction(handler);
-	const errorHookForcesAsync = hasErrorHook && (hasAfterHandle || hasMapResponse || hasResponseValidator || require_compile_utils.isAsyncLifecycle(hook?.error) || lifecycleMayReturnPromise(hook?.error, false));
+	const errorHookForcesAsync = hasErrorHook && (hasAfterHandle || hasMapResponse || hasResponseValidator || require_compile_utils.isAsyncLifecycle(hook?.error) || lifecycleMayReturnPromise(hook?.error));
 	const afterResponseForcesAsync = hasStaticAfterResponse && require_compile_utils.isAsyncLifecycle(hook?.afterResponse) || hasAfterResponse && (hasAfterHandle || hasMapResponse || hasResponseValidator || hasErrorHook);
-	const traceForcesAsync = (traceHandleOn || phaseOn("error") || phaseOn("afterResponse")) && isHandleFunction && !handlerIsAsync && (require_compile_utils.mayReturnPromise(handler) || mayReturnIdentifier(handler));
-	const handlerResultObserved = isHandleFunction && !handlerIsAsync && (hasResponseValidator || hasAfterHandle || hasMapResponse) && (require_compile_utils.mayReturnPromise(handler) || mayReturnIdentifier(handler));
-	const lifecycleForcesAsync = !!hook && ((beforeHandlePrefix ? compactPrefixForcesAsync(beforeHandlePrefix) : false) || lifecycleMayReturnPromise(hook.beforeHandle, true) || lifecycleMayReturnPromise(hook.transform, false) || lifecycleMayReturnPromise(hook.afterHandle, true) || lifecycleMayReturnPromise(hook.mapResponse, true));
+	const traceForcesAsync = (traceHandleOn || phaseOn("error") || phaseOn("afterResponse")) && isHandleFunction && !handlerIsAsync && require_compile_utils.mayReturnPromise(handler);
+	const handlerResultObserved = isHandleFunction && !handlerIsAsync && (hasResponseValidator || hasAfterHandle || hasMapResponse) && require_compile_utils.mayReturnPromise(handler);
+	const lifecycleForcesAsync = !!hook && ((beforeHandlePrefix ? compactPrefixForcesAsync(beforeHandlePrefix) : false) || lifecycleMayReturnPromise(hook.beforeHandle) || lifecycleMayReturnPromise(hook.transform) || lifecycleMayReturnPromise(hook.afterHandle) || lifecycleMayReturnPromise(hook.mapResponse));
 	const isAsync = hasBody || handlerIsAsync || errorHookForcesAsync || traceForcesAsync || afterResponseForcesAsync || handlerResultObserved || lifecycleForcesAsync || asyncCookieSign || responseValiAsync || hook && (!!require_compile_utils.isAsyncLifecycle(hook?.afterHandle) || !!require_compile_utils.isAsyncLifecycle(hook?.beforeHandle) || !!require_compile_utils.isAsyncLifecycle(hook?.transform) || !!require_compile_utils.isAsyncLifecycle(hook?.mapResponse) || !!require_compile_utils.isAsyncLifecycle(hook?.error) || bodyValiIsAsync || headersValiIsAsync || paramsValiIsAsync || queryValiIsAsync || cookieValidIsAsync);
 	const callHandlerSyncOnAsync = isAsync && isHandleFunction && !handlerIsAsync;
 	const syncErrorHook = hasErrorHook && !isAsync && !hasTrace;
@@ -195,5 +183,4 @@ function describeRoute(input) {
 exports.describeRoute = describeRoute;
 exports.isEmptyPipelineHook = isEmptyPipelineHook;
 exports.lifecycleMayReturnPromise = lifecycleMayReturnPromise;
-exports.mayReturnIdentifier = mayReturnIdentifier;
 exports.routeDescriptors = routeDescriptors;

package/dist/compile/handler/descriptor.mjs

@@ -14,16 +14,7 @@ import { mergeInference, sucrose } from "../../sucrose.mjs";
 */
 const routeDescriptors = /* @__PURE__ */ new WeakMap();
 const noTracePhases = /* @__PURE__ */ new Set();
-const matchReturnIdentifier = /(?:=>\s*|\breturn\s+)(?!(?:true|false|null|undefined|void|new|typeof|async|await|function|class)\b)[A-Za-z_$][\w$]*(?:\s*\.\s*[A-Za-z_$][\w$]*)*\s*(?![\w$([])/;
-const mayReturnIdentifierCache = /* @__PURE__ */ new WeakMap();
-function mayReturnIdentifier(fn) {
-	let result = mayReturnIdentifierCache.get(fn);
-	if (result !== void 0) return result;
-	result = matchReturnIdentifier.test(fn.toString());
-	mayReturnIdentifierCache.set(fn, result);
-	return result;
-}
-const lifecycleMayReturnPromise = (handlers, observed) => handlers ? Array.isArray(handlers) ? handlers.some((fn) => !isAsyncFunction(fn) && (mayReturnPromise(fn) || observed && mayReturnIdentifier(fn))) : !isAsyncFunction(handlers) && (mayReturnPromise(handlers) || observed && mayReturnIdentifier(handlers)) : false;
+const lifecycleMayReturnPromise = (handlers) => handlers ? Array.isArray(handlers) ? handlers.some(mayReturnPromise) : mayReturnPromise(handlers) : false;
 const compactPrefixInference = /* @__PURE__ */ new WeakMap();
 const compactPrefixAsync = /* @__PURE__ */ new WeakMap();
 const inferCompactPrefix = (prefix) => {
@@ -65,7 +56,7 @@ function compactPrefixForcesAsync(prefix) {
 		const item = pending[i];
 		for (let j = 0; !value && j < item.added.length; j++) {
 			const fn = item.added[j];
-			value = isAsyncFunction(fn) || !isAsyncFunction(fn) && (mayReturnPromise(fn) || mayReturnIdentifier(fn));
+			value = mayReturnPromise(fn);
 		}
 		compactPrefixAsync.set(item, value);
 	}
@@ -73,14 +64,11 @@ function compactPrefixForcesAsync(prefix) {
 }
 const isAsyncValidator = (vali) => vali?.isAsync ?? true;
 const mayReturnPromiseValidator = (vali) => vali?.mayReturnPromise === true;
-/**
-* Extracted from `buildNativeStaticResponse`'s for-in check so the native
-* static promotion predicate
-*/
+/** Whether a hook can be skipped by a native static response. */
 function isEmptyPipelineHook(hook) {
 	if (!hook) return true;
 	for (const key in hook) {
-		if (key === "detail" || key === "tags") continue;
+		if (key === "detail" || key === "tags" || key === "error") continue;
 		const value = hook[key];
 		if (value !== void 0 && value !== false && (!Array.isArray(value) || value.length)) return false;
 	}
@@ -136,11 +124,11 @@ function describeRoute(input) {
 		}
 	}
 	const handlerIsAsync = isHandleFunction && isAsyncFunction(handler);
-	const errorHookForcesAsync = hasErrorHook && (hasAfterHandle || hasMapResponse || hasResponseValidator || isAsyncLifecycle(hook?.error) || lifecycleMayReturnPromise(hook?.error, false));
+	const errorHookForcesAsync = hasErrorHook && (hasAfterHandle || hasMapResponse || hasResponseValidator || isAsyncLifecycle(hook?.error) || lifecycleMayReturnPromise(hook?.error));
 	const afterResponseForcesAsync = hasStaticAfterResponse && isAsyncLifecycle(hook?.afterResponse) || hasAfterResponse && (hasAfterHandle || hasMapResponse || hasResponseValidator || hasErrorHook);
-	const traceForcesAsync = (traceHandleOn || phaseOn("error") || phaseOn("afterResponse")) && isHandleFunction && !handlerIsAsync && (mayReturnPromise(handler) || mayReturnIdentifier(handler));
-	const handlerResultObserved = isHandleFunction && !handlerIsAsync && (hasResponseValidator || hasAfterHandle || hasMapResponse) && (mayReturnPromise(handler) || mayReturnIdentifier(handler));
-	const lifecycleForcesAsync = !!hook && ((beforeHandlePrefix ? compactPrefixForcesAsync(beforeHandlePrefix) : false) || lifecycleMayReturnPromise(hook.beforeHandle, true) || lifecycleMayReturnPromise(hook.transform, false) || lifecycleMayReturnPromise(hook.afterHandle, true) || lifecycleMayReturnPromise(hook.mapResponse, true));
+	const traceForcesAsync = (traceHandleOn || phaseOn("error") || phaseOn("afterResponse")) && isHandleFunction && !handlerIsAsync && mayReturnPromise(handler);
+	const handlerResultObserved = isHandleFunction && !handlerIsAsync && (hasResponseValidator || hasAfterHandle || hasMapResponse) && mayReturnPromise(handler);
+	const lifecycleForcesAsync = !!hook && ((beforeHandlePrefix ? compactPrefixForcesAsync(beforeHandlePrefix) : false) || lifecycleMayReturnPromise(hook.beforeHandle) || lifecycleMayReturnPromise(hook.transform) || lifecycleMayReturnPromise(hook.afterHandle) || lifecycleMayReturnPromise(hook.mapResponse));
 	const isAsync = hasBody || handlerIsAsync || errorHookForcesAsync || traceForcesAsync || afterResponseForcesAsync || handlerResultObserved || lifecycleForcesAsync || asyncCookieSign || responseValiAsync || hook && (!!isAsyncLifecycle(hook?.afterHandle) || !!isAsyncLifecycle(hook?.beforeHandle) || !!isAsyncLifecycle(hook?.transform) || !!isAsyncLifecycle(hook?.mapResponse) || !!isAsyncLifecycle(hook?.error) || bodyValiIsAsync || headersValiIsAsync || paramsValiIsAsync || queryValiIsAsync || cookieValidIsAsync);
 	const callHandlerSyncOnAsync = isAsync && isHandleFunction && !handlerIsAsync;
 	const syncErrorHook = hasErrorHook && !isAsync && !hasTrace;
@@ -191,4 +179,4 @@ function describeRoute(input) {
 }
 
 //#endregion
-export { describeRoute, isEmptyPipelineHook, lifecycleMayReturnPromise, mayReturnIdentifier, routeDescriptors };
+export { describeRoute, isEmptyPipelineHook, lifecycleMayReturnPromise, routeDescriptors };

package/dist/compile/handler/index.d.ts

@@ -1,5 +1,5 @@
 import { ChainNode } from "../../utils.js";
-import { AnyLocalHook, CompiledHandler, InternalRoute } from "../../types.js";
+import { AnyLocalHook, AppHook, CompiledHandler, InternalRoute } from "../../types.js";
 import { AnyElysia } from "../../base.js";
 import { setCaptureHeaderShorthand } from "./jit.js";
 
@@ -11,9 +11,10 @@ declare function resolveWSLocalHook(scope: AnyElysia, hook: Partial<AnyLocalHook
  * (JIT or rebuild) compile repopulates them anyway, just uncached
  */
 declare function clearHandlerAnalysisCaches(root: AnyElysia): void;
+declare function chainResolver(root: AnyElysia): ((node: ChainNode) => Partial<AppHook> | undefined) | undefined;
 declare const localMacroRoot: (instance: AnyElysia, root: AnyElysia) => AnyElysia;
 declare function buildNativeStaticResponse(route: InternalRoute, root: AnyElysia): Response | undefined;
-declare function composeRouteHook(instance: AnyElysia, localHook: Partial<AnyLocalHook> | undefined, appHook: ChainNode | undefined, inheritedChain: ChainNode | undefined, root: AnyElysia, macroScope?: AnyElysia): AnyLocalHook | undefined;
+declare function composeRouteHook(instance: AnyElysia, localHook: Partial<AnyLocalHook> | undefined, appHook: ChainNode | undefined, inheritedChain: ChainNode | undefined, root: AnyElysia, macroScope?: AnyElysia, allowCompactPrefix?: boolean): AnyLocalHook | undefined;
 declare function compileHandler(route: InternalRoute, root: AnyElysia, precomputedStatic?: Response, liveOnly?: boolean): CompiledHandler;
 //#endregion
-export { buildNativeStaticResponse, clearHandlerAnalysisCaches, compileHandler, composeRouteHook, localMacroRoot, resolveLocalHook, resolveWSLocalHook, setCaptureHeaderShorthand };
+export { buildNativeStaticResponse, chainResolver, clearHandlerAnalysisCaches, compileHandler, composeRouteHook, localMacroRoot, resolveLocalHook, resolveWSLocalHook, setCaptureHeaderShorthand };