@sinclair/typebox 0.24.37 → 0.24.40

package/compiler/compiler.js

@@ -151,6 +151,9 @@ var TypeCompiler;
             yield `(${value} === '${schema.const}')`;
         }
     }
+    function* Never(schema, value) {
+        yield `(false)`;
+    }
     function* Null(schema, value) {
         yield `(${value} === null)`;
     }
@@ -299,6 +302,8 @@ var TypeCompiler;
                 return yield* Integer(anySchema, value);
             case 'Literal':
                 return yield* Literal(anySchema, value);
+            case 'Never':
+                return yield* Never(anySchema, value);
             case 'Null':
                 return yield* Null(anySchema, value);
             case 'Number':

package/errors/errors.d.ts

@@ -13,34 +13,35 @@ export declare enum ValueErrorType {
     IntegerMinimum = 10,
     IntegerMaximum = 11,
     Literal = 12,
-    Null = 13,
-    Number = 14,
-    NumberMultipleOf = 15,
-    NumberExclusiveMinimum = 16,
-    NumberExclusiveMaximum = 17,
-    NumberMinumum = 18,
-    NumberMaximum = 19,
-    Object = 20,
-    ObjectMinProperties = 21,
-    ObjectMaxProperties = 22,
-    ObjectAdditionalProperties = 23,
-    Promise = 24,
-    RecordKeyNumeric = 25,
-    RecordKeyString = 26,
-    String = 27,
-    StringMinLength = 28,
-    StringMaxLength = 29,
-    StringPattern = 30,
-    StringFormatUnknown = 31,
-    StringFormat = 32,
-    TupleZeroLength = 33,
-    TupleLength = 34,
-    Undefined = 35,
-    Union = 36,
-    Uint8Array = 37,
-    Uint8ArrayMinByteLength = 38,
-    Uint8ArrayMaxByteLength = 39,
-    Void = 40
+    Never = 13,
+    Null = 14,
+    Number = 15,
+    NumberMultipleOf = 16,
+    NumberExclusiveMinimum = 17,
+    NumberExclusiveMaximum = 18,
+    NumberMinumum = 19,
+    NumberMaximum = 20,
+    Object = 21,
+    ObjectMinProperties = 22,
+    ObjectMaxProperties = 23,
+    ObjectAdditionalProperties = 24,
+    Promise = 25,
+    RecordKeyNumeric = 26,
+    RecordKeyString = 27,
+    String = 28,
+    StringMinLength = 29,
+    StringMaxLength = 30,
+    StringPattern = 31,
+    StringFormatUnknown = 32,
+    StringFormat = 33,
+    TupleZeroLength = 34,
+    TupleLength = 35,
+    Undefined = 36,
+    Union = 37,
+    Uint8Array = 38,
+    Uint8ArrayMinByteLength = 39,
+    Uint8ArrayMaxByteLength = 40,
+    Void = 41
 }
 export interface ValueError {
     type: ValueErrorType;

package/errors/errors.js

@@ -48,34 +48,35 @@ var ValueErrorType;
     ValueErrorType[ValueErrorType["IntegerMinimum"] = 10] = "IntegerMinimum";
     ValueErrorType[ValueErrorType["IntegerMaximum"] = 11] = "IntegerMaximum";
     ValueErrorType[ValueErrorType["Literal"] = 12] = "Literal";
-    ValueErrorType[ValueErrorType["Null"] = 13] = "Null";
-    ValueErrorType[ValueErrorType["Number"] = 14] = "Number";
-    ValueErrorType[ValueErrorType["NumberMultipleOf"] = 15] = "NumberMultipleOf";
-    ValueErrorType[ValueErrorType["NumberExclusiveMinimum"] = 16] = "NumberExclusiveMinimum";
-    ValueErrorType[ValueErrorType["NumberExclusiveMaximum"] = 17] = "NumberExclusiveMaximum";
-    ValueErrorType[ValueErrorType["NumberMinumum"] = 18] = "NumberMinumum";
-    ValueErrorType[ValueErrorType["NumberMaximum"] = 19] = "NumberMaximum";
-    ValueErrorType[ValueErrorType["Object"] = 20] = "Object";
-    ValueErrorType[ValueErrorType["ObjectMinProperties"] = 21] = "ObjectMinProperties";
-    ValueErrorType[ValueErrorType["ObjectMaxProperties"] = 22] = "ObjectMaxProperties";
-    ValueErrorType[ValueErrorType["ObjectAdditionalProperties"] = 23] = "ObjectAdditionalProperties";
-    ValueErrorType[ValueErrorType["Promise"] = 24] = "Promise";
-    ValueErrorType[ValueErrorType["RecordKeyNumeric"] = 25] = "RecordKeyNumeric";
-    ValueErrorType[ValueErrorType["RecordKeyString"] = 26] = "RecordKeyString";
-    ValueErrorType[ValueErrorType["String"] = 27] = "String";
-    ValueErrorType[ValueErrorType["StringMinLength"] = 28] = "StringMinLength";
-    ValueErrorType[ValueErrorType["StringMaxLength"] = 29] = "StringMaxLength";
-    ValueErrorType[ValueErrorType["StringPattern"] = 30] = "StringPattern";
-    ValueErrorType[ValueErrorType["StringFormatUnknown"] = 31] = "StringFormatUnknown";
-    ValueErrorType[ValueErrorType["StringFormat"] = 32] = "StringFormat";
-    ValueErrorType[ValueErrorType["TupleZeroLength"] = 33] = "TupleZeroLength";
-    ValueErrorType[ValueErrorType["TupleLength"] = 34] = "TupleLength";
-    ValueErrorType[ValueErrorType["Undefined"] = 35] = "Undefined";
-    ValueErrorType[ValueErrorType["Union"] = 36] = "Union";
-    ValueErrorType[ValueErrorType["Uint8Array"] = 37] = "Uint8Array";
-    ValueErrorType[ValueErrorType["Uint8ArrayMinByteLength"] = 38] = "Uint8ArrayMinByteLength";
-    ValueErrorType[ValueErrorType["Uint8ArrayMaxByteLength"] = 39] = "Uint8ArrayMaxByteLength";
-    ValueErrorType[ValueErrorType["Void"] = 40] = "Void";
+    ValueErrorType[ValueErrorType["Never"] = 13] = "Never";
+    ValueErrorType[ValueErrorType["Null"] = 14] = "Null";
+    ValueErrorType[ValueErrorType["Number"] = 15] = "Number";
+    ValueErrorType[ValueErrorType["NumberMultipleOf"] = 16] = "NumberMultipleOf";
+    ValueErrorType[ValueErrorType["NumberExclusiveMinimum"] = 17] = "NumberExclusiveMinimum";
+    ValueErrorType[ValueErrorType["NumberExclusiveMaximum"] = 18] = "NumberExclusiveMaximum";
+    ValueErrorType[ValueErrorType["NumberMinumum"] = 19] = "NumberMinumum";
+    ValueErrorType[ValueErrorType["NumberMaximum"] = 20] = "NumberMaximum";
+    ValueErrorType[ValueErrorType["Object"] = 21] = "Object";
+    ValueErrorType[ValueErrorType["ObjectMinProperties"] = 22] = "ObjectMinProperties";
+    ValueErrorType[ValueErrorType["ObjectMaxProperties"] = 23] = "ObjectMaxProperties";
+    ValueErrorType[ValueErrorType["ObjectAdditionalProperties"] = 24] = "ObjectAdditionalProperties";
+    ValueErrorType[ValueErrorType["Promise"] = 25] = "Promise";
+    ValueErrorType[ValueErrorType["RecordKeyNumeric"] = 26] = "RecordKeyNumeric";
+    ValueErrorType[ValueErrorType["RecordKeyString"] = 27] = "RecordKeyString";
+    ValueErrorType[ValueErrorType["String"] = 28] = "String";
+    ValueErrorType[ValueErrorType["StringMinLength"] = 29] = "StringMinLength";
+    ValueErrorType[ValueErrorType["StringMaxLength"] = 30] = "StringMaxLength";
+    ValueErrorType[ValueErrorType["StringPattern"] = 31] = "StringPattern";
+    ValueErrorType[ValueErrorType["StringFormatUnknown"] = 32] = "StringFormatUnknown";
+    ValueErrorType[ValueErrorType["StringFormat"] = 33] = "StringFormat";
+    ValueErrorType[ValueErrorType["TupleZeroLength"] = 34] = "TupleZeroLength";
+    ValueErrorType[ValueErrorType["TupleLength"] = 35] = "TupleLength";
+    ValueErrorType[ValueErrorType["Undefined"] = 36] = "Undefined";
+    ValueErrorType[ValueErrorType["Union"] = 37] = "Union";
+    ValueErrorType[ValueErrorType["Uint8Array"] = 38] = "Uint8Array";
+    ValueErrorType[ValueErrorType["Uint8ArrayMinByteLength"] = 39] = "Uint8ArrayMinByteLength";
+    ValueErrorType[ValueErrorType["Uint8ArrayMaxByteLength"] = 40] = "Uint8ArrayMaxByteLength";
+    ValueErrorType[ValueErrorType["Void"] = 41] = "Void";
 })(ValueErrorType = exports.ValueErrorType || (exports.ValueErrorType = {}));
 // -------------------------------------------------------------------
 // ValueErrors
