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

package/dist/type/elysia/number.mjs

@@ -1,9 +1,11 @@
 import { isEmpty } from "../../utils.mjs";
 import { noEnumerable } from "../constants.mjs";
-import { Number } from "typebox/type";
 
 //#region src/type/elysia/number.ts
-const emptyNumber = Object.freeze(Number());
+const emptyNumber = Object.freeze(Object.defineProperty({
+	type: "number",
+	"~kind": "Number"
+}, "~kind", noEnumerable));
 function NumberType(options) {
 	if (!options || isEmpty(options)) return emptyNumber;
 	const schema = {

package/dist/type/elysia/numeric-enum.js

@@ -1,11 +1,10 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_runtime = require('../../_virtual/_rolldown/runtime.js');
 const require_type_constants = require('../constants.js');
+const require_type_typebox_type = require('../typebox-type.js');
 const require_type_elysia_string = require('./string.js');
 const require_type_elysia_union = require('./union.js');
 const require_type_elysia_utils = require('./utils.js');
 const require_type_elysia_number = require('./number.js');
-let typebox_type = require("typebox/type");
 
 //#region src/type/elysia/numeric-enum.ts
 /**
@@ -14,7 +13,7 @@ let typebox_type = require("typebox/type");
 */
 function NumericEnum(item, property) {
 	const allowed = new Set(Object.values(item).filter((v) => typeof v === "number").map((v) => v));
-	const decoder = (0, typebox_type.Decode)((0, typebox_type.Refine)(require_type_elysia_union.Union([require_type_elysia_string.StringType({ format: "numeric" }), require_type_elysia_number.NumberType()], property), (value) => {
+	const decoder = require_type_typebox_type.Decode(require_type_typebox_type.Refine(require_type_elysia_union.Union([require_type_elysia_string.StringType({ format: "numeric" }), require_type_elysia_number.NumberType()], property), (value) => {
 		if (typeof value === "string" && value.trim() === "") return false;
 		const n = +value;
 		return !isNaN(n) && allowed.has(n);

package/dist/type/elysia/numeric-enum.mjs

@@ -1,9 +1,9 @@
 import { ELYSIA_TYPES } from "../constants.mjs";
+import { Decode, Refine } from "../typebox-type.mjs";
 import { StringType } from "./string.mjs";
 import { Union } from "./union.mjs";
 import { elyType } from "./utils.mjs";
 import { NumberType } from "./number.mjs";
-import { Decode, Refine } from "typebox/type";
 
 //#region src/type/elysia/numeric-enum.ts
 /**

package/dist/type/elysia/numeric.js

@@ -1,13 +1,12 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_runtime = require('../../_virtual/_rolldown/runtime.js');
 const require_utils = require('../../utils.js');
 const require_type_constants = require('../constants.js');
 const require_type_shared = require('../shared.js');
+const require_type_typebox_type = require('../typebox-type.js');
 const require_type_elysia_string = require('./string.js');
 const require_type_elysia_union = require('./union.js');
 const require_type_elysia_utils = require('./utils.js');
 const require_type_elysia_number = require('./number.js');
-let typebox_type = require("typebox/type");
 
 //#region src/type/elysia/numeric.ts
 function isDecimalString(value) {
@@ -33,7 +32,8 @@ function isDecimalString(value) {
 		}
 		if (!digits && !fractions) return false;
 	} else if (!digits) return false;
-	return index === length;
+	if (index !== length) return false;
+	return digits < 309 || Number.isFinite(+value);
 }
 let StringifiedNumber;
 let emptyNumeric;
@@ -46,11 +46,11 @@ function passesConstraints(n, c) {
 	return true;
 }
 function Numeric(property) {
-	StringifiedNumber ??= require_type_shared.pureRefine((0, typebox_type.Decode)((0, typebox_type.Refine)(require_type_elysia_string.StringType(), isDecimalString, () => "must be number"), (value) => +value));
+	StringifiedNumber ??= require_type_shared.pureRefine(require_type_typebox_type.Decode(require_type_typebox_type.Refine(require_type_elysia_string.StringType(), isDecimalString, () => "must be number"), (value) => +value));
 	if (!property || require_utils.isEmpty(property)) return emptyNumeric ??= Object.freeze(require_type_elysia_utils.elyType(require_type_constants.ELYSIA_TYPES.Numeric, require_type_elysia_union.Union([require_type_elysia_number.NumberType(), StringifiedNumber])));
 	const [constraints, meta] = require_type_elysia_utils.getMeta(property);
 	const number = require_type_elysia_number.NumberType(constraints);
-	const stringified = (0, typebox_type.Decode)((0, typebox_type.Refine)(require_type_elysia_string.StringType(), (value) => {
+	const stringified = require_type_typebox_type.Decode(require_type_typebox_type.Refine(require_type_elysia_string.StringType(), (value) => {
 		if (!isDecimalString(value)) return false;
 		return passesConstraints(+value, constraints);
 	}, () => "must be number"), (value) => +value);

package/dist/type/elysia/numeric.mjs

@@ -1,11 +1,11 @@
 import { isEmpty } from "../../utils.mjs";
 import { ELYSIA_TYPES } from "../constants.mjs";
 import { pureRefine } from "../shared.mjs";
+import { Decode, Refine } from "../typebox-type.mjs";
 import { StringType } from "./string.mjs";
 import { Union } from "./union.mjs";
 import { elyType, getMeta } from "./utils.mjs";
 import { NumberType } from "./number.mjs";
-import { Decode, Refine } from "typebox/type";
 
 //#region src/type/elysia/numeric.ts
 function isDecimalString(value) {
@@ -31,7 +31,8 @@ function isDecimalString(value) {
 		}
 		if (!digits && !fractions) return false;
 	} else if (!digits) return false;
-	return index === length;
+	if (index !== length) return false;
+	return digits < 309 || Number.isFinite(+value);
 }
 let StringifiedNumber;
 let emptyNumeric;

package/dist/type/elysia/object-string.js

@@ -1,13 +1,12 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_runtime = require('../../_virtual/_rolldown/runtime.js');
 const require_utils = require('../../utils.js');
 const require_type_bridge = require('../bridge.js');
 const require_type_constants = require('../constants.js');
+const require_type_typebox_type = require('../typebox-type.js');
 const require_type_elysia_string = require('./string.js');
 const require_type_elysia_union = require('./union.js');
 const require_type_elysia_utils = require('./utils.js');
 const require_type_elysia_object = require('./object.js');
-let typebox_type = require("typebox/type");
 
 //#region src/type/elysia/object-string.ts
 const MEMO_LIMIT = 8192;
@@ -17,7 +16,7 @@ function ObjectString(property, _options) {
 	let check;
 	let raw;
 	let parsed;
-	const objectString = (0, typebox_type.Decode)((0, typebox_type.Refine)(require_type_elysia_string.StringType(), (value) => {
+	const objectString = require_type_typebox_type.Decode(require_type_typebox_type.Refine(require_type_elysia_string.StringType(), (value) => {
 		if (value.charCodeAt(0) !== 123) return false;
 		if (value === raw) return true;
 		try {
@@ -30,13 +29,17 @@ function ObjectString(property, _options) {
 			} catch {
 				check = (v) => require_type_bridge.Check(object, v);
 			}
-			if (!check(next)) return false;
+			if (!check(next)) {
+				raw = parsed = void 0;
+				return false;
+			}
 			if (value.length <= MEMO_LIMIT) {
 				raw = value;
 				parsed = next;
 			}
 			return true;
 		} catch {
+			raw = parsed = void 0;
 			return false;
 		}
 	}, () => "must be an object"), (value) => {

package/dist/type/elysia/object-string.mjs

@@ -1,11 +1,11 @@
 import { nullObject } from "../../utils.mjs";
-import { Check, Compile, Decode as Decode$1 } from "../bridge.mjs";
+import { Check, Compile, Decode } from "../bridge.mjs";
 import { ELYSIA_TYPES } from "../constants.mjs";
+import { Decode as Decode$1, Refine } from "../typebox-type.mjs";
 import { StringType } from "./string.mjs";
 import { Union } from "./union.mjs";
 import { elyType, getMeta } from "./utils.mjs";
 import { ObjectType } from "./object.mjs";
-import { Decode, Refine } from "typebox/type";
 
 //#region src/type/elysia/object-string.ts
 const MEMO_LIMIT = 8192;
@@ -15,7 +15,7 @@ function ObjectString(property, _options) {
 	let check;
 	let raw;
 	let parsed;
-	const objectString = Decode(Refine(StringType(), (value) => {
+	const objectString = Decode$1(Refine(StringType(), (value) => {
 		if (value.charCodeAt(0) !== 123) return false;
 		if (value === raw) return true;
 		try {
@@ -28,20 +28,24 @@ function ObjectString(property, _options) {
 			} catch {
 				check = (v) => Check(object, v);
 			}
-			if (!check(next)) return false;
+			if (!check(next)) {
+				raw = parsed = void 0;
+				return false;
+			}
 			if (value.length <= MEMO_LIMIT) {
 				raw = value;
 				parsed = next;
 			}
 			return true;
 		} catch {
+			raw = parsed = void 0;
 			return false;
 		}
 	}, () => "must be an object"), (value) => {
 		const decoded = value === raw ? parsed : JSON.parse(value);
 		raw = void 0;
 		parsed = void 0;
-		return Decode$1(object, decoded);
+		return Decode(object, decoded);
 	});
 	return elyType(ELYSIA_TYPES.ObjectString, Union([object, objectString], meta));
 }

package/dist/type/elysia/string.js

@@ -1,12 +1,13 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_runtime = require('../../_virtual/_rolldown/runtime.js');
 const require_utils = require('../../utils.js');
 const require_type_constants = require('../constants.js');
 const require_type_shared = require('../shared.js');
-let typebox_type = require("typebox/type");
 
 //#region src/type/elysia/string.ts
-const emptyString = Object.freeze((0, typebox_type.String)());
+const emptyString = Object.freeze(Object.defineProperty({
+	type: "string",
+	"~kind": "String"
+}, "~kind", require_type_constants.noEnumerable));
 const stringFormatCache = /* @__PURE__ */ new Map();
 require_type_shared.referenceCache(stringFormatCache);
 function StringType(options) {

package/dist/type/elysia/string.mjs

@@ -1,10 +1,12 @@
 import { evictOldestHalf } from "../../utils.mjs";
 import { noEnumerable } from "../constants.mjs";
 import { SHARED_REFERENCE_CACHE_LIMIT, referenceCache } from "../shared.mjs";
-import { String } from "typebox/type";
 
 //#region src/type/elysia/string.ts
-const emptyString = Object.freeze(String());
+const emptyString = Object.freeze(Object.defineProperty({
+	type: "string",
+	"~kind": "String"
+}, "~kind", noEnumerable));
 const stringFormatCache = /* @__PURE__ */ new Map();
 referenceCache(stringFormatCache);
 function StringType(options) {

package/dist/type/elysia/uint8-array.js

@@ -1,15 +1,14 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_runtime = require('../../_virtual/_rolldown/runtime.js');
 const require_utils = require('../../utils.js');
 const require_type_constants = require('../constants.js');
+const require_type_typebox_type = require('../typebox-type.js');
 const require_type_elysia_utils = require('./utils.js');
-let typebox_type = require("typebox/type");
 
 //#region src/type/elysia/uint8-array.ts
 let BaseUint8Array;
 let emptyUint8Array;
 function Uint8ArrayType(property) {
-	BaseUint8Array ??= (0, typebox_type.Codec)((0, typebox_type.Refine)((0, typebox_type.Unsafe)({ "~kind": "Uint8Array" }), (value) => value instanceof Uint8Array || value instanceof ArrayBuffer, () => "must be Uint8Array")).Decode((value) => value instanceof Uint8Array ? value : new Uint8Array(value)).Encode((value) => value);
+	BaseUint8Array ??= require_type_typebox_type.Codec(require_type_typebox_type.Refine(require_type_typebox_type.Unsafe({ "~kind": "Uint8Array" }), (value) => value instanceof Uint8Array || value instanceof ArrayBuffer, () => "must be Uint8Array")).Decode((value) => value instanceof Uint8Array ? value : new Uint8Array(value)).Encode((value) => value);
 	if (!property || require_utils.isEmpty(property)) return emptyUint8Array ??= Object.freeze(require_type_elysia_utils.elyType(require_type_constants.ELYSIA_TYPES.Uint8Array, BaseUint8Array));
 	const refines = [[(value) => value instanceof Uint8Array || value instanceof ArrayBuffer, "must be Uint8Array"]];
 	if (property.minByteLength !== void 0) refines.push([(value) => value.byteLength >= property.minByteLength, `Expect byte to be more than ${property.minByteLength}`]);

package/dist/type/elysia/uint8-array.mjs

@@ -1,7 +1,7 @@
 import { isEmpty } from "../../utils.mjs";
 import { ELYSIA_TYPES } from "../constants.mjs";
+import { Codec, Refine, Unsafe } from "../typebox-type.mjs";
 import { Refines, cloneSchema, elyType, getMeta } from "./utils.mjs";
-import { Codec, Refine, Unsafe } from "typebox/type";
 
 //#region src/type/elysia/uint8-array.ts
 let BaseUint8Array;

package/dist/type/elysia/union-enum.js

@@ -1,8 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_runtime = require('../../_virtual/_rolldown/runtime.js');
 const require_type_constants = require('../constants.js');
+const require_type_typebox_type = require('../typebox-type.js');
 const require_type_elysia_utils = require('./utils.js');
-let typebox_type = require("typebox/type");
 
 //#region src/type/elysia/union-enum.ts
 let unionEnumNoEnumerable;
@@ -24,7 +23,7 @@ function UnionEnum(values, options) {
 		enumerable: false
 	});
 	if (!mixed) schema.type = kind;
-	return require_type_elysia_utils.elyType(require_type_constants.ELYSIA_TYPES.UnionEnum, (0, typebox_type.Unsafe)(schema));
+	return require_type_elysia_utils.elyType(require_type_constants.ELYSIA_TYPES.UnionEnum, require_type_typebox_type.Unsafe(schema));
 }
 
 //#endregion

package/dist/type/elysia/union-enum.mjs

@@ -1,6 +1,6 @@
 import { ELYSIA_TYPES } from "../constants.mjs";
+import { Unsafe } from "../typebox-type.mjs";
 import { elyType } from "./utils.mjs";
-import { Unsafe } from "typebox/type";
 
 //#region src/type/elysia/union-enum.ts
 let unionEnumNoEnumerable;

package/dist/type/elysia/utils.js

@@ -1,8 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_runtime = require('../../_virtual/_rolldown/runtime.js');
 const require_utils = require('../../utils.js');
 const require_type_shared = require('../shared.js');
-let typebox_type = require("typebox/type");
+const require_type_typebox_type = require('../typebox-type.js');
 
 //#region src/type/elysia/utils.ts
 function copyNonEnumerable(src, target, skipKey) {
@@ -82,7 +81,7 @@ function propertyChecksum(property) {
 	return [require_utils.fnv1a(JSON.stringify(entries))];
 }
 function Refines(schema, refines) {
-	for (const [refine, message] of refines) schema = (0, typebox_type.Refine)(schema, refine, () => message);
+	for (const [refine, message] of refines) schema = require_type_typebox_type.Refine(schema, refine, () => message);
 	return schema;
 }
 

package/dist/type/elysia/utils.mjs

@@ -1,6 +1,6 @@
 import { evictOldestHalf, fnv1a } from "../../utils.mjs";
 import { SHARED_REFERENCE_CACHE_LIMIT, clearSharedReferenceCaches, referenceCache } from "../shared.mjs";
-import { Refine } from "typebox/type";
+import { Refine } from "../typebox-type.mjs";
 
 //#region src/type/elysia/utils.ts
 function copyNonEnumerable(src, target, skipKey) {

package/dist/type/exports.js

@@ -1,4 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../_virtual/_rolldown/runtime.js');
+const require_type_typebox_type = require('./typebox-type.js');
 const require_type_elysia_array = require('./elysia/array.js');
 const require_type_elysia_string = require('./elysia/string.js');
 const require_type_elysia_union = require('./elysia/union.js');
@@ -27,8 +29,16 @@ const require_type_elysia_numeric_enum = require('./elysia/numeric-enum.js');
 const require_type_elysia_optional = require('./elysia/optional.js');
 const require_type_elysia_uint8_array = require('./elysia/uint8-array.js');
 const require_type_elysia_union_enum = require('./elysia/union-enum.js');
+let typebox_type = require("typebox/type");
+typebox_type = require_runtime.__toESM(typebox_type);
+let typebox_system = require("typebox/system");
+typebox_system = require_runtime.__toESM(typebox_system);
 
 //#region src/type/exports.ts
+require_type_typebox_type.injectTypeboxType({
+	type: typebox_type,
+	system: typebox_system
+});
 require_type_compat.setupTypebox();
 
 //#endregion
@@ -59,7 +69,6 @@ exports.String = require_type_elysia_string.StringType;
 exports.Uint8Array = require_type_elysia_uint8_array.Uint8ArrayType;
 exports.Union = require_type_elysia_union.Union;
 exports.UnionEnum = require_type_elysia_union_enum.UnionEnum;
-var typebox_type = require("typebox/type");
 Object.keys(typebox_type).forEach(function (k) {
   if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
     enumerable: true,

package/dist/type/exports.mjs

@@ -1,3 +1,4 @@
+import { injectTypeboxType } from "./typebox-type.mjs";
 import { ArrayType } from "./elysia/array.mjs";
 import { StringType } from "./elysia/string.mjs";
 import { Union } from "./elysia/union.mjs";
@@ -26,10 +27,16 @@ import { NumericEnum } from "./elysia/numeric-enum.mjs";
 import { Optional } from "./elysia/optional.mjs";
 import { Uint8ArrayType } from "./elysia/uint8-array.mjs";
 import { UnionEnum } from "./elysia/union-enum.mjs";
+import * as type from "typebox/type";
+import * as system from "typebox/system";
 
 export * from "typebox/type"
 
 //#region src/type/exports.ts
+injectTypeboxType({
+	type,
+	system
+});
 setupTypebox();
 
 //#endregion

package/dist/type/index.d.ts

@@ -4,10 +4,18 @@ import { exports_d_exports } from "./exports.js";
 import { setupTypebox } from "./compat.js";
 import { TypeBoxValidator } from "./validator/index.js";
 import * as TypeBoxType from "typebox/type";
-import { System as TypeSystem } from "typebox/system";
+import { System } from "typebox/system";
 
 //#region src/type/index.d.ts
 type TypeBuilder = Omit<typeof TypeBoxType, keyof typeof exports_d_exports> & typeof exports_d_exports;
 declare const t: TypeBuilder;
+/**
+ * `typebox/system` is a subgraph of `typebox/type`, so a static re-export here
+ * would pin ~231 KB of the deferral back into the eager graph. The proxy also
+ * guarantees Elysia's own `Settings` default lands BEFORE the namespace is
+ * handed out, keeping a user's explicit `TypeSystem.Settings.Set(...)` last —
+ * the ordering the eager `setupTypebox()` used to provide
+ */
+declare const TypeSystem: typeof System;
 //#endregion
 export { type AnySchema, type BaseSchema, type FileTypeDetector, type StandardJSONSchemaV1Like, type StandardSchemaV1Like, type TypeBoxSchema, TypeBoxValidator, TypeSystem, fileType, setFileTypeDetector, setupTypebox, t };

package/dist/type/index.js

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_runtime = require('../_virtual/_rolldown/runtime.js');
 const require_type_elysia_file_type = require('./elysia/file-type.js');
+const require_type_typebox_type = require('./typebox-type.js');
 const require_type_elysia_array = require('./elysia/array.js');
 const require_type_elysia_string = require('./elysia/string.js');
 const require_type_elysia_union = require('./elysia/union.js');
@@ -30,14 +30,39 @@ const require_type_elysia_numeric_enum = require('./elysia/numeric-enum.js');
 const require_type_elysia_optional = require('./elysia/optional.js');
 const require_type_elysia_uint8_array = require('./elysia/uint8-array.js');
 const require_type_elysia_union_enum = require('./elysia/union-enum.js');
-let typebox_type = require("typebox/type");
-typebox_type = require_runtime.__toESM(typebox_type);
-let typebox_system = require("typebox/system");
 
 //#region src/type/index.ts
 require_type_compat.setupTypebox();
-const t = {
-	...typebox_type,
+const hasOwn = (target, key) => Object.prototype.hasOwnProperty.call(target, key);
+/**
+* A namespace object that materializes `typebox/type` only when a key it does
+* not own is actually read
+*/
+const lazyNamespace = (resolve, overrides) => new Proxy(overrides, {
+	get: (target, key, receiver) => key in target ? Reflect.get(target, key, receiver) : resolve()[key],
+	has: (target, key) => key in target || key in resolve(),
+	ownKeys(target) {
+		const keys = Object.keys(resolve());
+		for (const key of Object.getOwnPropertyNames(target)) if (!keys.includes(key)) keys.push(key);
+		return keys;
+	},
+	getOwnPropertyDescriptor(target, key) {
+		if (hasOwn(target, key)) return Reflect.getOwnPropertyDescriptor(target, key);
+		const ns = resolve();
+		if (!hasOwn(ns, key)) return;
+		return {
+			value: ns[key],
+			enumerable: true,
+			writable: true,
+			configurable: true
+		};
+	},
+	preventExtensions: () => false,
+	set: (target, key, value) => Reflect.set(target, key, value),
+	defineProperty: (target, key, descriptor) => Reflect.defineProperty(target, key, descriptor),
+	deleteProperty: (target, key) => Reflect.deleteProperty(target, key)
+});
+const t = lazyNamespace(() => require_type_typebox_type.loadTypeNamespace().type, {
 	Accelerate: require_type_elysia_accelerate.Accelerate,
 	Array: require_type_elysia_array.ArrayType,
 	ArrayBuffer: require_type_elysia_array_buffer.ArrayBufferType,
@@ -65,16 +90,19 @@ const t = {
 	Uint8Array: require_type_elysia_uint8_array.Uint8ArrayType,
 	Union: require_type_elysia_union.Union,
 	UnionEnum: require_type_elysia_union_enum.UnionEnum
-};
+});
+/**
+* `typebox/system` is a subgraph of `typebox/type`, so a static re-export here
+* would pin ~231 KB of the deferral back into the eager graph. The proxy also
+* guarantees Elysia's own `Settings` default lands BEFORE the namespace is
+* handed out, keeping a user's explicit `TypeSystem.Settings.Set(...)` last —
+* the ordering the eager `setupTypebox()` used to provide
+*/
+const TypeSystem = lazyNamespace(() => require_type_typebox_type.loadTypeNamespace().system.System, Object.create(null));
 
 //#endregion
 exports.TypeBoxValidator = require_type_validator_index.TypeBoxValidator;
-Object.defineProperty(exports, 'TypeSystem', {
-  enumerable: true,
-  get: function () {
-    return typebox_system.System;
-  }
-});
+exports.TypeSystem = TypeSystem;
 exports.fileType = require_type_elysia_file_type.fileType;
 exports.setFileTypeDetector = require_type_elysia_file_type.setFileTypeDetector;
 exports.setupTypebox = require_type_compat.setupTypebox;

package/dist/type/index.mjs

@@ -1,4 +1,5 @@
 import { fileType, setFileTypeDetector } from "./elysia/file-type.mjs";
+import { loadTypeNamespace } from "./typebox-type.mjs";
 import { ArrayType } from "./elysia/array.mjs";
 import { StringType } from "./elysia/string.mjs";
 import { Union } from "./elysia/union.mjs";
@@ -9,11 +10,11 @@ import { NumberType } from "./elysia/number.mjs";
 import { Numeric } from "./elysia/numeric.mjs";
 import { BooleanType } from "./elysia/boolean.mjs";
 import { BooleanString } from "./elysia/boolean-string.mjs";
-import { Integer as Integer$1 } from "./elysia/integer.mjs";
+import { Integer } from "./elysia/integer.mjs";
 import { IntegerString } from "./elysia/integer-string.mjs";
 import { File } from "./elysia/file.mjs";
 import { TypeBoxValidator } from "./validator/index.mjs";
-import { Intersect as Intersect$1 } from "./elysia/intersect.mjs";
+import { Intersect } from "./elysia/intersect.mjs";
 import { setupTypebox } from "./compat.mjs";
 import { Accelerate } from "./elysia/accelerate.mjs";
 import { ArrayBufferType } from "./elysia/array-buffer.mjs";
@@ -28,13 +29,39 @@ import { NumericEnum } from "./elysia/numeric-enum.mjs";
 import { Optional } from "./elysia/optional.mjs";
 import { Uint8ArrayType } from "./elysia/uint8-array.mjs";
 import { UnionEnum } from "./elysia/union-enum.mjs";
-import * as TypeBox from "typebox/type";
-import { System as TypeSystem } from "typebox/system";
 
 //#region src/type/index.ts
 setupTypebox();
-const t = {
-	...TypeBox,
+const hasOwn = (target, key) => Object.prototype.hasOwnProperty.call(target, key);
+/**
+* A namespace object that materializes `typebox/type` only when a key it does
+* not own is actually read
+*/
+const lazyNamespace = (resolve, overrides) => new Proxy(overrides, {
+	get: (target, key, receiver) => key in target ? Reflect.get(target, key, receiver) : resolve()[key],
+	has: (target, key) => key in target || key in resolve(),
+	ownKeys(target) {
+		const keys = Object.keys(resolve());
+		for (const key of Object.getOwnPropertyNames(target)) if (!keys.includes(key)) keys.push(key);
+		return keys;
+	},
+	getOwnPropertyDescriptor(target, key) {
+		if (hasOwn(target, key)) return Reflect.getOwnPropertyDescriptor(target, key);
+		const ns = resolve();
+		if (!hasOwn(ns, key)) return;
+		return {
+			value: ns[key],
+			enumerable: true,
+			writable: true,
+			configurable: true
+		};
+	},
+	preventExtensions: () => false,
+	set: (target, key, value) => Reflect.set(target, key, value),
+	defineProperty: (target, key, descriptor) => Reflect.defineProperty(target, key, descriptor),
+	deleteProperty: (target, key) => Reflect.deleteProperty(target, key)
+});
+const t = lazyNamespace(() => loadTypeNamespace().type, {
 	Accelerate,
 	Array: ArrayType,
 	ArrayBuffer: ArrayBufferType,
@@ -46,8 +73,8 @@ const t = {
 	File,
 	Files,
 	Form,
-	Integer: Integer$1,
-	Intersect: Intersect$1,
+	Integer,
+	Intersect,
 	IntegerString,
 	MaybeEmpty,
 	NoValidate,
@@ -62,7 +89,15 @@ const t = {
 	Uint8Array: Uint8ArrayType,
 	Union,
 	UnionEnum
-};
+});
+/**
+* `typebox/system` is a subgraph of `typebox/type`, so a static re-export here
+* would pin ~231 KB of the deferral back into the eager graph. The proxy also
+* guarantees Elysia's own `Settings` default lands BEFORE the namespace is
+* handed out, keeping a user's explicit `TypeSystem.Settings.Set(...)` last —
+* the ordering the eager `setupTypebox()` used to provide
+*/
+const TypeSystem = lazyNamespace(() => loadTypeNamespace().system.System, Object.create(null));
 
 //#endregion
 export { TypeBoxValidator, TypeSystem, fileType, setFileTypeDetector, setupTypebox, t };

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

@@ -0,0 +1,9 @@
+import { TypeboxTypeNamespaces } from "./typebox-type.js";
+import { Codec, Decode, Evaluate, Intersect, Module, Null, Ref, Refine, Undefined, Unsafe } from "typebox/type";
+
+//#region src/type/typebox-type-live.d.ts
+declare function injectTypeboxType(_typebox?: TypeboxTypeNamespaces): void;
+declare function ensureTypeSettings(): void;
+declare const loadTypeNamespace: () => TypeboxTypeNamespaces;
+//#endregion
+export { Codec, Decode, Evaluate, Intersect, Module, Null, Ref, Refine, type TypeboxTypeNamespaces, Undefined, Unsafe, ensureTypeSettings, injectTypeboxType, loadTypeNamespace };

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

@@ -0,0 +1,31 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../_virtual/_rolldown/runtime.js');
+let typebox_type = require("typebox/type");
+typebox_type = require_runtime.__toESM(typebox_type);
+let typebox_system = require("typebox/system");
+typebox_system = require_runtime.__toESM(typebox_system);
+
+//#region src/type/typebox-type-live.ts
+typebox_system.Settings.Set({ unionPrioritySort: false });
+const namespaces = {
+	type: typebox_type,
+	system: typebox_system
+};
+function injectTypeboxType(_typebox) {}
+function ensureTypeSettings() {}
+const loadTypeNamespace = () => namespaces;
+
+//#endregion
+exports.Codec = typebox_type.Codec;
+exports.Decode = typebox_type.Decode;
+exports.Evaluate = typebox_type.Evaluate;
+exports.Intersect = typebox_type.Intersect;
+exports.Module = typebox_type.Module;
+exports.Null = typebox_type.Null;
+exports.Ref = typebox_type.Ref;
+exports.Refine = typebox_type.Refine;
+exports.Undefined = typebox_type.Undefined;
+exports.Unsafe = typebox_type.Unsafe;
+exports.ensureTypeSettings = ensureTypeSettings;
+exports.injectTypeboxType = injectTypeboxType;
+exports.loadTypeNamespace = loadTypeNamespace;

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

@@ -0,0 +1,16 @@
+import * as type from "typebox/type";
+import { Codec, Decode, Evaluate, Intersect, Module, Null, Ref, Refine, Undefined, Unsafe } from "typebox/type";
+import * as system from "typebox/system";
+
+//#region src/type/typebox-type-live.ts
+system.Settings.Set({ unionPrioritySort: false });
+const namespaces = {
+	type,
+	system
+};
+function injectTypeboxType(_typebox) {}
+function ensureTypeSettings() {}
+const loadTypeNamespace = () => namespaces;
+
+//#endregion
+export { Codec, Decode, Evaluate, Intersect, Module, Null, Ref, Refine, Undefined, Unsafe, ensureTypeSettings, injectTypeboxType, loadTypeNamespace };