elysia 2.0.0-exp.34 → 2.0.0-exp.35

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

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

package/dist/compile/aot-capture.js

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

package/dist/compile/aot-capture.mjs

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

package/dist/compile/aot.d.ts

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

package/dist/compile/aot.js

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

package/dist/compile/aot.mjs

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

package/dist/compile/lexer.d.ts

@@ -1,5 +1,5 @@
 //#region src/compile/lexer.d.ts
-declare const isSpace: (ch: string) => ch is " " | "\n" | "\t" | "\r";
+declare const isSpace: (ch: string) => ch is "\n" | " " | "\t" | "\r";
 declare const isIdentChar: (ch: string) => boolean;
 declare const isIdentCharCode: (code: number) => boolean;
 declare function skipString(src: string, start: number): number;

package/dist/plugin/source.js

@@ -6,8 +6,10 @@ const require_compile_jit_probe = require('../compile/jit-probe.js');
 const require_compile_handler_jit = require('../compile/handler/jit.js');
 const require_validator_index = require('../validator/index.js');
 const require_compile_handler_index = require('../compile/handler/index.js');
+const require_compile_aot_capture = require('../compile/aot-capture.js');
 
 //#region src/plugin/source.ts
+require_compile_aot_capture.installCaptureImpl();
 const autoGroupSize = (routes) => routes < 64 ? 1 : routes < 256 ? 2 : routes < 2048 ? 4 : routes < 8192 ? 16 : 64;
 async function compileToSource(app, options) {
 	return (await captureArtifacts(app, options)).source;

package/dist/plugin/source.mjs

@@ -5,8 +5,10 @@ import { JITProbe } from "../compile/jit-probe.mjs";
 import { setCaptureHeaderShorthand } from "../compile/handler/jit.mjs";
 import { Validator } from "../validator/index.mjs";
 import { compileHandler } from "../compile/handler/index.mjs";
+import { installCaptureImpl } from "../compile/aot-capture.mjs";
 
 //#region src/plugin/source.ts
+installCaptureImpl();
 const autoGroupSize = (routes) => routes < 64 ? 1 : routes < 256 ? 2 : routes < 2048 ? 4 : routes < 8192 ? 16 : 64;
 async function compileToSource(app, options) {
 	return (await captureArtifacts(app, options)).source;

package/dist/type/bridge.d.ts

@@ -1,17 +1,17 @@
-import { Intersect as Intersect$1 } from "./elysia/intersect.js";
+import { Intersect as Intersect$2 } from "./elysia/intersect.js";
 import { applyCoercions as applyCoercions$1, coerceBody as coerceBody$1, coerceFormData as coerceFormData$1, coerceQuery as coerceQuery$1, coerceRoot as coerceRoot$1, coerceStringToStructure as coerceStringToStructure$1 } from "./coerce.js";
 import { hasTypes as hasTypes$1 } from "./utils.js";
 import { TypeBoxValidatorCache as TypeBoxValidatorCache$1 } from "./validator/validator-cache.js";
 import { TypeBoxValidator as TypeBoxValidator$1 } from "./validator/index.js";
 import { Ref as Ref$1, TAny, TSchema } from "typebox/type";
 import { Compile as Compile$1 } from "typebox/compile";
-import { Clone as Clone$1, Create as Create$1, Decode as Decode$1, Default as Default$1, HasCodec as HasCodec$1 } from "typebox/value";
+import { Clone as Clone$1, Create as Create$1, Decode as Decode$2, Default as Default$1, HasCodec as HasCodec$1 } from "typebox/value";
 
 //#region src/type/bridge.d.ts
 interface TypeboxModule {
   Compile: typeof Compile$1;
   Create: typeof Create$1;
-  Decode: typeof Decode$1;
+  Decode: typeof Decode$2;
   applyCoercions: typeof applyCoercions$1;
   TypeBoxValidator: TypeBoxValidator$1;
   TypeBoxValidatorCache: TypeBoxValidatorCache$1;
@@ -22,14 +22,14 @@ interface TypeboxModule {
   coerceBody: typeof coerceBody$1;
   hasTypes: typeof hasTypes$1;
   HasCodec: typeof HasCodec$1;
-  Intersect: typeof Intersect$1;
+  Intersect: typeof Intersect$2;
   Default: typeof Default$1;
   Ref: typeof Ref$1;
   Clone: typeof Clone$1;
 }
 declare let Compile: typeof Compile$1;
 declare let Create: typeof Create$1;
-declare let Decode: typeof Decode$1;
+declare let Decode: typeof Decode$2;
 declare let applyCoercions: typeof applyCoercions$1;
 declare let TypeBoxValidator: TypeBoxValidator$1;
 type TypeBoxValidator<T extends TSchema = TAny> = TypeBoxValidator$1<T>;
@@ -42,7 +42,7 @@ declare let coerceStringToStructure: typeof coerceStringToStructure$1;
 declare let coerceBody: typeof coerceBody$1;
 declare let hasTypes: typeof hasTypes$1;
 declare let HasCodec: typeof HasCodec$1;
-declare let Intersect: typeof Intersect$1;
+declare let Intersect: typeof Intersect$2;
 declare let Default: typeof Default$1;
 declare let Ref: typeof Ref$1;
 declare let Clone: typeof Clone$1;

package/dist/type/types.d.ts

@@ -1,9 +1,9 @@
 import { ELYSIA_TYPES } from "./constants.js";
 import { CookieOptions } from "../cookie/types.js";
 import { MaybeArray } from "../types.js";
+import { Validator } from "typebox/schema";
 import { TObjectOptions, TSchemaOptions } from "typebox";
 import { TLocalizedValidationError } from "typebox/error";
-import { Validator } from "typebox/schema";
 
 //#region src/type/types.d.ts
 type FileUnit = number | `${number}${'k' | 'm'}`;

package/dist/type/validator/index.d.ts

@@ -7,6 +7,8 @@ import { TLocalizedValidationError } from "typebox/error";
 
 //#region src/type/validator/index.d.ts
 declare function shallowMergeObjects(members: any[]): TSchema | null;
+declare const isAsyncPredicate: (v: unknown) => boolean;
+declare function externalsShape(schema: unknown): string;
 declare class TypeBoxValidator<const in out T extends TSchema = TAny> extends Validator$1 {
   #private;
   tb?: Validator;
@@ -28,4 +30,4 @@ declare class TypeBoxValidator<const in out T extends TSchema = TAny> extends Va
   FromSync(value: Static<T>, type?: string): Static<T>;
 }
 //#endregion
-export { TypeBoxValidator, TypeBoxValidatorCache, shallowMergeObjects };
+export { TypeBoxValidator, TypeBoxValidatorCache, externalsShape, isAsyncPredicate, shallowMergeObjects };

package/dist/type/validator/index.js

@@ -7,14 +7,11 @@ const require_compile_aot = require('../../compile/aot.js');
 const require_compile_utils = require('../../compile/utils.js');
 const require_validator_index = require('../../validator/index.js');
 const require_type_validator_clean_safe = require('./clean-safe.js');
-const require_compile_handler_frozen_validator = require('../../compile/handler/frozen-validator.js');
 const require_type_coerce = require('../coerce.js');
 const require_type_utils = require('../utils.js');
 const require_type_elysia_file_type = require('../elysia/file-type.js');
 const require_type_validator_default_precompute = require('./default-precompute.js');
-const require_type_validator_frozen_check = require('./frozen-check.js');
 const require_type_validator_custom_error = require('./custom-error.js');
-const require_type_validator_string_codec_aot = require('./string-codec-aot.js');
 const require_type_validator_validator_cache = require('./validator-cache.js');
 let typebox_type = require("typebox/type");
 let typebox_value = require("typebox/value");
@@ -90,16 +87,6 @@ function externalsShape(schema) {
 	for (const e of require_compile_aot.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;
-	} });
-}
 var TypeBoxValidator = class extends require_validator_index.Validator {
 	#decodeMirror;
 	#encodeMirror;
@@ -144,12 +131,24 @@ var TypeBoxValidator = class extends require_validator_index.Validator {
 		if (options?.normalize === false && options.slot !== "headers" && options.slot !== "cookie") this.schema = require_type_coerce.nonAdditionalProperties(this.schema);
 		if (!isFrozen) {
 			const capturing = require_compile_aot.Capture.isCapturing();
-			this.tb = capturing ? sourceOnlyValidator(this.schema) : (0, typebox_schema.Compile)(this.schema);
+			this.tb = capturing && require_compile_aot.captureImpl ? require_compile_aot.captureImpl.sourceOnlyValidator(this.schema) : (0, typebox_schema.Compile)(this.schema);
 			this.hasCodec = (0, typebox_value.HasCodec)(this.schema);
 			this.isAsync = this.tb.buildResult.external.variables.some(isAsyncPredicate) ?? false;
 			this.hasDefault = require_type_utils.hasProperty("default", this.schema);
-			if (capturing) this.#maybeCapture(options, schemaHasRef, schema);
-			else this.#dropCompiledSource();
+			if (capturing && require_compile_aot.captureImpl && options?.aot && options.slot) require_compile_aot.captureImpl.maybeCapture({
+				aot: options.aot,
+				slot: options.slot,
+				hasRef: schemaHasRef,
+				originalSchema: schema,
+				schema: this.schema,
+				hasCodec: this.hasCodec,
+				hasDefault: this.hasDefault,
+				coerces: options.coerces,
+				normalize: options.normalize,
+				sanitize: options.sanitize,
+				buildResult: this.tb.buildResult
+			});
+			else if (!capturing) this.#dropCompiledSource();
 		}
 		if (frozen?.ps === 1) {
 			const objectTemplate = frozen.pod !== void 0 ? Object.freeze(frozen.pod) : void 0;
@@ -201,18 +200,7 @@ var TypeBoxValidator = class extends require_validator_index.Validator {
 		if (this.hasCodec && !this.#isForm && !this.#noValidate && !options?.slot?.startsWith("r") && options?.normalize !== false && options?.normalize !== "typebox") this.#decodeMirror = this.#setupCodecMirror(this.schema, options, frozen, "decode");
 		if (this.hasCodec && !this.#isForm && !this.#noValidate && options?.slot?.startsWith("r") && options?.normalize !== false && options?.normalize !== "typebox") this.#encodeMirror = this.#setupCodecMirror(this.schema, options, frozen, "encode");
 		if (!this.#noValidate) this.#findCustomError = require_type_validator_custom_error.buildFindCustomError(this.schema, frozen);
-		if (options?.aot && options.slot && require_compile_aot.Capture.isCapturing()) {
-			const captured = require_compile_aot.Capture.get({
-				method: options.aot.method,
-				path: options.aot.path,
-				slot: options.slot
-			});
-			if (captured) require_compile_aot.Capture.set({
-				method: options.aot.method,
-				path: options.aot.path,
-				slot: options.slot
-			}, { bridgeFree: require_compile_handler_frozen_validator.isCapturedBridgeFree(captured, rawSchema, captured.coercePlan && typeof rawSchema !== "string" ? require_type_coerce.buildCoercedFromPlan(rawSchema, captured.coercePlan) : rawSchema) });
-		}
+		if (options?.aot && options.slot && require_compile_aot.Capture.isCapturing() && require_compile_aot.captureImpl) require_compile_aot.captureImpl.captureBridgeFree(options.aot, options.slot, rawSchema);
 	}
 	#error(value, type) {
 		return new require_error.ValidationError(type, value, () => this.Errors(value), this.schema, this.#findCustomError);
@@ -235,38 +223,7 @@ var TypeBoxValidator = class extends require_validator_index.Validator {
 				return clean(value);
 			};
 		}
-		if (aot && slot) {
-			if (require_compile_aot.Capture.isCapturing()) try {
-				const emitted = (0, exact_mirror.default)(schema, {
-					Compile: typebox_schema.Compile,
-					sanitize: options?.sanitize,
-					emit: true
-				});
-				if (typeof emitted?.source === "string") {
-					const ext = emitted.externals;
-					if (!ext) require_compile_aot.Capture.set({
-						method: aot.method,
-						path: aot.path,
-						slot
-					}, { mirror: {
-						source: emitted.source,
-						hasExternals: false
-					} });
-					else if (ext.unions && !ext.hof) {
-						const u = require_compile_aot.Capture.mirrorUnions(schema, ext.unions);
-						if (u) require_compile_aot.Capture.set({
-							method: aot.method,
-							path: aot.path,
-							slot
-						}, { mirror: {
-							source: emitted.source,
-							hasExternals: true,
-							u
-						} });
-					}
-				}
-			} catch {}
-		}
+		if (aot && slot && require_compile_aot.Capture.isCapturing() && require_compile_aot.captureImpl) require_compile_aot.captureImpl.captureMirror(schema, aot, slot, options?.sanitize);
 		return (0, exact_mirror.default)(schema, {
 			Compile: typebox_schema.Compile,
 			sanitize: options?.sanitize
@@ -296,37 +253,7 @@ var TypeBoxValidator = class extends require_validator_index.Validator {
 		}
 		const dirOpt = dir === "decode" ? { decode: true } : { encode: true };
 		const captureSlot = dir === "decode" ? !slot?.startsWith("response") : !!slot?.startsWith("response");
-		if (aot && slot && require_compile_aot.Capture.isCapturing() && captureSlot) try {
-			const emitted = (0, exact_mirror.default)(schema, {
-				Compile: typebox_schema.Compile,
-				sanitize: options?.sanitize,
-				...dirOpt,
-				emit: true
-			});
-			if (typeof emitted?.source === "string") {
-				const ext = emitted.externals;
-				if (ext?.codecs && !ext.hof && require_compile_aot.Capture.mirrorCodecs(schema, ext.codecs, dir)) {
-					let u;
-					let freezable = true;
-					if (ext.unions && ext.unions.length) {
-						u = require_compile_aot.Capture.mirrorUnions(schema, ext.unions);
-						if (!u) freezable = false;
-					}
-					if (freezable) {
-						const mirror = {
-							source: emitted.source,
-							hasExternals: true,
-							u
-						};
-						require_compile_aot.Capture.set({
-							method: aot.method,
-							path: aot.path,
-							slot
-						}, dir === "decode" ? { decodeMirror: mirror } : { encodeMirror: mirror });
-					}
-				}
-			}
-		} catch {}
+		if (aot && slot && require_compile_aot.Capture.isCapturing() && captureSlot && require_compile_aot.captureImpl) require_compile_aot.captureImpl.captureCodecMirror(schema, aot, slot, options?.sanitize, dir);
 		try {
 			return (0, exact_mirror.default)(schema, {
 				Compile: typebox_schema.Compile,
@@ -347,69 +274,6 @@ var TypeBoxValidator = class extends require_validator_index.Validator {
 		this.hasCodec = frozen.k === 1;
 		return true;
 	}
-	#maybeCapture(options, hasRef, originalSchema) {
-		const aot = options?.aot;
-		const slot = options?.slot;
-		if (!aot || !slot || !require_compile_aot.Capture.isCapturing()) return;
-		if (this.hasCodec && !hasRef && options.coerces && options.normalize !== false && options.normalize !== "typebox") {
-			const plan = require_type_coerce.captureCoercePlan(originalSchema, this.schema);
-			if (plan && externalsShape(require_type_coerce.buildCoercedFromPlan(originalSchema, plan)) === externalsShape(this.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 (this.hasDefault) {
-			const defaults = require_type_validator_default_precompute.verifyPreallocatableDefault(this.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(this.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(this.schema, options?.sanitize);
-		if (innerCodecs) require_compile_aot.Capture.set({
-			method: aot.method,
-			path: aot.path,
-			slot
-		}, { innerCodecs });
-		const build = this.tb.buildResult;
-		const cf = require_type_validator_frozen_check.buildFrozenCheck(build, this.schema);
-		if (!cf) return;
-		require_compile_aot.Capture.set({
-			method: aot.method,
-			path: aot.path,
-			slot
-		}, {
-			...cf,
-			async: build.external.variables.some(isAsyncPredicate),
-			hasDefault: this.hasDefault,
-			hasCodec: this.hasCodec,
-			hasRef
-		});
-	}
 	#dropCompiledSource() {
 		const tb = this.tb;
 		if (!tb) return;
@@ -572,4 +436,6 @@ var TypeBoxValidator = class extends require_validator_index.Validator {
 //#endregion
 exports.TypeBoxValidator = TypeBoxValidator;
 exports.TypeBoxValidatorCache = require_type_validator_validator_cache.TypeBoxValidatorCache;
+exports.externalsShape = externalsShape;
+exports.isAsyncPredicate = isAsyncPredicate;
 exports.shallowMergeObjects = shallowMergeObjects;

package/dist/type/validator/index.mjs

@@ -1,22 +1,19 @@
 import { nullObject } from "../../utils.mjs";
 import { ELYSIA_TYPES } from "../constants.mjs";
 import { ValidationError } from "../../error.mjs";
-import { Capture, Compiled, EMPTY_EXTERNALS, collectExternals, instantiateFrozenBoth, instantiateFrozenDecodeMirror, instantiateFrozenMirror, reconstructInnerCodecs } from "../../compile/aot.mjs";
+import { Capture, Compiled, EMPTY_EXTERNALS, captureImpl, collectExternals, instantiateFrozenBoth, instantiateFrozenDecodeMirror, instantiateFrozenMirror, reconstructInnerCodecs } from "../../compile/aot.mjs";
 import { isAsyncFunction } from "../../compile/utils.mjs";
 import { Validator as Validator$1 } from "../../validator/index.mjs";
 import { isFullyClosedObject, schemaContainsRef } from "./clean-safe.mjs";
-import { isCapturedBridgeFree } from "../../compile/handler/frozen-validator.mjs";
-import { applyCoercions, buildCoercedFromPlan, captureCoercePlan, nonAdditionalProperties } from "../coerce.mjs";
+import { applyCoercions, buildCoercedFromPlan, nonAdditionalProperties } from "../coerce.mjs";
 import { hasProperty } from "../utils.mjs";
 import { ASYNC_REFINE, collectFileTypeChecks, takeFileTypeChecks } from "../elysia/file-type.mjs";
-import { applyPrecomputed, buildDefaultClonerSource, buildObjectDefaultMergeSource, createDefaultCloner, createMergerFromSource, createObjectDefaultMerger, verifyPreallocatableDefault } from "./default-precompute.mjs";
-import { buildFrozenCheck } from "./frozen-check.mjs";
-import { buildFindCustomError, captureCustomErrors } from "./custom-error.mjs";
-import { captureStringCodecEntries } from "./string-codec-aot.mjs";
+import { applyPrecomputed, createDefaultCloner, createMergerFromSource, createObjectDefaultMerger, verifyPreallocatableDefault } from "./default-precompute.mjs";
+import { buildFindCustomError } from "./custom-error.mjs";
 import { TypeBoxValidatorCache } from "./validator-cache.mjs";
 import { Evaluate, Intersect, Module } from "typebox/type";
 import { Clean, Decode as Decode$1, DecodeUnsafe, Default, Encode, EncodeUnsafe, Errors, HasCodec } from "typebox/value";
-import { Build, Compile } from "typebox/schema";
+import { Compile } from "typebox/schema";
 import createMirror from "exact-mirror";
 
 //#region src/type/validator/index.ts
@@ -87,16 +84,6 @@ function externalsShape(schema) {
 	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;
-	} });
-}
 var TypeBoxValidator = class extends Validator$1 {
 	#decodeMirror;
 	#encodeMirror;
@@ -141,12 +128,24 @@ var TypeBoxValidator = class extends Validator$1 {
 		if (options?.normalize === false && options.slot !== "headers" && options.slot !== "cookie") this.schema = nonAdditionalProperties(this.schema);
 		if (!isFrozen) {
 			const capturing = Capture.isCapturing();
-			this.tb = capturing ? sourceOnlyValidator(this.schema) : Compile(this.schema);
+			this.tb = capturing && captureImpl ? captureImpl.sourceOnlyValidator(this.schema) : Compile(this.schema);
 			this.hasCodec = HasCodec(this.schema);
 			this.isAsync = this.tb.buildResult.external.variables.some(isAsyncPredicate) ?? false;
 			this.hasDefault = hasProperty("default", this.schema);
-			if (capturing) this.#maybeCapture(options, schemaHasRef, schema);
-			else this.#dropCompiledSource();
+			if (capturing && captureImpl && options?.aot && options.slot) captureImpl.maybeCapture({
+				aot: options.aot,
+				slot: options.slot,
+				hasRef: schemaHasRef,
+				originalSchema: schema,
+				schema: this.schema,
+				hasCodec: this.hasCodec,
+				hasDefault: this.hasDefault,
+				coerces: options.coerces,
+				normalize: options.normalize,
+				sanitize: options.sanitize,
+				buildResult: this.tb.buildResult
+			});
+			else if (!capturing) this.#dropCompiledSource();
 		}
 		if (frozen?.ps === 1) {
 			const objectTemplate = frozen.pod !== void 0 ? Object.freeze(frozen.pod) : void 0;
@@ -198,18 +197,7 @@ var TypeBoxValidator = class extends Validator$1 {
 		if (this.hasCodec && !this.#isForm && !this.#noValidate && !options?.slot?.startsWith("r") && options?.normalize !== false && options?.normalize !== "typebox") this.#decodeMirror = this.#setupCodecMirror(this.schema, options, frozen, "decode");
 		if (this.hasCodec && !this.#isForm && !this.#noValidate && options?.slot?.startsWith("r") && options?.normalize !== false && options?.normalize !== "typebox") this.#encodeMirror = this.#setupCodecMirror(this.schema, options, frozen, "encode");
 		if (!this.#noValidate) this.#findCustomError = buildFindCustomError(this.schema, frozen);
-		if (options?.aot && options.slot && Capture.isCapturing()) {
-			const captured = Capture.get({
-				method: options.aot.method,
-				path: options.aot.path,
-				slot: options.slot
-			});
-			if (captured) Capture.set({
-				method: options.aot.method,
-				path: options.aot.path,
-				slot: options.slot
-			}, { bridgeFree: isCapturedBridgeFree(captured, rawSchema, captured.coercePlan && typeof rawSchema !== "string" ? buildCoercedFromPlan(rawSchema, captured.coercePlan) : rawSchema) });
-		}
+		if (options?.aot && options.slot && Capture.isCapturing() && captureImpl) captureImpl.captureBridgeFree(options.aot, options.slot, rawSchema);
 	}
 	#error(value, type) {
 		return new ValidationError(type, value, () => this.Errors(value), this.schema, this.#findCustomError);
@@ -232,38 +220,7 @@ var TypeBoxValidator = class extends Validator$1 {
 				return clean(value);
 			};
 		}
-		if (aot && slot) {
-			if (Capture.isCapturing()) try {
-				const emitted = createMirror(schema, {
-					Compile,
-					sanitize: options?.sanitize,
-					emit: true
-				});
-				if (typeof emitted?.source === "string") {
-					const ext = emitted.externals;
-					if (!ext) Capture.set({
-						method: aot.method,
-						path: aot.path,
-						slot
-					}, { mirror: {
-						source: emitted.source,
-						hasExternals: false
-					} });
-					else if (ext.unions && !ext.hof) {
-						const u = Capture.mirrorUnions(schema, ext.unions);
-						if (u) Capture.set({
-							method: aot.method,
-							path: aot.path,
-							slot
-						}, { mirror: {
-							source: emitted.source,
-							hasExternals: true,
-							u
-						} });
-					}
-				}
-			} catch {}
-		}
+		if (aot && slot && Capture.isCapturing() && captureImpl) captureImpl.captureMirror(schema, aot, slot, options?.sanitize);
 		return createMirror(schema, {
 			Compile,
 			sanitize: options?.sanitize
@@ -293,37 +250,7 @@ var TypeBoxValidator = class extends Validator$1 {
 		}
 		const dirOpt = dir === "decode" ? { decode: true } : { encode: true };
 		const captureSlot = dir === "decode" ? !slot?.startsWith("response") : !!slot?.startsWith("response");
-		if (aot && slot && Capture.isCapturing() && captureSlot) try {
-			const emitted = createMirror(schema, {
-				Compile,
-				sanitize: options?.sanitize,
-				...dirOpt,
-				emit: true
-			});
-			if (typeof emitted?.source === "string") {
-				const ext = emitted.externals;
-				if (ext?.codecs && !ext.hof && Capture.mirrorCodecs(schema, ext.codecs, dir)) {
-					let u;
-					let freezable = true;
-					if (ext.unions && ext.unions.length) {
-						u = Capture.mirrorUnions(schema, ext.unions);
-						if (!u) freezable = false;
-					}
-					if (freezable) {
-						const mirror = {
-							source: emitted.source,
-							hasExternals: true,
-							u
-						};
-						Capture.set({
-							method: aot.method,
-							path: aot.path,
-							slot
-						}, dir === "decode" ? { decodeMirror: mirror } : { encodeMirror: mirror });
-					}
-				}
-			}
-		} catch {}
+		if (aot && slot && Capture.isCapturing() && captureSlot && captureImpl) captureImpl.captureCodecMirror(schema, aot, slot, options?.sanitize, dir);
 		try {
 			return createMirror(schema, {
 				Compile,
@@ -344,69 +271,6 @@ var TypeBoxValidator = class extends Validator$1 {
 		this.hasCodec = frozen.k === 1;
 		return true;
 	}
-	#maybeCapture(options, hasRef, originalSchema) {
-		const aot = options?.aot;
-		const slot = options?.slot;
-		if (!aot || !slot || !Capture.isCapturing()) return;
-		if (this.hasCodec && !hasRef && options.coerces && options.normalize !== false && options.normalize !== "typebox") {
-			const plan = captureCoercePlan(originalSchema, this.schema);
-			if (plan && externalsShape(buildCoercedFromPlan(originalSchema, plan)) === externalsShape(this.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 (this.hasDefault) {
-			const defaults = verifyPreallocatableDefault(this.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(this.schema);
-		if (customErrors) Capture.set({
-			method: aot.method,
-			path: aot.path,
-			slot
-		}, { customErrors });
-		const innerCodecs = captureStringCodecEntries(this.schema, options?.sanitize);
-		if (innerCodecs) Capture.set({
-			method: aot.method,
-			path: aot.path,
-			slot
-		}, { innerCodecs });
-		const build = this.tb.buildResult;
-		const cf = buildFrozenCheck(build, this.schema);
-		if (!cf) return;
-		Capture.set({
-			method: aot.method,
-			path: aot.path,
-			slot
-		}, {
-			...cf,
-			async: build.external.variables.some(isAsyncPredicate),
-			hasDefault: this.hasDefault,
-			hasCodec: this.hasCodec,
-			hasRef
-		});
-	}
 	#dropCompiledSource() {
 		const tb = this.tb;
 		if (!tb) return;
@@ -567,4 +431,4 @@ var TypeBoxValidator = class extends Validator$1 {
 };
 
 //#endregion
-export { TypeBoxValidator, TypeBoxValidatorCache, shallowMergeObjects };
+export { TypeBoxValidator, TypeBoxValidatorCache, externalsShape, isAsyncPredicate, shallowMergeObjects };

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "elysia",
 	"description": "Ergonomic Framework for Human",
-	"version": "2.0.0-exp.34",
+	"version": "2.0.0-exp.35",
 	"author": {
 		"name": "saltyAom",
 		"url": "https://github.com/SaltyAom",