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

package/compiler/compiler.d.ts

@@ -1,15 +1,15 @@
 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;
     private readonly checkFunc;
     private readonly code;
     constructor(schema: T, checkFunc: CheckFunction, code: string);
-    /** Returns the generated validation code used to validate this type. */
+    /** 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>;
 }
@@ -26,7 +26,7 @@ export declare class TypeCompilerPreflightCheckError extends Error {
 }
 /** Compiles Types for Runtime Type Checking */
 export declare namespace TypeCompiler {
-    /** Returns the generated validation code used to validate this type. */
+    /** Returns the generated assertion code used to validate this type. */
     function Code<T extends Types.TSchema>(schema: T): string;
     /** Compiles the given type for runtime type checking. This compiler only accepts known TypeBox types non-inclusive of unsafe types. */
     function Compile<T extends Types.TSchema>(schema: T): TypeCheck<T>;

package/compiler/compiler.js

@@ -41,7 +41,7 @@ class TypeCheck {
         this.checkFunc = checkFunc;
         this.code = code;
     }
-    /** Returns the generated validation code used to validate this type. */
+    /** Returns the generated assertion code used to validate this type. */
     Code() {
         return this.code;
     }
@@ -504,7 +504,7 @@ var TypeCompiler;
         const locals = GetLocals();
         return `${locals.join('\n')}\nreturn ${check}`;
     }
-    /** Returns the generated validation code used to validate this type. */
+    /** Returns the generated assertion code used to validate this type. */
     function Code(schema) {
         if (!Types.TypeGuard.TSchema(schema))
             throw new TypeCompilerPreflightCheckError(schema);

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",
+  "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'           │
+│                                │                             │     }                          │
 │                                │                             │   }                            │
 │                                │                             │ }                              │
 │                                │                             │                                │
@@ -777,7 +777,7 @@ const T = Type.Unsafe<string>({ type: 'number' })    // const T = {
 type T = Static<typeof T>                            // type T = string
 ```
 
-The `Type.Unsafe(...)` type allows specific or non-standard OpenAPI schematics can be constructed.
+The `Type.Unsafe(...)` type allows for the expression of specific OpenAPI schema representations.
 
 ```typescript
 import { Type, Static, TSchema } from '@sinclair/typebox'
@@ -812,7 +812,7 @@ type T = Static<typeof T>                            // type T = 'A' | 'B' | 'C'
 
 ### Guards
 
-TypeBox provides a `TypeGuard` module used for type value assertions and reflection.
+TypeBox provides a `TypeGuard` module for reflection and type assertion.
 
 ```typescript
 import { Type, TypeGuard } from '@sinclair/typebox'
@@ -1029,15 +1029,15 @@ ValuePointer.Set(A, '/z', 1)                         // const A = { x: 1, y: 1,
 
 ## TypeCheck
 
-TypeBox types targets JSON Schema draft 6 so is immediately compatible with any validator that supports this specification. TypeBox also provides a built in type checking compiler designed specifically for high performance compilation and value assertion.
+TypeBox types target JSON Schema draft 6 so are compatible with any validator that supports this specification. TypeBox also provides a built in type checking compiler designed specifically for high performance compilation and value assertion.
 
-The following details using both Ajv and TypeBox's compiler infrastructure.
+The following sections detail using Ajv and TypeBox's compiler infrastructure.
 
 <a name='typecheck-ajv'></a>
 
 ## Ajv
 
-The following shows the recommended setup for Ajv with additional string formats.
+The following shows the recommended setup for Ajv.
 
 ```bash
 $ npm install ajv ajv-formats --save
@@ -1078,7 +1078,7 @@ const R = C({ x: 1, y: 2, z: 3 })                    // const R = true
 
 ### TypeCompiler
 
-The TypeBox TypeCompiler is a high performance JIT compiler that compiles TypeBox types into optimized JavaScript validation routines. The compiler is tuned both for fast compilation and value assertion. It is designed primarily for integrating into application frameworks but can also be used as a general purpose validator.
+The TypeBox TypeCompiler is a high performance JIT compiler that transforms TypeBox types into optimized JavaScript validation routines. The compiler is tuned for fast compilation as well as fast value assertion. It is designed to serve as a validation backend that can be integrated into larger applications; but can also be used as a general purpose validator.
 
 The TypeCompiler is provided as an optional import.
 
