elysia 2.0.0-beta.2 → 2.0.0-beta.4

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 };

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 { Build, Compile as SchemaCompile } from "typebox/schema";
+import { Check, Clean, Clone, Create, Decode, DecodeUnsafe, Default, Encode, EncodeUnsafe, Errors, HasCodec } from "typebox/value";
+import { Compile } from "typebox/compile";
+
+//#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_schema = require("typebox/schema");
+let typebox_value = require("typebox/value");
+let typebox_compile = require("typebox/compile");
+let typebox_system = require("typebox/system");
+
+//#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 { Build, Compile as SchemaCompile } from "typebox/schema";
+import { Check, Clean, Clone, Create, Decode, DecodeUnsafe, Default, Encode, EncodeUnsafe, Errors, HasCodec } from "typebox/value";
+import { Compile } from "typebox/compile";
+import { Settings } from "typebox/system";
+
+//#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_schema0 from "typebox/schema";
+import { Build as Build$1, Compile as Compile$1 } from "typebox/schema";
+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_compile0 from "typebox/compile";
+import { Compile as Compile$2 } from "typebox/compile";
+
+//#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$1;
+declare let Build: typeof Build$1;
+declare let Compile: typeof Compile$2;
+declare function injectTypebox(typebox: TypeboxNamespaces): void;
+//#endregion
+export { Build, Check, Clean, Clone, Compile, Create, Decode, DecodeUnsafe, Default, Encode, EncodeUnsafe, Errors, HasCodec, SchemaCompile, TypeboxNamespaces, injectTypebox };