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

package/dist/index.js

@@ -1,23 +1,27 @@
 import { useClient, defineType, defineField, pathToString, definePlugin } from "sanity";
 import { jsx, jsxs } from "react/jsx-runtime";
-import { ErrorOutlineIcon, CheckmarkCircleIcon, EmptyIcon, AddIcon, TrashIcon, ArrowLeftIcon, EditIcon, InfoOutlineIcon, TranslateIcon, CheckmarkIcon, CircleIcon, ArrowRightIcon, PanelRightIcon } from "@sanity/icons";
-import { createContext, useContext, useEffect, useState, useReducer, useMemo } from "react";
-import { Card, Flex, Stack, Text, Spinner, Button, Box, Checkbox, Select, TextInput, TextArea, Heading, Inline, Tooltip, Badge, Grid, Label, Code } from "@sanity/ui";
+import { ErrorOutlineIcon, CheckmarkCircleIcon, EmptyIcon, AddIcon, TrashIcon, WarningOutlineIcon, InfoOutlineIcon, ArrowLeftIcon, EditIcon, TranslateIcon, CheckmarkIcon, CircleIcon, ArrowRightIcon, PanelRightIcon } from "@sanity/icons";
+import { createContext, useContext, useEffect, useState, useReducer, useCallback, useMemo } from "react";
+import { Card, Flex, Stack, Text, Spinner, Button, Box, Tooltip, Checkbox, Select, TextInput, TextArea, Heading, Inline, Badge, Grid, Radio, Label, Code } from "@sanity/ui";
 import { useListeningQuery, useOpenInNewPane } from "sanity-plugin-utils";
 import defaults from "lodash.defaults";
