z-schema 12.0.4 → 12.1.0

package/dist/validation/array.mjs

@@ -0,0 +1,57 @@
+import { isUniqueArray } from "../utils/array.mjs";
+import { cacheValidationResult, deferOrRunSync, shouldSkipValidate } from "./shared.mjs";
+//#region src/validation/array.ts
+function additionalItemsValidator(report, schema, json) {
+	if (shouldSkipValidate(this.validateOptions, ["ARRAY_ADDITIONAL_ITEMS"])) return;
+	if (!Array.isArray(json)) return;
+	if (schema.additionalItems === false && Array.isArray(schema.items)) {
+		if (json.length > schema.items.length) report.addError("ARRAY_ADDITIONAL_ITEMS", void 0, void 0, schema, "additionalItems");
+	}
+}
+function itemsValidator() {}
+function prefixItemsValidator() {}
+function maxItemsValidator(report, schema, json) {
+	if (shouldSkipValidate(this.validateOptions, ["ARRAY_LENGTH_LONG"])) return;
+	if (!Array.isArray(json)) return;
+	if (json.length > schema.maxItems) report.addError("ARRAY_LENGTH_LONG", [json.length, schema.maxItems], void 0, schema, "maxItems");
+}
+function minItemsValidator(report, schema, json) {
+	if (shouldSkipValidate(this.validateOptions, ["ARRAY_LENGTH_SHORT"])) return;
+	if (!Array.isArray(json)) return;
+	if (json.length < schema.minItems) report.addError("ARRAY_LENGTH_SHORT", [json.length, schema.minItems], void 0, schema, "minItems");
+}
+function uniqueItemsValidator(report, schema, json) {
+	if (shouldSkipValidate(this.validateOptions, ["ARRAY_UNIQUE"])) return;
+	if (!Array.isArray(json)) return;
+	if (schema.uniqueItems === true) {
+		const matches = [];
+		if (isUniqueArray(json, matches, this.options.maxRecursionDepth) === false) report.addError("ARRAY_UNIQUE", matches, void 0, schema, "uniqueItems");
+	}
+}
+function containsValidator(report, schema, json) {
+	if (shouldSkipValidate(this.validateOptions, ["CONTAINS"])) return;
+	if (!Array.isArray(json)) return;
+	const containsSchema = schema.contains;
+	if (containsSchema === void 0) return;
+	const Report_ = report.constructor;
+	const subReports = [];
+	for (let idx = 0; idx < json.length; idx++) {
+		const subReport = new Report_(report);
+		subReports.push(subReport);
+		this._jsonValidate(subReport, containsSchema, json[idx]);
+		cacheValidationResult(report, containsSchema, json[idx], subReport.errors.length === 0);
+	}
+	const addContainsErrorIfNeeded = () => {
+		let matchingItems = 0;
+		for (const subReport of subReports) if (subReport.errors.length === 0) matchingItems += 1;
+		const supportsContainsBounds = this.options.version === "draft2019-09" || this.options.version === "draft2020-12";
+		const minContains = supportsContainsBounds && typeof schema.minContains === "number" ? schema.minContains ?? 1 : 1;
+		const maxContains = supportsContainsBounds && typeof schema.maxContains === "number" ? schema.maxContains : void 0;
+		if (!(matchingItems >= minContains) || !(maxContains === void 0 || matchingItems <= maxContains)) report.addError("CONTAINS", void 0, subReports, schema, void 0);
+	};
+	deferOrRunSync(report, subReports, addContainsErrorIfNeeded);
+}
+function maxContainsValidator() {}
+function minContainsValidator() {}
+//#endregion
+export { additionalItemsValidator, containsValidator, itemsValidator, maxContainsValidator, maxItemsValidator, minContainsValidator, minItemsValidator, prefixItemsValidator, uniqueItemsValidator };

package/dist/validation/combinators.mjs

