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

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');
@@ -11,24 +13,34 @@ const require_type_elysia_boolean = require('./elysia/boolean.js');
 const require_type_elysia_boolean_string = require('./elysia/boolean-string.js');
 const require_type_elysia_integer = require('./elysia/integer.js');
 const require_type_elysia_integer_string = require('./elysia/integer-string.js');
-const require_type_elysia_file = require('./elysia/file.js');
 const require_type_elysia_intersect = require('./elysia/intersect.js');
 const require_type_compat = require('./compat.js');
 const require_type_elysia_accelerate = require('./elysia/accelerate.js');
 const require_type_elysia_array_buffer = require('./elysia/array-buffer.js');
 const require_type_elysia_cookie = require('./elysia/cookie.js');
 const require_type_elysia_date = require('./elysia/date.js');
+const require_type_elysia_file = require('./elysia/file.js');
 const require_type_elysia_files = require('./elysia/files.js');
 const require_type_elysia_form = require('./elysia/form.js');
+const require_type_elysia_keep_config = require('./elysia/keep-config.js');
 const require_type_elysia_maybe_empty = require('./elysia/maybe-empty.js');
 const require_type_elysia_no_validate = require('./elysia/no-validate.js');
 const require_type_elysia_nullable = require('./elysia/nullable.js');
 const require_type_elysia_numeric_enum = require('./elysia/numeric-enum.js');
 const require_type_elysia_optional = require('./elysia/optional.js');
+const require_type_elysia_problem = require('./elysia/problem.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
@@ -38,14 +50,18 @@ exports.ArrayBuffer = require_type_elysia_array_buffer.ArrayBufferType;
 exports.ArrayString = require_type_elysia_array_string.ArrayString;
 exports.Boolean = require_type_elysia_boolean.BooleanType;
 exports.BooleanString = require_type_elysia_boolean_string.BooleanString;
+exports.Composite = require_type_elysia_keep_config.CompositeType;
 exports.Cookie = require_type_elysia_cookie.Cookie;
 exports.Date = require_type_elysia_date.DateType;
+exports.Evaluate = require_type_elysia_keep_config.EvaluateType;
 exports.File = require_type_elysia_file.File;
 exports.Files = require_type_elysia_files.Files;
 exports.Form = require_type_elysia_form.Form;
 exports.Integer = require_type_elysia_integer.Integer;
 exports.IntegerString = require_type_elysia_integer_string.IntegerString;
+exports.Interface = require_type_elysia_keep_config.InterfaceType;
 exports.Intersect = require_type_elysia_intersect.Intersect;
+exports.Mapped = require_type_elysia_keep_config.MappedType;
 exports.MaybeEmpty = require_type_elysia_maybe_empty.MaybeEmpty;
 exports.NoValidate = require_type_elysia_no_validate.NoValidate;
 exports.Nullable = require_type_elysia_nullable.Nullable;
@@ -54,12 +70,17 @@ exports.Numeric = require_type_elysia_numeric.Numeric;
 exports.NumericEnum = require_type_elysia_numeric_enum.NumericEnum;
 exports.Object = require_type_elysia_object.ObjectType;
 exports.ObjectString = require_type_elysia_object_string.ObjectString;
+exports.Omit = require_type_elysia_keep_config.OmitType;
 exports.Optional = require_type_elysia_optional.Optional;
+exports.Partial = require_type_elysia_keep_config.PartialType;
+exports.Pick = require_type_elysia_keep_config.PickType;
+exports.Problem = require_type_elysia_problem.Problem;
+exports.ReadonlyObject = require_type_elysia_keep_config.ReadonlyObjectType;
+exports.Required = require_type_elysia_keep_config.RequiredType;
 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";
@@ -10,27 +11,35 @@ import { BooleanType } from "./elysia/boolean.mjs";
 import { BooleanString } from "./elysia/boolean-string.mjs";
 import { Integer } from "./elysia/integer.mjs";
 import { IntegerString } from "./elysia/integer-string.mjs";
-import { File } from "./elysia/file.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";
 import { Cookie } from "./elysia/cookie.mjs";
 import { DateType } from "./elysia/date.mjs";
+import { File } from "./elysia/file.mjs";
 import { Files } from "./elysia/files.mjs";
 import { Form } from "./elysia/form.mjs";
+import { CompositeType, EvaluateType, InterfaceType, MappedType, OmitType, PartialType, PickType, ReadonlyObjectType, RequiredType } from "./elysia/keep-config.mjs";
 import { MaybeEmpty } from "./elysia/maybe-empty.mjs";
 import { NoValidate } from "./elysia/no-validate.mjs";
 import { Nullable } from "./elysia/nullable.mjs";
 import { NumericEnum } from "./elysia/numeric-enum.mjs";
 import { Optional } from "./elysia/optional.mjs";
+import { Problem } from "./elysia/problem.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
-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 };