-import { diffPatch } from "@sanity/diff-patch";
+import { toPlainText } from "@portabletext/react";
+import cloneDeep from "lodash.clonedeep";
+import get from "lodash.get";
+import set from "lodash.set";
 const TranslationContext = createContext({
   document: null,
   config: null,
   overallStatus: "idle",
   selectedTargetLanguages: [],
   translationJobs: /* @__PURE__ */ new Map(),
-  shouldTranslateDiffs: !1,
   shouldOverwriteFreshTranslations: !1,
   shouldTranslateReferences: !1,
   maxReferenceDepth: 1,
   references: [],
   translationMetadata: null,
+  translationMode: "sanity-only",
+  openaiValidated: !1,
   dispatch: () => {
   }
 }), useTranslationContext = () => {
@@ -27,7 +31,7 @@ const TranslationContext = createContext({
       "useTranslationContext must be used within a TranslationContextProvider with document and config props"
     );
   return context;
-}, TRANSLATION_METADATA_TYPE = "translation.metadata", UPDATE_EXISTING_TRANSLATION_PROMPT = "***IMPORTANT:** This document has an existing, but out-of-date translation. Please review the existing translation before processing and change as little as possible. Existing translation: $extantTranslation", undraftId = (id) => id.replace(/^drafts\./, ""), draftId = (id) => `drafts.${undraftId(id)}`, TRANSLATION_METADATA_QUERY = "*[_type == $translationMetadataType && references($documentId)][0]", useTranslationMetadata = ({ documentId }) => {
+}, TRANSLATION_METADATA_TYPE = "translation.metadata", undraftId = (id) => id.replace(/^drafts\./, ""), TRANSLATION_METADATA_QUERY = "*[_type == $translationMetadataType && references($documentId)][0]", useTranslationMetadata = ({ documentId }) => {
   const { dispatch } = useTranslationContext(), { data, loading, error } = useListeningQuery(TRANSLATION_METADATA_QUERY, {
     params: {
       documentId: undraftId(documentId),
@@ -80,6 +84,102 @@ const TranslationContext = createContext({
     isLoggingEnabled() && console.timeEnd(`[AI Translation] ${label}`);
   }
 };
+async function validateSuggestion(client, suggestion) {
+  return suggestion.type === "glossaryTerm" ? validateGlossaryTerm(client, suggestion) : suggestion.type === "protectedPhrase" ? validateProtectedPhrase(client, suggestion) : suggestion.type === "globalPrompt" || suggestion.type === "localePrompt" ? validatePrompt(suggestion) : { valid: !0, status: "valid" };
+}
+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,
@@ -107,8 +207,25 @@ async function analyzeFeedback({
     currentDocument
   }), analysis = await analyzeWithAI(client, analysisPrompt);
   devLog.info("AI analysis complete", { analysis });
-  const suggestions = convertAnalysisToSuggestions(analysis);
-  return devLog.info("Generated suggestions", { count: suggestions.length }), suggestions;
+  const suggestions = convertAnalysisToSuggestions(analysis, sourceLanguage, targetLanguage);
+  devLog.info("Generated suggestions", { count: suggestions.length }), 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("Suggestions validated", {
+    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({
   client,
@@ -216,11 +333,67 @@ function buildAnalysisPrompt({
     "",
     "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."
+    "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) {
+function convertAnalysisToSuggestions(analysis, sourceLanguage, targetLanguage) {
   const suggestions = [];
   if (analysis.globalPromptUpdates && suggestions.push({
     id: crypto.randomUUID(),
@@ -247,9 +420,10 @@ function convertAnalysisToSuggestions(analysis) {
         type: "glossaryTerm",
         description: `${term.sourceValue} \u2192 ${term.targetValue}`,
         approved: !0,
-        sourceLocale: term.sourceLocale,
+        // Use the provided source/target languages instead of relying on AI to provide them
+        sourceLocale: sourceLanguage,
         sourceValue: term.sourceValue,
-        targetLocale: term.targetLocale,
+        targetLocale: targetLanguage,
         targetValue: term.targetValue
       });
   return suggestions;
@@ -296,13 +470,35 @@ function parseAIResponse(responseText) {
   }
 }
 async function applyImprovementsFromSuggestions(client, schemaId, targetLanguage, suggestions, onProgress) {
-  devLog.info("Applying improvements from suggestions", { count: suggestions.length });
+  devLog.info("Applying improvements from suggestions", {
+    count: suggestions.length,
+    targetLanguage,
+    suggestions: suggestions.map((s) => ({
+      type: s.type,
+      approved: s.approved,
+      sourceLocale: s.sourceLocale,
+      targetLocale: s.targetLocale,
+      sourceValue: s.sourceValue,
+      targetValue: s.targetValue
+    }))
+  });
   const settingsId = "translation-settings";
   await client.fetch("*[_id == $id][0]", { id: settingsId }) || await client.createIfNotExists({
     _id: settingsId,
     _type: "translationSettings"
   });
-  const updates = [], globalPrompts = suggestions.filter((s) => s.type === "globalPrompt" && s.description.trim()), localePrompts = suggestions.filter((s) => s.type === "localePrompt" && s.description.trim()), protectedPhrases = suggestions.filter((s) => s.type === "protectedPhrase" && s.description.trim()), glossaryTerms = suggestions.filter(
+  const updates = [], globalPrompts = suggestions.filter((s) => s.type === "globalPrompt" && s.description.trim()), localePrompts = suggestions.filter((s) => s.type === "localePrompt" && s.description.trim()), protectedPhrases = suggestions.filter((s) => s.type === "protectedPhrase" && s.description.trim()), glossaryTermsBeforeFilter = suggestions.filter((s) => s.type === "glossaryTerm");
+  devLog.info("Glossary terms before filtering", {
+    count: glossaryTermsBeforeFilter.length,
+    terms: glossaryTermsBeforeFilter.map((s) => ({
+      sourceLocale: s.sourceLocale,
+      sourceValue: s.sourceValue,
+      targetLocale: s.targetLocale,
+      targetValue: s.targetValue,
+      approved: s.approved
+    }))
+  });
+  const glossaryTerms = suggestions.filter(
     (s) => s.type === "glossaryTerm" && s.sourceLocale?.trim() && s.sourceValue?.trim() && s.targetLocale?.trim() && s.targetValue?.trim()
   );
   if (devLog.info("Filtered suggestions by type", {
@@ -313,7 +509,7 @@ async function applyImprovementsFromSuggestions(client, schemaId, targetLanguage
   }), (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(updatePromptsWithTransform(client, schemaId, settingsId, targetLanguage, globalPrompts, localePrompts))), protectedPhrases.length > 0) {
+  }), updates.push(updatePromptsWithTemplate(client, schemaId, settingsId, targetLanguage, globalPrompts, localePrompts))), protectedPhrases.length > 0) {
     onProgress?.({ stage: "applying", message: "Adding protected phrases..." });
     const phrases = protectedPhrases.map((s) => s.description);
     devLog.debug("Applying protected phrases", { phrases }), updates.push(addProtectedPhrases(client, settingsId, phrases));
@@ -330,14 +526,17 @@ async function applyImprovementsFromSuggestions(client, schemaId, targetLanguage
     }));
     devLog.debug("Applying glossary terms", { terms }), updates.push(addGlossaryTerms(client, terms));
   }
-  updates.length === 0 && devLog.warn("No valid updates to apply - all suggestions may have been empty"), await Promise.all(updates), devLog.info("All improvements applied successfully");
+  updates.length === 0 && devLog.warn("No valid updates to apply - all suggestions may have been empty"), await Promise.all(updates), onProgress?.({ stage: "applying", message: "Recording changes..." }), await recordChangeHistory(
+    client,
+    settingsId,
+    targetLanguage,
+    suggestions.filter((s) => s.approved)
+  ), devLog.info("All improvements applied successfully");
 }
-async function updatePromptsWithTransform(client, schemaId, settingsId, targetLanguage, globalPrompts, localePrompts) {
-  if (devLog.info("Updating prompts with transform action", {
+async function updatePromptsWithTemplate(client, _schemaId, settingsId, targetLanguage, globalPrompts, localePrompts) {
+  if (devLog.info("Updating prompts with deterministic template", {
     settingsId,
     targetLanguage,
-    targetLanguageType: typeof targetLanguage,
-    targetLanguageValue: targetLanguage,
     hasGlobalUpdates: globalPrompts.length > 0,
     hasLocaleUpdates: localePrompts.length > 0
   }), !targetLanguage)
@@ -346,91 +545,56 @@ async function updatePromptsWithTransform(client, schemaId, settingsId, targetLa
       globalPrompts: globalPrompts.length,
       localePrompts: localePrompts.length
     }), new Error("targetLanguage is required but was undefined");
-  const targets = [];
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().split("T")[0], currentSettings = await client.fetch("*[_id == $settingsId][0]{ globalPrompt, localePrompts }", { settingsId });
   if (globalPrompts.length > 0) {
-    const combinedGlobalUpdate = globalPrompts.map((s) => s.description).join(`
-
+    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(`
 `);
-    targets.push({
-      path: "globalPrompt",
-      instruction: `You are updating a translation prompt document that contains rules and guidance for future AI translations.
-
-IMPORTANT: The text below is NEW GUIDANCE that should be INCORPORATED INTO the existing prompt as additional rules/instructions for future translations. DO NOT apply or execute these rules on the prompt text itself.
-
-Your task: Merge the new guidance below into the existing prompt text. Treat the new guidance as rules that will guide future translations, not as transformations to apply to the current text.
-
-Integration guidelines:
-- Add the new guidance as additional instructions/rules in the prompt
-- If it conflicts with existing guidance, update or replace the conflicting parts
-- If it's already covered, don't add redundant text
-- Maintain clear structure and consistent tone
-- Preserve all existing guidance that is still relevant
-- Keep the prompt written as instructions for a translator (e.g., "When translating, you should..." not "The translation has been...")
-
-New guidance to incorporate:
-
-\`\`\`
-${combinedGlobalUpdate}
-\`\`\``
-    }), devLog.debug("Added global prompt target", { combinedUpdate: combinedGlobalUpdate });
+    await client.patch(settingsId).set({ globalPrompt: newGlobalPrompt }).commit(), devLog.info("Global prompt updated", {
+      previousLength: currentGlobalPrompt.length,
+      newLength: newGlobalPrompt.length,
+      addedUpdates: updates.length
+    });
   }
   if (localePrompts.length > 0) {
-    const combinedLocaleUpdate = localePrompts.map((s) => s.description).join(`
-
-`), existingLocalePrompts = await client.fetch(
-      "*[_id == $settingsId][0].localePrompts",
-      { settingsId }
-    ), hasExistingLocalePrompt = existingLocalePrompts?.some((lp) => lp._key === targetLanguage);
-    devLog.debug("Checking existing locale prompt", {
-      targetLanguage,
-      hasExistingLocalePrompt,
-      existingCount: existingLocalePrompts?.length || 0
-    }), hasExistingLocalePrompt || (devLog.info("Creating new locale prompt entry", { targetLanguage }), await client.patch(settingsId).setIfMissing({ localePrompts: [] }).append("localePrompts", [
-      {
-        _type: "internationalizedArrayTextValue",
-        _key: targetLanguage,
-        value: ""
-        // Start with empty value, transform will fill it
-      }
-    ]).commit());
-    const localePromptPath = ["localePrompts", { _key: targetLanguage }, "value"];
-    targets.push({
-      // @ts-expect-error
-      path: localePromptPath,
-      instruction: `You are updating a translation prompt document that contains rules and guidance for future AI translations.
-
-IMPORTANT: The text below is NEW GUIDANCE that should be INCORPORATED INTO the existing prompt as additional rules/instructions for future translations. DO NOT apply or execute these rules on the prompt text itself.
-
-Your task: Merge the new guidance below into the existing prompt text. Treat the new guidance as rules that will guide future translations, not as transformations to apply to the current text.
-
-Integration guidelines:
-- Add the new guidance as additional instructions/rules in the prompt
-- If it conflicts with existing guidance, update or replace the conflicting parts
-- If it's already covered, don't add redundant text
-- Maintain clear structure and consistent tone
-- Preserve all existing guidance that is still relevant
-- Keep the prompt written as instructions for a translator (e.g., "When translating, you should..." not "The translation has been...")
-
-New guidance to incorporate:
-
-\`\`\`
-${combinedLocaleUpdate}
-\`\`\``
-    }), devLog.debug("Added locale prompt target", {
-      targetLanguage,
-      localePromptPath,
-      combinedUpdate: combinedLocaleUpdate
-    });
+    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(), devLog.info("Locale prompt updated", {
+        targetLanguage,
+        previousLength: currentValue.length,
+        newLength: newValue.length,
+        addedUpdates: updates.length
+      });
+    } 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("Locale prompt created", {
+        targetLanguage,
+        length: newValue.length,
+        addedUpdates: updates.length
+      });
+    }
   }
-  const result = await client.agent.action.transform({
-    schemaId,
-    documentId: settingsId,
-    instruction: "Update translation prompts based on user feedback to improve future translations.",
-    target: targets,
-    forcePublishedWrite: !0
-  });
-  devLog.info("Prompts updated via transform action", {
-    resultId: result._id,
+  devLog.info("Prompts updated successfully", {
     globalUpdated: globalPrompts.length > 0,
     localeUpdated: localePrompts.length > 0
   });
@@ -439,8 +603,14 @@ async function addProtectedPhrases(client, settingsId, phrases) {
   devLog.info("Adding protected phrases", { settingsId, phrasesCount: phrases.length, phrases });
   const currentPhrases = await client.fetch("*[_id == $settingsId][0].protectedPhrases", { settingsId });
   devLog.debug("Fetched current protected phrases", { currentCount: currentPhrases?.length });
-  const newPhrases = phrases.filter((phrase) => !currentPhrases?.includes(phrase));
-  if (newPhrases.length === 0) {
+  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 }));
+  if (newPhrases = newPhrases.filter((phrase) => !conflictingPhrases.includes(phrase)), newPhrases.length === 0) {
     devLog.info("No new protected phrases to add (all already exist)");
     return;
   }
@@ -448,7 +618,13 @@ async function addProtectedPhrases(client, settingsId, phrases) {
   devLog.info("Protected phrases added", { count: newPhrases.length, phrases: newPhrases, resultId: result._id });
 }
 async function addGlossaryTerms(client, terms) {
-  const validTerms = terms.filter(({ sourceValue, targetValue }) => sourceValue === targetValue ? (devLog.warn("Skipping glossary term where source === target (should be a protected phrase)", {
+  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);
@@ -465,32 +641,47 @@ async function addGlossaryTerms(client, terms) {
       }`,
       { sourceLocale, sourceValue }
     );
-    existingTerm ? existingTerm.translations.some((t) => t._key === targetLocale) ? devLog.info("Glossary term already has this translation", {
-      sourceLocale,
-      sourceValue,
-      targetLocale,
-      targetValue
-    }) : (await client.patch(existingTerm._id).append("translations", [
-      {
-        _type: "internationalizedArrayStringValue",
-        _key: targetLocale,
-        value: targetValue
-      }
-    ]).commit(), devLog.info("Updated existing glossary term", { sourceLocale, sourceValue, targetLocale, targetValue })) : (await client.create({
-      _type: "translationGlossaryTerm",
-      translations: [
-        {
-          _type: "internationalizedArrayStringValue",
-          _key: sourceLocale,
-          value: 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
         }
-      ]
-    }), devLog.info("Created new glossary term", { sourceLocale, sourceValue, targetLocale, targetValue }));
+      ]).commit(), devLog.info("Added target language to existing glossary term", {
+        sourceLocale,
+        sourceValue,
+        targetLocale,
+        targetValue
+      })) : existingTargetValue !== targetValue ? (await client.patch(existingTerm._id).set({ [`translations[${existingTargetIndex}].value`]: targetValue }).commit(), devLog.info("Updated existing glossary term translation", {
+        sourceLocale,
+        sourceValue,
+        targetLocale,
+        oldValue: existingTargetValue,
+        newValue: targetValue
+      })) : devLog.info("Glossary term already has this exact translation", {
+        sourceLocale,
+        sourceValue,
+        targetLocale,
+        targetValue
+      });
+    } else
+      await client.create({
+        _type: "translationGlossaryTerm",
+        translations: [
+          {
+            _type: "internationalizedArrayStringValue",
+            _key: sourceLocale,
+            value: sourceValue
+          },
+          {
+            _type: "internationalizedArrayStringValue",
+            _key: targetLocale,
+            value: targetValue
+          }
+        ]
+      }), devLog.info("Created new glossary term", { sourceLocale, sourceValue, targetLocale, targetValue });
   }
   devLog.info("Glossary terms processed", {
     totalRequested: terms.length,
@@ -498,6 +689,20 @@ async function addGlossaryTerms(client, terms) {
     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(), devLog.info("Change history recorded", {
+    count: historyEntries.length,
+    timestamp
+  }));
+}
 const ICON_SIZE = 64, progressIconMap = {
   in_progress: /* @__PURE__ */ jsx(Spinner, {}),
   completed: /* @__PURE__ */ jsx(CheckmarkCircleIcon, { fontSize: ICON_SIZE }),
@@ -520,7 +725,7 @@ const ICON_SIZE = 64, progressIconMap = {
   localePrompt: "Locale Prompt",
   protectedPhrase: "Protected Phrase",
   glossaryTerm: "Glossary Term"
-}, createNewSuggestion = (type = "protectedPhrase") => {
+}, createNewSuggestion = (type = "protectedPhrase", sourceLanguage, targetLanguage) => {
   const baseSuggestion = {
     id: crypto.randomUUID(),
     type,
@@ -530,11 +735,18 @@ const ICON_SIZE = 64, progressIconMap = {
   return type === "glossaryTerm" ? {
     ...baseSuggestion,
     sourceValue: "",
-    targetValue: ""
+    targetValue: "",
+    sourceLocale: sourceLanguage,
+    targetLocale: targetLanguage
   } : baseSuggestion;
-}, SuggestionReviewList = ({ suggestions, onSuggestionsChange }) => {
+}, SuggestionReviewList = ({
+  suggestions,
+  onSuggestionsChange,
+  sourceLanguage,
+  targetLanguage
+}) => {
   const [editingId, setEditingId] = useState(null), handleToggleApproval = (id) => {
-    const updated = suggestions.map((s) => s.id === id ? { ...s, approved: !s.approved } : s);
+    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) => {
@@ -546,7 +758,9 @@ const ICON_SIZE = 64, progressIconMap = {
           ...s,
           type: newType,
           sourceValue: match ? match[1].trim() : "",
-          targetValue: match ? match[2].trim() : ""
+          targetValue: match ? match[2].trim() : "",
+          sourceLocale: sourceLanguage,
+          targetLocale: targetLanguage
         };
       }
       return newType !== "glossaryTerm" && s.type === "glossaryTerm" ? {
@@ -567,6 +781,7 @@ const ICON_SIZE = 64, progressIconMap = {
         ...s,
         sourceValue: newSource,
         description: `${newSource} \u2192 ${s.targetValue || ""}`
+        // Preserve sourceLocale and targetLocale
       } : s
     );
     onSuggestionsChange(updated);
@@ -576,6 +791,7 @@ const ICON_SIZE = 64, progressIconMap = {
         ...s,
         targetValue: newTarget,
         description: `${s.sourceValue || ""} \u2192 ${newTarget}`
+        // Preserve sourceLocale and targetLocale
       } : s
     );
     onSuggestionsChange(updated);
@@ -583,7 +799,7 @@ const ICON_SIZE = 64, progressIconMap = {
     const updated = suggestions.filter((s) => s.id !== id);
     onSuggestionsChange(updated);
   }, handleAddSuggestion = (type) => {
-    const newSuggestion = createNewSuggestion(type);
+    const newSuggestion = createNewSuggestion(type, sourceLanguage, targetLanguage);
     onSuggestionsChange([...suggestions, newSuggestion]), setEditingId(newSuggestion.id);
   };
   return suggestions.length === 0 ? /* @__PURE__ */ jsxs(Stack, { space: 3, children: [
@@ -610,16 +826,24 @@ const ICON_SIZE = 64, progressIconMap = {
     ) })
   ] }) : /* @__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";
+      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: suggestion.approved ? "default" : "transparent",
+          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: /* @__PURE__ */ jsx(Checkbox, { checked: suggestion.approved, onChange: () => handleToggleApproval(suggestion.id) }) }),
+            /* @__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(
@@ -628,6 +852,7 @@ const ICON_SIZE = 64, progressIconMap = {
                     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))
                   }
                 ) }),
@@ -639,31 +864,42 @@ const ICON_SIZE = 64, progressIconMap = {
                     icon: TrashIcon,
                     fontSize: 1,
                     padding: 2,
-                    onClick: () => handleRemove(suggestion.id)
+                    onClick: () => handleRemove(suggestion.id),
+                    "aria-label": "Remove suggestion",
+                    title: "Remove suggestion"
                   }
                 )
               ] }),
-              isGlossaryTerm ? /* @__PURE__ */ jsx(Stack, { space: 2, children: /* @__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)
-                  }
-                ) }),
-                /* @__PURE__ */ jsx(Text, { size: 1, muted: !0, 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)
-                  }
-                ) })
-              ] }) }) : isPrompt ? /* @__PURE__ */ jsx(Stack, { space: 2, children: /* @__PURE__ */ jsx(
+              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,
@@ -672,7 +908,8 @@ const ICON_SIZE = 64, progressIconMap = {
                   onChange: (event) => handleDescriptionChange(suggestion.id, event.currentTarget.value),
                   onFocus: () => setEditingId(suggestion.id),
                   onBlur: () => setEditingId(null),
-                  placeholder: "Enter prompt guidance..."
+                  placeholder: "Enter prompt guidance...",
+                  "aria-label": `${IMPROVEMENT_TYPE_LABELS[suggestion.type]} content`
                 }
               ) }) : /* @__PURE__ */ jsx(
                 TextInput,
@@ -680,9 +917,17 @@ const ICON_SIZE = 64, progressIconMap = {
                   fontSize: 1,
                   value: suggestion.description,
                   onChange: (event) => handleDescriptionChange(suggestion.id, event.currentTarget.value),
-                  placeholder: "Enter protected phrase..."
+                  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 })
+                ] })
+              ] }) })
             ] })
           ] }) })
         },
@@ -704,7 +949,7 @@ const ICON_SIZE = 64, progressIconMap = {
 }, 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(""), handleShouldIncludeEditsChange = () => {
+  }), [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);
@@ -726,14 +971,16 @@ const ICON_SIZE = 64, progressIconMap = {
         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 } = translationHistory2;
+      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: sourceLanguage || "en-us",
-        targetLanguage: document[config.languageFieldName],
+        sourceLanguage: srcLanguage,
+        targetLanguage: tgtLanguage,
         userFeedback: feedback || void 0,
         shouldIncludeEdits,
         sourceSnapshot,
@@ -787,7 +1034,15 @@ const ICON_SIZE = 64, progressIconMap = {
         /* @__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 }),
+      /* @__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(
@@ -895,6 +1150,33 @@ const ICON_SIZE = 64, progressIconMap = {
       )
     ] })
   ] });
+}, validateOpenAIApiKey = async (apiKey, model = "gpt-5") => {
+  try {
+    const response = await fetch("https://api.openai.com/v1/models", {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${apiKey}`
+      }
+    });
+    if (!response.ok)
+      return {
+        valid: !1,
+        error: (await response.json()).error?.message || "Invalid API key"
+      };
+    const availableModels = (await response.json()).data.map((m) => m.id);
+    return availableModels.includes(model) ? {
+      valid: !0,
+      modelAvailable: availableModels
+    } : {
+      valid: !1,
+      error: `Model ${model} not available. Try: ${availableModels.slice(0, 5).join(", ")}`
+    };
+  } catch (error) {
+    return {
+      valid: !1,
+      error: error instanceof Error ? error.message : "Network error"
+    };
+  }
 }, translationReducer = (context, action) => {
   const logContext = {
     documentId: context.document?._id,
@@ -914,10 +1196,15 @@ const ICON_SIZE = 64, progressIconMap = {
         ...context,
         selectedTargetLanguages: action.payload
       };
-    case "SET_SHOULD_TRANSLATE_DIFFS":
+    case "SET_TRANSLATION_MODE":
+      return {
+        ...context,
+        translationMode: action.payload
+      };
+    case "SET_OPENAI_VALIDATED":
       return {
         ...context,
-        shouldTranslateDiffs: action.payload
+        openaiValidated: action.payload
       };
     case "SET_SHOULD_TRANSLATE_REFERENCES":
       return {
@@ -962,18 +1249,44 @@ const ICON_SIZE = 64, progressIconMap = {
     overallStatus: "idle",
     translationMetadata: null,
     selectedTargetLanguages: [],
-    shouldTranslateDiffs: !1,
     shouldOverwriteFreshTranslations: !1,
     shouldTranslateReferences: !1,
     maxReferenceDepth: 1,
     references: [],
-    translationJobs: /* @__PURE__ */ new Map()
+    translationJobs: /* @__PURE__ */ new Map(),
+    translationMode: config?.openai?.defaultMode || "sanity-only",
+    openaiValidated: !1
   }, [context, dispatch] = useReducer(translationReducer, initialContext);
-  return devLog.debug("Translation context state initialized", {
+  return useEffect(() => {
+    (async () => {
+      if (config?.openai?.enabled && config?.openai?.apiKey)
+        try {
+          const validation = await validateOpenAIApiKey(config.openai.apiKey, config.openai.model || "gpt-5");
+          dispatch({
+            type: "SET_OPENAI_VALIDATED",
+            payload: validation.valid
+          }), validation.valid ? devLog.info("OpenAI API key validated successfully", {
+            model: config.openai.model || "gpt-5",
+            component: "TranslationContextProvider"
+          }) : devLog.error("OpenAI API key validation failed", {
+            error: validation.error,
+            component: "TranslationContextProvider"
+          });
+        } catch (error) {
+          devLog.error("OpenAI validation error", error instanceof Error ? error : new Error(String(error)), {
+            component: "TranslationContextProvider"
+          }), dispatch({
+            type: "SET_OPENAI_VALIDATED",
+            payload: !1
+          });
+        }
+    })();
+  }, [config?.openai?.apiKey, config?.openai?.enabled, config?.openai?.model]), devLog.debug("Translation context state initialized", {
     documentId: document._id,
     overallStatus: context.overallStatus,
     selectedLanguages: context.selectedTargetLanguages,
-    shouldTranslateDiffs: context.shouldTranslateDiffs,
+    translationMode: context.translationMode,
+    openaiEnabled: config?.openai?.enabled,
     component: "TranslationContextProvider"
   }), /* @__PURE__ */ jsx(TranslationContext.Provider, { value: { ...context, dispatch }, children });
 }, getGiveTranslationFeedbackAction = (config) => ({ draft, published }) => {
@@ -1076,26 +1389,98 @@ const ICON_SIZE = 64, progressIconMap = {
   title: "Translation Settings",
   icon: TranslateIcon,
   type: "document",
+  groups: [
+    {
+      name: "general",
+      title: "General",
+      default: !0
+    },
+    {
+      name: "history",
+      title: "History"
+    }
+  ],
   fields: [
     defineField({
       name: "globalPrompt",
       title: "Global Translation Prompt",
       description: "A prompt that will given to the Sanity AI Agent for all translation tasks.",
       type: "text",
-      rows: 5
+      rows: 5,
+      group: "general"
     }),
     defineField({
       name: "localePrompts",
       title: "Locale Prompts",
       description: "Prompts that will be given to the Sanity AI Agent for each locale.",
-      type: "internationalizedArrayText"
+      type: "internationalizedArrayText",
+      group: "general"
     }),
     defineField({
       name: "protectedPhrases",
       title: "Protected Phrases",
       description: "Phrases that will never be translated.",
       type: "array",
-      of: [{ type: "string" }]
+      of: [{ type: "string" }],
+      group: "general"
+    }),
+    defineField({
+      name: "changeHistory",
+      title: "Change History",
+      description: "History of changes made via user feedback.",
+      type: "array",
+      readOnly: !0,
+      group: "history",
+      of: [
+        {
+          type: "object",
+          fields: [
+            defineField({
+              name: "timestamp",
+              title: "Timestamp",
+              type: "datetime"
+            }),
+            defineField({
+              name: "changeType",
+              title: "Change Type",
+              type: "string",
+              options: {
+                list: [
+                  { title: "Global Prompt", value: "globalPrompt" },
+                  { title: "Locale Prompt", value: "localePrompt" },
+                  { title: "Protected Phrase", value: "protectedPhrase" },
+                  { title: "Glossary Term", value: "glossaryTerm" }
+                ]
+              }
+            }),
+            defineField({
+              name: "description",
+              title: "Description",
+              type: "text",
+              rows: 3
+            }),
+            defineField({
+              name: "locale",
+              title: "Locale",
+              type: "string",
+              description: "Target locale for locale-specific changes"
+            })
+          ],
+          preview: {
+            select: {
+              timestamp: "timestamp",
+              changeType: "changeType",
+              description: "description"
+            },
+            prepare({ timestamp, changeType, description }) {
+              return {
+                title: `${changeType} - ${new Date(timestamp).toLocaleDateString()}`,
+                subtitle: description
+              };
+            }
+          }
+        }
+      ]
     })
   ],
   preview: {
@@ -1103,13 +1488,180 @@ const ICON_SIZE = 64, progressIconMap = {
       title: "Translation Settings"
     })
   }
-}), fetchTranslationPrompts = async ({
+});
+class Semaphore {
+  permits;
+  queue = [];
+  constructor(permits) {
+    this.permits = permits;
+  }
+  /**
+   * Acquire a permit from the semaphore
+   * If no permits are available, the caller will wait until one becomes available
+   */
+  async acquire() {
+    return this.permits > 0 ? (this.permits--, Promise.resolve()) : new Promise((resolve) => {
+      this.queue.push(resolve);
+    });
+  }
+  /**
+   * Release a permit back to the semaphore
+   * If there are waiting callers, one will be woken up
+   */
+  release() {
+    const next = this.queue.shift();
+    next ? next() : this.permits++;
+  }
+  /**
+   * Execute a function with semaphore protection
+   * Automatically acquires and releases the permit
+   */
+  async withPermit(fn) {
+    await this.acquire();
+    try {
+      return await fn();
+    } finally {
+      this.release();
+    }
+  }
+  /**
+   * Get the number of available permits
+   */
+  availablePermits() {
+    return this.permits;
+  }
+  /**
+   * Get the number of waiting callers
+   */
+  queueLength() {
+    return this.queue.length;
+  }
+  /**
+   * Update the number of permits
+   * If increasing permits, waiting callers will be notified
+   * If decreasing permits below current available, available permits will be reduced
+   */
+  updatePermits(newPermits) {
+    const currentTotal = this.permits + this.queue.length, difference = newPermits - currentTotal;
+    if (difference > 0) {
+      for (let i = 0; i < difference && this.queue.length > 0; i++) {
+        const next = this.queue.shift();
+        next && next();
+      }
+      const remainingIncrease = difference - (currentTotal - this.permits - this.queue.length);
+      remainingIncrease > 0 && (this.permits += remainingIncrease);
+    } else difference < 0 && (this.permits = Math.max(0, this.permits + difference));
+  }
+}
+function documentToPlainText(document) {
+  if (!document) return "";
+  const result = {};
+  for (const [key, value] of Object.entries(document))
+    Array.isArray(value) && value.some(
+      (item) => typeof item == "object" && item !== null && "_type" in item && item._type === "block"
+    ) ? result[key] = toPlainText(value) : result[key] = value;
+  return JSON.stringify(result);
+}
+const DEFAULTS = {
+  windowSlack: 2,
+  minTokenMatchRatio: 1,
+  stopwords: [
+    // common English fillers — extend per your locales
+    "a",
+    "an",
+    "the",
+    "and",
+    "or",
+    "to",
+    "of",
+    "for",
+    "in",
+    "on",
+    "at",
+    "by",
+    "with",
+    "using",
+    "from",
+    "into",
+    "over",
+    "under",
+    "as",
+    "is",
+    "are",
+    "be"
+  ],
+  dropVeryShortTermTokens: !0,
+  allowedWordCharsRegex: /[\p{L}\p{N}_]+/gu
+  // letters/numbers/underscore (Unicode)
+};
+function normalizeForMatch(s) {
+  return s.toLowerCase().normalize("NFKD").replace(new RegExp("\\p{M}+", "gu"), "").trim();
+}
+function tokenize(text, allowedWordChars = DEFAULTS.allowedWordCharsRegex) {
+  return normalizeForMatch(text).match(allowedWordChars) || [];
+}
+function preprocessSource(sourceText, opts) {
+  return { tokens: tokenize(sourceText, DEFAULTS.allowedWordCharsRegex) };
+}
+function prepareTermTokens(term, opts) {
+  const filtered = tokenize(term, opts.allowedWordCharsRegex).filter((t) => !opts.stopwords.includes(t));
+  return opts.dropVeryShortTermTokens ? filtered.filter((t) => t.length > 2) : filtered;
+}
+function freqMap(tokens) {
+  const m = /* @__PURE__ */ new Map();
+  for (const t of tokens) m.set(t, (m.get(t) ?? 0) + 1);
+  return m;
+}
+function matchTermInDocument(term, source, options) {
+  const opts = { ...DEFAULTS, ...options ?? {} }, termTokens = prepareTermTokens(term, opts);
+  if (termTokens.length === 0)
+    return { matched: !1, term, reason: "No substantive tokens after filtering." };
+  const termFreq = freqMap(termTokens), requiredCount = Math.ceil(termTokens.length * opts.minTokenMatchRatio), windowSize = Math.max(1, termTokens.length + opts.windowSlack), interesting = new Set(termFreq.keys()), windowCounts = /* @__PURE__ */ new Map();
+  let satisfiedCount = 0;
+  const addToken = (tok) => {
+    if (!interesting.has(tok)) return;
+    const before = windowCounts.get(tok) ?? 0, after = before + 1;
+    windowCounts.set(tok, after);
+    const cap = termFreq.get(tok);
+    before < cap && (satisfiedCount += 1);
+  }, removeToken = (tok) => {
+    if (!interesting.has(tok)) return;
+    const before = windowCounts.get(tok) ?? 0;
+    if (before === 0) return;
+    const after = before - 1;
+    windowCounts.set(tok, after);
+    const cap = termFreq.get(tok);
+    before <= cap && (satisfiedCount -= 1);
+  }, { tokens } = source;
+  for (let i = 0; i < Math.min(windowSize, tokens.length); i++) addToken(tokens[i]);
+  if (satisfiedCount >= requiredCount)
+    return {
+      matched: !0,
+      term,
+      windowStart: 0,
+      windowEnd: Math.min(windowSize, tokens.length) - 1,
+      matchedRatio: satisfiedCount / termTokens.length
+    };
+  for (let start = 1; start + windowSize <= tokens.length; start++) {
+    const prev = tokens[start - 1], next = tokens[start + windowSize - 1];
+    if (removeToken(prev), addToken(next), satisfiedCount >= requiredCount)
+      return {
+        matched: !0,
+        term,
+        windowStart: start,
+        windowEnd: start + windowSize - 1,
+        matchedRatio: satisfiedCount / termTokens.length
+      };
+  }
+  return { matched: !1, term, reason: "No window satisfied the token threshold." };
+}
+const fetchTranslationPrompts = async ({
   client,
   sourceLanguage,
   sourceDocument,
   targetLanguages
 }) => {
-  const sourceDocumentString = JSON.stringify(sourceDocument), translationSettings2 = await client.fetch(
+  const sourceDocumentString = documentToPlainText(sourceDocument), translationSettings2 = await client.fetch(
     `*[_id == "translation-settings"][0] {
       globalPrompt,
       localePrompts[locale in $targetLanguages],
@@ -1132,12 +1684,15 @@ const ICON_SIZE = 64, progressIconMap = {
       return !from || !to ? null : { from, to };
     }).filter((item) => item !== null);
     sourceDocument && (relevantTranslations = relevantTranslations.filter(
-      ({ from }) => termAppearsInDocument(from, sourceDocumentString)
+      ({ from }) => glossaryTermAppearsInDocument(from, sourceDocumentString)
     )), glossaryTermsByLocale[targetLanguage] = relevantTranslations;
   }
-  return {
+  let filteredProtectedPhrases = translationSettings2?.protectedPhrases;
+  return sourceDocument && filteredProtectedPhrases && (filteredProtectedPhrases = filteredProtectedPhrases.filter(
+    (phrase) => protectedPhraseAppearsInDocument(phrase, sourceDocumentString)
+  )), {
     globalPrompt: translationSettings2?.globalPrompt,
-    protectedPhrases: translationSettings2?.protectedPhrases,
+    protectedPhrases: filteredProtectedPhrases,
     localeInstructions: Object.fromEntries(
       targetLanguages.map((locale) => [
         locale,
@@ -1148,17 +1703,36 @@ const ICON_SIZE = 64, progressIconMap = {
       ])
     )
   };
-}, termAppearsInDocument = (term, documentString) => {
-  const baseTerm = term.split(":")[0].trim();
-  return documentString.includes(baseTerm.toLowerCase());
+}, glossaryTermAppearsInDocument = (term, documentString) => {
+  const baseTerm = term.split(":")[0].trim(), source = preprocessSource(documentString);
+  return matchTermInDocument(baseTerm, source, {
+    windowSlack: 10
+  }).matched;
+}, protectedPhraseAppearsInDocument = (phrase, documentString) => {
+  const source = preprocessSource(documentString);
+  return matchTermInDocument(phrase, source, {
+    windowSlack: 10
+  }).matched;
 }, formatGlossaryTermInstruction = (terms) => {
+  if (!terms || terms.length === 0)
+    return;
   const instructions = [
     "## Glossary Terms",
-    "Translate the following terms exactly as described below.",
-    "When a term includes a colon, the suffix following the colon describes how the term should be translated for the female gender."
+    "Use the translations below whenever the matching source term appears. Treat these mappings as required terminology.",
+    "Guidelines:",
+    "- Apply glossary terms when the meaning matches, even if there are slight variations in wording, punctuation, or word order.",
+    "- Preserve surrounding punctuation and keep the sentence natural.",
+    "- Match the source casing when possible; only adjust when required for correct grammar.",
+    "- If the source term meaning is absent, do not introduce a translation from this list.",
+    "- When a term includes a colon, translate the text before the colon for general use; use the text after the colon when the feminine form is required.",
+    "- Do not remove important words or phrases from the source text when they are essential to the meaning.",
+    "- Never add punctuation or symbols that are not present in the source text.",
+    "- Never apply glossary terms in code examples."
   ];
   return terms.forEach(({ from, to }) => {
-    instructions.push(`Always translate "${from}" to "${to}".`);
+    instructions.push(
+      `When text conveys the same meaning as "${from}", translate it as "${to}" unless the term is used in a code example.`
+    );
   }), instructions.join(`
 `);
 }, findKeyValues = (obj, targetKey) => {
@@ -1185,12 +1759,19 @@ const ICON_SIZE = 64, progressIconMap = {
   try {
     const doc = await client.fetch("*[_id == $documentId][0]", { documentId });
     if (!doc) {
-      console.error(documentId, "not found");
+      devLog.error("Document not found", new Error("Document not found"), {
+        documentId,
+        component: "localizeReferences"
+      });
       return;
     }
     const targetLanguage = doc[languageFieldName];
     if (!targetLanguage) {
-      console.error(documentId, "no value found for language field:", languageFieldName);
+      devLog.error("No value found for language field", new Error("Missing language field"), {
+        documentId,
+        languageFieldName,
+        component: "localizeReferences"
+      });
       return;
     }
     const refs = findKeyValues(doc, "_ref");
@@ -1198,94 +1779,46 @@ const ICON_SIZE = 64, progressIconMap = {
       return;
     await updateReferences(documentId, client, refs, targetLanguage);
   } catch (error) {
-    console.error("Error localizing references:", error);
+    devLog.error("Error localizing references", error instanceof Error ? error : new Error(String(error)), {
+      documentId,
+      component: "localizeReferences"
+    });
   }
 }, updateReferences = async (documentId, client, refs, targetLanguage) => {
-  const patch = client.patch(documentId);
   if (!refs?.length)
     return [];
+  const refIds = refs.map((r) => undraftId(r.value)), translations = await client.fetch(
+    `*[_type == $translationMetadataSchemaType && count(translations[value._ref in $refIds]) > 0]
+      .translations[value._ref in $refIds]{
+        "sourceId": value._ref,
+        "targetId": ^.translations[_key == $targetLanguage][0].value._ref
+      }[defined(targetId)]`,
+    {
+      translationMetadataSchemaType: TRANSLATION_METADATA_TYPE,
+      refIds,
+      targetLanguage
+    }
+  ), translationMap = /* @__PURE__ */ new Map();
+  for (const t of translations)
+    t.sourceId && t.targetId && translationMap.set(t.sourceId, t.targetId);
+  const patch = client.patch(documentId);
+  let hasChanges = !1;
   for (const ref of refs) {
-    const newId = await client.fetch(
-      "(*[_type == $translationMetadataSchemaType && references($sourceId)].translations[_key == $targetLanguage].value._ref)[0]",
-      {
-        translationMetadataSchemaType: TRANSLATION_METADATA_TYPE,
-        sourceId: undraftId(ref.value),
-        targetLanguage
-      }
-    );
+    const sourceId = undraftId(ref.value), newId = translationMap.get(sourceId);
     newId && (patch.set({ [pathToString(ref.path)]: undraftId(newId) }), patch.set({ [`${pathToString(ref.path.slice(0, -1))}._weak`]: !0 }), patch.set({
       [`${pathToString(ref.path.slice(0, -1))}._strengthenOnPublish`]: {
         _type: "reference",
         _weak: !1
       }
-    }), await patch.commit());
+    }), hasChanges = !0);
   }
-};
-class Semaphore {
-  permits;
-  queue = [];
-  constructor(permits) {
-    this.permits = permits;
-  }
-  /**
-   * Acquire a permit from the semaphore
-   * If no permits are available, the caller will wait until one becomes available
-   */
-  async acquire() {
-    return this.permits > 0 ? (this.permits--, Promise.resolve()) : new Promise((resolve) => {
-      this.queue.push(resolve);
-    });
-  }
-  /**
-   * Release a permit back to the semaphore
-   * If there are waiting callers, one will be woken up
-   */
-  release() {
-    const next = this.queue.shift();
-    next ? next() : this.permits++;
-  }
-  /**
-   * Execute a function with semaphore protection
-   * Automatically acquires and releases the permit
-   */
-  async withPermit(fn) {
-    await this.acquire();
-    try {
-      return await fn();
-    } finally {
-      this.release();
-    }
-  }
-  /**
-   * Get the number of available permits
-   */
-  availablePermits() {
-    return this.permits;
-  }
-  /**
-   * Get the number of waiting callers
-   */
-  queueLength() {
-    return this.queue.length;
-  }
-  /**
-   * Update the number of permits
-   * If increasing permits, waiting callers will be notified
-   * If decreasing permits below current available, available permits will be reduced
-   */
-  updatePermits(newPermits) {
-    const currentTotal = this.permits + this.queue.length, difference = newPermits - currentTotal;
-    if (difference > 0) {
-      for (let i = 0; i < difference && this.queue.length > 0; i++) {
-        const next = this.queue.shift();
-        next && next();
-      }
-      const remainingIncrease = difference - (currentTotal - this.permits - this.queue.length);
-      remainingIncrease > 0 && (this.permits += remainingIncrease);
-    } else difference < 0 && (this.permits = Math.max(0, this.permits + difference));
-  }
-}
-const setupTranslationJobStatuses = (dispatch, sourceDocuments, targetLanguages) => {
+  hasChanges && (await patch.commit(), devLog.info("Updated references in batch", {
+    documentId,
+    count: refs.length,
+    translatedCount: translationMap.size,
+    component: "updateReferences"
+  }));
+}, setupTranslationJobStatuses = (dispatch, sourceDocuments, targetLanguages) => {
   for (const sourceDocument of sourceDocuments)
     for (const lang of targetLanguages) {
       const payload = {
@@ -1300,21 +1833,6 @@ const setupTranslationJobStatuses = (dispatch, sourceDocuments, targetLanguages)
         payload
       });
     }
-}, getExistingTranslationId = (translationMetadata, targetLanguage) => translationMetadata?.translations?.length && translationMetadata.translations.find(
-  (translation) => translation._key === targetLanguage
-)?.value._ref || null, determineTranslationTarget = ({
-  translationMetadata,
-  targetLanguage
-}) => {
-  const existingTranslationId = getExistingTranslationId(translationMetadata, targetLanguage);
-  return existingTranslationId ? {
-    // Update existing translation
-    operation: "createOrReplace",
-    _id: existingTranslationId
-  } : {
-    // Create new translation
-    operation: "create"
-  };
 }, getTranslationMetadata = async ({
   client,
   sourceDocument,
@@ -1349,6 +1867,52 @@ const setupTranslationJobStatuses = (dispatch, sourceDocuments, targetLanguages)
   } catch (error) {
     throw console.error(sourceDocument._id, "Error creating translation metadata:", error), error;
   }
+}, updateTranslationMetadata = async ({
+  client,
+  targetLanguage,
+  sourceDocument,
+  sourceLanguage,
+  newDocument,
+  translationMetadata,
+  isNewTranslation
+}) => {
+  try {
+    const refToNewTranslation = {
+      _key: targetLanguage,
+      _type: "internationalizedArrayReferenceValue",
+      value: {
+        _type: "reference",
+        _ref: undraftId(newDocument._id),
+        _weak: !0,
+        _strengthenOnPublish: {
+          _type: "reference",
+          _weak: !1
+        }
+      }
+    }, newTranslationHistory = {
+      _key: targetLanguage,
+      language: targetLanguage,
+      sourceId: undraftId(sourceDocument._id),
+      sourceRev: sourceDocument._rev,
+      sourceLanguage,
+      sourceSnapshot: JSON.stringify(sourceDocument),
+      targetId: newDocument._id,
+      targetRev: newDocument._rev,
+      targetSnapshot: JSON.stringify(newDocument)
+    }, translationPatch = client.patch(translationMetadata._id).setIfMissing({ translations: [] });
+    isNewTranslation ? await translationPatch.insert("after", "translations[-1]", [refToNewTranslation]).commit() : await translationPatch.insert("replace", `translations[_key == "${targetLanguage}"]`, [refToNewTranslation]).commit();
+    const historyPatch = client.patch(translationMetadata._id).setIfMissing({ translationHistory: [] });
+    translationMetadata.translationHistory?.some(
+      (history) => history.language === targetLanguage
+    ) ? await historyPatch.insert("replace", `translationHistory[_key == "${targetLanguage}"]`, [newTranslationHistory]).commit() : await historyPatch.insert("after", "translationHistory[-1]", [newTranslationHistory]).commit();
+  } catch (error) {
+    throw devLog.error("Error updating translation metadata", error instanceof Error ? error : new Error(String(error)), {
+      sourceDocumentId: sourceDocument._id,
+      targetLanguage,
+      newDocumentId: newDocument._id,
+      component: "updateTranslationMetadata"
+    }), error;
+  }
 }, setJobStatus = (dispatch, _id, language, status, payload) => {
   dispatch({
     type: "SET_TRANSLATION_JOB_STATUS",
@@ -1358,45 +1922,44 @@ const setupTranslationJobStatuses = (dispatch, sourceDocuments, targetLanguages)
       status
     })
   });
-}, translateDocumentInPlace = async ({
-  client,
-  schemaId,
-  dispatch,
-  sourceDocument,
-  languageFieldName,
-  targetLanguage,
-  targetId,
-  patch
+}, getExistingTranslationId = (translationMetadata, targetLanguage) => translationMetadata?.translations?.length && translationMetadata.translations.find(
+  (translation) => translation._key === targetLanguage
+)?.value._ref || null, determineTranslationTarget = ({
+  translationMetadata,
+  targetLanguage
 }) => {
-  try {
-    return setJobStatus(dispatch, sourceDocument._id, targetLanguage, "translating"), await client.agent.action.translate({
-      schemaId,
-      documentId: targetId,
-      toLanguage: {
-        title: targetLanguage,
-        id: targetLanguage
-      },
-      fromLanguage: {
-        title: sourceDocument[languageFieldName],
-        id: sourceDocument[languageFieldName]
-      },
-      languageFieldPath: [languageFieldName],
-      styleGuide: `
-			  **IMPORTANT:** Much of this document is already translated into the target language. The original version of this document in the source language
-				was updated. The following patch instruction shows precisely how the source document was edited: $patchInstruction. Your job is to update this
-			  translation to including matching changes.
-				`,
-      styleGuideParams: {
-        patchInstruction: JSON.stringify(patch, null, 2)
-      }
-    });
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    setJobStatus(dispatch, sourceDocument._id, targetLanguage, "error", {
-      errorMessage
-    }), console.error("Error translating document:", error);
-    return;
-  }
+  const existingTranslationId = getExistingTranslationId(translationMetadata, targetLanguage);
+  return existingTranslationId ? {
+    // Update existing translation
+    operation: "createOrReplace",
+    _id: existingTranslationId
+  } : {
+    // Create new translation
+    operation: "create"
+  };
+}, analyzeDocumentContent = (document) => {
+  let hasCodeBlocks = !1, hasInlineCode = !1, codeBlockCount = 0, inlineCodeCount = 0;
+  const hasMarkdown = !1;
+  let hasPortableText = !1, estimatedFieldCount = 0;
+  const traverse = (value, depth = 0) => {
+    value != null && (depth > 0 && typeof value == "object" && estimatedFieldCount++, Array.isArray(value) ? value.forEach((item) => {
+      item && typeof item == "object" && "_type" in item && item._type === "code" && (hasCodeBlocks = !0, codeBlockCount++, hasPortableText = !0), item && typeof item == "object" && "_type" in item && item._type === "block" && "children" in item && Array.isArray(item.children) && (hasPortableText = !0, item.children.forEach((child) => {
+        child && typeof child == "object" && "marks" in child && Array.isArray(child.marks) && child.marks.includes("code") && (hasInlineCode = !0, inlineCodeCount++);
+      })), traverse(item, depth + 1);
+    }) : typeof value == "object" && Object.values(value).forEach((val) => traverse(val, depth + 1)));
+  };
+  traverse(document);
+  let complexity = "simple";
+  return estimatedFieldCount > 50 ? complexity = "complex" : estimatedFieldCount > 20 && (complexity = "moderate"), {
+    hasCodeBlocks,
+    hasInlineCode,
+    codeBlockCount,
+    inlineCodeCount,
+    hasMarkdown,
+    hasPortableText,
+    complexity,
+    estimatedFieldCount
+  };
 }, assembleLanguageSpecs = ({
   sourceDocument,
   languageFieldName,
@@ -1415,6 +1978,441 @@ const setupTranslationJobStatuses = (dispatch, sourceDocuments, targetLanguages)
       title: targetLanguage
     }
   };
+}, callGPT5 = async (apiKey, request) => {
+  const model = request.model || "gpt-5", isGPT5 = model === "gpt-5", useStreaming = !!request.onReasoningChunk, requestBody = {
+    model,
+    messages: request.messages,
+    stream: useStreaming
+  };
+  isGPT5 || (requestBody.temperature = request.temperature ?? 0.3), isGPT5 && (requestBody.reasoning_effort = request.reasoningEffort || "medium", requestBody.verbosity = request.verbosity || "medium");
+  const response = await fetch("https://api.openai.com/v1/chat/completions", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${apiKey}`
+    },
+    body: JSON.stringify(requestBody)
+  });
+  if (!response.ok) {
+    const error = await response.json();
+    throw new Error(`GPT-5 API error: ${error.error?.message || "Unknown error"}`);
+  }
+  if (useStreaming && response.body && request.onReasoningChunk)
+    return await handleStreamingResponse(response, request.onReasoningChunk, model);
+  const result = await response.json(), usage = result.usage || {}, tokensUsed = {
+    prompt: usage.prompt_tokens || 0,
+    completion: usage.completion_tokens || 0,
+    reasoning: usage.reasoning_tokens || 0,
+    // New in GPT-5
+    total: usage.total_tokens || 0
+  }, cost = calculateGPT5Cost(tokensUsed, request.model || "gpt-5"), messageContent = result.choices[0].message.content;
+  let reasoningSummary, actualContent = messageContent;
+  const reasoningMatch = messageContent.match(/^<reasoning>([\s\S]*?)<\/reasoning>\n\n([\s\S]*)$/i);
+  return reasoningMatch && (reasoningSummary = reasoningMatch[1].trim(), actualContent = reasoningMatch[2]), {
+    content: actualContent,
+    tokensUsed,
+    cost,
+    reasoningSummary
+  };
+}, handleStreamingResponse = async (response, onReasoningChunk, model) => {
+  if (!response.body)
+    throw new Error("Response body is null");
+  const reader = response.body.getReader(), decoder = new TextDecoder();
+  let fullContent = "", inReasoning = !1, reasoningBuffer = "", contentBuffer = "", tokensUsed = { prompt: 0, completion: 0, reasoning: 0, total: 0 };
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      const lines = decoder.decode(value, { stream: !0 }).split(`
+`).filter((line) => line.trim() !== "");
+      for (const line of lines)
+        if (line.startsWith("data: ")) {
+          const data = line.slice(6);
+          if (data === "[DONE]") continue;
+          try {
+            const parsed = JSON.parse(data);
+            parsed.usage && (tokensUsed = {
+              prompt: parsed.usage.prompt_tokens || 0,
+              completion: parsed.usage.completion_tokens || 0,
+              reasoning: parsed.usage.reasoning_tokens || 0,
+              total: parsed.usage.total_tokens || 0
+            });
+            const delta = parsed.choices?.[0]?.delta?.content;
+            if (delta)
+              if (fullContent += delta, delta.includes("<reasoning>")) {
+                inReasoning = !0;
+                const parts = delta.split("<reasoning>");
+                reasoningBuffer += parts[1] || "";
+              } else if (delta.includes("</reasoning>")) {
+                inReasoning = !1;
+                const parts = delta.split("</reasoning>");
+                reasoningBuffer += parts[0] || "", contentBuffer += parts[1] || "";
+              } else inReasoning ? (reasoningBuffer += delta, onReasoningChunk(reasoningBuffer)) : contentBuffer += delta;
+          } catch {
+          }
+        }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  const cost = calculateGPT5Cost(tokensUsed, model);
+  return {
+    content: contentBuffer || fullContent,
+    tokensUsed,
+    cost,
+    reasoningSummary: reasoningBuffer || void 0
+  };
+}, calculateGPT5Cost = (tokens, model) => {
+  const pricing = {
+    "gpt-5": {
+      input: 2e-6,
+      // $0.002 per 1k input tokens
+      output: 1e-5,
+      // $0.010 per 1k output tokens
+      reasoning: 5e-6
+      // $0.005 per 1k reasoning tokens
+    },
+    "gpt-4o": {
+      input: 5e-6,
+      output: 14999999999999999e-21,
+      reasoning: 0
+      // No reasoning tokens in GPT-4
+    },
+    "gpt-4-turbo": {
+      input: 1e-5,
+      output: 29999999999999997e-21,
+      reasoning: 0
+    },
+    "gpt-4": {
+      input: 29999999999999997e-21,
+      output: 59999999999999995e-21,
+      reasoning: 0
+    }
+  }, modelPricing = pricing[model] || pricing["gpt-5"];
+  return tokens.prompt * modelPricing.input + tokens.completion * modelPricing.output + tokens.reasoning * modelPricing.reasoning;
+}, deserializeDocument = (originalDoc, reviewedText) => {
+  const parsed = parseReviewFormat(reviewedText), result = cloneDeep(originalDoc);
+  return applyTextChanges(result, parsed), result;
+}, parseReviewFormat = (text) => {
+  const root = [], stack = [], lines = text.split(`
+`);
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    const openMatch = trimmed.match(/^<(field|block|span)([^>]*)>(.*)$/);
+    if (openMatch) {
+      const [, tagName, attrsStr, content] = openMatch, attributes = parseAttributes(attrsStr), node = {
+        type: tagName,
+        name: attributes.name,
+        text: content ? unescapeXml(content) : void 0,
+        attributes,
+        children: []
+      }, closingTag = `</${tagName}>`;
+      if (content.endsWith(closingTag.replace(/[<>]/g, ""))) {
+        const textContent = content.substring(0, content.lastIndexOf("<"));
+        if (node.text = unescapeXml(textContent), stack.length > 0) {
+          const parent = stack[stack.length - 1];
+          parent && parent.children.push(node);
+        } else
+          root.push(node);
+      } else if (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
+        stack.push(node);
+      continue;
+    }
+    if (trimmed.match(/^<\/(field|block|span)>$/) && stack.length > 0) {
+      const node = stack.pop();
+      if (node)
+        if (stack.length > 0) {
+          const parent = stack[stack.length - 1];
+          parent && parent.children.push(node);
+        } else
+          root.push(node);
+    }
+  }
+  return root;
+}, parseAttributes = (attrStr) => {
+  const attrs = {}, attrRegex = /(\w+)="([^"]*)"/g;
+  let match = attrRegex.exec(attrStr);
+  for (; match !== null; )
+    attrs[match[1]] = unescapeXml(match[2]), match = attrRegex.exec(attrStr);
+  return attrs;
+}, unescapeXml = (str) => str.replace(/&apos;/g, "'").replace(/&quot;/g, '"').replace(/&gt;/g, ">").replace(/&lt;/g, "<").replace(/&amp;/g, "&"), applyTextChanges = (doc, parsedNodes) => {
+  for (const node of parsedNodes)
+    if (node.type === "field" && node.name) {
+      const path = [node.name];
+      applyFieldChanges(doc, path, node);
+    }
+}, applyFieldChanges = (doc, path, node) => {
+  if (node.attributes.type === "array") {
+    node.children.forEach((child, idx) => {
+      applyFieldChanges(doc, [...path, idx], child);
+    });
+    return;
+  }
+  if (node.attributes.type === "object") {
+    for (const child of node.children)
+      child.name && applyFieldChanges(doc, [...path, child.name], child);
+    return;
+  }
+  if (node.children.some((c) => c.type === "block")) {
+    const fieldValue = get(doc, path);
+    Array.isArray(fieldValue) && node.children.forEach((blockNode, idx) => {
+      blockNode.type === "block" && applyBlockChanges(fieldValue[idx], blockNode);
+    });
+    return;
+  }
+  node.text !== void 0 && !node.attributes.readonly && set(doc, path, node.text);
+}, applyBlockChanges = (block, blockNode) => {
+  if (blockNode.attributes._key && block._key !== blockNode.attributes._key) {
+    devLog.warn("Block key mismatch, skipping", {
+      expected: block._key,
+      found: blockNode.attributes._key,
+      component: "deserializeDocument"
+    });
+    return;
+  }
+  const children = block.children;
+  Array.isArray(children) && blockNode.children.forEach((spanNode, idx) => {
+    const childItem = children[idx];
+    spanNode.type === "span" && childItem && applySpanChanges(childItem, spanNode);
+  });
+}, applySpanChanges = (span, spanNode) => {
+  if (spanNode.attributes._key && span._key !== spanNode.attributes._key) {
+    devLog.warn("Span key mismatch, skipping", {
+      expected: span._key,
+      found: spanNode.attributes._key,
+      component: "deserializeDocument"
+    });
+    return;
+  }
+  spanNode.text !== void 0 && (span.text = spanNode.text);
+}, serializeDocument = (doc) => {
+  const lines = [], serialize = (value, path = [], indent = 0) => {
+    const indentStr = "  ".repeat(indent);
+    if (path.length === 0) {
+      if (isPlainObject(value))
+        for (const [key, val] of Object.entries(value))
+          !key.startsWith("_") && key !== "language" && serialize(val, [key], indent);
+      return;
+    }
+    const fieldName = path[path.length - 1];
+    if (Array.isArray(value)) {
+      value.some((item) => item?._type === "block") ? (lines.push(`${indentStr}<field name="${fieldName}">`), value.forEach((block, idx) => {
+        serializeBlock(block, [...path, idx], indent + 1, lines);
+      }), lines.push(`${indentStr}</field>`)) : (lines.push(`${indentStr}<field name="${fieldName}" type="array">`), value.forEach((item, idx) => {
+        serialize(item, [...path, idx], indent + 1);
+      }), lines.push(`${indentStr}</field>`));
+      return;
+    }
+    if (isPlainObject(value)) {
+      lines.push(`${indentStr}<field name="${fieldName}" type="object">`);
+      for (const [key, val] of Object.entries(value))
+        key.startsWith("_") || serialize(val, [...path, key], indent + 1);
+      lines.push(`${indentStr}</field>`);
+      return;
+    }
+    if (typeof value == "string") {
+      value.length > 0 && lines.push(`${indentStr}<field name="${fieldName}">${escapeXml(value)}</field>`);
+      return;
+    }
+    (typeof value == "number" || typeof value == "boolean") && lines.push(`${indentStr}<field name="${fieldName}" type="${typeof value}" readonly="true">${value}</field>`);
+  };
+  return serialize(doc), lines.join(`
+`);
+}, serializeBlock = (block, path, indent, lines) => {
+  const indentStr = "  ".repeat(indent), metadata = {};
+  block._type && (metadata._type = block._type), block._key && (metadata._key = block._key), block.style && (metadata.style = block.style), block.listItem && (metadata.listItem = block.listItem), block.level && (metadata.level = block.level), block.markDefs && (metadata.markDefs = block.markDefs);
+  const metaStr = Object.entries(metadata).map(([k, v]) => `${k}="${escapeXml(typeof v == "string" ? v : JSON.stringify(v))}"`).join(" ");
+  lines.push(`${indentStr}<block ${metaStr}>`), Array.isArray(block.children) && block.children.forEach((child, idx) => {
+    serializeSpan(child, [...path, "children", idx], indent + 1, lines);
+  }), lines.push(`${indentStr}</block>`);
+}, serializeSpan = (span, _path, indent, lines) => {
+  const indentStr = "  ".repeat(indent);
+  if (!span || typeof span != "object") return;
+  const metadata = {};
+  span._type && (metadata._type = span._type), span._key && (metadata._key = span._key), span.marks && Array.isArray(span.marks) && (metadata.marks = span.marks.join(","));
+  const metaStr = Object.entries(metadata).map(([k, v]) => `${k}="${escapeXml(String(v))}"`).join(" "), text = typeof span.text == "string" ? span.text : "";
+  metaStr ? lines.push(`${indentStr}<span ${metaStr}>${escapeXml(text)}</span>`) : lines.push(`${indentStr}<span>${escapeXml(text)}</span>`);
+}, escapeXml = (str) => str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;"), isPlainObject = (val) => typeof val == "object" && val !== null && !Array.isArray(val), validateStructureIntegrity = (original, modified) => {
+  const errors = [], criticalFields = ["_id", "_type", "_rev", "_createdAt", "_updatedAt"];
+  for (const field of criticalFields)
+    original[field] !== modified[field] && errors.push({
+      path: [field],
+      expected: original[field],
+      actual: modified[field],
+      type: "metadata_changed"
+    });
+  return validateStructureRecursive(original, modified, [], errors), {
+    valid: errors.length === 0,
+    errors
+  };
+}, validateStructureRecursive = (original, modified, path, errors) => {
+  if (typeof original != typeof modified) {
+    errors.push({
+      path,
+      expected: typeof original,
+      actual: typeof modified,
+      type: "type_mismatch"
+    });
+    return;
+  }
+  if (Array.isArray(original)) {
+    if (!Array.isArray(modified)) {
+      errors.push({
+        path,
+        expected: "array",
+        actual: typeof modified,
+        type: "type_mismatch"
+      });
+      return;
+    }
+    if (original.length !== modified.length) {
+      errors.push({
+        path,
+        expected: `length ${original.length}`,
+        actual: `length ${modified.length}`,
+        type: "type_mismatch"
+      });
+      return;
+    }
+    original.forEach((item, idx) => {
+      validateStructureRecursive(item, modified[idx], [...path, String(idx)], errors);
+    });
+    return;
+  }
+  if (typeof original == "object" && original !== null && typeof modified == "object" && modified !== null) {
+    const origKeys = Object.keys(original).sort(), modKeys = Object.keys(modified).sort();
+    for (const key of origKeys)
+      key in modified || errors.push({
+        path: [...path, key],
+        expected: "present",
+        actual: "missing",
+        type: "missing"
+      });
+    for (const key of modKeys)
+      key in original || errors.push({
+        path: [...path, key],
+        expected: "absent",
+        actual: "present",
+        type: "extra"
+      });
+    const origObj = original, modObj = modified;
+    for (const key of origKeys)
+      key in modObj && (key.startsWith("_") || key === "marks" || key === "style" || key === "markDefs" ? JSON.stringify(origObj[key]) !== JSON.stringify(modObj[key]) && errors.push({
+        path: [...path, key],
+        expected: origObj[key],
+        actual: modObj[key],
+        type: "metadata_changed"
+      }) : key !== "text" && validateStructureRecursive(origObj[key], modObj[key], [...path, key], errors));
+  }
+}, assembleTranslationPrompt = (context, components) => {
+  const sections = [
+    {
+      id: "agentDirectives",
+      content: buildAgentDirectivesSection(context),
+      required: !0,
+      priority: 0
+    },
+    {
+      id: "criticalRules",
+      content: buildCriticalRulesSection(context),
+      required: !0,
+      priority: 1
+    }
+  ];
+  components.glossaryTerms?.trim() && sections.push({
+    id: "glossaryTerms",
+    content: buildGlossarySection(components.glossaryTerms),
+    required: !1,
+    priority: 3
+  });
+  const styleSection = buildStyleGuideSection(components.globalPrompt, components.localePrompt);
+  styleSection && sections.push({
+    id: "styleGuide",
+    content: styleSection,
+    required: !1,
+    priority: 4
+  }), sections.sort((a, b) => a.priority - b.priority);
+  let styleGuide = "";
+  const omittedSections = [], truncatedSections = [];
+  for (const section of sections) {
+    const prefix = styleGuide.length > 0 ? `
+
+---
+
+` : "", availableCharacters = 2e3 - (styleGuide.length + prefix.length);
+    if (availableCharacters <= 0) {
+      if (section.required) {
+        const truncatedContent = truncateSection(section.content, 0);
+        truncatedContent && (styleGuide += prefix + truncatedContent, truncatedSections.push(section.id));
+      } else
+        omittedSections.push(section.id);
+      continue;
+    }
+    if (section.content.length <= availableCharacters) {
+      styleGuide += prefix + section.content;
+      continue;
+    }
+    if (section.required) {
+      const truncatedContent = truncateSection(section.content, availableCharacters);
+      styleGuide += prefix + truncatedContent, truncatedSections.push(section.id);
+    } else
+      omittedSections.push(section.id);
+  }
+  return {
+    styleGuide,
+    omittedSections,
+    truncatedSections
+  };
+}, truncateSection = (content, limit) => {
+  if (limit <= 0)
+    return "";
+  if (content.length <= limit)
+    return content;
+  if (limit <= 1)
+    return content.slice(0, limit);
+  const ellipsis = "\u2026";
+  if (limit <= ellipsis.length)
+    return content.slice(0, limit);
+  const sliceEnd = limit - ellipsis.length, sliced = content.slice(0, sliceEnd), trimmed = sliced.replace(/\s+\S*$/, "").trimEnd();
+  return `${trimmed.length >= sliceEnd / 2 ? trimmed : sliced}${ellipsis}`;
+}, buildAgentDirectivesSection = (context) => {
+  const { targetLanguage, sourceLanguage } = context;
+  return `# AGENT WORKFLOW DIRECTIVES
+
+- Use only the provided ${sourceLanguage || "the source language"} source; never fetch outside context.
+- Scan each field once, then move directly into translation work.
+- Plan updates before editing so document structure remains intact.
+- Default to medium reasoning effort and escalate only for ambiguous passages.
+- Output just the ${targetLanguage || "the target language"} translation and mirror the source formatting exactly.`;
+}, buildCriticalRulesSection = (context) => {
+  const { sourceLanguage, targetLanguage } = context, fromLanguage = sourceLanguage || "the source language", toLanguage = targetLanguage || "the target language";
+  return `# CRITICAL TRANSLATION RULES
+
+Follow these without exception:
+
+1. Translate from ${fromLanguage} into ${toLanguage}; every output token must be ${toLanguage} unless flagged as protected.
+2. Preserve meaning exactly\u2014no additions, deletions, or tone shifts.
+3. Maintain all layout, markdown, rich-text marks, and data structure.
+4. Never invent metadata or field values that are absent in the source.
+5. Leave technical tokens (code, IDs, filenames) untouched.
+6. Keep punctuation, casing, and spacing unless ${toLanguage} grammar forces a change.`;
+}, buildGlossarySection = (glossaryTerms) => `# TERMINOLOGY RULES
+
+Apply these mappings immediately after protected phrases and before style preferences.
+
+${glossaryTerms}`, buildStyleGuideSection = (globalPrompt, localePrompt) => {
+  const components = [];
+  return (globalPrompt || localePrompt) && (components.push("# TRANSLATION STYLE GUIDE (LOWEST PRIORITY)"), components.push(
+    "Apply these directions only after honoring critical rules, protected phrases, and glossary terminology."
+  ), components.push("")), globalPrompt && (components.push("## General Guidelines"), components.push(globalPrompt), components.push("")), localePrompt && (components.push("## Language-Specific Guidelines"), components.push(localePrompt)), components.length > 0 ? components.join(`
+`) : null;
 }, translateEntireDocument = async ({
   dispatch,
   client,
@@ -1422,17 +2420,175 @@ const setupTranslationJobStatuses = (dispatch, sourceDocuments, targetLanguages)
   sourceDocument,
   targetLanguage,
   languageFieldName,
-  translationTarget,
+  translationTarget,
+  translationPrompts,
+  translationMode,
+  openaiConfig,
+  releaseId,
+  isNewTranslation
+}) => {
+  const logContext = {
+    documentId: sourceDocument._id,
+    targetLanguage,
+    schemaId,
+    operation: translationTarget.operation,
+    targetId: translationTarget._id,
+    translationMode,
+    releaseId,
+    isNewTranslation
+  };
+  devLog.group("translateEntireDocument", logContext), devLog.time("translateEntireDocument");
+  try {
+    let versionedDocumentId, baseDocumentId;
+    if (isNewTranslation) {
+      const { _id, _createdAt, _updatedAt, _rev, ...docWithoutMeta } = sourceDocument, newTranslationDoc = {
+        ...docWithoutMeta,
+        _type: sourceDocument._type,
+        [languageFieldName]: targetLanguage
+      };
+      devLog.info("Creating new translation document in release", logContext), baseDocumentId = translationTarget._id || `new-translation-${Date.now()}`, await client.action({
+        actionType: "sanity.action.document.version.create",
+        publishedId: baseDocumentId,
+        document: {
+          ...newTranslationDoc,
+          _type: sourceDocument._type,
+          _id: `versions.${releaseId}.${baseDocumentId}`
+        }
+      }), versionedDocumentId = `versions.${releaseId}.${baseDocumentId}`, devLog.info("New translation version created in release", {
+        ...logContext,
+        versionedDocumentId,
+        baseDocumentId
+      });
+    } else {
+      const existingTranslationId = translationTarget._id;
+      if (!existingTranslationId)
+        throw new Error("Translation target ID not found for update operation");
+      devLog.info("Creating version of existing translation in release", {
+        ...logContext,
+        existingTranslationId
+      });
+      const existingDoc = await client.getDocument(existingTranslationId);
+      if (!existingDoc)
+        throw new Error(`Existing translation document not found: ${existingTranslationId}`);
+      await client.action({
+        actionType: "sanity.action.document.version.create",
+        publishedId: existingTranslationId,
+        document: {
+          ...existingDoc,
+          _id: `versions.${releaseId}.${existingTranslationId}`
+        }
+      }), versionedDocumentId = `versions.${releaseId}.${existingTranslationId}`, baseDocumentId = existingTranslationId, devLog.info("Existing translation version created", {
+        ...logContext,
+        versionedDocumentId
+      });
+      const { _id, _createdAt, _updatedAt, _rev, ...sourceContent } = sourceDocument;
+      await client.createOrReplace({
+        ...sourceContent,
+        _id: versionedDocumentId,
+        [languageFieldName]: targetLanguage
+      }), devLog.info("Source content cloned onto version", {
+        ...logContext,
+        versionedDocumentId
+      });
+    }
+    let translatedDocument;
+    switch (translationMode) {
+      case "openai-only": {
+        if (!openaiConfig?.enabled || !openaiConfig?.apiKey)
+          throw new Error("OpenAI is not configured but openai-only mode was selected");
+        devLog.info("Using OpenAI-only translation", logContext), setJobStatus(dispatch, sourceDocument._id, targetLanguage, "translating_with_openai");
+        const versionedDoc = await client.getDocument(versionedDocumentId);
+        if (!versionedDoc)
+          throw new Error(`Versioned document not found: ${versionedDocumentId}`);
+        const translatedDoc = await translateInPlaceWithOpenAI({
+          dispatch,
+          sourceDocument,
+          targetDocument: versionedDoc,
+          targetLanguage,
+          languageFieldName,
+          translationPrompts,
+          openaiConfig,
+          isReview: !1
+        });
+        translatedDoc && (translatedDocument = await client.createOrReplace({
+          ...translatedDoc,
+          _id: versionedDocumentId
+        }));
+        break;
+      }
+      case "sanity-with-review":
+        if (!openaiConfig?.enabled || !openaiConfig?.apiKey)
+          throw new Error("OpenAI is not configured but sanity-with-review mode was selected");
+        if (devLog.info("Using Sanity + OpenAI review", logContext), translatedDocument = await translateWithSanityAgent({
+          dispatch,
+          client,
+          schemaId,
+          sourceDocument,
+          targetLanguage,
+          languageFieldName,
+          versionedDocumentId,
+          translationPrompts
+        }), translatedDocument) {
+          setJobStatus(dispatch, sourceDocument._id, targetLanguage, "reviewing_with_openai");
+          const reviewedDoc = await translateInPlaceWithOpenAI({
+            dispatch,
+            sourceDocument,
+            targetDocument: translatedDocument,
+            targetLanguage,
+            languageFieldName,
+            translationPrompts,
+            openaiConfig,
+            isReview: !0
+          });
+          reviewedDoc && (translatedDocument = await client.createOrReplace({
+            ...reviewedDoc,
+            _id: versionedDocumentId
+          }));
+        }
+        break;
+      default:
+        devLog.info("Using Sanity-only translation", logContext), translatedDocument = await translateWithSanityAgent({
+          dispatch,
+          client,
+          schemaId,
+          sourceDocument,
+          targetLanguage,
+          languageFieldName,
+          versionedDocumentId,
+          translationPrompts
+        });
+        break;
+    }
+    return devLog.timeEnd("translateEntireDocument"), devLog.groupEnd(), translatedDocument ? {
+      ...translatedDocument,
+      _id: baseDocumentId
+    } : void 0;
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    devLog.error(
+      "translateEntireDocument failed",
+      error instanceof Error ? error : new Error(String(error)),
+      logContext
+    ), setJobStatus(dispatch, sourceDocument._id, targetLanguage, "error", {
+      errorMessage
+    }), devLog.timeEnd("translateEntireDocument"), devLog.groupEnd();
+    return;
+  }
+}, translateWithSanityAgent = async ({
+  dispatch,
+  client,
+  schemaId,
+  sourceDocument,
+  targetLanguage,
+  languageFieldName,
+  versionedDocumentId,
   translationPrompts
 }) => {
   const logContext = {
     documentId: sourceDocument._id,
     targetLanguage,
-    schemaId,
-    operation: translationTarget.operation,
-    targetId: translationTarget._id
+    versionedDocumentId
   };
-  devLog.group("translateEntireDocument", logContext), devLog.time("translateEntireDocument");
   try {
     const { toLanguage, fromLanguage } = assembleLanguageSpecs({
       sourceDocument,
@@ -1444,104 +2600,263 @@ const setupTranslationJobStatuses = (dispatch, sourceDocuments, targetLanguages)
       toLanguage,
       fromLanguage
     });
-    let extantTranslation = "";
-    translationTarget._id && (devLog.debug("Checking for existing translation", {
+    const documentAnalysis = analyzeDocumentContent(sourceDocument);
+    devLog.debug("Document analysis completed", {
       ...logContext,
-      targetId: translationTarget._id
-    }), extantTranslation = await client.withConfig({
-      perspective: "raw"
-    }).fetch('*[_id in $ids] | order((_id match "drafts*") desc)[0]._id', {
-      ids: [undraftId(translationTarget._id), draftId(translationTarget._id)]
-    }), devLog.info("Extant translation found - will preserve existing content where possible", {
+      analysis: documentAnalysis
+    }), devLog.info("Starting Sanity agent translation", logContext), setJobStatus(dispatch, sourceDocument._id, targetLanguage, "translating");
+    const { styleGuide, omittedSections, truncatedSections } = assembleTranslationPrompt(
+      {
+        documentAnalysis,
+        isUpdate: !1,
+        // Always fresh translation in a version
+        targetLanguage,
+        sourceLanguage: sourceDocument[languageFieldName]
+      },
+      {
+        globalPrompt: translationPrompts.globalPrompt,
+        localePrompt: translationPrompts.localeInstructions[targetLanguage]?.prompt,
+        glossaryTerms: translationPrompts.localeInstructions[targetLanguage]?.glossaryTerms,
+        protectedPhrases: translationPrompts.protectedPhrases
+      }
+    );
+    devLog.info("Structured style guide generated", {
       ...logContext,
-      hasExtantTranslation: !!extantTranslation
-    })), devLog.info("Starting Sanity agent translation", logContext), setJobStatus(dispatch, sourceDocument._id, targetLanguage, "translating");
-    const styleGuide = [
-      translationPrompts.globalPrompt,
-      translationPrompts.localeInstructions[targetLanguage]?.prompt,
-      translationPrompts.localeInstructions[targetLanguage]?.glossaryTerms,
-      extantTranslation ? UPDATE_EXISTING_TRANSLATION_PROMPT : null
-    ].filter(Boolean).join(`
-
-`);
-    devLog.info("Style guide generated", {
+      styleGuideLength: styleGuide.length,
+      omittedSections,
+      truncatedSections
+    }), (omittedSections.length > 0 || truncatedSections.length > 0) && devLog.warn("Style guide adjusted to fit character limit", {
       ...logContext,
-      styleGuide
+      omittedSections,
+      truncatedSections
     });
     const newDocument = await client.agent.action.translate({
       schemaId,
       toLanguage,
       fromLanguage,
-      documentId: sourceDocument._id,
-      targetDocument: translationTarget,
+      documentId: versionedDocumentId,
+      // Use versioned document ID
       languageFieldPath: [languageFieldName],
       styleGuide,
-      styleGuideParams: {
-        extantTranslation
-      },
       protectedPhrases: translationPrompts.protectedPhrases || [],
       conditionalPaths: {
         defaultHidden: !1,
         defaultReadOnly: !1
       }
     });
-    return devLog.info("Document translation completed", {
+    return devLog.info("Sanity agent translation completed", {
       ...logContext,
       newDocumentId: newDocument._id,
       newDocumentRev: newDocument._rev
-    }), devLog.timeEnd("translateEntireDocument"), devLog.groupEnd(), newDocument;
+    }), newDocument;
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
     devLog.error(
-      "translateEntireDocument failed",
+      "Sanity agent translation failed",
       error instanceof Error ? error : new Error(String(error)),
       logContext
     ), setJobStatus(dispatch, sourceDocument._id, targetLanguage, "error", {
       errorMessage
-    }), devLog.timeEnd("translateEntireDocument"), devLog.groupEnd();
+    });
     return;
   }
-}, updateTranslationMetadata = async ({
-  client,
-  targetLanguage,
+}, translateInPlaceWithOpenAI = async ({
+  dispatch,
   sourceDocument,
-  sourceLanguage,
-  newDocument,
-  translationMetadata,
-  isNewTranslation
+  targetDocument,
+  targetLanguage,
+  languageFieldName,
+  translationPrompts,
+  openaiConfig,
+  isReview
 }) => {
+  const sourceLanguage = sourceDocument[languageFieldName], logContext = {
+    sourceId: sourceDocument._id,
+    targetId: targetDocument._id,
+    targetLanguage,
+    sourceLanguage,
+    isReview
+  };
   try {
-    const refToNewTranslation = {
-      _key: targetLanguage,
-      _type: "internationalizedArrayReferenceValue",
-      value: {
-        _type: "reference",
-        _ref: undraftId(newDocument._id),
-        _weak: !0,
-        _strengthenOnPublish: {
-          _type: "reference",
-          _weak: !1
-        }
-      }
-    }, newTranslationHistory = {
-      _key: targetLanguage,
-      language: targetLanguage,
-      sourceId: undraftId(sourceDocument._id),
-      sourceRev: sourceDocument._rev,
+    const sourceText = serializeDocument(sourceDocument), targetText = serializeDocument(targetDocument);
+    devLog.debug("Documents serialized for OpenAI", {
+      ...logContext,
+      sourceLength: sourceText.length,
+      targetLength: targetText.length
+    });
+    const prompt = isReview ? buildReviewPrompt({
+      sourceText,
+      translatedText: targetText,
       sourceLanguage,
-      sourceSnapshot: JSON.stringify(sourceDocument),
-      targetId: newDocument._id,
-      targetRev: newDocument._rev,
-      targetSnapshot: JSON.stringify(newDocument)
-    }, translationPatch = client.patch(translationMetadata._id).setIfMissing({ translations: [] });
-    isNewTranslation ? await translationPatch.insert("after", "translations[-1]", [refToNewTranslation]).commit() : await translationPatch.insert("replace", `translations[_key == "${targetLanguage}"]`, [refToNewTranslation]).commit();
-    const historyPatch = client.patch(translationMetadata._id).setIfMissing({ translationHistory: [] });
-    translationMetadata.translationHistory?.some(
-      (history) => history.language === targetLanguage
-    ) ? await historyPatch.insert("replace", `translationHistory[_key == "${targetLanguage}"]`, [newTranslationHistory]).commit() : await historyPatch.insert("after", "translationHistory[-1]", [newTranslationHistory]).commit();
+      targetLanguage,
+      translationPrompts
+    }) : buildTranslationPrompt({
+      sourceText,
+      sourceLanguage,
+      targetLanguage,
+      translationPrompts
+    });
+    devLog.debug("Calling GPT-5", {
+      ...logContext,
+      promptLength: prompt.length
+    });
+    const response = await callGPT5(openaiConfig.apiKey, {
+      messages: [
+        {
+          role: "system",
+          content: isReview ? "You are a translation quality reviewer. Review and refine translations while preserving structure." : "You are a professional translator. Translate documents while preserving their exact structure."
+        },
+        { role: "user", content: prompt }
+      ],
+      model: openaiConfig.model,
+      reasoningEffort: openaiConfig.reasoningEffort,
+      verbosity: openaiConfig.verbosity,
+      onReasoningChunk: (reasoning) => {
+        const status2 = isReview ? "reviewing_with_openai" : "translating_with_openai";
+        setJobStatus(dispatch, sourceDocument._id, targetLanguage, status2, {
+          reasoningProgress: reasoning
+        });
+      }
+    });
+    devLog.info("OpenAI operation completed", {
+      ...logContext,
+      tokensUsed: response.tokensUsed.total,
+      cost: response.cost
+    });
+    const result = deserializeDocument(targetDocument, response.content), validation = validateStructureIntegrity(targetDocument, result);
+    if (!validation.valid) {
+      devLog.error("Structure validation failed", {
+        ...logContext,
+        errors: validation.errors
+      });
+      const unexpectedErrors = validation.errors.filter(
+        (err) => !(err.path.length === 1 && err.path[0] === languageFieldName)
+      );
+      if (unexpectedErrors.length > 0)
+        throw new Error(
+          `Structure validation failed: ${unexpectedErrors.length} errors. First: ${unexpectedErrors[0].type} at ${unexpectedErrors[0].path.join(".")}`
+        );
+    }
+    devLog.info("Structure validation passed", logContext);
+    const status = isReview ? "reviewing_with_openai" : "translating_with_openai";
+    return setJobStatus(dispatch, sourceDocument._id, targetLanguage, status, {
+      tokensUsed: response.tokensUsed.total,
+      estimatedCost: response.cost,
+      reasoningSummary: response.reasoningSummary
+    }), result;
   } catch (error) {
-    throw console.error("Error updating translation metadata:", error), error;
+    throw devLog.error("OpenAI translation failed", error instanceof Error ? error : new Error(String(error)), logContext), error;
   }
+}, buildTranslationPrompt = ({
+  sourceText,
+  sourceLanguage,
+  targetLanguage,
+  translationPrompts
+}) => {
+  const { globalPrompt, localeInstructions, protectedPhrases } = translationPrompts, localePrompt = localeInstructions[targetLanguage]?.prompt, glossaryTerms = localeInstructions[targetLanguage]?.glossaryTerms;
+  return `# TRANSLATION TASK
+
+Translate this ${sourceLanguage} document into ${targetLanguage}.
+
+## Guidelines
+
+${globalPrompt ? `### General Guidelines
+${globalPrompt}
+` : ""}
+${localePrompt ? `### ${targetLanguage} Guidelines
+${localePrompt}
+` : ""}
+${glossaryTerms ? `### Required Terminology
+${glossaryTerms}
+` : ""}
+${protectedPhrases?.length ? `### Protected Phrases (do not translate)
+${protectedPhrases.join(", ")}
+` : ""}
+
+## Source Document (${sourceLanguage})
+
+\`\`\`
+${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
+
+If you used significant reasoning to make translation decisions, you may include a brief summary:
+<reasoning>
+Brief summary of key translation decisions and reasoning
+</reasoning>
+
+Then return the translated document:`;
+}, buildReviewPrompt = ({
+  sourceText,
+  translatedText,
+  sourceLanguage,
+  targetLanguage,
+  translationPrompts
+}) => {
+  const { globalPrompt, localeInstructions, protectedPhrases } = translationPrompts, localePrompt = localeInstructions[targetLanguage]?.prompt, glossaryTerms = localeInstructions[targetLanguage]?.glossaryTerms;
+  return `# TRANSLATION QUALITY REVIEW
+
+Review this ${targetLanguage} translation and return a corrected version.
+
+## Review Criteria
+
+1. **Accuracy**: Does it accurately convey the ${sourceLanguage} source meaning?
+2. **Terminology**: Are glossary terms used correctly?
+3. **Protected Phrases**: Are protected phrases preserved?
+4. **Fluency**: Is it natural and fluent in ${targetLanguage}?
+5. **Style**: Does it follow the style guide?
+6. **Completeness**: Is all content translated?
+
+## Guidelines
+
+${globalPrompt ? `### General Guidelines
+${globalPrompt}
+` : ""}
+${localePrompt ? `### ${targetLanguage} Guidelines
+${localePrompt}
+` : ""}
+${glossaryTerms ? `### Required Terminology
+${glossaryTerms}
+` : ""}
+${protectedPhrases?.length ? `### Protected Phrases (must preserve)
+${protectedPhrases.join(", ")}
+` : ""}
+
+## Source Document (${sourceLanguage})
+
+\`\`\`
+${sourceText}
+\`\`\`
+
+## Current Translation (${targetLanguage})
+
+\`\`\`
+${translatedText}
+\`\`\`
+
+## Instructions
+
+1. Review the translation for quality issues
+2. Make corrections where needed to improve accuracy, fluency, or adherence to guidelines
+3. Keep good translations as-is - only fix what needs fixing
+4. Return the corrected translation in THE EXACT SAME FORMAT
+5. **CRITICAL**: Only modify text content between tags
+6. Never add, remove, or change any tags, attributes, or structure
+
+If you made corrections or have insights about the translation quality, include a brief summary:
+<reasoning>
+Brief summary of review findings and corrections made
+</reasoning>
+
+Then return the corrected translation document:`;
 }, translateDocument = async ({
   dispatch,
   client,
@@ -1550,15 +2865,17 @@ const setupTranslationJobStatuses = (dispatch, sourceDocuments, targetLanguages)
   languageFieldName,
   shouldOverwriteFreshTranslations,
   schemaId,
-  shouldTranslateDiffs,
-  translationPrompts
+  translationPrompts,
+  translationMode,
+  openaiConfig,
+  releaseId
 }) => {
   const logContext = {
     documentId: sourceDocument._id,
     targetLanguage,
     schemaId,
-    shouldTranslateDiffs,
-    shouldOverwriteFreshTranslations
+    shouldOverwriteFreshTranslations,
+    translationMode
   };
   devLog.group("translateDocument", logContext), devLog.time("translateDocument"), setJobStatus(dispatch, sourceDocument._id, targetLanguage, "preparing_translation");
   try {
@@ -1598,48 +2915,20 @@ const setupTranslationJobStatuses = (dispatch, sourceDocuments, targetLanguages)
       operation: translationTarget.operation,
       isNewTranslation
     });
-    let newDocument;
-    if (!isNewTranslation && shouldTranslateDiffs) {
-      devLog.info("Starting diff-based translation", logContext);
-      const { currentTargetId, patch } = await patchTranslationTarget({
-        client,
-        currentSourceDocument: sourceDocument,
-        sourceLanguage,
-        translationMetadata,
-        targetLanguage
-      });
-      if (!currentTargetId) {
-        devLog.warn("No target ID found for diff translation", logContext), devLog.timeEnd("translateDocument"), devLog.groupEnd();
-        return;
-      }
-      devLog.debug("Patching translation target", {
-        ...logContext,
-        currentTargetId,
-        hasPatch: !!patch
-      }), newDocument = await translateDocumentInPlace({
-        client,
-        schemaId,
-        dispatch,
-        sourceDocument,
-        languageFieldName,
-        targetLanguage,
-        targetId: currentTargetId,
-        patch
-      });
-    } else
-      devLog.info("Starting full document translation", {
-        ...logContext,
-        translationTarget: translationTarget.operation
-      }), newDocument = await translateEntireDocument({
-        dispatch,
-        client,
-        schemaId,
-        sourceDocument,
-        targetLanguage,
-        languageFieldName,
-        translationTarget,
-        translationPrompts
-      });
+    const newDocument = await translateEntireDocument({
+      dispatch,
+      client,
+      schemaId,
+      sourceDocument,
+      targetLanguage,
+      languageFieldName,
+      translationTarget,
+      translationPrompts,
+      translationMode,
+      openaiConfig,
+      releaseId,
+      isNewTranslation
+    });
     if (!newDocument)
       throw devLog.error("Failed to create translation document", void 0, logContext), setJobStatus(dispatch, sourceDocument._id, targetLanguage, "error"), devLog.timeEnd("translateDocument"), devLog.groupEnd(), new Error("Failed to create translation document");
     return devLog.debug("Translation document created", {
@@ -1666,30 +2955,6 @@ const setupTranslationJobStatuses = (dispatch, sourceDocuments, targetLanguages)
     }), devLog.timeEnd("translateDocument"), devLog.groupEnd();
     return;
   }
-}, patchTranslationTarget = async ({
-  client,
-  currentSourceDocument,
-  translationMetadata,
-  targetLanguage
-}) => {
-  const sourceSnapshotString = translationMetadata.translationHistory.find(
-    (h) => undraftId(h.sourceId) === undraftId(currentSourceDocument._id)
-  )?.sourceSnapshot;
-  if (!sourceSnapshotString)
-    return {};
-  const sourceSnapshot = JSON.parse(sourceSnapshotString), targetId = translationMetadata.translations.find((t) => t._key === targetLanguage)?.value._ref;
-  if (!targetId)
-    return {};
-  const currentTargetId = await client.fetch(
-    '*[_id in $ids] | order((_id match "drafts*") desc)[0]._id',
-    { ids: [undraftId(targetId), draftId(targetId)] }
-  );
-  if (!currentTargetId)
-    return console.log(`No document found for ${targetId}`), {};
-  const patch = diffPatch(sourceSnapshot, currentSourceDocument, {
-    id: draftId(currentTargetId)
-  });
-  return { currentTargetId, patch };
 }, translationSemaphore = new Semaphore(2), translateDocumentSet = async ({
   client,
   sourceDocument,
@@ -1700,17 +2965,19 @@ const setupTranslationJobStatuses = (dispatch, sourceDocuments, targetLanguages)
   schemaId,
   references = [],
   maxConcurrentTranslationJobs,
-  shouldTranslateDiffs
+  translationMode,
+  openaiConfig
 }) => {
   const logContext = {
     documentId: sourceDocument._id,
     targetLanguages,
     referencesCount: references.length,
     maxConcurrentJobs: maxConcurrentTranslationJobs,
-    shouldTranslateDiffs,
+    translationMode,
     shouldOverwriteFreshTranslations
   };
   devLog.group("translateDocumentSet", logContext), devLog.time("translateDocumentSet");
+  let releaseId;
   try {
     const sourceLanguage = sourceDocument[languageFieldName];
     if (!sourceLanguage)
@@ -1722,6 +2989,22 @@ const setupTranslationJobStatuses = (dispatch, sourceDocuments, targetLanguages)
       type: "SET_OVERALL_STATUS",
       payload: "translating"
     });
+    const releaseTitle = `[AI Translation] ${sourceDocument.title || sourceDocument._id.split("-").slice(0, 2).join("-")} (${sourceDocument._type}) ${sourceLanguage} \u2192 ${targetLanguages.join(", ")}`, releaseDescription = `AI translation batch created on ${(/* @__PURE__ */ new Date()).toLocaleDateString()} at ${(/* @__PURE__ */ new Date()).toLocaleTimeString()}`;
+    devLog.info("Creating Content Release for translation batch", {
+      ...logContext,
+      releaseTitle
+    });
+    const { releaseId: newReleaseId } = await client.releases.create({
+      metadata: {
+        title: releaseTitle,
+        description: releaseDescription,
+        releaseType: "asap"
+      }
+    });
+    releaseId = newReleaseId, devLog.info("Content Release created", {
+      ...logContext,
+      releaseId
+    });
     const sourceDocuments = [
       {
         _id: sourceDocument._id,
@@ -1753,7 +3036,7 @@ const setupTranslationJobStatuses = (dispatch, sourceDocuments, targetLanguages)
             }).fetch("*[_id == $id][0]", {
               id: documentId
             });
-            if (document) {
+            if (document && releaseId) {
               const targetDocumentId = await translateDocument({
                 dispatch,
                 client,
@@ -1762,8 +3045,10 @@ const setupTranslationJobStatuses = (dispatch, sourceDocuments, targetLanguages)
                 languageFieldName,
                 shouldOverwriteFreshTranslations,
                 schemaId,
-                shouldTranslateDiffs,
-                translationPrompts
+                translationPrompts,
+                translationMode,
+                openaiConfig,
+                releaseId
               });
               targetDocumentId && targetDocumentIds.push(targetDocumentId);
             }
@@ -1811,11 +3096,24 @@ const setupTranslationJobStatuses = (dispatch, sourceDocuments, targetLanguages)
       failed
     }), dispatch({ type: "SET_OVERALL_STATUS", payload: "completed" })) : (devLog.info("Document set translation completed successfully", logContext), dispatch({ type: "SET_OVERALL_STATUS", payload: "completed" })), devLog.timeEnd("translateDocumentSet"), devLog.groupEnd();
   } 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)
+      try {
+        await client.releases.delete({ releaseId }), devLog.warn("Deleted release due to fatal error", {
+          ...logContext,
+          releaseId
+        });
+      } catch (cleanupError) {
+        devLog.error(
+          "Failed to cleanup release",
+          cleanupError instanceof Error ? cleanupError : new Error(String(cleanupError)),
+          logContext
+        );
+      }
+    throw devLog.timeEnd("translateDocumentSet"), devLog.groupEnd(), dispatch({ type: "SET_OVERALL_STATUS", payload: "error" }), error;
   }
 }, ActionButtonBar = ({ setIsDialogOpen }) => {
   const {
@@ -1826,22 +3124,50 @@ const setupTranslationJobStatuses = (dispatch, sourceDocuments, targetLanguages)
     references,
     selectedTargetLanguages,
     shouldOverwriteFreshTranslations,
-    shouldTranslateDiffs
-  } = useTranslationContext(), client = useClient({ apiVersion: "vX" });
+    translationMode
+  } = useTranslationContext(), client = useClient({ apiVersion: "vX" }), handleTranslate = useCallback(() => {
+    translateDocumentSet({
+      sourceDocument: document,
+      targetLanguages: selectedTargetLanguages,
+      client,
+      dispatch,
+      languageFieldName: config.languageFieldName,
+      schemaId: config.schemaId,
+      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(() => {
+    dispatch({
+      type: "SET_SELECTED_TARGET_LANGUAGES",
+      payload: config.supportedLanguages.map((lang) => lang.id).filter((id) => id !== document.language)
+    });
+  }, [dispatch, config.supportedLanguages, document.language]), handleSelectNone = useCallback(() => {
+    dispatch({
+      type: "SET_SELECTED_TARGET_LANGUAGES",
+      payload: []
+    });
+  }, [dispatch]);
   return /* @__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: () => {
-        dispatch({
-          type: "SET_SELECTED_TARGET_LANGUAGES",
-          payload: config.supportedLanguages.map((lang) => lang.id).filter((id) => id !== document.language)
-        });
-      }, children: "Select All" }),
-      /* @__PURE__ */ jsx(Button, { mode: "ghost", size: 2, onClick: () => {
-        dispatch({
-          type: "SET_SELECTED_TARGET_LANGUAGES",
-          payload: []
-        });
-      }, children: "Select None" })
+      /* @__PURE__ */ jsx(Button, { mode: "ghost", size: 2, onClick: handleSelectAll, children: "Select All" }),
+      /* @__PURE__ */ jsx(Button, { mode: "ghost", size: 2, onClick: handleSelectNone, children: "Select None" })
     ] }),
     /* @__PURE__ */ jsxs(Flex, { justify: "flex-end", gap: 2, children: [
       /* @__PURE__ */ jsx(Button, { onClick: () => setIsDialogOpen(!1), mode: "ghost", size: 2, children: "Cancel" }),
@@ -1851,21 +3177,7 @@ const setupTranslationJobStatuses = (dispatch, sourceDocuments, targetLanguages)
           mode: "ghost",
           tone: "positive",
           size: 2,
-          onClick: () => {
-            translateDocumentSet({
-              sourceDocument: document,
-              targetLanguages: selectedTargetLanguages,
-              client,
-              dispatch,
-              languageFieldName: config.languageFieldName,
-              schemaId: config.schemaId,
-              references,
-              shouldOverwriteFreshTranslations,
-              maxConcurrentTranslationJobs: config.maxConcurrentTranslationJobs,
-              maxReferenceDepth: config.maxReferenceDepth,
-              shouldTranslateDiffs
-            });
-          },
+          onClick: handleTranslate,
           disabled: selectedTargetLanguages.length === 0 || !["idle", "completed"].includes(overallStatus),
           children: "Translate"
         }
@@ -1910,6 +3222,88 @@ const setupTranslationJobStatuses = (dispatch, sourceDocuments, targetLanguages)
     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)) }) });
