elysia 2.0.0-exp.33 → 2.0.0-exp.35

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

@@ -0,0 +1,7 @@
+import { CaptureImpl } from "./aot.js";
+
+//#region src/compile/aot-capture.d.ts
+declare const impl: CaptureImpl;
+declare function installCaptureImpl(): void;
+//#endregion
+export { impl as captureImplementation, installCaptureImpl };

package/dist/compile/aot-capture.js

@@ -0,0 +1,178 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../_virtual/_rolldown/runtime.js');
+const require_compile_aot = require('./aot.js');
+const require_compile_handler_frozen_validator = require('./handler/frozen-validator.js');
+const require_type_coerce = require('../type/coerce.js');
+const require_type_validator_default_precompute = require('../type/validator/default-precompute.js');
+const require_type_validator_frozen_check = require('../type/validator/frozen-check.js');
+const require_type_validator_custom_error = require('../type/validator/custom-error.js');
+const require_type_validator_string_codec_aot = require('../type/validator/string-codec-aot.js');
+const require_type_validator_index = require('../type/validator/index.js');
+let typebox_schema = require("typebox/schema");
+let exact_mirror = require("exact-mirror");
+exact_mirror = require_runtime.__toESM(exact_mirror);
+
+//#region src/compile/aot-capture.ts
+function sourceOnlyValidator(schema) {
+	const buildResult = (0, typebox_schema.Build)(schema);
+	let full;
+	return new Proxy({}, { get(_, prop) {
+		if (prop === "buildResult") return buildResult;
+		const f = full ??= (0, typebox_schema.Compile)(schema);
+		const value = f[prop];
+		return typeof value === "function" ? value.bind(f) : value;
+	} });
+}
+function maybeCapture(args) {
+	const { aot, slot, hasRef, originalSchema, schema, hasCodec, hasDefault, coerces, normalize, buildResult } = args;
+	if (hasCodec && !hasRef && coerces && normalize !== false && normalize !== "typebox") {
+		const plan = require_type_coerce.captureCoercePlan(originalSchema, schema);
+		if (plan && require_type_validator_index.externalsShape(require_type_coerce.buildCoercedFromPlan(originalSchema, plan)) === require_type_validator_index.externalsShape(schema)) require_compile_aot.Capture.set({
+			method: aot.method,
+			path: aot.path,
+			slot
+		}, { coercePlan: plan });
+	}
+	const defaultFastPathCapture = {
+		precomputeSafe: void 0,
+		precomputedDefault: void 0,
+		precomputeNull: void 0,
+		precomputedObjectDefault: void 0,
+		defaultCloner: void 0,
+		objectDefaultMerger: void 0
+	};
+	if (hasDefault) {
+		const defaults = require_type_validator_default_precompute.verifyPreallocatableDefault(schema);
+		if (defaults) {
+			defaultFastPathCapture.precomputeSafe = true;
+			defaultFastPathCapture.precomputedDefault = defaults.pd;
+			defaultFastPathCapture.precomputeNull = defaults.pn;
+			defaultFastPathCapture.precomputedObjectDefault = defaults.pod;
+			defaultFastPathCapture.defaultCloner = defaults.pd !== void 0 ? require_type_validator_default_precompute.buildDefaultClonerSource(defaults.pd) : void 0;
+			defaultFastPathCapture.objectDefaultMerger = defaults.ms ?? (defaults.pod !== void 0 ? require_type_validator_default_precompute.buildObjectDefaultMergeSource(defaults.pod) : void 0);
+		}
+	}
+	require_compile_aot.Capture.set({
+		method: aot.method,
+		path: aot.path,
+		slot
+	}, defaultFastPathCapture);
+	const customErrors = require_type_validator_custom_error.captureCustomErrors(schema);
+	if (customErrors) require_compile_aot.Capture.set({
+		method: aot.method,
+		path: aot.path,
+		slot
+	}, { customErrors });
+	const innerCodecs = require_type_validator_string_codec_aot.captureStringCodecEntries(schema, args.sanitize);
+	if (innerCodecs) require_compile_aot.Capture.set({
+		method: aot.method,
+		path: aot.path,
+		slot
+	}, { innerCodecs });
+	const cf = require_type_validator_frozen_check.buildFrozenCheck(buildResult, schema);
+	if (!cf) return;
+	require_compile_aot.Capture.set({
+		method: aot.method,
+		path: aot.path,
+		slot
+	}, {
+		...cf,
+		async: buildResult.external.variables.some(require_type_validator_index.isAsyncPredicate),
+		hasDefault,
+		hasCodec,
+		hasRef
+	});
+}
+function captureMirror(schema, aot, slot, sanitize) {
+	try {
+		const emitted = (0, exact_mirror.default)(schema, {
+			Compile: typebox_schema.Compile,
+			sanitize,
+			emit: true
+		});
+		if (typeof emitted?.source === "string") {
+			const ext = emitted.externals;
+			if (!ext) require_compile_aot.Capture.set({
+				method: aot.method,
+				path: aot.path,
+				slot
+			}, { mirror: {
+				source: emitted.source,
+				hasExternals: false
+			} });
+			else if (ext.unions && !ext.hof) {
+				const u = require_compile_aot.Capture.mirrorUnions(schema, ext.unions);
+				if (u) require_compile_aot.Capture.set({
+					method: aot.method,
+					path: aot.path,
+					slot
+				}, { mirror: {
+					source: emitted.source,
+					hasExternals: true,
+					u
+				} });
+			}
+		}
+	} catch {}
+}
+function captureCodecMirror(schema, aot, slot, sanitize, dir) {
+	const dirOpt = dir === "decode" ? { decode: true } : { encode: true };
+	try {
+		const emitted = (0, exact_mirror.default)(schema, {
+			Compile: typebox_schema.Compile,
+			sanitize,
+			...dirOpt,
+			emit: true
+		});
+		if (typeof emitted?.source === "string") {
+			const ext = emitted.externals;
+			if (ext?.codecs && !ext.hof && require_compile_aot.Capture.mirrorCodecs(schema, ext.codecs, dir)) {
+				let u;
+				let freezable = true;
+				if (ext.unions && ext.unions.length) {
+					u = require_compile_aot.Capture.mirrorUnions(schema, ext.unions);
+					if (!u) freezable = false;
+				}
+				if (freezable) {
+					const mirror = {
+						source: emitted.source,
+						hasExternals: true,
+						u
+					};
+					require_compile_aot.Capture.set({
+						method: aot.method,
+						path: aot.path,
+						slot
+					}, dir === "decode" ? { decodeMirror: mirror } : { encodeMirror: mirror });
+				}
+			}
+		}
+	} catch {}
+}
+function captureBridgeFree(aot, slot, rawSchema) {
+	const captured = require_compile_aot.Capture.get({
+		method: aot.method,
+		path: aot.path,
+		slot
+	});
+	if (captured) require_compile_aot.Capture.set({
+		method: aot.method,
+		path: aot.path,
+		slot
+	}, { bridgeFree: require_compile_handler_frozen_validator.isCapturedBridgeFree(captured, rawSchema, captured.coercePlan && typeof rawSchema !== "string" ? require_type_coerce.buildCoercedFromPlan(rawSchema, captured.coercePlan) : rawSchema) });
+}
+const impl = {
+	sourceOnlyValidator,
+	maybeCapture,
+	captureMirror,
+	captureCodecMirror,
+	captureBridgeFree
+};
+function installCaptureImpl() {
+	require_compile_aot.setCaptureImpl(impl);
+}
+installCaptureImpl();
+
+//#endregion
+exports.captureImplementation = impl;
+exports.installCaptureImpl = installCaptureImpl;

