elysia 2.0.0-beta.2 → 2.0.0-beta.21

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

@@ -1,49 +1,15 @@
 import { nullObject } from "../../utils.mjs";
-import { Check, Compile, Decode as Decode$1 } from "../bridge.mjs";
 import { ELYSIA_TYPES } from "../constants.mjs";
-import { StringType } from "./string.mjs";
+import { jsonString } from "./json-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;
 function ObjectString(property, _options) {
 	const [{ properties, ...constraints }, meta] = getMeta(_options ?? nullObject());
 	const object = ObjectType(property, constraints);
-	let check;
-	let raw;
-	let parsed;
-	const objectString = Decode(Refine(StringType(), (value) => {
-		if (value.charCodeAt(0) !== 123) return false;
-		if (value === raw) return true;
-		try {
-			const next = JSON.parse(value);
-			if (!check) try {
-				const compiled = Compile(object);
-				if (compiled.evaluateResult) compiled.evaluateResult.code = void 0;
-				if (compiled.buildResult) compiled.buildResult.functions = void 0;
-				check = (v) => compiled.Check(v);
-			} catch {
-				check = (v) => Check(object, v);
-			}
-			if (!check(next)) return false;
-			if (value.length <= MEMO_LIMIT) {
-				raw = value;
-				parsed = next;
-			}
-			return true;
-		} catch {
-			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 elyType(ELYSIA_TYPES.ObjectString, Union([object, objectString], meta));
+	return elyType(ELYSIA_TYPES.ObjectString, Union([object, jsonString(object, 123, "must be an object")], meta));
 }
 
 //#endregion

package/dist/type/elysia/object.js

@@ -2,7 +2,10 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_utils = require('../../utils.js');
 
 //#region src/type/elysia/object.ts
-let objectKind;
+const objectKind = {
+	value: "Object",
+	enumerable: false
+};
 let objectProto;
 function ObjectType(properties, options) {
 	const keys = Object.keys(properties);
@@ -19,20 +22,13 @@ function ObjectType(properties, options) {
 		}
 	}
 	if (!options || require_utils.isEmpty(options)) {
-		objectProto ??= Object.defineProperty({}, "~kind", {
-			value: "Object",
-			enumerable: false
-		});
+		objectProto ??= Object.defineProperty({}, "~kind", objectKind);
 		const schema = Object.create(objectProto);
 		schema.type = "object";
 		schema.properties = properties;
 		schema.required = required;
 		return schema;
 	}
-	objectKind ??= {
-		value: "Object",
-		enumerable: false
-	};
 	const schema = {
 		...options,
 		type: "object",

package/dist/type/elysia/object.mjs

@@ -1,7 +1,10 @@
 import { isEmpty } from "../../utils.mjs";
 
 //#region src/type/elysia/object.ts
-let objectKind;
+const objectKind = {
+	value: "Object",
+	enumerable: false
+};
 let objectProto;
 function ObjectType(properties, options) {
 	const keys = Object.keys(properties);
@@ -18,20 +21,13 @@ function ObjectType(properties, options) {
 		}
 	}
 	if (!options || isEmpty(options)) {
-		objectProto ??= Object.defineProperty({}, "~kind", {
-			value: "Object",
-			enumerable: false
-		});
+		objectProto ??= Object.defineProperty({}, "~kind", objectKind);
 		const schema = Object.create(objectProto);
 		schema.type = "object";
 		schema.properties = properties;
 		schema.required = required;
 		return schema;
 	}
-	objectKind ??= {
-		value: "Object",
-		enumerable: false
-	};
 	const schema = {
 		...options,
 		type: "object",

package/dist/type/elysia/optional.js

@@ -1,18 +1,18 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_type_elysia_utils = require('./utils.js');
+const require_type_shared = require('../shared.js');
 
 //#region src/type/elysia/optional.ts
-let optionalPropertyWithValue;
+const optionalTrue = {
+	value: true,
+	enumerable: false,
+	configurable: true
+};
 let OptionalShared;
 function Optional(schema) {
 	if (OptionalShared?.has(schema)) return OptionalShared.get(schema);
 	const result = Object.assign(Object.create(Object.getPrototypeOf(schema)), schema);
-	require_type_elysia_utils.copyNonEnumerable(schema, result);
-	Object.defineProperty(result, "~optional", optionalPropertyWithValue ??= {
-		value: true,
-		enumerable: false,
-		configurable: true
-	});
+	require_type_shared.copyNonEnumerable(schema, result);
+	Object.defineProperty(result, "~optional", optionalTrue);
 	OptionalShared ??= /* @__PURE__ */ new WeakMap();
 	OptionalShared.set(schema, result);
 	return result;

package/dist/type/elysia/optional.mjs

@@ -1,17 +1,17 @@
-import { copyNonEnumerable } from "./utils.mjs";
+import { copyNonEnumerable } from "../shared.mjs";
 
 //#region src/type/elysia/optional.ts
-let optionalPropertyWithValue;
+const optionalTrue = {
+	value: true,
+	enumerable: false,
+	configurable: true
+};
 let OptionalShared;
 function Optional(schema) {
 	if (OptionalShared?.has(schema)) return OptionalShared.get(schema);
 	const result = Object.assign(Object.create(Object.getPrototypeOf(schema)), schema);
 	copyNonEnumerable(schema, result);
-	Object.defineProperty(result, "~optional", optionalPropertyWithValue ??= {
-		value: true,
-		enumerable: false,
-		configurable: true
-	});
+	Object.defineProperty(result, "~optional", optionalTrue);
 	OptionalShared ??= /* @__PURE__ */ new WeakMap();
 	OptionalShared.set(schema, result);
 	return result;

package/dist/type/elysia/problem.d.ts

@@ -0,0 +1,20 @@
+import { TInteger, TObject, TObjectOptions, TOptional, TProperties, TString } from "typebox";
+
+//#region src/type/elysia/problem.d.ts
+interface TProblemBase {
+  type: TString;
+  code: TOptional<TString>;
+  title: TString;
+  status: TInteger;
+  detail: TOptional<TString>;
+  instance: TOptional<TString>;
+}
+/**
+ * RFC 9457 Problem Details schema. Extension members are spread last, so they
+ * may override a base member.
+ *
+ * @see https://www.rfc-editor.org/info/rfc9457
+ */
+declare const Problem: <T extends TProperties = {}>(extension?: T, options?: TObjectOptions) => TObject<Omit<TProblemBase, keyof T> & T>;
+//#endregion
+export { Problem };

package/dist/type/elysia/problem.js

@@ -0,0 +1,25 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_type_elysia_string = require('./string.js');
+const require_type_elysia_object = require('./object.js');
+const require_type_elysia_integer = require('./integer.js');
+const require_type_elysia_optional = require('./optional.js');
+
+//#region src/type/elysia/problem.ts
+/**
+* RFC 9457 Problem Details schema. Extension members are spread last, so they
+* may override a base member.
+*
+* @see https://www.rfc-editor.org/info/rfc9457
+*/
+const Problem = (extension, options) => require_type_elysia_object.ObjectType({
+	type: require_type_elysia_string.StringType(),
+	code: require_type_elysia_optional.Optional(require_type_elysia_string.StringType()),
+	title: require_type_elysia_string.StringType(),
+	status: require_type_elysia_integer.Integer(),
+	detail: require_type_elysia_optional.Optional(require_type_elysia_string.StringType()),
+	instance: require_type_elysia_optional.Optional(require_type_elysia_string.StringType()),
+	...extension
+}, options);
+
+//#endregion
+exports.Problem = Problem;

package/dist/type/elysia/problem.mjs

@@ -0,0 +1,24 @@
+import { StringType } from "./string.mjs";
+import { ObjectType } from "./object.mjs";
+import { Integer } from "./integer.mjs";
+import { Optional } from "./optional.mjs";
+
+//#region src/type/elysia/problem.ts
+/**
+* RFC 9457 Problem Details schema. Extension members are spread last, so they
+* may override a base member.
+*
+* @see https://www.rfc-editor.org/info/rfc9457
+*/
+const Problem = (extension, options) => ObjectType({
+	type: StringType(),
+	code: Optional(StringType()),
+	title: StringType(),
+	status: Integer(),
+	detail: Optional(StringType()),
+	instance: Optional(StringType()),
+	...extension
+}, options);
+
+//#endregion
+export { Problem };

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.d.ts

@@ -1,6 +1,6 @@
 import { ArrayBufferOptions } from "../types.js";
 
 //#region src/type/elysia/uint8-array.d.ts
-declare function Uint8ArrayType(property?: ArrayBufferOptions): any;
+declare const Uint8ArrayType: (property?: ArrayBufferOptions) => any;
 //#endregion
 export { Uint8ArrayType };

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

@@ -1,27 +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_elysia_utils = require('./utils.js');
-let typebox_type = require("typebox/type");
+const require_type_typebox_type = require('../typebox-type.js');
+const require_type_elysia_array_buffer = require('./array-buffer.js');
 
 //#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);
-	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}`]);
-	if (property.maxByteLength !== void 0) refines.push([(value) => value.byteLength <= property.maxByteLength, `Expect byte to be less than ${property.maxByteLength}`]);
-	let schema = require_type_elysia_utils.Refines(BaseUint8Array, refines);
-	const [, meta] = require_type_elysia_utils.getMeta(property);
-	if (meta) {
-		schema = require_type_elysia_utils.cloneSchema(schema);
-		Object.assign(schema, meta);
-	}
-	return require_type_elysia_utils.elyType(require_type_constants.ELYSIA_TYPES.Uint8Array, schema);
-}
+const isUint8Array = (value) => value instanceof Uint8Array || value instanceof ArrayBuffer;
+const uint8Array = /* @__PURE__ */ require_type_elysia_array_buffer.bufferType(require_type_constants.ELYSIA_TYPES.Uint8Array, () => require_type_typebox_type.Codec(require_type_typebox_type.Refine(require_type_typebox_type.Unsafe({ "~kind": "Uint8Array" }), isUint8Array, () => "must be Uint8Array")).Decode((value) => value instanceof Uint8Array ? value : new Uint8Array(value)).Encode((value) => value));
+const Uint8ArrayType = (property) => uint8Array(property);
 
 //#endregion
 exports.Uint8ArrayType = Uint8ArrayType;

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

@@ -1,25 +1,11 @@
-import { isEmpty } from "../../utils.mjs";
 import { ELYSIA_TYPES } from "../constants.mjs";
-import { Refines, cloneSchema, elyType, getMeta } from "./utils.mjs";
-import { Codec, Refine, Unsafe } from "typebox/type";
+import { Codec, Refine, Unsafe } from "../typebox-type.mjs";
+import { bufferType } from "./array-buffer.mjs";
 
 //#region src/type/elysia/uint8-array.ts
-let BaseUint8Array;
-let emptyUint8Array;
-function Uint8ArrayType(property) {
-	BaseUint8Array ??= Codec(Refine(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 || isEmpty(property)) return emptyUint8Array ??= Object.freeze(elyType(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}`]);
-	if (property.maxByteLength !== void 0) refines.push([(value) => value.byteLength <= property.maxByteLength, `Expect byte to be less than ${property.maxByteLength}`]);
-	let schema = Refines(BaseUint8Array, refines);
-	const [, meta] = getMeta(property);
-	if (meta) {
-		schema = cloneSchema(schema);
-		Object.assign(schema, meta);
-	}
-	return elyType(ELYSIA_TYPES.Uint8Array, schema);
-}
+const isUint8Array = (value) => value instanceof Uint8Array || value instanceof ArrayBuffer;
+const uint8Array = /* @__PURE__ */ bufferType(ELYSIA_TYPES.Uint8Array, () => Codec(Refine(Unsafe({ "~kind": "Uint8Array" }), isUint8Array, () => "must be Uint8Array")).Decode((value) => value instanceof Uint8Array ? value : new Uint8Array(value)).Encode((value) => value));
+const Uint8ArrayType = (property) => uint8Array(property);
 
 //#endregion
 export { Uint8ArrayType };

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

@@ -1,11 +1,13 @@
 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;
+const unionEnumKind = {
+	value: "UnionEnum",
+	enumerable: false
+};
 function UnionEnum(values, options) {
 	let kind;
 	let mixed = false;
@@ -19,12 +21,9 @@ function UnionEnum(values, options) {
 		default: values[0],
 		...options,
 		enum: values
-	}, "~kind", unionEnumNoEnumerable ??= {
-		value: "UnionEnum",
-		enumerable: false
-	});
+	}, "~kind", unionEnumKind);
 	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,9 +1,12 @@
 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;
+const unionEnumKind = {
+	value: "UnionEnum",
+	enumerable: false
+};
 function UnionEnum(values, options) {
 	let kind;
 	let mixed = false;
@@ -17,10 +20,7 @@ function UnionEnum(values, options) {
 		default: values[0],
 		...options,
 		enum: values
-	}, "~kind", unionEnumNoEnumerable ??= {
-		value: "UnionEnum",
-		enumerable: false
-	});
+	}, "~kind", unionEnumKind);
 	if (!mixed) schema.type = kind;
 	return elyType(ELYSIA_TYPES.UnionEnum, Unsafe(schema));
 }

