@braze/sanity-plugin-ai-translation 0.2.26 → 0.2.32

package/dist/index.js

@@ -1,16 +1,68 @@
-import { useClient, defineType, defineField, getPublishedId, pathToString, definePlugin } from "sanity";
+import { useClient, getPublishedId, pathToString, defineType, defineField, definePlugin } from "sanity";
 import { jsx, jsxs } from "react/jsx-runtime";
 import { ErrorOutlineIcon, CheckmarkCircleIcon, EmptyIcon, AddIcon, TrashIcon, WarningOutlineIcon, InfoOutlineIcon, ArrowLeftIcon, EditIcon, TranslateIcon, CheckmarkIcon, CircleIcon, ArrowRightIcon, PanelRightIcon } from "@sanity/icons";
-import { createContext, useContext, useEffect, useState, useReducer, useCallback, useMemo } from "react";
+import { createContext, useReducer, useEffect, useContext, useState, useCallback, useMemo } from "react";
+import defaults from "lodash.defaults";
 import { Card, Flex, Stack, Text, Spinner, Button, Box, Tooltip, Checkbox, Select, TextInput, TextArea, Heading, Inline, Badge, Grid, Radio, Label, Code } from "@sanity/ui";
 import { useListeningQuery, useOpenInNewPane } from "sanity-plugin-utils";
-import defaults from "lodash.defaults";
 import { toPlainText } from "@portabletext/react";
 import { uuid } from "@sanity/uuid";
 import cloneDeep from "lodash.clonedeep";
 import get from "lodash.get";
 import set from "lodash.set";
