@braze/sanity-plugin-ai-translation 0.2.4 → 0.2.6

package/dist/index.js

@@ -1,15 +1,15 @@
-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, useReducer, useEffect, useContext, useState, useCallback, useMemo } from "react";
+import { getPublishedId, pathToString, useClient, defineType, defineField, definePlugin } from "sanity";
+import { jsx, jsxs, Fragment } from "react/jsx-runtime";
+import { WarningOutlineIcon, SearchIcon, CheckmarkIcon, ErrorOutlineIcon, CircleIcon, ArrowRightIcon, ResetIcon, PanelRightIcon, TranslateIcon } from "@sanity/icons";
+import { createContext, useReducer, useRef, useEffect, useContext, useMemo, useState, useCallback } 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 { Card, Stack, Flex, Text, Box, Heading, Button, Spinner, Inline, Checkbox, Grid, Radio, TextInput, Badge, Select, Label, Code, Tooltip } from "@sanity/ui";
 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";
+import { useListeningQuery, useOpenInNewPane } from "sanity-plugin-utils";
 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) : "");
@@ -62,19 +62,66 @@ const isLoggingEnabled = () => process.env.NEXT_PUBLIC_SANITY_STUDIO_AI_TRANSLAT
       error: error instanceof Error ? error.message : "Network error"
     };
   }
+}, undraftId = (id) => id.replace(/^drafts\./, ""), activeTranslations = /* @__PURE__ */ new Map(), registerActiveTranslation = (documentId, releaseId) => {
+  const entry = {
+    state: {
+      documentId,
+      releaseId,
+      overallStatus: "translating",
+      translationJobs: /* @__PURE__ */ new Map(),
+      startedAt: /* @__PURE__ */ new Date()
+    },
+    subscribers: /* @__PURE__ */ new Set()
+  };
+  activeTranslations.set(documentId, entry);
+}, updateActiveTranslationStatus = (documentId, status) => {
+  const entry = activeTranslations.get(documentId);
+  entry && (entry.state.overallStatus = status, notifySubscribers(entry));
+}, updateActiveTranslationJob = (documentId, job) => {
+  const entry = activeTranslations.get(documentId);
+  if (entry) {
+    const jobKey = `${undraftId(job._id)}_${job.language}`, existingJob = entry.state.translationJobs.get(jobKey), jobWithDefinedValues = Object.fromEntries(
+      Object.entries(job).filter(([_, value]) => value !== void 0)
+    ), mergedJob = existingJob ? { ...existingJob, ...jobWithDefinedValues } : jobWithDefinedValues;
+    entry.state.translationJobs.set(jobKey, mergedJob), notifySubscribers(entry);
+  }
+}, getActiveTranslation = (documentId) => activeTranslations.get(documentId)?.state ?? null, subscribeToActiveTranslation = (documentId, callback) => {
+  const entry = activeTranslations.get(documentId);
+  return entry ? (entry.subscribers.add(callback), callback(entry.state), () => {
+    entry.subscribers.delete(callback);
+  }) : () => {
+  };
+}, cleanupActiveTranslation = (documentId, delayMs = 6e4) => {
+  setTimeout(() => {
+    const entry = activeTranslations.get(documentId);
+    entry && ["completed", "error"].includes(entry.state.overallStatus) && activeTranslations.delete(documentId);
+  }, delayMs);
+}, notifySubscribers = (entry) => {
+  for (const subscriber of entry.subscribers)
+    try {
+      subscriber(entry.state);
+    } catch (error) {
+      console.error("Error in active translation subscriber:", error);
+    }
+}, forceCleanupActiveTranslation = (documentId) => {
+  activeTranslations.delete(documentId);
 }, TranslationContext = createContext({
   document: null,
   config: null,
   overallStatus: "idle",
   selectedTargetLanguages: [],
   translationJobs: /* @__PURE__ */ new Map(),
-  shouldOverwriteFreshTranslations: !1,
   shouldTranslateReferences: !1,
   maxReferenceDepth: 1,
   references: [],
+  selectedReferenceIds: /* @__PURE__ */ new Set(),
   translationMetadata: null,
   translationMode: "sanity-only",
   openaiValidated: !1,
+  releaseConfig: {
+    mode: "new",
+    newReleaseTitle: ""
+  },
   dispatch: () => {
   }
 }), translationReducer = (context, action) => {
@@ -85,7 +132,7 @@ const isLoggingEnabled = () => process.env.NEXT_PUBLIC_SANITY_STUDIO_AI_TRANSLAT
   };
   switch (devLog.debug("Translation action dispatched", {
     ...logContext,
-    payload: action.payload
+    payload: "payload" in action ? action.payload : void 0
   }), action.type) {
     case "SET_OVERALL_STATUS":
       return { ...context, overallStatus: action.payload };
@@ -116,48 +163,106 @@ const isLoggingEnabled = () => process.env.NEXT_PUBLIC_SANITY_STUDIO_AI_TRANSLAT
         ...context,
         maxReferenceDepth: action.payload
       };
-    case "SET_SHOULD_OVERWRITE_FRESH_TRANSLATIONS":
+    case "SET_REFERENCES":
       return {
         ...context,
-        shouldOverwriteFreshTranslations: action.payload
+        references: action.payload
       };
-    case "SET_REFERENCES":
+    case "SET_SELECTED_REFERENCE_IDS":
       return {
         ...context,
-        references: action.payload
+        selectedReferenceIds: 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);
+      if (!action.payload._id)
+        return devLog.warn("SET_TRANSLATION_JOB_STATUS action missing _id", {
+          ...logContext,
+          payload: action.payload
+        }), context;
+      const jobKey = `${undraftId(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
       };
     }
+    case "SET_RELEASE_CONFIG":
+      return {
+        ...context,
+        releaseConfig: {
+          ...context.releaseConfig,
+          ...action.payload
+        }
+      };
+    case "RESET_TRANSLATION_STATE":
+      return devLog.info("Resetting translation state for new translation", {
+        ...logContext,
+        previousStatus: context.overallStatus,
+        previousJobCount: context.translationJobs.size
+      }), {
+        ...context,
+        overallStatus: "idle",
+        translationJobs: /* @__PURE__ */ new Map(),
+        selectedReferenceIds: /* @__PURE__ */ new Set(),
+        // Clear any release conflicts from previous run
+        releaseConfig: {
+          ...context.releaseConfig,
+          conflicts: void 0,
+          replaceExisting: void 0
+        }
+      };
     default:
       return context;
   }
-}, TranslationContextProvider = ({ document, config, children }) => {
+}, generateDefaultReleaseTitle = (document) => `[AI Translation] ${document.title || document.name || document._id.split("-").slice(0, 2).join("-")}`, 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 = {
+  const defaultReleaseTitle = generateDefaultReleaseTitle(document), activeTranslation = getActiveTranslation(document._id), initialContext = {
     document,
     config,
-    overallStatus: "idle",
+    // If there's an active translation, restore its state
+    overallStatus: activeTranslation?.overallStatus ?? "idle",
     translationMetadata: null,
     selectedTargetLanguages: [],
-    shouldOverwriteFreshTranslations: !1,
     shouldTranslateReferences: !1,
     maxReferenceDepth: 1,
     references: [],
-    translationJobs: /* @__PURE__ */ new Map(),
+    selectedReferenceIds: /* @__PURE__ */ new Set(),
+    // Restore jobs from active translation if available
+    translationJobs: activeTranslation?.translationJobs ?? /* @__PURE__ */ new Map(),
     translationMode: config?.openai?.defaultMode || "sanity-only",
-    openaiValidated: !1
-  }, [context, dispatch] = useReducer(translationReducer, initialContext);
+    openaiValidated: !1,
+    releaseConfig: {
+      mode: "new",
+      newReleaseTitle: defaultReleaseTitle
+    }
+  };
+  activeTranslation && devLog.info("Reconnecting to active translation", {
+    documentId: document._id,
+    status: activeTranslation.overallStatus,
+    jobCount: activeTranslation.translationJobs.size,
+    component: "TranslationContextProvider"
+  });
+  const [context, dispatch] = useReducer(translationReducer, initialContext), lastProcessedRefsRef = useRef("");
   return useEffect(() => {
+    const handleActiveTranslationUpdate = (state) => {
+      dispatch({
+        type: "SET_OVERALL_STATUS",
+        payload: state.overallStatus
+      });
+      for (const job of state.translationJobs.values())
+        dispatch({
+          type: "SET_TRANSLATION_JOB_STATUS",
+          payload: job
+        });
+    }, unsubscribe = subscribeToActiveTranslation(document._id, handleActiveTranslationUpdate);
+    return () => {
+      unsubscribe();
+    };
+  }, [document._id]), useEffect(() => {
     (async () => {
       if (config?.openai?.enabled && config?.openai?.apiKey)
         try {
@@ -181,7 +286,28 @@ const isLoggingEnabled = () => process.env.NEXT_PUBLIC_SANITY_STUDIO_AI_TRANSLAT
           });
         }
     })();
-  }, [config?.openai?.apiKey, config?.openai?.enabled, config?.openai?.model]), devLog.debug("Translation context state initialized", {
+  }, [config?.openai?.apiKey, config?.openai?.enabled, config?.openai?.model]), useEffect(() => {
+    const currentRefsKey = context.references.map((ref) => ref._id).sort().join(",");
+    if (currentRefsKey !== lastProcessedRefsRef.current) {
+      if (context.references.length > 0) {
+        const currentReferenceIds = new Set(context.references.map((ref) => ref._id)), previousReferenceIds = new Set(
+          lastProcessedRefsRef.current ? lastProcessedRefsRef.current.split(",") : []
+        ), hasNewReferences = Array.from(currentReferenceIds).some((id) => !previousReferenceIds.has(id)), currentSelection = context.selectedReferenceIds;
+        if (currentSelection.size === 0 || hasNewReferences) {
+          const newSelection = new Set(currentSelection);
+          currentReferenceIds.forEach((id) => {
+            newSelection.add(id);
+          });
+          const currentIds = Array.from(currentSelection).sort(), newIds = Array.from(newSelection).sort();
+          (currentIds.length !== newIds.length || !currentIds.every((id, i) => id === newIds[i])) && dispatch({
+            type: "SET_SELECTED_REFERENCE_IDS",
+            payload: newSelection
+          });
+        }
+      }
+      lastProcessedRefsRef.current = currentRefsKey;
+    }
+  }, [context.references, context.selectedReferenceIds]), devLog.debug("Translation context state initialized", {
     documentId: document._id,
     overallStatus: context.overallStatus,
     selectedLanguages: context.selectedTargetLanguages,
@@ -196,1044 +322,238 @@ const isLoggingEnabled = () => process.env.NEXT_PUBLIC_SANITY_STUDIO_AI_TRANSLAT
       "useTranslationContext must be used within a TranslationContextProvider with document and config props"
     );
   return context;
-}, 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),
-      translationMetadataType: TRANSLATION_METADATA_TYPE
-    },
-    initialValue: null
+}, getExistingTranslationId = (translationMetadata, targetLanguage) => translationMetadata?.translations?.length && translationMetadata.translations.find(
+  (translation) => translation._key === targetLanguage
+)?.value._ref || null, TRANSLATION_METADATA_TYPE = "translation.metadata", getTranslationMetadata = async ({
+  client,
+  sourceDocument,
+  sourceLanguage
+}) => {
+  try {
+    return await client.fetch(
+      "*[_type == $tmType && references($sourceDocumentId)][0]",
+      {
+        tmType: TRANSLATION_METADATA_TYPE,
+        sourceDocumentId: undraftId(sourceDocument._id)
+      }
+    ) || await client.create({
+      _type: TRANSLATION_METADATA_TYPE,
+      translations: [
+        {
+          _key: sourceLanguage,
+          _type: "internationalizedArrayReferenceValue",
+          value: {
+            _type: "reference",
+            _ref: undraftId(sourceDocument._id),
+            _weak: !0,
+            _strengthenOnPublish: {
+              _type: sourceDocument._type,
+              _weak: !1
+            }
+          }
+        }
+      ],
+      translationHistory: []
+    });
+  } catch (error) {
+    throw console.error(sourceDocument._id, "Error creating translation metadata:", error), error;
+  }
+}, checkDocumentConflicts = async ({
+  client,
+  releaseId,
+  documentId,
+  documentTitle,
+  documentType,
+  targetLanguages,
+  languageFieldName
+}) => {
+  const conflicts = [], document = await client.withConfig({ perspective: "drafts" }).getDocument(documentId);
+  if (!document)
+    return conflicts;
+  const sourceLanguage = document[languageFieldName], translationMetadata = await getTranslationMetadata({
+    client,
+    sourceDocument: document,
+    sourceLanguage
   });
-  return useEffect(() => {
-    if (loading) {
-      dispatch({ type: "SET_OVERALL_STATUS", payload: "fetching_metadata" });
-      return;
-    }
-    if (error) {
-      dispatch({ type: "SET_OVERALL_STATUS", payload: "error" });
-      return;
-    }
-    if (data) {
-      dispatch({ type: "SET_TRANSLATION_METADATA", payload: data }), dispatch({ type: "SET_OVERALL_STATUS", payload: "idle" });
-      return;
+  for (const targetLanguage of targetLanguages) {
+    const existingTranslationId = getExistingTranslationId(translationMetadata, targetLanguage);
+    if (existingTranslationId) {
+      const versionedId = `versions.${releaseId}.${existingTranslationId}`;
+      await client.getDocument(versionedId) && (conflicts.push({
+        sourceDocumentId: documentId,
+        sourceDocumentTitle: documentTitle || document.title || document.name,
+        sourceDocumentType: documentType || document._type,
+        targetLanguage,
+        existingVersionId: versionedId
+      }), devLog.debug("Found existing version in release", {
+        releaseId,
+        sourceDocumentId: documentId,
+        targetLanguage,
+        versionedId
+      }));
     }
-    dispatch({ type: "SET_OVERALL_STATUS", payload: "idle" });
-  }, [data, loading, error, dispatch]), {
-    data,
-    loading,
-    error
-  };
-};
-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" };
-}
-async function validateGlossaryTerm(client, suggestion) {
-  const { sourceValue, targetValue, sourceLocale, targetLocale } = suggestion;
-  if (!sourceValue || !targetValue || !sourceLocale || !targetLocale)
-    return {
-      valid: !1,
-      status: "invalid",
-      reason: "Missing required fields for glossary term"
-    };
-  if (sourceValue.trim() === targetValue.trim())
-    return {
-      valid: !1,
-      status: "invalid",
-      reason: `Source and target are identical ("${sourceValue}") - this should be a protected phrase instead`
-    };
-  const protectedPhrases = await client.fetch('*[_id == "translation-settings"][0].protectedPhrases');
-  if (protectedPhrases?.some((phrase) => phrase.toLowerCase() === sourceValue.toLowerCase()))
-    return {
-      valid: !1,
-      status: "invalid",
-      reason: `Cannot add "${sourceValue}" to glossary because it is already a protected phrase. Protected phrases are never translated. If you want to create a translation mapping for this term, please remove it from protected phrases first by editing Translation Settings.`
-    };
-  if (targetValue && protectedPhrases?.some((phrase) => phrase.toLowerCase() === targetValue.toLowerCase()))
-    return {
-      valid: !1,
-      status: "invalid",
-      reason: `Cannot use "${targetValue}" as a translation target because it is a protected phrase. Protected phrases should not appear as translation targets.`
-    };
-  const existingTerm = await client.fetch(
-    `*[_type == "translationGlossaryTerm" && count(translations[_key == $sourceLocale && value == $sourceValue]) > 0][0] {
-        translations
-      }`,
-    { sourceLocale, sourceValue }
-  );
-  if (existingTerm) {
-    const existingTarget = existingTerm.translations.find((t) => t._key === targetLocale);
-    if (existingTarget?.value === targetValue)
-      return {
-        valid: !0,
-        status: "warning",
-        reason: `This translation already exists in the glossary: "${sourceValue}" \u2192 "${targetValue}"`
-      };
-    if (existingTarget && existingTarget.value !== targetValue)
-      return {
-        valid: !0,
-        status: "warning",
-        reason: `"${sourceValue}" already has a different translation in the glossary: "${existingTarget.value}". Applying this will update it to "${targetValue}".`
-      };
   }
-  return { valid: !0, status: "valid" };
-}
-async function validateProtectedPhrase(client, suggestion) {
-  const phrase = suggestion.description.trim();
-  if (!phrase)
-    return {
-      valid: !1,
-      status: "invalid",
-      reason: "Protected phrase cannot be empty"
-    };
-  if ((await client.fetch('*[_id == "translation-settings"][0].protectedPhrases'))?.some((p) => p.toLowerCase() === phrase.toLowerCase()))
-    return {
-      valid: !0,
-      status: "warning",
-      reason: `"${phrase}" is already in protected phrases`
-    };
-  const glossaryTermWithPhrase = await client.fetch(
-    `*[_type == "translationGlossaryTerm" && count(translations[value == $phrase]) > 0][0] {
-        _id,
-        translations
-      }`,
-    { phrase }
-  );
-  if (glossaryTermWithPhrase) {
-    const matchingTranslations = glossaryTermWithPhrase.translations.filter((t) => t.value.toLowerCase() === phrase.toLowerCase()).map((t) => t._key).join(", ");
-    return {
-      valid: !1,
-      status: "invalid",
-      reason: `Cannot add "${phrase}" as a protected phrase because it exists in the glossary as a translation (${matchingTranslations}). If you want to prevent this term from being translated, please remove it from the glossary first by editing Translation Settings.`
-    };
-  }
-  return { valid: !0, status: "valid" };
-}
-function validatePrompt(suggestion) {
-  const update = suggestion.description.trim();
-  return update ? update.toLowerCase().includes("has been") || update.toLowerCase().includes("was changed") || update.toLowerCase().includes("corrected to") ? {
-    valid: !0,
-    status: "warning",
-    reason: "This update may be describing past changes rather than adding new rules"
-  } : { valid: !0, status: "valid" } : {
-    valid: !1,
-    status: "invalid",
-    reason: "Prompt update cannot be empty"
-  };
-}
-async function analyzeFeedback({
-  client,
-  sourceLanguage,
-  targetLanguage,
-  userFeedback,
-  shouldIncludeEdits,
-  sourceSnapshot,
-  targetSnapshot,
-  currentDocument,
-  onProgress
-}) {
-  onProgress?.({ stage: "analyzing", message: "Analyzing feedback and edits..." });
-  const analysisPrompt = buildAnalysisPrompt({
-    sourceLanguage,
-    targetLanguage,
-    userFeedback,
-    shouldIncludeEdits,
-    sourceSnapshot,
-    targetSnapshot,
-    currentDocument
-  }), 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);
-      return {
-        ...suggestion,
-        warning: validation.reason,
-        validationStatus: validation.status,
-        // Only auto-approve valid suggestions; invalid ones cannot be approved
-        approved: validation.status === "valid"
-      };
-    })
-  );
-  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
-  }), validatedSuggestions;
-}
-async function applySuggestions({
+  return conflicts;
+}, checkReleaseConflicts = async ({
   client,
-  schemaId,
-  sourceLanguage,
-  targetLanguage,
-  suggestions,
-  onProgress
-}) {
-  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);
-  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,
-  targetLanguage,
-  userFeedback,
-  shouldIncludeEdits,
-  sourceSnapshot,
-  targetSnapshot,
-  currentDocument
-}) {
-  const parts = [
-    "You are analyzing feedback about AI translation quality to improve future translations.",
-    `Source language: ${sourceLanguage}`,
-    `Target language: ${targetLanguage}`,
-    "",
-    "Your task is to analyze the feedback and infer specific improvements to:",
-    "1. Global translation prompt (general guidance for all translations)",
-    "2. Locale-specific prompt (guidance specific to this target language)",
-    "3. Protected phrases (terms that should never be translated)",
-    "4. Glossary terms (specific term-to-term translation mappings)",
-    ""
-  ];
-  return userFeedback && parts.push("USER FEEDBACK:", userFeedback, ""), shouldIncludeEdits && sourceSnapshot && targetSnapshot && currentDocument && parts.push(
-    "EDIT ANALYSIS:",
-    "Compare the original translation with the edited version to understand what the user changed.",
-    "",
-    "Original source document:",
-    sourceSnapshot,
-    "",
-    "Original AI translation:",
-    targetSnapshot,
-    "",
-    "Current edited document:",
-    JSON.stringify(currentDocument, null, 2),
-    ""
-  ), parts.push(
-    "INSTRUCTIONS:",
-    "Analyze the feedback and/or edits to identify patterns and improvements.",
-    "",
-    "For edits, look for:",
-    "- Terminology changes that suggest glossary additions",
-    "- Phrases that were protected/unprotected incorrectly",
-    "- Style, tone, or formatting issues that suggest prompt improvements",
-    "- Consistent patterns across multiple changes",
-    "",
-    "IMPORTANT RULES:",
-    "1. DO NOT create redundant updates. Choose ONE mechanism for each issue:",
-    "   - Protected phrases = terms that should NEVER be translated (language-agnostic)",
-    '   - Glossary terms = specific translation mappings (e.g., "chat" \u2192 "cat" in French)',
-    "   - Locale prompts = guidance specific to this source\u2192target language pair",
-    "   - Global prompts = guidance that applies to ALL translations",
-    "",
-    "2. Be locale-specific:",
-    `   - This feedback is specifically about ${sourceLanguage} \u2192 ${targetLanguage} translation`,
-    "   - DO NOT assume rules apply to other language pairs unless explicitly stated",
-    "   - Prefer locale-specific prompts over global prompts unless universally applicable",
-    "",
-    "3. Protected phrases vs. Locale prompts:",
-    "   - Use protected phrases ONLY for brand names, product names, proper nouns, technical terms that should NEVER be translated in ANY language",
-    '   - Use locale prompts for language-pair-specific guidance (e.g., "Keep technical terms in English when translating to German")',
-    "   - NEVER mention specific terms in both protected phrases AND prompts",
-    "",
-    "4. Glossary vs. Protected phrases:",
-    '   - Glossary = "Always translate X as Y" (provides the correct translation)',
-    '   - Protected = "Never translate X" (keeps it as-is)',
-    "   - CRITICAL: If sourceValue === targetValue, use PROTECTED PHRASES, NOT glossary",
-    "   - Only use glossary when the term actually changes between languages",
-    "   - Use protected when the term should remain unchanged across all languages",
-    "",
-    "Output a JSON object with this structure:",
-    "{",
-    '  "globalPromptUpdates": "string | null - ONLY if this applies to ALL language pairs",',
-    `  "localePromptUpdates": "string | null - ONLY if this is specific to ${sourceLanguage}\u2192${targetLanguage}",`,
-    '  "protectedPhrasesToAdd": ["ONLY brand names, products, proper nouns that should NEVER translate"],',
-    '  "glossaryTermsToAdd": [{"sourceLocale": "sourceLocale","sourceValue": "term", "targetLocale": "targetLocale", "targetValue": "translation"} - ONLY specific term mappings],',
-    '  "reasoning": "string - Explain your analysis and which mechanism you chose for each issue"',
-    "}",
-    "",
-    "Be conservative: only suggest changes when there is clear evidence.",
-    "If in doubt, prefer locale-specific updates over global updates.",
-    "Avoid redundancy - if you add a protected phrase, do NOT mention it in prompts.",
-    "",
-    "CONCRETE EXAMPLES:",
-    "",
-    "Example 1 - Brand name protection:",
-    'User feedback: "Braze should never be translated"',
-    "Correct output:",
-    "{",
-    '  "protectedPhrasesToAdd": ["Braze"],',
-    '  "reasoning": "User explicitly stated Braze is a brand name that should not be translated"',
-    "}",
-    "WRONG: Do not add this to glossary or prompts.",
-    "",
-    "Example 2 - Terminology correction:",
-    'Edit analysis: User changed "discussion" to "chat" consistently in French translation',
-    "Correct output:",
-    "{",
-    `  "glossaryTermsToAdd": [{"sourceLocale": "${sourceLanguage}", "sourceValue": "discussion", "targetLocale": "${targetLanguage}", "targetValue": "chat"}],`,
-    '  "reasoning": "User consistently changed discussion\u2192chat, indicating preferred terminology"',
-    "}",
-    "WRONG: Do not add to protected phrases (values differ) or prompts (specific mapping).",
-    "",
-    "Example 3 - Style guidance:",
-    'User feedback: "Translation is too formal, use casual tone"',
-    "Correct output:",
-    "{",
-    `  "localePromptUpdates": "Use a casual, conversational tone when translating to ${targetLanguage}. Avoid overly formal language.",`,
-    '  "reasoning": "This is style guidance specific to this language pair"',
-    "}",
-    "WRONG: Do not make global (applies only to this target language).",
-    "",
-    "Example 4 - Technical term in English:",
-    `User feedback: "Keep technical terms like 'API' and 'webhook' in English"`,
-    "Correct output:",
-    "{",
-    `  "localePromptUpdates": "When translating to ${targetLanguage}, keep technical terms like 'API', 'webhook', and similar technical jargon in English.",`,
-    '  "reasoning": "This is language-pair-specific guidance about handling technical terms"',
-    "}",
-    'WRONG: Do not add "API" or "webhook" to protected phrases (already covered by prompt guidance).',
-    "",
-    "Example 5 - Multiple issues:",
-    'User feedback: "MyApp is our product name. Also, use more concise language."',
-    "Correct output:",
-    "{",
-    '  "protectedPhrasesToAdd": ["MyApp"],',
-    `  "localePromptUpdates": "Use concise language when translating to ${targetLanguage}. Prefer shorter phrases over lengthy explanations.",`,
-    '  "reasoning": "MyApp is a product name (protected). Conciseness is a style preference for this language pair (locale prompt)."',
-    "}",
-    "",
-    "Example 6 - Identical source and target:",
-    'Edit analysis: User kept "dashboard" as "dashboard" in Spanish',
-    "Correct output:",
-    "{",
-    '  "protectedPhrasesToAdd": ["dashboard"],',
-    '  "reasoning": "User kept the term unchanged, indicating it should not be translated"',
-    "}",
-    "WRONG: Do not add to glossary when source === target."
-  ), parts.join(`
-`);
-}
-function convertAnalysisToSuggestions(analysis, sourceLanguage, targetLanguage) {
-  const suggestions = [];
-  if (analysis.globalPromptUpdates && suggestions.push({
-    id: crypto.randomUUID(),
-    type: "globalPrompt",
-    description: analysis.globalPromptUpdates,
-    approved: !0
-  }), analysis.localePromptUpdates && suggestions.push({
-    id: crypto.randomUUID(),
-    type: "localePrompt",
-    description: analysis.localePromptUpdates,
-    approved: !0
-  }), analysis.protectedPhrasesToAdd)
-    for (const phrase of analysis.protectedPhrasesToAdd)
-      suggestions.push({
-        id: crypto.randomUUID(),
-        type: "protectedPhrase",
-        description: phrase,
-        approved: !0
-      });
-  if (analysis.glossaryTermsToAdd)
-    for (const term of analysis.glossaryTermsToAdd)
-      suggestions.push({
-        id: crypto.randomUUID(),
-        type: "glossaryTerm",
-        description: `${term.sourceValue} \u2192 ${term.targetValue}`,
-        approved: !0,
-        // Use explicit source/target languages from history instead of AI-provided values
-        sourceLocale: sourceLanguage,
-        sourceValue: term.sourceValue,
-        targetLocale: targetLanguage,
-        targetValue: term.targetValue
-      });
-  return suggestions;
-}
-async function analyzeWithAI(client, prompt) {
+  releaseId,
+  sourceDocument,
+  targetLanguages,
+  languageFieldName,
+  references = []
+}) => {
+  const allConflicts = [];
   try {
-    const response = await client.agent.action.prompt({
-      instruction: prompt,
-      format: "json"
+    const documentsToCheck = [
+      {
+        _id: sourceDocument._id,
+        _type: sourceDocument._type,
+        title: sourceDocument.title || sourceDocument.name
+      },
+      ...references.map((ref) => ({
+        _id: ref._id,
+        _type: ref._type,
+        title: ref.title
+      }))
+    ], conflictChecks = await Promise.all(
+      documentsToCheck.map(
+        (doc) => checkDocumentConflicts({
+          client,
+          releaseId,
+          documentId: doc._id,
+          documentTitle: doc.title,
+          documentType: doc._type,
+          targetLanguages,
+          languageFieldName
+        })
+      )
+    );
+    for (const conflicts of conflictChecks)
+      allConflicts.push(...conflicts);
+    devLog.debug("Release conflict check complete", {
+      releaseId,
+      documentsChecked: documentsToCheck.length,
+      conflictsFound: allConflicts.length
     });
-    devLog.debug("AI response received", { responseType: typeof response });
-    const responseText = typeof response == "string" ? response : response && typeof response == "object" ? JSON.stringify(response) : (() => {
-      throw new Error(`Unexpected response type: ${typeof response}`);
-    })();
-    return parseAIResponse(responseText);
   } catch (error) {
-    throw devLog.error("Error during AI analysis", { error }), new Error(`Failed to analyze feedback: ${error instanceof Error ? error.message : "Unknown error"}`);
+    devLog.error("Error checking release conflicts", error instanceof Error ? error : new Error(String(error)), {
+      releaseId,
+      sourceDocumentId: sourceDocument._id,
+      targetLanguages,
+      referencesCount: references.length
+    });
   }
-}
-function parseAIResponse(responseText) {
-  try {
-    let parsed;
-    try {
-      parsed = JSON.parse(responseText);
-    } catch {
-      const jsonMatch = responseText.match(/\{[\s\S]*\}/);
-      if (!jsonMatch) throw new Error("No JSON found in AI response");
-      parsed = JSON.parse(jsonMatch[0]);
-    }
-    if (!parsed || typeof parsed != "object")
-      throw new Error("Response is not a valid object");
-    const analysis = parsed;
-    if (typeof analysis.reasoning != "string")
-      throw new Error("Invalid response structure: missing reasoning");
-    return {
-      globalPromptUpdates: analysis.globalPromptUpdates || void 0,
-      localePromptUpdates: analysis.localePromptUpdates || void 0,
-      protectedPhrasesToAdd: Array.isArray(analysis.protectedPhrasesToAdd) ? analysis.protectedPhrasesToAdd : [],
-      glossaryTermsToAdd: Array.isArray(analysis.glossaryTermsToAdd) ? analysis.glossaryTermsToAdd : [],
-      reasoning: analysis.reasoning
-    };
-  } catch (error) {
-    throw devLog.error("Error parsing AI response", { error, responseText }), new Error("Failed to parse AI response as JSON");
+  return allConflicts;
+};
+function isNetworkError(error) {
+  if (!error) return !1;
+  if (error instanceof TypeError) {
+    const message = error.message.toLowerCase();
+    return message.includes("fetch") || message.includes("network") || message.includes("connection") || message.includes("failed to fetch") || message.includes("networkerror");
   }
-}
-async function applyImprovementsFromSuggestions(client, schemaId, targetLanguage, suggestions, onProgress) {
-  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()), glossaryTerms = suggestions.filter(
-    (s) => s.type === "glossaryTerm" && s.sourceLocale?.trim() && s.sourceValue?.trim() && s.targetLocale?.trim() && s.targetValue?.trim()
-  );
-  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);
-    updates.push(addProtectedPhrases(client, settingsId, phrases));
+  if (error && typeof error == "object" && "code" in error) {
+    const code = error.code;
+    return ["ECONNRESET", "ETIMEDOUT", "ENOTFOUND", "ECONNREFUSED", "EHOSTUNREACH"].includes(code);
   }
-  if (glossaryTerms.length > 0) {
-    onProgress?.({ stage: "applying", message: "Adding glossary terms..." });
-    const terms = glossaryTerms.map((s) => ({
-      // biome-ignore-start lint/style/noNonNullAssertion: safely handled
-      sourceLocale: s.sourceLocale,
-      sourceValue: s.sourceValue,
-      targetLocale: s.targetLocale,
-      targetValue: s.targetValue
-      // biome-ignore-end lint/style/noNonNullAssertion: safely handled
-    }));
-    updates.push(addGlossaryTerms(client, terms));
+  if (error && typeof error == "object" && "response" in error) {
+    const response = error.response;
+    if (response?.status)
+      return response.status >= 500 || response.status === 429;
   }
-  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)
-  );
+  if (error instanceof Error) {
+    const message = error.message;
+    if (/\b(50[0-9]|429)\b/.test(message))
+      return !0;
+  }
+  return !1;
 }
-async function updatePromptsWithTemplate(client, _schemaId, settingsId, targetLanguage, globalPrompts, localePrompts) {
-  if (!targetLanguage)
-    throw devLog.error("targetLanguage is undefined or empty!", {
-      targetLanguage,
-      globalPrompts: globalPrompts.length,
-      localePrompts: localePrompts.length
-    }), new Error("targetLanguage is required but was undefined");
-  const timestamp = (/* @__PURE__ */ new Date()).toISOString().split("T")[0], currentSettings = await client.fetch("*[_id == $settingsId][0]{ globalPrompt, localePrompts }", { settingsId });
-  if (globalPrompts.length > 0) {
-    const currentGlobalPrompt = currentSettings?.globalPrompt || "", updates = globalPrompts.map((s) => s.description.trim()).filter(Boolean), newGlobalPrompt = [
-      currentGlobalPrompt,
-      currentGlobalPrompt ? `
-` : "",
-      `## User Feedback (${timestamp})`,
-      ...updates.map((update) => `- ${update}`)
-    ].filter(Boolean).join(`
-`);
-    await client.patch(settingsId).set({ globalPrompt: newGlobalPrompt }).commit();
+function isSanityMutationError(error) {
+  if (!error) return !1;
+  if (error instanceof Error) {
+    const message = error.message.toLowerCase();
+    return [
+      "validation",
+      "schema",
+      "invalid document",
+      "invalid field",
+      "type mismatch",
+      "reference",
+      "patch",
+      "mutation",
+      "document structure",
+      "required field",
+      "field type",
+      "sanity"
+    ].some((pattern) => message.includes(pattern));
   }
-  if (localePrompts.length > 0) {
-    const updates = localePrompts.map((s) => s.description.trim()).filter(Boolean), existingLocalePrompts = currentSettings?.localePrompts || [], existingLocalePrompt = existingLocalePrompts.find((lp) => lp._key === targetLanguage);
-    if (existingLocalePrompt) {
-      const currentValue = existingLocalePrompt.value || "", newValue = [
-        currentValue,
-        currentValue ? `
-` : "",
-        `## User Feedback (${timestamp})`,
-        ...updates.map((update) => `- ${update}`)
-      ].filter(Boolean).join(`
-`), localeIndex = existingLocalePrompts.findIndex((lp) => lp._key === targetLanguage);
-      await client.patch(settingsId).set({ [`localePrompts[${localeIndex}].value`]: newValue }).commit();
-    } else {
-      const newValue = [`## User Feedback (${timestamp})`, ...updates.map((update) => `- ${update}`)].filter(Boolean).join(`
-`);
-      await client.patch(settingsId).setIfMissing({ localePrompts: [] }).append("localePrompts", [
-        {
-          _type: "internationalizedArrayTextValue",
-          _key: targetLanguage,
-          value: newValue
-        }
-      ]).commit();
+  if (error && typeof error == "object") {
+    const errorObj = error;
+    if (("statusCode" in errorObj || "response" in errorObj || "details" in errorObj) && "statusCode" in errorObj) {
+      const statusCode = errorObj.statusCode;
+      if (statusCode >= 400 && statusCode < 500 && statusCode !== 429)
+        return !0;
     }
   }
-  devLog.info("Prompts updated successfully", {
-    targetLanguage,
-    globalUpdated: globalPrompts.length > 0,
-    localeUpdated: localePrompts.length > 0
-  });
-}
-async function addProtectedPhrases(client, settingsId, phrases) {
-  const currentPhrases = await client.fetch("*[_id == $settingsId][0].protectedPhrases", { settingsId });
-  let newPhrases = phrases.filter((phrase) => !currentPhrases?.includes(phrase));
-  const conflictingPhrases = [];
-  for (const phrase of newPhrases)
-    await client.fetch(
-      'count(*[_type == "translationGlossaryTerm" && count(translations[value == $phrase]) > 0]) > 0',
-      { phrase }
-    ) && (conflictingPhrases.push(phrase), devLog.warn("Skipping protected phrase due to glossary conflict", { phrase }));
-  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 }));
+  return !1;
 }