package/dist/type/elysia/union.js

@@ -1,13 +1,8 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_utils = require('../../utils.js');
 const require_type_constants = require('../constants.js');
 
 //#region src/type/elysia/union.ts
 function Union(schemas, options) {
-	if (!options || require_utils.isEmpty(options)) return Object.defineProperty({
-		"~kind": "Union",
-		anyOf: schemas
-	}, "~kind", require_type_constants.noEnumerable);
 	const schema = {
 		...options,
 		"~kind": "Union",

package/dist/type/elysia/union.mjs

@@ -1,12 +1,7 @@
-import { isEmpty } from "../../utils.mjs";
 import { noEnumerable } from "../constants.mjs";
 
 //#region src/type/elysia/union.ts
 function Union(schemas, options) {
-	if (!options || isEmpty(options)) return Object.defineProperty({
-		"~kind": "Union",
-		anyOf: schemas
-	}, "~kind", noEnumerable);
 	const schema = {
 		...options,
 		"~kind": "Union",

package/dist/type/elysia/utils.d.ts

@@ -1,14 +1,12 @@
 import { ELYSIA_TYPES } from "../constants.js";
 import { BaseSchema } from "../types.js";
-import { clearSharedReferenceCaches } from "../shared.js";
 import { Static, TSchema } from "typebox";
 
 //#region src/type/elysia/utils.d.ts
-declare function copyNonEnumerable(src: object, target: object, skipKey?: string): void;
 declare function cloneSchema<T extends TSchema>(schema: T): T;
+declare function withMeta<T extends TSchema>(schema: T, property: object): T;
 declare function elyType<T extends TSchema>(name: ELYSIA_TYPES[keyof ELYSIA_TYPES], schema: T): T;
 declare function createSharedReference<const P extends Record<keyof any, unknown>, const T extends TSchema>(createType: (property: P) => T): (property: P) => T;
-declare const hasMeta: (property: Partial<BaseSchema> & Record<keyof any, unknown>) => boolean;
 declare function getMeta(property: Partial<BaseSchema> & Record<keyof any, unknown>, doHaveMeta?: boolean): readonly [{
   [x: string]: unknown;
   [x: number]: unknown;
@@ -50,4 +48,4 @@ declare function propertyChecksum(property: Partial<BaseSchema> & Record<keyof a
 type Refines<T> = [refine: (value: T) => boolean, message: string][];
 declare function Refines<T extends TSchema>(schema: T, refines: Refines<Static<T>>): T;
 //#endregion
-export { Refines, clearSharedReferenceCaches, cloneSchema, copyNonEnumerable, createSharedReference, elyType, getMeta, hasMeta, propertyChecksum };
+export { Refines, cloneSchema, createSharedReference, elyType, getMeta, propertyChecksum, withMeta };

package/dist/type/elysia/utils.js

@@ -1,30 +1,21 @@
 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) {
-	for (const key of Object.getOwnPropertyNames(src)) {
-		const desc = Object.getOwnPropertyDescriptor(src, key);
-		if (!desc || desc.enumerable || key === skipKey) continue;
-		Object.defineProperty(target, key, {
-			value: desc.value,
-			enumerable: false,
-			writable: true,
-			configurable: true
-		});
-	}
-}
 function cloneSchema(schema) {
 	const target = { ...schema };
-	copyNonEnumerable(schema, target);
+	require_type_shared.copyNonEnumerable(schema, target);
 	return target;
 }
+function withMeta(schema, property) {
+	const [, meta] = getMeta(property);
+	return meta ? Object.assign(cloneSchema(schema), meta) : schema;
+}
 function elyType(name, schema) {
 	const target = Object.assign(Object.create(Object.getPrototypeOf(schema)), schema, { "~elyTyp": name });
-	copyNonEnumerable(schema, target, "~elyTyp");
+	require_type_shared.copyNonEnumerable(schema, target, "~elyTyp");
 	return target;
 }
 function createSharedReference(createType) {
@@ -82,17 +73,15 @@ 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;
 }
 
 //#endregion
 exports.Refines = Refines;
-exports.clearSharedReferenceCaches = require_type_shared.clearSharedReferenceCaches;
 exports.cloneSchema = cloneSchema;
-exports.copyNonEnumerable = copyNonEnumerable;
 exports.createSharedReference = createSharedReference;
 exports.elyType = elyType;
 exports.getMeta = getMeta;
-exports.hasMeta = hasMeta;
-exports.propertyChecksum = propertyChecksum;
+exports.propertyChecksum = propertyChecksum;
+exports.withMeta = withMeta;

package/dist/type/elysia/utils.mjs

@@ -1,25 +1,17 @@
 import { evictOldestHalf, fnv1a } from "../../utils.mjs";
-import { SHARED_REFERENCE_CACHE_LIMIT, clearSharedReferenceCaches, referenceCache } from "../shared.mjs";
-import { Refine } from "typebox/type";
+import { SHARED_REFERENCE_CACHE_LIMIT, copyNonEnumerable, referenceCache } from "../shared.mjs";
+import { Refine } from "../typebox-type.mjs";
 
 //#region src/type/elysia/utils.ts
-function copyNonEnumerable(src, target, skipKey) {
-	for (const key of Object.getOwnPropertyNames(src)) {
-		const desc = Object.getOwnPropertyDescriptor(src, key);
-		if (!desc || desc.enumerable || key === skipKey) continue;
-		Object.defineProperty(target, key, {
-			value: desc.value,
-			enumerable: false,
-			writable: true,
-			configurable: true
-		});
-	}
-}
 function cloneSchema(schema) {
 	const target = { ...schema };
 	copyNonEnumerable(schema, target);
 	return target;
 }
+function withMeta(schema, property) {
+	const [, meta] = getMeta(property);
+	return meta ? Object.assign(cloneSchema(schema), meta) : schema;
+}
 function elyType(name, schema) {
 	const target = Object.assign(Object.create(Object.getPrototypeOf(schema)), schema, { "~elyTyp": name });
 	copyNonEnumerable(schema, target, "~elyTyp");
@@ -85,4 +77,4 @@ function Refines(schema, refines) {
 }
 
 //#endregion
-export { Refines, clearSharedReferenceCaches, cloneSchema, copyNonEnumerable, createSharedReference, elyType, getMeta, hasMeta, propertyChecksum };
+export { Refines, cloneSchema, createSharedReference, elyType, getMeta, propertyChecksum, withMeta };

package/dist/type/exports.d.ts

@@ -4,6 +4,7 @@ import { ArrayBufferType } from "./elysia/array-buffer.js";
 import { ArrayString } from "./elysia/array-string.js";
 import { BooleanType } from "./elysia/boolean.js";
 import { BooleanString } from "./elysia/boolean-string.js";
+import { CompositeType, EvaluateType, InterfaceType, MappedType, OmitType, PartialType, PickType, ReadonlyObjectType, RequiredType } from "./elysia/keep-config.js";
 import { Cookie } from "./elysia/cookie.js";
 import { DateType } from "./elysia/date.js";
 import { File } from "./elysia/file.js";
@@ -21,6 +22,7 @@ import { NumericEnum } from "./elysia/numeric-enum.js";
 import { ObjectType } from "./elysia/object.js";
 import { ObjectString } from "./elysia/object-string.js";
 import { Optional } from "./elysia/optional.js";
+import { Problem } from "./elysia/problem.js";
 import { StringType } from "./elysia/string.js";
 import { Uint8ArrayType } from "./elysia/uint8-array.js";
 import { Union } from "./elysia/union.js";
@@ -29,8 +31,8 @@ export * from "typebox/type";
 
 //#region src/type/exports.d.ts
 declare namespace exports_d_exports {
-  export { Accelerate, ArrayType as Array, ArrayBufferType as ArrayBuffer, ArrayString, BooleanType as Boolean, BooleanString, Cookie, DateType as Date, File, Files, Form, Integer, IntegerString, Intersect, MaybeEmpty, NoValidate, Nullable, NumberType as Number, Numeric, NumericEnum, ObjectType as Object, ObjectString, Optional, StringType as String, Uint8ArrayType as Uint8Array, Union, UnionEnum };
+  export { Accelerate, ArrayType as Array, ArrayBufferType as ArrayBuffer, ArrayString, BooleanType as Boolean, BooleanString, CompositeType as Composite, Cookie, DateType as Date, EvaluateType as Evaluate, File, Files, Form, Integer, IntegerString, InterfaceType as Interface, Intersect, MappedType as Mapped, MaybeEmpty, NoValidate, Nullable, NumberType as Number, Numeric, NumericEnum, ObjectType as Object, ObjectString, OmitType as Omit, Optional, PartialType as Partial, PickType as Pick, Problem, ReadonlyObjectType as ReadonlyObject, RequiredType as Required, StringType as String, Uint8ArrayType as Uint8Array, Union, UnionEnum };
 }
 import * as import_typebox_type from "typebox/type";
 //#endregion
-export { Accelerate, ArrayType as Array, ArrayBufferType as ArrayBuffer, ArrayString, BooleanType as Boolean, BooleanString, Cookie, DateType as Date, File, Files, Form, Integer, IntegerString, Intersect, MaybeEmpty, NoValidate, Nullable, NumberType as Number, Numeric, NumericEnum, ObjectType as Object, ObjectString, Optional, StringType as String, Uint8ArrayType as Uint8Array, Union, UnionEnum, exports_d_exports };
+export { Accelerate, ArrayType as Array, ArrayBufferType as ArrayBuffer, ArrayString, BooleanType as Boolean, BooleanString, CompositeType as Composite, Cookie, DateType as Date, EvaluateType as Evaluate, File, Files, Form, Integer, IntegerString, InterfaceType as Interface, Intersect, MappedType as Mapped, MaybeEmpty, NoValidate, Nullable, NumberType as Number, Numeric, NumericEnum, ObjectType as Object, ObjectString, OmitType as Omit, Optional, PartialType as Partial, PickType as Pick, Problem, ReadonlyObjectType as ReadonlyObject, RequiredType as Required, StringType as String, Uint8ArrayType as Uint8Array, Union, UnionEnum, exports_d_exports };