@jskit-ai/assistant-voice 0.1.1 → 0.1.2

package/examples/conversation/node_modules/.vite/deps/json-rest-schema.js

@@ -1,2071 +0,0 @@
-//#region ../../../../node_modules/json-rest-schema/src/utils/object-helpers.js
-/**
-* @file Shared object-shape helpers.
-*/
-function isPlainObject(value) {
-	if (value === null || typeof value !== "object") return false;
-	const prototype = Object.getPrototypeOf(value);
-	return prototype === Object.prototype || prototype === null || isEmptyNullPrototypeRecord(prototype);
-}
-function isEmptyNullPrototypeRecord(value) {
-	return value !== null && typeof value === "object" && Object.getPrototypeOf(value) === null && Reflect.ownKeys(value).length === 0;
-}
-//#endregion
-//#region ../../../../node_modules/json-rest-schema/src/core/nested-contract.js
-function isSchemaLike(value) {
-	return value !== null && typeof value === "object" && isPlainObject(value.structure) && isPlainObject(value.operations) && typeof value.validateWith === "function" && typeof value.toJsonSchema === "function" && typeof value.cleanup === "function";
-}
-function resolveArrayItemsConfig(fieldPath, definition) {
-	if (!Object.hasOwn(definition, "items")) return null;
-	const { items } = definition;
-	if (isSchemaLike(items)) return {
-		kind: "schema",
-		schema: items
-	};
-	if (!isPlainObject(items) || typeof items.type !== "string") throw new Error(`Array field "${fieldPath}" must define items as either a Schema instance or a field definition object.`);
-	return {
-		kind: "definition",
-		definition: items
-	};
-}
-function resolveObjectValuesConfig(fieldPath, definition) {
-	if (!Object.hasOwn(definition, "values")) return null;
-	const { values } = definition;
-	if (isSchemaLike(values)) return {
-		kind: "schema",
-		schema: values
-	};
-	if (!isPlainObject(values) || typeof values.type !== "string") throw new Error(`Object field "${fieldPath}" must define values as either a Schema instance or a field definition object.`);
-	return {
-		kind: "definition",
-		definition: values
-	};
-}
-function resolveObjectFieldMode(fieldPath, definition) {
-	const hasNestedSchema = Object.hasOwn(definition, "schema");
-	const hasValues = Object.hasOwn(definition, "values");
-	const hasAdditionalProperties = Object.hasOwn(definition, "additionalProperties");
-	if (hasNestedSchema && hasValues) throw new Error(`Object field "${fieldPath}" cannot define both schema and values.`);
-	if (hasAdditionalProperties && definition.additionalProperties !== true) throw new Error(`Object field "${fieldPath}" only supports additionalProperties: true.`);
-	if (hasValues && definition.additionalProperties === true) throw new Error(`Object field "${fieldPath}" cannot define both values and additionalProperties: true.`);
-	if (hasNestedSchema) {
-		if (!isSchemaLike(definition.schema)) throw new Error(`Object field "${fieldPath}" must define schema as a Schema instance.`);
-		return {
-			kind: "nested",
-			schema: definition.schema,
-			allowAdditionalProperties: definition.additionalProperties === true
-		};
-	}
-	if (hasValues) return {
-		kind: "map",
-		valuesConfig: resolveObjectValuesConfig(fieldPath, definition)
-	};
-	if (definition.additionalProperties === true) return { kind: "opaque" };
-	return { kind: "plain" };
-}
-//#endregion
-//#region ../../../../node_modules/json-rest-schema/src/core/definition-helpers.js
-/**
-* @file Shared schema-definition predicates used by runtime and transport code.
-*/
-function isNumericDefinition(definition) {
-	return definition?.type === "number" || definition?.type === "integer" || definition?.type === "epochMilliseconds" || definition?.type === "epochSeconds";
-}
-//#endregion
-//#region ../../../../node_modules/json-rest-schema/src/core/temporal.js
-/**
-* @file Shared validation contracts for JSON-native temporal values.
-*/
-var EPOCH_MILLISECONDS_LIMIT = 864e13;
-var EPOCH_SECONDS_LIMIT = 864e10;
-var EPOCH_INTEGER_STRING_PATTERN = "^(?:0|-?[1-9]\\d*)$";
-var YEAR_PATTERN = "\\d{4}";
-var MONTH_PATTERN = "0[1-9]|1[0-2]";
-var DAY_PATTERN = "0[1-9]|[12]\\d|3[01]";
-var HOUR_PATTERN = "[01]\\d|2[0-3]";
-var MINUTE_OR_SECOND_PATTERN = "[0-5]\\d";
-var HOUR_MINUTE_PATTERN = `(?:${HOUR_PATTERN}):${MINUTE_OR_SECOND_PATTERN}`;
-var TIME_ZONE_PATTERN = `(?:Z|[+-](?:${HOUR_PATTERN}):${MINUTE_OR_SECOND_PATTERN})`;
-var CAPTURED_DATE_PATTERN = `(${YEAR_PATTERN})-(${MONTH_PATTERN})-(${DAY_PATTERN})`;
-var JSON_SCHEMA_DATE_PATTERN = `${YEAR_PATTERN}-(?:${MONTH_PATTERN})-(?:${DAY_PATTERN})`;
-var DATE_JSON_SCHEMA_PATTERN = `^${JSON_SCHEMA_DATE_PATTERN}$`;
-var DATE_PATTERN = new RegExp(`^${CAPTURED_DATE_PATTERN}$`);
-var TIME_PATTERN = new RegExp(`^${HOUR_MINUTE_PATTERN}(?::${MINUTE_OR_SECOND_PATTERN}(?:\\.(\\d+))?)?$`);
-var DATE_TIME_PATTERN = new RegExp(`^${CAPTURED_DATE_PATTERN}T${HOUR_MINUTE_PATTERN}:${MINUTE_OR_SECOND_PATTERN}(?:\\.(\\d+))?${TIME_ZONE_PATTERN}$`);
-var EPOCH_INTEGER_STRING = new RegExp(EPOCH_INTEGER_STRING_PATTERN);
-var DAYS_PER_MONTH = [
-	31,
-	28,
-	31,
-	30,
-	31,
-	30,
-	31,
-	31,
-	30,
-	31,
-	30,
-	31
-];
-function isLeapYear(year) {
-	return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
-}
-function daysInMonth(year, month) {
-	if (month === 2) return isLeapYear(year) ? 29 : 28;
-	return DAYS_PER_MONTH[month - 1];
-}
-function isValidCalendarDateParts(yearText, monthText, dayText) {
-	const year = Number(yearText);
-	const month = Number(monthText);
-	const day = Number(dayText);
-	return month >= 1 && month <= 12 && day >= 1 && day <= daysInMonth(year, month);
-}
-function resolveTemporalPrecision(definition, fieldName) {
-	const precision = definition.temporalPrecision;
-	if (precision === void 0) return void 0;
-	if (!Number.isInteger(precision) || precision < 0) throw new Error(`temporalPrecision for "${fieldName}" must be a non-negative integer.`);
-	return precision;
-}
-function hasAllowedFractionalPrecision(fraction, temporalPrecision) {
-	if (fraction === void 0) return true;
-	return temporalPrecision === void 0 || fraction.length <= temporalPrecision;
-}
-function isValidDate(value) {
-	if (typeof value !== "string") return false;
-	const match = DATE_PATTERN.exec(value);
-	return match !== null && isValidCalendarDateParts(match[1], match[2], match[3]);
-}
-function isValidTime(value, temporalPrecision) {
-	if (typeof value !== "string") return false;
-	const match = TIME_PATTERN.exec(value);
-	return match !== null && hasAllowedFractionalPrecision(match[1], temporalPrecision);
-}
-function isValidDateTime(value, temporalPrecision) {
-	if (typeof value !== "string") return false;
-	const match = DATE_TIME_PATTERN.exec(value);
-	if (match === null) return false;
-	return isValidCalendarDateParts(match[1], match[2], match[3]) && hasAllowedFractionalPrecision(match[4], temporalPrecision);
-}
-function fractionalPattern(temporalPrecision) {
-	if (temporalPrecision === void 0) return "(?:\\.\\d+)?";
-	if (temporalPrecision === 0) return "";
-	return `(?:\\.\\d{1,${temporalPrecision}})?`;
-}
-function timeJsonSchemaPattern(definition, fieldName) {
-	return `^${HOUR_MINUTE_PATTERN}(?::${MINUTE_OR_SECOND_PATTERN}${fractionalPattern(resolveTemporalPrecision(definition, fieldName))})?$`;
-}
-function dateTimeJsonSchemaPattern(definition, fieldName) {
-	return `^${JSON_SCHEMA_DATE_PATTERN}T${HOUR_MINUTE_PATTERN}:${MINUTE_OR_SECOND_PATTERN}${fractionalPattern(resolveTemporalPrecision(definition, fieldName))}${TIME_ZONE_PATTERN}$`;
-}
-function castEpochInteger(value, limit) {
-	let integerValue;
-	if (typeof value === "number") integerValue = value;
-	else if (typeof value === "string" && EPOCH_INTEGER_STRING.test(value)) integerValue = Number(value);
-	else return null;
-	if (!Number.isSafeInteger(integerValue) || integerValue < -limit || integerValue > limit) return null;
-	return integerValue === 0 ? 0 : integerValue;
-}
-//#endregion
-//#region ../../../../node_modules/json-rest-schema/src/utils/path-helpers.js
-/**
-* @file Shared dotted-path helpers for schema errors and UI adapters.
-*/
-var UNSAFE_PATH_SEGMENTS = /* @__PURE__ */ new Set([
-	"__proto__",
-	"prototype",
-	"constructor"
-]);
-function isObjectLike(value) {
-	return value !== null && typeof value === "object";
-}
-function isNumericSegment(segment) {
-	return /^[0-9]+$/.test(segment);
-}
-function setOwnProperty(target, key, value) {
-	Object.defineProperty(target, key, {
-		value,
-		enumerable: true,
-		configurable: true,
-		writable: true
-	});
-}
-function assertSafePathSegment(segment, helperName) {
-	if (UNSAFE_PATH_SEGMENTS.has(segment)) throw new Error(`${helperName}() received unsafe path segment "${segment}".`);
-}
-function normalizeFieldPath(path) {
-	if (typeof path !== "string") return path;
-	return path.replace(/\[(.+?)\]/g, ".$1").replace(/^\.+/, "").replace(/\.+/g, ".").replace(/\.$/, "");
-}
-function buildPathSegments$1(path, helperName, { normalize = false, allowEmpty = false } = {}) {
-	const normalizedPath = normalize ? normalizeFieldPath(path) : path;
-	if (typeof normalizedPath !== "string" || normalizedPath.trim() === "") {
-		if (allowEmpty && normalizedPath === "") return [];
-		throw new Error(`${helperName}() expects a non-empty dotted path string.`);
-	}
-	const segments = normalizedPath.split(".");
-	if (segments.some((segment) => segment === "")) throw new Error(`${helperName}() received an invalid path "${normalizedPath}".`);
-	for (const segment of segments) assertSafePathSegment(segment, helperName);
-	return segments;
-}
-function joinPath$1(basePath, pathSegment) {
-	return basePath === "" ? String(pathSegment) : `${basePath}.${String(pathSegment)}`;
-}
-//#endregion
-//#region ../../../../node_modules/json-rest-schema/src/core/transport-schema.js
-var JSON_SCHEMA_DRAFT_07 = "http://json-schema.org/draft-07/schema#";
-var JSON_REST_EXTENSION_KEY = "x-json-rest-schema";
-var NON_NULL_JSON_TYPES = [
-	"object",
-	"array",
-	"string",
-	"number",
-	"boolean"
-];
-var EXPORT_CONTEXT_KEY = Symbol("json-rest-schema.exportContext");
-var BOOLEAN_TRUE_VALUES = [
-	"true",
-	"1",
-	"yes",
-	"y",
-	"on"
-];
-var BOOLEAN_FALSE_VALUES = [
-	"false",
-	"0",
-	"no",
-	"n",
-	"off"
-];
-function epochIntegerSchema(limit) {
-	return { anyOf: [{
-		type: "integer",
-		minimum: -limit,
-		maximum: limit
-	}, {
-		type: "string",
-		pattern: EPOCH_INTEGER_STRING_PATTERN
-	}] };
-}
-function extensionMetadataFragment(section, values) {
-	return { [JSON_REST_EXTENSION_KEY]: { [section]: values } };
-}
-var BUILTIN_TYPE_EXPORTERS = {
-	none: () => ({ type: NON_NULL_JSON_TYPES }),
-	blob: () => ({ type: NON_NULL_JSON_TYPES }),
-	serialize: () => ({ type: NON_NULL_JSON_TYPES }),
-	object: () => ({ type: "object" }),
-	array: () => ({ type: "array" }),
-	file: () => ({ type: "string" }),
-	string: () => ({ type: "string" }),
-	number: () => ({ type: ["number", "string"] }),
-	integer: () => ({ type: ["integer", "string"] }),
-	epochMilliseconds: () => epochIntegerSchema(EPOCH_MILLISECONDS_LIMIT),
-	epochSeconds: () => epochIntegerSchema(EPOCH_SECONDS_LIMIT),
-	dateTime: ({ definition, fieldName }) => ({
-		type: "string",
-		format: "date-time",
-		pattern: dateTimeJsonSchemaPattern(definition, fieldName)
-	}),
-	date: () => ({
-		type: "string",
-		format: "date",
-		pattern: DATE_JSON_SCHEMA_PATTERN
-	}),
-	time: ({ definition, fieldName }) => ({
-		type: "string",
-		pattern: timeJsonSchemaPattern(definition, fieldName)
-	}),
-	boolean: ({ definition }) => {
-		if (definition.strictBoolean === true) return { type: "boolean" };
-		const trueValues = /* @__PURE__ */ new Set([...BOOLEAN_TRUE_VALUES, String(definition.stringTrueWhen || "true").trim().toLowerCase()]);
-		return { anyOf: [
-			{ type: "boolean" },
-			{
-				type: "number",
-				enum: [0, 1]
-			},
-			{
-				type: "string",
-				enum: [.../* @__PURE__ */ new Set([...BOOLEAN_FALSE_VALUES, String(definition.stringFalseWhen || "false").trim().toLowerCase()]), ...trueValues]
-			}
-		] };
-	},
-	id: () => ({
-		type: ["integer", "string"],
-		minimum: 1,
-		pattern: "^[1-9][0-9]*$"
-	})
-};
-var BUILTIN_VALIDATOR_EXPORTERS = {
-	minLength: ({ definition, parameterValue }) => definition.type === "string" ? { minLength: parameterValue } : null,
-	maxLength: ({ definition, parameterValue }) => definition.type === "string" ? { maxLength: parameterValue } : null,
-	min: ({ definition, parameterValue }) => isNumericDefinition(definition) ? { minimum: parameterValue } : null,
-	max: ({ definition, parameterValue }) => isNumericDefinition(definition) ? { maximum: parameterValue } : null,
-	pattern: ({ definition, parameterValue }) => definition.type === "string" ? { pattern: parameterValue instanceof RegExp ? parameterValue.source : parameterValue } : null,
-	enum: ({ parameterValue }) => ({ enum: parameterValue }),
-	notEmpty: ({ parameterValue, definition }) => {
-		if (!parameterValue) return null;
-		if (definition.type === "array") return null;
-		return { minLength: 1 };
-	},
-	uppercase: ({ parameterValue }) => parameterValue ? extensionMetadataFragment("transforms", { uppercase: true }) : null,
-	lowercase: ({ parameterValue }) => parameterValue ? extensionMetadataFragment("transforms", { lowercase: true }) : null,
-	length: ({ parameterValue }) => extensionMetadataFragment("transforms", { length: parameterValue }),
-	unsigned: ({ parameterValue }) => parameterValue ? extensionMetadataFragment("metadata", { unsigned: true }) : null,
-	precision: ({ parameterValue }) => extensionMetadataFragment("metadata", { precision: parameterValue }),
-	scale: ({ parameterValue }) => extensionMetadataFragment("metadata", { scale: parameterValue }),
-	temporalPrecision: ({ parameterValue }) => extensionMetadataFragment("metadata", { temporalPrecision: parameterValue }),
-	strictBoolean: () => null,
-	required: () => null,
-	nullable: () => null,
-	nullOnEmpty: () => null,
-	defaultTo: () => null
-};
-function mergePlainObjects(target, source) {
-	for (const key of Object.keys(source)) {
-		const sourceValue = source[key];
-		const targetValue = target[key];
-		if (sourceValue && targetValue && typeof sourceValue === "object" && typeof targetValue === "object" && !Array.isArray(sourceValue) && !Array.isArray(targetValue)) {
-			mergePlainObjects(targetValue, sourceValue);
-			continue;
-		}
-		target[key] = sourceValue;
-	}
-}
-function mergeSchemaFragment(target, fragment) {
-	if (!fragment || typeof fragment !== "object" || Array.isArray(fragment)) throw new Error("JSON Schema export hooks must return an object or null.");
-	for (const key of Object.keys(fragment)) {
-		if (key === JSON_REST_EXTENSION_KEY && target[key] && typeof target[key] === "object" && typeof fragment[key] === "object" && !Array.isArray(target[key]) && !Array.isArray(fragment[key])) {
-			mergePlainObjects(target[key], fragment[key]);
-			continue;
-		}
-		target[key] = fragment[key];
-	}
-}
-function buildAnyOfSchema(baseSchema, alternatives) {
-	const finalAlternatives = [...Array.isArray(baseSchema.anyOf) && Object.keys(baseSchema).length === 1 ? baseSchema.anyOf : [baseSchema], ...alternatives];
-	if (finalAlternatives.length === 1) return baseSchema;
-	return { anyOf: finalAlternatives };
-}
-function getTypeExporter(schema, definition) {
-	if (!Object.hasOwn(schema.types, definition.type)) throw new Error(`No casting function for type: ${definition.type}`);
-	const handler = schema.types[definition.type];
-	if (typeof handler.toJsonSchema === "function") return handler.toJsonSchema;
-	const exporter = BUILTIN_TYPE_EXPORTERS[definition.type];
-	if (!exporter) throw new Error(`Type '${definition.type}' cannot be exported to JSON Schema without a toJsonSchema hook.`);
-	return exporter;
-}
-function getValidatorExporter(schema, parameterName, fieldName) {
-	if (!Object.hasOwn(schema.validators, parameterName)) return null;
-	const handler = schema.validators[parameterName];
-	if (typeof handler.toJsonSchema === "function") return handler.toJsonSchema;
-	const exporter = BUILTIN_VALIDATOR_EXPORTERS[parameterName];
-	if (exporter) return exporter;
-	throw new Error(`Validator '${parameterName}' on field '${fieldName}' cannot be exported to JSON Schema without a toJsonSchema hook.`);
-}
-function normalizeMode(mode) {
-	if (mode === void 0) return "create";
-	if ([
-		"create",
-		"replace",
-		"patch"
-	].includes(mode)) return mode;
-	throw new Error(`Unsupported JSON Schema export mode '${mode}'. Expected 'create', 'replace', or 'patch'.`);
-}
-function resolveOperationName(schema, options = {}) {
-	if (options.mode !== void 0 && options.operation !== void 0) {
-		const normalizedMode = normalizeMode(options.mode);
-		if (normalizedMode !== options.operation) throw new Error(`Conflicting JSON Schema export options: mode '${normalizedMode}' does not match operation '${options.operation}'.`);
-	}
-	if (options.operation !== void 0) {
-		if (!Object.hasOwn(schema.operations, options.operation)) throw new Error(`Unknown JSON Schema export operation '${options.operation}'.`);
-		return options.operation;
-	}
-	return normalizeMode(options.mode);
-}
-function resolveExportOperation(schema, options = {}) {
-	if (options.operationName !== void 0 && options.operationDescriptor !== void 0) return {
-		operationName: options.operationName,
-		operation: options.operationDescriptor
-	};
-	const operationName = resolveOperationName(schema, options);
-	return {
-		operationName,
-		operation: schema.operations[operationName]
-	};
-}
-function createExportOptions(options = {}) {
-	const exportOptions = { ...options };
-	Object.defineProperty(exportOptions, EXPORT_CONTEXT_KEY, {
-		value: {
-			definitions: {},
-			nodes: [],
-			nextDefinitionId: 1,
-			rootNode: null
-		},
-		enumerable: false
-	});
-	return exportOptions;
-}
-function getExportContext(options = {}) {
-	if (options[EXPORT_CONTEXT_KEY]) return options[EXPORT_CONTEXT_KEY];
-	return {
-		definitions: {},
-		nodes: [],
-		nextDefinitionId: 1,
-		rootNode: null
-	};
-}
-function sanitizeDefinitionNamePart(value) {
-	return String(value).replace(/[^a-zA-Z0-9]+/g, "_").replace(/^_+|_+$/g, "") || "operation";
-}
-function isReferenceOnlySchema(schema) {
-	return isPlainObject(schema) && Object.keys(schema).length === 1 && typeof schema.$ref === "string";
-}
-function wrapReferenceSchema(schema) {
-	if (!isReferenceOnlySchema(schema)) return schema;
-	return { allOf: [schema] };
-}
-function findExportNode(exportContext, schema, operationName, operation, additionalProperties) {
-	return exportContext.nodes.find((node) => node.schema === schema && node.operationName === operationName && node.operation === operation && node.additionalProperties === additionalProperties) || null;
-}
-function createDefinitionName(exportContext, operationName) {
-	const suffix = sanitizeDefinitionNamePart(operationName);
-	const definitionName = `SchemaNode_${exportContext.nextDefinitionId}_${suffix}`;
-	exportContext.nextDefinitionId += 1;
-	return definitionName;
-}
-function getOrCreateExportNode(schema, options, operationName, operation, additionalProperties, { root = false } = {}) {
-	const exportContext = getExportContext(options);
-	const existingNode = findExportNode(exportContext, schema, operationName, operation, additionalProperties);
-	if (existingNode) {
-		if (root) {
-			existingNode.pointer = "#";
-			exportContext.rootNode = existingNode;
-		}
-		return existingNode;
-	}
-	const node = {
-		schema,
-		operationName,
-		operation,
-		additionalProperties,
-		status: "new",
-		definitionName: root ? null : createDefinitionName(exportContext, operationName),
-		pointer: root ? "#" : null
-	};
-	if (!root) node.pointer = `#/definitions/${node.definitionName}`;
-	else exportContext.rootNode = node;
-	exportContext.nodes.push(node);
-	return node;
-}
-function buildExportNodeSchema(node, options) {
-	if (node.status === "built") return { $ref: node.pointer };
-	if (node.status === "building") return { $ref: node.pointer };
-	const exportContext = getExportContext(options);
-	node.status = "building";
-	if (node.pointer !== "#") exportContext.definitions[node.definitionName] = {};
-	const objectSchema = buildSchemaObjectFragment(node.schema, options, node.operationName, node.operation, node.additionalProperties);
-	node.status = "built";
-	if (node.pointer === "#") return objectSchema;
-	exportContext.definitions[node.definitionName] = objectSchema;
-	return { $ref: node.pointer };
-}
-function buildSchemaReference(schema, options, operationName, operation, additionalProperties = false) {
-	const exportContext = getExportContext(options);
-	const node = getOrCreateExportNode(schema, options, operationName, operation, additionalProperties);
-	if (exportContext.rootNode === node) return { $ref: "#" };
-	return buildExportNodeSchema(node, options);
-}
-function createFieldSchemaState(schema, { referenceBacked = false } = {}) {
-	return {
-		schema,
-		referenceBacked
-	};
-}
-function buildSchemaObjectFragment(schema, options, operationName, operation, additionalProperties = false) {
-	const properties = {};
-	const required = [];
-	for (const [fieldName, definition] of Object.entries(schema.structure)) {
-		setOwnProperty(properties, fieldName, buildFieldSchema(schema, fieldName, definition, options, operationName, operation));
-		if (operation.enforceRequired && definition.required === true) required.push(fieldName);
-	}
-	const objectSchema = {
-		type: "object",
-		properties,
-		additionalProperties
-	};
-	if (required.length > 0) objectSchema.required = required;
-	return objectSchema;
-}
-function buildArrayItemsSchema(schema, fieldName, definition, options, operationName, operation) {
-	const itemsConfig = resolveArrayItemsConfig(fieldName, definition);
-	if (!itemsConfig) return null;
-	if (itemsConfig.kind === "schema") return {
-		...wrapReferenceSchema(buildSchemaReference(itemsConfig.schema, options, "replace", itemsConfig.schema.operations.replace, false)),
-		[JSON_REST_EXTENSION_KEY]: { castType: "object" }
-	};
-	const itemOperationName = definition.items.type === "object" && Object.hasOwn(definition.items, "schema") ? "replace" : operationName;
-	const itemOperation = itemOperationName === "replace" ? schema.operations.replace : operation;
-	return buildFieldSchema(schema, `${fieldName}[]`, definition.items, options, itemOperationName, itemOperation);
-}
-function buildObjectValuesSchema(schema, fieldName, definition, options, operationName, operation) {
-	const valuesConfig = resolveObjectValuesConfig(fieldName, definition);
-	if (!valuesConfig) return null;
-	if (valuesConfig.kind === "schema") return {
-		...wrapReferenceSchema(buildSchemaReference(valuesConfig.schema, options, "replace", valuesConfig.schema.operations.replace, false)),
-		[JSON_REST_EXTENSION_KEY]: { castType: "object" }
-	};
-	const valueOperationName = valuesConfig.definition.type === "object" && Object.hasOwn(valuesConfig.definition, "schema") ? "replace" : operationName;
-	const valueOperation = valueOperationName === "replace" ? schema.operations.replace : operation;
-	return buildFieldSchema(schema, `${fieldName}.*`, valuesConfig.definition, options, valueOperationName, valueOperation);
-}
-function buildBaseFieldSchema(schema, fieldName, definition, options, operationName, operation) {
-	if (definition.type === "object") {
-		const objectMode = resolveObjectFieldMode(fieldName, definition);
-		if (objectMode.kind === "nested") return createFieldSchemaState(buildSchemaReference(objectMode.schema, options, operationName, operation, objectMode.allowAdditionalProperties === true), { referenceBacked: true });
-		if (objectMode.kind === "opaque") return createFieldSchemaState({
-			type: "object",
-			additionalProperties: true
-		});
-		if (objectMode.kind === "map") return createFieldSchemaState({
-			type: "object",
-			additionalProperties: buildObjectValuesSchema(schema, fieldName, definition, options, operationName, operation)
-		});
-	}
-	const baseSchema = getTypeExporter(schema, definition)({
-		schema,
-		fieldName,
-		definition,
-		operation: operationName,
-		mode: operationName,
-		options
-	});
-	if (!baseSchema || typeof baseSchema !== "object" || Array.isArray(baseSchema)) throw new Error(`Type '${definition.type}' on field '${fieldName}' returned an invalid JSON Schema fragment.`);
-	if (definition.type === "array") {
-		const itemsSchema = buildArrayItemsSchema(schema, fieldName, definition, options, operationName, operation);
-		if (itemsSchema) return createFieldSchemaState({
-			...baseSchema,
-			items: itemsSchema
-		}, { referenceBacked: isReferenceOnlySchema(baseSchema) });
-	}
-	return createFieldSchemaState(baseSchema, { referenceBacked: isReferenceOnlySchema(baseSchema) });
-}
-function buildFieldSchema(schema, fieldName, definition, options, operationName, operation) {
-	const exportContext = {
-		schema,
-		fieldName,
-		definition,
-		operation: operationName,
-		mode: operationName,
-		options
-	};
-	const baseFieldSchemaState = buildBaseFieldSchema(schema, fieldName, definition, options, operationName, operation);
-	const workingSchema = baseFieldSchemaState.referenceBacked ? wrapReferenceSchema(baseFieldSchemaState.schema) : { ...baseFieldSchemaState.schema };
-	const extensionMetadata = { castType: definition.type };
-	for (const parameterName of Object.keys(definition)) {
-		if (parameterName === "type") continue;
-		if (!Object.hasOwn(schema.validators, parameterName)) continue;
-		const exporter = getValidatorExporter(schema, parameterName, fieldName);
-		if (!exporter) continue;
-		const fragment = exporter({
-			...exportContext,
-			parameterName,
-			parameterValue: definition[parameterName],
-			fieldSchema: { ...workingSchema }
-		});
-		if (!fragment) continue;
-		mergeSchemaFragment(workingSchema, fragment);
-	}
-	if (workingSchema[JSON_REST_EXTENSION_KEY]) {
-		mergePlainObjects(extensionMetadata, workingSchema[JSON_REST_EXTENSION_KEY]);
-		delete workingSchema[JSON_REST_EXTENSION_KEY];
-	}
-	const alternatives = [];
-	if (definition.nullable === true) alternatives.push({ type: "null" });
-	if (definition.nullOnEmpty === true) alternatives.push({ const: "" });
-	const finalSchema = wrapReferenceSchema(buildAnyOfSchema(workingSchema, alternatives));
-	if (definition.defaultTo !== void 0 && operation.applyDefaults) {
-		if (typeof definition.defaultTo !== "function") {
-			const defaultResult = schema._normalizeDefault(definition, definition.defaultTo, {
-				fieldPath: fieldName,
-				currentObject: {},
-				containerKey: fieldName,
-				objectBeforeCast: {},
-				options: {},
-				settings: schema._buildOperationSettings(operationName, operation, {})
-			});
-			if (Object.keys(defaultResult.errors).length > 0) {
-				const firstError = Object.values(defaultResult.errors)[0];
-				throw new Error(`defaultTo for "${fieldName}" is invalid (${firstError.code}).`);
-			}
-			finalSchema.default = defaultResult.value;
-		} else extensionMetadata.defaults = { providedByFunction: true };
-	}
-	finalSchema[JSON_REST_EXTENSION_KEY] = extensionMetadata;
-	return finalSchema;
-}
-function buildJsonSchema(schema, options = {}) {
-	const exportOptions = createExportOptions(options);
-	const { operationName, operation } = resolveExportOperation(schema, exportOptions);
-	const additionalProperties = exportOptions.additionalProperties === void 0 ? false : exportOptions.additionalProperties;
-	const exportContext = getExportContext(exportOptions);
-	const transportSchema = {
-		$schema: JSON_SCHEMA_DRAFT_07,
-		...buildExportNodeSchema(getOrCreateExportNode(schema, exportOptions, operationName, operation, additionalProperties, { root: true }), exportOptions)
-	};
-	if (Object.keys(exportContext.definitions).length > 0) transportSchema.definitions = exportContext.definitions;
-	return transportSchema;
-}
-//#endregion
-//#region ../../../../node_modules/json-rest-schema/src/core/Schema.js
-/**
-* @file Defines the Schema class, which contains the core validation engine.
-*/
-/**
-* @typedef {object} ValidationError
-* @property {string} field - The name of the field that failed validation.
-* @property {string} code - A stable, machine-readable error code (e.g., 'MIN_LENGTH').
-* @property {string} message - The human-readable error message.
-* @property {object} [params] - A key-value object with context about the error (e.g., { min: 3, actual: 2 }).
-*/
-/**
-* @typedef {object} ValidationContext
-* @property {Schema} schema - The current schema instance.
-* @property {object} definition - The schema definition for the specific field.
-* @property {any} value - The current value of the field being processed.
-* @property {string} fieldName - The name of the field.
-* @property {object} object - The full object being validated (with modifications).
-* @property {object} objectBeforeCast - The original, unmodified input object.
-* @property {any} valueBeforeCast - The original value of the field.
-* @property {object} options - The global validation options.
-* @property {string} mode - The active validation contract. Preserved as a compatibility alias for `operation`.
-* @property {string} operation - The active validation contract name.
-* @property {boolean} fieldPresent - Whether the field was explicitly present in the input object.
-* @property {{nullable: boolean, nullOnEmpty: boolean}} computedOptions - Calculated options.
-* @property {string} [parameterName] - The name of the validator parameter being processed.
-* @property {any} [parameterValue] - The value of the validator parameter.
-* @property {function(): void} throwTypeError - Throws a standardized type casting error.
-* @property {function(string, string, object=): void} throwParamError - Throws a standardized parameter validation error.
-*/
-function isThenable$1(value) {
-	return value !== null && (typeof value === "object" || typeof value === "function") && typeof value.then === "function";
-}
-function isSchemaInstance(value) {
-	return value instanceof Schema;
-}
-function createSelectionNode() {
-	return {
-		self: false,
-		children: {}
-	};
-}
-function hasSelectionChildren(selectionNode) {
-	return Object.keys(selectionNode.children).length > 0;
-}
-function joinPath(basePath, pathSegment) {
-	return `${basePath}.${String(pathSegment)}`;
-}
-function buildFieldPath(basePath, fieldName) {
-	return basePath === "" ? String(fieldName) : joinPath(basePath, fieldName);
-}
-function stripPathPrefix(path, prefix) {
-	if (path === prefix) return "";
-	const prefixWithDot = `${prefix}.`;
-	if (!path.startsWith(prefixWithDot)) return null;
-	return path.slice(prefixWithDot.length);
-}
-function prefixErrorMap(errors, prefix) {
-	const prefixedErrors = {};
-	for (const error of Object.values(errors)) {
-		const field = joinPath(prefix, error.field);
-		setOwnProperty(prefixedErrors, field, {
-			...error,
-			field
-		});
-	}
-	return prefixedErrors;
-}
-function buildPathSegments(path) {
-	return buildPathSegments$1(path, "validatePath");
-}
-function buildSelectionTree(paths) {
-	const selectionTree = {};
-	for (const path of paths) {
-		const segments = buildPathSegments(path);
-		let currentTree = selectionTree;
-		for (let index = 0; index < segments.length; index++) {
-			const segment = segments[index];
-			if (!Object.hasOwn(currentTree, segment)) setOwnProperty(currentTree, segment, createSelectionNode());
-			if (index === segments.length - 1) currentTree[segment].self = true;
-			currentTree = currentTree[segment].children;
-		}
-	}
-	return selectionTree;
-}
-function getValueAtPath(value, pathSegments) {
-	let currentValue = value;
-	for (const segment of pathSegments) {
-		if (currentValue === null || currentValue === void 0) return void 0;
-		if (typeof currentValue !== "object") return void 0;
-		if (!Object.hasOwn(currentValue, segment)) return void 0;
-		currentValue = currentValue[segment];
-	}
-	return currentValue;
-}
-function hasSelectedValue(value) {
-	if (value === null) return true;
-	if (Array.isArray(value)) return Object.keys(value).length > 0;
-	if (isPlainObject(value)) return Object.keys(value).length > 0;
-	return value !== void 0;
-}
-function sortSelectionKeys(keys) {
-	return [...keys].sort((left, right) => {
-		const leftIsIndex = /^[0-9]+$/.test(left);
-		const rightIsIndex = /^[0-9]+$/.test(right);
-		if (leftIsIndex && rightIsIndex) return Number(left) - Number(right);
-		if (leftIsIndex) return -1;
-		if (rightIsIndex) return 1;
-		return left.localeCompare(right);
-	});
-}
-function isNumericPathSegment(segment) {
-	return /^[0-9]+$/.test(segment);
-}
-function cloneSchemaIntrospectionSnapshot(schema, seen = /* @__PURE__ */ new WeakMap()) {
-	if (seen.has(schema)) return seen.get(schema);
-	const snapshot = Object.create(Schema.prototype);
-	seen.set(schema, snapshot);
-	snapshot.structure = null;
-	snapshot.types = schema.types;
-	snapshot.validators = schema.validators;
-	snapshot.operations = schema.operations;
-	snapshot.structure = freezeIntrospectionValue(cloneIntrospectionValue(schema.structure, seen));
-	snapshot._installOperationMethods();
-	return Object.freeze(snapshot);
-}
-function cloneIntrospectionValue(value, seen = /* @__PURE__ */ new WeakMap()) {
-	if (value === null || typeof value !== "object") return value;
-	if (isSchemaInstance(value)) return cloneSchemaIntrospectionSnapshot(value, seen);
-	if (value instanceof Date) return new Date(value.getTime());
-	if (value instanceof RegExp) {
-		const cloned = new RegExp(value.source, value.flags);
-		cloned.lastIndex = value.lastIndex;
-		return cloned;
-	}
-	if (seen.has(value)) return seen.get(value);
-	if (Array.isArray(value)) {
-		const cloned = [];
-		seen.set(value, cloned);
-		for (const item of value) cloned.push(cloneIntrospectionValue(item, seen));
-		return cloned;
-	}
-	if (!isPlainObject(value)) return value;
-	const cloned = {};
-	seen.set(value, cloned);
-	for (const [key, entry] of Object.entries(value)) setOwnProperty(cloned, key, cloneIntrospectionValue(entry, seen));
-	return cloned;
-}
-function freezeIntrospectionValue(value, seen = /* @__PURE__ */ new WeakSet()) {
-	if (value === null || typeof value !== "object" || seen.has(value) || isSchemaInstance(value)) return value;
-	seen.add(value);
-	if (Array.isArray(value)) for (const item of value) freezeIntrospectionValue(item, seen);
-	else for (const key of Reflect.ownKeys(value)) freezeIntrospectionValue(value[key], seen);
-	return Object.freeze(value);
-}
-function createIntrospectionSnapshot(value) {
-	return freezeIntrospectionValue(cloneIntrospectionValue(value));
-}
-function resolveDefinitionFromSchemaPath(schema, pathSegments, basePath = "") {
-	if (!isSchemaInstance(schema)) return null;
-	if (!Array.isArray(pathSegments) || pathSegments.length < 1) return null;
-	const [fieldName, ...rest] = pathSegments;
-	if (!Object.hasOwn(schema.structure, fieldName)) return null;
-	const definition = schema.structure[fieldName];
-	if (rest.length < 1) return definition;
-	return resolveNestedDefinitionAtPath(schema, definition, rest, buildFieldPath(basePath, fieldName));
-}
-function resolveNestedDefinitionAtPath(schema, definition, pathSegments, fieldPath) {
-	if (definition?.type === "object") {
-		const objectMode = schema._resolveObjectFieldMode(fieldPath, definition);
-		if (objectMode.kind !== "nested") return null;
-		return resolveDefinitionFromSchemaPath(objectMode.schema, pathSegments, fieldPath);
-	}
-	if (definition?.type === "array") {
-		const itemsConfig = schema._resolveArrayItemsConfig(fieldPath, definition);
-		if (!itemsConfig || pathSegments.length < 1) return null;
-		const [indexSegment, ...rest] = pathSegments;
-		if (!isNumericPathSegment(indexSegment)) return null;
-		const itemPath = joinPath(fieldPath, indexSegment);
-		if (itemsConfig.kind === "schema") {
-			if (rest.length < 1) return null;
-			return resolveDefinitionFromSchemaPath(itemsConfig.schema, rest, itemPath);
-		}
-		if (rest.length < 1) return itemsConfig.definition;
-		return resolveNestedDefinitionAtPath(schema, itemsConfig.definition, rest, itemPath);
-	}
-	return null;
-}
-function buildNestedOptions(options, prefix) {
-	const nestedOptions = { ...options };
-	if (Array.isArray(options.skipFields)) {
-		const skipFields = options.skipFields.map((fieldPath) => stripPathPrefix(fieldPath, prefix)).filter((fieldPath) => fieldPath !== null && fieldPath !== "");
-		if (skipFields.length > 0) nestedOptions.skipFields = skipFields;
-		else delete nestedOptions.skipFields;
-	}
-	if (isPlainObject(options.skipParams)) {
-		const skipParams = {};
-		for (const [fieldPath, parameters] of Object.entries(options.skipParams)) {
-			const nestedFieldPath = stripPathPrefix(fieldPath, prefix);
-			if (nestedFieldPath === null || nestedFieldPath === "") continue;
-			setOwnProperty(skipParams, nestedFieldPath, parameters);
-		}
-		if (Object.keys(skipParams).length > 0) nestedOptions.skipParams = skipParams;
-		else delete nestedOptions.skipParams;
-	}
-	return nestedOptions;
-}
-var DEFAULT_OPERATIONS = Object.freeze({
-	create: Object.freeze({
-		targetFields: "schema",
-		enforceRequired: true,
-		applyDefaults: true,
-		outputFields: "validated",
-		rejectExplicitUndefined: true
-	}),
-	replace: Object.freeze({
-		targetFields: "schema",
-		enforceRequired: true,
-		applyDefaults: true,
-		outputFields: "validated",
-		rejectExplicitUndefined: true
-	}),
-	patch: Object.freeze({
-		targetFields: "input",
-		enforceRequired: false,
-		applyDefaults: false,
-		outputFields: "input",
-		rejectExplicitUndefined: true
-	})
-});
-function validateOperationOption(operationName, descriptor, key, allowedValues) {
-	const value = descriptor[key];
-	if (!allowedValues.includes(value)) throw new Error(`Operation "${operationName}" must define ${key} as one of: ${allowedValues.join(", ")}.`);
-}
-function validateBooleanOperationOption(operationName, descriptor, key, required = true) {
-	const value = descriptor[key];
-	if (value === void 0 && !required) return;
-	if (typeof value !== "boolean") throw new Error(`Operation "${operationName}" must define ${key} as a boolean.`);
-}
-function normalizeOperationDescriptor(operationName, descriptor) {
-	if (typeof descriptor !== "object" || descriptor === null || Array.isArray(descriptor)) throw new Error(`Operation "${operationName}" must be an object.`);
-	validateOperationOption(operationName, descriptor, "targetFields", ["schema", "input"]);
-	validateBooleanOperationOption(operationName, descriptor, "enforceRequired");
-	validateBooleanOperationOption(operationName, descriptor, "applyDefaults");
-	validateOperationOption(operationName, descriptor, "outputFields", ["validated", "input"]);
-	validateBooleanOperationOption(operationName, descriptor, "rejectExplicitUndefined", false);
-	return Object.freeze({
-		targetFields: descriptor.targetFields,
-		enforceRequired: descriptor.enforceRequired,
-		applyDefaults: descriptor.applyDefaults,
-		outputFields: descriptor.outputFields,
-		rejectExplicitUndefined: descriptor.rejectExplicitUndefined === void 0 ? true : descriptor.rejectExplicitUndefined
-	});
-}
-function normalizeOperations(operations = {}) {
-	if (typeof operations !== "object" || operations === null || Array.isArray(operations)) throw new Error("Schema operations must be an object.");
-	const normalizedOperations = Object.create(null);
-	for (const [operationName, descriptor] of Object.entries(DEFAULT_OPERATIONS)) setOwnProperty(normalizedOperations, operationName, descriptor);
-	for (const [operationName, descriptor] of Object.entries(operations)) setOwnProperty(normalizedOperations, operationName, normalizeOperationDescriptor(operationName, descriptor));
-	return Object.freeze(normalizedOperations);
-}
-function freezeOwnMap(source) {
-	const map = Object.create(null);
-	for (const [key, value] of Object.entries(source)) setOwnProperty(map, key, value);
-	return Object.freeze(map);
-}
-function cloneValidationOptions(options) {
-	const validationOptions = { ...options };
-	delete validationOptions.operation;
-	delete validationOptions.mode;
-	return validationOptions;
-}
-/**
-* Represents an instance of a schema that can validate objects against a structure.
-* This class is instantiated by the createSchema factory function.
-*/
-var Schema = class {
-	/**
-	* @param {object} structure The schema definition.
-	* @param {object} types The globally registered type handlers.
-	* @param {object} validators The globally registered validator handlers.
-	* @param {object} [operations={}] Per-schema operation descriptors.
-	*/
-	constructor(structure, types, validators, operations = {}) {
-		this.structure = structure;
-		this.types = freezeOwnMap(types);
-		this.validators = freezeOwnMap(validators);
-		this.operations = normalizeOperations(operations);
-		this._installOperationMethods();
-	}
-	/** @private */
-	_typeError(field) {
-		return this._paramError(field, "TYPE_CAST_FAILED", "Value could not be cast to the required type.");
-	}
-	/** @private */
-	_paramError(field, code, message, params = {}) {
-		const e = new Error(message);
-		e.errorObject = {
-			field,
-			code,
-			message,
-			params
-		};
-		return e;
-	}
-	/** @private */
-	_paramToBeSkipped(parameterName, skipParams, fieldName) {
-		if (typeof skipParams !== "object" || skipParams === null) return false;
-		if (Array.isArray(skipParams[fieldName]) && skipParams[fieldName].includes(parameterName)) return true;
-		return false;
-	}
-	/** @private */
-	_fieldToBeSkipped(fieldPath, options) {
-		return Array.isArray(options.skipFields) && options.skipFields.includes(fieldPath);
-	}
-	/** @private */
-	_mergeErrors(target, source) {
-		for (const [fieldPath, error] of Object.entries(source)) setOwnProperty(target, fieldPath, error);
-	}
-	/** @private */
-	_singleErrorMap(error) {
-		const errors = {};
-		setOwnProperty(errors, error.field, error);
-		return errors;
-	}
-	/** @private */
-	_assertSupportedOptions(options = {}) {
-		if (Object.hasOwn(options, "onlyObjectValues")) throw new Error("Unsupported validation option `onlyObjectValues`. Call `patch()` directly.");
-		if (Object.hasOwn(options, "mode")) throw new Error("Unsupported validation option `mode`. Call `validateWith()` or an operation method directly.");
-		if (Object.hasOwn(options, "operation")) throw new Error("Unsupported validation option `operation`. Call `validateWith()` or an operation method directly.");
-	}
-	/** @private */
-	_buildOperationSettings(operationName, operation, object) {
-		return {
-			operationName,
-			operation,
-			targetFieldNames: operation.targetFields === "input" ? Object.keys(object) : Object.keys(this.structure),
-			outputFieldNames: operation.outputFields === "input" ? Object.keys(object) : Object.keys(this.structure),
-			enforceRequired: operation.enforceRequired,
-			applyDefaults: operation.applyDefaults,
-			rejectExplicitUndefined: operation.rejectExplicitUndefined,
-			defaultedFields: /* @__PURE__ */ new Set(),
-			isFieldPresent: (fieldName) => Object.hasOwn(object, fieldName)
-		};
-	}
-	/** @private */
-	_assertPlainObjectInput(methodName, object) {
-		if (!isPlainObject(object)) throw new Error(`${methodName}() expects a plain object input.`);
-	}
-	/** @private */
-	_resolvePathValidationRequest(options = {}) {
-		const operationName = options.operation ?? options.mode ?? "patch";
-		if (Object.hasOwn(options, "operation") && Object.hasOwn(options, "mode") && options.operation !== options.mode) throw new Error("Path validation options `operation` and `mode` must match when both are provided.");
-		if (!Object.hasOwn(this.operations, operationName)) throw new Error(`Unknown operation "${operationName}".`);
-		return {
-			operationName,
-			operation: this.operations[operationName],
-			validationOptions: cloneValidationOptions(options)
-		};
-	}
-	/** @private */
-	_buildOperationResult(object, workingObject, settings) {
-		const validatedObject = {};
-		for (const fieldName of settings.outputFieldNames) {
-			if (!Object.hasOwn(this.structure, fieldName)) continue;
-			const fieldPresent = settings.isFieldPresent(fieldName);
-			if (!(workingObject[fieldName] !== void 0 || fieldPresent && object[fieldName] === null || settings.defaultedFields.has(fieldName))) continue;
-			if (!fieldPresent && !settings.defaultedFields.has(fieldName)) continue;
-			setOwnProperty(validatedObject, fieldName, workingObject[fieldName]);
-		}
-		return validatedObject;
-	}
-	/** @private */
-	_resolveObjectFieldMode(fieldPath, definition) {
-		return resolveObjectFieldMode(fieldPath, definition);
-	}
-	/** @private */
-	_resolveArrayItemsConfig(fieldPath, definition) {
-		return resolveArrayItemsConfig(fieldPath, definition);
-	}
-	/** @private */
-	_resolveObjectValuesConfig(fieldPath, definition) {
-		return resolveObjectValuesConfig(fieldPath, definition);
-	}
-	/** @private */
-	_buildArrayItemSettings(definition, settings) {
-		if (definition.type === "object" && Object.hasOwn(definition, "schema")) return {
-			...settings,
-			operationName: "replace",
-			operation: this.operations.replace
-		};
-		return settings;
-	}
-	/** @private */
-	_castValue(definition, rawValue, fieldPath, currentObject, containerKey, objectBeforeCast, options, settings) {
-		const nullable = definition.nullable === true || options.nullable === true;
-		const nullOnEmpty = definition.nullOnEmpty === true || options.nullOnEmpty === true;
-		if (!Object.hasOwn(this.types, definition.type)) throw new Error(`No casting function for type: ${definition.type}`);
-		const typeHandler = this.types[definition.type];
-		if (rawValue === null) {
-			if (nullable) {
-				setOwnProperty(currentObject, containerKey, null);
-				return {
-					errors: {},
-					shouldContinue: false
-				};
-			}
-			return {
-				errors: this._singleErrorMap({
-					field: fieldPath,
-					code: "NOT_NULLABLE",
-					message: "Field cannot be null",
-					params: {}
-				}),
-				shouldContinue: false
-			};
-		}
-		if (rawValue === "" && nullOnEmpty) {
-			setOwnProperty(currentObject, containerKey, null);
-			return {
-				errors: {},
-				shouldContinue: false
-			};
-		}
-		/** @type {ValidationContext} */
-		const context = {
-			schema: this,
-			definition,
-			value: rawValue,
-			fieldName: fieldPath,
-			object: currentObject,
-			objectBeforeCast,
-			valueBeforeCast: rawValue,
-			options,
-			mode: settings.operationName,
-			operation: settings.operationName,
-			fieldPresent: true,
-			computedOptions: {
-				nullable: nullable || nullOnEmpty,
-				nullOnEmpty
-			},
-			throwTypeError: () => {
-				throw this._typeError(fieldPath);
-			},
-			throwParamError: (code, message, params) => {
-				throw this._paramError(fieldPath, code, message, params);
-			}
-		};
-		try {
-			const castResult = typeHandler(context);
-			if (isThenable$1(castResult)) throw new Error(`Type handler for "${definition.type}" must be synchronous.`);
-			if (castResult !== void 0) {
-				setOwnProperty(currentObject, containerKey, castResult);
-				context.value = castResult;
-			}
-		} catch (e) {
-			if (e.errorObject) return {
-				errors: this._singleErrorMap(e.errorObject),
-				shouldContinue: false
-			};
-			throw e;
-		}
-		return {
-			errors: {},
-			context,
-			shouldContinue: true
-		};
-	}
-	/** @private */
-	_runFieldValidators(definition, fieldPath, currentObject, containerKey, context, options) {
-		for (const paramName of Object.keys(definition)) {
-			if (paramName === "type") continue;
-			if (this._paramToBeSkipped(paramName, options.skipParams, fieldPath)) continue;
-			if (!Object.hasOwn(this.validators, paramName)) continue;
-			const validatorHandler = this.validators[paramName];
-			try {
-				context.parameterName = paramName;
-				context.parameterValue = definition[paramName];
-				const validatorResult = validatorHandler(context);
-				if (isThenable$1(validatorResult)) throw new Error(`Validator handler for "${paramName}" must be synchronous.`);
-				if (validatorResult !== void 0) {
-					setOwnProperty(currentObject, containerKey, validatorResult);
-					context.value = validatorResult;
-				}
-			} catch (e) {
-				if (e.errorObject) return this._singleErrorMap(e.errorObject);
-				throw e;
-			}
-		}
-		return {};
-	}
-	/** @private */
-	_normalizeAndValidateValue(definition, rawValue, fieldPath, currentObject, containerKey, objectBeforeCast, options, settings) {
-		const castResult = this._castValue(definition, rawValue, fieldPath, currentObject, containerKey, objectBeforeCast, options, settings);
-		if (Object.keys(castResult.errors).length > 0) return castResult.errors;
-		if (!castResult.shouldContinue) return {};
-		const { context } = castResult;
-		const nestedErrors = this._validateNestedValue(definition, fieldPath, currentObject, containerKey, options, settings);
-		if (Object.keys(nestedErrors).length > 0) return nestedErrors;
-		context.value = currentObject[containerKey];
-		return this._runFieldValidators(definition, fieldPath, currentObject, containerKey, context, options);
-	}
-	/** @private */
-	_normalizeDefault(definition, defaultValue, { fieldPath, currentObject, containerKey, objectBeforeCast, options, settings }) {
-		const defaultObject = { ...currentObject };
-		setOwnProperty(defaultObject, containerKey, defaultValue);
-		return {
-			errors: this._normalizeAndValidateValue(definition, defaultValue, fieldPath, defaultObject, containerKey, objectBeforeCast, options, settings),
-			value: defaultObject[containerKey]
-		};
-	}
-	/** @private */
-	_validateNestedValue(definition, fieldPath, currentObject, containerKey, options, settings) {
-		if (definition.type === "object") {
-			const objectMode = this._resolveObjectFieldMode(fieldPath, definition);
-			if (objectMode.kind === "nested") return this._validateNestedObjectSchema(objectMode, fieldPath, currentObject, containerKey, options, settings);
-			if (objectMode.kind === "map") return this._validateObjectValues(fieldPath, currentObject, containerKey, objectMode.valuesConfig, options, settings);
-			return {};
-		}
-		if (definition.type !== "array") return {};
-		const itemsConfig = this._resolveArrayItemsConfig(fieldPath, definition);
-		if (!itemsConfig) return {};
-		return this._validateArrayItems(fieldPath, currentObject, containerKey, itemsConfig, options, settings);
-	}
-	/** @private */
-	_validateNestedObjectSchema(objectMode, fieldPath, currentObject, containerKey, options, settings) {
-		const sourceObject = currentObject[containerKey];
-		const nestedInput = objectMode.allowAdditionalProperties ? this._extractKnownObjectFields(sourceObject, objectMode.schema) : sourceObject;
-		const nestedResult = objectMode.schema._validateWithOperation(settings.operationName, settings.operation, nestedInput, buildNestedOptions(options, fieldPath));
-		setOwnProperty(currentObject, containerKey, objectMode.allowAdditionalProperties ? this._mergeKnownAndPassthroughObjectFields(sourceObject, objectMode.schema, nestedResult.validatedObject) : nestedResult.validatedObject);
-		return prefixErrorMap(nestedResult.errors, fieldPath);
-	}
-	/** @private */
-	_extractKnownObjectFields(sourceObject, nestedSchema) {
-		const knownObject = {};
-		for (const [key, value] of Object.entries(sourceObject)) if (Object.hasOwn(nestedSchema.structure, key)) setOwnProperty(knownObject, key, value);
-		return knownObject;
-	}
-	/** @private */
-	_mergeKnownAndPassthroughObjectFields(sourceObject, nestedSchema, validatedObject) {
-		const mergedObject = {};
-		for (const key of Object.keys(sourceObject)) {
-			if (!Object.hasOwn(nestedSchema.structure, key)) {
-				setOwnProperty(mergedObject, key, sourceObject[key]);
-				continue;
-			}
-			if (Object.hasOwn(validatedObject, key)) setOwnProperty(mergedObject, key, validatedObject[key]);
-		}
-		for (const [key, value] of Object.entries(validatedObject)) if (!Object.hasOwn(mergedObject, key)) setOwnProperty(mergedObject, key, value);
-		return mergedObject;
-	}
-	/** @private */
-	_validateObjectValues(fieldPath, currentObject, containerKey, valuesConfig, options, settings) {
-		const originalEntries = currentObject[containerKey];
-		const normalizedEntries = { ...originalEntries };
-		const errors = {};
-		setOwnProperty(currentObject, containerKey, normalizedEntries);
-		for (const key of Object.keys(originalEntries)) {
-			const valuePath = joinPath(fieldPath, key);
-			if (this._fieldToBeSkipped(valuePath, options)) continue;
-			const rawValue = normalizedEntries[key];
-			if (rawValue === void 0) {
-				if (settings.rejectExplicitUndefined) this._mergeErrors(errors, this._singleErrorMap(this._typeError(valuePath).errorObject));
-				else delete normalizedEntries[key];
-				continue;
-			}
-			if (valuesConfig.kind === "schema") {
-				const valueResult = valuesConfig.schema._validateWithOperation("replace", valuesConfig.schema.operations.replace, rawValue, buildNestedOptions(options, valuePath));
-				setOwnProperty(normalizedEntries, key, valueResult.validatedObject);
-				this._mergeErrors(errors, prefixErrorMap(valueResult.errors, valuePath));
-				continue;
-			}
-			const valueErrors = this._normalizeAndValidateValue(valuesConfig.definition, rawValue, valuePath, normalizedEntries, key, originalEntries, options, this._buildArrayItemSettings(valuesConfig.definition, settings));
-			this._mergeErrors(errors, valueErrors);
-		}
-		return errors;
-	}
-	/** @private */
-	_validateArrayItems(fieldPath, currentObject, containerKey, itemsConfig, options, settings) {
-		const originalItems = currentObject[containerKey];
-		const normalizedItems = originalItems.slice();
-		const errors = {};
-		setOwnProperty(currentObject, containerKey, normalizedItems);
-		for (let index = 0; index < normalizedItems.length; index++) {
-			const itemPath = joinPath(fieldPath, index);
-			if (this._fieldToBeSkipped(itemPath, options)) continue;
-			if (!Object.hasOwn(originalItems, index) || normalizedItems[index] === void 0) {
-				if (settings.rejectExplicitUndefined) this._mergeErrors(errors, this._singleErrorMap(this._typeError(itemPath).errorObject));
-				else delete normalizedItems[index];
-				continue;
-			}
-			if (itemsConfig.kind === "schema") {
-				const itemResult = itemsConfig.schema._validateWithOperation("replace", itemsConfig.schema.operations.replace, normalizedItems[index], buildNestedOptions(options, itemPath));
-				setOwnProperty(normalizedItems, index, itemResult.validatedObject);
-				this._mergeErrors(errors, prefixErrorMap(itemResult.errors, itemPath));
-				continue;
-			}
-			const itemErrors = this._normalizeAndValidateValue(itemsConfig.definition, normalizedItems[index], itemPath, normalizedItems, index, originalItems, options, this._buildArrayItemSettings(itemsConfig.definition, settings));
-			this._mergeErrors(errors, itemErrors);
-		}
-		return errors;
-	}
-	/**
-	* Processes a single field through the entire validation pipeline (pre-checks, casting, validators).
-	* This is the heart of the validation logic for an individual field.
-	* @private
-	* @param {string} fieldName - The name of the field to validate.
-	* @param {object} object - The original input object.
-	* @param {object} validatedObject - The object being built with validated data.
-	* @param {object} options - The global validation options.
-	* @param {object} settings - Mode-specific validation settings.
-	* @returns {ValidationError|null} An error object if validation fails, otherwise null.
-	*/
-	_validateField(fieldName, object, validatedObject, options, settings) {
-		if (!Object.hasOwn(this.structure, fieldName)) return {};
-		const definition = this.structure[fieldName];
-		if (this._fieldToBeSkipped(fieldName, options)) return {};
-		const fieldPresent = settings.isFieldPresent(fieldName);
-		const rawValue = object[fieldName];
-		const valueMissing = rawValue === void 0;
-		if (settings.enforceRequired && definition.required && (!fieldPresent || valueMissing)) {
-			if (!this._paramToBeSkipped("required", options.skipParams, fieldName)) return this._singleErrorMap({
-				field: fieldName,
-				code: "REQUIRED",
-				message: "Field is required",
-				params: {}
-			});
-		}
-		if (!fieldPresent) return {};
-		if (valueMissing) {
-			if (settings.rejectExplicitUndefined) return this._singleErrorMap(this._typeError(fieldName).errorObject);
-			return {};
-		}
-		return this._normalizeAndValidateValue(definition, rawValue, fieldName, validatedObject, fieldName, object, options, settings);
-	}
-	/** @private */
-	_validateWithOperation(operationName, operation, object, options) {
-		this._assertSupportedOptions(options);
-		const errors = {};
-		const workingObject = { ...object };
-		const settings = this._buildOperationSettings(operationName, operation, object);
-		for (const fieldName of Object.keys(object)) if (!Object.hasOwn(this.structure, fieldName)) setOwnProperty(errors, fieldName, {
-			field: fieldName,
-			code: "FIELD_NOT_ALLOWED",
-			message: "Field not allowed",
-			params: {}
-		});
-		for (const fieldName of settings.targetFieldNames) {
-			const fieldErrors = this._validateField(fieldName, object, workingObject, options, settings);
-			this._mergeErrors(errors, fieldErrors);
-		}
-		if (settings.applyDefaults) for (const fieldName of Object.keys(this.structure)) {
-			if (settings.isFieldPresent(fieldName)) continue;
-			if (this.structure[fieldName].defaultTo !== void 0) {
-				const definition = this.structure[fieldName];
-				const defaultValue = typeof definition.defaultTo === "function" ? definition.defaultTo() : definition.defaultTo;
-				const defaultResult = this._normalizeDefault(definition, defaultValue, {
-					fieldPath: fieldName,
-					currentObject: workingObject,
-					containerKey: fieldName,
-					objectBeforeCast: object,
-					options,
-					settings
-				});
-				this._mergeErrors(errors, defaultResult.errors);
-				if (Object.keys(defaultResult.errors).length > 0) continue;
-				setOwnProperty(workingObject, fieldName, defaultResult.value);
-				settings.defaultedFields.add(fieldName);
-			}
-		}
-		return {
-			validatedObject: this._buildOperationResult(object, workingObject, settings),
-			errors
-		};
-	}
-	/** @private */
-	_validateSelectedTree(selectionTree, object, options, settings, basePath = "") {
-		const errors = {};
-		const validatedObject = {};
-		for (const fieldName of sortSelectionKeys(Object.keys(selectionTree))) {
-			const fieldPath = buildFieldPath(basePath, fieldName);
-			if (!Object.hasOwn(this.structure, fieldName)) throw new Error(`Unknown schema path "${fieldPath}".`);
-			const fieldErrors = this._validateSelectedField(fieldName, selectionTree[fieldName], object, validatedObject, options, settings, fieldPath);
-			this._mergeErrors(errors, fieldErrors);
-		}
-		return {
-			validatedObject,
-			errors
-		};
-	}
-	/** @private */
-	_validateSelectedField(fieldName, selectionNode, object, validatedObject, options, settings, fieldPath) {
-		if (!Object.hasOwn(this.structure, fieldName)) return {};
-		const definition = this.structure[fieldName];
-		const exactSelected = selectionNode.self === true;
-		const hasChildren = hasSelectionChildren(selectionNode);
-		if (this._fieldToBeSkipped(fieldPath, options)) return {};
-		const fieldPresent = Object.hasOwn(object, fieldName);
-		const rawValue = object[fieldName];
-		const errors = {};
-		if (!fieldPresent) {
-			if (exactSelected && settings.enforceRequired && definition.required && !this._paramToBeSkipped("required", options.skipParams, fieldPath)) this._mergeErrors(errors, this._singleErrorMap({
-				field: fieldPath,
-				code: "REQUIRED",
-				message: "Field is required",
-				params: {}
-			}));
-			if (exactSelected && settings.applyDefaults && definition.defaultTo !== void 0) {
-				const defaultValue = typeof definition.defaultTo === "function" ? definition.defaultTo() : definition.defaultTo;
-				const defaultResult = this._normalizeDefault(definition, defaultValue, {
-					fieldPath,
-					currentObject: validatedObject,
-					containerKey: fieldName,
-					objectBeforeCast: object,
-					options,
-					settings
-				});
-				this._mergeErrors(errors, defaultResult.errors);
-				if (Object.keys(defaultResult.errors).length === 0) setOwnProperty(validatedObject, fieldName, defaultResult.value);
-			}
-			return errors;
-		}
-		if (rawValue === void 0) {
-			if (exactSelected && settings.rejectExplicitUndefined) return this._singleErrorMap(this._typeError(fieldPath).errorObject);
-			return {};
-		}
-		const currentObject = { [fieldName]: rawValue };
-		if (exactSelected) {
-			const fieldErrors = this._normalizeAndValidateValue(definition, rawValue, fieldPath, currentObject, fieldName, object, options, settings);
-			if (Object.hasOwn(currentObject, fieldName) && currentObject[fieldName] !== void 0) setOwnProperty(validatedObject, fieldName, currentObject[fieldName]);
-			else if (currentObject[fieldName] === null) setOwnProperty(validatedObject, fieldName, null);
-			return fieldErrors;
-		}
-		if (!hasChildren) return {};
-		const castResult = this._castValue(definition, rawValue, fieldPath, currentObject, fieldName, object, options, settings);
-		if (Object.keys(castResult.errors).length > 0) return castResult.errors;
-		if (!castResult.shouldContinue) return {};
-		const nestedResult = this._validateSelectedDescendants(definition, selectionNode.children, fieldPath, currentObject, fieldName, options, settings);
-		if (hasSelectedValue(currentObject[fieldName])) setOwnProperty(validatedObject, fieldName, currentObject[fieldName]);
-		return nestedResult;
-	}
-	/** @private */
-	_validateSelectedDescendants(definition, selectionTree, fieldPath, currentObject, containerKey, options, settings) {
-		if (definition.type === "object") {
-			const objectMode = this._resolveObjectFieldMode(fieldPath, definition);
-			if (objectMode.kind !== "nested") throw new Error(`Schema path "${fieldPath}" does not support nested field selection.`);
-			const nestedValue = currentObject[containerKey];
-			if (!isPlainObject(nestedValue)) return {};
-			const nestedResult = objectMode.schema._validateSelectedTree(selectionTree, nestedValue, buildNestedOptions(options, fieldPath), {
-				...settings,
-				defaultedFields: /* @__PURE__ */ new Set()
-			});
-			setOwnProperty(currentObject, containerKey, nestedResult.validatedObject);
-			return prefixErrorMap(nestedResult.errors, fieldPath);
-		}
-		if (definition.type === "array") {
-			const itemsConfig = this._resolveArrayItemsConfig(fieldPath, definition);
-			if (!itemsConfig) throw new Error(`Schema path "${fieldPath}" does not define array items for nested selection.`);
-			return this._validateSelectedArrayItems(fieldPath, currentObject, containerKey, itemsConfig, selectionTree, options, settings);
-		}
-		throw new Error(`Schema path "${fieldPath}" does not support nested field selection.`);
-	}
-	/** @private */
-	_validateSelectedArrayItems(fieldPath, currentObject, containerKey, itemsConfig, selectionTree, options, settings) {
-		const normalizedItems = [];
-		const sourceItems = currentObject[containerKey];
-		const errors = {};
-		setOwnProperty(currentObject, containerKey, normalizedItems);
-		for (const indexKey of sortSelectionKeys(Object.keys(selectionTree))) {
-			if (!/^[0-9]+$/.test(indexKey)) throw new Error(`Schema path "${joinPath(fieldPath, indexKey)}" is invalid because array segments must use numeric indexes.`);
-			const index = Number(indexKey);
-			const itemPath = joinPath(fieldPath, index);
-			const selectionNode = selectionTree[indexKey];
-			const exactSelected = selectionNode.self === true;
-			const hasChildren = hasSelectionChildren(selectionNode);
-			if (this._fieldToBeSkipped(itemPath, options)) continue;
-			if (!Object.hasOwn(sourceItems, index)) {
-				if (exactSelected && settings.rejectExplicitUndefined) setOwnProperty(errors, itemPath, this._typeError(itemPath).errorObject);
-				continue;
-			}
-			const rawValue = sourceItems[index];
-			if (rawValue === void 0) {
-				if (exactSelected && settings.rejectExplicitUndefined) setOwnProperty(errors, itemPath, this._typeError(itemPath).errorObject);
-				continue;
-			}
-			if (itemsConfig.kind === "schema") {
-				if (exactSelected) {
-					const itemResult = itemsConfig.schema._validateWithOperation("replace", itemsConfig.schema.operations.replace, rawValue, buildNestedOptions(options, itemPath));
-					if (hasSelectedValue(itemResult.validatedObject)) setOwnProperty(normalizedItems, index, itemResult.validatedObject);
-					this._mergeErrors(errors, prefixErrorMap(itemResult.errors, itemPath));
-					continue;
-				}
-				if (!hasChildren) continue;
-				const itemResult = itemsConfig.schema._validateSelectedTree(selectionNode.children, rawValue, buildNestedOptions(options, itemPath), {
-					...settings,
-					operationName: "replace",
-					operation: itemsConfig.schema.operations.replace,
-					defaultedFields: /* @__PURE__ */ new Set()
-				});
-				if (hasSelectedValue(itemResult.validatedObject)) setOwnProperty(normalizedItems, index, itemResult.validatedObject);
-				this._mergeErrors(errors, prefixErrorMap(itemResult.errors, itemPath));
-				continue;
-			}
-			const itemSettings = this._buildArrayItemSettings(itemsConfig.definition, settings);
-			const itemHolder = [rawValue];
-			if (exactSelected) {
-				const itemErrors = this._normalizeAndValidateValue(itemsConfig.definition, rawValue, itemPath, itemHolder, 0, sourceItems, options, itemSettings);
-				if (Object.hasOwn(itemHolder, 0) && itemHolder[0] !== void 0) setOwnProperty(normalizedItems, index, itemHolder[0]);
-				else if (itemHolder[0] === null) setOwnProperty(normalizedItems, index, null);
-				this._mergeErrors(errors, itemErrors);
-				continue;
-			}
-			if (!hasChildren) continue;
-			const castResult = this._castValue(itemsConfig.definition, rawValue, itemPath, itemHolder, 0, sourceItems, options, itemSettings);
-			if (Object.keys(castResult.errors).length > 0) {
-				this._mergeErrors(errors, castResult.errors);
-				continue;
-			}
-			if (!castResult.shouldContinue) continue;
-			const itemErrors = this._validateSelectedDescendants(itemsConfig.definition, selectionNode.children, itemPath, itemHolder, 0, options, itemSettings);
-			if (hasSelectedValue(itemHolder[0])) setOwnProperty(normalizedItems, index, itemHolder[0]);
-			this._mergeErrors(errors, itemErrors);
-		}
-		return errors;
-	}
-	/**
-	* Validates an object with a named operation contract.
-	* @param {string} operationName - The operation contract to use.
-	* @param {object} object - The input object to validate.
-	* @param {object} [options={}] - Validation options.
-	* @returns {{validatedObject: object, errors: Object.<string, ValidationError>}}
-	*/
-	validateWith(operationName, object, options = {}) {
-		if (!Object.hasOwn(this.operations, operationName)) throw new Error(`Unknown operation "${operationName}".`);
-		const operation = this.operations[operationName];
-		this._assertPlainObjectInput(operationName, object);
-		return this._validateWithOperation(operationName, operation, object, options);
-	}
-	/**
-	* Validates a single schema path against the selected operation.
-	* Defaults to `patch` semantics when no operation is specified.
-	* @param {string} path - A dotted schema path such as `email` or `workspace.slug`.
-	* @param {object} object - The input object to validate.
-	* @param {{operation?: string, mode?: string}} [options={}] - Path validation options.
-	* @returns {{validatedValue: any, errors: Object.<string, ValidationError>}}
-	*/
-	validateAt(path, object, options = {}) {
-		this._assertPlainObjectInput("validateAt", object);
-		const pathSegments = buildPathSegments(path);
-		const { operationName, operation, validationOptions } = this._resolvePathValidationRequest(options);
-		const result = this._validateSelectedTree(buildSelectionTree([path]), object, validationOptions, this._buildOperationSettings(operationName, operation, object));
-		return {
-			validatedValue: getValueAtPath(result.validatedObject, pathSegments),
-			errors: result.errors
-		};
-	}
-	/**
-	* Validates a selected set of schema paths against the chosen operation.
-	* Defaults to `patch` semantics when no operation is specified.
-	* @param {string[]} paths - A list of dotted schema paths.
-	* @param {object} object - The input object to validate.
-	* @param {{operation?: string, mode?: string}} [options={}] - Path validation options.
-	* @returns {{validatedObject: object, errors: Object.<string, ValidationError>}}
-	*/
-	validatePaths(paths, object, options = {}) {
-		this._assertPlainObjectInput("validatePaths", object);
-		if (!Array.isArray(paths) || paths.length === 0) throw new Error("validatePaths() expects a non-empty array of schema paths.");
-		const { operationName, operation, validationOptions } = this._resolvePathValidationRequest(options);
-		return this._validateSelectedTree(buildSelectionTree(paths), object, validationOptions, this._buildOperationSettings(operationName, operation, object));
-	}
-	/**
-	* Installs operation aliases such as `create`, `replace`, `patch`, or user-defined operations.
-	* @private
-	*/
-	_installOperationMethods() {
-		for (const operationName of Object.keys(this.operations)) {
-			if (operationName in this) throw new Error(`Operation name "${operationName}" is reserved and cannot be used as a schema method.`);
-			this[operationName] = (object, options = {}) => this.validateWith(operationName, object, options);
-		}
-	}
-	/**
-	* Exports the schema as a transport-facing JSON Schema object.
-	* @param {{operation?: string, mode?: 'create'|'replace'|'patch', additionalProperties?: boolean}} [options={}] - Export options.
-	* @returns {object} A draft-07 JSON Schema object.
-	*/
-	toJsonSchema(options = {}) {
-		return buildJsonSchema(this, options);
-	}
-	/**
-	* Returns a frozen snapshot map of the schema's top-level field definitions.
-	* @returns {object}
-	*/
-	getFieldDefinitions() {
-		return createIntrospectionSnapshot(this.structure);
-	}
-	/**
-	* Resolves a field definition by dotted path. Array items use numeric segments such as `roles.0.id`.
-	* Returns a frozen snapshot, or `null` when the path does not resolve to a field definition.
-	* @param {string} path
-	* @returns {object|null}
-	*/
-	getFieldDefinition(path) {
-		if (typeof path !== "string" || path.trim() === "") throw new Error("Field path must be a non-empty string.");
-		const definition = resolveDefinitionFromSchemaPath(this, buildPathSegments(path.trim()));
-		return definition === null ? null : createIntrospectionSnapshot(definition);
-	}
-	/**
-	* Resolves the `messages` object for a field definition by dotted path.
-	* Returns a frozen snapshot, or an empty frozen object when no messages exist.
-	* @param {string} path
-	* @returns {object}
-	*/
-	getFieldMessages(path) {
-		const definition = this.getFieldDefinition(path);
-		if (!definition || typeof definition.messages !== "object" || definition.messages === null) return Object.freeze({});
-		return createIntrospectionSnapshot(definition.messages);
-	}
-	/**
-	* Utility to filter an object, keeping only fields that have a specific parameter.
-	* @param {object} object - The object to clean.
-	* @param {string} parameterName - The schema parameter to look for.
-	* @returns {object} A new object with only the matching fields.
-	*/
-	cleanup(object, parameterName) {
-		const newObject = {};
-		for (const k of Object.keys(object)) if (Object.hasOwn(this.structure, k) && this.structure[k][parameterName]) setOwnProperty(newObject, k, object[k]);
-		return newObject;
-	}
-};
-//#endregion
-//#region ../../../../node_modules/flatted/esm/index.js
-var { parse: $parse, stringify: $stringify } = JSON;
-var { keys } = Object;
-var Primitive = String;
-var primitive = "string";
-var object = "object";
-var noop = (_, value) => value;
-var set = (known, input, value) => {
-	const index = Primitive(input.push(value) - 1);
-	known.set(value, index);
-	return index;
-};
-/**
-* Converts a JS value into a specialized flatted string.
-* @param {any} value
-* @param {((this: any, key: string, value: any) => any) | (string | number)[] | null | undefined} [replacer]
-* @param {string | number | undefined} [space]
-* @returns {string}
-*/
-var stringify = (value, replacer, space) => {
-	const $ = replacer && typeof replacer === object ? (k, v) => k === "" || -1 < replacer.indexOf(k) ? v : void 0 : replacer || noop;
-	const known = /* @__PURE__ */ new Map();
-	const input = [];
-	const output = [];
-	let i = +set(known, input, $.call({ "": value }, "", value));
-	let firstRun = !i;
-	while (i < input.length) {
-		firstRun = true;
-		output[i] = $stringify(input[i++], replace, space);
-	}
-	return "[" + output.join(",") + "]";
-	function replace(key, value) {
-		if (firstRun) {
-			firstRun = !firstRun;
-			return value;
-		}
-		const after = $.call(this, key, value);
-		switch (typeof after) {
-			case object: if (after === null) return after;
-			case primitive: return known.get(after) || set(known, input, after);
-		}
-		return after;
-	}
-};
-//#endregion
-//#region ../../../../node_modules/json-rest-schema/src/core/CorePlugin.js
-/**
-* @file Contains all the built-in type and validator handlers for the schema library.
-*/
-/**
-* @typedef {import('./Schema.js').ValidationContext} ValidationContext
-*/
-var DEFAULT_BOOLEAN_TRUE_VALUES = /* @__PURE__ */ new Set([
-	"true",
-	"1",
-	"yes",
-	"y",
-	"on"
-]);
-var DEFAULT_BOOLEAN_FALSE_VALUES = /* @__PURE__ */ new Set([
-	"false",
-	"0",
-	"no",
-	"n",
-	"off"
-]);
-function isThenable(value) {
-	return value !== null && (typeof value === "object" || typeof value === "function") && typeof value.then === "function";
-}
-function normalizeFiniteNumberInput(value) {
-	if (typeof value === "number") return Number.isFinite(value) ? value : null;
-	if (typeof value === "bigint") {
-		const numberValue = Number(value);
-		return Number.isSafeInteger(numberValue) ? numberValue : null;
-	}
-	if (typeof value === "string") {
-		const trimmed = value.trim();
-		if (trimmed === "") return null;
-		const numberValue = Number(trimmed);
-		return Number.isFinite(numberValue) ? numberValue : null;
-	}
-	return null;
-}
-function deepEqual(left, right) {
-	if (Object.is(left, right)) return true;
-	if (left instanceof Date && right instanceof Date) return left.getTime() === right.getTime();
-	if (left instanceof RegExp && right instanceof RegExp) return left.source === right.source && left.flags === right.flags;
-	if (Array.isArray(left) || Array.isArray(right)) {
-		if (!Array.isArray(left) || !Array.isArray(right)) return false;
-		if (left.length !== right.length) return false;
-		for (let index = 0; index < left.length; index++) if (!deepEqual(left[index], right[index])) return false;
-		return true;
-	}
-	if (left === null || right === null || typeof left !== "object" || typeof right !== "object") return false;
-	if (Object.getPrototypeOf(left) !== Object.getPrototypeOf(right)) return false;
-	const leftKeys = Object.keys(left);
-	const rightKeys = Object.keys(right);
-	if (leftKeys.length !== rightKeys.length) return false;
-	for (const key of leftKeys) {
-		if (!Object.hasOwn(right, key)) return false;
-		if (!deepEqual(left[key], right[key])) return false;
-	}
-	return true;
-}
-/**
-* The CorePlugin provides the default set of types and validators.
-*/
-var CorePlugin = { 
-/**
-* Installs the core types and validators.
-* @param {{addType: Function, addValidator: Function}} api - An object containing registration functions.
-*/
-install(api) {
-	const { addType, addValidator } = api;
-	addType("none", (context) => context.value);
-	addType("file", (context) => {
-		const val = context.value;
-		if (val === void 0 || val === null) context.throwTypeError();
-		const valType = typeof val;
-		if (valType === "string" || valType === "number" || valType === "boolean") {
-			const s = val.toString();
-			return context.definition.noTrim ? s : s.trim();
-		}
-		context.throwTypeError();
-	});
-	addType("string", (context) => {
-		const val = context.value;
-		if (val === void 0 || val === null) return "";
-		const valType = typeof val;
-		if (valType === "string" || valType === "number" || valType === "boolean") {
-			const s = val.toString();
-			return context.definition.noTrim ? s : s.trim();
-		}
-		context.throwTypeError();
-	});
-	addType("blob", (context) => context.value);
-	addType("number", (context) => {
-		const numberValue = normalizeFiniteNumberInput(context.value);
-		if (numberValue === null) context.throwTypeError();
-		return numberValue;
-	});
-	addType("integer", (context) => {
-		const numberValue = normalizeFiniteNumberInput(context.value);
-		if (numberValue === null || !Number.isInteger(numberValue)) context.throwTypeError();
-		return numberValue;
-	});
-	addType("epochMilliseconds", (context) => {
-		const epochMilliseconds = castEpochInteger(context.value, EPOCH_MILLISECONDS_LIMIT);
-		if (epochMilliseconds === null) context.throwTypeError();
-		return epochMilliseconds;
-	});
-	addType("epochSeconds", (context) => {
-		const epochSeconds = castEpochInteger(context.value, EPOCH_SECONDS_LIMIT);
-		if (epochSeconds === null) context.throwTypeError();
-		return epochSeconds;
-	});
-	addType("dateTime", (context) => {
-		const temporalPrecision = resolveTemporalPrecision(context.definition, context.fieldName);
-		if (!isValidDateTime(context.value, temporalPrecision)) context.throwTypeError();
-		return context.value;
-	});
-	addType("date", (context) => {
-		if (!isValidDate(context.value)) context.throwTypeError();
-		return context.value;
-	});
-	addType("time", (context) => {
-		const temporalPrecision = resolveTemporalPrecision(context.definition, context.fieldName);
-		if (!isValidTime(context.value, temporalPrecision)) context.throwTypeError();
-		return context.value;
-	});
-	addType("array", (context) => {
-		if (context.definition.type === "array" && !Array.isArray(context.value)) return [context.value];
-		return context.value;
-	});
-	addType("object", (context) => {
-		if (!isPlainObject(context.value)) context.throwTypeError();
-		return context.value;
-	});
-	addType("serialize", (context) => {
-		try {
-			return JSON.stringify(context.value);
-		} catch (e) {
-			try {
-				return stringify(context.value);
-			} catch (e2) {
-				context.throwTypeError();
-			}
-		}
-	});
-	addType("boolean", (context) => {
-		if (typeof context.value === "boolean") return context.value;
-		if (typeof context.value === "number") {
-			if (context.value === 1) return true;
-			if (context.value === 0) return false;
-			context.throwTypeError();
-		}
-		if (typeof context.value === "bigint") {
-			if (context.value === 1n) return true;
-			if (context.value === 0n) return false;
-			context.throwTypeError();
-		}
-		if (typeof context.value === "string") {
-			const falseVal = String(context.definition.stringFalseWhen || "false").trim().toLowerCase();
-			const trueVal = String(context.definition.stringTrueWhen || "true").trim().toLowerCase();
-			const lowerValue = context.value.trim().toLowerCase();
-			const falseValues = /* @__PURE__ */ new Set([...DEFAULT_BOOLEAN_FALSE_VALUES, falseVal]);
-			const trueValues = /* @__PURE__ */ new Set([...DEFAULT_BOOLEAN_TRUE_VALUES, trueVal]);
-			if (falseValues.has(lowerValue)) return false;
-			if (trueValues.has(lowerValue)) return true;
-		}
-		context.throwTypeError();
-	});
-	addType("id", (context) => {
-		if (typeof context.value === "number") {
-			if (Number.isSafeInteger(context.value) && context.value > 0) return context.value;
-			context.throwTypeError();
-		}
-		if (typeof context.value === "bigint") {
-			if (context.value > 0n && context.value <= BigInt(Number.MAX_SAFE_INTEGER)) return Number(context.value);
-			context.throwTypeError();
-		}
-		if (typeof context.value === "string") {
-			const trimmed = context.value.trim();
-			if (!/^[1-9][0-9]*$/.test(trimmed)) context.throwTypeError();
-			const numberValue = Number(trimmed);
-			if (!Number.isSafeInteger(numberValue)) context.throwTypeError();
-			return numberValue;
-		}
-		context.throwTypeError();
-	});
-	addValidator("minLength", (context) => {
-		if (context.value === void 0) return;
-		if (context.definition.type === "string" && context.value.toString && context.value.toString().length < context.parameterValue) context.throwParamError("MIN_LENGTH", `Length must be at least ${context.parameterValue} characters.`, {
-			min: context.parameterValue,
-			actual: context.value.toString().length
-		});
-	});
-	addValidator("min", (context) => {
-		if (context.value === void 0) return;
-		if (isNumericDefinition(context.definition) && typeof context.value === "number" && context.value < context.parameterValue) context.throwParamError("MIN_VALUE", `Value must be at least ${context.parameterValue}.`, {
-			min: context.parameterValue,
-			actual: context.value
-		});
-	});
-	addValidator("maxLength", (context) => {
-		if (context.value === void 0) return;
-		if (context.definition.type === "string" && context.value.toString && context.value.toString().length > context.parameterValue) context.throwParamError("MAX_LENGTH", `Length must be no more than ${context.parameterValue} characters.`, {
-			max: context.parameterValue,
-			actual: context.value.toString().length
-		});
-	});
-	addValidator("max", (context) => {
-		if (context.value === void 0) return;
-		if (isNumericDefinition(context.definition) && typeof context.value === "number" && context.value > context.parameterValue) context.throwParamError("MAX_VALUE", `Value must be no more than ${context.parameterValue}.`, {
-			max: context.parameterValue,
-			actual: context.value
-		});
-	});
-	addValidator("enum", (context) => {
-		if (!Array.isArray(context.parameterValue)) throw new Error(`Enum for ${context.fieldName} must be an array.`);
-		if (!context.parameterValue.some((allowedValue) => deepEqual(allowedValue, context.value))) context.throwParamError("ENUM_VALUE", "Value must match one of the allowed enum values.", { allowed: context.parameterValue });
-	});
-	addValidator("pattern", (context) => {
-		if (context.value === void 0) return;
-		if (context.definition.type !== "string" || typeof context.value !== "string") return;
-		const patternValue = context.parameterValue;
-		const matcher = patternValue instanceof RegExp ? new RegExp(patternValue.source, patternValue.flags) : typeof patternValue === "string" ? new RegExp(patternValue) : null;
-		if (!matcher) throw new Error(`Pattern for ${context.fieldName} must be a string or RegExp.`);
-		if (!matcher.test(context.value)) context.throwParamError("PATTERN", "Value does not match the required pattern.", { pattern: matcher.source });
-	});
-	addValidator("strictBoolean", (context) => {
-		if (!context.parameterValue) return;
-		if (context.definition.type !== "boolean") throw new Error(`strictBoolean can only be used on boolean fields (${context.fieldName}).`);
-		if (typeof context.valueBeforeCast !== "boolean") context.throwParamError("STRICT_BOOLEAN", "Value must be a boolean.");
-	});
-	addValidator("validator", (context) => {
-		if (typeof context.parameterValue !== "function") throw new Error(`Validator for ${context.fieldName} must be a function.`);
-		const r = context.parameterValue(context.value, context.object, context);
-		if (isThenable(r)) throw new Error(`Custom validator for "${context.fieldName}" must be synchronous.`);
-		if (typeof r === "string") context.throwParamError("CUSTOM_VALIDATOR_FAILED", r);
-	});
-	addValidator("uppercase", (context) => {
-		if (typeof context.value === "string") return context.value.toUpperCase();
-	});
-	addValidator("lowercase", (context) => {
-		if (typeof context.value === "string") return context.value.toLowerCase();
-	});
-	addValidator("length", (context) => {
-		if (typeof context.value === "string") return context.value.substr(0, context.parameterValue);
-		else if (Number.isInteger(Number(context.valueBeforeCast)) && String(context.valueBeforeCast).length > context.parameterValue) context.throwParamError("RANGE_EXCEEDED", "Numeric value is out of the allowed character range.", {
-			max: context.parameterValue,
-			actual: String(context.valueBeforeCast).length
-		});
-	});
-	addValidator("notEmpty", (context) => {
-		if (context.parameterValue && typeof context.value === "string" && context.value === "") context.throwParamError("NOT_EMPTY", "Field cannot be empty.");
-	});
-	addValidator("required", () => {});
-	addValidator("unsigned", () => {});
-	addValidator("precision", () => {});
-	addValidator("scale", () => {});
-	addValidator("temporalPrecision", (context) => {
-		if (context.definition.type !== "time" && context.definition.type !== "dateTime") throw new Error(`temporalPrecision can only be used on time or dateTime fields (${context.fieldName}).`);
-	});
-	addValidator("nullable", () => {});
-	addValidator("nullOnEmpty", () => {});
-	addValidator("defaultTo", () => {});
-} };
-//#endregion
-//#region ../../../../node_modules/json-rest-schema/src/utils/error-helpers.js
-/**
-* @file Small helper utilities for working with the flat dotted-path error map.
-*/
-function isValidationErrorObject(value) {
-	return isObjectLike(value) && typeof value.field === "string" && typeof value.code === "string" && typeof value.message === "string" && Object.hasOwn(value, "params");
-}
-function flattenNestedErrorsInto(nestedValue, currentPath, flatErrors) {
-	if (!isObjectLike(nestedValue)) throw new Error(`flattenErrors() found an invalid nested error value at "${currentPath}".`);
-	if (isValidationErrorObject(nestedValue)) {
-		if (currentPath === "") throw new Error("flattenErrors() cannot flatten a root-level error object without a path.");
-		buildPathSegments$1(currentPath, "flattenErrors");
-		setOwnProperty(flatErrors, currentPath, nestedValue);
-		return;
-	}
-	const entries = Array.isArray(nestedValue) ? Object.entries(nestedValue) : Object.entries(nestedValue).sort(([left], [right]) => left.localeCompare(right));
-	for (const [segment, childValue] of entries) flattenNestedErrorsInto(childValue, joinPath$1(currentPath, segment), flatErrors);
-}
-/**
-* Reads one error object from a flat dotted-path error map.
-* @param {Object.<string, object>} errors
-* @param {string} path
-* @returns {object|undefined}
-*/
-function getError(errors, path) {
-	buildPathSegments$1(path, "getError");
-	if (!isObjectLike(errors)) return void 0;
-	return Object.hasOwn(errors, path) ? errors[path] : void 0;
-}
-/**
-* Checks whether a flat dotted-path error map contains a specific path.
-* @param {Object.<string, object>} errors
-* @param {string} path
-* @returns {boolean}
-*/
-function hasError(errors, path) {
-	return getError(errors, path) !== void 0;
-}
-/**
-* Converts a flat dotted-path error map into a nested object/array structure.
-* @param {Object.<string, object>} errors
-* @returns {object}
-*/
-function nestErrors(errors) {
-	if (!isObjectLike(errors)) return {};
-	const nestedErrors = {};
-	for (const [path, error] of Object.entries(errors)) {
-		const segments = buildPathSegments$1(path, "nestErrors");
-		let currentNode = nestedErrors;
-		for (let index = 0; index < segments.length; index++) {
-			const segment = segments[index];
-			if (index === segments.length - 1) {
-				setOwnProperty(currentNode, segment, error);
-				continue;
-			}
-			const hasExistingNode = Object.hasOwn(currentNode, segment);
-			const existingNode = hasExistingNode ? currentNode[segment] : void 0;
-			if (hasExistingNode && (!isObjectLike(existingNode) || isValidationErrorObject(existingNode))) throw new Error(`nestErrors() cannot nest conflicting path "${path}".`);
-			if (!hasExistingNode) {
-				const nextSegment = segments[index + 1];
-				setOwnProperty(currentNode, segment, isNumericSegment(nextSegment) ? [] : {});
-			}
-			currentNode = currentNode[segment];
-		}
-	}
-	return nestedErrors;
-}
-/**
-* Converts a nested object/array error structure into the flat dotted-path map.
-* @param {object} nestedErrors
-* @returns {Object.<string, object>}
-*/
-function flattenErrors(nestedErrors) {
-	if (!isObjectLike(nestedErrors)) return {};
-	const flatErrors = {};
-	flattenNestedErrorsInto(nestedErrors, "", flatErrors);
-	return flatErrors;
-}
-//#endregion
-//#region ../../../../node_modules/json-rest-schema/src/index.js
-/**
-* @file Main entry point for the schema library.
-* Assembles and exports the `createSchema` factory function and related utilities.
-*/
-var factoryTypesBySource = /* @__PURE__ */ new WeakMap();
-var factoryValidatorsBySource = /* @__PURE__ */ new WeakMap();
-var registryMetadataSymbol = Symbol.for("json-rest-schema.registry-metadata");
-function registerTypeHandler(types, name, handler) {
-	if (typeof handler !== "function") throw new Error(`Type handler for '${name}' must be a function.`);
-	setOwnProperty(types, name, handler);
-}
-function registerValidatorHandler(validators, name, handler) {
-	if (typeof handler !== "function") throw new Error(`Validator handler for '${name}' must be a function.`);
-	setOwnProperty(validators, name, handler);
-}
-function createHandlerRegistry(source = {}) {
-	const registry = Object.create(null);
-	for (const [name, handler] of Object.entries(source)) setOwnProperty(registry, name, handler);
-	return registry;
-}
-function installPlugin(plugin, api) {
-	if (typeof plugin.install !== "function") throw new Error("Plugin must have an install method.");
-	plugin.install(api);
-}
-function attachRegistryMetadata(target, types, validators) {
-	factoryTypesBySource.set(target, types);
-	factoryValidatorsBySource.set(target, validators);
-	Object.defineProperty(target, registryMetadataSymbol, {
-		value: Object.freeze({
-			getTypes: () => types,
-			getValidators: () => validators
-		}),
-		enumerable: false,
-		configurable: false,
-		writable: false
-	});
-}
-function extractRegistryMetadata(source) {
-	if (!source || typeof source !== "object" && typeof source !== "function") return null;
-	const types = factoryTypesBySource.get(source);
-	const validators = factoryValidatorsBySource.get(source);
-	if (types && validators) return {
-		types,
-		validators
-	};
-	const symbolMetadata = source[registryMetadataSymbol];
-	if (symbolMetadata && typeof symbolMetadata.getTypes === "function" && typeof symbolMetadata.getValidators === "function") return {
-		types: symbolMetadata.getTypes(),
-		validators: symbolMetadata.getValidators()
-	};
-	if (typeof source === "object" && source.types && typeof source.types === "object" && source.validators && typeof source.validators === "object" && typeof source.create === "function" && typeof source.replace === "function" && typeof source.patch === "function" && typeof source.toJsonSchema === "function") return {
-		types: source.types,
-		validators: source.validators
-	};
-	return null;
-}
-function normalizeFactorySources(sources) {
-	if (sources.length === 1 && Array.isArray(sources[0])) return sources[0];
-	return sources;
-}
-function areEquivalentHandlers(left, right) {
-	return left === right;
-}
-function mergeRegistryHandlers(target, source, kind) {
-	for (const [name, handler] of Object.entries(source)) {
-		if (Object.hasOwn(target, name) && !areEquivalentHandlers(target[name], handler)) throw new Error(`Cannot merge schema factories with conflicting ${kind} "${name}".`);
-		setOwnProperty(target, name, handler);
-	}
-}
-function resolveMergedRegistries(fallbackTypes, fallbackValidators, sources) {
-	const normalizedSources = normalizeFactorySources(sources).filter(Boolean);
-	if (normalizedSources.length < 1) return {
-		types: createHandlerRegistry(fallbackTypes),
-		validators: createHandlerRegistry(fallbackValidators)
-	};
-	const mergedTypes = Object.create(null);
-	const mergedValidators = Object.create(null);
-	for (const source of normalizedSources) {
-		const metadata = extractRegistryMetadata(source);
-		if (!metadata) throw new Error("Factory sources must be schema instances or schema factories created by json-rest-schema.");
-		mergeRegistryHandlers(mergedTypes, metadata.types, "type");
-		mergeRegistryHandlers(mergedValidators, metadata.validators, "validator");
-	}
-	return {
-		types: mergedTypes,
-		validators: mergedValidators
-	};
-}
-function createSchemaFactory({ types = {}, validators = {}, installCore = true } = {}) {
-	const factoryTypes = createHandlerRegistry(types);
-	const factoryValidators = createHandlerRegistry(validators);
-	const factory = (structure, options = {}) => {
-		const schema = new Schema(structure, factoryTypes, factoryValidators, options.operations);
-		attachRegistryMetadata(schema, factoryTypes, factoryValidators);
-		return schema;
-	};
-	attachRegistryMetadata(factory, factoryTypes, factoryValidators);
-	factory.addType = (name, handler) => {
-		registerTypeHandler(factoryTypes, name, handler);
-	};
-	factory.addValidator = (name, handler) => {
-		registerValidatorHandler(factoryValidators, name, handler);
-	};
-	factory.use = (plugin) => {
-		installPlugin(plugin, {
-			addType: factory.addType,
-			addValidator: factory.addValidator
-		});
-	};
-	factory.createFactory = (...sources) => {
-		const mergedRegistries = resolveMergedRegistries(factoryTypes, factoryValidators, sources);
-		return createSchemaFactory({
-			types: mergedRegistries.types,
-			validators: mergedRegistries.validators,
-			installCore: false
-		});
-	};
-	if (installCore) factory.use(CorePlugin);
-	return factory;
-}
-var createSchema = createSchemaFactory({ installCore: true });
-function addType(name, handler) {
-	createSchema.addType(name, handler);
-}
-function addValidator(name, handler) {
-	createSchema.addValidator(name, handler);
-}
-function use(plugin) {
-	createSchema.use(plugin);
-}
-//#endregion
-export { addType, addValidator, createSchema, createSchemaFactory, flattenErrors, getError, hasError, nestErrors, use };