elysia 2.0.0-beta.2 → 2.0.0-beta.3

package/dist/type/typebox-type.d.ts

@@ -0,0 +1,24 @@
+import * as _$typebox_type0 from "typebox/type";
+import { Codec as Codec$1, Decode as Decode$1, Evaluate as Evaluate$1, Intersect as Intersect$1, Module as Module$1, Null as Null$1, Ref as Ref$1, Refine as Refine$1, Undefined as Undefined$1, Unsafe as Unsafe$1 } from "typebox/type";
+import * as _$typebox_system0 from "typebox/system";
+
+//#region src/type/typebox-type.d.ts
+interface TypeboxTypeNamespaces {
+  type: typeof _$typebox_type0;
+  system: typeof _$typebox_system0;
+}
+declare const loadTypeNamespace: () => TypeboxTypeNamespaces;
+declare function ensureTypeSettings(): void;
+declare let Codec: typeof Codec$1;
+declare let Decode: typeof Decode$1;
+declare let Evaluate: typeof Evaluate$1;
+declare let Intersect: typeof Intersect$1;
+declare let Module: typeof Module$1;
+declare let Null: typeof Null$1;
+declare let Ref: typeof Ref$1;
+declare let Refine: typeof Refine$1;
+declare let Undefined: typeof Undefined$1;
+declare let Unsafe: typeof Unsafe$1;
+declare function injectTypeboxType(typebox: TypeboxTypeNamespaces): void;
+//#endregion
+export { Codec, Decode, Evaluate, Intersect, Module, Null, Ref, Refine, TypeboxTypeNamespaces, Undefined, Unsafe, ensureTypeSettings, injectTypeboxType, loadTypeNamespace };

package/dist/type/typebox-type.js

@@ -0,0 +1,130 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+//#region src/type/typebox-type.ts
+let namespaces;
+let settingsApplied = false;
+/**
+* Loads `typebox/type` + `typebox/system` on first use
+*
+* separate from `typebox-value` (type ⊂ value)
+* sharing one would make a single `t.Date()` drag the whole value graph in
+*/
+function load() {
+	if (namespaces) return namespaces;
+	injectTypeboxType(resolveNamespaces());
+	return namespaces;
+}
+function resolveNamespaces() {
+	const req = {}.require ?? globalThis.process?.getBuiltinModule?.("module")?.createRequire(require("url").pathToFileURL(__filename).href);
+	if (!req) throw new Error("TypeBox couldn't be loaded: this runtime has no synchronous module loader. Build with the AOT plugin ('elysia/plugin/aot') so TypeBox is wired statically, or register it manually with setupTypebox({ typebox: { type, system } }).");
+	return {
+		type: req("typebox/type"),
+		system: req("typebox/system")
+	};
+}
+function applySettings() {
+	if (settingsApplied || !namespaces) return;
+	settingsApplied = true;
+	namespaces.system.Settings.Set({ unionPrioritySort: false });
+}
+const loadTypeNamespace = () => namespaces ?? load();
+function ensureTypeSettings() {
+	if (settingsApplied) return;
+	loadTypeNamespace();
+	applySettings();
+}
+function stub(get) {
+	return function(...args) {
+		load();
+		return get()(...args);
+	};
+}
+let Codec = stub(() => Codec);
+let Decode = stub(() => Decode);
+let Evaluate = stub(() => Evaluate);
+let Intersect = stub(() => Intersect);
+let Module = stub(() => Module);
+let Null = stub(() => Null);
+let Ref = stub(() => Ref);
+let Refine = stub(() => Refine);
+let Undefined = stub(() => Undefined);
+let Unsafe = stub(() => Unsafe);
+function injectTypeboxType(typebox) {
+	namespaces = typebox;
+	Codec = typebox.type.Codec;
+	Decode = typebox.type.Decode;
+	Evaluate = typebox.type.Evaluate;
+	Intersect = typebox.type.Intersect;
+	Module = typebox.type.Module;
+	Null = typebox.type.Null;
+	Ref = typebox.type.Ref;
+	Refine = typebox.type.Refine;
+	Undefined = typebox.type.Undefined;
+	Unsafe = typebox.type.Unsafe;
+	applySettings();
+}
+
+//#endregion
+Object.defineProperty(exports, 'Codec', {
+  enumerable: true,
+  get: function () {
+    return Codec;
+  }
+});
+Object.defineProperty(exports, 'Decode', {
+  enumerable: true,
+  get: function () {
+    return Decode;
+  }
+});
+Object.defineProperty(exports, 'Evaluate', {
+  enumerable: true,
+  get: function () {
+    return Evaluate;
+  }
+});
+Object.defineProperty(exports, 'Intersect', {
+  enumerable: true,
+  get: function () {
+    return Intersect;
+  }
+});
+Object.defineProperty(exports, 'Module', {
+  enumerable: true,
+  get: function () {
+    return Module;
+  }
+});
+Object.defineProperty(exports, 'Null', {
+  enumerable: true,
+  get: function () {
+    return Null;
+  }
+});
+Object.defineProperty(exports, 'Ref', {
+  enumerable: true,
+  get: function () {
+    return Ref;
+  }
+});
+Object.defineProperty(exports, 'Refine', {
+  enumerable: true,
+  get: function () {
+    return Refine;
+  }
+});
+Object.defineProperty(exports, 'Undefined', {
+  enumerable: true,
+  get: function () {
+    return Undefined;
+  }
+});
+Object.defineProperty(exports, 'Unsafe', {
+  enumerable: true,
+  get: function () {
+    return Unsafe;
+  }
+});
+exports.ensureTypeSettings = ensureTypeSettings;
+exports.injectTypeboxType = injectTypeboxType;
+exports.loadTypeNamespace = loadTypeNamespace;