@@ -0,0 +1,62 @@
+import { Report } from "../report.mjs";
+import { cacheValidationResult, deferOrRunSync } from "./shared.mjs";
+//#region src/validation/combinators.ts
+function allOfValidator(report, schema, json) {
+	for (let i = 0; i < schema.allOf.length; i++) {
+		const validateResult = this._jsonValidate(report, schema.allOf[i], json);
+		if (this.options.breakOnFirstError && validateResult === false) break;
+	}
+}
+function anyOfValidator(report, schema, json) {
+	const subReports = [];
+	for (let i = 0; i < schema.anyOf.length; i++) {
+		const subReport = new Report(report);
+		subReports.push(subReport);
+		this._jsonValidate(subReport, schema.anyOf[i], json);
+		cacheValidationResult(report, schema.anyOf[i], json, subReport.errors.length === 0);
+	}
+	deferOrRunSync(report, subReports, () => {
+		let passed = false;
+		for (const subReport of subReports) if (subReport.errors.length === 0) {
+			passed = true;
+			break;
+		}
+		if (passed === false) report.addError("ANY_OF_MISSING", void 0, subReports, schema, "anyOf");
+	});
+}
+function oneOfValidator(report, schema, json) {
+	const subReports = [];
+	for (let i = 0; i < schema.oneOf.length; i++) {
+		const subReport = new Report(report);
+		subReports.push(subReport);
+		this._jsonValidate(subReport, schema.oneOf[i], json);
+		cacheValidationResult(report, schema.oneOf[i], json, subReport.errors.length === 0);
+	}
+	deferOrRunSync(report, subReports, () => {
+		let passes = 0;
+		for (const subReport of subReports) if (subReport.errors.length === 0) passes++;
+		if (passes === 0) report.addError("ONE_OF_MISSING", void 0, subReports, schema, "oneOf");
+		else if (passes > 1) report.addError("ONE_OF_MULTIPLE", void 0, void 0, schema, "oneOf");
+	});
+}
+function notValidator(report, schema, json) {
+	const subReport = new Report(report);
+	if (this._jsonValidate(subReport, schema.not, json) === true) report.addError("NOT_PASSED", void 0, void 0, schema, "not");
+}
+function ifValidator(report, schema, json) {
+	if (this.options.version === "draft-04" || this.options.version === "draft-06") return;
+	const conditionSchema = schema.if;
+	const thenSchema = schema.then;
+	const elseSchema = schema.else;
+	if (conditionSchema === void 0 || thenSchema === void 0 && elseSchema === void 0) return;
+	const conditionReport = new Report(report);
+	this._jsonValidate(conditionReport, conditionSchema, json);
+	cacheValidationResult(report, conditionSchema, json, conditionReport.errors.length === 0);
+	const branchSchema = conditionReport.errors.length === 0 ? thenSchema : elseSchema;
+	if (branchSchema === void 0) return;
+	this._jsonValidate(report, branchSchema, json);
+}
+function thenValidator() {}
+function elseValidator() {}
+//#endregion
+export { allOfValidator, anyOfValidator, elseValidator, ifValidator, notValidator, oneOfValidator, thenValidator };

package/dist/validation/numeric.mjs

@@ -0,0 +1,38 @@
+import { shouldSkipValidate } from "./shared.mjs";
+//#region src/validation/numeric.ts
+function multipleOfValidator(report, schema, json) {
+	if (shouldSkipValidate(this.validateOptions, ["MULTIPLE_OF"])) return;
+	if (typeof json !== "number") return;
+	const result = json / schema.multipleOf;
+	if (!Number.isFinite(result) || Math.abs(result - Math.round(result)) >= 1e-10) report.addError("MULTIPLE_OF", [json, schema.multipleOf], void 0, schema, "multipleOf");
+}
+function maximumValidator(report, schema, json) {
+	if (shouldSkipValidate(this.validateOptions, ["MAXIMUM", "MAXIMUM_EXCLUSIVE"])) return;
+	if (typeof json !== "number") return;
+	if (schema.exclusiveMaximum !== true) {
+		if (json > schema.maximum) report.addError("MAXIMUM", [json, schema.maximum], void 0, schema, "maximum");
+	} else if (json >= schema.maximum) report.addError("MAXIMUM_EXCLUSIVE", [json, schema.maximum], void 0, schema, "maximum");
+}
+function exclusiveMaximumValidator(report, schema, json) {
+	if (typeof schema.exclusiveMaximum === "number") {
+		if (shouldSkipValidate(this.validateOptions, ["MAXIMUM_EXCLUSIVE"])) return;
+		if (typeof json !== "number") return;
+		if (json >= schema.exclusiveMaximum) report.addError("MAXIMUM_EXCLUSIVE", [json, schema.exclusiveMaximum], void 0, schema, "exclusiveMaximum");
+	}
+}
+function minimumValidator(report, schema, json) {
+	if (shouldSkipValidate(this.validateOptions, ["MINIMUM", "MINIMUM_EXCLUSIVE"])) return;
+	if (typeof json !== "number") return;
+	if (schema.exclusiveMinimum !== true) {
+		if (json < schema.minimum) report.addError("MINIMUM", [json, schema.minimum], void 0, schema, "minimum");
+	} else if (json <= schema.minimum) report.addError("MINIMUM_EXCLUSIVE", [json, schema.minimum], void 0, schema, "minimum");
+}
+function exclusiveMinimumValidator(report, schema, json) {
+	if (typeof schema.exclusiveMinimum === "number") {
+		if (shouldSkipValidate(this.validateOptions, ["MINIMUM_EXCLUSIVE"])) return;
+		if (typeof json !== "number") return;
+		if (json <= schema.exclusiveMinimum) report.addError("MINIMUM_EXCLUSIVE", [json, schema.exclusiveMinimum], void 0, schema, "exclusiveMinimum");
+	}
+}
+//#endregion
+export { exclusiveMaximumValidator, exclusiveMinimumValidator, maximumValidator, minimumValidator, multipleOfValidator };

