@sinclair/typebox 0.26.0-dev.1 → 0.26.0-dev.2

package/compiler/compiler.d.ts

@@ -1,5 +1,5 @@
 import * as Types from '../typebox';
-import { ValueError } from '../errors/index';
+import { ValueErrorIterator } from '../errors/index';
 export type CheckFunction = (value: unknown) => boolean;
 export declare class TypeCheck<T extends Types.TSchema> {
     private readonly schema;
@@ -9,7 +9,7 @@ export declare class TypeCheck<T extends Types.TSchema> {
     /** Returns the generated assertion code used to validate this type. */
     Code(): string;
     /** Returns an iterator for each error in this value. */
-    Errors(value: unknown): IterableIterator<ValueError>;
+    Errors(value: unknown): ValueErrorIterator;
     /** Returns true if the value matches the compiled type. */
     Check(value: unknown): value is Types.Static<T>;
 }

package/errors/errors.d.ts

@@ -67,11 +67,18 @@ export interface ValueError {
     value: unknown;
     message: string;
 }
+export declare class ValueErrorIterator {
+    private readonly iterator;
+    constructor(iterator: IterableIterator<ValueError>);
+    [Symbol.iterator](): IterableIterator<ValueError>;
+    /** Returns the first value error or undefined if no errors */
+    First(): ValueError | undefined;
+}
 export declare class ValueErrorsUnknownTypeError extends Error {
     readonly schema: Types.TSchema;
     constructor(schema: Types.TSchema);
 }
 /** Provides functionality to generate a sequence of errors against a TypeBox type.  */
 export declare namespace ValueErrors {
-    function Errors<T extends Types.TSchema>(schema: T, value: any): IterableIterator<ValueError>;
+    function Errors<T extends Types.TSchema>(schema: T, value: any): ValueErrorIterator;
 }

package/errors/errors.js

@@ -1,4 +1,6 @@
 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValueErrors = exports.ValueErrorsUnknownTypeError = exports.ValueErrorIterator = exports.ValueErrorType = void 0;
 /*--------------------------------------------------------------------------
 
 @sinclair/typebox/errors
@@ -26,8 +28,6 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ValueErrors = exports.ValueErrorsUnknownTypeError = exports.ValueErrorType = void 0;
 const Types = require("../typebox");
 const index_1 = require("../system/index");
 const hash_1 = require("../value/hash");
@@ -97,6 +97,23 @@ var ValueErrorType;
     ValueErrorType[ValueErrorType["Custom"] = 58] = "Custom";
 })(ValueErrorType = exports.ValueErrorType || (exports.ValueErrorType = {}));
 // -------------------------------------------------------------------
+// ValueErrorIterator
+// -------------------------------------------------------------------
+class ValueErrorIterator {
+    constructor(iterator) {
+        this.iterator = iterator;
+    }
+    [Symbol.iterator]() {
+        return this.iterator;
+    }
+    /** Returns the first value error or undefined if no errors */
+    First() {
+        const next = this.iterator.next();
+        return next.done ? undefined : next.value;
+    }
+}
+exports.ValueErrorIterator = ValueErrorIterator;
+// -------------------------------------------------------------------
 // ValueErrors
 // -------------------------------------------------------------------
 class ValueErrorsUnknownTypeError extends Error {
@@ -546,8 +563,8 @@ var ValueErrors;
                 return yield* UserDefined(anySchema, path, value);
         }
     }
-    function* Errors(schema, value) {
-        yield* Visit(schema, '', value);
+    function Errors(schema, value) {
+        return new ValueErrorIterator(Visit(schema, '', value));
     }
     ValueErrors.Errors = Errors;
 })(ValueErrors = exports.ValueErrors || (exports.ValueErrors = {}));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.26.0-dev.1",
+  "version": "0.26.0-dev.2",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",

package/readme.md

@@ -586,9 +586,9 @@ TypeBox provides property modifier types that allow properties to be mapped with
 │ const T = Type.Object({        │ type T = {                  │ const T = {                    │
 │   name: Type.Optional(         │   name?: string             │   type: 'object',              │
 │     Type.String()              │ }                           │   properties: {                │
-│   )                            │                             │      name: {                   │
-│ })  	                         │                             │        type: 'string'          │
-│                                │                             │      }                         │
+│   )                            │                             │     name: {                    │
+│ })  	                         │                             │       type: 'string'           │
+│                                │                             │     }                          │
 │                                │                             │   }                            │
 │                                │                             │ }                              │
 │                                │                             │                                │

package/typebox.d.ts

