gt-sanity 2.0.21 → 2.1.0

package/dist/index.cjs

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: !0 });
-var documentInternationalization = require("@sanity/document-internationalization"), jsxRuntime = require("react/jsx-runtime"), ui = require("@sanity/ui"), theme$1 = require("@sanity/ui/theme"), o = require("react"), sanity = require("sanity"), generaltranslation = require("generaltranslation"), internal = require("generaltranslation/internal"), blockTools = require("@portabletext/block-tools"), schema = require("@sanity/schema"), toHtml = require("@portabletext/to-html"), merge = require("lodash.merge"), jsonpathPlus = require("jsonpath-plus"), JSONPointer = require("jsonpointer"), mutator = require("@sanity/mutator"), icons = require("@sanity/icons"), router = require("sanity/router");
+var generaltranslation = require("generaltranslation"), internal = require("generaltranslation/internal"), sanity = require("sanity"), router = require("sanity/router"), jsxRuntime = require("react/jsx-runtime"), o = require("react"), icons = require("@sanity/icons"), ui = require("@sanity/ui"), theme$1 = require("@sanity/ui/theme"), mutator = require("@sanity/mutator"), jsonpathPlus = require("jsonpath-plus"), JSONPointer = require("jsonpointer"), blockTools = require("@portabletext/block-tools"), schema = require("@sanity/schema"), toHtml = require("@portabletext/to-html"), merge = require("lodash.merge"), documentInternationalization = require("@sanity/document-internationalization");
 function _interopDefaultCompat(e) {
   return e && typeof e == "object" && "default" in e ? e : { default: e };
 }
