@sanity/validation 6.12.0 → 6.13.0-next.17

package/lib/{validateDocument-Cq33kUmN.js → validateDocument-DtBbNOGc.js}

@@ -1,10 +1,10 @@
 import { isArrayOfBlocksSchemaType, isKeyedObject, isReference, isSlug, isTypedObject } from "@sanity/types";
 import { createClientConcurrencyLimiter } from "@sanity/util/client";
 import { ConcurrencyLimiter } from "@sanity/util/concurrency-limiter";
+import { dequal } from "dequal/lite";
 import flatten from "lodash-es/flatten.js";
-import isEqual from "lodash-es/isEqual.js";
-import { Observable, Subject, bufferTime, concat, defer, filter, finalize, firstValueFrom, from, lastValueFrom, map, merge, mergeMap, of, share, switchMap } from "rxjs";
-import { catchError, map as map$1, mergeAll, mergeMap as mergeMap$1, switchMap as switchMap$1, toArray } from "rxjs/operators";
+import { Observable, Subject, bufferTime, concat, defer, filter, firstValueFrom, from, lastValueFrom, map, merge, mergeMap, of, share, takeUntil, throwError } from "rxjs";
+import { catchError, map as map$1, mergeAll, mergeMap as mergeMap$1, switchMap, toArray } from "rxjs/operators";
 import { createInstance } from "i18next";
 import { Rule as Rule$1 } from "@sanity/schema";
 import get from "lodash-es/get.js";
@@ -59,7 +59,27 @@ const validationMarkerCodes = {
 	valueNotAllowed: "value.not-allowed",
 	valueRequired: "value.required",
 	valueTypeMismatch: "value.type-mismatch"
-}, validationLocaleStrings = {
+};
+function abortSignalAsObservable(signal) {
+	return new Observable((subscriber) => {
+		let onAbort = () => subscriber.error(signal.reason);
+		if (signal.aborted) {
+			onAbort();
+			return;
+		}
+		return signal.addEventListener("abort", onAbort, { once: !0 }), () => signal.removeEventListener("abort", onAbort);
+	});
+}
+function cancelWith(signal) {
+	return (source) => signal ? source.pipe(takeUntil(abortSignalAsObservable(signal))) : source;
+}
+var ClientUnavailableError = class extends Error {
+	name = "ClientUnavailableError";
+	constructor() {
+		super("A Sanity client is required to run this validation check");
+	}
+};
+const validationLocaleStrings = {
 	"array.exact-length": "Must have exactly {{wantedLength}} items",
 	"array.exact-length_blocks": "Must have exactly {{wantedLength}} blocks",
 	"array.item-duplicate": "Can't be a duplicate",
@@ -123,6 +143,13 @@ function getFallbackLocaleSource() {
 		t: i18n.t
 	}, fallbackLocaleSource;
 }