package/dist/type/typebox-type.mjs

@@ -0,0 +1,66 @@
+//#region src/type/typebox-type.ts
+let namespaces;
+let settingsApplied = false;
+/**
+* Loads `typebox/type` + `typebox/system` on first use
+*
+* separate from `typebox-value` (type ⊂ value)
+* sharing one would make a single `t.Date()` drag the whole value graph in
+*/
+function load() {
+	if (namespaces) return namespaces;
+	injectTypeboxType(resolveNamespaces());
+	return namespaces;
+}
+function resolveNamespaces() {
+	const req = import.meta.require ?? globalThis.process?.getBuiltinModule?.("module")?.createRequire(import.meta.url);
+	if (!req) throw new Error("TypeBox couldn't be loaded: this runtime has no synchronous module loader. Build with the AOT plugin ('elysia/plugin/aot') so TypeBox is wired statically, or register it manually with setupTypebox({ typebox: { type, system } }).");
+	return {
+		type: req("typebox/type"),
+		system: req("typebox/system")
+	};
+}
+function applySettings() {
+	if (settingsApplied || !namespaces) return;
+	settingsApplied = true;
+	namespaces.system.Settings.Set({ unionPrioritySort: false });
+}
+const loadTypeNamespace = () => namespaces ?? load();
+function ensureTypeSettings() {
+	if (settingsApplied) return;
+	loadTypeNamespace();
+	applySettings();
+}
+function stub(get) {
+	return function(...args) {
+		load();
+		return get()(...args);
+	};
+}
+let Codec = stub(() => Codec);
+let Decode = stub(() => Decode);
+let Evaluate = stub(() => Evaluate);
+let Intersect = stub(() => Intersect);
+let Module = stub(() => Module);
+let Null = stub(() => Null);
+let Ref = stub(() => Ref);
+let Refine = stub(() => Refine);
+let Undefined = stub(() => Undefined);
+let Unsafe = stub(() => Unsafe);
+function injectTypeboxType(typebox) {
+	namespaces = typebox;
+	Codec = typebox.type.Codec;
+	Decode = typebox.type.Decode;
+	Evaluate = typebox.type.Evaluate;
+	Intersect = typebox.type.Intersect;
+	Module = typebox.type.Module;
+	Null = typebox.type.Null;
+	Ref = typebox.type.Ref;
+	Refine = typebox.type.Refine;
+	Undefined = typebox.type.Undefined;
+	Unsafe = typebox.type.Unsafe;
+	applySettings();
+}
+
+//#endregion
+export { Codec, Decode, Evaluate, Intersect, Module, Null, Ref, Refine, Undefined, Unsafe, ensureTypeSettings, injectTypeboxType, loadTypeNamespace };

package/dist/type/typebox-value-live.d.ts