+}, TranslationModePanel = () => {
+  const { config, translationMode, openaiValidated, dispatch } = useTranslationContext();
+  if (!config?.openai?.enabled || !config?.openai?.apiKey)
+    return null;
+  if (!openaiValidated)
+    return /* @__PURE__ */ jsx(Card, { tone: "caution", padding: 4, border: !0, children: /* @__PURE__ */ jsxs(Stack, { space: 2, children: [
+      /* @__PURE__ */ jsx(Text, { weight: "semibold", children: "OpenAI Configuration" }),
+      /* @__PURE__ */ jsx(Text, { size: 1, muted: !0, children: "Validating API key..." })
+    ] }) });
+  const handleModeChange = (mode) => {
+    dispatch({
+      type: "SET_TRANSLATION_MODE",
+      payload: mode
+    });
+  };
+  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__ */ jsxs(Stack, { space: 2, children: [
+      /* @__PURE__ */ jsx(
+        Button,
+        {
+          type: "button",
+          mode: translationMode === "sanity-only" ? "ghost" : "bleed",
+          tone: translationMode === "sanity-only" ? "primary" : "default",
+          onClick: () => handleModeChange("sanity-only"),
+          children: /* @__PURE__ */ jsxs(Inline, { space: 2, children: [
+            /* @__PURE__ */ jsx(Radio, { checked: translationMode === "sanity-only", readOnly: !0 }),
+            /* @__PURE__ */ jsxs(Stack, { space: 2, children: [
+              /* @__PURE__ */ jsx(Text, { children: "Sanity Agent Only" }),
+              /* @__PURE__ */ jsx(Text, { size: 1, muted: !0, children: "Fast, reliable, and included with Sanity." })
+            ] })
+          ] })
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        Button,
+        {
+          type: "button",
+          mode: translationMode === "openai-only" ? "ghost" : "bleed",
+          tone: translationMode === "openai-only" ? "primary" : "default",
+          onClick: () => handleModeChange("openai-only"),
+          children: /* @__PURE__ */ jsxs(Inline, { space: 2, children: [
+            /* @__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(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: [
+      "\u{1F4B0} ",
+      /* @__PURE__ */ jsx("strong", { children: "OpenAI costs apply:" }),
+      " You'll be charged for API usage based on tokens processed."
+    ] }) })
+  ] }) });
 }, assembleReferences = async ({
   client,
   sourceDocument,
@@ -1934,7 +3328,14 @@ const setupTranslationJobStatuses = (dispatch, sourceDocuments, targetLanguages)
           typeof refId == "string" && refId.length > 0 && !references.has(refId) && !documentCache.has(refId) && allRefIds.add(refId);
         }
       } catch (error) {
-        console.error("assembleReferences: Error finding references in document:", error);
+        devLog.error(
+          "Error finding references in document",
+          error instanceof Error ? error : new Error(String(error)),
+          {
+            documentId: document._id,
+            component: "assembleReferences"
+          }
+        );
       }
     if (allRefIds.size === 0)
       break;