package/dist/compile/aot-capture.mjs

@@ -0,0 +1,174 @@
+import { Capture, setCaptureImpl } from "./aot.mjs";
+import { isCapturedBridgeFree } from "./handler/frozen-validator.mjs";
+import { buildCoercedFromPlan, captureCoercePlan } from "../type/coerce.mjs";
+import { buildDefaultClonerSource, buildObjectDefaultMergeSource, verifyPreallocatableDefault } from "../type/validator/default-precompute.mjs";
+import { buildFrozenCheck } from "../type/validator/frozen-check.mjs";
+import { captureCustomErrors } from "../type/validator/custom-error.mjs";
+import { captureStringCodecEntries } from "../type/validator/string-codec-aot.mjs";
+import { externalsShape, isAsyncPredicate } from "../type/validator/index.mjs";
+import { Build, Compile } from "typebox/schema";
+import createMirror from "exact-mirror";
+
+//#region src/compile/aot-capture.ts
+function sourceOnlyValidator(schema) {
+	const buildResult = Build(schema);
+	let full;
+	return new Proxy({}, { get(_, prop) {
+		if (prop === "buildResult") return buildResult;
+		const f = full ??= Compile(schema);
+		const value = f[prop];
+		return typeof value === "function" ? value.bind(f) : value;
+	} });
+}
+function maybeCapture(args) {
+	const { aot, slot, hasRef, originalSchema, schema, hasCodec, hasDefault, coerces, normalize, buildResult } = args;
+	if (hasCodec && !hasRef && coerces && normalize !== false && normalize !== "typebox") {
+		const plan = captureCoercePlan(originalSchema, schema);
+		if (plan && externalsShape(buildCoercedFromPlan(originalSchema, plan)) === externalsShape(schema)) Capture.set({
+			method: aot.method,
+			path: aot.path,
+			slot
+		}, { coercePlan: plan });
+	}
+	const defaultFastPathCapture = {
+		precomputeSafe: void 0,
+		precomputedDefault: void 0,
+		precomputeNull: void 0,
+		precomputedObjectDefault: void 0,
+		defaultCloner: void 0,
+		objectDefaultMerger: void 0
+	};
+	if (hasDefault) {
+		const defaults = verifyPreallocatableDefault(schema);
+		if (defaults) {
+			defaultFastPathCapture.precomputeSafe = true;
+			defaultFastPathCapture.precomputedDefault = defaults.pd;
+			defaultFastPathCapture.precomputeNull = defaults.pn;
+			defaultFastPathCapture.precomputedObjectDefault = defaults.pod;
+			defaultFastPathCapture.defaultCloner = defaults.pd !== void 0 ? buildDefaultClonerSource(defaults.pd) : void 0;
+			defaultFastPathCapture.objectDefaultMerger = defaults.ms ?? (defaults.pod !== void 0 ? buildObjectDefaultMergeSource(defaults.pod) : void 0);
+		}
+	}
+	Capture.set({
+		method: aot.method,
+		path: aot.path,
+		slot
+	}, defaultFastPathCapture);
+	const customErrors = captureCustomErrors(schema);
+	if (customErrors) Capture.set({
+		method: aot.method,
+		path: aot.path,
+		slot
+	}, { customErrors });
+	const innerCodecs = captureStringCodecEntries(schema, args.sanitize);
+	if (innerCodecs) Capture.set({
+		method: aot.method,
+		path: aot.path,
+		slot
+	}, { innerCodecs });
+	const cf = buildFrozenCheck(buildResult, schema);
+	if (!cf) return;
+	Capture.set({
+		method: aot.method,
+		path: aot.path,
+		slot
+	}, {
+		...cf,
+		async: buildResult.external.variables.some(isAsyncPredicate),
+		hasDefault,
+		hasCodec,
+		hasRef
+	});
+}
+function captureMirror(schema, aot, slot, sanitize) {
+	try {
+		const emitted = createMirror(schema, {
+			Compile,
+			sanitize,
+			emit: true
+		});
+		if (typeof emitted?.source === "string") {
+			const ext = emitted.externals;
+			if (!ext) Capture.set({
+				method: aot.method,
+				path: aot.path,
+				slot
+			}, { mirror: {
+				source: emitted.source,
+				hasExternals: false
+			} });
+			else if (ext.unions && !ext.hof) {
+				const u = Capture.mirrorUnions(schema, ext.unions);
+				if (u) Capture.set({
+					method: aot.method,
+					path: aot.path,
+					slot
+				}, { mirror: {
+					source: emitted.source,
+					hasExternals: true,
+					u
+				} });
+			}
+		}
+	} catch {}
+}
+function captureCodecMirror(schema, aot, slot, sanitize, dir) {
+	const dirOpt = dir === "decode" ? { decode: true } : { encode: true };
+	try {
+		const emitted = createMirror(schema, {
+			Compile,
+			sanitize,
+			...dirOpt,
+			emit: true
+		});
+		if (typeof emitted?.source === "string") {
+			const ext = emitted.externals;
+			if (ext?.codecs && !ext.hof && Capture.mirrorCodecs(schema, ext.codecs, dir)) {
+				let u;
+				let freezable = true;
+				if (ext.unions && ext.unions.length) {
+					u = Capture.mirrorUnions(schema, ext.unions);
+					if (!u) freezable = false;
+				}
+				if (freezable) {
+					const mirror = {
+						source: emitted.source,
+						hasExternals: true,
+						u
+					};
+					Capture.set({
+						method: aot.method,
+						path: aot.path,
+						slot
+					}, dir === "decode" ? { decodeMirror: mirror } : { encodeMirror: mirror });
+				}
+			}
+		}
+	} catch {}
+}
+function captureBridgeFree(aot, slot, rawSchema) {
+	const captured = Capture.get({
+		method: aot.method,
+		path: aot.path,
+		slot
+	});
+	if (captured) Capture.set({
+		method: aot.method,
+		path: aot.path,
+		slot
+	}, { bridgeFree: isCapturedBridgeFree(captured, rawSchema, captured.coercePlan && typeof rawSchema !== "string" ? buildCoercedFromPlan(rawSchema, captured.coercePlan) : rawSchema) });
+}
+const impl = {
+	sourceOnlyValidator,
+	maybeCapture,
+	captureMirror,
+	captureCodecMirror,
+	captureBridgeFree
+};
+function installCaptureImpl() {
+	setCaptureImpl(impl);
+}
+installCaptureImpl();
+
+//#endregion
+export { impl as captureImplementation, installCaptureImpl };