-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)", {
-    sourceValue,
-    targetValue
-  }), !1) : protectedPhrasesLower.includes(sourceValue.toLowerCase()) ? (devLog.warn("Skipping glossary term because source value is a protected phrase", {
-    sourceValue,
-    targetValue
-  }), !1) : protectedPhrasesLower.includes(targetValue.toLowerCase()) ? (devLog.warn("Skipping glossary term because target value is a protected phrase", {
-    sourceValue,
-    targetValue
-  }), !1) : !0);
-  if (validTerms.length === 0) {
-    devLog.info("No valid glossary terms to add");
-    return;
-  }
-  for (const { sourceLocale, sourceValue, targetLocale, targetValue } of validTerms) {
-    const existingTerm = await client.fetch(
-      `*[_type == "translationGlossaryTerm" && count(translations[_key == $sourceLocale && value == $sourceValue]) > 0
-      ][0] {
-        _id,
-        translations
-      }`,
-      { sourceLocale, sourceValue }
-    );
-    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", [
-        {
-          _type: "internationalizedArrayStringValue",
-          _key: targetLocale,
-          value: targetValue
-        }
-      ]).commit() : existingTargetValue !== targetValue && await client.patch(existingTerm._id).set({ [`translations[${existingTargetIndex}].value`]: targetValue }).commit();
-    } else
-      await client.create({
-        _type: "translationGlossaryTerm",
-        translations: [
-          {
-            _type: "internationalizedArrayStringValue",
-            _key: sourceLocale,
-            value: sourceValue
-          },
-          {
-            _type: "internationalizedArrayStringValue",
-            _key: targetLocale,
-            value: targetValue
-          }
-        ]
-      });
-  }
-  devLog.info("Glossary terms processed", {
-    processed: validTerms.length,
-    skipped: terms.length - validTerms.length
-  });
+const DEFAULT_RETRY_OPTIONS = {
+  maxAttempts: 2,
+  initialDelayMs: 0,
+  maxDelayMs: 5e3,
+  backoffMultiplier: 2,
+  retryableErrors: isNetworkError,
+  logRetries: !0
+};
+function calculateDelay(attempt, options) {
+  const delay = options.initialDelayMs * Math.pow(options.backoffMultiplier, attempt);
+  return Math.min(delay, options.maxDelayMs);
 }
-async function recordChangeHistory(client, settingsId, targetLanguage, suggestions) {
-  const timestamp = (/* @__PURE__ */ new Date()).toISOString(), historyEntries = suggestions.map((suggestion) => ({
-    _type: "object",
-    _key: crypto.randomUUID(),
-    timestamp,
-    changeType: suggestion.type,
-    description: suggestion.description,
-    locale: suggestion.type === "localePrompt" ? targetLanguage : void 0
-  }));
-  historyEntries.length !== 0 && await client.patch(settingsId).setIfMissing({ changeHistory: [] }).append("changeHistory", historyEntries).commit();
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
 }