@@ -1953,16 +3354,27 @@ const setupTranslationJobStatuses = (dispatch, sourceDocuments, targetLanguages)
           }
           documentCache.set(refId, fetchedDoc), references.add(refId), nextDepthDocuments.push(fetchedDoc);
         } else
-          documentCache.set(refId, null), console.warn(`assembleReferences: Document with _id "${refId}" not found`);
+          documentCache.set(refId, null), devLog.warn(`Document with _id "${refId}" not found`, {
+            refId,
+            component: "assembleReferences"
+          });
       }
       currentDepthDocuments = nextDepthDocuments;
     } catch (fetchError) {
       const error = fetchError instanceof Error ? fetchError : new Error(String(fetchError));
-      errors.push({ refId: `batch(${refIdArray.join(",")})`, error }), console.error("assembleReferences: Failed to batch fetch documents:", error.message);
+      errors.push({ refId: `batch(${refIdArray.join(",")})`, error }), devLog.error("Failed to batch fetch documents", error, {
+        refIdCount: refIdArray.length,
+        depth,
+        component: "assembleReferences"
+      });
       break;
     }
   }
-  errors.length > 0 && console.warn(`assembleReferences: Encountered ${errors.length} error(s) while fetching references`);
+  errors.length > 0 && devLog.warn(`Encountered ${errors.length} error(s) while fetching references`, {
+    errorCount: errors.length,
+    errors: errors.map((e) => ({ refId: e.refId, message: e.error.message })),
+    component: "assembleReferences"
+  });
   const result = [];
   for (const refId of references) {
     const cachedDoc = documentCache.get(refId);
@@ -2047,7 +3459,7 @@ const setupTranslationJobStatuses = (dispatch, sourceDocuments, targetLanguages)
     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, shouldTranslateDiffs } = useTranslationContext(), handleShouldOverwriteFreshTranslationsChange = () => {
+  const { dispatch, shouldOverwriteFreshTranslations } = useTranslationContext(), handleShouldOverwriteFreshTranslationsChange = () => {
     dispatch({
       type: "SET_SHOULD_OVERWRITE_FRESH_TRANSLATIONS",
       payload: !shouldOverwriteFreshTranslations
@@ -2078,38 +3490,6 @@ const setupTranslationJobStatuses = (dispatch, sourceDocuments, targetLanguages)
           ] })
         ] })
       }
