@sanity/agent-schema 0.1.0 → 0.2.0

package/dist/validation/index.js

@@ -0,0 +1,1919 @@
+import { isPrimitiveType, resolveFieldSchema, BUILT_IN_TYPE_FIELDS, resolveFieldSchemaAllUnions } from "../_chunks-es/navigateToField.js";
+function createError(path, code, message, received, expected, fix) {
+  return { path, code, message, received, expected, fix };
+}
+function formatValue(value) {
+  if (value === void 0) return "(not provided)";
+  if (value === null) return "null";
+  const type = typeof value;
+  if (type === "string") {
+    const str = value;
+    return str.length > 50 ? `"${str.slice(0, 47)}..." (string)` : `"${str}" (string)`;
+  }
+  if (type === "number") return `${value} (number)`;
+  if (type === "boolean") return `${value} (boolean)`;
+  if (Array.isArray(value))
+    return `[...] (array with ${value.length} items)`;
+  if (type === "object") {
+    const obj = value;
+    return obj._type ? `{_type: "${obj._type}", ...} (object)` : "{...} (object)";
+  }
+  return String(value);
+}
+function getExpectedJsType(schemaType) {
+  switch (schemaType) {
+    // String types
+    case "string":
+    case "text":
+    case "url":
+    case "email":
+    case "date":
+    case "datetime":
+      return "string";
+    // Number
+    case "number":
+      return "number";
+    // Boolean
+    case "boolean":
+      return "boolean";
+    // Array
+    case "array":
+      return "array";
+    // Everything else is an object (document, object, reference, image, file, slug, geopoint, block, custom types)
+    default:
+      return "object";
+  }
+}
+function getActualJsType(value) {
+  return value === null ? "null" : value === void 0 ? "undefined" : Array.isArray(value) ? "array" : typeof value;
+}
+function getUniquenessKey(item) {
+  if (typeof item != "object" || item === null)
+    return JSON.stringify(item);
+  const itemObj = item;
+  if (itemObj._type === "reference" && typeof itemObj._ref == "string")
+    return itemObj._ref;
+  const itemForComparison = Object.fromEntries(
+    Object.entries(itemObj).filter(([k]) => k !== "_key")
+  );
+  return JSON.stringify(itemForComparison);
+}
+function getValueAtPath(obj, path) {
+  const segments = parsePath(path);
+  let current = obj;
+  for (const segment of segments) {
+    if (current == null)
+      return;
+    if (segment.type === "property") {
+      if (typeof current != "object" || Array.isArray(current))
+        return;
+      current = current[segment.value];
+    } else if (segment.type === "index") {
+      if (!Array.isArray(current))
+        return;
+      current = current[segment.value];
+    } else if (segment.type === "key") {
+      if (!Array.isArray(current))
+        return;
+      current = current.find(
+        (item) => typeof item == "object" && item !== null && item._key === segment.value
+      );
+    }
+  }
+  return current;
+}
+function parsePath(path) {
+  const segments = [], parts = path.split(/\.(?![^[]*\])/);
+  for (const part of parts) {
+    const match = part.match(/^([^[]*)(?:\[(.+)\])?$/);
+    if (!match) continue;
+    const [, prop, selector] = match;
+    if (prop && segments.push({ type: "property", value: prop }), selector) {
+      const keyMatch = selector.match(/^_key\s*==\s*"([^"]+)"$/);
+      if (keyMatch)
+        segments.push({ type: "key", value: keyMatch[1] });
+      else {
+        const index = parseInt(selector, 10);
+        Number.isNaN(index) || segments.push({ type: "index", value: index });
+      }
+    }
+  }
+  return segments;
+}
+function validateNoExtraProperties(obj, allowedProperties, path, typeName, errors) {
+  for (const key of Object.keys(obj))
+    allowedProperties.has(key) || errors.push(
+      createError(
+        `${path}.${key}`,
+        "FIELD_NOT_IN_SCHEMA",
+        `Unknown property "${key}" on ${typeName} object`,
+        formatValue(obj[key]),
+        `Only allowed properties: ${[...allowedProperties].join(", ")}`,
+        `Remove the "${key}" property from the ${typeName} object`
+      )
+    );
+}
+function formatValidationErrors(errors) {
+  if (errors.length === 0)
+    return "";
+  const header = `Validation failed with ${errors.length} error(s):
+
+`, errorList = errors.map((err, i) => [
+    `${i + 1}. At path "${err.path}": ${err.message}`,
+    `   Received: ${err.received}`,
+    `   Expected: ${err.expected}`,
+    `   Fix: ${err.fix}`
+  ].join(`
+`)).join(`
+
+`);
+  return `${header + errorList}
+
+Please correct all errors and try again.`;
+}
+async function validateArray(value, fieldSchema, path, schema, errors, context, validateValue2) {
+  if (!Array.isArray(value)) {
+    errors.push(
+      createError(
+        path,
+        "TYPE_MISMATCH",
+        "Expected array",
+        formatValue(value),
+        "array",
+        "Provide an array value"
+      )
+    );
+    return;
+  }
+  const itemTypes = fieldSchema.of || [];
+  if (itemTypes.length === 0)
+    return;
+  const isPrimitiveArray = itemTypes.every(
+    (t) => !t.name && isPrimitiveType(t.type)
+  ), seenKeys = /* @__PURE__ */ new Set();
+  for (let i = 0; i < value.length; i++) {
+    const item = value[i], itemPath = `${path}[${i}]`, errorCountBefore = errors.length, itemObj = item, itemType = itemObj?._type, itemKey = itemObj?._key;
+    !isPrimitiveArray && typeof item == "object" && item !== null && (itemKey === void 0 ? errors.push(
+      createError(
+        itemPath,
+        "ARRAY_ITEM_INVALID",
+        'Object array item missing "_key" property',
+        formatValue(item),
+        "Object with _key property",
+        "Add a unique _key property to the array item"
+      )
+    ) : typeof itemKey == "string" && itemKey !== "" && (seenKeys.has(itemKey) ? errors.push(
+      createError(
+        `${itemPath}._key`,
+        "ARRAY_ITEM_INVALID",
+        `duplicate _key "${itemKey}" in array`,
+        itemKey,
+        "Unique _key value",
+        "Ensure all array items have unique _key values"
+      )
+    ) : seenKeys.add(itemKey)));
+    let matchingSchema;
+    for (const typeSchema of itemTypes) {
+      if (typeSchema.name && typeSchema.name === itemType) {
+        matchingSchema = typeSchema;
+        break;
+      }
+      if (!typeSchema.name && typeSchema.type === itemType) {
+        matchingSchema = typeSchema;
+        break;
+      }
+      if (typeSchema.type && !itemType && itemTypes.length === 1 && typeof item == "object" && item !== null) {
+        matchingSchema = typeSchema;
+        break;
+      }
+      if (!itemType && typeSchema.type && typeof typeSchema.type == "string" && isPrimitiveType(typeSchema.type)) {
+        matchingSchema = typeSchema;
+        break;
+      }
+    }
+    if (!matchingSchema && itemType) {
+      const globalTypeSchema = schema.find((s) => s.name === itemType);
+      globalTypeSchema && (matchingSchema = globalTypeSchema);
+    }
+    if (!matchingSchema) {
+      const allowedTypeNames = itemTypes.map((t) => t.name || t.type).filter(Boolean).join(", ");
+      if (!isPrimitiveArray && (typeof item == "string" || typeof item == "number" || typeof item == "boolean" || item === null)) {
+        errors.push(
+          createError(
+            itemPath,
+            "TYPE_MISMATCH",
+            "Expected object but found primitive in array",
+            formatValue(item),
+            `object of type: ${allowedTypeNames}`,
+            `Provide an object with _type set to one of: ${allowedTypeNames}`
+          )
+        ), tagItemErrors(errors, errorCountBefore, i, path);
+        continue;
+      }
+      const namedTypes = itemTypes.filter((t) => t.name);
+      namedTypes.length > 0 && itemType ? errors.push(
+        createError(
+          itemPath,
+          "ARRAY_ITEM_INVALID",
+          `Wrong _type "${itemType}" for array item`,
+          formatValue(item),
+          `_type must be one of: ${namedTypes.map((t) => t.name).join(", ")}`,
+          `Use one of the allowed types: ${namedTypes.map((t) => t.name).join(", ")}`
+        )
+      ) : errors.push(
+        createError(
+          itemPath,
+          "ARRAY_ITEM_INVALID",
+          itemType ? `Unknown array item type: ${itemType}` : "Invalid array item",
+          formatValue(item),
+          `One of: ${allowedTypeNames}`,
+          itemType ? `Use one of the allowed types: ${allowedTypeNames}` : `Provide a valid array item of type: ${allowedTypeNames}`
+        )
+      ), tagItemErrors(errors, errorCountBefore, i, path);
+      continue;
+    }
+    await validateValue2(item, matchingSchema, itemPath, errors, context, schema), tagItemErrors(errors, errorCountBefore, i, path);
+  }
+}
+function tagItemErrors(errors, startIndex, itemIndex, arrayPath) {
+  for (let e = startIndex; e < errors.length; e++)
+    errors[e].itemIndex = itemIndex, errors[e].arrayPath = arrayPath;
+}
+function validateUniqueItems(newItems, existingArray, pathPrefix, errors) {
+  const existingKeys = /* @__PURE__ */ new Set();
+  for (const item of existingArray)
+    existingKeys.add(getUniquenessKey(item));
+  const newKeys = /* @__PURE__ */ new Set();
+  for (let i = 0; i < newItems.length; i++) {
+    const item = newItems[i], uniquenessKey = getUniquenessKey(item);
+    existingKeys.has(uniquenessKey) ? errors.push(
+      createError(
+        `${pathPrefix}${i}]`,
+        "DUPLICATE_ARRAY_ITEM",
+        "Item would duplicate an existing array item",
+        formatValue(item),
+        "Unique array items",
+        "Remove the duplicate item or modify it to be unique"
+      )
+    ) : newKeys.has(uniquenessKey) && errors.push(
+      createError(
+        `${pathPrefix}${i}]`,
+        "DUPLICATE_ARRAY_ITEM",
+        "Items contain duplicates",
+        formatValue(item),
+        "Unique array items",
+        "Remove duplicate items from the operation"
+      )
+    ), newKeys.add(uniquenessKey);
+  }
+}
+function pathHasArraySelectors(path) {
+  return /\[(_key==|[0-9])/.test(path);
+}
+function resolveFieldSchemaAtPath(path, typeSchema, allSchemas, document) {
+  if (document && pathHasArraySelectors(path)) {
+    const documentResult = resolveFieldSchemaWithDocument(path, typeSchema, allSchemas, document);
+    if (documentResult)
+      return { schema: documentResult, resolvedVia: "document" };
+  }
+  const schemaResult = resolveFieldSchema(path, typeSchema, allSchemas);
+  if (schemaResult)
+    return { schema: schemaResult, resolvedVia: "schema" };
+  if (document) {
+    const documentResult = resolveFieldSchemaFromDocument(path, document, allSchemas);
+    if (documentResult)
+      return { schema: documentResult, resolvedVia: "document" };
+  }
+  return { schema: null, resolvedVia: null };
+}
+function resolveItemSchema(itemType, allSchemas, parentArraySchema) {
+  const directMatch = allSchemas.find((s) => s.name === itemType);
+  if (directMatch)
+    return directMatch;
+  if (parentArraySchema?.of) {
+    for (const ofItem of parentArraySchema.of)
+      if (ofItem.name === itemType && ofItem.type) {
+        const resolvedSchema = allSchemas.find((s) => s.name === ofItem.type);
+        if (resolvedSchema)
+          return resolvedSchema;
+      }
+  }
+  return null;
+}
+function parsePathIntoFieldSegments(path) {
+  const segments = [], parts = path.split(/\.(?![^[]*\])/);
+  for (const part of parts) {
+    const match = part.match(/^([^[]+)(\[.+\])?$/);
+    match && segments.push({
+      field: match[1],
+      selector: match[2] || null
+    });
+  }
+  return segments;
+}
+function resolveFieldSchemaWithDocument(path, typeSchema, allSchemas, document) {
+  const segments = parsePathIntoFieldSegments(path);
+  let currentSchema = typeSchema, currentPath = "";
+  for (let i = 0; i < segments.length; i++) {
+    const segment = segments[i], isLastSegment = i === segments.length - 1;
+    if (currentPath ? currentPath += `.${segment.field}` : currentPath = segment.field, segment.selector && (currentPath += segment.selector), BUILT_IN_TYPE_FIELDS[currentSchema.type]?.[segment.field]) {
+      const builtInField = BUILT_IN_TYPE_FIELDS[currentSchema.type][segment.field];
+      if (isLastSegment)
+        return builtInField;
+      if (builtInField.type === "array" && segment.selector && builtInField.of) {
+        const itemValue = getValueAtPath(document, currentPath);
+        if (itemValue && typeof itemValue == "object" && !Array.isArray(itemValue)) {
+          const itemType = itemValue._type;
+          if (itemType) {
+            if (BUILT_IN_TYPE_FIELDS[itemType]) {
+              currentSchema = { name: itemType, type: itemType };
+              continue;
+            }
+            const itemSchema = resolveItemSchema(itemType, allSchemas, builtInField);
+            if (itemSchema) {
+              currentSchema = itemSchema;
+              continue;
+            }
+          }
+        }
+        if (builtInField.of.length > 0) {
+          const firstItemType = builtInField.of[0].type;
+          if (BUILT_IN_TYPE_FIELDS[firstItemType]) {
+            currentSchema = { name: firstItemType, type: firstItemType };
+            continue;
+          }
+          currentSchema = allSchemas.find((s) => s.name === firstItemType) || builtInField.of[0];
+          continue;
+        }
+      }
+      currentSchema = builtInField;
+      continue;
+    }
+    let field;
+    if (currentSchema.fields && (field = currentSchema.fields.find((f) => f.name === segment.field)), !field && currentSchema.type === "array" && currentSchema.of) {
+      const parentPath = segments.slice(0, i).map((s) => s.field + (s.selector || "")).join("."), parentValue = parentPath ? getValueAtPath(document, parentPath) : document;
+      if (parentValue && typeof parentValue == "object" && !Array.isArray(parentValue)) {
+        const itemType = parentValue._type;
+        if (itemType) {
+          const itemSchema = resolveItemSchema(itemType, allSchemas, currentSchema);
+          itemSchema?.fields && (field = itemSchema.fields.find((f) => f.name === segment.field));
+        }
+      }
+    }
+    if (!field) {
+      const itemValue = getValueAtPath(document, currentPath);
+      if (itemValue && typeof itemValue == "object" && !Array.isArray(itemValue)) {
+        const itemType = itemValue._type;
+        if (itemType) {
+          const itemSchema = resolveItemSchema(itemType, allSchemas);
+          if (itemSchema) {
+            if (isLastSegment)
+              return itemSchema;
+            currentSchema = itemSchema;
+            continue;
+          }
+        }
+      }
+      return null;
+    }
+    if (isLastSegment)
+      return field;
+    let resolvedFieldForNav = field;
+    if (field.type !== "array" && field.type) {
+      const referencedArray = allSchemas.find((s) => s.name === field.type && s.type === "array");
+      referencedArray && (resolvedFieldForNav = referencedArray);
+    }
+    if (resolvedFieldForNav.type === "array" && segment.selector) {
+      const itemValue = getValueAtPath(document, currentPath);
+      if (itemValue && typeof itemValue == "object" && !Array.isArray(itemValue)) {
+        const itemType = itemValue._type;
+        if (itemType) {
+          const itemSchema = resolveItemSchema(itemType, allSchemas, resolvedFieldForNav);
+          if (itemSchema) {
+            currentSchema = itemSchema;
+            continue;
+          }
+        }
+      }
+      if (resolvedFieldForNav.of && resolvedFieldForNav.of.length > 0) {
+        const firstItemType = resolvedFieldForNav.of[0].type;
+        currentSchema = allSchemas.find((s) => s.name === firstItemType) || resolvedFieldForNav.of[0];
+        continue;
+      }
+    }
+    if (field.type && field.type !== "array") {
+      const referencedSchema = allSchemas.find((s) => s.name === field.type);
+      if (referencedSchema) {
+        currentSchema = referencedSchema;
+        continue;
+      }
+    }
+    currentSchema = field;
+  }
+  return currentSchema;
+}
+function resolveFieldSchemaFromDocument(path, document, allSchemas) {
+  const lastDotIndex = path.lastIndexOf(".");
+  if (lastDotIndex === -1)
+    return null;
+  const parentPath = path.substring(0, lastDotIndex), fieldName = path.substring(lastDotIndex + 1), parentValue = getValueAtPath(document, parentPath);
+  if (parentValue == null || typeof parentValue != "object" || Array.isArray(parentValue))
+    return null;
+  const parentType = parentValue._type;
+  if (!parentType)
+    return null;
+  const typeSchema = resolveItemSchema(parentType, allSchemas);
+  if (!typeSchema)
+    return null;
+  if (typeSchema.fields) {
+    const field = typeSchema.fields.find((f) => f.name === fieldName);
+    if (field)
+      return field;
+  }
+  return null;
+}
+function validateDocumentLanguageField(value, languageFieldName, availableLanguages, path, errors) {
+  if (!(!availableLanguages || availableLanguages.length === 0) && value != null) {
+    if (typeof value != "string") {
+      errors.push(
+        createError(
+          path,
+          "TYPE_MISMATCH",
+          `Language field "${languageFieldName}" must be a string`,
+          formatValue(value),
+          "string (language code)",
+          `Provide a language code like "${availableLanguages[0]}"`
+        )
+      );
+      return;
+    }
+    availableLanguages.includes(value) || errors.push(
+      createError(
+        path,
+        "INVALID_LANGUAGE",
+        `Invalid language code for "${languageFieldName}"`,
+        formatValue(value),
+        `One of: ${availableLanguages.map((l) => `"${l}"`).join(", ")}`,
+        `Use a valid language code: ${availableLanguages.join(", ")}`
+      )
+    );
+  }
+}
+function validateFieldLevelLanguageKey(key, allowedLanguages, path, errors) {
+  if (!allowedLanguages || allowedLanguages.length === 0)
+    return;
+  const languageIds = allowedLanguages.map((lang) => lang.id);
+  if (!languageIds.includes(key)) {
+    const languageList = allowedLanguages.map((lang) => `"${lang.id}"${lang.title ? ` (${lang.title})` : ""}`).join(", ");
+    errors.push(
+      createError(
+        path,
+        "INVALID_LANGUAGE",
+        `Invalid language key "${key}" in internationalized array`,
+        `"${key}"`,
+        `One of: ${languageList}`,
+        `Use a valid language key: ${languageIds.join(", ")}`
+      )
+    );
+  }
+}
+function validateFieldLevelLanguageField(languageValue, allowedLanguages, path, errors) {
+  if (!allowedLanguages || allowedLanguages.length === 0)
+    return;
+  if (typeof languageValue != "string" || languageValue === "") {
+    const languageIds2 = allowedLanguages.map((lang) => lang.id);
+    errors.push(
+      createError(
+        path,
+        "INVALID_LANGUAGE",
+        'Missing or invalid "language" field in internationalized array item',
+        formatValue(languageValue),
+        `One of: ${allowedLanguages.map((l) => `"${l.id}"${l.title ? ` (${l.title})` : ""}`).join(", ")}`,
+        `Set the "language" field to a valid language code: ${languageIds2.join(", ")}`
+      )
+    );
+    return;
+  }
+  const languageIds = allowedLanguages.map((lang) => lang.id);
+  if (!languageIds.includes(languageValue)) {
+    const languageList = allowedLanguages.map((lang) => `"${lang.id}"${lang.title ? ` (${lang.title})` : ""}`).join(", ");
+    errors.push(
+      createError(
+        path,
+        "INVALID_LANGUAGE",
+        `Invalid language "${languageValue}" in internationalized array item`,
+        `"${languageValue}"`,
+        `One of: ${languageList}`,
+        `Use a valid language: ${languageIds.join(", ")}`
+      )
+    );
+  }
+}
+function isV5InternationalizedArray(fieldSchema, allSchemas) {
+  const itemType = (allSchemas.find((s) => s.name === fieldSchema.name || s.name === fieldSchema.type) ?? fieldSchema).of?.[0];
+  if (!itemType) return !1;
+  const valueTypeName = itemType.name || itemType.type;
+  return valueTypeName ? !!(allSchemas.find((s) => s.name === valueTypeName)?.fields || itemType.fields)?.some((f) => f.name === "language") : !1;
+}
+function isInternationalizedArrayField(fieldSchema) {
+  return !!fieldSchema.type?.startsWith("internationalizedArray") || !!fieldSchema.name?.startsWith("internationalizedArray");
+}
+function resolveLanguages(fieldSchema, allSchemas) {
+  let languages = fieldSchema.options?.languages;
+  return languages?.length || (languages = allSchemas.find((s) => s.name === fieldSchema.type)?.options?.languages), languages?.length ? languages : void 0;
+}
+function validateInternationalizedArraySet(path, value, fieldSchema, typeSchema, allSchemas, errors) {
+  if (isInternationalizedArrayField(fieldSchema) && Array.isArray(value)) {
+    validateInternationalizedArrayItems(value, fieldSchema, allSchemas, path, errors);
+    return;
+  }
+  if (path.endsWith("._key") && typeof value == "string") {
+    const arrayPath = path.replace(/\[[^\]]+\]\._key$/, ""), arrayFieldSchema = resolveFieldSchema(arrayPath, typeSchema, allSchemas);
+    if (!arrayFieldSchema || !isInternationalizedArrayField(arrayFieldSchema) || isV5InternationalizedArray(arrayFieldSchema, allSchemas))
+      return;
+    const languages = resolveLanguages(arrayFieldSchema, allSchemas);
+    if (!languages)
+      return;
+    validateFieldLevelLanguageKey(value, languages, path, errors);
+    return;
+  }
+  if (path.endsWith(".language") && typeof value == "string") {
+    const arrayPath = path.replace(/\[[^\]]+\]\.language$/, ""), arrayFieldSchema = resolveFieldSchema(arrayPath, typeSchema, allSchemas);
+    if (!arrayFieldSchema || !isInternationalizedArrayField(arrayFieldSchema) || !isV5InternationalizedArray(arrayFieldSchema, allSchemas))
+      return;
+    const languages = resolveLanguages(arrayFieldSchema, allSchemas);
+    if (!languages)
+      return;
+    validateFieldLevelLanguageField(value, languages, path, errors);
+  }
+}
+function validateInternationalizedArrayItems(items, fieldSchema, allSchemas, path, errors) {
+  const languages = resolveLanguages(fieldSchema, allSchemas);
+  if (!languages)
+    return;
+  const v5 = isV5InternationalizedArray(fieldSchema, allSchemas);
+  for (let i = 0; i < items.length; i++) {
+    const item = items[i];
+    if (typeof item == "object" && item !== null) {
+      const itemObj = item;
+      v5 ? validateFieldLevelLanguageField(
+        itemObj.language,
+        languages,
+        `${path}[${i}].language`,
+        errors
+      ) : itemObj._key && typeof itemObj._key == "string" && validateFieldLevelLanguageKey(itemObj._key, languages, `${path}[${i}]._key`, errors);
+    }
+  }
+}
+async function validateObject(value, fieldSchema, path, schema, errors, context, validateValue2) {
+  if (typeof value != "object" || value === null || Array.isArray(value)) {
+    errors.push(
+      createError(
+        path,
+        "TYPE_MISMATCH",
+        "Expected object",
+        formatValue(value),
+        "object",
+        "Provide an object value"
+      )
+    );
+    return;
+  }
+  const objValue = value;
+  let fields = fieldSchema.fields || [];
+  if (fields.length === 0 && fieldSchema.type) {
+    const referencedType = schema.find((s) => s.name === fieldSchema.type);
+    referencedType?.fields && (fields = referencedType.fields);
+  }
+  if (fields.length === 0)
+    return;
+  const validFieldNames = new Set(fields.map((f) => f.name));
+  (fieldSchema.type === "block" || fieldSchema.name === "block") && (validFieldNames.add("children"), validFieldNames.add("markDefs"), validFieldNames.add("style"), validFieldNames.add("listItem"), validFieldNames.add("level"));
+  for (const key of Object.keys(objValue))
+    if (!key.startsWith("_") && !validFieldNames.has(key)) {
+      const validFieldsList = fields.map((f) => f.name).join(", ");
+      errors.push(
+        createError(
+          path ? `${path}.${key}` : key,
+          "FIELD_NOT_IN_SCHEMA",
+          "Field does not exist in schema",
+          formatValue(objValue[key]),
+          `Field must be one of: ${validFieldsList}`,
+          "Remove this field or check the schema for valid field names"
+        )
+      );
+    }
+  for (const field of fields) {
+    const fieldValue = objValue[field.name], fieldPath = path ? `${path}.${field.name}` : field.name;
+    fieldValue !== void 0 && await validateValue2(fieldValue, field, fieldPath, errors, context, schema);
+  }
+}
+function getValidImageMetadataFields(imagePath, typeSchema, schema) {
+  const imageFieldSchema = resolveFieldSchema(imagePath, typeSchema, schema);
+  if (!imageFieldSchema)
+    return null;
+  const validFieldNames = /* @__PURE__ */ new Set();
+  if (validFieldNames.add("hotspot"), validFieldNames.add("crop"), imageFieldSchema.fields)
+    for (const field of imageFieldSchema.fields)
+      validFieldNames.add(field.name);
+  return validFieldNames;
+}
+function getFieldSchemaAtPath(path, documentType, schema, existingDocument) {
+  const errors = [];
+  if (!path)
+    return errors.push(
+      createError(
+        "",
+        "INVALID_PATH",
+        "Empty path provided",
+        "(empty)",
+        "Non-empty path string",
+        "Provide a valid path to a field"
+      )
+    ), { schemas: null, errors };
+  const typeSchema = schema.find((s) => s.name === documentType);
+  if (!typeSchema)
+    return errors.push(
+      createError(
+        path,
+        "FIELD_NOT_IN_SCHEMA",
+        `Document type "${documentType}" not found in schema`,
+        documentType,
+        "Valid document type",
+        "Check the document type name"
+      )
+    ), { schemas: null, errors };
+  let fieldSchemas = resolveFieldSchemaAllUnions(path, typeSchema, schema);
+  if ((!fieldSchemas || fieldSchemas.length === 0) && existingDocument) {
+    const documentResolvedSchema = resolveFieldSchemaFromDocument(path, existingDocument, schema);
+    documentResolvedSchema && (fieldSchemas = [documentResolvedSchema]);
+  }
+  if (!fieldSchemas || fieldSchemas.length === 0)
+    return errors.push(
+      createError(
+        path,
+        "FIELD_NOT_IN_SCHEMA",
+        `Field at path "${path}" does not exist in schema`,
+        path,
+        "Valid field path",
+        "Check the path matches a field in the schema"
+      )
+    ), { schemas: null, errors };
+  if (existingDocument && (path.includes(".") || path.includes("[")) && getValueAtPath(existingDocument, path) === void 0) {
+    const lastDotIndex = path.lastIndexOf(".");
+    if (lastDotIndex > 0) {
+      const parentPath = path.substring(0, lastDotIndex);
+      if (getValueAtPath(existingDocument, parentPath) === void 0)
+        return path.includes("[") ? errors.push(
+          createError(
+            path,
+            "INVALID_PATH",
+            "Array item does not exist in document",
+            path,
+            "Existing array item",
+            "Ensure the array item exists before setting fields on it"
+          )
+        ) : errors.push(
+          createError(
+            path,
+            "INVALID_PATH",
+            `Parent object at "${parentPath}" does not exist in document`,
+            path,
+            "Existing parent object",
+            "Ensure the parent object exists before setting nested fields"
+          )
+        ), { schemas: fieldSchemas, errors };
+    } else if (path.includes("["))
+      return errors.push(
+        createError(
+          path,
+          "INVALID_PATH",
+          "Array item does not exist in document",
+          path,
+          "Existing array item",
+          "Ensure the array item exists before accessing it"
+        )
+      ), { schemas: fieldSchemas, errors };
+  }
+  return { schemas: fieldSchemas, errors: [] };
+}
+function validateImagePath(path, documentType, schema, existingDocument) {
+  const { schemas, errors } = getFieldSchemaAtPath(path, documentType, schema, existingDocument);
+  if (errors.length > 0)
+    return { valid: !1, errors, warnings: [] };
+  if (!schemas || schemas.length === 0)
+    return {
+      valid: !1,
+      warnings: [],
+      errors: [
+        createError(
+          path,
+          "FIELD_NOT_IN_SCHEMA",
+          `Field at path "${path}" does not exist in schema`,
+          path,
+          "Valid image field path",
+          "Check the path matches an image field in the schema"
+        )
+      ]
+    };
+  if (!schemas.some((s) => s.type === "image")) {
+    const types = schemas.map((s) => s.type || "unknown").join(", ");
+    return {
+      valid: !1,
+      warnings: [],
+      errors: [
+        createError(
+          path,
+          "TYPE_MISMATCH",
+          `Field at path "${path}" is not an image field`,
+          `type: ${types}`,
+          "type: image",
+          "Provide a path to an image field in the schema"
+        )
+      ]
+    };
+  }
+  return { valid: !0, errors: [], warnings: [] };
+}
+function validateImageMetadata(metadata, imagePath, typeSchema, schema) {
+  if (!metadata || typeof metadata != "object" || Object.keys(metadata).length === 0)
+    return;
+  const simpleValidFields = getValidImageMetadataFields(imagePath, typeSchema, schema);
+  let validFieldNames;
+  if (simpleValidFields && simpleValidFields.size > 0)
+    validFieldNames = simpleValidFields;
+  else {
+    const imageFieldSchemas = resolveFieldSchemaAllUnions(imagePath, typeSchema, schema);
+    if (!imageFieldSchemas || imageFieldSchemas.length === 0)
+      return;
+    validFieldNames = /* @__PURE__ */ new Set();
+    for (const fieldSchema of imageFieldSchemas)
+      if (fieldSchema?.fields && Array.isArray(fieldSchema.fields))
+        for (const field of fieldSchema.fields)
+          validFieldNames.add(field.name);
+  }
+  if (validFieldNames.size === 0)
+    return;
+  const cleanedMetadata = {};
+  for (const [key, value] of Object.entries(metadata))
+    validFieldNames.has(key) && typeof value == "string" && (cleanedMetadata[key] = value);
+  return Object.keys(cleanedMetadata).length > 0 ? cleanedMetadata : void 0;
+}
+async function validateBlock(value, fieldSchema, path, schema, errors, context, validateValue2) {
+  if (typeof value != "object" || value === null || Array.isArray(value)) {
+    errors.push(
+      createError(
+        path,
+        "TYPE_MISMATCH",
+        "Invalid block value",
+        formatValue(value),
+        'Object with { _type: "block", children: [...], markDefs?: [...] }',
+        "Provide a valid Portable Text block object"
+      )
+    );
+    return;
+  }
+  const blockObj = value;
+  if (blockObj.children === void 0)
+    errors.push(
+      createError(
+        `${path}.children`,
+        "REQUIRED_FIELD_MISSING",
+        'Block is missing required "children" field',
+        "undefined",
+        "Array of spans and inline objects",
+        'Provide a children array, e.g., children: [{ _type: "span", text: "Hello", _key: "s1", marks: [] }]'
+      )
+    );
+  else if (!Array.isArray(blockObj.children))
+    errors.push(
+      createError(
+        `${path}.children`,
+        "TYPE_MISMATCH",
+        "Block children must be an array",
+        formatValue(blockObj.children),
+        "Array of spans and inline objects",
+        'Provide an array of children, e.g., [{ _type: "span", text: "Hello", _key: "s1" }]'
+      )
+    );
+  else {
+    const markDefKeys = /* @__PURE__ */ new Set();
+    if (Array.isArray(blockObj.markDefs)) {
+      for (const markDef of blockObj.markDefs)
+        if (typeof markDef == "object" && markDef !== null) {
+          const key = markDef._key;
+          typeof key == "string" && markDefKeys.add(key);
+        }
+    }
+    const schemaDecorators = fieldSchema.marks?.decorators?.map((d) => d.value) || [], defaultDecorators = ["strong", "em", "code", "underline", "strike-through"], allowedDecorators = new Set(
+      schemaDecorators.length > 0 ? schemaDecorators : defaultDecorators
+    );
+    await validateBlockChildren(
+      blockObj.children,
+      fieldSchema,
+      `${path}.children`,
+      schema,
+      errors,
+      context,
+      markDefKeys,
+      allowedDecorators,
+      validateValue2
+    );
+  }
+  blockObj.markDefs !== void 0 && (Array.isArray(blockObj.markDefs) ? await validateBlockMarkDefs(
+    blockObj.markDefs,
+    fieldSchema,
+    `${path}.markDefs`,
+    schema,
+    errors,
+    context,
+    validateValue2
+  ) : errors.push(
+    createError(
+      `${path}.markDefs`,
+      "TYPE_MISMATCH",
+      "Block markDefs must be an array",
+      formatValue(blockObj.markDefs),
+      "Array of annotation objects",
+      'Provide an array of markDefs, e.g., [{ _type: "link", _key: "l1", href: "..." }]'
+    )
+  ));
+  const schemaStyles = fieldSchema.styles?.map((s) => s.value) || [], defaultStyles = ["normal", "h1", "h2", "h3", "h4", "h5", "h6", "blockquote"], allowedStyles = new Set(schemaStyles.length > 0 ? schemaStyles : defaultStyles);
+  if (blockObj.style !== void 0) {
+    if (typeof blockObj.style != "string")
+      errors.push(
+        createError(
+          `${path}.style`,
+          "TYPE_MISMATCH",
+          "Block style must be a string",
+          formatValue(blockObj.style),
+          'string (e.g., "normal", "h1", "blockquote")',
+          "Provide a valid style string"
+        )
+      );
+    else if (!allowedStyles.has(blockObj.style)) {
+      const styleList = [...allowedStyles].join(", ");
+      errors.push(
+        createError(
+          `${path}.style`,
+          "INVALID_ENUM_VALUE",
+          `Block style "${blockObj.style}" is not allowed`,
+          blockObj.style,
+          `One of: ${styleList}`,
+          `Use one of the allowed styles: ${styleList}`
+        )
+      );
+    }
+  }
+  const schemaLists = fieldSchema.lists?.map((l) => l.value) || [], defaultLists = ["bullet", "number"], allowedLists = new Set(schemaLists.length > 0 ? schemaLists : defaultLists);
+  if (blockObj.listItem !== void 0) {
+    if (typeof blockObj.listItem != "string")
+      errors.push(
+        createError(
+          `${path}.listItem`,
+          "TYPE_MISMATCH",
+          "Block listItem must be a string",
+          formatValue(blockObj.listItem),
+          'string (e.g., "bullet", "number")',
+          "Provide a valid listItem string"
+        )
+      );
+    else if (!allowedLists.has(blockObj.listItem)) {
+      const listItemList = [...allowedLists].join(", ");
+      errors.push(
+        createError(
+          `${path}.listItem`,
+          "INVALID_ENUM_VALUE",
+          `Block listItem "${blockObj.listItem}" is not allowed`,
+          blockObj.listItem,
+          `One of: ${listItemList}`,
+          `Use one of the allowed list types: ${listItemList}`
+        )
+      );
+    }
+  }
+  blockObj.level !== void 0 && typeof blockObj.level != "number" && errors.push(
+    createError(
+      `${path}.level`,
+      "TYPE_MISMATCH",
+      "Block level must be a number",
+      formatValue(blockObj.level),
+      "number (list nesting level, 1-based)",
+      "Provide a valid level number"
+    )
+  ), blockObj.listItem !== void 0 && blockObj.level === void 0 && errors.push(
+    createError(
+      `${path}.level`,
+      "REQUIRED_FIELD_MISSING",
+      "Block with listItem must have a level",
+      "undefined",
+      "number (list nesting level, 1-based)",
+      "Add a level property (e.g., level: 1) when using listItem"
+    )
+  ), blockObj.level !== void 0 && blockObj.listItem === void 0 && errors.push(
+    createError(
+      `${path}.listItem`,
+      "REQUIRED_FIELD_MISSING",
+      "Block with level must have a listItem",
+      "undefined",
+      'string (e.g., "bullet", "number")',
+      'Add a listItem property (e.g., listItem: "bullet") when using level'
+    )
+  );
+  const blockFields = fieldSchema.fields || [];
+  if (blockFields.length > 0) {
+    const validFieldNames = new Set(blockFields.map((f) => f.name));
+    validFieldNames.add("children"), validFieldNames.add("markDefs"), validFieldNames.add("style"), validFieldNames.add("listItem"), validFieldNames.add("level");
+    for (const key of Object.keys(blockObj))
+      if (!key.startsWith("_") && !validFieldNames.has(key)) {
+        const validFieldsList = [...validFieldNames].join(", ");
+        errors.push(
+          createError(
+            `${path}.${key}`,
+            "FIELD_NOT_IN_SCHEMA",
+            "Field does not exist in block schema",
+            formatValue(blockObj[key]),
+            `Field must be one of: ${validFieldsList}`,
+            "Remove this field or check the schema for valid field names"
+          )
+        );
+      }
+    for (const field of blockFields) {
+      if (["style", "listItem", "level", "children", "markDefs"].includes(field.name))
+        continue;
+      const fieldValue = blockObj[field.name];
+      if (fieldValue !== void 0) {
+        const fieldPath = `${path}.${field.name}`;
+        await validateValue2(fieldValue, field, fieldPath, errors, context, schema);
+      }
+    }
+  }
+}
+async function validateBlockChildren(children, blockSchema, path, schema, errors, context, markDefKeys, allowedDecorators, validateValue2) {
+  const inlineTypes = blockSchema.of || [], seenKeys = /* @__PURE__ */ new Set();
+  for (let i = 0; i < children.length; i++) {
+    const child = children[i], childPath = `${path}[${i}]`;
+    if (typeof child != "object" || child === null) {
+      errors.push(
+        createError(
+          childPath,
+          "TYPE_MISMATCH",
+          "Block child must be an object",
+          formatValue(child),
+          "Object (span or inline object)",
+          "Provide a span or inline object"
+        )
+      );
+      continue;
+    }
+    const childObj = child, childType = childObj._type, childKey = childObj._key;
+    if (childKey === void 0 ? errors.push(
+      createError(
+        childPath,
+        "ARRAY_ITEM_INVALID",
+        'Block child missing "_key" property',
+        formatValue(child),
+        "Object with _key property",
+        "Add a unique _key property to the child"
+      )
+    ) : typeof childKey == "string" && childKey !== "" && (seenKeys.has(childKey) ? errors.push(
+      createError(
+        `${childPath}._key`,
+        "ARRAY_ITEM_INVALID",
+        `duplicate _key "${childKey}" in children array`,
+        childKey,
+        "Unique _key value",
+        "Ensure all children have unique _key values"
+      )
+    ) : seenKeys.add(childKey)), childType === "span") {
+      validateSpan(childObj, childPath, errors, markDefKeys, allowedDecorators);
+      continue;
+    }
+    let matchingSchema;
+    for (const inlineSchema of inlineTypes)
+      if (inlineSchema.name === childType) {
+        matchingSchema = inlineSchema;
+        break;
+      }
+    if (matchingSchema)
+      await validateValue2(child, matchingSchema, childPath, errors, context, schema);
+    else if (childType) {
+      const allowedTypes = ["span", ...inlineTypes.map((t) => t.name).filter(Boolean)];
+      errors.push(
+        createError(
+          childPath,
+          "ARRAY_ITEM_INVALID",
+          `Unknown type "${childType}" in block children`,
+          formatValue(child),
+          `One of: ${allowedTypes.join(", ")}`,
+          `Use one of the allowed types: ${allowedTypes.join(", ")}`
+        )
+      );
+    } else
+      errors.push(
+        createError(
+          childPath,
+          "ARRAY_ITEM_INVALID",
+          "Block child missing _type property",
+          formatValue(child),
+          'Object with _type property ("span" or inline object type)',
+          "Add a _type property to identify the child type"
+        )
+      );
+  }
+}
+function validateSpan(spanObj, path, errors, markDefKeys, allowedDecorators) {
+  if (spanObj.text === void 0 ? errors.push(
+    createError(
+      `${path}.text`,
+      "REQUIRED_FIELD_MISSING",
+      'Span missing "text" property',
+      "(not provided)",
+      "string",
+      "Add a text property to the span"
+    )
+  ) : typeof spanObj.text != "string" && errors.push(
+    createError(
+      `${path}.text`,
+      "TYPE_MISMATCH",
+      "Span text must be a string",
+      formatValue(spanObj.text),
+      "string",
+      "Provide a string value for text"
+    )
+  ), spanObj.marks !== void 0)
+    if (!Array.isArray(spanObj.marks))
+      errors.push(
+        createError(
+          `${path}.marks`,
+          "TYPE_MISMATCH",
+          "Span marks must be an array",
+          formatValue(spanObj.marks),
+          "Array of strings (decorator names or annotation _keys)",
+          "Provide an array of mark strings"
+        )
+      );
+    else
+      for (let i = 0; i < spanObj.marks.length; i++) {
+        const mark = spanObj.marks[i];
+        if (typeof mark != "string")
+          errors.push(
+            createError(
+              `${path}.marks[${i}]`,
+              "TYPE_MISMATCH",
+              "Span mark must be a string",
+              formatValue(mark),
+              "string (decorator name or annotation _key)",
+              "Provide a string mark value"
+            )
+          );
+        else {
+          const isDecorator = allowedDecorators.has(mark), isMarkDefRef = markDefKeys.has(mark);
+          if (!isDecorator && !isMarkDefRef) {
+            const decoratorList = [...allowedDecorators].join(", ");
+            errors.push(
+              createError(
+                `${path}.marks[${i}]`,
+                "INVALID_MARK_REFERENCE",
+                `Mark "${mark}" is not a valid decorator and does not reference a markDef`,
+                mark,
+                `Decorator (${decoratorList}) or _key from markDefs`,
+                markDefKeys.size > 0 ? `Use a decorator (${decoratorList}) or one of the markDef keys: ${[...markDefKeys].join(", ")}` : `Use a decorator (${decoratorList}) or add a markDef with _key "${mark}"`
+              )
+            );
+          }
+        }
+      }
+}
+async function validateBlockMarkDefs(markDefs, blockSchema, path, schema, errors, context, validateValue2) {
+  const schemaAnnotations = blockSchema.marks?.annotations || [], defaultAnnotationTypes = ["link"], annotationTypes = schemaAnnotations.length > 0 ? schemaAnnotations : [], allowedAnnotationNames = schemaAnnotations.length > 0 ? schemaAnnotations.map((t) => t.name).filter(Boolean) : defaultAnnotationTypes, seenKeys = /* @__PURE__ */ new Set();
+  for (let i = 0; i < markDefs.length; i++) {
+    const markDef = markDefs[i], markPath = `${path}[${i}]`;
+    if (typeof markDef != "object" || markDef === null) {
+      errors.push(
+        createError(
+          markPath,
+          "TYPE_MISMATCH",
+          "markDef must be an object",
+          formatValue(markDef),
+          "Annotation object with _type and _key",
+          "Provide an annotation object"
+        )
+      );
+      continue;
+    }
+    const markObj = markDef, markType = markObj._type, markKey = markObj._key;
+    if (markKey === void 0 ? errors.push(
+      createError(
+        markPath,
+        "ARRAY_ITEM_INVALID",
+        'markDef missing "_key" property',
+        formatValue(markDef),
+        "Object with _key property",
+        "Add a unique _key property to the markDef"
+      )
+    ) : typeof markKey == "string" && markKey !== "" && (seenKeys.has(markKey) ? errors.push(
+      createError(
+        `${markPath}._key`,
+        "ARRAY_ITEM_INVALID",
+        `duplicate _key "${markKey}" in markDefs array`,
+        markKey,
+        "Unique _key value",
+        "Ensure all markDefs have unique _key values"
+      )
+    ) : seenKeys.add(markKey)), markType === void 0) {
+      errors.push(
+        createError(
+          markPath,
+          "ARRAY_ITEM_INVALID",
+          'markDef missing "_type" property',
+          formatValue(markDef),
+          "Object with _type property (annotation type)",
+          'Add a _type property to identify the annotation type, e.g., { _type: "link", _key: "l1", href: "..." }'
+        )
+      );
+      continue;
+    }
+    let matchingSchema;
+    for (const annSchema of annotationTypes)
+      if (annSchema.name === markType) {
+        matchingSchema = annSchema;
+        break;
+      }
+    matchingSchema ? await validateValue2(markDef, matchingSchema, markPath, errors, context, schema) : allowedAnnotationNames.includes(markType) || errors.push(
+      createError(
+        markPath,
+        "ARRAY_ITEM_INVALID",
+        `Unknown annotation type "${markType}" in markDefs`,
+        formatValue(markDef),
+        `One of: ${allowedAnnotationNames.join(", ")}`,
+        `Use one of the allowed annotation types: ${allowedAnnotationNames.join(", ")}`
+      )
+    );
+  }
+}
+function resolveEncodedValue(v) {
+  if (typeof v == "object" && v !== null && "__type" in v) {
+    const marker = v;
+    if (marker.__type === "number" && typeof marker.value == "string")
+      return parseFloat(marker.value);
+    if (marker.__type === "object" && typeof marker.value == "object" && marker.value !== null)
+      return marker.value;
+    if (marker.__type === "undefined")
+      return;
+  }
+  return v;
+}
+function validatePrimitive(value, schemaType, path, errors, fieldSchema) {
+  const expectedType = getExpectedJsType(schemaType), actualType = getActualJsType(value);
+  if (!(actualType === "null" || actualType === "undefined")) {
+    if (actualType !== expectedType) {
+      errors.push(
+        createError(
+          path,
+          "TYPE_MISMATCH",
+          "Type mismatch",
+          formatValue(value),
+          expectedType,
+          `Provide a ${expectedType} value`
+        )
+      );
+      return;
+    }
+    if (actualType === "string") {
+      const strValue = value;
+      schemaType === "date" ? validateDate(strValue, path, errors) : schemaType === "datetime" ? validateDatetime(strValue, path, errors) : schemaType === "email" ? validateEmail(strValue, path, errors) : schemaType === "url" && validateUrl(strValue, path, errors, fieldSchema);
+    }
+    if (actualType === "number") {
+      const numValue = value;
+      Number.isNaN(numValue) ? errors.push(
+        createError(
+          path,
+          "TYPE_MISMATCH",
+          "Invalid number (NaN)",
+          "NaN",
+          "A valid number",
+          "Provide a valid numeric value"
+        )
+      ) : Number.isFinite(numValue) || errors.push(
+        createError(
+          path,
+          "TYPE_MISMATCH",
+          "Invalid number (Infinity)",
+          numValue > 0 ? "Infinity" : "-Infinity",
+          "A finite number",
+          "Provide a valid finite numeric value"
+        )
+      );
+    }
+  }
+}
+function validateDate(value, path, errors) {
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(value)) {
+    errors.push(
+      createError(
+        path,
+        "INVALID_FORMAT",
+        "Invalid date format",
+        formatValue(value),
+        "ISO date format (YYYY-MM-DD)",
+        'Provide a date like "2024-01-15"'
+      )
+    );
+    return;
+  }
+  const parsed = /* @__PURE__ */ new Date(`${value}T00:00:00Z`);
+  if (Number.isNaN(parsed.getTime())) {
+    errors.push(
+      createError(
+        path,
+        "INVALID_FORMAT",
+        "Invalid date value",
+        formatValue(value),
+        "A valid date (e.g., month 01-12, valid day for month)",
+        'Provide a valid date like "2024-01-15"'
+      )
+    );
+    return;
+  }
+  const [year, month, day] = value.split("-").map(Number);
+  (parsed.getUTCFullYear() !== year || parsed.getUTCMonth() + 1 !== month || parsed.getUTCDate() !== day) && errors.push(
+    createError(
+      path,
+      "INVALID_FORMAT",
+      "Invalid date value",
+      formatValue(value),
+      "A valid date (e.g., valid day for the given month)",
+      'Provide a valid date like "2024-01-15"'
+    )
+  );
+}
+function validateDatetime(value, path, errors) {
+  if (!/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/.test(value)) {
+    errors.push(
+      createError(
+        path,
+        "INVALID_FORMAT",
+        "Invalid datetime format",
+        formatValue(value),
+        "ISO datetime format (YYYY-MM-DDTHH:mm:ss)",
+        'Provide a datetime like "2024-01-15T10:30:00Z"'
+      )
+    );
+    return;
+  }
+  const parsed = new Date(value);
+  if (Number.isNaN(parsed.getTime())) {
+    errors.push(
+      createError(
+        path,
+        "INVALID_FORMAT",
+        "Invalid datetime value",
+        formatValue(value),
+        "A valid datetime (valid date and time components)",
+        'Provide a valid datetime like "2024-01-15T10:30:00Z"'
+      )
+    );
+    return;
+  }
+  const datePart = value.slice(0, 10), [year, month, day] = datePart.split("-").map(Number);
+  (parsed.getUTCFullYear() !== year || parsed.getUTCMonth() + 1 !== month || parsed.getUTCDate() !== day) && errors.push(
+    createError(
+      path,
+      "INVALID_FORMAT",
+      "Invalid datetime value",
+      formatValue(value),
+      "A valid datetime (valid day for the given month)",
+      'Provide a valid datetime like "2024-01-15T10:30:00Z"'
+    )
+  );
+  const timeMatch = value.match(/T(\d{2}):(\d{2}):(\d{2})/);
+  if (timeMatch) {
+    const [, hour, minute] = timeMatch.map(Number);
+    (hour > 23 || minute > 59) && errors.push(
+      createError(
+        path,
+        "INVALID_FORMAT",
+        "Invalid datetime value",
+        formatValue(value),
+        "A valid time (hour 00-23, minute 00-59)",
+        'Provide a valid datetime like "2024-01-15T10:30:00Z"'
+      )
+    );
+  }
+}
+function validateEmail(value, path, errors) {
+  /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value) || errors.push(
+    createError(
+      path,
+      "INVALID_FORMAT",
+      "Invalid email format",
+      formatValue(value),
+      'Valid email address (e.g., "user@example.com")',
+      "Provide a valid email address"
+    )
+  );
+}
+function validateUrl(value, path, errors, fieldSchema) {
+  const allowRelative = fieldSchema?.validation?.some(
+    (group) => group.rules.some(
+      (rule) => (rule.type === "uri" || rule.flag === "uri") && rule.allowRelative === !0
+    )
+  );
+  if (!(allowRelative && value.startsWith("/")))
+    try {
+      new URL(value);
+    } catch {
+      errors.push(
+        createError(
+          path,
+          "INVALID_FORMAT",
+          "Invalid URL format",
+          formatValue(value),
+          allowRelative ? 'Valid URL (e.g., "https://example.com" or "/path")' : 'Valid URL (e.g., "https://example.com")',
+          allowRelative ? "Provide a valid URL starting with http://, https://, or /" : "Provide a valid URL starting with http:// or https://"
+        )
+      );
+    }
+}
+function validateSchemaRules(value, fieldSchema, path, errors, warnings) {
+  if (fieldSchema.validation)
+    for (const group of fieldSchema.validation) {
+      const target = group.level === "warning" || group.level === "info" ? warnings ?? null : errors;
+      if (target !== null)
+        for (const rule of group.rules) {
+          const r = rule, ruleType = r.type || r.flag;
+          ruleType === "min" || ruleType === "minimum" ? validateBound(value, "min", getConstraint(r), path, target) : ruleType === "max" || ruleType === "maximum" ? validateBound(value, "max", getConstraint(r), path, target) : ruleType === "enum" ? validateEnum(value, r, path, target) : ruleType === "regex" ? validateRegex(value, r, path, target) : (ruleType === "unique" || ruleType === "uniqueItems") && validateUniqueRule(value, path, target);
+        }
+    }
+}
+function getConstraint(r) {
+  if (r.value !== void 0) return parseFloat(r.value);
+  if (r.constraint !== void 0) return r.constraint;
+}
+function validateBound(value, direction, bound, path, target) {
+  if (bound === void 0) return;
+  const isMin = direction === "min", fails = isMin ? (actual) => actual < bound : (actual) => actual > bound;
+  typeof value == "string" && fails(value.length) ? target.push(
+    createError(
+      path,
+      "VALUE_OUT_OF_RANGE",
+      isMin ? `Value is below minimum length of ${bound}` : `Value exceeds maximum length of ${bound}`,
+      `${value.length} characters`,
+      `${isMin ? "At least" : "At most"} ${bound} characters`,
+      `Provide a value with ${isMin ? "at least" : "at most"} ${bound} characters`
+    )
+  ) : typeof value == "number" && fails(value) ? target.push(
+    createError(
+      path,
+      "VALUE_OUT_OF_RANGE",
+      isMin ? `Value is below minimum of ${bound}` : `Value exceeds maximum of ${bound}`,
+      String(value),
+      `${isMin ? "At least" : "At most"} ${bound}`,
+      `Provide a value of ${isMin ? "at least" : "at most"} ${bound}`
+    )
+  ) : Array.isArray(value) && fails(value.length) && target.push(
+    createError(
+      path,
+      "VALUE_OUT_OF_RANGE",
+      isMin ? `Array has fewer than ${bound} items` : `Array has more than ${bound} items`,
+      `${value.length} items`,
+      `${isMin ? "At least" : "At most"} ${bound} items`,
+      `Provide ${isMin ? "at least" : "at most"} ${bound} items`
+    )
+  );
+}
+function validateEnum(value, r, path, target) {
+  const allowedValues = r.values || r.constraint;
+  if (!allowedValues) return;
+  const resolvedValues = allowedValues.map(resolveEncodedValue), formatAllowed = () => resolvedValues.map((v) => JSON.stringify(v)).join(", ");
+  if (Array.isArray(value))
+    for (let i = 0; i < value.length; i++)
+      resolvedValues.includes(value[i]) || target.push(
+        createError(
+          `${path}[${i}]`,
+          "INVALID_ENUM_VALUE",
+          "Array item is not one of the allowed options",
+          formatValue(value[i]),
+          `One of: ${formatAllowed()}`,
+          `Use one of the allowed values: ${formatAllowed()}`
+        )
+      );
+  else resolvedValues.includes(value) || target.push(
+    createError(
+      path,
+      "INVALID_ENUM_VALUE",
+      "Value is not one of the allowed options",
+      formatValue(value),
+      `One of: ${formatAllowed()}`,
+      `Use one of the allowed values: ${formatAllowed()}`
+    )
+  );
+}
+function validateRegex(value, r, path, target) {
+  if (!r.pattern || typeof value != "string") return;
+  const pattern = r.pattern, flags = r.flags || "";
+  try {
+    new RegExp(pattern, flags).test(value) || target.push(
+      createError(
+        path,
+        "INVALID_FORMAT",
+        "Value does not match required regex pattern",
+        formatValue(value),
+        `String matching pattern: ${pattern}`,
+        "Provide a value that matches the required format"
+      )
+    );
+  } catch {
+  }
+}
+function validateUniqueRule(value, path, target) {
+  if (!Array.isArray(value)) return;
+  const seen = /* @__PURE__ */ new Set();
+  for (let i = 0; i < value.length; i++) {
+    const key = getUniquenessKey(value[i]);
+    if (seen.has(key)) {
+      target.push(
+        createError(
+          `${path}[${i}]`,
+          "DUPLICATE_ARRAY_ITEM",
+          "Duplicate item in array with unique constraint",
+          formatValue(value[i]),
+          "Unique array items",
+          "Remove or modify duplicate items in the array"
+        )
+      );
+      break;
+    }
+    seen.add(key);
+  }
+}
+async function validateReference(value, fieldSchema, path, errors, context) {
+  if (typeof value != "object" || value === null) {
+    errors.push(
+      createError(
+        path,
+        "TYPE_MISMATCH",
+        "Invalid reference value",
+        formatValue(value),
+        'Object with { _type: "reference", _ref: "document-id" }',
+        'Provide a reference object like { _type: "reference", _ref: "person-123" }'
+      )
+    );
+    return;
+  }
+  const refObj = value;
+  if (refObj._type === "globalDocumentReference")
+    return;
+  if (typeof refObj._ref != "string") {
+    errors.push(
+      createError(
+        `${path}._ref`,
+        "INVALID_REFERENCE",
+        'Reference missing "_ref" property',
+        formatValue(refObj._ref),
+        "string (document ID)",
+        "Provide a valid document ID in the _ref property"
+      )
+    );
+    return;
+  }
+  if (refObj._ref === "") {
+    errors.push(
+      createError(
+        `${path}._ref`,
+        "INVALID_REFERENCE",
+        'Reference "_ref" cannot be empty',
+        '""',
+        "Non-empty string (document ID)",
+        "Provide a valid document ID in the _ref property"
+      )
+    );
+    return;
+  }
+  validateNoExtraProperties(refObj, /* @__PURE__ */ new Set([
+    "_ref",
+    "_type",
+    "_weak",
+    "_key",
+    "_strengthenOnPublish"
+  ]), path, "reference", errors);
+  const allowedTypes = [];
+  if (fieldSchema.to && Array.isArray(fieldSchema.to))
+    for (const target of fieldSchema.to) {
+      const targetType = target.type;
+      targetType && allowedTypes.push(targetType);
+    }
+  if (!refObj._weak && context.client)
+    try {
+      const doc = await context.client.getDocument(refObj._ref);
+      if (!doc) {
+        errors.push(
+          createError(
+            `${path}._ref`,
+            "REFERENCE_NOT_FOUND",
+            "Referenced document does not exist",
+            formatValue(refObj._ref),
+            allowedTypes.length > 0 ? `Valid document ID of type "${allowedTypes.join('" or "')}"` : "Valid document ID",
+            "Use an existing document ID, or create the document first"
+          )
+        );
+        return;
+      }
+      allowedTypes.length > 0 && !allowedTypes.includes(doc._type) && errors.push(
+        createError(
+          `${path}._ref`,
+          "REFERENCE_WRONG_TYPE",
+          "Reference points to wrong document type",
+          `Document "${refObj._ref}" (type: ${doc._type})`,
+          `Reference to document of type "${allowedTypes.join('" or "')}"`,
+          `Use a document ID that references a "${allowedTypes[0]}" document`
+        )
+      );
+    } catch {
+    }
+}
+function validateSlug(value, path, errors) {
+  if (typeof value != "object" || value === null) {
+    errors.push(
+      createError(
+        path,
+        "TYPE_MISMATCH",
+        "Invalid slug value",
+        formatValue(value),
+        'Object with { _type: "slug", current: "slug-value" }',
+        'Provide a slug object like { _type: "slug", current: "my-page" }'
+      )
+    );
+    return;
+  }
+  const slugObj = value;
+  slugObj._type !== void 0 && slugObj._type !== "slug" && errors.push(
+    createError(
+      path,
+      "TYPE_MISMATCH",
+      "Slug has wrong _type value",
+      formatValue(slugObj._type),
+      '_type: "slug"',
+      'Set _type to "slug", e.g., { _type: "slug", current: "my-page" }'
+    )
+  ), typeof slugObj.current != "string" && errors.push(
+    createError(
+      path,
+      "TYPE_MISMATCH",
+      'Slug missing "current" property',
+      formatValue(value),
+      'Object with "current" string property',
+      'Add a "current" property with the slug string, e.g., { _type: "slug", current: "my-page" }'
+    )
+  ), validateNoExtraProperties(slugObj, /* @__PURE__ */ new Set(["_type", "current"]), path, "slug", errors);
+}
+function validateGeopoint(value, path, errors) {
+  if (typeof value != "object" || value === null) {
+    errors.push(
+      createError(
+        path,
+        "TYPE_MISMATCH",
+        "Invalid geopoint value",
+        formatValue(value),
+        'Object with { _type: "geopoint", lat: number, lng: number }',
+        'Provide a geopoint object like { _type: "geopoint", lat: 37.7749, lng: -122.4194 }'
+      )
+    );
+    return;
+  }
+  const geoObj = value;
+  typeof geoObj.lat != "number" ? errors.push(
+    createError(
+      `${path}.lat`,
+      "TYPE_MISMATCH",
+      'Geopoint missing valid "lat" property',
+      formatValue(geoObj.lat),
+      "number (latitude in degrees)",
+      "Provide a numeric latitude value, e.g., 37.7749"
+    )
+  ) : Number.isNaN(geoObj.lat) ? errors.push(
+    createError(
+      `${path}.lat`,
+      "TYPE_MISMATCH",
+      "Geopoint latitude is NaN",
+      "NaN",
+      "A valid numeric latitude (-90 to 90)",
+      "Provide a valid numeric latitude value, e.g., 37.7749"
+    )
+  ) : Number.isFinite(geoObj.lat) ? (geoObj.lat < -90 || geoObj.lat > 90) && errors.push(
+    createError(
+      `${path}.lat`,
+      "VALUE_OUT_OF_RANGE",
+      "Geopoint latitude out of range",
+      String(geoObj.lat),
+      "Latitude between -90 and 90 degrees",
+      "Provide a latitude between -90 and 90, e.g., 37.7749"
+    )
+  ) : errors.push(
+    createError(
+      `${path}.lat`,
+      "VALUE_OUT_OF_RANGE",
+      "Geopoint latitude is infinite",
+      geoObj.lat > 0 ? "Infinity" : "-Infinity",
+      "A finite numeric latitude (-90 to 90)",
+      "Provide a valid numeric latitude value, e.g., 37.7749"
+    )
+  ), typeof geoObj.lng != "number" ? errors.push(
+    createError(
+      `${path}.lng`,
+      "TYPE_MISMATCH",
+      'Geopoint missing valid "lng" property',
+      formatValue(geoObj.lng),
+      "number (longitude in degrees)",
+      "Provide a numeric longitude value, e.g., -122.4194"
+    )
+  ) : Number.isNaN(geoObj.lng) ? errors.push(
+    createError(
+      `${path}.lng`,
+      "TYPE_MISMATCH",
+      "Geopoint longitude is NaN",
+      "NaN",
+      "A valid numeric longitude (-180 to 180)",
+      "Provide a valid numeric longitude value, e.g., -122.4194"
+    )
+  ) : Number.isFinite(geoObj.lng) ? (geoObj.lng < -180 || geoObj.lng > 180) && errors.push(
+    createError(
+      `${path}.lng`,
+      "VALUE_OUT_OF_RANGE",
+      "Geopoint longitude out of range",
+      String(geoObj.lng),
+      "Longitude between -180 and 180 degrees",
+      "Provide a longitude between -180 and 180, e.g., -122.4194"
+    )
+  ) : errors.push(
+    createError(
+      `${path}.lng`,
+      "VALUE_OUT_OF_RANGE",
+      "Geopoint longitude is infinite",
+      geoObj.lng > 0 ? "Infinity" : "-Infinity",
+      "A finite numeric longitude (-180 to 180)",
+      "Provide a valid numeric longitude value, e.g., -122.4194"
+    )
+  ), validateNoExtraProperties(geoObj, /* @__PURE__ */ new Set(["_type", "lat", "lng", "alt"]), path, "geopoint", errors);
+}
+function validateImage(value, path, errors, fieldSchema, schema) {
+  if (typeof value != "object" || value === null) {
+    errors.push(
+      createError(
+        path,
+        "TYPE_MISMATCH",
+        "Invalid image value",
+        formatValue(value),
+        'Object with { _type: "image", asset: { _type: "reference", _ref: "..." } }',
+        "Provide an image object or use the create-image tool"
+      )
+    );
+    return;
+  }
+  const imgObj = value;
+  if (imgObj._type !== void 0 && imgObj._type !== "image" && imgObj._type !== fieldSchema?.name && errors.push(
+    createError(
+      `${path}._type`,
+      "TYPE_MISMATCH",
+      'Image must have _type: "image"',
+      formatValue(imgObj._type),
+      '_type: "image"',
+      'Set _type to "image"'
+    )
+  ), imgObj.asset !== void 0 && imgObj.asset !== null) {
+    const asset = imgObj.asset;
+    typeof asset._ref != "string" && errors.push(
+      createError(
+        `${path}.asset._ref`,
+        "TYPE_MISMATCH",
+        'Image asset missing "_ref" property',
+        formatValue(asset._ref),
+        "string (asset document ID)",
+        'Provide a valid asset reference like { _type: "reference", _ref: "image-abc123-..." }'
+      )
+    ), asset._type !== "reference" && errors.push(
+      createError(
+        `${path}.asset._type`,
+        "TYPE_MISMATCH",
+        'Image asset must have _type: "reference"',
+        formatValue(asset._type),
+        '_type: "reference"',
+        'Set asset._type to "reference", e.g., { _type: "reference", _ref: "image-abc123-..." }'
+      )
+    );
+  }
+  if (imgObj.hotspot !== void 0 && imgObj.hotspot !== null) {
+    const hotspot = imgObj.hotspot, hotspotProps = ["x", "y", "height", "width"];
+    for (const prop of hotspotProps)
+      hotspot[prop] !== void 0 && (typeof hotspot[prop] != "number" ? errors.push(
+        createError(
+          `${path}.hotspot.${prop}`,
+          "TYPE_MISMATCH",
+          `Hotspot ${prop} must be a number`,
+          formatValue(hotspot[prop]),
+          "number between 0 and 1",
+          `Provide a number between 0 and 1 for hotspot.${prop}`
+        )
+      ) : (hotspot[prop] < 0 || hotspot[prop] > 1) && errors.push(
+        createError(
+          `${path}.hotspot.${prop}`,
+          "VALUE_OUT_OF_RANGE",
+          `Hotspot ${prop} out of range`,
+          String(hotspot[prop]),
+          "number between 0 and 1",
+          `Provide a number between 0 and 1 for hotspot.${prop}`
+        )
+      ));
+  }
+  if (imgObj.crop !== void 0 && imgObj.crop !== null) {
+    const crop = imgObj.crop, cropProps = ["top", "bottom", "left", "right"];
+    for (const prop of cropProps)
+      crop[prop] !== void 0 && (typeof crop[prop] != "number" ? errors.push(
+        createError(
+          `${path}.crop.${prop}`,
+          "TYPE_MISMATCH",
+          `Crop ${prop} must be a number`,
+          formatValue(crop[prop]),
+          "number between 0 and 1",
+          `Provide a number between 0 and 1 for crop.${prop}`
+        )
+      ) : (crop[prop] < 0 || crop[prop] > 1) && errors.push(
+        createError(
+          `${path}.crop.${prop}`,
+          "VALUE_OUT_OF_RANGE",
+          `Crop ${prop} out of range`,
+          String(crop[prop]),
+          "number between 0 and 1",
+          `Provide a number between 0 and 1 for crop.${prop}`
+        )
+      ));
+  }
+  if (fieldSchema?.fields && schema)
+    for (const field of fieldSchema.fields) {
+      const fieldValue = imgObj[field.name];
+      if (fieldValue != null) {
+        const expectedType = getExpectedJsType(field.type);
+        getActualJsType(fieldValue) !== expectedType && errors.push(
+          createError(
+            `${path}.${field.name}`,
+            "TYPE_MISMATCH",
+            `Image metadata field "${field.name}" has wrong type`,
+            formatValue(fieldValue),
+            expectedType,
+            `Provide a ${expectedType} value for ${field.name}`
+          )
+        );
+      }
+    }
+  const allowedImageProperties = /* @__PURE__ */ new Set(["_type", "_key", "asset", "hotspot", "crop"]);
+  if (fieldSchema?.fields)
+    for (const field of fieldSchema.fields)
+      allowedImageProperties.add(field.name);
+  if (fieldSchema?.options) {
+    const options = fieldSchema.options;
+    if (typeof options.captionField == "string" && allowedImageProperties.add(options.captionField), options.aiAssist && typeof options.aiAssist == "object") {
+      const aiAssist = options.aiAssist;
+      typeof aiAssist.imageDescriptionField == "string" && allowedImageProperties.add(aiAssist.imageDescriptionField);
+    }
+  }
+  validateNoExtraProperties(imgObj, allowedImageProperties, path, "image", errors);
+}
+function validateFile(value, path, errors) {
+  if (typeof value != "object" || value === null) {
+    errors.push(
+      createError(
+        path,
+        "TYPE_MISMATCH",
+        "Invalid file value",
+        formatValue(value),
+        'Object with { _type: "file", asset: { _type: "reference", _ref: "..." } }',
+        "Provide a file object with an asset reference"
+      )
+    );
+    return;
+  }
+  const fileObj = value;
+  if (fileObj._type !== void 0 && fileObj._type !== "file" && errors.push(
+    createError(
+      `${path}._type`,
+      "TYPE_MISMATCH",
+      'File must have _type: "file"',
+      formatValue(fileObj._type),
+      '_type: "file"',
+      'Set _type to "file"'
+    )
+  ), fileObj.asset !== void 0 && fileObj.asset !== null) {
+    const asset = fileObj.asset;
+    asset._type !== "reference" && errors.push(
+      createError(
+        `${path}.asset._type`,
+        "TYPE_MISMATCH",
+        'File asset must have _type: "reference"',
+        formatValue(asset._type),
+        '_type: "reference"',
+        'Set asset._type to "reference", e.g., { _type: "reference", _ref: "file-abc123-..." }'
+      )
+    ), typeof asset._ref != "string" && errors.push(
+      createError(
+        `${path}.asset._ref`,
+        "TYPE_MISMATCH",
+        'File asset missing "_ref" property',
+        formatValue(asset._ref),
+        "string (asset document ID)",
+        'Provide a valid asset reference like { _type: "reference", _ref: "file-abc123-..." }'
+      )
+    );
+  }
+  validateNoExtraProperties(fileObj, /* @__PURE__ */ new Set(["_type", "_key", "asset"]), path, "file", errors);
+}
+async function validateValue(value, fieldSchema, path, errors, context, schema, warnings) {
+  const schemaType = fieldSchema.type;
+  if (value != null)
+    switch (validateSchemaRules(value, fieldSchema, path, errors, warnings), schemaType) {
+      // Primitive types
+      case "string":
+      case "text":
+      case "number":
+      case "boolean":
+      case "date":
+      case "datetime":
+      case "url":
+      case "email":
+        validatePrimitive(value, schemaType, path, errors, fieldSchema);
+        break;
+      // Special types
+      case "slug":
+        validateSlug(value, path, errors);
+        break;
+      case "geopoint":
+        validateGeopoint(value, path, errors);
+        break;
+      case "image":
+        validateImage(value, path, errors, fieldSchema, schema);
+        break;
+      case "file":
+        validateFile(value, path, errors);
+        break;
+      case "reference":
+        await validateReference(value, fieldSchema, path, errors, context);
+        break;
+      // Array type
+      case "array":
+        await validateArray(value, fieldSchema, path, schema, errors, context, validateValue);
+        break;
+      // Block type (Portable Text) - special validation
+      case "block":
+        await validateBlock(value, fieldSchema, path, schema, errors, context, validateValue);
+        break;
+      // Object/document types
+      case "object":
+      case "document":
+        await validateObject(value, fieldSchema, path, schema, errors, context, validateValue);
+        break;
+      // Custom types - look up in schema
+      default: {
+        const customSchema = schema.find((s) => s.name === schemaType);
+        if (customSchema) {
+          const actualType = customSchema.type;
+          actualType === "array" ? await validateArray(value, customSchema, path, schema, errors, context, validateValue) : actualType === "object" || actualType === "document" ? await validateObject(value, customSchema, path, schema, errors, context, validateValue) : actualType === "reference" ? await validateReference(value, customSchema, path, errors, context) : isPrimitiveType(actualType) ? validatePrimitive(value, actualType, path, errors) : await validateValue(value, customSchema, path, errors, context, schema);
+        }
+        break;
+      }
+    }
+}
+export {
+  createError,
+  formatValidationErrors,
+  formatValue,
+  getActualJsType,
+  getExpectedJsType,
+  getFieldSchemaAtPath,
+  getUniquenessKey,
+  getValidImageMetadataFields,
+  getValueAtPath,
+  isInternationalizedArrayField,
+  isV5InternationalizedArray,
+  resolveFieldSchemaAtPath,
+  validateArray,
+  validateBlock,
+  validateDocumentLanguageField,
+  validateFieldLevelLanguageField,
+  validateFieldLevelLanguageKey,
+  validateFile,
+  validateGeopoint,
+  validateImage,
+  validateImageMetadata,
+  validateImagePath,
+  validateInternationalizedArrayItems,
+  validateInternationalizedArraySet,
+  validateNoExtraProperties,
+  validateObject,
+  validatePrimitive,
+  validateReference,
+  validateSchemaRules,
+  validateSlug,
+  validateUniqueItems,
+  validateValue
+};
+//# sourceMappingURL=index.js.map