package/dist/compile/aot.d.ts

@@ -213,19 +213,60 @@ declare function captureSet(loc: {
   path: string;
   slot: ValidatorSlot;
 }, partial: Partial<CapturedValidator>): void;
-declare function captureGet(loc: {
-  method: string;
-  path: string;
-  slot: ValidatorSlot;
-}): CapturedValidator | undefined;
 declare const Capture: {
   readonly set: typeof captureSet;
-  readonly get: typeof captureGet;
+  readonly get: (loc: {
+    method: string;
+    path: string;
+    slot: ValidatorSlot;
+  }) => CapturedValidator | undefined;
   readonly handler: typeof captureHandler;
   readonly mirrorUnions: typeof captureMirrorUnions;
   readonly mirrorCodecs: typeof captureMirrorCodecs;
   readonly isCapturing: () => boolean;
   readonly isAotBuildEnv: () => boolean;
 };
+interface CaptureImpl {
+  /** Source-only TypeBox validator (retains codegen source for the manifest). */
+  sourceOnlyValidator(schema: any): any;
+  /**
+   * Capture the frozen check + defaults + custom-errors + inner-codecs + coerce
+   * plan for a validator slot. Mirrors the former `#maybeCapture`.
+   */
+  maybeCapture(args: {
+    aot: {
+      method: string;
+      path: string;
+    };
+    slot: ValidatorSlot;
+    hasRef: boolean;
+    originalSchema: any;
+    schema: any;
+    hasCodec: boolean;
+    hasDefault: boolean;
+    coerces: unknown;
+    normalize: boolean | 'exactMirror' | 'typebox' | undefined;
+    sanitize: unknown;
+    buildResult: CheckBuildResult;
+  }): void;
+  /** Capture the exact-mirror clean emit for a slot (former `#setupMirror`). */
+  captureMirror(schema: any, aot: {
+    method: string;
+    path: string;
+  }, slot: ValidatorSlot, sanitize: unknown): void;
+  /** Capture the codec decode/encode mirror emit (former `#setupCodecMirror`). */
+  captureCodecMirror(schema: any, aot: {
+    method: string;
+    path: string;
+  }, slot: ValidatorSlot, sanitize: unknown, dir: 'decode' | 'encode'): void;
+  /** Derive + store the bridge-free marker once every channel is captured. */
+  captureBridgeFree(aot: {
+    method: string;
+    path: string;
+  }, slot: ValidatorSlot, rawSchema: unknown): void;
+}
+/** Installed by the AOT build plugin; undefined at runtime. */
+declare let captureImpl: CaptureImpl | undefined;
+declare function setCaptureImpl(impl: CaptureImpl | undefined): void;
 //#endregion
