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

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, 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,63 @@ const isLoggingEnabled = () => process.env.NEXT_PUBLIC_SANITY_STUDIO_AI_TRANSLAT
       error: error instanceof Error ? error.message : "Network error"
     };
   }
+}, 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 = `${job._id}_${job.language}`, existingJob = entry.state.translationJobs.get(jobKey), mergedJob = existingJob ? { ...existingJob, ...job } : job;
+    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: [],
   translationMetadata: null,
   translationMode: "sanity-only",
   openaiValidated: !1,
+  releaseConfig: {
+    mode: "new",
+    newReleaseTitle: ""
+  },
   dispatch: () => {
   }
 }), translationReducer = (context, action) => {
@@ -85,7 +129,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,11 +160,6 @@ const isLoggingEnabled = () => process.env.NEXT_PUBLIC_SANITY_STUDIO_AI_TRANSLAT
         ...context,
         maxReferenceDepth: action.payload
       };
-    case "SET_SHOULD_OVERWRITE_FRESH_TRANSLATIONS":
-      return {
-        ...context,
-        shouldOverwriteFreshTranslations: action.payload
-      };
     case "SET_REFERENCES":
       return {
         ...context,
@@ -133,31 +172,82 @@ const isLoggingEnabled = () => process.env.NEXT_PUBLIC_SANITY_STUDIO_AI_TRANSLAT
         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(),
+        // 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(),
+    // 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);
   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 {
@@ -196,1043 +286,128 @@ 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
-  });
-  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
-  };
-};
-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({
+}, getExistingTranslationId = (translationMetadata, targetLanguage) => translationMetadata?.translations?.length && translationMetadata.translations.find(
+  (translation) => translation._key === targetLanguage
+)?.value._ref || null, undraftId = (id) => id.replace(/^drafts\./, ""), TRANSLATION_METADATA_TYPE = "translation.metadata", getTranslationMetadata = 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) {
+  sourceDocument,
+  sourceLanguage
+}) => {
   try {
-    const response = await client.agent.action.prompt({
-      instruction: prompt,
-      format: "json"
+    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: []
     });
-    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"}`);
-  }
-}
-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");
-  }
-}
-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 (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));
+    throw console.error(sourceDocument._id, "Error creating translation metadata:", error), error;
   }
-  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(
+}, 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,
-    settingsId,
-    targetLanguage,
-    suggestions.filter((s) => s.approved)
-  );
-}
-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();
-  }
-  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();
-    }
-  }
-  devLog.info("Prompts updated successfully", {
-    targetLanguage,
-    globalUpdated: globalPrompts.length > 0,
-    localeUpdated: localePrompts.length > 0
+    sourceDocument: document,
+    sourceLanguage
   });
-}
-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 }));
-}
-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
-          }
-        ]
-      });
+  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
+      }));
+    }
   }
