elysia 2.0.0-beta.27 → 2.0.0-beta.28

package/README.md

@@ -15,7 +15,7 @@
 
 <br>
 
-![Elysia chan cover | bun creeate elysia app](https://github.com/user-attachments/assets/a649731a-8cba-4ca2-8424-6656cbf84956)
+![Elysia chan cover | bun create elysia app](https://github.com/user-attachments/assets/a649731a-8cba-4ca2-8424-6656cbf84956)
 
 <!---
 ```bash

package/dist/adapter/utils.d.ts

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

package/dist/adapter/utils.js

@@ -55,10 +55,8 @@ function handleFile(response, set, request, size = response.size) {
 	}
 	const body = "value" in response ? response.value : response;
 	const immutable = set && (set.status === 206 || set.status === 304 || set.status === 412 || set.status === 416);
-	const defaultHeader = immutable ? require_utils.nullObject() : {
-		"accept-ranges": "bytes",
-		"content-range": size ? `bytes 0-${size - 1}/${size}` : void 0
-	};
+	const defaultHeader = immutable ? require_utils.nullObject() : { "accept-ranges": "bytes" };
+	if (!immutable && size) defaultHeader["content-range"] = `bytes 0-${size - 1}/${size}`;
 	if (!set && !size) return new Response(body);
 	if (!set) return new Response(body, { headers: defaultHeader });
 	if (set.headers instanceof Headers) {
@@ -358,11 +356,6 @@ function mergeHeaders(responseHeaders, setHeaders) {
 	applySetHeaders(headers, setHeaders, responseHeaders);
 	return headers;
 }
-function mergeStatus(responseStatus, setStatus) {
-	if (typeof setStatus === "string") setStatus = require_constants.StatusMap[setStatus];
-	if (responseStatus === 200) return setStatus;
-	return responseStatus;
-}
 function cancelPropagatingBody(clonedBody, orphanedBranch, preserveOrphan = false) {
 	const reader = clonedBody.getReader();
 	return new ReadableStream({
@@ -394,7 +387,8 @@ function createResponseHandler(handler) {
 		if (!borrowed && response.bodyUsed) throw new TypeError("Cannot reuse a consumed Response across requests");
 		let status;
 		if (set) {
-			status = mergeStatus(response.status, set.status);
+			status = response.status === 200 ? set.status : response.status;
+			if (typeof status === "string") status = require_constants.StatusMap[status];
 			const statusUnchanged = status === void 0 || status === response.status;
 			if (!mustClone && statusUnchanged && !set.cookie && !require_utils.isNotEmpty(set.headers)) return response;
 		} else if (!mustClone) return response;

package/dist/adapter/utils.mjs

@@ -55,10 +55,8 @@ function handleFile(response, set, request, size = response.size) {
 	}
 	const body = "value" in response ? response.value : response;
 	const immutable = set && (set.status === 206 || set.status === 304 || set.status === 412 || set.status === 416);
-	const defaultHeader = immutable ? nullObject() : {
-		"accept-ranges": "bytes",
-		"content-range": size ? `bytes 0-${size - 1}/${size}` : void 0
-	};
+	const defaultHeader = immutable ? nullObject() : { "accept-ranges": "bytes" };
+	if (!immutable && size) defaultHeader["content-range"] = `bytes 0-${size - 1}/${size}`;
 	if (!set && !size) return new Response(body);
 	if (!set) return new Response(body, { headers: defaultHeader });
 	if (set.headers instanceof Headers) {
@@ -358,11 +356,6 @@ function mergeHeaders(responseHeaders, setHeaders) {
 	applySetHeaders(headers, setHeaders, responseHeaders);
 	return headers;
 }
-function mergeStatus(responseStatus, setStatus) {
-	if (typeof setStatus === "string") setStatus = StatusMap[setStatus];
-	if (responseStatus === 200) return setStatus;
-	return responseStatus;
-}
 function cancelPropagatingBody(clonedBody, orphanedBranch, preserveOrphan = false) {
 	const reader = clonedBody.getReader();
 	return new ReadableStream({
@@ -394,7 +387,8 @@ function createResponseHandler(handler) {
 		if (!borrowed && response.bodyUsed) throw new TypeError("Cannot reuse a consumed Response across requests");
 		let status;
 		if (set) {
-			status = mergeStatus(response.status, set.status);
+			status = response.status === 200 ? set.status : response.status;
+			if (typeof status === "string") status = StatusMap[status];
 			const statusUnchanged = status === void 0 || status === response.status;
 			if (!mustClone && statusUnchanged && !set.cookie && !isNotEmpty(set.headers)) return response;
 		} else if (!mustClone) return response;

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

@@ -13,7 +13,8 @@ const textPlainInit = { headers: { "content-type": "text/plain" } };
 function handleElysiaFile(file, set = { headers: require_utils.nullObject() }, request) {
 	const contentType = file.type;
 	const headers = require_adapter_utils.materializeSetHeaders(set);
-	if (contentType !== "application/octet-stream") headers["content-type"] = contentType;
+	if (contentType !== "application/octet-stream") if (headers instanceof Headers) headers.set("content-type", contentType);
+	else headers["content-type"] = contentType;
 	const stats = file.stats;
 	if (stats) return stats.then((stat) => {
 		const size = stat.size;
@@ -63,7 +64,9 @@ function withStatus(response, set, request, owned) {
 		status: response.status,
 		headers: require_utils.nullObject()
 	};
-	if (response.headers) Object.assign(require_adapter_utils.materializeSetHeaders(set), response.headers);
+	if (response.headers) if (set.headers instanceof Headers) for (const [key, value] of Object.entries(response.headers)) if (key.toLowerCase() === "set-cookie") for (const cookie of Array.isArray(value) ? value : [value]) set.headers.append(key, cookie);
+	else set.headers.set(key, value);
+	else Object.assign(require_adapter_utils.materializeSetHeaders(set), response.headers);
 	return mapResponseWithSet(response.response, set, request, owned);
 }
 const checkRemovedSetRedirect = !require_universal_is_production.isProduction();
@@ -127,17 +130,7 @@ function errorToResponse(error, set, request, owned = false) {
 function mapFallback(response, set, request, owned = false) {
 	if (response instanceof Response) return handleResponse(response, set, request, owned);
 	if (response instanceof Error) return errorToResponse(response, set, request, owned);
-	if (response instanceof require_error.ElysiaStatus) {
-		if (set && response.headers) {
-			set.status = response.status;
-			set.headers = {
-				...set.headers,
-				...response.headers
-			};
-			return mapResponse(response.response, set, request, owned);
-		}
-		return withStatus(response, set, request, owned);
-	}
+	if (response instanceof require_error.ElysiaStatus) return withStatus(response, set, request, owned);
 	if (response instanceof require_universal_file.ElysiaFile) return handleElysiaFile(response, set, request);
 	if (require_utils.isElysiaForm(response)) return new Response(require_utils.formToFormData(response), set);
 	if (typeof response?.next === "function" || response instanceof ReadableStream) return handleStream(response, set, request, void 0, owned);

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

@@ -13,7 +13,8 @@ const textPlainInit = { headers: { "content-type": "text/plain" } };
 function handleElysiaFile(file, set = { headers: nullObject() }, request) {
 	const contentType = file.type;
 	const headers = materializeSetHeaders(set);
-	if (contentType !== "application/octet-stream") headers["content-type"] = contentType;
+	if (contentType !== "application/octet-stream") if (headers instanceof Headers) headers.set("content-type", contentType);
+	else headers["content-type"] = contentType;
 	const stats = file.stats;
 	if (stats) return stats.then((stat) => {
 		const size = stat.size;
@@ -63,7 +64,9 @@ function withStatus(response, set, request, owned) {
 		status: response.status,
 		headers: nullObject()
 	};
-	if (response.headers) Object.assign(materializeSetHeaders(set), response.headers);
+	if (response.headers) if (set.headers instanceof Headers) for (const [key, value] of Object.entries(response.headers)) if (key.toLowerCase() === "set-cookie") for (const cookie of Array.isArray(value) ? value : [value]) set.headers.append(key, cookie);
+	else set.headers.set(key, value);
+	else Object.assign(materializeSetHeaders(set), response.headers);
 	return mapResponseWithSet(response.response, set, request, owned);
 }
 const checkRemovedSetRedirect = !isProduction();
@@ -127,17 +130,7 @@ function errorToResponse(error, set, request, owned = false) {
 function mapFallback(response, set, request, owned = false) {
 	if (response instanceof Response) return handleResponse(response, set, request, owned);
 	if (response instanceof Error) return errorToResponse(response, set, request, owned);
-	if (response instanceof ElysiaStatus) {
-		if (set && response.headers) {
-			set.status = response.status;
-			set.headers = {
-				...set.headers,
-				...response.headers
-			};
-			return mapResponse(response.response, set, request, owned);
-		}
-		return withStatus(response, set, request, owned);
-	}
+	if (response instanceof ElysiaStatus) return withStatus(response, set, request, owned);
 	if (response instanceof ElysiaFile) return handleElysiaFile(response, set, request);
 	if (isElysiaForm(response)) return new Response(formToFormData(response), set);
 	if (typeof response?.next === "function" || response instanceof ReadableStream) return handleStream(response, set, request, void 0, owned);

package/dist/base.d.ts

@@ -1,10 +1,10 @@
 import { ElysiaStatus } from "./error.js";
+import { AnySchema } from "./type/types.js";
+import { AotFingerprint, CompilerSession, ProgramId } from "./compile/aot.js";
 import { ChainNode } from "./utils.js";
 import { ListenCallback, Serve, Server } from "./universal/server.js";
 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 { RouteErrorHooks } from "./handler/utils.js";
 import { WSCapability, WSHandlerResponse, WSLocalHook, WSMessageHandler, WSOptions, WSOptionsEntry } from "./ws/types.js";
@@ -99,7 +99,6 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
   '~aotFingerprint'?: AotFingerprint;
   '~compilerSession'?: CompilerSession;
   '~generation'?: Generation;
-  '~introspect'?: boolean;
   '~scopeChild'?: boolean;
   '~scopeChildren'?: AnyElysia[];
   constructor(config?: ElysiaConfig<BasePath, Scope>);
@@ -228,7 +227,7 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
    * ```typescript
    * new Elysia()
    *     .setup(({ server }) => {
-   *         console.log("Running at ${server?.url}:${server?.port}")
+   *         console.log(`Running at ${server?.url}`)
    *     })
    *     .listen(3000)
    * ```
@@ -403,7 +402,7 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
    *     .post('/', ({ body }) => body)
    * ```
    */
-  guard<const Input extends Metadata['macro'] & InputSchema<keyof Definitions['typebox'] & string>, const Schema extends MergeSchema<UnwrapRoute<Input, Definitions['typebox'], BasePath>, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>> & Metadata['schemas'] & Ephemeral['schemas'] & Volatile['schemas'], const MacroContext extends ({} extends Metadata['macroFn'] ? {} : MacroToContext<Metadata['macroFn'], Input, Definitions['typebox']>), const BeforeHandle extends MaybeArray<OptionalHandler<Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const AfterHandle extends MaybeArray<AfterHandler<Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const ErrorHandle extends MaybeArray<ErrorHandler<Definitions['error'], Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>>(hook: GuardLocalHook<Input, Schema & MacroContext, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>, keyof Metadata['parser'], BeforeHandle, AfterHandle, ErrorHandle> & {
+  guard<const Input extends Metadata['macro'] & InputSchema<keyof Definitions['typebox'] & string>, const Schema extends MergeSchema<UnwrapRoute<Input, Definitions['typebox'], BasePath>, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>> & Metadata['schemas'] & Ephemeral['schemas'] & Volatile['schemas'], const MacroContext extends ({} extends Metadata['macroFn'] ? {} : MacroToContext<Metadata['macroFn'], Input, Definitions['typebox']>), const BeforeHandle extends MaybeArray<OptionalHandler<Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const AfterHandle extends MaybeArray<AfterHandler<Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const ErrorHandle extends MaybeArray<ErrorHandler<Definitions['error'], Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>>(hook: GuardLocalHook<Input, Schema & MacroContext, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>, keyof Metadata['parser'], BeforeHandle, AfterHandle, ErrorHandle, 'merge'> & {
     schema: 'merge';
   } & MacroOptionContext<Metadata['macroFn'], Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, {
     derive: {};
@@ -423,7 +422,7 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
     response: UnionResponseStatus<Volatile['response'], ElysiaHandlerToResponseSchemaAmbiguous<BeforeHandle> & ElysiaHandlerToResponseSchemaAmbiguous<AfterHandle> & ElysiaHandlerToResponseSchemaAmbiguous<ErrorHandle> & MacroContext['return']>;
     error: Volatile['error'];
   }>;
-  guard<const Input extends Metadata['macro'] & InputSchema<keyof Definitions['typebox'] & string>, const Schema extends MergeSchema<UnwrapRoute<Input, Definitions['typebox'], BasePath>, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>> & Metadata['schemas'] & Ephemeral['schemas'] & Volatile['schemas'], const MacroContext extends ({} extends Metadata['macroFn'] ? {} : MacroToContext<Metadata['macroFn'], Input, Definitions['typebox']>), const BeforeHandle extends MaybeArray<OptionalHandler<Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const AfterHandle extends MaybeArray<AfterHandler<Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const ErrorHandle extends MaybeArray<ErrorHandler<Definitions['error'], Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const NewElysia extends AnyElysia>(hook: GuardLocalHook<Input, Schema & MacroContext, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>, keyof Metadata['parser'], BeforeHandle, AfterHandle, ErrorHandle> & {
+  guard<const Input extends Metadata['macro'] & InputSchema<keyof Definitions['typebox'] & string>, const Schema extends MergeSchema<UnwrapRoute<Input, Definitions['typebox'], BasePath>, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>> & Metadata['schemas'] & Ephemeral['schemas'] & Volatile['schemas'], const MacroContext extends ({} extends Metadata['macroFn'] ? {} : MacroToContext<Metadata['macroFn'], Input, Definitions['typebox']>), const BeforeHandle extends MaybeArray<OptionalHandler<Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const AfterHandle extends MaybeArray<AfterHandler<Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const ErrorHandle extends MaybeArray<ErrorHandler<Definitions['error'], Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const NewElysia extends AnyElysia>(hook: GuardLocalHook<Input, Schema & MacroContext, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>, keyof Metadata['parser'], BeforeHandle, AfterHandle, ErrorHandle, 'merge'> & {
     schema: 'merge';
   } & MacroOptionContext<Metadata['macroFn'], Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, {
     derive: {};
@@ -465,7 +464,7 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
     response: Volatile['response'];
     error: Volatile['error'];
   }>) => NewElysia): Elysia<BasePath, Scope, Singleton, Definitions, Metadata, Routes & NewElysia['~Routes'], Ephemeral, Volatile>;
-  guard<const Input extends Metadata['macro'] & InputSchema<keyof Definitions['typebox'] & string>, const Schema extends MergeSchema<UnwrapRoute<Input, Definitions['typebox'], BasePath>, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>> & Metadata['schemas'] & Ephemeral['schemas'] & Volatile['schemas'], const MacroContext extends ({} extends Metadata['macroFn'] ? {} : MacroToContext<Metadata['macroFn'], Input, Definitions['typebox']>), const BeforeHandle extends MaybeArray<OptionalHandler<Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const AfterHandle extends MaybeArray<AfterHandler<Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const ErrorHandle extends MaybeArray<ErrorHandler<Definitions['error'], Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>>(scope: 'local', hook: GuardLocalHook<Input, Schema & MacroContext, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>, keyof Metadata['parser'], BeforeHandle, AfterHandle, ErrorHandle> & {
+  guard<const Input extends Metadata['macro'] & InputSchema<keyof Definitions['typebox'] & string>, const Schema extends MergeSchema<UnwrapRoute<Input, Definitions['typebox'], BasePath>, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>> & Metadata['schemas'] & Ephemeral['schemas'] & Volatile['schemas'], const MacroContext extends ({} extends Metadata['macroFn'] ? {} : MacroToContext<Metadata['macroFn'], Input, Definitions['typebox']>), const BeforeHandle extends MaybeArray<OptionalHandler<Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const AfterHandle extends MaybeArray<AfterHandler<Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const ErrorHandle extends MaybeArray<ErrorHandler<Definitions['error'], Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>>(scope: 'local', hook: GuardLocalHook<Input, Schema & MacroContext, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>, keyof Metadata['parser'], BeforeHandle, AfterHandle, ErrorHandle, 'merge'> & {
     schema: 'merge';
   } & MacroOptionContext<Metadata['macroFn'], Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, {
     derive: {};
@@ -485,7 +484,7 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
     response: UnionResponseStatus<Volatile['response'], ElysiaHandlerToResponseSchemaAmbiguous<BeforeHandle> & ElysiaHandlerToResponseSchemaAmbiguous<AfterHandle> & ElysiaHandlerToResponseSchemaAmbiguous<ErrorHandle> & MacroContext['return']>;
     error: Volatile['error'];
   }>;
-  guard<const Input extends Metadata['macro'] & InputSchema<keyof Definitions['typebox'] & string>, const Schema extends MergeSchema<UnwrapRoute<Input, Definitions['typebox'], BasePath>, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>> & Metadata['schemas'] & Ephemeral['schemas'] & Volatile['schemas'], const MacroContext extends ({} extends Metadata['macroFn'] ? {} : MacroToContext<Metadata['macroFn'], Input, Definitions['typebox']>), const BeforeHandle extends MaybeArray<OptionalHandler<Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const AfterHandle extends MaybeArray<AfterHandler<Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const ErrorHandle extends MaybeArray<ErrorHandler<Definitions['error'], Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>>(scope: 'plugin', hook: GuardLocalHook<Input, Schema & MacroContext, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>, keyof Metadata['parser'], BeforeHandle, AfterHandle, ErrorHandle> & {
+  guard<const Input extends Metadata['macro'] & InputSchema<keyof Definitions['typebox'] & string>, const Schema extends MergeSchema<UnwrapRoute<Input, Definitions['typebox'], BasePath>, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>> & Metadata['schemas'] & Ephemeral['schemas'] & Volatile['schemas'], const MacroContext extends ({} extends Metadata['macroFn'] ? {} : MacroToContext<Metadata['macroFn'], Input, Definitions['typebox']>), const BeforeHandle extends MaybeArray<OptionalHandler<Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const AfterHandle extends MaybeArray<AfterHandler<Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const ErrorHandle extends MaybeArray<ErrorHandler<Definitions['error'], Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>>(scope: 'plugin', hook: GuardLocalHook<Input, Schema & MacroContext, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>, keyof Metadata['parser'], BeforeHandle, AfterHandle, ErrorHandle, 'merge'> & {
     schema: 'merge';
   } & MacroOptionContext<Metadata['macroFn'], Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, {
     derive: {};
@@ -505,7 +504,7 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
     response: UnionResponseStatus<Ephemeral['response'], ElysiaHandlerToResponseSchemaAmbiguous<BeforeHandle> & ElysiaHandlerToResponseSchemaAmbiguous<AfterHandle> & ElysiaHandlerToResponseSchemaAmbiguous<ErrorHandle> & MacroContext['return']>;
     error: Ephemeral['error'];
   }, Volatile>;
-  guard<const Input extends Metadata['macro'] & InputSchema<keyof Definitions['typebox'] & string>, const Schema extends MergeSchema<UnwrapRoute<Input, Definitions['typebox'], BasePath>, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>> & Metadata['schemas'] & Ephemeral['schemas'] & Volatile['schemas'], const MacroContext extends ({} extends Metadata['macroFn'] ? {} : MacroToContext<Metadata['macroFn'], Input, Definitions['typebox']>), const BeforeHandle extends MaybeArray<OptionalHandler<Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const AfterHandle extends MaybeArray<AfterHandler<Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const ErrorHandle extends MaybeArray<ErrorHandler<Definitions['error'], Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>>(scope: 'global', hook: GuardLocalHook<Input, Schema & MacroContext, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>, keyof Metadata['parser'], BeforeHandle, AfterHandle, ErrorHandle> & {
+  guard<const Input extends Metadata['macro'] & InputSchema<keyof Definitions['typebox'] & string>, const Schema extends MergeSchema<UnwrapRoute<Input, Definitions['typebox'], BasePath>, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>> & Metadata['schemas'] & Ephemeral['schemas'] & Volatile['schemas'], const MacroContext extends ({} extends Metadata['macroFn'] ? {} : MacroToContext<Metadata['macroFn'], Input, Definitions['typebox']>), const BeforeHandle extends MaybeArray<OptionalHandler<Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const AfterHandle extends MaybeArray<AfterHandler<Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const ErrorHandle extends MaybeArray<ErrorHandler<Definitions['error'], Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>>(scope: 'global', hook: GuardLocalHook<Input, Schema & MacroContext, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>, keyof Metadata['parser'], BeforeHandle, AfterHandle, ErrorHandle, 'merge'> & {
     schema: 'merge';
   } & MacroOptionContext<Metadata['macroFn'], Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, {
     derive: {};
@@ -543,7 +542,7 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
     parser: Metadata['parser'];
     response: Metadata['response'];
   }, {}, Ephemeral, Volatile>) => NewElysia): Elysia<BasePath, Scope, Singleton, Definitions, Metadata, Routes & NewElysia['~Routes'], Ephemeral, Volatile>;
-  group<const Prefix extends string, const Input extends Metadata['macro'] & InputSchema<keyof Definitions['typebox'] & string>, const Schema extends MergeSchema<UnwrapRoute<Input, Definitions['typebox'], JoinPath<BasePath, Prefix>>, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>> & Metadata['schemas'] & Ephemeral['schemas'] & Volatile['schemas'], const MacroContext extends ({} extends Metadata['macroFn'] ? {} : MacroToContext<Metadata['macroFn'], Input, Definitions['typebox']>), const BeforeHandle extends MaybeArray<OptionalHandler<Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const AfterHandle extends MaybeArray<AfterHandler<Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const ErrorHandle extends MaybeArray<ErrorHandler<Definitions['error'], Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const NewElysia extends AnyElysia>(prefix: Prefix, schema: GuardLocalHook<Input, Schema & MacroContext, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>, keyof Metadata['parser'], BeforeHandle, AfterHandle, ErrorHandle> & {
+  group<const Prefix extends string, const Input extends Metadata['macro'] & InputSchema<keyof Definitions['typebox'] & string>, const Schema extends MergeSchema<UnwrapRoute<Input, Definitions['typebox'], JoinPath<BasePath, Prefix>>, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>> & Metadata['schemas'] & Ephemeral['schemas'] & Volatile['schemas'], const MacroContext extends ({} extends Metadata['macroFn'] ? {} : MacroToContext<Metadata['macroFn'], Input, Definitions['typebox']>), const BeforeHandle extends MaybeArray<OptionalHandler<Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const AfterHandle extends MaybeArray<AfterHandler<Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const ErrorHandle extends MaybeArray<ErrorHandler<Definitions['error'], Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const NewElysia extends AnyElysia>(prefix: Prefix, schema: GuardLocalHook<Input, Schema & MacroContext, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>, keyof Metadata['parser'], BeforeHandle, AfterHandle, ErrorHandle, 'merge'> & {
     schema: 'merge';
   } & MacroOptionContext<Metadata['macroFn'], Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, {
     derive: {};
@@ -922,7 +921,8 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
   }, const Handle extends InlineHandlerNonMacro<NoInfer<Schema>, NoInfer<Decorator>>>(path: Path, fn: Handle & Metadata['macro']): this;
   /**
    * ### ws
-   * Register a WebSocket route. Mirrors `.get`/`.post` ergonomics:
+   * Register a WebSocket route as `(path, options)`, `(path, handler)`, or `(path, options, handler)`.
+   * Requires `.use(websocket())` from `elysia/websocket`.
    */
   ws<const Path extends string, const Input extends Metadata['macro'] & InputSchema<keyof Definitions['typebox'] & string>, const Schema extends IntersectIfObjectSchema<MergeSchema<UnwrapRoute<Input, Definitions['typebox'], JoinPath<BasePath, Path>>, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>, '', undefined extends Input['params'] ? true : false>, MergeScopedSchemas<Metadata['schemas'], Ephemeral['schemas'], Volatile['schemas']>>, const MacroContext extends ({} extends Metadata['macroFn'] ? {} : MacroToContext<Metadata['macroFn'], Input, Definitions['typebox']>)>(path: Path, options: WSLocalHook<Input, Schema & MacroContext, Singleton & {
     derive: Ephemeral['derive'] & Volatile['derive'] & MacroContext['derive'];

package/dist/base.js

@@ -178,7 +178,6 @@ var Elysia = class Elysia {
 		this["~aotFingerprint"] = void 0;
 		this["~compilerSession"] = void 0;
 		this["~generation"] = void 0;
-		this["~introspect"] = void 0;
 		this["~scopeChild"] = scopeChild;
 		this["~scopeChildren"] = void 0;
 		if (config) {
@@ -191,9 +190,9 @@ var Elysia = class Elysia {
 	get routes() {
 		const generation = this["~generation"];
 		if (this.#isCacheable && this.cachedGeneration === generation && this.cachedEpoch === mutationEpoch && this.cachedRoutes !== void 0) return this.cachedRoutes;
-		if (this.declaredRoutes === void 0 && this["~routeTable"]?.length) this.#materializeDeclaredRoutes();
-		if (!this.declaredRoutes?.length) return [];
-		const routes = this["~routes"].map(([method, path, handler, instance, hook, appHook, inheritedChain, macroScope]) => {
+		const declared = this["~routes"];
+		if (!declared.length) return [];
+		const routes = declared.map(([method, path, handler, instance, hook, appHook, inheritedChain, macroScope]) => {
 			const merged = require_compile_handler_index.composeRouteHook(instance, hook, appHook, inheritedChain, this, macroScope);
 			require_compile_handler_index.runIntrospect(merged);
 			if (merged?.schemas?.length) for (const entry of merged.schemas) {
@@ -367,7 +366,7 @@ var Elysia = class Elysia {
 		this.#assertMutable("error");
 		switch (arguments.length) {
 			case 1:
-				if (scopeOrFnOrError && typeof scopeOrFnOrError === "object") return this;
+				if (scopeOrFnOrError && typeof scopeOrFnOrError === "object" && !Array.isArray(scopeOrFnOrError)) throw new Error("[Elysia] .error({ CODE: Class }) was removed in 2.0 — use .error(Class, handler)");
 				return this.#onBranch("error", scopeOrFnOrError);
 			case 2:
 				if (typeof scopeOrFnOrError === "function" && scopeOrFnOrError.prototype instanceof Object) return this.#onErrorClass(scopeOrFnOrError, fnOrError);
@@ -656,9 +655,7 @@ var Elysia = class Elysia {
 	}
 	#use(app) {
 		let addedByThisCall;
-		const config = app["~config"];
-		if (app["~introspect"] || config?.introspect) this["~introspect"] = true;
-		const name = config?.name;
+		const name = app["~config"]?.name;
 		if (name) {
 			const hash = app.hash;
 			if (this.childrenHash?.has(hash)) return;

package/dist/base.mjs

@@ -176,7 +176,6 @@ var Elysia = class Elysia {
 		this["~aotFingerprint"] = void 0;
 		this["~compilerSession"] = void 0;
 		this["~generation"] = void 0;
-		this["~introspect"] = void 0;
 		this["~scopeChild"] = scopeChild;
 		this["~scopeChildren"] = void 0;
 		if (config) {
@@ -189,9 +188,9 @@ var Elysia = class Elysia {
 	get routes() {
 		const generation = this["~generation"];
 		if (this.#isCacheable && this.cachedGeneration === generation && this.cachedEpoch === mutationEpoch && this.cachedRoutes !== void 0) return this.cachedRoutes;
-		if (this.declaredRoutes === void 0 && this["~routeTable"]?.length) this.#materializeDeclaredRoutes();
-		if (!this.declaredRoutes?.length) return [];
-		const routes = this["~routes"].map(([method, path, handler, instance, hook, appHook, inheritedChain, macroScope]) => {
+		const declared = this["~routes"];
+		if (!declared.length) return [];
+		const routes = declared.map(([method, path, handler, instance, hook, appHook, inheritedChain, macroScope]) => {
 			const merged = composeRouteHook(instance, hook, appHook, inheritedChain, this, macroScope);
 			runIntrospect(merged);
 			if (merged?.schemas?.length) for (const entry of merged.schemas) {
@@ -365,7 +364,7 @@ var Elysia = class Elysia {
 		this.#assertMutable("error");
 		switch (arguments.length) {
 			case 1:
-				if (scopeOrFnOrError && typeof scopeOrFnOrError === "object") return this;
+				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)");
 				return this.#onBranch("error", scopeOrFnOrError);
 			case 2:
 				if (typeof scopeOrFnOrError === "function" && scopeOrFnOrError.prototype instanceof Object) return this.#onErrorClass(scopeOrFnOrError, fnOrError);
@@ -654,9 +653,7 @@ var Elysia = class Elysia {
 	}
 	#use(app) {
 		let addedByThisCall;
-		const config = app["~config"];
-		if (app["~introspect"] || config?.introspect) this["~introspect"] = true;
-		const name = config?.name;
+		const name = app["~config"]?.name;
 		if (name) {
 			const hash = app.hash;
 			if (this.childrenHash?.has(hash)) return;

package/dist/compile/aot-capture.js

@@ -57,7 +57,6 @@ function validateMergeSource(schema, source) {
 	const merger = require_type_validator_default_precompute.createMergerFromSource(source);
 	if (!merger) return false;
 	for (const probe of mergeProbes(schema)) {
-		if (probe === null || typeof probe !== "object") continue;
 		let expected;
 		try {
 			expected = (0, typebox_value.Default)(schema, structuredClone(probe));
@@ -76,7 +75,6 @@ function validateMergeSource(schema, source) {
 }
 const PROBE_SENTINEL = "__elysia_default_probe__";
 function* defaultProbes(pod) {
-	if (!pod) return;
 	yield {};
 	for (const k in pod) {
 		yield { [k]: PROBE_SENTINEL };
@@ -213,23 +211,20 @@ function captureCodecMirror(schema, aot, slot, sanitize, dir) {
 			const ext = emitted.externals;
 			if (ext?.codecs && !ext.hof && require_compile_aot_emit.captureMirrorCodecs(schema, ext.codecs, dir)) {
 				let u;
-				let freezable = true;
-				if (ext.unions && ext.unions.length) {
+				if (ext.unions?.length) {
 					u = require_compile_aot_emit.captureMirrorUnions(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 });
+					if (!u) return;
 				}
+				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 {}

package/dist/compile/aot-capture.mjs

@@ -56,7 +56,6 @@ function validateMergeSource(schema, source) {
 	const merger = createMergerFromSource(source);
 	if (!merger) return false;
 	for (const probe of mergeProbes(schema)) {
-		if (probe === null || typeof probe !== "object") continue;
 		let expected;
 		try {
 			expected = Default(schema, structuredClone(probe));
@@ -75,7 +74,6 @@ function validateMergeSource(schema, source) {
 }
 const PROBE_SENTINEL = "__elysia_default_probe__";
 function* defaultProbes(pod) {
-	if (!pod) return;
 	yield {};
 	for (const k in pod) {
 		yield { [k]: PROBE_SENTINEL };
@@ -212,23 +210,20 @@ function captureCodecMirror(schema, aot, slot, sanitize, dir) {
 			const ext = emitted.externals;
 			if (ext?.codecs && !ext.hof && captureMirrorCodecs(schema, ext.codecs, dir)) {
 				let u;
-				let freezable = true;
-				if (ext.unions && ext.unions.length) {
+				if (ext.unions?.length) {
 					u = captureMirrorUnions(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 });
+					if (!u) return;
 				}
+				const mirror = {
+					source: emitted.source,
+					hasExternals: true,
+					u
+				};
+				Capture.set({
+					method: aot.method,
+					path: aot.path,
+					slot
+				}, dir === "decode" ? { decodeMirror: mirror } : { encodeMirror: mirror });
 			}
 		}
 	} catch {}

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

@@ -5,7 +5,6 @@ declare function reconstructCheck(build: CheckBuildResult): {
   defs: string;
   value: string;
 };
-declare function externalsMatch(a: unknown[], b: unknown[]): boolean;
 /**
  * Align a TypeBox build's externals with the layout the runtime rebuilds from
  * the schema (`collectExternals`). Returns the build as is when they already
@@ -28,4 +27,4 @@ declare function captureMirrorUnions(schema: unknown, truthUnions: any[][]): {
 declare function captureMirrorCodecs(schema: unknown, truthCodecs: Function[], dir?: 'decode' | 'encode'): boolean;
 declare function installReconstructImpl(): void;
 //#endregion
-export { Source, alignBuildExternals, captureMirrorCodecs, captureMirrorUnions, externalsMatch, installReconstructImpl, reconstructCheck };
+export { Source, alignBuildExternals, captureMirrorCodecs, captureMirrorUnions, installReconstructImpl, reconstructCheck };

package/dist/compile/aot-emit.js

@@ -24,20 +24,10 @@ function reconstructCheckCode(build) {
 }
 const checkFactorySource = (identifier, code) => `(${identifier})=>{${code}}`;
 const handlerFactorySource = (alias, code) => `function(h${alias ? "," + alias : ""}){return ${code}}`;
-function externalsMatch(a, b) {
-	if (a.length !== b.length) return false;
-	for (let i = 0; i < a.length; i++) {
-		const x = a[i];
-		const y = b[i];
-		if (x === y) continue;
-		if (x instanceof RegExp && y instanceof RegExp) {
-			if (x.source !== y.source || x.flags !== y.flags) return false;
-			continue;
-		}
-		if (Array.isArray(x) && Array.isArray(y) && x.length === y.length && x.findIndex((v, j) => v !== y[j]) === -1) continue;
-		return false;
-	}
-	return true;
+function externalMatches(x, y) {
+	if (x === y) return true;
+	if (x instanceof RegExp && y instanceof RegExp) return x.source === y.source && x.flags === y.flags;
+	return Array.isArray(x) && Array.isArray(y) && x.length === y.length && x.findIndex((v, j) => v !== y[j]) === -1;
 }
 function alignBuildExternals(build, schema) {
 	const variables = build.external.variables;
@@ -49,7 +39,7 @@ function alignBuildExternals(build, schema) {
 	let same = variables.length === expected.length;
 	for (const v of variables) {
 		const c = expected[j];
-		if (j < expected.length && externalsMatch([c], [v])) slots.push(`${id}[${j++}]`);
+		if (j < expected.length && externalMatches(c, v)) slots.push(`${id}[${j++}]`);
 		else if (Array.isArray(c) && c.length === 1 && c[0] === v) {
 			slots.push(`${id}[${j++}][0]`);
 			same = false;
@@ -111,6 +101,5 @@ exports.Source = Source;
 exports.alignBuildExternals = alignBuildExternals;
 exports.captureMirrorCodecs = captureMirrorCodecs;
 exports.captureMirrorUnions = captureMirrorUnions;
-exports.externalsMatch = externalsMatch;
 exports.installReconstructImpl = installReconstructImpl;
 exports.reconstructCheck = reconstructCheck;

package/dist/compile/aot-emit.mjs

@@ -24,20 +24,10 @@ function reconstructCheckCode(build) {
 }
 const checkFactorySource = (identifier, code) => `(${identifier})=>{${code}}`;
 const handlerFactorySource = (alias, code) => `function(h${alias ? "," + alias : ""}){return ${code}}`;
-function externalsMatch(a, b) {
-	if (a.length !== b.length) return false;
-	for (let i = 0; i < a.length; i++) {
-		const x = a[i];
-		const y = b[i];
-		if (x === y) continue;
-		if (x instanceof RegExp && y instanceof RegExp) {
-			if (x.source !== y.source || x.flags !== y.flags) return false;
-			continue;
-		}
-		if (Array.isArray(x) && Array.isArray(y) && x.length === y.length && x.findIndex((v, j) => v !== y[j]) === -1) continue;
-		return false;
-	}
-	return true;
+function externalMatches(x, y) {
+	if (x === y) return true;
+	if (x instanceof RegExp && y instanceof RegExp) return x.source === y.source && x.flags === y.flags;
+	return Array.isArray(x) && Array.isArray(y) && x.length === y.length && x.findIndex((v, j) => v !== y[j]) === -1;
 }
 function alignBuildExternals(build, schema) {
 	const variables = build.external.variables;
@@ -49,7 +39,7 @@ function alignBuildExternals(build, schema) {
 	let same = variables.length === expected.length;
 	for (const v of variables) {
 		const c = expected[j];
-		if (j < expected.length && externalsMatch([c], [v])) slots.push(`${id}[${j++}]`);
+		if (j < expected.length && externalMatches(c, v)) slots.push(`${id}[${j++}]`);
 		else if (Array.isArray(c) && c.length === 1 && c[0] === v) {
 			slots.push(`${id}[${j++}][0]`);
 			same = false;
@@ -107,4 +97,4 @@ function installReconstructImpl() {
 }
 
 //#endregion
-export { Source, alignBuildExternals, captureMirrorCodecs, captureMirrorUnions, externalsMatch, installReconstructImpl, reconstructCheck };
+export { Source, alignBuildExternals, captureMirrorCodecs, captureMirrorUnions, installReconstructImpl, reconstructCheck };

package/dist/compile/aot-reconstruct.js

@@ -1,6 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_type_constants = require('../type/constants.js');
 const require_compile_aot = require('./aot.js');
+const require_type_shared = require('../type/shared.js');
 
 //#region src/compile/aot-reconstruct.ts
 const isValueLikeExternal = (v) => v === null || typeof v !== "object" && typeof v !== "function";
@@ -45,7 +46,7 @@ function collectMirrorUnions(schema, out = []) {
 function collectMirrorCodecs(schema, out = [], dir = "decode") {
 	if (!schema || typeof schema !== "object") return out;
 	const codec = schema["~codec"];
-	if (codec && typeof codec[dir] === "function" && out.indexOf(codec[dir]) === -1) out.push(codec[dir]);
+	if (codec && typeof codec[dir] === "function" && !out.some((fn) => require_type_shared.originalFunction(fn) === require_type_shared.originalFunction(codec[dir]))) out.push(codec[dir]);
 	if (schema.type === "object" && schema.properties) for (const key in schema.properties) collectMirrorCodecs(schema.properties[key], out, dir);
 	else if (schema.type === "array" && schema.items) if (Array.isArray(schema.items)) for (const it of schema.items) collectMirrorCodecs(it, out, dir);
 	else collectMirrorCodecs(schema.items, out, dir);
@@ -97,15 +98,17 @@ function reconstructInnerCodecs(ic, schema) {
 		const innerCheck = entry.c(entry.e ? collectExternals(innerSchema) : []);
 		const innerMirror = entry.d.x ? instantiateFrozenDecodeMirror(entry.d, innerSchema) : entry.d.s;
 		const open = entry.o;
-		node.codec["~refine"][0].check = (v) => {
+		const refinement = node.codec["~refine"][0];
+		refinement.check = require_type_shared.replaceFunction((v) => {
 			if (v.charCodeAt(0) !== open) return false;
 			try {
 				return innerCheck(JSON.parse(v));
 			} catch {
 				return false;
 			}
-		};
-		node.codec["~codec"].decode = (v) => innerMirror(JSON.parse(v));
+		}, refinement.check);
+		const codec = node.codec["~codec"];
+		codec.decode = require_type_shared.replaceFunction((v) => innerMirror(JSON.parse(v)), codec.decode);
 	}
 }
 const Reconstruct = {