@@ -1098,7 +1098,7 @@ const C = TypeCompiler.Compile(Type.Object({         // const C: TypeCheck<TObje
 const R = C.Check({ x: 1, y: 2, z: 3 })              // const R = true
 ```
 
-Use the `Errors(...)` function to produce diagnostics for a value. The `Errors(...)` function will return an iterator that will perform an exhaustive check across the value and yield any error found. For performance, this function should only be called after failed `Check(...)`.
+Use the `Errors(...)` function to produce diagnostic errors for a value. The `Errors(...)` function will return an iterator that if enumerated; will perform an exhaustive check across the entire value and yield any error found. For performance, this function should only be called after failed `Check(...)`. Applications may also choose to yield only the first value to avoid exhaustive error generation.
 
 ```typescript
 const C = TypeCompiler.Compile(Type.Object({         // const C: TypeCheck<TObject<{
@@ -1181,7 +1181,7 @@ const R = Value.Check(T, { x: 1, y: 2 })              // const R = true
 
 ### Formats
 
-Use the `Format(...)` function to create a custom string formats. The following creates a custom string format that checks for lowercase strings.
+Use the `Format(...)` function to create a custom string format. The following creates a custom string format that checks for lowercase strings.
 
 ```typescript
 TypeSystem.Format('lowercase', value => value === value.toLowerCase()) // format should be lowercase

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;
@@ -542,11 +545,11 @@ export declare class StandardTypeBuilder extends TypeBuilder {
     Deref<T extends TRef>(schema: T): TDeref<T>;
     /** `[Standard]` Creates a Enum type */
     Enum<T extends Record<string, string | number>>(item: T, options?: SchemaOptions): TEnum<T>;
-    /** `[Standard]` A conditional type expression that will return the true type if the left extends the right */
+    /** `[Standard]` A conditional type expression that will return the true type if the left type extends the right */
     Extends<L extends TSchema, R extends TSchema, T extends TSchema, U extends TSchema>(left: L, right: R, trueType: T, falseType: U, options?: SchemaOptions): TExtends<L, R, T, U>;
-    /** `[Standard]` Excludes from left any type that is not assignable to the right. */
+    /** `[Standard]` Excludes from the left type any type that is not assignable to the right */
     Exclude<L extends TSchema, R extends TSchema>(left: L, right: R, options?: SchemaOptions): TExclude<L, R>;
-    /** `[Standard]` Extracts from left any type that is assignable to the right. */
+    /** `[Standard]` Extracts from left left any type that is assignable to the right */
     Extract<L extends TSchema, R extends TSchema>(left: L, right: R, options?: SchemaOptions): TExtract<L, R>;
     /** `[Standard]` Creates an Integer type */
     Integer(options?: NumericOptions<number>): TInteger;
@@ -567,7 +570,7 @@ export declare class StandardTypeBuilder extends TypeBuilder {
     Null(options?: SchemaOptions): TNull;
     /** `[Standard]` Creates a Number type */
     Number(options?: NumericOptions<number>): TNumber;
-    /** `[Standard]` Creates a Object type */
+    /** `[Standard]` Creates an Object type */
     Object<T extends TProperties>(properties: T, options?: ObjectOptions): TObject<T>;
     /** `[Standard]` Creates a mapped type whose keys are omitted from the given type */
     Omit<T extends TSchema, K extends (keyof Static<T>)[]>(schema: T, keys: readonly [...K], options?: SchemaOptions): TOmit<T, K[number]>;
@@ -607,7 +610,7 @@ export declare class StandardTypeBuilder extends TypeBuilder {
     Unsafe<T>(options?: UnsafeOptions): TUnsafe<T>;
 }
 export declare class ExtendedTypeBuilder extends StandardTypeBuilder {
-    /** `[Extended]` Creates a BigInt */
+    /** `[Extended]` Creates a BigInt type */
     BigInt(options?: NumericOptions<bigint>): TBigInt;
     /** `[Extended]` Extracts the ConstructorParameters from the given Constructor type */
     ConstructorParameters<T extends TConstructor<any[], any>>(schema: T, options?: SchemaOptions): TConstructorParameters<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();
@@ -85,7 +86,7 @@ var ReferenceRegistry;
     function DerefOne(schema) {
         if (TypeGuard.TRef(schema) || TypeGuard.TSelf(schema)) {
             if (!references.has(schema.$ref))
-                throw Error(`ReferenceRegistry: Cannot deref schema with $id '${schema.$ref}`);
+                throw Error(`ReferenceRegistry: Cannot deref schema with $id '${schema.$ref}'`);
             return references.get(schema.$ref);
         }
         else {
@@ -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 };
     }
@@ -1503,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 = {}) {
@@ -1521,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;
             }
         }
@@ -1538,7 +1544,7 @@ class StandardTypeBuilder extends TypeBuilder {
         const anyOf = values.map((value) => (typeof value === 'string' ? { [exports.Kind]: 'Literal', type: 'string', const: value } : { [exports.Kind]: 'Literal', type: 'number', const: value }));
         return this.Create({ ...options, [exports.Kind]: 'Union', anyOf });
     }
-    /** `[Standard]` A conditional type expression that will return the true type if the left extends the right */
+    /** `[Standard]` A conditional type expression that will return the true type if the left type extends the right */
     Extends(left, right, trueType, falseType, options = {}) {
         switch (TypeExtends.Extends(ReferenceRegistry.Deref(left), ReferenceRegistry.Deref(right))) {
             case TypeExtendsResult.Union:
@@ -1549,7 +1555,7 @@ class StandardTypeBuilder extends TypeBuilder {
                 return TypeClone.Clone(falseType, options);
         }
     }
-    /** `[Standard]` Excludes from left any type that is not assignable to the right. */
+    /** `[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);
@@ -1559,7 +1565,7 @@ class StandardTypeBuilder extends TypeBuilder {
             return (TypeExtends.Extends(left, right) !== TypeExtendsResult.False ? this.Never(options) : TypeClone.Clone(left, options));
         }
     }
-    /** `[Standard]` Extracts from left any type that is assignable to the right. */
+    /** `[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);
@@ -1608,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 = {}) {
@@ -1618,16 +1624,19 @@ class StandardTypeBuilder extends TypeBuilder {
     Number(options = {}) {
         return this.Create({ ...options, [exports.Kind]: 'Number', type: 'number' });
     }
-    /** `[Standard]` Creates a Object type */
+    /** `[Standard]` Creates an Object type */
     Object(properties, options = {}) {
         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: TypeClone.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: TypeClone.Clone(properties, {}) });
+            return this.Create({ ...options, [exports.Kind]: 'Object', type: 'object', properties: clonedProperties });
         }
     }
     Omit(schema, unresolved, options = {}) {
@@ -1691,7 +1700,7 @@ 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');
@@ -1709,7 +1718,7 @@ class StandardTypeBuilder extends TypeBuilder {
             ...options,
             [exports.Kind]: 'Record',
             type: 'object',
-            patternProperties: { [pattern]: schema },
+            patternProperties: { [pattern]: TypeClone.Clone(schema, {}) },
             additionalProperties: false,
         });
     }