+const internalValidators = /* @__PURE__ */ new WeakSet();
+function markInternalValidator(validator) {
+	return internalValidators.add(validator), validator;
+}
+function isInternalValidator(validator) {
+	return typeof validator == "function" && internalValidators.has(validator);
+}
 function resolveConditionalProperty(property, context) {
 	let { currentUser, document, parent, value, path } = context;
 	return typeof property == "boolean" || property === void 0 ? !!property : property({
@@ -133,29 +160,27 @@ function resolveConditionalProperty(property, context) {
 		path
 	}) === !0;
 }
-function createBatchedGetDocumentExists(client) {
-	let id$ = new Subject(), limiter = new ConcurrencyLimiter(1), existence$ = id$.pipe(bufferTime(250, null, 100), map((ids) => Array.from(new Set(ids))), mergeMap((ids) => from(limiter.ready()).pipe(switchMap(() => client.observable.request({
+function createBatchedGetDocumentExists(client, defaultSignal) {
+	let id$ = new Subject(), existence$ = id$.pipe(bufferTime(250, null, 100), map((ids) => Array.from(new Set(ids))), filter((ids) => ids.length > 0), mergeMap((ids) => client.observable.request({
 		url: client.getDataUrl("doc", ids.join(",")),
 		query: { excludeContent: "true" },
+		signal: defaultSignal,
 		tag: "documents-availability"
 	}).pipe(map((availability) => ({
 		availability,
 		ids
-	})))), finalize(limiter.release))), mergeMap(({ availability, ids }) => ids.map((id) => {
-		let omittedIds = availability.omitted.reduce((acc, next) => (acc[next.id] = next.reason, acc), {});
-		return omittedIds[id] && omittedIds[id] === "existence" ? {
-			id,
-			exists: !1
-		} : {
+	}))), 1), mergeMap(({ availability, ids }) => {
+		let missingIds = new Set(availability.omitted.filter(({ reason }) => reason === "existence").map(({ id }) => id));
+		return ids.map((id) => ({
 			id,
-			exists: !0
-		};
-	})), share());
+			exists: !missingIds.has(id)
+		}));
+	}), share());
 	return async function getDocumentExists(options) {
-		let result = firstValueFrom(existence$.pipe(filter(({ id }) => id === options.id)));
-		id$.next(options.id);
-		let { exists } = await result;
-		return exists;
+		let signal = options.signal || defaultSignal;
+		signal?.throwIfAborted();
+		let result = firstValueFrom(existence$.pipe(filter(({ id }) => id === options.id), map(({ exists }) => exists), cancelWith(signal)));
+		return id$.next(options.id), result;
 	};
 }
 function pathToString(path = []) {
@@ -573,7 +598,10 @@ const dateValidators = {
 		if ("weak" in type && type.weak) return !0;
 		if (!getDocumentExists) throw Error("`getDocumentExists` was not provided in validation context");
 		let documentId = document?._id;
-		return documentId && value._ref == getPublishedId(documentId) || await getDocumentExists({ id: value._ref }) ? !0 : {
+		return documentId && value._ref == getPublishedId(documentId) || await getDocumentExists({
+			id: value._ref,
+			signal: context.signal
+		}) ? !0 : {
 			code: validationMarkerCodes.referenceNotPublished,
 			details: { referenceId: value._ref },
 			message: i18n.t("validation:object.reference-not-published", { documentId: value._ref })
@@ -599,7 +627,7 @@ const dateValidators = {
 			let [type, libraryId, documentId] = value.media._ref.split(":", 3), resourceConfig = { resource: {
 				type,
 				id: libraryId
-			} }, asset = await context.getClient({ apiVersion: "2025-02-19" }).withConfig(resourceConfig).fetch("*[_id == $id] { ..., 'currentVersion': @.currentVersion-> { ... }  }[0]", { id: documentId });
+			} }, asset = await context.getClient({ apiVersion: "2025-02-19" }).withConfig(resourceConfig).fetch("*[_id == $id] { ..., 'currentVersion': @.currentVersion-> { ... }  }[0]", { id: documentId }, { signal: context.signal });
 			if (!asset) return console.warn(`${context.i18n.t("validation:object.media-not-found")}\nAsset ID: ${value.media._ref}`), {
 				code: validationMarkerCodes.mediaNotFound,
 				details: { referenceId: value.media._ref },
@@ -740,8 +768,8 @@ const dateValidators = {
 		let rule = new Rule();
 		return rule._type = this._type, rule._message = this._message, rule._required = this._required, rule._rules = [...this._rules], rule._level = this._level, rule._fieldRules = this._fieldRules, rule._typeDef = this._typeDef, rule;
 	}
-	async validate(value, { __internal = {}, ...context }) {
-		let { customValidationConcurrencyLimiter } = __internal, valueIsEmpty = value == null;
+	async validate(value, options) {
+		let { __internal = {}, ...context } = options, { customValidation = !0, customValidationConcurrencyLimiter, markIncomplete } = __internal, valueIsEmpty = value == null;
 		if (valueIsEmpty && this._required === "optional") return EMPTY_ARRAY;
 		let rules = this._required === void 0 && valueIsEmpty ? this._rules.filter((curr) => curr.flag === "custom") : this._rules, validators = this._type && typeValidators[this._type] || genericValidators;
 		return (await Promise.all(rules.map(async (curr) => {
@@ -752,21 +780,16 @@ const dateValidators = {
 				throw Error(`Validator for flag "${curr.flag}" not found for ${forType}`);
 			}
 			let specConstraint = "constraint" in curr ? curr.constraint : null;
-			if (isFieldRef(specConstraint) && (specConstraint = get(context.parent, specConstraint.path)), curr.flag === "custom" && customValidationConcurrencyLimiter && !specConstraint?.bypassConcurrencyLimit) {
+			if (isFieldRef(specConstraint) && (specConstraint = get(context.parent, specConstraint.path)), (curr.flag === "custom" || curr.flag === "media") && !isInternalValidator(specConstraint) && !customValidation) return markIncomplete?.(), [];
+			if (curr.flag === "custom" && customValidationConcurrencyLimiter && !specConstraint?.bypassConcurrencyLimit) {
 				let customValidator = specConstraint;
-				specConstraint = async (...args) => {
-					await customValidationConcurrencyLimiter.ready();
-					try {
-						return await customValidator(...args);
-					} finally {
-						customValidationConcurrencyLimiter.release();
-					}
-				};
+				specConstraint = (...args) => customValidationConcurrencyLimiter.run(() => customValidator(...args), context.signal);
 			}
 			let message = isLocalizedMessages(this._message) ? localizeMessage(this._message, context.i18n) : this._message;
 			try {
 				return convertToValidationMarker(await validator(specConstraint, value, message, context), this._level, context, { code: fallbackCodeForRule(curr.flag) });
 			} catch (err) {
+				if (context.signal?.throwIfAborted(), err instanceof ClientUnavailableError) return markIncomplete?.(), [];
 				let errorMessage = `${pathToString(context.path)}: Exception occurred while validating value: ${err.message}`;
 				return convertToValidationMarker({
 					code: validationMarkerCodes.validationException,
@@ -776,6 +799,9 @@ const dateValidators = {
 		}))).flat();
 	}
 }, memoizedWarnOnArraySlug = memoize(warnOnArraySlug);
+function hasCustomSlugUniqueness(options) {
+	return typeof options == "object" && !!options && "isUnique" in options && typeof options.isUnique == "function";
+}
 function serializePath(path) {
 	return path.reduce((target, part, i) => {
 		let isIndex = typeof part == "number", isKey = isKeyedObject(part);
@@ -797,7 +823,10 @@ const defaultIsUnique = (slug, context) => {
 		docType,
 		published: getPublishedId(document._id),
 		slug
-	}, { tag: "validation.slug-is-unique" });
+	}, {
+		signal: context.signal,
+		tag: "validation.slug-is-unique"
+	});
 };
 function warnOnArraySlug(serializedPath) {
 	console.warn([
@@ -806,25 +835,21 @@ function warnOnArraySlug(serializedPath) {
 		"To disable this message, set `disableArrayWarning: true` on the slug `options` field"
 	].join("\n"));
 }
-/**
-* Validates slugs values by querying for uniqueness from the client.
-*
-* This is a custom rule implementation (e.g. `Rule.custom(slugValidator)`)
-* that's populated in `inferFromSchemaType` when the type name is `slug`
-*/
-const slugValidator = async (value, context) => {
+const slugStructureValidator = (value, context) => {
 	if (!value) return !0;
 	let { i18n } = context;
-	if (typeof value != "object" || Array.isArray(value)) return {
+	return typeof value != "object" || Array.isArray(value) ? {
 		code: validationMarkerCodes.slugInvalidType,
 		details: { actualType: typeString(value) },
 		message: i18n.t("validation:slug.not-object")
-	};
-	if (!isSlug(value) || value.current.trim().length === 0) return {
+	} : !isSlug(value) || value.current.trim().length === 0 ? {
 		code: validationMarkerCodes.slugMissingCurrent,
 		message: i18n.t("validation:slug.missing-current")
-	};
-	let isUnique = context?.type?.options?.isUnique || defaultIsUnique, slugContext = {
+	} : !0;
+};
+async function validateSlugUniqueness(value, context, isUnique) {
+	if (!isSlug(value) || value.current.trim().length === 0) return !0;
+	let { i18n } = context, slugContext = {
 		...context,
 		parent: context.parent,
 		type: context.type,
@@ -835,6 +860,10 @@ const slugValidator = async (value, context) => {
 		details: { slug: value.current },
 		message: i18n.t("validation:slug.not-unique", { slug: value.current })
 	};
+}
+const defaultSlugUniquenessValidator = (value, context) => validateSlugUniqueness(value, context, defaultIsUnique), customSlugUniquenessValidator = (value, context) => {
+	let options = context.type?.options;
+	return !hasCustomSlugUniqueness(options) || validateSlugUniqueness(value, context, options.isUnique);
 }, ruleConstraintTypes = {
 	array: !0,
 	boolean: !0,
@@ -850,7 +879,13 @@ function baseRuleReducer(inputRule, type) {
 	let baseRule = inputRule;
 	isRuleConstraint(type.jsonType) && (baseRule = baseRule.type(type.jsonType));
 	let typeOptionsList = type?.options && typeof type.options == "object" && "list" in type.options && type.options.list;
-	return Array.isArray(typeOptionsList) && (baseRule = baseRule.valid(typeOptionsList.map((option) => extractValueFromListOption(option, type)))), type.name === "datetime" || type.name === "date" ? baseRule.type("Date") : type.name === "url" ? baseRule.uri() : type.name === "slug" ? baseRule.custom(slugValidator, { bypassConcurrencyLimit: !0 }) : type.name === "reference" ? baseRule.reference() : type.name === "email" ? baseRule.email() : baseRule;
+	if (Array.isArray(typeOptionsList) && (baseRule = baseRule.valid(typeOptionsList.map((option) => extractValueFromListOption(option, type)))), type.name === "datetime" || type.name === "date") return baseRule.type("Date");
+	if (type.name === "url") return baseRule.uri();
+	if (type.name === "slug") {
+		let uniquenessValidator = hasCustomSlugUniqueness(type.options) ? customSlugUniquenessValidator : markInternalValidator(defaultSlugUniquenessValidator);
+		return baseRule.custom(markInternalValidator(slugStructureValidator), { bypassConcurrencyLimit: !0 }).custom(uniquenessValidator, { bypassConcurrencyLimit: !0 });
+	}
+	return type.name === "reference" ? baseRule.reference() : type.name === "email" ? baseRule.email() : baseRule;
 }
 function hasValueField(typeDef) {
 	return typeDef ? !("fields" in typeDef) && typeDef.type ? hasValueField(typeDef.type) : !("fields" in typeDef) || !Array.isArray(typeDef.fields) ? !1 : typeDef.fields.some((field) => field.name === "value") : !1;
@@ -861,7 +896,7 @@ function extractValueFromListOption(option, typeDef) {
 const isUriSpec = (spec) => spec.flag === "uri";
 function omitLeakedDefaultUri(rules, typeDef) {
 	if (!getTypeChain(typeDef).some((type) => type.name === "url")) return rules;
-	let defaultUri = new Rule$2(typeDef).uri()._rules.find(isUriSpec)?.constraint, isDefaultUri = (spec) => isUriSpec(spec) && isEqual(spec.constraint, defaultUri), isCustomUri = (spec) => isUriSpec(spec) && !isEqual(spec.constraint, defaultUri);
+	let defaultUri = new Rule$2(typeDef).uri()._rules.find(isUriSpec)?.constraint, isDefaultUri = (spec) => isUriSpec(spec) && dequal(spec.constraint, defaultUri), isCustomUri = (spec) => isUriSpec(spec) && !dequal(spec.constraint, defaultUri);
 	return rules.some((rule) => rule._rules.some(isCustomUri)) ? rules.map((rule) => {
 		if (!rule._rules.some(isDefaultUri)) return rule;
 		let cleaned = rule.clone();
@@ -912,6 +947,9 @@ const requestIdleCallbackShim = function requestIdleCallbackShim(callback, _opti
 		path: [unknownField]
 	}));
 }, DEFAULT_VALIDATION_CLIENT_OPTIONS = { apiVersion: "2025-02-19" }, isRecord = (maybeRecord) => typeof maybeRecord == "object" && !!maybeRecord && !Array.isArray(maybeRecord);
+function throwClientUnavailable() {
+	throw new ClientUnavailableError();
+}
 /**
 * Recursively extracts all `_fieldRules` from a rule and its nested constraints.
 * This handles cases where `Rule.fields()` is used inside `Rule.all()` or `Rule.either()`.
@@ -939,9 +977,10 @@ function resolveTypeForArrayItem(item, candidates) {
 * @beta
 * @deprecated Prefer {@link validateDocument} with `{document, schema, client}` for new code.
 */
-function validateDocumentWithWorkspace({ document, workspace, getClient = workspace.getClient, getDocumentExists, environment = "studio", maxCustomValidationConcurrency, maxFetchConcurrency, currentUser }) {
+function validateDocumentWithWorkspace({ document, workspace, getClient = workspace.getClient, getDocumentExists, environment = "studio", maxCustomValidationConcurrency, maxFetchConcurrency, currentUser, customValidation, signal }) {
 	return validateDocumentInternal({
 		currentUser,
+		customValidation,
 		document,
 		environment,
 		getClient,
@@ -949,33 +988,58 @@ function validateDocumentWithWorkspace({ document, workspace, getClient = worksp
 		i18n: workspace.i18n,
 		maxCustomValidationConcurrency,
 		maxFetchConcurrency,
-		schema: workspace.schema
+		schema: workspace.schema,
+		signal
 	});
 }
+/**
+* Validates a document against a compiled schema. Returns failures and whether
+* validation completed
+* without deciding whether the document may be edited or published.
+*
+* @beta
+*/
 function validateDocument(options) {
-	if ("workspace" in options) return validateDocumentWithWorkspace(options);
-	let { client, document, schema, ...internalOptions } = options;
-	return validateDocumentInternal({
+	let { client, customValidation = !!options.client, document, getDocumentExists, schema, ...internalOptions } = options;
+	return evaluateDocumentInternal({
 		...internalOptions,
+		customValidation,
 		document,
 		environment: "cli",
-		getClient: ({ apiVersion }) => client.withConfig({ apiVersion }),
+		getClient: client ? ({ apiVersion }) => client.withConfig({ apiVersion }) : throwClientUnavailable,
+		getDocumentExists: getDocumentExists || (client ? void 0 : throwClientUnavailable),
 		i18n: getFallbackLocaleSource(),
 		schema
 	});
 }
+function createDocumentValidationResult(markers, complete) {
+	return {
+		status: getDocumentValidationStatus(markers, complete),
+		markers: markers.map(toDocumentValidationMarker)
+	};
+}
+function getDocumentValidationStatus(markers, complete) {
+	return markers.length > 0 ? "failed" : complete ? "passed" : "notEvaluated";
+}
+/** @internal */
+function validateDocumentInternal(options) {
+	return evaluateDocumentInternal(options).then(({ markers }) => markers);
+}
 /** @internal */
-function validateDocumentInternal({ document, schema, getClient, getDocumentExists, i18n = getFallbackLocaleSource(), environment, maxCustomValidationConcurrency, maxFetchConcurrency, currentUser }) {
-	let limitConcurrency = createClientConcurrencyLimiter(maxFetchConcurrency ?? 25), getConcurrencyLimitedClient = (clientOptions) => limitConcurrency(getClient(clientOptions));
-	return lastValueFrom(validateDocumentObservable({
+function evaluateDocumentInternal({ document, schema, getClient, getDocumentExists, i18n = getFallbackLocaleSource(), environment, maxCustomValidationConcurrency, maxFetchConcurrency, currentUser, customValidation = !0, signal }) {
+	if (signal?.aborted) return Promise.reject(signal.reason);
+	let limitConcurrency = createClientConcurrencyLimiter(maxFetchConcurrency ?? 25, signal), getConcurrencyLimitedClient = (clientOptions) => limitConcurrency(getClient(clientOptions));
+	return lastValueFrom(evaluateDocumentObservable({
 		document,
 		getClient: getConcurrencyLimitedClient,
 		i18n,
 		schema,
-		getDocumentExists: getDocumentExists || createBatchedGetDocumentExists(getClient(DEFAULT_VALIDATION_CLIENT_OPTIONS)),
+		getDocumentExists: getDocumentExists || createBatchedGetDocumentExists(getClient(DEFAULT_VALIDATION_CLIENT_OPTIONS), signal),
 		environment,
 		maxCustomValidationConcurrency,
-		currentUser
+		currentUser,
+		customValidation,
+		signal
 	}));
 }
 const customValidationConcurrencyLimiters = /* @__PURE__ */ new WeakMap();
@@ -983,48 +1047,69 @@ const customValidationConcurrencyLimiters = /* @__PURE__ */ new WeakMap();
 * Validates a document against the given schema, returning an Observable
 * @internal
 */
-function validateDocumentObservable({ document, getClient, i18n = getFallbackLocaleSource(), schema, getDocumentExists, environment, maxCustomValidationConcurrency, currentUser }) {
+function validateDocumentObservable(options) {
+	return evaluateDocumentObservable(options).pipe(map$1(({ markers }) => markers));
+}
+/**
+* Validates a document against the given schema, including completion status.
+* @internal
+*/
+function evaluateDocumentObservable(options) {
+	let { signal } = options;
+	return defer(() => (signal?.throwIfAborted(), evaluateDocumentObservableWithoutCancellation(options))).pipe(cancelWith(signal));
+}
+function evaluateDocumentObservableWithoutCancellation({ document, getClient, i18n = getFallbackLocaleSource(), schema, getDocumentExists, environment, maxCustomValidationConcurrency, currentUser, customValidation = !0, signal }) {
 	if (typeof document?._type != "string") throw Error("Tried to validate a value without a '_type'");
 	let documentType = schema.get(document._type);
-	if (!documentType) return environment === "studio" ? (console.warn("Schema type for object type \"%s\" not found, skipping validation", document._type), of([])) : of([{
+	if (!documentType) return environment === "studio" ? (console.warn("Schema type for object type \"%s\" not found, skipping validation", document._type), of(createDocumentValidationResult([], !0))) : of(createDocumentValidationResult([{
 		code: validationMarkerCodes.documentUnknownType,
 		details: { documentType: document._type },
 		level: "warning",
 		message: `Could not find schema type for type '${document._type}', skipping validation`,
 		path: []
-	}]);
+	}], !0));
 	let customValidationConcurrencyLimiter = customValidationConcurrencyLimiters.get(schema);
-	customValidationConcurrencyLimiter || (customValidationConcurrencyLimiter = new ConcurrencyLimiter(maxCustomValidationConcurrency ?? 5), customValidationConcurrencyLimiters.set(schema, customValidationConcurrencyLimiter));
-	let validationOptions = {
-		getClient,
-		schema,
-		parent: void 0,
-		value: document,
-		path: [],
-		document,
-		type: documentType,
-		i18n,
-		getDocumentExists,
-		environment,
-		customValidationConcurrencyLimiter,
-		currentUser
-	};
-	return from(i18n.loadNamespaces(["validation"])).pipe(switchMap$1(() => validateItemObservable(validationOptions)), map$1((markers) => markers.map(toDocumentValidationMarker)), catchError((err) => {
-		console.error(err);
-		let message = err?.message || "Unknown error", errorMarker = {
-			code: validationMarkerCodes.validationException,
-			level: "error",
-			message,
-			item: { message },
-			path: []
+	return customValidationConcurrencyLimiter || (customValidationConcurrencyLimiter = new ConcurrencyLimiter(maxCustomValidationConcurrency ?? 5), customValidationConcurrencyLimiters.set(schema, customValidationConcurrencyLimiter)), defer(() => {
+		let complete = !0, validationOptions = {
+			getClient,
+			schema,
+			parent: void 0,
+			value: document,
+			path: [],
+			document,
+			type: documentType,
+			i18n,
+			getDocumentExists,
+			environment,
+			customValidationConcurrencyLimiter,
+			currentUser,
+			customValidation,
+			signal,
+			__internal: { markIncomplete: () => {
+				complete = !1;
+			} }
 		};
-		return of([errorMarker]);
-	}));
+		return from(i18n.loadNamespaces(["validation"])).pipe(switchMap(() => validateItemObservable(validationOptions)), map$1((markers) => createDocumentValidationResult(markers, complete)), catchError((err) => {
+			if (signal?.aborted) return throwError(() => signal.reason);
+			console.error(err);
+			let message = err?.message || "Unknown error", errorMarker = {
+				code: validationMarkerCodes.validationException,
+				level: "error",
+				message,
+				item: { message },
+				path: []
+			};
+			return of(createDocumentValidationResult([errorMarker], complete));
+		}));
+	});
 }
 function validateItem(opts) {
-	return lastValueFrom(validateItemObservable(opts));
+	return lastValueFrom(defer(() => (opts.signal?.throwIfAborted(), validateItemObservable(opts))).pipe(cancelWith(opts.signal)));
+}
+function validateRule(rule, value, context) {
+	return rule.validate(value, context);
 }
-function validateItemObservable({ value, type, path = [], parent, customValidationConcurrencyLimiter, environment, ...restOfContext }) {
+function validateItemObservable({ value, type, path = [], parent, customValidationConcurrencyLimiter, environment, customValidation = !0, __internal, ...restOfContext }) {
 	let ancestorHidden = restOfContext.hidden === !0, resolveHiddenForType = (schemaType, schemaValue, schemaParent, schemaPath, ancestorHiddenValue) => schemaType ? ancestorHiddenValue || resolveConditionalProperty(schemaType.hidden, {
 		...restOfContext,
 		parent: schemaParent,
@@ -1036,21 +1121,25 @@ function validateItemObservable({ value, type, path = [], parent, customValidati
 		"document",
 		"file",
 		"image"
-	].includes(t.name)) && environment !== "studio" ? rule.custom(unknownFieldsValidator(type), { bypassConcurrencyLimit: !0 }).warning() : rule, rules = normalizeValidationRules(type, {
+	].includes(t.name)) && environment !== "studio" ? rule.custom(markInternalValidator(unknownFieldsValidator(type)), { bypassConcurrencyLimit: !0 }).warning() : rule, rules = normalizeValidationRules(type, {
 		...restOfContext,
 		hidden,
 		environment,
 		parent,
 		path,
 		type
-	}), selfChecks = rules.map(addUnknownFieldsValidator).map((rule) => defer(() => rule.validate(value, {
+	}), selfChecks = rules.map(addUnknownFieldsValidator).map((rule) => defer(() => validateRule(rule, value, {
 		...restOfContext,
 		environment,
 		hidden,
 		parent,
 		path,
 		type,
-		__internal: { customValidationConcurrencyLimiter }
+		__internal: {
+			...__internal,
+			customValidation,
+			customValidationConcurrencyLimiter
+		}
 	}))), nestedChecks = [], selfIsRequired = rules.some((rule) => rule.isRequired());
 	if (type?.jsonType === "object" && (value || value == null && selfIsRequired)) {
 		let fieldTypes = type.fields.reduce((acc, field) => (acc[field.name] = field.type, acc), {});
@@ -1061,14 +1150,18 @@ function validateItemObservable({ value, type, path = [], parent, customValidati
 				validation
 			}).map(addUnknownFieldsValidator).map((subRule) => {
 				let nestedValue = isRecord(value) ? value[name] : void 0, nestedHidden = resolveHiddenForType(fieldType, nestedValue, value, path.concat(name), hidden);
-				return defer(() => subRule.validate(nestedValue, {
+				return defer(() => validateRule(subRule, nestedValue, {
 					...restOfContext,
 					parent: value,
 					path: path.concat(name),
 					type: fieldType,
 					environment,
 					hidden: nestedHidden,
-					__internal: { customValidationConcurrencyLimiter }
+					__internal: {
+						...__internal,
+						customValidation,
+						customValidationConcurrencyLimiter
+					}
 				}));
 			});
 		})), nestedChecks = nestedChecks.concat(type.fields.map((field) => validateItemObservable({
@@ -1079,7 +1172,9 @@ function validateItemObservable({ value, type, path = [], parent, customValidati
 			path: path.concat(field.name),
 			type: field.type,
 			environment,
-			customValidationConcurrencyLimiter
+			customValidationConcurrencyLimiter,
+			customValidation,
+			__internal
 		})));
 	}
 	return type?.jsonType === "array" && Array.isArray(value) && (nestedChecks = nestedChecks.concat(value.map((item, index) => validateItemObservable({
@@ -1090,7 +1185,9 @@ function validateItemObservable({ value, type, path = [], parent, customValidati
 		path: path.concat(isKeyedObject(item) ? { _key: item._key } : index),
 		type: resolveTypeForArrayItem(item, type.of),
 		environment,
-		customValidationConcurrencyLimiter
+		customValidationConcurrencyLimiter,
+		customValidation,
+		__internal
 	})))), defer(() => merge([...selfChecks, ...nestedChecks])).pipe(mergeMap$1((validateNode) => concat(idle(), validateNode), 40), mergeAll(), toArray(), map$1(flatten), map$1((results) => rules.some((rule) => extractFieldRulesFromRule(rule).length > 0) ? deduplicateMarkers(results) : results));
 }
 function deduplicateMarkers(markers) {
@@ -1102,7 +1199,7 @@ function deduplicateMarkers(markers) {
 			marker.message,
 			marker.path
 		]), bucket = buckets.get(key);
-		return bucket ? !bucket.some((existing) => isEqual(existing, marker)) && (bucket.push(marker), !0) : (buckets.set(key, [marker]), !0);
+		return bucket ? !bucket.some((existing) => dequal(existing, marker)) && (bucket.push(marker), !0) : (buckets.set(key, [marker]), !0);
 	});
 }
 function hasValidationMarkerCode(marker) {
@@ -1122,6 +1219,6 @@ function idle(timeout) {
 		return () => cancelIdleCallback(handle);
 	});
 }
-export { validateDocumentWithWorkspace as a, normalizeValidationRules as c, convertToValidationMarker as d, pathToString as f, validationMarkerCodes as h, validateDocumentObservable as i, Rule$2 as l, validationLocaleStrings as m, validateDocument as n, validateItem as o, getFallbackLocaleSource as p, validateDocumentInternal as r, getTypeChain as s, resolveTypeForArrayItem as t, typeString as u };
+export { validationMarkerCodes as _, validateDocumentInternal as a, validateItem as c, Rule$2 as d, typeString as f, validationLocaleStrings as g, getFallbackLocaleSource as h, validateDocument as i, getTypeChain as l, pathToString as m, evaluateDocumentObservable as n, validateDocumentObservable as o, convertToValidationMarker as p, resolveTypeForArrayItem as r, validateDocumentWithWorkspace as s, evaluateDocumentInternal as t, normalizeValidationRules as u };
 
-//# sourceMappingURL=validateDocument-Cq33kUmN.js.map
+//# sourceMappingURL=validateDocument-DtBbNOGc.js.map