-  devLog.info("Glossary terms processed", {
-    processed: validTerms.length,
-    skipped: terms.length - validTerms.length
-  });
-}
-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();
-}
-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
+  return conflicts;
+}, checkReleaseConflicts = async ({
+  client,
+  releaseId,
+  sourceDocument,
+  targetLanguages,
+  languageFieldName,
+  references = []
 }) => {
-  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);
-  };
-  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,
+  const allConflicts = [];
+  try {
+    const documentsToCheck = [
       {
-        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");
-    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,
-          {
-            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
-          }
-        )
-      ] }) }),
-      /* @__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"
-        }
+        _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
+        })
       )
-    ] })
-  ] });
-}, getGiveTranslationFeedbackAction = (config) => ({ draft, published }) => {
-  const document = draft ?? published, [isDialogOpen, setIsDialogOpen] = useState(!1);
-  return devLog.debug("ImproveTranslationPromptsAction initialized", {
-    documentId: document?._id,
-    documentType: document?._type
-  }), !document || !config.translatableSchemaTypes?.includes(document._type) ? (devLog.warn("Document not in translatable schema types", {
-    documentType: document?._type,
-    translatableTypes: config.translatableSchemaTypes
-  }), null) : config ? {
-    label: "Give Translation Feedback",
-    icon: TranslateIcon,
-    onHandle: () => {
-      devLog.info("Give Translation Feedback dialog opened", {
-        documentId: document._id,
-        documentType: document._type,
-        component: "GiveTranslationFeedbackAction"
-      }), setIsDialogOpen(!0);
-    },
-    dialog: isDialogOpen && {
-      type: "dialog",
-      onClose: () => setIsDialogOpen(!1),
-      header: "Give Translation Feedback",
-      content: /* @__PURE__ */ jsx(TranslationContextProvider, { document, config, children: /* @__PURE__ */ jsx(GiveFeedbackDialog, { setIsDialogOpen }) })
-    }
-  } : (devLog.error("Missing config in TranslateAction"), null);
+    );
+    for (const conflicts of conflictChecks)
+      allConflicts.push(...conflicts);
+    devLog.debug("Release conflict check complete", {
+      releaseId,
+      documentsChecked: documentsToCheck.length,
+      conflictsFound: allConflicts.length
+    });
+  } catch (error) {
+    devLog.error("Error checking release conflicts", error instanceof Error ? error : new Error(String(error)), {
+      releaseId,
+      sourceDocumentId: sourceDocument._id,
+      targetLanguages,
+      referencesCount: references.length
+    });
+  }
+  return allConflicts;
 };
 class Semaphore {
   permits;
@@ -1409,11 +584,21 @@ const fetchTranslationPrompts = async ({
   const sourceDocumentString = documentToPlainText(sourceDocument), translationSettings2 = await client.fetch(
     `*[_id == "translation-settings"][0] {
       globalPrompt,
-      localePrompts[locale in $targetLanguages],
+      localePrompts[_key in $targetLanguages],
       protectedPhrases
     }`,
     { targetLanguages }
-  ), translationGlossaryTerms = await client.fetch(
+  );
+  devLog.debug("Fetched translation settings", {
+    hasSettings: !!translationSettings2,
+    hasGlobalPrompt: !!translationSettings2?.globalPrompt,
+    globalPromptLength: translationSettings2?.globalPrompt?.length,
+    localePromptsCount: translationSettings2?.localePrompts?.length,
+    localePrompts: translationSettings2?.localePrompts,
+    protectedPhrasesCount: translationSettings2?.protectedPhrases?.length,
+    targetLanguages
+  });
+  const translationGlossaryTerms = await client.fetch(
     `*[
         _type == "translationGlossaryTerm"
         && count(translations[_key in $targetLanguages]) > 0
@@ -1433,9 +618,21 @@ const fetchTranslationPrompts = async ({
     )), glossaryTermsByLocale[targetLanguage] = relevantTranslations;
   }
   let filteredProtectedPhrases = translationSettings2?.protectedPhrases;
-  return sourceDocument && filteredProtectedPhrases && (filteredProtectedPhrases = filteredProtectedPhrases.filter(
-    (phrase) => protectedPhraseAppearsInDocument(phrase, sourceDocumentString)
-  )), {
+  return sourceDocument && filteredProtectedPhrases && (devLog.debug("Filtering protected phrases", {
+    totalPhrases: filteredProtectedPhrases.length,
+    phrases: filteredProtectedPhrases,
+    sourceDocumentStringLength: sourceDocumentString.length,
+    sourceDocumentPreview: sourceDocumentString.substring(0, 500)
+  }), filteredProtectedPhrases = filteredProtectedPhrases.filter((phrase) => {
+    const appears = protectedPhraseAppearsInDocument(phrase, sourceDocumentString);
+    return devLog.debug("Protected phrase match result", {
+      phrase,
+      appears
+    }), appears;
+  }), devLog.debug("Filtered protected phrases result", {
+    remainingCount: filteredProtectedPhrases.length,
+    remainingPhrases: filteredProtectedPhrases
+  })), {
     globalPrompt: translationSettings2?.globalPrompt,
     protectedPhrases: filteredProtectedPhrases,
     localeInstructions: Object.fromEntries(
@@ -1568,7 +765,7 @@ const fetchTranslationPrompts = async ({
     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 = {
@@ -1581,44 +778,8 @@ const fetchTranslationPrompts = async ({
       dispatch({
         type: "SET_TRANSLATION_JOB_STATUS",
         payload
-      });
+      }), mainSourceDocumentId && updateActiveTranslationJob(mainSourceDocumentId, payload);
     }
-}, 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,
@@ -1665,15 +826,156 @@ const fetchTranslationPrompts = async ({
       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) {
+    if (fieldPath === pattern)
+      return !0;
+    if (pattern.startsWith("**.")) {
+      const fieldName = pattern.substring(3), segments = fieldPath.split(".");
+      if (segments[segments.length - 1]?.split("[")[0] === fieldName)
+        return !0;
+    } else if (!pattern.includes(".") && !pattern.includes("[")) {
+      const segments = fieldPath.split(".");
+      if (segments[segments.length - 1]?.split("[")[0] === pattern)
+        return !0;
+    } else if (pattern.includes("[*]")) {
+      const regexPattern = pattern.replace(/\[/g, "\\[").replace(/\]/g, "\\]").replace(/\\\[\*\\\]/g, "\\[\\d+\\]");
+      if (new RegExp(`^${regexPattern}$`).test(fieldPath))
+        return !0;
+    }
+  }
+  return !1;
+}
+function filterExcludedFields(document, excludeFields = [], currentPath = "") {
+  if (!excludeFields.length)
+    return {
+      filteredDocument: document,
+      excludedValues: {}
+    };
+  const filteredDocument = {}, excludedValues = {};
+  let hasExclusions = !1;
+  for (const [key, value] of Object.entries(document)) {
+    const fieldPath = currentPath ? `${currentPath}.${key}` : key;
+    if (shouldExcludeField(fieldPath, excludeFields)) {
+      excludedValues[fieldPath] = value, hasExclusions = !0, devLog.debug("Excluding field from translation", {
+        fieldPath,
+        fieldType: typeof value,
+        value: typeof value == "string" ? value : "[object]"
+      });
+      continue;
+    }
+    if (value && typeof value == "object" && !Array.isArray(value) && value._type !== "reference") {
+      const nested = filterExcludedFields(value, excludeFields, fieldPath);
+      filteredDocument[key] = nested.filteredDocument, Object.assign(excludedValues, nested.excludedValues), Object.keys(nested.excludedValues).length > 0 && (hasExclusions = !0);
+    } else if (Array.isArray(value)) {
+      const filteredArray = [];
+      let arrayHasExclusions = !1;
+      for (let i = 0; i < value.length; i++) {
+        const arrayItem = value[i], itemPath = `${fieldPath}[${i}]`;
+        if (arrayItem && typeof arrayItem == "object" && !Array.isArray(arrayItem) && arrayItem._type !== "reference") {
+          const nested = filterExcludedFields(arrayItem, excludeFields, itemPath);
+          filteredArray[i] = nested.filteredDocument, Object.assign(excludedValues, nested.excludedValues), Object.keys(nested.excludedValues).length > 0 && (arrayHasExclusions = !0);
+        } else
+          filteredArray[i] = arrayItem;
+      }
+      filteredDocument[key] = filteredArray, arrayHasExclusions && (hasExclusions = !0);
+    } else
+      filteredDocument[key] = value;
+  }
+  return hasExclusions && devLog.info("Filtered excluded fields from document", {
+    documentId: document._id || "unknown",
+    excludedFieldCount: Object.keys(excludedValues).length,
+    excludedFields: Object.keys(excludedValues)
+  }), {
+    filteredDocument,
+    excludedValues
+  };
+}
+function restoreExcludedFields(translatedDocument, excludedValues) {
+  if (!Object.keys(excludedValues).length)
+    return translatedDocument;
+  const result = { ...translatedDocument };
+  for (const [fieldPath, value] of Object.entries(excludedValues))
+    setNestedValue(result, fieldPath, value);
+  return devLog.debug("Restored excluded fields to translated document", {
+    documentId: result._id || "unknown",
+    restoredFieldCount: Object.keys(excludedValues).length,
+    restoredFields: Object.keys(excludedValues)
+  }), result;
+}
+function setNestedValue(obj, path, value) {
+  const segments = path.split(".");
+  let current = obj;
+  for (let i = 0; i < segments.length - 1; i++) {
+    const segment = segments[i], arrayMatch2 = segment.match(/^(.+)\[(\d+)\]$/);
+    if (arrayMatch2) {
+      const [, fieldName, indexStr] = arrayMatch2, index = Number.parseInt(indexStr, 10);
+      for ((!(fieldName in current) || !Array.isArray(current[fieldName])) && (current[fieldName] = []); current[fieldName].length <= index; )
+        current[fieldName].push({});
+      current = current[fieldName][index];
+    } else
+      (!(segment in current) || typeof current[segment] != "object") && (current[segment] = {}), current = current[segment];
+  }
+  const finalSegment = segments[segments.length - 1], arrayMatch = finalSegment.match(/^(.+)\[(\d+)\]$/);
+  if (arrayMatch) {
+    const [, fieldName, indexStr] = arrayMatch, index = Number.parseInt(indexStr, 10);
+    for ((!(fieldName in current) || !Array.isArray(current[fieldName])) && (current[fieldName] = []); current[fieldName].length <= index; )
+      current[fieldName].push(null);
+    current[fieldName][index] = value;
+  } else
+    current[finalSegment] = value;
+}
+const COMMON_ENUM_FIELDS = [
+  "status",
+  "state",
+  "type",
+  "category",
+  "priority",
+  "visibility",
+  "role",
+  "permission",
+  "level",
+  "mode",
+  "format",
+  "variant",
+  "size",
+  "theme",
+  "kind",
+  "phase",
+  "stage"
+], PREDEFINED_EXCLUSIONS = {
+  /** Common enum and status fields */
+  enums: [...COMMON_ENUM_FIELDS],
+  /** All metadata and system fields (starting with _) */
+  metadata: ["_id", "_type", "_rev", "_createdAt", "_updatedAt"],
+  /** Common technical and configuration fields */
+  technical: [
+    "slug",
+    "handle",
+    "key",
+    "code",
+    "id",
+    "uuid",
+    "token",
+    "hash",
+    "checksum",
+    "version",
+    "config",
+    "settings"
+  ],
+  /** SEO and URL-related fields that often shouldn't be translated */
+  seo: ["slug", "handle", "permalink", "canonical", "redirect", "robots", "sitemap"]
 };
 function applyTransforms({
   document,
@@ -1837,9 +1139,10 @@ class TransformRegistry {
     }), matches[0];
   }
 }
-const globalTransformRegistry = new TransformRegistry(), callGPT5 = async (apiKey, request) => (request.model || "gpt-5") === "gpt-5" ? await callGPT5ResponsesAPI(apiKey, request) : await callChatCompletionsAPI(apiKey, request), callGPT5ResponsesAPI = async (apiKey, request) => {
+const globalTransformRegistry = new TransformRegistry(), callGPT5 = async (apiKey, request) => (request.model || "gpt-5").startsWith("gpt-5") ? await callGPT5ResponsesAPI(apiKey, request) : await callChatCompletionsAPI(apiKey, request), callGPT5ResponsesAPI = async (apiKey, request) => {
   const model = request.model || "gpt-5", requestBody = {
-    model: "gpt-5.1",
+    model: model === "gpt-5" ? "gpt-5.1" : model,
+    // Map gpt-5 to gpt-5.1, use others as-is
     input: request.messages
     // Uses 'input' instead of 'messages'
   };
@@ -1847,6 +1150,16 @@ const globalTransformRegistry = new TransformRegistry(), callGPT5 = async (apiKe
     effort: request.reasoningEffort,
     summary: "auto"
     // Enable automatic reasoning summaries
+  }), devLog.debug("OpenAI GPT-5 Request", {
+    model: requestBody.model,
+    reasoningEffort: request.reasoningEffort,
+    messages: request.messages.map((m) => ({
+      role: m.role,
+      contentLength: m.content.length,
+      contentPreview: m.content.substring(0, 500) + (m.content.length > 500 ? "..." : "")
+    }))
+  }), devLog.debug("OpenAI GPT-5 Full Prompt", {
+    messages: request.messages
   });
   const response = await fetch("https://api.openai.com/v1/responses", {
     method: "POST",
@@ -1864,7 +1177,8 @@ const globalTransformRegistry = new TransformRegistry(), callGPT5 = async (apiKe
     prompt: result.usage?.input_tokens || 0,
     completion: result.usage?.output_tokens || 0,
     reasoning: result.usage?.output_tokens_details?.reasoning_tokens || 0,
-    total: result.usage?.total_tokens || 0
+    total: result.usage?.total_tokens || 0,
+    cached: result.usage?.input_tokens_details?.cached_tokens || 0
   }, cost = calculateCost(tokensUsed, model);
   let content = "";
   if (result.output && Array.isArray(result.output)) {
@@ -1881,7 +1195,19 @@ const globalTransformRegistry = new TransformRegistry(), callGPT5 = async (apiKe
     model,
     messages: request.messages,
     temperature: request.temperature ?? 0.3
-  }, response = await fetch("https://api.openai.com/v1/chat/completions", {
+  };
+  devLog.debug("OpenAI Chat Completions Request", {
+    model,
+    temperature: request.temperature ?? 0.3,
+    messages: request.messages.map((m) => ({
+      role: m.role,
+      contentLength: m.content.length,
+      contentPreview: m.content.substring(0, 500) + (m.content.length > 500 ? "..." : "")
+    }))
+  }), devLog.debug("OpenAI Chat Completions Full Prompt", {
+    messages: request.messages
+  });
+  const response = await fetch("https://api.openai.com/v1/chat/completions", {
     method: "POST",
     headers: {
       "Content-Type": "application/json",
@@ -1897,7 +1223,8 @@ const globalTransformRegistry = new TransformRegistry(), callGPT5 = async (apiKe
     prompt: usage.prompt_tokens || 0,
     completion: usage.completion_tokens || 0,
     reasoning: usage.reasoning_tokens || 0,
-    total: usage.total_tokens || 0
+    total: usage.total_tokens || 0,
+    cached: usage.prompt_tokens_details?.cached_tokens || 0
   }, cost = calculateCost(tokensUsed, model);
   return {
     content: result.choices[0].message.content || "",
@@ -1907,27 +1234,47 @@ const globalTransformRegistry = new TransformRegistry(), callGPT5 = async (apiKe
 }, calculateCost = (tokens, model) => {
   const pricing = {
     "gpt-5": {
-      input: 2e-6,
+      input: 125e-8,
+      output: 1e-5,
+      reasoning: 0
+    },
+    "gpt-5.1": {
+      input: 125e-8,
       output: 1e-5,
-      reasoning: 5e-6
+      reasoning: 0
+    },
+    "gpt-5-mini": {
+      input: 25e-8,
+      output: 2e-6,
+      reasoning: 0
+    },
+    "gpt-5-nano": {
+      input: 50000000000000004e-24,
+      output: 40000000000000003e-23,
+      reasoning: 0
+    },
+    "gpt-5-pro": {
+      input: 15e-6,
+      output: 12e-5,
+      reasoning: 0
     },
     "gpt-4o": {
-      input: 5e-6,
-      output: 14999999999999999e-21,
+      input: 25e-7,
+      output: 1e-5,
       reasoning: 0
     },
     "gpt-4-turbo": {
       input: 1e-5,
-      output: 29999999999999997e-21,
+      output: 3e-5,
       reasoning: 0
     },
     "gpt-4": {
-      input: 29999999999999997e-21,
-      output: 59999999999999995e-21,
+      input: 3e-5,
+      output: 6e-5,
       reasoning: 0
     }
-  }, modelPricing = pricing[model] || pricing["gpt-5"];
-  return tokens.prompt * modelPricing.input + tokens.completion * modelPricing.output + tokens.reasoning * modelPricing.reasoning;
+  }, 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);
   return applyTextChanges(result, parsed), result;
@@ -1943,7 +1290,7 @@ const globalTransformRegistry = new TransformRegistry(), callGPT5 = async (apiKe
         type: "field",
         name: fieldName,
         text: unescapeXml(text2),
-        attributes: {},
+        attributes: { type: "string" },
         children: []
       };
       if (stack.length > 0) {
@@ -2016,6 +1363,26 @@ const globalTransformRegistry = new TransformRegistry(), callGPT5 = async (apiKe
           parent && parent.children.push(node);
         } else
           root.push(node);
+      } else if (attributes.type === "string" && content && content.includes(closingTag))
+        if (node.text = unescapeXml(content.replace(closingTag, "")), stack.length > 0) {
+          const parent = stack[stack.length - 1];
+          parent && parent.children.push(node);
+        } else
+          root.push(node);
+      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;
@@ -2072,7 +1439,10 @@ const globalTransformRegistry = new TransformRegistry(), callGPT5 = async (apiKe
     });
     return;
   }
-  node.text !== void 0 && !node.attributes.readonly && set(doc, path, node.text);
+  node.text !== void 0 && !node.attributes.readonly && (get(doc, path) !== void 0 ? set(doc, path, node.text) : devLog.debug("Skipping field not present in original document", {
+    path: path.join("."),
+    attemptedValue: node.text
+  }));
 }, applyBlockChanges = (block, blockNode) => {
   if (blockNode.attributes._key && block._key !== blockNode.attributes._key) {
     devLog.warn("Block key mismatch, skipping", {
@@ -2103,7 +1473,10 @@ const globalTransformRegistry = new TransformRegistry(), callGPT5 = async (apiKe
     });
     return;
   }
-  fieldNode.text !== void 0 && !fieldNode.attributes.readonly && (block[fieldName] = fieldNode.text);
+  fieldNode.text !== void 0 && !fieldNode.attributes.readonly && (fieldName in block ? block[fieldName] = fieldNode.text : devLog.debug("Skipping block field not present in original", {
+    fieldName,
+    attemptedValue: fieldNode.text
+  }));
 }, applySpanChanges = (span, spanNode) => {
   if (spanNode.attributes._key && span._key !== spanNode.attributes._key) {
     devLog.warn("Span key mismatch, skipping", {
@@ -2148,7 +1521,7 @@ const globalTransformRegistry = new TransformRegistry(), callGPT5 = async (apiKe
       return;
     }
     if (typeof value == "string") {
-      value.length > 0 && lines.push(`${fieldName}: ${escapeXml(value)}`);
+      value.length > 0 && lines.push(`${indentStr}<field name="${fieldName}" type="string">${escapeXml(value)}</field>`);
       return;
     }
     (typeof value == "number" || typeof value == "boolean") && lines.push(`${indentStr}<field name="${fieldName}" type="${typeof value}" readonly="true">${value}</field>`);
@@ -2185,7 +1558,7 @@ const globalTransformRegistry = new TransformRegistry(), callGPT5 = async (apiKe
     return;
   }
   if (typeof value == "string" && value.length > 0) {
-    lines.push(`${indentStr}<field name="${fieldName}">${escapeXml(value)}</field>`);
+    lines.push(`${indentStr}<field name="${fieldName}" type="string">${escapeXml(value)}</field>`);
     return;
   }
   (typeof value == "number" || typeof value == "boolean") && lines.push(`${indentStr}<field name="${fieldName}" type="${typeof value}" readonly="true">${value}</field>`);
@@ -2327,7 +1700,19 @@ const globalTransformRegistry = new TransformRegistry(), callGPT5 = async (apiKe
           `Structure validation failed: ${unexpectedErrors.length} errors. First: ${unexpectedErrors[0].type} at ${unexpectedErrors[0].path.join(".")}`
         );
     }
-    return setJobStatus(dispatch, sourceDocument._id, targetLanguage, "translating_with_openai", {
+    const translationValidation = validateTranslationCompleteness(sourceDocument, result, languageFieldName);
+    return translationValidation.valid || (devLog.warn("Translation completeness warning", {
+      ...logContext,
+      skippedFields: translationValidation.skippedFields,
+      warning: "GPT-5 may have skipped some important fields"
+    }), devLog.info("Skipped field details", {
+      ...logContext,
+      skippedFields: translationValidation.skippedFields.map((field) => ({
+        path: field.path,
+        originalValue: field.originalValue,
+        translatedValue: field.translatedValue
+      }))
+    })), setJobStatus(dispatch, sourceDocument._id, targetLanguage, "translating_with_openai", {
       tokensUsed: response.tokensUsed.total,
       estimatedCost: response.cost
     }), result;
@@ -2368,12 +1753,19 @@ ${sourceText}
 
 ## Instructions
 
-1. Translate all text content into ${targetLanguage}
-2. Follow the guidelines and terminology requirements above
-3. Preserve protected phrases exactly as they appear
-4. Return the document in THE EXACT SAME FORMAT
-5. **CRITICAL**: Only modify text content between tags
-6. Never add, remove, or change any tags, attributes, or structure
+1. **TRANSLATE ALL TEXT FIELDS**: Every field marked with type="string" or containing text must be translated
+2. **DO NOT SKIP SIMPLE FIELDS**: Pay special attention to simple fields like "title", "name", "description" - these are often the most important
+3. Follow the guidelines and terminology requirements above
+4. Preserve protected phrases exactly as they appear
+5. Return the document in THE EXACT SAME FORMAT
+6. **CRITICAL**: Only modify text content between tags
+7. Never add, remove, or change any tags, attributes, or structure
+
+**Common fields that must always be translated:**
+- title, name, heading, label
+- description, caption, alt text
+- All text within <field> tags
+- All text within <span> tags
 
 If you used significant reasoning to make translation decisions, you may include a brief summary:
 <reasoning>
@@ -2381,6 +1773,43 @@ Brief summary of key translation decisions and reasoning
 </reasoning>
 
 Then return the translated document:`;
+}, validateTranslationCompleteness = (sourceDoc, translatedDoc, languageFieldName) => {
+  const skippedFields = [], checkField = (source, translated, path = []) => {
+    if (path.length > 0) {
+      const fieldName = path[path.length - 1];
+      if (fieldName.startsWith("_") || fieldName === languageFieldName)
+        return;
+    }
+    if (typeof source == "string" && typeof translated == "string") {
+      if (source.length > 0 && source === translated) {
+        const fieldName = path[path.length - 1] || "unknown";
+        (["title", "name", "heading", "label", "description", "caption", "alt"].includes(
+          fieldName
+        ) || source.length > 10) && skippedFields.push({
+          path: path.join("."),
+          originalValue: source,
+          translatedValue: translated
+        });
+      }
+      return;
+    }
+    if (source && translated && typeof source == "object" && typeof translated == "object") {
+      if (Array.isArray(source) && Array.isArray(translated)) {
+        const maxLength = Math.min(source.length, translated.length);
+        for (let i = 0; i < maxLength; i++)
+          checkField(source[i], translated[i], [...path, String(i)]);
+      } else if (!Array.isArray(source) && !Array.isArray(translated))
+        for (const key of Object.keys(source))
+          !key.startsWith("_") && key !== languageFieldName && checkField(source[key], translated[key], [
+            ...path,
+            key
+          ]);
+    }
+  };
+  return checkField(sourceDoc, translatedDoc), {
+    valid: skippedFields.length === 0,
+    skippedFields
+  };
 }, assembleLanguageSpecs = ({
   sourceDocument,
   languageFieldName,
@@ -2501,22 +1930,55 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
   translationPrompts,
   translationMode,
   openaiConfig,
-  releaseId
+  releaseId,
+  excludeFields = [],
+  replaceExisting = !1,
+  mainSourceDocumentId
 }) => {
-  devLog.debug("Applying field transforms before translation", {
+  const safeExcludeFields = excludeFields.filter((field) => field !== languageFieldName);
+  excludeFields.length !== safeExcludeFields.length && devLog.warn("Language field was in excludeFields - removing it to prevent translation errors", {
     documentId: sourceDocument._id,
-    documentType: sourceDocument._type
+    languageFieldName,
+    originalExcludeFields: excludeFields,
+    safeExcludeFields
+  }), devLog.info("Filtering excluded fields before translation", {
+    documentId: sourceDocument._id,
+    documentType: sourceDocument._type,
+    excludeFields: safeExcludeFields,
+    excludeFieldsLength: safeExcludeFields?.length ?? 0,
+    sourceHasTitle: "title" in sourceDocument,
+    sourceTitleValue: sourceDocument.title
   });
-  const { transformedDocument, originalStructure } = applyTransforms({
-    document: sourceDocument,
-    registry: globalTransformRegistry,
-    schemaType: sourceDocument._type
+  const { filteredDocument, excludedValues } = filterExcludedFields(sourceDocument, safeExcludeFields);
+  devLog.info("After filtering excluded fields", {
+    documentId: sourceDocument._id,
+    filteredHasTitle: "title" in filteredDocument,
+    filteredTitleValue: filteredDocument.title,
+    excludedValuesKeys: Object.keys(excludedValues),
+    excludedValues
   });
+  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;
   switch (translationMode) {
     case "sanity-only": {
-      setJobStatus(dispatch, sourceDocument._id, targetLanguage, "translating"), translatedDoc = await getSanityAgentTranslation({
-        sourceDocument: transformedDocument,
+      setJobStatus(dispatch, sourceDocument._id, targetLanguage, "translating", void 0, mainSourceDocumentId), translatedDoc = await getSanityAgentTranslation({
+        sourceDocument: documentToTranslate,
         targetLanguage,
         languageFieldName,
         schemaId,
@@ -2528,9 +1990,16 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
     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({
+      setJobStatus(
+        dispatch,
+        sourceDocument._id,
+        targetLanguage,
+        "translating_with_openai",
+        void 0,
+        mainSourceDocumentId
+      ), translatedDoc = await getOpenAITranslation({
         dispatch,
-        sourceDocument: transformedDocument,
+        sourceDocument: documentToTranslate,
         targetLanguage,
         languageFieldName,
         translationPrompts,
@@ -2538,27 +2007,45 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
       });
       break;
     }
-    case "sanity-with-review":
-      throw new Error("Sanity with review translation method is not implemented");
     default:
       throw new Error(`Invalid translation mode: ${translationMode}`);
   }
   if (!translatedDoc)
     return null;
-  devLog.debug("Restoring field transforms after translation", {
+  let transformedResult;
+  Object.keys(originalStructure).length > 0 ? (devLog.debug("Restoring field transforms after translation", {
     documentId: sourceDocument._id,
     documentType: sourceDocument._type
-  });
-  const finalDoc = restoreTransforms({
+  }), transformedResult = restoreTransforms({
     translatedDocument: translatedDoc,
     originalStructure,
     registry: globalTransformRegistry,
     schemaType: sourceDocument._type
-  }), targetDocumentPublishedId = existingTranslationId || uuid(), targetDocumentVersionId = `versions.${releaseId}.${targetDocumentPublishedId}`, newDoc = {
+  })) : transformedResult = translatedDoc;
+  const excludedValuesToRestore = { ...excludedValues };
+  delete excludedValuesToRestore[languageFieldName], devLog.info("Before restoring excluded fields", {
+    documentId: sourceDocument._id,
+    excludedFieldCount: Object.keys(excludedValues).length,
+    excludedValuesKeys: Object.keys(excludedValues),
+    languageFieldExcluded: languageFieldName in excludedValues,
+    transformedResultHasTitle: "title" in transformedResult,
+    transformedResultTitle: transformedResult.title
+  });
+  const finalDoc = restoreExcludedFields(transformedResult, excludedValuesToRestore);
+  devLog.info("After restoring excluded fields", {
+    documentId: sourceDocument._id,
+    finalDocHasTitle: "title" in finalDoc,
+    finalDocTitle: finalDoc.title
+  });
+  const targetDocumentPublishedId = existingTranslationId || uuid(), targetDocumentVersionId = `versions.${releaseId}.${targetDocumentPublishedId}`, newDoc = {
     ...finalDoc,
     _id: targetDocumentVersionId
   };
-  return await client.action({
+  return replaceExisting && await client.getDocument(targetDocumentVersionId) && (devLog.info("Replacing existing version in release", {
+    documentId: sourceDocument._id,
+    targetDocumentVersionId,
+    releaseId
+  }), await client.delete(targetDocumentVersionId)), await client.action({
     actionType: "sanity.action.document.version.create",
     publishedId: targetDocumentPublishedId,
     document: newDoc
@@ -2570,36 +2057,28 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
   sourceLanguage,
   targetLanguage,
   languageFieldName,
-  shouldOverwriteFreshTranslations,
   schemaId,
   translationPrompts,
   translationMode,
   openaiConfig,
-  releaseId
+  releaseId,
+  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), newDocument = await handleTranslation({
+    }), existingTranslationId = getExistingTranslationId(translationMetadata, targetLanguage), newDocument = await handleTranslation({
       dispatch,
       client,
       schemaId,
@@ -2610,15 +2089,34 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
       translationPrompts,
       translationMode,
       openaiConfig,
-      releaseId
+      releaseId,
+      excludeFields,
+      replaceExisting,
+      mainSourceDocumentId
     });
     if (!newDocument) {
-      setJobStatus(dispatch, sourceDocument._id, targetLanguage, "error"), devLog.timeEnd("translateDocument"), devLog.groupEnd();
+      devLog.error("Translation failed: no document returned", new Error("Translation returned null"), logContext), setJobStatus(
+        dispatch,
+        sourceDocument._id,
+        targetLanguage,
+        "error",
+        {
+          errorMessage: "Translation failed"
+        },
+        mainSourceDocumentId
+      ), devLog.timeEnd("translateDocument"), devLog.groupEnd();
       return;
     }
-    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,
@@ -2626,17 +2124,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 ({
@@ -2645,12 +2157,13 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
   targetLanguages,
   dispatch,
   languageFieldName,
-  shouldOverwriteFreshTranslations,
   schemaId,
   references = [],
   maxConcurrentTranslationJobs,
   translationMode,
-  openaiConfig
+  openaiConfig,
+  excludeFields,
+  releaseConfig
 }) => {
   const logContext = {
     documentId: sourceDocument._id,
@@ -2659,28 +2172,36 @@ ${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 client.releases.create({
+        metadata: {
+          title: releaseTitle,
+          description: releaseDescription,
+          releaseType: "undecided"
+        }
+      })).releaseId, createdNewRelease = !0, devLog.info("Content Release created", {
+        ...logContext,
+        releaseId,
+        releaseTitle
+      });
+    }
+    registerActiveTranslation(sourceDocument._id, releaseId), updateActiveTranslationStatus(sourceDocument._id, "translating");
     const sourceDocuments = [
       {
         _id: sourceDocument._id,
@@ -2695,7 +2216,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 {
@@ -2703,7 +2224,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,
@@ -2711,12 +2232,15 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
                 sourceLanguage,
                 targetLanguage,
                 languageFieldName,
-                shouldOverwriteFreshTranslations,
                 schemaId,
                 translationPrompts,
                 translationMode,
                 openaiConfig,
-                releaseId: releaseId2
+                releaseId,
+                excludeFields,
+                replaceExisting: releaseConfig.replaceExisting,
+                // Pass main source document ID for active translations tracking
+                mainSourceDocumentId: sourceDocument._id
               });
               versionedTargetDocumentId && versionedTargetDocumentIds.push(versionedTargetDocumentId);
             }
@@ -2743,7 +2267,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,
@@ -2754,18 +2278,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,
@@ -2774,37 +2345,81 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
     dispatch,
     references,
     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);
+  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,
+        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,
+      config.languageFieldName,
+      config.schemaId,
+      config.maxConcurrentTranslationJobs,
+      config.maxReferenceDepth,
+      config.openai,
+      config.excludeFields,
       references,
-      shouldOverwriteFreshTranslations,
-      maxConcurrentTranslationJobs: config.maxConcurrentTranslationJobs,
-      maxReferenceDepth: config.maxReferenceDepth,
       translationMode,
-      openaiConfig: config.openai
-    });
-  }, [
-    document,
-    selectedTargetLanguages,
-    client,
-    dispatch,
-    config.languageFieldName,
-    config.schemaId,
-    config.maxConcurrentTranslationJobs,
-    config.maxReferenceDepth,
-    config.openai,
-    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
+      });
+      if (setIsCheckingConflicts(!1), foundConflicts.length > 0) {
+        setConflictContext({
+          releaseId: checkedReleaseId,
+          conflicts: foundConflicts
+        });
+        return;
+      }
+    }
+    startTranslation(!1);
+  }, [releaseConfig, client, document, selectedTargetLanguages, config.languageFieldName, startTranslation, references]), 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)
@@ -2815,7 +2430,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" })
@@ -2829,16 +2451,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({
@@ -2856,16 +2503,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 = () => {
@@ -2873,6 +2517,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)
@@ -2891,7 +2663,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(
@@ -2921,32 +2693,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: [
@@ -3109,41 +2862,7 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
     ] }),
     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." })
-          ] })
-        ] })
-      }
-    ) })
-  ] });
-}, 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, {})
@@ -3152,16 +2871,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 };
@@ -3183,7 +2905,7 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
             /* @__PURE__ */ jsxs(Code, { size: 1, children: [
               job._type,
               " \u2014 ",
-              job._id.slice(-6)
+              job._id?.slice(-6) || "unknown"
             ] }),
             !["completed", "skipped", "error"].includes(job.status) && /* @__PURE__ */ jsx(Text, { size: 1, weight: "semibold", children: getStatusLabel(job.status) }),
             job.status === "completed" && job.tokensUsed ? /* @__PURE__ */ jsxs(Text, { size: 1, muted: !0, children: [
@@ -3217,18 +2939,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);
@@ -3292,8 +3015,7 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
   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...",
   error: "Error",
   skipped: "Skipped",
@@ -3302,14 +3024,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
@@ -3317,7 +3055,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", {
@@ -3328,9 +3066,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({
@@ -3446,7 +3184,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",
@@ -3756,14 +3494,18 @@ const aiTranslationPlugin = definePlugin((config) => (config.fieldTransforms?.le
 })), {
   name: "sanity-plugin-ai-translation",
   document: {
-    actions: [getTranslateAction(config), getGiveTranslationFeedbackAction(config)]
+    actions: [getTranslateAction(config)]
   },
   schema: {
     types: [translationSettings, translationGlossaryTerm]
   }
 })), translationHistorySchema = translationHistory;
 export {
+  COMMON_ENUM_FIELDS,
+  PREDEFINED_EXCLUSIONS,
   aiTranslationPlugin,
+  filterExcludedFields,
+  restoreExcludedFields,
   richTextTransform,
   translationHistorySchema,
   vttCaptionTransform