@mux/ai 0.9.0 → 0.11.0

package/dist/workflows/index.js

@@ -987,24 +987,82 @@ function findCaptionTrack(asset, languageCode) {
     (track) => track.text_type === "subtitles" && track.language_code === languageCode
   );
 }
+function normalizeLineEndings(value) {
+  return value.replace(/\r\n/g, "\n");
+}
+function isTimingLine(line) {
+  return line.includes("-->");
+}
+function parseNumericCueIdentifier(line) {
+  if (!/^\d+$/.test(line)) {
+    return null;
+  }
+  return Number.parseInt(line, 10);
+}
+function isLikelyTitledCueIdentifier(line) {
+  return /^\d+\s+-\s+\S.*$/.test(line);
+}
+function isLikelyCueIdentifier({
+  line,
+  nextLine,
+  previousCueIdentifier
+}) {
+  if (!line || !nextLine || !isTimingLine(nextLine)) {
+    return false;
+  }
+  const numericIdentifier = parseNumericCueIdentifier(line);
+  if (numericIdentifier !== null) {
+    if (previousCueIdentifier === null || previousCueIdentifier === void 0) {
+      return numericIdentifier === 1;
+    }
+    return numericIdentifier === previousCueIdentifier + 1;
+  }
+  return isLikelyTitledCueIdentifier(line);
+}
+function getCueIdentifierLineIndex(lines, timingLineIndex, previousCueIdentifier) {
+  const identifierIndex = timingLineIndex - 1;
+  if (identifierIndex < 0) {
+    return -1;
+  }
+  const candidate = lines[identifierIndex].trim();
+  if (!candidate || isTimingLine(candidate)) {
+    return -1;
+  }
+  return isLikelyCueIdentifier({
+    line: candidate,
+    nextLine: lines[timingLineIndex]?.trim(),
+    previousCueIdentifier
+  }) ? identifierIndex : -1;
+}
 function extractTextFromVTT(vttContent) {
   if (!vttContent.trim()) {
     return "";
   }
   const lines = vttContent.split("\n");
   const textLines = [];
+  let previousCueIdentifier = null;
+  let isInsideNoteBlock = false;
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i].trim();
-    if (!line)
+    const nextLine = lines[i + 1]?.trim();
+    if (!line) {
+      isInsideNoteBlock = false;
+      continue;
+    }
+    if (isInsideNoteBlock)
       continue;
     if (line === "WEBVTT")
       continue;
-    if (line.startsWith("NOTE "))
+    if (line === "NOTE" || line.startsWith("NOTE ")) {
+      isInsideNoteBlock = true;
       continue;
-    if (line.includes("-->"))
+    }
+    if (isTimingLine(line))
       continue;
-    if (/^[\w-]+$/.test(line) && !line.includes(" "))
+    if (isLikelyCueIdentifier({ line, nextLine, previousCueIdentifier })) {
+      previousCueIdentifier = parseNumericCueIdentifier(line);
       continue;
+    }
     if (line.startsWith("STYLE") || line.startsWith("REGION"))
       continue;
     const cleanLine = line.replace(/<[^>]*>/g, "").trim();
