elysia 2.0.0-exp.35 → 2.0.0-exp.36

package/dist/base.d.ts

@@ -53,6 +53,7 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
   };
   '~hasWS'?: boolean;
   '~hasDynamicWS'?: boolean;
+  '~hasTrace'?: boolean;
   '~scopeChild'?: boolean;
   '~scopeChildren'?: AnyElysia[];
   constructor(config?: ElysiaConfig<BasePath, Scope>);
@@ -203,12 +204,39 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
   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>>;
-  /**
-   * ### mapDerive
-   * Alias of {@link derive}. Shares the same implementation at the
-   * prototype level (see `Elysia.prototype.mapDerive` after the class).
-   */
-  mapDerive: this['derive'];
+  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>;
+    schema: Volatile['schema'];
+    schemas: Volatile['schemas'];
+    response: UnionResponseStatus<Volatile['response'], ExtractErrorFromHandle<Derivative>>;
+    error: Volatile['error'];
+  }>;
+  mapDerive<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>): Elysia<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, {
+    derive: ExcludeElysiaResponse<Derivative>;
+    schema: Volatile['schema'];
+    schemas: Volatile['schemas'];
+    response: UnionResponseStatus<Volatile['response'], ExtractErrorFromHandle<Derivative>>;
+    error: Volatile['error'];
+  }>;
+  mapDerive<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>): Elysia<BasePath, Scope, Singleton, Definitions, Metadata, Routes, {
+    derive: ExcludeElysiaResponse<Derivative>;
+    schema: Ephemeral['schema'];
+    schemas: Ephemeral['schemas'];
+    response: UnionResponseStatus<Ephemeral['response'], ExtractErrorFromHandle<Derivative>>;
+    error: Ephemeral['error'];
+  }, Volatile>;
+  mapDerive<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>): Elysia<BasePath, Scope, {
+    decorator: Singleton['decorator'];
+    store: Singleton['store'];
+    derive: ExcludeElysiaResponse<Derivative>;
+  }, Definitions, {
+    schema: Metadata['schema'];
+    schemas: Metadata['schemas'];
+    macro: Metadata['macro'];
+    macroFn: Metadata['macroFn'];
+    parser: Metadata['parser'];
+    response: UnionResponseStatus<Metadata['response'], ExtractErrorFromHandle<Derivative>>;
+  }, Routes, Ephemeral, Volatile>;
   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>>;

package/dist/base.js

@@ -143,6 +143,7 @@ var Elysia = class Elysia {
 	#on(type, fn, scope = this["~config"]?.as) {
 		const added = require_utils.nullObject();
 		added[type] = fn;
+		if (type === "trace") this["~hasTrace"] = true;
 		this["~hookChain"] = {
 			added,
 			parent: this["~hookChain"],
@@ -217,6 +218,17 @@ var Elysia = class Elysia {
 		}
 		return result;
 	}
+	mapDerive(scopeOrFn, fn) {
+		const result = this.#onBranch("beforeHandle", scopeOrFn, fn);
+		const node = this["~hookChain"];
+		if (node?.added) {
+			const d = fn ?? scopeOrFn;
+			const entries = node.added["~deriveEntries"] ??= [];
+			if (Array.isArray(d)) for (const f of d) entries.push(require_utils.mapDeriveEntry(f));
+			else entries.push(require_utils.mapDeriveEntry(d));
+		}
+		return result;
+	}
 	afterHandle(scopeOrFn, fn) {
 		return this.#onBranch("afterHandle", scopeOrFn, fn);
 	}
@@ -368,6 +380,7 @@ var Elysia = class Elysia {
 			}
 			hook = promoted;
 		}