@@ -149,6 +150,9 @@ var ValueErrors;
             return yield { type: ValueErrorType.Literal, schema, path, value, message: `Expected ${error}` };
         }
     }
+    function* Never(schema, references, path, value) {
+        yield { type: ValueErrorType.Never, schema, path, value, message: `Value cannot be validated` };
+    }
     function* Null(schema, references, path, value) {
         if (!(value === null)) {
             return yield { type: ValueErrorType.Null, schema, path, value, message: `Expected null` };
@@ -337,6 +341,8 @@ var ValueErrors;
                 return yield* Integer(anySchema, anyReferences, path, value);
             case 'Literal':
                 return yield* Literal(anySchema, anyReferences, path, value);
+            case 'Never':
+                return yield* Never(anySchema, anyReferences, path, value);
             case 'Null':
                 return yield* Null(anySchema, anyReferences, path, value);
             case 'Number':

package/guard/guard.d.ts

@@ -19,6 +19,8 @@ export declare namespace TypeGuard {
     function TInteger(schema: unknown): schema is Types.TInteger;
     /** Returns true if the given schema is TLiteral */
     function TLiteral(schema: unknown): schema is Types.TLiteral;
+    /** Returns true if the given schema is TNever */
+    function TNever(schema: unknown): schema is Types.TNever;
     /** Returns true if the given schema is TNull */
     function TNull(schema: unknown): schema is Types.TNull;
     /** Returns true if the given schema is TNumber */

package/guard/guard.js

@@ -153,6 +153,22 @@ var TypeGuard;
         return IsObject(schema) && schema[Types.Kind] === 'Literal' && IsOptionalString(schema.$id) && (IsString(schema.const) || IsNumber(schema.const) || IsBoolean(schema.const));
     }
     TypeGuard.TLiteral = TLiteral;
+    /** Returns true if the given schema is TNever */
+    function TNever(schema) {
+        return (IsObject(schema) &&
+            schema[Types.Kind] === 'Never' &&
+            IsArray(schema.allOf) &&
+            schema.allOf.length === 2 &&
+            IsObject(schema.allOf[0]) &&
+            IsString(schema.allOf[0].type) &&
+            schema.allOf[0].type === 'number' &&
+            schema.allOf[0].const === 0 &&
+            IsObject(schema.allOf[1]) &&
+            IsString(schema.allOf[1].type) &&
+            schema.allOf[1].type === 'number' &&
+            schema.allOf[1].const === 1);
+    }
+    TypeGuard.TNever = TNever;
     /** Returns true if the given schema is TNull */
     function TNull(schema) {
         return IsObject(schema) && schema[Types.Kind] === 'Null' && schema.type === 'null' && IsOptionalString(schema.$id);
@@ -302,6 +318,7 @@ var TypeGuard;
             TFunction(schema) ||
             TInteger(schema) ||
             TLiteral(schema) ||
+            TNever(schema) ||
             TNull(schema) ||
             TNumber(schema) ||
             TObject(schema) ||

package/package.json

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

package/readme.md

@@ -302,6 +302,17 @@ The following table lists the standard TypeBox types.
 │                                │                             │ }                              │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
+│ const T = Type.Never()         │ type T = never              │ const T = {                    │
+│                                │                             │   allOf: [{                    │
+│                                │                             │     type: 'number'             │
+│                                │                             │     const: 0                   │
+│                                │                             │   }, {                         │
+│                                │                             │     type: 'number'             │
+│                                │                             │     const: 1                   │
+│                                │                             │   }]                           │
+│                                │                             │ }                              │
+│                                │                             │                                │
+├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Record(         │ type T = Record<            │ const T = {                    │
 │   Type.String(),               │   string,                   │   type: 'object',              │
 │   Type.Number()                │   number,                   │   patternProperties: {         │
@@ -428,7 +439,7 @@ const T = Type.Array(Type.Integer(), { minItems: 5 })
 
 ### Extended
 
-In addition to JSON schema types, TypeBox provides several extended types that allow for `function` and `constructor` types to be composed. These additional types are not valid JSON Schema and will not validate using typical JSON Schema validation. However, these types can be used to frame JSON schema and describe callable interfaces that may receive JSON validated data. These types are as follows.
+In addition to JSON schema types, TypeBox provides several extended types that allow for the composition of `function` and `constructor` types. These additional types are not valid JSON Schema and will not validate using typical JSON Schema validation. However, these types can be used to frame JSON schema and describe callable interfaces that may receive JSON validated data. These types are as follows.
 
 ```typescript
 ┌────────────────────────────────┬─────────────────────────────┬────────────────────────────────┐

package/typebox.d.ts

@@ -104,7 +104,7 @@ export declare type IntersectEvaluate<T extends readonly TSchema[], P extends un
     [K in keyof T]: T[K] extends TSchema ? Static<T[K], P> : never;
 };
 export declare type IntersectProperties<T extends readonly TObject[]> = {
-    [K in keyof T]: T[K]['properties'];
+    [K in keyof T]: T[K] extends TObject<infer P> ? P : {};
 };
 export interface TIntersect<T extends TObject[] = TObject[]> extends TObject {
     static: IntersectReduce<unknown, IntersectEvaluate<T, this['params']>>;
@@ -125,6 +125,15 @@ export interface TLiteral<T extends TLiteralValue = TLiteralValue> extends TSche
     static: T;
     const: T;
 }
+export interface TNever extends TSchema {
+    [Kind]: 'Never';
+    static: never;
+    allOf: [{
+        const: 0;
+    }, {
+        const: 1;
+    }];
+}
 export interface TNull extends TSchema {
     [Kind]: 'Null';
     static: null;
@@ -323,6 +332,8 @@ export declare class TypeBuilder {
     KeyOf<T extends TObject>(object: T, options?: SchemaOptions): TUnion<TKeyOf<T>>;
     /** Creates a literal type. */
     Literal<T extends TLiteralValue>(value: T, options?: SchemaOptions): TLiteral<T>;
+    /** Creates a never type */
+    Never(options?: SchemaOptions): TNever;
     /** Creates a null type */
     Null(options?: SchemaOptions): TNull;
     /** Creates a number type */
@@ -366,6 +377,7 @@ export declare class TypeBuilder {
     /** Creates a undefined type */
     Undefined(options?: SchemaOptions): TUndefined;
     /** Creates a union type */
+    Union(items: [], options?: SchemaOptions): TNever;
     Union<T extends TSchema[]>(items: [...T], options?: SchemaOptions): TUnion<T>;
     /** Creates a Uint8Array type */
     Uint8Array(options?: Uint8ArrayOptions): TUint8Array;

package/typebox.js

@@ -153,6 +153,17 @@ class TypeBuilder {
     Literal(value, options = {}) {
         return this.Create({ ...options, [exports.Kind]: 'Literal', const: value, type: typeof value });
     }
+    /** Creates a never type */
+    Never(options = {}) {
+        return this.Create({
+            ...options,
+            [exports.Kind]: 'Never',
+            allOf: [
+                { type: 'number', const: 0 },
+                { type: 'number', const: 1 },
+            ],
+        });
+    }
     /** Creates a null type */
     Null(options = {}) {
         return this.Create({ ...options, [exports.Kind]: 'Null', type: 'null' });
@@ -315,9 +326,8 @@ class TypeBuilder {
     Undefined(options = {}) {
         return this.Create({ ...options, [exports.Kind]: 'Undefined', type: 'object', specialized: 'Undefined' });
     }
-    /** Creates a union type */
     Union(items, options = {}) {
-        return this.Create({ ...options, [exports.Kind]: 'Union', anyOf: items });
+        return items.length === 0 ? exports.Type.Never({ ...options }) : this.Create({ ...options, [exports.Kind]: 'Union', anyOf: items });
     }
     /** Creates a Uint8Array type */
     Uint8Array(options = {}) {

package/value/cast.d.ts

@@ -1,4 +1,21 @@
 import * as Types from '../typebox';
+export declare class ValueCastReferenceTypeError extends Error {
+    readonly schema: Types.TRef | Types.TSelf;
+    constructor(schema: Types.TRef | Types.TSelf);
+}
+export declare class ValueCastArrayUniqueItemsTypeError extends Error {
+    readonly schema: Types.TSchema;
+    readonly value: unknown;
+    constructor(schema: Types.TSchema, value: unknown);
+}
+export declare class ValueCastNeverTypeError extends Error {
+    readonly schema: Types.TSchema;
+    constructor(schema: Types.TSchema);
+}
+export declare class ValueCastRecursiveTypeError extends Error {
+    readonly schema: Types.TSchema;
+    constructor(schema: Types.TSchema);
+}
 export declare class ValueCastUnknownTypeError extends Error {
     readonly schema: Types.TSchema;
     constructor(schema: Types.TSchema);

package/value/cast.js

@@ -27,50 +27,83 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ValueCast = exports.ValueCastUnknownTypeError = void 0;
+exports.ValueCast = exports.ValueCastUnknownTypeError = exports.ValueCastRecursiveTypeError = exports.ValueCastNeverTypeError = exports.ValueCastArrayUniqueItemsTypeError = exports.ValueCastReferenceTypeError = void 0;
 const Types = require("../typebox");
 const create_1 = require("./create");
 const check_1 = require("./check");
-// --------------------------------------------------------------------------
-// Specialized Union Cast. Because a union can be one of many varying types
-// with properties potentially overlapping, we need a strategy to determine
-// which of those types we should cast into. This strategy needs to factor
-// the value provided by the user to make this decision.
-//
-// The following will score each union type found within the types anyOf
-// array. Typically this is executed for objects only, so the score is a
-// essentially a tally of how many properties are valid. The reasoning
-// here is the discriminator field would tip the scales in favor of that
-// union if other properties overlap and match.
-// --------------------------------------------------------------------------
 var UnionValueCast;
 (function (UnionValueCast) {
+    // ----------------------------------------------------------------------------------------------
+    // The following will score a schema against a value. For objects, the score is the tally of
+    // points awarded for each property of the value. Property points are (1.0 / propertyCount)
+    // to prevent large property counts biasing results. Properties that match literal values are
+    // maximally awarded as literals are typically used as union discriminator fields.
+    // ----------------------------------------------------------------------------------------------
     function Score(schema, references, value) {
-        let score = 0;
         if (schema[Types.Kind] === 'Object' && typeof value === 'object' && value !== null) {
-            const objectSchema = schema;
-            const entries = globalThis.Object.entries(objectSchema.properties);
-            score += entries.reduce((acc, [key, schema]) => acc + (check_1.ValueCheck.Check(schema, references, value[key]) ? 1 : 0), 0);
+            const object = schema;
+            const keys = Object.keys(value);
+            const entries = globalThis.Object.entries(object.properties);
+            const [point, max] = [1 / entries.length, entries.length];
+            return entries.reduce((acc, [key, schema]) => {
+                const literal = schema[Types.Kind] === 'Literal' && schema.const === value[key] ? max : 0;
+                const checks = check_1.ValueCheck.Check(schema, references, value[key]) ? point : 0;
+                const exists = keys.includes(key) ? point : 0;
+                return acc + (literal + checks + exists);
+            }, 0);
+        }
+        else {
+            return check_1.ValueCheck.Check(schema, references, value) ? 1 : 0;
         }
-        return score;
     }
-    function Select(schema, references, value) {
-        let select = schema.anyOf[0];
-        let best = 0;
-        for (const subschema of schema.anyOf) {
-            const score = Score(subschema, references, value);
+    function Select(union, references, value) {
+        let [select, best] = [union.anyOf[0], 0];
+        for (const schema of union.anyOf) {
+            const score = Score(schema, references, value);
             if (score > best) {
-                select = subschema;
+                select = schema;
                 best = score;
             }
         }
         return select;
     }
-    function Create(schema, references, value) {
-        return check_1.ValueCheck.Check(schema, references, value) ? value : ValueCast.Cast(Select(schema, references, value), references, value);
+    function Create(union, references, value) {
+        return check_1.ValueCheck.Check(union, references, value) ? value : ValueCast.Cast(Select(union, references, value), references, value);
     }
     UnionValueCast.Create = Create;
 })(UnionValueCast || (UnionValueCast = {}));
+// -----------------------------------------------------------
+// Errors
+// -----------------------------------------------------------
+class ValueCastReferenceTypeError extends Error {
+    constructor(schema) {
+        super(`ValueCast: Cannot locate referenced schema with $id '${schema.$ref}'`);
+        this.schema = schema;
+    }
+}
+exports.ValueCastReferenceTypeError = ValueCastReferenceTypeError;
+class ValueCastArrayUniqueItemsTypeError extends Error {
+    constructor(schema, value) {
+        super('ValueCast: Array cast produced invalid data due to uniqueItems constraint');
+        this.schema = schema;
+        this.value = value;
+    }
+}
+exports.ValueCastArrayUniqueItemsTypeError = ValueCastArrayUniqueItemsTypeError;
+class ValueCastNeverTypeError extends Error {
+    constructor(schema) {
+        super('ValueCast: Never types cannot be cast');
+        this.schema = schema;
+    }
+}
+exports.ValueCastNeverTypeError = ValueCastNeverTypeError;
+class ValueCastRecursiveTypeError extends Error {
+    constructor(schema) {
+        super('ValueCast.Recursive: Cannot cast recursive schemas');
+        this.schema = schema;
+    }
+}
+exports.ValueCastRecursiveTypeError = ValueCastRecursiveTypeError;
 class ValueCastUnknownTypeError extends Error {
     constructor(schema) {
         super('ValueCast: Unknown type');
@@ -81,8 +114,11 @@ exports.ValueCastUnknownTypeError = ValueCastUnknownTypeError;
 var ValueCast;
 (function (ValueCast) {
     // -----------------------------------------------------------
-    // Convert
+    // Guards
     // -----------------------------------------------------------
+    function IsArray(value) {
+        return typeof value === 'object' && globalThis.Array.isArray(value);
+    }
     function IsString(value) {
         return typeof value === 'string';
     }
@@ -107,6 +143,9 @@ var ValueCast;
     function IsValueFalse(value) {
         return value === false || (IsNumber(value) && value === 0) || (IsBigInt(value) && value === 0n) || (IsString(value) && (value.toLowerCase() === 'false' || value === '0'));
     }
+    // -----------------------------------------------------------
+    // Convert
+    // -----------------------------------------------------------
     function TryConvertString(value) {
         return IsValueToString(value) ? value.toString() : value;
     }
@@ -128,9 +167,16 @@ var ValueCast;
     function Array(schema, references, value) {
         if (check_1.ValueCheck.Check(schema, references, value))
             return value;
-        if (!globalThis.Array.isArray(value))
-            return create_1.ValueCreate.Create(schema, references);
-        return value.map((val) => Visit(schema.items, references, val));
+        const created = IsArray(value) ? value : create_1.ValueCreate.Create(schema, references);
+        const minimum = IsNumber(schema.minItems) && created.length < schema.minItems ? [...created, ...globalThis.Array.from({ length: schema.minItems - created.length }, () => null)] : created;
+        const maximum = IsNumber(schema.maxItems) && minimum.length > schema.maxItems ? minimum.slice(0, schema.maxItems) : minimum;
+        const casted = maximum.map((value) => Visit(schema.items, references, value));
+        if (schema.uniqueItems !== true)
+            return casted;
+        const unique = [...new Set(casted)];
+        if (!check_1.ValueCheck.Check(schema, references, unique))
+            throw new ValueCastArrayUniqueItemsTypeError(schema, unique);
+        return unique;
     }
     function Boolean(schema, references, value) {
         const conversion = TryConvertBoolean(value);
@@ -161,6 +207,9 @@ var ValueCast;
     function Literal(schema, references, value) {
         return check_1.ValueCheck.Check(schema, references, value) ? value : create_1.ValueCreate.Create(schema, references);
     }
+    function Never(schema, references, value) {
+        throw new ValueCastNeverTypeError(schema);
+    }
     function Null(schema, references, value) {
         return check_1.ValueCheck.Check(schema, references, value) ? value : create_1.ValueCreate.Create(schema, references);
     }
@@ -199,18 +248,18 @@ var ValueCast;
         return result;
     }
     function Recursive(schema, references, value) {
-        throw new Error('ValueCast.Recursive: Cannot cast recursive schemas');
+        throw new ValueCastRecursiveTypeError(schema);
     }
     function Ref(schema, references, value) {
         const reference = references.find((reference) => reference.$id === schema.$ref);
         if (reference === undefined)
-            throw new Error(`ValueCast.Ref: Cannot find schema with $id '${schema.$ref}'.`);
+            throw new ValueCastReferenceTypeError(schema);
         return Visit(reference, references, value);
     }
     function Self(schema, references, value) {
         const reference = references.find((reference) => reference.$id === schema.$ref);
         if (reference === undefined)
-            throw new Error(`ValueCast.Self: Cannot find schema with $id '${schema.$ref}'.`);
+            throw new ValueCastReferenceTypeError(schema);
         return Visit(reference, references, value);
     }
     function String(schema, references, value) {
@@ -261,6 +310,8 @@ var ValueCast;
                 return Integer(anySchema, anyReferences, value);
             case 'Literal':
                 return Literal(anySchema, anyReferences, value);
+            case 'Never':
+                return Never(anySchema, anyReferences, value);
             case 'Null':
                 return Null(anySchema, anyReferences, value);
             case 'Number':

package/value/check.js

@@ -93,6 +93,9 @@ var ValueCheck;
     function Literal(schema, references, value) {
         return value === schema.const;
     }
+    function Never(schema, references, value) {
+        return false;
+    }
     function Null(schema, references, value) {
         return value === null;
     }
@@ -275,6 +278,8 @@ var ValueCheck;
                 return Integer(anySchema, anyReferences, value);
             case 'Literal':
                 return Literal(anySchema, anyReferences, value);
+            case 'Never':
+                return Never(anySchema, anyReferences, value);
             case 'Null':
                 return Null(anySchema, anyReferences, value);
             case 'Number':

package/value/create.d.ts

@@ -3,6 +3,10 @@ export declare class ValueCreateUnknownTypeError extends Error {
     readonly schema: Types.TSchema;
     constructor(schema: Types.TSchema);
 }
+export declare class ValueCreateNeverTypeError extends Error {
+    readonly schema: Types.TSchema;
+    constructor(schema: Types.TSchema);
+}
 export declare namespace ValueCreate {
     /** Creates a value from the given schema. If the schema specifies a default value, then that value is returned. */
     function Visit<T extends Types.TSchema>(schema: T, references: Types.TSchema[]): Types.Static<T>;

package/value/create.js

@@ -27,7 +27,7 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ValueCreate = exports.ValueCreateUnknownTypeError = void 0;
+exports.ValueCreate = exports.ValueCreateNeverTypeError = exports.ValueCreateUnknownTypeError = void 0;
 const Types = require("../typebox");
 class ValueCreateUnknownTypeError extends Error {
     constructor(schema) {
@@ -36,6 +36,13 @@ class ValueCreateUnknownTypeError extends Error {
     }
 }
 exports.ValueCreateUnknownTypeError = ValueCreateUnknownTypeError;
+class ValueCreateNeverTypeError extends Error {
+    constructor(schema) {
+        super('ValueCreate: Never types cannot be created');
+        this.schema = schema;
+    }
+}
+exports.ValueCreateNeverTypeError = ValueCreateNeverTypeError;
 var ValueCreate;
 (function (ValueCreate) {
     function Any(schema, references) {
@@ -125,6 +132,9 @@ var ValueCreate;
     function Literal(schema, references) {
         return schema.const;
     }
+    function Never(schema, references) {
+        throw new ValueCreateNeverTypeError(schema);
+    }
     function Null(schema, references) {
         return null;
     }
@@ -303,6 +313,8 @@ var ValueCreate;
                 return Integer(anySchema, anyReferences);
             case 'Literal':
                 return Literal(anySchema, anyReferences);
+            case 'Never':
+                return Never(anySchema, anyReferences);
             case 'Null':
                 return Null(anySchema, anyReferences);
             case 'Number':

package/value/delta.js

@@ -122,7 +122,6 @@ var ValueDelta;
             return yield* Value(path, current, next);
         }
         else {
-            console.log('left', current);
             throw new Error('ValueDelta: Cannot produce edits for value');
         }
     }