elysia 2.0.0-beta.2 → 2.0.0-beta.20

package/dist/type/typebox-value.js

@@ -0,0 +1,161 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_type_sync_require = require('./sync-require.js');
+const require_type_typebox_type = require('./typebox-type.js');
+const require_type_typebox_value_require = require('./typebox-value-require.js');
+
+//#region src/type/typebox-value.ts
+let loaded = false;
+/**
+* Loads `typebox/value` + `typebox/schema` + `typebox/compile` on first use
+*/
+function load() {
+	if (loaded) return;
+	require_type_typebox_type.loadTypeNamespace();
+	injectTypebox(resolveNamespaces());
+}
+function preloadTypebox() {
+	if (loaded || !require_type_typebox_type.isTypeUsed()) return;
+	return require_type_typebox_value_require.importTypebox()?.then(([typeSide, valueSide]) => {
+		if (loaded) return;
+		if (!require_type_typebox_type.isTypeNamespaceLoaded()) require_type_typebox_type.injectTypeboxType(typeSide);
+		injectTypebox(valueSide);
+	}, () => {});
+}
+function resolveNamespaces() {
+	const bundled = require_type_typebox_value_require.requireTypebox();
+	if (bundled) return bundled;
+	const req = require_type_sync_require.syncRequire({}, require("url").pathToFileURL(__filename).href);
+	if (!req) throw new Error("TypeBox couldn't be loaded: runtime has no synchronous module loader. Try building with the AOT plugin or register it with setupTypebox()");
+	return {
+		value: req("typebox/value"),
+		schema: req("typebox/schema"),
+		compile: req("typebox/compile")
+	};
+}
+function stub(get) {
+	return function(...args) {
+		load();
+		return get()(...args);
+	};
+}
+let Check = stub(() => Check);
+let Clean = stub(() => Clean);
+let Clone = stub(() => Clone);
+let Create = stub(() => Create);
+let Decode = stub(() => Decode);
+let DecodeUnsafe = stub(() => DecodeUnsafe);
+let Default = stub(() => Default);
+let Encode = stub(() => Encode);
+let EncodeUnsafe = stub(() => EncodeUnsafe);
+let Errors = stub(() => Errors);
+let HasCodec = stub(() => HasCodec);
+let SchemaCompile = stub(() => SchemaCompile);
+let Build = stub(() => Build);
+let Compile = stub(() => Compile);
+function injectTypebox(typebox) {
+	loaded = true;
+	require_type_typebox_type.loadTypeNamespace();
+	Check = typebox.value.Check;
+	Clean = typebox.value.Clean;
+	Clone = typebox.value.Clone;
+	Create = typebox.value.Create;
+	Decode = typebox.value.Decode;
+	DecodeUnsafe = typebox.value.DecodeUnsafe;
+	Default = typebox.value.Default;
+	Encode = typebox.value.Encode;
+	EncodeUnsafe = typebox.value.EncodeUnsafe;
+	Errors = typebox.value.Errors;
+	HasCodec = typebox.value.HasCodec;
+	SchemaCompile = typebox.schema.Compile;
+	Build = typebox.schema.Build;
+	Compile = typebox.compile.Compile;
+}
+
+//#endregion
+Object.defineProperty(exports, 'Build', {
+  enumerable: true,
+  get: function () {
+    return Build;
+  }
+});
+Object.defineProperty(exports, 'Check', {
+  enumerable: true,
+  get: function () {
+    return Check;
+  }
+});
+Object.defineProperty(exports, 'Clean', {
+  enumerable: true,
+  get: function () {
+    return Clean;
+  }
+});
+Object.defineProperty(exports, 'Clone', {
+  enumerable: true,
+  get: function () {
+    return Clone;
+  }
+});
+Object.defineProperty(exports, 'Compile', {
+  enumerable: true,
+  get: function () {
+    return Compile;
+  }
+});
+Object.defineProperty(exports, 'Create', {
+  enumerable: true,
+  get: function () {
+    return Create;
+  }
+});
+Object.defineProperty(exports, 'Decode', {
+  enumerable: true,
+  get: function () {
+    return Decode;
+  }
+});
+Object.defineProperty(exports, 'DecodeUnsafe', {
+  enumerable: true,
+  get: function () {
+    return DecodeUnsafe;
+  }
+});
+Object.defineProperty(exports, 'Default', {
+  enumerable: true,
+  get: function () {
+    return Default;
+  }
+});
+Object.defineProperty(exports, 'Encode', {
+  enumerable: true,
+  get: function () {
+    return Encode;
+  }
+});
+Object.defineProperty(exports, 'EncodeUnsafe', {
+  enumerable: true,
+  get: function () {
+    return EncodeUnsafe;
+  }
+});
+Object.defineProperty(exports, 'Errors', {
+  enumerable: true,
+  get: function () {
+    return Errors;
+  }
+});
+Object.defineProperty(exports, 'HasCodec', {
+  enumerable: true,
+  get: function () {
+    return HasCodec;
+  }
+});
+Object.defineProperty(exports, 'SchemaCompile', {
+  enumerable: true,
+  get: function () {
+    return SchemaCompile;
+  }
+});
+exports.injectTypebox = injectTypebox;
+exports.preloadTypebox = preloadTypebox;
+exports.warmTypebox = load;