package/dist/validation/object.mjs

@@ -0,0 +1,109 @@
+import { isObject } from "../utils/what-is.mjs";
+import { compileSchemaRegex } from "../utils/schema-regex.mjs";
+import { difference } from "../utils/array.mjs";
+import { deferOrRunSync, shouldSkipValidate, supportsDependentKeywords } from "./shared.mjs";
+//#region src/validation/object.ts
+function maxPropertiesValidator(report, schema, json) {
+	if (shouldSkipValidate(this.validateOptions, ["OBJECT_PROPERTIES_MAXIMUM"])) return;
+	if (!isObject(json)) return;
+	const keysCount = Object.keys(json).length;
+	if (keysCount > schema.maxProperties) report.addError("OBJECT_PROPERTIES_MAXIMUM", [keysCount, schema.maxProperties], void 0, schema, "maxProperties");
+}
+function minPropertiesValidator(report, schema, json) {
+	if (shouldSkipValidate(this.validateOptions, ["OBJECT_PROPERTIES_MINIMUM"])) return;
+	if (!isObject(json)) return;
+	const keysCount = Object.keys(json).length;
+	if (keysCount < schema.minProperties) report.addError("OBJECT_PROPERTIES_MINIMUM", [keysCount, schema.minProperties], void 0, schema, "minProperties");
+}
+function requiredValidator(report, schema, json) {
+	if (shouldSkipValidate(this.validateOptions, ["OBJECT_MISSING_REQUIRED_PROPERTY"])) return;
+	if (!isObject(json)) return;
+	const idx = schema.required.length;
+	for (let i = 0; i < idx; i++) {
+		const requiredPropertyName = schema.required[i];
+		if (!Object.hasOwn(json, requiredPropertyName)) report.addError("OBJECT_MISSING_REQUIRED_PROPERTY", [requiredPropertyName], void 0, schema, "required");
+	}
+}
+function additionalPropertiesValidator(report, schema, json) {
+	if (schema.properties === void 0 && schema.patternProperties === void 0) return propertiesValidator.call(this, report, schema, json);
+}
+function patternPropertiesValidator(report, schema, json) {
+	if (schema.properties === void 0) return propertiesValidator.call(this, report, schema, json);
+}
+function propertiesValidator(report, schema, json) {
+	if (shouldSkipValidate(this.validateOptions, ["OBJECT_ADDITIONAL_PROPERTIES"])) return;
+	if (!isObject(json)) return;
+	const properties = schema.properties !== void 0 ? schema.properties : {};
+	const patternProperties = schema.patternProperties !== void 0 ? schema.patternProperties : {};
+	if (schema.additionalProperties === false) {
+		let s = Object.keys(json);
+		const p = Object.keys(properties);
+		const pp = Object.keys(patternProperties);
+		s = difference(s, p);
+		for (const ppKey of pp) {
+			const result = compileSchemaRegex(ppKey);
+			if (!result.ok) continue;
+			const regExp = result.value;
+			for (let idx2 = s.length - 1; idx2 >= 0; idx2--) if (regExp.test(s[idx2]) === true) s.splice(idx2, 1);
+		}
+		if (s.length > 0) {
+			if (Array.isArray(this.options.assumeAdditional)) for (const allowed of this.options.assumeAdditional) {
+				const io = s.indexOf(allowed);
+				if (io !== -1) s.splice(io, 1);
+			}
+			if (s.length > 0) for (const extra of s) report.addError("OBJECT_ADDITIONAL_PROPERTIES", [extra], void 0, schema, "properties");
+		}
+	}
+}
+function dependenciesValidator(report, schema, json) {
+	if (shouldSkipValidate(this.validateOptions, ["OBJECT_DEPENDENCY_KEY"])) return;
+	if (!isObject(json)) return;
+	const keys = Object.keys(schema.dependencies);
+	for (const dependencyName of keys) if (Object.hasOwn(json, dependencyName)) {
+		const dependencyDefinition = schema.dependencies[dependencyName];
+		if (Array.isArray(dependencyDefinition)) {
+			for (const requiredPropertyName of dependencyDefinition) if (!Object.hasOwn(json, requiredPropertyName)) report.addError("OBJECT_DEPENDENCY_KEY", [requiredPropertyName, dependencyName], void 0, schema, "dependencies");
+		} else this._jsonValidate(report, dependencyDefinition, json);
+	}
+}
+function dependentSchemasValidator(report, schema, json) {
+	if (!supportsDependentKeywords(schema, this.options.version)) return;
+	if (!isObject(json) || !isObject(schema.dependentSchemas)) return;
+	const keys = Object.keys(schema.dependentSchemas);
+	for (const dependencyName of keys) if (Object.hasOwn(json, dependencyName)) {
+		const dependencySchema = schema.dependentSchemas[dependencyName];
+		this._jsonValidate(report, dependencySchema, json);
+	}
+}
+function dependentRequiredValidator(report, schema, json) {
+	if (!supportsDependentKeywords(schema, this.options.version)) return;
+	if (shouldSkipValidate(this.validateOptions, ["OBJECT_DEPENDENCY_KEY"])) return;
+	if (!isObject(json) || !isObject(schema.dependentRequired)) return;
+	const keys = Object.keys(schema.dependentRequired);
+	for (const dependencyName of keys) {
+		if (!Object.hasOwn(json, dependencyName)) continue;
+		const requiredProperties = schema.dependentRequired[dependencyName];
+		if (!Array.isArray(requiredProperties)) continue;
+		for (const requiredPropertyName of requiredProperties) if (!Object.hasOwn(json, requiredPropertyName)) report.addError("OBJECT_DEPENDENCY_KEY", [requiredPropertyName, dependencyName], void 0, schema, "dependentRequired");
+	}
+}
+function propertyNamesValidator(report, schema, json) {
+	if (shouldSkipValidate(this.validateOptions, ["PROPERTY_NAMES"])) return;
+	if (!isObject(json)) return;
+	const propertyNamesSchema = schema.propertyNames;
+	if (propertyNamesSchema === void 0) return;
+	const Report_ = report.constructor;
+	const keys = Object.keys(json);
+	const subReports = [];
+	for (const key of keys) {
+		const subReport = new Report_(report);
+		subReports.push(subReport);
+		this._jsonValidate(subReport, propertyNamesSchema, key);
+	}
+	const addPropertyNameErrors = () => {
+		for (let idx = 0; idx < keys.length; idx++) if (subReports[idx].errors.length > 0) report.addError("PROPERTY_NAMES", [keys[idx]], subReports[idx], schema, void 0);
+	};
+	deferOrRunSync(report, subReports, addPropertyNameErrors);
+}
+//#endregion
+export { additionalPropertiesValidator, dependenciesValidator, dependentRequiredValidator, dependentSchemasValidator, maxPropertiesValidator, minPropertiesValidator, patternPropertiesValidator, propertiesValidator, propertyNamesValidator, requiredValidator };