-export { Capture, CapturedHandler, CapturedMirror, CapturedValidator, CheckBuildResult, Compiled, CompiledSnapshot, EMPTY_EXTERNALS, FrozenBothFactory, FrozenCheckFactory, FrozenHandler, FrozenMirror, FrozenMirrorFactory, FrozenValidator, HandlerManifest, Source, StringCodecNode, ValidatorManifest, ValidatorSlot, beginValidatorCapture, collectExternals, collectMirrorUnions, collectStringCodecNodes, endHandlerCapture, endValidatorCapture, externalsMatch, instantiateFrozenBoth, instantiateFrozenDecodeMirror, instantiateFrozenEncodeMirror, instantiateFrozenMirror, reconstructCheck, reconstructInnerCodecs };
+export { Capture, CaptureImpl, CapturedHandler, CapturedMirror, CapturedValidator, CheckBuildResult, Compiled, CompiledSnapshot, EMPTY_EXTERNALS, FrozenBothFactory, FrozenCheckFactory, FrozenHandler, FrozenMirror, FrozenMirrorFactory, FrozenValidator, HandlerManifest, Source, StringCodecNode, ValidatorManifest, ValidatorSlot, beginValidatorCapture, captureImpl, collectExternals, collectMirrorUnions, collectStringCodecNodes, endHandlerCapture, endValidatorCapture, externalsMatch, instantiateFrozenBoth, instantiateFrozenDecodeMirror, instantiateFrozenEncodeMirror, instantiateFrozenMirror, reconstructCheck, reconstructInnerCodecs, setCaptureImpl };