-const ICON_SIZE = 64, progressIconMap = {
-  in_progress: /* @__PURE__ */ jsx(Spinner, {}),
-  completed: /* @__PURE__ */ jsx(CheckmarkCircleIcon, { fontSize: ICON_SIZE }),
-  error: /* @__PURE__ */ jsx(ErrorOutlineIcon, { fontSize: ICON_SIZE })
-}, ProgressPanel = ({
-  title,
-  description,
-  tone,
-  status = "in_progress",
-  icon,
-  ...props
-}) => /* @__PURE__ */ jsx(Card, { tone, padding: 4, ...props, children: /* @__PURE__ */ jsxs(Flex, { gap: 4, align: "center", justify: "center", children: [
-  icon || progressIconMap[status],
-  /* @__PURE__ */ jsxs(Stack, { space: 3, children: [
-    title && /* @__PURE__ */ jsx(Text, { size: 2, weight: "bold", children: title }),
-    description && /* @__PURE__ */ jsx(Text, { size: 1, muted: !0, children: description })
-  ] })
-] }) }), IMPROVEMENT_TYPE_LABELS = {
-  globalPrompt: "Global Prompt",
-  localePrompt: "Locale Prompt",
-  protectedPhrase: "Protected Phrase",
-  glossaryTerm: "Glossary Term"
-}, createNewSuggestion = (type = "protectedPhrase", sourceLanguage, targetLanguage) => {
-  const baseSuggestion = {
-    id: crypto.randomUUID(),
-    type,
-    description: "",
-    approved: !0
-  };
-  return type === "glossaryTerm" ? {
-    ...baseSuggestion,
-    sourceValue: "",
-    targetValue: "",
-    sourceLocale: sourceLanguage,
-    targetLocale: targetLanguage
-  } : baseSuggestion;
-}, SuggestionReviewList = ({
-  suggestions,
-  onSuggestionsChange,
-  sourceLanguage,
-  targetLanguage
-}) => {
-  const [editingId, setEditingId] = useState(null), handleToggleApproval = (id) => {
-    const updated = suggestions.map((s) => s.id === id && s.validationStatus !== "invalid" ? { ...s, approved: !s.approved } : s);
-    onSuggestionsChange(updated);
-  }, handleTypeChange = (id, newType) => {
-    const updated = suggestions.map((s) => {
-      if (s.id !== id)
-        return s;
-      if (newType === "glossaryTerm" && s.type !== "glossaryTerm") {
-        const match = s.description.match(/^(.+?)\s*→\s*(.+)$/);
-        return {
-          ...s,
-          type: newType,
-          sourceValue: match ? match[1].trim() : "",
-          targetValue: match ? match[2].trim() : "",
-          sourceLocale: sourceLanguage,
-          targetLocale: targetLanguage
-        };
-      }
-      return newType !== "glossaryTerm" && s.type === "glossaryTerm" ? {
-        ...s,
-        type: newType,
-        description: s.sourceValue && s.targetValue ? `${s.sourceValue} \u2192 ${s.targetValue}` : s.description,
-        sourceValue: void 0,
-        targetValue: void 0
-      } : { ...s, type: newType };
-    });
-    onSuggestionsChange(updated);
-  }, handleDescriptionChange = (id, newDescription) => {
-    const updated = suggestions.map((s) => s.id === id ? { ...s, description: newDescription } : s);
-    onSuggestionsChange(updated);
-  }, handleGlossarySourceChange = (id, newSource) => {
-    const updated = suggestions.map(
-      (s) => s.id === id ? {
-        ...s,
-        sourceValue: newSource,
-        description: `${newSource} \u2192 ${s.targetValue || ""}`
-        // Preserve sourceLocale and targetLocale
-      } : s
-    );
-    onSuggestionsChange(updated);
-  }, handleGlossaryTargetChange = (id, newTarget) => {
-    const updated = suggestions.map(
-      (s) => s.id === id ? {
-        ...s,
-        targetValue: newTarget,
-        description: `${s.sourceValue || ""} \u2192 ${newTarget}`
-        // Preserve sourceLocale and targetLocale
-      } : s
-    );
-    onSuggestionsChange(updated);
-  }, handleRemove = (id) => {
-    const updated = suggestions.filter((s) => s.id !== id);
-    onSuggestionsChange(updated);
-  }, handleAddSuggestion = (type) => {
-    const newSuggestion = createNewSuggestion(type, sourceLanguage, targetLanguage);
-    onSuggestionsChange([...suggestions, newSuggestion]), setEditingId(newSuggestion.id);
+async function retryWithBackoff(operation, options = {}) {
+  const opts = {
+    ...DEFAULT_RETRY_OPTIONS,
+    ...options,
+    retryableErrors: options.retryableErrors || DEFAULT_RETRY_OPTIONS.retryableErrors
   };
-  return suggestions.length === 0 ? /* @__PURE__ */ jsxs(Stack, { space: 3, children: [
-    /* @__PURE__ */ jsx(
-      ProgressPanel,
-      {
-        status: "error",
-        tone: "transparent",
-        title: "No suggestions generated",
-        description: 'Try providing more specific feedback or enabling "Include Edits".',
-        icon: /* @__PURE__ */ jsx(EmptyIcon, { fontSize: 24 })
-      }
-    ),
-    /* @__PURE__ */ jsx(Flex, { justify: "flex-start", children: /* @__PURE__ */ jsx(
-      Button,
-      {
-        mode: "ghost",
-        tone: "primary",
-        icon: AddIcon,
-        text: "Add Suggestion",
-        fontSize: 1,
-        onClick: () => handleAddSuggestion("protectedPhrase")
-      }
-    ) })
-  ] }) : /* @__PURE__ */ jsxs(Stack, { space: 3, children: [
-    suggestions.map((suggestion) => {
-      const isEditing = editingId === suggestion.id, isGlossaryTerm = suggestion.type === "glossaryTerm", isPrompt = suggestion.type === "globalPrompt" || suggestion.type === "localePrompt", hasWarning = suggestion.warning && suggestion.validationStatus !== "valid", isInvalid = suggestion.validationStatus === "invalid";
-      return /* @__PURE__ */ jsx(
-        Card,
-        {
-          padding: 4,
-          border: !0,
-          tone: isInvalid ? "critical" : hasWarning ? "caution" : suggestion.approved ? "default" : "transparent",
-          style: { opacity: suggestion.approved ? 1 : 0.5 },
-          children: /* @__PURE__ */ jsx(Stack, { space: 3, children: /* @__PURE__ */ jsxs(Flex, { align: "flex-start", gap: 3, children: [
-            /* @__PURE__ */ jsx(Box, { paddingTop: 1, children: isInvalid ? /* @__PURE__ */ jsx(
-              Tooltip,
-              {
-                content: /* @__PURE__ */ jsx(Box, { padding: 2, style: { maxWidth: "280px" }, children: /* @__PURE__ */ jsx(Text, { size: 1, children: "This suggestion cannot be applied because it conflicts with existing settings. See the error message below for details." }) }),
-                placement: "top",
-                portal: !0,
-                children: /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsx(Checkbox, { checked: !1, disabled: !0, readOnly: !0 }) })
-              }
-            ) : /* @__PURE__ */ jsx(Checkbox, { checked: suggestion.approved, onChange: () => handleToggleApproval(suggestion.id) }) }),
-            /* @__PURE__ */ jsxs(Stack, { space: 3, flex: 1, children: [
-              /* @__PURE__ */ jsxs(Flex, { gap: 2, align: "center", wrap: "wrap", children: [
-                /* @__PURE__ */ jsx(Box, { flex: 1, style: { minWidth: "200px" }, children: /* @__PURE__ */ jsx(
-                  Select,
-                  {
-                    fontSize: 1,
-                    value: suggestion.type,
-                    onChange: (event) => handleTypeChange(suggestion.id, event.currentTarget.value),
-                    "aria-label": "Suggestion type",
-                    children: Object.entries(IMPROVEMENT_TYPE_LABELS).map(([value, label]) => /* @__PURE__ */ jsx("option", { value, children: label }, value))
-                  }
-                ) }),
-                /* @__PURE__ */ jsx(
-                  Button,
-                  {
-                    mode: "bleed",
-                    tone: "critical",
-                    icon: TrashIcon,
-                    fontSize: 1,
-                    padding: 2,
-                    onClick: () => handleRemove(suggestion.id),
-                    "aria-label": "Remove suggestion",
-                    title: "Remove suggestion"
-                  }
-                )
-              ] }),
-              isGlossaryTerm ? /* @__PURE__ */ jsxs(Stack, { space: 3, children: [
-                (suggestion.sourceLocale || suggestion.targetLocale) && /* @__PURE__ */ jsxs(Flex, { gap: 2, align: "center", children: [
-                  /* @__PURE__ */ jsx(Box, { flex: 1, children: /* @__PURE__ */ jsx(Text, { size: 0, muted: !0, weight: "medium", children: suggestion.sourceLocale ? `Source (${suggestion.sourceLocale})` : "Source" }) }),
-                  /* @__PURE__ */ jsx(Box, { style: { width: "20px" } }),
-                  /* @__PURE__ */ jsx(Box, { flex: 1, children: /* @__PURE__ */ jsx(Text, { size: 0, muted: !0, weight: "medium", children: suggestion.targetLocale ? `Target (${suggestion.targetLocale})` : "Target" }) })
-                ] }),
-                /* @__PURE__ */ jsxs(Flex, { gap: 2, align: "center", children: [
-                  /* @__PURE__ */ jsx(Box, { flex: 1, children: /* @__PURE__ */ jsx(
-                    TextInput,
-                    {
-                      fontSize: 1,
-                      placeholder: "Source term",
-                      value: suggestion.sourceValue || "",
-                      onChange: (event) => handleGlossarySourceChange(suggestion.id, event.currentTarget.value),
-                      "aria-label": `Source term in ${suggestion.sourceLocale || "source language"}`
-                    }
-                  ) }),
-                  /* @__PURE__ */ jsx(Text, { size: 1, muted: !0, "aria-hidden": "true", children: "\u2192" }),
-                  /* @__PURE__ */ jsx(Box, { flex: 1, children: /* @__PURE__ */ jsx(
-                    TextInput,
-                    {
-                      fontSize: 1,
-                      placeholder: "Target term",
-                      value: suggestion.targetValue || "",
-                      onChange: (event) => handleGlossaryTargetChange(suggestion.id, event.currentTarget.value),
-                      "aria-label": `Target term in ${suggestion.targetLocale || "target language"}`
-                    }
-                  ) })
-                ] })
-              ] }) : isPrompt ? /* @__PURE__ */ jsx(Stack, { space: 2, children: /* @__PURE__ */ jsx(
-                TextArea,
-                {
-                  fontSize: 1,
-                  rows: isEditing ? 6 : 3,
-                  value: suggestion.description,
-                  onChange: (event) => handleDescriptionChange(suggestion.id, event.currentTarget.value),
-                  onFocus: () => setEditingId(suggestion.id),
-                  onBlur: () => setEditingId(null),
-                  placeholder: "Enter prompt guidance...",
-                  "aria-label": `${IMPROVEMENT_TYPE_LABELS[suggestion.type]} content`
-                }
-              ) }) : /* @__PURE__ */ jsx(
-                TextInput,
-                {
-                  fontSize: 1,
-                  value: suggestion.description,
-                  onChange: (event) => handleDescriptionChange(suggestion.id, event.currentTarget.value),
-                  placeholder: "Enter protected phrase...",
-                  "aria-label": "Protected phrase"
-                }
-              ),
-              hasWarning && /* @__PURE__ */ jsx(Card, { padding: 3, tone: isInvalid ? "critical" : "caution", border: !0, radius: 2, children: /* @__PURE__ */ jsxs(Flex, { align: "flex-start", gap: 2, children: [
-                /* @__PURE__ */ jsx(Text, { size: 1, children: isInvalid ? /* @__PURE__ */ jsx(WarningOutlineIcon, {}) : /* @__PURE__ */ jsx(InfoOutlineIcon, {}) }),
-                /* @__PURE__ */ jsxs(Stack, { space: 2, flex: 1, children: [
-                  /* @__PURE__ */ jsx(Text, { size: 1, weight: "medium", children: isInvalid ? "Invalid Suggestion" : "Warning" }),
-                  /* @__PURE__ */ jsx(Text, { size: 1, muted: !0, children: suggestion.warning })
-                ] })
-              ] }) })
-            ] })
-          ] }) })
-        },
-        suggestion.id
-      );
-    }),
-    /* @__PURE__ */ jsx(Flex, { justify: "flex-start", children: /* @__PURE__ */ jsx(
-      Button,
-      {
-        mode: "ghost",
-        tone: "neutral",
-        icon: AddIcon,
-        text: "Add Suggestion",
-        fontSize: 1,
-        onClick: () => handleAddSuggestion("protectedPhrase")
-      }
-    ) })
-  ] });
-}, GiveFeedbackDialog = ({ setIsDialogOpen }) => {
-  const client = useClient({ apiVersion: "vX" }), { document, config, translationMetadata } = useTranslationContext(), { loading } = useTranslationMetadata({
-    documentId: document._id
-  }), [feedback, setFeedback] = useState(""), [shouldIncludeEdits, setShouldIncludeEdits] = useState(!1), [processingState, setProcessingState] = useState("idle"), [suggestions, setSuggestions] = useState([]), [changeSummary, setChangeSummary] = useState(""), [error, setError] = useState(""), [sourceLanguage, setSourceLanguage] = useState(""), [targetLanguage, setTargetLanguage] = useState(""), handleShouldIncludeEditsChange = () => {
-    setShouldIncludeEdits(!shouldIncludeEdits);
-  }, handleCancel = () => {
-    setIsDialogOpen(!1);
-  }, handleAnalyze = async () => {
-    if (!feedback && !shouldIncludeEdits) {
-      setError('Please provide feedback or enable "Include Edits"');
-      return;
-    }
-    if (!config) {
-      setError("Missing plugin configuration");
-      return;
-    }
-    setError(""), setProcessingState("analyzing"), setChangeSummary("");
-    try {
-      const translationHistory2 = translationMetadata?.translationHistory?.find(
-        (history) => history.language === document[config.languageFieldName]
-      );
-      if (!translationHistory2)
-        throw new Error(
-          "No translation history found for this document. Please ensure this document was translated using the AI Translation plugin."
-        );
-      const { sourceSnapshot, targetSnapshot, sourceLanguage: srcLang } = translationHistory2;
-      if (!sourceSnapshot || !targetSnapshot)
-        throw new Error("Translation snapshots are missing from history.");
-      const srcLanguage = srcLang || "en-us", tgtLanguage = document[config.languageFieldName];
-      setSourceLanguage(srcLanguage), setTargetLanguage(tgtLanguage);
-      const generatedSuggestions = await analyzeFeedback({
-        client,
-        schemaId: config.schemaId,
-        sourceLanguage: srcLanguage,
-        targetLanguage: tgtLanguage,
-        userFeedback: feedback || void 0,
-        shouldIncludeEdits,
-        sourceSnapshot,
-        targetSnapshot,
-        currentDocument: shouldIncludeEdits ? document : void 0,
-        onProgress: ({ stage, message }) => {
-          setProcessingState(stage), setChangeSummary(message);
-        }
-      });
-      setSuggestions(generatedSuggestions), setProcessingState("reviewing");
-    } catch (err) {
-      console.error("Error analyzing feedback:", err), setError(err instanceof Error ? err.message : "An unexpected error occurred"), setProcessingState("error");
-    }
-  }, handleApplySuggestions = async () => {
-    if (!config) {
-      setError("Missing plugin configuration");
-      return;
-    }
-    if (suggestions.filter((s) => s.approved).length === 0) {
-      setError("Please approve at least one suggestion to apply");
-      return;
-    }
-    setError(""), setProcessingState("applying");
+  let lastError;
+  const maxAttempts = opts.maxAttempts + 1;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++)
     try {
-      const translationHistory2 = translationMetadata?.translationHistory?.find(
-        (history) => history.language === document[config.languageFieldName]
-      );
-      if (!translationHistory2)
-        throw new Error("Translation history not found");
-      await applySuggestions({
-        client,
-        schemaId: config.schemaId,
-        sourceLanguage: translationHistory2.sourceLanguage || "en-us",
-        targetLanguage: translationHistory2.language,
-        suggestions,
-        onProgress: ({ stage, message }) => {
-          setProcessingState(stage), setChangeSummary(message);
-        }
-      }), setProcessingState("completed");
-    } catch (err) {
-      console.error("Error applying suggestions:", err), setError(err instanceof Error ? err.message : "An unexpected error occurred"), setProcessingState("error");
-    }
-  };
-  if (loading)
-    return /* @__PURE__ */ jsx(ProgressPanel, { title: "Loading translation metadata" });
-  if (processingState === "analyzing")
-    return /* @__PURE__ */ jsx(ProgressPanel, { title: "Analyzing feedback with AI...", description: changeSummary });
-  if (processingState === "reviewing")
-    return /* @__PURE__ */ jsxs(Stack, { space: 4, children: [
-      /* @__PURE__ */ jsxs(Stack, { space: 4, children: [
-        /* @__PURE__ */ jsx(Heading, { children: "Review Suggestions" }),
-        /* @__PURE__ */ jsx(Text, { muted: !0, children: "The AI has analyzed your feedback and generated the following suggestions. Review and edit them before applying." })
-      ] }),
-      /* @__PURE__ */ jsx(
-        SuggestionReviewList,
-        {
-          suggestions,
-          onSuggestionsChange: setSuggestions,
-          sourceLanguage,
-          targetLanguage
-        }
-      ),
-      error && /* @__PURE__ */ jsx(Card, { padding: 3, tone: "critical", border: !0, children: /* @__PURE__ */ jsx(Text, { size: 1, children: error }) }),
-      /* @__PURE__ */ jsxs(Flex, { justify: "space-between", gap: 2, paddingTop: 2, children: [
-        /* @__PURE__ */ jsx(Flex, { gap: 2, children: /* @__PURE__ */ jsx(
-          Button,
-          {
-            type: "button",
-            mode: "bleed",
-            tone: "neutral",
-            onClick: () => setProcessingState("idle"),
-            icon: /* @__PURE__ */ jsx(ArrowLeftIcon, {}),
-            text: "Back"
-          }
-        ) }),
-        /* @__PURE__ */ jsxs(
-          Button,
-          {
-            type: "button",
-            mode: "ghost",
-            tone: "positive",
-            size: 1,
-            onClick: handleApplySuggestions,
-            disabled: suggestions.filter((s) => s.approved).length === 0,
-            children: [
-              "Apply ",
-              suggestions.filter((s) => s.approved).length,
-              " Suggestion",
-              suggestions.filter((s) => s.approved).length !== 1 ? "s" : ""
-            ]
-          }
-        )
-      ] })
-    ] });
-  if (processingState === "applying")
-    return /* @__PURE__ */ jsx(ProgressPanel, { title: "Updating translation settings...", description: changeSummary, icon: /* @__PURE__ */ jsx(EditIcon, {}) });
-  if (processingState === "completed") {
-    const appliedCount = suggestions.filter((s) => s.approved).length, description = `${appliedCount} suggestion${appliedCount !== 1 ? "s" : ""} applied. Translation prompts and glossary havebeen updated based on your feedback.`;
-    return /* @__PURE__ */ jsxs(Box, { padding: 4, children: [
-      /* @__PURE__ */ jsx(ProgressPanel, { title: "Translation settings updated", description, status: "completed" }),
-      /* @__PURE__ */ jsx(Flex, { justify: "flex-end", paddingTop: 3, children: /* @__PURE__ */ jsx(Button, { type: "button", mode: "ghost", tone: "primary", size: 1, onClick: handleCancel, children: "Close" }) })
-    ] });
-  }
-  return processingState === "error" ? /* @__PURE__ */ jsx(Box, { padding: 4, children: /* @__PURE__ */ jsxs(Stack, { space: 4, children: [
-    /* @__PURE__ */ jsx(ProgressPanel, { status: "error", title: "Error processing feedback", description: error, tone: "critical" }),
-    /* @__PURE__ */ jsxs(Flex, { justify: "flex-end", gap: 2, children: [
-      /* @__PURE__ */ jsx(Button, { type: "button", mode: "ghost", onClick: handleCancel, children: "Close" }),
-      /* @__PURE__ */ jsx(Button, { type: "reset", mode: "ghost", tone: "primary", onClick: () => setProcessingState("idle"), children: "Reset" })
-    ] })
-  ] }) }) : /* @__PURE__ */ jsxs(Stack, { space: 4, children: [
-    /* @__PURE__ */ jsx(Card, { tone: "transparent", padding: 4, children: /* @__PURE__ */ jsxs(Stack, { space: 4, children: [
-      /* @__PURE__ */ jsx(Stack, { space: 2, children: /* @__PURE__ */ jsxs(Stack, { space: 4, children: [
-        /* @__PURE__ */ jsxs(Inline, { space: 2, children: [
-          /* @__PURE__ */ jsx(Text, { size: 2, muted: !0, children: "Enter your feedback for the translation AI agent." }),
-          /* @__PURE__ */ jsx(
-            Tooltip,
-            {
-              portal: !0,
-              content: /* @__PURE__ */ jsx(Box, { padding: 2, style: { maxWidth: "280px" }, children: /* @__PURE__ */ jsx(Text, { size: 1, children: "The AI agent will use your feedback to improve translation prompts, update protected phrases, and modify the glossary. Be specific about what should be changed." }) }),
-              children: /* @__PURE__ */ jsx(Text, { size: 1, children: /* @__PURE__ */ jsx(InfoOutlineIcon, {}) })
-            }
-          )
-        ] }),
-        /* @__PURE__ */ jsx(
-          TextArea,
+      const result = await operation();
+      return attempt > 1 && opts.logRetries && devLog.info(`Operation succeeded after ${attempt} attempts`, {
+        ...opts.context,
+        attempt,
+        totalAttempts: attempt
+      }), result;
+    } catch (error) {
+      if (lastError = error, !opts.retryableErrors(error))
+        throw opts.logRetries && devLog.warn("Error is not retryable, aborting retries", {
+          ...opts.context,
+          attempt,
+          error: error instanceof Error ? error.message : String(error)
+        }), error;
+      if (attempt >= maxAttempts)
+        throw opts.logRetries && devLog.error(
+          `Operation failed after ${maxAttempts} attempts`,
+          error instanceof Error ? error : new Error(String(error)),
           {
-            rows: 8,
-            fontSize: 2,
-            onChange: (event) => setFeedback(event.currentTarget.value),
-            padding: 3,
-            placeholder: 'Example: "Braze" is a branded term and should not be translated.',
-            value: feedback
+            ...opts.context,
+            totalAttempts: maxAttempts
           }
-        )
-      ] }) }),
-      /* @__PURE__ */ jsx(Stack, { space: 2, children: /* @__PURE__ */ jsx(Stack, { space: 3, children: /* @__PURE__ */ jsx(
-        Button,
-        {
-          type: "button",
-          mode: shouldIncludeEdits ? "ghost" : "bleed",
-          size: 2,
-          onClick: handleShouldIncludeEditsChange,
-          tone: shouldIncludeEdits ? "primary" : "default",
-          children: /* @__PURE__ */ jsxs(Flex, { align: "flex-start", gap: 3, children: [
-            /* @__PURE__ */ jsx(Box, { paddingTop: 1, children: /* @__PURE__ */ jsx(Checkbox, { checked: shouldIncludeEdits, readOnly: !0, style: { pointerEvents: "none" } }) }),
-            /* @__PURE__ */ jsxs(Stack, { space: 2, flex: 1, children: [
-              /* @__PURE__ */ jsx(Text, { size: 2, weight: "medium", children: "Include Edits in Feedback" }),
-              /* @__PURE__ */ jsx(Text, { size: 1, muted: !0, style: { textAlign: "left" }, children: "The AI will analyze edits you made to the translation." })
-            ] })
-          ] })
-        }
-      ) }) })
-    ] }) }),
-    /* @__PURE__ */ jsxs(Flex, { justify: "flex-end", gap: 2, paddingTop: 2, children: [
-      /* @__PURE__ */ jsx(Button, { type: "button", mode: "ghost", size: 1, onClick: handleCancel, children: "Cancel" }),
-      /* @__PURE__ */ jsx(
-        Button,
-        {
-          type: "submit",
-          mode: "ghost",
-          tone: "positive",
-          size: 1,
-          onClick: handleAnalyze,
-          disabled: !feedback.trim() && !shouldIncludeEdits,
-          children: "Analyze Feedback"
-        }
-      )
-    ] })
-  ] });
-}, getGiveTranslationFeedbackAction = (config) => ({ draft, published }) => {
-  const document = draft ?? published, [isDialogOpen, setIsDialogOpen] = useState(!1);
-  return devLog.debug("ImproveTranslationPromptsAction initialized", {
-    documentId: document?._id,
-    documentType: document?._type
-  }), !document || !config.translatableSchemaTypes?.includes(document._type) ? (devLog.warn("Document not in translatable schema types", {
-    documentType: document?._type,
-    translatableTypes: config.translatableSchemaTypes
-  }), null) : config ? {
-    label: "Give Translation Feedback",
-    icon: TranslateIcon,
-    onHandle: () => {
-      devLog.info("Give Translation Feedback dialog opened", {
-        documentId: document._id,
-        documentType: document._type,
-        component: "GiveTranslationFeedbackAction"
-      }), setIsDialogOpen(!0);
-    },
-    dialog: isDialogOpen && {
-      type: "dialog",
-      onClose: () => setIsDialogOpen(!1),
-      header: "Give Translation Feedback",
-      content: /* @__PURE__ */ jsx(TranslationContextProvider, { document, config, children: /* @__PURE__ */ jsx(GiveFeedbackDialog, { setIsDialogOpen }) })
+        ), error;
+      const delay = calculateDelay(attempt - 1, opts);
+      opts.logRetries && devLog.warn(`Operation failed, retrying in ${delay}ms (attempt ${attempt}/${maxAttempts})`, {
+        ...opts.context,
+        attempt,
+        totalAttempts: maxAttempts,
+        delayMs: delay,
+        error: error instanceof Error ? error.message : String(error)
+      }), delay > 0 && await sleep(delay);
     }
-  } : (devLog.error("Missing config in TranslateAction"), null);
-};
+  throw lastError;
+}
 class Semaphore {
   permits;
   queue = [];
@@ -1584,13 +904,27 @@ const fetchTranslationPrompts = async ({
       }
     }), hasChanges = !0);
   }