package/dist/type/index.d.ts

@@ -1,13 +1,21 @@
 import { AnySchema, BaseSchema, StandardJSONSchemaV1Like, StandardSchemaV1Like, TypeBoxSchema } from "./types.js";
-import { FileTypeDetector, fileType, setFileTypeDetector } from "./elysia/file-type.js";
 import { exports_d_exports } from "./exports.js";
 import { setupTypebox } from "./compat.js";
+import { FileTypeDetector, fileType, setFileTypeDetector } from "./elysia/file-type.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,5 @@
 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');
@@ -13,45 +12,84 @@ const require_type_elysia_boolean = require('./elysia/boolean.js');
 const require_type_elysia_boolean_string = require('./elysia/boolean-string.js');
 const require_type_elysia_integer = require('./elysia/integer.js');
 const require_type_elysia_integer_string = require('./elysia/integer-string.js');
-const require_type_elysia_file = require('./elysia/file.js');
+const require_type_elysia_file_type = require('./elysia/file-type.js');
 const require_type_validator_index = require('./validator/index.js');
 const require_type_elysia_intersect = require('./elysia/intersect.js');
 const require_type_compat = require('./compat.js');
+const require_type_typebox_system_require = require('./typebox-system-require.js');
 const require_type_elysia_accelerate = require('./elysia/accelerate.js');
 const require_type_elysia_array_buffer = require('./elysia/array-buffer.js');
 const require_type_elysia_cookie = require('./elysia/cookie.js');
 const require_type_elysia_date = require('./elysia/date.js');
+const require_type_elysia_file = require('./elysia/file.js');
 const require_type_elysia_files = require('./elysia/files.js');
 const require_type_elysia_form = require('./elysia/form.js');
+const require_type_elysia_keep_config = require('./elysia/keep-config.js');
 const require_type_elysia_maybe_empty = require('./elysia/maybe-empty.js');
 const require_type_elysia_no_validate = require('./elysia/no-validate.js');
 const require_type_elysia_nullable = require('./elysia/nullable.js');
 const require_type_elysia_numeric_enum = require('./elysia/numeric-enum.js');
 const require_type_elysia_optional = require('./elysia/optional.js');
