@mux/ai 0.10.0 → 0.11.0

package/dist/workflows/index.js

@@ -2176,1654 +2176,2072 @@ 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
-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);
+// 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;
-  }
-  if (currentCues.length > 0) {
-    chunks.push(createChunkFromCues(currentCues, chunkIndex));
-  }
-  return chunks;
+function bytesToHex(bytes) {
+  return Array.from(bytes).map((byte) => byte.toString(16).padStart(2, "0")).join("");
 }
-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;
+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 (NEXT_SENTENCE_START_REGEX.test(nextCue.text.trim())) {
-    score += 1;
+  if (url.search || url.hash) {
+    throw new Error("S3 endpoint must not include query params or hash fragments.");
   }
-  return score;
+  enforceEndpointPolicy(url);
+  return url;
 }
-function chunkVTTCuesByBudget(cues, options) {
-  if (cues.length === 0) {
+function parseEndpointAllowlist(allowlist) {
+  if (!allowlist) {
     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;
+  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;
   }
-  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;
+  return hostname === pattern;
 }
-function chunkVTTCuesByDuration(cues, options) {
-  if (cues.length === 0) {
-    return [];
+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.`
+    );
   }
-  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++;
+  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 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}`);
-    }
-  }
+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}`;
 }
-
-// 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;
+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}`);
   }
-  return averaged;
 }
-async function generateSingleChunkEmbedding({
-  chunk,
-  provider,
-  modelId,
-  credentials
+async function createPresignedGetUrl({
+  accessKeyId,
+  secretAccessKey,
+  endpoint,
+  region,
+  bucket,
+  key,
+  expiresInSeconds = 3600
 }) {
-  "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,
-      tokenCount: chunk.tokenCount
-    }
+  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}`;
 }
-async function generateEmbeddingsInternal(assetId, options = {}) {
-  const {
-    provider = "openai",
-    model,
-    languageCode,
-    chunkingStrategy = { type: "token", maxTokens: 500, overlap: 100 },
-    batchSize = 5,
-    credentials
-  } = options;
-  const embeddingModel = resolveEmbeddingModelConfig({ ...options, provider, model });
-  const { asset: assetData, playbackId, policy } = await getPlaybackIdForAsset(assetId, credentials);
-  const assetDurationSeconds = getAssetDurationSecondsFromAsset(assetData);
-  const isAudioOnly = isAudioOnlyAsset(assetData);
-  const signingContext = await resolveMuxSigningContext(credentials);
-  if (policy === "signed" && !signingContext) {
+
+// src/lib/storage-adapter.ts
+function requireCredentials(accessKeyId, secretAccessKey) {
+  if (!accessKeyId || !secretAccessKey) {
     throw new Error(
-      "Signed playback ID requires signing credentials. Set MUX_SIGNING_KEY and MUX_PRIVATE_KEY environment variables."
+      "S3 credentials are required for default storage operations. Provide S3_ACCESS_KEY_ID and S3_SECRET_ACCESS_KEY or pass options.storageAdapter."
     );
   }
-  const readyTextTracks = getReadyTextTracks(assetData);
-  const useVttChunking = chunkingStrategy.type === "vtt";
-  let transcriptResult = await fetchTranscriptForAsset(assetData, playbackId, {
-    languageCode,
-    cleanTranscript: !useVttChunking,
-    shouldSign: policy === "signed",
-    credentials
-  });
-  if (isAudioOnly && !transcriptResult.track && readyTextTracks.length === 1) {
-    transcriptResult = await fetchTranscriptForAsset(assetData, playbackId, {
-      cleanTranscript: !useVttChunking,
-      shouldSign: policy === "signed",
-      credentials
-    });
-  }
-  if (!transcriptResult.track || !transcriptResult.transcriptText) {
-    const availableLanguages = readyTextTracks.map((t) => t.language_code).filter(Boolean).join(", ");
-    if (isAudioOnly) {
-      throw new Error(
-        `No transcript track found${languageCode ? ` for language '${languageCode}'` : ""}. Audio-only assets require a transcript. Available languages: ${availableLanguages || "none"}`
-      );
+  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(
-      `No caption track found${languageCode ? ` for language '${languageCode}'` : ""}. Available languages: ${availableLanguages || "none"}`
+      "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 transcriptText = transcriptResult.transcriptText;
-  if (!transcriptText.trim()) {
-    throw new Error("Transcript is empty");
+  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 chunks = useVttChunking ? chunkVTTCues(
-    parseVTTCues(transcriptText),
-    chunkingStrategy.maxTokens,
-    chunkingStrategy.overlapCues
-  ) : chunkText(transcriptText, chunkingStrategy);
-  if (chunks.length === 0) {
-    throw new Error("No chunks generated from transcript");
+  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 chunkEmbeddings = [];
+  const vttUrl = await buildTranscriptUrl(playbackId, trackId, policy === "signed", credentials);
+  let vttContent;
   try {
-    for (let i = 0; i < chunks.length; i += batchSize) {
-      const batch = chunks.slice(i, i + batchSize);
-      const batchResults = await Promise.all(
-        batch.map(
-          (chunk) => generateSingleChunkEmbedding({
-            chunk,
-            provider: embeddingModel.provider,
-            modelId: embeddingModel.modelId,
-            credentials
-          })
-        )
-      );
-      chunkEmbeddings.push(...batchResults);
+    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 generate embeddings with ${provider}: ${error instanceof Error ? error.message : "Unknown 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 (chunkEmbeddings.length === 0) {
-    throw new Error("No embeddings generated");
+  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"}`);
+    }
   }
-  const averagedEmbedding = averageEmbeddings(chunkEmbeddings.map((ce) => ce.embedding));
-  const totalTokens = chunks.reduce((sum, chunk) => sum + chunk.tokenCount, 0);
   return {
     assetId,
-    chunks: chunkEmbeddings,
-    averagedEmbedding,
-    provider,
-    model: embeddingModel.modelId,
-    metadata: {
-      totalChunks: chunks.length,
-      totalTokens,
-      chunkingStrategy: JSON.stringify(chunkingStrategy),
-      embeddingDimensions: chunkEmbeddings[0].embedding.length,
-      generatedAt: (/* @__PURE__ */ new Date()).toISOString()
-    },
-    usage: {
-      metadata: {
-        assetDurationSeconds
-      }
-    }
+    trackId,
+    originalVtt: vttContent,
+    editedVtt,
+    totalReplacementCount,
+    autoCensorProfanity: autoCensorResult,
+    replacements: replacementsResult,
+    uploadedTrackId,
+    presignedUrl,
+    usage: usageWithMetadata
   };
 }
-async function generateEmbeddings(assetId, options = {}) {
-  "use workflow";
-  return generateEmbeddingsInternal(assetId, options);
-}
-async function generateVideoEmbeddings(assetId, options = {}) {
-  "use workflow";
-  console.warn("generateVideoEmbeddings is deprecated. Use generateEmbeddings instead.");
-  return generateEmbeddingsInternal(assetId, options);
-}
 