-  hasChanges && (await patch.commit(), devLog.info("Updated references in batch", {
+  hasChanges && (await retryWithBackoff(
+    async () => {
+      await patch.commit();
+    },
+    {
+      maxAttempts: 2,
+      initialDelayMs: 0,
+      retryableErrors: isNetworkError,
+      context: {
+        operation: "localizeReferences",
+        documentId,
+        referenceCount: refs.length
+      }
+    }
+  ), devLog.info("Updated references in batch", {
     documentId,
     count: refs.length,
     translatedCount: translationMap.size,
     component: "updateReferences"
   }));
-}, setupTranslationJobStatuses = (dispatch, sourceDocuments, targetLanguages) => {
+}, setupTranslationJobStatuses = (dispatch, sourceDocuments, targetLanguages, mainSourceDocumentId) => {
   for (const sourceDocument of sourceDocuments)
     for (const lang of targetLanguages) {
       const payload = {
@@ -1603,146 +937,8 @@ const fetchTranslationPrompts = async ({
       dispatch({
         type: "SET_TRANSLATION_JOB_STATUS",
         payload
-      });
-    }
-}, DEFAULT_OPTIONS = {
-  maxRetries: 3,
-  initialDelayMs: 1e3,
-  maxDelayMs: 3e4,
-  backoffMultiplier: 2,
-  jitter: !0
-};
-function isRetryableError(error) {
-  if (error instanceof Error) {
-    const message = error.message.toLowerCase(), name = error.name.toLowerCase(), nonRetryablePatterns = [
-      "schema not found",
-      "invalid schema",
-      "not found",
-      "unauthorized",
-      "forbidden",
-      "invalid api key",
-      "missing api key",
-      "validation failed",
-      "invalid document",
-      "source language not found",
-      "invalid configuration",
-      "type mismatch"
-    ];
-    for (const pattern of nonRetryablePatterns)
-      if (message.includes(pattern) || name.includes(pattern))
-        return !1;
-    const retryablePatterns = [
-      "failed to fetch",
-      "network",
-      "timeout",
-      "econnreset",
-      "econnrefused",
-      "enotfound",
-      "socket",
-      "rate limit",
-      "too many requests",
-      "429",
-      "500",
-      "502",
-      "503",
-      "504",
-      "internal server error",
-      "bad gateway",
-      "service unavailable",
-      "gateway timeout",
-      "temporarily unavailable",
-      "try again"
-    ];
-    for (const pattern of retryablePatterns)
-      if (message.includes(pattern) || name.includes(pattern))
-        return !0;
-  }
-  if (typeof error == "object" && error !== null) {
-    const statusCode = error.statusCode || error.status;
-    if (statusCode) {
-      if (statusCode === 429 || statusCode >= 500 && statusCode < 600)
-        return !0;
-      if (statusCode >= 400 && statusCode < 500)
-        return !1;
-    }
-  }
-  return !0;
-}
-function calculateBackoffDelay(attempt, options) {
-  const { initialDelayMs, maxDelayMs, backoffMultiplier, jitter } = options;
-  let delay = initialDelayMs * backoffMultiplier ** attempt;
-  if (delay = Math.min(delay, maxDelayMs), jitter) {
-    const jitterFactor = 0.75 + Math.random() * 0.5;
-    delay = Math.round(delay * jitterFactor);
-  }
-  return delay;
-}
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-async function withRetry(fn, options = {}) {
-  const opts = { ...DEFAULT_OPTIONS, ...options }, shouldRetry = opts.isRetryable ?? isRetryableError;
-  let lastError, attempts = 0;
-  for (let attempt = 0; attempt <= opts.maxRetries; attempt++) {
-    attempts = attempt + 1;
-    try {
-      return { success: !0, result: await fn(), attempts };
-    } catch (error) {
-      if (lastError = error, attempt >= opts.maxRetries) {
-        devLog.debug("Max retries exhausted", { attempt: attempts, error });
-        break;
-      }
-      if (!shouldRetry(error)) {
-        devLog.debug("Error is not retryable", { attempt: attempts, error });
-        break;
-      }
-      const delay = calculateBackoffDelay(attempt, opts);
-      devLog.debug("Scheduling retry", {
-        attempt: attempts,
-        nextAttempt: attempt + 2,
-        delayMs: delay,
-        error: error instanceof Error ? error.message : String(error)
-      }), opts.onRetry && opts.onRetry(attempt + 1, error, delay), await sleep(delay);
+      }), mainSourceDocumentId && updateActiveTranslationJob(mainSourceDocumentId, payload);
     }
-  }
-  return { success: !1, error: lastError, attempts };
-}
-const getExistingTranslationId = (translationMetadata, targetLanguage) => translationMetadata?.translations?.length && translationMetadata.translations.find(
-  (translation) => translation._key === targetLanguage
-)?.value._ref || null, getTranslationMetadata = async ({
-  client,
-  sourceDocument,
-  sourceLanguage
-}) => {
-  try {
-    return await client.fetch(
-      "*[_type == $tmType && references($sourceDocumentId)][0]",
-      {
-        tmType: TRANSLATION_METADATA_TYPE,
-        sourceDocumentId: undraftId(sourceDocument._id)
-      }
-    ) || await client.create({
-      _type: TRANSLATION_METADATA_TYPE,
-      translations: [
-        {
-          _key: sourceLanguage,
-          _type: "internationalizedArrayReferenceValue",
-          value: {
-            _type: "reference",
-            _ref: undraftId(sourceDocument._id),
-            _weak: !0,
-            _strengthenOnPublish: {
-              _type: sourceDocument._type,
-              _weak: !1
-            }
-          }
-        }
-      ],
-      translationHistory: []
-    });
-  } catch (error) {
-    throw console.error(sourceDocument._id, "Error creating translation metadata:", error), error;
-  }
 }, updateTranslationMetadata = async ({
   client,
   targetLanguage,
@@ -1776,11 +972,71 @@ const getExistingTranslationId = (translationMetadata, targetLanguage) => transl
       targetRev: newDocument._rev,
       targetSnapshot: JSON.stringify(newDocument)
     }, translationPatch = client.patch(translationMetadata._id).setIfMissing({ translations: [] });
-    isNewTranslation ? await translationPatch.insert("after", "translations[-1]", [refToNewTranslation]).commit() : await translationPatch.insert("replace", `translations[_key == "${targetLanguage}"]`, [refToNewTranslation]).commit();
+    isNewTranslation ? await retryWithBackoff(
+      async () => {
+        await translationPatch.insert("after", "translations[-1]", [refToNewTranslation]).commit();
+      },
+      {
+        maxAttempts: 2,
+        initialDelayMs: 0,
+        retryableErrors: isNetworkError,
+        context: {
+          operation: "updateTranslationMetadata.translations",
+          sourceDocumentId: sourceDocument._id,
+          targetLanguage,
+          isNewTranslation: !0
+        }
+      }
+    ) : await retryWithBackoff(
+      async () => {
+        await translationPatch.insert("replace", `translations[_key == "${targetLanguage}"]`, [refToNewTranslation]).commit();
+      },
+      {
+        maxAttempts: 2,
+        initialDelayMs: 0,
+        retryableErrors: isNetworkError,
+        context: {
+          operation: "updateTranslationMetadata.translations",
+          sourceDocumentId: sourceDocument._id,
+          targetLanguage,
+          isNewTranslation: !1
+        }
+      }
+    );
     const historyPatch = client.patch(translationMetadata._id).setIfMissing({ translationHistory: [] });
     translationMetadata.translationHistory?.some(
       (history) => history.language === targetLanguage
-    ) ? await historyPatch.insert("replace", `translationHistory[_key == "${targetLanguage}"]`, [newTranslationHistory]).commit() : await historyPatch.insert("after", "translationHistory[-1]", [newTranslationHistory]).commit();
+    ) ? await retryWithBackoff(
+      async () => {
+        await historyPatch.insert("replace", `translationHistory[_key == "${targetLanguage}"]`, [newTranslationHistory]).commit();
+      },
+      {
+        maxAttempts: 2,
+        initialDelayMs: 0,
+        retryableErrors: isNetworkError,
+        context: {
+          operation: "updateTranslationMetadata.history",
+          sourceDocumentId: sourceDocument._id,
+          targetLanguage,
+          isNewHistory: !1
+        }
+      }
+    ) : await retryWithBackoff(
+      async () => {
+        await historyPatch.insert("after", "translationHistory[-1]", [newTranslationHistory]).commit();
+      },
+      {
+        maxAttempts: 2,
+        initialDelayMs: 0,
+        retryableErrors: isNetworkError,
+        context: {
+          operation: "updateTranslationMetadata.history",
+          sourceDocumentId: sourceDocument._id,
+          targetLanguage,
+          isNewHistory: !0
+        }
+      }
+    );
   } catch (error) {
     throw devLog.error("Error updating translation metadata", error instanceof Error ? error : new Error(String(error)), {
       sourceDocumentId: sourceDocument._id,
@@ -1789,15 +1045,16 @@ const getExistingTranslationId = (translationMetadata, targetLanguage) => transl
       component: "updateTranslationMetadata"
     }), error;
   }
-}, setJobStatus = (dispatch, _id, language, status, payload) => {
+}, setJobStatus = (dispatch, _id, language, status, payload, sourceDocumentId) => {
+  const job = defaults(payload, {
+    _id,
+    language,
+    status
+  });
   dispatch({
     type: "SET_TRANSLATION_JOB_STATUS",
-    payload: defaults(payload, {
-      _id,
-      language,
-      status
-    })
-  });
+    payload: job
+  }), sourceDocumentId && updateActiveTranslationJob(sourceDocumentId, job);
 };
 function shouldExcludeField(fieldPath, excludeFields) {
   for (const pattern of excludeFields) {
@@ -2030,7 +1287,9 @@ function restoreTransforms({
         schemaType,
         document: translatedDocument
       };
-      devLog.debug("Restoring transform for field", { fieldPath, schemaType }), restoredObj[key] = transform.fromTranslatable(value, originalValue, context);
+      devLog.debug("Restoring transform for field", { fieldPath, schemaType });
+      const restoredValue = transform.fromTranslatable(value, originalValue, context);
+      restoredObj[key] = restoredValue;
     } else
       restoredObj[key] = restoreTransforms({
         translatedDocument: value,
@@ -2123,14 +1382,29 @@ const globalTransformRegistry = new TransformRegistry(), callGPT5 = async (apiKe
   }), devLog.debug("OpenAI GPT-5 Full Prompt", {
     messages: request.messages
   });
-  const response = await fetch("https://api.openai.com/v1/responses", {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${apiKey}`
+  const response = await retryWithBackoff(
+    async () => {
+      const fetchResponse = await fetch("https://api.openai.com/v1/responses", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${apiKey}`
+        },
+        body: JSON.stringify(requestBody)
+      });
+      if (!fetchResponse.ok) {
+        const errorMessage = `GPT-5 API error: ${(await fetchResponse.json()).error?.message || "Unknown error"}`, errorObj = new Error(errorMessage);
+        throw errorObj.response = { status: fetchResponse.status }, errorObj;
+      }
+      return fetchResponse;
     },
-    body: JSON.stringify(requestBody)
-  });
+    {
+      maxAttempts: 2,
+      initialDelayMs: 0,
+      retryableErrors: isNetworkError,
+      context: { model: requestBody.model, endpoint: "responses" }
+    }
+  );
   if (!response.ok) {
     const error = await response.json();
     throw new Error(`GPT-5 API error: ${error.error?.message || "Unknown error"}`);
@@ -2169,14 +1443,29 @@ const globalTransformRegistry = new TransformRegistry(), callGPT5 = async (apiKe
   }), devLog.debug("OpenAI Chat Completions Full Prompt", {
     messages: request.messages
   });
-  const response = await fetch("https://api.openai.com/v1/chat/completions", {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${apiKey}`
+  const response = await retryWithBackoff(
+    async () => {
+      const fetchResponse = await fetch("https://api.openai.com/v1/chat/completions", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${apiKey}`
+        },
+        body: JSON.stringify(requestBody)
+      });
+      if (!fetchResponse.ok) {
+        const errorMessage = `OpenAI API error: ${(await fetchResponse.json()).error?.message || "Unknown error"}`, errorObj = new Error(errorMessage);
+        throw errorObj.response = { status: fetchResponse.status }, errorObj;
+      }
+      return fetchResponse;
     },