@@ -0,0 +1,9 @@
+import { TypeboxNamespaces } from "./typebox-value.js";
+import { Compile } from "typebox/compile";
+import { Check, Clean, Clone, Create, Decode, DecodeUnsafe, Default, Encode, EncodeUnsafe, Errors, HasCodec } from "typebox/value";
+import { Build, Compile as SchemaCompile } from "typebox/schema";
+
+//#region src/type/typebox-value-live.d.ts
+declare function injectTypebox(_typebox?: TypeboxNamespaces): void;
+//#endregion
+export { Build, Check, Clean, Clone, Compile, Create, Decode, DecodeUnsafe, Default, Encode, EncodeUnsafe, Errors, HasCodec, SchemaCompile, type TypeboxNamespaces, injectTypebox };

package/dist/type/typebox-value-live.js

@@ -0,0 +1,27 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../_virtual/_rolldown/runtime.js');
+let typebox_compile = require("typebox/compile");
+let typebox_value = require("typebox/value");
+let typebox_system = require("typebox/system");
+let typebox_schema = require("typebox/schema");
+
+//#region src/type/typebox-value-live.ts
+typebox_system.Settings.Set({ unionPrioritySort: false });
+function injectTypebox(_typebox) {}
+
+//#endregion
+exports.Build = typebox_schema.Build;
+exports.Check = typebox_value.Check;
+exports.Clean = typebox_value.Clean;
+exports.Clone = typebox_value.Clone;
+exports.Compile = typebox_compile.Compile;
+exports.Create = typebox_value.Create;
+exports.Decode = typebox_value.Decode;
+exports.DecodeUnsafe = typebox_value.DecodeUnsafe;
+exports.Default = typebox_value.Default;
+exports.Encode = typebox_value.Encode;
+exports.EncodeUnsafe = typebox_value.EncodeUnsafe;
+exports.Errors = typebox_value.Errors;
+exports.HasCodec = typebox_value.HasCodec;
+exports.SchemaCompile = typebox_schema.Compile;
+exports.injectTypebox = injectTypebox;

package/dist/type/typebox-value-live.mjs

@@ -0,0 +1,11 @@
+import { Compile } from "typebox/compile";
+import { Check, Clean, Clone, Create, Decode, DecodeUnsafe, Default, Encode, EncodeUnsafe, Errors, HasCodec } from "typebox/value";
+import { Settings } from "typebox/system";
+import { Build, Compile as SchemaCompile } from "typebox/schema";
+
+//#region src/type/typebox-value-live.ts
+Settings.Set({ unionPrioritySort: false });
+function injectTypebox(_typebox) {}
+
+//#endregion
+export { Build, Check, Clean, Clone, Compile, Create, Decode, DecodeUnsafe, Default, Encode, EncodeUnsafe, Errors, HasCodec, SchemaCompile, injectTypebox };

package/dist/type/typebox-value.d.ts

@@ -0,0 +1,30 @@
+import * as _$typebox_compile0 from "typebox/compile";
+import { Compile as Compile$1 } from "typebox/compile";
+import * as _$typebox_value0 from "typebox/value";
+import { Check as Check$1, Clean as Clean$1, Clone as Clone$1, Create as Create$1, Decode as Decode$1, DecodeUnsafe as DecodeUnsafe$1, Default as Default$1, Encode as Encode$1, EncodeUnsafe as EncodeUnsafe$1, Errors as Errors$1, HasCodec as HasCodec$1 } from "typebox/value";
+import * as _$typebox_schema0 from "typebox/schema";
+import { Build as Build$1, Compile as Compile$2 } from "typebox/schema";
+
+//#region src/type/typebox-value.d.ts
+interface TypeboxNamespaces {
+  value: typeof _$typebox_value0;
+  schema: typeof _$typebox_schema0;
+  compile: typeof _$typebox_compile0;
+}
+declare let Check: typeof Check$1;
+declare let Clean: typeof Clean$1;
+declare let Clone: typeof Clone$1;
+declare let Create: typeof Create$1;
+declare let Decode: typeof Decode$1;
+declare let DecodeUnsafe: typeof DecodeUnsafe$1;
+declare let Default: typeof Default$1;
+declare let Encode: typeof Encode$1;
+declare let EncodeUnsafe: typeof EncodeUnsafe$1;
+declare let Errors: typeof Errors$1;
+declare let HasCodec: typeof HasCodec$1;
+declare let SchemaCompile: typeof Compile$2;
+declare let Build: typeof Build$1;
+declare let Compile: typeof Compile$1;
+declare function injectTypebox(typebox: TypeboxNamespaces): void;
+//#endregion
+export { Build, Check, Clean, Clone, Compile, Create, Decode, DecodeUnsafe, Default, Encode, EncodeUnsafe, Errors, HasCodec, SchemaCompile, TypeboxNamespaces, injectTypebox };