package/dist/validation/ref.mjs

@@ -0,0 +1,49 @@
+import { getRemotePath } from "../utils/uri.mjs";
+import { findId, getId } from "../json-schema.mjs";
+//#region src/validation/ref.ts
+const getDynamicRefAnchorName = (dynamicRef) => {
+	const hashIdx = dynamicRef.indexOf("#");
+	if (hashIdx === -1) return;
+	const fragment = dynamicRef.slice(hashIdx + 1);
+	if (!fragment || fragment[0] === "/") return;
+	return fragment;
+};
+const findDynamicAnchorInScope = (scopeSchema, anchorName) => {
+	const scopeId = getId(scopeSchema);
+	const scopeBaseUri = scopeId ? getRemotePath(scopeId) : void 0;
+	const found = findId(scopeSchema, anchorName, scopeBaseUri, scopeBaseUri);
+	if (found && found.$dynamicAnchor === anchorName) return found;
+};
+/**
+* Resolves the effective target for a $recursiveRef, walking the recursive anchor stack.
+*/
+const resolveRecursiveRef = (schema, recursiveAnchorStack) => {
+	const resolved = schema.__$recursiveRefResolved;
+	if (!resolved) return;
+	let target = resolved;
+	if (typeof target === "object" && target.$recursiveAnchor === true) {
+		const dynamicTarget = recursiveAnchorStack[0];
+		if (dynamicTarget) target = dynamicTarget;
+	}
+	return target;
+};
+/**
+* Resolves the effective target for a $dynamicRef, walking the dynamic scope stack.
+*/
+const resolveDynamicRef = (schema, dynamicScopeStack) => {
+	const resolved = schema.__$dynamicRefResolved;
+	if (typeof resolved === "undefined" || !schema.$dynamicRef) return resolved;
+	let target = resolved;
+	const anchorName = getDynamicRefAnchorName(schema.$dynamicRef);
+	if (anchorName && typeof target === "object" && target.$dynamicAnchor === anchorName) for (let scopeIdx = 0; scopeIdx < dynamicScopeStack.length; scopeIdx++) {
+		const scopeSchema = dynamicScopeStack[scopeIdx];
+		const scopedTarget = findDynamicAnchorInScope(scopeSchema, anchorName);
+		if (scopedTarget) {
+			target = scopedTarget;
+			break;
+		}
+	}
+	return target;
+};
+//#endregion
+export { resolveDynamicRef, resolveRecursiveRef };