-    ) }),
-    /* @__PURE__ */ jsx(Flex, { justify: "space-between", align: "center", children: /* @__PURE__ */ jsx(
-      Button,
-      {
-        type: "button",
-        mode: shouldTranslateDiffs ? "ghost" : "bleed",
-        size: 2,
-        onClick: () => {
-          dispatch({
-            type: "SET_SHOULD_TRANSLATE_DIFFS",
-            payload: !shouldTranslateDiffs
-          });
-        },
-        tone: shouldTranslateDiffs ? "primary" : "neutral",
-        children: /* @__PURE__ */ jsxs(Inline, { space: 2, children: [
-          /* @__PURE__ */ jsx(
-            Checkbox,
-            {
-              checked: shouldTranslateDiffs,
-              onChange: handleShouldOverwriteFreshTranslationsChange,
-              label: shouldTranslateDiffs ? "Disable" : "Enable"
-            }
-          ),
-          /* @__PURE__ */ jsxs(Stack, { space: 3, children: [
-            /* @__PURE__ */ jsxs(Inline, { space: 1, children: [
-              /* @__PURE__ */ jsx(Text, { children: "Translate Diffs" }),
-              /* @__PURE__ */ jsx(Badge, { tone: "caution", children: "Experimental" })
-            ] }),
-            /* @__PURE__ */ jsx(Text, { size: 1, muted: !0, children: "Only re-translate content that has changed in the source document." })
-          ] })
-        ] })
-      }
     ) })
   ] });
 }, TranslationConfigView = ({ setIsDialogOpen }) => /* @__PURE__ */ jsxs(Stack, { space: 4, children: [
@@ -2117,16 +3497,24 @@ const setupTranslationJobStatuses = (dispatch, sourceDocuments, targetLanguages)
     /* @__PURE__ */ jsx(Label, { children: "Languages" }),
     /* @__PURE__ */ jsx(LanguageSelectionPanel, {})
   ] }),
