z-schema 12.2.0 → 12.3.1

package/src/validation/string.ts

@@ -2,7 +2,7 @@ import type { JsonSchemaInternal } from '../json-schema-versions.js';
 import type { Report } from '../report.js';
 import type { ZSchemaBase } from '../z-schema-base.js';
 
-import { getFormatValidators } from '../format-validators.js';
+import { resolveFormatValidator } from '../format-validators.js';
 import { decodeBase64, isValidBase64 } from '../utils/base64.js';
 import { compileSchemaRegex } from '../utils/schema-regex.js';
 import { unicodeLength } from '../utils/unicode.js';
@@ -13,9 +13,9 @@ import { isFormatAssertionVocabEnabled, shouldSkipValidate } from './shared.js';
 // minLength
 // ---------------------------------------------------------------------------
 
-export function minLengthValidator(this: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
+export function minLengthValidator(ctx: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
   // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.2.2.2
-  if (shouldSkipValidate(this.validateOptions, ['MIN_LENGTH'])) {
+  if (shouldSkipValidate(ctx.validateOptions, ['MIN_LENGTH'])) {
     return;
   }
   if (typeof json !== 'string') {
@@ -30,9 +30,9 @@ export function minLengthValidator(this: ZSchemaBase, report: Report, schema: Js
 // maxLength
 // ---------------------------------------------------------------------------
 
-export function maxLengthValidator(this: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
+export function maxLengthValidator(ctx: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
   // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.2.1.2
-  if (shouldSkipValidate(this.validateOptions, ['MAX_LENGTH'])) {
+  if (shouldSkipValidate(ctx.validateOptions, ['MAX_LENGTH'])) {
     return;
   }
   if (typeof json !== 'string') {
@@ -47,9 +47,9 @@ export function maxLengthValidator(this: ZSchemaBase, report: Report, schema: Js
 // pattern
 // ---------------------------------------------------------------------------
 
-export function patternValidator(this: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
+export function patternValidator(ctx: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
   // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.2.3.2
-  if (shouldSkipValidate(this.validateOptions, ['PATTERN'])) {
+  if (shouldSkipValidate(ctx.validateOptions, ['PATTERN'])) {
     return;
   }
   if (typeof json !== 'string') {
@@ -70,27 +70,24 @@ export function patternValidator(this: ZSchemaBase, report: Report, schema: Json
 // format
 // ---------------------------------------------------------------------------
 
-export function formatValidator(this: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
+export function formatValidator(ctx: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
   // http://json-schema.org/latest/json-schema-validation.html#rfc.section.7.2
-  if (this.options.formatAssertions === false) {
+  if (ctx.options.formatAssertions === false) {
     return;
   }
 
   // When formatAssertions is explicitly true, respect the meta-schema vocabulary:
   // for draft 2019-09/2020-12, format is annotation-only unless the format-assertion
   // vocabulary is enabled in the meta-schema.
-  if (this.options.formatAssertions === true) {
-    if (!isFormatAssertionVocabEnabled(schema, report, this.options.version)) {
-      return;
-    }
+  if (ctx.options.formatAssertions === true && !isFormatAssertionVocabEnabled(schema, report, ctx.options.version)) {
+    return;
   }
 
-  const isModernDraft = this.options.version === 'draft2019-09' || this.options.version === 'draft2020-12';
+  const isModernDraft = ctx.options.version === 'draft2019-09' || ctx.options.version === 'draft2020-12';
 
-  const formatValidators = getFormatValidators(this.options);
-  const formatValidatorFn = formatValidators[schema.format!];
+  const formatValidatorFn = resolveFormatValidator(schema.format!, ctx.options);
   if (typeof formatValidatorFn === 'function') {
-    if (shouldSkipValidate(this.validateOptions, ['INVALID_FORMAT'])) {
+    if (shouldSkipValidate(ctx.validateOptions, ['INVALID_FORMAT'])) {
       return;
     }
     if (report.hasError('INVALID_TYPE', [schema.type, whatIs(json)])) {
@@ -98,40 +95,38 @@ export function formatValidator(this: ZSchemaBase, report: Report, schema: JsonS
     }
     if (formatValidatorFn.length === 2) {
       // callback-based async
-      report.addAsyncTaskWithPath(formatValidatorFn, [json], function (result) {
+      report.addAsyncTaskWithPath(formatValidatorFn, [json], (result) => {
         if (result !== true) {
           report.addError('INVALID_FORMAT', [schema.format!, JSON.stringify(json)], undefined, schema, 'format');
         }
       });
     } else {
-      const result = formatValidatorFn.call(this, json);
+      const result = formatValidatorFn.call(ctx, json);
       if (result instanceof Promise) {
         // Promise-based async
         const promiseResult = result;
         report.addAsyncTaskWithPath(
-          async (callback) => {
+          async (callback: (result: unknown) => void) => {
             try {
               const resolved = await promiseResult;
               callback(resolved);
-            } catch (_error) {
+            } catch {
               callback(false);
             }
           },
-          [] as any,
-          function (resolvedResult) {
+          [],
+          (resolvedResult) => {
             if (resolvedResult !== true) {
               report.addError('INVALID_FORMAT', [schema.format!, JSON.stringify(json)], undefined, schema, 'format');
             }
           }
         );
-      } else {
+      } else if (!result) {
         // sync
-        if (result !== true) {
-          report.addError('INVALID_FORMAT', [schema.format!, JSON.stringify(json)], undefined, schema, 'format');
-        }
+        report.addError('INVALID_FORMAT', [schema.format!, JSON.stringify(json)], undefined, schema, 'format');
       }
     }
-  } else if (this.options.ignoreUnknownFormats !== true && !isModernDraft) {
+  } else if (ctx.options.ignoreUnknownFormats !== true && !isModernDraft) {
     report.addError('UNKNOWN_FORMAT', [schema.format!], undefined, schema, 'format');
   }
 }
@@ -140,15 +135,15 @@ export function formatValidator(this: ZSchemaBase, report: Report, schema: JsonS
 // contentEncoding
 // ---------------------------------------------------------------------------
 
-export function contentEncodingValidator(this: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
-  if (this.options.version !== 'draft-07') {
+export function contentEncodingValidator(ctx: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
+  if (ctx.options.version !== 'draft-07') {
     return;
   }
   if (typeof json !== 'string') {
     return;
   }
 
-  const contentEncoding = schema.contentEncoding;
+  const { contentEncoding } = schema;
   if (contentEncoding !== 'base64') {
     return;
   }
@@ -168,20 +163,15 @@ export function contentEncodingValidator(this: ZSchemaBase, report: Report, sche
 // contentMediaType
 // ---------------------------------------------------------------------------
 
-export function contentMediaTypeValidator(
-  this: ZSchemaBase,
-  report: Report,
-  schema: JsonSchemaInternal,
-  json: unknown
-) {
-  if (this.options.version !== 'draft-07') {
+export function contentMediaTypeValidator(ctx: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
+  if (ctx.options.version !== 'draft-07') {
     return;
   }
   if (typeof json !== 'string') {
     return;
   }
 
-  const contentMediaType = schema.contentMediaType;
+  const { contentMediaType } = schema;
   if (contentMediaType !== 'application/json') {
     return;
   }

package/src/validation/type.ts

@@ -10,9 +10,9 @@ import { shouldSkipValidate } from './shared.js';
 // type
 // ---------------------------------------------------------------------------
 
-export function typeValidator(this: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
+export function typeValidator(ctx: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
   // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.5.2.2
-  if (shouldSkipValidate(this.validateOptions, ['INVALID_TYPE'])) {
+  if (shouldSkipValidate(ctx.validateOptions, ['INVALID_TYPE'])) {
     return;
   }
   const jsonType = whatIs(json);
@@ -20,10 +20,8 @@ export function typeValidator(this: ZSchemaBase, report: Report, schema: JsonSch
     if (jsonType !== schema.type && (jsonType !== 'integer' || schema.type !== 'number')) {
       report.addError('INVALID_TYPE', [schema.type, jsonType], undefined, schema, 'type');
     }
-  } else {
-    if (!schema.type!.includes(jsonType) && (jsonType !== 'integer' || !schema.type!.includes('number'))) {
-      report.addError('INVALID_TYPE', [JSON.stringify(schema.type), jsonType], undefined, schema, 'type');
-    }
+  } else if (!schema.type!.includes(jsonType) && (jsonType !== 'integer' || !schema.type!.includes('number'))) {
+    report.addError('INVALID_TYPE', [JSON.stringify(schema.type), jsonType], undefined, schema, 'type');
   }
 }
 
@@ -31,25 +29,27 @@ export function typeValidator(this: ZSchemaBase, report: Report, schema: JsonSch
 // enum
 // ---------------------------------------------------------------------------
 
-export function enumValidator(this: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
+export function enumValidator(ctx: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
   // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.5.1.2
-  if (shouldSkipValidate(this.validateOptions, ['ENUM_CASE_MISMATCH', 'ENUM_MISMATCH'])) {
+  if (shouldSkipValidate(ctx.validateOptions, ['ENUM_CASE_MISMATCH', 'ENUM_MISMATCH'])) {
     return;
   }
-  let match = false,
-    caseInsensitiveMatch = false;
+  const eqOpts = { maxDepth: ctx.options.maxRecursionDepth };
+  const eqOptsCI = { caseInsensitiveComparison: true, maxDepth: ctx.options.maxRecursionDepth };
+  let caseInsensitiveMatch = false,
+    match = false;
   for (const enumVal of schema.enum!) {
-    if (areEqual(json, enumVal, { maxDepth: this.options.maxRecursionDepth })) {
+    if (areEqual(json, enumVal, eqOpts)) {
       match = true;
       break;
-    } else if (areEqual(json, enumVal, { caseInsensitiveComparison: true, maxDepth: this.options.maxRecursionDepth })) {
+    } else if (areEqual(json, enumVal, eqOptsCI)) {
       caseInsensitiveMatch = true;
     }
   }
 
-  if (match === false) {
+  if (!match) {
     const error =
-      caseInsensitiveMatch && this.options.enumCaseInsensitiveComparison ? 'ENUM_CASE_MISMATCH' : 'ENUM_MISMATCH';
+      caseInsensitiveMatch && ctx.options.enumCaseInsensitiveComparison ? 'ENUM_CASE_MISMATCH' : 'ENUM_MISMATCH';
     report.addError(error, [JSON.stringify(json)], undefined, schema, 'enum');
   }
 }
@@ -58,9 +58,9 @@ export function enumValidator(this: ZSchemaBase, report: Report, schema: JsonSch
 // const
 // ---------------------------------------------------------------------------
 
-export function constValidator(this: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
+export function constValidator(ctx: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
   const constValue = schema.const;
-  if (areEqual(json, constValue, { maxDepth: this.options.maxRecursionDepth }) === false) {
-    report.addError('CONST', [JSON.stringify(constValue)], undefined, schema, undefined);
+  if (!areEqual(json, constValue, { maxDepth: ctx.options.maxRecursionDepth })) {
+    report.addError('CONST', [JSON.stringify(constValue)], undefined, schema);
   }
 }

package/src/z-schema-base.ts

@@ -1,10 +1,10 @@
-import type { ValidateError } from './errors.js';
+import type { Errors, ValidateError } from './errors.js';
 import type { FormatValidatorFn } from './format-validators.js';
 import type { JsonSchema, JsonSchemaInternal, JsonSchemaVersion } from './json-schema-versions.js';
 import type { SchemaErrorDetail } from './report.js';
 import type { ZSchemaOptions } from './z-schema-options.js';
 
-import { type Errors, getValidateError } from './errors.js';
+import { getValidateError } from './errors.js';
 import { getSupportedFormats } from './format-validators.js';
 import { VERSION_SCHEMA_URL_MAPPING } from './json-schema-versions.js';
 import { isInternalKey } from './json-schema.js';
@@ -26,7 +26,10 @@ export interface ValidateOptions {
   excludeErrors?: Array<keyof typeof Errors>;
 }
 
-export type ValidateResponse = { valid: boolean; err?: ValidateError };
+export interface ValidateResponse {
+  valid: boolean;
+  err?: ValidateError;
+}
 
 export type ValidateCallback = (err: ValidateResponse['err'], valid: ValidateResponse['valid']) => void;
 
@@ -62,7 +65,7 @@ export class ZSchemaBase {
    * create a circular dependency).
    */
   _jsonValidate(report: Report, schema: boolean | JsonSchemaInternal, json: unknown): boolean {
-    return validateJson.call(this, report, schema, json);
+    return validateJson(this, report, schema, json);
   }
 
   getDefaultSchemaId(): string {
@@ -73,8 +76,7 @@ export class ZSchemaBase {
 
   _validate(json: unknown, schema: JsonSchema | string, options: ValidateOptions, callback: ValidateCallback): void;
   _validate(json: unknown, schema: JsonSchema | string, callback: ValidateCallback): void;
-  _validate(json: unknown, schema: JsonSchema | string, options: ValidateOptions): true;
-  _validate(json: unknown, schema: JsonSchema | string): true;
+  _validate(json: unknown, schema: JsonSchema | string, options?: ValidateOptions): true;
   _validate(
     json: unknown,
     schema: JsonSchema | string,
@@ -93,10 +95,10 @@ export class ZSchemaBase {
 
     if (typeof schema !== 'string' && typeof schema !== 'boolean' && !isObject(schema)) {
       const e = new Error(
-        'Invalid .validate call - schema must be a string or object but ' + whatIs(schema) + ' was passed!'
+        `Invalid .validate call - schema must be a string or object but ${whatIs(schema)} was passed!`
       );
       if (callback) {
-        setTimeout(function () {
+        setTimeout(() => {
           callback(e, false);
         }, 0);
         return;
@@ -113,9 +115,9 @@ export class ZSchemaBase {
       const schemaName = schema;
       _schema = this.scache.getSchema(report, schemaName)!;
       if (!_schema) {
-        const e = new Error("Schema with id '" + schemaName + "' wasn't found in the validator cache!");
+        const e = new Error(`Schema with id '${schemaName}' wasn't found in the validator cache!`);
         if (callback) {
-          setTimeout(function () {
+          setTimeout(() => {
             callback(e, false);
           }, 0);
           return;
@@ -144,11 +146,11 @@ export class ZSchemaBase {
 
     if (options.schemaPath) {
       report.rootSchema = _schema;
-      _schema = get(_schema, options.schemaPath);
+      _schema = get(_schema, options.schemaPath) as JsonSchemaInternal;
       if (!_schema) {
-        const e = new Error("Schema path '" + options.schemaPath + "' wasn't found in the schema!");
+        const e = new Error(`Schema path '${options.schemaPath}' wasn't found in the schema!`);
         if (callback) {
-          setTimeout(function () {
+          setTimeout(() => {
             callback(e, false);
           }, 0);
           return;
@@ -158,7 +160,7 @@ export class ZSchemaBase {
     }
 
     if (!foundError) {
-      validateJson.call(this, report, _schema, json);
+      validateJson(this, report, _schema, json);
     }
 
     if (callback) {
@@ -187,13 +189,13 @@ export class ZSchemaBase {
     const report = new Report(this.options);
 
     if (Array.isArray(schemaOrArr)) {
-      const arr = this.scache.getSchema(report, schemaOrArr)!;
+      const arr = this.scache.getSchema(report, schemaOrArr);
       const compiled = this.sc.compileSchema(report, arr);
       if (compiled) {
         this.sv.validateSchema(report, arr);
       }
     } else {
-      const schema = this.scache.getSchema(report, schemaOrArr)!;
+      const schema = this.scache.getSchema(report, schemaOrArr);
       const compiled = this.sc.compileSchema(report, schema);
       if (compiled) {
         this.sv.validateSchema(report, schema);
@@ -256,11 +258,13 @@ export class ZSchemaBase {
    * @returns An array of unresolvable reference URIs.
    */
   getMissingReferences(err: ValidateError): string[] {
-    if (!err) return [];
+    if (!err) {
+      return [];
+    }
     const details = err.details || [];
     const missingRefs: string[] = [];
-    function collect(details: SchemaErrorDetail[]) {
-      for (const detail of details) {
+    function collect(items: SchemaErrorDetail[]) {
+      for (const detail of items) {
         if (detail.code === 'UNRESOLVABLE_REFERENCE' || detail.code === 'SCHEMA_NOT_REACHABLE') {
           missingRefs.push(detail.params[0] as string);
         }
@@ -281,9 +285,11 @@ export class ZSchemaBase {
   getMissingRemoteReferences(err: ValidateError) {
     const missingReferences = this.getMissingReferences(err);
     const missingRemoteReferences: string[] = [];
+    const seen = new Set<string>();
     for (const ref of missingReferences) {
       const remoteReference = getRemotePath(ref);
-      if (remoteReference && !missingRemoteReferences.includes(remoteReference)) {
+      if (remoteReference && !seen.has(remoteReference)) {
+        seen.add(remoteReference);
         missingRemoteReferences.push(remoteReference);
       }
     }
@@ -299,41 +305,46 @@ export class ZSchemaBase {
   getResolvedSchema(schemaId: string): JsonSchema | undefined {
     const report = new Report(this.options);
     const schema = this.scache.getSchemaByUri(report, schemaId);
-    if (!schema) return undefined;
+    if (!schema) {
+      return undefined;
+    }
 
     const clonedSchema = deepClone(schema, this.options.maxRecursionDepth);
 
     const visited = new WeakSet<object>();
 
     // clean-up the schema and resolve references
-    const cleanup = function (schema: any) {
-      let key;
-      const typeOf = whatIs(schema);
+    const cleanup = (node: unknown) => {
+      const typeOf = whatIs(node);
       if (typeOf !== 'object' && typeOf !== 'array') {
         return;
       }
 
-      if (visited.has(schema)) {
+      if (visited.has(node as object)) {
         return;
       }
 
-      visited.add(schema);
-
-      if (schema.$ref && schema.__$refResolved) {
-        const from = schema.__$refResolved;
-        const to = schema;
-        delete schema.$ref;
-        delete schema.__$refResolved;
-        for (key in from) {
-          copyProp(from, to, key);
+      visited.add(node as object);
+
+      const schemaNode = node as JsonSchemaInternal;
+      if (schemaNode.$ref && schemaNode.__$refResolved) {
+        const from = schemaNode.__$refResolved;
+        const to = schemaNode;
+        delete schemaNode.$ref;
+        delete schemaNode.__$refResolved;
+        for (const key in from) {
+          if (Object.hasOwn(from, key)) {
+            copyProp(from, to, key);
+          }
         }
       }
-      for (key in schema) {
-        if (Object.hasOwn(schema, key)) {
+      const record = node as Record<string, unknown>;
+      for (const key in record) {
+        if (Object.hasOwn(record, key)) {
           if (isInternalKey(key)) {
-            delete (schema as any)[key];
+            delete record[key];
           } else {
-            cleanup((schema as any)[key]);
+            cleanup(record[key]);
           }
         }
       }

package/src/z-schema-options.ts

@@ -1,7 +1,8 @@
 import type { FormatValidatorFn } from './format-validators.js';
+import type { JsonSchemaVersion } from './json-schema-versions.js';
 import type { Report } from './report.js';
 
-import { CURRENT_DEFAULT_SCHEMA_VERSION, type JsonSchemaVersion } from './json-schema-versions.js';
+import { CURRENT_DEFAULT_SCHEMA_VERSION } from './json-schema-versions.js';
 import { shallowClone } from './utils/clone.js';
 import { DEFAULT_MAX_RECURSION_DEPTH, MAX_ASYNC_TIMEOUT } from './utils/constants.js';
 
@@ -103,7 +104,7 @@ export const normalizeOptions = (options?: ZSchemaOptions) => {
     // check that the options are correctly configured
     for (const key of keys) {
       if (defaultOptions[key] === undefined) {
-        throw new Error('Unexpected option passed to constructor: ' + key);
+        throw new Error(`Unexpected option passed to constructor: ${key}`);
       }
     }
 
@@ -111,7 +112,7 @@ export const normalizeOptions = (options?: ZSchemaOptions) => {
     keys = Object.keys(defaultOptions) as Array<keyof ZSchemaOptions>;
     for (const key of keys) {
       if (options[key] === undefined) {
-        (options as any)[key] = shallowClone(defaultOptions[key]);
+        (options as Record<string, unknown>)[key] = shallowClone(defaultOptions[key]);
       }
     }
 

package/src/z-schema.ts

@@ -15,11 +15,6 @@ import { defaultOptions } from './z-schema-options.js';
 import { getSchemaReader, setSchemaReader } from './z-schema-reader.js';
 
 export class ZSchema extends ZSchemaBase {
-  /** @internal Use ZSchema.create() instead. */
-  constructor(options: ZSchemaOptions | undefined, token: symbol) {
-    super(options, token);
-  }
-
   // ----- static methods start -----
 
   // class scoped format functions
@@ -30,7 +25,7 @@ export class ZSchema extends ZSchemaBase {
    * @param validatorFunction - A sync or async function `(value: unknown) => boolean | Promise<boolean>`.
    */
   public static registerFormat(name: string, validatorFunction: FormatValidatorFn): void {
-    return registerFormat(name, validatorFunction);
+    registerFormat(name, validatorFunction);
   }
 
   /**
@@ -38,7 +33,7 @@ export class ZSchema extends ZSchemaBase {
    * @param name - The format name to unregister.
    */
   public static unregisterFormat(name: string): void {
-    return unregisterFormat(name);
+    unregisterFormat(name);
   }
 
   /** Returns the names of all globally registered format validators. */
@@ -72,7 +67,7 @@ export class ZSchema extends ZSchemaBase {
    * @param schemaReader - A function `(uri: string) => JsonSchema | undefined`, or `undefined` to clear.
    */
   public static setSchemaReader(schemaReader: SchemaReader | undefined) {
-    return setSchemaReader(schemaReader);
+    setSchemaReader(schemaReader);
   }
 
   public static schemaSymbol = schemaSymbol;
@@ -148,8 +143,8 @@ export class ZSchema extends ZSchemaBase {
     try {
       this._validate(json, schema, options ?? {});
       return { valid: true };
-    } catch (err) {
-      return { valid: false, err: err as ValidateError };
+    } catch (error) {
+      return { valid: false, err: error as ValidateError };
     }
   }
 
@@ -164,11 +159,15 @@ export class ZSchema extends ZSchemaBase {
   validateAsync(json: unknown, schema: JsonSchema | string, options?: ValidateOptions): Promise<true> {
     return new Promise((resolve, reject) => {
       try {
-        this._validate(json, schema, options || {}, (err, valid) =>
-          err || valid !== true ? reject(err) : resolve(valid)
-        );
-      } catch (err) {
-        reject(err);
+        this._validate(json, schema, options || {}, (err, valid) => {
+          if (err || !valid) {
+            reject(err ?? new Error('Validation failed'));
+          } else {
+            resolve(valid);
+          }
+        });
+      } catch (error) {
+        reject(error instanceof Error ? error : new Error(String(error), { cause: error }));
       }
     });
   }
@@ -187,8 +186,8 @@ export class ZSchema extends ZSchemaBase {
         this._validate(json, schema, options || {}, (err, valid) => {
           resolve({ valid, err });
         });
-      } catch (err) {
-        resolve({ valid: false, err: err as ValidateError });
+      } catch (error) {
+        resolve({ valid: false, err: error as ValidateError });
       }
     });
   }
@@ -212,8 +211,8 @@ export class ZSchema extends ZSchemaBase {
     try {
       this._validateSchema(schemaOrArr);
       return { valid: true };
-    } catch (err) {
-      return { valid: false, err: err as ValidateError };
+    } catch (error) {
+      return { valid: false, err: error as ValidateError };
     }
   }
 }
@@ -223,11 +222,6 @@ export class ZSchema extends ZSchemaBase {
  * Created via `ZSchema.create({ safe: true })`.
  */
 export class ZSchemaSafe extends ZSchemaBase {
-  /** @internal Use ZSchema.create() instead. */
-  constructor(options: ZSchemaOptions | undefined, token: symbol) {
-    super(options, token);
-  }
-
   /**
    * Validate JSON data against a schema.
    * @param json - The data to validate.
@@ -239,8 +233,8 @@ export class ZSchemaSafe extends ZSchemaBase {
     try {
       this._validate(json, schema, options);
       return { valid: true };
-    } catch (err) {
-      return { valid: false, err: err as ValidateError };
+    } catch (error) {
+      return { valid: false, err: error as ValidateError };
     }
   }
 
@@ -253,8 +247,8 @@ export class ZSchemaSafe extends ZSchemaBase {
     try {
       this._validateSchema(schemaOrArr);
       return { valid: true };
-    } catch (err) {
-      return { valid: false, err: err as ValidateError };
+    } catch (error) {
+      return { valid: false, err: error as ValidateError };
     }
   }
 }
@@ -264,11 +258,6 @@ export class ZSchemaSafe extends ZSchemaBase {
  * Created via `ZSchema.create({ async: true })`.
  */
 export class ZSchemaAsync extends ZSchemaBase {
-  /** @internal Use ZSchema.create() instead. */
-  constructor(options: ZSchemaOptions | undefined, token: symbol) {
-    super(options, token);
-  }
-
   /**
    * Validate JSON data against a schema asynchronously.
    * @param json - The data to validate.
@@ -280,9 +269,15 @@ export class ZSchemaAsync extends ZSchemaBase {
   validate(json: unknown, schema: JsonSchema | string, options: ValidateOptions = {}): Promise<true> {
     return new Promise((resolve, reject) => {
       try {
-        this._validate(json, schema, options, (err, valid) => (err || valid !== true ? reject(err) : resolve(valid)));
-      } catch (err) {
-        reject(err);
+        this._validate(json, schema, options, (err, valid) => {
+          if (err || !valid) {
+            reject(err ?? new Error('Validation failed'));
+          } else {
+            resolve(valid);
+          }
+        });
+      } catch (error) {
+        reject(error instanceof Error ? error : new Error(String(error), { cause: error }));
       }
     });
   }
@@ -303,11 +298,6 @@ export class ZSchemaAsync extends ZSchemaBase {
  * Created via `ZSchema.create({ async: true, safe: true })`.
  */
 export class ZSchemaAsyncSafe extends ZSchemaBase {
-  /** @internal Use ZSchema.create() instead. */
-  constructor(options: ZSchemaOptions | undefined, token: symbol) {
-    super(options, token);
-  }
-
   /**
    * Validate JSON data against a schema asynchronously.
    * The promise always resolves (never rejects).
@@ -322,8 +312,8 @@ export class ZSchemaAsyncSafe extends ZSchemaBase {
         this._validate(json, schema, options, (err, valid) => {
           resolve({ valid, err });
         });
-      } catch (err) {
-        resolve({ valid: false, err: err as ValidateError });
+      } catch (error) {
+        resolve({ valid: false, err: error as ValidateError });
       }
     });
   }
@@ -337,8 +327,8 @@ export class ZSchemaAsyncSafe extends ZSchemaBase {
     try {
       this._validateSchema(schemaOrArr);
       return { valid: true };
-    } catch (err) {
-      return { valid: false, err: err as ValidateError };
+    } catch (error) {
+      return { valid: false, err: error as ValidateError };
     }
   }
 }