elysia 2.0.0-exp.34 → 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.d.ts

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

package/dist/compile/aot-capture.js

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

package/dist/compile/aot-capture.mjs

@@ -0,0 +1,181 @@
+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 { 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;
+	return new Proxy({}, { get(_, prop) {
+		if (prop === "buildResult") return buildResult;
+		const f = full ??= Compile(schema);
+		const value = f[prop];
+		return typeof value === "function" ? value.bind(f) : value;
+	} });
+}
+function maybeCapture(args) {
+	const { aot, slot, hasRef, originalSchema, schema, hasCodec, hasDefault, coerces, normalize, buildResult } = args;
+	if (hasCodec && !hasRef && coerces && normalize !== false && normalize !== "typebox") {
+		const plan = captureCoercePlan(originalSchema, schema);
+		if (plan && externalsShape(buildCoercedFromPlan(originalSchema, plan)) === externalsShape(schema)) Capture.set({
+			method: aot.method,
+			path: aot.path,
+			slot
+		}, { coercePlan: plan });
+	}
+	const defaultFastPathCapture = {
+		precomputeSafe: void 0,
+		precomputedDefault: void 0,
+		precomputeNull: void 0,
+		precomputedObjectDefault: void 0,
+		defaultCloner: void 0,
+		objectDefaultMerger: void 0
+	};
+	if (hasDefault) {
+		const defaults = verifyPreallocatableDefault(schema);
+		if (defaults) {
+			defaultFastPathCapture.precomputeSafe = true;
+			defaultFastPathCapture.precomputedDefault = defaults.pd;
+			defaultFastPathCapture.precomputeNull = defaults.pn;
+			defaultFastPathCapture.precomputedObjectDefault = defaults.pod;
+			defaultFastPathCapture.defaultCloner = defaults.pd !== void 0 ? buildDefaultClonerSource(defaults.pd) : void 0;
+			defaultFastPathCapture.objectDefaultMerger = defaults.ms ?? (defaults.pod !== void 0 ? buildObjectDefaultMergeSource(defaults.pod) : void 0);
+		}
+	}
+	Capture.set({
+		method: aot.method,
+		path: aot.path,
+		slot
+	}, defaultFastPathCapture);
+	const customErrors = captureCustomErrors(schema);
+	if (customErrors) Capture.set({
+		method: aot.method,
+		path: aot.path,
+		slot
+	}, { customErrors });
+	const innerCodecs = captureStringCodecEntries(schema, args.sanitize);
+	if (innerCodecs) Capture.set({
+		method: aot.method,
+		path: aot.path,
+		slot
+	}, { innerCodecs });
+	const cf = buildFrozenCheck(buildResult, schema);
+	if (!cf) return;
+	Capture.set({
+		method: aot.method,
+		path: aot.path,
+		slot
+	}, {
+		...cf,
+		async: buildResult.external.variables.some(isAsyncPredicate),
+		hasDefault,
+		hasCodec,
+		hasRef
+	});
+}
+function captureMirror(schema, aot, slot, sanitize) {
+	try {
+		const emitted = createMirror(schema, {
+			Compile,
+			sanitize,
+			emit: true
+		});
+		if (typeof emitted?.source === "string") {
+			const ext = emitted.externals;
+			if (!ext) Capture.set({
+				method: aot.method,
+				path: aot.path,
+				slot
+			}, { mirror: {
+				source: emitted.source,
+				hasExternals: false
+			} });
+			else if (ext.unions && !ext.hof) {
+				const u = captureMirrorUnions(schema, ext.unions);
+				if (u) Capture.set({
+					method: aot.method,
+					path: aot.path,
+					slot
+				}, { mirror: {
+					source: emitted.source,
+					hasExternals: true,
+					u
+				} });
+			}
+		}
+	} catch {}
+}
+function captureCodecMirror(schema, aot, slot, sanitize, dir) {
+	const dirOpt = dir === "decode" ? { decode: true } : { encode: true };
+	try {
+		const emitted = createMirror(schema, {
+			Compile,
+			sanitize,
+			...dirOpt,
+			emit: true
+		});
+		if (typeof emitted?.source === "string") {
+			const ext = emitted.externals;
+			if (ext?.codecs && !ext.hof && captureMirrorCodecs(schema, ext.codecs, dir)) {
+				let u;
+				let freezable = true;
+				if (ext.unions && 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 });
+				}
+			}
+		}
+	} catch {}
+}
+function captureBridgeFree(aot, slot, rawSchema) {
+	const captured = Capture.get({
+		method: aot.method,
+		path: aot.path,
+		slot
+	});
+	if (captured) Capture.set({
+		method: aot.method,
+		path: aot.path,
+		slot
+	}, { bridgeFree: isCapturedBridgeFree(captured, rawSchema, captured.coercePlan && typeof rawSchema !== "string" ? buildCoercedFromPlan(rawSchema, captured.coercePlan) : rawSchema) });
+}
+const impl = {
+	sourceOnlyValidator,
+	maybeCapture,
+	captureMirror,
+	captureCodecMirror,
+	captureBridgeFree
+};
+function installCaptureImpl() {
+	setCaptureImpl(impl);
+	installReconstructImpl();
+}
+installCaptureImpl();
+
+//#endregion
+export { impl as captureImplementation, 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 };