package/dist/type/typebox-value.js

@@ -0,0 +1,147 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_type_typebox_type = require('./typebox-type.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.ensureTypeSettings();
+	injectTypebox(resolveNamespaces());
+}
+function resolveNamespaces() {
+	const req = {}.require ?? globalThis.process?.getBuiltinModule?.("module")?.createRequire(require("url").pathToFileURL(__filename).href);
+	if (!req) throw new Error("TypeBox couldn't be loaded: this runtime has no synchronous module loader. Build with the AOT plugin ('elysia/plugin/aot') so TypeBox is wired statically, or register it manually with setupTypebox({ typebox: { value, schema, compile, type, system } }). All five namespaces are required together — `value`/`schema`/`compile` alone still reaches the type leaf through `ensureTypeSettings()` and crashes the same way.");
+	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.ensureTypeSettings();
+	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;

package/dist/type/typebox-value.mjs

@@ -0,0 +1,62 @@
+import { ensureTypeSettings } from "./typebox-type.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;
+	ensureTypeSettings();
+	injectTypebox(resolveNamespaces());
+}
+function resolveNamespaces() {
+	const req = import.meta.require ?? globalThis.process?.getBuiltinModule?.("module")?.createRequire(import.meta.url);
+	if (!req) throw new Error("TypeBox couldn't be loaded: this runtime has no synchronous module loader. Build with the AOT plugin ('elysia/plugin/aot') so TypeBox is wired statically, or register it manually with setupTypebox({ typebox: { value, schema, compile, type, system } }). All five namespaces are required together — `value`/`schema`/`compile` alone still reaches the type leaf through `ensureTypeSettings()` and crashes the same way.");
+	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;
+	ensureTypeSettings();
+	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 };

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) {
@@ -85,7 +84,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;
@@ -107,7 +106,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 +175,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) {
@@ -83,7 +83,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;
@@ -105,7 +105,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.js

@@ -1,8 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_runtime = require('../../_virtual/_rolldown/runtime.js');
 const require_constants = require('../../constants.js');
 const require_utils = require('../../utils.js');
-let typebox_value = require("typebox/value");
+const require_type_typebox_value = require('../typebox-value.js');
 
 //#region src/type/validator/default-precompute.ts
 function isPrecomputeSafe(schema, depth = 0) {
@@ -291,7 +290,7 @@ function presentExpr(child, isObject, varName) {
 	return isObject ? `(${varName}!==null&&typeof ${varName}==='object'&&!Array.isArray(${varName})?${child}(${varName}):${varName})` : `(Array.isArray(${varName})?${child}(${varName}):${varName})`;
 }
 function mergeExpression(schema, varName, helpers, memo) {
-	const full = (0, typebox_value.Default)(schema, void 0);
+	const full = require_type_typebox_value.Default(schema, void 0);
 	const child = emitMerger(schema, helpers, memo);
 	if (child === void 0) return;
 	const absent = full === void 0 ? void 0 : cloneExpression(full);
@@ -393,8 +392,8 @@ function verifyPreallocatableDefault(schema, validate = true) {
 	let pd;
 	let podRaw;
 	try {
-		pd = (0, typebox_value.Default)(schema, void 0);
-		podRaw = (0, typebox_value.Default)(schema, require_utils.nullObject());
+		pd = require_type_typebox_value.Default(schema, void 0);
+		podRaw = require_type_typebox_value.Default(schema, require_utils.nullObject());
 	} catch {
 		return;
 	}

package/dist/type/validator/default-precompute.mjs

@@ -1,6 +1,6 @@
 import { dangerousKeys } from "../../constants.mjs";
 import { nullObject } from "../../utils.mjs";
-import { Default } from "typebox/value";
+import { Default } from "../typebox-value.mjs";
 
 //#region src/type/validator/default-precompute.ts
 function isPrecomputeSafe(schema, depth = 0) {