elysia 2.0.0-beta.29 → 2.0.0-beta.30

package/dist/adapter/bun/index.js

@@ -290,7 +290,7 @@ const BunAdapter = require_adapter_index.createAdapter({
 		};
 		const registerCleanup = (handler) => {
 			if (ext.cleanupEpoch !== registerCleanup) return false;
-			if (!epoch.setup) throw new Error("[Elysia] .cleanup() called after its setup epoch settled");
+			if (!epoch.setup) throw new Error("[Elysia] .onStop() called after its onStart epoch settled");
 			if (Array.isArray(handler)) epochCleanup.push(...handler);
 			else epochCleanup.push(handler);
 			return true;
@@ -477,7 +477,7 @@ const BunAdapter = require_adapter_index.createAdapter({
 						if (cleanupFailures) errors.push(...cleanupFailures);
 						const release = () => releaseLifecycle(app, ext, createdExt, stop, registerCleanup);
 						if (releasable && abandonedSetups) abandonedSetups.then((results) => {
-							for (const result of results) if (result.status === "rejected") console.error("[Elysia] setup abandoned by stop(true) failed:", result.reason);
+							for (const result of results) if (result.status === "rejected") console.error("[Elysia] onStart abandoned by stop(true) failed:", result.reason);
 							release();
 						});
 						else if (releasable) release();

package/dist/adapter/bun/index.mjs

@@ -290,7 +290,7 @@ const BunAdapter = createAdapter({
 		};
 		const registerCleanup = (handler) => {
 			if (ext.cleanupEpoch !== registerCleanup) return false;
-			if (!epoch.setup) throw new Error("[Elysia] .cleanup() called after its setup epoch settled");
+			if (!epoch.setup) throw new Error("[Elysia] .onStop() called after its onStart epoch settled");
 			if (Array.isArray(handler)) epochCleanup.push(...handler);
 			else epochCleanup.push(handler);
 			return true;
@@ -477,7 +477,7 @@ const BunAdapter = createAdapter({
 						if (cleanupFailures) errors.push(...cleanupFailures);
 						const release = () => releaseLifecycle(app, ext, createdExt, stop, registerCleanup);
 						if (releasable && abandonedSetups) abandonedSetups.then((results) => {
-							for (const result of results) if (result.status === "rejected") console.error("[Elysia] setup abandoned by stop(true) failed:", result.reason);
+							for (const result of results) if (result.status === "rejected") console.error("[Elysia] onStart abandoned by stop(true) failed:", result.reason);
 							release();
 						});
 						else if (releasable) release();

package/dist/base.d.ts

@@ -5,7 +5,7 @@ import { Context, ErrorContext, LifecycleContext } from "./context.js";
 import { TraceCapability, TraceHandler } from "./trace.js";
 import { AnySchema } from "./type/types.js";
 import { AotFingerprint, CompilerSession, ProgramId } from "./compile/aot.js";
-import { AddRoute, AddWSRoute, AfterHandler, AfterResponseHandler, AnyErrorConstructor, AnyLocalHook, BodyHandler, CompiledHandler, CreateEden, DefaultEphemeral, DefaultMetadata, DefaultSingleton, DefinitionBase, ElysiaConfig, ElysiaHandlerToResponseSchemaAmbiguous, EphemeralType, ErrorDefinitionEntry, ErrorHandler, EventScope, ExcludeElysiaResponse, ExtractErrorFromHandle, GlobalHookReturn, GracefulHandler, GuardHookSingleton, GuardLocalHook, HTTPMethod, HistoryEntry, HookContextSchema, HookContextSingleton, InlineHandler, InlineHandlerNonMacro, InputSchema, InputSchemaKey, InternalRoute, IntersectIfObjectSchema, JoinPath, LocalHook, LocalHookReturn, Macro, MacroOptionContext, MacroToContext, MacroToProperty, MapResponse, MaybeArray, MaybePromise, MergeElysiaInstances, MergeSchema, MergeScopedSchemas, MetadataBase, ObjectMacroDefs, OptionalHandler, ParentResponse, PluginHookReturn, PreHandler, Prettify, PublicRoute, ResolveUsedRouteErrors, RouteBase, ScopedHookReturn, ScopedMapDeriveReturn, SingletonBase, StaticMapAliases, TransformHandler, UnionResponseStatus, UnwrapRoute, WrapFn } from "./types.js";
+import { AddRoute, AddWSRoute, AfterHandler, AfterResponseHandler, AnyErrorConstructor, AnyLocalHook, BodyHandler, CompiledHandler, CreateEden, DefaultEphemeral, DefaultMetadata, DefaultSingleton, DefinitionBase, ElysiaConfig, ElysiaHandlerToResponseSchemaAmbiguous, EphemeralType, ErrorDefinitionEntry, ErrorHandler, EventScope, ExcludeElysiaResponse, ExtractErrorFromHandle, GlobalHookReturn, GracefulHandler, GuardHookSingleton, GuardLocalHook, HTTPMethod, HistoryEntry, HookContextSchema, HookContextSingleton, InlineHandler, InlineHandlerNonMacro, InputSchema, InputSchemaKey, InternalRoute, IntersectIfObjectSchema, JoinPath, LegacyScope, LocalHook, LocalHookReturn, Macro, MacroOptionContext, MacroToContext, MacroToProperty, MapResponse, MaybeArray, MaybePromise, MergeElysiaInstances, MergeSchema, MergeScopedSchemas, MetadataBase, ObjectMacroDefs, OptionalHandler, ParentResponse, PluginHookReturn, PreHandler, Prettify, PublicRoute, ResolveUsedRouteErrors, RouteBase, ScopedHookReturn, ScopedMapDeriveReturn, SingletonBase, StaticMapAliases, TransformHandler, UnionResponseStatus, UnwrapRoute, WrapFn } from "./types.js";
 import { RouteErrorHooks } from "./handler/utils.js";
 import { WSCapability, WSHandlerResponse, WSLocalHook, WSMessageHandler, WSOptions, WSOptionsEntry } from "./ws/types.js";
 import { RouteTable } from "./route-table.js";
@@ -204,10 +204,14 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
     derive: Singleton['derive'];
   }, Definitions, Metadata, Routes, Ephemeral, Volatile>;
   headers(headers: Record<string, string>): this;
-  request(fn: MaybeArray<PreHandler<{}, Singleton>>): this;
-  parse(fn: MaybeArray<BodyHandler<MergeSchema<{}, {}, BasePath>, HookContextSingleton<Singleton, Ephemeral, Volatile>>>): this;
-  parse(name: string): this;
-  parse<const HookScope extends EventScope>(scope: HookScope, fn: MaybeArray<BodyHandler<MergeSchema<{}, {}, BasePath>, HookContextSingleton<Singleton, Ephemeral, Volatile>, undefined, HookScope>>): this;
+  onRequest(fn: MaybeArray<PreHandler<{}, Singleton>>): this;
+  onParse(fn: MaybeArray<BodyHandler<MergeSchema<{}, {}, BasePath>, HookContextSingleton<Singleton, Ephemeral, Volatile>>>): this;
+  onParse(name: string): this;
+  /** @deprecated 1.x syntax, use `.onParse('plugin', fn)`, `'scoped'` is now `'plugin'` */
+  onParse<const As extends 'local' | 'scoped' | 'global'>(options: {
+    as: As;
+  }, fn: MaybeArray<BodyHandler<MergeSchema<{}, {}, BasePath>, HookContextSingleton<Singleton, Ephemeral, Volatile>, undefined, LegacyScope<As>>>): this;
+  onParse<const HookScope extends EventScope>(scope: HookScope, fn: MaybeArray<BodyHandler<MergeSchema<{}, {}, BasePath>, HookContextSingleton<Singleton, Ephemeral, Volatile>, undefined, HookScope>>): this;
   parser<const Name extends string>(name: Name, fn: BodyHandler<MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>, BasePath> & Metadata['schemas'] & Ephemeral['schemas'] & Volatile['schemas'], Singleton & {
     derive: Ephemeral['derive'] & Volatile['derive'];
   }>): Elysia<BasePath, Scope, Singleton, Definitions, {
@@ -219,31 +223,43 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
     response: Metadata['response'];
   }, Routes, Ephemeral, Volatile>;
   /**
-   * ### setup | Life cycle event
+   * ### onStart | Life cycle event
    * Called after server is ready for serving
    *
    * ---
    * @example
    * ```typescript
    * new Elysia()
-   *     .setup(({ server }) => {
+   *     .onStart(({ server }) => {
    *         console.log(`Running at ${server?.url}`)
    *     })
    *     .listen(3000)
    * ```
    */
-  setup(handler: MaybeArray<GracefulHandler<this>>): this;
-  transform(fn: MaybeArray<TransformHandler<MergeSchema<{}, {}, BasePath>, HookContextSingleton<Singleton, Ephemeral, Volatile>>>): this;
-  transform<const HookScope extends EventScope>(scope: HookScope, fn: MaybeArray<TransformHandler<MergeSchema<{}, {}, BasePath>, HookContextSingleton<Singleton, Ephemeral, Volatile>, undefined, HookScope>>): this;
-  beforeHandle<const Handler extends MaybeArray<OptionalHandler<HookContextSchema<Metadata, Ephemeral, Volatile, BasePath>, HookContextSingleton<Singleton, Ephemeral, Volatile>>>>(fn: Handler): LocalHookReturn<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, ElysiaHandlerToResponseSchemaAmbiguous<Handler>>;
-  beforeHandle<const Handler extends MaybeArray<OptionalHandler<HookContextSchema<Metadata, Ephemeral, Volatile, BasePath>, HookContextSingleton<Singleton, Ephemeral, Volatile>>>>(scope: 'local', fn: Handler): LocalHookReturn<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, ElysiaHandlerToResponseSchemaAmbiguous<Handler>>;
-  beforeHandle<const Handler extends MaybeArray<OptionalHandler<HookContextSchema<Metadata, Ephemeral, Volatile, BasePath>, HookContextSingleton<Singleton, Ephemeral, Volatile>, undefined, 'plugin'>>>(scope: 'plugin', fn: Handler): PluginHookReturn<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, ElysiaHandlerToResponseSchemaAmbiguous<Handler>>;
-  beforeHandle<const Handler extends MaybeArray<OptionalHandler<HookContextSchema<Metadata, Ephemeral, Volatile, BasePath>, HookContextSingleton<Singleton, Ephemeral, Volatile>, undefined, 'global'>>>(scope: 'global', fn: Handler): GlobalHookReturn<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, ElysiaHandlerToResponseSchemaAmbiguous<Handler>>;
-  beforeHandle<const HookScope extends EventScope, const Handler extends MaybeArray<OptionalHandler<HookContextSchema<Metadata, Ephemeral, Volatile, BasePath>, HookContextSingleton<Singleton, Ephemeral, Volatile>, undefined, HookScope>>>(scope: HookScope, fn: Handler): ScopedHookReturn<HookScope, BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, ElysiaHandlerToResponseSchemaAmbiguous<Handler>>;
+  onStart(handler: MaybeArray<GracefulHandler<this>>): this;
+  onTransform(fn: MaybeArray<TransformHandler<MergeSchema<{}, {}, BasePath>, HookContextSingleton<Singleton, Ephemeral, Volatile>>>): this;
+  /** @deprecated 1.x syntax, use `.onTransform('plugin', fn)`, `'scoped'` is now `'plugin'` */
+  onTransform<const As extends 'local' | 'scoped' | 'global'>(options: {
+    as: As;
+  }, fn: MaybeArray<TransformHandler<MergeSchema<{}, {}, BasePath>, HookContextSingleton<Singleton, Ephemeral, Volatile>, undefined, LegacyScope<As>>>): this;
+  onTransform<const HookScope extends EventScope>(scope: HookScope, fn: MaybeArray<TransformHandler<MergeSchema<{}, {}, BasePath>, HookContextSingleton<Singleton, Ephemeral, Volatile>, undefined, HookScope>>): this;
+  onBeforeHandle<const Handler extends MaybeArray<OptionalHandler<HookContextSchema<Metadata, Ephemeral, Volatile, BasePath>, HookContextSingleton<Singleton, Ephemeral, Volatile>>>>(fn: Handler): LocalHookReturn<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, ElysiaHandlerToResponseSchemaAmbiguous<Handler>>;
+  onBeforeHandle<const Handler extends MaybeArray<OptionalHandler<HookContextSchema<Metadata, Ephemeral, Volatile, BasePath>, HookContextSingleton<Singleton, Ephemeral, Volatile>>>>(scope: 'local', fn: Handler): LocalHookReturn<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, ElysiaHandlerToResponseSchemaAmbiguous<Handler>>;
+  onBeforeHandle<const Handler extends MaybeArray<OptionalHandler<HookContextSchema<Metadata, Ephemeral, Volatile, BasePath>, HookContextSingleton<Singleton, Ephemeral, Volatile>, undefined, 'plugin'>>>(scope: 'plugin', fn: Handler): PluginHookReturn<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, ElysiaHandlerToResponseSchemaAmbiguous<Handler>>;
+  onBeforeHandle<const Handler extends MaybeArray<OptionalHandler<HookContextSchema<Metadata, Ephemeral, Volatile, BasePath>, HookContextSingleton<Singleton, Ephemeral, Volatile>, undefined, 'global'>>>(scope: 'global', fn: Handler): GlobalHookReturn<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, ElysiaHandlerToResponseSchemaAmbiguous<Handler>>;
+  /** @deprecated 1.x syntax, use `.onBeforeHandle('plugin', fn)`, `'scoped'` is now `'plugin'` */
+  onBeforeHandle<const As extends 'local' | 'scoped' | 'global', const Handler extends MaybeArray<OptionalHandler<HookContextSchema<Metadata, Ephemeral, Volatile, BasePath>, HookContextSingleton<Singleton, Ephemeral, Volatile>, undefined, LegacyScope<As>>>>(options: {
+    as: As;
+  }, fn: Handler): ScopedHookReturn<LegacyScope<As>, BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, ElysiaHandlerToResponseSchemaAmbiguous<Handler>>;
+  onBeforeHandle<const HookScope extends EventScope, const Handler extends MaybeArray<OptionalHandler<HookContextSchema<Metadata, Ephemeral, Volatile, BasePath>, HookContextSingleton<Singleton, Ephemeral, Volatile>, undefined, HookScope>>>(scope: HookScope, fn: Handler): ScopedHookReturn<HookScope, BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, ElysiaHandlerToResponseSchemaAmbiguous<Handler>>;
   derive<const Derivative extends Record<string, unknown> | ElysiaStatus<any, any, any> | void>(transform: (context: Context<HookContextSchema<Metadata, Ephemeral, Volatile, BasePath>, HookContextSingleton<Singleton, Ephemeral, Volatile>>) => MaybePromise<Derivative>): LocalHookReturn<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, ExtractErrorFromHandle<Derivative>, ExcludeElysiaResponse<Derivative>>;
   derive<const Derivative extends Record<string, unknown> | ElysiaStatus<any, any, any> | void>(scope: 'local', transform: (context: Context<HookContextSchema<Metadata, Ephemeral, Volatile, BasePath>, HookContextSingleton<Singleton, Ephemeral, Volatile>>) => MaybePromise<Derivative>): LocalHookReturn<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, ExtractErrorFromHandle<Derivative>, ExcludeElysiaResponse<Derivative>>;
   derive<const Derivative extends Record<string, unknown> | ElysiaStatus<any, any, any> | void>(scope: 'plugin', transform: (context: LifecycleContext<HookContextSchema<Metadata, Ephemeral, Volatile, BasePath>, HookContextSingleton<Singleton, Ephemeral, Volatile>, undefined, 'plugin'>) => MaybePromise<Derivative>): PluginHookReturn<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, ExtractErrorFromHandle<Derivative>, ExcludeElysiaResponse<Derivative>>;
   derive<const Derivative extends Record<string, unknown> | ElysiaStatus<any, any, any> | void>(scope: 'global', transform: (context: LifecycleContext<HookContextSchema<Metadata, Ephemeral, Volatile, BasePath>, HookContextSingleton<Singleton, Ephemeral, Volatile>, undefined, 'global'>) => MaybePromise<Derivative>): GlobalHookReturn<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, ExtractErrorFromHandle<Derivative>, ExcludeElysiaResponse<Derivative>>;
+  /** @deprecated 1.x syntax, use `.derive('plugin', fn)`, `'scoped'` is now `'plugin'` */
+  derive<const As extends 'local' | 'scoped' | 'global', const Derivative extends Record<string, unknown> | ElysiaStatus<any, any, any> | void>(options: {
+    as: As;
+  }, transform: (context: LifecycleContext<HookContextSchema<Metadata, Ephemeral, Volatile, BasePath>, HookContextSingleton<Singleton, Ephemeral, Volatile>, undefined, LegacyScope<As>>) => MaybePromise<Derivative>): ScopedHookReturn<LegacyScope<As>, BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, ExtractErrorFromHandle<Derivative>, ExcludeElysiaResponse<Derivative>>;
   derive<const HookScope extends EventScope, const Derivative extends Record<string, unknown> | ElysiaStatus<any, any, any> | void>(scope: HookScope, transform: (context: LifecycleContext<HookContextSchema<Metadata, Ephemeral, Volatile, BasePath>, HookContextSingleton<Singleton, Ephemeral, Volatile>, undefined, HookScope>) => MaybePromise<Derivative>): ScopedHookReturn<HookScope, BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, ExtractErrorFromHandle<Derivative>, ExcludeElysiaResponse<Derivative>>;
   mapDerive<const Derivative extends Record<string, unknown> | ElysiaStatus<any, any, any> | void>(transform: (context: Context<HookContextSchema<Metadata, Ephemeral, Volatile, BasePath>, HookContextSingleton<Singleton, Ephemeral, Volatile>>) => MaybePromise<Derivative>): Elysia<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, {
     derive: ExcludeElysiaResponse<Derivative>;
@@ -278,18 +294,34 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
     parser: Metadata['parser'];
     response: UnionResponseStatus<Metadata['response'], ExtractErrorFromHandle<Derivative>>;
   }, Routes, Ephemeral, Volatile>;
+  /** @deprecated 1.x syntax, use `.mapDerive('plugin', fn)`, `'scoped'` is now `'plugin'` */
+  mapDerive<const As extends 'local' | 'scoped' | 'global', const Derivative extends Record<string, unknown> | ElysiaStatus<any, any, any> | void>(options: {
+    as: As;
+  }, transform: (context: LifecycleContext<HookContextSchema<Metadata, Ephemeral, Volatile, BasePath>, HookContextSingleton<Singleton, Ephemeral, Volatile>, undefined, LegacyScope<As>>) => MaybePromise<Derivative>): ScopedMapDeriveReturn<LegacyScope<As>, BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, ExtractErrorFromHandle<Derivative>, ExcludeElysiaResponse<Derivative>>;
   mapDerive<const HookScope extends EventScope, const Derivative extends Record<string, unknown> | ElysiaStatus<any, any, any> | void>(scope: HookScope, transform: (context: LifecycleContext<HookContextSchema<Metadata, Ephemeral, Volatile, BasePath>, HookContextSingleton<Singleton, Ephemeral, Volatile>, undefined, HookScope>) => MaybePromise<Derivative>): ScopedMapDeriveReturn<HookScope, BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, ExtractErrorFromHandle<Derivative>, ExcludeElysiaResponse<Derivative>>;
-  afterHandle<const Handler extends MaybeArray<AfterHandler<HookContextSchema<Metadata, Ephemeral, Volatile, BasePath>, HookContextSingleton<Singleton, Ephemeral, Volatile>>>>(fn: Handler): LocalHookReturn<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, ElysiaHandlerToResponseSchemaAmbiguous<Handler>>;
-  afterHandle<const Handler extends MaybeArray<AfterHandler<HookContextSchema<Metadata, Ephemeral, Volatile, BasePath>, HookContextSingleton<Singleton, Ephemeral, Volatile>>>>(scope: 'local', fn: Handler): LocalHookReturn<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, ElysiaHandlerToResponseSchemaAmbiguous<Handler>>;
-  afterHandle<const Handler extends MaybeArray<AfterHandler<HookContextSchema<Metadata, Ephemeral, Volatile, BasePath>, HookContextSingleton<Singleton, Ephemeral, Volatile>, undefined, 'plugin'>>>(scope: 'plugin', fn: Handler): PluginHookReturn<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, ElysiaHandlerToResponseSchemaAmbiguous<Handler>>;
-  afterHandle<const Handler extends MaybeArray<AfterHandler<HookContextSchema<Metadata, Ephemeral, Volatile, BasePath>, HookContextSingleton<Singleton, Ephemeral, Volatile>, undefined, 'global'>>>(scope: 'global', fn: Handler): GlobalHookReturn<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, ElysiaHandlerToResponseSchemaAmbiguous<Handler>>;
-  afterHandle<const HookScope extends EventScope, const Handler extends MaybeArray<AfterHandler<HookContextSchema<Metadata, Ephemeral, Volatile, BasePath>, HookContextSingleton<Singleton, Ephemeral, Volatile>, undefined, HookScope>>>(scope: HookScope, fn: Handler): ScopedHookReturn<HookScope, BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, ElysiaHandlerToResponseSchemaAmbiguous<Handler>>;
+  onAfterHandle<const Handler extends MaybeArray<AfterHandler<HookContextSchema<Metadata, Ephemeral, Volatile, BasePath>, HookContextSingleton<Singleton, Ephemeral, Volatile>>>>(fn: Handler): LocalHookReturn<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, ElysiaHandlerToResponseSchemaAmbiguous<Handler>>;
+  onAfterHandle<const Handler extends MaybeArray<AfterHandler<HookContextSchema<Metadata, Ephemeral, Volatile, BasePath>, HookContextSingleton<Singleton, Ephemeral, Volatile>>>>(scope: 'local', fn: Handler): LocalHookReturn<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, ElysiaHandlerToResponseSchemaAmbiguous<Handler>>;
+  onAfterHandle<const Handler extends MaybeArray<AfterHandler<HookContextSchema<Metadata, Ephemeral, Volatile, BasePath>, HookContextSingleton<Singleton, Ephemeral, Volatile>, undefined, 'plugin'>>>(scope: 'plugin', fn: Handler): PluginHookReturn<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, ElysiaHandlerToResponseSchemaAmbiguous<Handler>>;
+  onAfterHandle<const Handler extends MaybeArray<AfterHandler<HookContextSchema<Metadata, Ephemeral, Volatile, BasePath>, HookContextSingleton<Singleton, Ephemeral, Volatile>, undefined, 'global'>>>(scope: 'global', fn: Handler): GlobalHookReturn<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, ElysiaHandlerToResponseSchemaAmbiguous<Handler>>;
+  /** @deprecated 1.x syntax, use `.onAfterHandle('plugin', fn)`, `'scoped'` is now `'plugin'` */
+  onAfterHandle<const As extends 'local' | 'scoped' | 'global', const Handler extends MaybeArray<AfterHandler<HookContextSchema<Metadata, Ephemeral, Volatile, BasePath>, HookContextSingleton<Singleton, Ephemeral, Volatile>, undefined, LegacyScope<As>>>>(options: {
+    as: As;
+  }, fn: Handler): ScopedHookReturn<LegacyScope<As>, BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, ElysiaHandlerToResponseSchemaAmbiguous<Handler>>;
+  onAfterHandle<const HookScope extends EventScope, const Handler extends MaybeArray<AfterHandler<HookContextSchema<Metadata, Ephemeral, Volatile, BasePath>, HookContextSingleton<Singleton, Ephemeral, Volatile>, undefined, HookScope>>>(scope: HookScope, fn: Handler): ScopedHookReturn<HookScope, BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, ElysiaHandlerToResponseSchemaAmbiguous<Handler>>;
   mapResponse(fn: MaybeArray<MapResponse<HookContextSchema<Metadata, Ephemeral, Volatile, BasePath>, HookContextSingleton<Singleton, Ephemeral, Volatile>>>): this;
+  /** @deprecated 1.x syntax, use `.mapResponse('plugin', fn)`, `'scoped'` is now `'plugin'` */
+  mapResponse<const As extends 'local' | 'scoped' | 'global'>(options: {
+    as: As;
+  }, fn: MaybeArray<MapResponse<HookContextSchema<Metadata, Ephemeral, Volatile, BasePath>, HookContextSingleton<Singleton, Ephemeral, Volatile>, undefined, LegacyScope<As>>>): this;
   mapResponse<const HookScope extends EventScope>(scope: HookScope, fn: MaybeArray<MapResponse<HookContextSchema<Metadata, Ephemeral, Volatile, BasePath>, HookContextSingleton<Singleton, Ephemeral, Volatile>, undefined, HookScope>>): this;
-  afterResponse(fn: AfterResponseHandler<HookContextSchema<Metadata, Ephemeral, Volatile, BasePath>, HookContextSingleton<Singleton, Ephemeral, Volatile>>): this;
-  afterResponse<const HookScope extends EventScope>(scope: HookScope, fn: AfterResponseHandler<HookContextSchema<Metadata, Ephemeral, Volatile, BasePath>, HookContextSingleton<Singleton, Ephemeral, Volatile>, undefined, HookScope>): this;
-  error<const Handler extends MaybeArray<ErrorHandler<[...Definitions['error'], ...Ephemeral['error'], ...Volatile['error']], {}, Singleton>>>(fn: Handler): LocalHookReturn<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, ElysiaHandlerToResponseSchemaAmbiguous<Handler>>;
-  error<const E extends AnyErrorConstructor & (abstract new (...args: any) => Error), const Fn extends (context: ErrorContext<{}, Singleton & {
+  onAfterResponse(fn: AfterResponseHandler<HookContextSchema<Metadata, Ephemeral, Volatile, BasePath>, HookContextSingleton<Singleton, Ephemeral, Volatile>>): this;
+  /** @deprecated 1.x syntax, use `.onAfterResponse('plugin', fn)`, `'scoped'` is now `'plugin'` */
+  onAfterResponse<const As extends 'local' | 'scoped' | 'global'>(options: {
+    as: As;
+  }, fn: AfterResponseHandler<HookContextSchema<Metadata, Ephemeral, Volatile, BasePath>, HookContextSingleton<Singleton, Ephemeral, Volatile>, undefined, LegacyScope<As>>): this;
+  onAfterResponse<const HookScope extends EventScope>(scope: HookScope, fn: AfterResponseHandler<HookContextSchema<Metadata, Ephemeral, Volatile, BasePath>, HookContextSingleton<Singleton, Ephemeral, Volatile>, undefined, HookScope>): this;
+  onError<const Handler extends MaybeArray<ErrorHandler<[...Definitions['error'], ...Ephemeral['error'], ...Volatile['error']], {}, Singleton>>>(fn: Handler): LocalHookReturn<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, ElysiaHandlerToResponseSchemaAmbiguous<Handler>>;
+  onError<const E extends AnyErrorConstructor & (abstract new (...args: any) => Error), const Fn extends (context: ErrorContext<{}, Singleton & {
     derive: Scope extends 'local' ? Partial<Ephemeral['derive'] & Volatile['derive']> : Scope extends 'plugin' ? Ephemeral['derive'] & Partial<Volatile['derive']> : Ephemeral['derive'] & Volatile['derive'];
   }> & {
     error: InstanceType<E>;
@@ -309,26 +341,32 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
     typebox: Definitions['typebox'];
     error: [...Definitions['error'], ErrorDefinitionEntry<E, ReturnType<Fn>>];
   }, Metadata, Routes, Ephemeral, Volatile>;
-  error<const E extends AnyErrorConstructor & (abstract new (...args: any) => Error), const Value>(error: E, value: Value): Elysia<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, {
+  onError<const E extends AnyErrorConstructor & (abstract new (...args: any) => Error), const Value>(error: E, value: Value): Elysia<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, {
     derive: Volatile['derive'];
     schema: Volatile['schema'];
     schemas: Volatile['schemas'];
     response: Volatile['response'];
     error: [...Volatile['error'], ErrorDefinitionEntry<E, Value>];
   }>;
-  error<const Handler extends MaybeArray<ErrorHandler<[...Definitions['error'], ...Ephemeral['error'], ...Volatile['error']], {}, Singleton & {
+  onError<const Handler extends MaybeArray<ErrorHandler<[...Definitions['error'], ...Ephemeral['error'], ...Volatile['error']], {}, Singleton & {
     derive: Partial<Ephemeral['derive'] & Volatile['derive']>;
   }>>>(scope: 'local', fn: Handler): LocalHookReturn<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, ElysiaHandlerToResponseSchemaAmbiguous<Handler>>;
-  error<const Handler extends MaybeArray<ErrorHandler<[...Definitions['error'], ...Ephemeral['error'], ...Volatile['error']], {}, Singleton & {
+  onError<const Handler extends MaybeArray<ErrorHandler<[...Definitions['error'], ...Ephemeral['error'], ...Volatile['error']], {}, Singleton & {
     derive: Ephemeral['derive'] & Partial<Volatile['derive']>;
   }>>>(scope: 'plugin', fn: Handler): PluginHookReturn<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, ElysiaHandlerToResponseSchemaAmbiguous<Handler>>;
-  error<const Handler extends MaybeArray<ErrorHandler<[...Definitions['error'], ...Ephemeral['error'], ...Volatile['error']], {}, Singleton & {
+  onError<const Handler extends MaybeArray<ErrorHandler<[...Definitions['error'], ...Ephemeral['error'], ...Volatile['error']], {}, Singleton & {
     derive: Ephemeral['derive'] & Volatile['derive'];
   }>>>(scope: 'global', fn: Handler): GlobalHookReturn<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, ElysiaHandlerToResponseSchemaAmbiguous<Handler>>;
-  error<const HookScope extends EventScope, const Handler extends MaybeArray<ErrorHandler<[...Definitions['error'], ...Ephemeral['error'], ...Volatile['error']], {}, Singleton & {
+  /** @deprecated 1.x syntax, use `.onError('plugin', fn)`, `'scoped'` is now `'plugin'` */
+  onError<const As extends 'local' | 'scoped' | 'global', const Handler extends MaybeArray<ErrorHandler<[...Definitions['error'], ...Ephemeral['error'], ...Volatile['error']], {}, Singleton & {
+    derive: Partial<Ephemeral['derive'] & Volatile['derive']>;
+  }>>>(options: {
+    as: As;
+  }, fn: Handler): ScopedHookReturn<LegacyScope<As>, BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, ElysiaHandlerToResponseSchemaAmbiguous<Handler>>;
+  onError<const HookScope extends EventScope, const Handler extends MaybeArray<ErrorHandler<[...Definitions['error'], ...Ephemeral['error'], ...Volatile['error']], {}, Singleton & {
     derive: Partial<Ephemeral['derive'] & Volatile['derive']>;
   }>>>(scope: HookScope, fn: Handler): ScopedHookReturn<HookScope, BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, ElysiaHandlerToResponseSchemaAmbiguous<Handler>>;
-  error<const S extends EventScope, const E extends AnyErrorConstructor & (abstract new (...args: any) => Error), const Fn extends (context: ErrorContext<{}, {
+  onError<const S extends EventScope, const E extends AnyErrorConstructor & (abstract new (...args: any) => Error), const Fn extends (context: ErrorContext<{}, {
     store: Singleton['store'];
     decorator: Singleton['decorator'];
     derive: {};
@@ -350,7 +388,7 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
     response: Volatile['response'];
     error: [...Volatile['error'], ErrorDefinitionEntry<E, ReturnType<Fn>>];
   }>;
-  error<const S extends EventScope, const E extends AnyErrorConstructor & (abstract new (...args: any) => Error), const Value>(scope: S, error: E, value: Value): S extends 'global' ? Elysia<BasePath, Scope, Singleton, {
+  onError<const S extends EventScope, const E extends AnyErrorConstructor & (abstract new (...args: any) => Error), const Value>(scope: S, error: E, value: Value): S extends 'global' ? Elysia<BasePath, Scope, Singleton, {
     typebox: Definitions['typebox'];
     error: [...Definitions['error'], ErrorDefinitionEntry<E, Value>];
   }, Metadata, Routes, Ephemeral, Volatile> : S extends 'plugin' ? Elysia<BasePath, Scope, Singleton, Definitions, Metadata, Routes, {
@@ -367,6 +405,10 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
     error: [...Volatile['error'], ErrorDefinitionEntry<E, Value>];
   }>;
   trace(fn: TraceHandler<any, any>): this;
+  /** @deprecated 1.x syntax, use `.trace('plugin', fn)`, `'scoped'` is now `'plugin'` */
+  trace<const As extends 'local' | 'scoped' | 'global'>(options: {
+    as: As;
+  }, fn: TraceHandler<any, any>): this;
   trace<const HookScope extends EventScope>(scope: HookScope, fn: TraceHandler<any, any>): this;
   as(type: 'plugin'): Elysia<BasePath, Scope, Singleton, Definitions, Metadata, Routes, {
     derive: Ephemeral['derive'] & Volatile['derive'];
@@ -970,23 +1012,23 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
    */
   wrap<T extends (...params: any) => MaybePromise<Response> = (request: Request, ...rest: any[]) => MaybePromise<Response>>(callback: WrapFn<T>): this;
   /**
-   * ### cleanup | Life cycle event
+   * ### onStop | Life cycle event
    * Called after server stop serving request
    *
    * ---
    * @example
    * ```typescript
    * new Elysia()
-   *     .cleanup((app) => {
+   *     .onStop((app) => {
    *         closeDatabase()
    *     })
    * ```
    */
-  cleanup(handler: MaybeArray<GracefulHandler<this>>): this;
+  onStop(handler: MaybeArray<GracefulHandler<this>>): this;
   /**
-   * Stop the underlying server (if any), then run every `cleanup` handler
+   * Stop the underlying server (if any), then run every `onStop` handler
    *
-   * Awaiting `stop()` from inside a `setup`, `cleanup` or WebSocket lifecycle
+   * Awaiting `stop()` from inside an `onStart`, `onStop` or WebSocket lifecycle
    * callback is only supported while that callback is still synchronous
    *
    * @param closeActiveConnections Pass `true` to terminate active

package/dist/base.js

@@ -69,6 +69,14 @@ const toModel = (key, value) => {
 const assertScope = (scope) => {
 	if (scope !== void 0 && scope !== "local" && scope !== "plugin" && scope !== "global") throw new Error(`[Elysia] Invalid hook scope ${JSON.stringify(scope)}, expected 'local', 'plugin' or 'global' (1.x 'scoped' is 'plugin')`);
 };
+let warnedLegacyScope = false;
+const legacyScope = ({ as }) => {
+	if (!warnedLegacyScope) {
+		warnedLegacyScope = true;
+		console.warn("[Elysia] { as: scope } is deprecated, pass the scope as the first argument instead ('scoped' is now 'plugin')");
+	}
+	return as === "scoped" ? "plugin" : as;
+};
 const hasHookKeys = (value) => {
 	for (const key in value) if (require_utils.schemaProperties.has(key) || require_utils.eventProperties.has(key) || key === "detail" || key === "tags") return true;
 	return false;
@@ -281,6 +289,7 @@ var Elysia = class Elysia {
 	}
 	#on(type, fn, scope = this["~config"]?.as) {
 		this.#assertMutable(type);
+		if (scope && typeof scope === "object") scope = legacyScope(scope) ?? this["~config"]?.as;
 		assertScope(scope);
 		const added = require_utils.nullObject();
 		added[type] = fn;
@@ -312,10 +321,10 @@ var Elysia = class Elysia {
 	#onBranch(type, scopeOrFn, fn) {
 		return fn ? this.#on(type, fn, scopeOrFn) : this.#on(type, scopeOrFn);
 	}
-	request(fn) {
+	onRequest(fn) {
 		return this.#on("request", fn, "global");
 	}
-	parse(scopeOrFnOrName, fn) {
+	onParse(scopeOrFnOrName, fn) {
 		if (fn === void 0 && typeof scopeOrFnOrName === "string") {
 			const named = this["~ext"]?.parser?.[scopeOrFnOrName];
 			return this.#onBranch("parse", named ?? scopeOrFnOrName);
@@ -328,15 +337,15 @@ var Elysia = class Elysia {
 		parsers[name] = fn;
 		return this;
 	}
-	setup(handler) {
-		this.#assertMutable("setup");
+	onStart(handler) {
+		this.#assertMutable("onStart");
 		(this.#ext.setup ??= []).push(...[].concat(handler));
 		return this;
 	}
-	transform(scopeOrFn, fn) {
+	onTransform(scopeOrFn, fn) {
 		return this.#onBranch("transform", scopeOrFn, fn);
 	}
-	beforeHandle(scopeOrFn, fn) {
+	onBeforeHandle(scopeOrFn, fn) {
 		return this.#onBranch("beforeHandle", scopeOrFn, fn);
 	}
 	derive(scopeOrFn, fn) {
@@ -353,20 +362,20 @@ var Elysia = class Elysia {
 	mapDerive(scopeOrFn, fn) {
 		return this.#derive(scopeOrFn, fn, require_utils.mapDeriveEntry);
 	}
-	afterHandle(scopeOrFn, fn) {
+	onAfterHandle(scopeOrFn, fn) {
 		return this.#onBranch("afterHandle", scopeOrFn, fn);
 	}
 	mapResponse(scopeOrFn, fn) {
 		return this.#onBranch("mapResponse", scopeOrFn, fn);
 	}
-	afterResponse(scopeOrFn, fn) {
+	onAfterResponse(scopeOrFn, fn) {
 		return this.#onBranch("afterResponse", scopeOrFn, fn);
 	}
-	error(scopeOrFnOrError, fnOrError, fn) {
-		this.#assertMutable("error");
+	onError(scopeOrFnOrError, fnOrError, fn) {
+		this.#assertMutable("onError");
 		switch (arguments.length) {
 			case 1:
-				if (scopeOrFnOrError && typeof scopeOrFnOrError === "object" && !Array.isArray(scopeOrFnOrError)) throw new Error("[Elysia] .error({ CODE: Class }) was removed in 2.0 — use .error(Class, handler)");
+				if (scopeOrFnOrError && typeof scopeOrFnOrError === "object" && !Array.isArray(scopeOrFnOrError)) throw new Error("[Elysia] .onError({ CODE: Class }) was removed in 2.0 — use .onError(Class, handler)");
 				return this.#onBranch("error", scopeOrFnOrError);
 			case 2:
 				if (typeof scopeOrFnOrError === "function" && scopeOrFnOrError.prototype instanceof Object) return this.#onErrorClass(scopeOrFnOrError, fnOrError);
@@ -384,7 +393,8 @@ var Elysia = class Elysia {
 	}
 	as(target) {
 		this.#assertMutable("as");
-		this.#as(this["~hookChain"], target === "global" ? "global" : "plugin");
+		if (target !== "plugin" && target !== "global") throw new Error(`[Elysia] Invalid .as() scope ${JSON.stringify(target)}, expected 'plugin' or 'global' (1.x 'scoped' is 'plugin')`);
+		this.#as(this["~hookChain"], target);
 		return this;
 	}
 	#as(node, scope) {
@@ -1015,13 +1025,14 @@ var Elysia = class Elysia {
 	#assertMutable(api) {
 		mutationEpoch++;
 		if (this["~generation"] === void 0) return;
-		throw new Error(`[Elysia] .${api}() called after the app was sealed by its first request, listen or compile`);
+		const on = "on" + api[0].toUpperCase() + api.slice(1);
+		throw new Error(`[Elysia] .${on in this ? on : api}() called after the app was sealed by its first request, listen or compile`);
 	}
 	#assertTableMutable(api) {
 		for (let app = this; app; app = app.scopeParent) app.#assertMutable(api);
 	}
 	get #isCacheable() {
-		return this["~generation"] !== void 0 && this.#routerBuilt && !require_compile_aot.Capture.isCapturing();
+		return this["~generation"] !== void 0 && this.#routerBuilt && !require_compile_aot.inAotBuild();
 	}
 	#cacheRoutes(generation) {
 		if (this.cachedGeneration === generation && this.cachedEpoch === mutationEpoch) return;
@@ -1607,9 +1618,9 @@ var Elysia = class Elysia {
 		(ext.hocOrigin ??= []).push(this.hash ?? {});
 		return this;
 	}
-	cleanup(handler) {
+	onStop(handler) {
 		if (this["~ext"]?.cleanupEpoch?.(handler)) return this;
-		this.#assertMutable("cleanup");
+		this.#assertMutable("onStop");
 		(this.#ext.cleanup ??= []).push(...[].concat(handler));
 		return this;
 	}

package/dist/base.mjs

@@ -3,7 +3,7 @@ import { isBun } from "./universal/constants.mjs";
 import { clearFlattenChainMemo, clonePlainDecorators, clonePlainDeep, coalesceSchemas, createErrorEventHandler, eventProperties, getLoosePath, guardNonPlainLeaves, hookToGuard, invalidateMacroEpoch, isEmpty, isHTMLBundle, isNotEmpty, isPlainObject, isRecordNumber, joinPath, macroOrigin, mapDeriveEntry, markPropertySingletons, markSingletons, mergeDeep, mergeResponse, nullObject, pluginHash, schemaProperties, serializeMacroSeed, throwLifecycleErrors } from "./utils.mjs";
 import { Ref, isBridgeLive, warmTypebox } from "./type/bridge.mjs";
 import { isProduction } from "./universal/is-production.mjs";
-import { Capture, Compiled, beginCompilerSession, createAotFingerprint, endCompilerSession } from "./compile/aot.mjs";
+import { Capture, Compiled, beginCompilerSession, createAotFingerprint, endCompilerSession, inAotBuild } from "./compile/aot.mjs";
 import { traceCapabilityRequired, wsCapabilityRequired } from "./generation.mjs";
 import { releaseAnalysisCaches } from "./compile/handler/descriptor.mjs";
 import { chainResolver, clearHandlerAnalysisCaches, compileHandler, composeRouteHook, localMacroRoot, resolveLocalHook, runIntrospect } from "./compile/handler/index.mjs";
@@ -67,6 +67,14 @@ const toModel = (key, value) => {
 const assertScope = (scope) => {
 	if (scope !== void 0 && scope !== "local" && scope !== "plugin" && scope !== "global") throw new Error(`[Elysia] Invalid hook scope ${JSON.stringify(scope)}, expected 'local', 'plugin' or 'global' (1.x 'scoped' is 'plugin')`);
 };
+let warnedLegacyScope = false;
+const legacyScope = ({ as }) => {
+	if (!warnedLegacyScope) {
+		warnedLegacyScope = true;
+		console.warn("[Elysia] { as: scope } is deprecated, pass the scope as the first argument instead ('scoped' is now 'plugin')");
+	}
+	return as === "scoped" ? "plugin" : as;
+};
 const hasHookKeys = (value) => {
 	for (const key in value) if (schemaProperties.has(key) || eventProperties.has(key) || key === "detail" || key === "tags") return true;
 	return false;
@@ -279,6 +287,7 @@ var Elysia = class Elysia {
 	}
 	#on(type, fn, scope = this["~config"]?.as) {
 		this.#assertMutable(type);
+		if (scope && typeof scope === "object") scope = legacyScope(scope) ?? this["~config"]?.as;
 		assertScope(scope);
 		const added = nullObject();
 		added[type] = fn;
@@ -310,10 +319,10 @@ var Elysia = class Elysia {
 	#onBranch(type, scopeOrFn, fn) {
 		return fn ? this.#on(type, fn, scopeOrFn) : this.#on(type, scopeOrFn);
 	}
-	request(fn) {
+	onRequest(fn) {
 		return this.#on("request", fn, "global");
 	}
-	parse(scopeOrFnOrName, fn) {
+	onParse(scopeOrFnOrName, fn) {
 		if (fn === void 0 && typeof scopeOrFnOrName === "string") {
 			const named = this["~ext"]?.parser?.[scopeOrFnOrName];
 			return this.#onBranch("parse", named ?? scopeOrFnOrName);
@@ -326,15 +335,15 @@ var Elysia = class Elysia {
 		parsers[name] = fn;
 		return this;
 	}
-	setup(handler) {
-		this.#assertMutable("setup");
+	onStart(handler) {
+		this.#assertMutable("onStart");
 		(this.#ext.setup ??= []).push(...[].concat(handler));
 		return this;
 	}
-	transform(scopeOrFn, fn) {
+	onTransform(scopeOrFn, fn) {
 		return this.#onBranch("transform", scopeOrFn, fn);
 	}
-	beforeHandle(scopeOrFn, fn) {
+	onBeforeHandle(scopeOrFn, fn) {
 		return this.#onBranch("beforeHandle", scopeOrFn, fn);
 	}
 	derive(scopeOrFn, fn) {
@@ -351,20 +360,20 @@ var Elysia = class Elysia {
 	mapDerive(scopeOrFn, fn) {
 		return this.#derive(scopeOrFn, fn, mapDeriveEntry);
 	}
-	afterHandle(scopeOrFn, fn) {
+	onAfterHandle(scopeOrFn, fn) {
 		return this.#onBranch("afterHandle", scopeOrFn, fn);
 	}
 	mapResponse(scopeOrFn, fn) {
 		return this.#onBranch("mapResponse", scopeOrFn, fn);
 	}
-	afterResponse(scopeOrFn, fn) {
+	onAfterResponse(scopeOrFn, fn) {
 		return this.#onBranch("afterResponse", scopeOrFn, fn);
 	}
-	error(scopeOrFnOrError, fnOrError, fn) {
-		this.#assertMutable("error");
+	onError(scopeOrFnOrError, fnOrError, fn) {
+		this.#assertMutable("onError");
 		switch (arguments.length) {
 			case 1:
-				if (scopeOrFnOrError && typeof scopeOrFnOrError === "object" && !Array.isArray(scopeOrFnOrError)) throw new Error("[Elysia] .error({ CODE: Class }) was removed in 2.0 \u2014 use .error(Class, handler)");
+				if (scopeOrFnOrError && typeof scopeOrFnOrError === "object" && !Array.isArray(scopeOrFnOrError)) throw new Error("[Elysia] .onError({ CODE: Class }) was removed in 2.0 \u2014 use .onError(Class, handler)");
 				return this.#onBranch("error", scopeOrFnOrError);
 			case 2:
 				if (typeof scopeOrFnOrError === "function" && scopeOrFnOrError.prototype instanceof Object) return this.#onErrorClass(scopeOrFnOrError, fnOrError);
@@ -382,7 +391,8 @@ var Elysia = class Elysia {
 	}
 	as(target) {
 		this.#assertMutable("as");
-		this.#as(this["~hookChain"], target === "global" ? "global" : "plugin");
+		if (target !== "plugin" && target !== "global") throw new Error(`[Elysia] Invalid .as() scope ${JSON.stringify(target)}, expected 'plugin' or 'global' (1.x 'scoped' is 'plugin')`);
+		this.#as(this["~hookChain"], target);
 		return this;
 	}
 	#as(node, scope) {
@@ -1013,13 +1023,14 @@ var Elysia = class Elysia {
 	#assertMutable(api) {
 		mutationEpoch++;
 		if (this["~generation"] === void 0) return;
-		throw new Error(`[Elysia] .${api}() called after the app was sealed by its first request, listen or compile`);
+		const on = "on" + api[0].toUpperCase() + api.slice(1);
+		throw new Error(`[Elysia] .${on in this ? on : api}() called after the app was sealed by its first request, listen or compile`);
 	}
 	#assertTableMutable(api) {
 		for (let app = this; app; app = app.scopeParent) app.#assertMutable(api);
 	}
 	get #isCacheable() {
-		return this["~generation"] !== void 0 && this.#routerBuilt && !Capture.isCapturing();
+		return this["~generation"] !== void 0 && this.#routerBuilt && !inAotBuild();
 	}
 	#cacheRoutes(generation) {
 		if (this.cachedGeneration === generation && this.cachedEpoch === mutationEpoch) return;
@@ -1605,9 +1616,9 @@ var Elysia = class Elysia {
 		(ext.hocOrigin ??= []).push(this.hash ?? {});
 		return this;
 	}
-	cleanup(handler) {
+	onStop(handler) {
 		if (this["~ext"]?.cleanupEpoch?.(handler)) return this;
-		this.#assertMutable("cleanup");
+		this.#assertMutable("onStop");
 		(this.#ext.cleanup ??= []).push(...[].concat(handler));
 		return this;
 	}

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_value = require("typebox/value");
 let typebox_schema = require("typebox/schema");
+let typebox_value = require("typebox/value");
 
 //#region src/compile/aot-capture.ts
 function emptyContainers(node, depth) {

package/dist/compile/aot-capture.mjs

@@ -12,8 +12,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, compileWithBuild } from "../type/validator/string-codec-aot.mjs";
-import { Default } from "typebox/value";
 import { Build, Compile } from "typebox/schema";
+import { Default } from "typebox/value";
 
 //#region src/compile/aot-capture.ts
 function emptyContainers(node, depth) {

package/dist/compile/aot.d.ts

@@ -228,6 +228,7 @@ declare function captureSet(loc: {
   path: string;
   slot: ValidatorSlot;
 }, partial: Partial<CapturedValidator>): void;
+declare function inAotBuild(): boolean;
 declare const Capture: {
   readonly set: typeof captureSet;
   readonly get: (loc: {
@@ -236,7 +237,6 @@ declare const Capture: {
     slot: ValidatorSlot;
   }) => CapturedValidator | undefined;
   readonly handler: typeof captureHandler;
-  readonly isCapturing: () => boolean;
   readonly isAotBuildEnv: () => boolean;
 };
 interface CaptureImpl {
@@ -282,4 +282,4 @@ interface CaptureImpl {
 declare let captureImpl: CaptureImpl | undefined;
 declare function setCaptureImpl(impl: CaptureImpl | undefined): void;
 //#endregion
-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, aotDriftMessage, beginCompilerSession, captureImpl, createAotFingerprint, endCompilerSession, getCompilerSession, reconstruct, setCaptureImpl, warnAotDrift };
+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, aotDriftMessage, beginCompilerSession, captureImpl, createAotFingerprint, endCompilerSession, getCompilerSession, inAotBuild, reconstruct, setCaptureImpl, warnAotDrift };

package/dist/compile/aot.js

@@ -142,14 +142,14 @@ const CompilerState = {
 const EMPTY_EXTERNALS = Object.freeze([]);
 const aotActivationError = () => /* @__PURE__ */ new Error("Elysia AOT capture module is not activated.");
 function captureHandler(v) {
-	if (!isValidatorCapturing()) return;
+	if (!inAotBuild()) 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;
+	if (!inAotBuild()) return;
 	const capture = activeSession?.capture;
 	if (!capture) return;
 	const k = `${method}_${path}_${slot}`;
@@ -163,16 +163,15 @@ function captureSet(loc, partial) {
 }
 const captureGet = (loc) => activeSession?.capture?.get(`${loc.method}_${loc.path}_${loc.slot}`);
 const isAotBuildEnv = () => !!require_universal_env.env.ELYSIA_AOT_BUILD;
-const isValidatorCapturing = () => {
+function inAotBuild() {
 	if (activeSession?.capture === void 0 && !isAotBuildEnv()) return false;
 	if (captureImpl === void 0) throw aotActivationError();
 	return true;
-};
+}
 const Capture = {
 	set: captureSet,
 	get: captureGet,
 	handler: captureHandler,
-	isCapturing: isValidatorCapturing,
 	isAotBuildEnv
 };
 let captureImpl;
@@ -198,6 +197,7 @@ Object.defineProperty(exports, 'captureImpl', {
 exports.createAotFingerprint = createAotFingerprint;
 exports.endCompilerSession = endCompilerSession;
 exports.getCompilerSession = getCompilerSession;
+exports.inAotBuild = inAotBuild;
 exports.reconstruct = reconstruct;
 exports.setCaptureImpl = setCaptureImpl;
 exports.warnAotDrift = warnAotDrift;