elysia 2.0.0-beta.2 → 2.0.0-beta.21

package/dist/compile/aot.d.ts

@@ -1,15 +1,13 @@
-import { CoercePlan } from "../type/coerce-plan.js";
+import { CoerceNode } from "../type/coerce-plan.js";
 //#region src/compile/aot.d.ts
-declare const AOT_MANIFEST_FORMAT = 3;
-declare const AOT_ABI: string;
+declare const AOT_MANIFEST_FORMAT = 6;
 interface AotFingerprint {
   abi: string;
 }
 interface ProgramId {
   readonly _: unique symbol;
 }
-declare const createProgramId: () => ProgramId;
-declare function createAotFingerprint(): AotFingerprint;
+declare const createAotFingerprint: () => AotFingerprint;
 interface CompilerSession {
   readonly sucroseCache: Map<number, {
     content: string;
@@ -73,7 +71,7 @@ interface FrozenValidator {
       x?: 1;
     };
   }>;
-  cp?: CoercePlan;
+  cp?: CoerceNode;
 }
 interface ValidatorManifest {
   [method: string]: {
@@ -81,8 +79,9 @@ interface ValidatorManifest {
   };
 }
 interface FrozenHandler {
-  a: string[];
-  f: (...deps: unknown[]) => unknown;
+  a?: string[];
+  f?: (...deps: unknown[]) => unknown;
+  k?: number;
 }
 interface HandlerManifest {
   [method: string]: {
@@ -91,17 +90,16 @@ interface HandlerManifest {
 }
 interface CompiledSnapshot {
   registered: CompiledProgramRegistration | undefined;
-  claimed: boolean;
+  claimed: WeakRef<ProgramId> | undefined;
   programs: WeakMap<ProgramId, CompiledProgram>;
 }
 interface CompiledProgramRegistration {
-  bf: 1;
   fingerprint: AotFingerprint;
   validators?: ValidatorManifest;
   handlers?: HandlerManifest;
   lazyGroups?: Array<() => ValidatorManifest>;
   lazyGroupOf?: Record<string, Record<string, number>>;
-  planRebuilder?: (original: unknown, plan: CoercePlan) => any;
+  planRebuilder?: (original: unknown, plan: CoerceNode) => any;
 }
 interface CompiledProgram extends CompiledProgramRegistration {
   builtGroups: Set<number>;
@@ -128,19 +126,18 @@ interface ReconstructImpl {
   reconstructInnerCodecs(ic: NonNullable<FrozenValidator['ic']>, schema: any): void;
 }
 declare function reconstruct(): ReconstructImpl;
+declare const aotDrift: (method: string, path: string) => string;
+declare function warnAotDrift(method: string, path: string): void;
 declare abstract class Compiled {
   static register(manifest: CompiledProgramRegistration): void;
   static claim(id: ProgramId, fingerprint: AotFingerprint): boolean;
-  static get reconstruct(): ReconstructImpl | undefined;
+  static assertUncontested(id: ProgramId): void;
   static set reconstruct(impl: ReconstructImpl | undefined);
   static getHandler(id: ProgramId | undefined, method: string, path: string): FrozenHandler | undefined;
+  static hasProgram(id: ProgramId | undefined): boolean;
   static getValidator(method: string, path: string, slot: ValidatorSlot, id?: ProgramId): FrozenValidator | undefined;
   static hasValidator(method: string, path: string, slot: ValidatorSlot, id?: ProgramId): boolean;
-  static getPlanRebuilder(id?: ProgramId): ((original: unknown, plan: CoercePlan) => any) | undefined;
-  /**
-   * Drop a fully consumed program registration after an eager production
-   * build publishes. Safe only when every route compiled before publish
-   */
+  static getPlanRebuilder(id?: ProgramId): ((original: unknown, plan: CoerceNode) => any) | undefined;
   static release(id: ProgramId): void;
   /** @internal test isolation */
   static clear(): void;
@@ -213,7 +210,7 @@ interface CapturedValidator {
     external: boolean;
     decode: CapturedMirror;
   }>;
-  coercePlan?: CoercePlan;
+  coercePlan?: CoerceNode;
   bridgeFree?: boolean;
 }
 /** @internal shared with `aot-capture.ts` (`beginValidatorCapture`). */
@@ -223,6 +220,7 @@ interface CapturedHandler {
   path: string;
   alias: string;
   code: string;
+  k: number | undefined;
 }
 declare function captureHandler(v: CapturedHandler): void;
 declare function captureSet(loc: {
@@ -284,4 +282,4 @@ interface CaptureImpl {
 declare let captureImpl: CaptureImpl | undefined;
 declare function setCaptureImpl(impl: CaptureImpl | undefined): void;
 //#endregion
-export { AOT_ABI, AOT_MANIFEST_FORMAT, AotFingerprint, Capture, CaptureImpl, CapturedHandler, CapturedMirror, CapturedValidator, CheckBuildResult, Compiled, CompiledProgramRegistration, CompiledSnapshot, CompilerSession, CompilerState, EMPTY_EXTERNALS, FrozenBothFactory, FrozenCheckFactory, FrozenHandler, FrozenMirror, FrozenMirrorFactory, FrozenValidator, HandlerManifest, ProgramId, ReconstructImpl, StringCodecNode, ValidatorManifest, ValidatorSlot, aotActivationError, beginCompilerSession, captureImpl, createAotFingerprint, createProgramId, endCompilerSession, getCompilerSession, reconstruct, setCaptureImpl };
+export { AOT_MANIFEST_FORMAT, AotFingerprint, Capture, CaptureImpl, CapturedHandler, CapturedMirror, CapturedValidator, CheckBuildResult, Compiled, CompiledProgramRegistration, CompiledSnapshot, CompilerSession, CompilerState, EMPTY_EXTERNALS, FrozenBothFactory, FrozenCheckFactory, FrozenHandler, FrozenMirror, FrozenMirrorFactory, FrozenValidator, HandlerManifest, ProgramId, ReconstructImpl, StringCodecNode, ValidatorManifest, ValidatorSlot, aotActivationError, aotDrift, beginCompilerSession, captureImpl, createAotFingerprint, endCompilerSession, getCompilerSession, reconstruct, setCaptureImpl, warnAotDrift };

package/dist/compile/aot.js

@@ -4,13 +4,10 @@ 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 createProgramId = () => ({});
+const AOT_MANIFEST_FORMAT = 6;
+const AOT_ABI = `${require_package.version}:${6}`;
 const sharedAotFingerprint = Object.freeze({ abi: AOT_ABI });
-function createAotFingerprint() {
-	return sharedAotFingerprint;
-}
+const createAotFingerprint = () => sharedAotFingerprint;
 let activeSession;
 const newCompilerSession = () => ({ sucroseCache: /* @__PURE__ */ new Map() });
 function beginCompilerSession(app) {
@@ -40,28 +37,29 @@ function reconstruct() {
 	if (reconstructImpl === void 0) throw new Error("Elysia AOT reconstruct module is not activated");
 	return reconstructImpl;
 }
+let drifted;
+const aotDrift = (method, path) => `[elysia-aot] ${method} ${path} differs from the AOT build`;
+function warnAotDrift(method, path) {
+	const key = method + " " + path;
+	if (drifted?.has(key)) return;
+	drifted ??= /* @__PURE__ */ new Set();
+	drifted.add(key);
+	console.warn(aotDrift(method, path) + ", compiled at runtime");
+}
 let registered;
-let claimed = false;
+let claimed;
 let programs = /* @__PURE__ */ new WeakMap();
 const programFor = (id) => id ? programs.get(id) : void 0;
-const fingerprintMismatch = (manifest, actual) => {
-	const differences = [];
-	const expected = manifest.fingerprint;
-	if (manifest.bf !== 1) differences.push(`bf (manifest ${manifest.bf}, app 1)`);
-	if (expected.abi !== actual.abi) differences.push(`abi (manifest ${expected.abi}, app ${actual.abi})`);
-	return differences;
-};
 var Compiled = class {
 	static register(manifest) {
 		registered = manifest;
-		claimed = false;
+		claimed = void 0;
 	}
 	static claim(id, fingerprint) {
 		if (!registered || claimed) return false;
 		const manifest = registered;
-		const differences = fingerprintMismatch(manifest, fingerprint);
-		if (differences.length) throw new Error(`[elysia-aot] Registered manifest fingerprint mismatch: ${differences.join("; ")}.`);
-		claimed = true;
+		if (manifest.fingerprint.abi !== fingerprint.abi) throw new Error(`[elysia-aot] Mismatch fingerprint`);
+		claimed = new WeakRef(id);
 		registered = void 0;
 		programs.set(id, {
 			...manifest,
@@ -69,8 +67,9 @@ var Compiled = class {
 		});
 		return true;
 	}
-	static get reconstruct() {
-		return reconstructImpl;
+	static assertUncontested(id) {
+		if (claimed === void 0 || claimed.deref() === id || isAotBuildEnv()) return;
+		throw new Error("[elysia-aot] A second Elysia app built a router in this process. An AOT build seals one app per process.");
 	}
 	static set reconstruct(impl) {
 		reconstructImpl = impl;
@@ -78,6 +77,9 @@ var Compiled = class {
 	static getHandler(id, method, path) {
 		return programFor(id)?.handlers?.[method]?.[path];
 	}
+	static hasProgram(id) {
+		return programFor(id) !== void 0;
+	}
 	static getValidator(method, path, slot, id) {
 		const program = programFor(id);
 		if (!program) return void 0;
@@ -106,18 +108,15 @@ var Compiled = class {
 	static getPlanRebuilder(id) {
 		return programFor(id)?.planRebuilder;
 	}
-	/**
-	* Drop a fully consumed program registration after an eager production
-	* build publishes. Safe only when every route compiled before publish
-	*/
 	static release(id) {
 		programs.delete(id);
 	}
 	/** @internal test isolation */
 	static clear() {
 		registered = void 0;
-		claimed = false;
+		claimed = void 0;
 		programs = /* @__PURE__ */ new WeakMap();
+		drifted?.clear();
 	}
 };
 /**
@@ -146,7 +145,16 @@ const CompilerState = {
 	}
 };
 const EMPTY_EXTERNALS = Object.freeze([]);
-function captureEntry({ method, path, slot }) {
+/** @internal shared with `aot-capture.ts` (`beginValidatorCapture`). */
+const aotActivationError = () => /* @__PURE__ */ new Error("Elysia AOT capture module is not activated.");
+function captureHandler(v) {
+	if (!isValidatorCapturing()) return;
+	const session = activeSession;
+	if (!session) return;
+	(session.handlerCapture ??= /* @__PURE__ */ new Map()).set(`${v.method}\0${v.path}`, v);
+}
+function captureSet(loc, partial) {
+	const { method, path, slot } = loc;
 	if (!isValidatorCapturing()) return;
 	const capture = activeSession?.capture;
 	if (!capture) return;
@@ -157,32 +165,14 @@ function captureEntry({ method, path, slot }) {
 		path,
 		slot
 	});
-	return e;
-}
-/** @internal shared with `aot-capture.ts` (`beginValidatorCapture`). */
-const aotActivationError = () => /* @__PURE__ */ new Error("Elysia AOT capture module is not activated.");
-function captureHandler(v) {
-	if (!isValidatorCapturing()) return;
-	const session = activeSession;
-	if (!session) return;
-	(session.handlerCapture ??= /* @__PURE__ */ new Map()).set(`${v.method}\0${v.path}`, v);
-}
-function captureSet(loc, partial) {
-	const e = captureEntry(loc);
-	if (e) Object.assign(e, partial);
+	Object.assign(e, partial);
 }
 const captureGet = (loc) => activeSession?.capture?.get(`${loc.method}_${loc.path}_${loc.slot}`);
 const isAotBuildEnv = () => !!require_universal_env.env.ELYSIA_AOT_BUILD;
 const isValidatorCapturing = () => {
-	if (activeSession?.capture !== void 0) {
-		if (captureImpl === void 0) throw aotActivationError();
-		return true;
-	}
-	if (isAotBuildEnv()) {
-		if (captureImpl === void 0) throw aotActivationError();
-		return true;
-	}
-	return false;
+	if (activeSession?.capture === void 0 && !isAotBuildEnv()) return false;
+	if (captureImpl === void 0) throw aotActivationError();
+	return true;
 };
 const Capture = {
 	set: captureSet,
@@ -198,13 +188,13 @@ function setCaptureImpl(impl) {
 }
 
 //#endregion
-exports.AOT_ABI = AOT_ABI;
 exports.AOT_MANIFEST_FORMAT = AOT_MANIFEST_FORMAT;
 exports.Capture = Capture;
 exports.Compiled = Compiled;
 exports.CompilerState = CompilerState;
 exports.EMPTY_EXTERNALS = EMPTY_EXTERNALS;
 exports.aotActivationError = aotActivationError;
+exports.aotDrift = aotDrift;
 exports.beginCompilerSession = beginCompilerSession;
 Object.defineProperty(exports, 'captureImpl', {
   enumerable: true,
@@ -213,8 +203,8 @@ Object.defineProperty(exports, 'captureImpl', {
   }
 });
 exports.createAotFingerprint = createAotFingerprint;
-exports.createProgramId = createProgramId;
 exports.endCompilerSession = endCompilerSession;
 exports.getCompilerSession = getCompilerSession;
 exports.reconstruct = reconstruct;
-exports.setCaptureImpl = setCaptureImpl;
+exports.setCaptureImpl = setCaptureImpl;
+exports.warnAotDrift = warnAotDrift;

package/dist/compile/aot.mjs

@@ -3,13 +3,10 @@ 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 createProgramId = () => ({});
+const AOT_MANIFEST_FORMAT = 6;
+const AOT_ABI = `${version}:${6}`;
 const sharedAotFingerprint = Object.freeze({ abi: AOT_ABI });
-function createAotFingerprint() {
-	return sharedAotFingerprint;
-}
+const createAotFingerprint = () => sharedAotFingerprint;
 let activeSession;
 const newCompilerSession = () => ({ sucroseCache: /* @__PURE__ */ new Map() });
 function beginCompilerSession(app) {
@@ -39,28 +36,29 @@ function reconstruct() {
 	if (reconstructImpl === void 0) throw new Error("Elysia AOT reconstruct module is not activated");
 	return reconstructImpl;
 }
+let drifted;
+const aotDrift = (method, path) => `[elysia-aot] ${method} ${path} differs from the AOT build`;
+function warnAotDrift(method, path) {
+	const key = method + " " + path;
+	if (drifted?.has(key)) return;
+	drifted ??= /* @__PURE__ */ new Set();
+	drifted.add(key);
+	console.warn(aotDrift(method, path) + ", compiled at runtime");
+}
 let registered;
-let claimed = false;
+let claimed;
 let programs = /* @__PURE__ */ new WeakMap();
 const programFor = (id) => id ? programs.get(id) : void 0;
-const fingerprintMismatch = (manifest, actual) => {
-	const differences = [];
-	const expected = manifest.fingerprint;
-	if (manifest.bf !== 1) differences.push(`bf (manifest ${manifest.bf}, app 1)`);
-	if (expected.abi !== actual.abi) differences.push(`abi (manifest ${expected.abi}, app ${actual.abi})`);
-	return differences;
-};
 var Compiled = class {
 	static register(manifest) {
 		registered = manifest;
-		claimed = false;
+		claimed = void 0;
 	}
 	static claim(id, fingerprint) {
 		if (!registered || claimed) return false;
 		const manifest = registered;
-		const differences = fingerprintMismatch(manifest, fingerprint);
-		if (differences.length) throw new Error(`[elysia-aot] Registered manifest fingerprint mismatch: ${differences.join("; ")}.`);
-		claimed = true;
+		if (manifest.fingerprint.abi !== fingerprint.abi) throw new Error(`[elysia-aot] Mismatch fingerprint`);
+		claimed = new WeakRef(id);
 		registered = void 0;
 		programs.set(id, {
 			...manifest,
@@ -68,8 +66,9 @@ var Compiled = class {
 		});
 		return true;
 	}
-	static get reconstruct() {
-		return reconstructImpl;
+	static assertUncontested(id) {
+		if (claimed === void 0 || claimed.deref() === id || isAotBuildEnv()) return;
+		throw new Error("[elysia-aot] A second Elysia app built a router in this process. An AOT build seals one app per process.");
 	}
 	static set reconstruct(impl) {
 		reconstructImpl = impl;
@@ -77,6 +76,9 @@ var Compiled = class {
 	static getHandler(id, method, path) {
 		return programFor(id)?.handlers?.[method]?.[path];
 	}
+	static hasProgram(id) {
+		return programFor(id) !== void 0;
+	}
 	static getValidator(method, path, slot, id) {
 		const program = programFor(id);
 		if (!program) return void 0;
@@ -105,18 +107,15 @@ var Compiled = class {
 	static getPlanRebuilder(id) {
 		return programFor(id)?.planRebuilder;
 	}
-	/**
-	* Drop a fully consumed program registration after an eager production
-	* build publishes. Safe only when every route compiled before publish
-	*/
 	static release(id) {
 		programs.delete(id);
 	}
 	/** @internal test isolation */
 	static clear() {
 		registered = void 0;
-		claimed = false;
+		claimed = void 0;
 		programs = /* @__PURE__ */ new WeakMap();
+		drifted?.clear();
 	}
 };
 /**
@@ -145,7 +144,16 @@ const CompilerState = {
 	}
 };
 const EMPTY_EXTERNALS = Object.freeze([]);
-function captureEntry({ method, path, slot }) {
+/** @internal shared with `aot-capture.ts` (`beginValidatorCapture`). */
+const aotActivationError = () => /* @__PURE__ */ new Error("Elysia AOT capture module is not activated.");
+function captureHandler(v) {
+	if (!isValidatorCapturing()) return;
+	const session = activeSession;
+	if (!session) return;
+	(session.handlerCapture ??= /* @__PURE__ */ new Map()).set(`${v.method}\0${v.path}`, v);
+}
+function captureSet(loc, partial) {
+	const { method, path, slot } = loc;
 	if (!isValidatorCapturing()) return;
 	const capture = activeSession?.capture;
 	if (!capture) return;
@@ -156,32 +164,14 @@ function captureEntry({ method, path, slot }) {
 		path,
 		slot
 	});
-	return e;
-}
-/** @internal shared with `aot-capture.ts` (`beginValidatorCapture`). */
-const aotActivationError = () => /* @__PURE__ */ new Error("Elysia AOT capture module is not activated.");
-function captureHandler(v) {
-	if (!isValidatorCapturing()) return;
-	const session = activeSession;
-	if (!session) return;
-	(session.handlerCapture ??= /* @__PURE__ */ new Map()).set(`${v.method}\0${v.path}`, v);
-}
-function captureSet(loc, partial) {
-	const e = captureEntry(loc);
-	if (e) Object.assign(e, partial);
+	Object.assign(e, partial);
 }
 const captureGet = (loc) => activeSession?.capture?.get(`${loc.method}_${loc.path}_${loc.slot}`);
 const isAotBuildEnv = () => !!env.ELYSIA_AOT_BUILD;
 const isValidatorCapturing = () => {
-	if (activeSession?.capture !== void 0) {
-		if (captureImpl === void 0) throw aotActivationError();
-		return true;
-	}
-	if (isAotBuildEnv()) {
-		if (captureImpl === void 0) throw aotActivationError();
-		return true;
-	}
-	return false;
+	if (activeSession?.capture === void 0 && !isAotBuildEnv()) return false;
+	if (captureImpl === void 0) throw aotActivationError();
+	return true;
 };
 const Capture = {
 	set: captureSet,
@@ -197,4 +187,4 @@ function setCaptureImpl(impl) {
 }
 
 //#endregion
-export { AOT_ABI, AOT_MANIFEST_FORMAT, Capture, Compiled, CompilerState, EMPTY_EXTERNALS, aotActivationError, beginCompilerSession, captureImpl, createAotFingerprint, createProgramId, endCompilerSession, getCompilerSession, reconstruct, setCaptureImpl };
+export { AOT_MANIFEST_FORMAT, Capture, Compiled, CompilerState, EMPTY_EXTERNALS, aotActivationError, aotDrift, beginCompilerSession, captureImpl, createAotFingerprint, endCompilerSession, getCompilerSession, reconstruct, setCaptureImpl, warnAotDrift };

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

@@ -1,16 +1,21 @@
-import { TraceEvent } from "../../trace.js";
+import { TraceEvent } from "../../constants.js";
 import { CompactBeforeHandlePrefix } from "../../utils.js";
-import { AnyLocalHook, MaybeArray } from "../../types.js";
-import { CompiledCookieConfig } from "../../cookie/config.js";
+import { AnyLocalHook } from "../../types.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 {
   handlerKind: 'function' | 'response' | 'promise' | 'static-value';
   async: boolean;
+  /**
+   * `async` only on a maybe-promise: compiled as a sync route that hands
+   * off to an async tail at the first thenable
+   */
+  tail: boolean;
   responseMode: 'compact' | 'default-headers' | 'set' | 'set-with-default-headers';
   hasBeforeHandle: boolean;
   hasAfterHandle: boolean;
@@ -50,7 +55,6 @@ interface RouteCompileState {
 }
 interface DescribeRouteInput {
   method: string;
-  path: string;
   handler: unknown;
   root: AnyElysia;
   adapter: ElysiaAdapter;
@@ -65,13 +69,6 @@ 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 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, routeDescriptors };

package/dist/compile/handler/descriptor.js

@@ -1,12 +1,12 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_utils = require('../../utils.js');
+const require_cookie_crypto = require('../../cookie/crypto.js');
 const require_compile_aot = require('../aot.js');
 const require_generation = require('../../generation.js');
-const require_cookie_crypto = require('../../cookie/crypto.js');
-const require_cookie_config = require('../../cookie/config.js');
 const require_compile_utils = require('../utils.js');
 const require_compile_jit_probe = require('../jit-probe.js');
 const require_sucrose = require('../../sucrose.js');
+const require_compile_handler_reconstruct = require('./reconstruct.js');
 
 //#region src/compile/handler/descriptor.ts
 /**
@@ -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,27 +57,13 @@ 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);
 	}
 	return value;
 }
-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
-*/
-function isEmptyPipelineHook(hook) {
-	if (!hook) return true;
-	for (const key in hook) {
-		if (key === "detail" || key === "tags") continue;
-		const value = hook[key];
-		if (value !== void 0 && value !== false && (!Array.isArray(value) || value.length)) return false;
-	}
-	return true;
-}
+const isAsyncValidator = (vali) => (vali?.isAsync ?? true) || vali?.mayReturnPromise === true;
 function describeRoute(input) {
 	const { method, handler, root, adapter, hook, buildValidator, isHandleFunction, isStaticResponse, isPromiseHandler } = input;
 	const vali = buildValidator();
@@ -100,14 +77,13 @@ function describeRoute(input) {
 	const hasMergeBody = !!hook?.schemas?.some((s) => s?.body);
 	const bodylessMethod = method === "GET" || method === "HEAD";
 	const hasBody = !!hook?.body || hasMergeBody || !bodylessMethod && (parseLength > 0 || inference.body) && parseFirst !== "none";
-	const bodyValiIsAsync = hasBody && (isAsyncValidator(vali?.body) || mayReturnPromiseValidator(vali?.body));
-	const headersValiIsAsync = vali?.headers && (isAsyncValidator(vali?.headers) || mayReturnPromiseValidator(vali?.headers));
-	const paramsValiIsAsync = vali?.params && (isAsyncValidator(vali?.params) || mayReturnPromiseValidator(vali?.params));
-	const queryValiIsAsync = vali?.query && (isAsyncValidator(vali?.query) || mayReturnPromiseValidator(vali?.query));
-	const cookieValidIsAsync = vali?.cookie && (isAsyncValidator(vali?.cookie) || mayReturnPromiseValidator(vali?.cookie));
-	const appCookieConfig = require_generation.frozenRootOf(root)["~config"]?.cookie;
+	const bodyValiIsAsync = hasBody && isAsyncValidator(vali?.body);
+	const headersValiIsAsync = vali?.headers && isAsyncValidator(vali.headers);
+	const paramsValiIsAsync = vali?.params && isAsyncValidator(vali.params);
+	const queryValiIsAsync = vali?.query && isAsyncValidator(vali.query);
+	const cookieValidIsAsync = vali?.cookie && isAsyncValidator(vali.cookie);
 	const needsCookie = !!vali?.cookie || !!inference.cookie;
-	const cookieConfig = needsCookie ? require_cookie_config.compileCookieConfig(hook?.cookie, appCookieConfig) : void 0;
+	const cookieConfig = needsCookie ? require_compile_handler_reconstruct.Reconstrct.cookie(hook, root) : void 0;
 	const hasCookieSign = !!cookieConfig?.hasSign;
 	const syncCookieSign = hasCookieSign && require_cookie_crypto.hasSyncHmac && !require_compile_aot.Capture.isCapturing();
 	const asyncCookieSign = hasCookieSign && !syncCookieSign;
@@ -131,19 +107,20 @@ function describeRoute(input) {
 	const traceHandleOn = phaseOn("handle");
 	let responseValiAsync = false;
 	if (vali?.response) {
-		for (const code in vali.response) if (isAsyncValidator(vali.response[code]) || mayReturnPromiseValidator(vali.response[code])) {
+		for (const code in vali.response) if (isAsyncValidator(vali.response[code])) {
 			responseValiAsync = true;
 			break;
 		}
 	}
 	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 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 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 || headersValiIsAsync || paramsValiIsAsync || queryValiIsAsync || cookieValidIsAsync;
 	const callHandlerSyncOnAsync = isAsync && isHandleFunction && !handlerIsAsync;
+	const tail = isAsync && !(hasErrorHook && hasMapResponse) && !hasBody && !handlerIsAsync && !asyncCookieSign && !responseValiAsync && !hasTrace && !beforeHandlePrefix?.length && !bodyValiIsAsync && !headersValiIsAsync && !paramsValiIsAsync && !queryValiIsAsync && !cookieValidIsAsync && !(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)));
 	const syncErrorHook = hasErrorHook && !isAsync && !hasTrace;
 	const syncAfterResponse = hasAfterResponse && !isAsync && !hasTrace && !hasErrorHook;
 	const handlerKind = isHandleFunction ? "function" : isStaticResponse ? "response" : isPromiseHandler ? "promise" : "static-value";
@@ -154,6 +131,7 @@ function describeRoute(input) {
 		descriptor: {
 			handlerKind,
 			async: !!isAsync,
+			tail,
 			responseMode,
 			hasBeforeHandle,
 			hasAfterHandle,
@@ -193,7 +171,4 @@ function describeRoute(input) {
 
 //#endregion
 exports.describeRoute = describeRoute;
-exports.isEmptyPipelineHook = isEmptyPipelineHook;
-exports.lifecycleMayReturnPromise = lifecycleMayReturnPromise;
-exports.mayReturnIdentifier = mayReturnIdentifier;
 exports.routeDescriptors = routeDescriptors;