+		if (hook.trace) this["~hasTrace"] = true;
 		this["~hookChain"] = {
 			added: hook,
 			parent: this["~hookChain"],
@@ -548,6 +561,7 @@ var Elysia = class Elysia {
 			if (addedByThisCall) for (const h of addedByThisCall) this.#childrenHash.delete(h);
 			throw new Error(`[Elysia] Macro "${macroName}" can be only define once`);
 		}
+		if (app["~hasTrace"]) this["~hasTrace"] = true;
 		if (app.#history) {
 			if (app["~hasWS"]) this["~hasWS"] = true;
 			const history = this.#history ??= [];
@@ -682,10 +696,10 @@ var Elysia = class Elysia {
 						continue;
 					}
 					if (key === "~deriveEntries") {
-						const entries = added["~deriveEntries"];
+						const entries = added[key];
 						if (!entries) continue;
 						const target = isGlobal ? globalEvents ??= require_utils.nullObject() : pluginEvents ??= require_utils.nullObject();
-						const list = target["~deriveEntries"] ??= [];
+						const list = target[key] ??= [];
 						for (let j = 0; j < entries.length; j++) list.push(entries[j]);
 						continue;
 					}
@@ -1256,7 +1270,6 @@ var Elysia = class Elysia {
 		return r;
 	}
 };
-Elysia.prototype.mapDerive = Elysia.prototype.derive;
 
 //#endregion
 exports.Elysia = Elysia;

package/dist/base.mjs

@@ -1,6 +1,6 @@
 import { isBun } from "./universal/constants.mjs";
 import { MethodMap, isDynamicRegex, needEncodeRegex } from "./constants.mjs";
-import { clonePlainDecorators, clonePlainDeep, coalesceStandaloneSchemas, createErrorEventHandler, eventProperties, fnOrigin, fnv1a, getLoosePath, guardNonPlainLeaves, hookToGuard, invalidateMacroEpoch, isEmpty, isNotEmpty, isRecordNumber, joinPath, macroOrigin, mapMethodBack, mergeDeep, mergeResponse, nullObject, pushField, schemaProperties, serializeMacroSeed } from "./utils.mjs";
+import { clonePlainDecorators, clonePlainDeep, coalesceStandaloneSchemas, createErrorEventHandler, eventProperties, fnOrigin, fnv1a, getLoosePath, guardNonPlainLeaves, hookToGuard, invalidateMacroEpoch, isEmpty, isNotEmpty, isRecordNumber, joinPath, macroOrigin, mapDeriveEntry, mapMethodBack, mergeDeep, mergeResponse, nullObject, pushField, schemaProperties, serializeMacroSeed } from "./utils.mjs";
 import { Ref } from "./type/bridge.mjs";
 import { Capture } from "./compile/aot.mjs";
 import { compileHandler, composeRouteHook, localMacroRoot, resolveLocalHook } from "./compile/handler/index.mjs";
@@ -140,6 +140,7 @@ var Elysia = class Elysia {
 	#on(type, fn, scope = this["~config"]?.as) {
 		const added = nullObject();
 		added[type] = fn;
+		if (type === "trace") this["~hasTrace"] = true;
 		this["~hookChain"] = {
 			added,
 			parent: this["~hookChain"],
@@ -214,6 +215,17 @@ var Elysia = class Elysia {
 		}
 		return result;
 	}
+	mapDerive(scopeOrFn, fn) {
+		const result = this.#onBranch("beforeHandle", scopeOrFn, fn);
+		const node = this["~hookChain"];
+		if (node?.added) {
+			const d = fn ?? scopeOrFn;
+			const entries = node.added["~deriveEntries"] ??= [];
+			if (Array.isArray(d)) for (const f of d) entries.push(mapDeriveEntry(f));
+			else entries.push(mapDeriveEntry(d));
+		}
+		return result;
+	}
 	afterHandle(scopeOrFn, fn) {
 		return this.#onBranch("afterHandle", scopeOrFn, fn);
 	}
@@ -365,6 +377,7 @@ var Elysia = class Elysia {
 			}
 			hook = promoted;
 		}
+		if (hook.trace) this["~hasTrace"] = true;
 		this["~hookChain"] = {
 			added: hook,
 			parent: this["~hookChain"],
@@ -545,6 +558,7 @@ var Elysia = class Elysia {
 			if (addedByThisCall) for (const h of addedByThisCall) this.#childrenHash.delete(h);
 			throw new Error(`[Elysia] Macro "${macroName}" can be only define once`);
 		}
+		if (app["~hasTrace"]) this["~hasTrace"] = true;
 		if (app.#history) {
 			if (app["~hasWS"]) this["~hasWS"] = true;
 			const history = this.#history ??= [];
@@ -679,10 +693,10 @@ var Elysia = class Elysia {
 						continue;
 					}
 					if (key === "~deriveEntries") {
-						const entries = added["~deriveEntries"];
+						const entries = added[key];
 						if (!entries) continue;
 						const target = isGlobal ? globalEvents ??= nullObject() : pluginEvents ??= nullObject();
-						const list = target["~deriveEntries"] ??= [];
+						const list = target[key] ??= [];
 						for (let j = 0; j < entries.length; j++) list.push(entries[j]);
 						continue;
 					}
@@ -1253,7 +1267,6 @@ var Elysia = class Elysia {
 		return r;
 	}
 };
-Elysia.prototype.mapDerive = Elysia.prototype.derive;
 
 //#endregion
 export { Elysia };

package/dist/compile/aot-capture.js

@@ -4,15 +4,21 @@ const require_compile_aot = require('./aot.js');
 const require_compile_handler_frozen_validator = require('./handler/frozen-validator.js');
 const require_type_coerce = require('../type/coerce.js');
 const require_type_validator_default_precompute = require('../type/validator/default-precompute.js');
+const require_compile_aot_reconstruct = require('./aot-reconstruct.js');
 const require_type_validator_frozen_check = require('../type/validator/frozen-check.js');
 const require_type_validator_custom_error = require('../type/validator/custom-error.js');
-const require_type_validator_string_codec_aot = require('../type/validator/string-codec-aot.js');
 const require_type_validator_index = require('../type/validator/index.js');
+const require_type_validator_string_codec_aot = require('../type/validator/string-codec-aot.js');
 let typebox_schema = require("typebox/schema");
 let exact_mirror = require("exact-mirror");
 exact_mirror = require_runtime.__toESM(exact_mirror);
 
 //#region src/compile/aot-capture.ts
+function externalsShape(schema) {
+	let out = "";
+	for (const e of require_compile_aot_reconstruct.collectExternals(schema)) out += e instanceof RegExp ? "r" : typeof e === "function" ? "f" : "v";
+	return out;
+}
 function sourceOnlyValidator(schema) {
 	const buildResult = (0, typebox_schema.Build)(schema);
 	let full;
@@ -27,7 +33,7 @@ function maybeCapture(args) {
 	const { aot, slot, hasRef, originalSchema, schema, hasCodec, hasDefault, coerces, normalize, buildResult } = args;
 	if (hasCodec && !hasRef && coerces && normalize !== false && normalize !== "typebox") {
 		const plan = require_type_coerce.captureCoercePlan(originalSchema, schema);
-		if (plan && require_type_validator_index.externalsShape(require_type_coerce.buildCoercedFromPlan(originalSchema, plan)) === require_type_validator_index.externalsShape(schema)) require_compile_aot.Capture.set({
+		if (plan && externalsShape(require_type_coerce.buildCoercedFromPlan(originalSchema, plan)) === externalsShape(schema)) require_compile_aot.Capture.set({
 			method: aot.method,
 			path: aot.path,
 			slot
@@ -101,7 +107,7 @@ function captureMirror(schema, aot, slot, sanitize) {
 				hasExternals: false
 			} });
 			else if (ext.unions && !ext.hof) {
-				const u = require_compile_aot.Capture.mirrorUnions(schema, ext.unions);
+				const u = require_compile_aot_reconstruct.captureMirrorUnions(schema, ext.unions);
 				if (u) require_compile_aot.Capture.set({
 					method: aot.method,
 					path: aot.path,
@@ -126,11 +132,11 @@ function captureCodecMirror(schema, aot, slot, sanitize, dir) {
 		});
 		if (typeof emitted?.source === "string") {
 			const ext = emitted.externals;
-			if (ext?.codecs && !ext.hof && require_compile_aot.Capture.mirrorCodecs(schema, ext.codecs, dir)) {
+			if (ext?.codecs && !ext.hof && require_compile_aot_reconstruct.captureMirrorCodecs(schema, ext.codecs, dir)) {
 				let u;
 				let freezable = true;
 				if (ext.unions && ext.unions.length) {
-					u = require_compile_aot.Capture.mirrorUnions(schema, ext.unions);
+					u = require_compile_aot_reconstruct.captureMirrorUnions(schema, ext.unions);
 					if (!u) freezable = false;
 				}
 				if (freezable) {
@@ -170,6 +176,7 @@ const impl = {
 };
 function installCaptureImpl() {
 	require_compile_aot.setCaptureImpl(impl);
+	require_compile_aot_reconstruct.installReconstructImpl();
 }
 installCaptureImpl();
 

package/dist/compile/aot-capture.mjs

@@ -2,14 +2,20 @@ import { Capture, setCaptureImpl } from "./aot.mjs";
 import { isCapturedBridgeFree } from "./handler/frozen-validator.mjs";
 import { buildCoercedFromPlan, captureCoercePlan } from "../type/coerce.mjs";
 import { buildDefaultClonerSource, buildObjectDefaultMergeSource, verifyPreallocatableDefault } from "../type/validator/default-precompute.mjs";
+import { captureMirrorCodecs, captureMirrorUnions, collectExternals, installReconstructImpl } from "./aot-reconstruct.mjs";
 import { buildFrozenCheck } from "../type/validator/frozen-check.mjs";
 import { captureCustomErrors } from "../type/validator/custom-error.mjs";
+import { isAsyncPredicate } from "../type/validator/index.mjs";
 import { captureStringCodecEntries } from "../type/validator/string-codec-aot.mjs";
-import { externalsShape, isAsyncPredicate } from "../type/validator/index.mjs";
 import { Build, Compile } from "typebox/schema";
 import createMirror from "exact-mirror";
 
 //#region src/compile/aot-capture.ts
+function externalsShape(schema) {
+	let out = "";
+	for (const e of collectExternals(schema)) out += e instanceof RegExp ? "r" : typeof e === "function" ? "f" : "v";
+	return out;
+}
 function sourceOnlyValidator(schema) {
 	const buildResult = Build(schema);
 	let full;
@@ -98,7 +104,7 @@ function captureMirror(schema, aot, slot, sanitize) {
 				hasExternals: false
 			} });
 			else if (ext.unions && !ext.hof) {
-				const u = Capture.mirrorUnions(schema, ext.unions);
+				const u = captureMirrorUnions(schema, ext.unions);
 				if (u) Capture.set({
 					method: aot.method,
 					path: aot.path,
@@ -123,11 +129,11 @@ function captureCodecMirror(schema, aot, slot, sanitize, dir) {
 		});
 		if (typeof emitted?.source === "string") {
 			const ext = emitted.externals;
-			if (ext?.codecs && !ext.hof && Capture.mirrorCodecs(schema, ext.codecs, dir)) {
+			if (ext?.codecs && !ext.hof && captureMirrorCodecs(schema, ext.codecs, dir)) {
 				let u;
 				let freezable = true;
 				if (ext.unions && ext.unions.length) {
-					u = Capture.mirrorUnions(schema, ext.unions);
+					u = captureMirrorUnions(schema, ext.unions);
 					if (!u) freezable = false;
 				}
 				if (freezable) {
@@ -167,6 +173,7 @@ const impl = {
 };
 function installCaptureImpl() {
 	setCaptureImpl(impl);
+	installReconstructImpl();
 }
 installCaptureImpl();
 

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

@@ -0,0 +1,54 @@
+import { CheckBuildResult, FrozenMirror, FrozenValidator, ReconstructImpl, StringCodecNode } from "./aot.js";
+
+//#region src/compile/aot-reconstruct.d.ts
+declare function reconstructCheck(build: CheckBuildResult): {
+  defs: string;
+  value: string;
+};
+/**
+ * Rebuild TypeBox `External[]` for `schema` in `BuildSchema` traversal order:
+ * object (patternProperties → properties) → array (items) → string (pattern) →
+ * guard → const → enum → not/allOf/anyOf/oneOf → refine LAST.
+ */
+declare function collectExternals(schema: any, out?: unknown[]): unknown[];
+declare function externalsMatch(a: unknown[], b: unknown[]): boolean;
+declare const Source: {
+  readonly checkFactory: (identifier: string, code: string) => string;
+  readonly checkCode: (defs: string, value: string) => string;
+  readonly handlerFactory: (alias: string, code: string) => string;
+  readonly mirrorFactory: (source: string, hasExternals: boolean) => string;
+  readonly bothFactory: (identifier: string, checkDefs: string, checkValue: string, mirrorSource: string, mirrorHasExternals: boolean) => string;
+};
+declare function collectMirrorUnions(schema: any, out?: unknown[][]): unknown[][];
+declare function instantiateFrozenMirror(frozen: FrozenMirror, schema: unknown): (value: unknown) => unknown;
+declare function instantiateFrozenDecodeMirror(frozen: FrozenMirror, schema: unknown, dir?: 'decode' | 'encode'): (value: unknown) => unknown;
+declare const instantiateFrozenEncodeMirror: (frozen: FrozenMirror, schema: unknown) => ((value: unknown) => unknown);
+declare function instantiateFrozenBoth(frozen: FrozenValidator, checkSchema: unknown, mirrorSchema: unknown): {
+  check?: (value: unknown) => boolean;
+  clean?: (value: unknown) => unknown;
+};
+declare function collectStringCodecNodes(schema: any, out?: StringCodecNode[]): StringCodecNode[];
+/**
+ * Overwrite every ObjectString/ArrayString node's `~refine[0].check` and
+ * `~codec.decode` with the baked `ic` closures. After this runs, the node no
+ * longer calls the constructor's live `typebox/value` Check/Decode
+ *
+ * Iterate in reverse so nested codecs reconstruct bottom-up.
+ */
+declare function reconstructInnerCodecs(ic: NonNullable<FrozenValidator['ic']>, schema: any): void;
+/**
+ * verify that mirror unions can be reconstructed in build time
+ *
+ * return undefined if not reconstructable
+ * `truthUnions` is `mir.externals.unions` (compiled branches).
+ */
+declare function captureMirrorUnions(schema: unknown, truthUnions: any[][]): {
+  identifier: string;
+  code: string;
+}[][] | undefined;
+declare function captureMirrorCodecs(schema: unknown, truthCodecs: Function[], dir?: 'decode' | 'encode'): boolean;
+/** Runtime reconstruction table the generated manifest module registers. */
+declare const Reconstruct: ReconstructImpl;
+declare function installReconstructImpl(): void;
+//#endregion
+export { Reconstruct, Source, captureMirrorCodecs, captureMirrorUnions, collectExternals, collectMirrorUnions, collectStringCodecNodes, externalsMatch, installReconstructImpl, instantiateFrozenBoth, instantiateFrozenDecodeMirror, instantiateFrozenEncodeMirror, instantiateFrozenMirror, reconstructCheck, reconstructInnerCodecs };

package/dist/compile/aot-reconstruct.js

@@ -0,0 +1,249 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_type_constants = require('../type/constants.js');
+const require_compile_aot = require('./aot.js');
+
+//#region src/compile/aot-reconstruct.ts
+/**
+* Frozen-manifest reconstruction + source emitters.
+*
+* Kept out of `aot.ts` so apps that never load a generated manifest module
+* tree-shake it: runtime call sites reach these through `reconstruct()`
+* (see `aot.ts`), wired by the generated `elysia/reconstruct`
+*
+* Everything here is pure (no module state): the stateful registration goes
+* through `Compiled` from `registerFrom`, so a duplicate copy of this module
+* resolving from another elysia install still reconstructs correctly.
+*/
+function reconstructCheck(build) {
+	const defs = build.functions.join(";\n");
+	if (!build.useUnevaluated) {
+		const single = /^([A-Za-z_$][\w$]*)\(value\)$/.exec(build.entry.trim());
+		if (single) return {
+			defs,
+			value: single[1]
+		};
+	}
+	return {
+		defs,
+		value: `(value) => { ${(build.useUnevaluated ? "const context = new CheckContext({}, {});\n" : "") + `return ${build.entry}`} }`
+	};
+}
+const checkCode = (defs, value) => `${defs}; return ${value}`;
+function reconstructCheckCode(build) {
+	const { defs, value } = reconstructCheck(build);
+	return checkCode(defs, value);
+}
+const checkFactorySource = (identifier, code) => `function(${identifier}){${code}}`;
+const handlerFactorySource = (alias, code) => `function(h${alias ? "," + alias : ""}){return ${code}}`;
+const isValueLikeExternal = (v) => v === null || typeof v !== "object" && typeof v !== "function";
+/**
+* Rebuild TypeBox `External[]` for `schema` in `BuildSchema` traversal order:
+* object (patternProperties → properties) → array (items) → string (pattern) →
+* guard → const → enum → not/allOf/anyOf/oneOf → refine LAST.
+*/
+function collectExternals(schema, out = []) {
+	if (!schema || typeof schema !== "object") return out;
+	const pp = schema.patternProperties;
+	if (pp) for (const pattern in pp) {
+		out.push(new RegExp(pattern, "u"));
+		collectExternals(pp[pattern], out);
+	}
+	if (schema.properties) for (const k in schema.properties) collectExternals(schema.properties[k], out);
+	const items = schema.items;
+	if (Array.isArray(items)) for (const it of items) collectExternals(it, out);
+	else if (items) collectExternals(items, out);
+	if (typeof schema.pattern === "string") out.push(new RegExp(schema.pattern, "u"));
+	if (schema["~guard"]) out.push(schema);
+	if ("const" in schema && !isValueLikeExternal(schema.const)) out.push(schema.const);
+	if (Array.isArray(schema.enum)) {
+		for (const o of schema.enum) if (!isValueLikeExternal(o)) out.push(o);
+	}
+	if (schema.not) collectExternals(schema.not, out);
+	if (Array.isArray(schema.allOf)) for (const s of schema.allOf) collectExternals(s, out);
+	if (Array.isArray(schema.anyOf)) for (const s of schema.anyOf) collectExternals(s, out);
+	if (Array.isArray(schema.oneOf)) for (const s of schema.oneOf) collectExternals(s, out);
+	if (schema["~refine"]) out.push(schema["~refine"]);
+	return out;
+}
+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)) {
+			if (x.length !== y.length) return false;
+			let ok = true;
+			for (let j = 0; j < x.length; j++) if (x[j] !== y[j]) {
+				ok = false;
+				break;
+			}
+			if (ok) continue;
+		}
+		return false;
+	}
+	return true;
+}
+const mirrorFactorySource = (source, hasExternals) => hasExternals ? `function(d){${source}}` : `function(v){${source}}`;
+const bothFactorySource = (identifier, checkDefs, checkValue, mirrorSource, mirrorHasExternals) => `function(${identifier},d){${checkDefs}; return{check:${checkValue},clean:${mirrorHasExternals ? `(function(d){${mirrorSource}})(d)` : `function(v){${mirrorSource}}`}}}`;
+const Source = {
+	checkFactory: checkFactorySource,
+	checkCode,
+	handlerFactory: handlerFactorySource,
+	mirrorFactory: mirrorFactorySource,
+	bothFactory: bothFactorySource
+};
+function collectMirrorUnions(schema, out = []) {
+	if (!schema || typeof schema !== "object") return out;
+	if (schema.type === "object" && schema.properties) for (const key in schema.properties) collectMirrorUnions(schema.properties[key], out);
+	else if (schema.type === "array" && schema.items) if (Array.isArray(schema.items)) for (const it of schema.items) collectMirrorUnions(it, out);
+	else collectMirrorUnions(schema.items, out);
+	else if (Array.isArray(schema.anyOf)) {
+		out.push(schema.anyOf);
+		for (const b of schema.anyOf) {
+			collectMirrorUnions(b, out);
+			collectMirrorUnions(b, out);
+		}
+	}
+	return 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 (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);
+	else if (Array.isArray(schema.anyOf)) for (const b of schema.anyOf) collectMirrorCodecs(b, out, dir);
+	return out;
+}
+function buildUnions(u, schema) {
+	const branchSchemas = collectMirrorUnions(schema);
+	return u.map((branches, ui) => branches.map((factory, i) => ({ Check: factory(collectExternals(branchSchemas[ui][i])) })));
+}
+function instantiateFrozenMirror(frozen, schema) {
+	if (!frozen.u) return frozen.s;
+	return frozen.s({ unions: buildUnions(frozen.u, schema) });
+}
+function instantiateFrozenDecodeMirror(frozen, schema, dir = "decode") {
+	const d = { codecs: collectMirrorCodecs(schema, [], dir) };
+	if (frozen.u) d.unions = buildUnions(frozen.u, schema);
+	return frozen.s(d);
+}
+const instantiateFrozenEncodeMirror = (frozen, schema) => instantiateFrozenDecodeMirror(frozen, schema, "encode");
+function instantiateFrozenBoth(frozen, checkSchema, mirrorSchema) {
+	return frozen.cm(frozen.e ? collectExternals(checkSchema) : require_compile_aot.EMPTY_EXTERNALS, frozen.u ? { unions: buildUnions(frozen.u, mirrorSchema) } : void 0);
+}
+function collectStringCodecNodes(schema, out = []) {
+	if (!schema || typeof schema !== "object") return out;
+	const ely = schema["~elyTyp"];
+	if (ely === require_type_constants.ELYSIA_TYPES.ObjectString || ely === require_type_constants.ELYSIA_TYPES.ArrayString) {
+		const inner = schema.anyOf?.[0];
+		const codec = schema.anyOf?.[1];
+		if (inner && codec?.["~codec"] && codec["~refine"]) out.push({
+			inner,
+			codec,
+			open: ely === require_type_constants.ELYSIA_TYPES.ObjectString ? 123 : 91
+		});
+	}
+	if (schema.properties) for (const k in schema.properties) collectStringCodecNodes(schema.properties[k], out);
+	const items = schema.items;
+	if (Array.isArray(items)) for (const it of items) collectStringCodecNodes(it, out);
+	else if (items) collectStringCodecNodes(items, out);
+	if (Array.isArray(schema.anyOf)) for (const b of schema.anyOf) collectStringCodecNodes(b, out);
+	return out;
+}
+/**
+* Overwrite every ObjectString/ArrayString node's `~refine[0].check` and
+* `~codec.decode` with the baked `ic` closures. After this runs, the node no
+* longer calls the constructor's live `typebox/value` Check/Decode
+*
+* Iterate in reverse so nested codecs reconstruct bottom-up.
+*/
+function reconstructInnerCodecs(ic, schema) {
+	const nodes = collectStringCodecNodes(schema);
+	for (let i = nodes.length - 1; i >= 0; i--) {
+		const entry = ic[i];
+		const node = nodes[i];
+		if (!entry || !node) continue;
+		const innerSchema = node.inner;
+		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) => {
+			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));
+	}
+}
+/**
+* verify that mirror unions can be reconstructed in build time
+*
+* return undefined if not reconstructable
+* `truthUnions` is `mir.externals.unions` (compiled branches).
+*/
+function captureMirrorUnions(schema, truthUnions) {
+	const branchSchemas = collectMirrorUnions(schema);
+	if (branchSchemas.length !== truthUnions.length) return;
+	const u = [];
+	for (let ui = 0; ui < truthUnions.length; ui++) {
+		if (!branchSchemas[ui] || branchSchemas[ui].length !== truthUnions[ui].length) return;
+		const branch = [];
+		for (let i = 0; i < truthUnions[ui].length; i++) {
+			const build = truthUnions[ui][i]?.buildResult;
+			if (!build?.functions?.length || !build.entry) return;
+			if (!externalsMatch(collectExternals(branchSchemas[ui][i]), build.external.variables)) return;
+			branch.push({
+				identifier: build.external.identifier,
+				code: reconstructCheckCode(build)
+			});
+		}
+		u.push(branch);
+	}
+	return u;
+}
+function captureMirrorCodecs(schema, truthCodecs, dir = "decode") {
+	const codecs = collectMirrorCodecs(schema, [], dir);
+	if (codecs.length !== truthCodecs.length) return false;
+	for (let i = 0; i < codecs.length; i++) if (codecs[i] !== truthCodecs[i]) return false;
+	return true;
+}
+/** Runtime reconstruction table the generated manifest module registers. */
+const Reconstruct = {
+	collectExternals,
+	collectMirrorUnions,
+	collectStringCodecNodes,
+	instantiateFrozenMirror,
+	instantiateFrozenDecodeMirror,
+	instantiateFrozenBoth,
+	reconstructInnerCodecs
+};
+function installReconstructImpl() {
+	require_compile_aot.Compiled.reconstruct = Reconstruct;
+}
+
+//#endregion
+exports.Reconstruct = Reconstruct;
+exports.Source = Source;
+exports.captureMirrorCodecs = captureMirrorCodecs;
+exports.captureMirrorUnions = captureMirrorUnions;
+exports.collectExternals = collectExternals;
+exports.collectMirrorUnions = collectMirrorUnions;
+exports.collectStringCodecNodes = collectStringCodecNodes;
+exports.externalsMatch = externalsMatch;
+exports.installReconstructImpl = installReconstructImpl;
+exports.instantiateFrozenBoth = instantiateFrozenBoth;
+exports.instantiateFrozenDecodeMirror = instantiateFrozenDecodeMirror;
+exports.instantiateFrozenEncodeMirror = instantiateFrozenEncodeMirror;
+exports.instantiateFrozenMirror = instantiateFrozenMirror;
+exports.reconstructCheck = reconstructCheck;
+exports.reconstructInnerCodecs = reconstructInnerCodecs;