-// src/lib/sampling-plan.ts
-var DEFAULT_FPS = 30;
-function roundToNearestFrameMs(tsMs, fps = DEFAULT_FPS) {
-  const frameMs = 1e3 / fps;
-  return Math.round(Math.round(tsMs / frameMs) * frameMs * 100) / 100;
+// 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 planSamplingTimestamps(options) {
-  const DEFAULT_MIN_CANDIDATES = 10;
-  const DEFAULT_MAX_CANDIDATES = 30;
-  const {
-    duration_sec,
-    min_candidates = DEFAULT_MIN_CANDIDATES,
-    max_candidates = DEFAULT_MAX_CANDIDATES,
-    trim_start_sec = 1,
-    trim_end_sec = 1,
-    fps = DEFAULT_FPS,
-    base_cadence_hz,
-    anchor_percents = [0.2, 0.5, 0.8],
-    anchor_window_sec = 1.5
-  } = options;
-  const usableSec = Math.max(0, duration_sec - (trim_start_sec + trim_end_sec));
-  if (usableSec <= 0)
+function chunkByTokens(text, maxTokens, overlapTokens = 0) {
+  if (!text.trim()) {
     return [];
-  const cadenceHz = base_cadence_hz ?? (duration_sec < 15 ? 3 : duration_sec < 60 ? 2 : duration_sec < 180 ? 1.5 : 1);
-  let target = Math.round(usableSec * cadenceHz);
-  target = Math.max(min_candidates, Math.min(max_candidates, target));
-  const stepSec = usableSec / target;
-  const t0 = trim_start_sec;
-  const base = [];
-  for (let i = 0; i < target; i++) {
-    const tsSec = t0 + (i + 0.5) * stepSec;
-    base.push(tsSec * 1e3);
   }
-  const slack = Math.max(0, max_candidates - base.length);
-  const extra = [];
-  if (slack > 0 && anchor_percents.length > 0) {
-    const perAnchor = Math.max(1, Math.min(5, Math.floor(slack / anchor_percents.length)));
-    for (const p of anchor_percents) {
-      const centerSec = Math.min(
-        t0 + usableSec - 1e-3,
-        // nudge just inside the end bound
-        Math.max(t0 + 1e-3, duration_sec * p)
-        // nudge just inside the start bound
-      );
-      const startSec = Math.max(t0, centerSec - anchor_window_sec / 2);
-      const endSec = Math.min(t0 + usableSec, centerSec + anchor_window_sec / 2);
-      if (endSec <= startSec)
-        continue;
-      const wStep = (endSec - startSec) / perAnchor;
-      for (let i = 0; i < perAnchor; i++) {
-        const tsSec = startSec + (i + 0.5) * wStep;
-        extra.push(tsSec * 1e3);
-      }
+  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;
     }
   }
-  const all = base.concat(extra).map((ms) => roundToNearestFrameMs(ms, fps)).filter((ms) => ms >= trim_start_sec * 1e3 && ms <= (duration_sec - trim_end_sec) * 1e3);
-  const uniqSorted = Array.from(new Set(all)).sort((a, b) => a - b);
-  return uniqSorted.slice(0, max_candidates);
+  return chunks;
 }
-
-// src/primitives/thumbnails.ts
-async function getThumbnailUrls(playbackId, duration, options = {}) {
-  "use step";
-  const { interval = 10, width = 640, shouldSign = false, maxSamples, credentials } = options;
-  let timestamps = [];
-  if (duration <= 50) {
-    const spacing = duration / 6;
-    for (let i = 1; i <= 5; i++) {
-      timestamps.push(Math.round(i * spacing));
-    }
-  } else {
-    for (let time = 0; time < duration; time += interval) {
-      timestamps.push(time);
+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 (maxSamples !== void 0 && timestamps.length > maxSamples) {
-    const newTimestamps = [];
-    newTimestamps.push(0);
-    if (maxSamples >= 2) {
-      const spacing = duration / (maxSamples - 1);
-      for (let i = 1; i < maxSamples - 1; i++) {
-        newTimestamps.push(spacing * i);
-      }
-      newTimestamps.push(duration);
+  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++;
     }
-    timestamps = newTimestamps;
+    currentTokenCount += cueTokenCount;
   }
-  const baseUrl = getMuxThumbnailBaseUrl(playbackId);
-  const urlPromises = timestamps.map(async (time) => {
-    const url = shouldSign ? await signUrl(baseUrl, playbackId, "thumbnail", { time, width }, credentials) : `${baseUrl}?time=${time}&width=${width}`;
-    return { url, time };
+  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 Promise.all(urlPromises);
+  return chunks;
 }
-
-// src/workflows/moderation.ts
-var DEFAULT_THRESHOLDS = {
-  sexual: 0.8,
-  violence: 0.8
-};
-var DEFAULT_PROVIDER2 = "openai";
-var HIVE_ENDPOINT = "https://api.thehive.ai/api/v2/task/sync";
-var HIVE_SEXUAL_CATEGORIES = [
-  "general_nsfw",
-  "yes_sexual_activity",
-  "yes_sex_toy",
-  "yes_female_nudity",
-  "yes_male_nudity"
-];
-var HIVE_VIOLENCE_CATEGORIES = [
-  "gun_in_hand",
-  "gun_not_in_hand",
-  "knife_in_hand",
-  "very_bloody",
-  "other_blood",
-  "hanging",
-  "noose",
-  "human_corpse",
-  "yes_emaciated_body",
-  "yes_self_harm",
-  "garm_death_injury_or_military_conflict"
-];
-async function processConcurrently(items, processor, maxConcurrent = 5) {
-  "use step";
-  const results = [];
-  for (let i = 0; i < items.length; i += maxConcurrent) {
-    const batch = items.slice(i, i + maxConcurrent);
-    const batchPromises = batch.map(processor);
-    const batchResults = await Promise.all(batchPromises);
-    results.push(...batchResults);
+function chunkVTTCuesByDuration(cues, options) {
+  if (cues.length === 0) {
+    return [];
   }
-  return results;
-}
-async function moderateImageWithOpenAI(entry) {
-  "use step";
-  const apiKey = await getApiKeyFromEnv("openai", entry.credentials);
-  try {
-    const res = await fetch("https://api.openai.com/v1/moderations", {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "Authorization": `Bearer ${apiKey}`
-      },
-      body: JSON.stringify({
-        model: entry.model,
-        input: [
-          {
-            type: "image_url",
-            image_url: {
-              url: entry.image
-            }
-          }
-        ]
-      })
-    });
-    const json = await res.json();
-    if (!res.ok) {
-      throw new Error(
-        `OpenAI moderation error: ${res.status} ${res.statusText} - ${JSON.stringify(json)}`
-      );
+  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++;
     }
-    const categoryScores = json.results?.[0]?.category_scores || {};
-    return {
-      url: entry.url,
-      time: entry.time,
-      sexual: categoryScores.sexual || 0,
-      violence: categoryScores.violence || 0,
-      error: false
-    };
-  } catch (error) {
-    console.error("OpenAI moderation failed:", error);
-    return {
-      url: entry.url,
-      time: entry.time,
-      sexual: 0,
-      violence: 0,
-      error: true,
-      errorMessage: error instanceof Error ? error.message : String(error)
-    };
+    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;
 }
-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, 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) {
-  "use step";
-  const apiKey = await getApiKeyFromEnv("openai", credentials);
-  try {
-    const res = await fetch("https://api.openai.com/v1/moderations", {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "Authorization": `Bearer ${apiKey}`
-      },
-      body: JSON.stringify({
-        model,
-        input: text
-      })
-    });
-    const json = await res.json();
-    if (!res.ok) {
-      throw new Error(
-        `OpenAI moderation error: ${res.status} ${res.statusText} - ${JSON.stringify(json)}`
-      );
+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}`);
     }
-    const categoryScores = json.results?.[0]?.category_scores || {};
-    return {
-      url,
-      sexual: categoryScores.sexual || 0,
-      violence: categoryScores.violence || 0,
-      error: false
-    };
-  } catch (error) {
-    console.error("OpenAI text moderation failed:", error);
-    return {
-      url,
-      sexual: 0,
-      violence: 0,
-      error: true,
-      errorMessage: error instanceof Error ? error.message : String(error)
-    };
   }
 }
-function chunkTextByUtf16CodeUnits(text, maxUnits) {
-  if (!text.trim()) {
+
+// src/workflows/embeddings.ts
+function averageEmbeddings(embeddings) {
+  if (embeddings.length === 0) {
     return [];
   }
-  if (text.length <= maxUnits) {
-    return [text];
-  }
-  const chunks = [];
-  for (let i = 0; i < text.length; i += maxUnits) {
-    const chunk = text.slice(i, i + maxUnits).trim();
-    if (chunk) {
-      chunks.push(chunk);
+  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 chunks;
-}
-async function requestOpenAITranscriptModeration(transcriptText, model, maxConcurrent = 5, credentials) {
-  "use step";
-  const chunks = chunkTextByUtf16CodeUnits(transcriptText, 1e4);
-  if (!chunks.length) {
-    return [
-      { url: "transcript:0", sexual: 0, violence: 0, error: true, errorMessage: "No transcript chunks to moderate" }
-    ];
+  for (let i = 0; i < dimensions; i++) {
+    averaged[i] /= embeddings.length;
   }
-  const targets = chunks.map((chunk, idx) => ({
-    chunk,
-    url: `transcript:${idx}`
-  }));
-  return processConcurrently(
-    targets,
-    async (entry) => requestOpenAITextModeration(entry.chunk, model, entry.url, credentials),
-    maxConcurrent
-  );
+  return averaged;
 }
-function getHiveCategoryScores(classes, categoryNames) {
-  const scoreMap = Object.fromEntries(
-    classes.map((c) => [c.class, c.score])
+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
+    })
   );
-  const missingCategories = categoryNames.filter((category) => !(category in scoreMap));
-  if (missingCategories.length > 0) {
-    console.warn(
-      `Hive response missing expected categories: ${missingCategories.join(", ")}`
-    );
-  }
-  const scores = categoryNames.map((category) => scoreMap[category] || 0);
-  return Math.max(...scores, 0);
+  return {
+    chunkId: chunk.id,
+    embedding: response.embedding,
+    metadata: {
+      startTime: chunk.startTime,
+      endTime: chunk.endTime,
+      tokenCount: chunk.tokenCount
+    }
+  };
 }
-async function moderateImageWithHive(entry) {
-  "use step";
-  const apiKey = await getApiKeyFromEnv("hive", entry.credentials);
-  try {
-    const formData = new FormData();
-    if (entry.source.kind === "url") {
-      formData.append("url", entry.source.value);
-    } else {
-      const extension = entry.source.contentType.split("/")[1] || "jpg";
-      const blob = new Blob([entry.source.buffer], {
-        type: entry.source.contentType
-      });
-      formData.append("media", blob, `thumbnail.${extension}`);
-    }
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), 15e3);
-    let res;
-    try {
-      res = await fetch(HIVE_ENDPOINT, {
-        method: "POST",
-        headers: {
-          Accept: "application/json",
-          Authorization: `Token ${apiKey}`
-        },
-        body: formData,
-        signal: controller.signal
-      });
-    } catch (err) {
-      if (err?.name === "AbortError") {
-        throw new Error("Hive request timed out after 15s");
-      }
-      throw err;
-    } finally {
-      clearTimeout(timeout);
-    }
-    const json = await res.json().catch(() => void 0);
-    if (!res.ok) {
-      throw new Error(
-        `Hive moderation error: ${res.status} ${res.statusText} - ${JSON.stringify(json)}`
-      );
-    }
-    if (json?.return_code != null && json.return_code !== 0) {
-      throw new Error(
-        `Hive API error (return_code ${json.return_code}): ${json.message || "Unknown error"}`
-      );
-    }
-    const classes = json?.status?.[0]?.response?.output?.[0]?.classes;
-    if (!Array.isArray(classes)) {
-      throw new TypeError(
-        `Unexpected Hive response structure: ${JSON.stringify(json)}`
-      );
-    }
-    const sexual = getHiveCategoryScores(classes, HIVE_SEXUAL_CATEGORIES);
-    const violence = getHiveCategoryScores(classes, HIVE_VIOLENCE_CATEGORIES);
-    return {
-      url: entry.url,
-      time: entry.time,
-      sexual,
-      violence,
-      error: false
-    };
-  } catch (error) {
-    return {
-      url: entry.url,
-      time: entry.time,
-      sexual: 0,
-      violence: 0,
-      error: true,
-      errorMessage: error instanceof Error ? error.message : String(error)
-    };
-  }
-}
-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
-  })) : images.map((img) => ({
-    url: img.url,
-    time: img.time,
-    source: { kind: "url", value: img.url },
-    credentials
-  }));
-  return await processConcurrently(targets, moderateImageWithHive, maxConcurrent);
-}
-async function getThumbnailUrlsFromTimestamps(playbackId, timestampsMs, options) {
-  "use step";
-  const { width, shouldSign, credentials } = options;
-  const baseUrl = getMuxThumbnailBaseUrl(playbackId);
-  const urlPromises = timestampsMs.map(async (tsMs) => {
-    const time = Number((tsMs / 1e3).toFixed(2));
-    const url = shouldSign ? await signUrl(baseUrl, playbackId, "thumbnail", { time, width }, credentials) : `${baseUrl}?time=${time}&width=${width}`;
-    return { url, time };
-  });
-  return Promise.all(urlPromises);
-}
-async function getModerationScores(assetId, options = {}) {
-  "use workflow";
+async function generateEmbeddingsInternal(assetId, options = {}) {
   const {
-    provider = DEFAULT_PROVIDER2,
-    model = provider === "openai" ? "omni-moderation-latest" : void 0,
+    provider = "openai",
+    model,
     languageCode,
-    thresholds = DEFAULT_THRESHOLDS,
-    thumbnailInterval = 10,
-    thumbnailWidth = 640,
-    maxSamples,
-    maxConcurrent = 5,
-    imageSubmissionMode = "url",
-    imageDownloadOptions,
-    credentials: providedCredentials
+    chunkingStrategy = { type: "token", maxTokens: 500, overlap: 100 },
+    batchSize = 5,
+    credentials
   } = options;
-  const credentials = providedCredentials;
-  const { asset, playbackId, policy } = await getPlaybackIdForAsset(assetId, credentials);
-  const videoTrackDurationSeconds = getVideoTrackDurationSecondsFromAsset(asset);
-  const videoTrackFps = getVideoTrackMaxFrameRateFromAsset(asset);
-  const assetDurationSeconds = getAssetDurationSecondsFromAsset(asset);
-  const candidateDurations = [videoTrackDurationSeconds, assetDurationSeconds].filter(
-    (d) => d != null
-  );
-  const duration = candidateDurations.length > 0 ? Math.min(...candidateDurations) : 0;
-  const isAudioOnly = isAudioOnlyAsset(asset);
+  const embeddingModel = resolveEmbeddingModelConfig({ ...options, provider, model });
+  const { asset: assetData, playbackId, policy } = await getPlaybackIdForAsset(assetId, credentials);
+  const assetDurationSeconds = getAssetDurationSecondsFromAsset(assetData);
+  const isAudioOnly = isAudioOnlyAsset(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."
     );
   }
-  let thumbnailScores;
-  let mode = "thumbnails";
-  let thumbnailCount;
-  if (isAudioOnly) {
-    mode = "transcript";
-    const readyTextTracks = getReadyTextTracks(asset);
-    let transcriptResult = await fetchTranscriptForAsset(asset, playbackId, {
-      languageCode,
-      cleanTranscript: true,
+  const readyTextTracks = getReadyTextTracks(assetData);
+  const useVttChunking = chunkingStrategy.type === "vtt";
+  let transcriptResult = await fetchTranscriptForAsset(assetData, playbackId, {
+    languageCode,
+    cleanTranscript: !useVttChunking,
+    shouldSign: policy === "signed",
+    credentials
+  });
+  if (isAudioOnly && !transcriptResult.track && readyTextTracks.length === 1) {
+    transcriptResult = await fetchTranscriptForAsset(assetData, playbackId, {
+      cleanTranscript: !useVttChunking,
       shouldSign: policy === "signed",
-      credentials,
-      required: true
+      credentials
     });
-    if (!transcriptResult.track && readyTextTracks.length === 1) {
-      transcriptResult = await fetchTranscriptForAsset(asset, playbackId, {
-        cleanTranscript: true,
-        shouldSign: policy === "signed",
-        credentials,
-        required: true
-      });
-    }
-    if (provider === "openai") {
-      thumbnailScores = await requestOpenAITranscriptModeration(
-        transcriptResult.transcriptText,
-        model || "omni-moderation-latest",
-        maxConcurrent,
-        credentials
+  }
+  if (!transcriptResult.track || !transcriptResult.transcriptText) {
+    const availableLanguages = readyTextTracks.map((t) => t.language_code).filter(Boolean).join(", ");
+    if (isAudioOnly) {
+      throw new Error(
+        `No transcript track found${languageCode ? ` for language '${languageCode}'` : ""}. Audio-only assets require a transcript. Available languages: ${availableLanguages || "none"}`
       );
-    } else if (provider === "hive") {
-      throw new Error("Hive does not support transcript moderation in this workflow. Use provider: 'openai' for audio-only assets.");
-    } else {
-      throw new Error(`Unsupported moderation provider: ${provider}`);
     }
-  } else {
-    const thumbnailUrls = maxSamples === void 0 ? (
-      // Generate thumbnail URLs (signed if needed) using existing interval-based logic.
-      await getThumbnailUrls(playbackId, duration, {
-        interval: thumbnailInterval,
-        width: thumbnailWidth,
-        shouldSign: policy === "signed",
-        credentials
-      })
-    ) : (
-      // In maxSamples mode, sample valid timestamps over the trimmed usable span.
-      // Use proportional trims (≈ duration/6, capped at 5s) to stay well inside the
-      // renderable range — Mux can't always serve thumbnails at the very edges.
-      await getThumbnailUrlsFromTimestamps(
-        playbackId,
-        planSamplingTimestamps({
-          duration_sec: duration,
-          max_candidates: maxSamples,
-          trim_start_sec: duration > 2 ? Math.min(5, Math.max(1, duration / 6)) : 0,
-          trim_end_sec: duration > 2 ? Math.min(5, Math.max(1, duration / 6)) : 0,
-          fps: videoTrackFps,
-          base_cadence_hz: thumbnailInterval > 0 ? 1 / thumbnailInterval : void 0
-        }),
-        {
-          width: thumbnailWidth,
-          shouldSign: policy === "signed",
-          credentials
-        }
-      )
+    throw new Error(
+      `No caption track found${languageCode ? ` for language '${languageCode}'` : ""}. Available languages: ${availableLanguages || "none"}`
     );
-    thumbnailCount = thumbnailUrls.length;
-    if (provider === "openai") {
-      thumbnailScores = await requestOpenAIModeration(
-        thumbnailUrls,
-        model || "omni-moderation-latest",
-        maxConcurrent,
-        imageSubmissionMode,
-        imageDownloadOptions,
-        credentials
-      );
-    } else if (provider === "hive") {
-      thumbnailScores = await requestHiveModeration(
-        thumbnailUrls,
-        maxConcurrent,
-        imageSubmissionMode,
-        imageDownloadOptions,
-        credentials
+  }
+  const transcriptText = transcriptResult.transcriptText;
+  if (!transcriptText.trim()) {
+    throw new Error("Transcript is empty");
+  }
+  const chunks = useVttChunking ? chunkVTTCues(
+    parseVTTCues(transcriptText),
+    chunkingStrategy.maxTokens,
+    chunkingStrategy.overlapCues
+  ) : chunkText(transcriptText, chunkingStrategy);
+  if (chunks.length === 0) {
+    throw new Error("No chunks generated from transcript");
+  }
+  const chunkEmbeddings = [];
+  try {
+    for (let i = 0; i < chunks.length; i += batchSize) {
+      const batch = chunks.slice(i, i + batchSize);
+      const batchResults = await Promise.all(
+        batch.map(
+          (chunk) => generateSingleChunkEmbedding({
+            chunk,
+            provider: embeddingModel.provider,
+            modelId: embeddingModel.modelId,
+            credentials
+          })
+        )
       );
-    } else {
-      throw new Error(`Unsupported moderation provider: ${provider}`);
+      chunkEmbeddings.push(...batchResults);
     }
-  }
-  const failed = thumbnailScores.filter((s) => s.error);
-  if (failed.length > 0) {
-    const details = failed.map((s) => `${s.url}: ${s.errorMessage || "Unknown error"}`).join("; ");
+  } catch (error) {
     throw new Error(
-      `Moderation failed for ${failed.length}/${thumbnailScores.length} thumbnail(s): ${details}`
+      `Failed to generate embeddings with ${provider}: ${error instanceof Error ? error.message : "Unknown error"}`
     );
   }
-  const maxSexual = Math.max(...thumbnailScores.map((s) => s.sexual));
-  const maxViolence = Math.max(...thumbnailScores.map((s) => s.violence));
-  const finalThresholds = { ...DEFAULT_THRESHOLDS, ...thresholds };
+  if (chunkEmbeddings.length === 0) {
+    throw new Error("No embeddings generated");
+  }
+  const averagedEmbedding = averageEmbeddings(chunkEmbeddings.map((ce) => ce.embedding));
+  const totalTokens = chunks.reduce((sum, chunk) => sum + chunk.tokenCount, 0);
   return {
     assetId,
-    mode,
-    isAudioOnly,
-    thumbnailScores,
+    chunks: chunkEmbeddings,
+    averagedEmbedding,
+    provider,
+    model: embeddingModel.modelId,
+    metadata: {
+      totalChunks: chunks.length,
+      totalTokens,
+      chunkingStrategy: JSON.stringify(chunkingStrategy),
+      embeddingDimensions: chunkEmbeddings[0].embedding.length,
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    },
     usage: {
       metadata: {
-        assetDurationSeconds: duration,
-        ...thumbnailCount === void 0 ? {} : { thumbnailCount }
+        assetDurationSeconds
       }
-    },
-    maxScores: {
-      sexual: maxSexual,
-      violence: maxViolence
-    },
-    exceedsThreshold: maxSexual > finalThresholds.sexual || maxViolence > finalThresholds.violence,
-    thresholds: finalThresholds
+    }
   };
 }
+async function generateEmbeddings(assetId, options = {}) {
+  "use workflow";
+  return generateEmbeddingsInternal(assetId, options);
+}
+async function generateVideoEmbeddings(assetId, options = {}) {
+  "use workflow";
+  console.warn("generateVideoEmbeddings is deprecated. Use generateEmbeddings instead.");
+  return generateEmbeddingsInternal(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()
-}).strict();
-var SUMMARY_OUTPUT = Output4.object({
-  name: "summary_metadata",
-  description: "Structured summary with title, description, and keywords.",
-  schema: summarySchema
-});
-var VALID_TONES = ["neutral", "playful", "professional"];
-var TONE_INSTRUCTIONS = {
-  neutral: "Provide a clear, straightforward analysis.",
-  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."
-};
-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;
-  return createPromptBuilder({
-    template: {
-      task: {
-        tag: "task",
-        content: "Analyze the storyboard frames and generate metadata that captures the essence of the video content."
-      },
-      title: {
-        tag: "title_requirements",
-        content: dedent4`
-          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.
-          Use active, specific language.`
-      },
-      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.`
-      },
-      keywords: {
-        tag: "keywords_requirements",
-        content: dedent4`
-          Specific, searchable terms (up to ${keywordLimit}) that capture:
-          - Primary subjects (people, animals, objects)
-          - Actions and activities being performed
-          - Setting and environment
-          - Notable objects or tools
-          - Style or genre (if applicable)
-          Prefer concrete nouns and action verbs over abstract concepts.
-          Use lowercase. Avoid redundant or overly generic terms like "video" or "content".`
-      },
-      qualityGuidelines: {
-        tag: "quality_guidelines",
-        content: dedent4`
-          - 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
-          - Balance brevity with informativeness`
+// src/lib/sampling-plan.ts
+var DEFAULT_FPS = 30;
+function roundToNearestFrameMs(tsMs, fps = DEFAULT_FPS) {
+  const frameMs = 1e3 / fps;
+  return Math.round(Math.round(tsMs / frameMs) * frameMs * 100) / 100;
+}
+function planSamplingTimestamps(options) {
+  const DEFAULT_MIN_CANDIDATES = 10;
+  const DEFAULT_MAX_CANDIDATES = 30;
+  const {
+    duration_sec,
+    min_candidates = DEFAULT_MIN_CANDIDATES,
+    max_candidates = DEFAULT_MAX_CANDIDATES,
+    trim_start_sec = 1,
+    trim_end_sec = 1,
+    fps = DEFAULT_FPS,
+    base_cadence_hz,
+    anchor_percents = [0.2, 0.5, 0.8],
+    anchor_window_sec = 1.5
+  } = options;
+  const usableSec = Math.max(0, duration_sec - (trim_start_sec + trim_end_sec));
+  if (usableSec <= 0)
+    return [];
+  const cadenceHz = base_cadence_hz ?? (duration_sec < 15 ? 3 : duration_sec < 60 ? 2 : duration_sec < 180 ? 1.5 : 1);
+  let target = Math.round(usableSec * cadenceHz);
+  target = Math.max(min_candidates, Math.min(max_candidates, target));
+  const stepSec = usableSec / target;
+  const t0 = trim_start_sec;
+  const base = [];
+  for (let i = 0; i < target; i++) {
+    const tsSec = t0 + (i + 0.5) * stepSec;
+    base.push(tsSec * 1e3);
+  }
+  const slack = Math.max(0, max_candidates - base.length);
+  const extra = [];
+  if (slack > 0 && anchor_percents.length > 0) {
+    const perAnchor = Math.max(1, Math.min(5, Math.floor(slack / anchor_percents.length)));
+    for (const p of anchor_percents) {
+      const centerSec = Math.min(
+        t0 + usableSec - 1e-3,
+        // nudge just inside the end bound
+        Math.max(t0 + 1e-3, duration_sec * p)
+        // nudge just inside the start bound
+      );
+      const startSec = Math.max(t0, centerSec - anchor_window_sec / 2);
+      const endSec = Math.min(t0 + usableSec, centerSec + anchor_window_sec / 2);
+      if (endSec <= startSec)
+        continue;
+      const wStep = (endSec - startSec) / perAnchor;
+      for (let i = 0; i < perAnchor; i++) {
+        const tsSec = startSec + (i + 0.5) * wStep;
+        extra.push(tsSec * 1e3);
       }
-    },
-    sectionOrder: ["task", "title", "description", "keywords", "qualityGuidelines"]
-  });
+    }
+  }
+  const all = base.concat(extra).map((ms) => roundToNearestFrameMs(ms, fps)).filter((ms) => ms >= trim_start_sec * 1e3 && ms <= (duration_sec - trim_end_sec) * 1e3);
+  const uniqSorted = Array.from(new Set(all)).sort((a, b) => a - b);
+  return uniqSorted.slice(0, max_candidates);
 }
-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;
-  return createPromptBuilder({
-    template: {
-      task: {
-        tag: "task",
-        content: "Analyze the transcript and generate metadata that captures the essence of the audio content."
-      },
-      title: {
-        tag: "title_requirements",
-        content: dedent4`
-          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.
-          Use active, specific language.`
-      },
-      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.`
-      },
-      keywords: {
-        tag: "keywords_requirements",
-        content: dedent4`
-          Specific, searchable terms (up to ${keywordLimit}) that capture:
-          - Primary topics and themes
-          - Speakers or presenters (if named)
-          - Key concepts and terminology
-          - Content type (interview, lecture, music, etc.)
-          - Genre or style (if applicable)
-          Prefer concrete nouns and relevant terms over abstract concepts.
-          Use lowercase. Avoid redundant or overly generic terms like "audio" or "content".`
-      },
-      qualityGuidelines: {
-        tag: "quality_guidelines",
-        content: dedent4`
-          - 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
-          - Balance brevity with informativeness`
+
+// src/primitives/thumbnails.ts
+async function getThumbnailUrls(playbackId, duration, options = {}) {
+  "use step";
+  const { interval = 10, width = 640, shouldSign = false, maxSamples, credentials } = options;
+  let timestamps = [];
+  if (duration <= 50) {
+    const spacing = duration / 6;
+    for (let i = 1; i <= 5; i++) {
+      timestamps.push(Math.round(i * spacing));
+    }
+  } else {
+    for (let time = 0; time < duration; time += interval) {
+      timestamps.push(time);
+    }
+  }
+  if (maxSamples !== void 0 && timestamps.length > maxSamples) {
+    const newTimestamps = [];
+    newTimestamps.push(0);
+    if (maxSamples >= 2) {
+      const spacing = duration / (maxSamples - 1);
+      for (let i = 1; i < maxSamples - 1; i++) {
+        newTimestamps.push(spacing * i);
       }
-    },
-    sectionOrder: ["task", "title", "description", "keywords", "qualityGuidelines"]
+      newTimestamps.push(duration);
+    }
+    timestamps = newTimestamps;
+  }
+  const baseUrl = getMuxThumbnailBaseUrl(playbackId);
+  const urlPromises = timestamps.map(async (time) => {
+    const url = shouldSign ? await signUrl(baseUrl, playbackId, "thumbnail", { time, width }, credentials) : `${baseUrl}?time=${time}&width=${width}`;
+    return { url, time };
   });
+  return Promise.all(urlPromises);
 }
-var SYSTEM_PROMPT3 = dedent4`
-  <role>
-    You are a video content analyst specializing in storyboard interpretation and multimodal analysis.
-  </role>
 
-  <context>
-    You receive storyboard images containing multiple sequential frames extracted from a video.
-    These frames are arranged in a grid and represent the visual progression of the content over time.
-    Read frames left-to-right, top-to-bottom to understand the temporal sequence.
-  </context>
-
-  <transcript_guidance>
-    When a transcript is provided alongside the storyboard:
-    - Use it to understand spoken content, dialogue, narration, and audio context
-    - Correlate transcript content with visual frames to build a complete picture
-    - Extract key terminology, names, and specific language used by speakers
-    - Let the transcript inform keyword selection, especially for topics not visually obvious
-    - Prioritize visual content for the description, but enrich it with transcript insights
-    - If transcript and visuals conflict, trust the visual evidence
-  </transcript_guidance>
-
-  <capabilities>
-    - Extract meaning from visual sequences
-    - Identify subjects, actions, settings, and narrative arcs
-    - Generate accurate, searchable metadata
-    - Synthesize visual and transcript information when provided
-  </capabilities>
-
-  <constraints>
-    - Only describe what is clearly observable in the frames or explicitly stated in the transcript
-    - Do not fabricate details or make unsupported assumptions
-    - Return structured data matching the requested schema
-    - Output only the JSON object; no markdown or extra text
-    - When a <language> section is provided, all output text MUST be written in that language
-  </constraints>
-
-  <tone_guidance>
-    Pay special attention to the <tone> section and lean heavily into those instructions.
-    Adapt your entire analysis and writing style to match the specified tone - this should influence
-    your word choice, personality, formality level, and overall presentation of the content.
-    The tone instructions are not suggestions but core requirements for how you should express yourself.
-  </tone_guidance>
-
-  <language_guidelines>
-    AVOID these meta-descriptive phrases that reference the medium rather than the content:
-    - "The image shows..." / "The storyboard shows..."
-    - "In this video..." / "This video features..."
-    - "The frames depict..." / "The footage shows..."
-    - "We can see..." / "You can see..."
-    - "The clip shows..." / "The scene shows..."
-
-    INSTEAD, describe the content directly:
-    - BAD: "The video shows a chef preparing a meal"
-    - GOOD: "A chef prepares a meal in a professional kitchen"
-
-    Write as if describing reality, not describing a recording of reality.
-  </language_guidelines>`;
-var AUDIO_ONLY_SYSTEM_PROMPT = dedent4`
-  <role>
-    You are an audio content analyst specializing in transcript analysis and metadata generation.
-  </role>
-
-  <context>
-    You receive transcript text from audio-only content (podcasts, audiobooks, music, etc.).
-    Your task is to analyze the spoken/audio content and generate accurate, searchable metadata.
-  </context>
-
-  <transcript_guidance>
-    - Carefully analyze the entire transcript to understand themes, topics, and key points
-    - Extract key terminology, names, concepts, and specific language used
-    - Identify the content type (interview, lecture, music, narration, etc.)
-    - Note the tone, style, and any distinctive characteristics of the audio
-    - Consider the intended audience and context based on language and content
-  </transcript_guidance>
-
-  <capabilities>
-    - Extract meaning and themes from spoken/audio content
-    - Identify subjects, topics, speakers, and narrative structure
-    - Generate accurate, searchable metadata from audio-based content
-    - Understand context and intent from transcript alone
-  </capabilities>
-
-  <constraints>
-    - Only describe what is explicitly stated or strongly implied in the transcript
-    - Do not fabricate details or make unsupported assumptions
-    - Return structured data matching the requested schema
-    - Focus entirely on audio/spoken content - there are no visual elements
-    - Output only the JSON object; no markdown or extra text
-    - When a <language> section is provided, all output text MUST be written in that language
-  </constraints>
-
-  <tone_guidance>
-    Pay special attention to the <tone> section and lean heavily into those instructions.
-    Adapt your entire analysis and writing style to match the specified tone - this should influence
-    your word choice, personality, formality level, and overall presentation of the content.
-    The tone instructions are not suggestions but core requirements for how you should express yourself.
-  </tone_guidance>
-
-  <language_guidelines>
-    AVOID these meta-descriptive phrases that reference the medium rather than the content:
-    - "The audio shows..." / "The transcript shows..."
-    - "In this recording..." / "This audio features..."
-    - "The speaker says..." / "We can hear..."
-    - "The clip contains..." / "The recording shows..."
-
-    INSTEAD, describe the content directly:
-    - BAD: "The audio features a discussion about climate change"
-    - GOOD: "A panel discusses climate change impacts and solutions"
-
-    Write as if describing reality, not describing a recording of reality.
-  </language_guidelines>`;
-function buildUserPrompt4({
-  tone,
-  transcriptText,
-  isCleanTranscript = true,
-  promptOverrides,
-  isAudioOnly = false,
-  titleLength,
-  descriptionLength,
-  tagCount,
-  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));
+// src/workflows/moderation.ts
+var DEFAULT_THRESHOLDS = {
+  sexual: 0.8,
+  violence: 0.8
+};
+var DEFAULT_PROVIDER2 = "openai";
+var HIVE_ENDPOINT = "https://api.thehive.ai/api/v2/task/sync";
+var HIVE_SEXUAL_CATEGORIES = [
+  "general_nsfw",
+  "yes_sexual_activity",
+  "yes_sex_toy",
+  "yes_female_nudity",
+  "yes_male_nudity"
+];
+var HIVE_VIOLENCE_CATEGORIES = [
+  "gun_in_hand",
+  "gun_not_in_hand",
+  "knife_in_hand",
+  "very_bloody",
+  "other_blood",
+  "hanging",
+  "noose",
+  "human_corpse",
+  "yes_emaciated_body",
+  "yes_self_harm",
+  "garm_death_injury_or_military_conflict"
+];
+async function processConcurrently(items, processor, maxConcurrent = 5) {
+  "use step";
+  const results = [];
+  for (let i = 0; i < items.length; i += maxConcurrent) {
+    const batch = items.slice(i, i + maxConcurrent);
+    const batchPromises = batch.map(processor);
+    const batchResults = await Promise.all(batchPromises);
+    results.push(...batchResults);
   }
-  const constraints = { titleLength, descriptionLength, tagCount };
-  const promptBuilder = isAudioOnly ? createAudioOnlyBuilder(constraints) : createSummarizationBuilder(constraints);
-  return promptBuilder.buildWithContext(promptOverrides, contextSections);
+  return results;
 }
-async function analyzeStoryboard2(imageDataUrl, provider, modelId, userPrompt, systemPrompt, credentials) {
+async function moderateImageWithOpenAI(entry) {
   "use step";
-  const model = await createLanguageModelFromConfig(provider, modelId, credentials);
-  const response = await generateText4({
-    model,
-    output: SUMMARY_OUTPUT,
-    messages: [
-      {
-        role: "system",
-        content: systemPrompt
+  const apiKey = await getApiKeyFromEnv("openai", entry.credentials);
+  try {
+    const res = await fetch("https://api.openai.com/v1/moderations", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${apiKey}`
       },
-      {
-        role: "user",
-        content: [
-          { type: "text", text: userPrompt },
-          { type: "image", image: imageDataUrl }
+      body: JSON.stringify({
+        model: entry.model,
+        input: [
+          {
+            type: "image_url",
+            image_url: {
+              url: entry.image
+            }
+          }
         ]
-      }
-    ]
-  });
-  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
+      })
+    });
+    const json = await res.json();
+    if (!res.ok) {
+      throw new Error(
+        `OpenAI moderation error: ${res.status} ${res.statusText} - ${JSON.stringify(json)}`
+      );
     }
-  };
+    const categoryScores = json.results?.[0]?.category_scores || {};
+    return {
+      url: entry.url,
+      time: entry.time,
+      sexual: categoryScores.sexual || 0,
+      violence: categoryScores.violence || 0,
+      error: false
+    };
+  } catch (error) {
+    console.error("OpenAI moderation failed:", error);
+    return {
+      url: entry.url,
+      time: entry.time,
+      sexual: 0,
+      violence: 0,
+      error: true,
+      errorMessage: error instanceof Error ? error.message : String(error)
+    };
+  }
 }
