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

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 { WarningOutlineIcon, SyncIcon, SearchIcon, CheckmarkIcon, ErrorOutlineIcon, CircleIcon, ArrowRightIcon, ResetIcon, PanelRightIcon, TranslateIcon } from "@sanity/icons";
+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,
@@ -119,6 +122,8 @@ const isLoggingEnabled = () => process.env.NEXT_PUBLIC_SANITY_STUDIO_AI_TRANSLAT
     mode: "new",
     newReleaseTitle: ""
   },
+  reconcilingStatus: "idle",
+  reconciliationProgress: void 0,
   dispatch: () => {
   }
 }), translationReducer = (context, action) => {
@@ -165,8 +170,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,12 +204,29 @@ 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,
           conflicts: void 0,
-          replaceExisting: void 0
-        }
+          replaceExisting: void 0,
+          skipConflicts: void 0
+        },
+        // Reset reconciliation state
+        reconcilingStatus: "idle",
+        reconciliationProgress: void 0
+      };
+    case "SET_RECONCILING_STATUS":
+      return {
+        ...context,
+        reconcilingStatus: action.payload,
+        // Clear progress when returning to idle or on error
+        reconciliationProgress: action.payload === "idle" || action.payload === "error" ? void 0 : context.reconciliationProgress
+      };
+    case "SET_RECONCILIATION_PROGRESS":
+      return {
+        ...context,
+        reconciliationProgress: action.payload
       };
     default:
       return context;
@@ -216,6 +248,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",
@@ -223,7 +256,10 @@ const isLoggingEnabled = () => process.env.NEXT_PUBLIC_SANITY_STUDIO_AI_TRANSLAT
     releaseConfig: {
       mode: "new",
       newReleaseTitle: defaultReleaseTitle
-    }
+    },
+    // Reconciliation state for existing releases
+    reconcilingStatus: "idle",
+    reconciliationProgress: void 0
   };
   activeTranslation && devLog.info("Reconnecting to active translation", {
     documentId: document._id,
@@ -231,7 +267,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 +307,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 +345,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 +466,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 * 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,12 +925,105 @@ 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,
     component: "updateReferences"
   }));