-const TranslationContext = createContext({
+const isLoggingEnabled = () => process.env.NEXT_PUBLIC_SANITY_STUDIO_AI_TRANSLATION_PLUGIN_LOGGING === "true" || process.env.SANITY_STUDIO_AI_TRANSLATION_PLUGIN_LOGGING === "true", devLog = {
+  info: (message, context) => {
+    isLoggingEnabled() && console.info("[AI Translation]", message, context ? JSON.stringify(context, null, 2) : "");
+  },
+  warn: (message, context) => {
+    isLoggingEnabled() && console.warn("[AI Translation]", message, context ? JSON.stringify(context, null, 2) : "");
+  },
+  error: (message, error, context) => {
+    isLoggingEnabled() && console.error("[AI Translation]", message, error, context ? JSON.stringify(context, null, 2) : "");
+  },
+  debug: (message, data, context) => {
+    isLoggingEnabled() && console.debug("[AI Translation]", message, data, context ? JSON.stringify(context, null, 2) : "");
+  },
+  group: (label, context) => {
+    isLoggingEnabled() && console.group(`[AI Translation] ${label}`, context ? JSON.stringify(context, null, 2) : "");
+  },
+  groupEnd: () => {
+    isLoggingEnabled() && console.groupEnd();
+  },
+  time: (label) => {
+    isLoggingEnabled() && console.time(`[AI Translation] ${label}`);
+  },
+  timeEnd: (label) => {
+    isLoggingEnabled() && console.timeEnd(`[AI Translation] ${label}`);
+  }
+}, validateOpenAIApiKey = async (apiKey, model = "gpt-5") => {
+  try {
+    const response = await fetch("https://api.openai.com/v1/models", {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${apiKey}`
+      }
+    });
+    if (!response.ok)
+      return {
+        valid: !1,
+        error: (await response.json()).error?.message || "Invalid API key"
+      };
+    const availableModels = (await response.json()).data.map((m) => m.id);
+    return availableModels.includes(model) ? {
+      valid: !0,
+      modelAvailable: availableModels
+    } : {
+      valid: !1,
+      error: `Model ${model} not available. Try: ${availableModels.slice(0, 5).join(", ")}`
+    };
+  } catch (error) {
+    return {
+      valid: !1,
+      error: error instanceof Error ? error.message : "Network error"
+    };
+  }
+}, TranslationContext = createContext({
   document: null,
   config: null,
   overallStatus: "idle",
@@ -25,14 +77,126 @@ const TranslationContext = createContext({
   openaiValidated: !1,
   dispatch: () => {
   }
-}), useTranslationContext = () => {
+}), translationReducer = (context, action) => {
+  const logContext = {
+    documentId: context.document?._id,
+    actionType: action.type,
+    component: "translationReducer"
+  };
+  switch (devLog.debug("Translation action dispatched", {
+    ...logContext,
+    payload: action.payload
+  }), action.type) {
+    case "SET_OVERALL_STATUS":
+      return { ...context, overallStatus: action.payload };
+    case "SET_TRANSLATION_METADATA":
+      return { ...context, translationMetadata: action.payload };
+    case "SET_SELECTED_TARGET_LANGUAGES":
+      return {
+        ...context,
+        selectedTargetLanguages: action.payload
+      };
+    case "SET_TRANSLATION_MODE":
+      return {
+        ...context,
+        translationMode: action.payload
+      };
+    case "SET_OPENAI_VALIDATED":
+      return {
+        ...context,
+        openaiValidated: action.payload
+      };
+    case "SET_SHOULD_TRANSLATE_REFERENCES":
+      return {
+        ...context,
+        shouldTranslateReferences: action.payload
+      };
+    case "SET_MAX_REFERENCE_DEPTH":
+      return {
+        ...context,
+        maxReferenceDepth: action.payload
+      };
+    case "SET_SHOULD_OVERWRITE_FRESH_TRANSLATIONS":
+      return {
+        ...context,
+        shouldOverwriteFreshTranslations: action.payload
+      };
+    case "SET_REFERENCES":
+      return {
+        ...context,
+        references: action.payload
+      };
+    case "SET_TRANSLATION_JOB_STATUS": {
+      const jobKey = `${action.payload._id}_${action.payload.language}`, newTranslationJobs = new Map(context.translationJobs), existingJob = newTranslationJobs.get(jobKey), mergedJob = defaults(action.payload, existingJob);
+      return newTranslationJobs.set(jobKey, mergedJob), {
+        ...context,
+        translationJobs: newTranslationJobs
+      };
+    }
+    default:
+      return context;
+  }
+}, TranslationContextProvider = ({ document, config, children }) => {
+  devLog.debug("TranslationContextProvider initialized", {
+    documentId: document._id,
+    documentType: document._type,
+    supportedLanguages: config.supportedLanguages?.map((l) => l.id),
+    component: "TranslationContextProvider"
+  });
+  const initialContext = {
+    document,
+    config,
+    overallStatus: "idle",
+    translationMetadata: null,
+    selectedTargetLanguages: [],
+    shouldOverwriteFreshTranslations: !1,
+    shouldTranslateReferences: !1,
+    maxReferenceDepth: 1,
+    references: [],
+    translationJobs: /* @__PURE__ */ new Map(),
+    translationMode: config?.openai?.defaultMode || "sanity-only",
+    openaiValidated: !1
+  }, [context, dispatch] = useReducer(translationReducer, initialContext);
+  return useEffect(() => {
+    (async () => {
+      if (config?.openai?.enabled && config?.openai?.apiKey)
+        try {
+          const validation = await validateOpenAIApiKey(config.openai.apiKey, config.openai.model || "gpt-5");
+          dispatch({
+            type: "SET_OPENAI_VALIDATED",
+            payload: validation.valid
+          }), validation.valid ? devLog.info("OpenAI API key validated successfully", {
+            model: config.openai.model || "gpt-5",
+            component: "TranslationContextProvider"
+          }) : devLog.error("OpenAI API key validation failed", {
+            error: validation.error,
+            component: "TranslationContextProvider"
+          });
+        } catch (error) {
+          devLog.error("OpenAI validation error", error instanceof Error ? error : new Error(String(error)), {
+            component: "TranslationContextProvider"
+          }), dispatch({
+            type: "SET_OPENAI_VALIDATED",
+            payload: !1
+          });
+        }
+    })();
+  }, [config?.openai?.apiKey, config?.openai?.enabled, config?.openai?.model]), devLog.debug("Translation context state initialized", {
+    documentId: document._id,
+    overallStatus: context.overallStatus,
+    selectedLanguages: context.selectedTargetLanguages,
+    translationMode: context.translationMode,
+    openaiEnabled: config?.openai?.enabled,
+    component: "TranslationContextProvider"
+  }), /* @__PURE__ */ jsx(TranslationContext.Provider, { value: { ...context, dispatch }, children });
+}, useTranslationContext = () => {
   const context = useContext(TranslationContext);
   if (!context.document || !context.config)
     throw new Error(
       "useTranslationContext must be used within a TranslationContextProvider with document and config props"
     );
   return context;
-}, TRANSLATION_METADATA_TYPE = "translation.metadata", undraftId = (id) => id.replace(/^drafts\./, ""), TRANSLATION_METADATA_QUERY = "*[_type == $translationMetadataType && references($documentId)][0]", useTranslationMetadata = ({ documentId }) => {
+}, undraftId = (id) => id.replace(/^drafts\./, ""), TRANSLATION_METADATA_TYPE = "translation.metadata", TRANSLATION_METADATA_QUERY = "*[_type == $translationMetadataType && references($documentId)][0]", useTranslationMetadata = ({ documentId }) => {
   const { dispatch } = useTranslationContext(), { data, loading, error } = useListeningQuery(TRANSLATION_METADATA_QUERY, {
     params: {
       documentId: undraftId(documentId),
@@ -59,31 +223,6 @@ const TranslationContext = createContext({
     loading,
     error
   };
-}, isLoggingEnabled = () => process.env.NEXT_PUBLIC_SANITY_STUDIO_AI_TRANSLATION_PLUGIN_LOGGING === "true" || process.env.SANITY_STUDIO_AI_TRANSLATION_PLUGIN_LOGGING === "true", devLog = {
-  info: (message, context) => {
-    isLoggingEnabled() && console.info("[AI Translation]", message, context ? JSON.stringify(context, null, 2) : "");
-  },
-  warn: (message, context) => {
-    isLoggingEnabled() && console.warn("[AI Translation]", message, context ? JSON.stringify(context, null, 2) : "");
-  },
-  error: (message, error, context) => {
-    isLoggingEnabled() && console.error("[AI Translation]", message, error, context ? JSON.stringify(context, null, 2) : "");
-  },
-  debug: (message, data, context) => {
-    isLoggingEnabled() && console.debug("[AI Translation]", message, data, context ? JSON.stringify(context, null, 2) : "");
-  },
-  group: (label, context) => {
-    isLoggingEnabled() && console.group(`[AI Translation] ${label}`, context ? JSON.stringify(context, null, 2) : "");
-  },
-  groupEnd: () => {
-    isLoggingEnabled() && console.groupEnd();
-  },
-  time: (label) => {
-    isLoggingEnabled() && console.time(`[AI Translation] ${label}`);
-  },
-  timeEnd: (label) => {
-    isLoggingEnabled() && console.timeEnd(`[AI Translation] ${label}`);
-  }
 };
 async function validateSuggestion(client, suggestion) {
   return suggestion.type === "glossaryTerm" ? validateGlossaryTerm(client, suggestion) : suggestion.type === "protectedPhrase" ? validateProtectedPhrase(client, suggestion) : suggestion.type === "globalPrompt" || suggestion.type === "localePrompt" ? validatePrompt(suggestion) : { valid: !0, status: "valid" };
@@ -411,7 +550,7 @@ function convertAnalysisToSuggestions(analysis, sourceLanguage, targetLanguage)
         type: "glossaryTerm",
         description: `${term.sourceValue} \u2192 ${term.targetValue}`,
         approved: !0,
-        // Use the provided source/target languages instead of relying on AI to provide them
+        // Use explicit source/target languages from history instead of AI-provided values
         sourceLocale: sourceLanguage,
         sourceValue: term.sourceValue,
         targetLocale: targetLanguage,
@@ -1069,358 +1208,45 @@ const ICON_SIZE = 64, progressIconMap = {
       )
     ] })
   ] });
-}, validateOpenAIApiKey = async (apiKey, model = "gpt-5") => {
-  try {
-    const response = await fetch("https://api.openai.com/v1/models", {
-      method: "GET",
-      headers: {
-        Authorization: `Bearer ${apiKey}`
-      }
-    });
-    if (!response.ok)
-      return {
-        valid: !1,
-        error: (await response.json()).error?.message || "Invalid API key"
-      };
-    const availableModels = (await response.json()).data.map((m) => m.id);
-    return availableModels.includes(model) ? {
-      valid: !0,
-      modelAvailable: availableModels
-    } : {
-      valid: !1,
-      error: `Model ${model} not available. Try: ${availableModels.slice(0, 5).join(", ")}`
-    };
-  } catch (error) {
-    return {
-      valid: !1,
-      error: error instanceof Error ? error.message : "Network error"
-    };
-  }
-}, translationReducer = (context, action) => {
-  const logContext = {
-    documentId: context.document?._id,
-    actionType: action.type,
-    component: "translationReducer"
-  };
-  switch (devLog.debug("Translation action dispatched", {
-    ...logContext,
-    payload: action.payload
-  }), action.type) {
-    case "SET_OVERALL_STATUS":
-      return { ...context, overallStatus: action.payload };
-    case "SET_TRANSLATION_METADATA":
-      return { ...context, translationMetadata: action.payload };
-    case "SET_SELECTED_TARGET_LANGUAGES":
-      return {
-        ...context,
-        selectedTargetLanguages: action.payload
-      };
-    case "SET_TRANSLATION_MODE":
-      return {
-        ...context,
-        translationMode: action.payload
-      };
-    case "SET_OPENAI_VALIDATED":
-      return {
-        ...context,
-        openaiValidated: action.payload
-      };
-    case "SET_SHOULD_TRANSLATE_REFERENCES":
-      return {
-        ...context,
-        shouldTranslateReferences: action.payload
-      };
-    case "SET_MAX_REFERENCE_DEPTH":
-      return {
-        ...context,
-        maxReferenceDepth: action.payload
-      };
-    case "SET_SHOULD_OVERWRITE_FRESH_TRANSLATIONS":
-      return {
-        ...context,
-        shouldOverwriteFreshTranslations: action.payload
-      };
-    case "SET_REFERENCES":
-      return {
-        ...context,
-        references: action.payload
-      };
-    case "SET_TRANSLATION_JOB_STATUS": {
-      const jobKey = `${action.payload._id}_${action.payload.language}`, newTranslationJobs = new Map(context.translationJobs), existingJob = newTranslationJobs.get(jobKey), mergedJob = defaults(action.payload, existingJob);
-      return newTranslationJobs.set(jobKey, mergedJob), {
-        ...context,
-        translationJobs: newTranslationJobs
-      };
-    }
-    default:
-      return context;
-  }
-}, TranslationContextProvider = ({ document, config, children }) => {
-  devLog.debug("TranslationContextProvider initialized", {
-    documentId: document._id,
-    documentType: document._type,
-    supportedLanguages: config.supportedLanguages?.map((l) => l.id),
-    component: "TranslationContextProvider"
-  });
-  const initialContext = {
-    document,
-    config,
-    overallStatus: "idle",
-    translationMetadata: null,
-    selectedTargetLanguages: [],
-    shouldOverwriteFreshTranslations: !1,
-    shouldTranslateReferences: !1,
-    maxReferenceDepth: 1,
-    references: [],
-    translationJobs: /* @__PURE__ */ new Map(),
-    translationMode: config?.openai?.defaultMode || "sanity-only",
-    openaiValidated: !1
-  }, [context, dispatch] = useReducer(translationReducer, initialContext);
-  return useEffect(() => {
-    (async () => {
-      if (config?.openai?.enabled && config?.openai?.apiKey)
-        try {
-          const validation = await validateOpenAIApiKey(config.openai.apiKey, config.openai.model || "gpt-5");
-          dispatch({
-            type: "SET_OPENAI_VALIDATED",
-            payload: validation.valid
-          }), validation.valid ? devLog.info("OpenAI API key validated successfully", {
-            model: config.openai.model || "gpt-5",
-            component: "TranslationContextProvider"
-          }) : devLog.error("OpenAI API key validation failed", {
-            error: validation.error,
-            component: "TranslationContextProvider"
-          });
-        } catch (error) {
-          devLog.error("OpenAI validation error", error instanceof Error ? error : new Error(String(error)), {
-            component: "TranslationContextProvider"
-          }), dispatch({
-            type: "SET_OPENAI_VALIDATED",
-            payload: !1
-          });
-        }
-    })();
-  }, [config?.openai?.apiKey, config?.openai?.enabled, config?.openai?.model]), devLog.debug("Translation context state initialized", {
-    documentId: document._id,
-    overallStatus: context.overallStatus,
-    selectedLanguages: context.selectedTargetLanguages,
-    translationMode: context.translationMode,
-    openaiEnabled: config?.openai?.enabled,
-    component: "TranslationContextProvider"
-  }), /* @__PURE__ */ jsx(TranslationContext.Provider, { value: { ...context, dispatch }, children });
-}, getGiveTranslationFeedbackAction = (config) => ({ draft, published }) => {
-  const document = draft ?? published, [isDialogOpen, setIsDialogOpen] = useState(!1);
-  return devLog.debug("ImproveTranslationPromptsAction initialized", {
-    documentId: document?._id,
-    documentType: document?._type
-  }), !document || !config.translatableSchemaTypes?.includes(document._type) ? (devLog.warn("Document not in translatable schema types", {
-    documentType: document?._type,
-    translatableTypes: config.translatableSchemaTypes
-  }), null) : config ? {
-    label: "Give Translation Feedback",
-    icon: TranslateIcon,
-    onHandle: () => {
-      devLog.info("Give Translation Feedback dialog opened", {
-        documentId: document._id,
-        documentType: document._type,
-        component: "GiveTranslationFeedbackAction"
-      }), setIsDialogOpen(!0);
-    },
-    dialog: isDialogOpen && {
-      type: "dialog",
-      onClose: () => setIsDialogOpen(!1),
-      header: "Give Translation Feedback",
-      content: /* @__PURE__ */ jsx(TranslationContextProvider, { document, config, children: /* @__PURE__ */ jsx(GiveFeedbackDialog, { setIsDialogOpen }) })
-    }
-  } : (devLog.error("Missing config in TranslateAction"), null);
-}, translationGlossaryTerm = defineType({
-  name: "translationGlossaryTerm",
-  title: "Translation Glossary Term",
-  icon: TranslateIcon,
-  type: "document",
-  fields: [
-    defineField({
-      name: "translations",
-      title: "Translations",
-      type: "internationalizedArrayString"
-    })
-  ],
-  preview: {
-    select: {
-      translations: "translations"
-    },
-    prepare({ translations }) {
-      const enTranslation = translations?.find((t) => t.locale === "en-us"), firstTranslation = translations?.[0];
-      return {
-        title: enTranslation?.value || firstTranslation?.value || "No translation available"
-      };
-    }
-  }
-}), translationHistory = defineField({
-  name: "translationHistory",
-  type: "array",
-  of: [
-    {
-      name: "targetLanguageHistory",
-      type: "object",
-      fields: [
-        defineField({
-          name: "language",
-          title: "Language",
-          description: "The language of the target document",
-          type: "string"
-        }),
-        defineField({
-          name: "sourceId",
-          title: "Source ID",
-          description: "The ID of the source document",
-          type: "string"
-        }),
-        defineField({
-          name: "sourceRev",
-          title: "Source Revision",
-          description: "The revision ID of the source document at the time of translation",
-          type: "string"
-        }),
-        defineField({
-          name: "sourceLanguage",
-          title: "Source Language",
-          description: "The language of the source document",
-          type: "string"
-        }),
-        defineField({
-          name: "sourceSnapshot",
-          title: "Source Snapshot",
-          description: "The snapshot of the source document at the time of translation",
-          type: "text"
-        }),
-        defineField({
-          name: "targetId",
-          title: "Target ID",
-          description: "The ID of the target document",
-          type: "string"
-        })
-      ]
-    }
-  ]
-}), translationSettings = defineType({
-  name: "translationSettings",
-  title: "Translation Settings",
-  icon: TranslateIcon,
-  type: "document",
-  groups: [
-    {
-      name: "general",
-      title: "General",
-      default: !0
-    },
-    {
-      name: "history",
-      title: "History"
-    }
-  ],
-  fields: [
-    defineField({
-      name: "globalPrompt",
-      title: "Global Translation Prompt",
-      description: "A prompt that will given to the Sanity AI Agent for all translation tasks.",
-      type: "text",
-      rows: 5,
-      group: "general"
-    }),
-    defineField({
-      name: "localePrompts",
-      title: "Locale Prompts",
-      description: "Prompts that will be given to the Sanity AI Agent for each locale.",
-      type: "internationalizedArrayText",
-      group: "general"
-    }),
-    defineField({
-      name: "protectedPhrases",
-      title: "Protected Phrases",
-      description: "Phrases that will never be translated.",
-      type: "array",
-      of: [{ type: "string" }],
-      group: "general"
-    }),
-    defineField({
-      name: "changeHistory",
-      title: "Change History",
-      description: "History of changes made via user feedback.",
-      type: "array",
-      readOnly: !0,
-      group: "history",
-      of: [
-        {
-          type: "object",
-          fields: [
-            defineField({
-              name: "timestamp",
-              title: "Timestamp",
-              type: "datetime"
-            }),
-            defineField({
-              name: "changeType",
-              title: "Change Type",
-              type: "string",
-              options: {
-                list: [
-                  { title: "Global Prompt", value: "globalPrompt" },
-                  { title: "Locale Prompt", value: "localePrompt" },
-                  { title: "Protected Phrase", value: "protectedPhrase" },
-                  { title: "Glossary Term", value: "glossaryTerm" }
-                ]
-              }
-            }),
-            defineField({
-              name: "description",
-              title: "Description",
-              type: "text",
-              rows: 3
-            }),
-            defineField({
-              name: "locale",
-              title: "Locale",
-              type: "string",
-              description: "Target locale for locale-specific changes"
-            })
-          ],
-          preview: {
-            select: {
-              timestamp: "timestamp",
-              changeType: "changeType",
-              description: "description"
-            },
-            prepare({ timestamp, changeType, description }) {
-              return {
-                title: `${changeType} - ${new Date(timestamp).toLocaleDateString()}`,
-                subtitle: description
-              };
-            }
-          }
-        }
-      ]
-    })
-  ],
-  preview: {
-    prepare: () => ({
-      title: "Translation Settings"
-    })
-  }
-});
-class Semaphore {
-  permits;
-  queue = [];
-  constructor(permits) {
-    this.permits = permits;
-  }
-  /**
-   * Acquire a permit from the semaphore
-   * If no permits are available, the caller will wait until one becomes available
-   */
-  async acquire() {
-    return this.permits > 0 ? (this.permits--, Promise.resolve()) : new Promise((resolve) => {
-      this.queue.push(resolve);
+}, getGiveTranslationFeedbackAction = (config) => ({ draft, published }) => {
+  const document = draft ?? published, [isDialogOpen, setIsDialogOpen] = useState(!1);
+  return devLog.debug("ImproveTranslationPromptsAction initialized", {
+    documentId: document?._id,
+    documentType: document?._type
+  }), !document || !config.translatableSchemaTypes?.includes(document._type) ? (devLog.warn("Document not in translatable schema types", {
+    documentType: document?._type,
+    translatableTypes: config.translatableSchemaTypes
+  }), null) : config ? {
+    label: "Give Translation Feedback",
+    icon: TranslateIcon,
+    onHandle: () => {
+      devLog.info("Give Translation Feedback dialog opened", {
+        documentId: document._id,
+        documentType: document._type,
+        component: "GiveTranslationFeedbackAction"
+      }), setIsDialogOpen(!0);
+    },
+    dialog: isDialogOpen && {
+      type: "dialog",
+      onClose: () => setIsDialogOpen(!1),
+      header: "Give Translation Feedback",
+      content: /* @__PURE__ */ jsx(TranslationContextProvider, { document, config, children: /* @__PURE__ */ jsx(GiveFeedbackDialog, { setIsDialogOpen }) })
+    }
+  } : (devLog.error("Missing config in TranslateAction"), null);
+};
+class Semaphore {
+  permits;
+  queue = [];
+  constructor(permits) {
+    this.permits = permits;
+  }
+  /**
+   * Acquire a permit from the semaphore
+   * If no permits are available, the caller will wait until one becomes available
+   */
+  async acquire() {
+    return this.permits > 0 ? (this.permits--, Promise.resolve()) : new Promise((resolve) => {
+      this.queue.push(resolve);
     });
   }
   /**
@@ -1583,11 +1409,21 @@ const fetchTranslationPrompts = async ({
   const sourceDocumentString = documentToPlainText(sourceDocument), translationSettings2 = await client.fetch(
     `*[_id == "translation-settings"][0] {
       globalPrompt,
-      localePrompts[locale in $targetLanguages],
+      localePrompts[_key in $targetLanguages],
       protectedPhrases
     }`,
     { targetLanguages }
-  ), translationGlossaryTerms = await client.fetch(
+  );
+  devLog.debug("Fetched translation settings", {
+    hasSettings: !!translationSettings2,
+    hasGlobalPrompt: !!translationSettings2?.globalPrompt,
+    globalPromptLength: translationSettings2?.globalPrompt?.length,
+    localePromptsCount: translationSettings2?.localePrompts?.length,
+    localePrompts: translationSettings2?.localePrompts,
+    protectedPhrasesCount: translationSettings2?.protectedPhrases?.length,
+    targetLanguages
+  });
+  const translationGlossaryTerms = await client.fetch(
     `*[
         _type == "translationGlossaryTerm"
         && count(translations[_key in $targetLanguages]) > 0
@@ -1607,9 +1443,21 @@ const fetchTranslationPrompts = async ({
     )), glossaryTermsByLocale[targetLanguage] = relevantTranslations;
   }
   let filteredProtectedPhrases = translationSettings2?.protectedPhrases;
-  return sourceDocument && filteredProtectedPhrases && (filteredProtectedPhrases = filteredProtectedPhrases.filter(
-    (phrase) => protectedPhraseAppearsInDocument(phrase, sourceDocumentString)
-  )), {
+  return sourceDocument && filteredProtectedPhrases && (devLog.debug("Filtering protected phrases", {
+    totalPhrases: filteredProtectedPhrases.length,
+    phrases: filteredProtectedPhrases,
+    sourceDocumentStringLength: sourceDocumentString.length,
+    sourceDocumentPreview: sourceDocumentString.substring(0, 500)
+  }), filteredProtectedPhrases = filteredProtectedPhrases.filter((phrase) => {
+    const appears = protectedPhraseAppearsInDocument(phrase, sourceDocumentString);
+    return devLog.debug("Protected phrase match result", {
+      phrase,
+      appears
+    }), appears;
+  }), devLog.debug("Filtered protected phrases result", {
+    remainingCount: filteredProtectedPhrases.length,
+    remainingPhrases: filteredProtectedPhrases
+  })), {
     globalPrompt: translationSettings2?.globalPrompt,
     protectedPhrases: filteredProtectedPhrases,
     localeInstructions: Object.fromEntries(
@@ -1757,7 +1605,109 @@ const fetchTranslationPrompts = async ({
         payload
       });
     }
-}, getExistingTranslationId = (translationMetadata, targetLanguage) => translationMetadata?.translations?.length && translationMetadata.translations.find(
+}, DEFAULT_OPTIONS = {
+  maxRetries: 3,
+  initialDelayMs: 1e3,
+  maxDelayMs: 3e4,
+  backoffMultiplier: 2,
+  jitter: !0
+};
+function isRetryableError(error) {
+  if (error instanceof Error) {
+    const message = error.message.toLowerCase(), name = error.name.toLowerCase(), nonRetryablePatterns = [
+      "schema not found",
+      "invalid schema",
+      "not found",
+      "unauthorized",
+      "forbidden",
+      "invalid api key",
+      "missing api key",
+      "validation failed",
+      "invalid document",
+      "source language not found",
+      "invalid configuration",
+      "type mismatch"
+    ];
+    for (const pattern of nonRetryablePatterns)
+      if (message.includes(pattern) || name.includes(pattern))
+        return !1;
+    const retryablePatterns = [
+      "failed to fetch",
+      "network",
+      "timeout",
+      "econnreset",
+      "econnrefused",
+      "enotfound",
+      "socket",
+      "rate limit",
+      "too many requests",
+      "429",
+      "500",
+      "502",
+      "503",
+      "504",
+      "internal server error",
+      "bad gateway",
+      "service unavailable",
+      "gateway timeout",
+      "temporarily unavailable",
+      "try again"
+    ];
+    for (const pattern of retryablePatterns)
+      if (message.includes(pattern) || name.includes(pattern))
+        return !0;
+  }
+  if (typeof error == "object" && error !== null) {
+    const statusCode = error.statusCode || error.status;
+    if (statusCode) {
+      if (statusCode === 429 || statusCode >= 500 && statusCode < 600)
+        return !0;
+      if (statusCode >= 400 && statusCode < 500)
+        return !1;
+    }
+  }
+  return !0;
+}
+function calculateBackoffDelay(attempt, options) {
+  const { initialDelayMs, maxDelayMs, backoffMultiplier, jitter } = options;
+  let delay = initialDelayMs * backoffMultiplier ** attempt;
+  if (delay = Math.min(delay, maxDelayMs), jitter) {
+    const jitterFactor = 0.75 + Math.random() * 0.5;
+    delay = Math.round(delay * jitterFactor);
+  }
+  return delay;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function withRetry(fn, options = {}) {
+  const opts = { ...DEFAULT_OPTIONS, ...options }, shouldRetry = opts.isRetryable ?? isRetryableError;
+  let lastError, attempts = 0;
+  for (let attempt = 0; attempt <= opts.maxRetries; attempt++) {
+    attempts = attempt + 1;
+    try {
+      return { success: !0, result: await fn(), attempts };
+    } catch (error) {
+      if (lastError = error, attempt >= opts.maxRetries) {
+        devLog.debug("Max retries exhausted", { attempt: attempts, error });
+        break;
+      }
+      if (!shouldRetry(error)) {
+        devLog.debug("Error is not retryable", { attempt: attempts, error });
+        break;
+      }
+      const delay = calculateBackoffDelay(attempt, opts);
+      devLog.debug("Scheduling retry", {
+        attempt: attempts,
+        nextAttempt: attempt + 2,
+        delayMs: delay,
+        error: error instanceof Error ? error.message : String(error)
+      }), opts.onRetry && opts.onRetry(attempt + 1, error, delay), await sleep(delay);
+    }
+  }
+  return { success: !1, error: lastError, attempts };
+}
+const getExistingTranslationId = (translationMetadata, targetLanguage) => translationMetadata?.translations?.length && translationMetadata.translations.find(
   (translation) => translation._key === targetLanguage
 )?.value._ref || null, getTranslationMetadata = async ({
   client,
@@ -1848,16 +1798,189 @@ const fetchTranslationPrompts = async ({
       status
     })
   });
-}, callGPT5 = async (apiKey, request) => (request.model || "gpt-5") === "gpt-5" ? await callGPT5ResponsesAPI(apiKey, request) : await callChatCompletionsAPI(apiKey, request), callGPT5ResponsesAPI = async (apiKey, request) => {
+};
+function applyTransforms({
+  document,
+  registry,
+  schemaType,
+  parentPath = ""
+}) {
+  if (!document)
+    return { transformedDocument: document, originalStructure: {} };
+  if (typeof document != "object")
+    return { transformedDocument: document, originalStructure: {} };
+  if (Array.isArray(document)) {
+    const originalStructure2 = {};
+    return { transformedDocument: document.map((item, index) => {
+      const itemPath = parentPath ? `${parentPath}[${index}]` : `[${index}]`, { transformedDocument: transformedItem, originalStructure: itemOriginalStructure } = applyTransforms({
+        document: item,
+        registry,
+        schemaType,
+        parentPath: itemPath
+      });
+      return Object.assign(originalStructure2, itemOriginalStructure), transformedItem;
+    }), originalStructure: originalStructure2 };
+  }
+  const transformedObj = {}, originalStructure = {};
+  for (const [key, value] of Object.entries(document)) {
+    const fieldPath = parentPath ? `${parentPath}.${key}` : key;
+    if (key.startsWith("_") && key !== "_type") {
+      transformedObj[key] = value;
+      continue;
+    }
+    const transform = registry.findTransform(schemaType, fieldPath, value, document);
+    if (transform) {
+      devLog.debug("Applying transform", { fieldPath, schemaType });
+      const context = {
+        fieldPath,
+        schemaType,
+        document
+      }, transformedValue = transform.toTranslatable(value, context);
+      transformedObj[key] = transformedValue, originalStructure[fieldPath] = {
+        value,
+        transform
+      };
+    } else {
+      const { transformedDocument: transformedValue, originalStructure: valueOriginalStructure } = applyTransforms({
+        document: value,
+        registry,
+        schemaType,
+        parentPath: fieldPath
+      });
+      Object.assign(originalStructure, valueOriginalStructure), transformedObj[key] = transformedValue;
+    }
+  }
+  return { transformedDocument: transformedObj, originalStructure };
+}
+function restoreTransforms({
+  translatedDocument,
+  originalStructure,
+  registry,
+  schemaType,
+  parentPath = ""
+}) {
+  if (translatedDocument == null || typeof translatedDocument != "object")
+    return translatedDocument;
+  if (Array.isArray(translatedDocument))
+    return translatedDocument.map((item, index) => {
+      const itemPath = parentPath ? `${parentPath}[${index}]` : `[${index}]`;
+      return restoreTransforms({
+        translatedDocument: item,
+        originalStructure,
+        registry,
+        schemaType,
+        parentPath: itemPath
+      });
+    });
+  const originalData = originalStructure[parentPath];
+  if (originalData) {
+    const { value: originalValue, transform } = originalData, context = {
+      fieldPath: parentPath,
+      schemaType,
+      document: translatedDocument
+    };
+    return devLog.debug("Restoring transform", { fieldPath: parentPath, schemaType }), transform.fromTranslatable(translatedDocument, originalValue, context);
+  }
+  const restoredObj = {}, translatedObj = translatedDocument;
+  for (const [key, value] of Object.entries(translatedObj)) {
+    const fieldPath = parentPath ? `${parentPath}.${key}` : key, fieldOriginalData = originalStructure[fieldPath];
+    if (fieldOriginalData) {
+      const { value: originalValue, transform } = fieldOriginalData, context = {
+        fieldPath,
+        schemaType,
+        document: translatedDocument
+      };
+      devLog.debug("Restoring transform for field", { fieldPath, schemaType }), restoredObj[key] = transform.fromTranslatable(value, originalValue, context);
+    } else
+      restoredObj[key] = restoreTransforms({
+        translatedDocument: value,
+        originalStructure,
+        registry,
+        schemaType,
+        parentPath: fieldPath
+      });
+  }
+  return restoredObj;
+}
+class TransformRegistry {
+  transforms = [];
+  /**
+   * Register a transform with the registry.
+   * @param transform - Field transform to register
+   */
+  register(transform) {
+    devLog.debug("Registering field transform", {
+      matcher: transform.matcher
+    }), this.transforms.push(transform);
+  }
+  /**
+   * Find a matching transform for the given field.
+   * If multiple transforms match, returns the first one (order matters!).
+   * @param schemaType - Document schema type
+   * @param fieldPath - Path to the field
+   * @param value - Optional field value for value-based matching
+   * @param document - Optional full document for context
+   * @returns Matching transform or undefined if none found
+   */
+  findTransform(schemaType, fieldPath, value, document) {
+    const matches = [];
+    for (const transform of this.transforms) {
+      const { matcher } = transform;
+      if (!(matcher.schemaType && matcher.schemaType !== schemaType)) {
+        if (matcher.fieldPath) {
+          if (typeof matcher.fieldPath == "string") {
+            if (matcher.fieldPath !== fieldPath)
+              continue;
+          } else if (matcher.fieldPath instanceof RegExp && !matcher.fieldPath.test(fieldPath))
+            continue;
+        }
+        if (matcher.fieldName) {
+          const segments = fieldPath.split(".");
+          if (segments[segments.length - 1]?.split("[")[0] !== matcher.fieldName)
+            continue;
+        }
+        if (matcher.valueMatcher) {
+          if (value === void 0)
+            continue;
+          const context = {
+            fieldPath,
+            schemaType,
+            document: document || {}
+          };
+          if (!matcher.valueMatcher(value, context))
+            continue;
+        }
+        matches.push(transform);
+      }
+    }
+    return matches.length > 1 && devLog.warn("Multiple transforms match the same field - using first match", {
+      schemaType,
+      fieldPath,
+      matchCount: matches.length,
+      firstMatcher: matches[0].matcher
+    }), matches[0];
+  }
+}
+const globalTransformRegistry = new TransformRegistry(), callGPT5 = async (apiKey, request) => (request.model || "gpt-5") === "gpt-5" ? await callGPT5ResponsesAPI(apiKey, request) : await callChatCompletionsAPI(apiKey, request), callGPT5ResponsesAPI = async (apiKey, request) => {
   const model = request.model || "gpt-5", requestBody = {
-    model,
+    model: "gpt-5.1",
     input: request.messages
     // Uses 'input' instead of 'messages'
   };
   request.reasoningEffort && (requestBody.reasoning = {
     effort: request.reasoningEffort,
     summary: "auto"
-    // Request reasoning summaries
+    // Enable automatic reasoning summaries
+  }), devLog.debug("OpenAI GPT-5 Request", {
+    model: requestBody.model,
+    reasoningEffort: request.reasoningEffort,
+    messages: request.messages.map((m) => ({
+      role: m.role,
+      contentLength: m.content.length,
+      contentPreview: m.content.substring(0, 500) + (m.content.length > 500 ? "..." : "")
+    }))
+  }), devLog.debug("OpenAI GPT-5 Full Prompt", {
+    messages: request.messages
   });
   const response = await fetch("https://api.openai.com/v1/responses", {
     method: "POST",
@@ -1892,7 +2015,19 @@ const fetchTranslationPrompts = async ({
     model,
     messages: request.messages,
     temperature: request.temperature ?? 0.3
-  }, response = await fetch("https://api.openai.com/v1/chat/completions", {
+  };
+  devLog.debug("OpenAI Chat Completions Request", {
+    model,
+    temperature: request.temperature ?? 0.3,
+    messages: request.messages.map((m) => ({
+      role: m.role,
+      contentLength: m.content.length,
+      contentPreview: m.content.substring(0, 500) + (m.content.length > 500 ? "..." : "")
+    }))
+  }), devLog.debug("OpenAI Chat Completions Full Prompt", {
+    messages: request.messages
+  });
+  const response = await fetch("https://api.openai.com/v1/chat/completions", {
     method: "POST",
     headers: {
       "Content-Type": "application/json",
@@ -1945,9 +2080,52 @@ const fetchTranslationPrompts = async ({
 }, parseReviewFormat = (text) => {
   const root = [], stack = [], lines = text.split(`
 `);
-  for (const line of lines) {
-    const trimmed = line.trim();
+  for (let i = 0; i < lines.length; i++) {
+    const trimmed = lines[i].trim();
     if (!trimmed) continue;
+    const compactStringMatch = trimmed.match(/^(\w+):\s*(.*)$/);
+    if (compactStringMatch && !trimmed.includes("<")) {
+      const [, fieldName, text2] = compactStringMatch, node = {
+        type: "field",
+        name: fieldName,
+        text: unescapeXml(text2),
+        attributes: {},
+        children: []
+      };
+      if (stack.length > 0) {
+        const parent = stack[stack.length - 1];
+        parent && parent.children.push(node);
+      } else
+        root.push(node);
+      continue;
+    }
+    const compactStartMatch = trimmed.match(/^---\s+(\w+)\s+---$/);
+    if (compactStartMatch) {
+      const fieldName = compactStartMatch[1], contentLines = [];
+      for (i++; i < lines.length; ) {
+        const currentLine = lines[i];
+        if (currentLine.trim().match(new RegExp(`^---\\s+/${fieldName}\\s+---$`)))
+          break;
+        contentLines.push(currentLine), i++;
+      }
+      const content = contentLines.join(`
+`);
+      let contentType = "translatable.vtt.captions";
+      (content.includes("<block") || content.includes("<span")) && (contentType = "translatable.richtext");
+      const node = {
+        type: "field",
+        name: fieldName,
+        text: content,
+        attributes: { type: contentType },
+        children: []
+      };
+      if (stack.length > 0) {
+        const parent = stack[stack.length - 1];
+        parent && parent.children.push(node);
+      } else
+        root.push(node);
+      continue;
+    }
     const openMatch = trimmed.match(/^<(field|block|span)([^>]*)>(.*)$/);
     if (openMatch) {
       const [, tagName, attrsStr, content] = openMatch, attributes = parseAttributes(attrsStr), node = {
@@ -1970,7 +2148,21 @@ const fetchTranslationPrompts = async ({
           parent && parent.children.push(node);
         } else
           root.push(node);
-      else
+      else if (attributes.type === "translatable.vtt.captions" || attributes.type === "translatable.richtext") {
+        const contentLines = [];
+        for (i++; i < lines.length; ) {
+          const currentLine = lines[i];
+          if (currentLine.trim().match(/^<\/field>$/))
+            break;
+          contentLines.push(currentLine), i++;
+        }
+        if (node.text = contentLines.join(`
+`), stack.length > 0) {
+          const parent = stack[stack.length - 1];
+          parent && parent.children.push(node);
+        } else
+          root.push(node);
+      } else
         stack.push(node);
       continue;
     }
@@ -1998,6 +2190,16 @@ const fetchTranslationPrompts = async ({
       applyFieldChanges(doc, path, node);
     }
 }, applyFieldChanges = (doc, path, node) => {
+  if (node.attributes.type === "translatable.vtt.captions") {
+    const fieldValue = get(doc, path);
+    fieldValue && typeof fieldValue == "object" && fieldValue._type === "translatable.vtt.captions" && node.text && set(doc, [...path, "translationText"], node.text);
+    return;
+  }
+  if (node.attributes.type === "translatable.richtext") {
+    const fieldValue = get(doc, path);
+    fieldValue && typeof fieldValue == "object" && fieldValue._type === "translatable.richtext" && node.text && set(doc, [...path, "translationText"], node.text);
+    return;
+  }
   if (node.attributes.type === "array") {
     node.children.forEach((child, idx) => {
       applyFieldChanges(doc, [...path, idx], child);
@@ -2064,7 +2266,7 @@ const fetchTranslationPrompts = async ({
     if (path.length === 0) {
       if (isPlainObject(value))
         for (const [key, val] of Object.entries(value))
-          !key.startsWith("_") && key !== "language" && serialize(val, [key], indent);
+          !key.startsWith("_") && key !== "language" && serialize(val, [key], 0);
       return;
     }
     const fieldName = path[path.length - 1];
@@ -2077,6 +2279,14 @@ const fetchTranslationPrompts = async ({
       return;
     }
     if (isPlainObject(value)) {
+      if (value._type === "translatable.vtt.captions" && typeof value.translationText == "string") {
+        lines.push(`${indentStr}--- ${fieldName} ---`), lines.push(value.translationText), lines.push(`${indentStr}--- /${fieldName} ---`);
+        return;
+      }
+      if (value._type === "translatable.richtext" && typeof value.translationText == "string") {
+        lines.push(`${indentStr}--- ${fieldName} ---`), lines.push(value.translationText), lines.push(`${indentStr}--- /${fieldName} ---`);
+        return;
+      }
       lines.push(`${indentStr}<field name="${fieldName}" type="object">`);
       for (const [key, val] of Object.entries(value))
         key.startsWith("_") || serialize(val, [...path, key], indent + 1);
@@ -2084,7 +2294,7 @@ const fetchTranslationPrompts = async ({
       return;
     }
     if (typeof value == "string") {
-      value.length > 0 && lines.push(`${indentStr}<field name="${fieldName}">${escapeXml(value)}</field>`);
+      value.length > 0 && lines.push(`${fieldName}: ${escapeXml(value)}`);
       return;
     }
     (typeof value == "number" || typeof value == "boolean") && lines.push(`${indentStr}<field name="${fieldName}" type="${typeof value}" readonly="true">${value}</field>`);
@@ -2217,7 +2427,14 @@ const fetchTranslationPrompts = async ({
     sourceLanguage
   };
   try {
-    const sourceText = serializeDocument(sourceDocument), prompt = buildTranslationPrompt$1({
+    const sourceText = serializeDocument(sourceDocument);
+    devLog.info("Serialized document for OpenAI", {
+      ...logContext,
+      characterCount: sourceText.length,
+      estimatedTokens: Math.ceil(sourceText.length / 4),
+      preview: sourceText.substring(0, 500)
+    });
+    const prompt = buildTranslationPrompt$1({
       sourceText,
       sourceLanguage,
       targetLanguage,
@@ -2232,7 +2449,15 @@ const fetchTranslationPrompts = async ({
       ],
       model: openaiConfig.model,
       reasoningEffort: openaiConfig.reasoningEffort
-    }), result = deserializeDocument(sourceDocument, response.content);
+    });
+    devLog.info("OpenAI translation response received", {
+      ...logContext,
+      tokensUsed: response.tokensUsed,
+      cost: response.cost,
+      responseLength: response.content.length,
+      responsePreview: response.content.substring(0, 500)
+    });
+    const result = deserializeDocument(sourceDocument, response.content);
     result[languageFieldName] = targetLanguage;
     const validation = validateStructureIntegrity(sourceDocument, result);
     if (!validation.valid) {
@@ -2424,11 +2649,20 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
   openaiConfig,
   releaseId
 }) => {
+  devLog.debug("Applying field transforms before translation", {
+    documentId: sourceDocument._id,
+    documentType: sourceDocument._type
+  });
+  const { transformedDocument, originalStructure } = applyTransforms({
+    document: sourceDocument,
+    registry: globalTransformRegistry,
+    schemaType: sourceDocument._type
+  });
   let translatedDoc;
   switch (translationMode) {
     case "sanity-only": {
       setJobStatus(dispatch, sourceDocument._id, targetLanguage, "translating"), translatedDoc = await getSanityAgentTranslation({
-        sourceDocument,
+        sourceDocument: transformedDocument,
         targetLanguage,
         languageFieldName,
         schemaId,
@@ -2442,7 +2676,7 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
         throw new Error("OpenAI is not configured but openai-only mode was selected");
       setJobStatus(dispatch, sourceDocument._id, targetLanguage, "translating_with_openai"), translatedDoc = await getOpenAITranslation({
         dispatch,
-        sourceDocument,
+        sourceDocument: transformedDocument,
         targetLanguage,
         languageFieldName,
         translationPrompts,
@@ -2457,8 +2691,17 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
   }
   if (!translatedDoc)
     return null;
-  const targetDocumentPublishedId = existingTranslationId || uuid(), targetDocumentVersionId = `versions.${releaseId}.${targetDocumentPublishedId}`, newDoc = {
-    ...translatedDoc,
+  devLog.debug("Restoring field transforms after translation", {
+    documentId: sourceDocument._id,
+    documentType: sourceDocument._type
+  });
+  const finalDoc = restoreTransforms({
+    translatedDocument: translatedDoc,
+    originalStructure,
+    registry: globalTransformRegistry,
+    schemaType: sourceDocument._type
+  }), targetDocumentPublishedId = existingTranslationId || uuid(), targetDocumentVersionId = `versions.${releaseId}.${targetDocumentPublishedId}`, newDoc = {
+    ...finalDoc,
     _id: targetDocumentVersionId
   };
   return await client.action({
@@ -2502,23 +2745,50 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
       });
       return;
     }
-    const existingTranslationId = getExistingTranslationId(translationMetadata, targetLanguage), newDocument = await handleTranslation({
-      dispatch,
-      client,
-      schemaId,
-      sourceDocument,
-      targetLanguage,
-      existingTranslationId,
-      languageFieldName,
-      translationPrompts,
-      translationMode,
-      openaiConfig,
-      releaseId
-    });
-    if (!newDocument) {
-      setJobStatus(dispatch, sourceDocument._id, targetLanguage, "error"), devLog.timeEnd("translateDocument"), devLog.groupEnd();
+    const existingTranslationId = getExistingTranslationId(translationMetadata, targetLanguage), translationResult = await withRetry(
+      () => handleTranslation({
+        dispatch,
+        client,
+        schemaId,
+        sourceDocument,
+        targetLanguage,
+        existingTranslationId,
+        languageFieldName,
+        translationPrompts,
+        translationMode,
+        openaiConfig,
+        releaseId
+      }),
+      {
+        maxRetries: 3,
+        initialDelayMs: 1e3,
+        isRetryable: isRetryableError,
+        onRetry: (attempt, error, delayMs) => {
+          devLog.warn("Translation failed, scheduling retry", {
+            ...logContext,
+            attempt,
+            delayMs,
+            error: error instanceof Error ? error.message : String(error)
+          }), setJobStatus(dispatch, sourceDocument._id, targetLanguage, "retrying", {
+            retryCount: attempt,
+            errorMessage: error instanceof Error ? error.message : String(error)
+          });
+        }
+      }
+    );
+    if (!translationResult.success || !translationResult.result) {
+      const errorMessage = translationResult.error instanceof Error ? translationResult.error.message : String(translationResult.error || "Translation failed");
+      devLog.error("Translation failed after retries", translationResult.error, {
+        ...logContext,
+        attempts: translationResult.attempts
+      }), setJobStatus(dispatch, sourceDocument._id, targetLanguage, "error", {
+        errorMessage,
+        retryCount: translationResult.attempts - 1
+        // -1 because attempts includes initial try
+      }), devLog.timeEnd("translateDocument"), devLog.groupEnd();
       return;
     }
+    const newDocument = translationResult.result;
     return setJobStatus(dispatch, sourceDocument._id, targetLanguage, "updating_metadata", {
       targetId: newDocument._id
     }), await updateTranslationMetadata({
@@ -2588,7 +2858,7 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
       {
         _id: sourceDocument._id,
         _type: sourceDocument._type,
-        // TODO: Handle this properly
+        // TODO: Extract document title more robustly across schema types
         title: sourceDocument.name || sourceDocument.title
       },
       ...references
@@ -3098,12 +3368,17 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
             job.status === "error" && job.errorMessage ? /* @__PURE__ */ jsx(Card, { tone: "critical", padding: 2, radius: 2, children: /* @__PURE__ */ jsxs(Text, { size: 1, children: [
               "Error: ",
               job.errorMessage
+            ] }) }) : null,
+            job.status === "retrying" && job.errorMessage ? /* @__PURE__ */ jsx(Card, { tone: "caution", padding: 2, radius: 2, children: /* @__PURE__ */ jsxs(Text, { size: 1, children: [
+              "Retrying after: ",
+              job.errorMessage
             ] }) }) : null
           ] })
         ] }),
         /* @__PURE__ */ jsxs(Flex, { gap: 2, align: "center", children: [
           job.status === "skipped" ? /* @__PURE__ */ jsx(SkippedBadge, {}) : null,
-          job.status === "error" ? /* @__PURE__ */ jsx(ErrorBadge, {}) : null,
+          job.status === "error" ? /* @__PURE__ */ jsx(ErrorBadge, { retryCount: job.retryCount }) : null,
+          job.status === "retrying" ? /* @__PURE__ */ jsx(RetryingBadge, { retryCount: job.retryCount }) : null,
           job.targetId ? /* @__PURE__ */ jsx(
             TranslationOpenerButton,
             {
@@ -3183,12 +3458,25 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
     content: /* @__PURE__ */ jsx(Box, { padding: 1, children: /* @__PURE__ */ jsx(Text, { size: 1, muted: !0, children: "There was already a fresh translation for this document and language." }) }),
     children: /* @__PURE__ */ jsx(Badge, { tone: "neutral", children: "Skipped" })
   }
-), ErrorBadge = () => /* @__PURE__ */ jsx(
+), ErrorBadge = ({ retryCount }) => /* @__PURE__ */ jsx(
   Tooltip,
   {
     portal: !0,
-    content: /* @__PURE__ */ jsx(Box, { padding: 1, children: /* @__PURE__ */ jsx(Text, { size: 1, muted: !0, children: "This translation failed. Check the error message for details." }) }),
-    children: /* @__PURE__ */ jsx(Badge, { tone: "critical", children: "Failed" })
+    content: /* @__PURE__ */ jsx(Box, { padding: 1, children: /* @__PURE__ */ jsx(Text, { size: 1, muted: !0, children: retryCount && retryCount > 0 ? `This translation failed after ${retryCount} retry attempt${retryCount > 1 ? "s" : ""}.` : "This translation failed. Check the error message for details." }) }),
+    children: /* @__PURE__ */ jsxs(Badge, { tone: "critical", children: [
+      "Failed",
+      retryCount && retryCount > 0 ? ` (${retryCount} retries)` : ""
+    ] })
+  }
+), RetryingBadge = ({ retryCount }) => /* @__PURE__ */ jsx(
+  Tooltip,
+  {
+    portal: !0,
+    content: /* @__PURE__ */ jsx(Box, { padding: 1, children: /* @__PURE__ */ jsx(Text, { size: 1, muted: !0, children: "Retrying translation after a temporary failure." }) }),
+    children: /* @__PURE__ */ jsxs(Badge, { tone: "caution", children: [
+      "Retry ",
+      retryCount || 1
+    ] })
   }
 ), getStatusLabel = (status) => ({
   idle: "Idle",
@@ -3198,6 +3486,7 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
   translating_with_openai: "Translating with GPT-5...",
   reviewing_with_openai: "Reviewing translation with GPT-5...",
   updating_metadata: "Saving metadata...",
+  retrying: "Retrying...",
   error: "Error",
   skipped: "Skipped",
   completed: "Completed"
@@ -3236,7 +3525,427 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
       content: /* @__PURE__ */ jsx(TranslationContextProvider, { document, config, children: /* @__PURE__ */ jsx(TranslationDialog, { setIsDialogOpen }) })
     }
   } : (devLog.error("Missing config in TranslateAction"), null);
-}, aiTranslationPlugin = definePlugin((config) => ({
+}, translationGlossaryTerm = defineType({
+  name: "translationGlossaryTerm",
+  title: "Translation Glossary Term",
+  icon: TranslateIcon,
+  type: "document",
+  fields: [
+    defineField({
+      name: "translations",
+      title: "Translations",
+      type: "internationalizedArrayString"
+    })
+  ],
+  preview: {
+    select: {
+      translations: "translations"
+    },
+    prepare({ translations }) {
+      const enTranslation = translations?.find((t) => t.locale === "en-us"), firstTranslation = translations?.[0];
+      return {
+        title: enTranslation?.value || firstTranslation?.value || "No translation available"
+      };
+    }
+  }
+}), translationHistory = defineField({
+  name: "translationHistory",
+  type: "array",
+  of: [
+    {
+      name: "targetLanguageHistory",
+      type: "object",
+      fields: [
+        defineField({
+          name: "language",
+          title: "Language",
+          description: "The language of the target document",
+          type: "string"
+        }),
+        defineField({
+          name: "sourceId",
+          title: "Source ID",
+          description: "The ID of the source document",
+          type: "string"
+        }),
+        defineField({
+          name: "sourceRev",
+          title: "Source Revision",
+          description: "The revision ID of the source document at the time of translation",
+          type: "string"
+        }),
+        defineField({
+          name: "sourceLanguage",
+          title: "Source Language",
+          description: "The language of the source document",
+          type: "string"
+        }),
+        defineField({
+          name: "sourceSnapshot",
+          title: "Source Snapshot",
+          description: "The snapshot of the source document at the time of translation",
+          type: "text"
+        }),
+        defineField({
+          name: "targetId",
+          title: "Target ID",
+          description: "The ID of the target document",
+          type: "string"
+        })
+      ]
+    }
+  ]
+}), translationSettings = defineType({
+  name: "translationSettings",
+  title: "Translation Settings",
+  icon: TranslateIcon,
+  type: "document",
+  groups: [
+    {
+      name: "general",
+      title: "General",
+      default: !0
+    },
+    {
+      name: "history",
+      title: "History"
+    }
+  ],
+  fields: [
+    defineField({
+      name: "globalPrompt",
+      title: "Global Translation Prompt",
+      description: "A prompt that will given to the Sanity AI Agent for all translation tasks.",
+      type: "text",
+      rows: 5,
+      group: "general"
+    }),
+    defineField({
+      name: "localePrompts",
+      title: "Locale Prompts",
+      description: "Prompts that will be given to the Sanity AI Agent for each locale.",
+      type: "internationalizedArrayText",
+      group: "general"
+    }),
+    defineField({
+      name: "protectedPhrases",
+      title: "Protected Phrases",
+      description: "Phrases that will never be translated.",
+      type: "array",
+      of: [{ type: "string" }],
+      group: "general"
+    }),
+    defineField({
+      name: "changeHistory",
+      title: "Change History",
+      description: "History of changes made via user feedback.",
+      type: "array",
+      readOnly: !0,
+      group: "history",
+      of: [
+        {
+          type: "object",
+          fields: [
+            defineField({
+              name: "timestamp",
+              title: "Timestamp",
+              type: "datetime"
+            }),
+            defineField({
+              name: "changeType",
+              title: "Change Type",
+              type: "string",
+              options: {
+                list: [
+                  { title: "Global Prompt", value: "globalPrompt" },
+                  { title: "Locale Prompt", value: "localePrompt" },
+                  { title: "Protected Phrase", value: "protectedPhrase" },
+                  { title: "Glossary Term", value: "glossaryTerm" }
+                ]
+              }
+            }),
+            defineField({
+              name: "description",
+              title: "Description",
+              type: "text",
+              rows: 3
+            }),
+            defineField({
+              name: "locale",
+              title: "Locale",
+              type: "string",
+              description: "Target locale for locale-specific changes"
+            })
+          ],
+          preview: {
+            select: {
+              timestamp: "timestamp",
+              changeType: "changeType",
+              description: "description"
+            },
+            prepare({ timestamp, changeType, description }) {
+              return {
+                title: `${changeType} - ${new Date(timestamp).toLocaleDateString()}`,
+                subtitle: description
+              };
+            }
+          }
+        }
+      ]
+    })
+  ],
+  preview: {
+    prepare: () => ({
+      title: "Translation Settings"
+    })
+  }
+});
+function isPortableText(value) {
+  return Array.isArray(value) && value.some((item) => item?._type === "block");
+}
+const richTextTransform = {
+  // Matcher combines field name pattern with value-based detection
+  // fieldPath pattern acts as a pre-filter for performance
+  // valueMatcher definitively checks if the value is actually Portable Text
+  matcher: {
+    // Pre-filter: Match all fields to enable detection based solely on value
+    fieldPath: /.*/,
+    // Definitive check: Verify the value is actually Portable Text
+    valueMatcher: (value) => Array.isArray(value) && isPortableText(value)
+  },
+  toTranslatable: (value, context) => {
+    if (!Array.isArray(value) || !isPortableText(value))
+      return {
+        _type: "translatable.richtext",
+        translationText: JSON.stringify(value),
+        _originalValue: value
+      };
+    devLog.info("Applying rich text transform with XML serialization", {
+      fieldPath: context.fieldPath,
+      blockCount: value.length
+    });
+    try {
+      const tempDoc = {
+        _id: "temp",
+        _type: "richTextWrapper",
+        _createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        _updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        _rev: "temp",
+        content: value
+      }, serialized = serializeDocument(tempDoc);
+      devLog.debug("Serialized rich text document", {
+        fieldPath: context.fieldPath,
+        serializedLength: serialized.length,
+        preview: serialized.substring(0, 200)
+      });
+      const contentRegex = /<field name="content"[^>]*>([\s\S]*)<\/field>/s, match = serialized.match(contentRegex);
+      if (match?.[1]) {
+        const result = {
+          _type: "translatable.richtext",
+          translationText: match[1].trim(),
+          _originalValue: value
+        };
+        return devLog.debug("Successfully extracted and wrapped rich text", {
+          fieldPath: context.fieldPath,
+          translationTextLength: result.translationText.length
+        }), result;
+      }
+      return devLog.warn("Failed to serialize rich text content - regex did not match", {
+        fieldPath: context.fieldPath,
+        serializedPreview: serialized.substring(0, 500)
+      }), {
+        _type: "translatable.richtext",
+        translationText: JSON.stringify(value),
+        _originalValue: value
+      };
+    } catch (error) {
+      return devLog.error("Error serializing rich text", error, {
+        fieldPath: context.fieldPath
+      }), {
+        _type: "translatable.richtext",
+        translationText: JSON.stringify(value),
+        _originalValue: value
+      };
+    }
+  },
+  fromTranslatable: (translatedValue, originalValue, context) => {
+    if (!translatedValue || translatedValue._type !== "translatable.richtext" || !translatedValue.translationText)
+      return devLog.debug("Value is not a translatable rich text object, returning original", {
+        fieldPath: context.fieldPath,
+        hasCorrectType: translatedValue._type === "translatable.richtext"
+      }), originalValue;
+    devLog.info("Deserializing rich text content", {
+      fieldPath: context.fieldPath,
+      translationTextLength: translatedValue.translationText.length
+    });
+    try {
+      const { translationText, _originalValue } = translatedValue, wrappedSerialized = `<field name="content">
+${translationText}
+</field>`;
+      devLog.debug("Prepared wrapped serialized content", {
+        fieldPath: context.fieldPath,
+        wrappedLength: wrappedSerialized.length,
+        preview: wrappedSerialized.substring(0, 300)
+      });
+      const tempOriginalDoc = {
+        _id: "temp",
+        _type: "richTextWrapper",
+        _createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        _updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        _rev: "temp",
+        content: originalValue
+      }, result = deserializeDocument(tempOriginalDoc, wrappedSerialized);
+      return devLog.debug("Deserialization result", {
+        fieldPath: context.fieldPath,
+        hasContent: !!result.content,
+        contentType: Array.isArray(result.content) ? "array" : typeof result.content,
+        contentLength: Array.isArray(result.content) ? result.content.length : void 0
+      }), result.content ? result.content : (devLog.warn("Deserialization returned no content, returning original", {
+        fieldPath: context.fieldPath,
+        resultKeys: Object.keys(result)
+      }), originalValue);
+    } catch (error) {
+      return devLog.error("Failed to deserialize rich text", error, {
+        fieldPath: context.fieldPath
+      }), originalValue;
+    }
+  }
+}, vttCaptionTransform = {
+  matcher: {
+    fieldName: "captions",
+    schemaType: "video"
+  },
+  toTranslatable: (captionsArray, context) => {
+    if (devLog.info("VTT captions toTranslatable - input:", {
+      fieldPath: context.fieldPath,
+      isArray: Array.isArray(captionsArray),
+      count: Array.isArray(captionsArray) ? captionsArray.length : 0,
+      firstCaption: Array.isArray(captionsArray) && captionsArray.length > 0 ? captionsArray[0] : null
+    }), !Array.isArray(captionsArray))
+      return devLog.debug("VTT caption field is not an array, returning empty transform", {
+        fieldPath: context.fieldPath,
+        value: captionsArray
+      }), {
+        _type: "translatable.vtt.captions",
+        translationText: "",
+        _originalMetadata: []
+      };
+    devLog.info("Applying VTT caption hybrid transform", {
+      fieldPath: context.fieldPath,
+      count: captionsArray.length
+    });
+    const translationText = serializeVTTCaptionText(captionsArray), originalMetadata = captionsArray.map((caption, index) => {
+      const { text: _text, ...metadata } = caption;
+      return {
+        ...metadata,
+        _originalIndex: index
+      };
+    });
+    return devLog.info("VTT captions serialized:", {
+      fieldPath: context.fieldPath,
+      translationTextLength: translationText.length,
+      translationTextPreview: translationText.substring(0, 200) + (translationText.length > 200 ? "..." : ""),
+      metadataCount: originalMetadata.length,
+      metadataExample: originalMetadata.length > 0 ? originalMetadata[0] : null
+    }), {
+      _type: "translatable.vtt.captions",
+      translationText,
+      _originalMetadata: originalMetadata
+    };
+  },
+  fromTranslatable: (translatedValue, _originalValue, context) => {
+    if (devLog.info("VTT captions fromTranslatable - input:", {
+      fieldPath: context.fieldPath,
+      valueType: typeof translatedValue,
+      isCorrectType: translatedValue._type === "translatable.vtt.captions",
+      hasText: !!translatedValue.translationText,
+      hasMetadata: Array.isArray(translatedValue._originalMetadata)
+    }), !translatedValue || translatedValue._type !== "translatable.vtt.captions" || !translatedValue.translationText || !Array.isArray(translatedValue._originalMetadata))
+      return devLog.debug("Value is not a translatable VTT caption object, skipping transform", {
+        fieldPath: context.fieldPath,
+        valueType: typeof translatedValue,
+        translatedValue
+      }), [];
+    devLog.info("Processing translated VTT captions", {
+      fieldPath: context.fieldPath,
+      metadataCount: translatedValue._originalMetadata.length
+    });
+    const { translationText, _originalMetadata } = translatedValue;
+    devLog.info("VTT captions translationText:", {
+      fieldPath: context.fieldPath,
+      translationTextLength: translationText.length,
+      translationTextPreview: translationText.substring(0, 200) + (translationText.length > 200 ? "..." : "")
+    });
+    const result = deserializeVTTCaptionText(translationText, _originalMetadata);
+    return devLog.info("VTT captions final result:", {
+      fieldPath: context.fieldPath,
+      resultCount: result.length,
+      resultExample: result.length > 0 ? result[0] : null
+    }), result;
+  }
+};
+function serializeVTTCaptionText(captions) {
+  if (devLog.debug("serializeVTTCaptionText - input:", {
+    captionsCount: captions.length,
+    firstCaption: captions.length > 0 ? captions[0] : null
+  }), !Array.isArray(captions) || captions.length === 0)
+    return "";
+  const result = captions.map((caption, index) => (devLog.debug(`Processing caption ${index}:`, {
+    text: caption.text,
+    hasText: typeof caption.text == "string"
+  }), `[${index}] ${caption.text || ""}`)).join(`
+`);
+  return devLog.debug("serializeVTTCaptionText - output:", {
+    resultLength: result.length,
+    resultPreview: result.substring(0, 100) + (result.length > 100 ? "..." : "")
+  }), result;
+}
+function deserializeVTTCaptionText(translationText, originalMetadata) {
+  if (devLog.debug("deserializeVTTCaptionText - input:", {
+    translationTextLength: translationText.length,
+    translationTextPreview: translationText.substring(0, 100) + (translationText.length > 100 ? "..." : ""),
+    metadataCount: originalMetadata.length,
+    metadataExample: originalMetadata.length > 0 ? originalMetadata[0] : null
+  }), !translationText || translationText.trim() === "")
+    return [];
+  const result = [], lines = translationText.split(`
+`), lineRegex = /^\[(\d+)\]\s*(.*)$/;
+  for (const line of lines) {
+    const match = line.match(lineRegex);
+    if (!match) {
+      devLog.warn("Failed to parse caption line", { line });
+      continue;
+    }
+    const index = Number.parseInt(match[1], 10), text = match[2];
+    devLog.debug("Found caption:", {
+      index,
+      text
+    });
+    const metadata = originalMetadata.find((m) => m._originalIndex === index);
+    if (metadata) {
+      devLog.debug(`Found matching metadata for index ${index}`);
+      const { _originalIndex, ...metadataWithoutIndex } = metadata;
+      result.push({
+        ...metadataWithoutIndex,
+        text
+      });
+    } else
+      devLog.warn("Missing metadata for caption", { index }), result.push({
+        _type: "vtt.cue",
+        _key: `caption-${index}`,
+        text,
+        startTime: 0,
+        endTime: 0
+      });
+  }
+  return result.length < originalMetadata.length && devLog.warn(`Missing captions in translation: found ${result.length} out of ${originalMetadata.length}`), devLog.debug("deserializeVTTCaptionText - output:", {
+    resultCount: result.length,
+    resultExample: result.length > 0 ? result[0] : null
+  }), result;
+}
+const aiTranslationPlugin = definePlugin((config) => (config.fieldTransforms?.length && (devLog.info(`Registering ${config.fieldTransforms.length} custom field transforms`), config.fieldTransforms.forEach((transform) => {
+  globalTransformRegistry.register(transform);
+})), {
   name: "sanity-plugin-ai-translation",
   document: {
     actions: [getTranslateAction(config), getGiveTranslationFeedbackAction(config)]
@@ -3247,6 +3956,8 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
 })), translationHistorySchema = translationHistory;
 export {
   aiTranslationPlugin,
-  translationHistorySchema
+  richTextTransform,
+  translationHistorySchema,
+  vttCaptionTransform
 };
 //# sourceMappingURL=index.js.map