+const require_type_elysia_problem = require('./elysia/problem.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,
+/**
+* A namespace object that materializes `typebox/type` only when a key it does
+* not own is actually read
+*/
+const lazyNamespace = (resolve, overrides, onRead) => new Proxy(overrides, {
+	get: (target, key, receiver) => {
+		onRead?.();
+		return 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 (Object.hasOwn(target, key)) return Reflect.getOwnPropertyDescriptor(target, key);
+		const ns = resolve();
+		if (!Object.hasOwn(ns, key)) return;
+		const get = Reflect.getOwnPropertyDescriptor(ns, key).get;
+		if (get) return {
+			get,
+			enumerable: true,
+			configurable: true
+		};
+		return {
+			value: ns[key],
+			enumerable: true,
+			writable: true,
+			configurable: true
+		};
+	},
+	preventExtensions: () => false,
+	set: (target, key, value) => Reflect.set(target, key, value)
+});
+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,
 	ArrayString: require_type_elysia_array_string.ArrayString,
 	Boolean: require_type_elysia_boolean.BooleanType,
 	BooleanString: require_type_elysia_boolean_string.BooleanString,
+	Composite: require_type_elysia_keep_config.CompositeType,
 	Cookie: require_type_elysia_cookie.Cookie,
 	Date: require_type_elysia_date.DateType,
+	Evaluate: require_type_elysia_keep_config.EvaluateType,
 	File: require_type_elysia_file.File,
 	Files: require_type_elysia_files.Files,
 	Form: require_type_elysia_form.Form,
 	Integer: require_type_elysia_integer.Integer,
+	Interface: require_type_elysia_keep_config.InterfaceType,
 	Intersect: require_type_elysia_intersect.Intersect,
 	IntegerString: require_type_elysia_integer_string.IntegerString,
+	Mapped: require_type_elysia_keep_config.MappedType,
 	MaybeEmpty: require_type_elysia_maybe_empty.MaybeEmpty,
 	NoValidate: require_type_elysia_no_validate.NoValidate,
 	Nullable: require_type_elysia_nullable.Nullable,
@@ -60,21 +98,30 @@ const t = {
 	NumericEnum: require_type_elysia_numeric_enum.NumericEnum,
 	Object: require_type_elysia_object.ObjectType,
 	ObjectString: require_type_elysia_object_string.ObjectString,
+	Omit: require_type_elysia_keep_config.OmitType,
 	Optional: require_type_elysia_optional.Optional,
+	Partial: require_type_elysia_keep_config.PartialType,
+	Pick: require_type_elysia_keep_config.PickType,
+	Problem: require_type_elysia_problem.Problem,
+	ReadonlyObject: require_type_elysia_keep_config.ReadonlyObjectType,
+	Required: require_type_elysia_keep_config.RequiredType,
 	String: require_type_elysia_string.StringType,
 	Uint8Array: require_type_elysia_uint8_array.Uint8ArrayType,
 	Union: require_type_elysia_union.Union,
 	UnionEnum: require_type_elysia_union_enum.UnionEnum
-};
+}, require_type_typebox_type.markTypeUsed);
+/**
+* `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_system_require.typeSystem(require_type_typebox_type.loadTypeNamespace().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,4 @@
-import { fileType, setFileTypeDetector } from "./elysia/file-type.mjs";
+import { loadTypeNamespace, markTypeUsed } from "./typebox-type.mjs";
 import { ArrayType } from "./elysia/array.mjs";
 import { StringType } from "./elysia/string.mjs";
 import { Union } from "./elysia/union.mjs";
@@ -9,46 +9,86 @@ 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 { fileType, setFileTypeDetector } from "./elysia/file-type.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 { typeSystem } from "./typebox-system-require.mjs";
 import { Accelerate } from "./elysia/accelerate.mjs";
 import { ArrayBufferType } from "./elysia/array-buffer.mjs";
 import { Cookie } from "./elysia/cookie.mjs";
 import { DateType } from "./elysia/date.mjs";
+import { File } from "./elysia/file.mjs";
 import { Files } from "./elysia/files.mjs";
 import { Form } from "./elysia/form.mjs";
+import { CompositeType, EvaluateType, InterfaceType, MappedType, OmitType, PartialType, PickType, ReadonlyObjectType, RequiredType } from "./elysia/keep-config.mjs";
 import { MaybeEmpty } from "./elysia/maybe-empty.mjs";
 import { NoValidate } from "./elysia/no-validate.mjs";
 import { Nullable } from "./elysia/nullable.mjs";
 import { NumericEnum } from "./elysia/numeric-enum.mjs";
 import { Optional } from "./elysia/optional.mjs";
+import { Problem } from "./elysia/problem.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,
+/**
+* A namespace object that materializes `typebox/type` only when a key it does
+* not own is actually read
+*/
+const lazyNamespace = (resolve, overrides, onRead) => new Proxy(overrides, {
+	get: (target, key, receiver) => {
+		onRead?.();
+		return 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 (Object.hasOwn(target, key)) return Reflect.getOwnPropertyDescriptor(target, key);
+		const ns = resolve();
+		if (!Object.hasOwn(ns, key)) return;
+		const get = Reflect.getOwnPropertyDescriptor(ns, key).get;
+		if (get) return {
+			get,
+			enumerable: true,
+			configurable: true
+		};
+		return {
+			value: ns[key],
+			enumerable: true,
+			writable: true,
+			configurable: true
+		};
+	},
+	preventExtensions: () => false,
+	set: (target, key, value) => Reflect.set(target, key, value)
+});
+const t = lazyNamespace(() => loadTypeNamespace().type, {
 	Accelerate,
 	Array: ArrayType,
 	ArrayBuffer: ArrayBufferType,
 	ArrayString,
 	Boolean: BooleanType,
 	BooleanString,
+	Composite: CompositeType,
 	Cookie,
 	Date: DateType,
+	Evaluate: EvaluateType,
 	File,
 	Files,
 	Form,
-	Integer: Integer$1,
-	Intersect: Intersect$1,
+	Integer,
+	Interface: InterfaceType,
+	Intersect,
 	IntegerString,
+	Mapped: MappedType,
 	MaybeEmpty,
 	NoValidate,
 	Nullable,
@@ -57,12 +97,26 @@ const t = {
 	NumericEnum,
 	Object: ObjectType,
 	ObjectString,
+	Omit: OmitType,
 	Optional,
+	Partial: PartialType,
+	Pick: PickType,
+	Problem,
+	ReadonlyObject: ReadonlyObjectType,
+	Required: RequiredType,
 	String: StringType,
 	Uint8Array: Uint8ArrayType,
 	Union,
 	UnionEnum
-};
+}, markTypeUsed);
+/**
+* `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(() => typeSystem(loadTypeNamespace().system), Object.create(null));
 
 //#endregion
 export { TypeBoxValidator, TypeSystem, fileType, setFileTypeDetector, setupTypebox, t };

package/dist/type/shared.d.ts

@@ -6,22 +6,16 @@ declare const SHARED_REFERENCE_CACHE_LIMIT = 1024;
 declare function referenceCache(cache: Map<number, any> | Map<string, any>): void;
 /** @internal */
 declare function clearSharedReferenceCaches(): void;