+  /* @__PURE__ */ jsxs(Stack, { space: 2, children: [
+    /* @__PURE__ */ jsx(Label, { children: "Translation Method" }),
+    /* @__PURE__ */ jsx(TranslationModePanel, {})
+  ] }),
   /* @__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 } = useTranslationContext(), headline = useMemo(
+  const { overallStatus, translationJobs, translationMode } = useTranslationContext(), headline = useMemo(
     () => overallStatus === "completed" ? "Translation completed" : "Translation in progress",
     [overallStatus]
-  ), jobs = useMemo(() => Array.from(translationJobs.values()), [translationJobs]);
+  ), jobs = useMemo(() => Array.from(translationJobs.values()), [translationJobs]), 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 };
+  }, [jobs, translationMode]);
   return /* @__PURE__ */ jsxs(Stack, { space: 4, children: [
     /* @__PURE__ */ jsx(Heading, { size: 2, children: headline }),
     /* @__PURE__ */ jsx(ProgressBar, { progress: jobs.filter((job) => TERMINAL_STATUSES.includes(job.status)).length, max: jobs.length }),
@@ -2146,6 +3534,25 @@ const setupTranslationJobStatuses = (dispatch, sourceDocuments, targetLanguages)
               " \u2014 ",
               job._id.slice(-6)
             ] }),
