@braze/sanity-plugin-ai-translation 0.2.23 → 0.2.24

package/dist/index.js

@@ -1,4 +1,4 @@
-import { useClient, defineType, defineField, pathToString, getPublishedId, definePlugin } from "sanity";
+import { useClient, defineType, defineField, getPublishedId, pathToString, definePlugin } from "sanity";
 import { jsx, jsxs } from "react/jsx-runtime";
 import { ErrorOutlineIcon, CheckmarkCircleIcon, EmptyIcon, AddIcon, TrashIcon, WarningOutlineIcon, InfoOutlineIcon, ArrowLeftIcon, EditIcon, TranslateIcon, CheckmarkIcon, CircleIcon, ArrowRightIcon, PanelRightIcon } from "@sanity/icons";
 import { createContext, useContext, useEffect, useState, useReducer, useCallback, useMemo } from "react";
@@ -192,12 +192,7 @@ async function analyzeFeedback({
   currentDocument,
   onProgress
 }) {
-  devLog.info("Starting feedback analysis", {
-    sourceLanguage,
-    targetLanguage,
-    hasUserFeedback: !!userFeedback,
-    shouldIncludeEdits
-  }), onProgress?.({ stage: "analyzing", message: "Analyzing feedback and edits..." });
+  onProgress?.({ stage: "analyzing", message: "Analyzing feedback and edits..." });
   const analysisPrompt = buildAnalysisPrompt({
     sourceLanguage,
     targetLanguage,
@@ -206,10 +201,8 @@ async function analyzeFeedback({
     sourceSnapshot,
     targetSnapshot,
     currentDocument
-  }), analysis = await analyzeWithAI(client, analysisPrompt);
-  devLog.info("AI analysis complete", { analysis });
-  const suggestions = convertAnalysisToSuggestions(analysis, sourceLanguage, targetLanguage);
-  devLog.info("Generated suggestions", { count: suggestions.length }), onProgress?.({ stage: "analyzing", message: "Validating suggestions..." });
+  }), analysis = await analyzeWithAI(client, analysisPrompt), suggestions = convertAnalysisToSuggestions(analysis, sourceLanguage, targetLanguage);
+  onProgress?.({ stage: "analyzing", message: "Validating suggestions..." });
   const validatedSuggestions = await Promise.all(
     suggestions.map(async (suggestion) => {
       const validation = await validateSuggestion(client, suggestion);
@@ -222,7 +215,10 @@ async function analyzeFeedback({
       };
     })
   );
-  return devLog.info("Suggestions validated", {
+  return devLog.info("Feedback analysis complete", {
+    sourceLanguage,
+    targetLanguage,
+    total: validatedSuggestions.length,
     valid: validatedSuggestions.filter((s) => s.validationStatus === "valid").length,
     warnings: validatedSuggestions.filter((s) => s.validationStatus === "warning").length,
     invalid: validatedSuggestions.filter((s) => s.validationStatus === "invalid").length
@@ -236,24 +232,18 @@ async function applySuggestions({
   suggestions,
   onProgress
 }) {
-  if (devLog.info("Applying suggestions", {
-    sourceLanguage,
-    targetLanguage,
-    targetLanguageType: typeof targetLanguage,
-    targetLanguageValue: targetLanguage,
-    count: suggestions.filter((s) => s.approved).length
-  }), !targetLanguage)
+  if (!targetLanguage)
     throw devLog.error("targetLanguage is undefined in applySuggestions!", {
       sourceLanguage,
       targetLanguage,
       suggestionsCount: suggestions.length
     }), new Error("targetLanguage is required but was undefined");
   const approvedSuggestions = suggestions.filter((s) => s.approved);
-  if (approvedSuggestions.length === 0) {
-    devLog.info("No approved suggestions to apply");
-    return;
-  }
-  onProgress?.({ stage: "applying", message: "Applying updates to translation settings..." }), await applyImprovementsFromSuggestions(client, schemaId, targetLanguage, approvedSuggestions, onProgress), devLog.info("Suggestions applied successfully");
+  approvedSuggestions.length !== 0 && (onProgress?.({ stage: "applying", message: "Applying updates to translation settings..." }), await applyImprovementsFromSuggestions(client, schemaId, targetLanguage, approvedSuggestions, onProgress), devLog.info("Suggestions applied successfully", {
+    sourceLanguage,
+    targetLanguage,
+    count: approvedSuggestions.length
+  }));
 }
 function buildAnalysisPrompt({
   sourceLanguage,
@@ -471,49 +461,21 @@ function parseAIResponse(responseText) {
   }
 }
 async function applyImprovementsFromSuggestions(client, schemaId, targetLanguage, suggestions, onProgress) {
-  devLog.info("Applying improvements from suggestions", {
-    count: suggestions.length,
-    targetLanguage,
-    suggestions: suggestions.map((s) => ({
-      type: s.type,
-      approved: s.approved,
-      sourceLocale: s.sourceLocale,
-      targetLocale: s.targetLocale,
-      sourceValue: s.sourceValue,
-      targetValue: s.targetValue
-    }))
-  });
   const settingsId = "translation-settings";
   await client.fetch("*[_id == $id][0]", { id: settingsId }) || await client.createIfNotExists({
     _id: settingsId,
     _type: "translationSettings"
   });
-  const updates = [], globalPrompts = suggestions.filter((s) => s.type === "globalPrompt" && s.description.trim()), localePrompts = suggestions.filter((s) => s.type === "localePrompt" && s.description.trim()), protectedPhrases = suggestions.filter((s) => s.type === "protectedPhrase" && s.description.trim()), glossaryTermsBeforeFilter = suggestions.filter((s) => s.type === "glossaryTerm");
-  devLog.info("Glossary terms before filtering", {
-    count: glossaryTermsBeforeFilter.length,
-    terms: glossaryTermsBeforeFilter.map((s) => ({
-      sourceLocale: s.sourceLocale,
-      sourceValue: s.sourceValue,
-      targetLocale: s.targetLocale,
-      targetValue: s.targetValue,
-      approved: s.approved
-    }))
-  });
-  const glossaryTerms = suggestions.filter(
+  const updates = [], globalPrompts = suggestions.filter((s) => s.type === "globalPrompt" && s.description.trim()), localePrompts = suggestions.filter((s) => s.type === "localePrompt" && s.description.trim()), protectedPhrases = suggestions.filter((s) => s.type === "protectedPhrase" && s.description.trim()), glossaryTerms = suggestions.filter(
     (s) => s.type === "glossaryTerm" && s.sourceLocale?.trim() && s.sourceValue?.trim() && s.targetLocale?.trim() && s.targetValue?.trim()
   );
-  if (devLog.info("Filtered suggestions by type", {
-    globalPrompts: globalPrompts.length,
-    localePrompts: localePrompts.length,
-    protectedPhrases: protectedPhrases.length,
-    glossaryTerms: glossaryTerms.length
-  }), (globalPrompts.length > 0 || localePrompts.length > 0) && (onProgress?.({
+  if ((globalPrompts.length > 0 || localePrompts.length > 0) && (onProgress?.({
     stage: "applying",
     message: globalPrompts.length > 0 && localePrompts.length > 0 ? "Updating global and locale translation prompts..." : globalPrompts.length > 0 ? "Updating global translation prompt..." : `Updating ${targetLanguage} translation prompt...`
   }), updates.push(updatePromptsWithTemplate(client, schemaId, settingsId, targetLanguage, globalPrompts, localePrompts))), protectedPhrases.length > 0) {
     onProgress?.({ stage: "applying", message: "Adding protected phrases..." });
     const phrases = protectedPhrases.map((s) => s.description);
-    devLog.debug("Applying protected phrases", { phrases }), updates.push(addProtectedPhrases(client, settingsId, phrases));
+    updates.push(addProtectedPhrases(client, settingsId, phrases));
   }
   if (glossaryTerms.length > 0) {
     onProgress?.({ stage: "applying", message: "Adding glossary terms..." });
@@ -525,22 +487,17 @@ async function applyImprovementsFromSuggestions(client, schemaId, targetLanguage
       targetValue: s.targetValue
       // biome-ignore-end lint/style/noNonNullAssertion: safely handled
     }));
-    devLog.debug("Applying glossary terms", { terms }), updates.push(addGlossaryTerms(client, terms));
+    updates.push(addGlossaryTerms(client, terms));
   }
   updates.length === 0 && devLog.warn("No valid updates to apply - all suggestions may have been empty"), await Promise.all(updates), onProgress?.({ stage: "applying", message: "Recording changes..." }), await recordChangeHistory(
     client,
     settingsId,
     targetLanguage,
     suggestions.filter((s) => s.approved)
-  ), devLog.info("All improvements applied successfully");
+  );
 }
 async function updatePromptsWithTemplate(client, _schemaId, settingsId, targetLanguage, globalPrompts, localePrompts) {
-  if (devLog.info("Updating prompts with deterministic template", {
-    settingsId,
-    targetLanguage,
-    hasGlobalUpdates: globalPrompts.length > 0,
-    hasLocaleUpdates: localePrompts.length > 0
-  }), !targetLanguage)
+  if (!targetLanguage)
     throw devLog.error("targetLanguage is undefined or empty!", {
       targetLanguage,
       globalPrompts: globalPrompts.length,
@@ -556,11 +513,7 @@ async function updatePromptsWithTemplate(client, _schemaId, settingsId, targetLa
       ...updates.map((update) => `- ${update}`)
     ].filter(Boolean).join(`
 `);
-    await client.patch(settingsId).set({ globalPrompt: newGlobalPrompt }).commit(), devLog.info("Global prompt updated", {
-      previousLength: currentGlobalPrompt.length,
-      newLength: newGlobalPrompt.length,
-      addedUpdates: updates.length
-    });
+    await client.patch(settingsId).set({ globalPrompt: newGlobalPrompt }).commit();
   }
   if (localePrompts.length > 0) {
     const updates = localePrompts.map((s) => s.description.trim()).filter(Boolean), existingLocalePrompts = currentSettings?.localePrompts || [], existingLocalePrompt = existingLocalePrompts.find((lp) => lp._key === targetLanguage);
@@ -573,12 +526,7 @@ async function updatePromptsWithTemplate(client, _schemaId, settingsId, targetLa
         ...updates.map((update) => `- ${update}`)
       ].filter(Boolean).join(`
 `), localeIndex = existingLocalePrompts.findIndex((lp) => lp._key === targetLanguage);
-      await client.patch(settingsId).set({ [`localePrompts[${localeIndex}].value`]: newValue }).commit(), devLog.info("Locale prompt updated", {
-        targetLanguage,
-        previousLength: currentValue.length,
-        newLength: newValue.length,
-        addedUpdates: updates.length
-      });
+      await client.patch(settingsId).set({ [`localePrompts[${localeIndex}].value`]: newValue }).commit();
     } else {
       const newValue = [`## User Feedback (${timestamp})`, ...updates.map((update) => `- ${update}`)].filter(Boolean).join(`
 `);
@@ -588,22 +536,17 @@ async function updatePromptsWithTemplate(client, _schemaId, settingsId, targetLa
           _key: targetLanguage,
           value: newValue
         }
-      ]).commit(), devLog.info("Locale prompt created", {
-        targetLanguage,
-        length: newValue.length,
-        addedUpdates: updates.length
-      });
+      ]).commit();
     }
   }
   devLog.info("Prompts updated successfully", {
+    targetLanguage,
     globalUpdated: globalPrompts.length > 0,
     localeUpdated: localePrompts.length > 0
   });
 }
 async function addProtectedPhrases(client, settingsId, phrases) {
-  devLog.info("Adding protected phrases", { settingsId, phrasesCount: phrases.length, phrases });
   const currentPhrases = await client.fetch("*[_id == $settingsId][0].protectedPhrases", { settingsId });
-  devLog.debug("Fetched current protected phrases", { currentCount: currentPhrases?.length });
   let newPhrases = phrases.filter((phrase) => !currentPhrases?.includes(phrase));
   const conflictingPhrases = [];
   for (const phrase of newPhrases)
@@ -611,12 +554,7 @@ async function addProtectedPhrases(client, settingsId, phrases) {
       'count(*[_type == "translationGlossaryTerm" && count(translations[value == $phrase]) > 0]) > 0',
       { phrase }
     ) && (conflictingPhrases.push(phrase), devLog.warn("Skipping protected phrase due to glossary conflict", { phrase }));
-  if (newPhrases = newPhrases.filter((phrase) => !conflictingPhrases.includes(phrase)), newPhrases.length === 0) {
-    devLog.info("No new protected phrases to add (all already exist)");
-    return;
-  }
-  const result = await client.patch(settingsId).setIfMissing({ protectedPhrases: [] }).append("protectedPhrases", newPhrases).commit();
-  devLog.info("Protected phrases added", { count: newPhrases.length, phrases: newPhrases, resultId: result._id });
+  newPhrases = newPhrases.filter((phrase) => !conflictingPhrases.includes(phrase)), newPhrases.length !== 0 && (await client.patch(settingsId).setIfMissing({ protectedPhrases: [] }).append("protectedPhrases", newPhrases).commit(), devLog.info("Protected phrases added", { count: newPhrases.length }));
 }
 async function addGlossaryTerms(client, terms) {
   const protectedPhrasesLower = (await client.fetch('*[_id == "translation-settings"][0].protectedPhrases'))?.map((p) => p.toLowerCase()) || [], validTerms = terms.filter(({ sourceValue, targetValue }) => sourceValue === targetValue ? (devLog.warn("Skipping glossary term where source === target (should be a protected phrase)", {
@@ -644,29 +582,13 @@ async function addGlossaryTerms(client, terms) {
     );
     if (existingTerm) {
       const existingTargetIndex = existingTerm.translations.findIndex((t) => t._key === targetLocale), existingTargetValue = existingTargetIndex >= 0 ? existingTerm.translations[existingTargetIndex].value : null;
-      existingTargetIndex === -1 ? (await client.patch(existingTerm._id).append("translations", [
+      existingTargetIndex === -1 ? await client.patch(existingTerm._id).append("translations", [
         {
           _type: "internationalizedArrayStringValue",
           _key: targetLocale,
           value: targetValue
         }
-      ]).commit(), devLog.info("Added target language to existing glossary term", {
-        sourceLocale,
-        sourceValue,
-        targetLocale,
-        targetValue
-      })) : existingTargetValue !== targetValue ? (await client.patch(existingTerm._id).set({ [`translations[${existingTargetIndex}].value`]: targetValue }).commit(), devLog.info("Updated existing glossary term translation", {
-        sourceLocale,
-        sourceValue,
-        targetLocale,
-        oldValue: existingTargetValue,
-        newValue: targetValue
-      })) : devLog.info("Glossary term already has this exact translation", {
-        sourceLocale,
-        sourceValue,
-        targetLocale,
-        targetValue
-      });
+      ]).commit() : existingTargetValue !== targetValue && await client.patch(existingTerm._id).set({ [`translations[${existingTargetIndex}].value`]: targetValue }).commit();
     } else
       await client.create({
         _type: "translationGlossaryTerm",
@@ -682,11 +604,10 @@ async function addGlossaryTerms(client, terms) {
             value: targetValue
           }
         ]
-      }), devLog.info("Created new glossary term", { sourceLocale, sourceValue, targetLocale, targetValue });
+      });
   }
   devLog.info("Glossary terms processed", {
-    totalRequested: terms.length,
-    validAdded: validTerms.length,
+    processed: validTerms.length,
     skipped: terms.length - validTerms.length
   });
 }
@@ -699,10 +620,7 @@ async function recordChangeHistory(client, settingsId, targetLanguage, suggestio
     description: suggestion.description,
     locale: suggestion.type === "localePrompt" ? targetLanguage : void 0
   }));
-  historyEntries.length !== 0 && (await client.patch(settingsId).setIfMissing({ changeHistory: [] }).append("changeHistory", historyEntries).commit(), devLog.info("Change history recorded", {
-    count: historyEntries.length,
-    timestamp
-  }));
+  historyEntries.length !== 0 && await client.patch(settingsId).setIfMissing({ changeHistory: [] }).append("changeHistory", historyEntries).commit();
 }
 const ICON_SIZE = 64, progressIconMap = {
   in_progress: /* @__PURE__ */ jsx(Spinner, {}),
@@ -1756,7 +1674,12 @@ const fetchTranslationPrompts = async ({
     }
   };
   return recursiveSearch(obj, []), results;
-}, localizeReferences = async ({ client, documentId, languageFieldName }) => {
+}, localizeReferences = async ({
+  client,
+  documentId,
+  sourceLanguage,
+  languageFieldName
+}) => {
   try {
     const doc = await client.fetch("*[_id == $documentId][0]", { documentId });
     if (!doc) {
@@ -1778,25 +1701,25 @@ const fetchTranslationPrompts = async ({
     const refs = findKeyValues(doc, "_ref");
     if (!refs?.length)
       return;
-    await updateReferences(documentId, client, refs, targetLanguage);
+    await updateReferences(documentId, client, refs, sourceLanguage, targetLanguage);
   } catch (error) {
     devLog.error("Error localizing references", error instanceof Error ? error : new Error(String(error)), {
       documentId,
       component: "localizeReferences"
     });
   }
-}, updateReferences = async (documentId, client, refs, targetLanguage) => {
+}, updateReferences = async (documentId, client, refs, sourceLanguage, targetLanguage) => {
   if (!refs?.length)
     return [];
-  const refIds = refs.map((r) => undraftId(r.value)), translations = await client.fetch(
-    `*[_type == $translationMetadataSchemaType && count(translations[value._ref in $refIds]) > 0]
-      .translations[value._ref in $refIds]{
-        "sourceId": value._ref,
-        "targetId": ^.translations[_key == $targetLanguage][0].value._ref
-      }[defined(targetId)]`,
+  const refIds = refs.map((r) => getPublishedId(r.value)), translations = await client.fetch(
+    `*[_type == $translationMetadataSchemaType && array::intersects(translations[].value._ref, $refIds)] {
+      "sourceId": translations[_key == $sourceLanguage][0].value._ref,
+      "targetId": translations[_key == $targetLanguage][0].value._ref
+    }`,
     {
       translationMetadataSchemaType: TRANSLATION_METADATA_TYPE,
       refIds,
+      sourceLanguage,
       targetLanguage
     }
   ), translationMap = /* @__PURE__ */ new Map();
@@ -1805,13 +1728,8 @@ const fetchTranslationPrompts = async ({
   const patch = client.patch(documentId);
   let hasChanges = !1;
   for (const ref of refs) {
-    const sourceId = undraftId(ref.value), newId = translationMap.get(sourceId);
-    newId && (patch.set({ [pathToString(ref.path)]: undraftId(newId) }), patch.set({ [`${pathToString(ref.path.slice(0, -1))}._weak`]: !0 }), patch.set({
-      [`${pathToString(ref.path.slice(0, -1))}._strengthenOnPublish`]: {
-        _type: "reference",
-        _weak: !1
-      }
-    }), hasChanges = !0);
+    const sourceId = getPublishedId(ref.value), newId = translationMap.get(sourceId);
+    newId && (patch.set({ [pathToString(ref.path)]: getPublishedId(newId) }), hasChanges = !0);
   }
   hasChanges && (await patch.commit(), devLog.info("Updated references in batch", {
     documentId,
@@ -2294,7 +2212,7 @@ const fetchTranslationPrompts = async ({
     sourceLanguage
   };
   try {
-    const sourceText = serializeDocument(sourceDocument), prompt = buildTranslationPrompt({
+    const sourceText = serializeDocument(sourceDocument), prompt = buildTranslationPrompt$1({
       sourceText,
       sourceLanguage,
       targetLanguage,
@@ -2330,7 +2248,7 @@ const fetchTranslationPrompts = async ({
   } catch (error) {
     throw devLog.error("OpenAI translation failed", error instanceof Error ? error : new Error(String(error)), logContext), error;
   }
-}, buildTranslationPrompt = ({
+}, buildTranslationPrompt$1 = ({
   sourceText,
   sourceLanguage,
   targetLanguage,
@@ -2377,111 +2295,46 @@ Brief summary of key translation decisions and reasoning
 </reasoning>
 
 Then return the translated document:`;
-}, analyzeDocumentContent = (document) => {
-  let hasCodeBlocks = !1, hasInlineCode = !1, codeBlockCount = 0, inlineCodeCount = 0;
-  const hasMarkdown = !1;
-  let hasPortableText = !1, estimatedFieldCount = 0;
-  const traverse = (value, depth = 0) => {
-    value != null && (depth > 0 && typeof value == "object" && estimatedFieldCount++, Array.isArray(value) ? value.forEach((item) => {
-      item && typeof item == "object" && "_type" in item && item._type === "code" && (hasCodeBlocks = !0, codeBlockCount++, hasPortableText = !0), item && typeof item == "object" && "_type" in item && item._type === "block" && "children" in item && Array.isArray(item.children) && (hasPortableText = !0, item.children.forEach((child) => {
-        child && typeof child == "object" && "marks" in child && Array.isArray(child.marks) && child.marks.includes("code") && (hasInlineCode = !0, inlineCodeCount++);
-      })), traverse(item, depth + 1);
-    }) : typeof value == "object" && Object.values(value).forEach((val) => traverse(val, depth + 1)));
-  };
-  traverse(document);
-  let complexity = "simple";
-  return estimatedFieldCount > 50 ? complexity = "complex" : estimatedFieldCount > 20 && (complexity = "moderate"), {
-    hasCodeBlocks,
-    hasInlineCode,
-    codeBlockCount,
-    inlineCodeCount,
-    hasMarkdown,
-    hasPortableText,
-    complexity,
-    estimatedFieldCount
-  };
-}, assembleTranslationPrompt = (context, components) => {
-  const sections = [
-    {
-      id: "agentDirectives",
-      content: buildAgentDirectivesSection(context),
-      required: !0,
-      priority: 0
+}, 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
     },
-    {
-      id: "criticalRules",
-      content: buildCriticalRulesSection(context),
-      required: !0,
-      priority: 1
+    toLanguage: {
+      id: targetLanguage,
+      title: targetLanguage
     }
-  ];
-  components.glossaryTerms?.trim() && sections.push({
-    id: "glossaryTerms",
-    content: buildGlossarySection(components.glossaryTerms),
-    required: !1,
-    priority: 3
-  });
+  };
+}, buildTranslationPrompt = ({
+  sourceLanguage,
+  targetLanguage,
+  components,
+  isUpdate = !1
+}) => {
+  const sections = [];
+  sections.push(buildAgentDirectivesSection(sourceLanguage, targetLanguage)), sections.push(buildCriticalRulesSection(sourceLanguage, targetLanguage)), isUpdate && sections.push(buildUpdateInstructionsSection()), components.glossaryTerms?.trim() && sections.push(buildGlossarySection(components.glossaryTerms)), components.protectedPhrases?.length && sections.push(buildProtectedPhrasesSection(components.protectedPhrases));
   const styleSection = buildStyleGuideSection(components.globalPrompt, components.localePrompt);
-  styleSection && sections.push({
-    id: "styleGuide",
-    content: styleSection,
-    required: !1,
-    priority: 4
-  }), sections.sort((a, b) => a.priority - b.priority);
-  let styleGuide = "";
-  const omittedSections = [], truncatedSections = [];
-  for (const section of sections) {
-    const prefix = styleGuide.length > 0 ? `
+  return styleSection && sections.push(styleSection), sections.join(`
 
 ---
 
-` : "", availableCharacters = 2e3 - (styleGuide.length + prefix.length);
-    if (availableCharacters <= 0) {
-      if (section.required) {
-        const truncatedContent = truncateSection(section.content, 0);
-        truncatedContent && (styleGuide += prefix + truncatedContent, truncatedSections.push(section.id));
-      } else
-        omittedSections.push(section.id);
-      continue;
-    }
-    if (section.content.length <= availableCharacters) {
-      styleGuide += prefix + section.content;
-      continue;
-    }
-    if (section.required) {
-      const truncatedContent = truncateSection(section.content, availableCharacters);
-      styleGuide += prefix + truncatedContent, truncatedSections.push(section.id);
-    } else
-      omittedSections.push(section.id);
-  }
-  return {
-    styleGuide,
-    omittedSections,
-    truncatedSections
-  };
-}, truncateSection = (content, limit) => {
-  if (limit <= 0)
-    return "";
-  if (content.length <= limit)
-    return content;
-  if (limit <= 1)
-    return content.slice(0, limit);
-  const ellipsis = "\u2026";
-  if (limit <= ellipsis.length)
-    return content.slice(0, limit);
-  const sliceEnd = limit - ellipsis.length, sliced = content.slice(0, sliceEnd), trimmed = sliced.replace(/\s+\S*$/, "").trimEnd();
-  return `${trimmed.length >= sliceEnd / 2 ? trimmed : sliced}${ellipsis}`;
-}, buildAgentDirectivesSection = (context) => {
-  const { targetLanguage, sourceLanguage } = context;
-  return `# AGENT WORKFLOW DIRECTIVES
+`);
+}, buildAgentDirectivesSection = (sourceLanguage, targetLanguage) => `# AGENT WORKFLOW DIRECTIVES
 
 - Use only the provided ${sourceLanguage || "the source language"} source; never fetch outside context.
 - Scan each field once, then move directly into translation work.
 - Plan updates before editing so document structure remains intact.
 - Default to medium reasoning effort and escalate only for ambiguous passages.
-- Output just the ${targetLanguage || "the target language"} translation and mirror the source formatting exactly.`;
-}, buildCriticalRulesSection = (context) => {
-  const { sourceLanguage, targetLanguage } = context, fromLanguage = sourceLanguage || "the source language", toLanguage = targetLanguage || "the target language";
+- Output just the ${targetLanguage || "the target language"} translation and mirror the source formatting exactly.`, buildCriticalRulesSection = (sourceLanguage, targetLanguage) => {
+  const fromLanguage = sourceLanguage || "the source language", toLanguage = targetLanguage || "the target language";
   return `# CRITICAL TRANSLATION RULES
 
 Follow these without exception:
@@ -2492,34 +2345,26 @@ Follow these without exception:
 4. Never invent metadata or field values that are absent in the source.
 5. Leave technical tokens (code, IDs, filenames) untouched.
 6. Keep punctuation, casing, and spacing unless ${toLanguage} grammar forces a change.`;
-}, buildGlossarySection = (glossaryTerms) => `# TERMINOLOGY RULES
+}, buildUpdateInstructionsSection = () => `# UPDATING EXISTING TRANSLATION
+
+This document already has a translation; only adjust fields that changed.
+
+- Compare the latest source to the existing target text.
+- Keep prior terminology and style unless the source demands a change.
+- Edit minimally while guaranteeing accuracy and completeness.`, buildGlossarySection = (glossaryTerms) => `# TERMINOLOGY RULES
 
 Apply these mappings immediately after protected phrases and before style preferences.
 
-${glossaryTerms}`, buildStyleGuideSection = (globalPrompt, localePrompt) => {
+${glossaryTerms}`, buildProtectedPhrasesSection = (protectedPhrases) => `# PROTECTED PHRASES
+
+These phrases must NEVER be translated. Keep them exactly as they appear:
+
+${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localePrompt) => {
   const components = [];
   return (globalPrompt || localePrompt) && (components.push("# TRANSLATION STYLE GUIDE (LOWEST PRIORITY)"), components.push(
     "Apply these directions only after honoring critical rules, protected phrases, and glossary terminology."
   ), components.push("")), globalPrompt && (components.push("## General Guidelines"), components.push(globalPrompt), components.push("")), localePrompt && (components.push("## Language-Specific Guidelines"), components.push(localePrompt)), components.length > 0 ? components.join(`
 `) : null;
-}, 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
-    }
-  };
 }, getSanityAgentTranslation = async ({
   sourceDocument,
   targetLanguage,
@@ -2528,19 +2373,18 @@ ${glossaryTerms}`, buildStyleGuideSection = (globalPrompt, localePrompt) => {
   client,
   translationPrompts
 }) => {
-  analyzeDocumentContent(sourceDocument);
-  const { styleGuide } = assembleTranslationPrompt(
-    {
-      // Always fresh translation in a version
-      targetLanguage,
-      sourceLanguage: sourceDocument[languageFieldName]
-    },
-    {
+  const styleGuide = buildTranslationPrompt({
+    sourceLanguage: sourceDocument[languageFieldName],
+    targetLanguage,
+    isUpdate: !1,
+    // Always fresh translation in a version
+    components: {
       globalPrompt: translationPrompts.globalPrompt,
       localePrompt: translationPrompts.localeInstructions[targetLanguage]?.prompt,
-      glossaryTerms: translationPrompts.localeInstructions[targetLanguage]?.glossaryTerms
+      glossaryTerms: translationPrompts.localeInstructions[targetLanguage]?.glossaryTerms,
+      protectedPhrases: translationPrompts.protectedPhrases
     }
-  ), { fromLanguage, toLanguage } = assembleLanguageSpecs({
+  }), { fromLanguage, toLanguage } = assembleLanguageSpecs({
     sourceDocument,
     languageFieldName,
     targetLanguage
@@ -2610,13 +2454,11 @@ ${glossaryTerms}`, buildStyleGuideSection = (globalPrompt, localePrompt) => {
     ...translatedDoc,
     _id: targetDocumentVersionId
   };
-  console.log("NEW DOC", newDoc);
-  const createdDoc = await client.action({
+  return await client.action({
     actionType: "sanity.action.document.version.create",
     publishedId: targetDocumentPublishedId,
     document: newDoc
-  });
-  return console.log("CREATED DOC", createdDoc), newDoc;
+  }), newDoc;
 }, translateDocument = async ({
   dispatch,
   client,
@@ -2720,29 +2562,20 @@ ${glossaryTerms}`, buildStyleGuideSection = (globalPrompt, localePrompt) => {
     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)), dispatch({
+    maxConcurrentTranslationJobs && translationSemaphore.updatePermits(maxConcurrentTranslationJobs), dispatch({
       type: "SET_OVERALL_STATUS",
       payload: "translating"
     });
-    const releaseTitle = `[AI Translation] ${sourceDocument.title || sourceDocument._id.split("-").slice(0, 2).join("-")} (${sourceDocument._type}) ${sourceLanguage} \u2192 ${targetLanguages.join(", ")}`, releaseDescription = `AI translation batch created on ${(/* @__PURE__ */ new Date()).toLocaleDateString()} at ${(/* @__PURE__ */ new Date()).toLocaleTimeString()}`;
-    devLog.info("Creating new Content Release for translation batch", {
-      ...logContext,
-      releaseTitle
-    });
-    const { releaseId: releaseId2 } = await client.releases.create({
+    const releaseTitle = `[AI Translation] ${sourceDocument.title || sourceDocument._id.split("-").slice(0, 2).join("-")} (${sourceDocument._type}) ${sourceLanguage} \u2192 ${targetLanguages.join(", ")}`, releaseDescription = `AI translation batch created on ${(/* @__PURE__ */ new Date()).toLocaleDateString()} at ${(/* @__PURE__ */ new Date()).toLocaleTimeString()}`, { releaseId: releaseId2 } = await client.releases.create({
       metadata: {
         title: releaseTitle,
         description: releaseDescription,
         releaseType: "undecided"
       }
     });
-    devLog.info("\u2705 NEW CONTENT RELEASE CREATED", {
+    devLog.info("Content Release created", {
       ...logContext,
-      releaseId: releaseId2,
-      releaseTitle
+      releaseId: releaseId2
     });
     const sourceDocuments = [
       {
@@ -2752,19 +2585,13 @@ ${glossaryTerms}`, buildStyleGuideSection = (globalPrompt, localePrompt) => {
         title: sourceDocument.name || sourceDocument.title
       },
       ...references
-    ], sourceDocumentIds = sourceDocuments.map((doc) => doc._id), targetDocumentIds = [];
-    devLog.debug("Prepared document set for translation", {
-      ...logContext,
-      sourceDocumentIds: sourceDocumentIds.length,
-      totalTranslationJobs: sourceDocumentIds.length * targetLanguages.length
-    });
-    const translationPrompts = await fetchTranslationPrompts({
+    ], sourceDocumentIds = sourceDocuments.map((doc) => doc._id), versionedTargetDocumentIds = [], translationPrompts = await fetchTranslationPrompts({
       client,
       sourceLanguage,
       targetLanguages,
       sourceDocument
     });
-    devLog.info("Translation prompts", translationPrompts), setupTranslationJobStatuses(dispatch, sourceDocuments, targetLanguages);
+    setupTranslationJobStatuses(dispatch, sourceDocuments, targetLanguages);
     const translationTasks = sourceDocumentIds.flatMap(
       (documentId) => targetLanguages.map(async (targetLanguage) => {
         try {
@@ -2773,7 +2600,7 @@ ${glossaryTerms}`, buildStyleGuideSection = (globalPrompt, localePrompt) => {
               perspective: "drafts"
             }).getDocument(documentId);
             if (document || devLog.error("\u274C SOURCE DOCUMENT NOT FOUND", { documentId }), document && releaseId2) {
-              const targetDocumentId = await translateDocument({
+              const versionedTargetDocumentId = await translateDocument({
                 dispatch,
                 client,
                 sourceDocument: document,
@@ -2787,7 +2614,7 @@ ${glossaryTerms}`, buildStyleGuideSection = (globalPrompt, localePrompt) => {
                 openaiConfig,
                 releaseId: releaseId2
               });
-              targetDocumentId && targetDocumentIds.push(targetDocumentId);
+              versionedTargetDocumentId && versionedTargetDocumentIds.push(versionedTargetDocumentId);
             }
           });
         } catch (error) {
@@ -2803,25 +2630,21 @@ ${glossaryTerms}`, buildStyleGuideSection = (globalPrompt, localePrompt) => {
         }
       })
     ), results = await Promise.allSettled(translationTasks), succeeded = results.filter((r) => r.status === "fulfilled").length, failed = results.filter((r) => r.status === "rejected").length;
-    devLog.info("Translation tasks summary", {
+    devLog.info("Translation tasks completed", {
       ...logContext,
       total: results.length,
       succeeded,
-      failed
-    }), devLog.info("All translation tasks completed", {
-      ...logContext,
-      targetDocumentIds: targetDocumentIds.length
+      failed,
+      targetDocuments: versionedTargetDocumentIds.length
     }), dispatch({
       type: "SET_OVERALL_STATUS",
       payload: "linking_references"
-    }), devLog.debug("Starting reference localization", {
-      ...logContext,
-      documentsToLocalize: targetDocumentIds.length
     }), await Promise.all(
-      targetDocumentIds.map(async (documentId) => {
+      versionedTargetDocumentIds.map(async (documentId) => {
         await localizeReferences({
           client,
           documentId,
+          sourceLanguage,
           languageFieldName
         });
       })
@@ -2831,7 +2654,7 @@ ${glossaryTerms}`, buildStyleGuideSection = (globalPrompt, localePrompt) => {
       ...logContext,
       succeeded,
       failed
-    }), dispatch({ type: "SET_OVERALL_STATUS", payload: "completed" })) : (devLog.info("Document set translation completed successfully", logContext), dispatch({ type: "SET_OVERALL_STATUS", payload: "completed" })), devLog.timeEnd("translateDocumentSet"), devLog.groupEnd();
+    }), dispatch({ type: "SET_OVERALL_STATUS", payload: "completed" })) : dispatch({ type: "SET_OVERALL_STATUS", payload: "completed" }), devLog.timeEnd("translateDocumentSet"), devLog.groupEnd();
   } catch (error) {
     throw devLog.error(
       "translateDocumentSet failed with unexpected error",
@@ -3377,26 +3200,9 @@ ${glossaryTerms}`, buildStyleGuideSection = (globalPrompt, localePrompt) => {
   "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", {
+  return STATES_IN_WHICH_TO_SHOW_CONFIG.includes(overallStatus) ? /* @__PURE__ */ jsx(TranslationConfigView, { setIsDialogOpen }) : STATES_IN_WHICH_TO_SHOW_TRANSLATION_PROGRESS.includes(overallStatus) ? /* @__PURE__ */ jsx(TranslationStatusPanel, {}) : STATES_IN_WHICH_TO_SHOW_ERROR.includes(overallStatus) ? /* @__PURE__ */ jsx("div", { children: "Error occurred" }) : (devLog.warn("Unhandled translation dialog state", {
     documentId: document._id,
-    overallStatus,
-    component: "TranslationDialog"
-  }), /* @__PURE__ */ jsx(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"
+    overallStatus
   }), /* @__PURE__ */ jsx("div", { children: "Unhandled overall state" }));
 }, getTranslateAction = (config) => ({ draft, published }) => {
   const document = draft ?? published, [isDialogOpen, setIsDialogOpen] = useState(!1);