package/dist/type/typebox-value.mjs

@@ -0,0 +1,74 @@
+import { syncRequire } from "./sync-require.mjs";
+import { injectTypeboxType, isTypeNamespaceLoaded, isTypeUsed, loadTypeNamespace } from "./typebox-type.mjs";
+import { importTypebox, requireTypebox } from "./typebox-value-require.mjs";
+
+//#region src/type/typebox-value.ts
+let loaded = false;
+/**
+* Loads `typebox/value` + `typebox/schema` + `typebox/compile` on first use
+*/
+function load() {
+	if (loaded) return;
+	loadTypeNamespace();
+	injectTypebox(resolveNamespaces());
+}
+function preloadTypebox() {
+	if (loaded || !isTypeUsed()) return;
+	return importTypebox()?.then(([typeSide, valueSide]) => {
+		if (loaded) return;
+		if (!isTypeNamespaceLoaded()) injectTypeboxType(typeSide);
+		injectTypebox(valueSide);
+	}, () => {});
+}
+function resolveNamespaces() {
+	const bundled = requireTypebox();
+	if (bundled) return bundled;
+	const req = syncRequire(import.meta, import.meta.url);
+	if (!req) throw new Error("TypeBox couldn't be loaded: runtime has no synchronous module loader. Try building with the AOT plugin or register it with setupTypebox()");
+	return {
+		value: req("typebox/value"),
+		schema: req("typebox/schema"),
+		compile: req("typebox/compile")
+	};
+}
+function stub(get) {
+	return function(...args) {
+		load();
+		return get()(...args);
+	};
+}
+let Check = stub(() => Check);
+let Clean = stub(() => Clean);
+let Clone = stub(() => Clone);
+let Create = stub(() => Create);
+let Decode = stub(() => Decode);
+let DecodeUnsafe = stub(() => DecodeUnsafe);
+let Default = stub(() => Default);
+let Encode = stub(() => Encode);
+let EncodeUnsafe = stub(() => EncodeUnsafe);
+let Errors = stub(() => Errors);
+let HasCodec = stub(() => HasCodec);
+let SchemaCompile = stub(() => SchemaCompile);
+let Build = stub(() => Build);
+let Compile = stub(() => Compile);
+function injectTypebox(typebox) {
+	loaded = true;
+	loadTypeNamespace();
+	Check = typebox.value.Check;
+	Clean = typebox.value.Clean;
+	Clone = typebox.value.Clone;
+	Create = typebox.value.Create;
+	Decode = typebox.value.Decode;
+	DecodeUnsafe = typebox.value.DecodeUnsafe;
+	Default = typebox.value.Default;
+	Encode = typebox.value.Encode;
+	EncodeUnsafe = typebox.value.EncodeUnsafe;
+	Errors = typebox.value.Errors;
+	HasCodec = typebox.value.HasCodec;
+	SchemaCompile = typebox.schema.Compile;
+	Build = typebox.schema.Build;
+	Compile = typebox.compile.Compile;
+}
+
+//#endregion
+export { Build, Check, Clean, Clone, Compile, Create, Decode, DecodeUnsafe, Default, Encode, EncodeUnsafe, Errors, HasCodec, SchemaCompile, injectTypebox, preloadTypebox, load as warmTypebox };

