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

package/dist/index.js

@@ -1,7 +1,7 @@
 import { getPublishedId, pathToString, useClient, defineType, defineField, definePlugin } from "sanity";
 import { jsx, jsxs, Fragment } from "react/jsx-runtime";
 import { WarningOutlineIcon, SearchIcon, CheckmarkIcon, ErrorOutlineIcon, CircleIcon, ArrowRightIcon, ResetIcon, PanelRightIcon, TranslateIcon } from "@sanity/icons";
-import { createContext, useReducer, useEffect, useContext, useMemo, useState, useCallback } from "react";
+import { createContext, useReducer, useRef, useEffect, useContext, useMemo, useState, useCallback } from "react";
 import defaults from "lodash.defaults";
 import { Card, Stack, Flex, Text, Box, Heading, Button, Spinner, Inline, Checkbox, Grid, Radio, TextInput, Badge, Select, Label, Code, Tooltip } from "@sanity/ui";
 import { toPlainText } from "@portabletext/react";
@@ -62,7 +62,7 @@ const isLoggingEnabled = () => process.env.NEXT_PUBLIC_SANITY_STUDIO_AI_TRANSLAT
       error: error instanceof Error ? error.message : "Network error"
     };
   }
-}, activeTranslations = /* @__PURE__ */ new Map(), registerActiveTranslation = (documentId, releaseId) => {
+}, undraftId = (id) => id.replace(/^drafts\./, ""), activeTranslations = /* @__PURE__ */ new Map(), registerActiveTranslation = (documentId, releaseId) => {
   const entry = {
     state: {
       documentId,
@@ -80,7 +80,9 @@ const isLoggingEnabled = () => process.env.NEXT_PUBLIC_SANITY_STUDIO_AI_TRANSLAT
 }, updateActiveTranslationJob = (documentId, job) => {
   const entry = activeTranslations.get(documentId);
   if (entry) {
-    const jobKey = `${job._id}_${job.language}`, existingJob = entry.state.translationJobs.get(jobKey), mergedJob = existingJob ? { ...existingJob, ...job } : job;
+    const jobKey = `${undraftId(job._id)}_${job.language}`, existingJob = entry.state.translationJobs.get(jobKey), jobWithDefinedValues = Object.fromEntries(
+      Object.entries(job).filter(([_, value]) => value !== void 0)
+    ), mergedJob = existingJob ? { ...existingJob, ...jobWithDefinedValues } : jobWithDefinedValues;
     entry.state.translationJobs.set(jobKey, mergedJob), notifySubscribers(entry);
   }
 }, getActiveTranslation = (documentId) => activeTranslations.get(documentId)?.state ?? null, subscribeToActiveTranslation = (documentId, callback) => {
@@ -112,6 +114,7 @@ const isLoggingEnabled = () => process.env.NEXT_PUBLIC_SANITY_STUDIO_AI_TRANSLAT
   shouldTranslateReferences: !1,
   maxReferenceDepth: 1,
   references: [],
+  selectedReferenceIds: /* @__PURE__ */ new Set(),
   translationMetadata: null,
   translationMode: "sanity-only",
   openaiValidated: !1,
@@ -165,8 +168,18 @@ const isLoggingEnabled = () => process.env.NEXT_PUBLIC_SANITY_STUDIO_AI_TRANSLAT
         ...context,
         references: action.payload
       };
+    case "SET_SELECTED_REFERENCE_IDS":
+      return {
+        ...context,
+        selectedReferenceIds: action.payload
+      };
     case "SET_TRANSLATION_JOB_STATUS": {
-      const jobKey = `${action.payload._id}_${action.payload.language}`, newTranslationJobs = new Map(context.translationJobs), existingJob = newTranslationJobs.get(jobKey), mergedJob = defaults(action.payload, existingJob);
+      if (!action.payload._id)
+        return devLog.warn("SET_TRANSLATION_JOB_STATUS action missing _id", {
+          ...logContext,
+          payload: action.payload
+        }), context;
+      const jobKey = `${undraftId(action.payload._id)}_${action.payload.language}`, newTranslationJobs = new Map(context.translationJobs), existingJob = newTranslationJobs.get(jobKey), mergedJob = defaults(action.payload, existingJob);
       return newTranslationJobs.set(jobKey, mergedJob), {
         ...context,
         translationJobs: newTranslationJobs
@@ -189,6 +202,7 @@ const isLoggingEnabled = () => process.env.NEXT_PUBLIC_SANITY_STUDIO_AI_TRANSLAT
         ...context,
         overallStatus: "idle",
         translationJobs: /* @__PURE__ */ new Map(),
+        selectedReferenceIds: /* @__PURE__ */ new Set(),
         // Clear any release conflicts from previous run
         releaseConfig: {
           ...context.releaseConfig,
@@ -216,6 +230,7 @@ const isLoggingEnabled = () => process.env.NEXT_PUBLIC_SANITY_STUDIO_AI_TRANSLAT
     shouldTranslateReferences: !1,
     maxReferenceDepth: 1,
     references: [],
+    selectedReferenceIds: /* @__PURE__ */ new Set(),
     // Restore jobs from active translation if available
     translationJobs: activeTranslation?.translationJobs ?? /* @__PURE__ */ new Map(),
     translationMode: config?.openai?.defaultMode || "sanity-only",
@@ -231,7 +246,7 @@ const isLoggingEnabled = () => process.env.NEXT_PUBLIC_SANITY_STUDIO_AI_TRANSLAT
     jobCount: activeTranslation.translationJobs.size,
     component: "TranslationContextProvider"
   });
-  const [context, dispatch] = useReducer(translationReducer, initialContext);
+  const [context, dispatch] = useReducer(translationReducer, initialContext), lastProcessedRefsRef = useRef("");
   return useEffect(() => {
     const handleActiveTranslationUpdate = (state) => {
       dispatch({
@@ -271,7 +286,28 @@ const isLoggingEnabled = () => process.env.NEXT_PUBLIC_SANITY_STUDIO_AI_TRANSLAT
           });
         }
     })();
-  }, [config?.openai?.apiKey, config?.openai?.enabled, config?.openai?.model]), devLog.debug("Translation context state initialized", {
+  }, [config?.openai?.apiKey, config?.openai?.enabled, config?.openai?.model]), useEffect(() => {
+    const currentRefsKey = context.references.map((ref) => ref._id).sort().join(",");
+    if (currentRefsKey !== lastProcessedRefsRef.current) {
+      if (context.references.length > 0) {
+        const currentReferenceIds = new Set(context.references.map((ref) => ref._id)), previousReferenceIds = new Set(
+          lastProcessedRefsRef.current ? lastProcessedRefsRef.current.split(",") : []
+        ), hasNewReferences = Array.from(currentReferenceIds).some((id) => !previousReferenceIds.has(id)), currentSelection = context.selectedReferenceIds;
+        if (currentSelection.size === 0 || hasNewReferences) {
+          const newSelection = new Set(currentSelection);
+          currentReferenceIds.forEach((id) => {
+            newSelection.add(id);
+          });
+          const currentIds = Array.from(currentSelection).sort(), newIds = Array.from(newSelection).sort();
+          (currentIds.length !== newIds.length || !currentIds.every((id, i) => id === newIds[i])) && dispatch({
+            type: "SET_SELECTED_REFERENCE_IDS",
+            payload: newSelection
+          });
+        }
+      }
+      lastProcessedRefsRef.current = currentRefsKey;
+    }
+  }, [context.references, context.selectedReferenceIds]), devLog.debug("Translation context state initialized", {
     documentId: document._id,
     overallStatus: context.overallStatus,
     selectedLanguages: context.selectedTargetLanguages,
@@ -288,7 +324,7 @@ const isLoggingEnabled = () => process.env.NEXT_PUBLIC_SANITY_STUDIO_AI_TRANSLAT
   return context;
 }, getExistingTranslationId = (translationMetadata, targetLanguage) => translationMetadata?.translations?.length && translationMetadata.translations.find(
   (translation) => translation._key === targetLanguage
-)?.value._ref || null, undraftId = (id) => id.replace(/^drafts\./, ""), TRANSLATION_METADATA_TYPE = "translation.metadata", getTranslationMetadata = async ({
+)?.value._ref || null, TRANSLATION_METADATA_TYPE = "translation.metadata", getTranslationMetadata = async ({
   client,
   sourceDocument,
   sourceLanguage
@@ -409,6 +445,115 @@ const isLoggingEnabled = () => process.env.NEXT_PUBLIC_SANITY_STUDIO_AI_TRANSLAT
   }
   return allConflicts;
 };
+function isNetworkError(error) {
+  if (!error) return !1;
+  if (error instanceof TypeError) {
+    const message = error.message.toLowerCase();
+    return message.includes("fetch") || message.includes("network") || message.includes("connection") || message.includes("failed to fetch") || message.includes("networkerror");
+  }
+  if (error && typeof error == "object" && "code" in error) {
+    const code = error.code;
+    return ["ECONNRESET", "ETIMEDOUT", "ENOTFOUND", "ECONNREFUSED", "EHOSTUNREACH"].includes(code);
+  }
+  if (error && typeof error == "object" && "response" in error) {
+    const response = error.response;
+    if (response?.status)
+      return response.status >= 500 || response.status === 429;
+  }
+  if (error instanceof Error) {
+    const message = error.message;
+    if (/\b(50[0-9]|429)\b/.test(message))
+      return !0;
+  }
+  return !1;
+}
+function isSanityMutationError(error) {
+  if (!error) return !1;
+  if (error instanceof Error) {
+    const message = error.message.toLowerCase();
+    return [
+      "validation",
+      "schema",
+      "invalid document",
+      "invalid field",
+      "type mismatch",
+      "reference",
+      "patch",
+      "mutation",
+      "document structure",
+      "required field",
+      "field type",
+      "sanity"
+    ].some((pattern) => message.includes(pattern));
+  }
+  if (error && typeof error == "object") {
+    const errorObj = error;
+    if (("statusCode" in errorObj || "response" in errorObj || "details" in errorObj) && "statusCode" in errorObj) {
+      const statusCode = errorObj.statusCode;
+      if (statusCode >= 400 && statusCode < 500 && statusCode !== 429)
+        return !0;
+    }
+  }
+  return !1;
+}
+const DEFAULT_RETRY_OPTIONS = {
+  maxAttempts: 2,
+  initialDelayMs: 0,
+  maxDelayMs: 5e3,
+  backoffMultiplier: 2,
+  retryableErrors: isNetworkError,
+  logRetries: !0
+};
+function calculateDelay(attempt, options) {
+  const delay = options.initialDelayMs * Math.pow(options.backoffMultiplier, attempt);
+  return Math.min(delay, options.maxDelayMs);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function retryWithBackoff(operation, options = {}) {
+  const opts = {
+    ...DEFAULT_RETRY_OPTIONS,
+    ...options,
+    retryableErrors: options.retryableErrors || DEFAULT_RETRY_OPTIONS.retryableErrors
+  };
+  let lastError;
+  const maxAttempts = opts.maxAttempts + 1;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++)
+    try {
+      const result = await operation();
+      return attempt > 1 && opts.logRetries && devLog.info(`Operation succeeded after ${attempt} attempts`, {
+        ...opts.context,
+        attempt,
+        totalAttempts: attempt
+      }), result;
+    } catch (error) {
+      if (lastError = error, !opts.retryableErrors(error))
+        throw opts.logRetries && devLog.warn("Error is not retryable, aborting retries", {
+          ...opts.context,
+          attempt,
+          error: error instanceof Error ? error.message : String(error)
+        }), error;
+      if (attempt >= maxAttempts)
+        throw opts.logRetries && devLog.error(
+          `Operation failed after ${maxAttempts} attempts`,
+          error instanceof Error ? error : new Error(String(error)),
+          {
+            ...opts.context,
+            totalAttempts: maxAttempts
+          }
+        ), error;
+      const delay = calculateDelay(attempt - 1, opts);
+      opts.logRetries && devLog.warn(`Operation failed, retrying in ${delay}ms (attempt ${attempt}/${maxAttempts})`, {
+        ...opts.context,
+        attempt,
+        totalAttempts: maxAttempts,
+        delayMs: delay,
+        error: error instanceof Error ? error.message : String(error)
+      }), delay > 0 && await sleep(delay);
+    }
+  throw lastError;
+}
 class Semaphore {
   permits;
   queue = [];
@@ -759,7 +904,21 @@ const fetchTranslationPrompts = async ({
       }
     }), hasChanges = !0);
   }
-  hasChanges && (await patch.commit(), devLog.info("Updated references in batch", {
+  hasChanges && (await retryWithBackoff(
+    async () => {
+      await patch.commit();
+    },
+    {
+      maxAttempts: 2,
+      initialDelayMs: 0,
+      retryableErrors: isNetworkError,
+      context: {
+        operation: "localizeReferences",
+        documentId,
+        referenceCount: refs.length
+      }
+    }
+  ), devLog.info("Updated references in batch", {
     documentId,
     count: refs.length,
     translatedCount: translationMap.size,
@@ -813,11 +972,71 @@ const fetchTranslationPrompts = async ({
       targetRev: newDocument._rev,
       targetSnapshot: JSON.stringify(newDocument)
     }, translationPatch = client.patch(translationMetadata._id).setIfMissing({ translations: [] });
-    isNewTranslation ? await translationPatch.insert("after", "translations[-1]", [refToNewTranslation]).commit() : await translationPatch.insert("replace", `translations[_key == "${targetLanguage}"]`, [refToNewTranslation]).commit();
+    isNewTranslation ? await retryWithBackoff(
+      async () => {
+        await translationPatch.insert("after", "translations[-1]", [refToNewTranslation]).commit();
+      },
+      {
+        maxAttempts: 2,
+        initialDelayMs: 0,
+        retryableErrors: isNetworkError,
+        context: {
+          operation: "updateTranslationMetadata.translations",
+          sourceDocumentId: sourceDocument._id,
+          targetLanguage,
+          isNewTranslation: !0
+        }
+      }
+    ) : await retryWithBackoff(
+      async () => {
+        await translationPatch.insert("replace", `translations[_key == "${targetLanguage}"]`, [refToNewTranslation]).commit();
+      },
+      {
+        maxAttempts: 2,
+        initialDelayMs: 0,
+        retryableErrors: isNetworkError,
+        context: {
+          operation: "updateTranslationMetadata.translations",
+          sourceDocumentId: sourceDocument._id,
+          targetLanguage,
+          isNewTranslation: !1
+        }
+      }
+    );
     const historyPatch = client.patch(translationMetadata._id).setIfMissing({ translationHistory: [] });
     translationMetadata.translationHistory?.some(
       (history) => history.language === targetLanguage
-    ) ? await historyPatch.insert("replace", `translationHistory[_key == "${targetLanguage}"]`, [newTranslationHistory]).commit() : await historyPatch.insert("after", "translationHistory[-1]", [newTranslationHistory]).commit();
+    ) ? await retryWithBackoff(
+      async () => {
+        await historyPatch.insert("replace", `translationHistory[_key == "${targetLanguage}"]`, [newTranslationHistory]).commit();
+      },
+      {
+        maxAttempts: 2,
+        initialDelayMs: 0,
+        retryableErrors: isNetworkError,
+        context: {
+          operation: "updateTranslationMetadata.history",
+          sourceDocumentId: sourceDocument._id,
+          targetLanguage,
+          isNewHistory: !1
+        }
+      }
+    ) : await retryWithBackoff(
+      async () => {
+        await historyPatch.insert("after", "translationHistory[-1]", [newTranslationHistory]).commit();
+      },
+      {
+        maxAttempts: 2,
+        initialDelayMs: 0,
+        retryableErrors: isNetworkError,
+        context: {
+          operation: "updateTranslationMetadata.history",
+          sourceDocumentId: sourceDocument._id,
+          targetLanguage,
+          isNewHistory: !0
+        }
+      }
+    );
   } catch (error) {
     throw devLog.error("Error updating translation metadata", error instanceof Error ? error : new Error(String(error)), {
       sourceDocumentId: sourceDocument._id,
@@ -1068,7 +1287,9 @@ function restoreTransforms({
         schemaType,
         document: translatedDocument
       };
-      devLog.debug("Restoring transform for field", { fieldPath, schemaType }), restoredObj[key] = transform.fromTranslatable(value, originalValue, context);
+      devLog.debug("Restoring transform for field", { fieldPath, schemaType });
+      const restoredValue = transform.fromTranslatable(value, originalValue, context);
+      restoredObj[key] = restoredValue;
     } else
       restoredObj[key] = restoreTransforms({
         translatedDocument: value,
@@ -1161,14 +1382,29 @@ const globalTransformRegistry = new TransformRegistry(), callGPT5 = async (apiKe
   }), devLog.debug("OpenAI GPT-5 Full Prompt", {
     messages: request.messages
   });
-  const response = await fetch("https://api.openai.com/v1/responses", {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${apiKey}`
+  const response = await retryWithBackoff(
+    async () => {
+      const fetchResponse = await fetch("https://api.openai.com/v1/responses", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${apiKey}`
+        },
+        body: JSON.stringify(requestBody)
+      });
+      if (!fetchResponse.ok) {
+        const errorMessage = `GPT-5 API error: ${(await fetchResponse.json()).error?.message || "Unknown error"}`, errorObj = new Error(errorMessage);
+        throw errorObj.response = { status: fetchResponse.status }, errorObj;
+      }
+      return fetchResponse;
     },
-    body: JSON.stringify(requestBody)
-  });
+    {
+      maxAttempts: 2,
+      initialDelayMs: 0,
+      retryableErrors: isNetworkError,
+      context: { model: requestBody.model, endpoint: "responses" }
+    }
+  );
   if (!response.ok) {
     const error = await response.json();
     throw new Error(`GPT-5 API error: ${error.error?.message || "Unknown error"}`);
@@ -1207,14 +1443,29 @@ const globalTransformRegistry = new TransformRegistry(), callGPT5 = async (apiKe
   }), devLog.debug("OpenAI Chat Completions Full Prompt", {
     messages: request.messages
   });
-  const response = await fetch("https://api.openai.com/v1/chat/completions", {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${apiKey}`
+  const response = await retryWithBackoff(
+    async () => {
+      const fetchResponse = await fetch("https://api.openai.com/v1/chat/completions", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${apiKey}`
+        },
+        body: JSON.stringify(requestBody)
+      });
+      if (!fetchResponse.ok) {
+        const errorMessage = `OpenAI API error: ${(await fetchResponse.json()).error?.message || "Unknown error"}`, errorObj = new Error(errorMessage);
+        throw errorObj.response = { status: fetchResponse.status }, errorObj;
+      }
+      return fetchResponse;
     },
-    body: JSON.stringify(requestBody)
-  });
+    {
+      maxAttempts: 2,
+      initialDelayMs: 0,
+      retryableErrors: isNetworkError,
+      context: { model, endpoint: "chat/completions" }
+    }
+  );
   if (!response.ok) {
     const error = await response.json();
     throw new Error(`OpenAI API error: ${error.error?.message || "Unknown error"}`);
@@ -1276,16 +1527,63 @@ const globalTransformRegistry = new TransformRegistry(), callGPT5 = async (apiKe
   }, modelPricing = pricing[model] || pricing["gpt-5"], cachedInputRate = model === "gpt-5.1" ? 0.125 / 1e6 : modelPricing.input;
   return Math.max(0, tokens.prompt - tokens.cached) * modelPricing.input + tokens.cached * cachedInputRate + tokens.completion * modelPricing.output + tokens.reasoning * modelPricing.reasoning;
 }, deserializeDocument = (originalDoc, reviewedText) => {
-  const parsed = parseReviewFormat(reviewedText), result = cloneDeep(originalDoc);
+  devLog.debug("Raw GPT-5 response received", {
+    length: reviewedText.length,
+    preview: reviewedText.substring(0, 1e3),
+    hasReasoning: reviewedText.includes("<reasoning>"),
+    hasCodeBlocks: reviewedText.includes("```")
+  });
+  const cleanedText = preprocessResponse(reviewedText);
+  cleanedText.length !== reviewedText.length && devLog.debug("Response after preprocessing", {
+    originalLength: reviewedText.length,
+    cleanedLength: cleanedText.length,
+    preview: cleanedText.substring(0, 500)
+  });
+  const parsed = parseReviewFormat(cleanedText, originalDoc);
+  devLog.debug("Parsed response structure", {
+    rootNodeCount: parsed.length,
+    rootNodeNames: parsed.map((n) => n.type === "field" && n.name ? n.name : "unknown")
+  });
+  const result = cloneDeep(originalDoc);
   return applyTextChanges(result, parsed), result;
-}, parseReviewFormat = (text) => {
+}, preprocessResponse = (text) => {
+  const originalLength = text.length;
+  let cleaned = text;
+  const beforeReasoning = cleaned.length;
+  cleaned = cleaned.replace(/<reasoning>[\s\S]*?<\/reasoning>/gi, "");
+  const reasoningRemoved = beforeReasoning !== cleaned.length, beforeCodeBlocks = cleaned.length;
+  cleaned = cleaned.replace(/^```[a-z]*\s*$/gim, ""), cleaned = cleaned.replace(/^```\s*$/gim, "");
+  const codeBlocksRemoved = beforeCodeBlocks !== cleaned.length, finalLength = cleaned.trim().length;
+  return (reasoningRemoved || codeBlocksRemoved) && devLog.debug("Preprocessed GPT-5 response", {
+    originalLength,
+    finalLength,
+    reasoningRemoved,
+    codeBlocksRemoved,
+    preview: cleaned.trim().substring(0, 200)
+  }), cleaned.trim();
+}, parseReviewFormat = (text, originalDoc) => {
   const root = [], stack = [], lines = text.split(`
 `);
+  devLog.debug("Parsing response text", {
+    lineCount: lines.length,
+    firstLines: lines.slice(0, 10).map((l, idx) => ({ line: idx, content: l.substring(0, 100) })),
+    hasFieldTags: text.includes("<field"),
+    hasBlockTags: text.includes("<block"),
+    hasSpanTags: text.includes("<span"),
+    textLength: text.length,
+    textPreview: text.substring(0, 500)
+  });
+  let processedLineCount = 0, skippedEmptyLineCount = 0, matchedPatternCount = 0;
   for (let i = 0; i < lines.length; i++) {
     const trimmed = lines[i].trim();
-    if (!trimmed) continue;
+    if (!trimmed) {
+      skippedEmptyLineCount++;
+      continue;
+    }
+    processedLineCount++;
     const compactStringMatch = trimmed.match(/^(\w+):\s*(.*)$/);
     if (compactStringMatch && !trimmed.includes("<")) {
+      matchedPatternCount++;
       const [, fieldName, text2] = compactStringMatch, node = {
         type: "field",
         name: fieldName,
@@ -1302,6 +1600,7 @@ const globalTransformRegistry = new TransformRegistry(), callGPT5 = async (apiKe
     }
     const compactStartMatch = trimmed.match(/^---\s+(\w+)\s+---$/);
     if (compactStartMatch) {
+      matchedPatternCount++;
       const fieldName = compactStartMatch[1], contentLines = [];
       for (i++; i < lines.length; ) {
         const currentLine = lines[i];
@@ -1311,8 +1610,16 @@ const globalTransformRegistry = new TransformRegistry(), callGPT5 = async (apiKe
       }
       const content = contentLines.join(`
 `);
-      let contentType = "translatable.vtt.captions";
-      (content.includes("<block") || content.includes("<span")) && (contentType = "translatable.richtext");
+      let contentType;
+      try {
+        const fieldValue = get(originalDoc, [fieldName]);
+        if (fieldValue && typeof fieldValue == "object" && fieldValue !== null) {
+          const fieldType = fieldValue._type;
+          typeof fieldType == "string" && fieldType.startsWith("translatable.") && (contentType = fieldType);
+        }
+      } catch {
+      }
+      contentType || (content.includes("<block") || content.includes("<span") ? contentType = "translatable.richtext" : contentType = "translatable.vtt.captions");
       const node = {
         type: "field",
         name: fieldName,
@@ -1329,6 +1636,12 @@ const globalTransformRegistry = new TransformRegistry(), callGPT5 = async (apiKe
     }
     const openMatch = trimmed.match(/^<(field|block|span)([^>]*)>(.*)$/);
     if (openMatch) {
+      matchedPatternCount++, devLog.debug("Matched opening tag", {
+        line: i,
+        tagName: openMatch[1],
+        attributes: openMatch[2],
+        contentPreview: openMatch[3]?.substring(0, 50)
+      });
       const [, tagName, attrsStr, content] = openMatch, attributes = parseAttributes(attrsStr), node = {
         type: tagName,
         name: attributes.name,
@@ -1349,7 +1662,7 @@ const globalTransformRegistry = new TransformRegistry(), callGPT5 = async (apiKe
           parent && parent.children.push(node);
         } else
           root.push(node);
-      else if (attributes.type === "translatable.vtt.captions" || attributes.type === "translatable.richtext") {
+      else if (attributes.type && typeof attributes.type == "string" && attributes.type.startsWith("translatable.")) {
         const contentLines = [];
         for (i++; i < lines.length; ) {
           const currentLine = lines[i];
@@ -1388,6 +1701,7 @@ const globalTransformRegistry = new TransformRegistry(), callGPT5 = async (apiKe
       continue;
     }
     if (trimmed.match(/^<\/(field|block|span)>$/) && stack.length > 0) {
+      matchedPatternCount++;
       const node = stack.pop();
       if (node)
         if (stack.length > 0) {
@@ -1395,9 +1709,24 @@ const globalTransformRegistry = new TransformRegistry(), callGPT5 = async (apiKe
           parent && parent.children.push(node);
         } else
           root.push(node);
+      continue;
     }
+    processedLineCount <= 20 && devLog.debug("Line did not match any pattern", {
+      line: i,
+      trimmed,
+      startsWithLessThan: trimmed.startsWith("<"),
+      startsWithField: trimmed.startsWith("<field"),
+      startsWithBacktick: trimmed.startsWith("`")
+    });
   }
-  return root;
+  return devLog.debug("Parse complete", {
+    totalLines: lines.length,
+    processedLines: processedLineCount,
+    skippedEmptyLines: skippedEmptyLineCount,
+    rootNodeCount: root.length,
+    stackLength: stack.length,
+    matchedPatterns: matchedPatternCount
+  }), root;
 }, parseAttributes = (attrStr) => {
   const attrs = {}, attrRegex = /(\w+)="([^"]*)"/g;
   let match = attrRegex.exec(attrStr);
@@ -1405,20 +1734,29 @@ const globalTransformRegistry = new TransformRegistry(), callGPT5 = async (apiKe
     attrs[match[1]] = unescapeXml(match[2]), match = attrRegex.exec(attrStr);
   return attrs;
 }, unescapeXml = (str) => str.replace(/&apos;/g, "'").replace(/&quot;/g, '"').replace(/&gt;/g, ">").replace(/&lt;/g, "<").replace(/&amp;/g, "&"), applyTextChanges = (doc, parsedNodes) => {
+  devLog.debug("Applying text changes from parsed nodes", {
+    nodeCount: parsedNodes.length,
+    nodeNames: parsedNodes.map((n) => n.type === "field" && n.name ? n.name : "unknown")
+  });
   for (const node of parsedNodes)
     if (node.type === "field" && node.name) {
-      const path = [node.name];
+      const path = [node.name], beforeValue = get(doc, path);
       applyFieldChanges(doc, path, node);
+      const afterValue = get(doc, path);
+      beforeValue !== afterValue && devLog.debug("Field updated during deserialization", {
+        path: path.join("."),
+        before: typeof beforeValue == "string" ? beforeValue.substring(0, 50) : beforeValue,
+        after: typeof afterValue == "string" ? afterValue.substring(0, 50) : afterValue
+      });
     }
 }, applyFieldChanges = (doc, path, node) => {
-  if (node.attributes.type === "translatable.vtt.captions") {
-    const fieldValue = get(doc, path);
-    fieldValue && typeof fieldValue == "object" && fieldValue._type === "translatable.vtt.captions" && node.text && set(doc, [...path, "translationText"], node.text);
-    return;
-  }
-  if (node.attributes.type === "translatable.richtext") {
+  const nodeType = node.attributes.type;
+  if (typeof nodeType == "string" && nodeType.startsWith("translatable.")) {
     const fieldValue = get(doc, path);
-    fieldValue && typeof fieldValue == "object" && fieldValue._type === "translatable.richtext" && node.text && set(doc, [...path, "translationText"], node.text);
+    if (fieldValue && typeof fieldValue == "object" && fieldValue !== null) {
+      const fieldType = fieldValue._type;
+      typeof fieldType == "string" && fieldType === nodeType && node.text && set(doc, [...path, "translationText"], node.text);
+    }
     return;
   }
   if (node.attributes.type === "array") {
@@ -1506,12 +1844,9 @@ const globalTransformRegistry = new TransformRegistry(), callGPT5 = async (apiKe
       return;
     }
     if (isPlainObject(value)) {
-      if (value._type === "translatable.vtt.captions" && typeof value.translationText == "string") {
-        lines.push(`${indentStr}--- ${fieldName} ---`), lines.push(value.translationText), lines.push(`${indentStr}--- /${fieldName} ---`);
-        return;
-      }
-      if (value._type === "translatable.richtext" && typeof value.translationText == "string") {
-        lines.push(`${indentStr}--- ${fieldName} ---`), lines.push(value.translationText), lines.push(`${indentStr}--- /${fieldName} ---`);
+      const valueObj = value, valueType = valueObj._type, translationText = valueObj.translationText;
+      if (typeof valueType == "string" && valueType.startsWith("translatable.") && typeof translationText == "string") {
+        lines.push(`${indentStr}--- ${fieldName} ---`), lines.push(translationText), lines.push(`${indentStr}--- /${fieldName} ---`);
         return;
       }
       lines.push(`${indentStr}<field name="${fieldName}" type="object">`);
@@ -1647,7 +1982,9 @@ const globalTransformRegistry = new TransformRegistry(), callGPT5 = async (apiKe
   languageFieldName,
   translationPrompts,
   targetLanguage,
-  openaiConfig
+  openaiConfig,
+  previousError,
+  errorContext
 }) => {
   const sourceLanguage = sourceDocument[languageFieldName], logContext = {
     sourceId: sourceDocument._id,
@@ -1665,7 +2002,8 @@ const globalTransformRegistry = new TransformRegistry(), callGPT5 = async (apiKe
       sourceText,
       sourceLanguage,
       targetLanguage,
-      translationPrompts
+      translationPrompts,
+      errorContext
     }), response = await callGPT5(openaiConfig.apiKey, {
       messages: [
         {
@@ -1723,14 +2061,21 @@ const globalTransformRegistry = new TransformRegistry(), callGPT5 = async (apiKe
   sourceText,
   sourceLanguage,
   targetLanguage,
-  translationPrompts
+  translationPrompts,
+  errorContext
 }) => {
   const { globalPrompt, localeInstructions, protectedPhrases } = translationPrompts, localePrompt = localeInstructions[targetLanguage]?.prompt, glossaryTerms = localeInstructions[targetLanguage]?.glossaryTerms;
   return `# TRANSLATION TASK
 
 Translate this ${sourceLanguage} document into ${targetLanguage}.
 
-## Guidelines
+${errorContext ? `## \u26A0\uFE0F IMPORTANT: Previous Attempt Error
+
+${errorContext}
+
+Please carefully review the error above and ensure your translation fixes the issue.
+
+` : ""}## Guidelines
 
 ${globalPrompt ? `### General Guidelines
 ${globalPrompt}
@@ -1904,21 +2249,34 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
     languageFieldName,
     targetLanguage
   });
-  return await client.agent.action.translate({
-    schemaId,
-    toLanguage,
-    fromLanguage,
-    documentId: sourceDocument._id,
-    noWrite: !0,
-    // Do not write to the document, just return the translated content
-    languageFieldPath: [languageFieldName],
-    styleGuide,
-    protectedPhrases: translationPrompts.protectedPhrases,
-    conditionalPaths: {
-      defaultHidden: !1,
-      defaultReadOnly: !1
+  return await retryWithBackoff(
+    async () => await client.agent.action.translate({
+      schemaId,
+      toLanguage,
+      fromLanguage,
+      documentId: sourceDocument._id,
+      noWrite: !0,
+      // Do not write to the document, just return the translated content
+      languageFieldPath: [languageFieldName],
+      styleGuide,
+      protectedPhrases: translationPrompts.protectedPhrases,
+      conditionalPaths: {
+        defaultHidden: !1,
+        defaultReadOnly: !1
+      }
+    }),
+    {
+      maxAttempts: 2,
+      initialDelayMs: 0,
+      retryableErrors: isNetworkError,
+      context: {
+        operation: "agent.action.translate",
+        documentId: sourceDocument._id,
+        targetLanguage,
+        schemaId
+      }
     }
-  });
+  );
 }, handleTranslation = async ({
   dispatch,
   client,
@@ -1974,43 +2332,44 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
       documentId: sourceDocument._id,
       documentType: sourceDocument._type
     }), documentToTranslate = filteredDocument;
-  let translatedDoc;
-  switch (translationMode) {
-    case "sanity-only": {
-      setJobStatus(dispatch, sourceDocument._id, targetLanguage, "translating", void 0, mainSourceDocumentId), translatedDoc = await getSanityAgentTranslation({
-        sourceDocument: documentToTranslate,
-        targetLanguage,
-        languageFieldName,
-        schemaId,
-        client,
-        translationPrompts
-      });
-      break;
-    }
-    case "openai-only": {
-      if (!openaiConfig?.enabled || !openaiConfig?.apiKey)
-        throw new Error("OpenAI is not configured but openai-only mode was selected");
-      setJobStatus(
-        dispatch,
-        sourceDocument._id,
-        targetLanguage,
-        "translating_with_openai",
-        void 0,
-        mainSourceDocumentId
-      ), translatedDoc = await getOpenAITranslation({
-        dispatch,
-        sourceDocument: documentToTranslate,
-        targetLanguage,
-        languageFieldName,
-        translationPrompts,
-        openaiConfig
-      });
-      break;
+  let translatedDoc, previousError = null;
+  const performTranslation = async (errorContext) => {
+    switch (translationMode) {
+      case "sanity-only":
+        return setJobStatus(dispatch, sourceDocument._id, targetLanguage, "translating", void 0, mainSourceDocumentId), await getSanityAgentTranslation({
+          sourceDocument: documentToTranslate,
+          targetLanguage,
+          languageFieldName,
+          schemaId,
+          client,
+          translationPrompts
+        });
+      case "openai-only": {
+        if (!openaiConfig?.enabled || !openaiConfig?.apiKey)
+          throw new Error("OpenAI is not configured but openai-only mode was selected");
+        return setJobStatus(
+          dispatch,
+          sourceDocument._id,
+          targetLanguage,
+          "translating_with_openai",
+          void 0,
+          mainSourceDocumentId
+        ), await getOpenAITranslation({
+          dispatch,
+          sourceDocument: documentToTranslate,
+          targetLanguage,
+          languageFieldName,
+          translationPrompts,
+          openaiConfig,
+          previousError: errorContext && previousError ? previousError : void 0,
+          errorContext
+        });
+      }
+      default:
+        throw new Error(`Invalid translation mode: ${translationMode}`);
     }
-    default:
-      throw new Error(`Invalid translation mode: ${translationMode}`);
-  }
-  if (!translatedDoc)
+  };
+  if (translatedDoc = await performTranslation(), !translatedDoc)
     return null;
   let transformedResult;
   Object.keys(originalStructure).length > 0 ? (devLog.debug("Restoring field transforms after translation", {
@@ -2041,15 +2400,76 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
     ...finalDoc,
     _id: targetDocumentVersionId
   };
-  return replaceExisting && await client.getDocument(targetDocumentVersionId) && (devLog.info("Replacing existing version in release", {
+  replaceExisting && await client.getDocument(targetDocumentVersionId) && (devLog.info("Replacing existing version in release", {
     documentId: sourceDocument._id,
     targetDocumentVersionId,
     releaseId
-  }), await client.delete(targetDocumentVersionId)), await client.action({
-    actionType: "sanity.action.document.version.create",
-    publishedId: targetDocumentPublishedId,
-    document: newDoc
-  }), newDoc;
+  }), await client.delete(targetDocumentVersionId));
+  try {
+    await retryWithBackoff(
+      async () => {
+        await client.action({
+          actionType: "sanity.action.document.version.create",
+          publishedId: targetDocumentPublishedId,
+          document: newDoc
+        });
+      },
+      {
+        maxAttempts: 2,
+        initialDelayMs: 0,
+        retryableErrors: isNetworkError,
+        context: {
+          documentId: sourceDocument._id,
+          targetLanguage,
+          operation: "version.create"
+        }
+      }
+    );
+  } catch (error) {
+    if (translationMode === "openai-only" && isSanityMutationError(error)) {
+      devLog.warn("Mutation error after OpenAI translation, retrying full translation", {
+        documentId: sourceDocument._id,
+        targetLanguage,
+        error: error instanceof Error ? error.message : String(error)
+      }), previousError = error instanceof Error ? error : new Error(String(error));
+      const errorContext = `Previous translation attempt failed with Sanity validation error: ${previousError.message}. Please ensure the translated document structure exactly matches the source document structure.`;
+      if (translatedDoc = await performTranslation(errorContext), !translatedDoc)
+        throw new Error("Translation retry failed: no document returned");
+      let retryTransformedResult;
+      Object.keys(originalStructure).length > 0 ? retryTransformedResult = restoreTransforms({
+        translatedDocument: translatedDoc,
+        originalStructure,
+        registry: globalTransformRegistry,
+        schemaType: sourceDocument._type
+      }) : retryTransformedResult = translatedDoc;
+      const retryNewDoc = {
+        ...restoreExcludedFields(retryTransformedResult, excludedValuesToRestore),
+        _id: targetDocumentVersionId
+      };
+      return await retryWithBackoff(
+        async () => {
+          await client.action({
+            actionType: "sanity.action.document.version.create",
+            publishedId: targetDocumentPublishedId,
+            document: retryNewDoc
+          });
+        },
+        {
+          maxAttempts: 2,
+          initialDelayMs: 0,
+          retryableErrors: isNetworkError,
+          context: {
+            documentId: sourceDocument._id,
+            targetLanguage,
+            operation: "version.create",
+            isRetry: !0
+          }
+        }
+      ), retryNewDoc;
+    }
+    throw error;
+  }
+  return newDoc;
 }, translateDocument = async ({
   dispatch,
   client,
@@ -2189,13 +2609,25 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
       });
     else {
       const releaseTitle = releaseConfig.newReleaseTitle, releaseDescription = `AI translation batch created on ${(/* @__PURE__ */ new Date()).toLocaleDateString()} at ${(/* @__PURE__ */ new Date()).toLocaleTimeString()}`;
-      releaseId = (await client.releases.create({
-        metadata: {
-          title: releaseTitle,
-          description: releaseDescription,
-          releaseType: "undecided"
+      releaseId = (await retryWithBackoff(
+        async () => await client.releases.create({
+          metadata: {
+            title: releaseTitle,
+            description: releaseDescription,
+            releaseType: "undecided"
+          }
+        }),
+        {
+          maxAttempts: 2,
+          initialDelayMs: 0,
+          retryableErrors: isNetworkError,
+          context: {
+            operation: "releases.create",
+            releaseTitle,
+            ...logContext
+          }
         }
-      })).releaseId, createdNewRelease = !0, devLog.info("Content Release created", {
+      )).releaseId, createdNewRelease = !0, devLog.info("Content Release created", {
         ...logContext,
         releaseId,
         releaseTitle
@@ -2344,10 +2776,11 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
     overallStatus,
     dispatch,
     references,
+    selectedReferenceIds,
     selectedTargetLanguages,
     translationMode,
     releaseConfig
-  } = useTranslationContext(), client = useClient({ apiVersion: "vX" }), [conflictContext, setConflictContext] = useState(null), [isCheckingConflicts, setIsCheckingConflicts] = useState(!1);
+  } = useTranslationContext(), client = useClient({ apiVersion: "vX" }), [conflictContext, setConflictContext] = useState(null), [isCheckingConflicts, setIsCheckingConflicts] = useState(!1), filteredReferences = references.filter((ref) => selectedReferenceIds.has(ref._id));
   useEffect(() => {
     releaseConfig.mode === "new" && conflictContext && setConflictContext(null);
   }, [releaseConfig.mode, conflictContext]);
@@ -2360,7 +2793,7 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
         dispatch,
         languageFieldName: config.languageFieldName,
         schemaId: config.schemaId,
-        references,
+        references: filteredReferences,
         maxConcurrentTranslationJobs: config.maxConcurrentTranslationJobs,
         maxReferenceDepth: config.maxReferenceDepth,
         translationMode,
@@ -2386,7 +2819,7 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
       config.maxReferenceDepth,
       config.openai,
       config.excludeFields,
-      references,
+      filteredReferences,
       translationMode,
       releaseConfig
     ]
@@ -2404,7 +2837,7 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
         sourceDocument: document,
         targetLanguages: selectedTargetLanguages,
         languageFieldName: config.languageFieldName,
-        references
+        references: filteredReferences
       });
       if (setIsCheckingConflicts(!1), foundConflicts.length > 0) {
         setConflictContext({
@@ -2415,7 +2848,7 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
       }
     }
     startTranslation(!1);
-  }, [releaseConfig, client, document, selectedTargetLanguages, config.languageFieldName, startTranslation, references]), handleCancelConflict = useCallback(() => {
+  }, [releaseConfig, client, document, selectedTargetLanguages, config.languageFieldName, startTranslation, filteredReferences]), handleCancelConflict = useCallback(() => {
     setConflictContext(null);
   }, []), handleReplaceConflict = useCallback(() => {
     conflictContext && startTranslation(!0, conflictContext.releaseId);
@@ -2789,8 +3222,104 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
     });
   }
   return result;
+}, ReferenceSelectionPanel = () => {
+  const { references, selectedReferenceIds, dispatch } = useTranslationContext(), [typeFilter, setTypeFilter] = useState("all"), documentTypes = useMemo(() => {
+    const types = new Set(references.map((ref) => ref._type));
+    return Array.from(types).sort();
+  }, [references]), filteredReferences = useMemo(() => typeFilter === "all" ? references : references.filter((ref) => ref._type === typeFilter), [references, typeFilter]), selectedCount = useMemo(() => filteredReferences.filter((ref) => selectedReferenceIds.has(ref._id)).length, [filteredReferences, selectedReferenceIds]), handleToggleReference = (referenceId) => {
+    const newSelection = new Set(selectedReferenceIds);
+    newSelection.has(referenceId) ? newSelection.delete(referenceId) : newSelection.add(referenceId), dispatch({
+      type: "SET_SELECTED_REFERENCE_IDS",
+      payload: newSelection
+    });
+  }, handleSelectAll = () => {
+    const newSelection = new Set(selectedReferenceIds);
+    filteredReferences.forEach((ref) => {
+      newSelection.add(ref._id);
+    }), dispatch({
+      type: "SET_SELECTED_REFERENCE_IDS",
+      payload: newSelection
+    });
+  }, handleSelectNone = () => {
+    const newSelection = new Set(selectedReferenceIds);
+    filteredReferences.forEach((ref) => {
+      newSelection.delete(ref._id);
+    }), dispatch({
+      type: "SET_SELECTED_REFERENCE_IDS",
+      payload: newSelection
+    });
+  };
+  return references.length === 0 ? null : /* @__PURE__ */ jsx(Card, { padding: 4, border: !0, muted: !0, children: /* @__PURE__ */ jsxs(Stack, { space: 3, children: [
+    /* @__PURE__ */ jsxs(Flex, { justify: "space-between", align: "center", gap: 2, children: [
+      /* @__PURE__ */ jsxs(Flex, { gap: 2, align: "center", children: [
+        /* @__PURE__ */ jsx(Text, { size: 1, weight: "semibold", children: "Select References" }),
+        /* @__PURE__ */ jsxs(Text, { size: 1, muted: !0, children: [
+          "(",
+          selectedCount,
+          " of ",
+          filteredReferences.length,
+          " selected)"
+        ] })
+      ] }),
+      /* @__PURE__ */ jsxs(Flex, { gap: 2, children: [
+        /* @__PURE__ */ jsx(Button, { mode: "ghost", size: 1, onClick: handleSelectAll, text: "Select All" }),
+        /* @__PURE__ */ jsx(Button, { mode: "ghost", size: 1, onClick: handleSelectNone, text: "Select None" })
+      ] })
+    ] }),
+    documentTypes.length > 1 && /* @__PURE__ */ jsxs(Flex, { align: "center", gap: 2, children: [
+      /* @__PURE__ */ jsx(Text, { size: 1, muted: !0, children: "Filter by type:" }),
+      /* @__PURE__ */ jsxs(
+        Select,
+        {
+          value: typeFilter,
+          onChange: (event) => setTypeFilter(event.target.value),
+          style: { minWidth: "150px" },
+          children: [
+            /* @__PURE__ */ jsxs("option", { value: "all", children: [
+              "All types (",
+              references.length,
+              ")"
+            ] }),
+            documentTypes.map((type) => {
+              const count = references.filter((ref) => ref._type === type).length;
+              return /* @__PURE__ */ jsxs("option", { value: type, children: [
+                type,
+                " (",
+                count,
+                ")"
+              ] }, type);
+            })
+          ]
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx(Box, { style: { maxHeight: "400px", overflowY: "auto" }, children: /* @__PURE__ */ jsx(Stack, { space: 2, children: filteredReferences.length === 0 ? /* @__PURE__ */ jsx(Text, { size: 1, muted: !0, children: "No references match the selected filter." }) : filteredReferences.map((reference) => {
+      const isSelected = selectedReferenceIds.has(reference._id), displayTitle = reference.title || reference._id;
+      return /* @__PURE__ */ jsx(Card, { padding: 3, border: !0, radius: 2, children: /* @__PURE__ */ jsxs(Flex, { align: "center", gap: 3, children: [
+        /* @__PURE__ */ jsx(
+          Checkbox,
+          {
+            checked: isSelected,
+            onChange: () => handleToggleReference(reference._id)
+          }
+        ),
+        /* @__PURE__ */ jsxs(Flex, { flex: 1, align: "center", gap: 2, children: [
+          /* @__PURE__ */ jsx(Text, { size: 1, children: displayTitle }),
+          /* @__PURE__ */ jsx(Badge, { tone: "primary", fontSize: 0, children: reference._type })
+        ] })
+      ] }) }, reference._id);
+    }) }) })
+  ] }) });
 }, ReferenceConfigPanel = () => {
-  const { dispatch, document, shouldTranslateReferences, maxReferenceDepth, config, references } = useTranslationContext(), client = useClient({ apiVersion: "vX" }), [isLoadingReferences, setIsLoadingReferences] = useState(!1), maxDepth = config.maxReferenceDepth || 3;
+  const {
+    dispatch,
+    document,
+    shouldTranslateReferences,
+    maxReferenceDepth,
+    config,
+    references,
+    selectedReferenceIds
+  } = useTranslationContext(), client = useClient({ apiVersion: "vX" }), [isLoadingReferences, setIsLoadingReferences] = useState(!1), [showSelectionPanel, setShowSelectionPanel] = useState(!1), maxDepth = config.maxReferenceDepth || 3;
   useEffect(() => {
     (async () => {
       if (setIsLoadingReferences(!0), !shouldTranslateReferences) {
@@ -2860,7 +3389,24 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
         )
       ] }) : null
     ] }),
-    shouldTranslateReferences ? /* @__PURE__ */ jsx(Flex, { padding: 2, justify: "flex-end", children: /* @__PURE__ */ jsx(Text, { size: 1, muted: !0, children: isLoadingReferences ? "Loading references..." : references.length === 0 ? "No translatable references found." : `${references.length} translatable references found.` }) }) : null
+    shouldTranslateReferences ? /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsxs(Flex, { padding: 2, justify: "space-between", align: "center", children: [
+        /* @__PURE__ */ jsx(Text, { size: 1, muted: !0, children: isLoadingReferences ? "Loading references..." : references.length === 0 ? "No translatable references found." : (() => {
+          const selectedCount = references.filter((ref) => selectedReferenceIds.has(ref._id)).length, totalCount = references.length;
+          return selectedCount === totalCount ? `${totalCount} reference${totalCount === 1 ? "" : "s"} will be translated along with this document.` : `${selectedCount} of ${totalCount} reference${totalCount === 1 ? "" : "s"} will be translated along with this document.`;
+        })() }),
+        !isLoadingReferences && references.length > 0 && /* @__PURE__ */ jsx(
+          Button,
+          {
+            mode: "ghost",
+            size: 1,
+            text: showSelectionPanel ? "Hide selection" : "Select specific references...",
+            onClick: () => setShowSelectionPanel(!showSelectionPanel)
+          }
+        )
+      ] }),
+      !isLoadingReferences && references.length > 0 && showSelectionPanel && /* @__PURE__ */ jsx(ReferenceSelectionPanel, {})
+    ] }) : null
   ] });
 }, WriteSettingsPanel = () => /* @__PURE__ */ jsx(ReferenceConfigPanel, {}), TranslationConfigView = ({ setIsDialogOpen }) => /* @__PURE__ */ jsxs(Stack, { space: 4, children: [
   /* @__PURE__ */ jsxs(Stack, { space: 2, children: [
@@ -3436,10 +3982,14 @@ function serializeVTTCaptionText(captions) {
     firstCaption: captions.length > 0 ? captions[0] : null
   }), !Array.isArray(captions) || captions.length === 0)
     return "";
-  const result = captions.map((caption, index) => (devLog.debug(`Processing caption ${index}:`, {
-    text: caption.text,
-    hasText: typeof caption.text == "string"
-  }), `[${index}] ${caption.text || ""}`)).join(`
+  const result = captions.map((caption, index) => {
+    devLog.debug(`Processing caption ${index}:`, {
+      text: caption.text,
+      hasText: typeof caption.text == "string"
+    });
+    const escapedText = (caption.text || "").replace(/\n/g, "\\n");
+    return `[${index}] ${escapedText}`;
+  }).join(`
 `);
   return devLog.debug("serializeVTTCaptionText - output:", {
     resultLength: result.length,
@@ -3456,29 +4006,46 @@ function deserializeVTTCaptionText(translationText, originalMetadata) {
     return [];
   const result = [], lines = translationText.split(`
 `), lineRegex = /^\[(\d+)\]\s*(.*)$/;
+  let currentIndex = null, currentTextParts = [];
   for (const line of lines) {
     const match = line.match(lineRegex);
-    if (!match) {
-      devLog.warn("Failed to parse caption line", { line });
-      continue;
-    }
-    const index = Number.parseInt(match[1], 10), text = match[2];
-    devLog.debug("Found caption:", {
-      index,
-      text
-    });
-    const metadata = originalMetadata.find((m) => m._originalIndex === index);
+    if (match) {
+      if (currentIndex !== null) {
+        const text = currentTextParts.join(`
+`).replace(/\\n/g, `
+`), metadata = originalMetadata.find((m) => m._originalIndex === currentIndex);
+        if (metadata) {
+          const { _originalIndex, ...metadataWithoutIndex } = metadata;
+          result.push({
+            ...metadataWithoutIndex,
+            text
+          });
+        } else
+          devLog.warn("Missing metadata for caption", { index: currentIndex }), result.push({
+            _type: "vtt.cue",
+            _key: `caption-${currentIndex}`,
+            text,
+            startTime: 0,
+            endTime: 0
+          });
+      }
+      currentIndex = Number.parseInt(match[1], 10), currentTextParts = [match[2]];
+    } else currentIndex !== null ? currentTextParts.push(line) : devLog.warn("Failed to parse caption line", { line });
+  }
+  if (currentIndex !== null) {
+    const text = currentTextParts.join(`
+`).replace(/\\n/g, `
+`), metadata = originalMetadata.find((m) => m._originalIndex === currentIndex);
     if (metadata) {
-      devLog.debug(`Found matching metadata for index ${index}`);
       const { _originalIndex, ...metadataWithoutIndex } = metadata;
       result.push({
         ...metadataWithoutIndex,
         text
       });
     } else
-      devLog.warn("Missing metadata for caption", { index }), result.push({
+      devLog.warn("Missing metadata for caption", { index: currentIndex }), result.push({
         _type: "vtt.cue",
-        _key: `caption-${index}`,
+        _key: `caption-${currentIndex}`,
         text,
         startTime: 0,
         endTime: 0
@@ -3489,6 +4056,293 @@ function deserializeVTTCaptionText(translationText, originalMetadata) {
     resultExample: result.length > 0 ? result[0] : null
   }), result;
 }
+const LOCALE_TO_ISO = {
+  // English variants
+  "en-us": "eng",
+  "en-US": "eng",
+  "en-gb": "eng",
+  "en-GB": "eng",
+  "en-ca": "eng",
+  "en-CA": "eng",
+  "en-au": "eng",
+  "en-AU": "eng",
+  // Spanish variants
+  es: "spa",
+  "es-es": "spa",
+  "es-ES": "spa",
+  "es-mx": "spa",
+  "es-MX": "spa",
+  // French variants
+  fr: "fra",
+  "fr-fr": "fra",
+  "fr-FR": "fra",
+  "fr-ca": "fra",
+  "fr-CA": "fra",
+  // German variants
+  de: "ger",
+  "de-de": "ger",
+  "de-DE": "ger",
+  "de-at": "ger",
+  "de-AT": "ger",
+  // Italian variants
+  it: "ita",
+  "it-it": "ita",
+  "it-IT": "ita",
+  // Portuguese variants
+  pt: "por",
+  "pt-br": "por",
+  "pt-BR": "por",
+  "pt-pt": "por",
+  "pt-PT": "por",
+  // Russian variants
+  ru: "rus",
+  "ru-ru": "rus",
+  "ru-RU": "rus",
+  // Japanese variants
+  ja: "jpn",
+  "ja-jp": "jpn",
+  "ja-JP": "jpn",
+  // Korean variants
+  ko: "kor",
+  "ko-kr": "kor",
+  "ko-KR": "kor",
+  // Chinese variants
+  zh: "chi",
+  "zh-cn": "chi",
+  "zh-CN": "chi",
+  "zh-tw": "chi",
+  "zh-TW": "chi",
+  "zh-hk": "chi",
+  "zh-HK": "chi"
+}, normalizeToIsoLanguageCode = (code) => {
+  const normalizedCode = code.toLowerCase();
+  return LOCALE_TO_ISO[normalizedCode];
+}, wistiaCaptionTransform = {
+  matcher: {
+    fieldName: "wistiaCaptions"
+  },
+  toTranslatable: (wistiaCaptions, context) => {
+    if (devLog.info("Wistia captions toTranslatable - input:", {
+      fieldPath: context.fieldPath,
+      hasCaptionContent: !!wistiaCaptions?.captionContent,
+      captionContentLength: wistiaCaptions?.captionContent?.length ?? 0,
+      isoLanguage: wistiaCaptions?.isoLanguage
+    }), !wistiaCaptions || !wistiaCaptions.captionContent)
+      return devLog.debug("Wistia caption field is missing or has no content, returning empty transform", {
+        fieldPath: context.fieldPath,
+        value: wistiaCaptions
+      }), {
+        _type: "translatable.wistia.captions",
+        translationText: "",
+        _originalMetadata: {
+          captionFileName: wistiaCaptions?.captionFileName,
+          isoLanguage: wistiaCaptions?.isoLanguage,
+          captionUploadStatus: wistiaCaptions?.captionUploadStatus,
+          captionUploadMessage: wistiaCaptions?.captionUploadMessage,
+          _originalIndex: 0
+        },
+        _srtCues: []
+      };
+    devLog.info("Applying Wistia caption transform", {
+      fieldPath: context.fieldPath,
+      captionContentPreview: wistiaCaptions.captionContent.substring(0, 200)
+    });
+    const srtCues = parseSRTContent(wistiaCaptions.captionContent);
+    devLog.debug("Parsed SRT cues:", {
+      fieldPath: context.fieldPath,
+      cueCount: srtCues.length,
+      firstCue: srtCues.length > 0 ? srtCues[0] : null
+    });
+    const translationText = serializeWistiaCaptionText(srtCues), originalMetadata = {
+      captionFileName: wistiaCaptions.captionFileName,
+      isoLanguage: wistiaCaptions.isoLanguage,
+      captionUploadStatus: wistiaCaptions.captionUploadStatus,
+      captionUploadMessage: wistiaCaptions.captionUploadMessage,
+      _originalIndex: 0
+    }, srtCuesMetadata = srtCues.map((cue) => ({
+      index: cue.index,
+      startTime: cue.startTime,
+      endTime: cue.endTime
+    }));
+    return devLog.info("Wistia captions serialized:", {
+      fieldPath: context.fieldPath,
+      translationTextLength: translationText.length,
+      translationTextPreview: translationText.substring(0, 200) + (translationText.length > 200 ? "..." : ""),
+      cueCount: srtCues.length
+    }), {
+      _type: "translatable.wistia.captions",
+      translationText,
+      _originalMetadata: originalMetadata,
+      _srtCues: srtCuesMetadata
+    };
+  },
+  fromTranslatable: (translatedValue, originalValue, context) => {
+    if (devLog.info("Wistia captions fromTranslatable - input:", {
+      fieldPath: context.fieldPath,
+      valueType: typeof translatedValue,
+      isCorrectType: translatedValue._type === "translatable.wistia.captions",
+      hasText: !!translatedValue.translationText,
+      hasMetadata: !!translatedValue._originalMetadata,
+      hasCues: Array.isArray(translatedValue._srtCues)
+    }), !translatedValue || translatedValue._type !== "translatable.wistia.captions" || !translatedValue._originalMetadata || !Array.isArray(translatedValue._srtCues))
+      return devLog.debug("Value is not a translatable Wistia caption object, returning original", {
+        fieldPath: context.fieldPath,
+        valueType: typeof translatedValue,
+        translatedValue
+      }), originalValue || {};
+    devLog.info("Processing translated Wistia captions", {
+      fieldPath: context.fieldPath,
+      cueCount: translatedValue._srtCues.length
+    });
+    const { translationText, _originalMetadata, _srtCues } = translatedValue;
+    devLog.info("Wistia captions translationText:", {
+      fieldPath: context.fieldPath,
+      translationTextLength: translationText.length,
+      translationTextPreview: translationText.substring(0, 200) + (translationText.length > 200 ? "..." : "")
+    });
+    const reconstructedCaptionContent = deserializeWistiaCaptionText(translationText, _srtCues), documentLanguage = getDocumentLanguage(context.document);
+    let updatedIsoLanguage = _originalMetadata.isoLanguage;
+    if (documentLanguage) {
+      const isoCode = normalizeToIsoLanguageCode(documentLanguage);
+      isoCode ? (updatedIsoLanguage = isoCode, devLog.debug("Updated isoLanguage based on document language", {
+        fieldPath: context.fieldPath,
+        documentLanguage,
+        isoCode
+      })) : devLog.debug("Could not convert document language to ISO code, preserving original", {
+        fieldPath: context.fieldPath,
+        documentLanguage,
+        originalIsoLanguage: _originalMetadata.isoLanguage
+      });
+    } else
+      devLog.debug("Document language field not found, preserving original isoLanguage", {
+        fieldPath: context.fieldPath,
+        originalIsoLanguage: _originalMetadata.isoLanguage
+      });
+    const result = {
+      captionContent: reconstructedCaptionContent,
+      captionFileName: _originalMetadata.captionFileName,
+      isoLanguage: updatedIsoLanguage,
+      captionUploadStatus: _originalMetadata.captionUploadStatus,
+      captionUploadMessage: _originalMetadata.captionUploadMessage
+    };
+    return devLog.info("Wistia captions final result:", {
+      fieldPath: context.fieldPath,
+      hasCaptionContent: !!result.captionContent,
+      captionContentLength: result.captionContent?.length ?? 0,
+      isoLanguage: result.isoLanguage
+    }), result;
+  }
+};
+function parseSRTContent(content) {
+  if (devLog.debug("parseSRTContent - input:", {
+    contentLength: content.length,
+    contentPreview: content.substring(0, 100) + (content.length > 100 ? "..." : "")
+  }), !content || content.trim() === "")
+    return [];
+  let normalizedContent = content;
+  content.includes("\\n") && !content.includes(`
+`) && (normalizedContent = content.replace(/\\n/g, `
+`), devLog.debug("Unescaped newlines in SRT content", {
+    originalLength: content.length,
+    normalizedLength: normalizedContent.length
+  }));
+  const cues = [], cueBlocks = normalizedContent.split(/\n\s*\n/);
+  for (const block of cueBlocks) {
+    const lines = block.trim().split(`
+`);
+    if (lines.length < 3)
+      continue;
+    const cueNumber = Number.parseInt(lines[0].trim(), 10);
+    if (Number.isNaN(cueNumber)) {
+      devLog.warn("Invalid SRT cue number", { line: lines[0] });
+      continue;
+    }
+    const timestampLine = lines[1].trim(), timestampMatch = timestampLine.match(/^(\d{2}:\d{2}:\d{2}[,.]\d{3})\s*-->\s*(\d{2}:\d{2}:\d{2}[,.]\d{3})$/);
+    if (!timestampMatch) {
+      devLog.warn("Invalid SRT timestamp format", { line: timestampLine });
+      continue;
+    }
+    const startTime = timestampMatch[1].replace(".", ","), endTime = timestampMatch[2].replace(".", ","), text = lines.slice(2).join(`
+`).trim();
+    text && cues.push({
+      index: cueNumber,
+      startTime,
+      endTime,
+      text
+    });
+  }
+  return devLog.debug("parseSRTContent - output:", {
+    cueCount: cues.length,
+    firstCue: cues.length > 0 ? cues[0] : null
+  }), cues;
+}
+function serializeWistiaCaptionText(cues) {
+  if (devLog.debug("serializeWistiaCaptionText - input:", {
+    cuesCount: cues.length,
+    firstCue: cues.length > 0 ? cues[0] : null
+  }), !Array.isArray(cues) || cues.length === 0)
+    return "";
+  const result = cues.map((cue) => {
+    devLog.debug(`Processing cue ${cue.index}:`, {
+      text: cue.text,
+      hasText: typeof cue.text == "string"
+    });
+    const escapedText = cue.text.replace(/\n/g, "\\n");
+    return `[${cue.index}] ${escapedText}`;
+  }).join(`
+`);
+  return devLog.debug("serializeWistiaCaptionText - output:", {
+    resultLength: result.length,
+    resultPreview: result.substring(0, 100) + (result.length > 100 ? "..." : "")
+  }), result;
+}
+function deserializeWistiaCaptionText(translationText, srtCuesMetadata) {
+  if (devLog.debug("deserializeWistiaCaptionText - input:", {
+    translationTextLength: translationText.length,
+    translationTextPreview: translationText.substring(0, 100) + (translationText.length > 100 ? "..." : ""),
+    metadataCount: srtCuesMetadata.length,
+    metadataExample: srtCuesMetadata.length > 0 ? srtCuesMetadata[0] : null
+  }), !translationText || translationText.trim() === "")
+    return "";
+  const result = [], lines = translationText.split(`
+`), lineRegex = /^\[(\d+)\]\s*(.*)$/, metadataByIndex = /* @__PURE__ */ new Map();
+  for (const metadata of srtCuesMetadata)
+    metadataByIndex.set(metadata.index, { startTime: metadata.startTime, endTime: metadata.endTime });
+  let currentIndex = null, currentTextParts = [];
+  for (const line of lines) {
+    const match = line.match(lineRegex);
+    if (match) {
+      if (currentIndex !== null) {
+        const text = currentTextParts.join(`
+`).replace(/\\n/g, `
+`), metadata = metadataByIndex.get(currentIndex);
+        metadata ? (result.push(`${currentIndex}`), result.push(`${metadata.startTime} --> ${metadata.endTime}`), result.push(text), result.push("")) : devLog.warn("Missing metadata for caption", { index: currentIndex });
+      }
+      currentIndex = Number.parseInt(match[1], 10), currentTextParts = [match[2]];
+    } else currentIndex !== null ? currentTextParts.push(line) : devLog.warn("Failed to parse caption line", { line });
+  }
+  if (currentIndex !== null) {
+    const text = currentTextParts.join(`
+`).replace(/\\n/g, `
+`), metadata = metadataByIndex.get(currentIndex);
+    metadata ? (result.push(`${currentIndex}`), result.push(`${metadata.startTime} --> ${metadata.endTime}`), result.push(text), result.push("")) : devLog.warn("Missing metadata for caption", { index: currentIndex });
+  }
+  result.length > 0 && result[result.length - 1] === "" && result.pop();
+  const reconstructed = result.join(`
+`);
+  return devLog.debug("deserializeWistiaCaptionText - output:", {
+    resultLength: reconstructed.length,
+    resultPreview: reconstructed.substring(0, 200) + (reconstructed.length > 200 ? "..." : "")
+  }), reconstructed;
+}
+function getDocumentLanguage(document) {
+  if (!document || typeof document != "object")
+    return;
+  const languageFieldNames = ["language", "lang", "locale"];
+  for (const fieldName of languageFieldNames)
+    if (fieldName in document && typeof document[fieldName] == "string")
+      return document[fieldName];
+}
 const aiTranslationPlugin = definePlugin((config) => (config.fieldTransforms?.length && (devLog.info(`Registering ${config.fieldTransforms.length} custom field transforms`), config.fieldTransforms.forEach((transform) => {
   globalTransformRegistry.register(transform);
 })), {
@@ -3508,6 +4362,7 @@ export {
   restoreExcludedFields,
   richTextTransform,
   translationHistorySchema,
-  vttCaptionTransform
+  vttCaptionTransform,
+  wistiaCaptionTransform
 };
 //# sourceMappingURL=index.js.map