package/dist/compile/aot.js

@@ -304,7 +304,9 @@ function captureEntry({ method, path, slot }) {
 	});
 	return e;
 }
+const aotActivationError = /* @__PURE__ */ new Error("Elysia AOT capture module is not activated.");
 function beginValidatorCapture() {
+	if (captureImpl === void 0) throw aotActivationError;
 	capture = /* @__PURE__ */ new Map();
 }
 function endValidatorCapture() {
@@ -327,13 +329,18 @@ function captureSet(loc, partial) {
 	const e = captureEntry(loc);
 	if (e) Object.assign(e, partial);
 }
-function captureGet(loc) {
-	return capture?.get(`${loc.method}_${loc.path}_${loc.slot}`);
-}
+const captureGet = (loc) => capture?.get(`${loc.method}_${loc.path}_${loc.slot}`);
 const isAotBuildEnv = () => !!require_universal_env.env.ELYSIA_AOT_BUILD;
 const isValidatorCapturing = () => {
-	if (capture !== void 0) return true;
-	return isAotBuildEnv();
+	if (capture !== void 0) {
+		if (captureImpl === void 0) throw aotActivationError;
+		return true;
+	}
+	if (isAotBuildEnv()) {
+		if (captureImpl === void 0) throw aotActivationError;
+		return true;
+	}
+	return false;
 };
 const Capture = {
 	set: captureSet,
@@ -344,6 +351,11 @@ const Capture = {
 	isCapturing: isValidatorCapturing,
 	isAotBuildEnv
 };
+/** Installed by the AOT build plugin; undefined at runtime. */
+let captureImpl;
+function setCaptureImpl(impl) {
+	captureImpl = impl;
+}
 
 //#endregion
 exports.Capture = Capture;
@@ -351,6 +363,12 @@ exports.Compiled = Compiled;
 exports.EMPTY_EXTERNALS = EMPTY_EXTERNALS;
 exports.Source = Source;
 exports.beginValidatorCapture = beginValidatorCapture;
+Object.defineProperty(exports, 'captureImpl', {
+  enumerable: true,
+  get: function () {
+    return captureImpl;
+  }
+});
 exports.collectExternals = collectExternals;
 exports.collectMirrorUnions = collectMirrorUnions;
 exports.collectStringCodecNodes = collectStringCodecNodes;
@@ -362,4 +380,5 @@ exports.instantiateFrozenDecodeMirror = instantiateFrozenDecodeMirror;
 exports.instantiateFrozenEncodeMirror = instantiateFrozenEncodeMirror;
 exports.instantiateFrozenMirror = instantiateFrozenMirror;
 exports.reconstructCheck = reconstructCheck;
-exports.reconstructInnerCodecs = reconstructInnerCodecs;
+exports.reconstructInnerCodecs = reconstructInnerCodecs;
+exports.setCaptureImpl = setCaptureImpl;

package/dist/compile/aot.mjs

@@ -303,7 +303,9 @@ function captureEntry({ method, path, slot }) {
 	});
 	return e;
 }
