elysia 2.0.0-exp.2 → 2.0.0-exp.21

package/dist/type/validator/index.mjs

@@ -0,0 +1,567 @@
+import { nullObject } from "../../utils.mjs";
+import { ValidationError } from "../../error.mjs";
+import { Capture, Compiled, EMPTY_EXTERNALS, collectExternals, instantiateFrozenBoth, instantiateFrozenDecodeMirror, instantiateFrozenMirror } from "../../compile/aot.mjs";
+import { Validator as Validator$1 } from "../../validator/index.mjs";
+import { ELYSIA_TYPES } from "../constants.mjs";
+import { isAsyncFunction } from "../../compile/utils.mjs";
+import { applyCoercions, buildCoercedFromPlan, captureCoercePlan, 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, reconstructInnerCodecs } from "./string-codec-aot.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 createMirror from "exact-mirror";
+
+//#region src/type/validator/index.ts
+const moduleCache = /* @__PURE__ */ new WeakMap();
+function schemaContainsRef(node, seen = /* @__PURE__ */ new WeakSet()) {
+	if (!node || typeof node !== "object" || seen.has(node)) return false;
+	seen.add(node);
+	if (node.$ref) return true;
+	const props = node.properties;
+	if (props) {
+		for (const k in props) if (schemaContainsRef(props[k], seen)) return true;
+	}
+	const items = node.items;
+	if (Array.isArray(items)) {
+		for (const it of items) if (schemaContainsRef(it, seen)) return true;
+	} else if (items && schemaContainsRef(items, seen)) return true;
+	for (const key of [
+		"anyOf",
+		"allOf",
+		"oneOf"
+	]) {
+		const arr = node[key];
+		if (Array.isArray(arr)) {
+			for (const x of arr) if (schemaContainsRef(x, seen)) return true;
+		}
+	}
+	if (node.additionalProperties && typeof node.additionalProperties === "object" && schemaContainsRef(node.additionalProperties, seen)) return true;
+	if (node.not && schemaContainsRef(node.not, seen)) return true;
+	const pp = node.patternProperties;
+	if (pp) {
+		for (const k in pp) if (schemaContainsRef(pp[k], seen)) return true;
+	}
+	return false;
+}
+function divergesFromEvaluate(node, seen) {
+	if (!node || typeof node !== "object" || seen.has(node)) return false;
+	seen.add(node);
+	for (const k in node) {
+		if (!Object.hasOwn(node, k)) return true;
+		const v = node[k];
+		if (typeof v === "object" && v && divergesFromEvaluate(v, seen)) return true;
+	}
+	return false;
+}
+const SIMPLE_OBJECT_KEYS = new Set([
+	"type",
+	"properties",
+	"required"
+]);
+function shallowMergeObjects(members) {
+	const properties = {};
+	let required;
+	for (const m of members) {
+		if (!m || m["~kind"] !== "Object" || m["~elyTyp"] !== void 0 || !m.properties || divergesFromEvaluate(m, /* @__PURE__ */ new WeakSet())) return null;
+		for (const k of Object.keys(m)) if (!SIMPLE_OBJECT_KEYS.has(k)) return null;
+		for (const k in m.properties) {
+			if (k in properties) return null;
+			properties[k] = m.properties[k];
+		}
+		if (Array.isArray(m.required) && m.required.length) (required ??= []).push(...m.required);
+	}
+	const out = {
+		type: "object",
+		properties
+	};
+	if (required) out.required = required;
+	return Object.defineProperty(out, "~kind", {
+		value: "Object",
+		enumerable: false
+	});
+}
+let inlineRefId = 0;
+const isAsyncPredicate = (v) => Array.isArray(v) ? v.some((x) => typeof x.check === "function" ? isAsyncFunction(x.check) || x.check["~elyAsyncRefine"] === true : false) : false;
+async function enforceFileTypeChecks(pending, type, value, schema) {
+	const results = await Promise.all(pending.map((x) => x.check));
+	for (let i = 0; i < results.length; i++) if (results[i] !== true) throw new ValidationError(type, value, [{
+		instancePath: findInstancePath(value, pending[i].file) ?? "",
+		message: results[i]
+	}], schema);
+}
+function findInstancePath(value, target, path = "") {
+	if (value === target) return path;
+	if (!value || typeof value !== "object") return;
+	if (Array.isArray(value)) {
+		for (let i = 0; i < value.length; i++) {
+			const found = findInstancePath(value[i], target, `${path}/${i}`);
+			if (found !== void 0) return found;
+		}
+		return;
+	}
+	for (const key in value) {
+		const found = findInstancePath(value[key], target, `${path}/${key}`);
+		if (found !== void 0) return found;
+	}
+}
+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;
+	} });
+}
+var TypeBoxValidator = class extends Validator$1 {
+	#decodeMirror;
+	#encodeMirror;
+	#findCustomError;
+	#defaultFastPath;
+	#noValidate;
+	#isForm;
+	#hasOptional;
+	constructor(schema, options, name, isIntersectable) {
+		super();
+		this.precomputeSafe = false;
+		this.#isForm = false;
+		this.#hasOptional = false;
+		if (isIntersectable) {
+			const members = [schema, ...options.schemas];
+			schema = shallowMergeObjects(members) ?? Evaluate(Intersect(members));
+		}
+		const originalElyTyp = schema?.["~elyTyp"];
+		const frozen = options?.aot && options.slot ? Compiled.getValidator(options.aot.method, options.aot.path, options.slot) : void 0;
+		let schemaHasRef = false;
+		if (name && options?.models) schema = moduleCache.getOrInsertComputed(options.models, () => Module(options.models))[name];
+		else if (options?.models && typeof name !== "string") {
+			schemaHasRef = frozen ? frozen.r === 1 : schemaContainsRef(schema);
+			if (schemaHasRef) {
+				const id = `inline@${++inlineRefId}`;
+				schema = Module({
+					...options.models,
+					[id]: schema
+				})[id];
+			}
+		}
+		const isFrozen = this.#reconstruct(options, frozen);
+		this.schema = isFrozen && frozen.cp ? buildCoercedFromPlan(schema, frozen.cp) : isFrozen && !this.hasCodec ? schema : applyCoercions(schema, options?.coerces);
+		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.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 (frozen?.ps === 1) {
+			const objectTemplate = frozen.pod !== void 0 ? Object.freeze(frozen.pod) : void 0;
+			this.precomputeSafe = true;
+			this.#defaultFastPath = {
+				value: frozen.pd,
+				appliesToNull: frozen.pn === 1,
+				objectTemplate,
+				clone: frozen.dc,
+				merge: frozen.pm
+			};
+		} else {
+			const defaults = this.hasDefault ? verifyPreallocatableDefault(this.schema, Capture.isCapturing()) : void 0;
+			if (defaults) {
+				this.precomputeSafe = true;
+				const objectTemplate = defaults.pod !== void 0 ? Object.freeze(defaults.pod) : void 0;
+				this.#defaultFastPath = {
+					value: defaults.pd,
+					appliesToNull: defaults.pn,
+					objectTemplate,
+					clone: defaults.pd !== void 0 ? createDefaultCloner(defaults.pd) : void 0,
+					merge: defaults.ms ? createMergerFromSource(defaults.ms) : objectTemplate !== void 0 ? createObjectDefaultMerger(objectTemplate) : void 0
+				};
+			} else {
+				this.precomputeSafe = false;
+				this.#defaultFastPath = void 0;
+			}
+		}
+		this.#noValidate = originalElyTyp === ELYSIA_TYPES.NoValidate;
+		this.#isForm = originalElyTyp === ELYSIA_TYPES.Form;
+		this.#hasOptional = !!this.schema?.["~optional"];
+		if (frozen?.ic) reconstructInnerCodecs(frozen.ic, this.schema);
+		if (isFrozen && frozen.cm) {
+			const both = instantiateFrozenBoth(frozen, this.schema, schema);
+			this.reconstructedCheck = both.check;
+			this.Clean = options?.normalize === false ? void 0 : both.clean;
+		} else {
+			if (isFrozen) this.reconstructedCheck = frozen.c(frozen.e ? collectExternals(this.schema) : EMPTY_EXTERNALS);
+			try {
+				this.Clean = options?.normalize === false ? void 0 : options?.normalize === "typebox" ? (value) => Clean(this.schema, value) : this.#setupMirror(schema, options, frozen);
+			} catch (error) {
+				console.warn("Failed to create exactMirror. Please report the following code to https://github.com/elysiajs/elysia/issues");
+				console.warn(schema);
+				console.warn(error);
+				if (options?.normalize !== false) this.Clean = (value) => Clean(this.schema, value);
+			}
+		}
+		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);
+	}
+	#error(value, type) {
+		return new ValidationError(type, value, () => this.Errors(value), this.schema, this.#findCustomError);
+	}
+	#setupMirror(schema, options, frozen) {
+		const aot = options?.aot;
+		const slot = options?.slot;
+		if (aot && slot && frozen?.m) {
+			const m = frozen.m;
+			let clean;
+			return (value) => {
+				if (clean === void 0) try {
+					clean = instantiateFrozenMirror(m, schema);
+				} catch (error) {
+					console.warn("Failed to create exactMirror. Please report the following code to https://github.com/elysiajs/elysia/issues");
+					console.warn(schema);
+					console.warn(error);
+					clean = (v) => v;
+				}
+				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 {}
+		}
+		return createMirror(schema, {
+			Compile,
+			sanitize: options?.sanitize
+		});
+	}
+	#setupCodecMirror(schema, options, frozen, dir) {
+		const aot = options?.aot;
+		const slot = options?.slot;
+		const frozenMirror = dir === "decode" ? frozen?.dm : frozen?.em;
+		if (aot && slot && frozenMirror) {
+			const m = frozenMirror;
+			let run;
+			return (value) => {
+				if (run === void 0) try {
+					run = instantiateFrozenDecodeMirror(m, schema, dir);
+				} catch {
+					run = dir === "decode" ? (v) => {
+						const decoded = DecodeUnsafe(nullObject(), schema, v);
+						return this.Clean ? this.Clean(decoded) : decoded;
+					} : (v) => {
+						const out = Encode(schema, v);
+						return this.Clean ? this.Clean(out) : out;
+					};
+				}
+				return run(value);
+			};
+		}
+		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 {}
+		try {
+			return createMirror(schema, {
+				Compile,
+				sanitize: options?.sanitize,
+				...dirOpt
+			});
+		} catch {}
+	}
+	Check(value) {
+		if (this.reconstructedCheck) return this.reconstructedCheck(value);
+		return this.tb.Check(value);
+	}
+	#reconstruct(options, frozen) {
+		if (!options?.aot || !options.slot || options.normalize === "typebox") return false;
+		if (!frozen?.c && !frozen?.cm) return false;
+		this.isAsync = frozen.a === 1;
+		this.hasDefault = frozen.d === 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;
+		if (tb.evaluateResult) tb.evaluateResult.code = void 0;
+		if (tb.buildResult) tb.buildResult.functions = void 0;
+	}
+	Errors(value) {
+		return Errors(this.schema, value);
+	}
+	Decode(value) {
+		return Decode$1(this.schema, value);
+	}
+	Encode(value) {
+		return this.hasCodec ? Encode(this.schema, value) : value;
+	}
+	EncodeFrom(value, type) {
+		if (this.#isForm) {
+			if (!this.#noValidate && !this.Check(value)) throw this.#error(value, type);
+			return value;
+		}
+		if (!this.hasCodec) {
+			if (!this.#noValidate && !this.Check(value)) throw this.#error(value, type);
+			if (this.Clean) value = this.Clean(value);
+			return value;
+		}
+		try {
+			if (this.#encodeMirror) {
+				const out = this.#encodeMirror(value);
+				if (!this.#noValidate && !this.Check(out)) throw new ValidationError(type, out, () => this.Errors(out), this.schema);
+				return out;
+			}
+			const out = this.#noValidate ? EncodeUnsafe(nullObject(), this.schema, value) : Encode(this.schema, value);
+			return this.Clean ? this.Clean(out) : out;
+		} catch (e) {
+			if (this.#noValidate) return this.Clean ? this.Clean(value) : value;
+			if (e instanceof ValidationError) throw e;
+			if (e?.error) throw e.error;
+			if (e?.status) throw e;
+			throw new ValidationError(type, value, () => this.Errors(value), this.schema);
+		}
+	}
+	#markForm(value) {
+		if (this.#isForm && value !== null && typeof value === "object" && !("~ely-form" in value)) Object.defineProperty(value, "~ely-form", {
+			value: 1,
+			configurable: true
+		});
+	}
+	#unmarkForm(value) {
+		if (this.#isForm && value !== null && typeof value === "object" && "~ely-form" in value && Object.getOwnPropertyDescriptor(value, "~ely-form")?.configurable) delete value["~ely-form"];
+	}
+	From(value, type) {
+		return this.isAsync ? this.FromAsync(value, type) : this.FromSync(value, type);
+	}
+	#cloneSharedDefault() {
+		const defaults = this.#defaultFastPath;
+		const value = defaults.value;
+		if (value === null || typeof value !== "object") return value;
+		return defaults.clone ? defaults.clone() : structuredClone(value);
+	}
+	#applyPrecomputedObjectDefault(value) {
+		const defaults = this.#defaultFastPath;
+		if (defaults.merge) return defaults.merge(value);
+		if (Array.isArray(value)) return value;
+		return applyPrecomputed(defaults.objectTemplate, value);
+	}
+	optionalBypass(value) {
+		const schema = this.schema;
+		if (!schema?.["~optional"]) return;
+		if (value === void 0 || value === null) return {
+			bypass: true,
+			value: schema["~kind"] === "Object" ? nullObject() : value
+		};
+		if (schema["~kind"] === "Object" && typeof value === "object" && !Array.isArray(value) && Object.keys(value).length === 0) return {
+			bypass: true,
+			value: nullObject()
+		};
+	}
+	async FromAsync(value, type) {
+		if (this.hasDefault) {
+			const defaults = this.#defaultFastPath;
+			if (defaults) {
+				if (value === void 0 || value === null && defaults.appliesToNull) value = this.#cloneSharedDefault();
+				else if (value !== null && typeof value === "object" && (defaults.merge !== void 0 || defaults.objectTemplate !== void 0)) value = this.#applyPrecomputedObjectDefault(value);
+			} else value = Default(this.schema, value);
+		}
+		if (this.#hasOptional) {
+			const bypass = this.optionalBypass(value);
+			if (bypass) return bypass.value;
+		}
+		if (this.#isForm) this.#markForm(value);
+		if (this.hasCodec) {
+			if (!this.#noValidate) {
+				collectFileTypeChecks();
+				const valid = this.Check(value);
+				const pendingFile = takeFileTypeChecks();
+				if (!valid) throw this.#error(value, type);
+				if (pendingFile) await enforceFileTypeChecks(pendingFile, type, value, this.schema);
+			}
+			if (this.#decodeMirror) value = this.#decodeMirror(value);
+			else try {
+				value = DecodeUnsafe(nullObject(), this.schema, value);
+			} catch (e) {
+				if (e instanceof ValidationError) throw e;
+				if (e?.error) throw e.error;
+				if (e?.status) throw e;
+				throw new ValidationError(type, value, () => this.Errors(value), this.schema);
+			}
+		} else if (!this.#noValidate) {
+			collectFileTypeChecks();
+			const valid = this.Check(value);
+			const pendingFile = takeFileTypeChecks();
+			if (!valid) throw this.#error(value, type);
+			if (pendingFile) await enforceFileTypeChecks(pendingFile, type, value, this.schema);
+		}
+		if (this.Clean && !this.#decodeMirror) value = this.Clean(value);
+		if (this.#isForm) this.#unmarkForm(value);
+		return value;
+	}
+	FromSync(value, type) {
+		if (this.hasDefault) {
+			const defaults = this.#defaultFastPath;
+			if (defaults) {
+				if (value === void 0 || value === null && defaults.appliesToNull) value = this.#cloneSharedDefault();
+				else if (value !== null && typeof value === "object" && (defaults.merge !== void 0 || defaults.objectTemplate !== void 0)) value = this.#applyPrecomputedObjectDefault(value);
+			} else value = Default(this.schema, value);
+		}
+		if (this.#hasOptional) {
+			const bypass = this.optionalBypass(value);
+			if (bypass) return bypass.value;
+		}
+		if (this.#isForm) this.#markForm(value);
+		if (this.hasCodec) {
+			if (!this.#noValidate && !this.Check(value)) throw this.#error(value, type);
+			if (this.#decodeMirror) value = this.#decodeMirror(value);
+			else try {
+				value = DecodeUnsafe(nullObject(), this.schema, value);
+			} catch (e) {
+				if (e instanceof ValidationError) throw e;
+				if (e?.error) throw e.error;
+				if (e?.status) throw e;
+				throw new ValidationError(type, value, () => this.Errors(value), this.schema);
+			}
+		} else if (!this.#noValidate && !this.Check(value)) throw this.#error(value, type);
+		if (this.Clean && !this.#decodeMirror) value = this.Clean(value);
+		if (this.#isForm) this.#unmarkForm(value);
+		return value;
+	}
+};
+
+//#endregion
+export { TypeBoxValidator, TypeBoxValidatorCache, shallowMergeObjects };

package/dist/type/validator/string-codec-aot.d.ts

@@ -0,0 +1,9 @@
+import { CapturedValidator, FrozenValidator } from "../../compile/aot.js";
+import { ValidatorOptions } from "../../validator/index.js";
+import { TSchema } from "typebox/type";
+
+//#region src/type/validator/string-codec-aot.d.ts
+declare function reconstructInnerCodecs(ic: NonNullable<FrozenValidator['ic']>, schema: any): void;
+declare function captureStringCodecEntries(schema: TSchema, sanitize: ValidatorOptions['sanitize']): CapturedValidator['innerCodecs'] | undefined;
+//#endregion
+export { captureStringCodecEntries, reconstructInnerCodecs };

package/dist/type/validator/string-codec-aot.js

@@ -0,0 +1,106 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../../_virtual/_rolldown/runtime.js');
+const require_compile_aot = require('../../compile/aot.js');
+const require_type_constants = require('../constants.js');
+const require_type_utils = require('../utils.js');
+const require_type_validator_frozen_check = require('./frozen-check.js');
+let typebox_schema = require("typebox/schema");
+let exact_mirror = require("exact-mirror");
+exact_mirror = require_runtime.__toESM(exact_mirror);
+
+//#region src/type/validator/string-codec-aot.ts
+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;
+}
+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 ? require_compile_aot.collectExternals(innerSchema) : []);
+		const innerMirror = entry.d.x ? require_compile_aot.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));
+	}
+}
+function captureInnerCodec(inner, open, sanitize) {
+	let cf;
+	try {
+		cf = require_type_validator_frozen_check.buildFrozenCheck((0, typebox_schema.Build)(inner), inner);
+		if (!cf) return;
+	} catch {
+		return;
+	}
+	let decode;
+	try {
+		const emitted = (0, exact_mirror.default)(inner, {
+			Compile: typebox_schema.Compile,
+			sanitize,
+			decode: true,
+			emit: true
+		});
+		if (typeof emitted?.source !== "string") return;
+		const ext = emitted.externals;
+		if (ext?.hof) return;
+		if (ext?.codecs && !require_compile_aot.Capture.mirrorCodecs(inner, ext.codecs)) return;
+		let u;
+		if (ext?.unions && ext.unions.length) {
+			u = require_compile_aot.Capture.mirrorUnions(inner, ext.unions);
+			if (!u) return;
+		}
+		decode = {
+			source: emitted.source,
+			hasExternals: !!(ext?.codecs || u),
+			u
+		};
+	} catch {
+		return;
+	}
+	if (require_type_utils.hasProperty("default", inner)) return;
+	return {
+		open,
+		...cf,
+		decode
+	};
+}
+function captureStringCodecEntries(schema, sanitize) {
+	const stringCodecs = collectStringCodecNodes(schema);
+	if (!stringCodecs.length) return;
+	const entries = [];
+	for (const { inner, open } of stringCodecs) {
+		const entry = captureInnerCodec(inner, open, sanitize);
+		if (!entry) break;
+		entries.push(entry);
+	}
+	return entries.length === stringCodecs.length ? entries : void 0;
+}
+
+//#endregion
+exports.captureStringCodecEntries = captureStringCodecEntries;
+exports.reconstructInnerCodecs = reconstructInnerCodecs;