-/**
- * @internal Tag every `~refine` entry of a framework-built node as pure.
- * Only ever call this on nodes whose predicates are self-contained: a predicate
- * that can transitively reach a USER refinement (e.g. ObjectString, which runs
- * `Check` over the inner schema) is NOT pure and must keep the pool.
- */
 declare function pureRefine<T>(node: T): T;
 /** @internal */
 declare const isPureRefinement: (refinement: object) => boolean;
 /** @internal */
 declare const coerceLeafCache: Map<string, any>;
 /** @internal test isolation */
-declare const coerceLeafCacheSize: () => number;
-/** @internal test isolation */
 declare function clearCoerceLeafCache(): void;
+declare function copyNonEnumerable(src: object, target: object, skipKey?: string): void;
 declare function cloneNode(node: BaseSchema, out: any): any;
+declare function dropCompiledSource(tb: any): void;
 declare function nonAdditionalProperties(node: BaseSchema, seen?: WeakSet<object>): BaseSchema;
 //#endregion
-export { SHARED_REFERENCE_CACHE_LIMIT, clearCoerceLeafCache, clearSharedReferenceCaches, cloneNode, coerceLeafCache, coerceLeafCacheSize, isPureRefinement, nonAdditionalProperties, pureRefine, referenceCache };
+export { SHARED_REFERENCE_CACHE_LIMIT, clearCoerceLeafCache, clearSharedReferenceCaches, cloneNode, coerceLeafCache, copyNonEnumerable, dropCompiledSource, isPureRefinement, nonAdditionalProperties, pureRefine, referenceCache };

package/dist/type/shared.js

@@ -14,12 +14,6 @@ function clearSharedReferenceCaches() {
 	for (const cache of sharedReferenceCaches) cache.clear();
 }
 const pureRefinements = /* @__PURE__ */ new WeakSet();