@@ -1,6 +1,7 @@
 export declare const Kind: unique symbol;
 export declare const Hint: unique symbol;
 export declare const Modifier: unique symbol;
+export declare const Recursive: unique symbol;
 export type TupleToIntersect<T extends any[]> = T extends [infer I] ? I : T extends [infer I, ...infer R] ? I & TupleToIntersect<R> : never;
 export type TupleToUnion<T extends any[]> = {
     [K in keyof T]: T[K];
@@ -41,8 +42,9 @@ export interface TKind {
     [Kind]: string;
 }
 export interface TSchema extends SchemaOptions, TKind {
-    [Hint]?: string;
     [Modifier]?: string;
+    [Recursive]?: string;
+    [Hint]?: string;
     params: unknown[];
     static: unknown;
 }
@@ -170,7 +172,7 @@ export type TKeyOfTuple<T extends TSchema> = {
 } extends infer U ? UnionToTuple<Exclude<{
     [K in keyof U]: U[K];
 }[keyof U], undefined>> : never;
-export type TKeyOf<T extends TSchema = TSchema> = (T extends TIntersect ? TKeyOfTuple<T> : T extends TUnion ? TKeyOfTuple<T> : T extends TObject ? TKeyOfTuple<T> : [
+export type TKeyOf<T extends TSchema = TSchema, D = TDeref<T>> = (D extends TIntersect ? TKeyOfTuple<T> : D extends TUnion ? TKeyOfTuple<T> : D extends TObject ? TKeyOfTuple<T> : [
 ]) extends infer R ? R extends [] ? TNever : TUnion<Assert<R, TSchema[]>> : never;
 export type TLiteralValue = string | number | boolean | bigint;
 export interface TLiteral<T extends TLiteralValue = TLiteralValue> extends TSchema {
@@ -242,7 +244,7 @@ export type TOmitArray<T extends TSchema[], K extends keyof any> = Assert<{
     [K2 in keyof T]: TOmit<Assert<T[K2], TSchema>, K>;
 }, TSchema[]>;
 export type TOmitProperties<T extends TProperties, K extends keyof any> = Evaluate<Assert<Omit<T, K>, TProperties>>;
-export type TOmit<T extends TSchema, K extends keyof any> = T extends TIntersect<infer S> ? TIntersect<TOmitArray<S, K>> : T extends TUnion<infer S> ? TUnion<TOmitArray<S, K>> : T extends TObject<infer S> ? TObject<TOmitProperties<S, K>> : T;
+export type TOmit<T extends TSchema, K extends keyof any, D = TDeref<T>> = D extends TIntersect<infer S> ? TIntersect<TOmitArray<S, K>> : D extends TUnion<infer S> ? TUnion<TOmitArray<S, K>> : D extends TObject<infer S> ? TObject<TOmitProperties<S, K>> : D;
 export type TParameters<T extends TFunction> = TTuple<T['parameters']>;
 export type TPartialArray<T extends TSchema[]> = Assert<{
     [K in keyof T]: TPartial<Assert<T[K], TSchema>>;
@@ -250,14 +252,14 @@ export type TPartialArray<T extends TSchema[]> = Assert<{
 export type TPartialProperties<T extends TProperties> = Evaluate<Assert<{
     [K in keyof T]: T[K] extends TReadonlyOptional<infer U> ? TReadonlyOptional<U> : T[K] extends TReadonly<infer U> ? TReadonlyOptional<U> : T[K] extends TOptional<infer U> ? TOptional<U> : TOptional<T[K]>;
 }, TProperties>>;
-export type TPartial<T extends TSchema> = T extends TIntersect<infer S> ? TIntersect<TPartialArray<S>> : T extends TUnion<infer S> ? TUnion<TPartialArray<S>> : T extends TObject<infer S> ? TObject<TPartialProperties<S>> : T;
+export type TPartial<T extends TSchema, D = TDeref<T>> = D extends TIntersect<infer S> ? TIntersect<TPartialArray<S>> : D extends TUnion<infer S> ? TUnion<TPartialArray<S>> : D extends TObject<infer S> ? TObject<TPartialProperties<S>> : D;
 export type TPickArray<T extends TSchema[], K extends keyof any> = {
     [K2 in keyof T]: TPick<Assert<T[K2], TSchema>, K>;
 };
 export type TPickProperties<T extends TProperties, K extends keyof any> = Pick<T, Assert<Extract<K, keyof T>, keyof T>> extends infer R ? ({
     [K in keyof R]: Assert<R[K], TSchema> extends TSchema ? R[K] : never;
 }) : never;
-export type TPick<T extends TSchema, K extends keyof any> = T extends TIntersect<infer S> ? TIntersect<TPickArray<S, K>> : T extends TUnion<infer S> ? TUnion<TPickArray<S, K>> : T extends TObject<infer S> ? TObject<TPickProperties<S, K>> : T;
+export type TPick<T extends TSchema, K extends keyof any, D = TDeref<T>> = D extends TIntersect<infer S> ? TIntersect<TPickArray<S, K>> : D extends TUnion<infer S> ? TUnion<TPickArray<S, K>> : D extends TObject<infer S> ? TObject<TPickProperties<S, K>> : D;
 export type TPromiseStatic<T extends TSchema, P extends unknown[]> = Promise<Static<T, P>>;
 export interface TPromise<T extends TSchema = TSchema> extends TSchema {
     [Kind]: 'Promise';
@@ -305,7 +307,7 @@ export type TRequiredArray<T extends TSchema[]> = Assert<{
 export type TRequiredProperties<T extends TProperties> = Evaluate<Assert<{
     [K in keyof T]: T[K] extends TReadonlyOptional<infer U> ? TReadonly<U> : T[K] extends TReadonly<infer U> ? TReadonly<U> : T[K] extends TOptional<infer U> ? U : T[K];
 }, TProperties>>;
-export type TRequired<T extends TSchema> = T extends TIntersect<infer S> ? TIntersect<TRequiredArray<S>> : T extends TUnion<infer S> ? TUnion<TRequiredArray<S>> : T extends TObject<infer S> ? TObject<TRequiredProperties<S>> : T;
+export type TRequired<T extends TSchema, D = TDeref<T>> = D extends TIntersect<infer S> ? TIntersect<TRequiredArray<S>> : D extends TUnion<infer S> ? TUnion<TRequiredArray<S>> : D extends TObject<infer S> ? TObject<TRequiredProperties<S>> : D;
 export type StringFormatOption = 'date-time' | 'time' | 'date' | 'email' | 'idn-email' | 'hostname' | 'idn-hostname' | 'ipv4' | 'ipv6' | 'uri' | 'uri-reference' | 'iri' | 'uuid' | 'iri-reference' | 'uri-template' | 'json-pointer' | 'relative-json-pointer' | 'regex';
 export interface StringOptions<Format extends string> extends SchemaOptions {
     minLength?: number;
@@ -507,9 +509,10 @@ export declare enum TypeExtendsResult {
 export declare namespace TypeExtends {
     function Extends(left: TSchema, right: TSchema): TypeExtendsResult;
 }
-/** Specialized Clone for Types. */
+/** Specialized Clone for Types. Clones and removes non self-referential identifiers */
 export declare namespace TypeClone {
-    function Clone<T extends TSchema | TProperties>(schema: T, options: SchemaOptions): T;
+    /** Clones a type. This function will omit non-self referential identifiers on the cloned type. */
+    function Clone<T extends TSchema>(schema: T, options: SchemaOptions): T;
 }
 export declare namespace ObjectMap {
     function Map<T = TSchema>(schema: TSchema, callback: (object: TObject) => TObject, options: SchemaOptions): T;
@@ -520,8 +523,6 @@ export declare namespace KeyResolver {
 export declare class TypeBuilder {
     /** `[Utility]` Creates a schema without `static` and `params` types */
     protected Create<T>(schema: Omit<T, 'static' | 'params'>): T;
-    /** `[Utility]` Clones a schema or properties object */
-    protected Clone<T extends TSchema | TProperties>(schema: T, options?: SchemaOptions): T;
     /** `[Standard]` Omits compositing symbols from this schema */
     Strict<T extends TSchema>(schema: T): T;
 }

package/typebox.js

@@ -27,13 +27,14 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Type = exports.StandardType = exports.ExtendedTypeBuilder = exports.StandardTypeBuilder = exports.TypeBuilder = exports.KeyResolver = exports.ObjectMap = exports.TypeClone = exports.TypeExtends = exports.TypeExtendsResult = exports.ExtendsUndefined = exports.TypeGuard = exports.TypeGuardUnknownTypeError = exports.FormatRegistry = exports.ReferenceRegistry = exports.TypeRegistry = exports.Modifier = exports.Hint = exports.Kind = void 0;
+exports.Type = exports.StandardType = exports.ExtendedTypeBuilder = exports.StandardTypeBuilder = exports.TypeBuilder = exports.KeyResolver = exports.ObjectMap = exports.TypeClone = exports.TypeExtends = exports.TypeExtendsResult = exports.ExtendsUndefined = exports.TypeGuard = exports.TypeGuardUnknownTypeError = exports.FormatRegistry = exports.ReferenceRegistry = exports.TypeRegistry = exports.Recursive = exports.Modifier = exports.Hint = exports.Kind = void 0;
 // -------------------------------------------------------------------------------------
-// Symbols
+// Compositing Symbols
 // -------------------------------------------------------------------------------------
 exports.Kind = Symbol.for('TypeBox.Kind');
 exports.Hint = Symbol.for('TypeBox.Hint');
 exports.Modifier = Symbol.for('TypeBox.Modifier');
+exports.Recursive = Symbol.for('TypeBox.Recursive');
 var TypeRegistry;
 (function (TypeRegistry) {
     const types = new Map();
@@ -1356,7 +1357,7 @@ var TypeExtends;
             return Unknown(left_, right_);
         if (TypeGuard.TVoid(left_))
             return Void(left_, right_);
-        throw Error(`TypeExtends: Unknown left operand '${left[exports.Kind]}'`);
+        throw Error(`TypeExtends: Unknown left type operand '${left[exports.Kind]}'`);
     }
     function Extends(left, right) {
         return Visit(left, right);
@@ -1366,9 +1367,12 @@ var TypeExtends;
 // -------------------------------------------------------------------------------------
 // TypeClone
 // -------------------------------------------------------------------------------------
-/** Specialized Clone for Types. */
+/** Specialized Clone for Types. Clones and removes non self-referential identifiers */
 var TypeClone;
 (function (TypeClone) {
+    function IsRecursive(value) {
+        return typeof value[exports.Recursive] === 'string';
+    }
     function IsObject(value) {
         return typeof value === 'object' && value !== null && !globalThis.Array.isArray(value);
     }
@@ -1383,14 +1387,16 @@ var TypeClone;
         return clone;
     }
     function Visit(value) {
-        if (IsObject(value))
-            delete value['$id'];
-        if (IsObject(value))
-            return Object({ ...value });
-        if (IsArray(value))
-            return Array([...value]);
-        return value;
+        const clone = IsObject(value) ? { ...value } : IsArray(value) ? [...value] : value;
+        if (IsObject(clone) && !IsRecursive(clone))
+            delete clone['$id'];
+        if (IsObject(clone))
+            return Object(clone);
+        if (IsArray(clone))
+            return Array(clone);
+        return clone;
     }
+    /** Clones a type. This function will omit non-self referential identifiers on the cloned type. */
     function Clone(schema, options) {
         return { ...Visit({ ...schema }), ...options };
     }
@@ -1469,12 +1475,6 @@ class TypeBuilder {
         ReferenceRegistry.Set(schema);
         return schema;
     }
-    /** `[Utility]` Clones a schema or properties object */
-    Clone(schema, options = {}) {
-        const clone = TypeClone.Clone(schema, options);
-        ReferenceRegistry.Set(clone);
-        return clone;
-    }
     /** `[Standard]` Omits compositing symbols from this schema */
     Strict(schema) {
         return JSON.parse(JSON.stringify(schema));
@@ -1490,11 +1490,11 @@ class StandardTypeBuilder extends TypeBuilder {
     // ----------------------------------------------------------------------
     /** `[Modifier]` Creates a Optional property */
     Optional(schema) {
-        return { [exports.Modifier]: 'Optional', ...this.Clone(schema, {}) };
+        return { [exports.Modifier]: 'Optional', ...TypeClone.Clone(schema, {}) };
     }
     /** `[Modifier]` Creates a ReadonlyOptional property */
     ReadonlyOptional(schema) {
-        return { [exports.Modifier]: 'ReadonlyOptional', ...this.Clone(schema, {}) };
+        return { [exports.Modifier]: 'ReadonlyOptional', ...TypeClone.Clone(schema, {}) };
     }
     /** `[Modifier]` Creates a Readonly object or property */
     Readonly(schema) {
@@ -1509,7 +1509,7 @@ class StandardTypeBuilder extends TypeBuilder {
     }
     /** `[Standard]` Creates an Array type */
     Array(items, options = {}) {
-        return this.Create({ ...options, [exports.Kind]: 'Array', type: 'array', items });
+        return this.Create({ ...options, [exports.Kind]: 'Array', type: 'array', items: TypeClone.Clone(items, {}) });
     }
     /** `[Standard]` Creates a Boolean type */
     Boolean(options = {}) {
@@ -1527,7 +1527,7 @@ class StandardTypeBuilder extends TypeBuilder {
         const properties = {};
         for (const object of schemas) {
             for (const [key, property] of globalThis.Object.entries(object.properties)) {
-                const mapped = key in properties ? this.Union([properties[key], property]) : property;
+                const mapped = key in properties ? this.Union([properties[key], property]) : TypeClone.Clone(property, {});
                 properties[key] = optional.has(key) ? this.Optional(mapped) : mapped;
             }
         }
@@ -1548,31 +1548,31 @@ class StandardTypeBuilder extends TypeBuilder {
     Extends(left, right, trueType, falseType, options = {}) {
         switch (TypeExtends.Extends(ReferenceRegistry.Deref(left), ReferenceRegistry.Deref(right))) {
             case TypeExtendsResult.Union:
-                return this.Union([this.Clone(trueType, options), this.Clone(falseType, options)]);
+                return this.Union([TypeClone.Clone(trueType, options), TypeClone.Clone(falseType, options)]);
             case TypeExtendsResult.True:
-                return this.Clone(trueType, options);
+                return TypeClone.Clone(trueType, options);
             case TypeExtendsResult.False:
-                return this.Clone(falseType, options);
+                return TypeClone.Clone(falseType, options);
         }
     }
     /** `[Standard]` Excludes from the left type any type that is not assignable to the right */
     Exclude(left, right, options = {}) {
         if (TypeGuard.TUnion(left)) {
             const narrowed = left.anyOf.filter((inner) => TypeExtends.Extends(inner, right) === TypeExtendsResult.False);
-            return (narrowed.length === 1 ? this.Clone(narrowed[0], options) : this.Union(narrowed, options));
+            return (narrowed.length === 1 ? TypeClone.Clone(narrowed[0], options) : this.Union(narrowed, options));
         }
         else {
-            return (TypeExtends.Extends(left, right) !== TypeExtendsResult.False ? this.Never(options) : this.Clone(left, options));
+            return (TypeExtends.Extends(left, right) !== TypeExtendsResult.False ? this.Never(options) : TypeClone.Clone(left, options));
         }
     }
     /** `[Standard]` Extracts from left left any type that is assignable to the right */
     Extract(left, right, options = {}) {
         if (TypeGuard.TUnion(left)) {
             const narrowed = left.anyOf.filter((inner) => TypeExtends.Extends(inner, right) !== TypeExtendsResult.False);
-            return (narrowed.length === 1 ? this.Clone(narrowed[0], options) : this.Union(narrowed, options));
+            return (narrowed.length === 1 ? TypeClone.Clone(narrowed[0], options) : this.Union(narrowed, options));
         }
         else {
-            return (TypeExtends.Extends(left, right) !== TypeExtendsResult.False ? this.Clone(left, options) : this.Never(options));
+            return (TypeExtends.Extends(left, right) !== TypeExtendsResult.False ? TypeClone.Clone(left, options) : this.Never(options));
         }
     }
     /** `[Standard]` Creates an Integer type */
@@ -1583,9 +1583,9 @@ class StandardTypeBuilder extends TypeBuilder {
         if (allOf.length === 0)
             return exports.Type.Never();
         if (allOf.length === 1)
-            return this.Clone(allOf[0], options);
+            return TypeClone.Clone(allOf[0], options);
         const objects = allOf.every((schema) => TypeGuard.TObject(schema));
-        const cloned = allOf.map((schema) => this.Clone(schema, {}));
+        const cloned = allOf.map((schema) => TypeClone.Clone(schema, {}));
         if (options.unevaluatedProperties === false || TypeGuard.TSchema(options.unevaluatedProperties) || objects) {
             return this.Create({ ...options, [exports.Kind]: 'Intersect', type: 'object', allOf: cloned });
         }
@@ -1614,7 +1614,7 @@ class StandardTypeBuilder extends TypeBuilder {
     }
     /** `[Standard]` Creates a Not type. The first argument is the disallowed type, the second is the allowed. */
     Not(not, schema, options) {
-        return this.Create({ ...options, [exports.Kind]: 'Not', allOf: [{ not }, schema] });
+        return this.Create({ ...options, [exports.Kind]: 'Not', allOf: [{ not: TypeClone.Clone(not, {}) }, TypeClone.Clone(schema, {})] });
     }
     /** `[Standard]` Creates a Null type */
     Null(options = {}) {
@@ -1629,17 +1629,20 @@ class StandardTypeBuilder extends TypeBuilder {
         const keys = globalThis.Object.keys(properties);
         const optional = keys.filter((key) => TypeGuard.TOptional(properties[key]) || TypeGuard.TReadonlyOptional(properties[key]));
         const required = keys.filter((name) => !optional.includes(name));
+        const clonedProperties = globalThis.Object.getOwnPropertyNames(properties).reduce((acc, key) => {
+            return { ...acc, [key]: TypeClone.Clone(properties[key], {}) };
+        }, {});
         if (required.length > 0) {
-            return this.Create({ ...options, [exports.Kind]: 'Object', type: 'object', properties: this.Clone(properties, {}), required });
+            return this.Create({ ...options, [exports.Kind]: 'Object', type: 'object', properties: clonedProperties, required });
         }
         else {
-            return this.Create({ ...options, [exports.Kind]: 'Object', type: 'object', properties: this.Clone(properties, {}) });
+            return this.Create({ ...options, [exports.Kind]: 'Object', type: 'object', properties: clonedProperties });
         }
     }
     Omit(schema, unresolved, options = {}) {
         const keys = TypeGuard.TUnionLiteral(unresolved) ? unresolved.anyOf.map((schema) => schema.const) : unresolved;
         // prettier-ignore
-        return ObjectMap.Map(this.Clone(ReferenceRegistry.Deref(schema), {}), (schema) => {
+        return ObjectMap.Map(TypeClone.Clone(ReferenceRegistry.Deref(schema), {}), (schema) => {
             if (schema.required) {
                 schema.required = schema.required.filter((key) => !keys.includes(key));
                 if (schema.required.length === 0)
@@ -1672,7 +1675,7 @@ class StandardTypeBuilder extends TypeBuilder {
             }
         }
         // prettier-ignore
-        return ObjectMap.Map(this.Clone(ReferenceRegistry.Deref(schema), {}), (schema) => {
+        return ObjectMap.Map(TypeClone.Clone(ReferenceRegistry.Deref(schema), {}), (schema) => {
             delete schema.required;
             globalThis.Object.keys(schema.properties).forEach(key => Apply(schema.properties[key]));
             return schema;
@@ -1681,7 +1684,7 @@ class StandardTypeBuilder extends TypeBuilder {
     Pick(schema, unresolved, options = {}) {
         const keys = TypeGuard.TUnionLiteral(unresolved) ? unresolved.anyOf.map((schema) => schema.const) : unresolved;
         // prettier-ignore
-        return ObjectMap.Map(this.Clone(ReferenceRegistry.Deref(schema), {}), (schema) => {
+        return ObjectMap.Map(TypeClone.Clone(ReferenceRegistry.Deref(schema), {}), (schema) => {
             if (schema.required) {
                 schema.required = schema.required.filter((key) => keys.includes(key));
                 if (schema.required.length === 0)
@@ -1697,14 +1700,14 @@ class StandardTypeBuilder extends TypeBuilder {
     Record(key, schema, options = {}) {
         if (TypeGuard.TLiteral(key)) {
             if (typeof key.const === 'string' || typeof key.const === 'number') {
-                return this.Object({ [key.const]: schema }, options);
+                return this.Object({ [key.const]: TypeClone.Clone(schema, {}) }, options);
             }
             else
                 throw Error('TypeBuilder: Record key can only be derived from literals of number or string');
         }
         if (TypeGuard.TUnion(key)) {
             if (key.anyOf.every((schema) => TypeGuard.TLiteral(schema) && (typeof schema.const === 'string' || typeof schema.const === 'number'))) {
-                const properties = key.anyOf.reduce((acc, literal) => ({ ...acc, [literal.const]: this.Clone(schema, {}) }), {});
+                const properties = key.anyOf.reduce((acc, literal) => ({ ...acc, [literal.const]: TypeClone.Clone(schema, {}) }), {});
                 return this.Object(properties, { ...options, [exports.Hint]: 'Record' });
             }
             else
@@ -1715,7 +1718,7 @@ class StandardTypeBuilder extends TypeBuilder {
             ...options,
             [exports.Kind]: 'Record',
             type: 'object',
-            patternProperties: { [pattern]: schema },
+            patternProperties: { [pattern]: TypeClone.Clone(schema, {}) },
             additionalProperties: false,
         });
     }
@@ -1726,12 +1729,12 @@ class StandardTypeBuilder extends TypeBuilder {
         const self = callback({ [exports.Kind]: 'Self', $ref: `${options.$id}` });
         const reassign = self;
         reassign.$id = options.$id; // required as $id is readonly
-        return this.Create({ ...options, ...self });
+        return this.Create({ ...options, ...self, [exports.Recursive]: reassign.$id });
     }
     /** `[Standard]` Creates a Ref type. The referenced type must contain a $id */
     Ref(schema, options = {}) {
         if (schema.$id === undefined)
-            throw Error('TypeBuilder.Ref: Referenced schema must specify an $id');
+            throw Error('StandardTypeBuilder.Ref: Target type must specify an $id');
         return this.Create({ ...options, [exports.Kind]: 'Ref', $ref: schema.$id });
     }
     /** `[Standard]` Creates a mapped type where all properties are Required */
@@ -1754,7 +1757,7 @@ class StandardTypeBuilder extends TypeBuilder {
             }
         }
         // prettier-ignore
-        return ObjectMap.Map(this.Clone(ReferenceRegistry.Deref(schema), {}), (schema) => {
+        return ObjectMap.Map(TypeClone.Clone(ReferenceRegistry.Deref(schema), {}), (schema) => {
             schema.required = globalThis.Object.keys(schema.properties);
             globalThis.Object.keys(schema.properties).forEach(key => Apply(schema.properties[key]));
             return schema;
@@ -1767,9 +1770,10 @@ class StandardTypeBuilder extends TypeBuilder {
     /** `[Standard]` Creates a Tuple type */
     Tuple(items, options = {}) {
         const [additionalItems, minItems, maxItems] = [false, items.length, items.length];
+        const clonedItems = items.map((item) => TypeClone.Clone(item, {}));
         // prettier-ignore
         const schema = (items.length > 0 ?
-            { ...options, [exports.Kind]: 'Tuple', type: 'array', items, additionalItems, minItems, maxItems } :
+            { ...options, [exports.Kind]: 'Tuple', type: 'array', items: clonedItems, additionalItems, minItems, maxItems } :
             { ...options, [exports.Kind]: 'Tuple', type: 'array', minItems, maxItems });
         return this.Create(schema);
     }
@@ -1777,9 +1781,9 @@ class StandardTypeBuilder extends TypeBuilder {
         if (anyOf.length === 0)
             return this.Never(options);
         if (anyOf.length === 1)
-            return this.Clone(anyOf[0], options);
-        const cloned = anyOf.map((schema) => this.Clone(schema, {}));
-        return this.Create({ ...options, [exports.Kind]: 'Union', anyOf: cloned });
+            return TypeClone.Clone(anyOf[0], options);
+        const clonedAnyOf = anyOf.map((schema) => TypeClone.Clone(schema, {}));
+        return this.Create({ ...options, [exports.Kind]: 'Union', anyOf: clonedAnyOf });
     }
     /** `[Standard]` Creates an Unknown type */
     Unknown(options = {}) {
@@ -1804,15 +1808,17 @@ class ExtendedTypeBuilder extends StandardTypeBuilder {
         return this.Tuple([...schema.parameters], { ...options });
     }
     Constructor(parameters, returns, options = {}) {
-        if (parameters[exports.Kind] === 'Tuple') {
-            const inner = parameters.items === undefined ? [] : parameters.items;
-            return this.Create({ ...options, [exports.Kind]: 'Constructor', type: 'object', instanceOf: 'Constructor', parameters: inner, returns });
+        const clonedReturns = TypeClone.Clone(returns, {});
+        if (TypeGuard.TTuple(parameters)) {
+            const clonedParameters = parameters.items === undefined ? [] : parameters.items.map((parameter) => TypeClone.Clone(parameter, {}));
+            return this.Create({ ...options, [exports.Kind]: 'Constructor', type: 'object', instanceOf: 'Constructor', parameters: clonedParameters, returns: clonedReturns });
         }
         else if (globalThis.Array.isArray(parameters)) {
-            return this.Create({ ...options, [exports.Kind]: 'Constructor', type: 'object', instanceOf: 'Constructor', parameters, returns });
+            const clonedParameters = parameters.map((parameter) => TypeClone.Clone(parameter, {}));
+            return this.Create({ ...options, [exports.Kind]: 'Constructor', type: 'object', instanceOf: 'Constructor', parameters: clonedParameters, returns: clonedReturns });
         }
         else {
-            throw new Error('TypeBuilder.Constructor: Invalid parameters');
+            throw new Error('ExtendedTypeBuilder.Constructor: Invalid parameters');
         }
     }
     /** `[Extended]` Creates a Date type */
@@ -1820,20 +1826,22 @@ class ExtendedTypeBuilder extends StandardTypeBuilder {
         return this.Create({ ...options, [exports.Kind]: 'Date', type: 'object', instanceOf: 'Date' });
     }
     Function(parameters, returns, options = {}) {
-        if (parameters[exports.Kind] === 'Tuple') {
-            const inner = parameters.items === undefined ? [] : parameters.items;
-            return this.Create({ ...options, [exports.Kind]: 'Function', type: 'object', instanceOf: 'Function', parameters: inner, returns });
+        const clonedReturns = TypeClone.Clone(returns, {});
+        if (TypeGuard.TTuple(parameters)) {
+            const clonedParameters = parameters.items === undefined ? [] : parameters.items.map((parameter) => TypeClone.Clone(parameter, {}));
+            return this.Create({ ...options, [exports.Kind]: 'Function', type: 'object', instanceOf: 'Function', parameters: clonedParameters, returns: clonedReturns });
         }
         else if (globalThis.Array.isArray(parameters)) {
-            return this.Create({ ...options, [exports.Kind]: 'Function', type: 'object', instanceOf: 'Function', parameters, returns });
+            const clonedParameters = parameters.map((parameter) => TypeClone.Clone(parameter, {}));
+            return this.Create({ ...options, [exports.Kind]: 'Function', type: 'object', instanceOf: 'Function', parameters: clonedParameters, returns: clonedReturns });
         }
         else {
-            throw new Error('TypeBuilder.Function: Invalid parameters');
+            throw new Error('ExtendedTypeBuilder.Function: Invalid parameters');
         }
     }
     /** `[Extended]` Extracts the InstanceType from the given Constructor */
     InstanceType(schema, options = {}) {
-        return this.Clone(schema.returns, options);
+        return TypeClone.Clone(schema.returns, options);
     }
     /** `[Extended]` Extracts the Parameters from the given Function type */
     Parameters(schema, options = {}) {
@@ -1841,7 +1849,7 @@ class ExtendedTypeBuilder extends StandardTypeBuilder {
     }
     /** `[Extended]` Creates a Promise type */
     Promise(item, options = {}) {
-        return this.Create({ ...options, [exports.Kind]: 'Promise', type: 'object', instanceOf: 'Promise', item });
+        return this.Create({ ...options, [exports.Kind]: 'Promise', type: 'object', instanceOf: 'Promise', item: TypeClone.Clone(item, {}) });
     }
     /** `[Extended]` Creates a regular expression type */
     RegEx(regex, options = {}) {
@@ -1849,7 +1857,7 @@ class ExtendedTypeBuilder extends StandardTypeBuilder {
     }
     /** `[Extended]` Extracts the ReturnType from the given Function */
     ReturnType(schema, options = {}) {
-        return this.Clone(schema.returns, options);
+        return TypeClone.Clone(schema.returns, options);
     }
     /** `[Extended]` Creates a Symbol type */
     Symbol(options) {

package/value/index.d.ts

@@ -1,4 +1,4 @@
-export { ValueError, ValueErrorType } from '../errors/index';
+export { ValueError, ValueErrorIterator, ValueErrorType } from '../errors/index';
 export { ValueHash } from './hash';
 export { Edit, Insert, Update, Delete } from './delta';
 export * from './pointer';

package/value/index.js

@@ -41,8 +41,9 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Delete = exports.Update = exports.Insert = exports.Edit = exports.ValueHash = exports.ValueErrorType = void 0;
+exports.Delete = exports.Update = exports.Insert = exports.Edit = exports.ValueHash = exports.ValueErrorType = exports.ValueErrorIterator = void 0;
 var index_1 = require("../errors/index");
+Object.defineProperty(exports, "ValueErrorIterator", { enumerable: true, get: function () { return index_1.ValueErrorIterator; } });
 Object.defineProperty(exports, "ValueErrorType", { enumerable: true, get: function () { return index_1.ValueErrorType; } });
 var hash_1 = require("./hash");
 Object.defineProperty(exports, "ValueHash", { enumerable: true, get: function () { return hash_1.ValueHash; } });

package/value/value.d.ts

@@ -1,5 +1,5 @@
 import * as Types from '../typebox';
-import { ValueError } from '../errors/index';
+import { ValueErrorIterator } from '../errors/index';
 import { Edit } from './delta';
 /** Provides functions to perform structural updates to JavaScript values */
 export declare namespace Value {
@@ -14,7 +14,7 @@ export declare namespace Value {
     /** Returns a structural clone of the given value */
     function Clone<T>(value: T): T;
     /** Returns an iterator for each error in this value. */
-    function Errors<T extends Types.TSchema>(schema: T, value: unknown): IterableIterator<ValueError>;
+    function Errors<T extends Types.TSchema>(schema: T, value: unknown): ValueErrorIterator;
     /** Returns true if left and right values are structurally equal */
     function Equal<T>(left: T, right: unknown): right is T;
     /** Returns edits to transform the current value into the next value */