elysia 2.0.0-beta.2 → 2.0.0-beta.20

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,14 +12,16 @@ 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_maybe_empty = require('./elysia/maybe-empty.js');
@@ -28,16 +29,48 @@ 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,
@@ -61,20 +94,24 @@ const t = {
 	Object: require_type_elysia_object.ObjectType,
 	ObjectString: require_type_elysia_object_string.ObjectString,
 	Optional: require_type_elysia_optional.Optional,
+	Problem: require_type_elysia_problem.Problem,
 	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,16 +9,18 @@ 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 { MaybeEmpty } from "./elysia/maybe-empty.mjs";
@@ -26,15 +28,48 @@ 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,
@@ -46,8 +81,8 @@ const t = {
 	File,
 	Files,
 	Form,
-	Integer: Integer$1,
-	Intersect: Intersect$1,
+	Integer,
+	Intersect,
 	IntegerString,
 	MaybeEmpty,
 	NoValidate,
@@ -58,11 +93,20 @@ const t = {
 	Object: ObjectType,
 	ObjectString,
 	Optional,
+	Problem,
 	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;

package/dist/type/shared.mjs

@@ -13,12 +13,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)) {
@@ -31,20 +25,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,
@@ -52,104 +39,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", 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;
@@ -158,4 +104,4 @@ function nonAdditionalProperties(node, seen = /* @__PURE__ */ new WeakSet()) {
 }
 
 //#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/sync-require.d.ts

@@ -0,0 +1,11 @@
+//#region src/type/sync-require.d.ts
+/**
+ * Synchronous `require` resolving from the CALLER's module: pass its own
+ * `import.meta` and `import.meta.url` (a CJS build empties `import.meta` but
+ * still rewrites `import.meta.url`)
+ *
+ * Never swapped by the AOT build plugin
+ */
+declare const syncRequire: (meta: ImportMeta, url: string) => ((specifier: string) => any) | undefined;
+//#endregion
+export { syncRequire };

package/dist/type/sync-require.js

@@ -0,0 +1,14 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+//#region src/type/sync-require.ts
+/**
+* Synchronous `require` resolving from the CALLER's module: pass its own
+* `import.meta` and `import.meta.url` (a CJS build empties `import.meta` but
+* still rewrites `import.meta.url`)
+*
+* Never swapped by the AOT build plugin
+*/
+const syncRequire = (meta, url) => meta.require ?? globalThis.process?.getBuiltinModule?.("module")?.createRequire(url);
+
+//#endregion
+exports.syncRequire = syncRequire;

package/dist/type/sync-require.mjs

@@ -0,0 +1,12 @@
+//#region src/type/sync-require.ts
+/**
+* Synchronous `require` resolving from the CALLER's module: pass its own
+* `import.meta` and `import.meta.url` (a CJS build empties `import.meta` but
+* still rewrites `import.meta.url`)
+*
+* Never swapped by the AOT build plugin
+*/
+const syncRequire = (meta, url) => meta.require ?? globalThis.process?.getBuiltinModule?.("module")?.createRequire(url);
+
+//#endregion
+export { syncRequire };

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

@@ -0,0 +1,2 @@
+import { Arguments, Environment, Hashing, Memory, Settings } from "typebox/system";
+export { Arguments, Environment, Hashing, Memory, Settings };