+            !["completed", "skipped", "error"].includes(job.status) && /* @__PURE__ */ jsxs(Stack, { space: 2, children: [
+              /* @__PURE__ */ jsx(Text, { size: 1, weight: "semibold", children: getStatusLabel(job.status) }),
+              job.reasoningProgress && /* @__PURE__ */ jsx(Card, { tone: "primary", padding: 3, radius: 2, children: /* @__PURE__ */ jsxs(Stack, { space: 2, children: [
+                /* @__PURE__ */ jsx(Text, { size: 1, weight: "semibold", children: "\u{1F914} GPT-5 Reasoning" }),
+                /* @__PURE__ */ jsx(Text, { size: 1, style: { fontStyle: "italic" }, children: job.reasoningProgress })
+              ] }) })
+            ] }),
+            job.status === "completed" && job.tokensUsed ? /* @__PURE__ */ jsxs(Stack, { space: 2, children: [
+              /* @__PURE__ */ jsxs(Text, { size: 1, muted: !0, children: [
+                job.tokensUsed.toLocaleString(),
+                " tokens (~$",
+                job.estimatedCost?.toFixed(4),
+                ")"
+              ] }),
+              job.reasoningSummary && /* @__PURE__ */ jsx(Card, { tone: "primary", padding: 2, radius: 2, children: /* @__PURE__ */ jsxs(Text, { size: 1, children: [
+                "\u{1F4A1} ",
+                job.reasoningSummary
+              ] }) })
+            ] }) : null,
             job.status === "error" && job.errorMessage ? /* @__PURE__ */ jsx(Card, { tone: "critical", padding: 2, radius: 2, children: /* @__PURE__ */ jsxs(Text, { size: 1, children: [
               "Error: ",
               job.errorMessage
@@ -2166,7 +3573,23 @@ const setupTranslationJobStatuses = (dispatch, sourceDocuments, targetLanguages)
           ) : null
         ] })
       ] }) }) }, job._id)) }) }) })