@@ -1053,20 +1111,34 @@ function parseVTTCues(vttContent) {
     return [];
   const lines = vttContent.split("\n");
   const cues = [];
+  let previousCueIdentifier = null;
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i].trim();
-    if (line.includes("-->")) {
+    if (isTimingLine(line)) {
       const [startStr, endStr] = line.split(" --> ").map((s) => s.trim());
       const startTime = vttTimestampToSeconds(startStr);
       const endTime = vttTimestampToSeconds(endStr.split(" ")[0]);
-      const textLines = [];
+      const currentCueIdentifierLine = lines[i - 1]?.trim() ?? "";
+      const currentCueIdentifier = isLikelyCueIdentifier({
+        line: currentCueIdentifierLine,
+        nextLine: line,
+        previousCueIdentifier
+      }) ? parseNumericCueIdentifier(currentCueIdentifierLine) : null;
+      const rawTextLines = [];
       let j = i + 1;
-      while (j < lines.length && lines[j].trim() && !lines[j].includes("-->")) {
-        const cleanLine = lines[j].trim().replace(/<[^>]*>/g, "");
-        if (cleanLine)
-          textLines.push(cleanLine);
+      while (j < lines.length && lines[j].trim() && !isTimingLine(lines[j].trim())) {
+        rawTextLines.push(lines[j].trim());
         j++;
       }
+      const trailingNumericLine = parseNumericCueIdentifier(rawTextLines.at(-1) ?? "");
+      if (trailingNumericLine !== null && isLikelyCueIdentifier({
+        line: rawTextLines.at(-1) ?? "",
+        nextLine: lines[j]?.trim(),
+        previousCueIdentifier: currentCueIdentifier
+      }) && rawTextLines.length > 1) {
+        rawTextLines.pop();
+      }
+      const textLines = rawTextLines.map((textLine) => textLine.replace(/<[^>]*>/g, "")).filter(Boolean);
       if (textLines.length > 0) {
         cues.push({
           startTime,
@@ -1074,10 +1146,102 @@ function parseVTTCues(vttContent) {
           text: textLines.join(" ")
         });
       }
+      previousCueIdentifier = currentCueIdentifier;
     }
   }
   return cues;
 }
+function splitVttPreambleAndCueBlocks(vttContent) {
+  const normalizedContent = normalizeLineEndings(vttContent).trim();
+  if (!normalizedContent) {
+    return {
+      preamble: "WEBVTT",
+      cueBlocks: []
+    };
+  }
+  const rawBlocks = normalizedContent.split(/\n{2,}/).map((block) => block.trim()).filter(Boolean);
+  const cueBlockStartIndex = rawBlocks.findIndex((block) => block.includes("-->"));
+  if (cueBlockStartIndex === -1) {
+    return {
+      preamble: normalizedContent.startsWith("WEBVTT") ? normalizedContent : `WEBVTT
+
+${normalizedContent}`,
+      cueBlocks: []
+    };
+  }
+  const hasMergedCueBlocks = rawBlocks.slice(cueBlockStartIndex).some((block) => (block.match(/-->/g) ?? []).length > 1);
+  if (hasMergedCueBlocks) {
+    const lines = normalizedContent.split("\n");
+    const timingLineIndices = lines.map((line, index) => isTimingLine(line.trim()) ? index : -1).filter((index) => index >= 0);
+    let previousCueIdentifier = null;
+    const firstCueStartIndex = getCueIdentifierLineIndex(lines, timingLineIndices[0], previousCueIdentifier);
+    const preambleEndIndex = firstCueStartIndex >= 0 ? firstCueStartIndex : timingLineIndices[0];
+    const preamble2 = lines.slice(0, preambleEndIndex).join("\n").trim() || "WEBVTT";
+    const cueBlocks2 = timingLineIndices.map((timingLineIndex, index) => {
+      const cueIdentifierLineIndex = getCueIdentifierLineIndex(lines, timingLineIndex, previousCueIdentifier);
+      const cueStartIndex = cueIdentifierLineIndex >= 0 ? cueIdentifierLineIndex : timingLineIndex;
+      const currentCueIdentifier = cueIdentifierLineIndex >= 0 ? parseNumericCueIdentifier(lines[cueIdentifierLineIndex].trim()) : null;
+      const nextTimingLineIndex = timingLineIndices[index + 1] ?? lines.length;
+      let cueEndIndex = nextTimingLineIndex - 1;
+      while (cueEndIndex > timingLineIndex && !lines[cueEndIndex].trim()) {
+        cueEndIndex--;
+      }
+      const nextCueIdentifierLineIndex = index < timingLineIndices.length - 1 ? getCueIdentifierLineIndex(lines, nextTimingLineIndex, currentCueIdentifier) : -1;
+      if (nextCueIdentifierLineIndex === cueEndIndex) {
+        cueEndIndex--;
+      }
+      while (cueEndIndex > timingLineIndex && !lines[cueEndIndex].trim()) {
+        cueEndIndex--;
+      }
+      previousCueIdentifier = currentCueIdentifier;
+      return lines.slice(cueStartIndex, cueEndIndex + 1).join("\n").trim();
+    });
+    return {
+      preamble: preamble2,
+      cueBlocks: cueBlocks2
+    };
+  }
+  const preambleBlocks = rawBlocks.slice(0, cueBlockStartIndex);
+  const cueBlocks = rawBlocks.slice(cueBlockStartIndex);
+  const preamble = preambleBlocks.length > 0 ? preambleBlocks.join("\n\n") : "WEBVTT";
+  return {
+    preamble,
+    cueBlocks
+  };
+}
+function buildVttFromCueBlocks(cueBlocks, preamble = "WEBVTT") {
+  if (cueBlocks.length === 0) {
+    return `${preamble.trim()}
+`;
+  }
+  return `${preamble.trim()}
+
+${cueBlocks.map((block) => block.trim()).join("\n\n")}
+`;
+}
+function replaceCueText(cueBlock, translatedText) {
+  const lines = normalizeLineEndings(cueBlock).split("\n").map((line) => line.trim()).filter(Boolean);
+  const timingLineIndex = lines.findIndex((line) => line.includes("-->"));
+  if (timingLineIndex === -1) {
+    throw new Error("Cue block is missing a timestamp line");
+  }
+  const headerLines = lines.slice(0, timingLineIndex + 1);
+  const translatedLines = normalizeLineEndings(translatedText).split("\n").map((line) => line.trim()).filter(Boolean);
+  return [...headerLines, ...translatedLines].join("\n");
+}
+function buildVttFromTranslatedCueBlocks(cueBlocks, translatedTexts, preamble = "WEBVTT") {
+  if (cueBlocks.length !== translatedTexts.length) {
+    throw new Error(`Expected ${cueBlocks.length} translated cues, received ${translatedTexts.length}`);
+  }
+  return buildVttFromCueBlocks(
+    cueBlocks.map((cueBlock, index) => replaceCueText(cueBlock, translatedTexts[index])),
+    preamble
+  );
+}
+function concatenateVttSegments(segments, preamble = "WEBVTT") {
+  const cueBlocks = segments.flatMap((segment) => splitVttPreambleAndCueBlocks(segment).cueBlocks);
+  return buildVttFromCueBlocks(cueBlocks, preamble);
+}
 async function buildTranscriptUrl(playbackId, trackId, shouldSign = false, credentials) {
   "use step";
   const baseUrl = `https://stream.mux.com/${playbackId}/text/${trackId}.vtt`;
@@ -2012,128 +2176,916 @@ async function generateChapters(assetId, languageCode, options = {}) {
   };
 }
 
-// src/workflows/embeddings.ts
-import { embed } from "ai";
+// src/workflows/edit-captions.ts
+import { generateText as generateText4, Output as Output4 } from "ai";
+import dedent4 from "dedent";
+import { z as z5 } from "zod";
 
-// src/primitives/text-chunking.ts
-function estimateTokenCount(text) {
-  const words = text.trim().split(/\s+/).length;
-  return Math.ceil(words / 0.75);
+// src/lib/mux-tracks.ts
+async function fetchVttFromMux(vttUrl) {
+  "use step";
+  const vttResponse = await fetch(vttUrl);
+  if (!vttResponse.ok) {
+    throw new Error(`Failed to fetch VTT file: ${vttResponse.statusText}`);
+  }
+  return vttResponse.text();
 }
-function chunkByTokens(text, maxTokens, overlapTokens = 0) {
-  if (!text.trim()) {
-    return [];
+async function createTextTrackOnMux(assetId, languageCode, trackName, presignedUrl, credentials) {
+  "use step";
+  const muxClient = await resolveMuxClient(credentials);
+  const mux = await muxClient.createClient();
+  const trackResponse = await mux.video.assets.createTrack(assetId, {
+    type: "text",
+    text_type: "subtitles",
+    language_code: languageCode,
+    name: trackName,
+    url: presignedUrl
+  });
+  if (!trackResponse.id) {
+    throw new Error("Failed to create text track: no track ID returned from Mux");
   }
-  const chunks = [];
-  const words = text.trim().split(/\s+/);
-  const wordsPerChunk = Math.floor(maxTokens * 0.75);
-  const overlapWords = Math.floor(overlapTokens * 0.75);
-  let chunkIndex = 0;
-  let currentPosition = 0;
-  while (currentPosition < words.length) {
-    const chunkWords = words.slice(
-      currentPosition,
-      currentPosition + wordsPerChunk
-    );
-    const chunkText2 = chunkWords.join(" ");
-    const tokenCount = estimateTokenCount(chunkText2);
-    chunks.push({
-      id: `chunk-${chunkIndex}`,
-      text: chunkText2,
-      tokenCount
-    });
-    currentPosition += wordsPerChunk - overlapWords;
-    chunkIndex++;
-    if (currentPosition <= (chunkIndex - 1) * (wordsPerChunk - overlapWords)) {
-      break;
-    }
+  return trackResponse.id;
+}
+
+// src/lib/s3-sigv4.ts
+var AWS4_ALGORITHM = "AWS4-HMAC-SHA256";
+var AWS4_REQUEST_TERMINATOR = "aws4_request";
+var AWS4_SERVICE = "s3";
+var S3_ALLOWED_ENDPOINT_PATTERNS = parseEndpointAllowlist(
+  env_default.S3_ALLOWED_ENDPOINT_HOSTS
+);
+function getCrypto() {
+  const webCrypto = globalThis.crypto;
+  if (!webCrypto?.subtle) {
+    throw new Error("Web Crypto API is required for S3 signing.");
   }
-  return chunks;
+  return webCrypto;
 }
-function createChunkFromCues(cues, index) {
-  const text = cues.map((c) => c.text).join(" ");
-  return {
-    id: `chunk-${index}`,
-    text,
-    tokenCount: estimateTokenCount(text),
-    startTime: cues[0].startTime,
-    endTime: cues[cues.length - 1].endTime
-  };
+var textEncoder = new TextEncoder();
+function toBytes(value) {
+  return typeof value === "string" ? textEncoder.encode(value) : value;
 }
-function chunkVTTCues(cues, maxTokens, overlapCues = 2) {
-  if (cues.length === 0)
-    return [];
-  const chunks = [];
-  let currentCues = [];
-  let currentTokens = 0;
-  let chunkIndex = 0;
-  for (let i = 0; i < cues.length; i++) {
-    const cue = cues[i];
-    const cueTokens = estimateTokenCount(cue.text);
-    if (currentTokens + cueTokens > maxTokens && currentCues.length > 0) {
-      chunks.push(createChunkFromCues(currentCues, chunkIndex));
-      chunkIndex++;
-      const overlapStart = Math.max(0, currentCues.length - overlapCues);
-      currentCues = currentCues.slice(overlapStart);
-      currentTokens = currentCues.reduce(
-        (sum, c) => sum + estimateTokenCount(c.text),
-        0
-      );
-    }
-    currentCues.push(cue);
-    currentTokens += cueTokens;
+function bytesToHex(bytes) {
+  return Array.from(bytes).map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+async function sha256Hex(value) {
+  const digest = await getCrypto().subtle.digest("SHA-256", toBytes(value));
+  return bytesToHex(new Uint8Array(digest));
+}
+async function hmacSha256Raw(key, value) {
+  const cryptoKey = await getCrypto().subtle.importKey(
+    "raw",
+    key,
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  const signature = await getCrypto().subtle.sign("HMAC", cryptoKey, textEncoder.encode(value));
+  return new Uint8Array(signature);
+}
+async function deriveSigningKey(secretAccessKey, shortDate, region) {
+  const kDate = await hmacSha256Raw(textEncoder.encode(`AWS4${secretAccessKey}`), shortDate);
+  const kRegion = await hmacSha256Raw(kDate, region);
+  const kService = await hmacSha256Raw(kRegion, AWS4_SERVICE);
+  return hmacSha256Raw(kService, AWS4_REQUEST_TERMINATOR);
+}
+function formatAmzDate(date = /* @__PURE__ */ new Date()) {
+  const iso = date.toISOString();
+  const shortDate = iso.slice(0, 10).replace(/-/g, "");
+  const amzDate = `${iso.slice(0, 19).replace(/[-:]/g, "")}Z`;
+  return { amzDate, shortDate };
+}
+function encodeRFC3986(value) {
+  return encodeURIComponent(value).replace(/[!'()*]/g, (char) => `%${char.charCodeAt(0).toString(16).toUpperCase()}`);
+}
+function encodePath(path) {
+  return path.split("/").map((segment) => encodeRFC3986(segment)).join("/");
+}
+function normalizeEndpoint(endpoint) {
+  let url;
+  try {
+    url = new URL(endpoint);
+  } catch {
+    throw new Error(`Invalid S3 endpoint: ${endpoint}`);
   }
-  if (currentCues.length > 0) {
-    chunks.push(createChunkFromCues(currentCues, chunkIndex));
+  if (url.search || url.hash) {
+    throw new Error("S3 endpoint must not include query params or hash fragments.");
   }
-  return chunks;
+  enforceEndpointPolicy(url);
+  return url;
 }
-function chunkText(text, strategy) {
-  switch (strategy.type) {
-    case "token": {
-      return chunkByTokens(text, strategy.maxTokens, strategy.overlap ?? 0);
-    }
-    default: {
-      const exhaustiveCheck = strategy;
-      throw new Error(`Unsupported chunking strategy: ${exhaustiveCheck}`);
-    }
+function parseEndpointAllowlist(allowlist) {
+  if (!allowlist) {
+    return [];
   }
+  return allowlist.split(",").map((value) => value.trim().toLowerCase()).filter(Boolean);
 }
-
-// src/workflows/embeddings.ts
-function averageEmbeddings(embeddings) {
-  if (embeddings.length === 0) {
-    return [];
+function hostnameMatchesPattern(hostname, pattern) {
+  if (pattern.startsWith("*.")) {
+    const suffix = pattern.slice(1);
+    return hostname.endsWith(suffix) && hostname.length > suffix.length;
   }
-  const dimensions = embeddings[0].length;
-  const averaged = Array.from({ length: dimensions }, () => 0);
-  for (const embedding of embeddings) {
-    for (let i = 0; i < dimensions; i++) {
-      averaged[i] += embedding[i];
-    }
+  return hostname === pattern;
+}
+function enforceEndpointPolicy(url) {
+  const hostname = url.hostname.toLowerCase();
+  if (url.protocol !== "https:") {
+    throw new Error(
+      `Insecure S3 endpoint protocol "${url.protocol}" is not allowed. Use HTTPS.`
+    );
   }
-  for (let i = 0; i < dimensions; i++) {
-    averaged[i] /= embeddings.length;
+  if (S3_ALLOWED_ENDPOINT_PATTERNS.length > 0 && !S3_ALLOWED_ENDPOINT_PATTERNS.some((pattern) => hostnameMatchesPattern(hostname, pattern))) {
+    throw new Error(
+      `S3 endpoint host "${hostname}" is not in S3_ALLOWED_ENDPOINT_HOSTS.`
+    );
   }
-  return averaged;
 }
-async function generateSingleChunkEmbedding({
-  chunk,
-  provider,
-  modelId,
-  credentials
-}) {
-  "use step";
-  const model = await createEmbeddingModelFromConfig(provider, modelId, credentials);
-  const response = await withRetry(
-    () => embed({
-      model,
-      value: chunk.text
-    })
-  );
-  return {
-    chunkId: chunk.id,
-    embedding: response.embedding,
+function buildCanonicalUri(endpoint, bucket, key) {
+  const endpointPath = endpoint.pathname === "/" ? "" : encodePath(endpoint.pathname.replace(/\/+$/, ""));
+  const encodedBucket = encodeRFC3986(bucket);
+  const encodedKey = encodePath(key);
+  return `${endpointPath}/${encodedBucket}/${encodedKey}`;
+}
+function buildCanonicalQuery(params) {
+  return Object.entries(params).sort(([a], [b]) => a.localeCompare(b)).map(([key, value]) => `${encodeRFC3986(key)}=${encodeRFC3986(value)}`).join("&");
+}
+async function signString(secretAccessKey, shortDate, region, value) {
+  const signingKey = await deriveSigningKey(secretAccessKey, shortDate, region);
+  const signatureBytes = await hmacSha256Raw(signingKey, value);
+  return bytesToHex(signatureBytes);
+}
+function buildCredentialScope(shortDate, region) {
+  return `${shortDate}/${region}/${AWS4_SERVICE}/${AWS4_REQUEST_TERMINATOR}`;
+}
+async function putObjectToS3({
+  accessKeyId,
+  secretAccessKey,
+  endpoint,
+  region,
+  bucket,
+  key,
+  body,
+  contentType
+}) {
+  const resolvedEndpoint = normalizeEndpoint(endpoint);
+  const canonicalUri = buildCanonicalUri(resolvedEndpoint, bucket, key);
+  const host = resolvedEndpoint.host;
+  const normalizedContentType = contentType?.trim();
+  const { amzDate, shortDate } = formatAmzDate();
+  const payloadHash = await sha256Hex(body);
+  const signingHeaders = [
+    ["host", host],
+    ["x-amz-content-sha256", payloadHash],
+    ["x-amz-date", amzDate],
+    ...normalizedContentType ? [["content-type", normalizedContentType]] : []
+  ].sort(([a], [b]) => a.localeCompare(b));
+  const canonicalHeaders = signingHeaders.map(([name, value]) => `${name}:${value}`).join("\n");
+  const signedHeaders = signingHeaders.map(([name]) => name).join(";");
+  const canonicalRequest = [
+    "PUT",
+    canonicalUri,
+    "",
+    `${canonicalHeaders}
+`,
+    signedHeaders,
+    payloadHash
+  ].join("\n");
+  const credentialScope = buildCredentialScope(shortDate, region);
+  const stringToSign = [
+    AWS4_ALGORITHM,
+    amzDate,
+    credentialScope,
+    await sha256Hex(canonicalRequest)
+  ].join("\n");
+  const signature = await signString(secretAccessKey, shortDate, region, stringToSign);
+  const authorization = `${AWS4_ALGORITHM} Credential=${accessKeyId}/${credentialScope}, SignedHeaders=${signedHeaders}, Signature=${signature}`;
+  const requestUrl = `${resolvedEndpoint.origin}${canonicalUri}`;
+  const response = await fetch(requestUrl, {
+    method: "PUT",
+    headers: {
+      "Authorization": authorization,
+      "x-amz-content-sha256": payloadHash,
+      "x-amz-date": amzDate,
+      ...normalizedContentType ? { "content-type": normalizedContentType } : {}
+    },
+    body
+  });
+  if (!response.ok) {
+    const errorBody = await response.text().catch(() => "");
+    const detail = errorBody ? ` ${errorBody}` : "";
+    throw new Error(`S3 PUT failed (${response.status} ${response.statusText}).${detail}`);
+  }
+}
+async function createPresignedGetUrl({
+  accessKeyId,
+  secretAccessKey,
+  endpoint,
+  region,
+  bucket,
+  key,
+  expiresInSeconds = 3600
+}) {
+  const resolvedEndpoint = normalizeEndpoint(endpoint);
+  const canonicalUri = buildCanonicalUri(resolvedEndpoint, bucket, key);
+  const host = resolvedEndpoint.host;
+  const { amzDate, shortDate } = formatAmzDate();
+  const credentialScope = buildCredentialScope(shortDate, region);
+  const signedHeaders = "host";
+  const queryParams = {
+    "X-Amz-Algorithm": AWS4_ALGORITHM,
+    "X-Amz-Credential": `${accessKeyId}/${credentialScope}`,
+    "X-Amz-Date": amzDate,
+    "X-Amz-Expires": `${expiresInSeconds}`,
+    "X-Amz-SignedHeaders": signedHeaders
+  };
+  const canonicalQuery = buildCanonicalQuery(queryParams);
+  const canonicalRequest = [
+    "GET",
+    canonicalUri,
+    canonicalQuery,
+    `host:${host}
+`,
+    signedHeaders,
+    "UNSIGNED-PAYLOAD"
+  ].join("\n");
+  const stringToSign = [
+    AWS4_ALGORITHM,
+    amzDate,
+    credentialScope,
+    await sha256Hex(canonicalRequest)
+  ].join("\n");
+  const signature = await signString(secretAccessKey, shortDate, region, stringToSign);
+  const queryWithSignature = `${canonicalQuery}&X-Amz-Signature=${signature}`;
+  return `${resolvedEndpoint.origin}${canonicalUri}?${queryWithSignature}`;
+}
+
+// src/lib/storage-adapter.ts
+function requireCredentials(accessKeyId, secretAccessKey) {
+  if (!accessKeyId || !secretAccessKey) {
+    throw new Error(
+      "S3 credentials are required for default storage operations. Provide S3_ACCESS_KEY_ID and S3_SECRET_ACCESS_KEY or pass options.storageAdapter."
+    );
+  }
+  return { accessKeyId, secretAccessKey };
+}
+async function putObjectWithStorageAdapter(input, adapter) {
+  if (adapter) {
+    await adapter.putObject(input);
+    return;
+  }
+  const credentials = requireCredentials(input.accessKeyId, input.secretAccessKey);
+  await putObjectToS3({
+    accessKeyId: credentials.accessKeyId,
+    secretAccessKey: credentials.secretAccessKey,
+    endpoint: input.endpoint,
+    region: input.region,
+    bucket: input.bucket,
+    key: input.key,
+    body: input.body,
+    contentType: input.contentType
+  });
+}
+async function createPresignedGetUrlWithStorageAdapter(input, adapter) {
+  if (adapter) {
+    return adapter.createPresignedGetUrl(input);
+  }
+  const credentials = requireCredentials(input.accessKeyId, input.secretAccessKey);
+  return createPresignedGetUrl({
+    accessKeyId: credentials.accessKeyId,
+    secretAccessKey: credentials.secretAccessKey,
+    endpoint: input.endpoint,
+    region: input.region,
+    bucket: input.bucket,
+    key: input.key,
+    expiresInSeconds: input.expiresInSeconds
+  });
+}
+
+// src/workflows/edit-captions.ts
+var profanityDetectionSchema = z5.object({
+  profanity: z5.array(z5.string()).describe(
+    "Unique profane words or short phrases exactly as they appear in the transcript text. Include each distinct form only once (e.g., if 'fuck' and 'fucking' both appear, list both)."
+  )
+});
+var SYSTEM_PROMPT3 = dedent4`
+  You are a content moderation assistant. Your task is to identify profane, vulgar, or obscene
+  words and phrases in subtitle text. Return ONLY the exact profane words or phrases as they appear
+  in the text. Do not modify, censor, or paraphrase them. Do not include words that are merely
+  informal or slang but not profane. Focus on words that would be bleeped on broadcast television.`;
+function transformCueText(rawVtt, transform) {
+  const lines = rawVtt.split("\n");
+  let inCueText = false;
+  let currentCueStartTime = 0;
+  const transformed = lines.map((line) => {
+    if (line.includes("-->")) {
+      const startTimestamp = line.split("-->")[0].trim();
+      currentCueStartTime = vttTimestampToSeconds(startTimestamp);
+      inCueText = true;
+      return line;
+    }
+    if (line.trim() === "") {
+      inCueText = false;
+      return line;
+    }
+    if (inCueText) {
+      return transform(line, currentCueStartTime);
+    }
+    return line;
+  });
+  return transformed.join("\n");
+}
+function buildReplacementRegex(words) {
+  const filtered = words.filter((w) => w.length > 0);
+  if (filtered.length === 0)
+    return null;
+  filtered.sort((a, b) => b.length - a.length);
+  const escaped = filtered.map((w) => w.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+  const pattern = escaped.join("|");
+  return new RegExp(`\\b(?:${pattern})\\b`, "gi");
+}
+function createReplacer(mode) {
+  switch (mode) {
+    case "blank":
+      return (match) => `[${"_".repeat(match.length)}]`;
+    case "remove":
+      return () => "";
+    case "mask":
+      return (match) => "?".repeat(match.length);
+  }
+}
+function censorVttContent(rawVtt, profanity, mode) {
+  if (profanity.length === 0) {
+    return { censoredVtt: rawVtt, replacements: [] };
+  }
+  const regex = buildReplacementRegex(profanity);
+  if (!regex) {
+    return { censoredVtt: rawVtt, replacements: [] };
+  }
+  const replacer = createReplacer(mode);
+  const replacements = [];
+  const censoredVtt = transformCueText(rawVtt, (line, cueStartTime) => {
+    return line.replace(regex, (match) => {
+      const after = replacer(match);
+      replacements.push({ cueStartTime, before: match, after });
+      return after;
+    });
+  });
+  return { censoredVtt, replacements };
+}
+function applyOverrideLists(detected, alwaysCensor, neverCensor) {
+  const seen = new Set(detected.map((w) => w.toLowerCase()));
+  const merged = [...detected];
+  for (const word of alwaysCensor) {
+    const lower = word.toLowerCase();
+    if (!seen.has(lower)) {
+      seen.add(lower);
+      merged.push(word);
+    }
+  }
+  const neverSet = new Set(neverCensor.map((w) => w.toLowerCase()));
+  return merged.filter((w) => !neverSet.has(w.toLowerCase()));
+}
+function applyReplacements(rawVtt, replacements) {
+  const filtered = replacements.filter((r) => r.find.length > 0);
+  if (filtered.length === 0) {
+    return { editedVtt: rawVtt, replacements: [] };
+  }
+  const records = [];
+  const editedVtt = transformCueText(rawVtt, (line, cueStartTime) => {
+    let result = line;
+    for (const { find, replace } of filtered) {
+      const escaped = find.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      const regex = new RegExp(`\\b${escaped}\\b`, "g");
+      result = result.replace(regex, (match) => {
+        records.push({ cueStartTime, before: match, after: replace });
+        return replace;
+      });
+    }
+    return result;
+  });
+  return { editedVtt, replacements: records };
+}
+async function identifyProfanityWithAI({
+  plainText,
+  provider,
+  modelId,
+  credentials
+}) {
+  "use step";
+  const model = await createLanguageModelFromConfig(provider, modelId, credentials);
+  const response = await generateText4({
+    model,
+    output: Output4.object({ schema: profanityDetectionSchema }),
+    messages: [
+      {
+        role: "system",
+        content: SYSTEM_PROMPT3
+      },
+      {
+        role: "user",
+        content: `Identify all profane words and phrases in the following subtitle transcript. Return each unique profane word or phrase exactly as it appears in the text.
+
+<transcript>
+${plainText}
+</transcript>`
+      }
+    ]
+  });
+  return {
+    profanity: response.output.profanity,
+    usage: {
+      inputTokens: response.usage.inputTokens,
+      outputTokens: response.usage.outputTokens,
+      totalTokens: response.usage.totalTokens,
+      reasoningTokens: response.usage.reasoningTokens,
+      cachedInputTokens: response.usage.cachedInputTokens
+    }
+  };
+}
+async function uploadEditedVttToS3({
+  editedVtt,
+  assetId,
+  trackId,
+  s3Endpoint,
+  s3Region,
+  s3Bucket,
+  storageAdapter,
+  s3SignedUrlExpirySeconds
+}) {
+  "use step";
+  const s3AccessKeyId = env_default.S3_ACCESS_KEY_ID;
+  const s3SecretAccessKey = env_default.S3_SECRET_ACCESS_KEY;
+  const vttKey = `edited/${assetId}/${trackId}-edited-${Date.now()}.vtt`;
+  await putObjectWithStorageAdapter({
+    accessKeyId: s3AccessKeyId,
+    secretAccessKey: s3SecretAccessKey,
+    endpoint: s3Endpoint,
+    region: s3Region,
+    bucket: s3Bucket,
+    key: vttKey,
+    body: editedVtt,
+    contentType: "text/vtt"
+  }, storageAdapter);
+  return createPresignedGetUrlWithStorageAdapter({
+    accessKeyId: s3AccessKeyId,
+    secretAccessKey: s3SecretAccessKey,
+    endpoint: s3Endpoint,
+    region: s3Region,
+    bucket: s3Bucket,
+    key: vttKey,
+    expiresInSeconds: s3SignedUrlExpirySeconds ?? 86400
+  }, storageAdapter);
+}
+async function deleteTrackOnMux(assetId, trackId, credentials) {
+  "use step";
+  const muxClient = await resolveMuxClient(credentials);
+  const mux = await muxClient.createClient();
+  await mux.video.assets.deleteTrack(assetId, trackId);
+}
+async function editCaptions(assetId, trackId, options) {
+  "use workflow";
+  const {
+    provider,
+    model,
+    autoCensorProfanity: autoCensorOption,
+    replacements: replacementsOption,
+    deleteOriginalTrack,
+    uploadToMux: uploadToMuxOption,
+    s3Endpoint: providedS3Endpoint,
+    s3Region: providedS3Region,
+    s3Bucket: providedS3Bucket,
+    trackNameSuffix,
+    storageAdapter,
+    credentials
+  } = options;
+  const hasAutoCensor = !!autoCensorOption;
+  const hasReplacements = !!replacementsOption && replacementsOption.length > 0;
+  if (!hasAutoCensor && !hasReplacements) {
+    throw new Error("At least one of autoCensorProfanity or replacements must be provided.");
+  }
+  if (autoCensorOption && !provider) {
+    throw new Error("provider is required when using autoCensorProfanity.");
+  }
+  const deleteOriginal = deleteOriginalTrack !== false;
+  const uploadToMux = uploadToMuxOption !== false;
+  const s3Endpoint = providedS3Endpoint ?? env_default.S3_ENDPOINT;
+  const s3Region = providedS3Region ?? env_default.S3_REGION ?? "auto";
+  const s3Bucket = providedS3Bucket ?? env_default.S3_BUCKET;
+  const s3AccessKeyId = env_default.S3_ACCESS_KEY_ID;
+  const s3SecretAccessKey = env_default.S3_SECRET_ACCESS_KEY;
+  if (uploadToMux && (!s3Endpoint || !s3Bucket || !storageAdapter && (!s3AccessKeyId || !s3SecretAccessKey))) {
+    throw new Error(
+      "Storage configuration is required for uploading to Mux. Provide s3Endpoint and s3Bucket. If no storageAdapter is supplied, also provide s3AccessKeyId and s3SecretAccessKey in options or set S3_ENDPOINT, S3_BUCKET, S3_ACCESS_KEY_ID, and S3_SECRET_ACCESS_KEY environment variables."
+    );
+  }
+  const { asset: assetData, playbackId, policy } = await getPlaybackIdForAsset(assetId, credentials);
+  const assetDurationSeconds = getAssetDurationSecondsFromAsset(assetData);
+  const signingContext = await resolveMuxSigningContext(credentials);
+  if (policy === "signed" && !signingContext) {
+    throw new Error(
+      "Signed playback ID requires signing credentials. Set MUX_SIGNING_KEY and MUX_PRIVATE_KEY environment variables."
+    );
+  }
+  const readyTextTracks = getReadyTextTracks(assetData);
+  const sourceTrack = readyTextTracks.find((t) => t.id === trackId);
+  if (!sourceTrack) {
+    const availableTrackIds = readyTextTracks.map((t) => t.id).filter(Boolean).join(", ");
+    throw new Error(
+      `Track '${trackId}' not found or not ready on asset '${assetId}'. Available track IDs: ${availableTrackIds || "none"}`
+    );
+  }
+  const vttUrl = await buildTranscriptUrl(playbackId, trackId, policy === "signed", credentials);
+  let vttContent;
+  try {
+    vttContent = await fetchVttFromMux(vttUrl);
+  } catch (error) {
+    throw new Error(`Failed to fetch VTT content: ${error instanceof Error ? error.message : "Unknown error"}`);
+  }
+  let editedVtt = vttContent;
+  let totalReplacementCount = 0;
+  let autoCensorResult;
+  let usage;
+  if (autoCensorOption) {
+    const { mode = "blank", alwaysCensor = [], neverCensor = [] } = autoCensorOption;
+    const plainText = extractTextFromVTT(vttContent);
+    if (!plainText.trim()) {
+      throw new Error("Track transcript is empty; nothing to censor.");
+    }
+    const modelConfig = resolveLanguageModelConfig({
+      ...options,
+      provider,
+      model
+    });
+    let detectedProfanity;
+    try {
+      const result = await identifyProfanityWithAI({
+        plainText,
+        provider: modelConfig.provider,
+        modelId: modelConfig.modelId,
+        credentials
+      });
+      detectedProfanity = result.profanity;
+      usage = result.usage;
+    } catch (error) {
+      throw new Error(`Failed to detect profanity with ${modelConfig.provider}: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+    const finalProfanity = applyOverrideLists(detectedProfanity, alwaysCensor, neverCensor);
+    const { censoredVtt, replacements: censorReplacements } = censorVttContent(editedVtt, finalProfanity, mode);
+    editedVtt = censoredVtt;
+    totalReplacementCount += censorReplacements.length;
+    autoCensorResult = { replacements: censorReplacements };
+  }
+  let replacementsResult;
+  if (replacementsOption && replacementsOption.length > 0) {
+    const { editedVtt: afterReplacements, replacements: staticReplacements } = applyReplacements(editedVtt, replacementsOption);
+    editedVtt = afterReplacements;
+    totalReplacementCount += staticReplacements.length;
+    replacementsResult = { replacements: staticReplacements };
+  }
+  const usageWithMetadata = usage ? {
+    ...usage,
+    metadata: {
+      assetDurationSeconds
+    }
+  } : void 0;
+  if (!uploadToMux) {
+    return {
+      assetId,
+      trackId,
+      originalVtt: vttContent,
+      editedVtt,
+      totalReplacementCount,
+      autoCensorProfanity: autoCensorResult,
+      replacements: replacementsResult,
+      usage: usageWithMetadata
+    };
+  }
+  let presignedUrl;
+  try {
+    presignedUrl = await uploadEditedVttToS3({
+      editedVtt,
+      assetId,
+      trackId,
+      s3Endpoint,
+      s3Region,
+      s3Bucket,
+      storageAdapter,
+      s3SignedUrlExpirySeconds: options.s3SignedUrlExpirySeconds
+    });
+  } catch (error) {
+    throw new Error(`Failed to upload VTT to S3: ${error instanceof Error ? error.message : "Unknown error"}`);
+  }
+  let uploadedTrackId;
+  try {
+    const languageCode = sourceTrack.language_code || "en";
+    const suffix = trackNameSuffix ?? "edited";
+    const trackName = `${sourceTrack.name || "Subtitles"} (${suffix})`;
+    uploadedTrackId = await createTextTrackOnMux(
+      assetId,
+      languageCode,
+      trackName,
+      presignedUrl,
+      credentials
+    );
+  } catch (error) {
+    console.warn(`Failed to add track to Mux asset: ${error instanceof Error ? error.message : "Unknown error"}`);
+  }
+  if (deleteOriginal && uploadedTrackId) {
+    try {
+      await deleteTrackOnMux(assetId, trackId, credentials);
+    } catch (error) {
+      console.warn(`Failed to delete original track: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  return {
+    assetId,
+    trackId,
+    originalVtt: vttContent,
+    editedVtt,
+    totalReplacementCount,
+    autoCensorProfanity: autoCensorResult,
+    replacements: replacementsResult,
+    uploadedTrackId,
+    presignedUrl,
+    usage: usageWithMetadata
+  };
+}
+
+// src/workflows/embeddings.ts
+import { embed } from "ai";
+
+// src/primitives/text-chunking.ts
+var DEFAULT_MIN_CHUNK_DURATION_RATIO = 2 / 3;
+var DEFAULT_BOUNDARY_LOOKAHEAD_CUES = 12;
+var DEFAULT_BOUNDARY_PAUSE_SECONDS = 1.25;
+var STRONG_BOUNDARY_SCORE = 4;
+var PREFERRED_BOUNDARY_WINDOW_SECONDS = 5 * 60;
+var SENTENCE_BOUNDARY_REGEX = /[.!?]["')\]]*$/;
+var CLAUSE_BOUNDARY_REGEX = /[,;:]["')\]]*$/;
+var NEXT_SENTENCE_START_REGEX = /^[A-Z0-9"'([{]/;
+function estimateTokenCount(text) {
+  const words = text.trim().split(/\s+/).length;
+  return Math.ceil(words / 0.75);
+}
+function chunkByTokens(text, maxTokens, overlapTokens = 0) {
+  if (!text.trim()) {
+    return [];
+  }
+  const chunks = [];
+  const words = text.trim().split(/\s+/);
+  const wordsPerChunk = Math.floor(maxTokens * 0.75);
+  const overlapWords = Math.floor(overlapTokens * 0.75);
+  let chunkIndex = 0;
+  let currentPosition = 0;
+  while (currentPosition < words.length) {
+    const chunkWords = words.slice(
+      currentPosition,
+      currentPosition + wordsPerChunk
+    );
+    const chunkText2 = chunkWords.join(" ");
+    const tokenCount = estimateTokenCount(chunkText2);
+    chunks.push({
+      id: `chunk-${chunkIndex}`,
+      text: chunkText2,
+      tokenCount
+    });
+    currentPosition += wordsPerChunk - overlapWords;
+    chunkIndex++;
+    if (currentPosition <= (chunkIndex - 1) * (wordsPerChunk - overlapWords)) {
+      break;
+    }
+  }
+  return chunks;
+}
+function createChunkFromCues(cues, index) {
+  const text = cues.map((c) => c.text).join(" ");
+  return {
+    id: `chunk-${index}`,
+    text,
+    tokenCount: estimateTokenCount(text),
+    startTime: cues[0].startTime,
+    endTime: cues[cues.length - 1].endTime
+  };
+}
+function chunkVTTCues(cues, maxTokens, overlapCues = 2) {
+  if (cues.length === 0)
+    return [];
+  const chunks = [];
+  let currentCues = [];
+  let currentTokens = 0;
+  let chunkIndex = 0;
+  for (let i = 0; i < cues.length; i++) {
+    const cue = cues[i];
+    const cueTokens = estimateTokenCount(cue.text);
+    if (currentTokens + cueTokens > maxTokens && currentCues.length > 0) {
+      chunks.push(createChunkFromCues(currentCues, chunkIndex));
+      chunkIndex++;
+      const overlapStart = Math.max(0, currentCues.length - overlapCues);
+      currentCues = currentCues.slice(overlapStart);
+      currentTokens = currentCues.reduce(
+        (sum, c) => sum + estimateTokenCount(c.text),
+        0
+      );
+    }
+    currentCues.push(cue);
+    currentTokens += cueTokens;
+  }
+  if (currentCues.length > 0) {
+    chunks.push(createChunkFromCues(currentCues, chunkIndex));
+  }
+  return chunks;
+}
+function scoreCueBoundary(cues, index, boundaryPauseSeconds) {
+  const cue = cues[index];
+  const nextCue = cues[index + 1];
+  if (!nextCue) {
+    return Number.POSITIVE_INFINITY;
+  }
+  const trimmedText = cue.text.trim();
+  let score = 0;
+  if (SENTENCE_BOUNDARY_REGEX.test(trimmedText)) {
+    score += 4;
+  } else if (CLAUSE_BOUNDARY_REGEX.test(trimmedText)) {
+    score += 2;
+  }
+  if (nextCue.startTime - cue.endTime >= boundaryPauseSeconds) {
+    score += 2;
+  }
+  if (NEXT_SENTENCE_START_REGEX.test(nextCue.text.trim())) {
+    score += 1;
+  }
+  return score;
+}
+function chunkVTTCuesByBudget(cues, options) {
+  if (cues.length === 0) {
+    return [];
+  }
+  const maxCuesPerChunk = Math.max(1, options.maxCuesPerChunk);
+  let maxTextTokensPerChunk = Number.POSITIVE_INFINITY;
+  if (options.maxTextTokensPerChunk) {
+    maxTextTokensPerChunk = Math.max(1, options.maxTextTokensPerChunk);
+  }
+  const chunks = [];
+  let chunkIndex = 0;
+  let cueStartIndex = 0;
+  let currentTokenCount = 0;
+  for (let cueIndex = 0; cueIndex < cues.length; cueIndex++) {
+    const cue = cues[cueIndex];
+    const cueTokenCount = estimateTokenCount(cue.text);
+    const currentCueCount = cueIndex - cueStartIndex;
+    const wouldExceedCueCount = currentCueCount >= maxCuesPerChunk;
+    const wouldExceedTokenCount = currentCueCount > 0 && currentTokenCount + cueTokenCount > maxTextTokensPerChunk;
+    if (wouldExceedCueCount || wouldExceedTokenCount) {
+      chunks.push({
+        id: `chunk-${chunkIndex}`,
+        cueStartIndex,
+        cueEndIndex: cueIndex - 1,
+        cueCount: cueIndex - cueStartIndex,
+        startTime: cues[cueStartIndex].startTime,
+        endTime: cues[cueIndex - 1].endTime
+      });
+      cueStartIndex = cueIndex;
+      currentTokenCount = 0;
+      chunkIndex++;
+    }
+    currentTokenCount += cueTokenCount;
+  }
+  chunks.push({
+    id: `chunk-${chunkIndex}`,
+    cueStartIndex,
+    cueEndIndex: cues.length - 1,
+    cueCount: cues.length - cueStartIndex,
+    startTime: cues[cueStartIndex].startTime,
+    endTime: cues[cues.length - 1].endTime
+  });
+  return chunks;
+}
+function chunkVTTCuesByDuration(cues, options) {
+  if (cues.length === 0) {
+    return [];
+  }
+  const targetChunkDurationSeconds = Math.max(1, options.targetChunkDurationSeconds);
+  const maxChunkDurationSeconds = Math.max(targetChunkDurationSeconds, options.maxChunkDurationSeconds);
+  const minChunkDurationSeconds = Math.min(
+    targetChunkDurationSeconds,
+    Math.max(
+      1,
+      options.minChunkDurationSeconds ?? Math.floor(targetChunkDurationSeconds * DEFAULT_MIN_CHUNK_DURATION_RATIO)
+    )
+  );
+  const boundaryLookaheadCues = Math.max(1, options.boundaryLookaheadCues ?? DEFAULT_BOUNDARY_LOOKAHEAD_CUES);
+  const boundaryPauseSeconds = options.boundaryPauseSeconds ?? DEFAULT_BOUNDARY_PAUSE_SECONDS;
+  const preferredBoundaryStartSeconds = Math.max(
+    minChunkDurationSeconds,
+    targetChunkDurationSeconds - Math.min(PREFERRED_BOUNDARY_WINDOW_SECONDS, targetChunkDurationSeconds / 6)
+  );
+  const chunks = [];
+  let chunkIndex = 0;
+  let cueStartIndex = 0;
+  while (cueStartIndex < cues.length) {
+    const chunkStartTime = cues[cueStartIndex].startTime;
+    let cueEndIndex = cueStartIndex;
+    let bestBoundaryIndex = -1;
+    let bestBoundaryScore = -1;
+    let bestPreferredBoundaryIndex = -1;
+    let bestPreferredBoundaryScore = -1;
+    while (cueEndIndex < cues.length) {
+      const cue = cues[cueEndIndex];
+      const currentDuration = cue.endTime - chunkStartTime;
+      if (currentDuration >= minChunkDurationSeconds) {
+        const boundaryScore = scoreCueBoundary(cues, cueEndIndex, boundaryPauseSeconds);
+        if (boundaryScore >= bestBoundaryScore) {
+          bestBoundaryIndex = cueEndIndex;
+          bestBoundaryScore = boundaryScore;
+        }
+        if (currentDuration >= preferredBoundaryStartSeconds && boundaryScore >= bestPreferredBoundaryScore) {
+          bestPreferredBoundaryIndex = cueEndIndex;
+          bestPreferredBoundaryScore = boundaryScore;
+        }
+      }
+      const nextCue = cues[cueEndIndex + 1];
+      if (!nextCue) {
+        break;
+      }
+      const nextDuration = nextCue.endTime - chunkStartTime;
+      const lookaheadExceeded = cueEndIndex - cueStartIndex >= boundaryLookaheadCues;
+      const preferredBoundaryIndex = bestPreferredBoundaryIndex >= cueStartIndex ? bestPreferredBoundaryIndex : bestBoundaryIndex;
+      const preferredBoundaryScore = bestPreferredBoundaryIndex >= cueStartIndex ? bestPreferredBoundaryScore : bestBoundaryScore;
+      if (currentDuration >= targetChunkDurationSeconds) {
+        if (preferredBoundaryIndex >= cueStartIndex && preferredBoundaryScore >= STRONG_BOUNDARY_SCORE) {
+          cueEndIndex = preferredBoundaryIndex;
+          break;
+        }
+        if (nextDuration > maxChunkDurationSeconds || lookaheadExceeded) {
+          cueEndIndex = preferredBoundaryIndex >= cueStartIndex ? preferredBoundaryIndex : cueEndIndex;
+          break;
+        }
+      }
+      if (nextDuration > maxChunkDurationSeconds) {
+        cueEndIndex = preferredBoundaryIndex >= cueStartIndex ? preferredBoundaryIndex : cueEndIndex;
+        break;
+      }
+      cueEndIndex++;
+    }
+    chunks.push({
+      id: `chunk-${chunkIndex}`,
+      cueStartIndex,
+      cueEndIndex,
+      cueCount: cueEndIndex - cueStartIndex + 1,
+      startTime: cues[cueStartIndex].startTime,
+      endTime: cues[cueEndIndex].endTime
+    });
+    cueStartIndex = cueEndIndex + 1;
+    chunkIndex++;
+  }
+  return chunks;
+}
+function chunkText(text, strategy) {
+  switch (strategy.type) {
+    case "token": {
+      return chunkByTokens(text, strategy.maxTokens, strategy.overlap ?? 0);
+    }
+    default: {
+      const exhaustiveCheck = strategy;
+      throw new Error(`Unsupported chunking strategy: ${exhaustiveCheck}`);
+    }
+  }
+}
+
+// src/workflows/embeddings.ts
+function averageEmbeddings(embeddings) {
+  if (embeddings.length === 0) {
+    return [];
+  }
+  const dimensions = embeddings[0].length;
+  const averaged = Array.from({ length: dimensions }, () => 0);
+  for (const embedding of embeddings) {
+    for (let i = 0; i < dimensions; i++) {
+      averaged[i] += embedding[i];
+    }
+  }
+  for (let i = 0; i < dimensions; i++) {
+    averaged[i] /= embeddings.length;
+  }
+  return averaged;
+}
+async function generateSingleChunkEmbedding({
+  chunk,
+  provider,
+  modelId,
+  credentials
+}) {
+  "use step";
+  const model = await createEmbeddingModelFromConfig(provider, modelId, credentials);
+  const response = await withRetry(
+    () => embed({
+      model,
+      value: chunk.text
+    })
+  );
+  return {
+    chunkId: chunk.id,
+    embedding: response.embedding,
     metadata: {
       startTime: chunk.startTime,
       endTime: chunk.endTime,
@@ -2343,10 +3295,8 @@ async function getThumbnailUrls(playbackId, duration, options = {}) {
   }
   const baseUrl = getMuxThumbnailBaseUrl(playbackId);
   const urlPromises = timestamps.map(async (time) => {
-    if (shouldSign) {
-      return signUrl(baseUrl, playbackId, "thumbnail", { time, width }, credentials);
-    }
-    return `${baseUrl}?time=${time}&width=${width}`;
+    const url = shouldSign ? await signUrl(baseUrl, playbackId, "thumbnail", { time, width }, credentials) : `${baseUrl}?time=${time}&width=${width}`;
+    return { url, time };
   });
   return Promise.all(urlPromises);
 }
@@ -2420,6 +3370,7 @@ async function moderateImageWithOpenAI(entry) {
     const categoryScores = json.results?.[0]?.category_scores || {};
     return {
       url: entry.url,
+      time: entry.time,
       sexual: categoryScores.sexual || 0,
       violence: categoryScores.violence || 0,
       error: false
@@ -2428,6 +3379,7 @@ async function moderateImageWithOpenAI(entry) {
     console.error("OpenAI moderation failed:", error);
     return {
       url: entry.url,
+      time: entry.time,
       sexual: 0,
       violence: 0,
       error: true,
@@ -2435,11 +3387,13 @@ async function moderateImageWithOpenAI(entry) {
     };
   }
 }
-async function requestOpenAIModeration(imageUrls, model, maxConcurrent = 5, submissionMode = "url", downloadOptions, credentials) {
+async function requestOpenAIModeration(images, model, maxConcurrent = 5, submissionMode = "url", downloadOptions, credentials) {
   "use step";
+  const imageUrls = images.map((img) => img.url);
+  const timeByUrl = new Map(images.map((img) => [img.url, img.time]));
   const targetUrls = submissionMode === "base64" ? (await downloadImagesAsBase64(imageUrls, downloadOptions, maxConcurrent)).map(
-    (img) => ({ url: img.url, image: img.base64Data, model, credentials })
-  ) : imageUrls.map((url) => ({ url, image: url, model, credentials }));
+    (img) => ({ url: img.url, time: timeByUrl.get(img.url), image: img.base64Data, model, credentials })
+  ) : images.map((img) => ({ url: img.url, time: img.time, image: img.url, model, credentials }));
   return processConcurrently(targetUrls, moderateImageWithOpenAI, maxConcurrent);
 }
 async function requestOpenAITextModeration(text, model, url, credentials) {
@@ -2584,6 +3538,7 @@ async function moderateImageWithHive(entry) {
     const violence = getHiveCategoryScores(classes, HIVE_VIOLENCE_CATEGORIES);
     return {
       url: entry.url,
+      time: entry.time,
       sexual,
       violence,
       error: false
@@ -2591,6 +3546,7 @@ async function moderateImageWithHive(entry) {
   } catch (error) {
     return {
       url: entry.url,
+      time: entry.time,
       sexual: 0,
       violence: 0,
       error: true,
@@ -2598,19 +3554,23 @@ async function moderateImageWithHive(entry) {
     };
   }
 }
-async function requestHiveModeration(imageUrls, maxConcurrent = 5, submissionMode = "url", downloadOptions, credentials) {
+async function requestHiveModeration(images, maxConcurrent = 5, submissionMode = "url", downloadOptions, credentials) {
   "use step";
+  const imageUrls = images.map((img) => img.url);
+  const timeByUrl = new Map(images.map((img) => [img.url, img.time]));
   const targets = submissionMode === "base64" ? (await downloadImagesAsBase64(imageUrls, downloadOptions, maxConcurrent)).map((img) => ({
     url: img.url,
+    time: timeByUrl.get(img.url),
     source: {
       kind: "file",
       buffer: img.buffer,
       contentType: img.contentType
     },
     credentials
-  })) : imageUrls.map((url) => ({
-    url,
-    source: { kind: "url", value: url },
+  })) : images.map((img) => ({
+    url: img.url,
+    time: img.time,
+    source: { kind: "url", value: img.url },
     credentials
   }));
   return await processConcurrently(targets, moderateImageWithHive, maxConcurrent);
@@ -2621,10 +3581,8 @@ async function getThumbnailUrlsFromTimestamps(playbackId, timestampsMs, options)
   const baseUrl = getMuxThumbnailBaseUrl(playbackId);
   const urlPromises = timestampsMs.map(async (tsMs) => {
     const time = Number((tsMs / 1e3).toFixed(2));
-    if (shouldSign) {
-      return signUrl(baseUrl, playbackId, "thumbnail", { time, width }, credentials);
-    }
-    return `${baseUrl}?time=${time}&width=${width}`;
+    const url = shouldSign ? await signUrl(baseUrl, playbackId, "thumbnail", { time, width }, credentials) : `${baseUrl}?time=${time}&width=${width}`;
+    return { url, time };
   });
   return Promise.all(urlPromises);
 }
@@ -2775,16 +3733,18 @@ async function getModerationScores(assetId, options = {}) {
 }
 
 // src/workflows/summarization.ts
-import { generateText as generateText4, Output as Output4 } from "ai";
-import dedent4 from "dedent";
-import { z as z5 } from "zod";
-var SUMMARY_KEYWORD_LIMIT = 10;
-var summarySchema = z5.object({
-  keywords: z5.array(z5.string()),
-  title: z5.string(),
-  description: z5.string()
+import { generateText as generateText5, Output as Output5 } from "ai";
+import dedent5 from "dedent";
+import { z as z6 } from "zod";
+var DEFAULT_SUMMARY_KEYWORD_LIMIT = 10;
+var DEFAULT_TITLE_LENGTH = 10;
+var DEFAULT_DESCRIPTION_LENGTH = 50;
+var summarySchema = z6.object({
+  keywords: z6.array(z6.string()),
+  title: z6.string(),
+  description: z6.string()
 }).strict();
-var SUMMARY_OUTPUT = Output4.object({
+var SUMMARY_OUTPUT = Output5.object({
   name: "summary_metadata",
   description: "Structured summary with title, description, and keywords.",
   schema: summarySchema
@@ -2795,10 +3755,49 @@ var TONE_INSTRUCTIONS = {
   playful: "Channel your inner diva! Answer with maximum sass, wit, and playful attitude. Don't hold back - be cheeky, clever, and delightfully snarky. Make it pop!",
   professional: "Provide a professional, executive-level analysis suitable for business reporting."
 };
+var DESCRIPTION_LENGTH_THRESHOLD_SMALL = 25;
+var DESCRIPTION_LENGTH_THRESHOLD_LARGE = 100;
+function buildDescriptionGuidance(wordCount, contentType) {
+  if (wordCount < DESCRIPTION_LENGTH_THRESHOLD_SMALL) {
+    if (contentType === "video") {
+      return dedent5`A brief summary of the video in approximately ${wordCount} words.
+        Focus on the single most important subject or action.
+        Write in present tense.`;
+    }
+    return dedent5`A brief summary of the audio content in approximately ${wordCount} words.
+      Focus on the single most important topic or theme.
+      Write in present tense.`;
+  }
+  if (wordCount > DESCRIPTION_LENGTH_THRESHOLD_LARGE) {
+    if (contentType === "video") {
+      return dedent5`A detailed summary that describes what happens across the video.
+        Aim for approximately ${wordCount} words, and you may use multiple sentences.
+        Be thorough: cover subjects, actions, setting, progression, and any notable details visible across frames.
+        Write in present tense. Be specific about observable details rather than making assumptions.
+        If the transcript provides dialogue or narration, incorporate key points but prioritize visual content.`;
+    }
+    return dedent5`A detailed summary that describes the audio content.
+      Aim for approximately ${wordCount} words, and you may use multiple sentences.
+      Be thorough: cover topics, speakers, themes, progression, and any notable insights.
+      Write in present tense. Be specific about what is discussed or presented rather than making assumptions.
+      Focus on the spoken content and any key insights, dialogue, or narrative elements.`;
+  }
+  if (contentType === "video") {
+    return dedent5`A summary that describes what happens across the video.
+      Aim for approximately ${wordCount} words, and you may use multiple sentences.
+      Cover the main subjects, actions, setting, and any notable progression visible across frames.
+      Write in present tense. Be specific about observable details rather than making assumptions.
+      If the transcript provides dialogue or narration, incorporate key points but prioritize visual content.`;
+  }
+  return dedent5`A summary that describes the audio content.
+    Aim for approximately ${wordCount} words, and you may use multiple sentences.
+    Cover the main topics, speakers, themes, and any notable progression in the discussion or narration.
+    Write in present tense. Be specific about what is discussed or presented rather than making assumptions.
+    Focus on the spoken content and any key insights, dialogue, or narrative elements.`;
+}
 function createSummarizationBuilder({ titleLength, descriptionLength, tagCount } = {}) {
-  const titleBrevity = titleLength != null ? `Aim for approximately ${titleLength} characters.` : "Aim for brevity - typically under 10 words.";
-  const descConstraint = descriptionLength != null ? `approximately ${descriptionLength} characters` : "2-4 sentences";
-  const keywordLimit = tagCount ?? SUMMARY_KEYWORD_LIMIT;
+  const titleBrevity = `Aim for approximately ${titleLength ?? DEFAULT_TITLE_LENGTH} words.`;
+  const keywordLimit = tagCount ?? DEFAULT_SUMMARY_KEYWORD_LIMIT;
   return createPromptBuilder({
     template: {
       task: {
@@ -2807,7 +3806,7 @@ function createSummarizationBuilder({ titleLength, descriptionLength, tagCount }
       },
       title: {
         tag: "title_requirements",
-        content: dedent4`
+        content: dedent5`
           A short, compelling headline that immediately communicates the subject or action.
           ${titleBrevity} Think of how a news headline or video card title would read.
           Start with the primary subject, action, or topic - never begin with "A video of" or similar phrasing.
@@ -2815,15 +3814,11 @@ function createSummarizationBuilder({ titleLength, descriptionLength, tagCount }
       },
       description: {
         tag: "description_requirements",
-        content: dedent4`
-          A concise summary (${descConstraint}) that describes what happens across the video.
-          Cover the main subjects, actions, setting, and any notable progression visible across frames.
-          Write in present tense. Be specific about observable details rather than making assumptions.
-          If the transcript provides dialogue or narration, incorporate key points but prioritize visual content.`
+        content: buildDescriptionGuidance(descriptionLength ?? DEFAULT_DESCRIPTION_LENGTH, "video")
       },
       keywords: {
         tag: "keywords_requirements",
-        content: dedent4`
+        content: dedent5`
           Specific, searchable terms (up to ${keywordLimit}) that capture:
           - Primary subjects (people, animals, objects)
           - Actions and activities being performed
@@ -2835,7 +3830,7 @@ function createSummarizationBuilder({ titleLength, descriptionLength, tagCount }
       },
       qualityGuidelines: {
         tag: "quality_guidelines",
-        content: dedent4`
+        content: dedent5`
           - Examine all frames to understand the full context and progression
           - Be precise: "golden retriever" is better than "dog" when identifiable
           - Capture the narrative: what begins, develops, and concludes
@@ -2846,9 +3841,8 @@ function createSummarizationBuilder({ titleLength, descriptionLength, tagCount }
   });
 }
 function createAudioOnlyBuilder({ titleLength, descriptionLength, tagCount } = {}) {
-  const titleBrevity = titleLength != null ? `Aim for approximately ${titleLength} characters.` : "Aim for brevity - typically under 10 words.";
-  const descConstraint = descriptionLength != null ? `approximately ${descriptionLength} characters` : "2-4 sentences";
-  const keywordLimit = tagCount ?? SUMMARY_KEYWORD_LIMIT;
+  const titleBrevity = `Aim for approximately ${titleLength ?? DEFAULT_TITLE_LENGTH} words.`;
+  const keywordLimit = tagCount ?? DEFAULT_SUMMARY_KEYWORD_LIMIT;
   return createPromptBuilder({
     template: {
       task: {
@@ -2857,7 +3851,7 @@ function createAudioOnlyBuilder({ titleLength, descriptionLength, tagCount } = {
       },
       title: {
         tag: "title_requirements",
-        content: dedent4`
+        content: dedent5`
           A short, compelling headline that immediately communicates the subject or topic.
           ${titleBrevity} Think of how a podcast title or audio description would read.
           Start with the primary subject, action, or topic - never begin with "An audio of" or similar phrasing.
@@ -2865,15 +3859,11 @@ function createAudioOnlyBuilder({ titleLength, descriptionLength, tagCount } = {
       },
       description: {
         tag: "description_requirements",
-        content: dedent4`
-          A concise summary (${descConstraint}) that describes the audio content.
-          Cover the main topics, speakers, themes, and any notable progression in the discussion or narration.
-          Write in present tense. Be specific about what is discussed or presented rather than making assumptions.
-          Focus on the spoken content and any key insights, dialogue, or narrative elements.`
+        content: buildDescriptionGuidance(descriptionLength ?? DEFAULT_DESCRIPTION_LENGTH, "audio")
       },
       keywords: {
         tag: "keywords_requirements",
-        content: dedent4`
+        content: dedent5`
           Specific, searchable terms (up to ${keywordLimit}) that capture:
           - Primary topics and themes
           - Speakers or presenters (if named)
@@ -2885,7 +3875,7 @@ function createAudioOnlyBuilder({ titleLength, descriptionLength, tagCount } = {
       },
       qualityGuidelines: {
         tag: "quality_guidelines",
-        content: dedent4`
+        content: dedent5`
           - Analyze the full transcript to understand context and themes
           - Be precise: use specific terminology when mentioned
           - Capture the narrative: what is introduced, discussed, and concluded
@@ -2895,7 +3885,7 @@ function createAudioOnlyBuilder({ titleLength, descriptionLength, tagCount } = {
     sectionOrder: ["task", "title", "description", "keywords", "qualityGuidelines"]
   });
 }
-var SYSTEM_PROMPT3 = dedent4`
+var SYSTEM_PROMPT4 = dedent5`
   <role>
     You are a video content analyst specializing in storyboard interpretation and multimodal analysis.
   </role>
@@ -2952,7 +3942,7 @@ var SYSTEM_PROMPT3 = dedent4`
 
     Write as if describing reality, not describing a recording of reality.
   </language_guidelines>`;
-var AUDIO_ONLY_SYSTEM_PROMPT = dedent4`
+var AUDIO_ONLY_SYSTEM_PROMPT = dedent5`
   <role>
     You are an audio content analyst specializing in transcript analysis and metadata generation.
   </role>
@@ -3018,56 +4008,26 @@ function buildUserPrompt4({
   languageName
 }) {
   const contextSections = [createToneSection(TONE_INSTRUCTIONS[tone])];
-  if (languageName) {
-    contextSections.push(createLanguageSection(languageName));
-  }
-  if (transcriptText) {
-    const format = isCleanTranscript ? "plain text" : "WebVTT";
-    contextSections.push(createTranscriptSection(transcriptText, format));
-  }
-  const constraints = { titleLength, descriptionLength, tagCount };
-  const promptBuilder = isAudioOnly ? createAudioOnlyBuilder(constraints) : createSummarizationBuilder(constraints);
-  return promptBuilder.buildWithContext(promptOverrides, contextSections);
-}
-async function analyzeStoryboard2(imageDataUrl, provider, modelId, userPrompt, systemPrompt, credentials) {
-  "use step";
-  const model = await createLanguageModelFromConfig(provider, modelId, credentials);
-  const response = await generateText4({
-    model,
-    output: SUMMARY_OUTPUT,
-    messages: [
-      {
-        role: "system",
-        content: systemPrompt
-      },
-      {
-        role: "user",
-        content: [
-          { type: "text", text: userPrompt },
-          { type: "image", image: imageDataUrl }
-        ]
-      }
-    ]
-  });
-  if (!response.output) {
-    throw new Error("Summarization output missing");
+  if (languageName) {
+    contextSections.push(createLanguageSection(languageName));
+  } else {
+    contextSections.push({
+      tag: "language",
+      content: "Respond in English. Never switch languages to satisfy length constraints."
+    });
   }
-  const parsed = summarySchema.parse(response.output);
-  return {
-    result: parsed,
-    usage: {
-      inputTokens: response.usage.inputTokens,
-      outputTokens: response.usage.outputTokens,
-      totalTokens: response.usage.totalTokens,
-      reasoningTokens: response.usage.reasoningTokens,
-      cachedInputTokens: response.usage.cachedInputTokens
-    }
-  };
+  if (transcriptText) {
+    const format = isCleanTranscript ? "plain text" : "WebVTT";
+    contextSections.push(createTranscriptSection(transcriptText, format));
+  }
+  const constraints = { titleLength, descriptionLength, tagCount };
+  const promptBuilder = isAudioOnly ? createAudioOnlyBuilder(constraints) : createSummarizationBuilder(constraints);
+  return promptBuilder.buildWithContext(promptOverrides, contextSections);
 }
-async function analyzeAudioOnly(provider, modelId, userPrompt, systemPrompt, credentials) {
+async function analyzeStoryboard2(imageDataUrl, provider, modelId, userPrompt, systemPrompt, credentials) {
   "use step";
   const model = await createLanguageModelFromConfig(provider, modelId, credentials);
-  const response = await generateText4({
+  const response = await generateText5({
     model,
     output: SUMMARY_OUTPUT,
     messages: [
@@ -3077,430 +4037,211 @@ async function analyzeAudioOnly(provider, modelId, userPrompt, systemPrompt, cre
       },
       {
         role: "user",
-        content: userPrompt
-      }
-    ]
-  });
-  if (!response.output) {
-    throw new Error("Summarization output missing");
-  }
-  const parsed = summarySchema.parse(response.output);
-  return {
-    result: parsed,
-    usage: {
-      inputTokens: response.usage.inputTokens,
-      outputTokens: response.usage.outputTokens,
-      totalTokens: response.usage.totalTokens,
-      reasoningTokens: response.usage.reasoningTokens,
-      cachedInputTokens: response.usage.cachedInputTokens
-    }
-  };
-}
-function normalizeKeywords(keywords, limit = SUMMARY_KEYWORD_LIMIT) {
-  if (!Array.isArray(keywords) || keywords.length === 0) {
-    return [];
-  }
-  const uniqueLowercase = /* @__PURE__ */ new Set();
-  const normalized = [];
-  for (const keyword of keywords) {
-    const trimmed = keyword?.trim();
-    if (!trimmed) {
-      continue;
-    }
-    const lower = trimmed.toLowerCase();
-    if (uniqueLowercase.has(lower)) {
-      continue;
-    }
-    uniqueLowercase.add(lower);
-    normalized.push(trimmed);
-    if (normalized.length === limit) {
-      break;
-    }
-  }
-  return normalized;
-}
-async function getSummaryAndTags(assetId, options) {
-  "use workflow";
-  const {
-    provider = "openai",
-    model,
-    tone = "neutral",
-    includeTranscript = true,
-    cleanTranscript = true,
-    imageSubmissionMode = "url",
-    imageDownloadOptions,
-    promptOverrides,
-    credentials,
-    titleLength,
-    descriptionLength,
-    tagCount,
-    outputLanguageCode
-  } = options ?? {};
-  if (!VALID_TONES.includes(tone)) {
-    throw new Error(
-      `Invalid tone "${tone}". Valid tones are: ${VALID_TONES.join(", ")}`
-    );
-  }
-  const modelConfig = resolveLanguageModelConfig({
-    ...options,
-    model,
-    provider
-  });
-  const workflowCredentials = credentials;
-  const { asset: assetData, playbackId, policy } = await getPlaybackIdForAsset(assetId, workflowCredentials);
-  const assetDurationSeconds = getAssetDurationSecondsFromAsset(assetData);
-  const isAudioOnly = isAudioOnlyAsset(assetData);
-  if (isAudioOnly && !includeTranscript) {
-    throw new Error(
-      "Audio-only assets require a transcript. Set includeTranscript: true and ensure the asset has a ready text track (captions/subtitles)."
-    );
-  }
-  const signingContext = await resolveMuxSigningContext(workflowCredentials);
-  if (policy === "signed" && !signingContext) {
-    throw new Error(
-      "Signed playback ID requires signing credentials. Set MUX_SIGNING_KEY and MUX_PRIVATE_KEY environment variables."
-    );
-  }
-  const transcriptResult = includeTranscript ? await fetchTranscriptForAsset(assetData, playbackId, {
-    cleanTranscript,
-    shouldSign: policy === "signed",
-    credentials: workflowCredentials,
-    required: isAudioOnly
-  }) : void 0;
-  const transcriptText = transcriptResult?.transcriptText ?? "";
-  const resolvedLanguageCode = outputLanguageCode && outputLanguageCode !== "auto" ? outputLanguageCode : transcriptResult?.track?.language_code ?? getReadyTextTracks(assetData)[0]?.language_code;
-  const languageName = resolvedLanguageCode ? getLanguageName(resolvedLanguageCode) : void 0;
-  const userPrompt = buildUserPrompt4({
-    tone,
-    transcriptText,
-    isCleanTranscript: cleanTranscript,
-    promptOverrides,
-    isAudioOnly,
-    titleLength,
-    descriptionLength,
-    tagCount,
-    languageName
-  });
-  let analysisResponse;
-  let imageUrl;
-  const systemPrompt = isAudioOnly ? AUDIO_ONLY_SYSTEM_PROMPT : SYSTEM_PROMPT3;
-  try {
-    if (isAudioOnly) {
-      analysisResponse = await analyzeAudioOnly(
-        modelConfig.provider,
-        modelConfig.modelId,
-        userPrompt,
-        systemPrompt,
-        workflowCredentials
-      );
-    } else {
-      const storyboardUrl = await getStoryboardUrl(playbackId, 640, policy === "signed", workflowCredentials);
-      imageUrl = storyboardUrl;
-      if (imageSubmissionMode === "base64") {
-        const downloadResult = await downloadImageAsBase64(storyboardUrl, imageDownloadOptions);
-        analysisResponse = await analyzeStoryboard2(
-          downloadResult.base64Data,
-          modelConfig.provider,
-          modelConfig.modelId,
-          userPrompt,
-          systemPrompt,
-          workflowCredentials
-        );
-      } else {
-        analysisResponse = await withRetry(() => analyzeStoryboard2(
-          storyboardUrl,
-          modelConfig.provider,
-          modelConfig.modelId,
-          userPrompt,
-          systemPrompt,
-          workflowCredentials
-        ));
-      }
-    }
-  } catch (error) {
-    const contentType = isAudioOnly ? "audio" : "video";
-    throw new Error(
-      `Failed to analyze ${contentType} content with ${provider}: ${error instanceof Error ? error.message : "Unknown error"}`
-    );
-  }
-  if (!analysisResponse.result) {
-    throw new Error(`Failed to analyze video content for asset ${assetId}`);
-  }
-  if (!analysisResponse.result.title) {
-    throw new Error(`Failed to generate title for asset ${assetId}`);
-  }
-  if (!analysisResponse.result.description) {
-    throw new Error(`Failed to generate description for asset ${assetId}`);
-  }
-  return {
-    assetId,
-    title: analysisResponse.result.title,
-    description: analysisResponse.result.description,
-    tags: normalizeKeywords(analysisResponse.result.keywords, tagCount ?? SUMMARY_KEYWORD_LIMIT),
-    storyboardUrl: imageUrl,
-    // undefined for audio-only assets
-    usage: {
-      ...analysisResponse.usage,
-      metadata: {
-        assetDurationSeconds
-      }
-    },
-    transcriptText: transcriptText || void 0
-  };
-}
-
-// src/lib/s3-sigv4.ts
-var AWS4_ALGORITHM = "AWS4-HMAC-SHA256";
-var AWS4_REQUEST_TERMINATOR = "aws4_request";
-var AWS4_SERVICE = "s3";
-var S3_ALLOWED_ENDPOINT_PATTERNS = parseEndpointAllowlist(
-  env_default.S3_ALLOWED_ENDPOINT_HOSTS
-);
-function getCrypto() {
-  const webCrypto = globalThis.crypto;
-  if (!webCrypto?.subtle) {
-    throw new Error("Web Crypto API is required for S3 signing.");
-  }
-  return webCrypto;
-}
-var textEncoder = new TextEncoder();
-function toBytes(value) {
-  return typeof value === "string" ? textEncoder.encode(value) : value;
-}
-function bytesToHex(bytes) {
-  return Array.from(bytes).map((byte) => byte.toString(16).padStart(2, "0")).join("");
-}
-async function sha256Hex(value) {
-  const digest = await getCrypto().subtle.digest("SHA-256", toBytes(value));
-  return bytesToHex(new Uint8Array(digest));
-}
-async function hmacSha256Raw(key, value) {
-  const cryptoKey = await getCrypto().subtle.importKey(
-    "raw",
-    key,
-    { name: "HMAC", hash: "SHA-256" },
-    false,
-    ["sign"]
-  );
-  const signature = await getCrypto().subtle.sign("HMAC", cryptoKey, textEncoder.encode(value));
-  return new Uint8Array(signature);
-}
-async function deriveSigningKey(secretAccessKey, shortDate, region) {
-  const kDate = await hmacSha256Raw(textEncoder.encode(`AWS4${secretAccessKey}`), shortDate);
-  const kRegion = await hmacSha256Raw(kDate, region);
-  const kService = await hmacSha256Raw(kRegion, AWS4_SERVICE);
-  return hmacSha256Raw(kService, AWS4_REQUEST_TERMINATOR);
-}
-function formatAmzDate(date = /* @__PURE__ */ new Date()) {
-  const iso = date.toISOString();
-  const shortDate = iso.slice(0, 10).replace(/-/g, "");
-  const amzDate = `${iso.slice(0, 19).replace(/[-:]/g, "")}Z`;
-  return { amzDate, shortDate };
-}
-function encodeRFC3986(value) {
-  return encodeURIComponent(value).replace(/[!'()*]/g, (char) => `%${char.charCodeAt(0).toString(16).toUpperCase()}`);
-}
-function encodePath(path) {
-  return path.split("/").map((segment) => encodeRFC3986(segment)).join("/");
-}
-function normalizeEndpoint(endpoint) {
-  let url;
-  try {
-    url = new URL(endpoint);
-  } catch {
-    throw new Error(`Invalid S3 endpoint: ${endpoint}`);
+        content: [
+          { type: "text", text: userPrompt },
+          { type: "image", image: imageDataUrl }
+        ]
+      }
+    ]
+  });
+  if (!response.output) {
+    throw new Error("Summarization output missing");
   }
-  if (url.search || url.hash) {
-    throw new Error("S3 endpoint must not include query params or hash fragments.");
+  const parsed = summarySchema.parse(response.output);
+  return {
+    result: parsed,
+    usage: {
+      inputTokens: response.usage.inputTokens,
+      outputTokens: response.usage.outputTokens,
+      totalTokens: response.usage.totalTokens,
+      reasoningTokens: response.usage.reasoningTokens,
+      cachedInputTokens: response.usage.cachedInputTokens
+    }
+  };
+}
+async function analyzeAudioOnly(provider, modelId, userPrompt, systemPrompt, credentials) {
+  "use step";
+  const model = await createLanguageModelFromConfig(provider, modelId, credentials);
+  const response = await generateText5({
+    model,
+    output: SUMMARY_OUTPUT,
+    messages: [
+      {
+        role: "system",
+        content: systemPrompt
+      },
+      {
+        role: "user",
+        content: userPrompt
+      }
+    ]
+  });
+  if (!response.output) {
+    throw new Error("Summarization output missing");
   }
-  enforceEndpointPolicy(url);
-  return url;
+  const parsed = summarySchema.parse(response.output);
+  return {
+    result: parsed,
+    usage: {
+      inputTokens: response.usage.inputTokens,
+      outputTokens: response.usage.outputTokens,
+      totalTokens: response.usage.totalTokens,
+      reasoningTokens: response.usage.reasoningTokens,
+      cachedInputTokens: response.usage.cachedInputTokens
+    }
+  };
 }
-function parseEndpointAllowlist(allowlist) {
-  if (!allowlist) {
+function normalizeKeywords(keywords, limit = DEFAULT_SUMMARY_KEYWORD_LIMIT) {
+  if (!Array.isArray(keywords) || keywords.length === 0) {
     return [];
   }
-  return allowlist.split(",").map((value) => value.trim().toLowerCase()).filter(Boolean);
-}
-function hostnameMatchesPattern(hostname, pattern) {
-  if (pattern.startsWith("*.")) {
-    const suffix = pattern.slice(1);
-    return hostname.endsWith(suffix) && hostname.length > suffix.length;
+  const uniqueLowercase = /* @__PURE__ */ new Set();
+  const normalized = [];
+  for (const keyword of keywords) {
+    const trimmed = keyword?.trim();
+    if (!trimmed) {
+      continue;
+    }
+    const lower = trimmed.toLowerCase();
+    if (uniqueLowercase.has(lower)) {
+      continue;
+    }
+    uniqueLowercase.add(lower);
+    normalized.push(trimmed);
+    if (normalized.length === limit) {
+      break;
+    }
   }
-  return hostname === pattern;
+  return normalized;
 }
-function enforceEndpointPolicy(url) {
-  const hostname = url.hostname.toLowerCase();
-  if (url.protocol !== "https:") {
+async function getSummaryAndTags(assetId, options) {
+  "use workflow";
+  const {
+    provider = "openai",
+    model,
+    tone = "neutral",
+    includeTranscript = true,
+    cleanTranscript = true,
+    imageSubmissionMode = "url",
+    imageDownloadOptions,
+    promptOverrides,
+    credentials,
+    titleLength,
+    descriptionLength,
+    tagCount,
+    outputLanguageCode
+  } = options ?? {};
+  if (!VALID_TONES.includes(tone)) {
     throw new Error(
-      `Insecure S3 endpoint protocol "${url.protocol}" is not allowed. Use HTTPS.`
+      `Invalid tone "${tone}". Valid tones are: ${VALID_TONES.join(", ")}`
     );
   }
-  if (S3_ALLOWED_ENDPOINT_PATTERNS.length > 0 && !S3_ALLOWED_ENDPOINT_PATTERNS.some((pattern) => hostnameMatchesPattern(hostname, pattern))) {
+  const modelConfig = resolveLanguageModelConfig({
+    ...options,
+    model,
+    provider
+  });
+  const workflowCredentials = credentials;
+  const { asset: assetData, playbackId, policy } = await getPlaybackIdForAsset(assetId, workflowCredentials);
+  const assetDurationSeconds = getAssetDurationSecondsFromAsset(assetData);
+  const isAudioOnly = isAudioOnlyAsset(assetData);
+  if (isAudioOnly && !includeTranscript) {
     throw new Error(
-      `S3 endpoint host "${hostname}" is not in S3_ALLOWED_ENDPOINT_HOSTS.`
+      "Audio-only assets require a transcript. Set includeTranscript: true and ensure the asset has a ready text track (captions/subtitles)."
     );
   }
-}
-function buildCanonicalUri(endpoint, bucket, key) {
-  const endpointPath = endpoint.pathname === "/" ? "" : encodePath(endpoint.pathname.replace(/\/+$/, ""));
-  const encodedBucket = encodeRFC3986(bucket);
-  const encodedKey = encodePath(key);
-  return `${endpointPath}/${encodedBucket}/${encodedKey}`;
-}
-function buildCanonicalQuery(params) {
-  return Object.entries(params).sort(([a], [b]) => a.localeCompare(b)).map(([key, value]) => `${encodeRFC3986(key)}=${encodeRFC3986(value)}`).join("&");
-}
-async function signString(secretAccessKey, shortDate, region, value) {
-  const signingKey = await deriveSigningKey(secretAccessKey, shortDate, region);
-  const signatureBytes = await hmacSha256Raw(signingKey, value);
-  return bytesToHex(signatureBytes);
-}
-function buildCredentialScope(shortDate, region) {
-  return `${shortDate}/${region}/${AWS4_SERVICE}/${AWS4_REQUEST_TERMINATOR}`;
-}
-async function putObjectToS3({
-  accessKeyId,
-  secretAccessKey,
-  endpoint,
-  region,
-  bucket,
-  key,
-  body,
-  contentType
-}) {
-  const resolvedEndpoint = normalizeEndpoint(endpoint);
-  const canonicalUri = buildCanonicalUri(resolvedEndpoint, bucket, key);
-  const host = resolvedEndpoint.host;
-  const normalizedContentType = contentType?.trim();
-  const { amzDate, shortDate } = formatAmzDate();
-  const payloadHash = await sha256Hex(body);
-  const signingHeaders = [
-    ["host", host],
-    ["x-amz-content-sha256", payloadHash],
-    ["x-amz-date", amzDate],
-    ...normalizedContentType ? [["content-type", normalizedContentType]] : []
-  ].sort(([a], [b]) => a.localeCompare(b));
-  const canonicalHeaders = signingHeaders.map(([name, value]) => `${name}:${value}`).join("\n");
-  const signedHeaders = signingHeaders.map(([name]) => name).join(";");
-  const canonicalRequest = [
-    "PUT",
-    canonicalUri,
-    "",
-    `${canonicalHeaders}
-`,
-    signedHeaders,
-    payloadHash
-  ].join("\n");
-  const credentialScope = buildCredentialScope(shortDate, region);
-  const stringToSign = [
-    AWS4_ALGORITHM,
-    amzDate,
-    credentialScope,
-    await sha256Hex(canonicalRequest)
-  ].join("\n");
-  const signature = await signString(secretAccessKey, shortDate, region, stringToSign);
-  const authorization = `${AWS4_ALGORITHM} Credential=${accessKeyId}/${credentialScope}, SignedHeaders=${signedHeaders}, Signature=${signature}`;
-  const requestUrl = `${resolvedEndpoint.origin}${canonicalUri}`;
-  const response = await fetch(requestUrl, {
-    method: "PUT",
-    headers: {
-      "Authorization": authorization,
-      "x-amz-content-sha256": payloadHash,
-      "x-amz-date": amzDate,
-      ...normalizedContentType ? { "content-type": normalizedContentType } : {}
-    },
-    body
-  });
-  if (!response.ok) {
-    const errorBody = await response.text().catch(() => "");
-    const detail = errorBody ? ` ${errorBody}` : "";
-    throw new Error(`S3 PUT failed (${response.status} ${response.statusText}).${detail}`);
+  const signingContext = await resolveMuxSigningContext(workflowCredentials);
+  if (policy === "signed" && !signingContext) {
+    throw new Error(
+      "Signed playback ID requires signing credentials. Set MUX_SIGNING_KEY and MUX_PRIVATE_KEY environment variables."
+    );
   }
-}
-async function createPresignedGetUrl({
-  accessKeyId,
-  secretAccessKey,
-  endpoint,
-  region,
-  bucket,
-  key,
-  expiresInSeconds = 3600
-}) {
-  const resolvedEndpoint = normalizeEndpoint(endpoint);
-  const canonicalUri = buildCanonicalUri(resolvedEndpoint, bucket, key);
-  const host = resolvedEndpoint.host;
-  const { amzDate, shortDate } = formatAmzDate();
-  const credentialScope = buildCredentialScope(shortDate, region);
-  const signedHeaders = "host";
-  const queryParams = {
-    "X-Amz-Algorithm": AWS4_ALGORITHM,
-    "X-Amz-Credential": `${accessKeyId}/${credentialScope}`,
-    "X-Amz-Date": amzDate,
-    "X-Amz-Expires": `${expiresInSeconds}`,
-    "X-Amz-SignedHeaders": signedHeaders
-  };
-  const canonicalQuery = buildCanonicalQuery(queryParams);
-  const canonicalRequest = [
-    "GET",
-    canonicalUri,
-    canonicalQuery,
-    `host:${host}
-`,
-    signedHeaders,
-    "UNSIGNED-PAYLOAD"
-  ].join("\n");
-  const stringToSign = [
-    AWS4_ALGORITHM,
-    amzDate,
-    credentialScope,
-    await sha256Hex(canonicalRequest)
-  ].join("\n");
-  const signature = await signString(secretAccessKey, shortDate, region, stringToSign);
-  const queryWithSignature = `${canonicalQuery}&X-Amz-Signature=${signature}`;
-  return `${resolvedEndpoint.origin}${canonicalUri}?${queryWithSignature}`;
-}
-
-// src/lib/storage-adapter.ts
-function requireCredentials(accessKeyId, secretAccessKey) {
-  if (!accessKeyId || !secretAccessKey) {
+  const transcriptResult = includeTranscript ? await fetchTranscriptForAsset(assetData, playbackId, {
+    cleanTranscript,
+    shouldSign: policy === "signed",
+    credentials: workflowCredentials,
+    required: isAudioOnly
+  }) : void 0;
+  const transcriptText = transcriptResult?.transcriptText ?? "";
+  const resolvedLanguageCode = outputLanguageCode && outputLanguageCode !== "auto" ? outputLanguageCode : transcriptResult?.track?.language_code ?? getReadyTextTracks(assetData)[0]?.language_code;
+  const languageName = resolvedLanguageCode ? getLanguageName(resolvedLanguageCode) : void 0;
+  const userPrompt = buildUserPrompt4({
+    tone,
+    transcriptText,
+    isCleanTranscript: cleanTranscript,
+    promptOverrides,
+    isAudioOnly,
+    titleLength,
+    descriptionLength,
+    tagCount,
+    languageName
+  });
+  let analysisResponse;
+  let imageUrl;
+  const systemPrompt = isAudioOnly ? AUDIO_ONLY_SYSTEM_PROMPT : SYSTEM_PROMPT4;
+  try {
+    if (isAudioOnly) {
+      analysisResponse = await analyzeAudioOnly(
+        modelConfig.provider,
+        modelConfig.modelId,
+        userPrompt,
+        systemPrompt,
+        workflowCredentials
+      );
+    } else {
+      const storyboardUrl = await getStoryboardUrl(playbackId, 640, policy === "signed", workflowCredentials);
+      imageUrl = storyboardUrl;
+      if (imageSubmissionMode === "base64") {
+        const downloadResult = await downloadImageAsBase64(storyboardUrl, imageDownloadOptions);
+        analysisResponse = await analyzeStoryboard2(
+          downloadResult.base64Data,
+          modelConfig.provider,
+          modelConfig.modelId,
+          userPrompt,
+          systemPrompt,
+          workflowCredentials
+        );
+      } else {
+        analysisResponse = await withRetry(() => analyzeStoryboard2(
+          storyboardUrl,
+          modelConfig.provider,
+          modelConfig.modelId,
+          userPrompt,
+          systemPrompt,
+          workflowCredentials
+        ));
+      }
+    }
+  } catch (error) {
+    const contentType = isAudioOnly ? "audio" : "video";
     throw new Error(
-      "S3 credentials are required for default storage operations. Provide S3_ACCESS_KEY_ID and S3_SECRET_ACCESS_KEY or pass options.storageAdapter."
+      `Failed to analyze ${contentType} content with ${provider}: ${error instanceof Error ? error.message : "Unknown error"}`
     );
   }
-  return { accessKeyId, secretAccessKey };
-}
-async function putObjectWithStorageAdapter(input, adapter) {
-  if (adapter) {
-    await adapter.putObject(input);
-    return;
+  if (!analysisResponse.result) {
+    throw new Error(`Failed to analyze video content for asset ${assetId}`);
   }
-  const credentials = requireCredentials(input.accessKeyId, input.secretAccessKey);
-  await putObjectToS3({
-    accessKeyId: credentials.accessKeyId,
-    secretAccessKey: credentials.secretAccessKey,
-    endpoint: input.endpoint,
-    region: input.region,
-    bucket: input.bucket,
-    key: input.key,
-    body: input.body,
-    contentType: input.contentType
-  });
-}
-async function createPresignedGetUrlWithStorageAdapter(input, adapter) {
-  if (adapter) {
-    return adapter.createPresignedGetUrl(input);
+  if (!analysisResponse.result.title) {
+    throw new Error(`Failed to generate title for asset ${assetId}`);
   }
-  const credentials = requireCredentials(input.accessKeyId, input.secretAccessKey);
-  return createPresignedGetUrl({
-    accessKeyId: credentials.accessKeyId,
-    secretAccessKey: credentials.secretAccessKey,
-    endpoint: input.endpoint,
-    region: input.region,
-    bucket: input.bucket,
-    key: input.key,
-    expiresInSeconds: input.expiresInSeconds
-  });
+  if (!analysisResponse.result.description) {
+    throw new Error(`Failed to generate description for asset ${assetId}`);
+  }
+  return {
+    assetId,
+    title: analysisResponse.result.title,
+    description: analysisResponse.result.description,
+    tags: normalizeKeywords(analysisResponse.result.keywords, tagCount ?? DEFAULT_SUMMARY_KEYWORD_LIMIT),
+    storyboardUrl: imageUrl,
+    // undefined for audio-only assets
+    usage: {
+      ...analysisResponse.usage,
+      metadata: {
+        assetDurationSeconds
+      }
+    },
+    transcriptText: transcriptText || void 0
+  };
 }
 
 // src/workflows/translate-audio.ts
@@ -3679,7 +4420,8 @@ async function uploadDubbedAudioToS3({
   s3Endpoint,
   s3Region,
   s3Bucket,
-  storageAdapter
+  storageAdapter,
+  s3SignedUrlExpirySeconds
 }) {
   "use step";
   const s3AccessKeyId = env_default.S3_ACCESS_KEY_ID;
@@ -3702,10 +4444,11 @@ async function uploadDubbedAudioToS3({
     region: s3Region,
     bucket: s3Bucket,
     key: audioKey,
-    expiresInSeconds: 3600
+    expiresInSeconds: s3SignedUrlExpirySeconds ?? 86400
   }, storageAdapter);
+  const expiryHours = Math.round((s3SignedUrlExpirySeconds ?? 86400) / 3600);
   console.warn(`\u2705 Audio uploaded successfully to: ${audioKey}`);
-  console.warn(`\u{1F517} Generated presigned URL (expires in 1 hour)`);
+  console.warn(`\u{1F517} Generated presigned URL (expires in ${expiryHours} hour${expiryHours === 1 ? "" : "s"})`);
   return presignedUrl;
 }
 async function createAudioTrackOnMux(assetId, languageCode, presignedUrl, credentials) {
@@ -3869,7 +4612,8 @@ async function translateAudio(assetId, toLanguageCode, options = {}) {
       s3Endpoint,
       s3Region,
       s3Bucket,
-      storageAdapter: effectiveStorageAdapter
+      storageAdapter: effectiveStorageAdapter,
+      s3SignedUrlExpirySeconds: options.s3SignedUrlExpirySeconds
     });
   } catch (error) {
     throw new Error(`Failed to upload audio to S3: ${error instanceof Error ? error.message : "Unknown error"}`);
@@ -3905,19 +4649,186 @@ async function translateAudio(assetId, toLanguageCode, options = {}) {
 }
 
 // src/workflows/translate-captions.ts
-import { generateText as generateText5, Output as Output5 } from "ai";
-import { z as z6 } from "zod";
-var translationSchema = z6.object({
-  translation: z6.string()
+import {
+  APICallError,
+  generateText as generateText6,
+  NoObjectGeneratedError,
+  Output as Output6,
+  RetryError,
+  TypeValidationError
+} from "ai";
+import dedent6 from "dedent";
+import { z as z7 } from "zod";
+var translationSchema = z7.object({
+  translation: z7.string()
 });
-var SYSTEM_PROMPT4 = 'You are a subtitle translation expert. Translate VTT subtitle files to the target language specified by the user. Preserve all timestamps and VTT formatting exactly as they appear. Return JSON with a single key "translation" containing the translated VTT content.';
-async function fetchVttFromMux(vttUrl) {
-  "use step";
-  const vttResponse = await fetch(vttUrl);
-  if (!vttResponse.ok) {
-    throw new Error(`Failed to fetch VTT file: ${vttResponse.statusText}`);
+var SYSTEM_PROMPT5 = dedent6`
+  You are a subtitle translation expert. Translate VTT subtitle files to the target language specified by the user.
+  You may receive either a full VTT file or a chunk from a larger VTT.
+  Preserve all timestamps, cue ordering, and VTT formatting exactly as they appear.
+  Return JSON with a single key "translation" containing the translated VTT content.
+`;
+var CUE_TRANSLATION_SYSTEM_PROMPT = dedent6`
+  You are a subtitle translation expert.
+  You will receive a sequence of subtitle cues extracted from a VTT file.
+  Translate the cues to the requested target language while preserving their original order.
+  Treat the cue list as continuous context so the translation reads naturally across adjacent lines.
+  Return JSON with a single key "translations" containing exactly one translated string for each input cue.
+  Do not merge, split, omit, reorder, or add cues.
+`;
+var DEFAULT_TRANSLATION_CHUNKING = {
+  enabled: true,
+  minimumAssetDurationSeconds: 30 * 60,
+  targetChunkDurationSeconds: 30 * 60,
+  maxConcurrentTranslations: 4,
+  maxCuesPerChunk: 80,
+  maxCueTextTokensPerChunk: 2e3
+};
+var TOKEN_USAGE_FIELDS = [
+  "inputTokens",
+  "outputTokens",
+  "totalTokens",
+  "reasoningTokens",
+  "cachedInputTokens"
+];
+var TranslationChunkValidationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "TranslationChunkValidationError";
   }
-  return vttResponse.text();
+};
+function isTranslationChunkValidationError(error) {
+  return error instanceof TranslationChunkValidationError;
+}
+function isProviderServiceError(error) {
+  if (!error) {
+    return false;
+  }
+  if (RetryError.isInstance(error)) {
+    return isProviderServiceError(error.lastError);
+  }
+  if (APICallError.isInstance(error)) {
+    return true;
+  }
+  if (error instanceof Error && "cause" in error) {
+    return isProviderServiceError(error.cause);
+  }
+  return false;
+}
+function shouldSplitChunkTranslationError(error) {
+  if (isProviderServiceError(error)) {
+    return false;
+  }
+  return NoObjectGeneratedError.isInstance(error) || TypeValidationError.isInstance(error) || isTranslationChunkValidationError(error);
+}
+function isDefinedTokenUsageValue(value) {
+  return typeof value === "number";
+}
+function resolveTranslationChunkingOptions(options) {
+  const targetChunkDurationSeconds = Math.max(
+    1,
+    options?.targetChunkDurationSeconds ?? DEFAULT_TRANSLATION_CHUNKING.targetChunkDurationSeconds
+  );
+  return {
+    enabled: options?.enabled ?? DEFAULT_TRANSLATION_CHUNKING.enabled,
+    minimumAssetDurationSeconds: Math.max(
+      1,
+      options?.minimumAssetDurationSeconds ?? DEFAULT_TRANSLATION_CHUNKING.minimumAssetDurationSeconds
+    ),
+    targetChunkDurationSeconds,
+    maxConcurrentTranslations: Math.max(
+      1,
+      options?.maxConcurrentTranslations ?? DEFAULT_TRANSLATION_CHUNKING.maxConcurrentTranslations
+    ),
+    maxCuesPerChunk: Math.max(
+      1,
+      options?.maxCuesPerChunk ?? DEFAULT_TRANSLATION_CHUNKING.maxCuesPerChunk
+    ),
+    maxCueTextTokensPerChunk: Math.max(
+      1,
+      options?.maxCueTextTokensPerChunk ?? DEFAULT_TRANSLATION_CHUNKING.maxCueTextTokensPerChunk
+    )
+  };
+}
+function aggregateTokenUsage(usages) {
+  return TOKEN_USAGE_FIELDS.reduce((aggregate, field) => {
+    const values = usages.map((usage) => usage[field]).filter(isDefinedTokenUsageValue);
+    if (values.length > 0) {
+      aggregate[field] = values.reduce((total, value) => total + value, 0);
+    }
+    return aggregate;
+  }, {});
+}
+function createTranslationChunkRequest(id, cues, cueBlocks) {
+  return {
+    id,
+    cueCount: cues.length,
+    startTime: cues[0].startTime,
+    endTime: cues[cues.length - 1].endTime,
+    cues,
+    cueBlocks
+  };
+}
+function splitTranslationChunkRequestByBudget(id, cues, cueBlocks, maxCuesPerChunk, maxCueTextTokensPerChunk) {
+  const chunks = chunkVTTCuesByBudget(cues, {
+    maxCuesPerChunk,
+    maxTextTokensPerChunk: maxCueTextTokensPerChunk
+  });
+  return chunks.map(
+    (chunk, index) => createTranslationChunkRequest(
+      chunks.length === 1 ? id : `${id}-part-${index}`,
+      cues.slice(chunk.cueStartIndex, chunk.cueEndIndex + 1),
+      cueBlocks.slice(chunk.cueStartIndex, chunk.cueEndIndex + 1)
+    )
+  );
+}
+function buildTranslationChunkRequests(vttContent, assetDurationSeconds, chunkingOptions) {
+  const resolvedChunking = resolveTranslationChunkingOptions(chunkingOptions);
+  const cues = parseVTTCues(vttContent);
+  if (cues.length === 0) {
+    return null;
+  }
+  const { preamble, cueBlocks } = splitVttPreambleAndCueBlocks(vttContent);
+  if (cueBlocks.length !== cues.length) {
+    console.warn(
+      `Falling back to full-VTT caption translation because cue block count (${cueBlocks.length}) does not match parsed cue count (${cues.length}).`
+    );
+    return null;
+  }
+  if (!resolvedChunking.enabled) {
+    return {
+      preamble,
+      chunks: [
+        createTranslationChunkRequest("chunk-0", cues, cueBlocks)
+      ]
+    };
+  }
+  if (typeof assetDurationSeconds !== "number" || assetDurationSeconds < resolvedChunking.minimumAssetDurationSeconds) {
+    return {
+      preamble,
+      chunks: [
+        createTranslationChunkRequest("chunk-0", cues, cueBlocks)
+      ]
+    };
+  }
+  const targetChunkDurationSeconds = resolvedChunking.targetChunkDurationSeconds;
+  const durationChunks = chunkVTTCuesByDuration(cues, {
+    targetChunkDurationSeconds,
+    maxChunkDurationSeconds: Math.max(targetChunkDurationSeconds, Math.round(targetChunkDurationSeconds * (7 / 6))),
+    minChunkDurationSeconds: Math.max(1, Math.round(targetChunkDurationSeconds * (2 / 3)))
+  });
+  return {
+    preamble,
+    chunks: durationChunks.flatMap(
+      (chunk) => splitTranslationChunkRequestByBudget(
+        chunk.id,
+        cues.slice(chunk.cueStartIndex, chunk.cueEndIndex + 1),
+        cueBlocks.slice(chunk.cueStartIndex, chunk.cueEndIndex + 1),
+        resolvedChunking.maxCuesPerChunk,
+        resolvedChunking.maxCueTextTokensPerChunk
+      )
+    )
+  };
 }
 async function translateVttWithAI({
   vttContent,
@@ -3929,13 +4840,13 @@ async function translateVttWithAI({
 }) {
   "use step";
   const model = await createLanguageModelFromConfig(provider, modelId, credentials);
-  const response = await generateText5({
+  const response = await generateText6({
     model,
-    output: Output5.object({ schema: translationSchema }),
+    output: Output6.object({ schema: translationSchema }),
     messages: [
       {
         role: "system",
-        content: SYSTEM_PROMPT4
+        content: SYSTEM_PROMPT5
       },
       {
         role: "user",
@@ -3956,6 +4867,176 @@ ${vttContent}`
     }
   };
 }
+async function translateCueChunkWithAI({
+  cues,
+  fromLanguageCode,
+  toLanguageCode,
+  provider,
+  modelId,
+  credentials
+}) {
+  "use step";
+  const model = await createLanguageModelFromConfig(provider, modelId, credentials);
+  const schema = z7.object({
+    translations: z7.array(z7.string().min(1)).length(cues.length)
+  });
+  const cuePayload = cues.map((cue, index) => ({
+    index,
+    startTime: cue.startTime,
+    endTime: cue.endTime,
+    text: cue.text
+  }));
+  const response = await generateText6({
+    model,
+    output: Output6.object({ schema }),
+    messages: [
+      {
+        role: "system",
+        content: CUE_TRANSLATION_SYSTEM_PROMPT
+      },
+      {
+        role: "user",
+        content: `Translate from ${fromLanguageCode} to ${toLanguageCode}.
+Return exactly ${cues.length} translated cues in the same order as the input.
+
+${JSON.stringify(cuePayload, null, 2)}`
+      }
+    ]
+  });
+  return {
+    translations: response.output.translations,
+    usage: {
+      inputTokens: response.usage.inputTokens,
+      outputTokens: response.usage.outputTokens,
+      totalTokens: response.usage.totalTokens,
+      reasoningTokens: response.usage.reasoningTokens,
+      cachedInputTokens: response.usage.cachedInputTokens
+    }
+  };
+}
+function splitTranslationChunkAtMidpoint(chunk) {
+  const midpoint = Math.floor(chunk.cueCount / 2);
+  if (midpoint <= 0 || midpoint >= chunk.cueCount) {
+    throw new Error(`Cannot split chunk ${chunk.id} with cueCount=${chunk.cueCount}`);
+  }
+  return [
+    createTranslationChunkRequest(
+      `${chunk.id}-a`,
+      chunk.cues.slice(0, midpoint),
+      chunk.cueBlocks.slice(0, midpoint)
+    ),
+    createTranslationChunkRequest(
+      `${chunk.id}-b`,
+      chunk.cues.slice(midpoint),
+      chunk.cueBlocks.slice(midpoint)
+    )
+  ];
+}
+async function translateChunkWithFallback({
+  chunk,
+  fromLanguageCode,
+  toLanguageCode,
+  provider,
+  modelId,
+  credentials
+}) {
+  "use step";
+  try {
+    const result = await translateCueChunkWithAI({
+      cues: chunk.cues,
+      fromLanguageCode,
+      toLanguageCode,
+      provider,
+      modelId,
+      credentials
+    });
+    if (result.translations.length !== chunk.cueCount) {
+      throw new TranslationChunkValidationError(
+        `Chunk ${chunk.id} returned ${result.translations.length} cues, expected ${chunk.cueCount} for ${Math.round(chunk.startTime)}s-${Math.round(chunk.endTime)}s`
+      );
+    }
+    return {
+      translatedVtt: buildVttFromTranslatedCueBlocks(chunk.cueBlocks, result.translations),
+      usage: result.usage
+    };
+  } catch (error) {
+    if (!shouldSplitChunkTranslationError(error) || chunk.cueCount <= 1) {
+      throw new Error(
+        `Chunk ${chunk.id} failed for ${Math.round(chunk.startTime)}s-${Math.round(chunk.endTime)}s: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+    const [leftChunk, rightChunk] = splitTranslationChunkAtMidpoint(chunk);
+    const [leftResult, rightResult] = await Promise.all([
+      translateChunkWithFallback({
+        chunk: leftChunk,
+        fromLanguageCode,
+        toLanguageCode,
+        provider,
+        modelId,
+        credentials
+      }),
+      translateChunkWithFallback({
+        chunk: rightChunk,
+        fromLanguageCode,
+        toLanguageCode,
+        provider,
+        modelId,
+        credentials
+      })
+    ]);
+    return {
+      translatedVtt: concatenateVttSegments([leftResult.translatedVtt, rightResult.translatedVtt]),
+      usage: aggregateTokenUsage([leftResult.usage, rightResult.usage])
+    };
+  }
+}
+async function translateCaptionTrack({
+  vttContent,
+  assetDurationSeconds,
+  fromLanguageCode,
+  toLanguageCode,
+  provider,
+  modelId,
+  credentials,
+  chunking
+}) {
+  "use step";
+  const chunkPlan = buildTranslationChunkRequests(vttContent, assetDurationSeconds, chunking);
+  if (!chunkPlan) {
+    return translateVttWithAI({
+      vttContent,
+      fromLanguageCode,
+      toLanguageCode,
+      provider,
+      modelId,
+      credentials
+    });
+  }
+  const resolvedChunking = resolveTranslationChunkingOptions(chunking);
+  const translatedSegments = [];
+  const usageByChunk = [];
+  for (let index = 0; index < chunkPlan.chunks.length; index += resolvedChunking.maxConcurrentTranslations) {
+    const batch = chunkPlan.chunks.slice(index, index + resolvedChunking.maxConcurrentTranslations);
+    const batchResults = await Promise.all(
+      batch.map(
+        (chunk) => translateChunkWithFallback({
+          chunk,
+          fromLanguageCode,
+          toLanguageCode,
+          provider,
+          modelId,
+          credentials
+        })
+      )
+    );
+    translatedSegments.push(...batchResults.map((result) => result.translatedVtt));
+    usageByChunk.push(...batchResults.map((result) => result.usage));
+  }
+  return {
+    translatedVtt: concatenateVttSegments(translatedSegments, chunkPlan.preamble),
+    usage: aggregateTokenUsage(usageByChunk)
+  };
+}
 async function uploadVttToS3({
   translatedVtt,
   assetId,
@@ -3964,7 +5045,8 @@ async function uploadVttToS3({
   s3Endpoint,
   s3Region,
   s3Bucket,
-  storageAdapter
+  storageAdapter,
+  s3SignedUrlExpirySeconds
 }) {
   "use step";
   const s3AccessKeyId = env_default.S3_ACCESS_KEY_ID;
@@ -3987,25 +5069,9 @@ async function uploadVttToS3({
     region: s3Region,
     bucket: s3Bucket,
     key: vttKey,
-    expiresInSeconds: 3600
+    expiresInSeconds: s3SignedUrlExpirySeconds ?? 86400
   }, storageAdapter);
 }
-async function createTextTrackOnMux(assetId, languageCode, trackName, presignedUrl, credentials) {
-  "use step";
-  const muxClient = await resolveMuxClient(credentials);
-  const mux = await muxClient.createClient();
-  const trackResponse = await mux.video.assets.createTrack(assetId, {
-    type: "text",
-    text_type: "subtitles",
-    language_code: languageCode,
-    name: trackName,
-    url: presignedUrl
-  });
-  if (!trackResponse.id) {
-    throw new Error("Failed to create text track: no track ID returned from Mux");
-  }
-  return trackResponse.id;
-}
 async function translateCaptions(assetId, fromLanguageCode, toLanguageCode, options) {
   "use workflow";
   const {
@@ -4016,7 +5082,8 @@ async function translateCaptions(assetId, fromLanguageCode, toLanguageCode, opti
     s3Bucket: providedS3Bucket,
     uploadToMux: uploadToMuxOption,
     storageAdapter,
-    credentials: providedCredentials
+    credentials: providedCredentials,
+    chunking
   } = options;
   const credentials = providedCredentials;
   const effectiveStorageAdapter = storageAdapter;
@@ -4077,13 +5144,15 @@ async function translateCaptions(assetId, fromLanguageCode, toLanguageCode, opti
   let translatedVtt;
   let usage;
   try {
-    const result = await translateVttWithAI({
+    const result = await translateCaptionTrack({
       vttContent,
+      assetDurationSeconds,
       fromLanguageCode,
       toLanguageCode,
       provider: modelConfig.provider,
       modelId: modelConfig.modelId,
-      credentials
+      credentials,
+      chunking
     });
     translatedVtt = result.translatedVtt;
     usage = result.usage;
@@ -4120,7 +5189,8 @@ async function translateCaptions(assetId, fromLanguageCode, toLanguageCode, opti
       s3Endpoint,
       s3Region,
       s3Bucket,
-      storageAdapter: effectiveStorageAdapter
+      storageAdapter: effectiveStorageAdapter,
+      s3SignedUrlExpirySeconds: options.s3SignedUrlExpirySeconds
     });
   } catch (error) {
     throw new Error(`Failed to upload VTT to S3: ${error instanceof Error ? error.message : "Unknown error"}`);
@@ -4153,21 +5223,33 @@ async function translateCaptions(assetId, fromLanguageCode, toLanguageCode, opti
   };
 }
 export {
+  DEFAULT_DESCRIPTION_LENGTH,
+  DEFAULT_SUMMARY_KEYWORD_LIMIT,
+  DEFAULT_TITLE_LENGTH,
   HIVE_SEXUAL_CATEGORIES,
   HIVE_VIOLENCE_CATEGORIES,
-  SUMMARY_KEYWORD_LIMIT,
+  aggregateTokenUsage,
+  applyOverrideLists,
+  applyReplacements,
   askQuestions,
+  buildReplacementRegex,
   burnedInCaptionsSchema,
+  censorVttContent,
   chapterSchema,
   chaptersSchema,
+  createReplacer,
+  editCaptions,
   generateChapters,
   generateEmbeddings,
   generateVideoEmbeddings,
   getModerationScores,
   getSummaryAndTags,
   hasBurnedInCaptions,
+  profanityDetectionSchema,
   questionAnswerSchema,
+  shouldSplitChunkTranslationError,
   summarySchema,
+  transformCueText,
   translateAudio,
   translateCaptions,
   translationSchema