-/**
-* @internal Tag every `~refine` entry of a framework-built node as pure.
-* Only ever call this on nodes whose predicates are self-contained: a predicate
-* that can transitively reach a USER refinement (e.g. ObjectString, which runs
-* `Check` over the inner schema) is NOT pure and must keep the pool.
-*/
 function pureRefine(node) {
 	const refinements = node?.["~refine"];
 	if (Array.isArray(refinements)) {
@@ -32,20 +26,13 @@ const isPureRefinement = (refinement) => pureRefinements.has(refinement);
 /** @internal */
 const coerceLeafCache = /* @__PURE__ */ new Map();
 /** @internal test isolation */
-const coerceLeafCacheSize = () => coerceLeafCache.size;
-/** @internal test isolation */
 function clearCoerceLeafCache() {
 	coerceLeafCache.clear();
 }
-function cloneNode(node, out) {
-	if (out !== node) return out;
-	const target = {
-		...node,
-		"~kind": node["~kind"]
-	};
-	for (const key of Object.getOwnPropertyNames(node)) {
-		const desc = Object.getOwnPropertyDescriptor(node, key);
-		if (!desc || desc.enumerable || key === "~kind") continue;
+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,
@@ -53,104 +40,63 @@ function cloneNode(node, out) {
 			configurable: true
 		});
 	}
+}
+function cloneNode(node, out) {
+	if (out !== node) return out;
+	const target = {
+		...node,
+		"~kind": node["~kind"]
+	};
+	copyNonEnumerable(node, target, "~kind");
 	return Object.defineProperty(target, "~kind", require_type_constants.noEnumerable);
 }
+function dropCompiledSource(tb) {
+	if (tb.evaluateResult) tb.evaluateResult.code = void 0;
+	if (tb.buildResult) tb.buildResult.functions = void 0;
+}
 function nonAdditionalProperties(node, seen = /* @__PURE__ */ new WeakSet()) {
 	if (!node || typeof node !== "object" || seen.has(node)) return node;
 	seen.add(node);
 	let out = node;
-	if (node.properties) {
-		let newProps;
-		for (const k in node.properties) {
-			const v = node.properties[k];
+	const set = (key, value) => {
+		out = cloneNode(node, out);
+		out[key] = value;
+	};
+	const single = (key) => {
+		const v = node[key];
+		const r = nonAdditionalProperties(v, seen);
+		if (r !== v) set(key, r);
+	};
+	const record = (key) => {
+		const children = node[key];
+		let copy;
+		for (const k in children) {
+			const v = children[k];
 			const r = nonAdditionalProperties(v, seen);
-			if (r !== v) {
-				newProps ??= { ...node.properties };
-				newProps[k] = r;
-			}
+			if (r !== v) (copy ??= { ...children })[k] = r;
 		}
-		if (newProps) {
-			out = cloneNode(node, out);
-			out.properties = newProps;
-		}
-	}
-	if (node.items) if (Array.isArray(node.items)) {
-		let newItems;
-		for (let i = 0; i < node.items.length; i++) {
-			const r = nonAdditionalProperties(node.items[i], seen);
-			if (r !== node.items[i]) {
-				newItems ??= [...node.items];
-				newItems[i] = r;
-			}
-		}
-		if (newItems) {
-			out = cloneNode(node, out);
-			out.items = newItems;
-		}
-	} else {
-		const r = nonAdditionalProperties(node.items, seen);
-		if (r !== node.items) {
-			out = cloneNode(node, out);
-			out.items = r;
-		}
-	}
+		if (copy) set(key, copy);
+	};
+	if (node.properties) record("properties");
+	if (node.items && !Array.isArray(node.items)) single("items");
 	for (const key of [
+		"items",
 		"anyOf",
 		"allOf",
 		"oneOf"
 	]) {
 		const arr = node[key];
 		if (!Array.isArray(arr)) continue;
-		let newArr;
+		let copy;
 		for (let i = 0; i < arr.length; i++) {
 			const r = nonAdditionalProperties(arr[i], seen);
-			if (r !== arr[i]) {
-				newArr ??= [...arr];
-				newArr[i] = r;
-			}
-		}
-		if (newArr) {
-			out = cloneNode(node, out);
-			out[key] = newArr;
-		}
-	}
-	if (node.additionalProperties && typeof node.additionalProperties === "object") {
-		const r = nonAdditionalProperties(node.additionalProperties, seen);
-		if (r !== node.additionalProperties) {
-			out = cloneNode(node, out);
-			out.additionalProperties = r;
-		}
-	}
-	if (node.patternProperties) {
-		let newPP;
-		for (const k in node.patternProperties) {
-			const v = node.patternProperties[k];
-			const r = nonAdditionalProperties(v, seen);
-			if (r !== v) {
-				newPP ??= { ...node.patternProperties };
-				newPP[k] = r;
-			}
-		}
-		if (newPP) {
-			out = cloneNode(node, out);
-			out.patternProperties = newPP;
-		}
-	}
-	if (node.$defs) {
-		let newDefs;
-		for (const k in node.$defs) {
-			const v = node.$defs[k];
-			const r = nonAdditionalProperties(v, seen);
-			if (r !== v) {
-				newDefs ??= { ...node.$defs };
-				newDefs[k] = r;
-			}
-		}
-		if (newDefs) {
-			out = cloneNode(node, out);
-			out.$defs = newDefs;
+			if (r !== arr[i]) (copy ??= [...arr])[i] = r;
 		}
+		if (copy) set(key, copy);
 	}
+	if (node.additionalProperties && typeof node.additionalProperties === "object") single("additionalProperties");
+	if (node.patternProperties) record("patternProperties");
+	if (node.$defs) record("$defs");
 	if ((node.type === "object" || node["~kind"] === "Object") && !("additionalProperties" in node)) {
 		out = cloneNode(node, out);
 		out.additionalProperties = false;
@@ -164,7 +110,8 @@ exports.clearCoerceLeafCache = clearCoerceLeafCache;
 exports.clearSharedReferenceCaches = clearSharedReferenceCaches;
 exports.cloneNode = cloneNode;
 exports.coerceLeafCache = coerceLeafCache;
-exports.coerceLeafCacheSize = coerceLeafCacheSize;
+exports.copyNonEnumerable = copyNonEnumerable;
+exports.dropCompiledSource = dropCompiledSource;
 exports.isPureRefinement = isPureRefinement;
 exports.nonAdditionalProperties = nonAdditionalProperties;
 exports.pureRefine = pureRefine;