-    ] })
+    ] }),
+    openaiStats && openaiStats.jobsWithUsage > 0 && /* @__PURE__ */ jsx(Card, { tone: "primary", padding: 4, border: !0, children: /* @__PURE__ */ jsxs(Stack, { space: 2, children: [
+      /* @__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: ",
+          /* @__PURE__ */ jsx("strong", { children: openaiStats.totalTokens.toLocaleString() })
+        ] }),
+        /* @__PURE__ */ jsxs(Text, { size: 1, children: [
+          "\u{1F4B0} Total Cost: ",
+          /* @__PURE__ */ jsxs("strong", { children: [
+            "$",
+            openaiStats.totalCost.toFixed(4)
+          ] })
+        ] })
+      ] })
+    ] }) })
   ] });
 }, ProgressBar = ({ progress, max = 100 }) => {
   const percentage = Math.min(progress / max * 100, 100);
@@ -2225,7 +3648,18 @@ const setupTranslationJobStatuses = (dispatch, sourceDocuments, targetLanguages)
     content: /* @__PURE__ */ jsx(Box, { padding: 1, children: /* @__PURE__ */ jsx(Text, { size: 1, muted: !0, children: "This translation failed. Check the error message for details." }) }),
     children: /* @__PURE__ */ jsx(Badge, { tone: "critical", children: "Failed" })
   }
-), STATES_IN_WHICH_TO_SHOW_CONFIG = ["fetching_metadata", "idle"], STATES_IN_WHICH_TO_SHOW_TRANSLATION_PROGRESS = [
+), getStatusLabel = (status) => ({
+  idle: "Idle",
+  queued: "Queued...",
+  preparing_translation: "Preparing translation...",
+  translating: "Translating with Sanity Agent...",
+  translating_with_openai: "Translating with GPT-5...",
+  reviewing_with_openai: "Reviewing translation with GPT-5...",
+  updating_metadata: "Saving metadata...",
+  error: "Error",
+  skipped: "Skipped",
+  completed: "Completed"
+})[status] || status, STATES_IN_WHICH_TO_SHOW_CONFIG = ["fetching_metadata", "idle"], STATES_IN_WHICH_TO_SHOW_TRANSLATION_PROGRESS = [
   "translating",
   "linking_references",
   "completed"