package/dist/validation/shared.mjs

@@ -0,0 +1,97 @@
+import { isObject } from "../utils/what-is.mjs";
+//#region src/validation/shared.ts
+const shouldSkipValidate = function(options, errors) {
+	return options && Array.isArray(options.includeErrors) && options.includeErrors.length > 0 && !errors.some(function(err) {
+		return options.includeErrors.includes(err);
+	});
+};
+const supportsDependentKeywords = (schema, version) => {
+	if (typeof schema.$schema === "string") return !/draft-04|draft-06|draft-07/.test(schema.$schema);
+	return !(version === "draft-04" || version === "draft-06" || version === "draft-07");
+};
+const VOCAB_VALIDATION_2019_09 = "https://json-schema.org/draft/2019-09/vocab/validation";
+const VOCAB_VALIDATION_2020_12 = "https://json-schema.org/draft/2020-12/vocab/validation";
+const VOCAB_FORMAT_2019_09 = "https://json-schema.org/draft/2019-09/vocab/format";
+const VOCAB_FORMAT_ASSERTION_2020_12 = "https://json-schema.org/draft/2020-12/vocab/format-assertion";
+const VALIDATION_VOCAB_KEYWORDS = new Set([
+	"type",
+	"multipleOf",
+	"maximum",
+	"exclusiveMaximum",
+	"minimum",
+	"exclusiveMinimum",
+	"maxLength",
+	"minLength",
+	"pattern",
+	"maxItems",
+	"minItems",
+	"uniqueItems",
+	"maxContains",
+	"minContains",
+	"maxProperties",
+	"minProperties",
+	"required",
+	"dependentRequired",
+	"enum",
+	"const",
+	"contentEncoding",
+	"contentMediaType"
+]);
+const isValidationVocabularyEnabled = (schema, report, version) => {
+	if (version !== "draft2019-09" && version !== "draft2020-12") return true;
+	const currentSchemaMeta = schema.__$schemaResolved;
+	const rootSchemaMeta = report.rootSchema && typeof report.rootSchema !== "boolean" ? report.rootSchema.__$schemaResolved : void 0;
+	const metaSchema = currentSchemaMeta || rootSchemaMeta;
+	if (!metaSchema || typeof metaSchema !== "object" || !isObject(metaSchema.$vocabulary)) return true;
+	const vocabulary = metaSchema.$vocabulary;
+	if (Object.hasOwn(vocabulary, VOCAB_VALIDATION_2019_09) || Object.hasOwn(vocabulary, VOCAB_VALIDATION_2020_12)) return vocabulary[VOCAB_VALIDATION_2019_09] === true || vocabulary[VOCAB_VALIDATION_2020_12] === true;
+	return false;
+};
+/**
+* Checks whether the format-assertion vocabulary is enabled in the meta-schema.
+* For draft 2019-09: checks if the format vocabulary is set to true.
+* For draft 2020-12: checks if the format-assertion vocabulary is present and true.
+* Returns true for older drafts (format was always an assertion).
+*/
+const isFormatAssertionVocabEnabled = (schema, report, version) => {
+	if (version !== "draft2019-09" && version !== "draft2020-12") return true;
+	const currentSchemaMeta = schema.__$schemaResolved;
+	const rootSchemaMeta = report.rootSchema && typeof report.rootSchema !== "boolean" ? report.rootSchema.__$schemaResolved : void 0;
+	const metaSchema = currentSchemaMeta || rootSchemaMeta;
+	if (!metaSchema || typeof metaSchema !== "object" || !isObject(metaSchema.$vocabulary)) return false;
+	const vocabulary = metaSchema.$vocabulary;
+	if (Object.hasOwn(vocabulary, VOCAB_FORMAT_ASSERTION_2020_12)) return vocabulary[VOCAB_FORMAT_ASSERTION_2020_12] === true;
+	if (Object.hasOwn(vocabulary, VOCAB_FORMAT_2019_09)) return vocabulary[VOCAB_FORMAT_2019_09] === true;
+	return false;
+};
+function cacheValidationResult(report, schema, json, passed) {
+	let schemaMap = report.__validationResultCache.get(schema);
+	if (!schemaMap) {
+		schemaMap = /* @__PURE__ */ new Map();
+		report.__validationResultCache.set(schema, schemaMap);
+	}
+	schemaMap.set(json, passed);
+}
+function getCachedValidationResult(report, schema, json) {
+	return report.__validationResultCache.get(schema)?.get(json);
+}
+/**
+* Shared async-task aggregation pattern.
+*
+* 1. Collects async tasks from `subReports` into `report`.
+* 2. If new async tasks were added, defers `decisionFn` via `report.addAsyncTask`
+*    with proper path save/restore so error paths are correct.
+* 3. Otherwise, runs `decisionFn` synchronously.
+*/
+function deferOrRunSync(report, subReports, decisionFn) {
+	const asyncTasksBefore = report.asyncTasks.length;
+	for (const subReport of subReports) report.asyncTasks.push(...subReport.asyncTasks);
+	if (report.asyncTasks.length > asyncTasksBefore) report.addAsyncTaskWithPath((callback) => {
+		setTimeout(() => callback(null), 0);
+	}, [], () => {
+		decisionFn();
+	});
+	else decisionFn();
+}
+//#endregion
+export { VALIDATION_VOCAB_KEYWORDS, cacheValidationResult, deferOrRunSync, getCachedValidationResult, isFormatAssertionVocabEnabled, isValidationVocabularyEnabled, shouldSkipValidate, supportsDependentKeywords };