package/dist/type/utils.js

@@ -5,18 +5,9 @@ const require_type_validator_clean_safe = require('./validator/clean-safe.js');
 //#region src/type/utils.ts
 const prunePrimitive = (node) => "~elyTyp" in node && require_type_constants.primitiveElysiaTypes.has(node["~elyTyp"]);
 const refTarget = (node) => node.$ref && node.$defs ? node.$defs[node.$ref] : void 0;
-const typeSets = /* @__PURE__ */ new WeakMap();
-function typeSetOf(types) {
-	let set = typeSets.get(types);
-	if (set === void 0) {
-		set = new Set(types);
-		typeSets.set(types, set);
-	}
-	return set;
-}
 function hasTypes(types, schema) {
 	if ("~standard" in schema) return false;
-	const set = typeSetOf(types);
+	const set = new Set(types);
 	const seen = /* @__PURE__ */ new WeakSet();
 	const wantsFiles = set.has(require_type_constants.ELYSIA_TYPES.Files);
 	const test = (node) => {

package/dist/type/utils.mjs

@@ -4,18 +4,9 @@ import { schemaSome } from "./validator/clean-safe.mjs";
 //#region src/type/utils.ts
 const prunePrimitive = (node) => "~elyTyp" in node && primitiveElysiaTypes.has(node["~elyTyp"]);
 const refTarget = (node) => node.$ref && node.$defs ? node.$defs[node.$ref] : void 0;
-const typeSets = /* @__PURE__ */ new WeakMap();
-function typeSetOf(types) {
-	let set = typeSets.get(types);
-	if (set === void 0) {
-		set = new Set(types);
-		typeSets.set(types, set);
-	}
-	return set;
-}
 function hasTypes(types, schema) {
 	if ("~standard" in schema) return false;
-	const set = typeSetOf(types);
+	const set = new Set(types);
 	const seen = /* @__PURE__ */ new WeakSet();
 	const wantsFiles = set.has(ELYSIA_TYPES.Files);
 	const test = (node) => {

package/dist/type/validator/clean-safe.d.ts

@@ -1,8 +1,6 @@
 //#region src/type/validator/clean-safe.d.ts
-declare function schemaSome(schema: any, test: (node: any) => boolean, seen?: WeakSet<object>, prune?: (node: any) => boolean): boolean;
+declare function schemaSome(schema: any, test: (node: any) => boolean, seen?: WeakSet<object>, prune?: (node: any) => boolean, conditional?: boolean): boolean;
 declare const schemaHasDangerousProperties: (schema: any) => boolean;
-declare const schemaContainsRef: (node: any, seen?: WeakSet<WeakKey>) => boolean;
-declare function isCleanSafeNode(node: any, visiting: WeakSet<object>, clean: WeakSet<object>): boolean;
 declare function isFullyClosedObject(schema: any): boolean;
 //#endregion
-export { isCleanSafeNode, isFullyClosedObject, schemaContainsRef, schemaHasDangerousProperties, schemaSome };
+export { isFullyClosedObject, schemaHasDangerousProperties, schemaSome };

package/dist/type/validator/clean-safe.js

@@ -2,19 +2,19 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_constants = require('../../constants.js');
 
 //#region src/type/validator/clean-safe.ts
-function schemaSome(schema, test, seen = /* @__PURE__ */ new WeakSet(), prune) {
+function schemaSome(schema, test, seen = /* @__PURE__ */ new WeakSet(), prune, conditional = false) {
 	if (!schema || typeof schema !== "object" || seen.has(schema)) return false;
 	seen.add(schema);
 	if (test(schema)) return true;
 	if (prune && prune(schema)) return false;
 	const props = schema.properties;
 	if (props) {
-		for (const k in props) if (Object.hasOwn(props, k) && schemaSome(props[k], test, seen, prune)) return true;
+		for (const k in props) if ((conditional || Object.hasOwn(props, k)) && schemaSome(props[k], test, seen, prune, conditional)) return true;
 	}
 	const items = schema.items;
 	if (Array.isArray(items)) {
-		for (const it of items) if (schemaSome(it, test, seen, prune)) return true;
-	} else if (items && schemaSome(items, test, seen, prune)) return true;
+		for (const it of items) if (schemaSome(it, test, seen, prune, conditional)) return true;
+	} else if (items && schemaSome(items, test, seen, prune, conditional)) return true;
 	for (const k of [
 		"anyOf",
 		"allOf",
@@ -22,14 +22,21 @@ function schemaSome(schema, test, seen = /* @__PURE__ */ new WeakSet(), prune) {
 	]) {
 		const arr = schema[k];
 		if (Array.isArray(arr)) {
-			for (const x of arr) if (schemaSome(x, test, seen, prune)) return true;
+			for (const x of arr) if (schemaSome(x, test, seen, prune, conditional)) return true;
 		}
 	}
-	if (schema.additionalProperties && typeof schema.additionalProperties === "object" && schemaSome(schema.additionalProperties, test, seen, prune)) return true;
-	if (schema.not && schemaSome(schema.not, test, seen, prune)) return true;
+	if (schema.additionalProperties && typeof schema.additionalProperties === "object" && schemaSome(schema.additionalProperties, test, seen, prune, conditional)) return true;
+	if (schema.not && schemaSome(schema.not, test, seen, prune, conditional)) return true;
+	if (conditional) {
+		for (const k of [
+			"if",
+			"then",
+			"else"
+		]) if (schema[k] && schemaSome(schema[k], test, seen, prune, true)) return true;
+	}
 	const pp = schema.patternProperties;
 	if (pp) {
-		for (const k in pp) if (schemaSome(pp[k], test, seen, prune)) return true;
+		for (const k in pp) if (schemaSome(pp[k], test, seen, prune, conditional)) return true;
 	}
 	return false;
 }
@@ -39,7 +46,6 @@ const schemaHasDangerousProperties = (schema) => schemaSome(schema, (node) => {
 	for (const key of require_constants.dangerousKeys) if (Object.hasOwn(properties, key)) return true;
 	return false;
 });
-const schemaContainsRef = (node, seen = /* @__PURE__ */ new WeakSet()) => schemaSome(node, (n) => !!n.$ref, seen);
 function isCleanSafeNode(node, visiting, clean) {
 	if (!node || typeof node !== "object") return true;
 	if (clean.has(node)) return true;
@@ -75,8 +81,6 @@ function isFullyClosedObject(schema) {
 }
 
 //#endregion
-exports.isCleanSafeNode = isCleanSafeNode;
 exports.isFullyClosedObject = isFullyClosedObject;
-exports.schemaContainsRef = schemaContainsRef;
 exports.schemaHasDangerousProperties = schemaHasDangerousProperties;
 exports.schemaSome = schemaSome;

package/dist/type/validator/clean-safe.mjs

@@ -1,19 +1,19 @@
 import { dangerousKeys } from "../../constants.mjs";
 
 //#region src/type/validator/clean-safe.ts
-function schemaSome(schema, test, seen = /* @__PURE__ */ new WeakSet(), prune) {
+function schemaSome(schema, test, seen = /* @__PURE__ */ new WeakSet(), prune, conditional = false) {
 	if (!schema || typeof schema !== "object" || seen.has(schema)) return false;
 	seen.add(schema);
 	if (test(schema)) return true;
 	if (prune && prune(schema)) return false;
 	const props = schema.properties;
 	if (props) {
-		for (const k in props) if (Object.hasOwn(props, k) && schemaSome(props[k], test, seen, prune)) return true;
+		for (const k in props) if ((conditional || Object.hasOwn(props, k)) && schemaSome(props[k], test, seen, prune, conditional)) return true;
 	}
 	const items = schema.items;
 	if (Array.isArray(items)) {
-		for (const it of items) if (schemaSome(it, test, seen, prune)) return true;
-	} else if (items && schemaSome(items, test, seen, prune)) return true;
+		for (const it of items) if (schemaSome(it, test, seen, prune, conditional)) return true;
+	} else if (items && schemaSome(items, test, seen, prune, conditional)) return true;
 	for (const k of [
 		"anyOf",
 		"allOf",
@@ -21,14 +21,21 @@ function schemaSome(schema, test, seen = /* @__PURE__ */ new WeakSet(), prune) {
 	]) {
 		const arr = schema[k];
 		if (Array.isArray(arr)) {
-			for (const x of arr) if (schemaSome(x, test, seen, prune)) return true;
+			for (const x of arr) if (schemaSome(x, test, seen, prune, conditional)) return true;
 		}
 	}
-	if (schema.additionalProperties && typeof schema.additionalProperties === "object" && schemaSome(schema.additionalProperties, test, seen, prune)) return true;
-	if (schema.not && schemaSome(schema.not, test, seen, prune)) return true;
+	if (schema.additionalProperties && typeof schema.additionalProperties === "object" && schemaSome(schema.additionalProperties, test, seen, prune, conditional)) return true;
+	if (schema.not && schemaSome(schema.not, test, seen, prune, conditional)) return true;
+	if (conditional) {
+		for (const k of [
+			"if",
+			"then",
+			"else"
+		]) if (schema[k] && schemaSome(schema[k], test, seen, prune, true)) return true;
+	}
 	const pp = schema.patternProperties;
 	if (pp) {
-		for (const k in pp) if (schemaSome(pp[k], test, seen, prune)) return true;
+		for (const k in pp) if (schemaSome(pp[k], test, seen, prune, conditional)) return true;
 	}
 	return false;
 }
@@ -38,7 +45,6 @@ const schemaHasDangerousProperties = (schema) => schemaSome(schema, (node) => {
 	for (const key of dangerousKeys) if (Object.hasOwn(properties, key)) return true;
 	return false;
 });
-const schemaContainsRef = (node, seen = /* @__PURE__ */ new WeakSet()) => schemaSome(node, (n) => !!n.$ref, seen);
 function isCleanSafeNode(node, visiting, clean) {
 	if (!node || typeof node !== "object") return true;
 	if (clean.has(node)) return true;
@@ -74,4 +80,4 @@ function isFullyClosedObject(schema) {
 }
 
 //#endregion
-export { isCleanSafeNode, isFullyClosedObject, schemaContainsRef, schemaHasDangerousProperties, schemaSome };
+export { isFullyClosedObject, schemaHasDangerousProperties, schemaSome };

package/dist/type/validator/custom-error.js

@@ -1,10 +1,9 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_runtime = require('../../_virtual/_rolldown/runtime.js');
 const require_utils = require('../../utils.js');
 const require_error = require('../../error.js');
 const require_compile_aot = require('../../compile/aot.js');
+const require_type_typebox_value = require('../typebox-value.js');
 const require_type_validator_frozen_check = require('./frozen-check.js');
-let typebox_schema = require("typebox/schema");
 
 //#region src/type/validator/custom-error.ts
 function encodePointer(segments) {
@@ -50,18 +49,17 @@ const literalOf = (propSchema) => {
 	if ("const" in propSchema) return { value: propSchema.const };
 	if (Array.isArray(propSchema.enum) && propSchema.enum.length === 1) return { value: propSchema.enum[0] };
 };
-function computeDiscriminators(branches) {
+const findDiscriminators = (branches) => {
 	let candidates;
 	for (const branch of branches) {
-		if (!branch || !branch.properties) return;
+		if (!branch?.properties) return null;
 		const keys = /* @__PURE__ */ new Set();
 		for (const k in branch.properties) if (literalOf(branch.properties[k])) keys.add(k);
-		if (!keys.size) return;
 		if (!candidates) candidates = keys;
 		else for (const c of [...candidates]) if (!keys.has(c)) candidates.delete(c);
-		if (!candidates.size) return;
+		if (!candidates.size) return null;
 	}
-	if (!candidates || !candidates.size) return;
+	if (!candidates) return null;
 	const perBranch = branches.map(require_utils.nullObject);
 	let hasDisambiguating = false;
 	for (const key of candidates) {
@@ -73,8 +71,8 @@ function computeDiscriminators(branches) {
 		}
 		if (new Set(seenValues).size === branches.length) hasDisambiguating = true;
 	}
-	return hasDisambiguating ? perBranch : void 0;
-}
+	return hasDisambiguating ? perBranch : null;
+};
 function buildFindCustomError(schema, frozen) {
 	const nodes = collectCustomErrorNodes(schema, [], [], /* @__PURE__ */ new WeakSet());
 	if (!nodes.length) return;
@@ -85,7 +83,7 @@ function buildFindCustomError(schema, frozen) {
 		const cached = unionCheckCache.get(node);
 		if (cached) return cached;
 		try {
-			const uc = (0, typebox_schema.Compile)(node);
+			const uc = require_type_typebox_value.SchemaCompile(node);
 			const fn = (v) => uc.Check(v);
 			unionCheckCache.set(node, fn);
 			return fn;
@@ -94,10 +92,8 @@ function buildFindCustomError(schema, frozen) {
 		}
 	};
 	const discriminatorsOf = (node, branches) => {
-		if (discriminatorCache.has(node)) return discriminatorCache.get(node) ?? void 0;
-		const d = computeDiscriminators(branches) ?? null;
-		discriminatorCache.set(node, d);
-		return d ?? void 0;
+		if (!discriminatorCache.has(node)) discriminatorCache.set(node, findDiscriminators(branches));
+		return discriminatorCache.get(node) ?? void 0;
 	};
 	const checks = [];
 	for (const { path, node, each, segments, union } of nodes) {
@@ -107,7 +103,7 @@ function buildFindCustomError(schema, frozen) {
 			check = fe.c(fe.e ? require_compile_aot.reconstruct().collectExternals(node) : require_compile_aot.EMPTY_EXTERNALS);
 		} catch {}
 		else try {
-			const c = (0, typebox_schema.Compile)(node);
+			const c = require_type_typebox_value.SchemaCompile(node);
 			check = (v) => c.Check(v);
 		} catch {}
 		if (!check) continue;
@@ -176,7 +172,7 @@ function captureCustomErrors(schema) {
 	for (const { path, node, union, each } of ceNodes) {
 		if (union || each) continue;
 		try {
-			const cf = require_type_validator_frozen_check.buildFrozenCheck((0, typebox_schema.Build)(node), node);
+			const cf = require_type_validator_frozen_check.buildFrozenCheck(require_type_typebox_value.Build(node), node);
 			if (cf) entries.push({
 				path,
 				...cf

package/dist/type/validator/custom-error.mjs

@@ -1,8 +1,8 @@
 import { nullObject } from "../../utils.mjs";
 import { subValueAt } from "../../error.mjs";
 import { EMPTY_EXTERNALS, reconstruct } from "../../compile/aot.mjs";
+import { Build, SchemaCompile } from "../typebox-value.mjs";
 import { buildFrozenCheck } from "./frozen-check.mjs";
-import { Build, Compile } from "typebox/schema";
 
 //#region src/type/validator/custom-error.ts
 function encodePointer(segments) {
@@ -48,18 +48,17 @@ const literalOf = (propSchema) => {
 	if ("const" in propSchema) return { value: propSchema.const };
 	if (Array.isArray(propSchema.enum) && propSchema.enum.length === 1) return { value: propSchema.enum[0] };
 };
-function computeDiscriminators(branches) {
+const findDiscriminators = (branches) => {
 	let candidates;
 	for (const branch of branches) {
-		if (!branch || !branch.properties) return;
+		if (!branch?.properties) return null;
 		const keys = /* @__PURE__ */ new Set();
 		for (const k in branch.properties) if (literalOf(branch.properties[k])) keys.add(k);
-		if (!keys.size) return;
 		if (!candidates) candidates = keys;
 		else for (const c of [...candidates]) if (!keys.has(c)) candidates.delete(c);
-		if (!candidates.size) return;
+		if (!candidates.size) return null;
 	}
-	if (!candidates || !candidates.size) return;
+	if (!candidates) return null;
 	const perBranch = branches.map(nullObject);
 	let hasDisambiguating = false;
 	for (const key of candidates) {
@@ -71,8 +70,8 @@ function computeDiscriminators(branches) {
 		}
 		if (new Set(seenValues).size === branches.length) hasDisambiguating = true;
 	}
-	return hasDisambiguating ? perBranch : void 0;
-}
+	return hasDisambiguating ? perBranch : null;
+};
 function buildFindCustomError(schema, frozen) {
 	const nodes = collectCustomErrorNodes(schema, [], [], /* @__PURE__ */ new WeakSet());
 	if (!nodes.length) return;
@@ -83,7 +82,7 @@ function buildFindCustomError(schema, frozen) {
 		const cached = unionCheckCache.get(node);
 		if (cached) return cached;
 		try {
-			const uc = Compile(node);
+			const uc = SchemaCompile(node);
 			const fn = (v) => uc.Check(v);
 			unionCheckCache.set(node, fn);
 			return fn;
@@ -92,10 +91,8 @@ function buildFindCustomError(schema, frozen) {
 		}
 	};
 	const discriminatorsOf = (node, branches) => {
-		if (discriminatorCache.has(node)) return discriminatorCache.get(node) ?? void 0;
-		const d = computeDiscriminators(branches) ?? null;
-		discriminatorCache.set(node, d);
-		return d ?? void 0;
+		if (!discriminatorCache.has(node)) discriminatorCache.set(node, findDiscriminators(branches));
+		return discriminatorCache.get(node) ?? void 0;
 	};
 	const checks = [];
 	for (const { path, node, each, segments, union } of nodes) {
@@ -105,7 +102,7 @@ function buildFindCustomError(schema, frozen) {
 			check = fe.c(fe.e ? reconstruct().collectExternals(node) : EMPTY_EXTERNALS);
 		} catch {}
 		else try {
-			const c = Compile(node);
+			const c = SchemaCompile(node);
 			check = (v) => c.Check(v);
 		} catch {}
 		if (!check) continue;

package/dist/type/validator/default-precompute.d.ts

@@ -7,6 +7,14 @@ declare function applyPrecomputed(defaults: Record<string, unknown>, value: Reco
 declare function isEmittable(v: unknown, seen: Set<unknown>, top?: boolean): boolean;
 declare function buildDefaultClonerSource(value: unknown): string | undefined;
 declare function buildObjectDefaultMergeSource(defaults: Record<string, unknown>): string | undefined;
+/**
+ * How many emitted default-precompute sources have failed to compile.
+ *
+ * Build-time only. A non-zero count means codegen emitted source that
+ * `Function()` rejected, so those routes silently fell back to the interpreted
+ * default path — always a bug in this module, never a user error.
+ */
+declare const precomputeCompileFailures: () => number;
 declare function createDefaultCloner(value: unknown): DefaultCloner | undefined;
 declare function createObjectDefaultMerger(defaults: Record<string, unknown>): ObjectDefaultMerger | undefined;
 declare function createMergerFromSource(source: string): ((value: any) => any) | undefined;
@@ -23,4 +31,4 @@ declare function verifyPreallocatableDefault(schema: TSchema, validate?: boolean
   ms: string | undefined;
 } | undefined;
 //#endregion
-export { DefaultProbeImpl, applyPrecomputed, buildDefaultClonerSource, buildObjectDefaultMergeSource, canonical, createDefaultCloner, createMergerFromSource, createObjectDefaultMerger, isEmittable, setDefaultProbeImpl, verifyPreallocatableDefault };
+export { DefaultProbeImpl, applyPrecomputed, buildDefaultClonerSource, buildObjectDefaultMergeSource, canonical, createDefaultCloner, createMergerFromSource, createObjectDefaultMerger, isEmittable, precomputeCompileFailures, setDefaultProbeImpl, verifyPreallocatableDefault };