-    body: JSON.stringify(requestBody)
-  });
+    {
+      maxAttempts: 2,
+      initialDelayMs: 0,
+      retryableErrors: isNetworkError,
+      context: { model, endpoint: "chat/completions" }
+    }
+  );
   if (!response.ok) {
     const error = await response.json();
     throw new Error(`OpenAI API error: ${error.error?.message || "Unknown error"}`);
@@ -2238,16 +1527,63 @@ const globalTransformRegistry = new TransformRegistry(), callGPT5 = async (apiKe
   }, modelPricing = pricing[model] || pricing["gpt-5"], cachedInputRate = model === "gpt-5.1" ? 0.125 / 1e6 : modelPricing.input;
   return Math.max(0, tokens.prompt - tokens.cached) * modelPricing.input + tokens.cached * cachedInputRate + tokens.completion * modelPricing.output + tokens.reasoning * modelPricing.reasoning;
 }, deserializeDocument = (originalDoc, reviewedText) => {
-  const parsed = parseReviewFormat(reviewedText), result = cloneDeep(originalDoc);
+  devLog.debug("Raw GPT-5 response received", {
+    length: reviewedText.length,
+    preview: reviewedText.substring(0, 1e3),
+    hasReasoning: reviewedText.includes("<reasoning>"),
+    hasCodeBlocks: reviewedText.includes("```")
+  });
+  const cleanedText = preprocessResponse(reviewedText);
+  cleanedText.length !== reviewedText.length && devLog.debug("Response after preprocessing", {
+    originalLength: reviewedText.length,
+    cleanedLength: cleanedText.length,
+    preview: cleanedText.substring(0, 500)
+  });
+  const parsed = parseReviewFormat(cleanedText, originalDoc);
+  devLog.debug("Parsed response structure", {
+    rootNodeCount: parsed.length,
+    rootNodeNames: parsed.map((n) => n.type === "field" && n.name ? n.name : "unknown")
+  });
+  const result = cloneDeep(originalDoc);
   return applyTextChanges(result, parsed), result;
-}, parseReviewFormat = (text) => {
+}, preprocessResponse = (text) => {
+  const originalLength = text.length;
+  let cleaned = text;
+  const beforeReasoning = cleaned.length;
+  cleaned = cleaned.replace(/<reasoning>[\s\S]*?<\/reasoning>/gi, "");
+  const reasoningRemoved = beforeReasoning !== cleaned.length, beforeCodeBlocks = cleaned.length;
+  cleaned = cleaned.replace(/^```[a-z]*\s*$/gim, ""), cleaned = cleaned.replace(/^```\s*$/gim, "");
+  const codeBlocksRemoved = beforeCodeBlocks !== cleaned.length, finalLength = cleaned.trim().length;
+  return (reasoningRemoved || codeBlocksRemoved) && devLog.debug("Preprocessed GPT-5 response", {
+    originalLength,
+    finalLength,
+    reasoningRemoved,
+    codeBlocksRemoved,
+    preview: cleaned.trim().substring(0, 200)
+  }), cleaned.trim();
+}, parseReviewFormat = (text, originalDoc) => {
   const root = [], stack = [], lines = text.split(`
 `);
+  devLog.debug("Parsing response text", {
+    lineCount: lines.length,
+    firstLines: lines.slice(0, 10).map((l, idx) => ({ line: idx, content: l.substring(0, 100) })),
+    hasFieldTags: text.includes("<field"),
+    hasBlockTags: text.includes("<block"),
+    hasSpanTags: text.includes("<span"),
+    textLength: text.length,
+    textPreview: text.substring(0, 500)
+  });
+  let processedLineCount = 0, skippedEmptyLineCount = 0, matchedPatternCount = 0;
   for (let i = 0; i < lines.length; i++) {
     const trimmed = lines[i].trim();
-    if (!trimmed) continue;
+    if (!trimmed) {
+      skippedEmptyLineCount++;
+      continue;
+    }
+    processedLineCount++;
     const compactStringMatch = trimmed.match(/^(\w+):\s*(.*)$/);
     if (compactStringMatch && !trimmed.includes("<")) {
+      matchedPatternCount++;
       const [, fieldName, text2] = compactStringMatch, node = {
         type: "field",
         name: fieldName,
@@ -2264,6 +1600,7 @@ const globalTransformRegistry = new TransformRegistry(), callGPT5 = async (apiKe
     }
     const compactStartMatch = trimmed.match(/^---\s+(\w+)\s+---$/);
     if (compactStartMatch) {
+      matchedPatternCount++;
       const fieldName = compactStartMatch[1], contentLines = [];
       for (i++; i < lines.length; ) {
         const currentLine = lines[i];
@@ -2273,8 +1610,16 @@ const globalTransformRegistry = new TransformRegistry(), callGPT5 = async (apiKe
       }
       const content = contentLines.join(`
 `);
-      let contentType = "translatable.vtt.captions";
-      (content.includes("<block") || content.includes("<span")) && (contentType = "translatable.richtext");
+      let contentType;
+      try {
+        const fieldValue = get(originalDoc, [fieldName]);
+        if (fieldValue && typeof fieldValue == "object" && fieldValue !== null) {
+          const fieldType = fieldValue._type;
+          typeof fieldType == "string" && fieldType.startsWith("translatable.") && (contentType = fieldType);
+        }
+      } catch {
+      }
+      contentType || (content.includes("<block") || content.includes("<span") ? contentType = "translatable.richtext" : contentType = "translatable.vtt.captions");
       const node = {
         type: "field",
         name: fieldName,
@@ -2291,6 +1636,12 @@ const globalTransformRegistry = new TransformRegistry(), callGPT5 = async (apiKe
     }
     const openMatch = trimmed.match(/^<(field|block|span)([^>]*)>(.*)$/);
     if (openMatch) {
+      matchedPatternCount++, devLog.debug("Matched opening tag", {
+        line: i,
+        tagName: openMatch[1],
+        attributes: openMatch[2],
+        contentPreview: openMatch[3]?.substring(0, 50)
+      });
       const [, tagName, attrsStr, content] = openMatch, attributes = parseAttributes(attrsStr), node = {
         type: tagName,
         name: attributes.name,
@@ -2311,7 +1662,7 @@ const globalTransformRegistry = new TransformRegistry(), callGPT5 = async (apiKe
           parent && parent.children.push(node);
         } else
           root.push(node);
-      else if (attributes.type === "translatable.vtt.captions" || attributes.type === "translatable.richtext") {
+      else if (attributes.type && typeof attributes.type == "string" && attributes.type.startsWith("translatable.")) {
         const contentLines = [];
         for (i++; i < lines.length; ) {
           const currentLine = lines[i];
@@ -2331,11 +1682,26 @@ const globalTransformRegistry = new TransformRegistry(), callGPT5 = async (apiKe
           parent && parent.children.push(node);
         } else
           root.push(node);
-      else
+      else if (attributes.type === "string" && !content) {
+        const contentLines = [];
+        for (i++; i < lines.length; ) {
+          const currentLine = lines[i];
+          if (currentLine.trim() === "</field>")
+            break;
+          contentLines.push(currentLine), i++;
+        }
+        if (node.text = contentLines.join(`
+`).trim(), stack.length > 0) {
+          const parent = stack[stack.length - 1];
+          parent && parent.children.push(node);
+        } else
+          root.push(node);
+      } else
         stack.push(node);
       continue;
     }
     if (trimmed.match(/^<\/(field|block|span)>$/) && stack.length > 0) {
+      matchedPatternCount++;
       const node = stack.pop();
       if (node)
         if (stack.length > 0) {
@@ -2343,9 +1709,24 @@ const globalTransformRegistry = new TransformRegistry(), callGPT5 = async (apiKe
           parent && parent.children.push(node);
         } else
           root.push(node);
+      continue;
     }
+    processedLineCount <= 20 && devLog.debug("Line did not match any pattern", {
+      line: i,
+      trimmed,
+      startsWithLessThan: trimmed.startsWith("<"),
+      startsWithField: trimmed.startsWith("<field"),
+      startsWithBacktick: trimmed.startsWith("`")
+    });
   }
-  return root;
+  return devLog.debug("Parse complete", {
+    totalLines: lines.length,
+    processedLines: processedLineCount,
+    skippedEmptyLines: skippedEmptyLineCount,
+    rootNodeCount: root.length,
+    stackLength: stack.length,
+    matchedPatterns: matchedPatternCount
+  }), root;
 }, parseAttributes = (attrStr) => {
   const attrs = {}, attrRegex = /(\w+)="([^"]*)"/g;
   let match = attrRegex.exec(attrStr);
@@ -2353,20 +1734,29 @@ const globalTransformRegistry = new TransformRegistry(), callGPT5 = async (apiKe
     attrs[match[1]] = unescapeXml(match[2]), match = attrRegex.exec(attrStr);
   return attrs;
 }, unescapeXml = (str) => str.replace(/&apos;/g, "'").replace(/&quot;/g, '"').replace(/&gt;/g, ">").replace(/&lt;/g, "<").replace(/&amp;/g, "&"), applyTextChanges = (doc, parsedNodes) => {
+  devLog.debug("Applying text changes from parsed nodes", {
+    nodeCount: parsedNodes.length,
+    nodeNames: parsedNodes.map((n) => n.type === "field" && n.name ? n.name : "unknown")
+  });
   for (const node of parsedNodes)
     if (node.type === "field" && node.name) {
-      const path = [node.name];
+      const path = [node.name], beforeValue = get(doc, path);
       applyFieldChanges(doc, path, node);
+      const afterValue = get(doc, path);
+      beforeValue !== afterValue && devLog.debug("Field updated during deserialization", {
+        path: path.join("."),
+        before: typeof beforeValue == "string" ? beforeValue.substring(0, 50) : beforeValue,
+        after: typeof afterValue == "string" ? afterValue.substring(0, 50) : afterValue
+      });
     }
 }, 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 nodeType = node.attributes.type;
+  if (typeof nodeType == "string" && nodeType.startsWith("translatable.")) {
     const fieldValue = get(doc, path);
-    fieldValue && typeof fieldValue == "object" && fieldValue._type === "translatable.richtext" && node.text && set(doc, [...path, "translationText"], node.text);
+    if (fieldValue && typeof fieldValue == "object" && fieldValue !== null) {
+      const fieldType = fieldValue._type;
+      typeof fieldType == "string" && fieldType === nodeType && node.text && set(doc, [...path, "translationText"], node.text);
+    }
     return;
   }
   if (node.attributes.type === "array") {
@@ -2454,12 +1844,9 @@ const globalTransformRegistry = new TransformRegistry(), callGPT5 = async (apiKe
       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} ---`);
+      const valueObj = value, valueType = valueObj._type, translationText = valueObj.translationText;
+      if (typeof valueType == "string" && valueType.startsWith("translatable.") && typeof translationText == "string") {
+        lines.push(`${indentStr}--- ${fieldName} ---`), lines.push(translationText), lines.push(`${indentStr}--- /${fieldName} ---`);
         return;
       }
       lines.push(`${indentStr}<field name="${fieldName}" type="object">`);
@@ -2595,7 +1982,9 @@ const globalTransformRegistry = new TransformRegistry(), callGPT5 = async (apiKe
   languageFieldName,
   translationPrompts,
   targetLanguage,
-  openaiConfig
+  openaiConfig,
+  previousError,
+  errorContext
 }) => {
   const sourceLanguage = sourceDocument[languageFieldName], logContext = {
     sourceId: sourceDocument._id,
@@ -2613,7 +2002,8 @@ const globalTransformRegistry = new TransformRegistry(), callGPT5 = async (apiKe
       sourceText,
       sourceLanguage,
       targetLanguage,
-      translationPrompts
+      translationPrompts,
+      errorContext
     }), response = await callGPT5(openaiConfig.apiKey, {
       messages: [
         {
@@ -2671,14 +2061,21 @@ const globalTransformRegistry = new TransformRegistry(), callGPT5 = async (apiKe
   sourceText,
   sourceLanguage,
   targetLanguage,
-  translationPrompts
+  translationPrompts,
+  errorContext
 }) => {
   const { globalPrompt, localeInstructions, protectedPhrases } = translationPrompts, localePrompt = localeInstructions[targetLanguage]?.prompt, glossaryTerms = localeInstructions[targetLanguage]?.glossaryTerms;
   return `# TRANSLATION TASK
 
 Translate this ${sourceLanguage} document into ${targetLanguage}.
 
-## Guidelines
+${errorContext ? `## \u26A0\uFE0F IMPORTANT: Previous Attempt Error
+
+${errorContext}
+
+Please carefully review the error above and ensure your translation fixes the issue.
+
+` : ""}## Guidelines
 
 ${globalPrompt ? `### General Guidelines
 ${globalPrompt}
@@ -2852,21 +2249,34 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
     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
+  return await retryWithBackoff(
+    async () => 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
+      }
+    }),
+    {
+      maxAttempts: 2,
+      initialDelayMs: 0,
+      retryableErrors: isNetworkError,
+      context: {
+        operation: "agent.action.translate",
+        documentId: sourceDocument._id,
+        targetLanguage,
+        schemaId
+      }
     }
-  });
+  );
 }, handleTranslation = async ({
   dispatch,
   client,
@@ -2879,7 +2289,9 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
   translationMode,
   openaiConfig,
   releaseId,
-  excludeFields = []
+  excludeFields = [],
+  replaceExisting = !1,
+  mainSourceDocumentId
 }) => {
   const safeExcludeFields = excludeFields.filter((field) => field !== languageFieldName);
   excludeFields.length !== safeExcludeFields.length && devLog.warn("Language field was in excludeFields - removing it to prevent translation errors", {
@@ -2902,58 +2314,74 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
     filteredTitleValue: filteredDocument.title,
     excludedValuesKeys: Object.keys(excludedValues),
     excludedValues
-  }), devLog.debug("Applying field transforms before translation", {
-    documentId: sourceDocument._id,
-    documentType: sourceDocument._type
   });
-  const { transformedDocument, originalStructure } = applyTransforms({
-    document: filteredDocument,
-    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;
+  let documentToTranslate, originalStructure = {};
+  if (translationMode === "openai-only") {
+    devLog.debug("Applying field transforms before translation (OpenAI mode)", {
+      documentId: sourceDocument._id,
+      documentType: sourceDocument._type
+    });
+    const transformResult = applyTransforms({
+      document: filteredDocument,
+      registry: globalTransformRegistry,
+      schemaType: sourceDocument._type
+    });
+    documentToTranslate = transformResult.transformedDocument, originalStructure = transformResult.originalStructure;
+  } else
+    devLog.debug("Skipping field transforms (Sanity Agent mode)", {
+      documentId: sourceDocument._id,
+      documentType: sourceDocument._type
+    }), documentToTranslate = filteredDocument;
+  let translatedDoc, previousError = null;
+  const performTranslation = async (errorContext) => {
+    switch (translationMode) {
+      case "sanity-only":
+        return setJobStatus(dispatch, sourceDocument._id, targetLanguage, "translating", void 0, mainSourceDocumentId), await getSanityAgentTranslation({
+          sourceDocument: documentToTranslate,
+          targetLanguage,
+          languageFieldName,
+          schemaId,
+          client,
+          translationPrompts
+        });
+      case "openai-only": {
+        if (!openaiConfig?.enabled || !openaiConfig?.apiKey)
+          throw new Error("OpenAI is not configured but openai-only mode was selected");
+        return setJobStatus(
+          dispatch,
+          sourceDocument._id,
+          targetLanguage,
+          "translating_with_openai",
+          void 0,
+          mainSourceDocumentId
+        ), await getOpenAITranslation({
+          dispatch,
+          sourceDocument: documentToTranslate,
+          targetLanguage,
+          languageFieldName,
+          translationPrompts,
+          openaiConfig,
+          previousError: errorContext && previousError ? previousError : void 0,
+          errorContext
+        });
+      }
+      default:
+        throw new Error(`Invalid translation mode: ${translationMode}`);
     }
-    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)
+  };
+  if (translatedDoc = await performTranslation(), !translatedDoc)
     return null;
-  devLog.debug("Restoring field transforms after translation", {
+  let transformedResult;
+  Object.keys(originalStructure).length > 0 ? (devLog.debug("Restoring field transforms after translation", {
     documentId: sourceDocument._id,
     documentType: sourceDocument._type
-  });
-  const transformedResult = restoreTransforms({
+  }), transformedResult = restoreTransforms({
     translatedDocument: translatedDoc,
     originalStructure,
     registry: globalTransformRegistry,
     schemaType: sourceDocument._type
-  }), excludedValuesToRestore = { ...excludedValues };
+  })) : transformedResult = translatedDoc;
+  const excludedValuesToRestore = { ...excludedValues };
   delete excludedValuesToRestore[languageFieldName], devLog.info("Before restoring excluded fields", {
     documentId: sourceDocument._id,
     excludedFieldCount: Object.keys(excludedValues).length,
@@ -2972,11 +2400,76 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
     ...finalDoc,
     _id: targetDocumentVersionId
   };
-  return await client.action({
-    actionType: "sanity.action.document.version.create",
-    publishedId: targetDocumentPublishedId,
-    document: newDoc
-  }), newDoc;
+  replaceExisting && await client.getDocument(targetDocumentVersionId) && (devLog.info("Replacing existing version in release", {
+    documentId: sourceDocument._id,
+    targetDocumentVersionId,
+    releaseId
+  }), await client.delete(targetDocumentVersionId));
+  try {
+    await retryWithBackoff(
+      async () => {
+        await client.action({
+          actionType: "sanity.action.document.version.create",
+          publishedId: targetDocumentPublishedId,
+          document: newDoc
+        });
+      },
+      {
+        maxAttempts: 2,
+        initialDelayMs: 0,
+        retryableErrors: isNetworkError,
+        context: {
+          documentId: sourceDocument._id,
+          targetLanguage,
+          operation: "version.create"
+        }
+      }
+    );
+  } catch (error) {
+    if (translationMode === "openai-only" && isSanityMutationError(error)) {
+      devLog.warn("Mutation error after OpenAI translation, retrying full translation", {
+        documentId: sourceDocument._id,
+        targetLanguage,
+        error: error instanceof Error ? error.message : String(error)
+      }), previousError = error instanceof Error ? error : new Error(String(error));
+      const errorContext = `Previous translation attempt failed with Sanity validation error: ${previousError.message}. Please ensure the translated document structure exactly matches the source document structure.`;
+      if (translatedDoc = await performTranslation(errorContext), !translatedDoc)
+        throw new Error("Translation retry failed: no document returned");
+      let retryTransformedResult;
+      Object.keys(originalStructure).length > 0 ? retryTransformedResult = restoreTransforms({
+        translatedDocument: translatedDoc,
+        originalStructure,
+        registry: globalTransformRegistry,
+        schemaType: sourceDocument._type
+      }) : retryTransformedResult = translatedDoc;
+      const retryNewDoc = {
+        ...restoreExcludedFields(retryTransformedResult, excludedValuesToRestore),
+        _id: targetDocumentVersionId
+      };
+      return await retryWithBackoff(
+        async () => {
+          await client.action({
+            actionType: "sanity.action.document.version.create",
+            publishedId: targetDocumentPublishedId,
+            document: retryNewDoc
+          });
+        },
+        {
+          maxAttempts: 2,
+          initialDelayMs: 0,
+          retryableErrors: isNetworkError,
+          context: {
+            documentId: sourceDocument._id,
+            targetLanguage,
+            operation: "version.create",
+            isRetry: !0
+          }
+        }
+      ), retryNewDoc;
+    }
+    throw error;
+  }
+  return newDoc;
 }, translateDocument = async ({
   dispatch,
   client,
@@ -2984,84 +2477,66 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
   sourceLanguage,
   targetLanguage,
   languageFieldName,
-  shouldOverwriteFreshTranslations,
   schemaId,
   translationPrompts,
   translationMode,
   openaiConfig,
   releaseId,
-  excludeFields
+  excludeFields,
+  replaceExisting,
+  mainSourceDocumentId
 }) => {
   const logContext = {
     documentId: sourceDocument._id,
     targetLanguage,
     schemaId,
-    shouldOverwriteFreshTranslations,
     translationMode
   };
-  devLog.group("translateDocument", logContext), devLog.time("translateDocument"), setJobStatus(dispatch, sourceDocument._id, targetLanguage, "preparing_translation");
+  devLog.group("translateDocument", logContext), devLog.time("translateDocument"), setJobStatus(dispatch, sourceDocument._id, targetLanguage, "preparing_translation", void 0, mainSourceDocumentId);
   try {
     const translationMetadata = await getTranslationMetadata({
       client,
       sourceDocument,
       sourceLanguage
-    }), isAlreadyFreshTranslation = translationMetadata.translationHistory?.some(
-      (history) => history.language === targetLanguage && history.sourceRev === sourceDocument._rev
-    );
-    if (!shouldOverwriteFreshTranslations && isAlreadyFreshTranslation) {
-      setJobStatus(dispatch, sourceDocument._id, targetLanguage, "skipped", {
-        targetId: translationMetadata.translations.find((t) => t._key === targetLanguage)?.value._ref
-      });
-      return;
-    }
-    const existingTranslationId = getExistingTranslationId(translationMetadata, targetLanguage), translationResult = await withRetry(
-      () => handleTranslation({
+    }), existingTranslationId = getExistingTranslationId(translationMetadata, targetLanguage), newDocument = await handleTranslation({
+      dispatch,
+      client,
+      schemaId,
+      sourceDocument,
+      targetLanguage,
+      existingTranslationId,
+      languageFieldName,
+      translationPrompts,
+      translationMode,
+      openaiConfig,
+      releaseId,
+      excludeFields,
+      replaceExisting,
+      mainSourceDocumentId
+    });
+    if (!newDocument) {
+      devLog.error("Translation failed: no document returned", new Error("Translation returned null"), logContext), setJobStatus(
         dispatch,
-        client,
-        schemaId,
-        sourceDocument,
+        sourceDocument._id,
         targetLanguage,
-        existingTranslationId,
-        languageFieldName,
-        translationPrompts,
-        translationMode,
-        openaiConfig,
-        releaseId,
-        excludeFields
-      }),
-      {
-        maxRetries: 3,
-        initialDelayMs: 1e3,
-        isRetryable: isRetryableError,
-        onRetry: (attempt, error, delayMs) => {
-          devLog.warn("Translation failed, scheduling retry", {
-            ...logContext,
-            attempt,
-            delayMs,
-            error: error instanceof Error ? error.message : String(error)
-          }), setJobStatus(dispatch, sourceDocument._id, targetLanguage, "retrying", {
-            retryCount: attempt,
-            errorMessage: error instanceof Error ? error.message : String(error)
-          });
-        }
-      }
-    );
-    if (!translationResult.success || !translationResult.result) {
-      const errorMessage = translationResult.error instanceof Error ? translationResult.error.message : String(translationResult.error || "Translation failed");
-      devLog.error("Translation failed after retries", translationResult.error, {
-        ...logContext,
-        attempts: translationResult.attempts
-      }), setJobStatus(dispatch, sourceDocument._id, targetLanguage, "error", {
-        errorMessage,
-        retryCount: translationResult.attempts - 1
-        // -1 because attempts includes initial try
-      }), devLog.timeEnd("translateDocument"), devLog.groupEnd();
+        "error",
+        {
+          errorMessage: "Translation failed"
+        },
+        mainSourceDocumentId
+      ), devLog.timeEnd("translateDocument"), devLog.groupEnd();
       return;
     }
-    const newDocument = translationResult.result;
-    return setJobStatus(dispatch, sourceDocument._id, targetLanguage, "updating_metadata", {
-      targetId: newDocument._id
-    }), await updateTranslationMetadata({
+    return setJobStatus(
+      dispatch,
+      sourceDocument._id,
+      targetLanguage,
+      "updating_metadata",
+      {
+        targetId: newDocument._id
+      },
+      mainSourceDocumentId
+    ), await updateTranslationMetadata({
       client,
       sourceDocument,
       sourceLanguage,
@@ -3069,17 +2544,31 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
       targetLanguage,
       translationMetadata,
       isNewTranslation: !existingTranslationId
-    }), setJobStatus(dispatch, sourceDocument._id, targetLanguage, "completed", {
-      targetId: newDocument._id
-    }), devLog.info("Translation completed successfully", {
+    }), setJobStatus(
+      dispatch,
+      sourceDocument._id,
+      targetLanguage,
+      "completed",
+      {
+        targetId: newDocument._id
+      },
+      mainSourceDocumentId
+    ), devLog.info("Translation completed successfully", {
       ...logContext,
       newDocumentId: newDocument._id
     }), devLog.timeEnd("translateDocument"), devLog.groupEnd(), newDocument._id;
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
-    devLog.error("Translation failed", error instanceof Error ? error : new Error(String(error)), logContext), setJobStatus(dispatch, sourceDocument._id, targetLanguage, "error", {
-      errorMessage
-    }), devLog.timeEnd("translateDocument"), devLog.groupEnd();
+    devLog.error("Translation failed", error instanceof Error ? error : new Error(String(error)), logContext), setJobStatus(
+      dispatch,
+      sourceDocument._id,
+      targetLanguage,
+      "error",
+      {
+        errorMessage
+      },
+      mainSourceDocumentId
+    ), devLog.timeEnd("translateDocument"), devLog.groupEnd();
     return;
   }
 }, translationSemaphore = new Semaphore(2), translateDocumentSet = async ({
@@ -3088,13 +2577,13 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
   targetLanguages,
   dispatch,
   languageFieldName,
-  shouldOverwriteFreshTranslations,
   schemaId,
   references = [],
   maxConcurrentTranslationJobs,
   translationMode,
   openaiConfig,
-  excludeFields
+  excludeFields,
+  releaseConfig
 }) => {
   const logContext = {
     documentId: sourceDocument._id,
@@ -3103,28 +2592,48 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
     referencesCount: references.length,
     maxConcurrentJobs: maxConcurrentTranslationJobs,
     translationMode,
-    shouldOverwriteFreshTranslations
+    releaseMode: releaseConfig.mode
   };
-  let releaseId;
+  let releaseId, createdNewRelease = !1;
   try {
     const sourceLanguage = sourceDocument[languageFieldName];
     if (!sourceLanguage)
       throw devLog.error("Source language not found"), new Error("Source language not found");
-    maxConcurrentTranslationJobs && translationSemaphore.updatePermits(maxConcurrentTranslationJobs), dispatch({
+    if (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()}`, { releaseId: releaseId2 } = await client.releases.create({
-      metadata: {
-        title: releaseTitle,
-        description: releaseDescription,
-        releaseType: "undecided"
-      }
-    });
-    devLog.info("Content Release created", {
-      ...logContext,
-      releaseId: releaseId2
-    });
+    }), releaseConfig.mode === "existing" && releaseConfig.existingReleaseId)
+      releaseId = releaseConfig.existingReleaseId, devLog.info("Using existing Content Release", {
+        ...logContext,
+        releaseId
+      });
+    else {
+      const releaseTitle = releaseConfig.newReleaseTitle, releaseDescription = `AI translation batch created on ${(/* @__PURE__ */ new Date()).toLocaleDateString()} at ${(/* @__PURE__ */ new Date()).toLocaleTimeString()}`;
+      releaseId = (await retryWithBackoff(
+        async () => await client.releases.create({
+          metadata: {
+            title: releaseTitle,
+            description: releaseDescription,
+            releaseType: "undecided"
+          }
+        }),
+        {
+          maxAttempts: 2,
+          initialDelayMs: 0,
+          retryableErrors: isNetworkError,
+          context: {
+            operation: "releases.create",
+            releaseTitle,
+            ...logContext
+          }
+        }
+      )).releaseId, createdNewRelease = !0, devLog.info("Content Release created", {
+        ...logContext,
+        releaseId,
+        releaseTitle
+      });
+    }
+    registerActiveTranslation(sourceDocument._id, releaseId), updateActiveTranslationStatus(sourceDocument._id, "translating");
     const sourceDocuments = [
       {
         _id: sourceDocument._id,
@@ -3139,7 +2648,7 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
       targetLanguages,
       sourceDocument
     });
-    setupTranslationJobStatuses(dispatch, sourceDocuments, targetLanguages);
+    setupTranslationJobStatuses(dispatch, sourceDocuments, targetLanguages, sourceDocument._id);
     const translationTasks = sourceDocumentIds.flatMap(
       (documentId) => targetLanguages.map(async (targetLanguage) => {
         try {
@@ -3147,7 +2656,7 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
             const document = await client.withConfig({
               perspective: "drafts"
             }).getDocument(documentId);
-            if (document || devLog.error("\u274C SOURCE DOCUMENT NOT FOUND", { documentId }), document && releaseId2) {
+            if (document || devLog.error("\u274C SOURCE DOCUMENT NOT FOUND", { documentId }), document && releaseId) {
               const versionedTargetDocumentId = await translateDocument({
                 dispatch,
                 client,
@@ -3155,13 +2664,15 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
                 sourceLanguage,
                 targetLanguage,
                 languageFieldName,
-                shouldOverwriteFreshTranslations,
                 schemaId,
                 translationPrompts,
                 translationMode,
                 openaiConfig,
-                releaseId: releaseId2,
-                excludeFields
+                releaseId,
+                excludeFields,
+                replaceExisting: releaseConfig.replaceExisting,
+                // Pass main source document ID for active translations tracking
+                mainSourceDocumentId: sourceDocument._id
               });
               versionedTargetDocumentId && versionedTargetDocumentIds.push(versionedTargetDocumentId);
             }
@@ -3188,7 +2699,7 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
     }), dispatch({
       type: "SET_OVERALL_STATUS",
       payload: "linking_references"
-    }), await Promise.all(
+    }), updateActiveTranslationStatus(sourceDocument._id, "linking_references"), await Promise.all(
       versionedTargetDocumentIds.map(async (documentId) => {
         await localizeReferences({
           client,
@@ -3199,18 +2710,65 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
       })
     );
     const hasAnyFailures = failed > 0;
-    hasAnyFailures && succeeded === 0 ? (devLog.error("All translation tasks failed", void 0, logContext), dispatch({ type: "SET_OVERALL_STATUS", payload: "error" })) : hasAnyFailures ? (devLog.warn("Translation completed with some failures", {
+    hasAnyFailures && succeeded === 0 ? (devLog.error("All translation tasks failed", void 0, logContext), dispatch({ type: "SET_OVERALL_STATUS", payload: "error" }), updateActiveTranslationStatus(sourceDocument._id, "error"), cleanupActiveTranslation(sourceDocument._id)) : hasAnyFailures ? (devLog.warn("Translation completed with some failures", {
       ...logContext,
       succeeded,
       failed
-    }), dispatch({ type: "SET_OVERALL_STATUS", payload: "completed" })) : dispatch({ type: "SET_OVERALL_STATUS", payload: "completed" }), devLog.timeEnd("translateDocumentSet"), devLog.groupEnd();
+    }), dispatch({ type: "SET_OVERALL_STATUS", payload: "completed" }), updateActiveTranslationStatus(sourceDocument._id, "completed"), cleanupActiveTranslation(sourceDocument._id)) : (dispatch({ type: "SET_OVERALL_STATUS", payload: "completed" }), updateActiveTranslationStatus(sourceDocument._id, "completed"), cleanupActiveTranslation(sourceDocument._id)), devLog.timeEnd("translateDocumentSet"), devLog.groupEnd();
   } catch (error) {
-    throw devLog.error(
+    if (devLog.error(
       "translateDocumentSet failed with unexpected error",
       error instanceof Error ? error : new Error(String(error)),
       logContext
-    ), devLog.timeEnd("translateDocumentSet"), devLog.groupEnd(), dispatch({ type: "SET_OVERALL_STATUS", payload: "error" }), error;
+    ), releaseId && createdNewRelease)
+      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" }), updateActiveTranslationStatus(sourceDocument._id, "error"), cleanupActiveTranslation(sourceDocument._id), error;
   }
+}, ReleaseConflictWarning = ({ conflicts, onCancel, onReplace }) => {
+  const uniqueDocuments = useMemo(() => new Set(conflicts.map((c) => c.sourceDocumentId)).size, [conflicts]), summaryText = useMemo(() => conflicts.length === 1 ? "1 translation" : uniqueDocuments === 1 ? `${conflicts.length} translations` : `${conflicts.length} translations across ${uniqueDocuments} documents`, [conflicts.length, uniqueDocuments]);
+  return /* @__PURE__ */ jsx(Card, { tone: "caution", padding: 4, border: !0, radius: 2, children: /* @__PURE__ */ jsxs(Stack, { space: 4, children: [
+    /* @__PURE__ */ jsxs(Flex, { align: "center", gap: 2, children: [
+      /* @__PURE__ */ jsx(Text, { size: 2, children: /* @__PURE__ */ jsx(WarningOutlineIcon, {}) }),
+      /* @__PURE__ */ jsx(Text, { weight: "semibold", children: "This release already contains translations for this content and target language(s)." })
+    ] }),
+    /* @__PURE__ */ jsxs(Text, { size: 1, children: [
+      "The selected release already has ",
+      summaryText,
+      " that will be overwritten if you continue:"
+    ] }),
+    /* @__PURE__ */ jsx(Card, { padding: 3, border: !0, radius: 2, children: /* @__PURE__ */ jsx(Box, { style: { maxHeight: "500px", overflowY: "auto" }, children: /* @__PURE__ */ jsx(Stack, { space: 2, children: conflicts.map((conflict) => /* @__PURE__ */ jsxs(Text, { size: 1, muted: !0, children: [
+      conflict.sourceDocumentTitle || conflict.sourceDocumentId,
+      conflict.sourceDocumentType && ` (${conflict.sourceDocumentType})`,
+      " \u2192 ",
+      conflict.targetLanguage
+    ] }, conflict.existingVersionId)) }) }) }),
+    /* @__PURE__ */ jsxs(Stack, { space: 4, children: [
+      /* @__PURE__ */ jsx(Heading, { size: 0, children: "Choose an action:" }),
+      /* @__PURE__ */ jsxs(Text, { size: 1, children: [
+        /* @__PURE__ */ jsx("strong", { children: "Cancel" }),
+        " \u2014 Go back and select a different release, or create a new one."
+      ] }),
+      /* @__PURE__ */ jsxs(Text, { size: 1, children: [
+        /* @__PURE__ */ jsx("strong", { children: "Replace" }),
+        " \u2014 Delete the existing translations in this release and create new ones."
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs(Flex, { gap: 2, justify: "flex-end", children: [
+      /* @__PURE__ */ jsx(Button, { mode: "ghost", text: "Cancel", onClick: onCancel }),
+      /* @__PURE__ */ jsx(Button, { mode: "ghost", tone: "caution", text: "Replace Existing", onClick: onReplace })
+    ] })
+  ] }) });
 }, ActionButtonBar = ({ setIsDialogOpen }) => {
   const {
     document,
@@ -3218,40 +2776,83 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
     overallStatus,
     dispatch,
     references,
+    selectedReferenceIds,
     selectedTargetLanguages,
-    shouldOverwriteFreshTranslations,
-    translationMode
-  } = useTranslationContext(), client = useClient({ apiVersion: "vX" }), handleTranslate = useCallback(() => {
-    translateDocumentSet({
-      sourceDocument: document,
-      targetLanguages: selectedTargetLanguages,
+    translationMode,
+    releaseConfig
+  } = useTranslationContext(), client = useClient({ apiVersion: "vX" }), [conflictContext, setConflictContext] = useState(null), [isCheckingConflicts, setIsCheckingConflicts] = useState(!1), filteredReferences = references.filter((ref) => selectedReferenceIds.has(ref._id));
+  useEffect(() => {
+    releaseConfig.mode === "new" && conflictContext && setConflictContext(null);
+  }, [releaseConfig.mode, conflictContext]);
+  const startTranslation = useCallback(
+    (replaceExisting, overrideReleaseId) => {
+      setConflictContext(null), translateDocumentSet({
+        sourceDocument: document,
+        targetLanguages: selectedTargetLanguages,
+        client,
+        dispatch,
+        languageFieldName: config.languageFieldName,
+        schemaId: config.schemaId,
+        references: filteredReferences,
+        maxConcurrentTranslationJobs: config.maxConcurrentTranslationJobs,
+        maxReferenceDepth: config.maxReferenceDepth,
+        translationMode,
+        openaiConfig: config.openai,
+        excludeFields: config.excludeFields,
+        releaseConfig: {
+          ...releaseConfig,
+          replaceExisting,
+          // Use the override release ID if provided (from conflict context),
+          // otherwise use the current releaseConfig value
+          existingReleaseId: overrideReleaseId ?? releaseConfig.existingReleaseId
+        }
+      });
+    },
+    [
+      document,
+      selectedTargetLanguages,
       client,
       dispatch,
-      languageFieldName: config.languageFieldName,
-      schemaId: config.schemaId,
-      references,
-      shouldOverwriteFreshTranslations,
-      maxConcurrentTranslationJobs: config.maxConcurrentTranslationJobs,
-      maxReferenceDepth: config.maxReferenceDepth,
+      config.languageFieldName,
+      config.schemaId,
+      config.maxConcurrentTranslationJobs,
+      config.maxReferenceDepth,
+      config.openai,
+      config.excludeFields,
+      filteredReferences,
       translationMode,
-      openaiConfig: config.openai,
-      excludeFields: config.excludeFields
-    });
-  }, [
-    document,
-    selectedTargetLanguages,
-    client,
-    dispatch,
-    config.languageFieldName,
-    config.schemaId,
-    config.maxConcurrentTranslationJobs,
-    config.maxReferenceDepth,
-    config.openai,
-    config.excludeFields,
-    references,
-    shouldOverwriteFreshTranslations,
-    translationMode
-  ]), handleSelectAll = useCallback(() => {
+      releaseConfig
+    ]
+  ), handleTranslate = useCallback(async () => {
+    if (releaseConfig.mode === "new") {
+      startTranslation(!1);
+      return;
+    }
+    if (releaseConfig.mode === "existing" && releaseConfig.existingReleaseId) {
+      const checkedReleaseId = releaseConfig.existingReleaseId;
+      setIsCheckingConflicts(!0);
+      const foundConflicts = await checkReleaseConflicts({
+        client,
+        releaseId: checkedReleaseId,
+        sourceDocument: document,
+        targetLanguages: selectedTargetLanguages,
+        languageFieldName: config.languageFieldName,
+        references: filteredReferences
+      });
+      if (setIsCheckingConflicts(!1), foundConflicts.length > 0) {
+        setConflictContext({
+          releaseId: checkedReleaseId,
+          conflicts: foundConflicts
+        });
+        return;
+      }
+    }
+    startTranslation(!1);
+  }, [releaseConfig, client, document, selectedTargetLanguages, config.languageFieldName, startTranslation, filteredReferences]), handleCancelConflict = useCallback(() => {
+    setConflictContext(null);
+  }, []), handleReplaceConflict = useCallback(() => {
+    conflictContext && startTranslation(!0, conflictContext.releaseId);
+  }, [startTranslation, conflictContext]), handleSelectAll = useCallback(() => {
     dispatch({
       type: "SET_SELECTED_TARGET_LANGUAGES",
       payload: config.supportedLanguages.map((lang) => lang.id).filter((id) => id !== document.language)
@@ -3262,7 +2863,14 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
       payload: []
     });
   }, [dispatch]);
-  return /* @__PURE__ */ jsxs(Flex, { justify: "space-between", gap: 2, children: [
+  return conflictContext ? /* @__PURE__ */ jsx(Stack, { space: 4, children: /* @__PURE__ */ jsx(
+    ReleaseConflictWarning,
+    {
+      conflicts: conflictContext.conflicts,
+      onCancel: handleCancelConflict,
+      onReplace: handleReplaceConflict
+    }
+  ) }) : /* @__PURE__ */ jsxs(Flex, { justify: "space-between", gap: 2, children: [
     /* @__PURE__ */ jsxs(Flex, { justify: "flex-start", gap: 2, children: [
       /* @__PURE__ */ jsx(Button, { mode: "ghost", size: 2, onClick: handleSelectAll, children: "Select All" }),
       /* @__PURE__ */ jsx(Button, { mode: "ghost", size: 2, onClick: handleSelectNone, children: "Select None" })
@@ -3276,16 +2884,41 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
           tone: "positive",
           size: 2,
           onClick: handleTranslate,
-          disabled: selectedTargetLanguages.length === 0 || !["idle", "completed"].includes(overallStatus),
-          children: "Translate"
+          disabled: selectedTargetLanguages.length === 0 || !["idle", "completed"].includes(overallStatus) || releaseConfig.mode === "existing" && !releaseConfig.existingReleaseId || isCheckingConflicts,
+          children: isCheckingConflicts ? "Checking..." : "Translate"
         }
       )
     ] })
   ] });
+}, TRANSLATION_METADATA_QUERY = "*[_type == $translationMetadataType && references($documentId)][0]", useTranslationMetadata = ({ documentId }) => {
+  const { dispatch } = useTranslationContext(), { data, loading, error } = useListeningQuery(TRANSLATION_METADATA_QUERY, {
+    params: {
+      documentId: undraftId(documentId),
+      translationMetadataType: TRANSLATION_METADATA_TYPE
+    },
+    initialValue: null
+  });
+  return useEffect(() => {
+    if (loading) {
+      dispatch({ type: "SET_OVERALL_STATUS", payload: "fetching_metadata" });
+      return;
+    }
+    if (error) {
+      dispatch({ type: "SET_OVERALL_STATUS", payload: "error" });
+      return;
+    }
+    if (data) {
+      dispatch({ type: "SET_TRANSLATION_METADATA", payload: data }), dispatch({ type: "SET_OVERALL_STATUS", payload: "idle" });
+      return;
+    }
+    dispatch({ type: "SET_OVERALL_STATUS", payload: "idle" });
+  }, [data, loading, error, dispatch]), {
+    data,
+    loading,
+    error
+  };
 }, LanguageCheckbox = ({ lang, isLoading }) => {
-  const { document, dispatch, selectedTargetLanguages, translationMetadata } = useTranslationContext(), isDisabled = lang.id === document.language, isChecked = selectedTargetLanguages.includes(lang.id), hasTranslation = translationMetadata?.translations?.some((translation) => translation._key === lang.id), isStale = hasTranslation && translationMetadata?.translationHistory?.some(
-    (history) => history.language === lang.id && history.sourceRev !== document._rev
-  ), handleChange = () => {
+  const { document, dispatch, selectedTargetLanguages } = useTranslationContext(), isDisabled = lang.id === document.language, isChecked = selectedTargetLanguages.includes(lang.id), handleChange = () => {
     if (isDisabled) return;
     const updatedLanguages = isChecked ? selectedTargetLanguages.filter((langId) => langId !== lang.id) : [...selectedTargetLanguages, lang.id];
     dispatch({
@@ -3303,16 +2936,13 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
       disabled: isDisabled,
       tone: isChecked ? "primary" : "default",
       muted: !0,
-      children: /* @__PURE__ */ jsxs(Flex, { align: "center", gap: 2, style: { cursor: "pointer" }, children: [
-        /* @__PURE__ */ jsxs(Inline, { space: 3, children: [
-          /* @__PURE__ */ jsx(Checkbox, { checked: isChecked, onChange: handleChange, label: lang.title, disabled: isDisabled }),
-          /* @__PURE__ */ jsxs(Flex, { direction: "column", gap: 3, children: [
-            /* @__PURE__ */ jsx(Text, { children: lang.title }),
-            isDisabled ? /* @__PURE__ */ jsx(Text, { size: 1, muted: !0, children: "The current language" }) : /* @__PURE__ */ jsx(Text, { size: 1, muted: !0, children: hasTranslation && !isDisabled ? "Already translated" : "Not translated" })
-          ] })
-        ] }),
-        !isDisabled && hasTranslation && /* @__PURE__ */ jsx(Flex, { flex: 1, justify: "flex-end", children: /* @__PURE__ */ jsx(Badge, { tone: isStale ? "caution" : "positive", size: 3, muted: !0, children: isStale ? "Stale" : "Fresh" }) })
-      ] })
+      children: /* @__PURE__ */ jsx(Flex, { align: "center", gap: 2, style: { cursor: "pointer" }, children: /* @__PURE__ */ jsxs(Inline, { space: 3, children: [
+        /* @__PURE__ */ jsx(Checkbox, { checked: isChecked, onChange: handleChange, label: lang.title, disabled: isDisabled }),
+        /* @__PURE__ */ jsxs(Flex, { direction: "column", gap: 3, children: [
+          /* @__PURE__ */ jsx(Text, { children: lang.title }),
+          isDisabled && /* @__PURE__ */ jsx(Text, { size: 1, muted: !0, children: "The current language" })
+        ] })
+      ] }) })
     }
   );
 }, LanguageSelectionPanel = () => {
@@ -3320,6 +2950,134 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
     documentId: document._id
   });
   return /* @__PURE__ */ jsx(Card, { padding: 4, muted: !0, border: !0, children: /* @__PURE__ */ jsx(Grid, { columns: [1, 2], gap: 3, children: config?.supportedLanguages.map((lang) => /* @__PURE__ */ jsx(LanguageCheckbox, { lang, isLoading: loading }, lang.id)) }) });
+}, ReleaseSelectionPanel = () => {
+  const { dispatch, releaseConfig } = useTranslationContext(), client = useClient({ apiVersion: "vX" }), [releases, setReleases] = useState([]), [isLoading, setIsLoading] = useState(!1), [error, setError] = useState(null), [searchQuery, setSearchQuery] = useState("");
+  useEffect(() => {
+    (async () => {
+      setIsLoading(!0), setError(null);
+      try {
+        const result = await client.fetch(
+          'releases::all()[state == "active"] | order(_createdAt desc)'
+        );
+        setReleases(result), devLog.debug("Fetched active releases", {
+          count: result.length,
+          component: "ReleaseSelectionPanel"
+        });
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : "Failed to fetch releases";
+        setError(errorMessage), devLog.error("Failed to fetch releases", err instanceof Error ? err : new Error(errorMessage), {
+          component: "ReleaseSelectionPanel"
+        });
+      } finally {
+        setIsLoading(!1);
+      }
+    })();
+  }, [client]);
+  const handleModeChange = useCallback(
+    (mode) => {
+      dispatch({
+        type: "SET_RELEASE_CONFIG",
+        payload: { mode }
+      });
+    },
+    [dispatch]
+  ), handleTitleChange = useCallback(
+    (event) => {
+      dispatch({
+        type: "SET_RELEASE_CONFIG",
+        payload: { newReleaseTitle: event.target.value }
+      });
+    },
+    [dispatch]
+  ), handleSelectRelease = useCallback(
+    (releaseId) => {
+      dispatch({
+        type: "SET_RELEASE_CONFIG",
+        payload: { existingReleaseId: releaseId }
+      });
+    },
+    [dispatch]
+  ), handleSearchChange = useCallback((event) => {
+    setSearchQuery(event.target.value);
+  }, []), filteredReleases = useMemo(() => {
+    if (!searchQuery.trim())
+      return releases;
+    const query = searchQuery.toLowerCase();
+    return releases.filter((release) => release.metadata.title.toLowerCase().includes(query));
+  }, [releases, searchQuery]), formatDate = (dateString) => new Date(dateString).toLocaleDateString(void 0, {
+    month: "short",
+    day: "numeric",
+    year: "numeric"
+  });
+  return /* @__PURE__ */ jsx(Card, { padding: 4, border: !0, children: /* @__PURE__ */ jsxs(Stack, { space: 4, children: [
+    /* @__PURE__ */ jsxs(Stack, { space: 3, children: [
+      /* @__PURE__ */ jsxs(Flex, { align: "center", gap: 3, as: "label", style: { cursor: "pointer" }, onClick: () => handleModeChange("new"), children: [
+        /* @__PURE__ */ jsx(Radio, { checked: releaseConfig.mode === "new", readOnly: !0 }),
+        /* @__PURE__ */ jsx(Text, { weight: "medium", children: "Create new release" })
+      ] }),
+      /* @__PURE__ */ jsxs(
+        Flex,
+        {
+          align: "center",
+          gap: 3,
+          as: "label",
+          style: { cursor: "pointer" },
+          onClick: () => handleModeChange("existing"),
+          children: [
+            /* @__PURE__ */ jsx(Radio, { checked: releaseConfig.mode === "existing", readOnly: !0 }),
+            /* @__PURE__ */ jsx(Text, { weight: "medium", children: "Add to existing release" })
+          ]
+        }
+      )
+    ] }),
+    releaseConfig.mode === "new" && /* @__PURE__ */ jsx(
+      TextInput,
+      {
+        value: releaseConfig.newReleaseTitle,
+        onChange: handleTitleChange,
+        placeholder: "Release title..."
+      }
+    ),
+    releaseConfig.mode === "existing" && /* @__PURE__ */ jsxs(Stack, { space: 3, children: [
+      isLoading && /* @__PURE__ */ jsxs(Flex, { align: "center", gap: 2, children: [
+        /* @__PURE__ */ jsx(Spinner, { muted: !0 }),
+        /* @__PURE__ */ jsx(Text, { size: 1, muted: !0, children: "Loading..." })
+      ] }),
+      error && /* @__PURE__ */ jsx(Text, { size: 1, muted: !0, children: error }),
+      !isLoading && !error && releases.length === 0 && /* @__PURE__ */ jsx(Text, { size: 1, muted: !0, children: "No active releases found." }),
+      !isLoading && !error && releases.length > 0 && /* @__PURE__ */ jsxs(Fragment, { children: [
+        /* @__PURE__ */ jsx(
+          TextInput,
+          {
+            icon: SearchIcon,
+            value: searchQuery,
+            onChange: handleSearchChange,
+            placeholder: "Search releases..."
+          }
+        ),
+        /* @__PURE__ */ jsx(Box, { style: { maxHeight: "200px", overflowY: "auto" }, children: /* @__PURE__ */ jsx(Stack, { space: 1, children: filteredReleases.length === 0 ? /* @__PURE__ */ jsx(Text, { size: 1, muted: !0, children: "No releases match your search." }) : filteredReleases.map((release) => {
+          const releaseName = release._id.replace("_.releases.", ""), isSelected = releaseConfig.existingReleaseId === releaseName;
+          return /* @__PURE__ */ jsx(
+            Card,
+            {
+              padding: 3,
+              radius: 2,
+              tone: isSelected ? "primary" : "default",
+              style: { cursor: "pointer" },
+              onClick: () => handleSelectRelease(releaseName),
+              border: !0,
+              muted: isSelected,
+              children: /* @__PURE__ */ jsxs(Flex, { direction: "column", gap: 3, children: [
+                /* @__PURE__ */ jsx(Text, { size: 1, children: release.metadata.title }),
+                /* @__PURE__ */ jsx(Text, { size: 1, muted: !0, children: formatDate(release._createdAt) })
+              ] })
+            },
+            release._id
+          );
+        }) }) })
+      ] })
+    ] })
+  ] }) });
 }, TranslationModePanel = () => {
   const { config, translationMode, openaiValidated, dispatch } = useTranslationContext();
   if (!config?.openai?.enabled || !config?.openai?.apiKey)
@@ -3338,7 +3096,7 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
   return /* @__PURE__ */ jsx(Card, { padding: 4, border: !0, children: /* @__PURE__ */ jsxs(Stack, { space: 3, children: [
     /* @__PURE__ */ jsxs(Inline, { space: 2, children: [
       /* @__PURE__ */ jsx(Text, { weight: "semibold", children: "Translation Mode" }),
-      /* @__PURE__ */ jsx(Badge, { tone: "positive", children: "GPT-5 Available" })
+      /* @__PURE__ */ jsx(Badge, { tone: "positive", children: "OpenAI Available" })
     ] }),
     /* @__PURE__ */ jsxs(Stack, { space: 2, children: [
       /* @__PURE__ */ jsx(
@@ -3368,32 +3126,13 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
             /* @__PURE__ */ jsx(Radio, { checked: translationMode === "openai-only", readOnly: !0 }),
             /* @__PURE__ */ jsxs(Stack, { space: 2, children: [
               /* @__PURE__ */ jsxs(Inline, { space: 2, children: [
-                /* @__PURE__ */ jsx(Text, { children: "GPT-5 Only" }),
+                /* @__PURE__ */ jsx(Text, { children: "OpenAI Only" }),
                 /* @__PURE__ */ jsx(Badge, { tone: "caution", children: "Beta" })
               ] }),
               /* @__PURE__ */ jsx(Text, { size: 1, muted: !0, children: "Full style guide capacity with 1M token context window." })
             ] })
           ] })
         }
-      ),
-      /* @__PURE__ */ jsx(
-        Button,
-        {
-          type: "button",
-          mode: translationMode === "sanity-with-review" ? "ghost" : "bleed",
-          tone: translationMode === "sanity-with-review" ? "primary" : "default",
-          onClick: () => handleModeChange("sanity-with-review"),
-          children: /* @__PURE__ */ jsxs(Inline, { space: 2, children: [
-            /* @__PURE__ */ jsx(Radio, { checked: translationMode === "sanity-with-review", readOnly: !0 }),
-            /* @__PURE__ */ jsxs(Stack, { space: 2, children: [
-              /* @__PURE__ */ jsxs(Inline, { space: 2, children: [
-                /* @__PURE__ */ jsx(Text, { children: "Sanity + GPT-5 Review" }),
-                /* @__PURE__ */ jsx(Badge, { tone: "primary", children: "Highest Quality" })
-              ] }),
-              /* @__PURE__ */ jsx(Text, { size: 1, muted: !0, children: "Sanity translation refined by GPT-5. Takes longer but best results." })
-            ] })
-          ] })
-        }
       )
     ] }),
     translationMode !== "sanity-only" && /* @__PURE__ */ jsx(Card, { tone: "caution", padding: 3, border: !0, children: /* @__PURE__ */ jsxs(Text, { size: 1, children: [
@@ -3483,8 +3222,104 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
     });
   }
   return result;
+}, ReferenceSelectionPanel = () => {
+  const { references, selectedReferenceIds, dispatch } = useTranslationContext(), [typeFilter, setTypeFilter] = useState("all"), documentTypes = useMemo(() => {
+    const types = new Set(references.map((ref) => ref._type));
+    return Array.from(types).sort();
+  }, [references]), filteredReferences = useMemo(() => typeFilter === "all" ? references : references.filter((ref) => ref._type === typeFilter), [references, typeFilter]), selectedCount = useMemo(() => filteredReferences.filter((ref) => selectedReferenceIds.has(ref._id)).length, [filteredReferences, selectedReferenceIds]), handleToggleReference = (referenceId) => {
+    const newSelection = new Set(selectedReferenceIds);
+    newSelection.has(referenceId) ? newSelection.delete(referenceId) : newSelection.add(referenceId), dispatch({
+      type: "SET_SELECTED_REFERENCE_IDS",
+      payload: newSelection
+    });
+  }, handleSelectAll = () => {
+    const newSelection = new Set(selectedReferenceIds);
+    filteredReferences.forEach((ref) => {
+      newSelection.add(ref._id);
+    }), dispatch({
+      type: "SET_SELECTED_REFERENCE_IDS",
+      payload: newSelection
+    });
+  }, handleSelectNone = () => {
+    const newSelection = new Set(selectedReferenceIds);
+    filteredReferences.forEach((ref) => {
+      newSelection.delete(ref._id);
+    }), dispatch({
+      type: "SET_SELECTED_REFERENCE_IDS",
+      payload: newSelection
+    });
+  };
+  return references.length === 0 ? null : /* @__PURE__ */ jsx(Card, { padding: 4, border: !0, muted: !0, children: /* @__PURE__ */ jsxs(Stack, { space: 3, children: [
+    /* @__PURE__ */ jsxs(Flex, { justify: "space-between", align: "center", gap: 2, children: [
+      /* @__PURE__ */ jsxs(Flex, { gap: 2, align: "center", children: [
+        /* @__PURE__ */ jsx(Text, { size: 1, weight: "semibold", children: "Select References" }),
+        /* @__PURE__ */ jsxs(Text, { size: 1, muted: !0, children: [
+          "(",
+          selectedCount,
+          " of ",
+          filteredReferences.length,
+          " selected)"
+        ] })
+      ] }),
+      /* @__PURE__ */ jsxs(Flex, { gap: 2, children: [
+        /* @__PURE__ */ jsx(Button, { mode: "ghost", size: 1, onClick: handleSelectAll, text: "Select All" }),
+        /* @__PURE__ */ jsx(Button, { mode: "ghost", size: 1, onClick: handleSelectNone, text: "Select None" })
+      ] })
+    ] }),
+    documentTypes.length > 1 && /* @__PURE__ */ jsxs(Flex, { align: "center", gap: 2, children: [
+      /* @__PURE__ */ jsx(Text, { size: 1, muted: !0, children: "Filter by type:" }),
+      /* @__PURE__ */ jsxs(
+        Select,
+        {
+          value: typeFilter,
+          onChange: (event) => setTypeFilter(event.target.value),
+          style: { minWidth: "150px" },
+          children: [
+            /* @__PURE__ */ jsxs("option", { value: "all", children: [
+              "All types (",
+              references.length,
+              ")"
+            ] }),
+            documentTypes.map((type) => {
+              const count = references.filter((ref) => ref._type === type).length;
+              return /* @__PURE__ */ jsxs("option", { value: type, children: [
+                type,
+                " (",
+                count,
+                ")"
+              ] }, type);
+            })
+          ]
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx(Box, { style: { maxHeight: "400px", overflowY: "auto" }, children: /* @__PURE__ */ jsx(Stack, { space: 2, children: filteredReferences.length === 0 ? /* @__PURE__ */ jsx(Text, { size: 1, muted: !0, children: "No references match the selected filter." }) : filteredReferences.map((reference) => {
+      const isSelected = selectedReferenceIds.has(reference._id), displayTitle = reference.title || reference._id;
+      return /* @__PURE__ */ jsx(Card, { padding: 3, border: !0, radius: 2, children: /* @__PURE__ */ jsxs(Flex, { align: "center", gap: 3, children: [
+        /* @__PURE__ */ jsx(
+          Checkbox,
+          {
+            checked: isSelected,
+            onChange: () => handleToggleReference(reference._id)
+          }
+        ),
+        /* @__PURE__ */ jsxs(Flex, { flex: 1, align: "center", gap: 2, children: [
+          /* @__PURE__ */ jsx(Text, { size: 1, children: displayTitle }),
+          /* @__PURE__ */ jsx(Badge, { tone: "primary", fontSize: 0, children: reference._type })
+        ] })
+      ] }) }, reference._id);
+    }) }) })
+  ] }) });
 }, ReferenceConfigPanel = () => {
-  const { dispatch, document, shouldTranslateReferences, maxReferenceDepth, config, references } = useTranslationContext(), client = useClient({ apiVersion: "vX" }), [isLoadingReferences, setIsLoadingReferences] = useState(!1), maxDepth = config.maxReferenceDepth || 3;
+  const {
+    dispatch,
+    document,
+    shouldTranslateReferences,
+    maxReferenceDepth,
+    config,
+    references,
+    selectedReferenceIds
+  } = useTranslationContext(), client = useClient({ apiVersion: "vX" }), [isLoadingReferences, setIsLoadingReferences] = useState(!1), [showSelectionPanel, setShowSelectionPanel] = useState(!1), maxDepth = config.maxReferenceDepth || 3;
   useEffect(() => {
     (async () => {
       if (setIsLoadingReferences(!0), !shouldTranslateReferences) {
@@ -3554,43 +3389,26 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
         )
       ] }) : null
     ] }),
-    shouldTranslateReferences ? /* @__PURE__ */ jsx(Flex, { padding: 2, justify: "flex-end", children: /* @__PURE__ */ jsx(Text, { size: 1, muted: !0, children: isLoadingReferences ? "Loading references..." : references.length === 0 ? "No translatable references found." : `${references.length} translatable references found.` }) }) : null
-  ] });
-}, WriteSettingsPanel = () => {
-  const { dispatch, shouldOverwriteFreshTranslations } = useTranslationContext(), handleShouldOverwriteFreshTranslationsChange = () => {
-    dispatch({
-      type: "SET_SHOULD_OVERWRITE_FRESH_TRANSLATIONS",
-      payload: !shouldOverwriteFreshTranslations
-    });
-  };
-  return /* @__PURE__ */ jsxs(Stack, { space: 2, children: [
-    /* @__PURE__ */ jsx(ReferenceConfigPanel, {}),
-    /* @__PURE__ */ jsx(Flex, { justify: "space-between", align: "center", children: /* @__PURE__ */ jsx(
-      Button,
-      {
-        type: "button",
-        mode: shouldOverwriteFreshTranslations ? "ghost" : "bleed",
-        size: 2,
-        onClick: handleShouldOverwriteFreshTranslationsChange,
-        tone: shouldOverwriteFreshTranslations ? "primary" : "neutral",
-        children: /* @__PURE__ */ jsxs(Inline, { space: 2, children: [
-          /* @__PURE__ */ jsx(
-            Checkbox,
-            {
-              checked: shouldOverwriteFreshTranslations,
-              onChange: handleShouldOverwriteFreshTranslationsChange,
-              label: shouldOverwriteFreshTranslations ? "Disable" : "Enable"
-            }
-          ),
-          /* @__PURE__ */ jsxs(Stack, { space: 2, children: [
-            /* @__PURE__ */ jsx(Text, { children: "Overwrite Fresh Translations" }),
-            /* @__PURE__ */ jsx(Text, { size: 1, muted: !0, children: "All existing translations will be overwritten even if they are fresh." })
-          ] })
-        ] })
-      }
-    ) })
+    shouldTranslateReferences ? /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsxs(Flex, { padding: 2, justify: "space-between", align: "center", children: [
+        /* @__PURE__ */ jsx(Text, { size: 1, muted: !0, children: isLoadingReferences ? "Loading references..." : references.length === 0 ? "No translatable references found." : (() => {
+          const selectedCount = references.filter((ref) => selectedReferenceIds.has(ref._id)).length, totalCount = references.length;
+          return selectedCount === totalCount ? `${totalCount} reference${totalCount === 1 ? "" : "s"} will be translated along with this document.` : `${selectedCount} of ${totalCount} reference${totalCount === 1 ? "" : "s"} will be translated along with this document.`;
+        })() }),
+        !isLoadingReferences && references.length > 0 && /* @__PURE__ */ jsx(
+          Button,
+          {
+            mode: "ghost",
+            size: 1,
+            text: showSelectionPanel ? "Hide selection" : "Select specific references...",
+            onClick: () => setShowSelectionPanel(!showSelectionPanel)
+          }
+        )
+      ] }),
+      !isLoadingReferences && references.length > 0 && showSelectionPanel && /* @__PURE__ */ jsx(ReferenceSelectionPanel, {})
+    ] }) : null
   ] });
-}, TranslationConfigView = ({ setIsDialogOpen }) => /* @__PURE__ */ jsxs(Stack, { space: 4, children: [
+}, WriteSettingsPanel = () => /* @__PURE__ */ jsx(ReferenceConfigPanel, {}), TranslationConfigView = ({ setIsDialogOpen }) => /* @__PURE__ */ jsxs(Stack, { space: 4, children: [
   /* @__PURE__ */ jsxs(Stack, { space: 2, children: [
     /* @__PURE__ */ jsx(Label, { children: "Languages" }),
     /* @__PURE__ */ jsx(LanguageSelectionPanel, {})
@@ -3599,16 +3417,19 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
     /* @__PURE__ */ jsx(Label, { children: "Translation Method" }),
     /* @__PURE__ */ jsx(TranslationModePanel, {})
   ] }),
+  /* @__PURE__ */ jsxs(Stack, { space: 2, children: [
+    /* @__PURE__ */ jsx(Label, { children: "Content Release" }),
+    /* @__PURE__ */ jsx(ReleaseSelectionPanel, {})
+  ] }),
   /* @__PURE__ */ jsxs(Stack, { space: 2, children: [
     /* @__PURE__ */ jsx(Label, { children: "Settings" }),
     /* @__PURE__ */ jsx(Card, { padding: 4, border: !0, muted: !0, children: /* @__PURE__ */ jsx(WriteSettingsPanel, {}) })
   ] }),
   /* @__PURE__ */ jsx(ActionButtonBar, { setIsDialogOpen })
 ] }), TERMINAL_STATUSES = ["completed", "skipped", "error"], TranslationStatusPanel = () => {
-  const { overallStatus, translationJobs, translationMode } = useTranslationContext(), headline = useMemo(
-    () => overallStatus === "completed" ? "Translation completed" : "Translation in progress",
-    [overallStatus]
-  ), jobs = useMemo(() => Array.from(translationJobs.values()), [translationJobs]), openaiStats = useMemo(() => {
+  const { overallStatus, translationJobs, translationMode, dispatch, document } = useTranslationContext(), headline = useMemo(() => overallStatus === "completed" ? "Translation completed" : overallStatus === "error" ? "Translation failed" : "Translation in progress", [overallStatus]), jobs = useMemo(() => Array.from(translationJobs.values()), [translationJobs]), isTerminalState = overallStatus === "completed" || overallStatus === "error", handleReset = useCallback(() => {
+    forceCleanupActiveTranslation(document._id), dispatch({ type: "RESET_TRANSLATION_STATE" });
+  }, [dispatch, document._id]), openaiStats = useMemo(() => {
     if (translationMode === "sanity-only") return null;
     const completedJobs = jobs.filter((j) => j.status === "completed"), totalTokens = completedJobs.reduce((sum, job) => sum + (job.tokensUsed || 0), 0), totalCost = completedJobs.reduce((sum, job) => sum + (job.estimatedCost || 0), 0);
     return { totalTokens, totalCost, jobsWithUsage: completedJobs.filter((j) => j.tokensUsed).length };
@@ -3642,17 +3463,12 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
             job.status === "error" && job.errorMessage ? /* @__PURE__ */ jsx(Card, { tone: "critical", padding: 2, radius: 2, children: /* @__PURE__ */ jsxs(Text, { size: 1, children: [
               "Error: ",
               job.errorMessage
-            ] }) }) : null,
-            job.status === "retrying" && job.errorMessage ? /* @__PURE__ */ jsx(Card, { tone: "caution", padding: 2, radius: 2, children: /* @__PURE__ */ jsxs(Text, { size: 1, children: [
-              "Retrying after: ",
-              job.errorMessage
             ] }) }) : null
           ] })
         ] }),
         /* @__PURE__ */ jsxs(Flex, { gap: 2, align: "center", children: [
           job.status === "skipped" ? /* @__PURE__ */ jsx(SkippedBadge, {}) : null,
-          job.status === "error" ? /* @__PURE__ */ jsx(ErrorBadge, { retryCount: job.retryCount }) : null,
-          job.status === "retrying" ? /* @__PURE__ */ jsx(RetryingBadge, { retryCount: job.retryCount }) : null,
+          job.status === "error" ? /* @__PURE__ */ jsx(ErrorBadge, {}) : null,
           job.targetId ? /* @__PURE__ */ jsx(
             TranslationOpenerButton,
             {
@@ -3669,18 +3485,19 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
       /* @__PURE__ */ jsx(Text, { weight: "semibold", children: "OpenAI Usage Summary" }),
       /* @__PURE__ */ jsxs(Inline, { space: 4, children: [
         /* @__PURE__ */ jsxs(Text, { size: 1, children: [
-          "\u{1F4CA} Total Tokens: ",
+          "Total Tokens: ",
           /* @__PURE__ */ jsx("strong", { children: openaiStats.totalTokens.toLocaleString() })
         ] }),
         /* @__PURE__ */ jsxs(Text, { size: 1, children: [
-          "\u{1F4B0} Total Cost: ",
+          "Total Cost: ",
           /* @__PURE__ */ jsxs("strong", { children: [
             "$",
             openaiStats.totalCost.toFixed(4)
           ] })
         ] })
       ] })
-    ] }) })
+    ] }) }),
+    isTerminalState && /* @__PURE__ */ jsx(Flex, { justify: "flex-end", children: /* @__PURE__ */ jsx(Button, { mode: "ghost", tone: "primary", text: "Translate More", icon: ResetIcon, onClick: handleReset }) })
   ] });
 }, ProgressBar = ({ progress, max = 100 }) => {
   const percentage = Math.min(progress / max * 100, 100);
@@ -3732,35 +3549,20 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
     content: /* @__PURE__ */ jsx(Box, { padding: 1, children: /* @__PURE__ */ jsx(Text, { size: 1, muted: !0, children: "There was already a fresh translation for this document and language." }) }),
     children: /* @__PURE__ */ jsx(Badge, { tone: "neutral", children: "Skipped" })
   }
-), ErrorBadge = ({ retryCount }) => /* @__PURE__ */ jsx(
-  Tooltip,
-  {
-    portal: !0,
-    content: /* @__PURE__ */ jsx(Box, { padding: 1, children: /* @__PURE__ */ jsx(Text, { size: 1, muted: !0, children: retryCount && retryCount > 0 ? `This translation failed after ${retryCount} retry attempt${retryCount > 1 ? "s" : ""}.` : "This translation failed. Check the error message for details." }) }),
-    children: /* @__PURE__ */ jsxs(Badge, { tone: "critical", children: [
-      "Failed",
-      retryCount && retryCount > 0 ? ` (${retryCount} retries)` : ""
-    ] })
-  }
-), RetryingBadge = ({ retryCount }) => /* @__PURE__ */ jsx(
+), ErrorBadge = () => /* @__PURE__ */ jsx(
   Tooltip,
   {
     portal: !0,
-    content: /* @__PURE__ */ jsx(Box, { padding: 1, children: /* @__PURE__ */ jsx(Text, { size: 1, muted: !0, children: "Retrying translation after a temporary failure." }) }),
-    children: /* @__PURE__ */ jsxs(Badge, { tone: "caution", children: [
-      "Retry ",
-      retryCount || 1
-    ] })
+    content: /* @__PURE__ */ jsx(Box, { padding: 1, children: /* @__PURE__ */ jsx(Text, { size: 1, muted: !0, children: "This translation failed. Check the error message for details." }) }),
+    children: /* @__PURE__ */ jsx(Badge, { tone: "critical", children: "Failed" })
   }
 ), getStatusLabel = (status) => ({
   idle: "Idle",
   queued: "Queued...",
   preparing_translation: "Preparing translation...",
   translating: "Translating with Sanity Agent...",
-  translating_with_openai: "Translating with GPT-5...",
-  reviewing_with_openai: "Reviewing translation with GPT-5...",
+  translating_with_openai: "Translating with OpenAI...",
   updating_metadata: "Saving metadata...",
-  retrying: "Retrying...",
   error: "Error",
   skipped: "Skipped",
   completed: "Completed"
@@ -3768,14 +3570,30 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
   "translating",
   "linking_references",
   "completed"
-], STATES_IN_WHICH_TO_SHOW_ERROR = ["error"], TranslationDialog = ({ setIsDialogOpen }) => {
+], STATES_IN_WHICH_TO_SHOW_ERROR = ["error"], TranslationDialog = ({ setIsDialogOpen, onStatusChange }) => {
   const { overallStatus, document } = useTranslationContext();
-  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", {
+  return useEffect(() => {
+    onStatusChange?.(overallStatus);
+  }, [overallStatus, onStatusChange]), 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
   }), /* @__PURE__ */ jsx("div", { children: "Unhandled overall state" }));
-}, getTranslateAction = (config) => ({ draft, published }) => {
-  const document = draft ?? published, [isDialogOpen, setIsDialogOpen] = useState(!1);
+}, IN_PROGRESS_STATUSES = ["translating", "linking_references"], getButtonLabel = (status) => status === "completed" ? "Translation Complete" : status && IN_PROGRESS_STATUSES.includes(status) ? "Translating..." : "Translate", getTranslateAction = (config) => ({ draft, published }) => {
+  const document = draft ?? published, [isDialogOpen, setIsDialogOpen] = useState(!1), [currentStatus, setCurrentStatus] = useState(null), isTranslating = currentStatus !== null && IN_PROGRESS_STATUSES.includes(currentStatus), handleStatusChange = useCallback((status) => {
+    setCurrentStatus(status);
+  }, []), handleClose = useCallback(() => {
+    if (isTranslating) {
+      if (!window.confirm(
+        "Translation is in progress. Closing this dialog will not stop the translation, but refreshing the page will cancel the translation. You can reopen the Translate dialog to see updated progress."
+      ))
+        return;
+      devLog.warn("User closed dialog during active translation", {
+        documentId: document?._id,
+        component: "TranslateAction"
+      });
+    }
+    setIsDialogOpen(!1);
+  }, [isTranslating, document?._id]);
   return devLog.debug("TranslateAction initialized", {
     documentId: document?._id,
     documentType: document?._type
@@ -3783,7 +3601,7 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
     documentType: document?._type,
     translatableTypes: config.translatableSchemaTypes
   }), null) : config ? {
-    label: "Translate",
+    label: getButtonLabel(currentStatus),
     icon: TranslateIcon,
     onHandle: () => {
       devLog.info("Translation dialog opened", {
@@ -3794,9 +3612,9 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
     },
     dialog: isDialogOpen && {
       type: "dialog",
-      onClose: () => setIsDialogOpen(!1),
+      onClose: handleClose,
       header: "Translate Document",
-      content: /* @__PURE__ */ jsx(TranslationContextProvider, { document, config, children: /* @__PURE__ */ jsx(TranslationDialog, { setIsDialogOpen }) })
+      content: /* @__PURE__ */ jsx(TranslationContextProvider, { document, config, children: /* @__PURE__ */ jsx(TranslationDialog, { setIsDialogOpen, onStatusChange: handleStatusChange }) })
     }
   } : (devLog.error("Missing config in TranslateAction"), null);
 }, translationGlossaryTerm = defineType({
@@ -3912,7 +3730,7 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
     defineField({
       name: "changeHistory",
       title: "Change History",
-      description: "History of changes made via user feedback.",
+      description: "History of changes made to translation settings.",
       type: "array",
       readOnly: !0,
       group: "history",
@@ -4164,10 +3982,14 @@ function serializeVTTCaptionText(captions) {
     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(`
+  const result = captions.map((caption, index) => {
+    devLog.debug(`Processing caption ${index}:`, {
+      text: caption.text,
+      hasText: typeof caption.text == "string"
+    });
+    const escapedText = (caption.text || "").replace(/\n/g, "\\n");
+    return `[${index}] ${escapedText}`;
+  }).join(`
 `);
   return devLog.debug("serializeVTTCaptionText - output:", {
     resultLength: result.length,
@@ -4184,29 +4006,46 @@ function deserializeVTTCaptionText(translationText, originalMetadata) {
     return [];
   const result = [], lines = translationText.split(`
 `), lineRegex = /^\[(\d+)\]\s*(.*)$/;
+  let currentIndex = null, currentTextParts = [];
   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 (match) {
+      if (currentIndex !== null) {
+        const text = currentTextParts.join(`
+`).replace(/\\n/g, `
+`), metadata = originalMetadata.find((m) => m._originalIndex === currentIndex);
+        if (metadata) {
+          const { _originalIndex, ...metadataWithoutIndex } = metadata;
+          result.push({
+            ...metadataWithoutIndex,
+            text
+          });
+        } else
+          devLog.warn("Missing metadata for caption", { index: currentIndex }), result.push({
+            _type: "vtt.cue",
+            _key: `caption-${currentIndex}`,
+            text,
+            startTime: 0,
+            endTime: 0
+          });
+      }
+      currentIndex = Number.parseInt(match[1], 10), currentTextParts = [match[2]];
+    } else currentIndex !== null ? currentTextParts.push(line) : devLog.warn("Failed to parse caption line", { line });
+  }
+  if (currentIndex !== null) {
+    const text = currentTextParts.join(`
+`).replace(/\\n/g, `
+`), metadata = originalMetadata.find((m) => m._originalIndex === currentIndex);
     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({
+      devLog.warn("Missing metadata for caption", { index: currentIndex }), result.push({
         _type: "vtt.cue",
-        _key: `caption-${index}`,
+        _key: `caption-${currentIndex}`,
         text,
         startTime: 0,
         endTime: 0
@@ -4217,12 +4056,299 @@ function deserializeVTTCaptionText(translationText, originalMetadata) {
     resultExample: result.length > 0 ? result[0] : null
   }), result;
 }
+const LOCALE_TO_ISO = {
+  // English variants
+  "en-us": "eng",
+  "en-US": "eng",
+  "en-gb": "eng",
+  "en-GB": "eng",
+  "en-ca": "eng",
+  "en-CA": "eng",
+  "en-au": "eng",
+  "en-AU": "eng",
+  // Spanish variants
+  es: "spa",
+  "es-es": "spa",
+  "es-ES": "spa",
+  "es-mx": "spa",
+  "es-MX": "spa",
+  // French variants
+  fr: "fra",
+  "fr-fr": "fra",
+  "fr-FR": "fra",
+  "fr-ca": "fra",
+  "fr-CA": "fra",
+  // German variants
+  de: "ger",
+  "de-de": "ger",
+  "de-DE": "ger",
+  "de-at": "ger",
+  "de-AT": "ger",
+  // Italian variants
+  it: "ita",
+  "it-it": "ita",
+  "it-IT": "ita",
+  // Portuguese variants
+  pt: "por",
+  "pt-br": "por",
+  "pt-BR": "por",
+  "pt-pt": "por",
+  "pt-PT": "por",
+  // Russian variants
+  ru: "rus",
+  "ru-ru": "rus",
+  "ru-RU": "rus",
+  // Japanese variants
+  ja: "jpn",
+  "ja-jp": "jpn",
+  "ja-JP": "jpn",
+  // Korean variants
+  ko: "kor",
+  "ko-kr": "kor",
+  "ko-KR": "kor",
+  // Chinese variants
+  zh: "chi",
+  "zh-cn": "chi",
+  "zh-CN": "chi",
+  "zh-tw": "chi",
+  "zh-TW": "chi",
+  "zh-hk": "chi",
+  "zh-HK": "chi"
+}, normalizeToIsoLanguageCode = (code) => {
+  const normalizedCode = code.toLowerCase();
+  return LOCALE_TO_ISO[normalizedCode];
+}, wistiaCaptionTransform = {
+  matcher: {
+    fieldName: "wistiaCaptions"
+  },
+  toTranslatable: (wistiaCaptions, context) => {
+    if (devLog.info("Wistia captions toTranslatable - input:", {
+      fieldPath: context.fieldPath,
+      hasCaptionContent: !!wistiaCaptions?.captionContent,
+      captionContentLength: wistiaCaptions?.captionContent?.length ?? 0,
+      isoLanguage: wistiaCaptions?.isoLanguage
+    }), !wistiaCaptions || !wistiaCaptions.captionContent)
+      return devLog.debug("Wistia caption field is missing or has no content, returning empty transform", {
+        fieldPath: context.fieldPath,
+        value: wistiaCaptions
+      }), {
+        _type: "translatable.wistia.captions",
+        translationText: "",
+        _originalMetadata: {
+          captionFileName: wistiaCaptions?.captionFileName,
+          isoLanguage: wistiaCaptions?.isoLanguage,
+          captionUploadStatus: wistiaCaptions?.captionUploadStatus,
+          captionUploadMessage: wistiaCaptions?.captionUploadMessage,
+          _originalIndex: 0
+        },
+        _srtCues: []
+      };
+    devLog.info("Applying Wistia caption transform", {
+      fieldPath: context.fieldPath,
+      captionContentPreview: wistiaCaptions.captionContent.substring(0, 200)
+    });
+    const srtCues = parseSRTContent(wistiaCaptions.captionContent);
+    devLog.debug("Parsed SRT cues:", {
+      fieldPath: context.fieldPath,
+      cueCount: srtCues.length,
+      firstCue: srtCues.length > 0 ? srtCues[0] : null
+    });
+    const translationText = serializeWistiaCaptionText(srtCues), originalMetadata = {
+      captionFileName: wistiaCaptions.captionFileName,
+      isoLanguage: wistiaCaptions.isoLanguage,
+      captionUploadStatus: wistiaCaptions.captionUploadStatus,
+      captionUploadMessage: wistiaCaptions.captionUploadMessage,
+      _originalIndex: 0
+    }, srtCuesMetadata = srtCues.map((cue) => ({
+      index: cue.index,
+      startTime: cue.startTime,
+      endTime: cue.endTime
+    }));
+    return devLog.info("Wistia captions serialized:", {
+      fieldPath: context.fieldPath,
+      translationTextLength: translationText.length,
+      translationTextPreview: translationText.substring(0, 200) + (translationText.length > 200 ? "..." : ""),
+      cueCount: srtCues.length
+    }), {
+      _type: "translatable.wistia.captions",
+      translationText,
+      _originalMetadata: originalMetadata,
+      _srtCues: srtCuesMetadata
+    };
+  },
+  fromTranslatable: (translatedValue, originalValue, context) => {
+    if (devLog.info("Wistia captions fromTranslatable - input:", {
+      fieldPath: context.fieldPath,
+      valueType: typeof translatedValue,
+      isCorrectType: translatedValue._type === "translatable.wistia.captions",
+      hasText: !!translatedValue.translationText,
+      hasMetadata: !!translatedValue._originalMetadata,
+      hasCues: Array.isArray(translatedValue._srtCues)
+    }), !translatedValue || translatedValue._type !== "translatable.wistia.captions" || !translatedValue._originalMetadata || !Array.isArray(translatedValue._srtCues))
+      return devLog.debug("Value is not a translatable Wistia caption object, returning original", {
+        fieldPath: context.fieldPath,
+        valueType: typeof translatedValue,
+        translatedValue
+      }), originalValue || {};
+    devLog.info("Processing translated Wistia captions", {
+      fieldPath: context.fieldPath,
+      cueCount: translatedValue._srtCues.length
+    });
+    const { translationText, _originalMetadata, _srtCues } = translatedValue;
+    devLog.info("Wistia captions translationText:", {
+      fieldPath: context.fieldPath,
+      translationTextLength: translationText.length,
+      translationTextPreview: translationText.substring(0, 200) + (translationText.length > 200 ? "..." : "")
+    });
+    const reconstructedCaptionContent = deserializeWistiaCaptionText(translationText, _srtCues), documentLanguage = getDocumentLanguage(context.document);
+    let updatedIsoLanguage = _originalMetadata.isoLanguage;
+    if (documentLanguage) {
+      const isoCode = normalizeToIsoLanguageCode(documentLanguage);
+      isoCode ? (updatedIsoLanguage = isoCode, devLog.debug("Updated isoLanguage based on document language", {
+        fieldPath: context.fieldPath,
+        documentLanguage,
+        isoCode
+      })) : devLog.debug("Could not convert document language to ISO code, preserving original", {
+        fieldPath: context.fieldPath,
+        documentLanguage,
+        originalIsoLanguage: _originalMetadata.isoLanguage
+      });
+    } else
+      devLog.debug("Document language field not found, preserving original isoLanguage", {
+        fieldPath: context.fieldPath,
+        originalIsoLanguage: _originalMetadata.isoLanguage
+      });
+    const result = {
+      captionContent: reconstructedCaptionContent,
+      captionFileName: _originalMetadata.captionFileName,
+      isoLanguage: updatedIsoLanguage,
+      captionUploadStatus: _originalMetadata.captionUploadStatus,
+      captionUploadMessage: _originalMetadata.captionUploadMessage
+    };
+    return devLog.info("Wistia captions final result:", {
+      fieldPath: context.fieldPath,
+      hasCaptionContent: !!result.captionContent,
+      captionContentLength: result.captionContent?.length ?? 0,
+      isoLanguage: result.isoLanguage
+    }), result;
+  }
+};
+function parseSRTContent(content) {
+  if (devLog.debug("parseSRTContent - input:", {
+    contentLength: content.length,
+    contentPreview: content.substring(0, 100) + (content.length > 100 ? "..." : "")
+  }), !content || content.trim() === "")
+    return [];
+  let normalizedContent = content;
+  content.includes("\\n") && !content.includes(`
+`) && (normalizedContent = content.replace(/\\n/g, `
+`), devLog.debug("Unescaped newlines in SRT content", {
+    originalLength: content.length,
+    normalizedLength: normalizedContent.length
+  }));
+  const cues = [], cueBlocks = normalizedContent.split(/\n\s*\n/);
+  for (const block of cueBlocks) {
+    const lines = block.trim().split(`
+`);
+    if (lines.length < 3)
+      continue;
+    const cueNumber = Number.parseInt(lines[0].trim(), 10);
+    if (Number.isNaN(cueNumber)) {
+      devLog.warn("Invalid SRT cue number", { line: lines[0] });
+      continue;
+    }
+    const timestampLine = lines[1].trim(), timestampMatch = timestampLine.match(/^(\d{2}:\d{2}:\d{2}[,.]\d{3})\s*-->\s*(\d{2}:\d{2}:\d{2}[,.]\d{3})$/);
+    if (!timestampMatch) {
+      devLog.warn("Invalid SRT timestamp format", { line: timestampLine });
+      continue;
+    }
+    const startTime = timestampMatch[1].replace(".", ","), endTime = timestampMatch[2].replace(".", ","), text = lines.slice(2).join(`
+`).trim();
+    text && cues.push({
+      index: cueNumber,
+      startTime,
+      endTime,
+      text
+    });
+  }
+  return devLog.debug("parseSRTContent - output:", {
+    cueCount: cues.length,
+    firstCue: cues.length > 0 ? cues[0] : null
+  }), cues;
+}
+function serializeWistiaCaptionText(cues) {
+  if (devLog.debug("serializeWistiaCaptionText - input:", {
+    cuesCount: cues.length,
+    firstCue: cues.length > 0 ? cues[0] : null
+  }), !Array.isArray(cues) || cues.length === 0)
+    return "";
+  const result = cues.map((cue) => {
+    devLog.debug(`Processing cue ${cue.index}:`, {
+      text: cue.text,
+      hasText: typeof cue.text == "string"
+    });
+    const escapedText = cue.text.replace(/\n/g, "\\n");
+    return `[${cue.index}] ${escapedText}`;
+  }).join(`
+`);
+  return devLog.debug("serializeWistiaCaptionText - output:", {
+    resultLength: result.length,
+    resultPreview: result.substring(0, 100) + (result.length > 100 ? "..." : "")
+  }), result;
+}
+function deserializeWistiaCaptionText(translationText, srtCuesMetadata) {
+  if (devLog.debug("deserializeWistiaCaptionText - input:", {
+    translationTextLength: translationText.length,
+    translationTextPreview: translationText.substring(0, 100) + (translationText.length > 100 ? "..." : ""),
+    metadataCount: srtCuesMetadata.length,
+    metadataExample: srtCuesMetadata.length > 0 ? srtCuesMetadata[0] : null
+  }), !translationText || translationText.trim() === "")
+    return "";
+  const result = [], lines = translationText.split(`
+`), lineRegex = /^\[(\d+)\]\s*(.*)$/, metadataByIndex = /* @__PURE__ */ new Map();
+  for (const metadata of srtCuesMetadata)
+    metadataByIndex.set(metadata.index, { startTime: metadata.startTime, endTime: metadata.endTime });
+  let currentIndex = null, currentTextParts = [];
+  for (const line of lines) {
+    const match = line.match(lineRegex);
+    if (match) {
+      if (currentIndex !== null) {
+        const text = currentTextParts.join(`
+`).replace(/\\n/g, `
+`), metadata = metadataByIndex.get(currentIndex);
+        metadata ? (result.push(`${currentIndex}`), result.push(`${metadata.startTime} --> ${metadata.endTime}`), result.push(text), result.push("")) : devLog.warn("Missing metadata for caption", { index: currentIndex });
+      }
+      currentIndex = Number.parseInt(match[1], 10), currentTextParts = [match[2]];
+    } else currentIndex !== null ? currentTextParts.push(line) : devLog.warn("Failed to parse caption line", { line });
+  }
+  if (currentIndex !== null) {
+    const text = currentTextParts.join(`
+`).replace(/\\n/g, `
+`), metadata = metadataByIndex.get(currentIndex);
+    metadata ? (result.push(`${currentIndex}`), result.push(`${metadata.startTime} --> ${metadata.endTime}`), result.push(text), result.push("")) : devLog.warn("Missing metadata for caption", { index: currentIndex });
+  }
+  result.length > 0 && result[result.length - 1] === "" && result.pop();
+  const reconstructed = result.join(`
+`);
+  return devLog.debug("deserializeWistiaCaptionText - output:", {
+    resultLength: reconstructed.length,
+    resultPreview: reconstructed.substring(0, 200) + (reconstructed.length > 200 ? "..." : "")
+  }), reconstructed;
+}
+function getDocumentLanguage(document) {
+  if (!document || typeof document != "object")
+    return;
+  const languageFieldNames = ["language", "lang", "locale"];
+  for (const fieldName of languageFieldNames)
+    if (fieldName in document && typeof document[fieldName] == "string")
+      return document[fieldName];
+}
 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)]
+    actions: [getTranslateAction(config)]
   },
   schema: {
     types: [translationSettings, translationGlossaryTerm]
@@ -4236,6 +4362,7 @@ export {
   restoreExcludedFields,
   richTextTransform,
   translationHistorySchema,
-  vttCaptionTransform
+  vttCaptionTransform,
+  wistiaCaptionTransform
 };
 //# sourceMappingURL=index.js.map