@braze/sanity-plugin-ai-translation 0.1.0

package/dist/index.js

@@ -0,0 +1,2225 @@
+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 { useListeningQuery, useOpenInNewPane } from "sanity-plugin-utils";
+import defaults from "lodash.defaults";
+import { diffPatch } from "@sanity/diff-patch";
+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,
+  dispatch: () => {
+  }
+}), useTranslationContext = () => {
+  const context = useContext(TranslationContext);
+  if (!context.document || !context.config)
+    throw new Error(
+      "useTranslationContext must be used within a TranslationContextProvider with document and config props"
+    );
+  return context;
+}, TRANSLATION_METADATA_TYPE = "translation.metadata", 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 }) => {
+  const { dispatch } = useTranslationContext(), { data, loading, error } = useListeningQuery(TRANSLATION_METADATA_QUERY, {
+    params: {
+      documentId: undraftId(documentId),
+      translationMetadataType: TRANSLATION_METADATA_TYPE
+    },
+    initialValue: null
+  });
+  return useEffect(() => {
+    if (loading) {
+      dispatch({ type: "SET_OVERALL_STATUS", payload: "fetching_metadata" });
+      return;
+    }
+    if (error) {
+      dispatch({ type: "SET_OVERALL_STATUS", payload: "error" });
+      return;
+    }
+    if (data) {
+      dispatch({ type: "SET_TRANSLATION_METADATA", payload: data }), dispatch({ type: "SET_OVERALL_STATUS", payload: "idle" });
+      return;
+    }
+    dispatch({ type: "SET_OVERALL_STATUS", payload: "idle" });
+  }, [data, loading, error, dispatch]), {
+    data,
+    loading,
+    error
+  };
+}, isLoggingEnabled = () => process.env.NEXT_PUBLIC_SANITY_STUDIO_AI_TRANSLATION_PLUGIN_LOGGING === "true", devLog = {
+  info: (message, context) => {
+    isLoggingEnabled() && console.info("[AI Translation]", message, context ? JSON.stringify(context, null, 2) : "");
+  },
+  warn: (message, context) => {
+    isLoggingEnabled() && console.warn("[AI Translation]", message, context ? JSON.stringify(context, null, 2) : "");
+  },
+  error: (message, error, context) => {
+    isLoggingEnabled() && console.error("[AI Translation]", message, error, context ? JSON.stringify(context, null, 2) : "");
+  },
+  debug: (message, data, context) => {
+    isLoggingEnabled() && console.debug("[AI Translation]", message, data, context ? JSON.stringify(context, null, 2) : "");
+  },
+  group: (label, context) => {
+    isLoggingEnabled() && console.group(`[AI Translation] ${label}`, context ? JSON.stringify(context, null, 2) : "");
+  },
+  groupEnd: () => {
+    isLoggingEnabled() && console.groupEnd();
+  },
+  time: (label) => {
+    isLoggingEnabled() && console.time(`[AI Translation] ${label}`);
+  },
+  timeEnd: (label) => {
+    isLoggingEnabled() && console.timeEnd(`[AI Translation] ${label}`);
+  }
+};
+async function analyzeFeedback({
+  client,
+  sourceLanguage,
+  targetLanguage,
+  userFeedback,
+  shouldIncludeEdits,
+  sourceSnapshot,
+  targetSnapshot,
+  currentDocument,
+  onProgress
+}) {
+  devLog.info("Starting feedback analysis", {
+    sourceLanguage,
+    targetLanguage,
+    hasUserFeedback: !!userFeedback,
+    shouldIncludeEdits
+  }), onProgress?.({ stage: "analyzing", message: "Analyzing feedback and edits..." });
+  const analysisPrompt = buildAnalysisPrompt({
+    sourceLanguage,
+    targetLanguage,
+    userFeedback,
+    shouldIncludeEdits,
+    sourceSnapshot,
+    targetSnapshot,
+    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;
+}
+async function applySuggestions({
+  client,
+  schemaId,
+  sourceLanguage,
+  targetLanguage,
+  suggestions,
+  onProgress
+}) {
+  devLog.info("Applying suggestions", {
+    sourceLanguage,
+    targetLanguage,
+    count: suggestions.filter((s) => s.approved).length
+  });
+  const approvedSuggestions = suggestions.filter((s) => s.approved);
+  if (approvedSuggestions.length === 0) {
+    devLog.info("No approved suggestions to apply");
+    return;
+  }
+  onProgress?.({ stage: "applying", message: "Applying updates to translation settings..." }), await applyImprovementsFromSuggestions(client, schemaId, sourceLanguage, approvedSuggestions, onProgress), devLog.info("Suggestions applied successfully");
+}
+function buildAnalysisPrompt({
+  sourceLanguage,
+  targetLanguage,
+  userFeedback,
+  shouldIncludeEdits,
+  sourceSnapshot,
+  targetSnapshot,
+  currentDocument
+}) {
+  const parts = [
+    "You are analyzing feedback about AI translation quality to improve future translations.",
+    `Source language: ${sourceLanguage}`,
+    `Target language: ${targetLanguage}`,
+    "",
+    "Your task is to analyze the feedback and infer specific improvements to:",
+    "1. Global translation prompt (general guidance for all translations)",
+    "2. Locale-specific prompt (guidance specific to this target language)",
+    "3. Protected phrases (terms that should never be translated)",
+    "4. Glossary terms (specific term-to-term translation mappings)",
+    ""
+  ];
+  return userFeedback && parts.push("USER FEEDBACK:", userFeedback, ""), shouldIncludeEdits && sourceSnapshot && targetSnapshot && currentDocument && parts.push(
+    "EDIT ANALYSIS:",
+    "Compare the original translation with the edited version to understand what the user changed.",
+    "",
+    "Original source document:",
+    sourceSnapshot,
+    "",
+    "Original AI translation:",
+    targetSnapshot,
+    "",
+    "Current edited document:",
+    JSON.stringify(currentDocument, null, 2),
+    ""
+  ), parts.push(
+    "INSTRUCTIONS:",
+    "Analyze the feedback and/or edits to identify patterns and improvements.",
+    "",
+    "For edits, look for:",
+    "- Terminology changes that suggest glossary additions",
+    "- Phrases that were protected/unprotected incorrectly",
+    "- Style, tone, or formatting issues that suggest prompt improvements",
+    "- Consistent patterns across multiple changes",
+    "",
+    "IMPORTANT RULES:",
+    "1. DO NOT create redundant updates. Choose ONE mechanism for each issue:",
+    "   - Protected phrases = terms that should NEVER be translated (language-agnostic)",
+    '   - Glossary terms = specific translation mappings (e.g., "chat" \u2192 "cat" in French)',
+    "   - Locale prompts = guidance specific to this source\u2192target language pair",
+    "   - Global prompts = guidance that applies to ALL translations",
+    "",
+    "2. Be locale-specific:",
+    `   - This feedback is specifically about ${sourceLanguage} \u2192 ${targetLanguage} translation`,
+    "   - DO NOT assume rules apply to other language pairs unless explicitly stated",
+    "   - Prefer locale-specific prompts over global prompts unless universally applicable",
+    "",
+    "3. Protected phrases vs. Locale prompts:",
+    "   - Use protected phrases ONLY for brand names, product names, proper nouns, technical terms that should NEVER be translated in ANY language",
+    '   - Use locale prompts for language-pair-specific guidance (e.g., "Keep technical terms in English when translating to German")',
+    "   - NEVER mention specific terms in both protected phrases AND prompts",
+    "",
+    "4. Glossary vs. Protected phrases:",
+    '   - Glossary = "Always translate X as Y" (provides the correct translation)',
+    '   - Protected = "Never translate X" (keeps it as-is)',
+    "   - CRITICAL: If sourceValue === targetValue, use PROTECTED PHRASES, NOT glossary",
+    "   - Only use glossary when the term actually changes between languages",
+    "   - Use protected when the term should remain unchanged across all languages",
+    "",
+    "Output a JSON object with this structure:",
+    "{",
+    '  "globalPromptUpdates": "string | null - ONLY if this applies to ALL language pairs",',
+    `  "localePromptUpdates": "string | null - ONLY if this is specific to ${sourceLanguage}\u2192${targetLanguage}",`,
+    '  "protectedPhrasesToAdd": ["ONLY brand names, products, proper nouns that should NEVER translate"],',
+    '  "glossaryTermsToAdd": [{"sourceValue": "term", "targetValue": "translation"} - ONLY specific term mappings],',
+    '  "reasoning": "string - Explain your analysis and which mechanism you chose for each issue"',
+    "}",
+    "",
+    "Be conservative: only suggest changes when there is clear evidence.",
+    "If in doubt, prefer locale-specific updates over global updates.",
+    "Avoid redundancy - if you add a protected phrase, do NOT mention it in prompts."
+  ), parts.join(`
+`);
+}
+function convertAnalysisToSuggestions(analysis) {
+  const suggestions = [];
+  if (analysis.globalPromptUpdates && suggestions.push({
+    id: crypto.randomUUID(),
+    type: "globalPrompt",
+    description: analysis.globalPromptUpdates,
+    approved: !0
+  }), analysis.localePromptUpdates && suggestions.push({
+    id: crypto.randomUUID(),
+    type: "localePrompt",
+    description: analysis.localePromptUpdates,
+    approved: !0
+  }), analysis.protectedPhrasesToAdd)
+    for (const phrase of analysis.protectedPhrasesToAdd)
+      suggestions.push({
+        id: crypto.randomUUID(),
+        type: "protectedPhrase",
+        description: phrase,
+        approved: !0
+      });
+  if (analysis.glossaryTermsToAdd)
+    for (const term of analysis.glossaryTermsToAdd)
+      suggestions.push({
+        id: crypto.randomUUID(),
+        type: "glossaryTerm",
+        description: `${term.sourceValue} \u2192 ${term.targetValue}`,
+        approved: !0,
+        sourceValue: term.sourceValue,
+        targetValue: term.targetValue
+      });
+  return suggestions;
+}
+async function analyzeWithAI(client, prompt) {
+  try {
+    const response = await client.agent.action.prompt({
+      instruction: prompt,
+      format: "json"
+    });
+    devLog.debug("AI response received", { responseType: typeof response });
+    const responseText = typeof response == "string" ? response : response && typeof response == "object" ? JSON.stringify(response) : (() => {
+      throw new Error(`Unexpected response type: ${typeof response}`);
+    })();
+    return parseAIResponse(responseText);
+  } catch (error) {
+    throw devLog.error("Error during AI analysis", { error }), new Error(`Failed to analyze feedback: ${error instanceof Error ? error.message : "Unknown error"}`);
+  }
+}
+function parseAIResponse(responseText) {
+  try {
+    let parsed;
+    try {
+      parsed = JSON.parse(responseText);
+    } catch {
+      const jsonMatch = responseText.match(/\{[\s\S]*\}/);
+      if (!jsonMatch) throw new Error("No JSON found in AI response");
+      parsed = JSON.parse(jsonMatch[0]);
+    }
+    if (!parsed || typeof parsed != "object")
+      throw new Error("Response is not a valid object");
+    const analysis = parsed;
+    if (typeof analysis.reasoning != "string")
+      throw new Error("Invalid response structure: missing reasoning");
+    return {
+      globalPromptUpdates: analysis.globalPromptUpdates || void 0,
+      localePromptUpdates: analysis.localePromptUpdates || void 0,
+      protectedPhrasesToAdd: Array.isArray(analysis.protectedPhrasesToAdd) ? analysis.protectedPhrasesToAdd : [],
+      glossaryTermsToAdd: Array.isArray(analysis.glossaryTermsToAdd) ? analysis.glossaryTermsToAdd : [],
+      reasoning: analysis.reasoning
+    };
+  } catch (error) {
+    throw devLog.error("Error parsing AI response", { error, responseText }), new Error("Failed to parse AI response as JSON");
+  }
+}
+async function applyImprovementsFromSuggestions(client, sourceLanguage, targetLanguage, suggestions, onProgress) {
+  devLog.info("Applying improvements from suggestions", { count: suggestions.length });
+  const settingsId = "translation-settings";
+  await client.fetch("*[_id == $id][0]", { id: settingsId }) || await client.createIfNotExists({
+    _id: settingsId,
+    _type: "translationSettings"
+  });
+  const updates = [], globalPrompts = suggestions.filter((s) => s.type === "globalPrompt" && s.description.trim()), localePrompts = suggestions.filter((s) => s.type === "localePrompt" && s.description.trim()), protectedPhrases = suggestions.filter((s) => s.type === "protectedPhrase" && s.description.trim()), glossaryTerms = suggestions.filter(
+    (s) => s.type === "glossaryTerm" && s.sourceValue?.trim() && s.targetValue?.trim()
+  );
+  if (devLog.info("Filtered suggestions by type", {
+    globalPrompts: globalPrompts.length,
+    localePrompts: localePrompts.length,
+    protectedPhrases: protectedPhrases.length,
+    glossaryTerms: glossaryTerms.length
+  }), globalPrompts.length > 0) {
+    onProgress?.({ stage: "applying", message: "Updating global translation prompt..." });
+    const combinedUpdate = globalPrompts.map((s) => s.description).join(`
+
+`);
+    devLog.debug("Applying global prompt update", { combinedUpdate }), updates.push(updateGlobalPrompt(client, settingsId, combinedUpdate));
+  }
+  if (localePrompts.length > 0) {
+    onProgress?.({ stage: "applying", message: `Updating ${targetLanguage} translation prompt...` });
+    const combinedUpdate = localePrompts.map((s) => s.description).join(`
+
+`);
+    devLog.debug("Applying locale prompt update", { targetLanguage, combinedUpdate }), updates.push(updateLocalePrompt(client, settingsId, targetLanguage, combinedUpdate));
+  }
+  if (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));
+  }
+  if (glossaryTerms.length > 0) {
+    onProgress?.({ stage: "applying", message: "Adding glossary terms..." });
+    const terms = glossaryTerms.map((s) => ({
+      // biome-ignore-start lint/style/noNonNullAssertion: safely handled
+      sourceValue: s.sourceValue,
+      targetValue: s.targetValue
+      // biome-ignore-end lint/style/noNonNullAssertion: safely handled
+    }));
+    devLog.debug("Applying glossary terms", { terms }), updates.push(addGlossaryTerms(client, terms, sourceLanguage, targetLanguage));
+  }
+  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");
+}
+async function mergePromptWithAI(client, currentPrompt, newGuidance, context) {
+  const instruction = `
+You are updating a ${context === "global" ? "translation" : `locale-specific translation for ${context}`} prompt.
+Your task is to merge new guidance into an existing prompt.
+
+CURRENT PROMPT:
+${currentPrompt}
+
+NEW GUIDANCE TO ADD:
+${newGuidance}
+
+INSTRUCTIONS:
+- Read the current prompt carefully
+- Integrate the new guidance into the prompt in a natural, coherent way
+- If the new guidance conflicts with existing content, update or replace the conflicting parts
+- If the new guidance is already covered, do not add redundant text
+- Maintain the structure and tone of the prompt
+- Output ONLY the updated prompt text, with no preamble or explanation
+
+OUTPUT THE UPDATED PROMPT:`.trim(), mergedPrompt = await client.agent.action.prompt({
+    instruction,
+    format: "string"
+  });
+  return devLog.debug("AI merged prompt", {
+    context,
+    originalLength: currentPrompt.length,
+    newLength: mergedPrompt.length
+  }), mergedPrompt;
+}
+async function updateGlobalPrompt(client, settingsId, updates) {
+  devLog.info("Updating global prompt", { settingsId, updatesLength: updates.length });
+  const currentPrompt = await client.fetch("*[_id == $settingsId][0].globalPrompt", { settingsId });
+  devLog.debug("Fetched current global prompt", {
+    hasCurrentPrompt: !!currentPrompt,
+    currentLength: currentPrompt?.length
+  });
+  const newPrompt = currentPrompt ? await mergePromptWithAI(client, currentPrompt, updates, "global") : updates, result = await client.patch(settingsId).set({ globalPrompt: newPrompt.trim() }).commit();
+  devLog.info("Global prompt updated", { resultId: result._id, newPromptLength: newPrompt.length });
+}
+async function updateLocalePrompt(client, settingsId, locale, updates) {
+  devLog.info("Updating locale prompt", { settingsId, locale, updatesLength: updates.length });
+  const currentLocalePrompts = await client.fetch(
+    "*[_id == $settingsId][0].localePrompts",
+    { settingsId }
+  );
+  devLog.debug("Fetched current locale prompts", { count: currentLocalePrompts?.length });
+  const existingPrompt = currentLocalePrompts?.find((lp) => lp.locale === locale);
+  if (devLog.debug("Found existing prompt for locale", { locale, hasExisting: !!existingPrompt }), existingPrompt?.prompt) {
+    const newPrompt = await mergePromptWithAI(client, existingPrompt.prompt, updates, locale), updatedPrompts = currentLocalePrompts.map(
+      (lp) => lp.locale === locale ? { ...lp, prompt: newPrompt.trim() } : lp
+    ), result = await client.patch(settingsId).set({ localePrompts: updatedPrompts }).commit();
+    devLog.info("Locale prompt updated (merged)", { locale, resultId: result._id });
+  } else {
+    const result = await client.patch(settingsId).setIfMissing({ localePrompts: [] }).append("localePrompts", [
+      {
+        _type: "localePrompt",
+        _key: locale,
+        locale,
+        prompt: updates.trim()
+      }
+    ]).commit();
+    devLog.info("Locale prompt created", { locale, resultId: result._id });
+  }
+}
+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) {
+    devLog.info("No new protected phrases to add (all already exist)");
+    return;
+  }
+  const result = await client.patch(settingsId).setIfMissing({ protectedPhrases: [] }).append("protectedPhrases", newPhrases).commit();
+  devLog.info("Protected phrases added", { count: newPhrases.length, phrases: newPhrases, resultId: result._id });
+}
+async function addGlossaryTerms(client, terms, sourceLocale, targetLocale) {
+  const validTerms = terms.filter(({ sourceValue, targetValue }) => sourceValue === targetValue ? (devLog.warn("Skipping glossary term where source === target (should be a protected phrase)", {
+    sourceValue,
+    targetValue
+  }), !1) : !0);
+  if (validTerms.length === 0) {
+    devLog.info("No valid glossary terms to add");
+    return;
+  }
+  for (const { sourceValue, targetValue } of validTerms) {
+    const existingTerm = await client.fetch(
+      `*[_type == "translationGlossaryTerm"
+        && count(translations[locale == $sourceLocale && value == $sourceValue]) > 0
+      ][0] {
+        _id,
+        translations
+      }`,
+      { sourceLocale, sourceValue }
+    );
+    existingTerm ? existingTerm.translations.some(
+      (t) => t.locale === targetLocale && t.value === targetValue
+    ) ? devLog.info("Glossary term already has this translation", { sourceValue, targetValue, targetLocale }) : (await client.patch(existingTerm._id).append("translations", [
+      {
+        _type: "translation",
+        _key: targetLocale,
+        locale: targetLocale,
+        value: targetValue
+      }
+    ]).commit(), devLog.info("Updated existing glossary term", { sourceValue, targetValue, targetLocale })) : (await client.create({
+      _type: "translationGlossaryTerm",
+      translations: [
+        {
+          _type: "translation",
+          _key: sourceLocale,
+          locale: sourceLocale,
+          value: sourceValue
+        },
+        {
+          _type: "translation",
+          _key: targetLocale,
+          locale: targetLocale,
+          value: targetValue
+        }
+      ]
+    }), devLog.info("Created new glossary term", { sourceLocale, sourceValue, targetLocale, targetValue }));
+  }
+  devLog.info("Glossary terms processed", {
+    totalRequested: terms.length,
+    validAdded: validTerms.length,
+    skipped: terms.length - validTerms.length
+  });
+}
+const ICON_SIZE = 64, progressIconMap = {
+  in_progress: /* @__PURE__ */ jsx(Spinner, {}),
+  completed: /* @__PURE__ */ jsx(CheckmarkCircleIcon, { fontSize: ICON_SIZE }),
+  error: /* @__PURE__ */ jsx(ErrorOutlineIcon, { fontSize: ICON_SIZE })
+}, ProgressPanel = ({
+  title,
+  description,
+  tone,
+  status = "in_progress",
+  icon,
+  ...props
+}) => /* @__PURE__ */ jsx(Card, { tone, padding: 4, ...props, children: /* @__PURE__ */ jsxs(Flex, { gap: 4, align: "center", justify: "center", children: [
+  icon || progressIconMap[status],
+  /* @__PURE__ */ jsxs(Stack, { space: 3, children: [
+    title && /* @__PURE__ */ jsx(Text, { size: 2, weight: "bold", children: title }),
+    description && /* @__PURE__ */ jsx(Text, { size: 1, muted: !0, children: description })
+  ] })
+] }) }), IMPROVEMENT_TYPE_LABELS = {
+  globalPrompt: "Global Prompt",
+  localePrompt: "Locale Prompt",
+  protectedPhrase: "Protected Phrase",
+  glossaryTerm: "Glossary Term"
+}, createNewSuggestion = (type = "protectedPhrase") => {
+  const baseSuggestion = {
+    id: crypto.randomUUID(),
+    type,
+    description: "",
+    approved: !0
+  };
+  return type === "glossaryTerm" ? {
+    ...baseSuggestion,
+    sourceValue: "",
+    targetValue: ""
+  } : baseSuggestion;
+}, SuggestionReviewList = ({ suggestions, onSuggestionsChange }) => {
+  const [editingId, setEditingId] = useState(null), handleToggleApproval = (id) => {
+    const updated = suggestions.map((s) => s.id === id ? { ...s, approved: !s.approved } : s);
+    onSuggestionsChange(updated);
+  }, handleTypeChange = (id, newType) => {
+    const updated = suggestions.map((s) => {
+      if (s.id !== id)
+        return s;
+      if (newType === "glossaryTerm" && s.type !== "glossaryTerm") {
+        const match = s.description.match(/^(.+?)\s*→\s*(.+)$/);
+        return {
+          ...s,
+          type: newType,
+          sourceValue: match ? match[1].trim() : "",
+          targetValue: match ? match[2].trim() : ""
+        };
+      }
+      return newType !== "glossaryTerm" && s.type === "glossaryTerm" ? {
+        ...s,
+        type: newType,
+        description: s.sourceValue && s.targetValue ? `${s.sourceValue} \u2192 ${s.targetValue}` : s.description,
+        sourceValue: void 0,
+        targetValue: void 0
+      } : { ...s, type: newType };
+    });
+    onSuggestionsChange(updated);
+  }, handleDescriptionChange = (id, newDescription) => {
+    const updated = suggestions.map((s) => s.id === id ? { ...s, description: newDescription } : s);
+    onSuggestionsChange(updated);
+  }, handleGlossarySourceChange = (id, newSource) => {
+    const updated = suggestions.map(
+      (s) => s.id === id ? {
+        ...s,
+        sourceValue: newSource,
+        description: `${newSource} \u2192 ${s.targetValue || ""}`
+      } : s
+    );
+    onSuggestionsChange(updated);
+  }, handleGlossaryTargetChange = (id, newTarget) => {
+    const updated = suggestions.map(
+      (s) => s.id === id ? {
+        ...s,
+        targetValue: newTarget,
+        description: `${s.sourceValue || ""} \u2192 ${newTarget}`
+      } : s
+    );
+    onSuggestionsChange(updated);
+  }, handleRemove = (id) => {
+    const updated = suggestions.filter((s) => s.id !== id);
+    onSuggestionsChange(updated);
+  }, handleAddSuggestion = (type) => {
+    const newSuggestion = createNewSuggestion(type);
+    onSuggestionsChange([...suggestions, newSuggestion]), setEditingId(newSuggestion.id);
+  };
+  return suggestions.length === 0 ? /* @__PURE__ */ jsxs(Stack, { space: 3, children: [
+    /* @__PURE__ */ jsx(
+      ProgressPanel,
+      {
+        status: "error",
+        tone: "transparent",
+        title: "No suggestions generated",
+        description: 'Try providing more specific feedback or enabling "Include Edits".',
+        icon: /* @__PURE__ */ jsx(EmptyIcon, { fontSize: 24 })
+      }
+    ),
+    /* @__PURE__ */ jsx(Flex, { justify: "flex-start", children: /* @__PURE__ */ jsx(
+      Button,
+      {
+        mode: "ghost",
+        tone: "primary",
+        icon: AddIcon,
+        text: "Add Suggestion",
+        fontSize: 1,
+        onClick: () => handleAddSuggestion("protectedPhrase")
+      }
+    ) })
+  ] }) : /* @__PURE__ */ jsxs(Stack, { space: 3, children: [
+    suggestions.map((suggestion) => {
+      const isEditing = editingId === suggestion.id, isGlossaryTerm = suggestion.type === "glossaryTerm", isPrompt = suggestion.type === "globalPrompt" || suggestion.type === "localePrompt";
+      return /* @__PURE__ */ jsx(
+        Card,
+        {
+          padding: 4,
+          border: !0,
+          tone: 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__ */ jsxs(Stack, { space: 3, flex: 1, children: [
+              /* @__PURE__ */ jsxs(Flex, { gap: 2, align: "center", wrap: "wrap", children: [
+                /* @__PURE__ */ jsx(Box, { flex: 1, style: { minWidth: "200px" }, children: /* @__PURE__ */ jsx(
+                  Select,
+                  {
+                    fontSize: 1,
+                    value: suggestion.type,
+                    onChange: (event) => handleTypeChange(suggestion.id, event.currentTarget.value),
+                    children: Object.entries(IMPROVEMENT_TYPE_LABELS).map(([value, label]) => /* @__PURE__ */ jsx("option", { value, children: label }, value))
+                  }
+                ) }),
+                /* @__PURE__ */ jsx(
+                  Button,
+                  {
+                    mode: "bleed",
+                    tone: "critical",
+                    icon: TrashIcon,
+                    fontSize: 1,
+                    padding: 2,
+                    onClick: () => handleRemove(suggestion.id)
+                  }
+                )
+              ] }),
+              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(
+                TextArea,
+                {
+                  fontSize: 1,
+                  rows: isEditing ? 6 : 3,
+                  value: suggestion.description,
+                  onChange: (event) => handleDescriptionChange(suggestion.id, event.currentTarget.value),
+                  onFocus: () => setEditingId(suggestion.id),
+                  onBlur: () => setEditingId(null),
+                  placeholder: "Enter prompt guidance..."
+                }
+              ) }) : /* @__PURE__ */ jsx(
+                TextInput,
+                {
+                  fontSize: 1,
+                  value: suggestion.description,
+                  onChange: (event) => handleDescriptionChange(suggestion.id, event.currentTarget.value),
+                  placeholder: "Enter protected phrase..."
+                }
+              )
+            ] })
+          ] }) })
+        },
+        suggestion.id
+      );
+    }),
+    /* @__PURE__ */ jsx(Flex, { justify: "flex-start", children: /* @__PURE__ */ jsx(
+      Button,
+      {
+        mode: "ghost",
+        tone: "neutral",
+        icon: AddIcon,
+        text: "Add Suggestion",
+        fontSize: 1,
+        onClick: () => handleAddSuggestion("protectedPhrase")
+      }
+    ) })
+  ] });
+}, GiveFeedbackDialog = ({ setIsDialogOpen }) => {
+  const client = useClient({ apiVersion: "vX" }), { document, config, translationMetadata } = useTranslationContext(), { loading } = useTranslationMetadata({
+    documentId: document._id
+  }), [feedback, setFeedback] = useState(""), [shouldIncludeEdits, setShouldIncludeEdits] = useState(!1), [processingState, setProcessingState] = useState("idle"), [suggestions, setSuggestions] = useState([]), [changeSummary, setChangeSummary] = useState(""), [error, setError] = useState(""), handleShouldIncludeEditsChange = () => {
+    setShouldIncludeEdits(!shouldIncludeEdits);
+  }, handleCancel = () => {
+    setIsDialogOpen(!1);
+  }, handleAnalyze = async () => {
+    if (!feedback && !shouldIncludeEdits) {
+      setError('Please provide feedback or enable "Include Edits"');
+      return;
+    }
+    if (!config) {
+      setError("Missing plugin configuration");
+      return;
+    }
+    setError(""), setProcessingState("analyzing"), setChangeSummary("");
+    try {
+      const translationHistory2 = translationMetadata?.translationHistory?.find(
+        (history) => history.language === document[config.languageFieldName]
+      );
+      if (!translationHistory2)
+        throw new Error(
+          "No translation history found for this document. Please ensure this document was translated using the AI Translation plugin."
+        );
+      const { sourceSnapshot, targetSnapshot, sourceLanguage } = translationHistory2;
+      if (!sourceSnapshot || !targetSnapshot)
+        throw new Error("Translation snapshots are missing from history.");
+      const generatedSuggestions = await analyzeFeedback({
+        client,
+        schemaId: config.schemaId,
+        sourceLanguage: sourceLanguage || "en-us",
+        targetLanguage: document[config.languageFieldName],
+        userFeedback: feedback || void 0,
+        shouldIncludeEdits,
+        sourceSnapshot,
+        targetSnapshot,
+        currentDocument: shouldIncludeEdits ? document : void 0,
+        onProgress: ({ stage, message }) => {
+          setProcessingState(stage), setChangeSummary(message);
+        }
+      });
+      setSuggestions(generatedSuggestions), setProcessingState("reviewing");
+    } catch (err) {
+      console.error("Error analyzing feedback:", err), setError(err instanceof Error ? err.message : "An unexpected error occurred"), setProcessingState("error");
+    }
+  }, handleApplySuggestions = async () => {
+    if (!config) {
+      setError("Missing plugin configuration");
+      return;
+    }
+    if (suggestions.filter((s) => s.approved).length === 0) {
+      setError("Please approve at least one suggestion to apply");
+      return;
+    }
+    setError(""), setProcessingState("applying");
+    try {
+      const translationHistory2 = translationMetadata?.translationHistory?.find(
+        (history) => history.language === document[config.languageFieldName]
+      );
+      if (!translationHistory2)
+        throw new Error("Translation history not found");
+      await applySuggestions({
+        client,
+        schemaId: config.schemaId,
+        sourceLanguage: translationHistory2.sourceLanguage || "en-us",
+        targetLanguage: document[config.languageFieldName],
+        suggestions,
+        onProgress: ({ stage, message }) => {
+          setProcessingState(stage), setChangeSummary(message);
+        }
+      }), setProcessingState("completed");
+    } catch (err) {
+      console.error("Error applying suggestions:", err), setError(err instanceof Error ? err.message : "An unexpected error occurred"), setProcessingState("error");
+    }
+  };
+  if (loading)
+    return /* @__PURE__ */ jsx(ProgressPanel, { title: "Loading translation metadata" });
+  if (processingState === "analyzing")
+    return /* @__PURE__ */ jsx(ProgressPanel, { title: "Analyzing feedback with AI...", description: changeSummary });
+  if (processingState === "reviewing")
+    return /* @__PURE__ */ jsxs(Stack, { space: 4, children: [
+      /* @__PURE__ */ jsxs(Stack, { space: 4, children: [
+        /* @__PURE__ */ jsx(Heading, { children: "Review Suggestions" }),
+        /* @__PURE__ */ jsx(Text, { muted: !0, children: "The AI has analyzed your feedback and generated the following suggestions. Review and edit them before applying." })
+      ] }),
+      /* @__PURE__ */ jsx(SuggestionReviewList, { suggestions, onSuggestionsChange: setSuggestions }),
+      error && /* @__PURE__ */ jsx(Card, { padding: 3, tone: "critical", border: !0, children: /* @__PURE__ */ jsx(Text, { size: 1, children: error }) }),
+      /* @__PURE__ */ jsxs(Flex, { justify: "space-between", gap: 2, paddingTop: 2, children: [
+        /* @__PURE__ */ jsx(Flex, { gap: 2, children: /* @__PURE__ */ jsx(
+          Button,
+          {
+            type: "button",
+            mode: "bleed",
+            tone: "neutral",
+            onClick: () => setProcessingState("idle"),
+            icon: /* @__PURE__ */ jsx(ArrowLeftIcon, {}),
+            text: "Back"
+          }
+        ) }),
+        /* @__PURE__ */ jsxs(
+          Button,
+          {
+            type: "button",
+            mode: "ghost",
+            tone: "positive",
+            size: 1,
+            onClick: handleApplySuggestions,
+            disabled: suggestions.filter((s) => s.approved).length === 0,
+            children: [
+              "Apply ",
+              suggestions.filter((s) => s.approved).length,
+              " Suggestion",
+              suggestions.filter((s) => s.approved).length !== 1 ? "s" : ""
+            ]
+          }
+        )
+      ] })
+    ] });
+  if (processingState === "applying")
+    return /* @__PURE__ */ jsx(ProgressPanel, { title: "Updating translation settings...", description: changeSummary, icon: /* @__PURE__ */ jsx(EditIcon, {}) });
+  if (processingState === "completed") {
+    const appliedCount = suggestions.filter((s) => s.approved).length, description = `${appliedCount} suggestion${appliedCount !== 1 ? "s" : ""} applied. Translation prompts and glossary havebeen updated based on your feedback.`;
+    return /* @__PURE__ */ jsxs(Box, { padding: 4, children: [
+      /* @__PURE__ */ jsx(ProgressPanel, { title: "Translation settings updated", description, status: "completed" }),
+      /* @__PURE__ */ jsx(Flex, { justify: "flex-end", paddingTop: 3, children: /* @__PURE__ */ jsx(Button, { type: "button", mode: "ghost", tone: "primary", size: 1, onClick: handleCancel, children: "Close" }) })
+    ] });
+  }
+  return processingState === "error" ? /* @__PURE__ */ jsx(Box, { padding: 4, children: /* @__PURE__ */ jsxs(Stack, { space: 4, children: [
+    /* @__PURE__ */ jsx(ProgressPanel, { status: "error", title: "Error processing feedback", description: error, tone: "critical" }),
+    /* @__PURE__ */ jsxs(Flex, { justify: "flex-end", gap: 2, children: [
+      /* @__PURE__ */ jsx(Button, { type: "button", mode: "ghost", onClick: handleCancel, children: "Close" }),
+      /* @__PURE__ */ jsx(Button, { type: "reset", mode: "ghost", tone: "primary", onClick: () => setProcessingState("idle"), children: "Reset" })
+    ] })
+  ] }) }) : /* @__PURE__ */ jsxs(Stack, { space: 4, children: [
+    /* @__PURE__ */ jsx(Card, { tone: "transparent", padding: 4, children: /* @__PURE__ */ jsxs(Stack, { space: 4, children: [
+      /* @__PURE__ */ jsx(Stack, { space: 2, children: /* @__PURE__ */ jsxs(Stack, { space: 4, children: [
+        /* @__PURE__ */ jsxs(Inline, { space: 2, children: [
+          /* @__PURE__ */ jsx(Text, { size: 2, muted: !0, children: "Enter your feedback for the translation AI agent." }),
+          /* @__PURE__ */ jsx(
+            Tooltip,
+            {
+              portal: !0,
+              content: /* @__PURE__ */ jsx(Box, { padding: 2, style: { maxWidth: "280px" }, children: /* @__PURE__ */ jsx(Text, { size: 1, children: "The AI agent will use your feedback to improve translation prompts, update protected phrases, and modify the glossary. Be specific about what should be changed." }) }),
+              children: /* @__PURE__ */ jsx(Text, { size: 1, children: /* @__PURE__ */ jsx(InfoOutlineIcon, {}) })
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsx(
+          TextArea,
+          {
+            rows: 8,
+            fontSize: 2,
+            onChange: (event) => setFeedback(event.currentTarget.value),
+            padding: 3,
+            placeholder: 'Example: "Braze" is a branded term and should not be translated.',
+            value: feedback
+          }
+        )
+      ] }) }),
+      /* @__PURE__ */ jsx(Stack, { space: 2, children: /* @__PURE__ */ jsx(Stack, { space: 3, children: /* @__PURE__ */ jsx(
+        Button,
+        {
+          type: "button",
+          mode: shouldIncludeEdits ? "ghost" : "bleed",
+          size: 2,
+          onClick: handleShouldIncludeEditsChange,
+          tone: shouldIncludeEdits ? "primary" : "default",
+          children: /* @__PURE__ */ jsxs(Flex, { align: "flex-start", gap: 3, children: [
+            /* @__PURE__ */ jsx(Box, { paddingTop: 1, children: /* @__PURE__ */ jsx(Checkbox, { checked: shouldIncludeEdits, readOnly: !0, style: { pointerEvents: "none" } }) }),
+            /* @__PURE__ */ jsxs(Stack, { space: 2, flex: 1, children: [
+              /* @__PURE__ */ jsx(Text, { size: 2, weight: "medium", children: "Include Edits in Feedback" }),
+              /* @__PURE__ */ jsx(Text, { size: 1, muted: !0, style: { textAlign: "left" }, children: "The AI will analyze edits you made to the translation." })
+            ] })
+          ] })
+        }
+      ) }) })
+    ] }) }),
+    /* @__PURE__ */ jsxs(Flex, { justify: "flex-end", gap: 2, paddingTop: 2, children: [
+      /* @__PURE__ */ jsx(Button, { type: "button", mode: "ghost", size: 1, onClick: handleCancel, children: "Cancel" }),
+      /* @__PURE__ */ jsx(
+        Button,
+        {
+          type: "submit",
+          mode: "ghost",
+          tone: "positive",
+          size: 1,
+          onClick: handleAnalyze,
+          disabled: !feedback.trim() && !shouldIncludeEdits,
+          children: "Analyze Feedback"
+        }
+      )
+    ] })
+  ] });
+}, translationReducer = (context, action) => {
+  const logContext = {
+    documentId: context.document?._id,
+    actionType: action.type,
+    component: "translationReducer"
+  };
+  switch (devLog.debug("Translation action dispatched", {
+    ...logContext,
+    payload: action.payload
+  }), action.type) {
+    case "SET_OVERALL_STATUS":
+      return { ...context, overallStatus: action.payload };
+    case "SET_TRANSLATION_METADATA":
+      return { ...context, translationMetadata: action.payload };
+    case "SET_SELECTED_TARGET_LANGUAGES":
+      return {
+        ...context,
+        selectedTargetLanguages: action.payload
+      };
+    case "SET_SHOULD_TRANSLATE_DIFFS":
+      return {
+        ...context,
+        shouldTranslateDiffs: action.payload
+      };
+    case "SET_SHOULD_TRANSLATE_REFERENCES":
+      return {
+        ...context,
+        shouldTranslateReferences: action.payload
+      };
+    case "SET_MAX_REFERENCE_DEPTH":
+      return {
+        ...context,
+        maxReferenceDepth: action.payload
+      };
+    case "SET_SHOULD_OVERWRITE_FRESH_TRANSLATIONS":
+      return {
+        ...context,
+        shouldOverwriteFreshTranslations: action.payload
+      };
+    case "SET_REFERENCES":
+      return {
+        ...context,
+        references: action.payload
+      };
+    case "SET_TRANSLATION_JOB_STATUS": {
+      const jobKey = `${action.payload._id}_${action.payload.language}`, newTranslationJobs = new Map(context.translationJobs);
+      return newTranslationJobs.set(jobKey, defaults(action.payload, newTranslationJobs.get(jobKey))), {
+        ...context,
+        translationJobs: newTranslationJobs
+      };
+    }
+    default:
+      return context;
+  }
+}, TranslationContextProvider = ({ document, config, children }) => {
+  devLog.debug("TranslationContextProvider initialized", {
+    documentId: document._id,
+    documentType: document._type,
+    supportedLanguages: config.supportedLanguages?.map((l) => l.id),
+    component: "TranslationContextProvider"
+  });
+  const initialContext = {
+    document,
+    config,
+    overallStatus: "idle",
+    translationMetadata: null,
+    selectedTargetLanguages: [],
+    shouldTranslateDiffs: !1,
+    shouldOverwriteFreshTranslations: !1,
+    shouldTranslateReferences: !1,
+    maxReferenceDepth: 1,
+    references: [],
+    translationJobs: /* @__PURE__ */ new Map()
+  }, [context, dispatch] = useReducer(translationReducer, initialContext);
+  return devLog.debug("Translation context state initialized", {
+    documentId: document._id,
+    overallStatus: context.overallStatus,
+    selectedLanguages: context.selectedTargetLanguages,
+    shouldTranslateDiffs: context.shouldTranslateDiffs,
+    component: "TranslationContextProvider"
+  }), /* @__PURE__ */ jsx(TranslationContext.Provider, { value: { ...context, dispatch }, children });
+}, getGiveTranslationFeedbackAction = (config) => ({ draft, published }) => {
+  const document = draft ?? published, [isDialogOpen, setIsDialogOpen] = useState(!1);
+  return devLog.debug("ImproveTranslationPromptsAction initialized", {
+    documentId: document?._id,
+    documentType: document?._type
+  }), !document || !config.translatableSchemaTypes?.includes(document._type) ? (devLog.warn("Document not in translatable schema types", {
+    documentType: document?._type,
+    translatableTypes: config.translatableSchemaTypes
+  }), null) : config ? {
+    label: "Give Translation Feedback",
+    icon: TranslateIcon,
+    onHandle: () => {
+      devLog.info("Give Translation Feedback dialog opened", {
+        documentId: document._id,
+        documentType: document._type,
+        component: "GiveTranslationFeedbackAction"
+      }), setIsDialogOpen(!0);
+    },
+    dialog: isDialogOpen && {
+      type: "dialog",
+      onClose: () => setIsDialogOpen(!1),
+      header: "Give Translation Feedback",
+      content: /* @__PURE__ */ jsx(TranslationContextProvider, { document, config, children: /* @__PURE__ */ jsx(GiveFeedbackDialog, { setIsDialogOpen }) })
+    }
+  } : (devLog.error("Missing config in TranslateAction"), null);
+}, translationGlossaryTerm = defineType({
+  name: "translationGlossaryTerm",
+  title: "Translation Glossary Term",
+  icon: TranslateIcon,
+  type: "document",
+  fields: [
+    defineField({
+      name: "translations",
+      title: "Translations",
+      type: "array",
+      of: [
+        {
+          name: "translation",
+          title: "Translation",
+          type: "object",
+          fields: [
+            defineField({
+              name: "locale",
+              type: "string"
+            }),
+            defineField({
+              name: "value",
+              type: "string"
+            })
+          ]
+        }
+      ]
+    })
+  ],
+  preview: {
+    select: {
+      translations: "translations"
+    },
+    prepare({ translations }) {
+      const enTranslation = translations?.find((t) => t.locale === "en-us"), firstTranslation = translations?.[0];
+      return {
+        title: enTranslation?.value || firstTranslation?.value || "No translation available"
+      };
+    }
+  }
+}), translationHistory = defineField({
+  name: "translationHistory",
+  type: "array",
+  of: [
+    {
+      name: "targetLanguageHistory",
+      type: "object",
+      fields: [
+        defineField({
+          name: "language",
+          title: "Language",
+          description: "The language of the target document",
+          type: "string"
+        }),
+        defineField({
+          name: "sourceId",
+          title: "Source ID",
+          description: "The ID of the source document",
+          type: "string"
+        }),
+        defineField({
+          name: "sourceRev",
+          title: "Source Revision",
+          description: "The revision ID of the source document at the time of translation",
+          type: "string"
+        }),
+        defineField({
+          name: "sourceLanguage",
+          title: "Source Language",
+          description: "The language of the source document",
+          type: "string"
+        }),
+        defineField({
+          name: "sourceSnapshot",
+          title: "Source Snapshot",
+          description: "The snapshot of the source document at the time of translation",
+          type: "text"
+        }),
+        defineField({
+          name: "targetId",
+          title: "Target ID",
+          description: "The ID of the target document",
+          type: "string"
+        })
+      ]
+    }
+  ]
+}), localePrompt = defineField({
+  name: "localePrompt",
+  title: "Locale Prompt",
+  type: "object",
+  fields: [
+    defineField({
+      name: "locale",
+      type: "string"
+    }),
+    defineField({
+      name: "prompt",
+      type: "text",
+      rows: 5
+    })
+  ]
+}), translationSettings = defineType({
+  name: "translationSettings",
+  title: "Translation Settings",
+  icon: TranslateIcon,
+  type: "document",
+  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
+    }),
+    defineField({
+      name: "localePrompts",
+      title: "Locale Prompts",
+      description: "Prompts that will be given to the Sanity AI Agent for each locale.",
+      type: "array",
+      of: [localePrompt]
+    }),
+    defineField({
+      name: "protectedPhrases",
+      title: "Protected Phrases",
+      description: "Phrases that will never be translated.",
+      type: "array",
+      of: [{ type: "string" }]
+    })
+  ],
+  preview: {
+    prepare: () => ({
+      title: "Translation Settings"
+    })
+  }
+}), fetchTranslationPrompts = async ({
+  client,
+  sourceLanguage,
+  targetLanguages
+}) => {
+  const translationSettings2 = await client.fetch(
+    `*[_id == "translation-settings"][0] {
+      globalPrompt,
+      localePrompts[locale in $targetLanguages],
+      protectedPhrases
+    }`,
+    { targetLanguages }
+  ), translationGlossaryTerms = await client.fetch(
+    `*[
+        _type == "translationGlossaryTerm"
+        && count(translations[locale in $targetLanguages]) > 0
+        && count(translations[locale == $sourceLanguage]) > 0
+      ].translations`,
+    { targetLanguages, sourceLanguage }
+  ) || [], glossaryTermsByLocale = {};
+  for (const targetLanguage of targetLanguages) {
+    const relevantTranslations = translationGlossaryTerms.filter(
+      (termTranslations) => termTranslations.some((translation) => translation.locale === targetLanguage)
+    ).map((termTranslations) => {
+      const from = termTranslations.find((translation) => translation.locale === sourceLanguage)?.value, to = termTranslations.find((translation) => translation.locale === targetLanguage)?.value;
+      return !from || !to ? null : { from, to };
+    }).filter((item) => item !== null);
+    glossaryTermsByLocale[targetLanguage] = relevantTranslations;
+  }
+  return {
+    globalPrompt: translationSettings2?.globalPrompt,
+    protectedPhrases: translationSettings2?.protectedPhrases,
+    localeInstructions: Object.fromEntries(
+      targetLanguages.map((locale) => [
+        locale,
+        {
+          prompt: translationSettings2?.localePrompts?.find((lp) => lp.locale === locale)?.prompt,
+          glossaryTerms: formatGlossaryTermInstruction(glossaryTermsByLocale[locale])
+        }
+      ])
+    )
+  };
+}, formatGlossaryTermInstruction = (terms) => {
+  const instructions = ["Translate the following terms exactly as described below:"];
+  return terms.forEach(({ from, to }) => {
+    instructions.push(`"${from}" -> "${to}"`);
+  }), instructions.join(`
+`);
+}, findKeyValues = (obj, targetKey) => {
+  const results = [], recursiveSearch = (current, currentPath) => {
+    if (current != null) {
+      if (Array.isArray(current)) {
+        current.forEach((item, index) => {
+          recursiveSearch(item, [...currentPath, index]);
+        });
+        return;
+      }
+      if (typeof current == "object")
+        for (const [key, value] of Object.entries(current)) {
+          const newPath = [...currentPath, key];
+          key === targetKey && results.push({
+            value,
+            path: newPath
+          }), recursiveSearch(value, newPath);
+        }
+    }
+  };
+  return recursiveSearch(obj, []), results;
+}, localizeReferences = async ({ client, documentId, languageFieldName }) => {
+  try {
+    const doc = await client.fetch("*[_id == $documentId][0]", { documentId });
+    if (!doc) {
+      console.error(documentId, "not found");
+      return;
+    }
+    const targetLanguage = doc[languageFieldName];
+    if (!targetLanguage) {
+      console.error(documentId, "no value found for language field:", languageFieldName);
+      return;
+    }
+    const refs = findKeyValues(doc, "_ref");
+    if (!refs?.length)
+      return;
+    await updateReferences(documentId, client, refs, targetLanguage);
+  } catch (error) {
+    console.error("Error localizing references:", error);
+  }
+}, updateReferences = async (documentId, client, refs, targetLanguage) => {
+  const patch = client.patch(documentId);
+  if (!refs?.length)
+    return [];
+  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
+      }
+    );
+    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());
+  }
+};
+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) => {
+  for (const sourceDocument of sourceDocuments)
+    for (const lang of targetLanguages) {
+      const payload = {
+        _id: sourceDocument._id,
+        _type: sourceDocument._type,
+        language: lang,
+        status: "queued",
+        title: sourceDocument.title
+      };
+      dispatch({
+        type: "SET_TRANSLATION_JOB_STATUS",
+        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,
+  sourceLanguage
+}) => {
+  try {
+    return await client.fetch(
+      "*[_type == $tmType && references($sourceDocumentId)][0]",
+      {
+        tmType: TRANSLATION_METADATA_TYPE,
+        sourceDocumentId: undraftId(sourceDocument._id)
+      }
+    ) || await client.create({
+      _type: TRANSLATION_METADATA_TYPE,
+      translations: [
+        {
+          _key: sourceLanguage,
+          _type: "internationalizedArrayReferenceValue",
+          value: {
+            _type: "reference",
+            _ref: undraftId(sourceDocument._id),
+            _weak: !0,
+            _strengthenOnPublish: {
+              _type: sourceDocument._type,
+              _weak: !1
+            }
+          }
+        }
+      ],
+      translationHistory: []
+    });
+  } catch (error) {
+    throw console.error(sourceDocument._id, "Error creating translation metadata:", error), error;
+  }
+}, setJobStatus = (dispatch, _id, language, status, payload) => {
+  dispatch({
+    type: "SET_TRANSLATION_JOB_STATUS",
+    payload: defaults(payload, {
+      _id,
+      language,
+      status
+    })
+  });
+}, translateDocumentInPlace = async ({
+  client,
+  schemaId,
+  dispatch,
+  sourceDocument,
+  languageFieldName,
+  targetLanguage,
+  targetId,
+  patch
+}) => {
+  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) {
+    setJobStatus(dispatch, sourceDocument._id, targetLanguage, "error"), console.error("Error translating document:", error);
+  }
+}, assembleLanguageSpecs = ({
+  sourceDocument,
+  languageFieldName,
+  targetLanguage
+}) => {
+  const sourceLanugageId = sourceDocument[languageFieldName];
+  if (!sourceLanugageId)
+    throw new Error("[assembleLanguages] Source language ID is missing");
+  return {
+    fromLanguage: {
+      id: sourceLanugageId,
+      title: sourceLanugageId
+    },
+    toLanguage: {
+      id: targetLanguage,
+      title: targetLanguage
+    }
+  };
+}, translateEntireDocument = async ({
+  dispatch,
+  client,
+  schemaId,
+  sourceDocument,
+  targetLanguage,
+  languageFieldName,
+  translationTarget,
+  translationPrompts
+}) => {
+  const logContext = {
+    documentId: sourceDocument._id,
+    targetLanguage,
+    schemaId,
+    operation: translationTarget.operation,
+    targetId: translationTarget._id
+  };
+  devLog.group("translateEntireDocument", logContext), devLog.time("translateEntireDocument");
+  try {
+    const { toLanguage, fromLanguage } = assembleLanguageSpecs({
+      sourceDocument,
+      languageFieldName,
+      targetLanguage
+    });
+    devLog.debug("Language specs assembled", {
+      ...logContext,
+      toLanguage,
+      fromLanguage
+    });
+    let extantTranslation = "";
+    translationTarget._id && (devLog.debug("Checking for existing translation", {
+      ...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", {
+      ...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", {
+      ...logContext,
+      styleGuide
+    });
+    const newDocument = await client.agent.action.translate({
+      schemaId,
+      toLanguage,
+      fromLanguage,
+      documentId: sourceDocument._id,
+      targetDocument: translationTarget,
+      languageFieldPath: [languageFieldName],
+      styleGuide,
+      styleGuideParams: {
+        extantTranslation
+      },
+      protectedPhrases: translationPrompts.protectedPhrases || []
+    });
+    return devLog.info("Document translation completed", {
+      ...logContext,
+      newDocumentId: newDocument._id,
+      newDocumentRev: newDocument._rev
+    }), devLog.timeEnd("translateEntireDocument"), devLog.groupEnd(), newDocument;
+  } catch (error) {
+    throw devLog.error(
+      "translateEntireDocument failed",
+      error instanceof Error ? error : new Error(String(error)),
+      logContext
+    ), devLog.timeEnd("translateEntireDocument"), devLog.groupEnd(), 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 console.error("Error updating translation metadata:", error), error;
+  }
+}, translateDocument = async ({
+  dispatch,
+  client,
+  sourceDocument,
+  targetLanguage,
+  languageFieldName,
+  shouldOverwriteFreshTranslations,
+  schemaId,
+  shouldTranslateDiffs,
+  translationPrompts
+}) => {
+  const logContext = {
+    documentId: sourceDocument._id,
+    targetLanguage,
+    schemaId,
+    shouldTranslateDiffs,
+    shouldOverwriteFreshTranslations
+  };
+  devLog.group("translateDocument", logContext), devLog.time("translateDocument"), setJobStatus(dispatch, sourceDocument._id, targetLanguage, "preparing_translation");
+  try {
+    const sourceLanguage = sourceDocument[languageFieldName];
+    if (devLog.debug("Checking source document language", {
+      ...logContext,
+      sourceLanguage,
+      languageFieldName
+    }), !sourceLanguage) {
+      const error = `Source document ${sourceDocument._id} does not have a language`;
+      throw devLog.error(error, void 0, logContext), new Error(error);
+    }
+    devLog.debug("Getting translation metadata", logContext);
+    const translationMetadata = await getTranslationMetadata({
+      client,
+      sourceDocument,
+      sourceLanguage
+    }), isAlreadyFreshTranslation = translationMetadata.translationHistory?.some(
+      (history) => history.language === targetLanguage && history.sourceRev === sourceDocument._rev
+    ) ?? !1;
+    if (devLog.debug("Checking if translation is already fresh", {
+      ...logContext,
+      isAlreadyFreshTranslation,
+      currentRev: sourceDocument._rev
+    }), !shouldOverwriteFreshTranslations && isAlreadyFreshTranslation) {
+      devLog.info("Skipping fresh translation", logContext), setJobStatus(dispatch, sourceDocument._id, targetLanguage, "skipped", {
+        targetId: translationMetadata.translations.find((t) => t._key === targetLanguage)?.value._ref
+      }), devLog.timeEnd("translateDocument"), devLog.groupEnd();
+      return;
+    }
+    const translationTarget = determineTranslationTarget({
+      translationMetadata,
+      targetLanguage
+    }), isNewTranslation = translationTarget.operation === "create";
+    devLog.debug("Translation target determined", {
+      ...logContext,
+      operation: translationTarget.operation,
+      isNewTranslation
+    });
+    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
+      });
+    if (!newDocument)
+      throw devLog.error("Failed to create translation document", void 0, logContext), setJobStatus(dispatch, sourceDocument._id, targetLanguage, "error"), devLog.timeEnd("translateDocument"), devLog.groupEnd(), new Error("Failed to create translation document");
+    return devLog.debug("Translation document created", {
+      ...logContext,
+      newDocumentId: newDocument._id
+    }), devLog.debug("Updating translation metadata", logContext), setJobStatus(dispatch, sourceDocument._id, targetLanguage, "updating_metadata", {
+      targetId: newDocument._id
+    }), await updateTranslationMetadata({
+      client,
+      sourceDocument,
+      sourceLanguage,
+      newDocument,
+      targetLanguage,
+      translationMetadata,
+      isNewTranslation
+    }), setJobStatus(dispatch, sourceDocument._id, targetLanguage, "completed"), devLog.info("Translation completed successfully", {
+      ...logContext,
+      newDocumentId: newDocument._id
+    }), devLog.timeEnd("translateDocument"), devLog.groupEnd(), newDocument._id;
+  } catch (error) {
+    throw devLog.error("Translation failed", error instanceof Error ? error : new Error(String(error)), logContext), setJobStatus(dispatch, sourceDocument._id, targetLanguage, "error"), devLog.timeEnd("translateDocument"), devLog.groupEnd(), error;
+  }
+}, 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,
+  targetLanguages,
+  dispatch,
+  languageFieldName,
+  shouldOverwriteFreshTranslations,
+  schemaId,
+  references = [],
+  maxConcurrentTranslationJobs,
+  shouldTranslateDiffs
+}) => {
+  const logContext = {
+    documentId: sourceDocument._id,
+    targetLanguages,
+    referencesCount: references.length,
+    maxConcurrentJobs: maxConcurrentTranslationJobs,
+    shouldTranslateDiffs,
+    shouldOverwriteFreshTranslations
+  };
+  devLog.group("translateDocumentSet", logContext), devLog.time("translateDocumentSet");
+  try {
+    const sourceLanguage = sourceDocument[languageFieldName];
+    if (!sourceLanguage)
+      throw devLog.error("Source language not found"), new Error("Source language not found");
+    maxConcurrentTranslationJobs && (devLog.debug("Updating translation semaphore permits", {
+      ...logContext,
+      newPermits: maxConcurrentTranslationJobs
+    }), translationSemaphore.updatePermits(maxConcurrentTranslationJobs)), devLog.info("Starting document set translation", logContext), dispatch({
+      type: "SET_OVERALL_STATUS",
+      payload: "translating"
+    });
+    const sourceDocuments = [
+      {
+        _id: sourceDocument._id,
+        _type: sourceDocument._type,
+        // TODO: Handle this properly
+        title: sourceDocument.name || sourceDocument.title
+      },
+      ...references
+    ], sourceDocumentIds = sourceDocuments.map((doc) => doc._id), targetDocumentIds = [];
+    devLog.debug("Prepared document set for translation", {
+      ...logContext,
+      sourceDocumentIds: sourceDocumentIds.length,
+      totalTranslationJobs: sourceDocumentIds.length * targetLanguages.length
+    });
+    const translationPrompts = await fetchTranslationPrompts({
+      client,
+      sourceLanguage,
+      targetLanguages
+    });
+    devLog.info("Translation prompts", translationPrompts), setupTranslationJobStatuses(dispatch, sourceDocuments, targetLanguages);
+    const translationTasks = sourceDocumentIds.flatMap(
+      (documentId) => targetLanguages.map(async (targetLanguage) => {
+        await translationSemaphore.withPermit(async () => {
+          const document = await client.withConfig({
+            // This enables us to detect documents that might be stale due to unpublished changes
+            perspective: "raw"
+          }).fetch("*[_id == $id][0]", {
+            id: documentId
+          });
+          if (document) {
+            const targetDocumentId = await translateDocument({
+              dispatch,
+              client,
+              sourceDocument: document,
+              targetLanguage,
+              languageFieldName,
+              shouldOverwriteFreshTranslations,
+              schemaId,
+              shouldTranslateDiffs,
+              translationPrompts
+            });
+            targetDocumentId && targetDocumentIds.push(targetDocumentId);
+          }
+        });
+      })
+    );
+    await Promise.all(translationTasks), devLog.info("All translation tasks completed", {
+      ...logContext,
+      targetDocumentIds: targetDocumentIds.length
+    }), dispatch({
+      type: "SET_OVERALL_STATUS",
+      payload: "linking_references"
+    }), devLog.debug("Starting reference localization", {
+      ...logContext,
+      documentsToLocalize: targetDocumentIds.length
+    }), await Promise.all(
+      targetDocumentIds.map(async (documentId) => {
+        await localizeReferences({
+          client,
+          documentId,
+          languageFieldName
+        });
+      })
+    ), devLog.info("Document set translation completed successfully", logContext), devLog.timeEnd("translateDocumentSet"), devLog.groupEnd(), dispatch({ type: "SET_OVERALL_STATUS", payload: "completed" });
+  } catch (error) {
+    return devLog.error("translateDocumentSet failed", error instanceof Error ? error : new Error(String(error)), logContext), devLog.timeEnd("translateDocumentSet"), devLog.groupEnd(), dispatch({ type: "SET_OVERALL_STATUS", payload: "error" }), Promise.reject(error);
+  }
+}, ActionButtonBar = ({ setIsDialogOpen }) => {
+  const {
+    document,
+    config,
+    overallStatus,
+    dispatch,
+    references,
+    selectedTargetLanguages,
+    shouldOverwriteFreshTranslations,
+    shouldTranslateDiffs
+  } = useTranslationContext(), client = useClient({ apiVersion: "vX" });
+  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__ */ jsxs(Flex, { justify: "flex-end", gap: 2, children: [
+      /* @__PURE__ */ jsx(Button, { onClick: () => setIsDialogOpen(!1), mode: "ghost", size: 2, children: "Cancel" }),
+      /* @__PURE__ */ jsx(
+        Button,
+        {
+          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,
+              shouldTranslateDiffs
+            });
+          },
+          disabled: selectedTargetLanguages.length === 0 || !["idle", "completed"].includes(overallStatus),
+          children: "Translate"
+        }
+      )
+    ] })
+  ] });
+}, LanguageCheckbox = ({ lang, isLoading }) => {
+  const { document, dispatch, selectedTargetLanguages, translationMetadata } = useTranslationContext(), isDisabled = lang.id === document.language, isChecked = selectedTargetLanguages.includes(lang.id), hasTranslation = translationMetadata?.translations?.some((translation) => translation._key === lang.id), isStale = hasTranslation && translationMetadata?.translationHistory?.some(
+    (history) => history.language === lang.id && history.sourceRev !== document._rev
+  ), handleChange = () => {
+    if (isDisabled) return;
+    const updatedLanguages = isChecked ? selectedTargetLanguages.filter((langId) => langId !== lang.id) : [...selectedTargetLanguages, lang.id];
+    dispatch({
+      type: "SET_SELECTED_TARGET_LANGUAGES",
+      payload: updatedLanguages
+    });
+  };
+  return isLoading ? /* @__PURE__ */ jsx(Button, { type: "button", mode: "bleed", size: 2, onClick: handleChange, disabled: !0, muted: !0, children: /* @__PURE__ */ jsx(Flex, { align: "center", justify: "center", paddingY: 3, children: /* @__PURE__ */ jsx(Spinner, { size: 1 }) }) }) : /* @__PURE__ */ jsx(
+    Button,
+    {
+      type: "button",
+      mode: isChecked ? "ghost" : "bleed",
+      size: 2,
+      onClick: handleChange,
+      disabled: isDisabled,
+      tone: isChecked ? "primary" : "default",
+      muted: !0,
+      children: /* @__PURE__ */ jsxs(Flex, { align: "center", gap: 2, style: { cursor: "pointer" }, children: [
+        /* @__PURE__ */ jsxs(Inline, { space: 3, children: [
+          /* @__PURE__ */ jsx(Checkbox, { checked: isChecked, onChange: handleChange, label: lang.title, disabled: isDisabled }),
+          /* @__PURE__ */ jsxs(Flex, { direction: "column", gap: 3, children: [
+            /* @__PURE__ */ jsx(Text, { children: lang.title }),
+            isDisabled ? /* @__PURE__ */ jsx(Text, { size: 1, muted: !0, children: "The current language" }) : /* @__PURE__ */ jsx(Text, { size: 1, muted: !0, children: hasTranslation && !isDisabled ? "Already translated" : "Not translated" })
+          ] })
+        ] }),
+        !isDisabled && hasTranslation && /* @__PURE__ */ jsx(Flex, { flex: 1, justify: "flex-end", children: /* @__PURE__ */ jsx(Badge, { tone: isStale ? "caution" : "positive", size: 3, muted: !0, children: isStale ? "Stale" : "Fresh" }) })
+      ] })
+    }
+  );
+}, LanguageSelectionPanel = () => {
+  const { document, config } = useTranslationContext(), { loading } = useTranslationMetadata({
+    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)) }) });
+}, assembleReferences = async ({
+  client,
+  sourceDocument,
+  maxReferenceDepth,
+  translatableSchemaTypes = []
+}) => {
+  if (!client)
+    throw new Error("assembleReferences: client is required");
+  if (!sourceDocument || !sourceDocument._id)
+    throw new Error("assembleReferences: sourceDocument with _id is required");
+  if (typeof maxReferenceDepth != "number" || maxReferenceDepth < 0)
+    throw new Error("assembleReferences: maxReferenceDepth must be a non-negative number");
+  const references = /* @__PURE__ */ new Set(), documentCache = /* @__PURE__ */ new Map(), errors = [];
+  let currentDepthDocuments = [sourceDocument];
+  for (let depth = 0; depth < maxReferenceDepth && currentDepthDocuments.length > 0; depth++) {
+    const allRefIds = /* @__PURE__ */ new Set();
+    for (const document of currentDepthDocuments)
+      try {
+        const refResults = findKeyValues(document, "_ref");
+        for (const result2 of refResults) {
+          const refId = result2.value;
+          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);
+      }
+    if (allRefIds.size === 0)
+      break;
+    const refIdArray = Array.from(allRefIds);
+    try {
+      const batchResults = await client.fetch("*[_id in $ids]", { ids: refIdArray }), fetchedDocuments = /* @__PURE__ */ new Map();
+      for (const doc of batchResults)
+        fetchedDocuments.set(doc._id, doc);
+      const nextDepthDocuments = [];
+      for (const refId of refIdArray) {
+        const fetchedDoc = fetchedDocuments.get(refId);
+        if (fetchedDoc) {
+          if (translatableSchemaTypes.length > 0 && !translatableSchemaTypes.includes(fetchedDoc._type)) {
+            documentCache.set(refId, null);
+            continue;
+          }
+          documentCache.set(refId, fetchedDoc), references.add(refId), nextDepthDocuments.push(fetchedDoc);
+        } else
+          documentCache.set(refId, null), console.warn(`assembleReferences: Document with _id "${refId}" not found`);
+      }
+      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);
+      break;
+    }
+  }
+  errors.length > 0 && console.warn(`assembleReferences: Encountered ${errors.length} error(s) while fetching references`);
+  const result = [];
+  for (const refId of references) {
+    const cachedDoc = documentCache.get(refId);
+    cachedDoc && result.push({
+      _id: cachedDoc._id,
+      _type: cachedDoc._type,
+      title: cachedDoc.name || cachedDoc.title
+    });
+  }
+  return result;
+}, ReferenceConfigPanel = () => {
+  const { dispatch, document, shouldTranslateReferences, maxReferenceDepth, config, references } = useTranslationContext(), client = useClient({ apiVersion: "vX" }), [isLoadingReferences, setIsLoadingReferences] = useState(!1);
+  useEffect(() => {
+    (async () => {
+      if (setIsLoadingReferences(!0), !shouldTranslateReferences) {
+        dispatch({
+          type: "SET_REFERENCES",
+          payload: []
+        });
+        return;
+      }
+      const newReferences = await assembleReferences({
+        client,
+        sourceDocument: document,
+        maxReferenceDepth,
+        translatableSchemaTypes: config.translatableSchemaTypes
+      });
+      dispatch({
+        type: "SET_REFERENCES",
+        payload: newReferences
+      }), setIsLoadingReferences(!1);
+    })();
+  }, [document, client, dispatch, shouldTranslateReferences, maxReferenceDepth, config.translatableSchemaTypes]);
+  const handleMaxReferenceDepthChange = async (event) => {
+    dispatch({
+      type: "SET_MAX_REFERENCE_DEPTH",
+      payload: Number.parseInt(event.target.value)
+    });
+  }, handleShouldTranslateChange = () => {
+    dispatch({
+      type: "SET_SHOULD_TRANSLATE_REFERENCES",
+      payload: !shouldTranslateReferences
+    });
+  };
+  return /* @__PURE__ */ jsxs(Stack, { space: 2, children: [
+    /* @__PURE__ */ jsxs(Flex, { justify: "space-between", align: "center", children: [
+      /* @__PURE__ */ jsx(
+        Button,
+        {
+          type: "button",
+          mode: shouldTranslateReferences ? "ghost" : "bleed",
+          size: 2,
+          onClick: handleShouldTranslateChange,
+          tone: shouldTranslateReferences ? "primary" : "neutral",
+          children: /* @__PURE__ */ jsxs(Inline, { space: 2, children: [
+            /* @__PURE__ */ jsx(
+              Checkbox,
+              {
+                checked: shouldTranslateReferences,
+                onChange: handleShouldTranslateChange,
+                label: shouldTranslateReferences ? "Disable" : "Enable"
+              }
+            ),
+            /* @__PURE__ */ jsx(Text, { children: "Translate References" })
+          ] })
+        }
+      ),
+      shouldTranslateReferences ? /* @__PURE__ */ jsxs(Inline, { space: 2, children: [
+        /* @__PURE__ */ jsx(Text, { children: "Max Depth:" }),
+        /* @__PURE__ */ jsxs(
+          Select,
+          {
+            disabled: !shouldTranslateReferences,
+            placeholder: "Depth",
+            onChange: handleMaxReferenceDepthChange,
+            value: maxReferenceDepth.toString(),
+            children: [
+              /* @__PURE__ */ jsx("option", { value: 1, children: "1" }),
+              /* @__PURE__ */ jsx("option", { value: 2, children: "2" }),
+              /* @__PURE__ */ jsx("option", { value: 3, children: "3" })
+            ]
+          }
+        )
+      ] }) : null
+    ] }),
+    shouldTranslateReferences ? /* @__PURE__ */ jsx(Flex, { padding: 2, justify: "flex-end", children: /* @__PURE__ */ jsx(Text, { size: 1, muted: !0, children: isLoadingReferences ? "Loading references..." : references.length === 0 ? "No translatable references found." : `${references.length} translatable references found.` }) }) : null
+  ] });
+}, WriteSettingsPanel = () => {
+  const { dispatch, shouldOverwriteFreshTranslations, shouldTranslateDiffs } = useTranslationContext(), handleShouldOverwriteFreshTranslationsChange = () => {
+    dispatch({
+      type: "SET_SHOULD_OVERWRITE_FRESH_TRANSLATIONS",
+      payload: !shouldOverwriteFreshTranslations
+    });
+  };
+  return /* @__PURE__ */ jsxs(Stack, { space: 2, children: [
+    /* @__PURE__ */ jsx(ReferenceConfigPanel, {}),
+    /* @__PURE__ */ jsx(Flex, { justify: "space-between", align: "center", children: /* @__PURE__ */ jsx(
+      Button,
+      {
+        type: "button",
+        mode: shouldOverwriteFreshTranslations ? "ghost" : "bleed",
+        size: 2,
+        onClick: handleShouldOverwriteFreshTranslationsChange,
+        tone: shouldOverwriteFreshTranslations ? "primary" : "neutral",
+        children: /* @__PURE__ */ jsxs(Inline, { space: 2, children: [
+          /* @__PURE__ */ jsx(
+            Checkbox,
+            {
+              checked: shouldOverwriteFreshTranslations,
+              onChange: handleShouldOverwriteFreshTranslationsChange,
+              label: shouldOverwriteFreshTranslations ? "Disable" : "Enable"
+            }
+          ),
+          /* @__PURE__ */ jsxs(Stack, { space: 2, children: [
+            /* @__PURE__ */ jsx(Text, { children: "Overwrite Fresh Translations" }),
+            /* @__PURE__ */ jsx(Text, { size: 1, muted: !0, children: "All existing translations will be overwritten even if they are fresh." })
+          ] })
+        ] })
+      }
+    ) }),
+    /* @__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: [
+  /* @__PURE__ */ jsxs(Stack, { space: 2, children: [
+    /* @__PURE__ */ jsx(Label, { children: "Languages" }),
+    /* @__PURE__ */ jsx(LanguageSelectionPanel, {})
+  ] }),
+  /* @__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(
+    () => overallStatus === "completed" ? "Translation completed" : "Translation in progress",
+    [overallStatus]
+  ), jobs = useMemo(() => Array.from(translationJobs.values()), [translationJobs]);
+  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 }),
+    /* @__PURE__ */ jsxs(Stack, { space: 3, children: [
+      /* @__PURE__ */ jsx(Label, { children: "Translations" }),
+      /* @__PURE__ */ jsx(Card, { padding: 2, tone: "transparent", children: /* @__PURE__ */ jsx(Stack, { space: 2, children: /* @__PURE__ */ jsx("ul", { children: jobs.map((job) => /* @__PURE__ */ jsx("li", { children: /* @__PURE__ */ jsx(Box, { padding: 3, children: /* @__PURE__ */ jsxs(Flex, { justify: "space-between", align: "center", children: [
+        /* @__PURE__ */ jsxs(Inline, { space: 2, children: [
+          /* @__PURE__ */ jsx(Flex, { align: "center", justify: "center", style: { width: "24px", height: "24px" }, children: ["completed", "skipped"].includes(job.status) ? /* @__PURE__ */ jsx(CheckmarkIcon, { fontSize: 24 }) : job.status === "queued" ? /* @__PURE__ */ jsx(CircleIcon, { fontSize: 24 }) : /* @__PURE__ */ jsx(Spinner, {}) }),
+          /* @__PURE__ */ jsxs(Stack, { space: 3, children: [
+            /* @__PURE__ */ jsxs(Inline, { space: 2, children: [
+              /* @__PURE__ */ jsx(Text, { size: 1, weight: "semibold", children: job.title || "Untitled Document" }),
+              /* @__PURE__ */ jsx(ArrowRightIcon, { fontSize: 18 }),
+              /* @__PURE__ */ jsx(Code, { size: 1, children: job.language })
+            ] }),
+            /* @__PURE__ */ jsxs(Code, { size: 1, children: [
+              job._type,
+              " \u2014 ",
+              job._id.slice(-6)
+            ] })
+          ] })
+        ] }),
+        /* @__PURE__ */ jsxs(Flex, { gap: 2, align: "center", children: [
+          job.status === "skipped" ? /* @__PURE__ */ jsx(SkippedBadge, {}) : null,
+          job.targetId ? /* @__PURE__ */ jsx(
+            TranslationOpenerButton,
+            {
+              target: {
+                _id: job.targetId,
+                _type: job._type
+              }
+            }
+          ) : null
+        ] })
+      ] }) }) }, job._id)) }) }) })
+    ] })
+  ] });
+}, ProgressBar = ({ progress, max = 100 }) => {
+  const percentage = Math.min(progress / max * 100, 100);
+  return /* @__PURE__ */ jsxs(Stack, { space: 2, children: [
+    /* @__PURE__ */ jsx(
+      "div",
+      {
+        style: {
+          width: "100%",
+          height: "8px",
+          backgroundColor: "var(--card-border-color)",
+          borderRadius: "4px",
+          overflow: "hidden"
+        },
+        children: /* @__PURE__ */ jsx(
+          "div",
+          {
+            style: {
+              width: `${percentage}%`,
+              height: "100%",
+              backgroundColor: "var(--card-accent-fg-color)",
+              borderRadius: "4px",
+              transition: "width 0.3s ease-in-out"
+            }
+          }
+        )
+      }
+    ),
+    /* @__PURE__ */ jsxs(Flex, { justify: "space-between", align: "center", children: [
+      /* @__PURE__ */ jsxs(Text, { size: 1, muted: !0, children: [
+        percentage.toFixed(0),
+        "%"
+      ] }),
+      /* @__PURE__ */ jsxs(Text, { size: 1, muted: !0, children: [
+        progress,
+        " / ",
+        max,
+        " jobs completed."
+      ] })
+    ] })
+  ] });
+}, TranslationOpenerButton = ({ target }) => {
+  const openInNewPane = useOpenInNewPane(target._id, target._type);
+  return /* @__PURE__ */ jsx(Button, { mode: "bleed", text: "View", iconRight: PanelRightIcon, onClick: () => openInNewPane() });
+}, SkippedBadge = () => /* @__PURE__ */ jsx(
+  Tooltip,
+  {
+    portal: !0,
+    content: /* @__PURE__ */ jsx(Box, { padding: 1, children: /* @__PURE__ */ jsx(Text, { size: 1, muted: !0, children: "There was already a fresh translation for this document and language." }) }),
+    children: /* @__PURE__ */ jsx(Badge, { tone: "neutral", children: "Skipped" })
+  }
+), STATES_IN_WHICH_TO_SHOW_CONFIG = ["fetching_metadata", "idle"], STATES_IN_WHICH_TO_SHOW_TRANSLATION_PROGRESS = [
+  "translating",
+  "linking_references",
+  "completed"
+], STATES_IN_WHICH_TO_SHOW_ERROR = ["error"], TranslationDialog = ({ setIsDialogOpen }) => {
+  const { overallStatus, document } = useTranslationContext();
+  return devLog.debug("TranslationDialog rendered", {
+    documentId: document._id,
+    overallStatus,
+    component: "TranslationDialog"
+  }), STATES_IN_WHICH_TO_SHOW_CONFIG.includes(overallStatus) ? (devLog.debug("Showing translation config view", {
+    documentId: document._id,
+    overallStatus,
+    component: "TranslationDialog"
+  }), /* @__PURE__ */ jsx(TranslationConfigView, { setIsDialogOpen })) : STATES_IN_WHICH_TO_SHOW_TRANSLATION_PROGRESS.includes(overallStatus) ? (devLog.debug("Showing translation progress panel", {
+    documentId: document._id,
+    overallStatus,
+    component: "TranslationDialog"
+  }), /* @__PURE__ */ jsx(TranslationStatusPanel, {})) : STATES_IN_WHICH_TO_SHOW_ERROR.includes(overallStatus) ? (devLog.warn("Translation error state reached", {
+    documentId: document._id,
+    overallStatus,
+    component: "TranslationDialog"
+  }), /* @__PURE__ */ jsx("div", { children: "Error occurred" })) : (devLog.warn("Unhandled translation dialog state", {
+    documentId: document._id,
+    overallStatus,
+    component: "TranslationDialog"
+  }), /* @__PURE__ */ jsx("div", { children: "Unhandled overall state" }));
+}, getTranslateAction = (config) => ({ draft, published }) => {
+  const document = draft ?? published, [isDialogOpen, setIsDialogOpen] = useState(!1);
+  return devLog.debug("TranslateAction initialized", {
+    documentId: document?._id,
+    documentType: document?._type
+  }), !document || !config.translatableSchemaTypes?.includes(document._type) ? (devLog.warn("Document not in translatable schema types", {
+    documentType: document?._type,
+    translatableTypes: config.translatableSchemaTypes
+  }), null) : config ? {
+    label: "Translate",
+    icon: TranslateIcon,
+    onHandle: () => {
+      devLog.info("Translation dialog opened", {
+        documentId: document._id,
+        documentType: document._type,
+        component: "TranslateAction"
+      }), setIsDialogOpen(!0);
+    },
+    dialog: isDialogOpen && {
+      type: "dialog",
+      onClose: () => setIsDialogOpen(!1),
+      header: "Translate Document",
+      content: /* @__PURE__ */ jsx(TranslationContextProvider, { document, config, children: /* @__PURE__ */ jsx(TranslationDialog, { setIsDialogOpen }) })
+    }
+  } : (devLog.error("Missing config in TranslateAction"), null);
+}, aiTranslationPlugin = definePlugin((config) => ({
+  name: "sanity-plugin-ai-translation",
+  document: {
+    actions: [getTranslateAction(config), getGiveTranslationFeedbackAction(config)]
+  },
+  schema: {
+    types: [translationSettings, translationGlossaryTerm]
+  }
+})), translationHistorySchema = translationHistory;
+export {
+  aiTranslationPlugin,
+  translationHistorySchema
+};
+//# sourceMappingURL=index.js.map