package/dist/validation/string.mjs

@@ -0,0 +1,88 @@
+import { whatIs } from "../utils/what-is.mjs";
+import { getFormatValidators } from "../format-validators.mjs";
+import { compileSchemaRegex } from "../utils/schema-regex.mjs";
+import { isFormatAssertionVocabEnabled, shouldSkipValidate } from "./shared.mjs";
+import { decodeBase64, isValidBase64 } from "../utils/base64.mjs";
+import { unicodeLength } from "../utils/unicode.mjs";
+//#region src/validation/string.ts
+function minLengthValidator(report, schema, json) {
+	if (shouldSkipValidate(this.validateOptions, ["MIN_LENGTH"])) return;
+	if (typeof json !== "string") return;
+	if (unicodeLength(json) < schema.minLength) report.addError("MIN_LENGTH", [json.length, schema.minLength], void 0, schema, "minLength");
+}
+function maxLengthValidator(report, schema, json) {
+	if (shouldSkipValidate(this.validateOptions, ["MAX_LENGTH"])) return;
+	if (typeof json !== "string") return;
+	if (unicodeLength(json) > schema.maxLength) report.addError("MAX_LENGTH", [json.length, schema.maxLength], void 0, schema, "maxLength");
+}
+function patternValidator(report, schema, json) {
+	if (shouldSkipValidate(this.validateOptions, ["PATTERN"])) return;
+	if (typeof json !== "string") return;
+	const result = compileSchemaRegex(schema.pattern);
+	if (!result.ok) {
+		report.addError("PATTERN", [
+			schema.pattern,
+			json,
+			result.error.message
+		], void 0, schema, "pattern");
+		return;
+	}
+	if (!result.value.test(json)) report.addError("PATTERN", [schema.pattern, json], void 0, schema, "pattern");
+}
+function formatValidator(report, schema, json) {
+	if (this.options.formatAssertions === false) return;
+	if (this.options.formatAssertions === true) {
+		if (!isFormatAssertionVocabEnabled(schema, report, this.options.version)) return;
+	}
+	const isModernDraft = this.options.version === "draft2019-09" || this.options.version === "draft2020-12";
+	const formatValidatorFn = getFormatValidators(this.options)[schema.format];
+	if (typeof formatValidatorFn === "function") {
+		if (shouldSkipValidate(this.validateOptions, ["INVALID_FORMAT"])) return;
+		if (report.hasError("INVALID_TYPE", [schema.type, whatIs(json)])) return;
+		if (formatValidatorFn.length === 2) report.addAsyncTaskWithPath(formatValidatorFn, [json], function(result) {
+			if (result !== true) report.addError("INVALID_FORMAT", [schema.format, JSON.stringify(json)], void 0, schema, "format");
+		});
+		else {
+			const result = formatValidatorFn.call(this, json);
+			if (result instanceof Promise) {
+				const promiseResult = result;
+				report.addAsyncTaskWithPath(async (callback) => {
+					try {
+						callback(await promiseResult);
+					} catch (_error) {
+						callback(false);
+					}
+				}, [], function(resolvedResult) {
+					if (resolvedResult !== true) report.addError("INVALID_FORMAT", [schema.format, JSON.stringify(json)], void 0, schema, "format");
+				});
+			} else if (result !== true) report.addError("INVALID_FORMAT", [schema.format, JSON.stringify(json)], void 0, schema, "format");
+		}
+	} else if (this.options.ignoreUnknownFormats !== true && !isModernDraft) report.addError("UNKNOWN_FORMAT", [schema.format], void 0, schema, "format");
+}
+function contentEncodingValidator(report, schema, json) {
+	if (this.options.version !== "draft-07") return;
+	if (typeof json !== "string") return;
+	if (schema.contentEncoding !== "base64") return;
+	if (!isValidBase64(json)) report.addError("INVALID_FORMAT", ["contentEncoding:base64", JSON.stringify(json)], void 0, schema, "contentEncoding");
+}
+function contentMediaTypeValidator(report, schema, json) {
+	if (this.options.version !== "draft-07") return;
+	if (typeof json !== "string") return;
+	if (schema.contentMediaType !== "application/json") return;
+	let payload = json;
+	if (schema.contentEncoding === "base64") {
+		const decoded = decodeBase64(json);
+		if (decoded === void 0) {
+			report.addError("INVALID_FORMAT", ["contentEncoding:base64", JSON.stringify(json)], void 0, schema, "contentEncoding");
+			return;
+		}
+		payload = decoded;
+	}
+	try {
+		JSON.parse(payload);
+	} catch {
+		report.addError("INVALID_FORMAT", ["contentMediaType:application/json", JSON.stringify(json)], void 0, schema, "contentMediaType");
+	}
+}
+//#endregion
+export { contentEncodingValidator, contentMediaTypeValidator, formatValidator, maxLengthValidator, minLengthValidator, patternValidator };