+}, updateBackwardReferences = async ({
+  client,
+  releaseId,
+  sourceDocumentIds,
+  targetLanguages,
+  sourceLanguage,
+  languageFieldName,
+  excludeDocumentIds
+}) => {
+  if (!sourceDocumentIds.length || !targetLanguages.length)
+    return;
+  const normalizedSourceIds = sourceDocumentIds.map((id) => getPublishedId(id));
+  devLog.debug("Starting backward reference update", {
+    releaseId,
+    sourceDocumentCount: normalizedSourceIds.length,
+    targetLanguages,
+    excludeCount: excludeDocumentIds.length,
+    component: "updateBackwardReferences"
+  });
+  try {
+    for (const targetLanguage of targetLanguages) {
+      const existingDocsWithStaleRefs = await client.fetch(
+        `*[
+          _id match "versions." + $releaseId + ".*" &&
+          @[$languageFieldName] == $targetLanguage &&
+          !(_id in $excludeIds)
+        ] {
+          _id,
+          "hasStaleRefs": count(*[
+            _id in $sourceDocumentIds && 
+            ^references(@._id)
+          ]) > 0
+        }[hasStaleRefs == true]`,
+        {
+          releaseId,
+          targetLanguage,
+          languageFieldName,
+          excludeIds: excludeDocumentIds,
+          sourceDocumentIds: normalizedSourceIds
+        }
+      );
+      if (existingDocsWithStaleRefs.length === 0) {
+        devLog.debug("No existing documents with stale references found", {
+          releaseId,
+          targetLanguage,
+          component: "updateBackwardReferences"
+        });
+        continue;
+      }
+      devLog.info("Found existing documents with stale references", {
+        releaseId,
+        targetLanguage,
+        count: existingDocsWithStaleRefs.length,
+        documentIds: existingDocsWithStaleRefs.map((d) => d._id),
+        component: "updateBackwardReferences"
+      }), await Promise.all(
+        existingDocsWithStaleRefs.map(async ({ _id }) => {
+          await localizeReferences({
+            client,
+            documentId: _id,
+            sourceLanguage,
+            languageFieldName
+          });
+        })
+      ), devLog.info("Updated backward references", {
+        releaseId,
+        targetLanguage,
+        updatedCount: existingDocsWithStaleRefs.length,
+        component: "updateBackwardReferences"
+      });
+    }
+  } catch (error) {
+    devLog.error("Error updating backward references", error instanceof Error ? error : new Error(String(error)), {
+      releaseId,
+      sourceDocumentIds: normalizedSourceIds,
+      targetLanguages,
+      component: "updateBackwardReferences"
+    });
+  }
 }, setupTranslationJobStatuses = (dispatch, sourceDocuments, targetLanguages, mainSourceDocumentId) => {
   for (const sourceDocument of sourceDocuments)
     for (const lang of targetLanguages) {
@@ -780,6 +1039,57 @@ const fetchTranslationPrompts = async ({
         payload
       }), mainSourceDocumentId && updateActiveTranslationJob(mainSourceDocumentId, payload);
     }
+}, emitTelemetryEvent = (config, event) => {
+  if (config?.onEvent)
+    try {
+      config.onEvent(event), devLog.debug("Telemetry event emitted", { eventName: event.name });
+    } catch (error) {
+      devLog.warn("Failed to emit telemetry event", {
+        eventName: event.name,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+}, emitTelemetryError = (config, bundle) => {
+  if (config?.onError)
+    try {
+      config.onError(bundle), devLog.debug("Telemetry error emitted", {
+        documentId: bundle.documentId,
+        errorType: bundle.error.type
+      });
+    } catch (error) {
+      devLog.warn("Failed to emit telemetry error", {
+        documentId: bundle.documentId,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+}, buildErrorBundle = (params) => {
+  const durationMs = Date.now() - params.startTime;
+  return {
+    documentId: params.documentId,
+    documentType: params.documentType,
+    targetLanguage: params.targetLanguage,
+    sourceLanguage: params.sourceLanguage,
+    translationMode: params.translationMode,
+    error: {
+      message: params.error.message,
+      stack: params.error.stack,
+      type: params.errorType
+    },
+    debug: {
+      originalDocument: params.originalDocument,
+      serializedDocument: params.serializedDocument,
+      openaiResponse: params.openaiResponse,
+      translationPrompts: params.translationPrompts,
+      validationErrors: params.validationErrors
+    },
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    durationMs
+  };
+}, createTimestamp = () => (/* @__PURE__ */ new Date()).toISOString(), classifyError = (error, context) => {
+  if (context)
+    return context;
+  const message = error.message.toLowerCase();
+  return message.includes("network") || message.includes("fetch") || message.includes("timeout") || message.includes("econnrefused") || message.includes("enotfound") ? "network" : message.includes("openai") || message.includes("gpt") || message.includes("api error") ? "openai_api" : message.includes("validation") || message.includes("structure") || message.includes("invalid") ? "validation" : message.includes("deserialize") || message.includes("parse") ? "deserialization" : message.includes("serialize") || message.includes("xml") ? "serialization" : message.includes("agent") || message.includes("sanity") ? "sanity_agent" : "unknown";
 }, updateTranslationMetadata = async ({
   client,
   targetLanguage,
@@ -813,11 +1123,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 +1438,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 +1533,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 +1594,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 +1678,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 +1751,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 +1761,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 +1787,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,
@@ -1336,25 +1800,27 @@ const globalTransformRegistry = new TransformRegistry(), callGPT5 = async (apiKe
         attributes,
         children: []
       }, closingTag = `</${tagName}>`;
-      if (content.endsWith(closingTag.replace(/[<>]/g, ""))) {
-        const textContent = content.substring(0, content.lastIndexOf("<"));
-        if (node.text = unescapeXml(textContent), stack.length > 0) {
-          const parent = stack[stack.length - 1];
-          parent && parent.children.push(node);
-        } else
-          root.push(node);
-      } else if (content.includes(closingTag))
-        if (node.text = unescapeXml(content.replace(closingTag, "")), stack.length > 0) {
+      if (content.includes(closingTag)) {
+        const closeIdx = content.indexOf(closingTag);
+        node.text = unescapeXml(content.substring(0, closeIdx));
+        const remainder = content.substring(closeIdx + closingTag.length).trim();
+        if (stack.length > 0) {
           const parent = stack[stack.length - 1];
           parent && parent.children.push(node);
         } else
           root.push(node);
-      else if (attributes.type === "translatable.vtt.captions" || attributes.type === "translatable.richtext") {
+        remainder && (lines[i] = remainder, i--);
+      } else if (attributes.type && typeof attributes.type == "string" && attributes.type.startsWith("translatable.")) {
         const contentLines = [];
         for (i++; i < lines.length; ) {
           const currentLine = lines[i];
-          if (currentLine.trim().match(/^<\/field>$/))
+          if (currentLine.includes("</field>")) {
+            const idx = currentLine.indexOf("</field>"), before = currentLine.substring(0, idx).trimEnd();
+            before.trim() && contentLines.push(before);
+            const after = currentLine.substring(idx + 8).trim();
+            after && (lines[i] = after, i--);
             break;
+          }
           contentLines.push(currentLine), i++;
         }
         if (node.text = contentLines.join(`
@@ -1363,18 +1829,36 @@ const globalTransformRegistry = new TransformRegistry(), callGPT5 = async (apiKe
           parent && parent.children.push(node);
         } else
           root.push(node);
-      } else if (attributes.type === "string" && content && content.includes(closingTag))
-        if (node.text = unescapeXml(content.replace(closingTag, "")), stack.length > 0) {
+      } else if (attributes.type === "string" && content && !content.includes(closingTag)) {
+        const contentLines = [content];
+        for (i++; i < lines.length; ) {
+          const currentLine = lines[i];
+          if (currentLine.includes(closingTag)) {
+            const closingIndex = currentLine.indexOf(closingTag), remainingContent = currentLine.substring(0, closingIndex).trimEnd();
+            remainingContent && contentLines.push(remainingContent);
+            const after = currentLine.substring(closingIndex + closingTag.length).trim();
+            after && (lines[i] = after, i--);
+            break;
+          }
+          contentLines.push(currentLine), i++;
+        }
+        if (node.text = unescapeXml(contentLines.join(`
+`)), stack.length > 0) {
           const parent = stack[stack.length - 1];
           parent && parent.children.push(node);
         } else
           root.push(node);
-      else if (attributes.type === "string" && !content) {
+      } else if (attributes.type === "string" && !content) {
         const contentLines = [];
         for (i++; i < lines.length; ) {
           const currentLine = lines[i];
-          if (currentLine.trim() === "</field>")
+          if (currentLine.includes("</field>")) {
+            const idx = currentLine.indexOf("</field>"), before = currentLine.substring(0, idx).trimEnd();
+            before.trim() && contentLines.push(before);
+            const after = currentLine.substring(idx + 8).trim();
+            after && (lines[i] = after, i--);
             break;
+          }
           contentLines.push(currentLine), i++;
         }
         if (node.text = contentLines.join(`
@@ -1387,17 +1871,130 @@ const globalTransformRegistry = new TransformRegistry(), callGPT5 = async (apiKe
         stack.push(node);
       continue;
     }
-    if (trimmed.match(/^<\/(field|block|span)>$/) && stack.length > 0) {
-      const node = stack.pop();
-      if (node)
-        if (stack.length > 0) {
-          const parent = stack[stack.length - 1];
-          parent && parent.children.push(node);
+    if (trimmed.match(/^<\/(field|block|span)>/)) {
+      let afterClosingTag = trimmed;
+      for (; ; ) {
+        const match = afterClosingTag.match(/^<\/(field|block|span)>/);
+        if (!match) break;
+        if (stack.length === 0) {
+          devLog.warn("Closing tag found but stack is empty", {
+            line: i,
+            tagName: match[1],
+            trimmed: afterClosingTag
+          }), afterClosingTag = afterClosingTag.substring(match[0].length).trim(), afterClosingTag = afterClosingTag.replace(/<!--[\s\S]*?-->/g, "").trim();
+          continue;
+        }
+        matchedPatternCount++, devLog.debug("Matched closing tag", {
+          line: i,
+          tagName: match[1],
+          trimmed: afterClosingTag,
+          stackLength: stack.length,
+          stackTopName: stack[stack.length - 1]?.name
+        });
+        const node = stack.pop();
+        if (node)
+          if (stack.length > 0) {
+            const parent = stack[stack.length - 1];
+            parent && parent.children.push(node);
+          } else
+            root.push(node);
+        afterClosingTag = afterClosingTag.substring(match[0].length).trim(), afterClosingTag = afterClosingTag.replace(/<!--[\s\S]*?-->/g, "").trim();
+      }
+      if (afterClosingTag) {
+        const remainingOpenMatch = afterClosingTag.match(/^<(field|block|span)([^>]*)>(.*)$/);
+        if (remainingOpenMatch) {
+          const [, tagName, attrsStr, content] = remainingOpenMatch, attributes = parseAttributes(attrsStr), remainingNode = {
+            type: tagName,
+            name: attributes.name,
+            text: content ? unescapeXml(content) : void 0,
+            attributes,
+            children: []
+          }, remainingClosingTag = `</${tagName}>`;
+          if (content.includes(remainingClosingTag)) {
+            const closeIdx = content.indexOf(remainingClosingTag);
+            remainingNode.text = unescapeXml(content.substring(0, closeIdx));
+            const remainder = content.substring(closeIdx + remainingClosingTag.length).trim();
+            if (stack.length > 0) {
+              const parent = stack[stack.length - 1];
+              parent && parent.children.push(remainingNode);
+            } else
+              root.push(remainingNode);
+            remainder && (lines[i] = remainder, i--);
+          } else if (attributes.type === "string" && content)
+            if (remainingNode.text = unescapeXml(content), stack.length > 0) {
+              const parent = stack[stack.length - 1];
+              parent && parent.children.push(remainingNode);
+            } else
+              root.push(remainingNode);
+          else if (attributes.type === "string" && !content) {
+            const contentLines = [];
+            for (i++; i < lines.length; ) {
+              const currentLine = lines[i];
+              if (currentLine.includes(`</${tagName}>`)) {
+                const idx = currentLine.indexOf(`</${tagName}>`), before = currentLine.substring(0, idx).trimEnd();
+                before.trim() && contentLines.push(before);
+                const after = currentLine.substring(idx + `</${tagName}>`.length).trim();
+                after && (lines[i] = after, i--);
+                break;
+              }
+              contentLines.push(currentLine), i++;
+            }
+            if (remainingNode.text = contentLines.join(`
+`).trim(), stack.length > 0) {
+              const parent = stack[stack.length - 1];
+              parent && parent.children.push(remainingNode);
+            } else
+              root.push(remainingNode);
+          } else
+            stack.push(remainingNode);
         } else
-          root.push(node);
+          lines[i] = afterClosingTag, i--;
+      }
+      continue;
+    }
+    if (trimmed.startsWith("</")) {
+      const attemptedCloseMatch = trimmed.match(/^<\/(field|block|span)>/);
+      attemptedCloseMatch ? stack.length === 0 && devLog.warn("Closing tag matched but stack is empty (unmatched closing tag)", {
+        line: i,
+        tagName: attemptedCloseMatch[1],
+        trimmed
+      }) : devLog.warn("Line starts with </ but did not match closing tag pattern", {
+        line: i,
+        trimmed,
+        stackLength: stack.length,
+        stackTopName: stack[stack.length - 1]?.name,
+        stackTopType: stack[stack.length - 1]?.type
+      });
     }
+    processedLineCount <= 20 && devLog.debug("Line did not match any pattern", {
+      line: i,
+      trimmed,
+      startsWithLessThan: trimmed.startsWith("<"),
+      startsWithField: trimmed.startsWith("<field"),
+      startsWithBacktick: trimmed.startsWith("`"),
+      startsWithClosingTag: trimmed.startsWith("</")
+    });
   }
-  return root;
+  if (stack.length > 0)
+    for (devLog.warn("Nodes remaining in stack after parsing complete", {
+      stackLength: stack.length,
+      remainingNodes: stack.map((n) => ({
+        type: n.type,
+        name: n.name,
+        attributes: n.attributes
+      }))
+    }); stack.length > 0; ) {
+      const node = stack.pop();
+      node && root.push(node);
+    }
+  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 +2002,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") {
@@ -1428,8 +2034,28 @@ const globalTransformRegistry = new TransformRegistry(), callGPT5 = async (apiKe
     return;
   }
   if (node.attributes.type === "object") {
-    for (const child of node.children)
-      child.name && applyFieldChanges(doc, [...path, child.name], child);
+    const currentValue = get(doc, path);
+    if (currentValue && typeof currentValue == "object" && !Array.isArray(currentValue)) {
+      const currentValueObj = currentValue;
+      for (const child of node.children)
+        if (child.name) {
+          const childValue = currentValueObj[child.name];
+          if (/^\d+$/.test(child.name) && childValue === void 0) {
+            devLog.warn("Skipping numeric child name in object field - field does not exist (likely parsing error)", {
+              path: path.join("."),
+              childName: child.name,
+              availableKeys: Object.keys(currentValueObj),
+              childType: child.attributes.type
+            });
+            continue;
+          }
+          applyFieldChanges(doc, [...path, child.name], child);
+        }
+    } else
+      devLog.warn("Object field type but value is not an object", {
+        path: path.join("."),
+        actualType: Array.isArray(currentValue) ? "array" : typeof currentValue
+      });
     return;
   }
   if (node.children.some((c) => c.type === "block")) {
@@ -1439,10 +2065,17 @@ const globalTransformRegistry = new TransformRegistry(), callGPT5 = async (apiKe
     });
     return;
   }
-  node.text !== void 0 && !node.attributes.readonly && (get(doc, path) !== void 0 ? set(doc, path, node.text) : devLog.debug("Skipping field not present in original document", {
-    path: path.join("."),
-    attemptedValue: node.text
-  }));
+  if (node.text !== void 0 && !node.attributes.readonly) {
+    const existingValue = get(doc, path);
+    existingValue !== void 0 && typeof existingValue == "string" ? set(doc, path, node.text) : existingValue !== void 0 ? devLog.debug("Skipping field - existing value is not a string (would corrupt structure)", {
+      path: path.join("."),
+      existingType: typeof existingValue,
+      attemptedValue: node.text?.substring(0, 50)
+    }) : devLog.debug("Skipping field not present in original document", {
+      path: path.join("."),
+      attemptedValue: node.text
+    });
+  }
 }, applyBlockChanges = (block, blockNode) => {
   if (blockNode.attributes._key && block._key !== blockNode.attributes._key) {
     devLog.warn("Block key mismatch, skipping", {
@@ -1473,7 +2106,11 @@ const globalTransformRegistry = new TransformRegistry(), callGPT5 = async (apiKe
     });
     return;
   }
-  fieldNode.text !== void 0 && !fieldNode.attributes.readonly && (fieldName in block ? block[fieldName] = fieldNode.text : devLog.debug("Skipping block field not present in original", {
+  fieldNode.text !== void 0 && !fieldNode.attributes.readonly && (fieldName in block && typeof block[fieldName] == "string" ? block[fieldName] = fieldNode.text : fieldName in block ? devLog.debug("Skipping block field - existing value is not a string (would corrupt structure)", {
+    fieldName,
+    existingType: typeof block[fieldName],
+    attemptedValue: fieldNode.text?.substring(0, 50)
+  }) : devLog.debug("Skipping block field not present in original", {
     fieldName,
     attemptedValue: fieldNode.text
   }));
@@ -1506,12 +2143,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,15 +2281,19 @@ const globalTransformRegistry = new TransformRegistry(), callGPT5 = async (apiKe
   languageFieldName,
   translationPrompts,
   targetLanguage,
-  openaiConfig
+  openaiConfig,
+  previousError: _previousError,
+  errorContext,
+  telemetryConfig
 }) => {
-  const sourceLanguage = sourceDocument[languageFieldName], logContext = {
+  const startTime = Date.now(), sourceLanguage = sourceDocument[languageFieldName], logContext = {
     sourceId: sourceDocument._id,
     sourceLanguage
   };
+  let serializedDocument, openaiResponseContent;
   try {
     const sourceText = serializeDocument(sourceDocument);
-    devLog.info("Serialized document for OpenAI", {
+    serializedDocument = sourceText, devLog.info("Serialized document for OpenAI", {
       ...logContext,
       characterCount: sourceText.length,
       estimatedTokens: Math.ceil(sourceText.length / 4),
@@ -1665,7 +2303,8 @@ const globalTransformRegistry = new TransformRegistry(), callGPT5 = async (apiKe
       sourceText,
       sourceLanguage,
       targetLanguage,
-      translationPrompts
+      translationPrompts,
+      errorContext
     }), response = await callGPT5(openaiConfig.apiKey, {
       messages: [
         {
@@ -1677,7 +2316,7 @@ const globalTransformRegistry = new TransformRegistry(), callGPT5 = async (apiKe
       model: openaiConfig.model,
       reasoningEffort: openaiConfig.reasoningEffort
     });
-    devLog.info("OpenAI translation response received", {
+    openaiResponseContent = response.content, devLog.info("OpenAI translation response received", {
       ...logContext,
       tokensUsed: response.tokensUsed,
       cost: response.cost,
@@ -1715,22 +2354,55 @@ const globalTransformRegistry = new TransformRegistry(), callGPT5 = async (apiKe
     })), setJobStatus(dispatch, sourceDocument._id, targetLanguage, "translating_with_openai", {
       tokensUsed: response.tokensUsed.total,
       estimatedCost: response.cost
-    }), result;
+    }), {
+      document: result,
+      tokensUsed: response.tokensUsed.total,
+      cost: response.cost
+    };
   } catch (error) {
-    throw devLog.error("OpenAI translation failed", error instanceof Error ? error : new Error(String(error)), logContext), error;
+    const err = error instanceof Error ? error : new Error(String(error));
+    throw devLog.error("OpenAI translation failed", err, logContext), emitTelemetryError(
+      telemetryConfig,
+      buildErrorBundle({
+        documentId: sourceDocument._id,
+        documentType: sourceDocument._type,
+        targetLanguage,
+        sourceLanguage,
+        translationMode: "openai-only",
+        error: err,
+        errorType: classifyError(err, "openai_api"),
+        startTime,
+        originalDocument: sourceDocument,
+        serializedDocument,
+        openaiResponse: openaiResponseContent,
+        translationPrompts: {
+          globalPrompt: translationPrompts.globalPrompt,
+          localePrompt: translationPrompts.localeInstructions[targetLanguage]?.prompt,
+          protectedPhrases: translationPrompts.protectedPhrases,
+          glossaryTerms: translationPrompts.localeInstructions[targetLanguage]?.glossaryTerms ? [translationPrompts.localeInstructions[targetLanguage].glossaryTerms] : void 0
+        }
+      })
+    ), error;
   }
 }, buildTranslationPrompt$1 = ({
   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 +2576,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,
@@ -1933,9 +2618,10 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
   releaseId,
   excludeFields = [],
   replaceExisting = !1,
-  mainSourceDocumentId
+  mainSourceDocumentId,
+  telemetryConfig
 }) => {
-  const safeExcludeFields = excludeFields.filter((field) => field !== languageFieldName);
+  const startTime = Date.now(), sourceLanguage = sourceDocument[languageFieldName], safeExcludeFields = excludeFields.filter((field) => field !== languageFieldName);
   excludeFields.length !== safeExcludeFields.length && devLog.warn("Language field was in excludeFields - removing it to prevent translation errors", {
     documentId: sourceDocument._id,
     languageFieldName,
@@ -1974,43 +2660,79 @@ ${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, translationMetrics = {}, previousError = null;
+  const performTranslation = async (errorContext) => {
+    switch (translationMode) {
+      case "sanity-only": {
+        setJobStatus(dispatch, sourceDocument._id, targetLanguage, "translating", void 0, mainSourceDocumentId);
+        try {
+          return { document: await getSanityAgentTranslation({
+            sourceDocument: documentToTranslate,
+            targetLanguage,
+            languageFieldName,
+            schemaId,
+            client,
+            translationPrompts
+          }) };
+        } catch (error) {
+          const err = error instanceof Error ? error : new Error(String(error));
+          throw emitTelemetryError(
+            telemetryConfig,
+            buildErrorBundle({
+              documentId: sourceDocument._id,
+              documentType: sourceDocument._type,
+              targetLanguage,
+              sourceLanguage,
+              translationMode: "sanity-only",
+              error: err,
+              errorType: classifyError(err, "sanity_agent"),
+              startTime,
+              originalDocument: sourceDocument,
+              translationPrompts: {
+                globalPrompt: translationPrompts.globalPrompt,
+                localePrompt: translationPrompts.localeInstructions[targetLanguage]?.prompt,
+                protectedPhrases: translationPrompts.protectedPhrases
+              }
+            })
+          ), error;
+        }
+      }
+      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
+        );
+        const result = await getOpenAITranslation({
+          dispatch,
+          sourceDocument: documentToTranslate,
+          targetLanguage,
+          languageFieldName,
+          translationPrompts,
+          openaiConfig,
+          previousError: errorContext && previousError ? previousError : void 0,
+          errorContext,
+          telemetryConfig
+        });
+        return result ? {
+          document: result.document,
+          tokensUsed: result.tokensUsed,
+          cost: result.cost
+        } : { document: null };
+      }
+      default:
+        throw new Error(`Invalid translation mode: ${translationMode}`);
     }
-    default:
-      throw new Error(`Invalid translation mode: ${translationMode}`);
-  }
-  if (!translatedDoc)
+  }, translationResult = await performTranslation();
+  if (translatedDoc = translationResult.document, translationMetrics = {
+    tokensUsed: translationResult.tokensUsed,
+    cost: translationResult.cost
+  }, !translatedDoc)
     return null;
   let transformedResult;
   Object.keys(originalStructure).length > 0 ? (devLog.debug("Restoring field transforms after translation", {
@@ -2041,15 +2763,88 @@ ${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.`, retryResult = await performTranslation(errorContext);
+      if (translatedDoc = retryResult.document, !translatedDoc)
+        throw new Error("Translation retry failed: no document returned");
+      translationMetrics = {
+        tokensUsed: retryResult.tokensUsed,
+        cost: retryResult.cost
+      };
+      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
+          }
+        }
+      ), {
+        document: retryNewDoc,
+        tokensUsed: translationMetrics.tokensUsed,
+        cost: translationMetrics.cost
+      };
+    }
+    throw error;
+  }
+  return {
+    document: newDoc,
+    tokensUsed: translationMetrics.tokensUsed,
+    cost: translationMetrics.cost
+  };
 }, translateDocument = async ({
   dispatch,
   client,
@@ -2064,9 +2859,10 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
   releaseId,
   excludeFields,
   replaceExisting,
-  mainSourceDocumentId
+  mainSourceDocumentId,
+  telemetryConfig
 }) => {
-  const logContext = {
+  const jobStartTime = Date.now(), logContext = {
     documentId: sourceDocument._id,
     targetLanguage,
     schemaId,
@@ -2078,7 +2874,7 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
       client,
       sourceDocument,
       sourceLanguage
-    }), existingTranslationId = getExistingTranslationId(translationMetadata, targetLanguage), newDocument = await handleTranslation({
+    }), existingTranslationId = getExistingTranslationId(translationMetadata, targetLanguage), translationResult = await handleTranslation({
       dispatch,
       client,
       schemaId,
@@ -2092,8 +2888,9 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
       releaseId,
       excludeFields,
       replaceExisting,
-      mainSourceDocumentId
-    });
+      mainSourceDocumentId,
+      telemetryConfig
+    }), newDocument = translationResult?.document;
     if (!newDocument) {
       devLog.error("Translation failed: no document returned", new Error("Translation returned null"), logContext), setJobStatus(
         dispatch,
@@ -2130,12 +2927,27 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
       targetLanguage,
       "completed",
       {
-        targetId: newDocument._id
+        targetId: newDocument._id,
+        tokensUsed: translationResult?.tokensUsed,
+        estimatedCost: translationResult?.cost
       },
       mainSourceDocumentId
     ), devLog.info("Translation completed successfully", {
       ...logContext,
       newDocumentId: newDocument._id
+    }), emitTelemetryEvent(telemetryConfig, {
+      name: "translation.job_completed",
+      timestamp: createTimestamp(),
+      data: {
+        documentId: sourceDocument._id,
+        documentType: sourceDocument._type,
+        sourceLanguage,
+        targetLanguage,
+        translationMode,
+        durationMs: Date.now() - jobStartTime,
+        tokensUsed: translationResult?.tokensUsed,
+        estimatedCost: translationResult?.cost
+      }
     }), devLog.timeEnd("translateDocument"), devLog.groupEnd(), newDocument._id;
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
@@ -2163,9 +2975,10 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
   translationMode,
   openaiConfig,
   excludeFields,
-  releaseConfig
+  releaseConfig,
+  telemetryConfig
 }) => {
-  const logContext = {
+  const batchStartTime = Date.now(), logContext = {
     documentId: sourceDocument._id,
     documentRev: sourceDocument._rev,
     targetLanguages,
@@ -2179,7 +2992,19 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
     const sourceLanguage = sourceDocument[languageFieldName];
     if (!sourceLanguage)
       throw devLog.error("Source language not found"), new Error("Source language not found");
-    if (maxConcurrentTranslationJobs && translationSemaphore.updatePermits(maxConcurrentTranslationJobs), dispatch({
+    if (emitTelemetryEvent(telemetryConfig, {
+      name: "translation.batch_started",
+      timestamp: createTimestamp(),
+      data: {
+        documentId: sourceDocument._id,
+        documentType: sourceDocument._type,
+        sourceLanguage,
+        targetLanguages,
+        translationMode,
+        referenceCount: references.length,
+        releaseMode: releaseConfig.mode
+      }
+    }), maxConcurrentTranslationJobs && translationSemaphore.updatePermits(maxConcurrentTranslationJobs), dispatch({
       type: "SET_OVERALL_STATUS",
       payload: "translating"
     }), releaseConfig.mode === "existing" && releaseConfig.existingReleaseId)
@@ -2189,13 +3014,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
@@ -2217,8 +3054,28 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
       sourceDocument
     });
     setupTranslationJobStatuses(dispatch, sourceDocuments, targetLanguages, sourceDocument._id);
-    const translationTasks = sourceDocumentIds.flatMap(
+    const shouldSkipConflict = (documentId, targetLanguage) => !releaseConfig.skipConflicts || releaseConfig.skipConflicts.length === 0 ? !1 : releaseConfig.skipConflicts.some(
+      (conflict) => conflict.sourceDocumentId === documentId && conflict.targetLanguage === targetLanguage
+    ), skippedCount = sourceDocumentIds.reduce((count, documentId) => count + targetLanguages.filter((lang) => shouldSkipConflict(documentId, lang)).length, 0), translationTasks = sourceDocumentIds.flatMap(
       (documentId) => targetLanguages.map(async (targetLanguage) => {
+        if (shouldSkipConflict(documentId, targetLanguage)) {
+          const docInfo = sourceDocuments.find((d) => d._id === documentId);
+          devLog.info("Skipping conflicting translation", {
+            documentId,
+            targetLanguage,
+            reason: "User chose to skip conflicts"
+          }), dispatch({
+            type: "SET_TRANSLATION_JOB_STATUS",
+            payload: {
+              _id: documentId,
+              _type: docInfo?._type,
+              language: targetLanguage,
+              status: "skipped",
+              title: docInfo?.title
+            }
+          });
+          return;
+        }
         try {
           await translationSemaphore.withPermit(async () => {
             const document = await client.withConfig({
@@ -2240,7 +3097,8 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
                 excludeFields,
                 replaceExisting: releaseConfig.replaceExisting,
                 // Pass main source document ID for active translations tracking
-                mainSourceDocumentId: sourceDocument._id
+                mainSourceDocumentId: sourceDocument._id,
+                telemetryConfig
               });
               versionedTargetDocumentId && versionedTargetDocumentIds.push(versionedTargetDocumentId);
             }
@@ -2257,13 +3115,28 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
           );
         }
       })
-    ), results = await Promise.allSettled(translationTasks), succeeded = results.filter((r) => r.status === "fulfilled").length, failed = results.filter((r) => r.status === "rejected").length;
+    ), results = await Promise.allSettled(translationTasks), succeeded = results.filter((r) => r.status === "fulfilled").length - skippedCount, failed = results.filter((r) => r.status === "rejected").length;
     devLog.info("Translation tasks completed", {
       ...logContext,
       total: results.length,
       succeeded,
       failed,
+      skipped: skippedCount,
       targetDocuments: versionedTargetDocumentIds.length
+    }), emitTelemetryEvent(telemetryConfig, {
+      name: "translation.batch_completed",
+      timestamp: createTimestamp(),
+      data: {
+        documentId: sourceDocument._id,
+        documentType: sourceDocument._type,
+        sourceLanguage,
+        targetLanguages,
+        translationMode,
+        succeeded,
+        failed,
+        skipped: skippedCount,
+        durationMs: Date.now() - batchStartTime
+      }
     }), dispatch({
       type: "SET_OVERALL_STATUS",
       payload: "linking_references"
@@ -2276,7 +3149,15 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
           languageFieldName
         });
       })
-    );
+    ), releaseConfig.mode === "existing" && releaseId && await updateBackwardReferences({
+      client,
+      releaseId,
+      sourceDocumentIds,
+      targetLanguages,
+      sourceLanguage,
+      languageFieldName,
+      excludeDocumentIds: versionedTargetDocumentIds
+    });
     const hasAnyFailures = failed > 0;
     hasAnyFailures && succeeded === 0 ? (devLog.error("All translation tasks failed", void 0, logContext), dispatch({ type: "SET_OVERALL_STATUS", payload: "error" }), updateActiveTranslationStatus(sourceDocument._id, "error"), cleanupActiveTranslation(sourceDocument._id)) : hasAnyFailures ? (devLog.warn("Translation completed with some failures", {
       ...logContext,
@@ -2303,8 +3184,14 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
       }
     throw devLog.timeEnd("translateDocumentSet"), devLog.groupEnd(), dispatch({ type: "SET_OVERALL_STATUS", payload: "error" }), updateActiveTranslationStatus(sourceDocument._id, "error"), cleanupActiveTranslation(sourceDocument._id), error;
   }
-}, ReleaseConflictWarning = ({ conflicts, onCancel, onReplace }) => {
-  const uniqueDocuments = useMemo(() => new Set(conflicts.map((c) => c.sourceDocumentId)).size, [conflicts]), summaryText = useMemo(() => conflicts.length === 1 ? "1 translation" : uniqueDocuments === 1 ? `${conflicts.length} translations` : `${conflicts.length} translations across ${uniqueDocuments} documents`, [conflicts.length, uniqueDocuments]);
+}, ReleaseConflictWarning = ({
+  conflicts,
+  totalTranslations,
+  onCancel,
+  onReplace,
+  onSkipConflicts
+}) => {
+  const uniqueDocuments = useMemo(() => new Set(conflicts.map((c) => c.sourceDocumentId)).size, [conflicts]), nonConflictingCount = totalTranslations - conflicts.length, hasNonConflicting = nonConflictingCount > 0, summaryText = useMemo(() => conflicts.length === 1 ? "1 translation" : uniqueDocuments === 1 ? `${conflicts.length} translations` : `${conflicts.length} translations across ${uniqueDocuments} documents`, [conflicts.length, uniqueDocuments]);
   return /* @__PURE__ */ jsx(Card, { tone: "caution", padding: 4, border: !0, radius: 2, children: /* @__PURE__ */ jsxs(Stack, { space: 4, children: [
     /* @__PURE__ */ jsxs(Flex, { align: "center", gap: 2, children: [
       /* @__PURE__ */ jsx(Text, { size: 2, children: /* @__PURE__ */ jsx(WarningOutlineIcon, {}) }),
@@ -2328,13 +3215,34 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
         " \u2014 Go back and select a different release, or create a new one."
       ] }),
       /* @__PURE__ */ jsxs(Text, { size: 1, children: [
-        /* @__PURE__ */ jsx("strong", { children: "Replace" }),
+        /* @__PURE__ */ jsx("strong", { children: "Replace All" }),
         " \u2014 Delete the existing translations in this release and create new ones."
+      ] }),
+      /* @__PURE__ */ jsxs(Text, { size: 1, children: [
+        /* @__PURE__ */ jsx("strong", { children: "Skip Conflicts" }),
+        " \u2014 Translate only the ",
+        nonConflictingCount,
+        " non-conflicting translation",
+        nonConflictingCount !== 1 ? "s" : "",
+        ", leaving existing ones unchanged.",
+        !hasNonConflicting && " (All translations have conflicts)"
       ] })
     ] }),
-    /* @__PURE__ */ jsxs(Flex, { gap: 2, justify: "flex-end", children: [
+    /* @__PURE__ */ jsxs(Flex, { gap: 2, justify: "space-between", children: [
       /* @__PURE__ */ jsx(Button, { mode: "ghost", text: "Cancel", onClick: onCancel }),
-      /* @__PURE__ */ jsx(Button, { mode: "ghost", tone: "caution", text: "Replace Existing", onClick: onReplace })
+      /* @__PURE__ */ jsxs(Flex, { gap: 2, justify: "flex-end", children: [
+        /* @__PURE__ */ jsx(Button, { mode: "bleed", tone: "caution", text: "Replace All", onClick: onReplace }),
+        /* @__PURE__ */ jsx(
+          Button,
+          {
+            mode: "ghost",
+            tone: "caution",
+            text: "Skip Conflicts",
+            onClick: onSkipConflicts,
+            disabled: !hasNonConflicting
+          }
+        )
+      ] })
     ] })
   ] }) });
 }, ActionButtonBar = ({ setIsDialogOpen }) => {
@@ -2344,15 +3252,16 @@ ${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)), totalTranslations = useMemo(() => (1 + filteredReferences.length) * selectedTargetLanguages.length, [filteredReferences.length, selectedTargetLanguages.length]);
   useEffect(() => {
     releaseConfig.mode === "new" && conflictContext && setConflictContext(null);
   }, [releaseConfig.mode, conflictContext]);
   const startTranslation = useCallback(
-    (replaceExisting, overrideReleaseId) => {
+    (replaceExisting, overrideReleaseId, skipConflicts) => {
       setConflictContext(null), translateDocumentSet({
         sourceDocument: document,
         targetLanguages: selectedTargetLanguages,
@@ -2360,7 +3269,7 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
         dispatch,
         languageFieldName: config.languageFieldName,
         schemaId: config.schemaId,
-        references,
+        references: filteredReferences,
         maxConcurrentTranslationJobs: config.maxConcurrentTranslationJobs,
         maxReferenceDepth: config.maxReferenceDepth,
         translationMode,
@@ -2369,6 +3278,7 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
         releaseConfig: {
           ...releaseConfig,
           replaceExisting,
+          skipConflicts,
           // Use the override release ID if provided (from conflict context),
           // otherwise use the current releaseConfig value
           existingReleaseId: overrideReleaseId ?? releaseConfig.existingReleaseId
@@ -2386,7 +3296,7 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
       config.maxReferenceDepth,
       config.openai,
       config.excludeFields,
-      references,
+      filteredReferences,
       translationMode,
       releaseConfig
     ]
@@ -2404,7 +3314,7 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
         sourceDocument: document,
         targetLanguages: selectedTargetLanguages,
         languageFieldName: config.languageFieldName,
-        references
+        references: filteredReferences
       });
       if (setIsCheckingConflicts(!1), foundConflicts.length > 0) {
         setConflictContext({
@@ -2415,10 +3325,20 @@ ${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);
+  }, [startTranslation, conflictContext]), handleSkipConflicts = useCallback(() => {
+    conflictContext && startTranslation(!1, conflictContext.releaseId, conflictContext.conflicts);
   }, [startTranslation, conflictContext]), handleSelectAll = useCallback(() => {
     dispatch({
       type: "SET_SELECTED_TARGET_LANGUAGES",
@@ -2434,8 +3354,10 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
     ReleaseConflictWarning,
     {
       conflicts: conflictContext.conflicts,
+      totalTranslations,
       onCancel: handleCancelConflict,
-      onReplace: handleReplaceConflict
+      onReplace: handleReplaceConflict,
+      onSkipConflicts: handleSkipConflicts
     }
   ) }) : /* @__PURE__ */ jsxs(Flex, { justify: "space-between", gap: 2, children: [
     /* @__PURE__ */ jsxs(Flex, { justify: "flex-start", gap: 2, children: [
@@ -2517,8 +3439,183 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
     documentId: document._id
   });
   return /* @__PURE__ */ jsx(Card, { padding: 4, muted: !0, border: !0, children: /* @__PURE__ */ jsx(Grid, { columns: [1, 2], gap: 3, children: config?.supportedLanguages.map((lang) => /* @__PURE__ */ jsx(LanguageCheckbox, { lang, isLoading: loading }, lang.id)) }) });
+}, reconcileReleaseReferences = async ({
+  client,
+  releaseId,
+  sourceLanguage,
+  languageFieldName,
+  onProgress
+}) => {
+  devLog.info("Starting release reference reconciliation", {
+    releaseId,
+    sourceLanguage,
+    component: "reconcileReleaseReferences"
+  });
+  try {
+    const docsInRelease = await client.fetch(
+      `*[_id match "versions." + $releaseId + ".*"] {
+        _id,
+        "language": @[$languageFieldName]
+      }`,
+      { releaseId, languageFieldName }
+    );
+    if (docsInRelease.length === 0)
+      return devLog.info("No documents found in release", {
+        releaseId,
+        component: "reconcileReleaseReferences"
+      }), { total: 0, updated: 0, errors: 0 };
+    devLog.info("Found documents in release", {
+      releaseId,
+      count: docsInRelease.length,
+      component: "reconcileReleaseReferences"
+    });
+    let updated = 0, errors = 0;
+    for (let i = 0; i < docsInRelease.length; i++) {
+      const doc = docsInRelease[i];
+      onProgress && onProgress(i + 1, docsInRelease.length);
+      try {
+        if (!doc.language) {
+          devLog.warn("Document missing language field, skipping", {
+            documentId: doc._id,
+            component: "reconcileReleaseReferences"
+          });
+          continue;
+        }
+        await localizeReferences({
+          client,
+          documentId: doc._id,
+          sourceLanguage,
+          languageFieldName
+        }), updated++;
+      } catch (error) {
+        errors++, devLog.error(
+          "Failed to reconcile references for document",
+          error instanceof Error ? error : new Error(String(error)),
+          {
+            documentId: doc._id,
+            component: "reconcileReleaseReferences"
+          }
+        );
+      }
+    }
+    const result = {
+      total: docsInRelease.length,
+      updated,
+      errors
+    };
+    return devLog.info("Release reference reconciliation complete", {
+      releaseId,
+      ...result,
+      component: "reconcileReleaseReferences"
+    }), result;
+  } catch (error) {
+    throw devLog.error("Failed to reconcile release references", error instanceof Error ? error : new Error(String(error)), {
+      releaseId,
+      component: "reconcileReleaseReferences"
+    }), error;
+  }
+}, ReconcileReferencesButton = ({ sourceLanguage }) => {
+  const { releaseConfig, overallStatus, config } = useTranslationContext(), client = useClient({ apiVersion: "vX" }), [documentCount, setDocumentCount] = useState(null), [isLoadingCount, setIsLoadingCount] = useState(!1), [reconcilingStatus, setReconcilingStatus] = useState("idle"), [reconciliationProgress, setReconciliationProgress] = useState(
+    void 0
+  ), releaseId = releaseConfig.existingReleaseId, languageFieldName = config?.languageFieldName ?? "language";
+  useEffect(() => {
+    if (!releaseId || releaseConfig.mode !== "existing") {
+      setDocumentCount(null);
+      return;
+    }
+    (async () => {
+      setIsLoadingCount(!0);
+      try {
+        const count = await client.fetch('count(*[_id match "versions." + $releaseId + ".*"])', { releaseId });
+        setDocumentCount(count), devLog.debug("Fetched release document count", {
+          releaseId,
+          count,
+          component: "ReconcileReferencesButton"
+        });
+      } catch (error) {
+        devLog.error(
+          "Failed to fetch release document count",
+          error instanceof Error ? error : new Error(String(error)),
+          {
+            releaseId,
+            component: "ReconcileReferencesButton"
+          }
+        ), setDocumentCount(null);
+      } finally {
+        setIsLoadingCount(!1);
+      }
+    })();
+  }, [releaseId, releaseConfig.mode, client]);
+  const handleReconcile = useCallback(async () => {
+    if (releaseId) {
+      devLog.info("Starting reference reconciliation", {
+        releaseId,
+        sourceLanguage,
+        component: "ReconcileReferencesButton"
+      }), setReconcilingStatus("reconciling");
+      try {
+        const result = await reconcileReleaseReferences({
+          client,
+          releaseId,
+          sourceLanguage,
+          languageFieldName,
+          onProgress: (current, total) => {
+            setReconciliationProgress({ current, total });
+          }
+        });
+        devLog.info("Reference reconciliation completed", {
+          releaseId,
+          ...result,
+          component: "ReconcileReferencesButton"
+        }), setReconcilingStatus("completed"), setTimeout(() => {
+          setReconcilingStatus("idle"), setReconciliationProgress(void 0);
+        }, 2e3);
+      } catch (error) {
+        devLog.error("Reference reconciliation failed", error instanceof Error ? error : new Error(String(error)), {
+          releaseId,
+          component: "ReconcileReferencesButton"
+        }), setReconcilingStatus("error"), setReconciliationProgress(void 0);
+      }
+    }
+  }, [releaseId, sourceLanguage, languageFieldName, client]);
+  if (releaseConfig.mode !== "existing" || !releaseId)
+    return null;
+  const isTranslating = overallStatus === "translating" || overallStatus === "linking_references", isReconciling = reconcilingStatus === "reconciling";
+  return /* @__PURE__ */ jsx(Card, { padding: 3, border: !0, radius: 2, tone: reconcilingStatus === "error" ? "critical" : "default", children: /* @__PURE__ */ jsxs(Stack, { space: 3, children: [
+    /* @__PURE__ */ jsxs(Flex, { align: "center", justify: "space-between", gap: 3, children: [
+      /* @__PURE__ */ jsxs(Stack, { space: 2, children: [
+        /* @__PURE__ */ jsx(Text, { size: 1, weight: "medium", children: "Reconcile References" }),
+        /* @__PURE__ */ jsx(Text, { size: 1, muted: !0, children: isLoadingCount ? "Loading..." : documentCount === null ? "Unable to load document count" : documentCount === 0 ? "No documents in release" : /* @__PURE__ */ jsxs(Fragment, { children: [
+          documentCount,
+          " document",
+          documentCount !== 1 ? "s" : "",
+          " in release"
+        ] }) })
+      ] }),
+      /* @__PURE__ */ jsx(
+        Button,
+        {
+          icon: isReconciling ? Spinner : SyncIcon,
+          text: reconcilingStatus === "completed" ? "Done!" : reconcilingStatus === "error" ? "Retry" : isReconciling ? "Reconciling..." : "Reconcile",
+          tone: reconcilingStatus === "completed" ? "positive" : reconcilingStatus === "error" ? "critical" : "default",
+          mode: "ghost",
+          onClick: handleReconcile,
+          disabled: (isTranslating || isReconciling || isLoadingCount || documentCount === 0) && reconcilingStatus !== "error"
+        }
+      )
+    ] }),
+    isReconciling && reconciliationProgress && /* @__PURE__ */ jsx(Flex, { align: "center", gap: 2, children: /* @__PURE__ */ jsxs(Text, { size: 1, muted: !0, children: [
+      "Processing ",
+      reconciliationProgress.current,
+      " of ",
+      reconciliationProgress.total,
+      "..."
+    ] }) }),
+    reconcilingStatus === "error" && /* @__PURE__ */ jsx(Text, { size: 1, muted: !0, children: "Reconciliation failed. Click Retry to try again." }),
+    reconcilingStatus === "idle" && documentCount !== null && documentCount > 0 && /* @__PURE__ */ jsx(Text, { size: 1, muted: !0, children: "Updates all document references to point to their translated versions in this release." })
+  ] }) });
 }, ReleaseSelectionPanel = () => {
-  const { dispatch, releaseConfig } = useTranslationContext(), client = useClient({ apiVersion: "vX" }), [releases, setReleases] = useState([]), [isLoading, setIsLoading] = useState(!1), [error, setError] = useState(null), [searchQuery, setSearchQuery] = useState("");
+  const { dispatch, releaseConfig, document, config } = useTranslationContext(), client = useClient({ apiVersion: "vX" }), languageFieldName = config?.languageFieldName ?? "language", sourceLanguage = document?.[languageFieldName], [releases, setReleases] = useState([]), [isLoading, setIsLoading] = useState(!1), [error, setError] = useState(null), [searchQuery, setSearchQuery] = useState(""), [showReconcileUI, setShowReconcileUI] = useState(!1);
   useEffect(() => {
     (async () => {
       setIsLoading(!0), setError(null);
@@ -2631,12 +3728,33 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
               radius: 2,
               tone: isSelected ? "primary" : "default",
               style: { cursor: "pointer" },
-              onClick: () => handleSelectRelease(releaseName),
+              onClick: () => {
+                handleSelectRelease(releaseName), isSelected || setShowReconcileUI(!1);
+              },
               border: !0,
               muted: isSelected,
               children: /* @__PURE__ */ jsxs(Flex, { direction: "column", gap: 3, children: [
-                /* @__PURE__ */ jsx(Text, { size: 1, children: release.metadata.title }),
-                /* @__PURE__ */ jsx(Text, { size: 1, muted: !0, children: formatDate(release._createdAt) })
+                /* @__PURE__ */ jsxs(Flex, { justify: "space-between", align: "center", children: [
+                  /* @__PURE__ */ jsxs(Flex, { direction: "column", gap: 2, children: [
+                    /* @__PURE__ */ jsx(Text, { size: 1, children: release.metadata.title }),
+                    /* @__PURE__ */ jsx(Text, { size: 1, muted: !0, children: formatDate(release._createdAt) })
+                  ] }),
+                  isSelected && sourceLanguage && /* @__PURE__ */ jsx(
+                    Button,
+                    {
+                      icon: SyncIcon,
+                      text: showReconcileUI ? "Hide" : "Reconcile References",
+                      mode: "bleed",
+                      tone: "primary",
+                      fontSize: 0,
+                      padding: 2,
+                      onClick: (e) => {
+                        e.stopPropagation(), setShowReconcileUI(!showReconcileUI);
+                      }
+                    }
+                  )
+                ] }),
+                isSelected && sourceLanguage && showReconcileUI && /* @__PURE__ */ jsx(ReconcileReferencesButton, { sourceLanguage })
               ] })
             },
             release._id
@@ -2789,8 +3907,90 @@ ${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 +4060,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 +4653,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 +4677,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 +4727,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 +5033,7 @@ export {
   restoreExcludedFields,
   richTextTransform,
   translationHistorySchema,
-  vttCaptionTransform
+  vttCaptionTransform,
+  wistiaCaptionTransform
 };
 //# sourceMappingURL=index.js.map