@braze/sanity-plugin-ai-translation 0.2.1 → 0.2.3

package/dist/index.js

@@ -1,15 +1,68 @@
-import { useClient, defineType, defineField, 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",
@@ -24,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),
@@ -58,31 +223,6 @@ const TranslationContext = createContext({
     loading,
     error
   };
-}, isLoggingEnabled = () => process.env.NEXT_PUBLIC_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" };
@@ -191,12 +331,7 @@ async function analyzeFeedback({
   currentDocument,
   onProgress
 }) {
-  devLog.info("Starting feedback analysis", {
-    sourceLanguage,
-    targetLanguage,
-    hasUserFeedback: !!userFeedback,
-    shouldIncludeEdits
-  }), onProgress?.({ stage: "analyzing", message: "Analyzing feedback and edits..." });
+  onProgress?.({ stage: "analyzing", message: "Analyzing feedback and edits..." });
   const analysisPrompt = buildAnalysisPrompt({
     sourceLanguage,
     targetLanguage,
@@ -205,10 +340,8 @@ async function analyzeFeedback({
     sourceSnapshot,
     targetSnapshot,
     currentDocument
-  }), analysis = await analyzeWithAI(client, analysisPrompt);
-  devLog.info("AI analysis complete", { analysis });
-  const suggestions = convertAnalysisToSuggestions(analysis, sourceLanguage, targetLanguage);
-  devLog.info("Generated suggestions", { count: suggestions.length }), onProgress?.({ stage: "analyzing", message: "Validating suggestions..." });
+  }), analysis = await analyzeWithAI(client, analysisPrompt), suggestions = convertAnalysisToSuggestions(analysis, sourceLanguage, targetLanguage);
+  onProgress?.({ stage: "analyzing", message: "Validating suggestions..." });
   const validatedSuggestions = await Promise.all(
     suggestions.map(async (suggestion) => {
       const validation = await validateSuggestion(client, suggestion);
@@ -221,7 +354,10 @@ async function analyzeFeedback({
       };
     })
   );
-  return devLog.info("Suggestions validated", {
+  return devLog.info("Feedback analysis complete", {
+    sourceLanguage,
+    targetLanguage,
+    total: validatedSuggestions.length,
     valid: validatedSuggestions.filter((s) => s.validationStatus === "valid").length,
     warnings: validatedSuggestions.filter((s) => s.validationStatus === "warning").length,
     invalid: validatedSuggestions.filter((s) => s.validationStatus === "invalid").length
@@ -235,24 +371,18 @@ async function applySuggestions({
   suggestions,
   onProgress
 }) {
-  if (devLog.info("Applying suggestions", {
-    sourceLanguage,
-    targetLanguage,
-    targetLanguageType: typeof targetLanguage,
-    targetLanguageValue: targetLanguage,
-    count: suggestions.filter((s) => s.approved).length
-  }), !targetLanguage)
+  if (!targetLanguage)
     throw devLog.error("targetLanguage is undefined in applySuggestions!", {
       sourceLanguage,
       targetLanguage,
       suggestionsCount: suggestions.length
     }), new Error("targetLanguage is required but was undefined");
   const approvedSuggestions = suggestions.filter((s) => s.approved);
-  if (approvedSuggestions.length === 0) {
-    devLog.info("No approved suggestions to apply");
-    return;
-  }
-  onProgress?.({ stage: "applying", message: "Applying updates to translation settings..." }), await applyImprovementsFromSuggestions(client, schemaId, targetLanguage, approvedSuggestions, onProgress), devLog.info("Suggestions applied successfully");
+  approvedSuggestions.length !== 0 && (onProgress?.({ stage: "applying", message: "Applying updates to translation settings..." }), await applyImprovementsFromSuggestions(client, schemaId, targetLanguage, approvedSuggestions, onProgress), devLog.info("Suggestions applied successfully", {
+    sourceLanguage,
+    targetLanguage,
+    count: approvedSuggestions.length
+  }));
 }
 function buildAnalysisPrompt({
   sourceLanguage,
@@ -420,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,
@@ -470,49 +600,21 @@ function parseAIResponse(responseText) {
   }
 }
 async function applyImprovementsFromSuggestions(client, schemaId, targetLanguage, suggestions, onProgress) {
-  devLog.info("Applying improvements from suggestions", {
-    count: suggestions.length,
-    targetLanguage,
-    suggestions: suggestions.map((s) => ({
-      type: s.type,
-      approved: s.approved,
-      sourceLocale: s.sourceLocale,
-      targetLocale: s.targetLocale,
-      sourceValue: s.sourceValue,
-      targetValue: s.targetValue
-    }))
-  });
   const settingsId = "translation-settings";
   await client.fetch("*[_id == $id][0]", { id: settingsId }) || await client.createIfNotExists({
     _id: settingsId,
     _type: "translationSettings"
   });
-  const updates = [], globalPrompts = suggestions.filter((s) => s.type === "globalPrompt" && s.description.trim()), localePrompts = suggestions.filter((s) => s.type === "localePrompt" && s.description.trim()), protectedPhrases = suggestions.filter((s) => s.type === "protectedPhrase" && s.description.trim()), glossaryTermsBeforeFilter = suggestions.filter((s) => s.type === "glossaryTerm");
-  devLog.info("Glossary terms before filtering", {
-    count: glossaryTermsBeforeFilter.length,
-    terms: glossaryTermsBeforeFilter.map((s) => ({
-      sourceLocale: s.sourceLocale,
-      sourceValue: s.sourceValue,
-      targetLocale: s.targetLocale,
-      targetValue: s.targetValue,
-      approved: s.approved
-    }))
-  });
-  const glossaryTerms = suggestions.filter(
+  const updates = [], globalPrompts = suggestions.filter((s) => s.type === "globalPrompt" && s.description.trim()), localePrompts = suggestions.filter((s) => s.type === "localePrompt" && s.description.trim()), protectedPhrases = suggestions.filter((s) => s.type === "protectedPhrase" && s.description.trim()), glossaryTerms = suggestions.filter(
     (s) => s.type === "glossaryTerm" && s.sourceLocale?.trim() && s.sourceValue?.trim() && s.targetLocale?.trim() && s.targetValue?.trim()
   );
-  if (devLog.info("Filtered suggestions by type", {
-    globalPrompts: globalPrompts.length,
-    localePrompts: localePrompts.length,
-    protectedPhrases: protectedPhrases.length,
-    glossaryTerms: glossaryTerms.length
-  }), (globalPrompts.length > 0 || localePrompts.length > 0) && (onProgress?.({
+  if ((globalPrompts.length > 0 || localePrompts.length > 0) && (onProgress?.({
     stage: "applying",
     message: globalPrompts.length > 0 && localePrompts.length > 0 ? "Updating global and locale translation prompts..." : globalPrompts.length > 0 ? "Updating global translation prompt..." : `Updating ${targetLanguage} translation prompt...`
   }), updates.push(updatePromptsWithTemplate(client, schemaId, settingsId, targetLanguage, globalPrompts, localePrompts))), protectedPhrases.length > 0) {
     onProgress?.({ stage: "applying", message: "Adding protected phrases..." });
     const phrases = protectedPhrases.map((s) => s.description);
-    devLog.debug("Applying protected phrases", { phrases }), updates.push(addProtectedPhrases(client, settingsId, phrases));
+    updates.push(addProtectedPhrases(client, settingsId, phrases));
   }
   if (glossaryTerms.length > 0) {
     onProgress?.({ stage: "applying", message: "Adding glossary terms..." });
@@ -524,22 +626,17 @@ async function applyImprovementsFromSuggestions(client, schemaId, targetLanguage
       targetValue: s.targetValue
       // biome-ignore-end lint/style/noNonNullAssertion: safely handled
     }));
-    devLog.debug("Applying glossary terms", { terms }), updates.push(addGlossaryTerms(client, terms));
+    updates.push(addGlossaryTerms(client, terms));
   }
   updates.length === 0 && devLog.warn("No valid updates to apply - all suggestions may have been empty"), await Promise.all(updates), onProgress?.({ stage: "applying", message: "Recording changes..." }), await recordChangeHistory(
     client,
     settingsId,
     targetLanguage,
     suggestions.filter((s) => s.approved)
-  ), devLog.info("All improvements applied successfully");
+  );
 }
 async function updatePromptsWithTemplate(client, _schemaId, settingsId, targetLanguage, globalPrompts, localePrompts) {
-  if (devLog.info("Updating prompts with deterministic template", {
-    settingsId,
-    targetLanguage,
-    hasGlobalUpdates: globalPrompts.length > 0,
-    hasLocaleUpdates: localePrompts.length > 0
-  }), !targetLanguage)
+  if (!targetLanguage)
     throw devLog.error("targetLanguage is undefined or empty!", {
       targetLanguage,
       globalPrompts: globalPrompts.length,
@@ -555,11 +652,7 @@ async function updatePromptsWithTemplate(client, _schemaId, settingsId, targetLa
       ...updates.map((update) => `- ${update}`)
     ].filter(Boolean).join(`
 `);
-    await client.patch(settingsId).set({ globalPrompt: newGlobalPrompt }).commit(), devLog.info("Global prompt updated", {
-      previousLength: currentGlobalPrompt.length,
-      newLength: newGlobalPrompt.length,
-      addedUpdates: updates.length
-    });
+    await client.patch(settingsId).set({ globalPrompt: newGlobalPrompt }).commit();
   }
   if (localePrompts.length > 0) {
     const updates = localePrompts.map((s) => s.description.trim()).filter(Boolean), existingLocalePrompts = currentSettings?.localePrompts || [], existingLocalePrompt = existingLocalePrompts.find((lp) => lp._key === targetLanguage);
@@ -572,12 +665,7 @@ async function updatePromptsWithTemplate(client, _schemaId, settingsId, targetLa
         ...updates.map((update) => `- ${update}`)
       ].filter(Boolean).join(`
 `), localeIndex = existingLocalePrompts.findIndex((lp) => lp._key === targetLanguage);
-      await client.patch(settingsId).set({ [`localePrompts[${localeIndex}].value`]: newValue }).commit(), devLog.info("Locale prompt updated", {
-        targetLanguage,
-        previousLength: currentValue.length,
-        newLength: newValue.length,
-        addedUpdates: updates.length
-      });
+      await client.patch(settingsId).set({ [`localePrompts[${localeIndex}].value`]: newValue }).commit();
     } else {
       const newValue = [`## User Feedback (${timestamp})`, ...updates.map((update) => `- ${update}`)].filter(Boolean).join(`
 `);
@@ -587,22 +675,17 @@ async function updatePromptsWithTemplate(client, _schemaId, settingsId, targetLa
           _key: targetLanguage,
           value: newValue
         }
-      ]).commit(), devLog.info("Locale prompt created", {
-        targetLanguage,
-        length: newValue.length,
-        addedUpdates: updates.length
-      });
+      ]).commit();
     }
   }
   devLog.info("Prompts updated successfully", {
+    targetLanguage,
     globalUpdated: globalPrompts.length > 0,
     localeUpdated: localePrompts.length > 0
   });
 }
 async function addProtectedPhrases(client, settingsId, phrases) {
-  devLog.info("Adding protected phrases", { settingsId, phrasesCount: phrases.length, phrases });
   const currentPhrases = await client.fetch("*[_id == $settingsId][0].protectedPhrases", { settingsId });
-  devLog.debug("Fetched current protected phrases", { currentCount: currentPhrases?.length });
   let newPhrases = phrases.filter((phrase) => !currentPhrases?.includes(phrase));
   const conflictingPhrases = [];
   for (const phrase of newPhrases)
@@ -610,12 +693,7 @@ async function addProtectedPhrases(client, settingsId, phrases) {
       'count(*[_type == "translationGlossaryTerm" && count(translations[value == $phrase]) > 0]) > 0',
       { phrase }
     ) && (conflictingPhrases.push(phrase), devLog.warn("Skipping protected phrase due to glossary conflict", { phrase }));
-  if (newPhrases = newPhrases.filter((phrase) => !conflictingPhrases.includes(phrase)), newPhrases.length === 0) {
-    devLog.info("No new protected phrases to add (all already exist)");
-    return;
-  }
-  const result = await client.patch(settingsId).setIfMissing({ protectedPhrases: [] }).append("protectedPhrases", newPhrases).commit();
-  devLog.info("Protected phrases added", { count: newPhrases.length, phrases: newPhrases, resultId: result._id });
+  newPhrases = newPhrases.filter((phrase) => !conflictingPhrases.includes(phrase)), newPhrases.length !== 0 && (await client.patch(settingsId).setIfMissing({ protectedPhrases: [] }).append("protectedPhrases", newPhrases).commit(), devLog.info("Protected phrases added", { count: newPhrases.length }));
 }
 async function addGlossaryTerms(client, terms) {
   const protectedPhrasesLower = (await client.fetch('*[_id == "translation-settings"][0].protectedPhrases'))?.map((p) => p.toLowerCase()) || [], validTerms = terms.filter(({ sourceValue, targetValue }) => sourceValue === targetValue ? (devLog.warn("Skipping glossary term where source === target (should be a protected phrase)", {
@@ -643,29 +721,13 @@ async function addGlossaryTerms(client, terms) {
     );
     if (existingTerm) {
       const existingTargetIndex = existingTerm.translations.findIndex((t) => t._key === targetLocale), existingTargetValue = existingTargetIndex >= 0 ? existingTerm.translations[existingTargetIndex].value : null;
-      existingTargetIndex === -1 ? (await client.patch(existingTerm._id).append("translations", [
+      existingTargetIndex === -1 ? await client.patch(existingTerm._id).append("translations", [
         {
           _type: "internationalizedArrayStringValue",
           _key: targetLocale,
           value: targetValue
         }
-      ]).commit(), devLog.info("Added target language to existing glossary term", {
-        sourceLocale,
-        sourceValue,
-        targetLocale,
-        targetValue
-      })) : existingTargetValue !== targetValue ? (await client.patch(existingTerm._id).set({ [`translations[${existingTargetIndex}].value`]: targetValue }).commit(), devLog.info("Updated existing glossary term translation", {
-        sourceLocale,
-        sourceValue,
-        targetLocale,
-        oldValue: existingTargetValue,
-        newValue: targetValue
-      })) : devLog.info("Glossary term already has this exact translation", {
-        sourceLocale,
-        sourceValue,
-        targetLocale,
-        targetValue
-      });
+      ]).commit() : existingTargetValue !== targetValue && await client.patch(existingTerm._id).set({ [`translations[${existingTargetIndex}].value`]: targetValue }).commit();
     } else
       await client.create({
         _type: "translationGlossaryTerm",
@@ -681,11 +743,10 @@ async function addGlossaryTerms(client, terms) {
             value: targetValue
           }
         ]
-      }), devLog.info("Created new glossary term", { sourceLocale, sourceValue, targetLocale, targetValue });
+      });
   }
   devLog.info("Glossary terms processed", {
-    totalRequested: terms.length,
-    validAdded: validTerms.length,
+    processed: validTerms.length,
     skipped: terms.length - validTerms.length
   });
 }
@@ -698,10 +759,7 @@ async function recordChangeHistory(client, settingsId, targetLanguage, suggestio
     description: suggestion.description,
     locale: suggestion.type === "localePrompt" ? targetLanguage : void 0
   }));
-  historyEntries.length !== 0 && (await client.patch(settingsId).setIfMissing({ changeHistory: [] }).append("changeHistory", historyEntries).commit(), devLog.info("Change history recorded", {
-    count: historyEntries.length,
-    timestamp
-  }));
+  historyEntries.length !== 0 && await client.patch(settingsId).setIfMissing({ changeHistory: [] }).append("changeHistory", historyEntries).commit();
 }
 const ICON_SIZE = 64, progressIconMap = {
   in_progress: /* @__PURE__ */ jsx(Spinner, {}),
@@ -1150,145 +1208,6 @@ 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);
-      return newTranslationJobs.set(jobKey, defaults(action.payload, newTranslationJobs.get(jobKey))), {
-        ...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", {
@@ -1314,181 +1233,7 @@ const ICON_SIZE = 64, progressIconMap = {
       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 = [];
@@ -1755,7 +1500,12 @@ const fetchTranslationPrompts = async ({
     }
   };
   return recursiveSearch(obj, []), results;
-}, localizeReferences = async ({ client, documentId, languageFieldName }) => {
+}, localizeReferences = async ({
+  client,
+  documentId,
+  sourceLanguage,
+  languageFieldName
+}) => {
   try {
     const doc = await client.fetch("*[_id == $documentId][0]", { documentId });
     if (!doc) {
@@ -1777,25 +1527,26 @@ const fetchTranslationPrompts = async ({
     const refs = findKeyValues(doc, "_ref");
     if (!refs?.length)
       return;
-    await updateReferences(documentId, client, refs, targetLanguage);
+    await updateReferences(documentId, client, refs, sourceLanguage, targetLanguage);
   } catch (error) {
     devLog.error("Error localizing references", error instanceof Error ? error : new Error(String(error)), {
       documentId,
       component: "localizeReferences"
     });
   }
-}, updateReferences = async (documentId, client, refs, targetLanguage) => {
+}, updateReferences = async (documentId, client, refs, sourceLanguage, targetLanguage) => {
   if (!refs?.length)
     return [];
-  const refIds = refs.map((r) => undraftId(r.value)), translations = await client.fetch(
-    `*[_type == $translationMetadataSchemaType && count(translations[value._ref in $refIds]) > 0]
-      .translations[value._ref in $refIds]{
-        "sourceId": value._ref,
-        "targetId": ^.translations[_key == $targetLanguage][0].value._ref
-      }[defined(targetId)]`,
+  const refIds = refs.map((r) => getPublishedId(r.value)), translations = await client.fetch(
+    `*[_type == $translationMetadataSchemaType && array::intersects(translations[].value._ref, $refIds)] {
+      "sourceId": translations[_key == $sourceLanguage][0].value._ref,
+      "targetId": translations[_key == $targetLanguage][0].value._ref,
+      "targetType": translations[_key == $sourceLanguage][0].value -> _type
+    }`,
     {
       translationMetadataSchemaType: TRANSLATION_METADATA_TYPE,
       refIds,
+      sourceLanguage,
       targetLanguage
     }
   ), translationMap = /* @__PURE__ */ new Map();
@@ -1804,11 +1555,10 @@ const fetchTranslationPrompts = async ({
   const patch = client.patch(documentId);
   let hasChanges = !1;
   for (const ref of refs) {
-    const sourceId = undraftId(ref.value), newId = translationMap.get(sourceId);
-    newId && (patch.set({ [pathToString(ref.path)]: undraftId(newId) }), patch.set({ [`${pathToString(ref.path.slice(0, -1))}._weak`]: !0 }), patch.set({
+    const sourceId = getPublishedId(ref.value), newId = translationMap.get(sourceId);
+    newId && (patch.set({ [pathToString(ref.path)]: getPublishedId(newId) }), patch.set({
       [`${pathToString(ref.path.slice(0, -1))}._strengthenOnPublish`]: {
-        _type: "reference",
-        _weak: !1
+        type: translations.find((t) => t.targetId === getPublishedId(newId))?.targetType || void 0
       }
     }), hasChanges = !0);
   }
@@ -1833,7 +1583,9 @@ const fetchTranslationPrompts = async ({
         payload
       });
     }
-}, getTranslationMetadata = async ({
+}, getExistingTranslationId = (translationMetadata, targetLanguage) => translationMetadata?.translations?.length && translationMetadata.translations.find(
+  (translation) => translation._key === targetLanguage
+)?.value._ref || null, getTranslationMetadata = async ({
   client,
   sourceDocument,
   sourceLanguage
@@ -1882,7 +1634,7 @@ const fetchTranslationPrompts = async ({
       _type: "internationalizedArrayReferenceValue",
       value: {
         _type: "reference",
-        _ref: undraftId(newDocument._id),
+        _ref: getPublishedId(newDocument._id),
         _weak: !0,
         _strengthenOnPublish: {
           _type: "reference",
@@ -1892,7 +1644,7 @@ const fetchTranslationPrompts = async ({
     }, newTranslationHistory = {
       _key: targetLanguage,
       language: targetLanguage,
-      sourceId: undraftId(sourceDocument._id),
+      sourceId: getPublishedId(sourceDocument._id),
       sourceRev: sourceDocument._rev,
       sourceLanguage,
       sourceSnapshot: JSON.stringify(sourceDocument),
@@ -1922,70 +1674,214 @@ const fetchTranslationPrompts = async ({
       status
     })
   });
-}, getExistingTranslationId = (translationMetadata, targetLanguage) => translationMetadata?.translations?.length && translationMetadata.translations.find(
-  (translation) => translation._key === targetLanguage
-)?.value._ref || null, determineTranslationTarget = ({
-  translationMetadata,
-  targetLanguage
-}) => {
-  const existingTranslationId = getExistingTranslationId(translationMetadata, targetLanguage);
-  return existingTranslationId ? {
-    // Update existing translation
-    operation: "createOrReplace",
-    _id: existingTranslationId
-  } : {
-    // Create new translation
-    operation: "create"
-  };
-}, analyzeDocumentContent = (document) => {
-  let hasCodeBlocks = !1, hasInlineCode = !1, codeBlockCount = 0, inlineCodeCount = 0;
-  const hasMarkdown = !1;
-  let hasPortableText = !1, estimatedFieldCount = 0;
-  const traverse = (value, depth = 0) => {
-    value != null && (depth > 0 && typeof value == "object" && estimatedFieldCount++, Array.isArray(value) ? value.forEach((item) => {
-      item && typeof item == "object" && "_type" in item && item._type === "code" && (hasCodeBlocks = !0, codeBlockCount++, hasPortableText = !0), item && typeof item == "object" && "_type" in item && item._type === "block" && "children" in item && Array.isArray(item.children) && (hasPortableText = !0, item.children.forEach((child) => {
-        child && typeof child == "object" && "marks" in child && Array.isArray(child.marks) && child.marks.includes("code") && (hasInlineCode = !0, inlineCodeCount++);
-      })), traverse(item, depth + 1);
-    }) : typeof value == "object" && Object.values(value).forEach((val) => traverse(val, depth + 1)));
-  };
-  traverse(document);
-  let complexity = "simple";
-  return estimatedFieldCount > 50 ? complexity = "complex" : estimatedFieldCount > 20 && (complexity = "moderate"), {
-    hasCodeBlocks,
-    hasInlineCode,
-    codeBlockCount,
-    inlineCodeCount,
-    hasMarkdown,
-    hasPortableText,
-    complexity,
-    estimatedFieldCount
-  };
-}, assembleLanguageSpecs = ({
-  sourceDocument,
-  languageFieldName,
-  targetLanguage
-}) => {
-  const sourceLanugageId = sourceDocument[languageFieldName];
-  if (!sourceLanugageId)
-    throw new Error("[assembleLanguages] Source language ID is missing");
-  return {
-    fromLanguage: {
-      id: sourceLanugageId,
-      title: sourceLanugageId
-    },
-    toLanguage: {
-      id: targetLanguage,
-      title: targetLanguage
+};
+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: "gpt-5.1",
+    input: request.messages
+    // Uses 'input' instead of 'messages'
+  };
+  request.reasoningEffort && (requestBody.reasoning = {
+    effort: request.reasoningEffort,
+    summary: "auto"
+    // Enable automatic reasoning summaries
+  });
+  const response = await fetch("https://api.openai.com/v1/responses", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${apiKey}`
+    },
+    body: JSON.stringify(requestBody)
+  });
+  if (!response.ok) {
+    const error = await response.json();
+    throw new Error(`GPT-5 API error: ${error.error?.message || "Unknown error"}`);
+  }
+  const result = await response.json(), tokensUsed = {
+    prompt: result.usage?.input_tokens || 0,
+    completion: result.usage?.output_tokens || 0,
+    reasoning: result.usage?.output_tokens_details?.reasoning_tokens || 0,
+    total: result.usage?.total_tokens || 0
+  }, cost = calculateCost(tokensUsed, model);
+  let content = "";
+  if (result.output && Array.isArray(result.output)) {
+    const messageItem = result.output.find((item) => item.type === "message");
+    messageItem?.content && Array.isArray(messageItem.content) && (content = messageItem.content.find((item) => item.type === "output_text")?.text || "");
+  }
+  return content || (content = result.output_text || result.text || ""), {
+    content,
+    tokensUsed,
+    cost
   };
-}, callGPT5 = async (apiKey, request) => {
-  const model = request.model || "gpt-5", isGPT5 = model === "gpt-5", useStreaming = !!request.onReasoningChunk, requestBody = {
+}, callChatCompletionsAPI = async (apiKey, request) => {
+  const model = request.model || "gpt-4o", requestBody = {
     model,
     messages: request.messages,
-    stream: useStreaming
-  };
-  isGPT5 || (requestBody.temperature = request.temperature ?? 0.3), isGPT5 && (requestBody.reasoning_effort = request.reasoningEffort || "medium", requestBody.verbosity = request.verbosity || "medium");
-  const response = await fetch("https://api.openai.com/v1/chat/completions", {
+    temperature: request.temperature ?? 0.3
+  }, response = await fetch("https://api.openai.com/v1/chat/completions", {
     method: "POST",
     headers: {
       "Content-Type": "application/json",
@@ -1995,88 +1891,30 @@ const fetchTranslationPrompts = async ({
   });
   if (!response.ok) {
     const error = await response.json();
-    throw new Error(`GPT-5 API error: ${error.error?.message || "Unknown error"}`);
+    throw new Error(`OpenAI API error: ${error.error?.message || "Unknown error"}`);
   }
-  if (useStreaming && response.body && request.onReasoningChunk)
-    return await handleStreamingResponse(response, request.onReasoningChunk, model);
   const result = await response.json(), usage = result.usage || {}, tokensUsed = {
     prompt: usage.prompt_tokens || 0,
     completion: usage.completion_tokens || 0,
     reasoning: usage.reasoning_tokens || 0,
-    // New in GPT-5
     total: usage.total_tokens || 0
-  }, cost = calculateGPT5Cost(tokensUsed, request.model || "gpt-5"), messageContent = result.choices[0].message.content;
-  let reasoningSummary, actualContent = messageContent;
-  const reasoningMatch = messageContent.match(/^<reasoning>([\s\S]*?)<\/reasoning>\n\n([\s\S]*)$/i);
-  return reasoningMatch && (reasoningSummary = reasoningMatch[1].trim(), actualContent = reasoningMatch[2]), {
-    content: actualContent,
-    tokensUsed,
-    cost,
-    reasoningSummary
-  };
-}, handleStreamingResponse = async (response, onReasoningChunk, model) => {
-  if (!response.body)
-    throw new Error("Response body is null");
-  const reader = response.body.getReader(), decoder = new TextDecoder();
-  let fullContent = "", inReasoning = !1, reasoningBuffer = "", contentBuffer = "", tokensUsed = { prompt: 0, completion: 0, reasoning: 0, total: 0 };
-  try {
-    for (; ; ) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      const lines = decoder.decode(value, { stream: !0 }).split(`
-`).filter((line) => line.trim() !== "");
-      for (const line of lines)
-        if (line.startsWith("data: ")) {
-          const data = line.slice(6);
-          if (data === "[DONE]") continue;
-          try {
-            const parsed = JSON.parse(data);
-            parsed.usage && (tokensUsed = {
-              prompt: parsed.usage.prompt_tokens || 0,
-              completion: parsed.usage.completion_tokens || 0,
-              reasoning: parsed.usage.reasoning_tokens || 0,
-              total: parsed.usage.total_tokens || 0
-            });
-            const delta = parsed.choices?.[0]?.delta?.content;
-            if (delta)
-              if (fullContent += delta, delta.includes("<reasoning>")) {
-                inReasoning = !0;
-                const parts = delta.split("<reasoning>");
-                reasoningBuffer += parts[1] || "";
-              } else if (delta.includes("</reasoning>")) {
-                inReasoning = !1;
-                const parts = delta.split("</reasoning>");
-                reasoningBuffer += parts[0] || "", contentBuffer += parts[1] || "";
-              } else inReasoning ? (reasoningBuffer += delta, onReasoningChunk(reasoningBuffer)) : contentBuffer += delta;
-          } catch {
-          }
-        }
-    }
-  } finally {
-    reader.releaseLock();
-  }
-  const cost = calculateGPT5Cost(tokensUsed, model);
+  }, cost = calculateCost(tokensUsed, model);
   return {
-    content: contentBuffer || fullContent,
+    content: result.choices[0].message.content || "",
     tokensUsed,
-    cost,
-    reasoningSummary: reasoningBuffer || void 0
+    cost
   };
-}, calculateGPT5Cost = (tokens, model) => {
+}, calculateCost = (tokens, model) => {
   const pricing = {
     "gpt-5": {
       input: 2e-6,
-      // $0.002 per 1k input tokens
       output: 1e-5,
-      // $0.010 per 1k output tokens
       reasoning: 5e-6
-      // $0.005 per 1k reasoning tokens
     },
     "gpt-4o": {
       input: 5e-6,
       output: 14999999999999999e-21,
       reasoning: 0
-      // No reasoning tokens in GPT-4
     },
     "gpt-4-turbo": {
       input: 1e-5,
@@ -2096,9 +1934,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 = {
@@ -2121,7 +2002,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;
     }
@@ -2149,6 +2044,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);
@@ -2178,10 +2083,27 @@ const fetchTranslationPrompts = async ({
     return;
   }
   const children = block.children;
-  Array.isArray(children) && blockNode.children.forEach((spanNode, idx) => {
+  Array.isArray(children) && blockNode.children.some((c) => c.type === "span") ? blockNode.children.forEach((spanNode, idx) => {
     const childItem = children[idx];
     spanNode.type === "span" && childItem && applySpanChanges(childItem, spanNode);
+  }) : blockNode.children.some((c) => c.type === "field") && blockNode.children.forEach((fieldNode) => {
+    fieldNode.type === "field" && fieldNode.name && applyBlockFieldChanges(block, fieldNode.name, fieldNode);
   });
+}, applyBlockFieldChanges = (block, fieldName, fieldNode) => {
+  const currentValue = block[fieldName];
+  if (fieldNode.attributes.type === "array") {
+    Array.isArray(currentValue) && fieldNode.children.forEach((childNode, idx) => {
+      childNode.type === "block" && currentValue[idx] ? applyBlockChanges(currentValue[idx], childNode) : childNode.type === "field" && applyBlockFieldChanges(currentValue[idx], childNode.name || String(idx), childNode);
+    });
+    return;
+  }
+  if (fieldNode.attributes.type === "object") {
+    currentValue && typeof currentValue == "object" && fieldNode.children.forEach((childNode) => {
+      childNode.name && applyBlockFieldChanges(currentValue, childNode.name, childNode);
+    });
+    return;
+  }
+  fieldNode.text !== void 0 && !fieldNode.attributes.readonly && (block[fieldName] = fieldNode.text);
 }, applySpanChanges = (span, spanNode) => {
   if (spanNode.attributes._key && span._key !== spanNode.attributes._key) {
     devLog.warn("Span key mismatch, skipping", {
@@ -2198,7 +2120,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];
@@ -2211,6 +2133,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);
@@ -2218,512 +2148,172 @@ const fetchTranslationPrompts = async ({
       return;
     }
     if (typeof value == "string") {
-      value.length > 0 && lines.push(`${indentStr}<field name="${fieldName}">${escapeXml(value)}</field>`);
-      return;
-    }
-    (typeof value == "number" || typeof value == "boolean") && lines.push(`${indentStr}<field name="${fieldName}" type="${typeof value}" readonly="true">${value}</field>`);
-  };
-  return serialize(doc), lines.join(`
-`);
-}, serializeBlock = (block, path, indent, lines) => {
-  const indentStr = "  ".repeat(indent), metadata = {};
-  block._type && (metadata._type = block._type), block._key && (metadata._key = block._key), block.style && (metadata.style = block.style), block.listItem && (metadata.listItem = block.listItem), block.level && (metadata.level = block.level), block.markDefs && (metadata.markDefs = block.markDefs);
-  const metaStr = Object.entries(metadata).map(([k, v]) => `${k}="${escapeXml(typeof v == "string" ? v : JSON.stringify(v))}"`).join(" ");
-  lines.push(`${indentStr}<block ${metaStr}>`), Array.isArray(block.children) && block.children.forEach((child, idx) => {
-    serializeSpan(child, [...path, "children", idx], indent + 1, lines);
-  }), lines.push(`${indentStr}</block>`);
-}, serializeSpan = (span, _path, indent, lines) => {
-  const indentStr = "  ".repeat(indent);
-  if (!span || typeof span != "object") return;
-  const metadata = {};
-  span._type && (metadata._type = span._type), span._key && (metadata._key = span._key), span.marks && Array.isArray(span.marks) && (metadata.marks = span.marks.join(","));
-  const metaStr = Object.entries(metadata).map(([k, v]) => `${k}="${escapeXml(String(v))}"`).join(" "), text = typeof span.text == "string" ? span.text : "";
-  metaStr ? lines.push(`${indentStr}<span ${metaStr}>${escapeXml(text)}</span>`) : lines.push(`${indentStr}<span>${escapeXml(text)}</span>`);
-}, escapeXml = (str) => str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;"), isPlainObject = (val) => typeof val == "object" && val !== null && !Array.isArray(val), validateStructureIntegrity = (original, modified) => {
-  const errors = [], criticalFields = ["_id", "_type", "_rev", "_createdAt", "_updatedAt"];
-  for (const field of criticalFields)
-    original[field] !== modified[field] && errors.push({
-      path: [field],
-      expected: original[field],
-      actual: modified[field],
-      type: "metadata_changed"
-    });
-  return validateStructureRecursive(original, modified, [], errors), {
-    valid: errors.length === 0,
-    errors
-  };
-}, validateStructureRecursive = (original, modified, path, errors) => {
-  if (typeof original != typeof modified) {
-    errors.push({
-      path,
-      expected: typeof original,
-      actual: typeof modified,
-      type: "type_mismatch"
-    });
-    return;
-  }
-  if (Array.isArray(original)) {
-    if (!Array.isArray(modified)) {
-      errors.push({
-        path,
-        expected: "array",
-        actual: typeof modified,
-        type: "type_mismatch"
-      });
-      return;
-    }
-    if (original.length !== modified.length) {
-      errors.push({
-        path,
-        expected: `length ${original.length}`,
-        actual: `length ${modified.length}`,
-        type: "type_mismatch"
-      });
+      value.length > 0 && lines.push(`${fieldName}: ${escapeXml(value)}`);
       return;
     }
-    original.forEach((item, idx) => {
-      validateStructureRecursive(item, modified[idx], [...path, String(idx)], errors);
-    });
-    return;
-  }
-  if (typeof original == "object" && original !== null && typeof modified == "object" && modified !== null) {
-    const origKeys = Object.keys(original).sort(), modKeys = Object.keys(modified).sort();
-    for (const key of origKeys)
-      key in modified || errors.push({
-        path: [...path, key],
-        expected: "present",
-        actual: "missing",
-        type: "missing"
-      });
-    for (const key of modKeys)
-      key in original || errors.push({
-        path: [...path, key],
-        expected: "absent",
-        actual: "present",
-        type: "extra"
-      });
-    const origObj = original, modObj = modified;
-    for (const key of origKeys)
-      key in modObj && (key.startsWith("_") || key === "marks" || key === "style" || key === "markDefs" ? JSON.stringify(origObj[key]) !== JSON.stringify(modObj[key]) && errors.push({
-        path: [...path, key],
-        expected: origObj[key],
-        actual: modObj[key],
-        type: "metadata_changed"
-      }) : key !== "text" && validateStructureRecursive(origObj[key], modObj[key], [...path, key], errors));
-  }
-}, assembleTranslationPrompt = (context, components) => {
-  const sections = [
-    {
-      id: "agentDirectives",
-      content: buildAgentDirectivesSection(context),
-      required: !0,
-      priority: 0
-    },
-    {
-      id: "criticalRules",
-      content: buildCriticalRulesSection(context),
-      required: !0,
-      priority: 1
-    }
-  ];
-  components.glossaryTerms?.trim() && sections.push({
-    id: "glossaryTerms",
-    content: buildGlossarySection(components.glossaryTerms),
-    required: !1,
-    priority: 3
-  });
-  const styleSection = buildStyleGuideSection(components.globalPrompt, components.localePrompt);
-  styleSection && sections.push({
-    id: "styleGuide",
-    content: styleSection,
-    required: !1,
-    priority: 4
-  }), sections.sort((a, b) => a.priority - b.priority);
-  let styleGuide = "";
-  const omittedSections = [], truncatedSections = [];
-  for (const section of sections) {
-    const prefix = styleGuide.length > 0 ? `
-
----
-
-` : "", availableCharacters = 2e3 - (styleGuide.length + prefix.length);
-    if (availableCharacters <= 0) {
-      if (section.required) {
-        const truncatedContent = truncateSection(section.content, 0);
-        truncatedContent && (styleGuide += prefix + truncatedContent, truncatedSections.push(section.id));
-      } else
-        omittedSections.push(section.id);
-      continue;
-    }
-    if (section.content.length <= availableCharacters) {
-      styleGuide += prefix + section.content;
-      continue;
-    }
-    if (section.required) {
-      const truncatedContent = truncateSection(section.content, availableCharacters);
-      styleGuide += prefix + truncatedContent, truncatedSections.push(section.id);
-    } else
-      omittedSections.push(section.id);
-  }
-  return {
-    styleGuide,
-    omittedSections,
-    truncatedSections
-  };
-}, truncateSection = (content, limit) => {
-  if (limit <= 0)
-    return "";
-  if (content.length <= limit)
-    return content;
-  if (limit <= 1)
-    return content.slice(0, limit);
-  const ellipsis = "\u2026";
-  if (limit <= ellipsis.length)
-    return content.slice(0, limit);
-  const sliceEnd = limit - ellipsis.length, sliced = content.slice(0, sliceEnd), trimmed = sliced.replace(/\s+\S*$/, "").trimEnd();
-  return `${trimmed.length >= sliceEnd / 2 ? trimmed : sliced}${ellipsis}`;
-}, buildAgentDirectivesSection = (context) => {
-  const { targetLanguage, sourceLanguage } = context;
-  return `# AGENT WORKFLOW DIRECTIVES
-
-- Use only the provided ${sourceLanguage || "the source language"} source; never fetch outside context.
-- Scan each field once, then move directly into translation work.
-- Plan updates before editing so document structure remains intact.
-- Default to medium reasoning effort and escalate only for ambiguous passages.
-- Output just the ${targetLanguage || "the target language"} translation and mirror the source formatting exactly.`;
-}, buildCriticalRulesSection = (context) => {
-  const { sourceLanguage, targetLanguage } = context, fromLanguage = sourceLanguage || "the source language", toLanguage = targetLanguage || "the target language";
-  return `# CRITICAL TRANSLATION RULES
-
-Follow these without exception:
-
-1. Translate from ${fromLanguage} into ${toLanguage}; every output token must be ${toLanguage} unless flagged as protected.
-2. Preserve meaning exactly\u2014no additions, deletions, or tone shifts.
-3. Maintain all layout, markdown, rich-text marks, and data structure.
-4. Never invent metadata or field values that are absent in the source.
-5. Leave technical tokens (code, IDs, filenames) untouched.
-6. Keep punctuation, casing, and spacing unless ${toLanguage} grammar forces a change.`;
-}, buildGlossarySection = (glossaryTerms) => `# TERMINOLOGY RULES
-
-Apply these mappings immediately after protected phrases and before style preferences.
-
-${glossaryTerms}`, buildStyleGuideSection = (globalPrompt, localePrompt) => {
-  const components = [];
-  return (globalPrompt || localePrompt) && (components.push("# TRANSLATION STYLE GUIDE (LOWEST PRIORITY)"), components.push(
-    "Apply these directions only after honoring critical rules, protected phrases, and glossary terminology."
-  ), components.push("")), globalPrompt && (components.push("## General Guidelines"), components.push(globalPrompt), components.push("")), localePrompt && (components.push("## Language-Specific Guidelines"), components.push(localePrompt)), components.length > 0 ? components.join(`
-`) : null;
-}, translateEntireDocument = async ({
-  dispatch,
-  client,
-  schemaId,
-  sourceDocument,
-  targetLanguage,
-  languageFieldName,
-  translationTarget,
-  translationPrompts,
-  translationMode,
-  openaiConfig,
-  releaseId,
-  isNewTranslation
-}) => {
-  const logContext = {
-    documentId: sourceDocument._id,
-    targetLanguage,
-    schemaId,
-    operation: translationTarget.operation,
-    targetId: translationTarget._id,
-    translationMode,
-    releaseId,
-    isNewTranslation
-  };
-  devLog.group("translateEntireDocument", logContext), devLog.time("translateEntireDocument");
-  try {
-    let versionedDocumentId, baseDocumentId;
-    if (isNewTranslation) {
-      const { _id, _createdAt, _updatedAt, _rev, ...docWithoutMeta } = sourceDocument, newTranslationDoc = {
-        ...docWithoutMeta,
-        _type: sourceDocument._type,
-        [languageFieldName]: targetLanguage
-      };
-      devLog.info("Creating new translation document in release", logContext), baseDocumentId = translationTarget._id || `new-translation-${Date.now()}`, await client.action({
-        actionType: "sanity.action.document.version.create",
-        publishedId: baseDocumentId,
-        document: {
-          ...newTranslationDoc,
-          _type: sourceDocument._type,
-          _id: `versions.${releaseId}.${baseDocumentId}`
-        }
-      }), versionedDocumentId = `versions.${releaseId}.${baseDocumentId}`, devLog.info("New translation version created in release", {
-        ...logContext,
-        versionedDocumentId,
-        baseDocumentId
-      });
-    } else {
-      const existingTranslationId = translationTarget._id;
-      if (!existingTranslationId)
-        throw new Error("Translation target ID not found for update operation");
-      devLog.info("Creating version of existing translation in release", {
-        ...logContext,
-        existingTranslationId
-      });
-      const existingDoc = await client.getDocument(existingTranslationId);
-      if (!existingDoc)
-        throw new Error(`Existing translation document not found: ${existingTranslationId}`);
-      await client.action({
-        actionType: "sanity.action.document.version.create",
-        publishedId: existingTranslationId,
-        document: {
-          ...existingDoc,
-          _id: `versions.${releaseId}.${existingTranslationId}`
-        }
-      }), versionedDocumentId = `versions.${releaseId}.${existingTranslationId}`, baseDocumentId = existingTranslationId, devLog.info("Existing translation version created", {
-        ...logContext,
-        versionedDocumentId
-      });
-      const { _id, _createdAt, _updatedAt, _rev, ...sourceContent } = sourceDocument;
-      await client.createOrReplace({
-        ...sourceContent,
-        _id: versionedDocumentId,
-        [languageFieldName]: targetLanguage
-      }), devLog.info("Source content cloned onto version", {
-        ...logContext,
-        versionedDocumentId
-      });
-    }
-    let translatedDocument;
-    switch (translationMode) {
-      case "openai-only": {
-        if (!openaiConfig?.enabled || !openaiConfig?.apiKey)
-          throw new Error("OpenAI is not configured but openai-only mode was selected");
-        devLog.info("Using OpenAI-only translation", logContext), setJobStatus(dispatch, sourceDocument._id, targetLanguage, "translating_with_openai");
-        const versionedDoc = await client.getDocument(versionedDocumentId);
-        if (!versionedDoc)
-          throw new Error(`Versioned document not found: ${versionedDocumentId}`);
-        const translatedDoc = await translateInPlaceWithOpenAI({
-          dispatch,
-          sourceDocument,
-          targetDocument: versionedDoc,
-          targetLanguage,
-          languageFieldName,
-          translationPrompts,
-          openaiConfig,
-          isReview: !1
-        });
-        translatedDoc && (translatedDocument = await client.createOrReplace({
-          ...translatedDoc,
-          _id: versionedDocumentId
-        }));
-        break;
-      }
-      case "sanity-with-review":
-        if (!openaiConfig?.enabled || !openaiConfig?.apiKey)
-          throw new Error("OpenAI is not configured but sanity-with-review mode was selected");
-        if (devLog.info("Using Sanity + OpenAI review", logContext), translatedDocument = await translateWithSanityAgent({
-          dispatch,
-          client,
-          schemaId,
-          sourceDocument,
-          targetLanguage,
-          languageFieldName,
-          versionedDocumentId,
-          translationPrompts
-        }), translatedDocument) {
-          setJobStatus(dispatch, sourceDocument._id, targetLanguage, "reviewing_with_openai");
-          const reviewedDoc = await translateInPlaceWithOpenAI({
-            dispatch,
-            sourceDocument,
-            targetDocument: translatedDocument,
-            targetLanguage,
-            languageFieldName,
-            translationPrompts,
-            openaiConfig,
-            isReview: !0
-          });
-          reviewedDoc && (translatedDocument = await client.createOrReplace({
-            ...reviewedDoc,
-            _id: versionedDocumentId
-          }));
-        }
-        break;
-      default:
-        devLog.info("Using Sanity-only translation", logContext), translatedDocument = await translateWithSanityAgent({
-          dispatch,
-          client,
-          schemaId,
-          sourceDocument,
-          targetLanguage,
-          languageFieldName,
-          versionedDocumentId,
-          translationPrompts
-        });
-        break;
-    }
-    return devLog.timeEnd("translateEntireDocument"), devLog.groupEnd(), translatedDocument ? {
-      ...translatedDocument,
-      _id: baseDocumentId
-    } : void 0;
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    devLog.error(
-      "translateEntireDocument failed",
-      error instanceof Error ? error : new Error(String(error)),
-      logContext
-    ), setJobStatus(dispatch, sourceDocument._id, targetLanguage, "error", {
-      errorMessage
-    }), devLog.timeEnd("translateEntireDocument"), devLog.groupEnd();
-    return;
-  }
-}, translateWithSanityAgent = async ({
-  dispatch,
-  client,
-  schemaId,
-  sourceDocument,
-  targetLanguage,
-  languageFieldName,
-  versionedDocumentId,
-  translationPrompts
-}) => {
-  const logContext = {
-    documentId: sourceDocument._id,
-    targetLanguage,
-    versionedDocumentId
+    (typeof value == "number" || typeof value == "boolean") && lines.push(`${indentStr}<field name="${fieldName}" type="${typeof value}" readonly="true">${value}</field>`);
   };
-  try {
-    const { toLanguage, fromLanguage } = assembleLanguageSpecs({
-      sourceDocument,
-      languageFieldName,
-      targetLanguage
-    });
-    devLog.debug("Language specs assembled", {
-      ...logContext,
-      toLanguage,
-      fromLanguage
+  return serialize(doc), lines.join(`
+`);
+}, serializeBlock = (block, path, indent, lines) => {
+  const indentStr = "  ".repeat(indent), metadata = {};
+  block._type && (metadata._type = block._type), block._key && (metadata._key = block._key), block.style && (metadata.style = block.style), block.listItem && (metadata.listItem = block.listItem), block.level && (metadata.level = block.level), block.markDefs && (metadata.markDefs = block.markDefs);
+  const metaStr = Object.entries(metadata).map(([k, v]) => `${k}="${escapeXml(typeof v == "string" ? v : JSON.stringify(v))}"`).join(" ");
+  if (lines.push(`${indentStr}<block ${metaStr}>`), Array.isArray(block.children) && block._type === "block")
+    block.children.forEach((child, idx) => {
+      serializeSpan(child, [...path, "children", idx], indent + 1, lines);
     });
-    const documentAnalysis = analyzeDocumentContent(sourceDocument);
-    devLog.debug("Document analysis completed", {
-      ...logContext,
-      analysis: documentAnalysis
-    }), devLog.info("Starting Sanity agent translation", logContext), setJobStatus(dispatch, sourceDocument._id, targetLanguage, "translating");
-    const { styleGuide, omittedSections, truncatedSections } = assembleTranslationPrompt(
-      {
-        documentAnalysis,
-        isUpdate: !1,
-        // Always fresh translation in a version
-        targetLanguage,
-        sourceLanguage: sourceDocument[languageFieldName]
-      },
-      {
-        globalPrompt: translationPrompts.globalPrompt,
-        localePrompt: translationPrompts.localeInstructions[targetLanguage]?.prompt,
-        glossaryTerms: translationPrompts.localeInstructions[targetLanguage]?.glossaryTerms,
-        protectedPhrases: translationPrompts.protectedPhrases
-      }
-    );
-    devLog.info("Structured style guide generated", {
-      ...logContext,
-      styleGuideLength: styleGuide.length,
-      omittedSections,
-      truncatedSections
-    }), (omittedSections.length > 0 || truncatedSections.length > 0) && devLog.warn("Style guide adjusted to fit character limit", {
-      ...logContext,
-      omittedSections,
-      truncatedSections
+  else
+    for (const [key, value] of Object.entries(block))
+      key.startsWith("_") || key === "style" || key === "listItem" || key === "level" || key === "markDefs" || serializeBlockField(value, key, [...path, key], indent + 1, lines);
+  lines.push(`${indentStr}</block>`);
+}, serializeBlockField = (value, fieldName, path, indent, lines) => {
+  const indentStr = "  ".repeat(indent);
+  if (Array.isArray(value)) {
+    value.some((item) => item?._type) ? (lines.push(`${indentStr}<field name="${fieldName}" type="array">`), value.forEach((item, idx) => {
+      item?._type === "block" && item?.children ? serializeBlock(item, [...path, idx], indent + 1, lines) : item?._type ? serializeBlock(item, [...path, idx], indent + 1, lines) : serializeBlockField(item, String(idx), [...path, idx], indent + 1, lines);
+    }), lines.push(`${indentStr}</field>`)) : (lines.push(`${indentStr}<field name="${fieldName}" type="array">`), value.forEach((item, idx) => {
+      serializeBlockField(item, String(idx), [...path, idx], indent + 1, lines);
+    }), lines.push(`${indentStr}</field>`));
+    return;
+  }
+  if (isPlainObject(value)) {
+    lines.push(`${indentStr}<field name="${fieldName}" type="object">`);
+    for (const [key, val] of Object.entries(value))
+      key.startsWith("_") || serializeBlockField(val, key, [...path, key], indent + 1, lines);
+    lines.push(`${indentStr}</field>`);
+    return;
+  }
+  if (typeof value == "string" && value.length > 0) {
+    lines.push(`${indentStr}<field name="${fieldName}">${escapeXml(value)}</field>`);
+    return;
+  }
+  (typeof value == "number" || typeof value == "boolean") && lines.push(`${indentStr}<field name="${fieldName}" type="${typeof value}" readonly="true">${value}</field>`);
+}, serializeSpan = (span, _path, indent, lines) => {
+  const indentStr = "  ".repeat(indent);
+  if (!span || typeof span != "object") return;
+  const metadata = {};
+  span._type && (metadata._type = span._type), span._key && (metadata._key = span._key), span.marks && Array.isArray(span.marks) && (metadata.marks = span.marks.join(","));
+  const metaStr = Object.entries(metadata).map(([k, v]) => `${k}="${escapeXml(String(v))}"`).join(" "), text = typeof span.text == "string" ? span.text : "";
+  metaStr ? lines.push(`${indentStr}<span ${metaStr}>${escapeXml(text)}</span>`) : lines.push(`${indentStr}<span>${escapeXml(text)}</span>`);
+}, escapeXml = (str) => str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;"), isPlainObject = (val) => typeof val == "object" && val !== null && !Array.isArray(val), validateStructureIntegrity = (original, modified) => {
+  const errors = [], criticalFields = ["_id", "_type", "_rev", "_createdAt", "_updatedAt"];
+  for (const field of criticalFields)
+    original[field] !== modified[field] && errors.push({
+      path: [field],
+      expected: original[field],
+      actual: modified[field],
+      type: "metadata_changed"
     });
-    const newDocument = await client.agent.action.translate({
-      schemaId,
-      toLanguage,
-      fromLanguage,
-      documentId: versionedDocumentId,
-      // Use versioned document ID
-      languageFieldPath: [languageFieldName],
-      styleGuide,
-      protectedPhrases: translationPrompts.protectedPhrases || [],
-      conditionalPaths: {
-        defaultHidden: !1,
-        defaultReadOnly: !1
-      }
+  return validateStructureRecursive(original, modified, [], errors), {
+    valid: errors.length === 0,
+    errors
+  };
+}, validateStructureRecursive = (original, modified, path, errors) => {
+  if (typeof original != typeof modified) {
+    errors.push({
+      path,
+      expected: typeof original,
+      actual: typeof modified,
+      type: "type_mismatch"
     });
-    return devLog.info("Sanity agent translation completed", {
-      ...logContext,
-      newDocumentId: newDocument._id,
-      newDocumentRev: newDocument._rev
-    }), newDocument;
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    devLog.error(
-      "Sanity agent translation failed",
-      error instanceof Error ? error : new Error(String(error)),
-      logContext
-    ), setJobStatus(dispatch, sourceDocument._id, targetLanguage, "error", {
-      errorMessage
+    return;
+  }
+  if (Array.isArray(original)) {
+    if (!Array.isArray(modified)) {
+      errors.push({
+        path,
+        expected: "array",
+        actual: typeof modified,
+        type: "type_mismatch"
+      });
+      return;
+    }
+    if (original.length !== modified.length) {
+      errors.push({
+        path,
+        expected: `length ${original.length}`,
+        actual: `length ${modified.length}`,
+        type: "type_mismatch"
+      });
+      return;
+    }
+    original.forEach((item, idx) => {
+      validateStructureRecursive(item, modified[idx], [...path, String(idx)], errors);
     });
     return;
   }
-}, translateInPlaceWithOpenAI = async ({
+  if (typeof original == "object" && original !== null && typeof modified == "object" && modified !== null) {
+    const origKeys = Object.keys(original).sort(), modKeys = Object.keys(modified).sort();
+    for (const key of origKeys)
+      key in modified || errors.push({
+        path: [...path, key],
+        expected: "present",
+        actual: "missing",
+        type: "missing"
+      });
+    for (const key of modKeys)
+      key in original || errors.push({
+        path: [...path, key],
+        expected: "absent",
+        actual: "present",
+        type: "extra"
+      });
+    const origObj = original, modObj = modified;
+    for (const key of origKeys)
+      key in modObj && (key.startsWith("_") || key === "marks" || key === "style" || key === "markDefs" ? JSON.stringify(origObj[key]) !== JSON.stringify(modObj[key]) && errors.push({
+        path: [...path, key],
+        expected: origObj[key],
+        actual: modObj[key],
+        type: "metadata_changed"
+      }) : key !== "text" && validateStructureRecursive(origObj[key], modObj[key], [...path, key], errors));
+  }
+}, getOpenAITranslation = async ({
   dispatch,
   sourceDocument,
-  targetDocument,
-  targetLanguage,
   languageFieldName,
   translationPrompts,
-  openaiConfig,
-  isReview
+  targetLanguage,
+  openaiConfig
 }) => {
   const sourceLanguage = sourceDocument[languageFieldName], logContext = {
     sourceId: sourceDocument._id,
-    targetId: targetDocument._id,
-    targetLanguage,
-    sourceLanguage,
-    isReview
+    sourceLanguage
   };
   try {
-    const sourceText = serializeDocument(sourceDocument), targetText = serializeDocument(targetDocument);
-    devLog.debug("Documents serialized for OpenAI", {
+    const sourceText = serializeDocument(sourceDocument);
+    devLog.info("Serialized document for OpenAI", {
       ...logContext,
-      sourceLength: sourceText.length,
-      targetLength: targetText.length
+      characterCount: sourceText.length,
+      estimatedTokens: Math.ceil(sourceText.length / 4),
+      preview: sourceText.substring(0, 500)
     });
-    const prompt = isReview ? buildReviewPrompt({
-      sourceText,
-      translatedText: targetText,
-      sourceLanguage,
-      targetLanguage,
-      translationPrompts
-    }) : buildTranslationPrompt({
+    const prompt = buildTranslationPrompt$1({
       sourceText,
       sourceLanguage,
       targetLanguage,
       translationPrompts
-    });
-    devLog.debug("Calling GPT-5", {
-      ...logContext,
-      promptLength: prompt.length
-    });
-    const response = await callGPT5(openaiConfig.apiKey, {
+    }), response = await callGPT5(openaiConfig.apiKey, {
       messages: [
         {
-          role: "system",
-          content: isReview ? "You are a translation quality reviewer. Review and refine translations while preserving structure." : "You are a professional translator. Translate documents while preserving their exact structure."
+          role: "developer",
+          content: "You are a translation quality reviewer. Review and refine translations while preserving structure."
         },
         { role: "user", content: prompt }
       ],
       model: openaiConfig.model,
-      reasoningEffort: openaiConfig.reasoningEffort,
-      verbosity: openaiConfig.verbosity,
-      onReasoningChunk: (reasoning) => {
-        const status2 = isReview ? "reviewing_with_openai" : "translating_with_openai";
-        setJobStatus(dispatch, sourceDocument._id, targetLanguage, status2, {
-          reasoningProgress: reasoning
-        });
-      }
+      reasoningEffort: openaiConfig.reasoningEffort
     });
-    devLog.info("OpenAI operation completed", {
+    devLog.info("OpenAI translation response received", {
       ...logContext,
-      tokensUsed: response.tokensUsed.total,
-      cost: response.cost
+      tokensUsed: response.tokensUsed,
+      cost: response.cost,
+      responseLength: response.content.length,
+      responsePreview: response.content.substring(0, 500)
     });
-    const result = deserializeDocument(targetDocument, response.content), validation = validateStructureIntegrity(targetDocument, result);
+    const result = deserializeDocument(sourceDocument, response.content);
+    result[languageFieldName] = targetLanguage;
+    const validation = validateStructureIntegrity(sourceDocument, result);
     if (!validation.valid) {
       devLog.error("Structure validation failed", {
         ...logContext,
@@ -2737,17 +2327,14 @@ ${glossaryTerms}`, buildStyleGuideSection = (globalPrompt, localePrompt) => {
           `Structure validation failed: ${unexpectedErrors.length} errors. First: ${unexpectedErrors[0].type} at ${unexpectedErrors[0].path.join(".")}`
         );
     }
-    devLog.info("Structure validation passed", logContext);
-    const status = isReview ? "reviewing_with_openai" : "translating_with_openai";
-    return setJobStatus(dispatch, sourceDocument._id, targetLanguage, status, {
+    return setJobStatus(dispatch, sourceDocument._id, targetLanguage, "translating_with_openai", {
       tokensUsed: response.tokensUsed.total,
-      estimatedCost: response.cost,
-      reasoningSummary: response.reasoningSummary
+      estimatedCost: response.cost
     }), result;
   } catch (error) {
     throw devLog.error("OpenAI translation failed", error instanceof Error ? error : new Error(String(error)), logContext), error;
   }
-}, buildTranslationPrompt = ({
+}, buildTranslationPrompt$1 = ({
   sourceText,
   sourceLanguage,
   targetLanguage,
@@ -2794,73 +2381,193 @@ Brief summary of key translation decisions and reasoning
 </reasoning>
 
 Then return the translated document:`;
-}, buildReviewPrompt = ({
-  sourceText,
-  translatedText,
+}, assembleLanguageSpecs = ({
+  sourceDocument,
+  languageFieldName,
+  targetLanguage
+}) => {
+  const sourceLanugageId = sourceDocument[languageFieldName];
+  if (!sourceLanugageId)
+    throw new Error("[assembleLanguages] Source language ID is missing");
+  return {
+    fromLanguage: {
+      id: sourceLanugageId,
+      title: sourceLanugageId
+    },
+    toLanguage: {
+      id: targetLanguage,
+      title: targetLanguage
+    }
+  };
+}, buildTranslationPrompt = ({
   sourceLanguage,
   targetLanguage,
-  translationPrompts
+  components,
+  isUpdate = !1
 }) => {
-  const { globalPrompt, localeInstructions, protectedPhrases } = translationPrompts, localePrompt = localeInstructions[targetLanguage]?.prompt, glossaryTerms = localeInstructions[targetLanguage]?.glossaryTerms;
-  return `# TRANSLATION QUALITY REVIEW
-
-Review this ${targetLanguage} translation and return a corrected version.
-
-## Review Criteria
+  const sections = [];
+  sections.push(buildAgentDirectivesSection(sourceLanguage, targetLanguage)), sections.push(buildCriticalRulesSection(sourceLanguage, targetLanguage)), isUpdate && sections.push(buildUpdateInstructionsSection()), components.glossaryTerms?.trim() && sections.push(buildGlossarySection(components.glossaryTerms)), components.protectedPhrases?.length && sections.push(buildProtectedPhrasesSection(components.protectedPhrases));
+  const styleSection = buildStyleGuideSection(components.globalPrompt, components.localePrompt);
+  return styleSection && sections.push(styleSection), sections.join(`
 
-1. **Accuracy**: Does it accurately convey the ${sourceLanguage} source meaning?
-2. **Terminology**: Are glossary terms used correctly?
-3. **Protected Phrases**: Are protected phrases preserved?
-4. **Fluency**: Is it natural and fluent in ${targetLanguage}?
-5. **Style**: Does it follow the style guide?
-6. **Completeness**: Is all content translated?
+---
 
-## Guidelines
+`);
+}, buildAgentDirectivesSection = (sourceLanguage, targetLanguage) => `# AGENT WORKFLOW DIRECTIVES
 
-${globalPrompt ? `### General Guidelines
-${globalPrompt}
-` : ""}
-${localePrompt ? `### ${targetLanguage} Guidelines
-${localePrompt}
-` : ""}
-${glossaryTerms ? `### Required Terminology
-${glossaryTerms}
-` : ""}
-${protectedPhrases?.length ? `### Protected Phrases (must preserve)
-${protectedPhrases.join(", ")}
-` : ""}
+- Use only the provided ${sourceLanguage || "the source language"} source; never fetch outside context.
+- Scan each field once, then move directly into translation work.
+- Plan updates before editing so document structure remains intact.
+- Default to medium reasoning effort and escalate only for ambiguous passages.
+- Output just the ${targetLanguage || "the target language"} translation and mirror the source formatting exactly.`, buildCriticalRulesSection = (sourceLanguage, targetLanguage) => {
+  const fromLanguage = sourceLanguage || "the source language", toLanguage = targetLanguage || "the target language";
+  return `# CRITICAL TRANSLATION RULES
 
-## Source Document (${sourceLanguage})
+Follow these without exception:
 
-\`\`\`
-${sourceText}
-\`\`\`
+1. Translate from ${fromLanguage} into ${toLanguage}; every output token must be ${toLanguage} unless flagged as protected.
+2. Preserve meaning exactly\u2014no additions, deletions, or tone shifts.
+3. Maintain all layout, markdown, rich-text marks, and data structure.
+4. Never invent metadata or field values that are absent in the source.
+5. Leave technical tokens (code, IDs, filenames) untouched.
+6. Keep punctuation, casing, and spacing unless ${toLanguage} grammar forces a change.`;
+}, buildUpdateInstructionsSection = () => `# UPDATING EXISTING TRANSLATION
 
-## Current Translation (${targetLanguage})
+This document already has a translation; only adjust fields that changed.
 
-\`\`\`
-${translatedText}
-\`\`\`
+- Compare the latest source to the existing target text.
+- Keep prior terminology and style unless the source demands a change.
+- Edit minimally while guaranteeing accuracy and completeness.`, buildGlossarySection = (glossaryTerms) => `# TERMINOLOGY RULES
 
-## Instructions
+Apply these mappings immediately after protected phrases and before style preferences.
 
-1. Review the translation for quality issues
-2. Make corrections where needed to improve accuracy, fluency, or adherence to guidelines
-3. Keep good translations as-is - only fix what needs fixing
-4. Return the corrected translation in THE EXACT SAME FORMAT
-5. **CRITICAL**: Only modify text content between tags
-6. Never add, remove, or change any tags, attributes, or structure
+${glossaryTerms}`, buildProtectedPhrasesSection = (protectedPhrases) => `# PROTECTED PHRASES
 
-If you made corrections or have insights about the translation quality, include a brief summary:
-<reasoning>
-Brief summary of review findings and corrections made
-</reasoning>
+These phrases must NEVER be translated. Keep them exactly as they appear:
 
-Then return the corrected translation document:`;
+${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localePrompt) => {
+  const components = [];
+  return (globalPrompt || localePrompt) && (components.push("# TRANSLATION STYLE GUIDE (LOWEST PRIORITY)"), components.push(
+    "Apply these directions only after honoring critical rules, protected phrases, and glossary terminology."
+  ), components.push("")), globalPrompt && (components.push("## General Guidelines"), components.push(globalPrompt), components.push("")), localePrompt && (components.push("## Language-Specific Guidelines"), components.push(localePrompt)), components.length > 0 ? components.join(`
+`) : null;
+}, getSanityAgentTranslation = async ({
+  sourceDocument,
+  targetLanguage,
+  languageFieldName,
+  schemaId,
+  client,
+  translationPrompts
+}) => {
+  const styleGuide = buildTranslationPrompt({
+    sourceLanguage: sourceDocument[languageFieldName],
+    targetLanguage,
+    isUpdate: !1,
+    // Always fresh translation in a version
+    components: {
+      globalPrompt: translationPrompts.globalPrompt,
+      localePrompt: translationPrompts.localeInstructions[targetLanguage]?.prompt,
+      glossaryTerms: translationPrompts.localeInstructions[targetLanguage]?.glossaryTerms,
+      protectedPhrases: translationPrompts.protectedPhrases
+    }
+  }), { fromLanguage, toLanguage } = assembleLanguageSpecs({
+    sourceDocument,
+    languageFieldName,
+    targetLanguage
+  });
+  return await client.agent.action.translate({
+    schemaId,
+    toLanguage,
+    fromLanguage,
+    documentId: sourceDocument._id,
+    noWrite: !0,
+    // Do not write to the document, just return the translated content
+    languageFieldPath: [languageFieldName],
+    styleGuide,
+    protectedPhrases: translationPrompts.protectedPhrases,
+    conditionalPaths: {
+      defaultHidden: !1,
+      defaultReadOnly: !1
+    }
+  });
+}, handleTranslation = async ({
+  dispatch,
+  client,
+  schemaId,
+  sourceDocument,
+  targetLanguage,
+  existingTranslationId,
+  languageFieldName,
+  translationPrompts,
+  translationMode,
+  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: transformedDocument,
+        targetLanguage,
+        languageFieldName,
+        schemaId,
+        client,
+        translationPrompts
+      });
+      break;
+    }
+    case "openai-only": {
+      if (!openaiConfig?.enabled || !openaiConfig?.apiKey)
+        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: transformedDocument,
+        targetLanguage,
+        languageFieldName,
+        translationPrompts,
+        openaiConfig
+      });
+      break;
+    }
+    case "sanity-with-review":
+      throw new Error("Sanity with review translation method is not implemented");
+    default:
+      throw new Error(`Invalid translation mode: ${translationMode}`);
+  }
+  if (!translatedDoc)
+    return null;
+  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({
+    actionType: "sanity.action.document.version.create",
+    publishedId: targetDocumentPublishedId,
+    document: newDoc
+  }), newDoc;
 }, translateDocument = async ({
   dispatch,
   client,
   sourceDocument,
+  sourceLanguage,
   targetLanguage,
   languageFieldName,
   shouldOverwriteFreshTranslations,
@@ -2879,62 +2586,37 @@ Then return the corrected translation document:`;
   };
   devLog.group("translateDocument", logContext), devLog.time("translateDocument"), setJobStatus(dispatch, sourceDocument._id, targetLanguage, "preparing_translation");
   try {
-    const sourceLanguage = sourceDocument[languageFieldName];
-    if (devLog.debug("Checking source document language", {
-      ...logContext,
-      sourceLanguage,
-      languageFieldName
-    }), !sourceLanguage) {
-      const error = `Source document ${sourceDocument._id} does not have a language`;
-      throw devLog.error(error, void 0, logContext), new Error(error);
-    }
-    devLog.debug("Getting translation metadata", logContext);
     const translationMetadata = await getTranslationMetadata({
       client,
       sourceDocument,
       sourceLanguage
     }), isAlreadyFreshTranslation = translationMetadata.translationHistory?.some(
       (history) => history.language === targetLanguage && history.sourceRev === sourceDocument._rev
-    ) ?? !1;
-    if (devLog.debug("Checking if translation is already fresh", {
-      ...logContext,
-      isAlreadyFreshTranslation,
-      currentRev: sourceDocument._rev
-    }), !shouldOverwriteFreshTranslations && isAlreadyFreshTranslation) {
-      devLog.info("Skipping fresh translation", logContext), setJobStatus(dispatch, sourceDocument._id, targetLanguage, "skipped", {
+    );
+    if (!shouldOverwriteFreshTranslations && isAlreadyFreshTranslation) {
+      setJobStatus(dispatch, sourceDocument._id, targetLanguage, "skipped", {
         targetId: translationMetadata.translations.find((t) => t._key === targetLanguage)?.value._ref
-      }), devLog.timeEnd("translateDocument"), devLog.groupEnd();
-      return;
-    }
-    const translationTarget = determineTranslationTarget({
-      translationMetadata,
-      targetLanguage
-    }), isNewTranslation = translationTarget.operation === "create";
-    devLog.debug("Translation target determined", {
-      ...logContext,
-      operation: translationTarget.operation,
-      isNewTranslation
-    });
-    const newDocument = await translateEntireDocument({
+      });
+      return;
+    }
+    const existingTranslationId = getExistingTranslationId(translationMetadata, targetLanguage), newDocument = await handleTranslation({
       dispatch,
       client,
       schemaId,
       sourceDocument,
       targetLanguage,
+      existingTranslationId,
       languageFieldName,
-      translationTarget,
       translationPrompts,
       translationMode,
       openaiConfig,
-      releaseId,
-      isNewTranslation
+      releaseId
     });
-    if (!newDocument)
-      throw devLog.error("Failed to create translation document", void 0, logContext), setJobStatus(dispatch, sourceDocument._id, targetLanguage, "error"), devLog.timeEnd("translateDocument"), devLog.groupEnd(), new Error("Failed to create translation document");
-    return devLog.debug("Translation document created", {
-      ...logContext,
-      newDocumentId: newDocument._id
-    }), devLog.debug("Updating translation metadata", logContext), setJobStatus(dispatch, sourceDocument._id, targetLanguage, "updating_metadata", {
+    if (!newDocument) {
+      setJobStatus(dispatch, sourceDocument._id, targetLanguage, "error"), devLog.timeEnd("translateDocument"), devLog.groupEnd();
+      return;
+    }
+    return setJobStatus(dispatch, sourceDocument._id, targetLanguage, "updating_metadata", {
       targetId: newDocument._id
     }), await updateTranslationMetadata({
       client,
@@ -2943,8 +2625,10 @@ Then return the corrected translation document:`;
       newDocument,
       targetLanguage,
       translationMetadata,
-      isNewTranslation
-    }), setJobStatus(dispatch, sourceDocument._id, targetLanguage, "completed"), devLog.info("Translation completed successfully", {
+      isNewTranslation: !existingTranslationId
+    }), setJobStatus(dispatch, sourceDocument._id, targetLanguage, "completed", {
+      targetId: newDocument._id
+    }), devLog.info("Translation completed successfully", {
       ...logContext,
       newDocumentId: newDocument._id
     }), devLog.timeEnd("translateDocument"), devLog.groupEnd(), newDocument._id;
@@ -2970,77 +2654,61 @@ Then return the corrected translation document:`;
 }) => {
   const logContext = {
     documentId: sourceDocument._id,
+    documentRev: sourceDocument._rev,
     targetLanguages,
     referencesCount: references.length,
     maxConcurrentJobs: maxConcurrentTranslationJobs,
     translationMode,
     shouldOverwriteFreshTranslations
   };
-  devLog.group("translateDocumentSet", logContext), devLog.time("translateDocumentSet");
   let releaseId;
   try {
     const sourceLanguage = sourceDocument[languageFieldName];
     if (!sourceLanguage)
       throw devLog.error("Source language not found"), new Error("Source language not found");
-    maxConcurrentTranslationJobs && (devLog.debug("Updating translation semaphore permits", {
-      ...logContext,
-      newPermits: maxConcurrentTranslationJobs
-    }), translationSemaphore.updatePermits(maxConcurrentTranslationJobs)), devLog.info("Starting document set translation", logContext), dispatch({
+    maxConcurrentTranslationJobs && translationSemaphore.updatePermits(maxConcurrentTranslationJobs), dispatch({
       type: "SET_OVERALL_STATUS",
       payload: "translating"
     });
-    const releaseTitle = `[AI Translation] ${sourceDocument.title || sourceDocument._id.split("-").slice(0, 2).join("-")} (${sourceDocument._type}) ${sourceLanguage} \u2192 ${targetLanguages.join(", ")}`, releaseDescription = `AI translation batch created on ${(/* @__PURE__ */ new Date()).toLocaleDateString()} at ${(/* @__PURE__ */ new Date()).toLocaleTimeString()}`;
-    devLog.info("Creating Content Release for translation batch", {
-      ...logContext,
-      releaseTitle
-    });
-    const { releaseId: newReleaseId } = await client.releases.create({
+    const releaseTitle = `[AI Translation] ${sourceDocument.title || sourceDocument._id.split("-").slice(0, 2).join("-")} (${sourceDocument._type}) ${sourceLanguage} \u2192 ${targetLanguages.join(", ")}`, releaseDescription = `AI translation batch created on ${(/* @__PURE__ */ new Date()).toLocaleDateString()} at ${(/* @__PURE__ */ new Date()).toLocaleTimeString()}`, { releaseId: releaseId2 } = await client.releases.create({
       metadata: {
         title: releaseTitle,
         description: releaseDescription,
-        releaseType: "asap"
+        releaseType: "undecided"
       }
     });
-    releaseId = newReleaseId, devLog.info("Content Release created", {
+    devLog.info("Content Release created", {
       ...logContext,
-      releaseId
+      releaseId: releaseId2
     });
     const sourceDocuments = [
       {
         _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
-    ], sourceDocumentIds = sourceDocuments.map((doc) => doc._id), targetDocumentIds = [];
-    devLog.debug("Prepared document set for translation", {
-      ...logContext,
-      sourceDocumentIds: sourceDocumentIds.length,
-      totalTranslationJobs: sourceDocumentIds.length * targetLanguages.length
-    });
-    const translationPrompts = await fetchTranslationPrompts({
+    ], sourceDocumentIds = sourceDocuments.map((doc) => doc._id), versionedTargetDocumentIds = [], translationPrompts = await fetchTranslationPrompts({
       client,
       sourceLanguage,
       targetLanguages,
       sourceDocument
     });
-    devLog.info("Translation prompts", translationPrompts), setupTranslationJobStatuses(dispatch, sourceDocuments, targetLanguages);
+    setupTranslationJobStatuses(dispatch, sourceDocuments, targetLanguages);
     const translationTasks = sourceDocumentIds.flatMap(
       (documentId) => targetLanguages.map(async (targetLanguage) => {
         try {
           await translationSemaphore.withPermit(async () => {
             const document = await client.withConfig({
-              // This enables us to detect documents that might be stale due to unpublished changes
-              perspective: "raw"
-            }).fetch("*[_id == $id][0]", {
-              id: documentId
-            });
-            if (document && releaseId) {
-              const targetDocumentId = await translateDocument({
+              perspective: "drafts"
+            }).getDocument(documentId);
+            if (document || devLog.error("\u274C SOURCE DOCUMENT NOT FOUND", { documentId }), document && releaseId2) {
+              const versionedTargetDocumentId = await translateDocument({
                 dispatch,
                 client,
                 sourceDocument: document,
+                sourceLanguage,
                 targetLanguage,
                 languageFieldName,
                 shouldOverwriteFreshTranslations,
@@ -3048,9 +2716,9 @@ Then return the corrected translation document:`;
                 translationPrompts,
                 translationMode,
                 openaiConfig,
-                releaseId
+                releaseId: releaseId2
               });
-              targetDocumentId && targetDocumentIds.push(targetDocumentId);
+              versionedTargetDocumentId && versionedTargetDocumentIds.push(versionedTargetDocumentId);
             }
           });
         } catch (error) {
@@ -3066,25 +2734,21 @@ Then return the corrected translation document:`;
         }
       })
     ), results = await Promise.allSettled(translationTasks), succeeded = results.filter((r) => r.status === "fulfilled").length, failed = results.filter((r) => r.status === "rejected").length;
-    devLog.info("Translation tasks summary", {
+    devLog.info("Translation tasks completed", {
       ...logContext,
       total: results.length,
       succeeded,
-      failed
-    }), devLog.info("All translation tasks completed", {
-      ...logContext,
-      targetDocumentIds: targetDocumentIds.length
+      failed,
+      targetDocuments: versionedTargetDocumentIds.length
     }), dispatch({
       type: "SET_OVERALL_STATUS",
       payload: "linking_references"
-    }), devLog.debug("Starting reference localization", {
-      ...logContext,
-      documentsToLocalize: targetDocumentIds.length
     }), await Promise.all(
-      targetDocumentIds.map(async (documentId) => {
+      versionedTargetDocumentIds.map(async (documentId) => {
         await localizeReferences({
           client,
           documentId,
+          sourceLanguage,
           languageFieldName
         });
       })
@@ -3094,26 +2758,13 @@ Then return the corrected translation document:`;
       ...logContext,
       succeeded,
       failed
-    }), dispatch({ type: "SET_OVERALL_STATUS", payload: "completed" })) : (devLog.info("Document set translation completed successfully", logContext), dispatch({ type: "SET_OVERALL_STATUS", payload: "completed" })), devLog.timeEnd("translateDocumentSet"), devLog.groupEnd();
+    }), dispatch({ type: "SET_OVERALL_STATUS", payload: "completed" })) : dispatch({ type: "SET_OVERALL_STATUS", payload: "completed" }), devLog.timeEnd("translateDocumentSet"), devLog.groupEnd();
   } catch (error) {
-    if (devLog.error(
+    throw devLog.error(
       "translateDocumentSet failed with unexpected error",
       error instanceof Error ? error : new Error(String(error)),
       logContext
-    ), releaseId)
-      try {
-        await client.releases.delete({ releaseId }), devLog.warn("Deleted release due to fatal error", {
-          ...logContext,
-          releaseId
-        });
-      } catch (cleanupError) {
-        devLog.error(
-          "Failed to cleanup release",
-          cleanupError instanceof Error ? cleanupError : new Error(String(cleanupError)),
-          logContext
-        );
-      }
-    throw devLog.timeEnd("translateDocumentSet"), devLog.groupEnd(), dispatch({ type: "SET_OVERALL_STATUS", payload: "error" }), error;
+    ), devLog.timeEnd("translateDocumentSet"), devLog.groupEnd(), dispatch({ type: "SET_OVERALL_STATUS", payload: "error" }), error;
   }
 }, ActionButtonBar = ({ setIsDialogOpen }) => {
   const {
@@ -3534,24 +3185,12 @@ Then return the corrected translation document:`;
               " \u2014 ",
               job._id.slice(-6)
             ] }),
-            !["completed", "skipped", "error"].includes(job.status) && /* @__PURE__ */ jsxs(Stack, { space: 2, children: [
-              /* @__PURE__ */ jsx(Text, { size: 1, weight: "semibold", children: getStatusLabel(job.status) }),
-              job.reasoningProgress && /* @__PURE__ */ jsx(Card, { tone: "primary", padding: 3, radius: 2, children: /* @__PURE__ */ jsxs(Stack, { space: 2, children: [
-                /* @__PURE__ */ jsx(Text, { size: 1, weight: "semibold", children: "\u{1F914} GPT-5 Reasoning" }),
-                /* @__PURE__ */ jsx(Text, { size: 1, style: { fontStyle: "italic" }, children: job.reasoningProgress })
-              ] }) })
-            ] }),
-            job.status === "completed" && job.tokensUsed ? /* @__PURE__ */ jsxs(Stack, { space: 2, children: [
-              /* @__PURE__ */ jsxs(Text, { size: 1, muted: !0, children: [
-                job.tokensUsed.toLocaleString(),
-                " tokens (~$",
-                job.estimatedCost?.toFixed(4),
-                ")"
-              ] }),
-              job.reasoningSummary && /* @__PURE__ */ jsx(Card, { tone: "primary", padding: 2, radius: 2, children: /* @__PURE__ */ jsxs(Text, { size: 1, children: [
-                "\u{1F4A1} ",
-                job.reasoningSummary
-              ] }) })
+            !["completed", "skipped", "error"].includes(job.status) && /* @__PURE__ */ jsx(Text, { size: 1, weight: "semibold", children: getStatusLabel(job.status) }),
+            job.status === "completed" && job.tokensUsed ? /* @__PURE__ */ jsxs(Text, { size: 1, muted: !0, children: [
+              job.tokensUsed.toLocaleString(),
+              " tokens (~$",
+              job.estimatedCost?.toFixed(4),
+              ")"
             ] }) : null,
             job.status === "error" && job.errorMessage ? /* @__PURE__ */ jsx(Card, { tone: "critical", padding: 2, radius: 2, children: /* @__PURE__ */ jsxs(Text, { size: 1, children: [
               "Error: ",
@@ -3665,26 +3304,9 @@ Then return the corrected translation document:`;
   "completed"
 ], STATES_IN_WHICH_TO_SHOW_ERROR = ["error"], TranslationDialog = ({ setIsDialogOpen }) => {
   const { overallStatus, document } = useTranslationContext();
-  return devLog.debug("TranslationDialog rendered", {
-    documentId: document._id,
-    overallStatus,
-    component: "TranslationDialog"
-  }), STATES_IN_WHICH_TO_SHOW_CONFIG.includes(overallStatus) ? (devLog.debug("Showing translation config view", {
-    documentId: document._id,
-    overallStatus,
-    component: "TranslationDialog"
-  }), /* @__PURE__ */ jsx(TranslationConfigView, { setIsDialogOpen })) : STATES_IN_WHICH_TO_SHOW_TRANSLATION_PROGRESS.includes(overallStatus) ? (devLog.debug("Showing translation progress panel", {
+  return STATES_IN_WHICH_TO_SHOW_CONFIG.includes(overallStatus) ? /* @__PURE__ */ jsx(TranslationConfigView, { setIsDialogOpen }) : STATES_IN_WHICH_TO_SHOW_TRANSLATION_PROGRESS.includes(overallStatus) ? /* @__PURE__ */ jsx(TranslationStatusPanel, {}) : STATES_IN_WHICH_TO_SHOW_ERROR.includes(overallStatus) ? /* @__PURE__ */ jsx("div", { children: "Error occurred" }) : (devLog.warn("Unhandled translation dialog state", {
     documentId: document._id,
-    overallStatus,
-    component: "TranslationDialog"
-  }), /* @__PURE__ */ jsx(TranslationStatusPanel, {})) : STATES_IN_WHICH_TO_SHOW_ERROR.includes(overallStatus) ? (devLog.warn("Translation error state reached", {
-    documentId: document._id,
-    overallStatus,
-    component: "TranslationDialog"
-  }), /* @__PURE__ */ jsx("div", { children: "Error occurred" })) : (devLog.warn("Unhandled translation dialog state", {
-    documentId: document._id,
-    overallStatus,
-    component: "TranslationDialog"
+    overallStatus
   }), /* @__PURE__ */ jsx("div", { children: "Unhandled overall state" }));
 }, getTranslateAction = (config) => ({ draft, published }) => {
   const document = draft ?? published, [isDialogOpen, setIsDialogOpen] = useState(!1);
@@ -3711,7 +3333,427 @@ Then return the corrected translation document:`;
       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)]
@@ -3722,6 +3764,8 @@ Then return the corrected translation document:`;
 })), translationHistorySchema = translationHistory;
 export {
   aiTranslationPlugin,
-  translationHistorySchema
+  richTextTransform,
+  translationHistorySchema,
+  vttCaptionTransform
 };
 //# sourceMappingURL=index.js.map