-async function analyzeAudioOnly(provider, modelId, userPrompt, systemPrompt, credentials) {
+async function requestOpenAIModeration(images, model, maxConcurrent = 5, submissionMode = "url", downloadOptions, 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: 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
-    }
-  };
+  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, 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);
 }
-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;
+async function requestOpenAITextModeration(text, model, url, credentials) {
+  "use step";
+  const apiKey = await getApiKeyFromEnv("openai", credentials);
   try {
-    if (isAudioOnly) {
-      analysisResponse = await analyzeAudioOnly(
-        modelConfig.provider,
-        modelConfig.modelId,
-        userPrompt,
-        systemPrompt,
-        workflowCredentials
+    const res = await fetch("https://api.openai.com/v1/moderations", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${apiKey}`
+      },
+      body: JSON.stringify({
+        model,
+        input: text
+      })
+    });
+    const json = await res.json();
+    if (!res.ok) {
+      throw new Error(
+        `OpenAI moderation error: ${res.status} ${res.statusText} - ${JSON.stringify(json)}`
       );
-    } 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
-        ));
-      }
     }
+    const categoryScores = json.results?.[0]?.category_scores || {};
+    return {
+      url,
+      sexual: categoryScores.sexual || 0,
+      violence: categoryScores.violence || 0,
+      error: false
+    };
   } catch (error) {
-    const contentType = isAudioOnly ? "audio" : "video";
-    throw new Error(
-      `Failed to analyze ${contentType} content with ${provider}: ${error instanceof Error ? error.message : "Unknown error"}`
-    );
+    console.error("OpenAI text moderation failed:", error);
+    return {
+      url,
+      sexual: 0,
+      violence: 0,
+      error: true,
+      errorMessage: error instanceof Error ? error.message : String(error)
+    };
   }
-  if (!analysisResponse.result) {
-    throw new Error(`Failed to analyze video content for asset ${assetId}`);
+}
+function chunkTextByUtf16CodeUnits(text, maxUnits) {
+  if (!text.trim()) {
+    return [];
   }
-  if (!analysisResponse.result.title) {
-    throw new Error(`Failed to generate title for asset ${assetId}`);
+  if (text.length <= maxUnits) {
+    return [text];
   }
-  if (!analysisResponse.result.description) {
-    throw new Error(`Failed to generate description for asset ${assetId}`);
+  const chunks = [];
+  for (let i = 0; i < text.length; i += maxUnits) {
+    const chunk = text.slice(i, i + maxUnits).trim();
+    if (chunk) {
+      chunks.push(chunk);
+    }
   }
-  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
-  };
+  return chunks;
 }
-
-// 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.");
+async function requestOpenAITranscriptModeration(transcriptText, model, maxConcurrent = 5, credentials) {
+  "use step";
+  const chunks = chunkTextByUtf16CodeUnits(transcriptText, 1e4);
+  if (!chunks.length) {
+    return [
+      { url: "transcript:0", sexual: 0, violence: 0, error: true, errorMessage: "No transcript chunks to moderate" }
+    ];
   }
-  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 targets = chunks.map((chunk, idx) => ({
+    chunk,
+    url: `transcript:${idx}`
+  }));
+  return processConcurrently(
+    targets,
+    async (entry) => requestOpenAITextModeration(entry.chunk, model, entry.url, credentials),
+    maxConcurrent
   );
-  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 getHiveCategoryScores(classes, categoryNames) {
+  const scoreMap = Object.fromEntries(
+    classes.map((c) => [c.class, c.score])
+  );
+  const missingCategories = categoryNames.filter((category) => !(category in scoreMap));
+  if (missingCategories.length > 0) {
+    console.warn(
+      `Hive response missing expected categories: ${missingCategories.join(", ")}`
+    );
+  }
+  const scores = categoryNames.map((category) => scoreMap[category] || 0);
+  return Math.max(...scores, 0);
 }
-function normalizeEndpoint(endpoint) {
-  let url;
+async function moderateImageWithHive(entry) {
+  "use step";
+  const apiKey = await getApiKeyFromEnv("hive", entry.credentials);
   try {
-    url = new URL(endpoint);
-  } catch {
-    throw new Error(`Invalid S3 endpoint: ${endpoint}`);
-  }
-  if (url.search || url.hash) {
-    throw new Error("S3 endpoint must not include query params or hash fragments.");
+    const formData = new FormData();
+    if (entry.source.kind === "url") {
+      formData.append("url", entry.source.value);
+    } else {
+      const extension = entry.source.contentType.split("/")[1] || "jpg";
+      const blob = new Blob([entry.source.buffer], {
+        type: entry.source.contentType
+      });
+      formData.append("media", blob, `thumbnail.${extension}`);
+    }
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 15e3);
+    let res;
+    try {
+      res = await fetch(HIVE_ENDPOINT, {
+        method: "POST",
+        headers: {
+          Accept: "application/json",
+          Authorization: `Token ${apiKey}`
+        },
+        body: formData,
+        signal: controller.signal
+      });
+    } catch (err) {
+      if (err?.name === "AbortError") {
+        throw new Error("Hive request timed out after 15s");
+      }
+      throw err;
+    } finally {
+      clearTimeout(timeout);
+    }
+    const json = await res.json().catch(() => void 0);
+    if (!res.ok) {
+      throw new Error(
+        `Hive moderation error: ${res.status} ${res.statusText} - ${JSON.stringify(json)}`
+      );
+    }
+    if (json?.return_code != null && json.return_code !== 0) {
+      throw new Error(
+        `Hive API error (return_code ${json.return_code}): ${json.message || "Unknown error"}`
+      );
+    }
+    const classes = json?.status?.[0]?.response?.output?.[0]?.classes;
+    if (!Array.isArray(classes)) {
+      throw new TypeError(
+        `Unexpected Hive response structure: ${JSON.stringify(json)}`
+      );
+    }
+    const sexual = getHiveCategoryScores(classes, HIVE_SEXUAL_CATEGORIES);
+    const violence = getHiveCategoryScores(classes, HIVE_VIOLENCE_CATEGORIES);
+    return {
+      url: entry.url,
+      time: entry.time,
+      sexual,
+      violence,
+      error: false
+    };
+  } catch (error) {
+    return {
+      url: entry.url,
+      time: entry.time,
+      sexual: 0,
+      violence: 0,
+      error: true,
+      errorMessage: error instanceof Error ? error.message : String(error)
+    };
   }
-  enforceEndpointPolicy(url);
-  return url;
 }
-function parseEndpointAllowlist(allowlist) {
-  if (!allowlist) {
-    return [];
-  }
-  return allowlist.split(",").map((value) => value.trim().toLowerCase()).filter(Boolean);
+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
+  })) : images.map((img) => ({
+    url: img.url,
+    time: img.time,
+    source: { kind: "url", value: img.url },
+    credentials
+  }));
+  return await processConcurrently(targets, moderateImageWithHive, maxConcurrent);
 }
-function hostnameMatchesPattern(hostname, pattern) {
-  if (pattern.startsWith("*.")) {
-    const suffix = pattern.slice(1);
-    return hostname.endsWith(suffix) && hostname.length > suffix.length;
-  }
-  return hostname === pattern;
+async function getThumbnailUrlsFromTimestamps(playbackId, timestampsMs, options) {
+  "use step";
+  const { width, shouldSign, credentials } = options;
+  const baseUrl = getMuxThumbnailBaseUrl(playbackId);
+  const urlPromises = timestampsMs.map(async (tsMs) => {
+    const time = Number((tsMs / 1e3).toFixed(2));
+    const url = shouldSign ? await signUrl(baseUrl, playbackId, "thumbnail", { time, width }, credentials) : `${baseUrl}?time=${time}&width=${width}`;
+    return { url, time };
+  });
+  return Promise.all(urlPromises);
 }
-function enforceEndpointPolicy(url) {
-  const hostname = url.hostname.toLowerCase();
-  if (url.protocol !== "https:") {
+async function getModerationScores(assetId, options = {}) {
+  "use workflow";
+  const {
+    provider = DEFAULT_PROVIDER2,
+    model = provider === "openai" ? "omni-moderation-latest" : void 0,
+    languageCode,
+    thresholds = DEFAULT_THRESHOLDS,
+    thumbnailInterval = 10,
+    thumbnailWidth = 640,
+    maxSamples,
+    maxConcurrent = 5,
+    imageSubmissionMode = "url",
+    imageDownloadOptions,
+    credentials: providedCredentials
+  } = options;
+  const credentials = providedCredentials;
+  const { asset, playbackId, policy } = await getPlaybackIdForAsset(assetId, credentials);
+  const videoTrackDurationSeconds = getVideoTrackDurationSecondsFromAsset(asset);
+  const videoTrackFps = getVideoTrackMaxFrameRateFromAsset(asset);
+  const assetDurationSeconds = getAssetDurationSecondsFromAsset(asset);
+  const candidateDurations = [videoTrackDurationSeconds, assetDurationSeconds].filter(
+    (d) => d != null
+  );
+  const duration = candidateDurations.length > 0 ? Math.min(...candidateDurations) : 0;
+  const isAudioOnly = isAudioOnlyAsset(asset);
+  const signingContext = await resolveMuxSigningContext(credentials);
+  if (policy === "signed" && !signingContext) {
     throw new Error(
-      `Insecure S3 endpoint protocol "${url.protocol}" is not allowed. Use HTTPS.`
+      "Signed playback ID requires signing credentials. Set MUX_SIGNING_KEY and MUX_PRIVATE_KEY environment variables."
     );
   }
-  if (S3_ALLOWED_ENDPOINT_PATTERNS.length > 0 && !S3_ALLOWED_ENDPOINT_PATTERNS.some((pattern) => hostnameMatchesPattern(hostname, pattern))) {
+  let thumbnailScores;
+  let mode = "thumbnails";
+  let thumbnailCount;
+  if (isAudioOnly) {
+    mode = "transcript";
+    const readyTextTracks = getReadyTextTracks(asset);
+    let transcriptResult = await fetchTranscriptForAsset(asset, playbackId, {
+      languageCode,
+      cleanTranscript: true,
+      shouldSign: policy === "signed",
+      credentials,
+      required: true
+    });
+    if (!transcriptResult.track && readyTextTracks.length === 1) {
+      transcriptResult = await fetchTranscriptForAsset(asset, playbackId, {
+        cleanTranscript: true,
+        shouldSign: policy === "signed",
+        credentials,
+        required: true
+      });
+    }
+    if (provider === "openai") {
+      thumbnailScores = await requestOpenAITranscriptModeration(
+        transcriptResult.transcriptText,
+        model || "omni-moderation-latest",
+        maxConcurrent,
+        credentials
+      );
+    } else if (provider === "hive") {
+      throw new Error("Hive does not support transcript moderation in this workflow. Use provider: 'openai' for audio-only assets.");
+    } else {
+      throw new Error(`Unsupported moderation provider: ${provider}`);
+    }
+  } else {
+    const thumbnailUrls = maxSamples === void 0 ? (
+      // Generate thumbnail URLs (signed if needed) using existing interval-based logic.
+      await getThumbnailUrls(playbackId, duration, {
+        interval: thumbnailInterval,
+        width: thumbnailWidth,
+        shouldSign: policy === "signed",
+        credentials
+      })
+    ) : (
+      // In maxSamples mode, sample valid timestamps over the trimmed usable span.
+      // Use proportional trims (≈ duration/6, capped at 5s) to stay well inside the
+      // renderable range — Mux can't always serve thumbnails at the very edges.
+      await getThumbnailUrlsFromTimestamps(
+        playbackId,
+        planSamplingTimestamps({
+          duration_sec: duration,
+          max_candidates: maxSamples,
+          trim_start_sec: duration > 2 ? Math.min(5, Math.max(1, duration / 6)) : 0,
+          trim_end_sec: duration > 2 ? Math.min(5, Math.max(1, duration / 6)) : 0,
+          fps: videoTrackFps,
+          base_cadence_hz: thumbnailInterval > 0 ? 1 / thumbnailInterval : void 0
+        }),
+        {
+          width: thumbnailWidth,
+          shouldSign: policy === "signed",
+          credentials
+        }
+      )
+    );
+    thumbnailCount = thumbnailUrls.length;
+    if (provider === "openai") {
+      thumbnailScores = await requestOpenAIModeration(
+        thumbnailUrls,
+        model || "omni-moderation-latest",
+        maxConcurrent,
+        imageSubmissionMode,
+        imageDownloadOptions,
+        credentials
+      );
+    } else if (provider === "hive") {
+      thumbnailScores = await requestHiveModeration(
+        thumbnailUrls,
+        maxConcurrent,
+        imageSubmissionMode,
+        imageDownloadOptions,
+        credentials
+      );
+    } else {
+      throw new Error(`Unsupported moderation provider: ${provider}`);
+    }
+  }
+  const failed = thumbnailScores.filter((s) => s.error);
+  if (failed.length > 0) {
+    const details = failed.map((s) => `${s.url}: ${s.errorMessage || "Unknown error"}`).join("; ");
     throw new Error(
-      `S3 endpoint host "${hostname}" is not in S3_ALLOWED_ENDPOINT_HOSTS.`
+      `Moderation failed for ${failed.length}/${thumbnailScores.length} thumbnail(s): ${details}`
     );
   }
+  const maxSexual = Math.max(...thumbnailScores.map((s) => s.sexual));
+  const maxViolence = Math.max(...thumbnailScores.map((s) => s.violence));
+  const finalThresholds = { ...DEFAULT_THRESHOLDS, ...thresholds };
+  return {
+    assetId,
+    mode,
+    isAudioOnly,
+    thumbnailScores,
+    usage: {
+      metadata: {
+        assetDurationSeconds: duration,
+        ...thumbnailCount === void 0 ? {} : { thumbnailCount }
+      }
+    },
+    maxScores: {
+      sexual: maxSexual,
+      violence: maxViolence
+    },
+    exceedsThreshold: maxSexual > finalThresholds.sexual || maxViolence > finalThresholds.violence,
+    thresholds: finalThresholds
+  };
 }
-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);
+
+// src/workflows/summarization.ts
+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 = Output5.object({
+  name: "summary_metadata",
+  description: "Structured summary with title, description, and keywords.",
+  schema: summarySchema
+});
+var VALID_TONES = ["neutral", "playful", "professional"];
+var TONE_INSTRUCTIONS = {
+  neutral: "Provide a clear, straightforward analysis.",
+  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 buildCredentialScope(shortDate, region) {
-  return `${shortDate}/${region}/${AWS4_SERVICE}/${AWS4_REQUEST_TERMINATOR}`;
+function createSummarizationBuilder({ titleLength, descriptionLength, tagCount } = {}) {
+  const titleBrevity = `Aim for approximately ${titleLength ?? DEFAULT_TITLE_LENGTH} words.`;
+  const keywordLimit = tagCount ?? DEFAULT_SUMMARY_KEYWORD_LIMIT;
+  return createPromptBuilder({
+    template: {
+      task: {
+        tag: "task",
+        content: "Analyze the storyboard frames and generate metadata that captures the essence of the video content."
+      },
+      title: {
+        tag: "title_requirements",
+        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.
+          Use active, specific language.`
+      },
+      description: {
+        tag: "description_requirements",
+        content: buildDescriptionGuidance(descriptionLength ?? DEFAULT_DESCRIPTION_LENGTH, "video")
+      },
+      keywords: {
+        tag: "keywords_requirements",
+        content: dedent5`
+          Specific, searchable terms (up to ${keywordLimit}) that capture:
+          - Primary subjects (people, animals, objects)
+          - Actions and activities being performed
+          - Setting and environment
+          - Notable objects or tools
+          - Style or genre (if applicable)
+          Prefer concrete nouns and action verbs over abstract concepts.
+          Use lowercase. Avoid redundant or overly generic terms like "video" or "content".`
+      },
+      qualityGuidelines: {
+        tag: "quality_guidelines",
+        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
+          - Balance brevity with informativeness`
+      }
+    },
+    sectionOrder: ["task", "title", "description", "keywords", "qualityGuidelines"]
+  });
 }
-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 } : {}
+function createAudioOnlyBuilder({ titleLength, descriptionLength, tagCount } = {}) {
+  const titleBrevity = `Aim for approximately ${titleLength ?? DEFAULT_TITLE_LENGTH} words.`;
+  const keywordLimit = tagCount ?? DEFAULT_SUMMARY_KEYWORD_LIMIT;
+  return createPromptBuilder({
+    template: {
+      task: {
+        tag: "task",
+        content: "Analyze the transcript and generate metadata that captures the essence of the audio content."
+      },
+      title: {
+        tag: "title_requirements",
+        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.
+          Use active, specific language.`
+      },
+      description: {
+        tag: "description_requirements",
+        content: buildDescriptionGuidance(descriptionLength ?? DEFAULT_DESCRIPTION_LENGTH, "audio")
+      },
+      keywords: {
+        tag: "keywords_requirements",
+        content: dedent5`
+          Specific, searchable terms (up to ${keywordLimit}) that capture:
+          - Primary topics and themes
+          - Speakers or presenters (if named)
+          - Key concepts and terminology
+          - Content type (interview, lecture, music, etc.)
+          - Genre or style (if applicable)
+          Prefer concrete nouns and relevant terms over abstract concepts.
+          Use lowercase. Avoid redundant or overly generic terms like "audio" or "content".`
+      },
+      qualityGuidelines: {
+        tag: "quality_guidelines",
+        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
+          - Balance brevity with informativeness`
+      }
     },
-    body
+    sectionOrder: ["task", "title", "description", "keywords", "qualityGuidelines"]
   });
-  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
+var SYSTEM_PROMPT4 = dedent5`
+  <role>
+    You are a video content analyst specializing in storyboard interpretation and multimodal analysis.
+  </role>
+
+  <context>
+    You receive storyboard images containing multiple sequential frames extracted from a video.
+    These frames are arranged in a grid and represent the visual progression of the content over time.
+    Read frames left-to-right, top-to-bottom to understand the temporal sequence.
+  </context>
+
+  <transcript_guidance>
+    When a transcript is provided alongside the storyboard:
+    - Use it to understand spoken content, dialogue, narration, and audio context
+    - Correlate transcript content with visual frames to build a complete picture
+    - Extract key terminology, names, and specific language used by speakers
+    - Let the transcript inform keyword selection, especially for topics not visually obvious
+    - Prioritize visual content for the description, but enrich it with transcript insights
+    - If transcript and visuals conflict, trust the visual evidence
+  </transcript_guidance>
+
+  <capabilities>
+    - Extract meaning from visual sequences
+    - Identify subjects, actions, settings, and narrative arcs
+    - Generate accurate, searchable metadata
+    - Synthesize visual and transcript information when provided
+  </capabilities>
+
+  <constraints>
+    - Only describe what is clearly observable in the frames or explicitly stated in the transcript
+    - Do not fabricate details or make unsupported assumptions
+    - Return structured data matching the requested schema
+    - Output only the JSON object; no markdown or extra text
+    - When a <language> section is provided, all output text MUST be written in that language
+  </constraints>
+
+  <tone_guidance>
+    Pay special attention to the <tone> section and lean heavily into those instructions.
+    Adapt your entire analysis and writing style to match the specified tone - this should influence
+    your word choice, personality, formality level, and overall presentation of the content.
+    The tone instructions are not suggestions but core requirements for how you should express yourself.
+  </tone_guidance>
+
+  <language_guidelines>
+    AVOID these meta-descriptive phrases that reference the medium rather than the content:
+    - "The image shows..." / "The storyboard shows..."
+    - "In this video..." / "This video features..."
+    - "The frames depict..." / "The footage shows..."
+    - "We can see..." / "You can see..."
+    - "The clip shows..." / "The scene shows..."
+
+    INSTEAD, describe the content directly:
+    - BAD: "The video shows a chef preparing a meal"
+    - GOOD: "A chef prepares a meal in a professional kitchen"
+
+    Write as if describing reality, not describing a recording of reality.
+  </language_guidelines>`;
+var AUDIO_ONLY_SYSTEM_PROMPT = dedent5`
+  <role>
+    You are an audio content analyst specializing in transcript analysis and metadata generation.
+  </role>
+
+  <context>
+    You receive transcript text from audio-only content (podcasts, audiobooks, music, etc.).
+    Your task is to analyze the spoken/audio content and generate accurate, searchable metadata.
+  </context>
+
+  <transcript_guidance>
+    - Carefully analyze the entire transcript to understand themes, topics, and key points
+    - Extract key terminology, names, concepts, and specific language used
+    - Identify the content type (interview, lecture, music, narration, etc.)
+    - Note the tone, style, and any distinctive characteristics of the audio
+    - Consider the intended audience and context based on language and content
+  </transcript_guidance>
+
+  <capabilities>
+    - Extract meaning and themes from spoken/audio content
+    - Identify subjects, topics, speakers, and narrative structure
+    - Generate accurate, searchable metadata from audio-based content
+    - Understand context and intent from transcript alone
+  </capabilities>
+
+  <constraints>
+    - Only describe what is explicitly stated or strongly implied in the transcript
+    - Do not fabricate details or make unsupported assumptions
+    - Return structured data matching the requested schema
+    - Focus entirely on audio/spoken content - there are no visual elements
+    - Output only the JSON object; no markdown or extra text
+    - When a <language> section is provided, all output text MUST be written in that language
+  </constraints>
+
+  <tone_guidance>
+    Pay special attention to the <tone> section and lean heavily into those instructions.
+    Adapt your entire analysis and writing style to match the specified tone - this should influence
+    your word choice, personality, formality level, and overall presentation of the content.
+    The tone instructions are not suggestions but core requirements for how you should express yourself.
+  </tone_guidance>
+
+  <language_guidelines>
+    AVOID these meta-descriptive phrases that reference the medium rather than the content:
+    - "The audio shows..." / "The transcript shows..."
+    - "In this recording..." / "This audio features..."
+    - "The speaker says..." / "We can hear..."
+    - "The clip contains..." / "The recording shows..."
+
+    INSTEAD, describe the content directly:
+    - BAD: "The audio features a discussion about climate change"
+    - GOOD: "A panel discusses climate change impacts and solutions"
+
+    Write as if describing reality, not describing a recording of reality.
+  </language_guidelines>`;
+function buildUserPrompt4({
+  tone,
+  transcriptText,
+  isCleanTranscript = true,
+  promptOverrides,
+  isAudioOnly = false,
+  titleLength,
+  descriptionLength,
+  tagCount,
+  languageName
 }) {
-  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 contextSections = [createToneSection(TONE_INSTRUCTIONS[tone])];
+  if (languageName) {
+    contextSections.push(createLanguageSection(languageName));
+  } else {
+    contextSections.push({
+      tag: "language",
+      content: "Respond in English. Never switch languages to satisfy length constraints."
+    });
+  }
+  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 generateText5({
+    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");
+  }
+  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");
+  }
+  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
+    }
   };
-  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."
-    );
+function normalizeKeywords(keywords, limit = DEFAULT_SUMMARY_KEYWORD_LIMIT) {
+  if (!Array.isArray(keywords) || keywords.length === 0) {
+    return [];
   }
-  return { accessKeyId, secretAccessKey };
+  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 putObjectWithStorageAdapter(input, adapter) {
-  if (adapter) {
-    await adapter.putObject(input);
-    return;
+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 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
+  const modelConfig = resolveLanguageModelConfig({
+    ...options,
+    model,
+    provider
   });
-}
-async function createPresignedGetUrlWithStorageAdapter(input, adapter) {
-  if (adapter) {
-    return adapter.createPresignedGetUrl(input);
+  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 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
+  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_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(
+      `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 ?? 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
@@ -4002,7 +4420,8 @@ async function uploadDubbedAudioToS3({
   s3Endpoint,
   s3Region,
   s3Bucket,
-  storageAdapter
+  storageAdapter,
+  s3SignedUrlExpirySeconds
 }) {
   "use step";
   const s3AccessKeyId = env_default.S3_ACCESS_KEY_ID;
@@ -4025,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) {
@@ -4192,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"}`);
@@ -4230,24 +4651,24 @@ async function translateAudio(assetId, toLanguageCode, options = {}) {
 // src/workflows/translate-captions.ts
 import {
   APICallError,
-  generateText as generateText5,
+  generateText as generateText6,
   NoObjectGeneratedError,
-  Output as Output5,
+  Output as Output6,
   RetryError,
   TypeValidationError
 } from "ai";
-import dedent5 from "dedent";
-import { z as z6 } from "zod";
-var translationSchema = z6.object({
-  translation: z6.string()
+import dedent6 from "dedent";
+import { z as z7 } from "zod";
+var translationSchema = z7.object({
+  translation: z7.string()
 });
-var SYSTEM_PROMPT4 = dedent5`
+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 = dedent5`
+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.
@@ -4409,14 +4830,6 @@ function buildTranslationChunkRequests(vttContent, assetDurationSeconds, chunkin
     )
   };
 }
-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();
-}
 async function translateVttWithAI({
   vttContent,
   fromLanguageCode,
@@ -4427,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",
@@ -4464,8 +4877,8 @@ async function translateCueChunkWithAI({
 }) {
   "use step";
   const model = await createLanguageModelFromConfig(provider, modelId, credentials);
-  const schema = z6.object({
-    translations: z6.array(z6.string().min(1)).length(cues.length)
+  const schema = z7.object({
+    translations: z7.array(z7.string().min(1)).length(cues.length)
   });
   const cuePayload = cues.map((cue, index) => ({
     index,
@@ -4473,9 +4886,9 @@ async function translateCueChunkWithAI({
     endTime: cue.endTime,
     text: cue.text
   }));
-  const response = await generateText5({
+  const response = await generateText6({
     model,
-    output: Output5.object({ schema }),
+    output: Output6.object({ schema }),
     messages: [
       {
         role: "system",
@@ -4632,7 +5045,8 @@ async function uploadVttToS3({
   s3Endpoint,
   s3Region,
   s3Bucket,
-  storageAdapter
+  storageAdapter,
+  s3SignedUrlExpirySeconds
 }) {
   "use step";
   const s3AccessKeyId = env_default.S3_ACCESS_KEY_ID;
@@ -4655,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 {
@@ -4791,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"}`);
@@ -4824,23 +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