-var o__default = /* @__PURE__ */ _interopDefaultCompat(o), merge__default = /* @__PURE__ */ _interopDefaultCompat(merge), JSONPointer__default = /* @__PURE__ */ _interopDefaultCompat(JSONPointer);
+var o__default = /* @__PURE__ */ _interopDefaultCompat(o), JSONPointer__default = /* @__PURE__ */ _interopDefaultCompat(JSONPointer), merge__default = /* @__PURE__ */ _interopDefaultCompat(merge);
 const useClient = () => sanity.useClient({ apiVersion: "2025-09-15" });
 function useSecrets(id) {
   const [loading, setLoading] = o.useState(!0), [secrets, setSecrets] = o.useState(null), client = useClient();
@@ -42,9 +42,12 @@ class GTConfig {
   additionalSerializers;
   additionalDeserializers;
   additionalBlockDeserializers;
+  translationLevel;
+  fieldLevelDocuments;
+  fieldLevelTypePrefix;
   static instance;
-  constructor(secretsNamespace, languageField, sourceLocale, locales, singletons, singletonMapping, ignoreFields, dedupeFields, skipFields, translateDocuments, additionalStopTypes = [], additionalSerializers = {}, additionalDeserializers = { types: {} }, additionalBlockDeserializers = []) {
-    this.secretsNamespace = secretsNamespace, this.languageField = languageField, this.sourceLocale = sourceLocale, this.locales = locales, this.singletons = singletons, this.singletonMapping = singletonMapping, this.ignoreFields = ignoreFields, this.dedupeFields = dedupeFields, this.skipFields = skipFields, this.translateDocuments = translateDocuments, this.additionalStopTypes = additionalStopTypes, this.additionalSerializers = additionalSerializers, this.additionalDeserializers = additionalDeserializers, this.additionalBlockDeserializers = additionalBlockDeserializers;
+  constructor(secretsNamespace, languageField, sourceLocale, locales, singletons, singletonMapping, ignoreFields, dedupeFields, skipFields, translateDocuments, additionalStopTypes = [], additionalSerializers = {}, additionalDeserializers = { types: {} }, additionalBlockDeserializers = [], translationLevel = "document", fieldLevelDocuments = [], fieldLevelTypePrefix = "internationalizedArray") {
+    this.secretsNamespace = secretsNamespace, this.languageField = languageField, this.sourceLocale = sourceLocale, this.locales = locales, this.singletons = singletons, this.singletonMapping = singletonMapping, this.ignoreFields = ignoreFields, this.dedupeFields = dedupeFields, this.skipFields = skipFields, this.translateDocuments = translateDocuments, this.additionalStopTypes = additionalStopTypes, this.additionalSerializers = additionalSerializers, this.additionalDeserializers = additionalDeserializers, this.additionalBlockDeserializers = additionalBlockDeserializers, this.translationLevel = translationLevel, this.fieldLevelDocuments = fieldLevelDocuments, this.fieldLevelTypePrefix = fieldLevelTypePrefix;
   }
   static getInstance() {
     return this.instance || (this.instance = new GTConfig(
@@ -64,8 +67,8 @@ class GTConfig {
       []
     )), this.instance;
   }
-  init(secretsNamespace, languageField, sourceLocale, locales, singletons, singletonMapping, ignoreFields, dedupeFields, skipFields, translateDocuments, additionalStopTypes = [], additionalSerializers = {}, additionalDeserializers = { types: {} }, additionalBlockDeserializers = []) {
-    this.secretsNamespace = secretsNamespace, this.languageField = languageField, this.sourceLocale = sourceLocale, this.locales = locales, this.singletons = singletons, this.singletonMapping = singletonMapping, this.ignoreFields = ignoreFields, this.dedupeFields = dedupeFields, this.skipFields = skipFields, this.translateDocuments = translateDocuments, this.additionalStopTypes = additionalStopTypes, this.additionalSerializers = additionalSerializers, this.additionalDeserializers = additionalDeserializers, this.additionalBlockDeserializers = additionalBlockDeserializers;
+  init(secretsNamespace, languageField, sourceLocale, locales, singletons, singletonMapping, ignoreFields, dedupeFields, skipFields, translateDocuments, additionalStopTypes = [], additionalSerializers = {}, additionalDeserializers = { types: {} }, additionalBlockDeserializers = [], translationLevel = "document", fieldLevelDocuments = [], fieldLevelTypePrefix = "internationalizedArray") {
+    this.secretsNamespace = secretsNamespace, this.languageField = languageField, this.sourceLocale = sourceLocale, this.locales = locales, this.singletons = singletons, this.singletonMapping = singletonMapping, this.ignoreFields = ignoreFields, this.dedupeFields = dedupeFields, this.skipFields = skipFields, this.translateDocuments = translateDocuments, this.additionalStopTypes = additionalStopTypes, this.additionalSerializers = additionalSerializers, this.additionalDeserializers = additionalDeserializers, this.additionalBlockDeserializers = additionalBlockDeserializers, this.translationLevel = translationLevel, this.fieldLevelDocuments = fieldLevelDocuments, this.fieldLevelTypePrefix = fieldLevelTypePrefix;
   }
   getSecretsNamespace() {
     return this.secretsNamespace;
@@ -109,6 +112,15 @@ class GTConfig {
   getAdditionalBlockDeserializers() {
     return this.additionalBlockDeserializers;
   }
+  getTranslationLevel() {
+    return this.translationLevel;
+  }
+  getFieldLevelDocuments() {
+    return this.fieldLevelDocuments;
+  }
+  getFieldLevelTypePrefix() {
+    return this.fieldLevelTypePrefix;
+  }
 }
 const pluginConfig = GTConfig.getInstance(), theme = theme$1.buildTheme(), BaseTranslationWrapper = ({
   children,
@@ -122,21 +134,21 @@ const pluginConfig = GTConfig.getInstance(), theme = theme$1.buildTheme(), BaseT
     !loadingSecrets && secrets && children
   ] });
   return /* @__PURE__ */ jsxRuntime.jsx(ui.ThemeProvider, { theme, children: /* @__PURE__ */ jsxRuntime.jsx(ui.ToastProvider, { paddingY: 7, children: showContainer ? /* @__PURE__ */ jsxRuntime.jsx(ui.Box, { padding, children: content }) : content }) });
-}, isRecord$4 = (value) => typeof value == "object" && value !== null && !Array.isArray(value), reconcileArray = (origArray, translatedArray) => {
+}, isRecord$5 = (value) => typeof value == "object" && value !== null && !Array.isArray(value), reconcileArray = (origArray, translatedArray) => {
   if (translatedArray && translatedArray.some((el) => typeof el == "string"))
     return translatedArray;
   const combined = JSON.parse(JSON.stringify(origArray));
   return translatedArray.forEach((translatedItem) => {
-    if (!isRecord$4(translatedItem) || !translatedItem._key)
+    if (!isRecord$5(translatedItem) || !translatedItem._key)
       return;
     const foundBlockIdx = origArray.findIndex(
-      (origBlock) => isRecord$4(origBlock) && origBlock._key === translatedItem._key
+      (origBlock) => isRecord$5(origBlock) && origBlock._key === translatedItem._key
     );
     foundBlockIdx < 0 ? console.warn(
       `This block no longer exists on the original document. Was it removed? ${JSON.stringify(
         translatedItem
       )}`
-    ) : isRecord$4(origArray[foundBlockIdx]) && (origArray[foundBlockIdx]._type === "block" || origArray[foundBlockIdx]._type === "span") ? combined[foundBlockIdx] = translatedItem : isRecord$4(origArray[foundBlockIdx]) && (combined[foundBlockIdx] = reconcileObject(
+    ) : isRecord$5(origArray[foundBlockIdx]) && (origArray[foundBlockIdx]._type === "block" || origArray[foundBlockIdx]._type === "span") ? combined[foundBlockIdx] = translatedItem : isRecord$5(origArray[foundBlockIdx]) && (combined[foundBlockIdx] = reconcileObject(
       origArray[foundBlockIdx],
       translatedItem
     ));
@@ -149,8 +161,8 @@ const pluginConfig = GTConfig.getInstance(), theme = theme$1.buildTheme(), BaseT
     !value || key[0] === "_" || (typeof value == "string" ? updatedObj[key] = value : Array.isArray(value) ? updatedObj[key] = reconcileArray(
       Array.isArray(origObject[key]) ? origObject[key] : [],
       value
-    ) : isRecord$4(value) && (updatedObj[key] = reconcileObject(
-      isRecord$4(origObject[key]) ? origObject[key] : {},
+    ) : isRecord$5(value) && (updatedObj[key] = reconcileObject(
+      isRecord$5(origObject[key]) ? origObject[key] : {},
       value
     )));
   }), updatedObj;
@@ -171,7 +183,7 @@ const pluginConfig = GTConfig.getInstance(), theme = theme$1.buildTheme(), BaseT
       origVal ?? [],
       translatedVal
     ) : typeof translatedVal == "object" && Object.keys(translatedVal).length && (valToPatch = reconcileObject(
-      isRecord$4(origVal) ? origVal : {},
+      isRecord$5(origVal) ? origVal : {},
       translatedVal
     ));
     const destinationPath = [
@@ -190,215 +202,701 @@ const pluginConfig = GTConfig.getInstance(), theme = theme$1.buildTheme(), BaseT
   documentLevelMerge,
   reconcileArray,
   reconcileObject
-}, defaultSchema = schema.Schema.compile({
-  name: "default",
-  types: [
-    {
-      type: "object",
-      name: "default",
-      fields: [
-        {
-          name: "block",
-          type: "array",
-          of: [{ type: "block" }]
-        }
-      ]
-    }
-  ]
-}), blockContentType = defaultSchema.get("default").fields.find((field) => field.name === "block").type, preprocess = (html) => {
-  const intermediateBlocks = blockTools.htmlToBlocks(
-    `<p>${html}</p>`,
-    blockContentType
-  );
-  if (!intermediateBlocks.length)
-    throw new Error(`Error parsing string '${html}'`);
-  return intermediateBlocks[0].children[0].text;
 };
-function attachGTData(html, data, type) {
-  const firstElement = new DOMParser().parseFromString(html, "text/html").body.firstElementChild;
-  if (!firstElement)
-    return html;
-  const encodedData = encode(JSON.stringify({ [type]: data }));
-  return firstElement.setAttribute("data-gt-internal", encodedData), firstElement.outerHTML;
+function getPublishedId(documentId) {
+  return documentId.startsWith("drafts.") ? documentId.slice(7) : documentId;
 }
-function detachGTData(html) {
-  const firstElement = new DOMParser().parseFromString(html, "text/html").body.firstElementChild;
-  if (!firstElement)
-    return { html };
-  const encodedData = firstElement.getAttribute("data-gt-internal");
-  let extractedData;
-  if (encodedData)
-    try {
-      const decodedData = decode(encodedData);
-      extractedData = JSON.parse(decodedData), firstElement.removeAttribute("data-gt-internal");
-    } catch (error) {
-      console.warn("Failed to decode GT internal data:", error);
-    }
-  return {
-    html: firstElement.outerHTML,
-    data: extractedData
-  };
+function getDocumentPublishedId(document2) {
+  return getPublishedId(document2._id);
 }
-function encode(data) {
-  const bytes = new TextEncoder().encode(data);
-  let binary = "";
-  for (let i = 0; i < bytes.length; i++)
-    binary += String.fromCharCode(bytes[i]);
-  return btoa(binary);
+function dedupeDocumentsPreferDraft(documents) {
+  const byPublishedId = /* @__PURE__ */ new Map();
+  for (const document2 of documents) {
+    const publishedId = getDocumentPublishedId(document2);
+    (!byPublishedId.get(publishedId) || document2._id.startsWith("drafts.")) && byPublishedId.set(publishedId, document2);
+  }
+  return Array.from(byPublishedId.values());
 }
-function decode(base64) {
-  const binary = atob(base64), bytes = new Uint8Array(binary.length);
-  for (let i = 0; i < binary.length; i++)
-    bytes[i] = binary.charCodeAt(i);
-  return new TextDecoder().decode(bytes);
+function createTranslationStatusKey(branchId, documentId, versionId, localeId) {
+  const publishedId = getPublishedId(documentId);
+  return branchId ? `${branchId}:${publishedId}:${versionId}:${localeId}` : `${publishedId}:${versionId}:${localeId}`;
 }
-const isRecord$3 = (value) => typeof value == "object" && value !== null && !Array.isArray(value), defaultStopTypes = [
-  "reference",
-  "date",
-  "datetime",
-  "file",
-  "geopoint",
-  "image",
-  "number",
-  "crop",
-  "hotspot",
-  "boolean",
-  "url",
-  "color",
-  "code"
-], defaultMarks = {}, defaultPortableTextBlockStyles = {
-  normal: ({ value, children }) => `<p id="${value._key}">${children}</p>`,
-  blockquote: ({ value, children }) => `<blockquote id="${value._key}">${children}</blockquote>`,
-  h1: ({ value, children }) => `<h1 id="${value._key}">${children}</h1>`,
-  h2: ({ value, children }) => `<h2 id="${value._key}">${children}</h2>`,
-  h3: ({ value, children }) => `<h3 id="${value._key}">${children}</h3>`,
-  h4: ({ value, children }) => `<h4 id="${value._key}">${children}</h4>`,
-  h5: ({ value, children }) => `<h5 id="${value._key}">${children}</h5>`,
-  h6: ({ value, children }) => `<h6 id="${value._key}">${children}</h6>`
-}, defaultLists = {
-  number: ({ value, children }) => `<ol id="${value._key.replace("-parent", "")}">${children}</ol>`,
-  bullet: ({ value, children }) => `<ul id="${value._key.replace("-parent", "")}">${children}</ul>`
-}, defaultListItem = ({
-  value,
-  children
-}) => {
-  const { _key, level } = value;
-  return `<li id="${(_key || "").replace("-parent", "")}" data-level="${level}">${children}</li>`;
-}, unknownBlockFunc = ({ value, children }) => `<p id="${value._key}" data-type="unknown-block-style" data-style="${value.style}">${children}</p>`, customSerializers = {
-  unknownType: ({ value }) => `<div class="${value._type}"></div>`,
-  types: {},
-  marks: defaultMarks,
-  block: defaultPortableTextBlockStyles,
-  list: defaultLists,
-  listItem: defaultListItem,
-  unknownBlockStyle: unknownBlockFunc
-}, customDeserializers = { types: {} }, customBlockDeserializers = [
-  // handle marks with data-gt-internal
-  {
-    deserialize(node2, next2) {
-      if (node2.nodeType !== 1)
-        return;
-      const el = node2;
-      if (!el.hasChildNodes() || !el.getAttribute("data-gt-internal"))
-        return;
-      const { html, data } = detachGTData(el.outerHTML), block = blockTools.htmlToBlocks(html, blockContentType)[0], children = next2(el.childNodes);
-      let markDefs = [];
-      return "markDefs" in block && (markDefs = block.markDefs ?? []), data?.markDef && markDefs.push(data.markDef), Array.isArray(children) && children.forEach((child) => {
-        if (!isRecord$3(child))
-          return;
-        const marks = Array.isArray(child.marks) ? child.marks : [];
-        child.marks = data?.markDef?._key ? [...marks, data.markDef._key] : marks;
-      }), {
-        ...block,
-        markDefs,
-        children
-      };
-    }
-  },
-  //handle undeclared styles
-  {
-    deserialize(node2, next2) {
-      if (node2.nodeType !== 1)
-        return;
-      const el = node2;
-      if (!el.hasChildNodes() || el.getAttribute("data-type") !== "unknown-block-style")
-        return;
-      const style = el.getAttribute("data-style") ?? "";
-      return {
-        ...blockTools.htmlToBlocks(el.outerHTML, blockContentType)[0],
-        style,
-        children: next2(el.childNodes)
-      };
-    }
-  },
-  //handle list items
-  {
-    deserialize(node2, next2) {
-      if (node2.nodeType !== 1)
-        return;
-      const el = node2;
-      if (!el.hasChildNodes() || el.tagName.toLowerCase() !== "li")
-        return;
-      const tagsToStyle = {
-        ul: "bullet",
-        ol: "number"
-      }, parent = el.parentNode;
-      if (!parent || !parent.tagName)
-        return;
-      const listItem = tagsToStyle[parent.tagName.toLowerCase()];
-      if (!listItem)
-        return;
-      const level = el.getAttribute("data-level") && parseInt(el.getAttribute("data-level") || "0", 10), _key = el.id;
-      let block = blockTools.htmlToBlocks(parent.outerHTML, blockContentType)[0];
-      const customStyle = el.children?.[0]?.getAttribute("data-style");
-      if (new RegExp(/<("[^"]*"|'[^']*'|[^'">])*>/).test(el.innerHTML)) {
-        const newBlock = blockTools.htmlToBlocks(el.innerHTML, blockContentType)[0];
-        if (newBlock && (block = {
-          ...block,
-          ...newBlock,
-          // @ts-ignore
-          style: customStyle ?? newBlock.style
-        }, customStyle))
-          return block;
+function createStableTranslationKey(branchId, documentId, localeId) {
+  const publishedId = getPublishedId(documentId);
+  return branchId ? `${branchId}:${publishedId}:${localeId}` : `${publishedId}:${localeId}`;
+}
+const findLatestDraft = (documentId, client) => {
+  const publishedId = getPublishedId(documentId), query = "*[_id == $id || _id == $draftId]", params = { id: publishedId, draftId: `drafts.${publishedId}` };
+  return client.fetch(query, params).then(
+    (docs) => docs.find((doc) => doc._id.startsWith("drafts.")) ?? docs[0]
+  );
+}, findDocumentAtRevision = async (documentId, rev, client) => {
+  const baseUrl = `/data/history/${client.config().dataset}/documents/${documentId}?revision=${rev}`, url = client.getUrl(baseUrl);
+  return await fetch(url, { credentials: "include" }).then((req) => req.json()).then((req) => req.documents && req.documents.length ? req.documents[0] : null);
+};
+function forEachMatchingField(documentId, document2, fields, callback) {
+  const applicable = fields.filter(
+    (field) => field.documentId === documentId || field.documentId === void 0 || field.documentId === null
+  );
+  for (const entry of applicable)
+    if (entry.fields)
+      for (const field of entry.fields) {
+        const { property, type } = field;
+        try {
+          const results = jsonpathPlus.JSONPath({
+            json: document2,
+            path: property,
+            resultType: "all",
+            flatten: !0,
+            wrap: !0
+          });
+          results && results.length > 0 && results.forEach(
+            (result) => {
+              type !== void 0 ? typeof result.value == "object" && result.value !== null && !Array.isArray(result.value) && result.value._type === type && callback(result) : callback(result);
+            }
+          );
+        } catch (error) {
+          console.warn(`Invalid JSONPath: ${property}`, error);
+        }
       }
-      return {
-        ...block,
-        level,
-        _key,
-        listItem,
-        children: next2(el.childNodes)
-      };
-    }
-  }
-], META_FIELDS$1 = ["_key", "_type", "_id"], isRecord$2 = (value) => typeof value == "object" && value !== null && !Array.isArray(value), languageObjectFieldFilter = (obj, baseLang) => {
-  const filterToLangField = (childObj) => {
-    const filteredObj = {};
-    return filteredObj[baseLang] = childObj[baseLang], META_FIELDS$1.forEach((field) => {
-      childObj[field] && (filteredObj[field] = childObj[field]);
-    }), filteredObj;
-  }, findBaseLang = (childObj) => {
-    const filteredObj = {};
-    META_FIELDS$1.forEach((field) => {
-      childObj[field] && (filteredObj[field] = childObj[field]);
-    });
-    for (const key in childObj)
-      if (childObj.hasOwnProperty(key)) {
-        const value = childObj[key];
-        if (isRecord$2(value) && Object.hasOwn(value, baseLang))
-          filteredObj[key] = filterToLangField(value);
-        else if (Array.isArray(value) && value.length && typeof value[0] == "object") {
-          const validLangObjects = value.reduce(
-            (validArr, objInArray) => {
-              if (!isRecord$2(objInArray))
-                return validArr;
-              if (objInArray._type === "block")
-                validArr.push(objInArray);
-              else if (Object.hasOwn(objInArray, baseLang))
-                validArr.push(filterToLangField(objInArray));
-              else {
-                const filtered = findBaseLang(objInArray);
-                Object.keys(filtered).filter(
-                  (objInArrayKey) => META_FIELDS$1.indexOf(objInArrayKey) === -1
+}
+function deleteMatchingFields(documentId, document2, fields) {
+  const arrayRemovals = [];
+  forEachMatchingField(documentId, document2, fields, (result) => {
+    Array.isArray(result.parent) ? arrayRemovals.push({
+      parent: result.parent,
+      index: Number(result.parentProperty)
+    }) : delete result.parent[result.parentProperty];
+  }), arrayRemovals.sort((a, b) => b.index - a.index);
+  for (const { parent, index } of arrayRemovals)
+    parent.splice(index, 1);
+}
+function applyDocuments(documentId, sourceDocument, targetDocument, ignore, skip = [], dedupe = [], localeId) {
+  const mergedDocument = JSON.parse(JSON.stringify(sourceDocument)), clonedTarget = JSON.parse(JSON.stringify(targetDocument));
+  for (const [key, value] of Object.entries(clonedTarget))
+    mergedDocument[key] = value;
+  return forEachMatchingField(documentId, sourceDocument, ignore, (result) => {
+    JSONPointer__default.default.set(mergedDocument, result.pointer, result.value);
+  }), forEachMatchingField(documentId, sourceDocument, dedupe, (result) => {
+    JSONPointer__default.default.set(
+      mergedDocument,
+      result.pointer,
+      dedupeFieldValue(result.value, localeId)
+    );
+  }), deleteMatchingFields(documentId, mergedDocument, skip), mergedDocument;
+}
+function dedupeFieldValue(value, localeId) {
+  if (!localeId) return value;
+  if (typeof value == "string")
+    return appendLocaleSuffix(value, localeId);
+  if (value && typeof value == "object" && !Array.isArray(value) && typeof value.current == "string") {
+    const slug = value;
+    return {
+      ...slug,
+      current: appendLocaleSuffix(slug.current, localeId)
+    };
+  }
+  return value;
+}
+function appendLocaleSuffix(value, localeId) {
+  if (!value) return value;
+  const suffix = createLocaleSuffix(localeId);
+  return !suffix || value.endsWith(suffix) ? value : `${value}${suffix}`;
+}
+function createLocaleSuffix(localeId) {
+  const normalized = localeId.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+  return normalized ? `-${normalized}` : "";
+}
+function randomKey() {
+  return Math.random().toString(36).slice(2, 10);
+}
+async function createI18nDocAndPatchMetadata(sourceDocument, translatedDoc, localeId, client, translationMetadata, sourceDocumentId, languageField = "language") {
+  const publishedSourceDocumentId = getPublishedId(sourceDocumentId);
+  translatedDoc[languageField] = localeId;
+  const existingLocaleKey = translationMetadata.translations.find(
+    (translation) => translation.language === localeId
+  ), operation = existingLocaleKey ? "replace" : "after", location = existingLocaleKey ? `translations[language == "${localeId}"]` : "translations[-1]", { _updatedAt, _createdAt, ...rest } = translatedDoc, appliedDocument = applyDocuments(
+    publishedSourceDocumentId,
+    sourceDocument,
+    rest,
+    pluginConfig.getIgnoreFields(),
+    pluginConfig.getSkipFields(),
+    pluginConfig.getDedupeFields(),
+    localeId
+  ), isSingleton = pluginConfig.getSingletons().includes(publishedSourceDocumentId);
+  let createDocumentPromise;
+  if (isSingleton) {
+    const translatedDocId = pluginConfig.getSingletonMapping()(
+      publishedSourceDocumentId,
+      localeId
+    );
+    createDocumentPromise = client.create({
+      ...appliedDocument,
+      _type: rest._type,
+      _id: `drafts.${translatedDocId}`
+    });
+  } else
+    createDocumentPromise = client.create({
+      ...appliedDocument,
+      _type: rest._type,
+      _id: "drafts."
+    });
+  const doc = await createDocumentPromise, _ref = getPublishedId(doc._id);
+  await client.transaction().patch(
+    translationMetadata._id,
+    (p) => p.insert(operation, location, [
+      {
+        _key: randomKey(),
+        language: localeId,
+        _type: "internationalizedArrayReferenceValue",
+        value: {
+          _type: "reference",
+          _ref,
+          _weak: !0,
+          _strengthenOnPublish: {
+            type: doc._type
+          }
+        }
+      }
+    ])
+  ).commit();
+}
+const getOrCreateTranslationMetadata = async (documentId, baseDocument, client, baseLanguage) => {
+  const publishedId = getPublishedId(documentId), existingMetadata = await client.fetch(
+    `*[
+        _type == 'translation.metadata' &&
+        translations[language == $baseLanguage][0].value._ref == $id
+      ][0]`,
+    { baseLanguage, id: publishedId }
+  );
+  if (existingMetadata)
+    return existingMetadata;
+  const baseLangEntry = {
+    _key: randomKey(),
+    language: baseLanguage,
+    _type: "internationalizedArrayReferenceValue",
+    value: {
+      _type: "reference",
+      _ref: getPublishedId(baseDocument._id)
+    }
+  };
+  baseDocument._id.startsWith("drafts.") && (baseLangEntry.value = {
+    ...baseLangEntry.value,
+    _weak: !0,
+    //this should reflect doc i18n config when this
+    //plugin is able to take that as a config option
+    _strengthenOnPublish: {
+      type: baseDocument._type
+    }
+  });
+  try {
+    return await client.createIfNotExists({
+      _id: `translation.metadata.${publishedId}`,
+      _type: "translation.metadata",
+      translations: [baseLangEntry]
+    });
+  } catch (error) {
+    const metadata = await client.fetch(
+      `*[
+          _type == 'translation.metadata' &&
+          translations[language == $baseLanguage][0].value._ref == $id
+        ][0]`,
+      { baseLanguage, id: publishedId }
+    );
+    if (metadata)
+      return metadata;
+    throw error;
+  }
+}, SYSTEM_FIELDS = ["_id", "_rev", "_updatedAt", "language"], isSystemField = (field) => SYSTEM_FIELDS.includes(field);
+async function patchI18nDoc(sourceDocumentId, i18nDocId, sourceDocument, mergedDocument, translatedFields, client, existingDocument) {
+  const cleanedMerge = {};
+  Object.entries(mergedDocument).forEach(([key, value]) => {
+    key in translatedFields && //don't overwrite any existing system values on the i18n doc
+    !isSystemField(key) && (cleanedMerge[key] = value);
+  });
+  const cleanedSourceDocument = {};
+  Object.entries(sourceDocument).forEach(([key, value]) => {
+    isSystemField(key) || (cleanedSourceDocument[key] = value);
+  });
+  const appliedDocument = applyDocuments(
+    sourceDocumentId,
+    cleanedSourceDocument,
+    cleanedMerge,
+    pluginConfig.getIgnoreFields(),
+    pluginConfig.getSkipFields()
+  ), dedupeFields = pluginConfig.getDedupeFields();
+  deleteMatchingFields(sourceDocumentId, appliedDocument, dedupeFields), existingDocument && forEachMatchingField(
+    sourceDocumentId,
+    existingDocument,
+    dedupeFields,
+    (result) => {
+      JSONPointer__default.default.set(appliedDocument, result.pointer, result.value);
+    }
+  ), await client.patch(i18nDocId, { set: appliedDocument }).commit();
+}
+const documentLevelPatch = async (docInfo, translatedFields, localeId, client, languageField = "language", mergeWithTargetLocale = !1) => {
+  const baseLanguage = pluginConfig.getSourceLocale();
+  let baseDoc = null, i18nDoc = null;
+  docInfo.documentId && docInfo.versionId && (baseDoc = await findDocumentAtRevision(
+    docInfo.documentId,
+    docInfo.versionId,
+    client
+  )), baseDoc || (baseDoc = await findLatestDraft(docInfo.documentId, client));
+  const i18nDocId = (await getOrCreateTranslationMetadata(
+    docInfo.documentId,
+    baseDoc,
+    client,
+    baseLanguage
+  )).translations.find(
+    (translation) => translation.language === localeId
+  )?.value?._ref;
+  i18nDocId && (i18nDoc = await findLatestDraft(i18nDocId, client)), mergeWithTargetLocale && i18nDoc ? baseDoc = i18nDoc : docInfo.documentId && docInfo.versionId && (baseDoc = await findDocumentAtRevision(
+    docInfo.documentId,
+    docInfo.versionId,
+    client
+  )), baseDoc || (baseDoc = await findLatestDraft(docInfo.documentId, client));
+  const merged = BaseDocumentMerger.documentLevelMerge(
+    translatedFields,
+    baseDoc
+  );
+  if (i18nDoc)
+    await patchI18nDoc(
+      docInfo.documentId,
+      i18nDoc._id,
+      baseDoc,
+      merged,
+      translatedFields,
+      client,
+      i18nDoc
+    );
+  else {
+    const freshTranslationMetadata = await getOrCreateTranslationMetadata(
+      docInfo.documentId,
+      baseDoc,
+      client,
+      baseLanguage
+    ), freshI18nDocId = freshTranslationMetadata.translations.find(
+      (translation) => translation.language === localeId
+    )?.value?._ref;
+    if (freshI18nDocId) {
+      const freshI18nDoc = await findLatestDraft(freshI18nDocId, client);
+      await patchI18nDoc(
+        docInfo.documentId,
+        freshI18nDoc._id,
+        baseDoc,
+        merged,
+        translatedFields,
+        client,
+        freshI18nDoc
+      );
+      return;
+    }
+    await createI18nDocAndPatchMetadata(
+      baseDoc,
+      merged,
+      localeId,
+      client,
+      freshTranslationMetadata,
+      docInfo.documentId,
+      languageField
+    );
+  }
+}, DEFAULT_TYPE_PREFIX$1 = "internationalizedArray";
+function hasRecognizedTypePrefix(type) {
+  return type.startsWith(DEFAULT_TYPE_PREFIX$1) || type.startsWith(pluginConfig.getFieldLevelTypePrefix());
+}
+const isRecord$4 = (value) => typeof value == "object" && value !== null && !Array.isArray(value);
+function isInternationalizedArrayItem(item) {
+  return isRecord$4(item) && typeof item._type == "string" && hasRecognizedTypePrefix(item._type) && item._type.endsWith("Value") && typeof item.language == "string" && "value" in item;
+}
+function isInternationalizedArrayField(value) {
+  return Array.isArray(value) && value.length > 0 && value.every(isInternationalizedArrayItem);
+}
+function findLocaleItem(field, locale) {
+  return field.find((item) => item.language === locale);
+}
+function upsertLocaleItem(baseArray, translatedValue, targetLocale, sourceLocale) {
+  const itemType = (findLocaleItem(baseArray, sourceLocale) ?? baseArray[0])._type, updated = baseArray.map(
+    (item) => item.language === targetLocale ? { ...item, value: translatedValue } : { ...item }
+  );
+  return findLocaleItem(updated, targetLocale) || updated.push({
+    _key: randomKey(),
+    _type: itemType,
+    language: targetLocale,
+    value: translatedValue
+  }), updated;
+}
+function mergeValue(baseValue, translatedValue, targetLocale, sourceLocale) {
+  if (isInternationalizedArrayField(baseValue))
+    return upsertLocaleItem(
+      baseValue,
+      translatedValue,
+      targetLocale,
+      sourceLocale
+    );
+  if (Array.isArray(baseValue) && Array.isArray(translatedValue)) {
+    let changed = !1;
+    const merged = baseValue.map((item) => {
+      if (!isRecord$4(item) || typeof item._key != "string")
+        return item;
+      const translatedItem = translatedValue.find(
+        (candidate) => isRecord$4(candidate) && candidate._key === item._key
+      );
+      if (!translatedItem)
+        return item;
+      const mergedItem = mergeValue(
+        item,
+        translatedItem,
+        targetLocale,
+        sourceLocale
+      );
+      return mergedItem !== void 0 ? (changed = !0, mergedItem) : item;
+    });
+    return changed ? merged : void 0;
+  }
+  if (isRecord$4(baseValue) && isRecord$4(translatedValue)) {
+    let changed = !1;
+    const merged = { ...baseValue };
+    for (const key of Object.keys(translatedValue)) {
+      if (key.startsWith("_") || !(key in baseValue))
+        continue;
+      const mergedChild = mergeValue(
+        baseValue[key],
+        translatedValue[key],
+        targetLocale,
+        sourceLocale
+      );
+      mergedChild !== void 0 && (merged[key] = mergedChild, changed = !0);
+    }
+    return changed ? merged : void 0;
+  }
+}
+function mergeInternationalizedArrays(baseDoc, translatedFields, targetLocale, sourceLocale) {
+  const changes = {};
+  for (const key of Object.keys(translatedFields)) {
+    if (key.startsWith("_") || !(key in baseDoc))
+      continue;
+    const merged = mergeValue(
+      baseDoc[key],
+      translatedFields[key],
+      targetLocale,
+      sourceLocale
+    );
+    merged !== void 0 && (changes[key] = merged);
+  }
+  return changes;
+}
+const internationalizedArrayPatch = async (docInfo, translatedFields, localeId, client) => {
+  const sourceLocale = pluginConfig.getSourceLocale(), baseDoc = await findLatestDraft(docInfo.documentId, client);
+  if (!baseDoc)
+    return;
+  const changes = mergeInternationalizedArrays(
+    baseDoc,
+    translatedFields,
+    localeId,
+    sourceLocale
+  );
+  if (Object.keys(changes).length === 0)
+    return;
+  if (baseDoc._id.startsWith("drafts.")) {
+    await client.patch(baseDoc._id).set(changes).commit();
+    return;
+  }
+  const draftId = `drafts.${getPublishedId(baseDoc._id)}`;
+  await client.transaction().createIfNotExists({ ...baseDoc, _id: draftId }).patch(draftId, (patch) => patch.set(changes)).commit();
+}, defaultSchema = schema.Schema.compile({
+  name: "default",
+  types: [
+    {
+      type: "object",
+      name: "default",
+      fields: [
+        {
+          name: "block",
+          type: "array",
+          of: [{ type: "block" }]
+        }
+      ]
+    }
+  ]
+}), blockContentType = defaultSchema.get("default").fields.find((field) => field.name === "block").type, preprocess = (html) => {
+  const intermediateBlocks = blockTools.htmlToBlocks(
+    `<p>${html}</p>`,
+    blockContentType
+  );
+  if (!intermediateBlocks.length)
+    throw new Error(`Error parsing string '${html}'`);
+  return intermediateBlocks[0].children[0].text;
+};
+function attachGTData(html, data, type) {
+  const firstElement = new DOMParser().parseFromString(html, "text/html").body.firstElementChild;
+  if (!firstElement)
+    return html;
+  const encodedData = encode(JSON.stringify({ [type]: data }));
+  return firstElement.setAttribute("data-gt-internal", encodedData), firstElement.outerHTML;
+}
+function detachGTData(html) {
+  const firstElement = new DOMParser().parseFromString(html, "text/html").body.firstElementChild;
+  if (!firstElement)
+    return { html };
+  const encodedData = firstElement.getAttribute("data-gt-internal");
+  let extractedData;
+  if (encodedData)
+    try {
+      const decodedData = decode(encodedData);
+      extractedData = JSON.parse(decodedData), firstElement.removeAttribute("data-gt-internal");
+    } catch (error) {
+      console.warn("Failed to decode GT internal data:", error);
+    }
+  return {
+    html: firstElement.outerHTML,
+    data: extractedData
+  };
+}
+function encode(data) {
+  const bytes = new TextEncoder().encode(data);
+  let binary = "";
+  for (let i = 0; i < bytes.length; i++)
+    binary += String.fromCharCode(bytes[i]);
+  return btoa(binary);
+}
+function decode(base64) {
+  const binary = atob(base64), bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++)
+    bytes[i] = binary.charCodeAt(i);
+  return new TextDecoder().decode(bytes);
+}
+const isRecord$3 = (value) => typeof value == "object" && value !== null && !Array.isArray(value), defaultStopTypes = [
+  "reference",
+  "date",
+  "datetime",
+  "file",
+  "geopoint",
+  "image",
+  "number",
+  "crop",
+  "hotspot",
+  "boolean",
+  "url",
+  "color",
+  "code"
+], defaultMarks = {}, defaultPortableTextBlockStyles = {
+  normal: ({ value, children }) => `<p id="${value._key}">${children}</p>`,
+  blockquote: ({ value, children }) => `<blockquote id="${value._key}">${children}</blockquote>`,
+  h1: ({ value, children }) => `<h1 id="${value._key}">${children}</h1>`,
+  h2: ({ value, children }) => `<h2 id="${value._key}">${children}</h2>`,
+  h3: ({ value, children }) => `<h3 id="${value._key}">${children}</h3>`,
+  h4: ({ value, children }) => `<h4 id="${value._key}">${children}</h4>`,
+  h5: ({ value, children }) => `<h5 id="${value._key}">${children}</h5>`,
+  h6: ({ value, children }) => `<h6 id="${value._key}">${children}</h6>`
+}, defaultLists = {
+  number: ({ value, children }) => `<ol id="${value._key.replace("-parent", "")}">${children}</ol>`,
+  bullet: ({ value, children }) => `<ul id="${value._key.replace("-parent", "")}">${children}</ul>`
+}, defaultListItem = ({
+  value,
+  children
+}) => {
+  const { _key, level } = value;
+  return `<li id="${(_key || "").replace("-parent", "")}" data-level="${level}">${children}</li>`;
+}, unknownBlockFunc = ({ value, children }) => `<p id="${value._key}" data-type="unknown-block-style" data-style="${value.style}">${children}</p>`, customSerializers = {
+  unknownType: ({ value }) => `<div class="${value._type}"></div>`,
+  types: {},
+  marks: defaultMarks,
+  block: defaultPortableTextBlockStyles,
+  list: defaultLists,
+  listItem: defaultListItem,
+  unknownBlockStyle: unknownBlockFunc
+}, customDeserializers = { types: {} }, customBlockDeserializers = [
+  // handle marks with data-gt-internal
+  {
+    deserialize(node2, next2) {
+      if (node2.nodeType !== 1)
+        return;
+      const el = node2;
+      if (!el.hasChildNodes() || !el.getAttribute("data-gt-internal"))
+        return;
+      const { html, data } = detachGTData(el.outerHTML), block = blockTools.htmlToBlocks(html, blockContentType)[0], children = next2(el.childNodes);
+      let markDefs = [];
+      return "markDefs" in block && (markDefs = block.markDefs ?? []), data?.markDef && markDefs.push(data.markDef), Array.isArray(children) && children.forEach((child) => {
+        if (!isRecord$3(child))
+          return;
+        const marks = Array.isArray(child.marks) ? child.marks : [];
+        child.marks = data?.markDef?._key ? [...marks, data.markDef._key] : marks;
+      }), {
+        ...block,
+        markDefs,
+        children
+      };
+    }
+  },
+  //handle undeclared styles
+  {
+    deserialize(node2, next2) {
+      if (node2.nodeType !== 1)
+        return;
+      const el = node2;
+      if (!el.hasChildNodes() || el.getAttribute("data-type") !== "unknown-block-style")
+        return;
+      const style = el.getAttribute("data-style") ?? "";
+      return {
+        ...blockTools.htmlToBlocks(el.outerHTML, blockContentType)[0],
+        style,
+        children: next2(el.childNodes)
+      };
+    }
+  },
+  //handle list items
+  {
+    deserialize(node2, next2) {
+      if (node2.nodeType !== 1)
+        return;
+      const el = node2;
+      if (!el.hasChildNodes() || el.tagName.toLowerCase() !== "li")
+        return;
+      const tagsToStyle = {
+        ul: "bullet",
+        ol: "number"
+      }, parent = el.parentNode;
+      if (!parent || !parent.tagName)
+        return;
+      const listItem = tagsToStyle[parent.tagName.toLowerCase()];
+      if (!listItem)
+        return;
+      const level = el.getAttribute("data-level") && parseInt(el.getAttribute("data-level") || "0", 10), _key = el.id;
+      let block = blockTools.htmlToBlocks(parent.outerHTML, blockContentType)[0];
+      const customStyle = el.children?.[0]?.getAttribute("data-style");
+      if (new RegExp(/<("[^"]*"|'[^']*'|[^'">])*>/).test(el.innerHTML)) {
+        const newBlock = blockTools.htmlToBlocks(el.innerHTML, blockContentType)[0];
+        if (newBlock && (block = {
+          ...block,
+          ...newBlock,
+          // @ts-ignore
+          style: customStyle ?? newBlock.style
+        }, customStyle))
+          return block;
+      }
+      return {
+        ...block,
+        level,
+        _key,
+        listItem,
+        children: next2(el.childNodes)
+      };
+    }
+  }
+];
+function mergeBlocks(blocks) {
+  const mergedBlock = { ...blocks[0] };
+  mergedBlock.markDefs = mergedBlock.markDefs ?? [];
+  for (const [idx, block] of blocks.entries())
+    idx !== 0 && (mergedBlock.children.push(...block.children), mergedBlock.markDefs.push(...block.markDefs ?? []));
+  return mergedBlock._type = "block", mergedBlock;
+}
+const deserializeArray = (arrayHTML, deserializers = customDeserializers, blockDeserializers = customBlockDeserializers) => {
+  const output = [];
+  return Array.from(arrayHTML.children).forEach((child) => {
+    let deserializedObject;
+    try {
+      if (child.tagName?.toLowerCase() === "span")
+        deserializedObject = preprocess(child.innerHTML);
+      else if (child.className || child.getAttribute("data-type") === "object")
+        deserializedObject = deserializeObject(
+          child,
+          deserializers,
+          blockDeserializers
+        ), deserializedObject && typeof deserializedObject == "object" && !Array.isArray(deserializedObject) && (deserializedObject._key = child.id);
+      else {
+        const blocks = blockTools.htmlToBlocks(child.outerHTML, blockContentType, {
+          rules: blockDeserializers
+        });
+        deserializedObject = mergeBlocks(
+          blocks
+        ), deserializedObject._key = child.id;
+      }
+    } catch (e) {
+      console.debug(
+        `Tried to deserialize block: ${child.outerHTML} in an array but failed to identify it! Error: ${e}`
+      );
+    }
+    output.push(deserializedObject);
+  }), output;
+}, deserializeObject = (objectHTML, deserializers = customDeserializers, blockDeserializers = customBlockDeserializers) => {
+  const deserialize = deserializers.types?.[objectHTML.className];
+  if (deserialize)
+    return deserialize(objectHTML);
+  const output = {};
+  return objectHTML.className && (output._type = objectHTML.className), Array.from(objectHTML.children).forEach((child) => {
+    if (child.tagName?.toLowerCase() === "span")
+      output[child.className] = preprocess(child.innerHTML);
+    else if (child.getAttribute("data-level") === "field") {
+      const deserialized = deserializeHTML(
+        child.outerHTML,
+        deserializers,
+        blockDeserializers
+      );
+      deserialized && Object.keys(deserialized).length ? output[child.className] = deserialized : console.debug(
+        `Deserializer: Skipping empty or unreadable HTML: ${child.outerHTML}`
+      );
+    } else child.getAttribute("data-type") === "array" && (output[child.className] = deserializeArray(
+      child,
+      deserializers,
+      blockDeserializers
+    ));
+  }), output;
+}, deserializeHTML = (html, deserializers, blockDeserializers) => {
+  let HTMLnode = new DOMParser().parseFromString(html, "text/html").body.children[0];
+  if (HTMLnode?.getAttribute("data-level") === "field" && (HTMLnode = HTMLnode.children[0]), !HTMLnode)
+    return {};
+  let output;
+  const deserialize = deserializers.types?.[HTMLnode.className];
+  return deserialize ? output = deserialize(HTMLnode) : HTMLnode.getAttribute("data-type") === "object" ? output = deserializeObject(HTMLnode, deserializers, blockDeserializers) : HTMLnode.getAttribute("data-type") === "array" ? output = deserializeArray(HTMLnode, deserializers, blockDeserializers) : (output = {}, console.debug(
+    `Tried to deserialize block ${HTMLnode.outerHTML} but failed to identify it!`
+  )), output;
+}, deserializeDocument$1 = (serializedDoc, deserializers = customDeserializers, blockDeserializers = customBlockDeserializers) => {
+  const metadata = {}, head = new DOMParser().parseFromString(serializedDoc, "text/html").head;
+  return Array.from(head.children).forEach((metaTag) => {
+    const validTags = ["_id", "_rev", "_type"], metaName = metaTag.getAttribute("name");
+    metaName && validTags.includes(metaName) && (metadata[metaName] = metaTag.getAttribute("content"));
+  }), {
+    ...deserializeHTML(
+      serializedDoc,
+      deserializers,
+      blockDeserializers
+    ),
+    ...metadata
+  };
+}, BaseDocumentDeserializer = {
+  deserializeDocument: deserializeDocument$1,
+  deserializeHTML
+}, META_FIELDS$1 = ["_key", "_type", "_id"], isRecord$2 = (value) => typeof value == "object" && value !== null && !Array.isArray(value), languageObjectFieldFilter = (obj, baseLang) => {
+  const filterToLangField = (childObj) => {
+    const filteredObj = {};
+    return filteredObj[baseLang] = childObj[baseLang], META_FIELDS$1.forEach((field) => {
+      childObj[field] && (filteredObj[field] = childObj[field]);
+    }), filteredObj;
+  }, findBaseLang = (childObj) => {
+    const filteredObj = {};
+    META_FIELDS$1.forEach((field) => {
+      childObj[field] && (filteredObj[field] = childObj[field]);
+    });
+    for (const key in childObj)
+      if (childObj.hasOwnProperty(key)) {
+        const value = childObj[key];
+        if (isRecord$2(value) && Object.hasOwn(value, baseLang))
+          filteredObj[key] = filterToLangField(value);
+        else if (Array.isArray(value) && value.length && typeof value[0] == "object") {
+          const validLangObjects = value.reduce(
+            (validArr, objInArray) => {
+              if (!isRecord$2(objInArray))
+                return validArr;
+              if (objInArray._type === "block")
+                validArr.push(objInArray);
+              else if (Object.hasOwn(objInArray, baseLang))
+                validArr.push(filterToLangField(objInArray));
+              else {
+                const filtered = findBaseLang(objInArray);
+                Object.keys(filtered).filter(
+                  (objInArrayKey) => META_FIELDS$1.indexOf(objInArrayKey) === -1
                 ).length && validArr.push(filtered);
               }
               return validArr;
@@ -507,240 +1005,78 @@ const isRecord$3 = (value) => typeof value == "object" && value !== null && !Arr
       );
       return schema2 && schema2.fields ? fieldFilter(block, schema2.fields, stopTypes) : block;
     }).map((obj) => typeof obj == "string" ? `<span>${obj}</span>` : serializeObject(obj, stopTypes, serializers));
-    return `<div class="${fieldName}" data-type="array">${output.join("")}</div>`;
-  };
-  return {
-    serializeDocument: (doc, translationLevel = "document", baseLang = "en", stopTypes = defaultStopTypes, serializers = customSerializers) => {
-      const schema2 = getSchema(doc._type);
-      let filteredObj = {};
-      translationLevel === "field" ? filteredObj = languageObjectFieldFilter(doc, baseLang) : filteredObj = fieldFilter(doc, schema2?.fields ?? [], stopTypes);
-      const serializedFields = {};
-      for (const key in filteredObj) {
-        if (filteredObj.hasOwnProperty(key) === !1) continue;
-        const value = filteredObj[key];
-        if (typeof value == "string")
-          serializedFields[key] = value;
-        else if (Array.isArray(value))
-          serializedFields[key] = serializeArray(
-            value.filter(
-              (item) => typeof item == "string" || isRecord$1(item)
-            ),
-            key,
-            stopTypes,
-            serializers
-          );
-        else if (value && isRecord$1(value) && !stopTypes.find((stopType) => stopType == value?._type)) {
-          const serialized = serializeObject(
-            value,
-            stopTypes,
-            serializers
-          );
-          serializedFields[key] = `<div class="${key}" data-level='field'>${serialized}</div>`;
-        }
-      }
-      const rawHTMLBody = document.createElement("body");
-      rawHTMLBody.innerHTML = serializeObject(
-        serializedFields,
-        stopTypes,
-        serializers
-      );
-      const rawHTMLHead = document.createElement("head");
-      ["_id", "_type", "_rev"].forEach((field) => {
-        const metaEl = document.createElement("meta");
-        metaEl.setAttribute("name", field), metaEl.setAttribute("content", doc[field]), rawHTMLHead.appendChild(metaEl);
-      });
-      const versionMeta = document.createElement("meta");
-      versionMeta.setAttribute("name", "version"), versionMeta.setAttribute("content", "3"), rawHTMLHead.appendChild(versionMeta);
-      const rawHTML = document.createElement("html");
-      return rawHTML.appendChild(rawHTMLHead), rawHTML.appendChild(rawHTMLBody), {
-        name: doc._id,
-        content: rawHTML.outerHTML
-      };
-    },
-    fieldFilter,
-    languageObjectFieldFilter,
-    serializeArray,
-    serializeObject
-  };
-};
-function mergeBlocks(blocks) {
-  const mergedBlock = { ...blocks[0] };
-  mergedBlock.markDefs = mergedBlock.markDefs ?? [];
-  for (const [idx, block] of blocks.entries())
-    idx !== 0 && (mergedBlock.children.push(...block.children), mergedBlock.markDefs.push(...block.markDefs ?? []));
-  return mergedBlock._type = "block", mergedBlock;
-}
-const deserializeArray = (arrayHTML, deserializers = customDeserializers, blockDeserializers = customBlockDeserializers) => {
-  const output = [];
-  return Array.from(arrayHTML.children).forEach((child) => {
-    let deserializedObject;
-    try {
-      if (child.tagName?.toLowerCase() === "span")
-        deserializedObject = preprocess(child.innerHTML);
-      else if (child.className || child.getAttribute("data-type") === "object")
-        deserializedObject = deserializeObject(
-          child,
-          deserializers,
-          blockDeserializers
-        ), deserializedObject && typeof deserializedObject == "object" && !Array.isArray(deserializedObject) && (deserializedObject._key = child.id);
-      else {
-        const blocks = blockTools.htmlToBlocks(child.outerHTML, blockContentType, {
-          rules: blockDeserializers
-        });
-        deserializedObject = mergeBlocks(
-          blocks
-        ), deserializedObject._key = child.id;
-      }
-    } catch (e) {
-      console.debug(
-        `Tried to deserialize block: ${child.outerHTML} in an array but failed to identify it! Error: ${e}`
-      );
-    }
-    output.push(deserializedObject);
-  }), output;
-}, deserializeObject = (objectHTML, deserializers = customDeserializers, blockDeserializers = customBlockDeserializers) => {
-  const deserialize = deserializers.types?.[objectHTML.className];
-  if (deserialize)
-    return deserialize(objectHTML);
-  const output = {};
-  return objectHTML.className && (output._type = objectHTML.className), Array.from(objectHTML.children).forEach((child) => {
-    if (child.tagName?.toLowerCase() === "span")
-      output[child.className] = preprocess(child.innerHTML);
-    else if (child.getAttribute("data-level") === "field") {
-      const deserialized = deserializeHTML(
-        child.outerHTML,
-        deserializers,
-        blockDeserializers
-      );
-      deserialized && Object.keys(deserialized).length ? output[child.className] = deserialized : console.debug(
-        `Deserializer: Skipping empty or unreadable HTML: ${child.outerHTML}`
-      );
-    } else child.getAttribute("data-type") === "array" && (output[child.className] = deserializeArray(
-      child,
-      deserializers,
-      blockDeserializers
-    ));
-  }), output;
-}, deserializeHTML = (html, deserializers, blockDeserializers) => {
-  let HTMLnode = new DOMParser().parseFromString(html, "text/html").body.children[0];
-  if (HTMLnode?.getAttribute("data-level") === "field" && (HTMLnode = HTMLnode.children[0]), !HTMLnode)
-    return {};
-  let output;
-  const deserialize = deserializers.types?.[HTMLnode.className];
-  return deserialize ? output = deserialize(HTMLnode) : HTMLnode.getAttribute("data-type") === "object" ? output = deserializeObject(HTMLnode, deserializers, blockDeserializers) : HTMLnode.getAttribute("data-type") === "array" ? output = deserializeArray(HTMLnode, deserializers, blockDeserializers) : (output = {}, console.debug(
-    `Tried to deserialize block ${HTMLnode.outerHTML} but failed to identify it!`
-  )), output;
-}, deserializeDocument$1 = (serializedDoc, deserializers = customDeserializers, blockDeserializers = customBlockDeserializers) => {
-  const metadata = {}, head = new DOMParser().parseFromString(serializedDoc, "text/html").head;
-  return Array.from(head.children).forEach((metaTag) => {
-    const validTags = ["_id", "_rev", "_type"], metaName = metaTag.getAttribute("name");
-    metaName && validTags.includes(metaName) && (metadata[metaName] = metaTag.getAttribute("content"));
-  }), {
-    ...deserializeHTML(
-      serializedDoc,
-      deserializers,
-      blockDeserializers
-    ),
-    ...metadata
-  };
-}, BaseDocumentDeserializer = {
-  deserializeDocument: deserializeDocument$1,
-  deserializeHTML
-};
-function forEachMatchingField(documentId, document2, fields, callback) {
-  const applicable = fields.filter(
-    (field) => field.documentId === documentId || field.documentId === void 0 || field.documentId === null
-  );
-  for (const entry of applicable)
-    if (entry.fields)
-      for (const field of entry.fields) {
-        const { property, type } = field;
-        try {
-          const results = jsonpathPlus.JSONPath({
-            json: document2,
-            path: property,
-            resultType: "all",
-            flatten: !0,
-            wrap: !0
-          });
-          results && results.length > 0 && results.forEach(
-            (result) => {
-              type !== void 0 ? typeof result.value == "object" && result.value !== null && !Array.isArray(result.value) && result.value._type === type && callback(result) : callback(result);
-            }
-          );
-        } catch (error) {
-          console.warn(`Invalid JSONPath: ${property}`, error);
-        }
-      }
-}
-function deleteMatchingFields(documentId, document2, fields) {
-  const arrayRemovals = [];
-  forEachMatchingField(documentId, document2, fields, (result) => {
-    Array.isArray(result.parent) ? arrayRemovals.push({
-      parent: result.parent,
-      index: Number(result.parentProperty)
-    }) : delete result.parent[result.parentProperty];
-  }), arrayRemovals.sort((a, b) => b.index - a.index);
-  for (const { parent, index } of arrayRemovals)
-    parent.splice(index, 1);
-}
-function applyDocuments(documentId, sourceDocument, targetDocument, ignore, skip = [], dedupe = [], localeId) {
-  const mergedDocument = JSON.parse(JSON.stringify(sourceDocument)), clonedTarget = JSON.parse(JSON.stringify(targetDocument));
-  for (const [key, value] of Object.entries(clonedTarget))
-    mergedDocument[key] = value;
-  return forEachMatchingField(documentId, sourceDocument, ignore, (result) => {
-    JSONPointer__default.default.set(mergedDocument, result.pointer, result.value);
-  }), forEachMatchingField(documentId, sourceDocument, dedupe, (result) => {
-    JSONPointer__default.default.set(
-      mergedDocument,
-      result.pointer,
-      dedupeFieldValue(result.value, localeId)
-    );
-  }), deleteMatchingFields(documentId, mergedDocument, skip), mergedDocument;
-}
-function dedupeFieldValue(value, localeId) {
-  if (!localeId) return value;
-  if (typeof value == "string")
-    return appendLocaleSuffix(value, localeId);
-  if (value && typeof value == "object" && !Array.isArray(value) && typeof value.current == "string") {
-    const slug = value;
-    return {
-      ...slug,
-      current: appendLocaleSuffix(slug.current, localeId)
-    };
+    return `<div class="${fieldName}" data-type="array">${output.join("")}</div>`;
+  };
+  return {
+    serializeDocument: (doc, translationLevel = "document", baseLang = "en", stopTypes = defaultStopTypes, serializers = customSerializers) => {
+      const schema2 = getSchema(doc._type);
+      let filteredObj = {};
+      translationLevel === "field" ? filteredObj = languageObjectFieldFilter(doc, baseLang) : filteredObj = fieldFilter(doc, schema2?.fields ?? [], stopTypes);
+      const serializedFields = {};
+      for (const key in filteredObj) {
+        if (filteredObj.hasOwnProperty(key) === !1) continue;
+        const value = filteredObj[key];
+        if (typeof value == "string")
+          serializedFields[key] = value;
+        else if (Array.isArray(value))
+          serializedFields[key] = serializeArray(
+            value.filter(
+              (item) => typeof item == "string" || isRecord$1(item)
+            ),
+            key,
+            stopTypes,
+            serializers
+          );
+        else if (value && isRecord$1(value) && !stopTypes.find((stopType) => stopType == value?._type)) {
+          const serialized = serializeObject(
+            value,
+            stopTypes,
+            serializers
+          );
+          serializedFields[key] = `<div class="${key}" data-level='field'>${serialized}</div>`;
+        }
+      }
+      const rawHTMLBody = document.createElement("body");
+      rawHTMLBody.innerHTML = serializeObject(
+        serializedFields,
+        stopTypes,
+        serializers
+      );
+      const rawHTMLHead = document.createElement("head");
+      ["_id", "_type", "_rev"].forEach((field) => {
+        const metaEl = document.createElement("meta");
+        metaEl.setAttribute("name", field), metaEl.setAttribute("content", doc[field]), rawHTMLHead.appendChild(metaEl);
+      });
+      const versionMeta = document.createElement("meta");
+      versionMeta.setAttribute("name", "version"), versionMeta.setAttribute("content", "3"), rawHTMLHead.appendChild(versionMeta);
+      const rawHTML = document.createElement("html");
+      return rawHTML.appendChild(rawHTMLHead), rawHTML.appendChild(rawHTMLBody), {
+        name: doc._id,
+        content: rawHTML.outerHTML
+      };
+    },
+    fieldFilter,
+    languageObjectFieldFilter,
+    serializeArray,
+    serializeObject
+  };
+};
+function collapseToSourceLocale(value, sourceLocale) {
+  if (isInternationalizedArrayField(value)) {
+    const sourceItem = findLocaleItem(value, sourceLocale);
+    return sourceItem ? collapseToSourceLocale(sourceItem.value, sourceLocale) : void 0;
   }
-  return value;
-}
-function appendLocaleSuffix(value, localeId) {
-  if (!value) return value;
-  const suffix = createLocaleSuffix(localeId);
-  return !suffix || value.endsWith(suffix) ? value : `${value}${suffix}`;
-}
-function createLocaleSuffix(localeId) {
-  const normalized = localeId.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
-  return normalized ? `-${normalized}` : "";
-}
-function getPublishedId(documentId) {
-  return documentId.startsWith("drafts.") ? documentId.slice(7) : documentId;
-}
-function getDocumentPublishedId(document2) {
-  return getPublishedId(document2._id);
-}
-function dedupeDocumentsPreferDraft(documents) {
-  const byPublishedId = /* @__PURE__ */ new Map();
-  for (const document2 of documents) {
-    const publishedId = getDocumentPublishedId(document2);
-    (!byPublishedId.get(publishedId) || document2._id.startsWith("drafts.")) && byPublishedId.set(publishedId, document2);
+  if (Array.isArray(value))
+    return value.map((item) => collapseToSourceLocale(item, sourceLocale)).filter((item) => item !== void 0);
+  if (isRecord$4(value)) {
+    const collapsed = {};
+    for (const key of Object.keys(value)) {
+      const collapsedValue = collapseToSourceLocale(value[key], sourceLocale);
+      collapsedValue !== void 0 && (collapsed[key] = collapsedValue);
+    }
+    return collapsed;
   }
-  return Array.from(byPublishedId.values());
-}
-function createTranslationStatusKey(branchId, documentId, versionId, localeId) {
-  const publishedId = getPublishedId(documentId);
-  return branchId ? `${branchId}:${publishedId}:${versionId}:${localeId}` : `${publishedId}:${versionId}:${localeId}`;
-}
-function createStableTranslationKey(branchId, documentId, localeId) {
-  const publishedId = getPublishedId(documentId);
-  return branchId ? `${branchId}:${publishedId}:${localeId}` : `${publishedId}:${localeId}`;
+  return value;
 }
 function deserializeDocument(document2) {
   const deserializers = merge__default.default(
@@ -756,21 +1092,25 @@ function deserializeDocument(document2) {
     blockDeserializers
   );
 }
-function serializeDocument(document2, schema2, baseLanguage) {
+function serializeDocument(document2, schema2, baseLanguage, level = "document") {
   const stopTypes = [
     ...defaultStopTypes,
     ...pluginConfig.getAdditionalStopTypes()
   ], serializers = merge__default.default(
     customSerializers,
     pluginConfig.getAdditionalSerializers()
-  ), docToSerialize = stripIgnoredFields(
+  );
+  let docToSerialize = stripIgnoredFields(
     document2,
     pluginConfig.getIgnoreFields(),
     pluginConfig.getDedupeFields()
-  );
-  return BaseDocumentSerializer(schema2).serializeDocument(
+  ), innerLevel = level;
+  return level === "internationalizedArray" && (docToSerialize = collapseToSourceLocale(
+    docToSerialize,
+    baseLanguage
+  ), innerLevel = "document"), BaseDocumentSerializer(schema2).serializeDocument(
     docToSerialize,
-    "document",
+    innerLevel,
     baseLanguage,
     stopTypes,
     serializers
@@ -786,6 +1126,32 @@ function stripIgnoredFields(document2, ignoreFields, dedupeFields) {
     fieldsToStrip
   ), strippedDoc;
 }
+const documentAdapter = {
+  level: "document",
+  serialize: (document2, schema2, baseLanguage) => serializeDocument(document2, schema2, baseLanguage, "document"),
+  patch: (docInfo, deserialized, localeId, client, mergeWithTargetLocale) => documentLevelPatch(
+    docInfo,
+    deserialized,
+    localeId,
+    client,
+    pluginConfig.getLanguageField(),
+    mergeWithTargetLocale
+  )
+}, internationalizedArrayAdapter = {
+  level: "internationalizedArray",
+  serialize: (document2, schema2, baseLanguage) => serializeDocument(document2, schema2, baseLanguage, "internationalizedArray"),
+  patch: (docInfo, deserialized, localeId, client) => internationalizedArrayPatch(docInfo, deserialized, localeId, client)
+};
+function matchesFieldLevel(type) {
+  return type ? pluginConfig.getFieldLevelDocuments().some((filter2) => filter2.type === type) : !1;
+}
+function getTranslationStrategyForType(type) {
+  const level = pluginConfig.getTranslationLevel();
+  return level === "internationalizedArray" || level === "mixed" && matchesFieldLevel(type) ? internationalizedArrayAdapter : documentAdapter;
+}
+function getTranslationStrategy(document2) {
+  return getTranslationStrategyForType(document2._type);
+}
 async function uploadFiles(documents, secrets) {
   return overrideConfig(secrets), await gt.uploadSourceFiles(
     documents.map(({ info, serializedDocument }) => ({
@@ -820,283 +1186,79 @@ async function initProject(uploadResult, options, secrets) {
       if (status[0].status === "completed") {
         setupCompleted = !0;
         break;
-      }
-      if (status[0].status === "failed") {
-        setupFailedMessage = status[0].error?.message || "Unknown error";
-        break;
-      }
-      if (Date.now() - start > setupTimeoutMs) {
-        setupFailedMessage = "Timed out while waiting for setup generation";
-        break;
-      }
-      await new Promise((r) => setTimeout(r, pollInterval));
-    }
-    console.log(setupCompleted ? "Setup successfully completed" : `Setup ${setupFailedMessage ? "failed" : "timed out"} \u2014 proceeding without setup${setupFailedMessage ? ` (${setupFailedMessage})` : ""}`);
-  }
-  return !0;
-}
-async function createJobs(uploadResult, localeIds, secrets) {
-  return overrideConfig(secrets), await gt.enqueueFiles(uploadResult.uploadedFiles, {
-    sourceLocale: gt.sourceLocale || internal.libraryDefaultLocale,
-    targetLocales: localeIds
-  });
-}
-async function downloadTranslations(files, secrets, maxRetries = 3, retryDelay = 1e3) {
-  overrideConfig(secrets);
-  let retries = 0;
-  for (; retries <= maxRetries; )
-    try {
-      return (await gt.downloadFileBatch(
-        files.map((file) => ({
-          fileId: file.fileId,
-          branchId: file.branchId,
-          versionId: file.versionId,
-          locale: file.locale
-        }))
-      )).files || [];
-    } catch {
-      retries++, await new Promise((resolve) => setTimeout(resolve, retryDelay));
-    }
-  return [];
-}
-async function checkTranslationStatus(fileQueryData, downloadStatus, secrets) {
-  overrideConfig(secrets);
-  try {
-    const currentQueryData = fileQueryData.filter((item) => {
-      const statusKey = createTranslationStatusKey(
-        item.branchId,
-        item.fileId,
-        item.versionId,
-        item.locale
-      ), stableKey = createStableTranslationKey(
-        item.branchId,
-        item.fileId,
-        item.locale
-      );
-      return !downloadStatus.downloaded.has(statusKey) && !downloadStatus.downloaded.has(stableKey) && !downloadStatus.failed.has(statusKey) && !downloadStatus.failed.has(stableKey) && !downloadStatus.skipped.has(statusKey) && !downloadStatus.skipped.has(stableKey);
-    });
-    return currentQueryData.length === 0 ? !0 : ((await gt.queryFileData({
-      translatedFiles: currentQueryData
-    })).translatedFiles || []).filter(
-      (translation) => translation.completedAt
-    );
-  } catch (error) {
-    return console.error("Error checking translation status", error), [];
-  }
-}
-const findLatestDraft = (documentId, client) => {
-  const publishedId = getPublishedId(documentId), query = "*[_id == $id || _id == $draftId]", params = { id: publishedId, draftId: `drafts.${publishedId}` };
-  return client.fetch(query, params).then(
-    (docs) => docs.find((doc) => doc._id.startsWith("drafts.")) ?? docs[0]
-  );
-}, findDocumentAtRevision = async (documentId, rev, client) => {
-  const baseUrl = `/data/history/${client.config().dataset}/documents/${documentId}?revision=${rev}`, url = client.getUrl(baseUrl);
-  return await fetch(url, { credentials: "include" }).then((req) => req.json()).then((req) => req.documents && req.documents.length ? req.documents[0] : null);
-};
-function randomKey() {
-  return Math.random().toString(36).slice(2, 10);
-}
-async function createI18nDocAndPatchMetadata(sourceDocument, translatedDoc, localeId, client, translationMetadata, sourceDocumentId, languageField = "language") {
-  const publishedSourceDocumentId = getPublishedId(sourceDocumentId);
-  translatedDoc[languageField] = localeId;
-  const existingLocaleKey = translationMetadata.translations.find(
-    (translation) => translation.language === localeId
-  ), operation = existingLocaleKey ? "replace" : "after", location = existingLocaleKey ? `translations[language == "${localeId}"]` : "translations[-1]", { _updatedAt, _createdAt, ...rest } = translatedDoc, appliedDocument = applyDocuments(
-    publishedSourceDocumentId,
-    sourceDocument,
-    rest,
-    pluginConfig.getIgnoreFields(),
-    pluginConfig.getSkipFields(),
-    pluginConfig.getDedupeFields(),
-    localeId
-  ), isSingleton = pluginConfig.getSingletons().includes(publishedSourceDocumentId);
-  let createDocumentPromise;
-  if (isSingleton) {
-    const translatedDocId = pluginConfig.getSingletonMapping()(
-      publishedSourceDocumentId,
-      localeId
-    );
-    createDocumentPromise = client.create({
-      ...appliedDocument,
-      _type: rest._type,
-      _id: `drafts.${translatedDocId}`
-    });
-  } else
-    createDocumentPromise = client.create({
-      ...appliedDocument,
-      _type: rest._type,
-      _id: "drafts."
-    });
-  const doc = await createDocumentPromise, _ref = getPublishedId(doc._id);
-  await client.transaction().patch(
-    translationMetadata._id,
-    (p) => p.insert(operation, location, [
-      {
-        _key: randomKey(),
-        language: localeId,
-        _type: "internationalizedArrayReferenceValue",
-        value: {
-          _type: "reference",
-          _ref,
-          _weak: !0,
-          _strengthenOnPublish: {
-            type: doc._type
-          }
-        }
-      }
-    ])
-  ).commit();
-}
-const getOrCreateTranslationMetadata = async (documentId, baseDocument, client, baseLanguage) => {
-  const publishedId = getPublishedId(documentId), existingMetadata = await client.fetch(
-    `*[
-        _type == 'translation.metadata' &&
-        translations[language == $baseLanguage][0].value._ref == $id
-      ][0]`,
-    { baseLanguage, id: publishedId }
-  );
-  if (existingMetadata)
-    return existingMetadata;
-  const baseLangEntry = {
-    _key: randomKey(),
-    language: baseLanguage,
-    _type: "internationalizedArrayReferenceValue",
-    value: {
-      _type: "reference",
-      _ref: getPublishedId(baseDocument._id)
-    }
-  };
-  baseDocument._id.startsWith("drafts.") && (baseLangEntry.value = {
-    ...baseLangEntry.value,
-    _weak: !0,
-    //this should reflect doc i18n config when this
-    //plugin is able to take that as a config option
-    _strengthenOnPublish: {
-      type: baseDocument._type
+      }
+      if (status[0].status === "failed") {
+        setupFailedMessage = status[0].error?.message || "Unknown error";
+        break;
+      }
+      if (Date.now() - start > setupTimeoutMs) {
+        setupFailedMessage = "Timed out while waiting for setup generation";
+        break;
+      }
+      await new Promise((r) => setTimeout(r, pollInterval));
     }
-  });
-  try {
-    return await client.createIfNotExists({
-      _id: `translation.metadata.${publishedId}`,
-      _type: "translation.metadata",
-      translations: [baseLangEntry]
-    });
-  } catch (error) {
-    const metadata = await client.fetch(
-      `*[
-          _type == 'translation.metadata' &&
-          translations[language == $baseLanguage][0].value._ref == $id
-        ][0]`,
-      { baseLanguage, id: publishedId }
-    );
-    if (metadata)
-      return metadata;
-    throw error;
+    console.log(setupCompleted ? "Setup successfully completed" : `Setup ${setupFailedMessage ? "failed" : "timed out"} \u2014 proceeding without setup${setupFailedMessage ? ` (${setupFailedMessage})` : ""}`);
   }
-}, SYSTEM_FIELDS = ["_id", "_rev", "_updatedAt", "language"], isSystemField = (field) => SYSTEM_FIELDS.includes(field);
-async function patchI18nDoc(sourceDocumentId, i18nDocId, sourceDocument, mergedDocument, translatedFields, client, existingDocument) {
-  const cleanedMerge = {};
-  Object.entries(mergedDocument).forEach(([key, value]) => {
-    key in translatedFields && //don't overwrite any existing system values on the i18n doc
-    !isSystemField(key) && (cleanedMerge[key] = value);
-  });
-  const cleanedSourceDocument = {};
-  Object.entries(sourceDocument).forEach(([key, value]) => {
-    isSystemField(key) || (cleanedSourceDocument[key] = value);
+  return !0;
+}
+async function createJobs(uploadResult, localeIds, secrets) {
+  return overrideConfig(secrets), await gt.enqueueFiles(uploadResult.uploadedFiles, {
+    sourceLocale: gt.sourceLocale || internal.libraryDefaultLocale,
+    targetLocales: localeIds
   });
-  const appliedDocument = applyDocuments(
-    sourceDocumentId,
-    cleanedSourceDocument,
-    cleanedMerge,
-    pluginConfig.getIgnoreFields(),
-    pluginConfig.getSkipFields()
-  ), dedupeFields = pluginConfig.getDedupeFields();
-  deleteMatchingFields(sourceDocumentId, appliedDocument, dedupeFields), existingDocument && forEachMatchingField(
-    sourceDocumentId,
-    existingDocument,
-    dedupeFields,
-    (result) => {
-      JSONPointer__default.default.set(appliedDocument, result.pointer, result.value);
+}
+async function downloadTranslations(files, secrets, maxRetries = 3, retryDelay = 1e3) {
+  overrideConfig(secrets);
+  let retries = 0;
+  for (; retries <= maxRetries; )
+    try {
+      return (await gt.downloadFileBatch(
+        files.map((file) => ({
+          fileId: file.fileId,
+          branchId: file.branchId,
+          versionId: file.versionId,
+          locale: file.locale
+        }))
+      )).files || [];
+    } catch {
+      retries++, await new Promise((resolve) => setTimeout(resolve, retryDelay));
     }
-  ), await client.patch(i18nDocId, { set: appliedDocument }).commit();
+  return [];
 }
-const documentLevelPatch = async (docInfo, translatedFields, localeId, client, languageField = "language", mergeWithTargetLocale = !1) => {
-  const baseLanguage = pluginConfig.getSourceLocale();
-  let baseDoc = null, i18nDoc = null;
-  docInfo.documentId && docInfo.versionId && (baseDoc = await findDocumentAtRevision(
-    docInfo.documentId,
-    docInfo.versionId,
-    client
-  )), baseDoc || (baseDoc = await findLatestDraft(docInfo.documentId, client));
-  const i18nDocId = (await getOrCreateTranslationMetadata(
-    docInfo.documentId,
-    baseDoc,
-    client,
-    baseLanguage
-  )).translations.find(
-    (translation) => translation.language === localeId
-  )?.value?._ref;
-  i18nDocId && (i18nDoc = await findLatestDraft(i18nDocId, client)), mergeWithTargetLocale && i18nDoc ? baseDoc = i18nDoc : docInfo.documentId && docInfo.versionId && (baseDoc = await findDocumentAtRevision(
-    docInfo.documentId,
-    docInfo.versionId,
-    client
-  )), baseDoc || (baseDoc = await findLatestDraft(docInfo.documentId, client));
-  const merged = BaseDocumentMerger.documentLevelMerge(
-    translatedFields,
-    baseDoc
-  );
-  if (i18nDoc)
-    await patchI18nDoc(
-      docInfo.documentId,
-      i18nDoc._id,
-      baseDoc,
-      merged,
-      translatedFields,
-      client,
-      i18nDoc
-    );
-  else {
-    const freshTranslationMetadata = await getOrCreateTranslationMetadata(
-      docInfo.documentId,
-      baseDoc,
-      client,
-      baseLanguage
-    ), freshI18nDocId = freshTranslationMetadata.translations.find(
-      (translation) => translation.language === localeId
-    )?.value?._ref;
-    if (freshI18nDocId) {
-      const freshI18nDoc = await findLatestDraft(freshI18nDocId, client);
-      await patchI18nDoc(
-        docInfo.documentId,
-        freshI18nDoc._id,
-        baseDoc,
-        merged,
-        translatedFields,
-        client,
-        freshI18nDoc
+async function checkTranslationStatus(fileQueryData, downloadStatus, secrets) {
+  overrideConfig(secrets);
+  try {
+    const currentQueryData = fileQueryData.filter((item) => {
+      const statusKey = createTranslationStatusKey(
+        item.branchId,
+        item.fileId,
+        item.versionId,
+        item.locale
+      ), stableKey = createStableTranslationKey(
+        item.branchId,
+        item.fileId,
+        item.locale
       );
-      return;
-    }
-    await createI18nDocAndPatchMetadata(
-      baseDoc,
-      merged,
-      localeId,
-      client,
-      freshTranslationMetadata,
-      docInfo.documentId,
-      languageField
+      return !downloadStatus.downloaded.has(statusKey) && !downloadStatus.downloaded.has(stableKey) && !downloadStatus.failed.has(statusKey) && !downloadStatus.failed.has(stableKey) && !downloadStatus.skipped.has(statusKey) && !downloadStatus.skipped.has(stableKey);
+    });
+    return currentQueryData.length === 0 ? !0 : ((await gt.queryFileData({
+      translatedFiles: currentQueryData
+    })).translatedFiles || []).filter(
+      (translation) => translation.completedAt
     );
+  } catch (error) {
+    return console.error("Error checking translation status", error), [];
   }
-};
+}
 async function importDocument(docInfo, localeId, document2, context, mergeWithTargetLocale = !1) {
   const { client } = context, deserialized = deserializeDocument(document2);
-  return documentLevelPatch(
+  return getTranslationStrategyForType(
+    deserialized._type
+  ).patch(
     docInfo,
-    // versionId is not used here, since we just use the _rev id in the deserialized HTML itself
     deserialized,
     localeId,
     client,
-    pluginConfig.getLanguageField(),
     mergeWithTargetLocale
   );
 }
@@ -1224,11 +1386,13 @@ async function processImportBatch(items, options = {}) {
       ), item.key),
       {
         ...options,
-        getConcurrencyKey: (item) => createStableTranslationKey(
-          void 0,
-          item.docInfo.documentId,
-          item.locale
-        ),
+        // Serialize all locales of the same document when imports may patch the
+        // source document in place: internationalized-array imports do a
+        // read-merge-set, so concurrent locale imports would clobber each other
+        // (last write wins). Document-level imports write to separate per-locale
+        // documents and stay parallel. In 'mixed' mode the per-document strategy
+        // is only known after deserialization, so serialize conservatively.
+        getConcurrencyKey: (item) => pluginConfig.getTranslationLevel() === "document" ? void 0 : getPublishedId(item.docInfo.documentId),
         onItemSuccess: (item, key) => {
           successfulImports.push(key), options.onItemSuccess?.(item, key);
         },
@@ -1324,7 +1488,34 @@ const getLocales = async (_secrets) => pluginConfig.getLocales().map((locale) =>
   localeId: locale,
   description: gt.getLocaleProperties(locale).name,
   enabled: !0
-})), TranslationsContext = o.createContext(null), useTranslations = () => {
+})), TranslationsContext = o.createContext(null), getUploadedVersionsStorageKey = (projectId, dataset) => `gt-sanity:uploadedVersions:${projectId ?? ""}:${dataset ?? ""}`;
+function readUploadedVersions(storageKey) {
+  try {
+    const raw = window.sessionStorage.getItem(storageKey);
+    if (!raw) return /* @__PURE__ */ new Map();
+    const parsed = JSON.parse(raw);
+    return isPlainRecord(parsed) ? new Map(
+      Object.entries(parsed).filter(
+        (entry) => typeof entry[1] == "string"
+      )
+    ) : /* @__PURE__ */ new Map();
+  } catch {
+    return /* @__PURE__ */ new Map();
+  }
+}
+function writeUploadedVersions(storageKey, versions) {
+  try {
+    window.sessionStorage.setItem(
+      storageKey,
+      JSON.stringify(Object.fromEntries(versions))
+    );
+  } catch {
+  }
+}
+function isPlainRecord(value) {
+  return typeof value == "object" && value !== null && !Array.isArray(value);
+}
+const useTranslations = () => {
   const context = o.useContext(TranslationsContext);
   if (!context)
     throw new Error("useTranslations must be used within TranslationsProvider");
@@ -1345,13 +1536,21 @@ const getLocales = async (_secrets) => pluginConfig.getLocales().map((locale) =>
     downloaded: /* @__PURE__ */ new Set(),
     failed: /* @__PURE__ */ new Set(),
     skipped: /* @__PURE__ */ new Set()
-  }), downloadStatusRef = o.useRef(downloadStatus), [translationStatuses, setTranslationStatuses] = o.useState(/* @__PURE__ */ new Map()), [isRefreshing, setIsRefreshing] = o.useState(!1), client = useClient(), schema2 = sanity.useSchema(), translationContext = { client, schema: schema2 }, toast = ui.useToast(), { loading: loadingSecrets, secrets } = useSecrets(
+  }), downloadStatusRef = o.useRef(downloadStatus), [translationStatuses, setTranslationStatuses] = o.useState(/* @__PURE__ */ new Map()), [isRefreshing, setIsRefreshing] = o.useState(!1), client = useClient(), { projectId, dataset } = client.config(), uploadedVersionsStorageKey = getUploadedVersionsStorageKey(
+    projectId,
+    dataset
+  ), [uploadedVersions, setUploadedVersions] = o.useState(
+    () => readUploadedVersions(uploadedVersionsStorageKey)
+  ), schema2 = sanity.useSchema(), translationContext = { client, schema: schema2 }, toast = ui.useToast(), { loading: loadingSecrets, secrets } = useSecrets(
     pluginConfig.getSecretsNamespace()
   ), [branchId, setBranchId] = o.useState(void 0);
   o.useEffect(() => {
     downloadStatusRef.current = downloadStatus;
   }, [downloadStatus]);
-  const fetchDocuments = o.useCallback(async () => {
+  const getVersionId = o.useCallback(
+    (document2) => uploadedVersions.get(getDocumentPublishedId(document2)) ?? document2._rev,
+    [uploadedVersions]
+  ), fetchDocuments = o.useCallback(async () => {
     setLoadingDocuments(!0);
     try {
       if (singleDocument) {
@@ -1423,7 +1622,7 @@ const getLocales = async (_secrets) => pluginConfig.getLocales().map((locale) =>
         const availableLocaleIds = locales.filter((locale) => locale.enabled !== !1).map((locale) => locale.localeId), transformedDocuments = documents.map((doc) => {
           const { [pluginConfig.getLanguageField()]: _2, ...cleanDoc } = doc, baseLanguage = pluginConfig.getSourceLocale();
           try {
-            const serialized = serializeDocument(
+            const serialized = getTranslationStrategy(doc).serialize(
               cleanDoc,
               schema2,
               baseLanguage
@@ -1440,7 +1639,11 @@ const getLocales = async (_secrets) => pluginConfig.getLocales().map((locale) =>
           }
           return null;
         }).filter((doc) => doc !== null), uploadResult = await uploadFiles(transformedDocuments, secrets);
-        await initProject(uploadResult, { timeout: 600 }, secrets), await createJobs(uploadResult, availableLocaleIds, secrets), toast.push({
+        await initProject(uploadResult, { timeout: 600 }, secrets), await createJobs(uploadResult, availableLocaleIds, secrets);
+        const nextUploadedVersions = new Map(uploadedVersions);
+        for (const { info } of transformedDocuments)
+          info.versionId && nextUploadedVersions.set(info.documentId, info.versionId);
+        writeUploadedVersions(uploadedVersionsStorageKey, nextUploadedVersions), setUploadedVersions(nextUploadedVersions), toast.push({
           title: `Translation tasks created for ${documents.length} documents`,
           status: "success",
           closable: !0
@@ -1455,7 +1658,14 @@ const getLocales = async (_secrets) => pluginConfig.getLocales().map((locale) =>
         setIsBusy(!1);
       }
     }
-  }, [secrets, documents, locales, schema2]), handleImportAll = o.useCallback(async () => {
+  }, [
+    secrets,
+    documents,
+    locales,
+    schema2,
+    uploadedVersions,
+    uploadedVersionsStorageKey
+  ]), handleImportAll = o.useCallback(async () => {
     if (!(!secrets || documents.length === 0 || !branchId)) {
       setIsBusy(!0);
       try {
@@ -1641,7 +1851,7 @@ const getLocales = async (_secrets) => pluginConfig.getLocales().map((locale) =>
           for (const localeId of availableLocaleIds) {
             const documentId = getDocumentPublishedId(doc);
             fileQueryData.push({
-              versionId: doc._rev,
+              versionId: getVersionId(doc),
               fileId: documentId,
               branchId,
               locale: localeId
@@ -1656,7 +1866,7 @@ const getLocales = async (_secrets) => pluginConfig.getLocales().map((locale) =>
           const newStatuses = /* @__PURE__ */ new Map();
           for (const doc of documents)
             for (const localeId of availableLocaleIds) {
-              const documentId = getDocumentPublishedId(doc), versionId = doc._rev, key = createTranslationStatusKey(
+              const documentId = getDocumentPublishedId(doc), versionId = getVersionId(doc), key = createTranslationStatusKey(
                 branchId,
                 documentId,
                 versionId,
@@ -1699,7 +1909,7 @@ const getLocales = async (_secrets) => pluginConfig.getLocales().map((locale) =>
         setIsRefreshing(!1);
       }
     }
-  }, [secrets, documents, locales, branchId]), handleImportDocument = o.useCallback(
+  }, [secrets, documents, locales, branchId, getVersionId]), handleImportDocument = o.useCallback(
     async (documentId, versionId, localeId) => {
       if (!secrets) return;
       const key = createTranslationStatusKey(
@@ -1961,6 +2171,7 @@ const getLocales = async (_secrets) => pluginConfig.getLocales().map((locale) =>
     loadingSecrets,
     secrets,
     branchId,
+    getVersionId,
     // Actions
     setLocales,
     setAutoRefresh,
@@ -3247,7 +3458,8 @@ const WrapText = dt(ui.Box)`
     autoPatchReferences,
     setAutoPatchReferences,
     autoPublish,
-    setAutoPublish
+    setAutoPublish,
+    getVersionId
   } = useTranslations(), [isImporting, setIsImporting] = o.useState(!1), [isPublishing, setIsPublishing] = o.useState(!1), toast = ui.useToast(), document2 = documents[0], currentDocumentLanguage = o.useMemo(() => {
     if (!document2) return null;
     const languageField = pluginConfig.getLanguageField();
@@ -3257,15 +3469,15 @@ const WrapText = dt(ui.Box)`
     return locales.filter(
       (locale) => locale.enabled !== !1 && locale.localeId !== sourceLocale
     );
-  }, [locales]), documentId = o.useMemo(() => document2 ? getDocumentPublishedId(document2) : null, [document2]), handleImportTranslations = o.useCallback(
+  }, [locales]), documentId = o.useMemo(() => document2 ? getDocumentPublishedId(document2) : null, [document2]), versionId = o.useMemo(() => document2 ? getVersionId(document2) : null, [document2, getVersionId]), handleImportTranslations = o.useCallback(
     async (options = {}) => {
       const { autoOnly = !1 } = options;
-      if (isImporting || !documentId || autoOnly && !autoImport) return;
+      if (isImporting || !documentId || !versionId || autoOnly && !autoImport) return;
       const readyTranslations = availableLocales.filter((locale) => {
         const key = createTranslationStatusKey(
           branchId,
           documentId,
-          document2._rev,
+          versionId,
           locale.localeId
         );
         return translationStatuses.get(key)?.isReady && !importedTranslations.has(key);
@@ -3273,11 +3485,9 @@ const WrapText = dt(ui.Box)`
       if (readyTranslations.length !== 0) {
         setIsImporting(!0);
         try {
-          await Promise.all(
-            readyTranslations.map(
-              (locale) => handleImportDocument(documentId, document2._rev, locale.localeId)
-            )
-          ), autoPatchReferences && await handlePatchDocumentReferences(), autoPublish && await handlePublishAllTranslations();
+          for (const locale of readyTranslations)
+            await handleImportDocument(documentId, versionId, locale.localeId);
+          autoPatchReferences && await handlePatchDocumentReferences(), autoPublish && await handlePublishAllTranslations();
         } finally {
           setIsImporting(!1);
         }
@@ -3287,6 +3497,7 @@ const WrapText = dt(ui.Box)`
       autoImport,
       isImporting,
       documentId,
+      versionId,
       availableLocales,
       translationStatuses,
       importedTranslations,
@@ -3361,7 +3572,7 @@ const WrapText = dt(ui.Box)`
         }
       )
     ] }),
-    documentId && availableLocales.length > 0 && /* @__PURE__ */ jsxRuntime.jsxs(ui.Stack, { space: 4, children: [
+    documentId && versionId && availableLocales.length > 0 && /* @__PURE__ */ jsxRuntime.jsxs(ui.Stack, { space: 4, children: [
       /* @__PURE__ */ jsxRuntime.jsxs(ui.Flex, { align: "center", justify: "space-between", children: [
         /* @__PURE__ */ jsxRuntime.jsx(ui.Text, { as: "h2", weight: "semibold", size: 2, children: "Translation Status" }),
         /* @__PURE__ */ jsxRuntime.jsxs(ui.Flex, { gap: 3, align: "center", children: [
@@ -3391,7 +3602,7 @@ const WrapText = dt(ui.Box)`
         const key = createTranslationStatusKey(
           branchId,
           documentId,
-          document2._rev,
+          versionId,
           locale.localeId
         ), status = translationStatuses.get(key), progress = status?.progress || 0, isImported = importedTranslations.has(key);
         return /* @__PURE__ */ jsxRuntime.jsx(
@@ -3403,7 +3614,7 @@ const WrapText = dt(ui.Box)`
             importFile: async () => {
               !isImported && status?.isReady && await handleImportDocument(
                 documentId,
-                document2._rev,
+                versionId,
                 locale.localeId
               );
             }
@@ -3426,7 +3637,7 @@ const WrapText = dt(ui.Box)`
                   const key = createTranslationStatusKey(
                     branchId,
                     documentId,
-                    document2._rev,
+                    versionId,
                     locale.localeId
                   );
                   return !translationStatuses.get(key)?.isReady || importedTranslations.has(key);
@@ -3453,7 +3664,7 @@ const WrapText = dt(ui.Box)`
               const key = createTranslationStatusKey(
                 branchId,
                 documentId,
-                document2._rev,
+                versionId,
                 locale.localeId
               );
               return importedTranslations.has(key);
@@ -3463,7 +3674,7 @@ const WrapText = dt(ui.Box)`
               const key = createTranslationStatusKey(
                 branchId,
                 documentId,
-                document2._rev,
+                versionId,
                 locale.localeId
               );
               return translationStatuses.get(key)?.isReady;
@@ -3551,9 +3762,6 @@ const WrapText = dt(ui.Box)`
     /* @__PURE__ */ jsxRuntime.jsx("code", { children: pluginConfig.getSourceLocale() }),
     " documents."
   ] }) });
-}, TranslationTab = (props) => {
-  const { displayed } = props.document;
-  return /* @__PURE__ */ jsxRuntime.jsx(BaseTranslationWrapper, { showContainer: !1, children: /* @__PURE__ */ jsxRuntime.jsx(TranslationsProvider, { singleDocument: displayed, children: /* @__PURE__ */ jsxRuntime.jsx(TranslationView, {}) }) });
 }, translateAction = (props) => {
   const [dialogOpen, setDialogOpen] = o.useState(!1), document2 = props.draft || props.published;
   return {
@@ -3568,7 +3776,228 @@ const WrapText = dt(ui.Box)`
       content: /* @__PURE__ */ jsxRuntime.jsx(BaseTranslationWrapper, { showContainer: !1, children: /* @__PURE__ */ jsxRuntime.jsx(TranslationsProvider, { singleDocument: document2, children: /* @__PURE__ */ jsxRuntime.jsx(TranslationView, {}) }) })
     } : null
   };
-}, TranslationsTable = () => {
+};
+function readGTOptions(schemaType) {
+  return schemaType?.options?.gtInternationalizedArray;
+}
+function toneFromValidation(validation) {
+  if (validation?.length) {
+    if (validation.some((marker) => marker.level === "error")) return "critical";
+    if (validation.some((marker) => marker.level === "warning")) return "caution";
+  }
+}
+function RemoveLocaleButton(props) {
+  const { isSource, readOnly, onRemove } = props, button = (
+    // The span keeps the tooltip working when the button is disabled
+    // (disabled buttons don't emit pointer events).
+    /* @__PURE__ */ jsxRuntime.jsx("span", { style: { paddingBottom: "2px" }, children: /* @__PURE__ */ jsxRuntime.jsx(
+      ui.Button,
+      {
+        mode: "bleed",
+        icon: icons.RemoveCircleIcon,
+        tone: "critical",
+        disabled: readOnly || isSource,
+        onClick: onRemove
+      }
+    ) })
+  );
+  return isSource ? /* @__PURE__ */ jsxRuntime.jsx(
+    ui.Tooltip,
+    {
+      animate: !0,
+      portal: !0,
+      placement: "top",
+      fallbackPlacements: ["right", "left"],
+      content: /* @__PURE__ */ jsxRuntime.jsx(ui.Text, { muted: !0, size: 1, children: "Can't remove the source language" }),
+      children: button
+    }
+  ) : button;
+}
+function InternationalizedValueItem(props) {
+  const { inputProps, parentSchemaType, schemaType, validation } = props, value = props.value, { onChange } = inputProps, gtOptions = readGTOptions(schemaType) ?? readGTOptions(parentSchemaType), language = value?.language, languageLabel = language ? gtOptions?.titles?.[language] ?? language : "Unknown language", isSource = !!language && language === gtOptions?.sourceLocale, wrappedOnChange = o.useCallback(
+    (patch) => {
+      if (!Array.isArray(patch)) {
+        onChange(patch);
+        return;
+      }
+      const currentValue = value?.value;
+      if (!((currentValue == null || Array.isArray(currentValue) && currentValue.length === 0) && patch.some(
+        (p) => p.type === "insert" && Array.isArray(p.path) && p.path.length > 0 && (p.path[0] === "value" || typeof p.path[0] == "number")
+      ))) {
+        onChange(patch);
+        return;
+      }
+      const rerooted = patch.map(
+        (p) => p.type === "insert" && Array.isArray(p.path) && p.path[0] !== "value" ? { ...p, path: ["value", ...p.path] } : p
+      );
+      onChange(
+        currentValue === void 0 ? [sanity.setIfMissing([], ["value"]), ...rerooted] : rerooted
+      );
+    },
+    [onChange, value?.value]
+  ), members = o.useMemo(
+    () => inputProps.members.filter(
+      (member) => member.kind === "field" && member.name === "value"
+    ).map((member) => ({
+      ...member,
+      field: {
+        ...member.field,
+        schemaType: {
+          ...member.field.schemaType,
+          title: /* @__PURE__ */ jsxRuntime.jsx(ui.Label, { muted: !0, size: 1, children: languageLabel })
+        }
+      }
+    })),
+    [inputProps.members, languageLabel]
+  ), handleRemove = o.useCallback(() => {
+    onChange(sanity.unset());
+  }, [onChange]);
+  return /* @__PURE__ */ jsxRuntime.jsx(ui.Card, { paddingTop: 2, tone: toneFromValidation(validation), children: /* @__PURE__ */ jsxRuntime.jsxs(ui.Flex, { align: "flex-end", gap: 2, children: [
+    /* @__PURE__ */ jsxRuntime.jsx(ui.Box, { flex: 1, children: inputProps.renderInput({
+      ...inputProps,
+      members,
+      onChange: wrappedOnChange
+      // renderInput's parameter is typed as the base InputProps, which
+      // doesn't know about object members.
+    }) }),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      RemoveLocaleButton,
+      {
+        isSource,
+        readOnly: !!inputProps.readOnly,
+        onRemove: handleRemove
+      }
+    )
+  ] }) });
+}
+function InternationalizedArrayInput(props) {
+  const { members, schemaType, value, readOnly, onItemAppend } = props, gtOptions = readGTOptions(schemaType), itemType = schemaType.of[0]?.name, handleAdd = o.useCallback(
+    (language) => {
+      const item = { _key: randomKey(), _type: itemType, language };
+      onItemAppend(item);
+    },
+    [onItemAppend, itemType]
+  );
+  if (!gtOptions)
+    return props.renderDefault(props);
+  const allLocales = [gtOptions.sourceLocale, ...gtOptions.locales], existing = new Set(
+    (value ?? []).map((item) => item.language).filter(Boolean)
+  ), missing = allLocales.filter((locale) => !existing.has(locale));
+  return /* @__PURE__ */ jsxRuntime.jsxs(ui.Stack, { space: 3, children: [
+    members.length > 0 ? /* @__PURE__ */ jsxRuntime.jsx(ui.Stack, { space: 2, children: members.map(
+      (member) => member.kind === "item" ? /* @__PURE__ */ jsxRuntime.jsx(sanity.ArrayOfObjectsItem, { ...props, member }, member.key) : /* @__PURE__ */ jsxRuntime.jsx(sanity.MemberItemError, { member }, member.key)
+    ) }) : /* @__PURE__ */ jsxRuntime.jsx(ui.Card, { border: !0, tone: "transparent", padding: 3, radius: 2, children: /* @__PURE__ */ jsxRuntime.jsx(ui.Text, { size: 1, muted: !0, children: "This internationalized field currently has no translations." }) }),
+    !readOnly && missing.length > 0 ? /* @__PURE__ */ jsxRuntime.jsx(ui.Grid, { columns: Math.min(missing.length, 4), gap: 1, children: missing.map((locale) => /* @__PURE__ */ jsxRuntime.jsx(
+      ui.Button,
+      {
+        icon: icons.AddIcon,
+        mode: "ghost",
+        text: gtOptions.titles?.[locale] ?? locale,
+        onClick: () => handleAdd(locale)
+      },
+      locale
+    )) }) : null
+  ] });
+}
+const DEFAULT_TYPE_PREFIX = "internationalizedArray";
+function resolveComponents(overrides) {
+  const input = overrides?.input === !1 ? void 0 : overrides?.input ?? InternationalizedArrayInput, item = overrides?.item === !1 ? void 0 : overrides?.item ?? InternationalizedValueItem, defaultField = input === InternationalizedArrayInput ? (
+    // Reset the field level so inline per-locale inputs don't inherit
+    // nested-object indentation.
+    ((fieldProps) => fieldProps.renderDefault({ ...fieldProps, level: 0 }))
+  ) : void 0, field = overrides?.field === !1 ? void 0 : overrides?.field ?? defaultField;
+  return { input, item, field };
+}
+function capitalize(value) {
+  return value.charAt(0).toUpperCase() + value.slice(1);
+}
+function fieldTypeName(fieldType) {
+  return typeof fieldType == "string" ? fieldType : fieldType.name;
+}
+function valueField(fieldType) {
+  if (fieldType === "string" || fieldType === "text")
+    return { name: "value", type: fieldType, title: "Value" };
+  if (fieldType === "block")
+    return {
+      name: "value",
+      type: "array",
+      title: "Value",
+      of: [{ type: "block" }]
+    };
+  const { name: _name, ...rest } = fieldType;
+  return { name: "value", title: "Value", ...rest };
+}
+function makeLanguageTitle(options) {
+  const { languageTitles, getLanguageTitle, sourceLocale } = options;
+  return (locale) => getLanguageTitle?.(locale) ?? languageTitles?.[locale] ?? generaltranslation.getLocaleProperties(locale, sourceLocale).name ?? locale;
+}
+function buildTypesForPrefix(prefix2, options) {
+  const { sourceLocale, locales, fieldTypes } = options, languageTitle = makeLanguageTitle(options), components = resolveComponents(options.components);
+  return fieldTypes.map((fieldType) => {
+    const typeName = `${prefix2}${capitalize(fieldTypeName(fieldType))}`, valueTypeName = `${typeName}Value`, gtInternationalizedArray = {
+      sourceLocale,
+      locales,
+      titles: Object.fromEntries(
+        [sourceLocale, ...locales].map((locale) => [
+          locale,
+          languageTitle(locale)
+        ])
+      )
+    }, valueObject = {
+      type: "object",
+      name: valueTypeName,
+      ...components.item ? { components: { item: components.item } } : {},
+      fields: [
+        {
+          name: "language",
+          type: "string",
+          title: "Language",
+          readOnly: !0,
+          // GT's inline item shows the locale as the value field's label;
+          // with a custom or detached item, keep the field visible so the
+          // locale is still discoverable in default/dialog rendering.
+          hidden: components.item === InternationalizedValueItem
+        },
+        valueField(fieldType)
+      ],
+      options: { gtInternationalizedArray },
+      preview: {
+        select: { language: "language", value: "value" },
+        prepare(selection) {
+          const localeLabel = selection.language ? languageTitle(selection.language) : "Unknown";
+          return {
+            title: typeof selection.value == "string" ? selection.value : localeLabel,
+            subtitle: localeLabel
+          };
+        }
+      }
+    }, arrayComponents = {
+      ...components.input ? { input: components.input } : {},
+      ...components.field ? { field: components.field } : {}
+    };
+    return {
+      name: typeName,
+      type: "array",
+      ...Object.keys(arrayComponents).length ? { components: arrayComponents } : {},
+      of: [valueObject],
+      options: { gtInternationalizedArray }
+    };
+  });
+}
+function createInternationalizedArrayTypes(options) {
+  const prefix2 = options.typePrefix ?? DEFAULT_TYPE_PREFIX, includeCompatibilityTypes = options.includeCompatibilityTypes ?? !0, types = buildTypesForPrefix(prefix2, options);
+  return includeCompatibilityTypes && prefix2 !== DEFAULT_TYPE_PREFIX && types.push(...buildTypesForPrefix(DEFAULT_TYPE_PREFIX, options)), types;
+}
+function resolveFieldLevelConfig(config) {
+  return {
+    enabled: !1,
+    fieldTypes: ["string", "text"],
+    typePrefix: DEFAULT_TYPE_PREFIX,
+    includeCompatibilityTypes: !0,
+    ...config
+  };
+}
+const TranslationsTable = () => {
   const {
     documents,
     locales,
@@ -3577,7 +4006,8 @@ const WrapText = dt(ui.Box)`
     downloadStatus,
     importedTranslations,
     handleImportDocument,
-    branchId
+    branchId,
+    getVersionId
   } = useTranslations();
   return loadingDocuments ? /* @__PURE__ */ jsxRuntime.jsx(ui.Flex, { align: "center", justify: "center", padding: 4, children: /* @__PURE__ */ jsxRuntime.jsx(ui.Spinner, {}) }) : /* @__PURE__ */ jsxRuntime.jsx(ui.Box, { style: { maxHeight: "60vh", overflowY: "auto" }, children: /* @__PURE__ */ jsxRuntime.jsx(ui.Stack, { space: 2, children: documents.map((document2) => /* @__PURE__ */ jsxRuntime.jsx(ui.Card, { shadow: 1, padding: 3, children: /* @__PURE__ */ jsxRuntime.jsxs(ui.Stack, { space: 3, children: [
     /* @__PURE__ */ jsxRuntime.jsx(ui.Flex, { justify: "space-between", align: "flex-start", children: /* @__PURE__ */ jsxRuntime.jsxs(ui.Box, { flex: 1, children: [
@@ -3585,10 +4015,10 @@ const WrapText = dt(ui.Box)`
       /* @__PURE__ */ jsxRuntime.jsx(ui.Text, { size: 0, muted: !0, style: { marginTop: "2px" }, children: document2._type })
     ] }) }),
     /* @__PURE__ */ jsxRuntime.jsx(ui.Stack, { space: 2, children: locales.length > 0 ? locales.filter((locale) => locale.enabled !== !1).map((locale) => {
-      const documentId = getDocumentPublishedId(document2), key = createTranslationStatusKey(
+      const documentId = getDocumentPublishedId(document2), versionId = getVersionId(document2), key = createTranslationStatusKey(
         branchId,
         documentId,
-        document2._rev,
+        versionId,
         locale.localeId
       ), status = translationStatuses.get(key), isDownloaded = downloadStatus.downloaded.has(key), isImported = importedTranslations.has(key);
       return /* @__PURE__ */ jsxRuntime.jsx(
@@ -3600,12 +4030,12 @@ const WrapText = dt(ui.Box)`
           importFile: async () => {
             await handleImportDocument(
               documentId,
-              document2._rev,
+              versionId,
               locale.localeId
             );
           }
         },
-        `${document2._id}-${document2._rev}-${locale.localeId}`
+        `${document2._id}-${versionId}-${locale.localeId}`
       );
     }) : /* @__PURE__ */ jsxRuntime.jsx(ui.Text, { size: 1, muted: !0, children: "No locales configured" }) })
   ] }) }, document2._id)) }) });
@@ -3959,7 +4389,10 @@ const WrapText = dt(ui.Box)`
       }
     )
   ] });
-}, TranslationsTool = () => /* @__PURE__ */ jsxRuntime.jsx(BaseTranslationWrapper, { showContainer: !1, children: /* @__PURE__ */ jsxRuntime.jsx(TranslationsProvider, { children: /* @__PURE__ */ jsxRuntime.jsx(TranslationsToolContent, {}) }) }), gtPlugin = sanity.definePlugin(
+}, TranslationsTool = () => /* @__PURE__ */ jsxRuntime.jsx(BaseTranslationWrapper, { showContainer: !1, children: /* @__PURE__ */ jsxRuntime.jsx(TranslationsProvider, { children: /* @__PURE__ */ jsxRuntime.jsx(TranslationsToolContent, {}) }) }), TranslationTab = (props) => {
+  const { displayed } = props.document;
+  return /* @__PURE__ */ jsxRuntime.jsx(BaseTranslationWrapper, { showContainer: !1, children: /* @__PURE__ */ jsxRuntime.jsx(TranslationsProvider, { singleDocument: displayed, children: /* @__PURE__ */ jsxRuntime.jsx(TranslationView, {}) }) });
+}, gtPlugin = sanity.definePlugin(
   ({
     languageField = "language",
     sourceLocale,
@@ -3979,11 +4412,16 @@ const WrapText = dt(ui.Box)`
     additionalSerializers = {},
     additionalDeserializers = {},
     additionalBlockDeserializers = [],
-    showDocumentInternationalization = !0
+    showDocumentInternationalization = !0,
+    internationalizedArray,
+    fieldLevelLocalization,
+    translationLevel = "document",
+    fieldLevelDocuments
   }) => {
-    const resolvedSourceLocale = sourceLocale ?? defaultLocale ?? internal.libraryDefaultLocale;
-    let normalizedTranslateDocuments;
-    translateDocuments && (normalizedTranslateDocuments = translateDocuments.map((entry) => typeof entry == "string" ? { type: entry } : entry).filter((filter2) => filter2.documentId || filter2.type)), pluginConfig.init(
+    const resolvedSourceLocale = sourceLocale ?? defaultLocale ?? internal.libraryDefaultLocale, normalizeFilters = (entries) => entries?.map((entry) => typeof entry == "string" ? { type: entry } : entry).filter((filter2) => filter2.documentId || filter2.type), normalizedTranslateDocuments = normalizeFilters(translateDocuments), normalizedFieldLevelDocuments = normalizeFilters(fieldLevelDocuments) ?? [], fieldLevelConfig = resolveFieldLevelConfig(
+      internationalizedArray ?? fieldLevelLocalization
+    );
+    pluginConfig.init(
       secretsNamespace,
       languageField,
       resolvedSourceLocale,
@@ -3998,17 +4436,22 @@ const WrapText = dt(ui.Box)`
       additionalStopTypes,
       additionalSerializers,
       additionalDeserializers,
-      additionalBlockDeserializers
+      additionalBlockDeserializers,
+      translationLevel,
+      normalizedFieldLevelDocuments,
+      fieldLevelConfig.typePrefix
     ), gt.setConfig({
       sourceLocale: resolvedSourceLocale,
       customMapping,
       apiKey,
       projectId
     });
+    const arrayLocalizedTypes = /* @__PURE__ */ new Set();
+    translationLevel === "internationalizedArray" ? normalizedTranslateDocuments?.map((filter2) => filter2.type).filter((type) => !!type).forEach((type) => arrayLocalizedTypes.add(type)) : translationLevel === "mixed" && normalizedFieldLevelDocuments.map((filter2) => filter2.type).filter((type) => !!type).forEach((type) => arrayLocalizedTypes.add(type));
     const plugins = [];
     if (showDocumentInternationalization) {
-      const schemaTypes = normalizedTranslateDocuments?.map((filter2) => filter2.type).filter((type) => !!type) ?? [];
-      if (schemaTypes.length > 0) {
+      const schemaTypes2 = normalizedTranslateDocuments?.map((filter2) => filter2.type).filter((type) => !!type).filter((type) => !arrayLocalizedTypes.has(type)) ?? [];
+      if (schemaTypes2.length > 0) {
         const supportedLanguages = [resolvedSourceLocale, ...locales].map((locale) => {
           const props = generaltranslation.getLocaleProperties(locale, resolvedSourceLocale);
           return { id: locale, title: props.name };
@@ -4016,15 +4459,28 @@ const WrapText = dt(ui.Box)`
         plugins.push(
           documentInternationalization.documentInternationalization({
             supportedLanguages,
-            schemaTypes,
+            schemaTypes: schemaTypes2,
             languageField
           })
         );
       }
     }
+    const schemaTypes = fieldLevelConfig.enabled ? createInternationalizedArrayTypes({
+      sourceLocale: resolvedSourceLocale,
+      locales,
+      fieldTypes: fieldLevelConfig.fieldTypes,
+      languageTitles: fieldLevelConfig.languageTitles,
+      getLanguageTitle: fieldLevelConfig.getLanguageTitle,
+      typePrefix: fieldLevelConfig.typePrefix,
+      includeCompatibilityTypes: fieldLevelConfig.includeCompatibilityTypes,
+      components: fieldLevelConfig.components
+    }) : [];
     return {
       name: "gt-sanity",
       plugins,
+      schema: {
+        types: schemaTypes
+      },
       tools: [
         {
           name: "translations",
@@ -4074,6 +4530,7 @@ exports.BaseDocumentMerger = BaseDocumentMerger;
 exports.BaseDocumentSerializer = BaseDocumentSerializer;
 exports.TranslationsTab = TranslationTab;
 exports.attachGTData = attachGTData;
+exports.createInternationalizedArrayTypes = createInternationalizedArrayTypes;
 exports.customSerializers = customSerializers;
 exports.defaultStopTypes = defaultStopTypes;
 exports.detachGTData = detachGTData;