+const aotActivationError = /* @__PURE__ */ new Error("Elysia AOT capture module is not activated.");
 function beginValidatorCapture() {
+	if (captureImpl === void 0) throw aotActivationError;
 	capture = /* @__PURE__ */ new Map();
 }
 function endValidatorCapture() {
@@ -326,13 +328,18 @@ function captureSet(loc, partial) {
 	const e = captureEntry(loc);
 	if (e) Object.assign(e, partial);
 }
-function captureGet(loc) {
-	return capture?.get(`${loc.method}_${loc.path}_${loc.slot}`);
-}
+const captureGet = (loc) => capture?.get(`${loc.method}_${loc.path}_${loc.slot}`);
 const isAotBuildEnv = () => !!env.ELYSIA_AOT_BUILD;
 const isValidatorCapturing = () => {
-	if (capture !== void 0) return true;
-	return isAotBuildEnv();
+	if (capture !== void 0) {
+		if (captureImpl === void 0) throw aotActivationError;
+		return true;
+	}
+	if (isAotBuildEnv()) {
+		if (captureImpl === void 0) throw aotActivationError;
+		return true;
+	}
+	return false;
 };
 const Capture = {
 	set: captureSet,
@@ -343,6 +350,11 @@ const Capture = {
 	isCapturing: isValidatorCapturing,
 	isAotBuildEnv
 };
+/** Installed by the AOT build plugin; undefined at runtime. */
+let captureImpl;
+function setCaptureImpl(impl) {
+	captureImpl = impl;
+}
 
 //#endregion
-export { Capture, Compiled, EMPTY_EXTERNALS, Source, beginValidatorCapture, collectExternals, collectMirrorUnions, collectStringCodecNodes, endHandlerCapture, endValidatorCapture, externalsMatch, instantiateFrozenBoth, instantiateFrozenDecodeMirror, instantiateFrozenEncodeMirror, instantiateFrozenMirror, reconstructCheck, reconstructInnerCodecs };
+export { Capture, Compiled, EMPTY_EXTERNALS, Source, beginValidatorCapture, captureImpl, collectExternals, collectMirrorUnions, collectStringCodecNodes, endHandlerCapture, endValidatorCapture, externalsMatch, instantiateFrozenBoth, instantiateFrozenDecodeMirror, instantiateFrozenEncodeMirror, instantiateFrozenMirror, reconstructCheck, reconstructInnerCodecs, setCaptureImpl };

package/dist/compile/handler/jit.js

@@ -165,6 +165,8 @@ function compileHandlerJit({ method, path, handler, root, hook, adapter, buildVa
 	const traceHandlers = hook?.trace ?? void 0;
 	const hasTrace = !!traceHandlers?.length;
 	const traceCount = hasTrace ? traceHandlers.length : 0;
+	const hasLifecycleHook = parseLength > 0 || !!hook?.transform?.length || hasBeforeHandle || hasAfterHandle || hasMapResponse || hasErrorHook || hasAfterResponse;
+	const abortCheck = hasLifecycleHook ? `if(aborted)return emp.clone()\n` : "";
 	const tracePhases = hasTrace ? require_trace.unionTracePhases(traceHandlers) : /* @__PURE__ */ new Set();
 	const phaseOn = (phase) => hasTrace && (tracePhases === null || tracePhases.has(phase));
 	const hasAnyPhase = hasTrace && (tracePhases === null || tracePhases.size > 0);
@@ -217,6 +219,10 @@ function compileHandlerJit({ method, path, handler, root, hook, adapter, buildVa
 	const syncAfterResponse = hasAfterResponse && !isAsync && !hasTrace && !hasErrorHook;
 	const callHandler = isHandleFunction ? callHandlerSyncOnAsync ? `_r=h(c)\nif(_r instanceof Promise)_r=await _r\n` : `_r=${isAsync ? "await " : ""}h(c)\n` : isStaticResponse ? `_r=cr(h)\n` : isPromiseHandler ? `_r=h.then(cr)\n` : `_r=h\n`;
 	let code = `${isAsync ? "async " : ""}function route(c){\n`;
+	if (hasLifecycleHook) {
+		link(require_handler_utils.emptyResponse, "emp");
+		code += "let aborted=c.request.signal.aborted\nif(!aborted)c.request.signal.addEventListener('abort',()=>{aborted=true},{once:true})\n" + abortCheck;
+	}
 	if ((hasAfterResponse || hasTrace) && !syncAfterResponse) code += "let _stl\n";
 	if (asyncCookieSign) code += "let _sg\n";
 	if (hasTrace) {
@@ -265,6 +271,7 @@ function compileHandlerJit({ method, path, handler, root, hook, adapter, buildVa
 		link(require_error.ParseError, "pe");
 		code += "try{\n" + parseCode + "}catch(e){throw new pe(e)}\n";
 		if (hasTrace) code += endTrace("parse");
+		if (hasLifecycleHook) code += abortCheck;
 	} else if (hasTrace) code += beginTrace("parse", 0) + endTrace("parse");
 	if (hook?.transform?.length || hasTrace) {
 		const transformLen = hook?.transform?.length ?? 0;
@@ -272,9 +279,10 @@ function compileHandlerJit({ method, path, handler, root, hook, adapter, buildVa
 		if (transformLen) {
 			link(hook.transform, "tf");
 			if (isAsync) code += "let _tf\n";
-			code += require_compile_handler_utils.mapTransform(hook.transform, [isAsync, buildReport("transform")]);
+			code += require_compile_handler_utils.mapTransform(hook.transform, [isAsync, buildReport("transform")], "aborted");
 		}
 		code += endTrace("transform");
+		if (transformLen) code += abortCheck;
 	}
 	if (vali?.body) {
 		link(vali, "va");
@@ -344,9 +352,10 @@ function compileHandlerJit({ method, path, handler, root, hook, adapter, buildVa
 			if (hasBeforeHandle) {
 				link(hook.beforeHandle, "bf");
 				const deriveEntries = hook["~deriveEntries"];
-				code += require_compile_handler_utils.mapBeforeHandle(hook.beforeHandle, deriveEntries?.length ? new Set(deriveEntries) : void 0, link, isAsync, buildReport("beforeHandle"));
+				code += require_compile_handler_utils.mapBeforeHandle(hook.beforeHandle, deriveEntries?.length ? new Set(deriveEntries) : void 0, link, isAsync, buildReport("beforeHandle"), "aborted");
 			}
 			code += endTrace("beforeHandle");
+			if (hasBeforeHandle) code += abortCheck;
 		}
 		if (hasAfterResponse || traceHandleOn) link(require_adapter_utils.tee, "tee");
 		const teeConsumers = (hasAfterResponse ? 1 : 0) + (traceHandleOn ? 1 : 0);
@@ -367,6 +376,7 @@ function compileHandlerJit({ method, path, handler, root, hook, adapter, buildVa
 			code += `}\n`;
 		} else if (hasBeforeHandle) code += `if(_r===undefined){\n${callHandler}${teeBlock}}\n`;
 		else code += callHandler + teeBlock;
+		if (hasLifecycleHook) code += abortCheck;
 		if (syncAfterResponse) {
 			link(require_handler_utils.forwardError, "fe");
 			factoryHelpers += `function _fin(c,_r){
@@ -386,18 +396,20 @@ const _s=tee(_r,${teeCount})\nreturn _fin2(c,_s[0],_s[1])\n}\nreturn _fin2(c,_r,
 				code += beginTrace("afterHandle", afLen);
 				if (hasAfterHandle) {
 					link(hook.afterHandle, "af");
-					code += require_compile_handler_utils.mapAfterHandle(hook.afterHandle, isAsync, buildReport("afterHandle"));
+					code += require_compile_handler_utils.mapAfterHandle(hook.afterHandle, isAsync, buildReport("afterHandle"), "aborted");
 				}
 				code += endTrace("afterHandle");
+				if (hasAfterHandle) code += abortCheck;
 			}
 			if (hasMapResponse || hasTrace) {
 				const mrLen = hook?.mapResponse?.length ?? 0;
 				code += beginTrace("mapResponse", mrLen);
 				if (hasMapResponse) {
 					link(hook.mapResponse, "mr");
-					code += require_compile_handler_utils.mapMapResponse(hook.mapResponse, isAsync, buildReport("mapResponse"));
+					code += require_compile_handler_utils.mapMapResponse(hook.mapResponse, isAsync, buildReport("mapResponse"), "aborted");
 				}
 				code += endTrace("mapResponse");
+				if (hasMapResponse) code += abortCheck;
 			}
 			if (hasResponseValidator) {
 				link(vali, "va");
@@ -406,17 +418,18 @@ const _s=tee(_r,${teeCount})\nreturn _fin2(c,_s[0],_s[1])\n}\nreturn _fin2(c,_r,
 				code += `if(_r instanceof es){
 const _vr=va.response[_r.code]
 if(_vr)_r.response=${awaitStr}_vr.EncodeFrom(_r.response,'response')\n}else if(!(_r instanceof Response)&&!(_r instanceof ReadableStream)&&typeof _r?.next!=='function'){\nconst _vr=va.response[c.set.status??200]\nif(_vr)_r=${awaitStr}_vr.EncodeFrom(_r,'response')\n}\n`;
+				if (hasLifecycleHook) code += abortCheck;
 			}
 			code += schedule;
 			code += signPrefix;
 			const finalMap = hasSet ? `${map}(_r,c.set,c.request)` : `${map}(_r,c.request)`;
-			if (syncErrorHook) code += `if(_r instanceof Promise)return ${finalMap}.catch((_e)=>_ce(_e,c))\n`;
+			if (syncErrorHook) code += `if(_r instanceof Promise)return ${finalMap}.catch((_e)=>_ce(_e,c,aborted))\n`;
 			code += `return ${finalMap}\n`;
 		}
 	} else if (isHandleFunction) {
 		if (!isAsync) link(require_handler_utils.forwardError, "fe");
 		const mapArgs = hasSet ? "c.set,c.request" : "c.request";
-		code += (callHandlerSyncOnAsync ? `let _r=h(c)\nif(_r instanceof Promise)_r=await _r\n` : `let _r=${isAsync ? "await " : ""}h(c)\n`) + `if(_r instanceof Error)throw _r\n` + (isAsync ? `return ${map}(_r,${mapArgs})\n` : syncErrorHook ? `if(_r instanceof Promise)return ${map}(_r.then(fe),${mapArgs}).catch((_e)=>_ce(_e,c))\nreturn ${map}(_r,${mapArgs})\n` : `if(_r instanceof Promise)_r=_r.then(fe)\nreturn ${map}(_r,${mapArgs})\n`);
+		code += (callHandlerSyncOnAsync ? `let _r=h(c)\nif(_r instanceof Promise)_r=await _r\n` : `let _r=${isAsync ? "await " : ""}h(c)\n`) + abortCheck + `if(_r instanceof Error)throw _r\n` + (isAsync ? `return ${map}(_r,${mapArgs})\n` : syncErrorHook ? `if(_r instanceof Promise)return ${map}(_r.then(fe),${mapArgs}).catch((_e)=>_ce(_e,c,aborted))\nreturn ${map}(_r,${mapArgs})\n` : `if(_r instanceof Promise)_r=_r.then(fe)\nreturn ${map}(_r,${mapArgs})\n`);
 	} else code += `return ${mapReturn}`;
 	if (hasErrorHook || hasTrace) {
 		let body = "";
@@ -438,9 +451,9 @@ let _r${hasMapResponse ? ",tmp" : ""}\n` + require_compile_handler_utils.mapErro
 				map,
 				link,
 				res.map,
-				(hasMapResponse ? `c.responseValue=_r\n` + require_compile_handler_utils.mapMapResponse(hook.mapResponse, isAsync, void 0) : "") + endTrace("error") + schedule,
+				(hasMapResponse ? `c.responseValue=_r\n` + require_compile_handler_utils.mapMapResponse(hook.mapResponse, isAsync, void 0, "aborted") : "") + endTrace("error") + abortCheck + schedule,
 				signPrefix
-			]) + endTrace("error") + schedule + `if(typeof e?.toResponse==='function')try{
+			], "aborted") + endTrace("error") + abortCheck + schedule + `if(typeof e?.toResponse==='function')try{
 const _er=e.toResponse()
 if(_er instanceof Promise)return _er.then(${asyncCookieSign ? "async " : ""}(_v)=>{if(_v instanceof Response){${signPrefix}return ${map}(_v,c.set,c.request)}return _efb(e,c)},()=>_efb(e,c))\nif(_er instanceof Response){${signPrefix}return ${map}(_er,c.set,c.request)}\n}catch{}\nreturn _efb(e,c)\n`;
 		} else {
@@ -448,8 +461,8 @@ if(_er instanceof Promise)return _er.then(${asyncCookieSign ? "async " : ""}(_v)
 			body += `throw e\n`;
 		}
 		if (syncErrorHook) {
-			factoryHelpers += `function _ce(e,c){\n${body}}\n`;
-			code += `}catch(e){return _ce(e,c)}\n`;
+			factoryHelpers += `function _ce(e,c,aborted){\n${body}}\n`;
+			code += `}catch(e){return _ce(e,c,aborted)}\n`;
 		} else code += `}catch(e){\n${body}}\n`;
 	}
 	code += "}";