package/dist/validation/type.mjs

@@ -0,0 +1,32 @@
+import { whatIs } from "../utils/what-is.mjs";
+import { areEqual } from "../utils/json.mjs";
+import { shouldSkipValidate } from "./shared.mjs";
+//#region src/validation/type.ts
+function typeValidator(report, schema, json) {
+	if (shouldSkipValidate(this.validateOptions, ["INVALID_TYPE"])) return;
+	const jsonType = whatIs(json);
+	if (typeof schema.type === "string") {
+		if (jsonType !== schema.type && (jsonType !== "integer" || schema.type !== "number")) report.addError("INVALID_TYPE", [schema.type, jsonType], void 0, schema, "type");
+	} else if (!schema.type.includes(jsonType) && (jsonType !== "integer" || !schema.type.includes("number"))) report.addError("INVALID_TYPE", [JSON.stringify(schema.type), jsonType], void 0, schema, "type");
+}
+function enumValidator(report, schema, json) {
+	if (shouldSkipValidate(this.validateOptions, ["ENUM_CASE_MISMATCH", "ENUM_MISMATCH"])) return;
+	let match = false, caseInsensitiveMatch = false;
+	for (const enumVal of schema.enum) if (areEqual(json, enumVal, { maxDepth: this.options.maxRecursionDepth })) {
+		match = true;
+		break;
+	} else if (areEqual(json, enumVal, {
+		caseInsensitiveComparison: true,
+		maxDepth: this.options.maxRecursionDepth
+	})) caseInsensitiveMatch = true;
+	if (match === false) {
+		const error = caseInsensitiveMatch && this.options.enumCaseInsensitiveComparison ? "ENUM_CASE_MISMATCH" : "ENUM_MISMATCH";
+		report.addError(error, [JSON.stringify(json)], void 0, schema, "enum");
+	}
+}
+function constValidator(report, schema, json) {
+	const constValue = schema.const;
+	if (areEqual(json, constValue, { maxDepth: this.options.maxRecursionDepth }) === false) report.addError("CONST", [JSON.stringify(constValue)], void 0, schema, void 0);
+}
+//#endregion
+export { constValidator, enumValidator, typeValidator };