@@ -1720,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 */
@@ -1761,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);
     }
@@ -1772,8 +1782,8 @@ class StandardTypeBuilder extends TypeBuilder {
             return this.Never(options);
         if (anyOf.length === 1)
             return TypeClone.Clone(anyOf[0], options);
-        const cloned = anyOf.map((schema) => TypeClone.Clone(schema, {}));
-        return this.Create({ ...options, [exports.Kind]: 'Union', anyOf: cloned });
+        const clonedAnyOf = anyOf.map((schema) => TypeClone.Clone(schema, {}));
+        return this.Create({ ...options, [exports.Kind]: 'Union', anyOf: clonedAnyOf });
     }
     /** `[Standard]` Creates an Unknown type */
     Unknown(options = {}) {
@@ -1789,7 +1799,7 @@ exports.StandardTypeBuilder = StandardTypeBuilder;
 // TypeBuilder
 // -------------------------------------------------------------------------------------
 class ExtendedTypeBuilder extends StandardTypeBuilder {
-    /** `[Extended]` Creates a BigInt */
+    /** `[Extended]` Creates a BigInt type */
     BigInt(options = {}) {
         return this.Create({ ...options, [exports.Kind]: 'BigInt', type: 'null', typeOf: 'BigInt' });
     }
@@ -1798,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 */
@@ -1814,15 +1826,17 @@ 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 */
@@ -1835,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 = {}) {

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 */