@sanity/agent-mutations 0.1.0

package/dist/index.js

@@ -0,0 +1,1644 @@
+import { isInternationalizedArrayField, isV5InternationalizedArray, createError, getValueAtPath, resolveFieldSchemaAtPath, validateValue, validateInternationalizedArraySet, validateDocumentLanguageField, validateInternationalizedArrayItems, validateUniqueItems } from "@sanity/agent-schema/validation";
+import { resolveFieldSchema, isPrimitiveType } from "@sanity/agent-schema";
+import { isPublishedId, isVersionId, isDraftId, getPublishedId } from "@sanity/id-utils";
+function extractArrayPath(path) {
+  const arrayFields = [], currentPath = path;
+  let offset = 0;
+  for (; offset < currentPath.length; ) {
+    const selectorMatch = currentPath.slice(offset).match(/^([^.[]+)(\[_key==["'][^"']+["']\])/);
+    if (selectorMatch)
+      arrayFields.push(selectorMatch[1]), offset += selectorMatch[0].length, currentPath[offset] === "." && offset++;
+    else {
+      const remainingMatch = currentPath.slice(offset).match(/^([^.[]+)/);
+      remainingMatch && arrayFields.length > 0 && arrayFields.push(remainingMatch[1]);
+      break;
+    }
+  }
+  if (arrayFields.length > 0)
+    return arrayFields.join(".");
+  const firstFieldMatch = path.match(/^([^.[]+)/);
+  return firstFieldMatch ? firstFieldMatch[1] : path;
+}
+function groupOperationsByArrayContext(params) {
+  const groups = [];
+  if ((params.set && params.set.length > 0 || params.unset && params.unset.length > 0 || params.insertBefore && params.insertBefore.length > 0 || params.insertAfter && params.insertAfter.length > 0) && groups.push({
+    context: "main",
+    operations: {
+      set: params.set || [],
+      unset: params.unset || [],
+      append: [],
+      insertBefore: params.insertBefore || [],
+      insertAfter: params.insertAfter || []
+    }
+  }), params.append && params.append.length > 0) {
+    const appendsByArrayPath = /* @__PURE__ */ new Map();
+    for (const appendOp of params.append) {
+      const arrayPath = extractArrayPath(appendOp.path);
+      appendsByArrayPath.has(arrayPath) || appendsByArrayPath.set(arrayPath, []), appendsByArrayPath.get(arrayPath).push(appendOp);
+    }
+    for (const [arrayPath, appendOps] of appendsByArrayPath.entries())
+      if (appendOps.length > 1)
+        for (let i = 0; i < appendOps.length; i++)
+          groups.push({
+            context: `append:${arrayPath}:${i}`,
+            operations: {
+              set: [],
+              unset: [],
+              append: [appendOps[i]],
+              insertBefore: [],
+              insertAfter: []
+            }
+          });
+      else
+        groups.push({
+          context: `append:${arrayPath}`,
+          operations: {
+            set: [],
+            unset: [],
+            append: appendOps,
+            insertBefore: [],
+            insertAfter: []
+          }
+        });
+  }
+  return groups;
+}
+function buildPatchTransaction(options) {
+  const { client, documentId, operations, setIfMissing } = options, transaction = client.transaction(), groups = groupOperationsByArrayContext(operations);
+  for (const [path, value] of Object.entries(setIfMissing))
+    transaction.patch(documentId, { setIfMissing: { [path]: value } });
+  for (const group of groups) {
+    for (const op of group.operations.insertBefore) {
+      const path = `${op.arrayPath}[_key=="${op.key}"]`;
+      transaction.patch(documentId, { insert: { before: path, items: op.items } });
+    }
+    for (const op of group.operations.insertAfter) {
+      const path = `${op.arrayPath}[_key=="${op.key}"]`;
+      transaction.patch(documentId, { insert: { after: path, items: op.items } });
+    }
+    for (const op of group.operations.set)
+      op.value !== void 0 && transaction.patch(documentId, { set: { [op.path]: op.value } });
+    for (const path of group.operations.unset)
+      transaction.patch(documentId, { unset: [path] });
+    for (const op of group.operations.append)
+      transaction.patch(documentId, { insert: { after: op.path, items: op.items } });
+  }
+  return transaction;
+}
+const PRIMITIVE_TYPES = [
+  "string",
+  "number",
+  "boolean",
+  "date",
+  "datetime",
+  "text",
+  "url",
+  "email",
+  "slug"
+];
+function isPrimitiveArray(field) {
+  return !field || field.type !== "array" || !field.of || field.of.length === 0 ? !1 : field.of.every((item) => {
+    const itemType = item.type || (typeof item == "string" ? item : "");
+    return !itemType || typeof itemType != "string" ? !1 : PRIMITIVE_TYPES.includes(itemType);
+  });
+}
+function hasNumericIndex(path) {
+  return /\[\d+\]/.test(path);
+}
+function parseArrayIndex(path) {
+  const match = path.match(/^(.*?)\[(\d+)\](.*)$/);
+  return match ? {
+    basePath: match[1],
+    index: parseInt(match[2], 10),
+    restPath: match[3]
+  } : null;
+}
+function getArrayAtPath(document, path) {
+  const parts = path.split(/\.(?![^[]*\])/);
+  let current = document;
+  for (const part of parts) {
+    const keyMatch = part.match(/^([^[]+)\[_key=="([^"]+)"\]$/);
+    if (keyMatch) {
+      const [, fieldName, keyValue] = keyMatch, currentObj = current;
+      if (!currentObj[fieldName] || !Array.isArray(currentObj[fieldName]) || (current = currentObj[fieldName].find((item) => item._key === keyValue), !current)) return null;
+      continue;
+    }
+    if (!current || typeof current != "object")
+      return null;
+    current = current[part];
+  }
+  return Array.isArray(current) ? current : null;
+}
+function getKeyAtIndex(array, index) {
+  if (index < 0 || index >= array.length)
+    return null;
+  const item = array[index];
+  if (!item || typeof item != "object")
+    return null;
+  const key = item._key;
+  return typeof key == "string" ? key : null;
+}
+const BUILT_IN_BLOCK_SCHEMA = {
+  name: "block",
+  type: "object",
+  fields: [
+    { name: "style", type: "string" },
+    { name: "children", type: "array", of: [{ type: "span" }] },
+    { name: "markDefs", type: "array", of: [{ type: "object" }] },
+    { name: "listItem", type: "string" },
+    { name: "level", type: "number" }
+  ]
+}, BUILT_IN_SPAN_SCHEMA = {
+  name: "span",
+  type: "object",
+  fields: [
+    { name: "text", type: "string" },
+    { name: "marks", type: "array", of: [{ type: "string" }] }
+  ]
+}, BUILT_IN_SCHEMAS = {
+  block: BUILT_IN_BLOCK_SCHEMA,
+  span: BUILT_IN_SPAN_SCHEMA
+};
+function getDocumentItemAtPath(document, pathParts, upToIndex) {
+  let current = document;
+  for (let i = 0; i <= upToIndex; i++) {
+    const part = pathParts[i];
+    if (current == null || typeof current != "object")
+      return null;
+    const keyMatch = part.match(/^([^[]+)\[_key=="([^"]+)"\]$/);
+    if (keyMatch) {
+      const [, fieldName, keyValue] = keyMatch, arr = current[fieldName];
+      if (!Array.isArray(arr)) return null;
+      current = arr.find((item) => item && typeof item == "object" ? item._key === keyValue : !1);
+      continue;
+    }
+    const indexMatch = part.match(/^([^[]+)\[(\d+)\]$/);
+    if (indexMatch) {
+      const [, fieldName, indexStr] = indexMatch, arr = current[fieldName];
+      if (!Array.isArray(arr)) return null;
+      const index = parseInt(indexStr, 10);
+      if (index < 0 || index >= arr.length) return null;
+      current = arr[index];
+      continue;
+    }
+    current = current[part];
+  }
+  return current;
+}
+function getFieldAtPath(path, typeSchema, allSchemas, document) {
+  const parts = path.split(/\.(?![^[]*\])/);
+  let currentSchema = typeSchema;
+  for (let i = 0; i < parts.length; i++) {
+    const part = parts[i], keyMatch = part.match(/^([^[]+)\[_key=="([^"]+)"\]$/), indexMatch = part.match(/^([^[]+)\[(\d+)\]$/), fieldName = keyMatch ? keyMatch[1] : indexMatch ? indexMatch[1] : part, field = currentSchema.fields?.find((f) => f.name === fieldName);
+    if (!field) return null;
+    if (i === parts.length - 1)
+      return field;
+    let resolvedField = field;
+    if (field.type !== "array" && field.type !== "object" && field.type !== "string" && field.type !== "number" && field.type !== "boolean") {
+      const aliasSchema = allSchemas.find((s) => s.name === field.type);
+      aliasSchema && aliasSchema.type === "array" && aliasSchema.of && (resolvedField = { ...field, type: "array", of: aliasSchema.of });
+    }
+    if (resolvedField.type === "array" && resolvedField.of && resolvedField.of.length > 0) {
+      let itemSchema;
+      if (document && (keyMatch || indexMatch)) {
+        const docItem = getDocumentItemAtPath(document, parts, i);
+        if (docItem && typeof docItem == "object" && "_type" in docItem) {
+          const actualType = docItem._type;
+          if (itemSchema = allSchemas.find((s) => s.name === actualType) || BUILT_IN_SCHEMAS[actualType], !itemSchema) {
+            for (const itemTypeRef of resolvedField.of)
+              if (typeof itemTypeRef == "object" && itemTypeRef.name === actualType) {
+                itemSchema = itemTypeRef;
+                break;
+              }
+          }
+        }
+      }
+      if (!itemSchema)
+        for (const itemTypeRef of resolvedField.of) {
+          const itemTypeName = typeof itemTypeRef == "string" ? itemTypeRef : itemTypeRef.type;
+          if (itemTypeName && (itemSchema = allSchemas.find((s) => s.name === itemTypeName) || BUILT_IN_SCHEMAS[itemTypeName], itemSchema))
+            break;
+        }
+      if (!itemSchema)
+        return null;
+      currentSchema = itemSchema;
+    } else if (resolvedField.type === "object" && resolvedField.fields)
+      currentSchema = resolvedField;
+    else
+      return null;
+  }
+  return null;
+}
+function convertArrayIndexOperations(operations, typeSchema, allSchemas, document) {
+  const primitiveArrayOps = /* @__PURE__ */ new Map(), passThroughSets = [], passThroughUnsets = [];
+  if (operations.set && operations.set.length > 0)
+    for (const op of operations.set) {
+      if (!hasNumericIndex(op.path)) {
+        passThroughSets.push(op);
+        continue;
+      }
+      const parsed = parseArrayIndex(op.path);
+      if (!parsed) {
+        passThroughSets.push(op);
+        continue;
+      }
+      const { basePath, index, restPath } = parsed, field = getFieldAtPath(basePath, typeSchema, allSchemas, document);
+      if (!field)
+        throw new Error(
+          `Field validation failed:
+  - ${op.path}: Field "${basePath}" does not exist in schema "${typeSchema.name}"
+
+Please correct the invalid field paths and try again.`
+        );
+      if (field.type !== "array")
+        throw new Error(
+          `Field validation failed:
+  - ${op.path}: Field "${basePath}" is not an array (type: ${field.type})
+
+Please correct the invalid field paths and try again.`
+        );
+      if (isPrimitiveArray(field)) {
+        if (restPath)
+          throw new Error(
+            `Field validation failed:
+  - ${op.path}: Cannot access nested path "${restPath}" on primitive array item at "${basePath}[${index}]"
+
+Primitive arrays (strings, numbers, etc.) don't have nested fields.`
+          );
+        const group = primitiveArrayOps.get(basePath) || { sets: [], unsets: [] };
+        group.sets.push({ index, value: op.value }), primitiveArrayOps.set(basePath, group);
+      } else {
+        const converted = convertObjectArraySetOperation(
+          op,
+          basePath,
+          index,
+          restPath,
+          typeSchema,
+          allSchemas,
+          document
+        );
+        passThroughSets.push(...converted);
+      }
+    }
+  if (operations.unset && operations.unset.length > 0)
+    for (const path of operations.unset) {
+      if (!hasNumericIndex(path)) {
+        passThroughUnsets.push(path);
+        continue;
+      }
+      const parsed = parseArrayIndex(path);
+      if (!parsed) {
+        passThroughUnsets.push(path);
+        continue;
+      }
+      const { basePath, index, restPath } = parsed, field = getFieldAtPath(basePath, typeSchema, allSchemas, document);
+      if (!field)
+        throw new Error(
+          `Field validation failed:
+  - ${path}: Field "${basePath}" does not exist in schema "${typeSchema.name}"
+
+Please correct the invalid field paths and try again.`
+        );
+      if (field.type !== "array")
+        throw new Error(
+          `Field validation failed:
+  - ${path}: Field "${basePath}" is not an array (type: ${field.type})
+
+Please correct the invalid field paths and try again.`
+        );
+      if (isPrimitiveArray(field)) {
+        if (restPath)
+          throw new Error(
+            `Field validation failed:
+  - ${path}: Cannot access nested path "${restPath}" on primitive array item at "${basePath}[${index}]"
+
+Primitive arrays (strings, numbers, etc.) don't have nested fields.`
+          );
+        const group = primitiveArrayOps.get(basePath) || { sets: [], unsets: [] };
+        group.unsets.push(index), primitiveArrayOps.set(basePath, group);
+      } else
+        throw new Error(
+          `Unsetting object array items by index is not supported. Path: ${path}
+
+To remove an item from an object array, use the unset operation with _key notation: items[_key=="..."]`
+        );
+    }
+  const appendsToMerge = /* @__PURE__ */ new Map(), passThroughAppends = [];
+  if (operations.append)
+    for (const appendOp of operations.append)
+      if (primitiveArrayOps.has(appendOp.path)) {
+        const existingItems = appendsToMerge.get(appendOp.path) ?? [];
+        appendsToMerge.set(appendOp.path, [...existingItems, ...appendOp.items]);
+      } else
+        passThroughAppends.push(appendOp);
+  const mergedSets = mergePrimitiveArrayOperations(primitiveArrayOps, appendsToMerge, document), result = {}, allSets = [...passThroughSets, ...mergedSets];
+  return allSets.length > 0 && (result.set = allSets), passThroughUnsets.length > 0 && (result.unset = passThroughUnsets), passThroughAppends.length > 0 && (result.append = passThroughAppends), operations.insertBefore && operations.insertBefore.length > 0 && (result.insertBefore = operations.insertBefore), operations.insertAfter && operations.insertAfter.length > 0 && (result.insertAfter = operations.insertAfter), result;
+}
+function mergePrimitiveArrayOperations(primitiveArrayOps, appendsToMerge, document) {
+  const mergedSets = [];
+  for (const [basePath, ops] of primitiveArrayOps) {
+    const currentArray = getArrayAtPath(document, basePath);
+    if (!currentArray)
+      throw new Error(
+        `Field validation failed:
+  - ${basePath}: Array "${basePath}" not found in document or is empty
+
+Please ensure the array exists before modifying items by index.`
+      );
+    const maxIndex = currentArray.length - 1;
+    for (const { index } of ops.sets)
+      if (index < 0 || index > maxIndex)
+        throw new Error(
+          `Field validation failed:
+  - ${basePath}[${index}]: Index ${index} is out of bounds for array "${basePath}" (length: ${currentArray.length})
+
+Please use a valid index between 0 and ${maxIndex}.`
+        );
+    for (const index of ops.unsets)
+      if (index < 0 || index > maxIndex)
+        throw new Error(
+          `Field validation failed:
+  - ${basePath}[${index}]: Index ${index} is out of bounds for array "${basePath}" (length: ${currentArray.length})
+
+Please use a valid index between 0 and ${maxIndex}.`
+        );
+    const newArray = [...currentArray];
+    for (const { index, value } of ops.sets)
+      newArray[index] = value;
+    const uniqueUnsets = [...new Set(ops.unsets)].sort((a, b) => b - a);
+    for (const index of uniqueUnsets)
+      newArray.splice(index, 1);
+    const itemsToAppend = appendsToMerge.get(basePath);
+    itemsToAppend && newArray.push(...itemsToAppend), mergedSets.push({ path: basePath, value: newArray });
+  }
+  return mergedSets;
+}
+function convertObjectArraySetOperation(op, basePath, index, restPath, typeSchema, allSchemas, document) {
+  const currentArray = getArrayAtPath(document, basePath);
+  if (!currentArray)
+    throw new Error(
+      `Field validation failed:
+  - ${op.path}: Array "${basePath}" not found in document or is empty
+
+Please ensure the array exists before modifying items by index.`
+    );
+  if (index < 0 || index >= currentArray.length)
+    throw new Error(
+      `Field validation failed:
+  - ${op.path}: Index ${index} is out of bounds for array "${basePath}" (length: ${currentArray.length})
+
+Please use a valid index between 0 and ${currentArray.length - 1}.`
+    );
+  const key = getKeyAtIndex(currentArray, index);
+  if (!key)
+    throw new Error(
+      `Field validation failed:
+  - ${op.path}: Array item at "${basePath}[${index}]" does not have a _key field
+
+Object arrays require _key fields for addressing. Please ensure all array items have _key fields.`
+    );
+  const newPath = `${basePath}[_key=="${key}"]${restPath}`;
+  if (restPath && hasNumericIndex(restPath)) {
+    const nestedParsed = parseArrayIndex(newPath);
+    if (nestedParsed) {
+      const nestedField = getFieldAtPath(nestedParsed.basePath, typeSchema, allSchemas, document);
+      if (nestedField && nestedField.type === "array")
+        if (isPrimitiveArray(nestedField)) {
+          const nestedArray = getArrayAtPath(document, nestedParsed.basePath);
+          if (!nestedArray)
+            throw new Error(
+              `Field validation failed:
+  - ${op.path}: Array "${nestedParsed.basePath}" not found in document
+
+Please ensure the array exists before modifying items by index.`
+            );
+          const newArray = [...nestedArray];
+          return newArray[nestedParsed.index] = op.value, [{ path: nestedParsed.basePath, value: newArray }];
+        } else
+          return convertObjectArraySetOperation(
+            { path: newPath, value: op.value },
+            nestedParsed.basePath,
+            nestedParsed.index,
+            nestedParsed.restPath,
+            typeSchema,
+            allSchemas,
+            document
+          );
+    }
+  }
+  return [
+    {
+      path: newPath,
+      value: op.value
+    }
+  ];
+}
+function filterInvalidArrayItems(ops, errors) {
+  const perItemErrors = [], structuralErrors = [];
+  for (const error of errors)
+    error.itemIndex !== void 0 && error.arrayPath !== void 0 ? perItemErrors.push(error) : structuralErrors.push(error);
+  if (structuralErrors.length > 0)
+    return { hasStructuralErrors: !0, skippedItems: [] };
+  if (perItemErrors.length === 0)
+    return { hasStructuralErrors: !1, skippedItems: [] };
+  const invalidByPath = /* @__PURE__ */ new Map();
+  for (const error of perItemErrors) {
+    const existing = invalidByPath.get(error.arrayPath) ?? /* @__PURE__ */ new Set();
+    existing.add(error.itemIndex), invalidByPath.set(error.arrayPath, existing);
+  }
+  const skippedItems = [], seen = /* @__PURE__ */ new Set();
+  for (const error of perItemErrors) {
+    const key = `${error.arrayPath}:${error.itemIndex}`;
+    seen.has(key) || (seen.add(key), skippedItems.push({
+      arrayPath: error.arrayPath,
+      index: error.itemIndex,
+      type: void 0,
+      // filled below from the actual item
+      reason: error.message
+    }));
+  }
+  const cleanedSet = ops.set?.map((op) => {
+    const invalidIndices = invalidByPath.get(op.path);
+    if (!invalidIndices || !Array.isArray(op.value)) return op;
+    for (const idx of invalidIndices) {
+      const item = op.value[idx], skipped = skippedItems.find((s) => s.arrayPath === op.path && s.index === idx);
+      skipped && item && (skipped.type = item._type);
+    }
+    const filtered = op.value.filter((_, idx) => !invalidIndices.has(idx));
+    return { ...op, value: filtered };
+  }), cleanedAppend = ops.append?.map((op) => {
+    const invalidIndices = invalidByPath.get(op.path);
+    if (!invalidIndices) return op;
+    for (const idx of invalidIndices) {
+      const item = op.items[idx], skipped = skippedItems.find((s) => s.arrayPath === op.path && s.index === idx);
+      skipped && item && (skipped.type = item._type);
+    }
+    const filtered = op.items.filter((_, idx) => !invalidIndices.has(idx));
+    return { ...op, items: filtered };
+  }), filterInsert = (insertOps) => insertOps?.map((op) => {
+    const invalidIndices = invalidByPath.get(op.arrayPath);
+    if (!invalidIndices) return op;
+    for (const idx of invalidIndices) {
+      const item = op.items[idx], skipped = skippedItems.find((s) => s.arrayPath === op.arrayPath && s.index === idx);
+      skipped && item && (skipped.type = item._type);
+    }
+    const filtered = op.items.filter((_, idx) => !invalidIndices.has(idx));
+    return { ...op, items: filtered };
+  });
+  return {
+    hasStructuralErrors: !1,
+    skippedItems,
+    set: cleanedSet,
+    append: cleanedAppend,
+    insertBefore: filterInsert(ops.insertBefore),
+    insertAfter: filterInsert(ops.insertAfter)
+  };
+}
+function formatPartialWriteError(skippedItems, totalItemsByPath) {
+  const lines = [], byPath = /* @__PURE__ */ new Map();
+  for (const item of skippedItems) {
+    const existing = byPath.get(item.arrayPath) ?? [];
+    existing.push(item), byPath.set(item.arrayPath, existing);
+  }
+  for (const [arrayPath, items] of byPath) {
+    const total = totalItemsByPath.get(arrayPath) ?? 0, written = total - items.length, details = items.map((s) => `${s.type ?? "unknown"} at index ${s.index} (${s.reason})`).join("; ");
+    lines.push(
+      `Partial write to "${arrayPath}": wrote ${written}/${total} items. Skipped ${items.length}: ${details}.`
+    );
+  }
+  return lines.push("Read the document and use insertAfter to add the missing items."), lines.join(`
+`);
+}
+function generateKey() {
+  const chars = "abcdefghijklmnopqrstuvwxyz0123456789";
+  let key = "";
+  for (let i = 0; i < 12; i++)
+    key += chars.charAt(Math.floor(Math.random() * chars.length));
+  return key;
+}
+function addMissingKeys(value, options) {
+  if (value == null)
+    return value;
+  if (Array.isArray(value))
+    return value.map((item) => {
+      if (item && typeof item == "object" && !Array.isArray(item)) {
+        const obj = item, processedObj = {};
+        for (const [key, val] of Object.entries(obj))
+          processedObj[key] = addMissingKeys(val);
+        return processedObj._key ? processedObj : {
+          _key: generateKey(),
+          ...processedObj
+        };
+      }
+      return addMissingKeys(item);
+    });
+  if (typeof value == "object") {
+    const obj = value, result = {};
+    for (const [key, val] of Object.entries(obj))
+      result[key] = addMissingKeys(val);
+    return options?.ensureRootKey && !result._key ? {
+      _key: generateKey(),
+      ...result
+    } : result;
+  }
+  return value;
+}
+function collectKeys(value, currentPath, keys) {
+  if (value != null) {
+    if (Array.isArray(value))
+      value.forEach((item, index) => {
+        if (item && typeof item == "object" && !Array.isArray(item)) {
+          const obj = item, itemPath = currentPath ? `${currentPath}.${index}` : `${index}`;
+          if (typeof obj._key == "string") {
+            const existing = keys.get(obj._key) || [];
+            existing.push(itemPath), keys.set(obj._key, existing);
+          }
+          for (const [key, val] of Object.entries(obj))
+            key !== "_key" && collectKeys(val, `${itemPath}.${key}`, keys);
+        } else {
+          const itemPath = currentPath ? `${currentPath}.${index}` : `${index}`;
+          collectKeys(item, itemPath, keys);
+        }
+      });
+    else if (typeof value == "object") {
+      const obj = value;
+      for (const [key, val] of Object.entries(obj)) {
+        const nestedPath = currentPath ? `${currentPath}.${key}` : key;
+        collectKeys(val, nestedPath, keys);
+      }
+    }
+  }
+}
+function regenerateDuplicatesInternal(value, currentPath, duplicateKeys, seenKeys, keyMapping) {
+  if (value == null)
+    return value;
+  if (Array.isArray(value))
+    return value.map((item, index) => {
+      if (item && typeof item == "object" && !Array.isArray(item)) {
+        const obj = item, itemPath2 = currentPath ? `${currentPath}.${index}` : `${index}`, oldKey = obj._key;
+        let newKey = oldKey;
+        if (oldKey && duplicateKeys.has(oldKey))
+          if (seenKeys.has(oldKey)) {
+            newKey = generateKey();
+            const oldKeyPath = `${itemPath2.split(".").slice(0, -1).join(".")}[_key=="${oldKey}"]`.replace(/^\./, ""), newKeyPath = `${itemPath2.split(".").slice(0, -1).join(".")}[_key=="${newKey}"]`.replace(/^\./, "");
+            keyMapping.set(itemPath2, newKeyPath || `[_key=="${newKey}"]`), oldKeyPath && keyMapping.set(oldKeyPath, newKeyPath || `[_key=="${newKey}"]`);
+          } else
+            seenKeys.add(oldKey);
+        const processedObj = {};
+        for (const [key, val] of Object.entries(obj))
+          key !== "_key" && (processedObj[key] = regenerateDuplicatesInternal(
+            val,
+            `${itemPath2}.${key}`,
+            duplicateKeys,
+            seenKeys,
+            keyMapping
+          ));
+        return {
+          _key: newKey,
+          ...processedObj
+        };
+      }
+      const itemPath = currentPath ? `${currentPath}.${index}` : `${index}`;
+      return regenerateDuplicatesInternal(item, itemPath, duplicateKeys, seenKeys, keyMapping);
+    });
+  if (typeof value == "object") {
+    const obj = value, result = {};
+    for (const [key, val] of Object.entries(obj)) {
+      const nestedPath = currentPath ? `${currentPath}.${key}` : key;
+      result[key] = regenerateDuplicatesInternal(
+        val,
+        nestedPath,
+        duplicateKeys,
+        seenKeys,
+        keyMapping
+      );
+    }
+    return result;
+  }
+  return value;
+}
+function regenerateDuplicateKeys(value) {
+  const keyPaths = /* @__PURE__ */ new Map();
+  collectKeys(value, "", keyPaths);
+  const duplicateKeys = /* @__PURE__ */ new Set();
+  let duplicatesFound = 0;
+  for (const [key, paths] of keyPaths)
+    paths.length > 1 && (duplicateKeys.add(key), duplicatesFound += paths.length - 1);
+  if (duplicateKeys.size === 0)
+    return {
+      value,
+      keyMapping: /* @__PURE__ */ new Map(),
+      duplicatesFound: 0
+    };
+  const keyMapping = /* @__PURE__ */ new Map();
+  return {
+    value: regenerateDuplicatesInternal(
+      value,
+      "",
+      duplicateKeys,
+      /* @__PURE__ */ new Set(),
+      keyMapping
+    ),
+    keyMapping,
+    duplicatesFound
+  };
+}
+function normalizeKeyQuotes(path) {
+  return path.replace(/\[_key=='([^']+)'\]/g, '[_key=="$1"]');
+}
+function normalizeArrayIndices(path) {
+  return path.replace(/\[(\d+)\]/g, ".$1");
+}
+function applySingleTransformation(path, keyMapping) {
+  if (keyMapping.has(path))
+    return { path: keyMapping.get(path), transformed: !0 };
+  let longestMatch = "", longestMatchValue = "";
+  for (const [oldPath, newPath] of keyMapping.entries())
+    (path === oldPath || path.startsWith(`${oldPath}.`) || path.startsWith(`${oldPath}[`)) && oldPath.length > longestMatch.length && (longestMatch = oldPath, longestMatchValue = newPath);
+  if (longestMatch) {
+    const remainder = path.slice(longestMatch.length);
+    return { path: longestMatchValue + remainder, transformed: !0 };
+  }
+  return { path, transformed: !1 };
+}
+function transformPathWithKeyMapping(path, keyMapping) {
+  if (!keyMapping || keyMapping.size === 0)
+    return path;
+  let currentPath = normalizeArrayIndices(path), iterations = 0;
+  const maxIterations = 10;
+  for (; iterations < maxIterations; ) {
+    const result = applySingleTransformation(currentPath, keyMapping);
+    if (!result.transformed)
+      break;
+    currentPath = result.path, iterations++;
+  }
+  return currentPath;
+}
+function mapKeyThroughKeyMapping(key, keyMapping) {
+  return !keyMapping || typeof keyMapping != "object" ? key : keyMapping[key] ?? key;
+}
+function resolveTopLevelFieldSchema(path, typeSchema, allSchemas) {
+  const topField = path.split(".")[0].split("[")[0], field = typeSchema.fields?.find((f) => f.name === topField);
+  return field ? allSchemas.find((s) => s.name === field.type) ?? field : void 0;
+}
+function resolveLanguageIds(fieldSchema, allSchemas) {
+  let languages = fieldSchema.options?.languages;
+  return languages?.length || (languages = allSchemas.find((s) => s.name === fieldSchema.type)?.options?.languages), languages?.length ? new Set(languages.map((l) => l.id)) : /* @__PURE__ */ new Set();
+}
+function isV4PatternItem(item, languageIds) {
+  const key = item._key;
+  return typeof key == "string" && languageIds.has(key) && !("language" in item);
+}
+function isV5PatternItem(item) {
+  return "language" in item && typeof item.language == "string";
+}
+function normalizeItemV4ToV5(item) {
+  const languageCode = item._key;
+  return { ...item, _key: generateKey(), language: languageCode };
+}
+function normalizeItemV5ToV4(item) {
+  const { language: languageCode, ...rest } = item;
+  return { ...rest, _key: languageCode };
+}
+function normalizeItems(items, fieldSchema, allSchemas) {
+  const isV5 = isV5InternationalizedArray(fieldSchema, allSchemas), languageIds = resolveLanguageIds(fieldSchema, allSchemas);
+  return languageIds.size === 0 ? items : items.map((item) => {
+    if (typeof item != "object" || item === null || Array.isArray(item)) return item;
+    const obj = item;
+    if (isV5) {
+      if (isV4PatternItem(obj, languageIds))
+        return normalizeItemV4ToV5(obj);
+    } else if (isV5PatternItem(obj))
+      return normalizeItemV5ToV4(obj);
+    return item;
+  });
+}
+function normalizeInternationalizedArrays(operations, options) {
+  const { typeSchema, allSchemas } = options;
+  return {
+    set: operations.set?.map((op) => {
+      const fieldSchema = resolveTopLevelFieldSchema(op.path, typeSchema, allSchemas);
+      return !fieldSchema || !isInternationalizedArrayField(fieldSchema) || !Array.isArray(op.value) ? op : { ...op, value: normalizeItems(op.value, fieldSchema, allSchemas) };
+    }),
+    unset: operations.unset,
+    append: operations.append?.map((op) => {
+      const fieldSchema = resolveTopLevelFieldSchema(op.path, typeSchema, allSchemas);
+      return !fieldSchema || !isInternationalizedArrayField(fieldSchema) ? op : {
+        ...op,
+        items: normalizeItems(op.items, fieldSchema, allSchemas)
+      };
+    }),
+    insertBefore: operations.insertBefore?.map((op) => {
+      const fieldSchema = resolveTopLevelFieldSchema(op.arrayPath, typeSchema, allSchemas);
+      return !fieldSchema || !isInternationalizedArrayField(fieldSchema) ? op : { ...op, items: normalizeItems(op.items, fieldSchema, allSchemas) };
+    }),
+    insertAfter: operations.insertAfter?.map((op) => {
+      const fieldSchema = resolveTopLevelFieldSchema(op.arrayPath, typeSchema, allSchemas);
+      return !fieldSchema || !isInternationalizedArrayField(fieldSchema) ? op : { ...op, items: normalizeItems(op.items, fieldSchema, allSchemas) };
+    })
+  };
+}
+function isReferenceObject(value) {
+  return value !== null && typeof value == "object" && "_ref" in value && typeof value._ref == "string" && "_type" in value && typeof value._type == "string";
+}
+function getReferenceFieldDefinition(fieldPath, typeSchema, fullSchema) {
+  return resolveFieldSchema(fieldPath, typeSchema, fullSchema);
+}
+function getArrayItemSchema(arrayFieldPath, typeSchema, fullSchema) {
+  const field = getReferenceFieldDefinition(arrayFieldPath, typeSchema, fullSchema);
+  return !field || field.type !== "array" || !field.of || field.of.length === 0 || field.of.length > 1 ? null : field.of[0];
+}
+function isWeakReferenceField(fieldDefinition) {
+  return fieldDefinition.type === "reference" && fieldDefinition.weak === !0 ? !0 : fieldDefinition.type === "array" && fieldDefinition.of ? fieldDefinition.of.some((item) => item.type === "reference" && item.weak === !0) : !1;
+}
+const documentCache = /* @__PURE__ */ new Map();
+function clearDocumentCache() {
+  documentCache.clear();
+}
+async function lookupDocument(client, docId) {
+  if (documentCache.has(docId))
+    return documentCache.get(docId);
+  try {
+    const doc = await client.getDocument(docId), result = doc ? { _type: doc._type } : null;
+    return documentCache.set(docId, result), result;
+  } catch {
+    return documentCache.set(docId, null), null;
+  }
+}
+async function normalizeReferenceObject(client, ref, fieldPath, typeSchema, fullSchema, targetDocumentId, validationErrors, applyStrengthenOnPublish, parentObjectType) {
+  let fieldDefinition;
+  if (typeSchema.type === "reference" ? fieldDefinition = typeSchema : fieldDefinition = getReferenceFieldDefinition(
+    fieldPath,
+    typeSchema,
+    fullSchema
+  ), !fieldDefinition && parentObjectType) {
+    const globalType = fullSchema.find((s) => s.name === parentObjectType);
+    if (globalType?.fields) {
+      const fieldName = fieldPath.split(".").pop()?.replace(/\[\d+\]$/, "");
+      if (fieldName) {
+        const field = globalType.fields.find((f) => f.name === fieldName);
+        field && (fieldDefinition = field);
+      }
+    }
+  }
+  if (fieldDefinition?.type === "array" && fieldDefinition.of) {
+    const referenceSchemas = fieldDefinition.of.filter((item) => item.type === "reference");
+    referenceSchemas.length === 1 && (fieldDefinition = referenceSchemas[0]);
+  }
+  const isSchemaWeak = fieldDefinition ? isWeakReferenceField(fieldDefinition) : !1, isTargetPublished = isPublishedId(targetDocumentId), originalRefId = ref._ref;
+  if (ref._type === "globalDocumentReference")
+    return { ...ref, _weak: !0 };
+  if (ref._weak) {
+    const publishedId2 = isVersionId(originalRefId) || isDraftId(originalRefId) ? getPublishedId(originalRefId) : originalRefId;
+    if (isSchemaWeak || ref._strengthenOnPublish)
+      return { ...ref, _ref: publishedId2 };
+    if (applyStrengthenOnPublish && !isTargetPublished) {
+      const allPossibleTypes2 = [];
+      fieldDefinition?.to && Array.isArray(fieldDefinition.to) && allPossibleTypes2.push(...fieldDefinition.to.map((t) => t.type).filter(Boolean));
+      const targetType = allPossibleTypes2.length === 1 ? allPossibleTypes2[0] : ref._type !== "reference" ? ref._type : allPossibleTypes2[0];
+      if (targetType)
+        return {
+          ...ref,
+          _ref: publishedId2,
+          _strengthenOnPublish: { type: targetType, template: { id: targetType } }
+        };
+    }
+    return { ...ref, _ref: publishedId2 };
+  }
+  let publishedId, needsWeakAndStrengthen = !1, documentType = null;
+  if (isVersionId(originalRefId)) {
+    if (isTargetPublished)
+      return validationErrors.push(
+        createError(
+          fieldPath,
+          "INVALID_REFERENCE",
+          "Cannot reference versioned document from published document",
+          `"${originalRefId}" (versioned)`,
+          "Published document reference",
+          "Use a published document ID instead of a versioned one"
+        )
+      ), null;
+    const versionedDoc = await lookupDocument(client, originalRefId);
+    if (!versionedDoc)
+      return validationErrors.push(
+        createError(
+          fieldPath,
+          "REFERENCE_NOT_FOUND",
+          "Referenced versioned document does not exist",
+          `"${originalRefId}"`,
+          "Valid document ID",
+          "Provide a document ID that exists in the dataset"
+        )
+      ), null;
+    documentType = versionedDoc._type, publishedId = getPublishedId(originalRefId), needsWeakAndStrengthen = !0;
+  } else if (isDraftId(originalRefId)) {
+    if (isTargetPublished)
+      return validationErrors.push(
+        createError(
+          fieldPath,
+          "INVALID_REFERENCE",
+          "Cannot reference draft document from published document",
+          `"${originalRefId}" (draft)`,
+          "Published document reference",
+          "Use a published document ID instead of a draft one"
+        )
+      ), null;
+    const draftDoc = await lookupDocument(client, originalRefId);
+    if (!draftDoc)
+      return validationErrors.push(
+        createError(
+          fieldPath,
+          "REFERENCE_NOT_FOUND",
+          "Referenced draft document does not exist",
+          `"${originalRefId}"`,
+          "Valid document ID",
+          "Provide a document ID that exists in the dataset"
+        )
+      ), null;
+    documentType = draftDoc._type, publishedId = getPublishedId(originalRefId), needsWeakAndStrengthen = !0;
+  } else {
+    publishedId = originalRefId;
+    const publishedDoc = await lookupDocument(client, publishedId);
+    if (!publishedDoc)
+      return validationErrors.push(
+        createError(
+          fieldPath,
+          "REFERENCE_NOT_FOUND",
+          "Referenced document does not exist",
+          `"${originalRefId}"`,
+          "Valid document ID",
+          "Provide a document ID that exists in the dataset"
+        )
+      ), null;
+    documentType = publishedDoc._type, needsWeakAndStrengthen = !1;
+  }
+  const normalized = {
+    ...ref
+  };
+  if (isSchemaWeak && (normalized._weak = !0), !applyStrengthenOnPublish)
+    return normalized;
+  const allPossibleTypes = [];
+  if (fieldDefinition?.to && Array.isArray(fieldDefinition.to) && allPossibleTypes.push(...fieldDefinition.to.map((t) => t.type).filter(Boolean)), allPossibleTypes.length > 0 && documentType && !allPossibleTypes.includes(documentType))
+    return validationErrors.push(
+      createError(
+        fieldPath,
+        "REFERENCE_WRONG_TYPE",
+        "Reference points to wrong document type",
+        `"${originalRefId}" (type: ${documentType})`,
+        `Reference to: ${allPossibleTypes.join(", ")}`,
+        `Change the reference to point to a document of type ${allPossibleTypes.join(" or ")}`
+      )
+    ), null;
+  if (!isSchemaWeak && needsWeakAndStrengthen && !isTargetPublished && documentType) {
+    let targetType = documentType;
+    allPossibleTypes.length === 1 && (targetType = allPossibleTypes[0]), normalized._ref = publishedId, normalized._weak = !0, normalized._strengthenOnPublish = {
+      type: targetType,
+      template: {
+        id: targetType
+      }
+    };
+  }
+  return normalized;
+}
+async function traverseAndNormalize(client, value, currentPath, typeSchema, fullSchema, targetDocumentId, validationErrors, applyStrengthenOnPublish, parentObjectType) {
+  if (value == null)
+    return value;
+  if (Array.isArray(value))
+    return (await Promise.all(
+      value.map(async (item, index) => {
+        const itemPath = `${currentPath}[${index}]`;
+        return await traverseAndNormalize(
+          client,
+          item,
+          itemPath,
+          typeSchema,
+          fullSchema,
+          targetDocumentId,
+          validationErrors,
+          applyStrengthenOnPublish,
+          parentObjectType
+        );
+      })
+    )).filter((item) => item !== null);
+  if (isReferenceObject(value))
+    return await normalizeReferenceObject(
+      client,
+      value,
+      currentPath,
+      typeSchema,
+      fullSchema,
+      targetDocumentId,
+      validationErrors,
+      applyStrengthenOnPublish,
+      parentObjectType
+    );
+  if (typeof value == "object") {
+    const obj = value, normalized = {}, thisObjectType = typeof obj._type == "string" ? obj._type : void 0;
+    for (const [key, val] of Object.entries(obj)) {
+      if (key.startsWith("_")) {
+        normalized[key] = val;
+        continue;
+      }
+      const fieldPath = currentPath ? `${currentPath}.${key}` : key, result = await traverseAndNormalize(
+        client,
+        val,
+        fieldPath,
+        typeSchema,
+        fullSchema,
+        targetDocumentId,
+        validationErrors,
+        applyStrengthenOnPublish,
+        thisObjectType
+      );
+      result !== null && (normalized[key] = result);
+    }
+    return normalized;
+  }
+  return value;
+}
+async function normalizeDocumentReferences(client, document, schema, applyStrengthenOnPublish = !0) {
+  if (clearDocumentCache(), !document || !schema || schema.length === 0)
+    return {
+      normalized: document,
+      validationErrors: []
+    };
+  const typeSchema = schema.find((t) => t.name === document._type);
+  if (!typeSchema)
+    return {
+      normalized: document,
+      validationErrors: []
+    };
+  const validationErrors = [];
+  return {
+    normalized: await traverseAndNormalize(
+      client,
+      document,
+      "",
+      typeSchema,
+      schema,
+      document._id,
+      validationErrors,
+      applyStrengthenOnPublish
+    ),
+    validationErrors
+  };
+}
+function getLastItemKey(arrayValue, excludeKeys) {
+  if (!(!Array.isArray(arrayValue) || arrayValue.length === 0))
+    for (let i = arrayValue.length - 1; i >= 0; i--) {
+      const item = arrayValue[i];
+      if (item && typeof item == "object" && "_key" in item) {
+        const key = item._key;
+        if (!excludeKeys || !excludeKeys.has(key))
+          return key;
+      }
+    }
+}
+function extractUnsetKeysForArray(unsetPaths, arrayPath) {
+  const keys = /* @__PURE__ */ new Set(), regex = new RegExp(`^${escapeRegex(arrayPath)}\\[_key==["']([^"']+)["']\\]$`);
+  for (const path of unsetPaths) {
+    const match = path.match(regex);
+    match && keys.add(match[1]);
+  }
+  return keys;
+}
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function collectExistingKeys(arrayValue) {
+  const keys = /* @__PURE__ */ new Set();
+  if (!Array.isArray(arrayValue)) return keys;
+  for (const item of arrayValue)
+    if (item && typeof item == "object" && "_key" in item) {
+      const key = item._key;
+      typeof key == "string" && keys.add(key);
+    }
+  return keys;
+}
+async function normalizeArrayItems(client, items, arrayPath, typeSchema, fullSchema, targetDocumentId, validationErrors, applyStrengthenOnPublish) {
+  const arrayItemSchema = getArrayItemSchema(arrayPath, typeSchema, fullSchema), arrayFieldDef = getReferenceFieldDefinition(arrayPath, typeSchema, fullSchema), normalizedItems = [];
+  for (const item of items) {
+    let schemaForItem = arrayItemSchema;
+    if (!schemaForItem && arrayFieldDef?.of) {
+      const itemRecord = item;
+      if (typeof itemRecord._ref == "string") {
+        const matchingRefSchema = arrayFieldDef.of.find((s) => s.type !== "reference" ? !1 : s.name === itemRecord._type || s.type === itemRecord._type && !s.name);
+        if (matchingRefSchema)
+          schemaForItem = matchingRefSchema;
+        else {
+          const refSchemas = arrayFieldDef.of.filter((s) => s.type === "reference");
+          if (refSchemas.length > 0) {
+            const allWeak = refSchemas.every((s) => s.weak === !0), allStrong = refSchemas.every((s) => s.weak !== !0);
+            if (allWeak || allStrong)
+              schemaForItem = refSchemas[0];
+            else {
+              normalizedItems.push(item);
+              continue;
+            }
+          }
+        }
+      } else
+        schemaForItem = arrayFieldDef.of.find((ofSchema) => ofSchema.name === itemRecord._type || ofSchema.type === itemRecord._type) || null;
+    }
+    const normalizedItem = await traverseAndNormalize(
+      client,
+      item,
+      "",
+      schemaForItem || typeSchema,
+      fullSchema,
+      targetDocumentId,
+      validationErrors,
+      applyStrengthenOnPublish
+    );
+    normalizedItem !== null && normalizedItems.push(normalizedItem);
+  }
+  return normalizedItems;
+}
+function collectAllKeys(value, keys) {
+  if (value != null) {
+    if (Array.isArray(value))
+      for (const item of value)
+        if (item && typeof item == "object" && !Array.isArray(item)) {
+          const obj = item;
+          if (typeof obj._key == "string") {
+            const count = keys.get(obj._key) || 0;
+            keys.set(obj._key, count + 1);
+          }
+          for (const val of Object.values(obj))
+            collectAllKeys(val, keys);
+        } else
+          collectAllKeys(item, keys);
+    else if (typeof value == "object")
+      for (const val of Object.values(value))
+        collectAllKeys(val, keys);
+  }
+}
+function regenerateDuplicateKeysInValue(value, duplicateKeys, conflictingKeys, seenKeys) {
+  if (value == null) return value;
+  if (Array.isArray(value))
+    return value.map((item) => {
+      if (item && typeof item == "object" && !Array.isArray(item)) {
+        const obj = item, oldKey = obj._key;
+        let newKey = oldKey;
+        oldKey && (conflictingKeys.has(oldKey) || duplicateKeys.has(oldKey) && seenKeys.has(oldKey) ? newKey = generateKey() : seenKeys.add(oldKey));
+        const processedObj = {};
+        for (const [key, val] of Object.entries(obj))
+          key !== "_key" && (processedObj[key] = regenerateDuplicateKeysInValue(
+            val,
+            duplicateKeys,
+            conflictingKeys,
+            seenKeys
+          ));
+        return { _key: newKey, ...processedObj };
+      }
+      return regenerateDuplicateKeysInValue(item, duplicateKeys, conflictingKeys, seenKeys);
+    });
+  if (typeof value == "object") {
+    const obj = value, result = {};
+    for (const [key, val] of Object.entries(obj))
+      result[key] = regenerateDuplicateKeysInValue(val, duplicateKeys, conflictingKeys, seenKeys);
+    return result;
+  }
+  return value;
+}
+function getParentPaths(path) {
+  const parentPaths = [], arrayMatch = path.match(/\[_key==[^\]]+\]|\[\d+\]/);
+  let pathToAnalyze;
+  arrayMatch && arrayMatch.index !== void 0 ? pathToAnalyze = path.slice(0, arrayMatch.index) : pathToAnalyze = path;
+  const segments = pathToAnalyze.split(".").filter(Boolean);
+  for (let i = 0; i < segments.length - 1; i++)
+    parentPaths.push(segments.slice(0, i + 1).join("."));
+  return parentPaths;
+}
+function computeSetIfMissing(paths, typeSchema, fullSchema) {
+  const setIfMissing = {};
+  for (const path of paths) {
+    const parentPaths = getParentPaths(path);
+    for (const parentPath of parentPaths) {
+      if (setIfMissing[parentPath] !== void 0) continue;
+      const fieldSchema = resolveFieldSchema(parentPath, typeSchema, fullSchema);
+      fieldSchema && (fieldSchema.type === "array" ? setIfMissing[parentPath] = [] : (fieldSchema.type === "object" || fieldSchema.fields) && (setIfMissing[parentPath] = fieldSchema.name ? { _type: fieldSchema.name } : {}));
+    }
+  }
+  return setIfMissing;
+}
+function regenerateDuplicateKeysForAppend(items, existingArrayKeys) {
+  const keyCounts = /* @__PURE__ */ new Map();
+  collectAllKeys(items, keyCounts);
+  const duplicateKeys = /* @__PURE__ */ new Set();
+  for (const [key, count] of keyCounts)
+    count > 1 && duplicateKeys.add(key);
+  return duplicateKeys.size === 0 && existingArrayKeys.size === 0 ? items : regenerateDuplicateKeysInValue(
+    items,
+    duplicateKeys,
+    existingArrayKeys,
+    /* @__PURE__ */ new Set()
+  );
+}
+async function normalizePatchOperations(client, operations, documentType, fullSchema, targetDocumentId, options = {}) {
+  const { applyStrengthenOnPublish = !0, existingDocument } = options;
+  if (clearDocumentCache(), !operations || !documentType || !fullSchema || fullSchema.length === 0)
+    return {
+      normalized: operations,
+      validationErrors: [],
+      setIfMissing: {}
+    };
+  const typeSchema = fullSchema.find((t) => t.name === documentType);
+  if (!typeSchema)
+    return {
+      normalized: operations,
+      validationErrors: [],
+      setIfMissing: {}
+    };
+  const validationErrors = [], normalized = {};
+  for (const [opType, opValue] of Object.entries(operations))
+    if (opType === "set" && Array.isArray(opValue)) {
+      const normalizedSet = [];
+      for (const op of opValue) {
+        const normalizedValue = await traverseAndNormalize(
+          client,
+          op.value,
+          op.path,
+          typeSchema,
+          fullSchema,
+          targetDocumentId,
+          validationErrors,
+          applyStrengthenOnPublish
+        );
+        normalizedValue !== null && normalizedSet.push({
+          path: op.path,
+          value: normalizedValue
+        });
+      }
+      normalized[opType] = normalizedSet;
+    } else if (opType === "append" && Array.isArray(opValue)) {
+      const normalizedAppend = [], appendAfterKeyForPath = {};
+      for (const op of opValue) {
+        const normalizedItems = Array.isArray(op.items) ? await normalizeArrayItems(
+          client,
+          op.items,
+          op.path,
+          typeSchema,
+          fullSchema,
+          targetDocumentId,
+          validationErrors,
+          applyStrengthenOnPublish
+        ) : [];
+        if (normalizedItems.length > 0) {
+          let resolvedPath = op.path, existingArrayKeys = /* @__PURE__ */ new Set();
+          if (existingDocument) {
+            const arrayValue = getValueAtPath(existingDocument, op.path);
+            existingArrayKeys = collectExistingKeys(arrayValue);
+            const unsetKeys = extractUnsetKeysForArray(operations.unset || [], op.path);
+            let appendAfterKey = appendAfterKeyForPath[op.path];
+            appendAfterKey || (appendAfterKey = getLastItemKey(arrayValue, unsetKeys)), appendAfterKey && (resolvedPath = `${op.path}[_key=="${appendAfterKey}"]`);
+          }
+          const deduplicatedItems = regenerateDuplicateKeysForAppend(
+            normalizedItems,
+            existingArrayKeys
+          ), lastItem = deduplicatedItems[deduplicatedItems.length - 1];
+          lastItem && typeof lastItem == "object" && "_key" in lastItem && (appendAfterKeyForPath[op.path] = lastItem._key), normalizedAppend.push({
+            path: resolvedPath,
+            items: deduplicatedItems
+          });
+        }
+      }
+      normalized[opType] = normalizedAppend;
+    } else if ((opType === "insertBefore" || opType === "insertAfter") && Array.isArray(opValue)) {
+      const normalizedInserts = [];
+      for (const op of opValue) {
+        const normalizedItems = Array.isArray(op.items) ? await normalizeArrayItems(
+          client,
+          op.items,
+          op.arrayPath,
+          typeSchema,
+          fullSchema,
+          targetDocumentId,
+          validationErrors,
+          applyStrengthenOnPublish
+        ) : [];
+        if (normalizedItems.length > 0) {
+          let existingArrayKeys = /* @__PURE__ */ new Set();
+          if (existingDocument) {
+            const arrayValue = getValueAtPath(existingDocument, op.arrayPath);
+            existingArrayKeys = collectExistingKeys(arrayValue);
+          }
+          const deduplicatedItems = regenerateDuplicateKeysForAppend(
+            normalizedItems,
+            existingArrayKeys
+          );
+          normalizedInserts.push({
+            arrayPath: op.arrayPath,
+            key: op.key,
+            items: deduplicatedItems
+          });
+        }
+      }
+      normalized[opType] = normalizedInserts;
+    } else
+      normalized[opType] = opValue;
+  const allPaths = [];
+  if (normalized.set && Array.isArray(normalized.set))
+    for (const op of normalized.set)
+      allPaths.push(op.path);
+  if (normalized.append && Array.isArray(normalized.append))
+    for (const op of normalized.append)
+      allPaths.push(op.path);
+  const setIfMissing = computeSetIfMissing(allPaths, typeSchema, fullSchema);
+  return {
+    normalized,
+    validationErrors,
+    setIfMissing
+  };
+}
+function acceptsFlatPortableText(fieldPath, typeSchema, allSchemas) {
+  const fieldSchema = resolveFieldSchema(fieldPath, typeSchema, allSchemas);
+  return fieldSchema ? arrayAcceptsBlocks(fieldSchema, allSchemas) : !1;
+}
+function acceptsOnlyFlatPortableText(fieldPath, typeSchema, allSchemas) {
+  const fieldSchema = resolveFieldSchema(fieldPath, typeSchema, allSchemas);
+  return fieldSchema ? arrayIsBlockOnly(fieldSchema, allSchemas) : !1;
+}
+function hasAnyFlatPortableTextField(typeSchema, allSchemas) {
+  return typeSchema.fields ? typeSchema.fields.some((field) => {
+    const resolved = field.type ? allSchemas.find((s) => s.name === field.type) ?? field : field;
+    return arrayAcceptsBlocks(resolved, allSchemas);
+  }) : !1;
+}
+function arrayAcceptsBlocks(fieldSchema, allSchemas) {
+  let schema = fieldSchema;
+  if (!schema.of && schema.type) {
+    const resolved = allSchemas.find((s) => s.name === schema.type);
+    resolved && (schema = resolved);
+  }
+  const arrayOf = schema.of;
+  return !arrayOf || arrayOf.length === 0 ? !1 : arrayOf.some((item) => resolveBlockMember(item, allSchemas) !== void 0);
+}
+function arrayIsBlockOnly(fieldSchema, allSchemas) {
+  let schema = fieldSchema;
+  if (!schema.of && schema.type) {
+    const resolved = allSchemas.find((s) => s.name === schema.type);
+    resolved && (schema = resolved);
+  }
+  const arrayOf = schema.of;
+  return !arrayOf || arrayOf.length === 0 ? !1 : arrayOf.every((item) => {
+    const block = resolveBlockMember(item, allSchemas);
+    if (!block) return !1;
+    const annotations = block.marks?.annotations;
+    return !annotations || annotations.length === 0;
+  });
+}
+function resolveBlockMember(item, allSchemas) {
+  if (item.type === "block") return item;
+  if (item.type) {
+    const resolved = allSchemas.find((s) => s.name === item.type);
+    if (resolved?.type === "block") return resolved;
+  }
+}
+function normalizeOperationPaths(operations) {
+  return {
+    set: operations.set?.map((op) => ({
+      ...op,
+      path: normalizeKeyQuotes(op.path)
+    })),
+    unset: operations.unset?.map((path) => normalizeKeyQuotes(path)),
+    append: operations.append?.map((op) => ({
+      ...op,
+      path: normalizeKeyQuotes(op.path)
+    })),
+    insertBefore: operations.insertBefore?.map((op) => ({
+      ...op,
+      arrayPath: normalizeKeyQuotes(op.arrayPath)
+    })),
+    insertAfter: operations.insertAfter?.map((op) => ({
+      ...op,
+      arrayPath: normalizeKeyQuotes(op.arrayPath)
+    }))
+  };
+}
+function applyKeyMapping(operations, keyMapping) {
+  return {
+    set: operations.set?.map((op) => ({
+      ...op,
+      path: transformPathWithKeyMapping(op.path, keyMapping)
+    })),
+    unset: operations.unset?.map((path) => transformPathWithKeyMapping(path, keyMapping)),
+    append: operations.append?.map((op) => ({
+      ...op,
+      path: transformPathWithKeyMapping(op.path, keyMapping)
+    })),
+    insertBefore: operations.insertBefore?.map((op) => ({
+      ...op,
+      arrayPath: transformPathWithKeyMapping(op.arrayPath, keyMapping),
+      key: mapKeyThroughKeyMapping(op.key, keyMapping)
+    })),
+    insertAfter: operations.insertAfter?.map((op) => ({
+      ...op,
+      arrayPath: transformPathWithKeyMapping(op.arrayPath, keyMapping),
+      key: mapKeyThroughKeyMapping(op.key, keyMapping)
+    }))
+  };
+}
+function addMissingKeysToOperations(operations) {
+  return {
+    set: operations.set?.map((op) => ({
+      ...op,
+      value: addMissingKeys(op.value)
+    })),
+    unset: operations.unset,
+    append: operations.append?.map((op) => ({
+      ...op,
+      items: op.items.map((item) => addMissingKeys(item, { ensureRootKey: !0 }))
+    })),
+    insertBefore: operations.insertBefore?.map((op) => ({
+      ...op,
+      items: op.items.map((item) => addMissingKeys(item, { ensureRootKey: !0 }))
+    })),
+    insertAfter: operations.insertAfter?.map((op) => ({
+      ...op,
+      items: op.items.map((item) => addMissingKeys(item, { ensureRootKey: !0 }))
+    }))
+  };
+}
+function convertAppendToSetForMissingArrays(operations, document) {
+  if (!operations.append || operations.append.length === 0)
+    return operations;
+  const remainingAppends = [], convertedSets = [];
+  for (const op of operations.append) {
+    const isSimplePath = !op.path.includes("["), existingValue = getValueAtPath(document, op.path), isMissingOrEmpty = existingValue == null || Array.isArray(existingValue) && existingValue.length === 0;
+    isSimplePath && isMissingOrEmpty ? convertedSets.push({ path: op.path, value: [...op.items] }) : remainingAppends.push(op);
+  }
+  return convertedSets.length === 0 ? operations : {
+    ...operations,
+    set: [...operations.set ?? [], ...convertedSets],
+    append: remainingAppends.length > 0 ? remainingAppends : void 0
+  };
+}
+function prepareOperations(operations, options) {
+  let prepared = normalizeOperationPaths(operations);
+  return options.keyMapping && (prepared = applyKeyMapping(prepared, options.keyMapping)), prepared = convertArrayIndexOperations(
+    prepared,
+    options.typeSchema,
+    options.allSchemas,
+    options.document
+  ), prepared = convertAppendToSetForMissingArrays(prepared, options.document), prepared = normalizeInternationalizedArrays(prepared, {
+    typeSchema: options.typeSchema,
+    allSchemas: options.allSchemas
+  }), prepared = addMissingKeysToOperations(prepared), prepared;
+}
+function pathEndsWithArrayIndex(path) {
+  return /\[\d+\]$/.test(path) || /\[_key==[^\]]+\]$/.test(path);
+}
+function resolveToArraySchema(fieldSchema, allSchemas) {
+  if (fieldSchema.type === "array")
+    return fieldSchema;
+  if (fieldSchema.type && !isPrimitiveType(fieldSchema.type)) {
+    const referencedSchema = allSchemas.find((s) => s.name === fieldSchema.type);
+    if (referencedSchema)
+      return referencedSchema;
+  }
+  return fieldSchema;
+}
+function getSchemaForSetValue(fieldSchema, path, value, allSchemas) {
+  if (!pathEndsWithArrayIndex(path))
+    return fieldSchema;
+  const resolvedSchema = resolveToArraySchema(fieldSchema, allSchemas);
+  if (resolvedSchema.type !== "array" || !resolvedSchema.of?.length)
+    return fieldSchema;
+  const itemSchemas = resolvedSchema.of;
+  if (typeof value == "object" && value !== null && !Array.isArray(value)) {
+    const valueType = value._type;
+    if (valueType) {
+      let matchingSchema = itemSchemas.find(
+        (schema) => schema.name === valueType || schema.type === valueType
+      );
+      if (matchingSchema || (matchingSchema = allSchemas.find((s) => s.name === valueType)), matchingSchema)
+        return matchingSchema;
+    }
+  }
+  return itemSchemas[0];
+}
+function hasUniqueConstraint(fieldSchema) {
+  return !!fieldSchema.validation?.some(
+    (group) => group.rules.some((rule) => {
+      const r = rule, ruleType = r.type || r.flag;
+      return ruleType === "unique" || ruleType === "uniqueItems";
+    })
+  );
+}
+async function validatePatchOperations(operations, documentType, schema, context) {
+  const errors = [], warnings = [], typeSchema = schema.find((s) => s.name === documentType);
+  return typeSchema ? (await validateSetOperations(operations.set, typeSchema, schema, context, errors, warnings), validateUnsetOperations(operations.unset, typeSchema, schema, context, errors), await validateAppendOperations(operations.append, typeSchema, schema, context, errors, warnings), await validateInsertOperations(operations, typeSchema, schema, context, errors, warnings), {
+    valid: errors.length === 0,
+    errors,
+    warnings
+  }) : (errors.push(
+    createError(
+      "_type",
+      "FIELD_NOT_IN_SCHEMA",
+      `Document type "${documentType}" not found in schema`,
+      documentType,
+      "Valid document type",
+      "Check the schema for valid document type names"
+    )
+  ), { valid: !1, errors, warnings });
+}
+async function validateSetOperations(ops, typeSchema, schema, context, errors, warnings) {
+  if (ops)
+    for (const op of ops) {
+      const fieldSchema = resolveFieldSchemaAtPath(
+        op.path,
+        typeSchema,
+        schema,
+        context.existingDocument
+      ).schema;
+      if (!fieldSchema) {
+        errors.push(
+          createError(
+            op.path,
+            "FIELD_NOT_IN_SCHEMA",
+            "Path does not exist in schema",
+            op.path,
+            "Valid field path",
+            "Check the schema for valid field paths"
+          )
+        );
+        continue;
+      }
+      if (op.value !== void 0) {
+        const valueSchema = getSchemaForSetValue(fieldSchema, op.path, op.value, schema);
+        await validateValue(op.value, valueSchema, op.path, errors, context, schema, warnings);
+      }
+      if (validateInternationalizedArraySet(op.path, op.value, fieldSchema, typeSchema, schema, errors), context.localizationConfig?.documentLevel) {
+        const { languageField, availableLanguages } = context.localizationConfig.documentLevel;
+        languageField && op.path === languageField && availableLanguages && validateDocumentLanguageField(op.value, languageField, availableLanguages, op.path, errors);
+      }
+    }
+}
+function validateUnsetOperations(ops, typeSchema, schema, context, errors) {
+  if (ops)
+    for (const path of ops)
+      resolveFieldSchemaAtPath(path, typeSchema, schema, context.existingDocument).schema || errors.push(
+        createError(
+          path,
+          "FIELD_NOT_IN_SCHEMA",
+          "Path does not exist in schema",
+          path,
+          "Valid field path",
+          "Check the schema for valid field paths"
+        )
+      );
+}
+async function validateAppendOperations(ops, typeSchema, schema, context, errors, warnings) {
+  if (ops)
+    for (const op of ops) {
+      const fieldSchema = resolveFieldSchema(op.path, typeSchema, schema);
+      if (!fieldSchema) {
+        errors.push(
+          createError(
+            op.path,
+            "FIELD_NOT_IN_SCHEMA",
+            "Path does not exist in schema",
+            op.path,
+            "Valid array field path",
+            "Check the schema for valid array field paths"
+          )
+        );
+        continue;
+      }
+      if (context.existingDocument && op.path.includes("[_key==") && getValueAtPath(context.existingDocument, op.path) === void 0) {
+        errors.push(
+          createError(
+            op.path,
+            "FIELD_NOT_IN_SCHEMA",
+            "Path does not exist in document",
+            op.path,
+            "Valid array path that exists in document",
+            "Check that the path with _key selectors points to an existing location"
+          )
+        );
+        continue;
+      }
+      const arraySchema = resolveToArraySchema(fieldSchema, schema);
+      if (arraySchema.of && arraySchema.of.length > 0) {
+        const errorCountBefore = errors.length;
+        await validateValue(op.items, arraySchema, op.path, errors, context, schema, warnings);
+        for (let e = errorCountBefore; e < errors.length; e++)
+          errors[e].path = errors[e].path.replace(
+            new RegExp(`^${op.path.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\[(\\d+)\\]`),
+            `${op.path}[append:$1]`
+          );
+      }
+      if (isInternationalizedArrayField(fieldSchema) && validateInternationalizedArrayItems(op.items, fieldSchema, schema, op.path, errors), hasUniqueConstraint(fieldSchema) && context.existingDocument) {
+        const existingArray = getValueAtPath(context.existingDocument, op.path);
+        Array.isArray(existingArray) && validateUniqueItems(op.items, existingArray, `${op.path}[append:`, errors);
+      }
+    }
+}
+async function validateInsertOperations(operations, typeSchema, schema, context, errors, warnings) {
+  for (const opType of ["insertBefore", "insertAfter"]) {
+    const insertOps = operations[opType];
+    if (insertOps)
+      for (const op of insertOps) {
+        const fieldSchema = resolveFieldSchema(op.arrayPath, typeSchema, schema);
+        if (!fieldSchema) {
+          errors.push(
+            createError(
+              op.arrayPath,
+              "FIELD_NOT_IN_SCHEMA",
+              "Array path does not exist in schema",
+              op.arrayPath,
+              "Valid array field path",
+              "Check the schema for valid array field paths"
+            )
+          );
+          continue;
+        }
+        const resolvedSchema = resolveToArraySchema(fieldSchema, schema);
+        if (resolvedSchema.type !== "array" && !resolvedSchema.of) {
+          errors.push(
+            createError(
+              op.arrayPath,
+              "TYPE_MISMATCH",
+              "Path must point to an array field",
+              fieldSchema.type || "unknown",
+              "Array field",
+              "Use an array field path for insert operations"
+            )
+          );
+          continue;
+        }
+        const arraySchema = resolvedSchema;
+        if (context.existingDocument) {
+          const existingArray = getValueAtPath(context.existingDocument, op.arrayPath);
+          Array.isArray(existingArray) && (existingArray.some(
+            (item) => typeof item == "object" && item !== null && item._key === op.key
+          ) || errors.push(
+            createError(
+              `${op.arrayPath}[_key=="${op.key}"]`,
+              "INVALID_PATH",
+              `Anchor key "${op.key}" not found in array`,
+              op.key,
+              "Existing _key in the array",
+              "Use a _key that exists in the target array"
+            )
+          ));
+        }
+        if (isInternationalizedArrayField(fieldSchema) && validateInternationalizedArrayItems(op.items, fieldSchema, schema, op.arrayPath, errors), await validateInsertItems(op, opType, arraySchema, schema, context, errors, warnings), hasUniqueConstraint(fieldSchema) && context.existingDocument) {
+          const existingArray = getValueAtPath(context.existingDocument, op.arrayPath);
+          Array.isArray(existingArray) && validateUniqueItems(op.items, existingArray, `${op.arrayPath}[${opType}:`, errors);
+        }
+      }
+  }
+}
+async function validateInsertItems(op, opType, arraySchema, schema, context, errors, warnings) {
+  const itemSchemas = arraySchema.of || [];
+  if (itemSchemas.length !== 0)
+    for (let i = 0; i < op.items.length; i++) {
+      const item = op.items[i], itemPath = `${op.arrayPath}[${opType}:${i}]`, errorCountBefore = errors.length, itemType = (typeof item == "object" && item !== null ? item : null)?._type;
+      let matchingSchema;
+      for (const ofSchema of itemSchemas) {
+        if (ofSchema.name === itemType || ofSchema.type === itemType) {
+          matchingSchema = ofSchema;
+          break;
+        }
+        if (!itemType && isPrimitiveType(ofSchema.type)) {
+          matchingSchema = ofSchema;
+          break;
+        }
+      }
+      matchingSchema && await validateValue(item, matchingSchema, itemPath, errors, context, schema, warnings);
+      for (let e = errorCountBefore; e < errors.length; e++)
+        errors[e].itemIndex = i, errors[e].arrayPath = op.arrayPath;
+    }
+}
+export {
+  acceptsFlatPortableText,
+  acceptsOnlyFlatPortableText,
+  addMissingKeys,
+  buildPatchTransaction,
+  clearDocumentCache,
+  convertArrayIndexOperations,
+  filterInvalidArrayItems,
+  formatPartialWriteError,
+  generateKey,
+  getArrayAtPath,
+  getArrayItemSchema,
+  getKeyAtIndex,
+  getReferenceFieldDefinition,
+  hasAnyFlatPortableTextField,
+  hasNumericIndex,
+  isPrimitiveArray,
+  mapKeyThroughKeyMapping,
+  normalizeDocumentReferences,
+  normalizeInternationalizedArrays,
+  normalizeKeyQuotes,
+  normalizePatchOperations,
+  parseArrayIndex,
+  prepareOperations,
+  regenerateDuplicateKeys,
+  transformPathWithKeyMapping,
+  traverseAndNormalize,
+  validatePatchOperations
+};
+//# sourceMappingURL=index.js.map