package/dist/z-schema-base.d.mts

@@ -0,0 +1,85 @@
+import { FormatValidatorFn } from "./format-validators.mjs";
+import { ZSchemaOptions } from "./z-schema-options.mjs";
+import { Report } from "./report.mjs";
+import { Errors, ValidateError } from "./errors.mjs";
+import { SchemaCache } from "./schema-cache.mjs";
+import { SchemaValidator } from "./schema-validator.mjs";
+import { SchemaCompiler } from "./schema-compiler.mjs";
+import { JsonSchema, JsonSchemaInternal } from "./json-schema-versions.mjs";
+
+//#region src/z-schema-base.d.ts
+interface ValidateOptions {
+  schemaPath?: string;
+  includeErrors?: Array<keyof typeof Errors>;
+  excludeErrors?: Array<keyof typeof Errors>;
+}
+type ValidateResponse = {
+  valid: boolean;
+  err?: ValidateError;
+};
+type ValidateCallback = (err: ValidateResponse['err'], valid: ValidateResponse['valid']) => void;
+declare class ZSchemaBase {
+  scache: SchemaCache;
+  sc: SchemaCompiler;
+  sv: SchemaValidator;
+  validateOptions: ValidateOptions;
+  options: ZSchemaOptions;
+  constructor(options: ZSchemaOptions | undefined, token: symbol);
+  /**
+   * Internal recursive JSON validation — delegates to the `validate` function
+   * in `json-validation.ts`. Exposed as a method so that per-keyword validator
+   * modules (array, combinators, object) can call back into the core validator
+   * via `this` without importing `json-validation.ts` directly (which would
+   * create a circular dependency).
+   */
+  _jsonValidate(report: Report, schema: boolean | JsonSchemaInternal, json: unknown): boolean;
+  getDefaultSchemaId(): string;
+  _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;
+  _validateSchema(schemaOrArr: JsonSchema | JsonSchema[]): true;
+  /**
+   * Register a format validator on this instance only (does not affect other instances or the global registry).
+   * @param name - The format name.
+   * @param validatorFunction - A sync or async function `(value: unknown) => boolean | Promise<boolean>`.
+   */
+  registerFormat(name: string, validatorFunction: FormatValidatorFn): void;
+  /**
+   * Unregister an instance-scoped format validator.
+   * @param name - The format name to unregister.
+   */
+  unregisterFormat(name: string): void;
+  /** Returns the names of format validators registered on this instance. */
+  getRegisteredFormats(): string[];
+  /** Returns all supported format names (global + instance-registered). */
+  getSupportedFormats(): string[];
+  /**
+   * Register a remote schema in this instance's cache so `$ref` can resolve to it.
+   * @param uri - The URI the schema will be known by.
+   * @param schema - The schema object or JSON string.
+   * @param validationOptions - Optional options used for schema preparation.
+   */
+  setRemoteReference(uri: string, schema: string | JsonSchema, validationOptions?: ZSchemaOptions): void;
+  /**
+   * Extract unresolvable `$ref` URIs from a validation error.
+   * @param err - A `ValidateError` from a failed validation.
+   * @returns An array of unresolvable reference URIs.
+   */
+  getMissingReferences(err: ValidateError): string[];
+  /**
+   * Extract unresolvable **remote** `$ref` URIs from a validation error (local fragment-only refs are excluded).
+   * @param err - A `ValidateError` from a failed validation.
+   * @returns An array of remote reference base URIs.
+   */
+  getMissingRemoteReferences(err: ValidateError): string[];
+  /**
+   * Resolve a previously compiled schema by its `$id` / `id`, cleaning up internal bookkeeping properties
+   * and inlining resolved `$ref` targets.
+   * @param schemaId - The schema identifier to look up.
+   * @returns A clean, resolved copy of the schema, or `undefined` if not found.
+   */
+  getResolvedSchema(schemaId: string): JsonSchema | undefined;
+}
+//#endregion
+export { ValidateCallback, ValidateOptions, ValidateResponse, ZSchemaBase };