@mux/ai 0.1.2 → 0.1.4

package/dist/index.js

@@ -1,26 +1,10 @@
-import pRetry, { AbortError } from 'p-retry';
-import Mux from '@mux/mux-node';
-import OpenAI from 'openai';
-import Anthropic from '@anthropic-ai/sdk';
-import { z } from 'zod';
-import { zodTextFormat } from 'openai/helpers/zod';
-import { S3Client, GetObjectCommand } from '@aws-sdk/client-s3';
-import { Upload } from '@aws-sdk/lib-storage';
-import { getSignedUrl } from '@aws-sdk/s3-request-presigner';
-
+"use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -33,19 +17,702 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/utils/image-download.ts
-var image_download_exports = {};
-__export(image_download_exports, {
-  downloadImageAsBase64: () => downloadImageAsBase64,
-  downloadImagesAsBase64: () => downloadImagesAsBase64,
-  uploadImageToAnthropicFiles: () => uploadImageToAnthropicFiles
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  primitives: () => primitives_exports,
+  version: () => version,
+  workflows: () => workflows_exports
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/primitives/index.ts
+var primitives_exports = {};
+__export(primitives_exports, {
+  DEFAULT_STORYBOARD_WIDTH: () => DEFAULT_STORYBOARD_WIDTH,
+  buildTranscriptUrl: () => buildTranscriptUrl,
+  chunkByTokens: () => chunkByTokens,
+  chunkText: () => chunkText,
+  chunkVTTCues: () => chunkVTTCues,
+  estimateTokenCount: () => estimateTokenCount,
+  extractTextFromVTT: () => extractTextFromVTT,
+  extractTimestampedTranscript: () => extractTimestampedTranscript,
+  fetchTranscriptForAsset: () => fetchTranscriptForAsset,
+  findCaptionTrack: () => findCaptionTrack,
+  getReadyTextTracks: () => getReadyTextTracks,
+  getStoryboardUrl: () => getStoryboardUrl,
+  getThumbnailUrls: () => getThumbnailUrls,
+  parseVTTCues: () => parseVTTCues,
+  vttTimestampToSeconds: () => vttTimestampToSeconds
+});
+
+// src/lib/url-signing.ts
+var import_mux_node = __toESM(require("@mux/mux-node"));
+
+// src/env.ts
+var import_node_path = __toESM(require("path"));
+var import_dotenv = require("dotenv");
+var import_dotenv_expand = require("dotenv-expand");
+var import_zod = require("zod");
+(0, import_dotenv_expand.expand)((0, import_dotenv.config)({
+  path: import_node_path.default.resolve(
+    process.cwd(),
+    process.env.NODE_ENV === "test" ? ".env.test" : ".env"
+  )
+}));
+function optionalString(description, message) {
+  return import_zod.z.preprocess(
+    (value) => typeof value === "string" && value.trim().length === 0 ? void 0 : value,
+    import_zod.z.string().trim().min(1, message).optional()
+  ).describe(description);
+}
+function requiredString(description, message) {
+  return import_zod.z.preprocess(
+    (value) => typeof value === "string" ? value.trim().length > 0 ? value.trim() : void 0 : value,
+    import_zod.z.string().trim().min(1, message)
+  ).describe(description);
+}
+var EnvSchema = import_zod.z.object({
+  NODE_ENV: import_zod.z.string().default("development").describe("Runtime environment."),
+  MUX_TOKEN_ID: requiredString("Mux access token ID.", "Required to access Mux APIs"),
+  MUX_TOKEN_SECRET: requiredString("Mux access token secret.", "Required to access Mux APIs"),
+  MUX_SIGNING_KEY: optionalString("Mux signing key ID for signed playback URLs.", "Used to sign playback URLs"),
+  MUX_PRIVATE_KEY: optionalString("Mux signing private key for signed playback URLs.", "Used to sign playback URLs"),
+  OPENAI_API_KEY: optionalString("OpenAI API key for OpenAI-backed workflows.", "OpenAI API key"),
+  ANTHROPIC_API_KEY: optionalString("Anthropic API key for Claude-backed workflows.", "Anthropic API key"),
+  GOOGLE_GENERATIVE_AI_API_KEY: optionalString("Google Generative AI API key for Gemini-backed workflows.", "Google Generative AI API key"),
+  ELEVENLABS_API_KEY: optionalString("ElevenLabs API key for audio translation.", "ElevenLabs API key"),
+  HIVE_API_KEY: optionalString("Hive Visual Moderation API key.", "Hive API key"),
+  S3_ENDPOINT: optionalString("S3-compatible endpoint for uploads.", "S3 endpoint"),
+  S3_REGION: optionalString("S3 region (defaults to 'auto' when omitted)."),
+  S3_BUCKET: optionalString("Bucket used for caption and audio uploads.", "S3 bucket"),
+  S3_ACCESS_KEY_ID: optionalString("Access key ID for S3-compatible uploads.", "S3 access key id"),
+  S3_SECRET_ACCESS_KEY: optionalString("Secret access key for S3-compatible uploads.", "S3 secret access key")
+});
+function parseEnv() {
+  const parsedEnv = EnvSchema.safeParse(process.env);
+  if (!parsedEnv.success) {
+    console.error("\u274C Invalid env:");
+    console.error(JSON.stringify(parsedEnv.error.flatten().fieldErrors, null, 2));
+    process.exit(1);
+  }
+  return parsedEnv.data;
+}
+var env = parseEnv();
+var env_default = env;
+
+// src/lib/url-signing.ts
+function resolveSigningContext(config2) {
+  const keyId = config2.muxSigningKey ?? env_default.MUX_SIGNING_KEY;
+  const keySecret = config2.muxPrivateKey ?? env_default.MUX_PRIVATE_KEY;
+  if (!keyId || !keySecret) {
+    return void 0;
+  }
+  return { keyId, keySecret };
+}
+function createSigningClient(context) {
+  return new import_mux_node.default({
+    // These are not needed for signing, but the SDK requires them
+    // Using empty strings as we only need the jwt functionality
+    tokenId: env_default.MUX_TOKEN_ID || "",
+    tokenSecret: env_default.MUX_TOKEN_SECRET || "",
+    jwtSigningKey: context.keyId,
+    jwtPrivateKey: context.keySecret
+  });
+}
+async function signPlaybackId(playbackId, context, type = "video", params) {
+  const client = createSigningClient(context);
+  const stringParams = params ? Object.fromEntries(
+    Object.entries(params).map(([key, value]) => [key, String(value)])
+  ) : void 0;
+  return client.jwt.signPlaybackId(playbackId, {
+    type,
+    expiration: context.expiration || "1h",
+    params: stringParams
+  });
+}
+async function signUrl(url, playbackId, context, type = "video", params) {
+  const token = await signPlaybackId(playbackId, context, type, params);
+  const separator = url.includes("?") ? "&" : "?";
+  return `${url}${separator}token=${token}`;
+}
+
+// src/primitives/storyboards.ts
+var DEFAULT_STORYBOARD_WIDTH = 640;
+async function getStoryboardUrl(playbackId, width = DEFAULT_STORYBOARD_WIDTH, signingContext) {
+  const baseUrl = `https://image.mux.com/${playbackId}/storyboard.png`;
+  if (signingContext) {
+    return signUrl(baseUrl, playbackId, signingContext, "storyboard", { width });
+  }
+  return `${baseUrl}?width=${width}`;
+}
+
+// src/primitives/text-chunking.ts
+function estimateTokenCount(text) {
+  const words = text.trim().split(/\s+/).length;
+  return Math.ceil(words / 0.75);
+}
+function chunkByTokens(text, maxTokens, overlapTokens = 0) {
+  if (!text.trim()) {
+    return [];
+  }
+  const chunks = [];
+  const words = text.trim().split(/\s+/);
+  const wordsPerChunk = Math.floor(maxTokens * 0.75);
+  const overlapWords = Math.floor(overlapTokens * 0.75);
+  let chunkIndex = 0;
+  let currentPosition = 0;
+  while (currentPosition < words.length) {
+    const chunkWords = words.slice(
+      currentPosition,
+      currentPosition + wordsPerChunk
+    );
+    const chunkText2 = chunkWords.join(" ");
+    const tokenCount = estimateTokenCount(chunkText2);
+    chunks.push({
+      id: `chunk-${chunkIndex}`,
+      text: chunkText2,
+      tokenCount
+    });
+    currentPosition += wordsPerChunk - overlapWords;
+    chunkIndex++;
+    if (currentPosition <= (chunkIndex - 1) * (wordsPerChunk - overlapWords)) {
+      break;
+    }
+  }
+  return chunks;
+}
+function createChunkFromCues(cues, index) {
+  const text = cues.map((c) => c.text).join(" ");
+  return {
+    id: `chunk-${index}`,
+    text,
+    tokenCount: estimateTokenCount(text),
+    startTime: cues[0].startTime,
+    endTime: cues[cues.length - 1].endTime
+  };
+}
+function chunkVTTCues(cues, maxTokens, overlapCues = 2) {
+  if (cues.length === 0)
+    return [];
+  const chunks = [];
+  let currentCues = [];
+  let currentTokens = 0;
+  let chunkIndex = 0;
+  for (let i = 0; i < cues.length; i++) {
+    const cue = cues[i];
+    const cueTokens = estimateTokenCount(cue.text);
+    if (currentTokens + cueTokens > maxTokens && currentCues.length > 0) {
+      chunks.push(createChunkFromCues(currentCues, chunkIndex));
+      chunkIndex++;
+      const overlapStart = Math.max(0, currentCues.length - overlapCues);
+      currentCues = currentCues.slice(overlapStart);
+      currentTokens = currentCues.reduce(
+        (sum, c) => sum + estimateTokenCount(c.text),
+        0
+      );
+    }
+    currentCues.push(cue);
+    currentTokens += cueTokens;
+  }
+  if (currentCues.length > 0) {
+    chunks.push(createChunkFromCues(currentCues, chunkIndex));
+  }
+  return chunks;
+}
+function chunkText(text, strategy) {
+  switch (strategy.type) {
+    case "token": {
+      return chunkByTokens(text, strategy.maxTokens, strategy.overlap ?? 0);
+    }
+    default: {
+      const exhaustiveCheck = strategy;
+      throw new Error(`Unsupported chunking strategy: ${exhaustiveCheck}`);
+    }
+  }
+}
+
+// src/primitives/thumbnails.ts
+async function getThumbnailUrls(playbackId, duration, options = {}) {
+  const { interval = 10, width = 640, signingContext } = options;
+  const 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);
+    }
+  }
+  const baseUrl = `https://image.mux.com/${playbackId}/thumbnail.png`;
+  const urlPromises = timestamps.map(async (time) => {
+    if (signingContext) {
+      return signUrl(baseUrl, playbackId, signingContext, "thumbnail", { time, width });
+    }
+    return `${baseUrl}?time=${time}&width=${width}`;
+  });
+  return Promise.all(urlPromises);
+}
+
+// src/primitives/transcripts.ts
+function getReadyTextTracks(asset) {
+  return (asset.tracks || []).filter(
+    (track) => track.type === "text" && track.status === "ready"
+  );
+}
+function findCaptionTrack(asset, languageCode) {
+  const tracks = getReadyTextTracks(asset);
+  if (!tracks.length)
+    return void 0;
+  if (!languageCode) {
+    return tracks[0];
+  }
+  return tracks.find(
+    (track) => track.text_type === "subtitles" && track.language_code === languageCode
+  );
+}
+function extractTextFromVTT(vttContent) {
+  if (!vttContent.trim()) {
+    return "";
+  }
+  const lines = vttContent.split("\n");
+  const textLines = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (!line)
+      continue;
+    if (line === "WEBVTT")
+      continue;
+    if (line.startsWith("NOTE "))
+      continue;
+    if (line.includes("-->"))
+      continue;
+    if (/^[\w-]+$/.test(line) && !line.includes(" "))
+      continue;
+    if (line.startsWith("STYLE") || line.startsWith("REGION"))
+      continue;
+    const cleanLine = line.replace(/<[^>]*>/g, "").trim();
+    if (cleanLine) {
+      textLines.push(cleanLine);
+    }
+  }
+  return textLines.join(" ").replace(/\s+/g, " ").trim();
+}
+function vttTimestampToSeconds(timestamp) {
+  const parts = timestamp.split(":");
+  if (parts.length !== 3)
+    return 0;
+  const hours = Number.parseInt(parts[0], 10) || 0;
+  const minutes = Number.parseInt(parts[1], 10) || 0;
+  const seconds = Number.parseFloat(parts[2]) || 0;
+  return hours * 3600 + minutes * 60 + seconds;
+}
+function extractTimestampedTranscript(vttContent) {
+  if (!vttContent.trim()) {
+    return "";
+  }
+  const lines = vttContent.split("\n");
+  const segments = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (line.includes("-->")) {
+      const startTime = line.split(" --> ")[0].trim();
+      const timeInSeconds = vttTimestampToSeconds(startTime);
+      let j = i + 1;
+      while (j < lines.length && !lines[j].trim()) {
+        j++;
+      }
+      if (j < lines.length) {
+        const text = lines[j].trim().replace(/<[^>]*>/g, "");
+        if (text) {
+          segments.push({ time: timeInSeconds, text });
+        }
+      }
+    }
+  }
+  return segments.map((segment) => `[${Math.floor(segment.time)}s] ${segment.text}`).join("\n");
+}
+function parseVTTCues(vttContent) {
+  if (!vttContent.trim())
+    return [];
+  const lines = vttContent.split("\n");
+  const cues = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (line.includes("-->")) {
+      const [startStr, endStr] = line.split(" --> ").map((s) => s.trim());
+      const startTime = vttTimestampToSeconds(startStr);
+      const endTime = vttTimestampToSeconds(endStr.split(" ")[0]);
+      const textLines = [];
+      let j = i + 1;
+      while (j < lines.length && lines[j].trim() && !lines[j].includes("-->")) {
+        const cleanLine = lines[j].trim().replace(/<[^>]*>/g, "");
+        if (cleanLine)
+          textLines.push(cleanLine);
+        j++;
+      }
+      if (textLines.length > 0) {
+        cues.push({
+          startTime,
+          endTime,
+          text: textLines.join(" ")
+        });
+      }
+    }
+  }
+  return cues;
+}
+async function buildTranscriptUrl(playbackId, trackId, signingContext) {
+  const baseUrl = `https://stream.mux.com/${playbackId}/text/${trackId}.vtt`;
+  if (signingContext) {
+    return signUrl(baseUrl, playbackId, signingContext, "video");
+  }
+  return baseUrl;
+}
+async function fetchTranscriptForAsset(asset, playbackId, options = {}) {
+  const { languageCode, cleanTranscript = true, signingContext } = options;
+  const track = findCaptionTrack(asset, languageCode);
+  if (!track) {
+    return { transcriptText: "" };
+  }
+  if (!track.id) {
+    return { transcriptText: "", track };
+  }
+  const transcriptUrl = await buildTranscriptUrl(playbackId, track.id, signingContext);
+  try {
+    const response = await fetch(transcriptUrl);
+    if (!response.ok) {
+      return { transcriptText: "", transcriptUrl, track };
+    }
+    const rawVtt = await response.text();
+    const transcriptText = cleanTranscript ? extractTextFromVTT(rawVtt) : rawVtt;
+    return { transcriptText, transcriptUrl, track };
+  } catch (error) {
+    console.warn("Failed to fetch transcript:", error);
+    return { transcriptText: "", transcriptUrl, track };
+  }
+}
+
+// src/workflows/index.ts
+var workflows_exports = {};
+__export(workflows_exports, {
+  SUMMARY_KEYWORD_LIMIT: () => SUMMARY_KEYWORD_LIMIT,
+  burnedInCaptionsSchema: () => burnedInCaptionsSchema,
+  chapterSchema: () => chapterSchema,
+  chaptersSchema: () => chaptersSchema,
+  generateChapters: () => generateChapters,
+  generateVideoEmbeddings: () => generateVideoEmbeddings,
+  getModerationScores: () => getModerationScores,
+  getSummaryAndTags: () => getSummaryAndTags,
+  hasBurnedInCaptions: () => hasBurnedInCaptions,
+  summarySchema: () => summarySchema,
+  translateAudio: () => translateAudio,
+  translateCaptions: () => translateCaptions,
+  translationSchema: () => translationSchema
 });
+
+// src/workflows/burned-in-captions.ts
+var import_ai = require("ai");
+
+// node_modules/dedent/dist/dedent.mjs
+function ownKeys(object, enumerableOnly) {
+  var keys = Object.keys(object);
+  if (Object.getOwnPropertySymbols) {
+    var symbols = Object.getOwnPropertySymbols(object);
+    enumerableOnly && (symbols = symbols.filter(function(sym) {
+      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+    })), keys.push.apply(keys, symbols);
+  }
+  return keys;
+}
+function _objectSpread(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = null != arguments[i] ? arguments[i] : {};
+    i % 2 ? ownKeys(Object(source), true).forEach(function(key) {
+      _defineProperty(target, key, source[key]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function(key) {
+      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+    });
+  }
+  return target;
+}
+function _defineProperty(obj, key, value) {
+  key = _toPropertyKey(key);
+  if (key in obj) {
+    Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+function _toPropertyKey(arg) {
+  var key = _toPrimitive(arg, "string");
+  return typeof key === "symbol" ? key : String(key);
+}
+function _toPrimitive(input, hint) {
+  if (typeof input !== "object" || input === null) return input;
+  var prim = input[Symbol.toPrimitive];
+  if (prim !== void 0) {
+    var res = prim.call(input, hint || "default");
+    if (typeof res !== "object") return res;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (hint === "string" ? String : Number)(input);
+}
+var dedent = createDedent({});
+var dedent_default = dedent;
+function createDedent(options) {
+  dedent2.withOptions = (newOptions) => createDedent(_objectSpread(_objectSpread({}, options), newOptions));
+  return dedent2;
+  function dedent2(strings, ...values) {
+    const raw = typeof strings === "string" ? [strings] : strings.raw;
+    const {
+      alignValues = false,
+      escapeSpecialCharacters = Array.isArray(strings),
+      trimWhitespace = true
+    } = options;
+    let result = "";
+    for (let i = 0; i < raw.length; i++) {
+      let next = raw[i];
+      if (escapeSpecialCharacters) {
+        next = next.replace(/\\\n[ \t]*/g, "").replace(/\\`/g, "`").replace(/\\\$/g, "$").replace(/\\\{/g, "{");
+      }
+      result += next;
+      if (i < values.length) {
+        const value = alignValues ? alignValue(values[i], result) : values[i];
+        result += value;
+      }
+    }
+    const lines = result.split("\n");
+    let mindent = null;
+    for (const l of lines) {
+      const m = l.match(/^(\s+)\S+/);
+      if (m) {
+        const indent = m[1].length;
+        if (!mindent) {
+          mindent = indent;
+        } else {
+          mindent = Math.min(mindent, indent);
+        }
+      }
+    }
+    if (mindent !== null) {
+      const m = mindent;
+      result = lines.map((l) => l[0] === " " || l[0] === "	" ? l.slice(m) : l).join("\n");
+    }
+    if (trimWhitespace) {
+      result = result.trim();
+    }
+    if (escapeSpecialCharacters) {
+      result = result.replace(/\\n/g, "\n");
+    }
+    return result;
+  }
+}
+function alignValue(value, precedingText) {
+  if (typeof value !== "string" || !value.includes("\n")) {
+    return value;
+  }
+  const currentLine = precedingText.slice(precedingText.lastIndexOf("\n") + 1);
+  const indentMatch = currentLine.match(/^(\s+)/);
+  if (indentMatch) {
+    const indent = indentMatch[1];
+    return value.replace(/\n/g, `
+${indent}`);
+  }
+  return value;
+}
+
+// src/workflows/burned-in-captions.ts
+var import_zod2 = require("zod");
+
+// src/lib/client-factory.ts
+var import_mux_node2 = __toESM(require("@mux/mux-node"));
+
+// src/lib/providers.ts
+var import_anthropic = require("@ai-sdk/anthropic");
+var import_google = require("@ai-sdk/google");
+var import_openai = require("@ai-sdk/openai");
+var DEFAULT_LANGUAGE_MODELS = {
+  openai: "gpt-5-mini",
+  anthropic: "claude-haiku-4-5",
+  google: "gemini-2.5-flash"
+};
+var DEFAULT_EMBEDDING_MODELS = {
+  openai: "text-embedding-3-small",
+  google: "gemini-embedding-001"
+};
+function requireEnv(value, name) {
+  if (!value) {
+    throw new Error(`Missing ${name}. Set ${name} in your environment or pass it in options.`);
+  }
+  return value;
+}
+function resolveLanguageModel(options = {}) {
+  const provider = options.provider || "openai";
+  const modelId = options.model || DEFAULT_LANGUAGE_MODELS[provider];
+  switch (provider) {
+    case "openai": {
+      const apiKey = options.openaiApiKey ?? env_default.OPENAI_API_KEY;
+      requireEnv(apiKey, "OPENAI_API_KEY");
+      const openai = (0, import_openai.createOpenAI)({
+        apiKey
+      });
+      return {
+        provider,
+        modelId,
+        model: openai(modelId)
+      };
+    }
+    case "anthropic": {
+      const apiKey = options.anthropicApiKey ?? env_default.ANTHROPIC_API_KEY;
+      requireEnv(apiKey, "ANTHROPIC_API_KEY");
+      const anthropic = (0, import_anthropic.createAnthropic)({
+        apiKey
+      });
+      return {
+        provider,
+        modelId,
+        model: anthropic(modelId)
+      };
+    }
+    case "google": {
+      const apiKey = options.googleApiKey ?? env_default.GOOGLE_GENERATIVE_AI_API_KEY;
+      requireEnv(apiKey, "GOOGLE_GENERATIVE_AI_API_KEY");
+      const google = (0, import_google.createGoogleGenerativeAI)({
+        apiKey
+      });
+      return {
+        provider,
+        modelId,
+        model: google(modelId)
+      };
+    }
+    default: {
+      const exhaustiveCheck = provider;
+      throw new Error(`Unsupported provider: ${exhaustiveCheck}`);
+    }
+  }
+}
+function resolveEmbeddingModel(options = {}) {
+  const provider = options.provider || "openai";
+  const modelId = options.model || DEFAULT_EMBEDDING_MODELS[provider];
+  switch (provider) {
+    case "openai": {
+      const apiKey = options.openaiApiKey ?? env_default.OPENAI_API_KEY;
+      requireEnv(apiKey, "OPENAI_API_KEY");
+      const openai = (0, import_openai.createOpenAI)({
+        apiKey
+      });
+      return {
+        provider,
+        modelId,
+        model: openai.embedding(modelId)
+      };
+    }
+    case "google": {
+      const apiKey = options.googleApiKey ?? env_default.GOOGLE_GENERATIVE_AI_API_KEY;
+      requireEnv(apiKey, "GOOGLE_GENERATIVE_AI_API_KEY");
+      const google = (0, import_google.createGoogleGenerativeAI)({
+        apiKey
+      });
+      return {
+        provider,
+        modelId,
+        model: google.textEmbeddingModel(modelId)
+      };
+    }
+    default: {
+      const exhaustiveCheck = provider;
+      throw new Error(`Unsupported embedding provider: ${exhaustiveCheck}`);
+    }
+  }
+}
+
+// src/lib/client-factory.ts
+function validateCredentials(options, requiredProvider) {
+  const muxTokenId = options.muxTokenId ?? env_default.MUX_TOKEN_ID;
+  const muxTokenSecret = options.muxTokenSecret ?? env_default.MUX_TOKEN_SECRET;
+  const openaiApiKey = options.openaiApiKey ?? env_default.OPENAI_API_KEY;
+  const anthropicApiKey = options.anthropicApiKey ?? env_default.ANTHROPIC_API_KEY;
+  const googleApiKey = options.googleApiKey ?? env_default.GOOGLE_GENERATIVE_AI_API_KEY;
+  if (!muxTokenId || !muxTokenSecret) {
+    throw new Error(
+      "Mux credentials are required. Provide muxTokenId and muxTokenSecret in options or set MUX_TOKEN_ID and MUX_TOKEN_SECRET environment variables."
+    );
+  }
+  if (requiredProvider === "openai" && !openaiApiKey) {
+    throw new Error(
+      "OpenAI API key is required. Provide openaiApiKey in options or set OPENAI_API_KEY environment variable."
+    );
+  }
+  if (requiredProvider === "anthropic" && !anthropicApiKey) {
+    throw new Error(
+      "Anthropic API key is required. Provide anthropicApiKey in options or set ANTHROPIC_API_KEY environment variable."
+    );
+  }
+  if (requiredProvider === "google" && !googleApiKey) {
+    throw new Error(
+      "Google Generative AI API key is required. Provide googleApiKey in options or set GOOGLE_GENERATIVE_AI_API_KEY environment variable."
+    );
+  }
+  return {
+    muxTokenId,
+    muxTokenSecret,
+    openaiApiKey,
+    anthropicApiKey,
+    googleApiKey
+  };
+}
+function createMuxClient(credentials) {
+  if (!credentials.muxTokenId || !credentials.muxTokenSecret) {
+    throw new Error("Mux credentials are required. Provide muxTokenId and muxTokenSecret in options or set MUX_TOKEN_ID and MUX_TOKEN_SECRET environment variables.");
+  }
+  return new import_mux_node2.default({
+    tokenId: credentials.muxTokenId,
+    tokenSecret: credentials.muxTokenSecret
+  });
+}
+function createWorkflowClients(options, provider) {
+  const providerToUse = provider || options.provider || "openai";
+  const credentials = validateCredentials(options, providerToUse);
+  const languageModel = resolveLanguageModel({
+    ...options,
+    provider: providerToUse
+  });
+  return {
+    mux: createMuxClient(credentials),
+    languageModel,
+    credentials
+  };
+}
+
+// src/lib/image-download.ts
+var import_node_buffer = require("buffer");
+var import_p_retry = __toESM(require("p-retry"));
+var DEFAULT_OPTIONS = {
+  timeout: 1e4,
+  retries: 3,
+  retryDelay: 1e3,
+  maxRetryDelay: 1e4,
+  exponentialBackoff: true
+};
 async function downloadImageAsBase64(url, options = {}) {
   const opts = { ...DEFAULT_OPTIONS, ...options };
   let attemptCount = 0;
-  return pRetry(
+  return (0, import_p_retry.default)(
     async () => {
       attemptCount++;
       const controller = new AbortController();
@@ -60,18 +727,18 @@ async function downloadImageAsBase64(url, options = {}) {
         clearTimeout(timeoutId);
         if (!response.ok) {
           if (response.status >= 400 && response.status < 500 && response.status !== 429) {
-            throw new AbortError(`HTTP ${response.status}: ${response.statusText}`);
+            throw new import_p_retry.AbortError(`HTTP ${response.status}: ${response.statusText}`);
           }
           throw new Error(`HTTP ${response.status}: ${response.statusText}`);
         }
         const contentType = response.headers.get("content-type");
         if (!contentType?.startsWith("image/")) {
-          throw new AbortError(`Invalid content type: ${contentType}. Expected image/*`);
+          throw new import_p_retry.AbortError(`Invalid content type: ${contentType}. Expected image/*`);
         }
         const arrayBuffer = await response.arrayBuffer();
-        const buffer = Buffer.from(arrayBuffer);
+        const buffer = import_node_buffer.Buffer.from(arrayBuffer);
         if (buffer.length === 0) {
-          throw new AbortError("Downloaded image is empty");
+          throw new import_p_retry.AbortError("Downloaded image is empty");
         }
         const base64Data = `data:${contentType};base64,${buffer.toString("base64")}`;
         return {
@@ -84,7 +751,7 @@ async function downloadImageAsBase64(url, options = {}) {
         };
       } catch (error) {
         clearTimeout(timeoutId);
-        if (error instanceof AbortError) {
+        if (error instanceof import_p_retry.AbortError) {
           throw error;
         }
         if (error instanceof Error) {
@@ -122,68 +789,548 @@ async function downloadImagesAsBase64(urls, options = {}, maxConcurrent = 5) {
   }
   return results;
 }
-async function uploadImageToAnthropicFiles(url, anthropicApiKey, options = {}) {
-  const downloadResult = await downloadImageAsBase64(url, options);
-  const formData = new FormData();
-  const imageBlob = new Blob([downloadResult.buffer], {
-    type: downloadResult.contentType
-  });
-  const extension = downloadResult.contentType.split("/")[1] || "png";
-  formData.append("file", imageBlob, `image.${extension}`);
-  const response = await fetch("https://api.anthropic.com/v1/files", {
-    method: "POST",
-    headers: {
-      "x-api-key": anthropicApiKey,
-      "anthropic-version": "2023-06-01",
-      "anthropic-beta": "files-api-2025-04-14"
-      // Don't set Content-Type header - let fetch set it with boundary for multipart
-    },
-    body: formData
-  });
-  if (!response.ok) {
-    const errorText = await response.text();
-    throw new Error(`Anthropic Files API error: ${response.status} ${response.statusText} - ${errorText}`);
+
+// src/lib/mux-assets.ts
+function getPlaybackId(asset) {
+  const playbackIds = asset.playback_ids || [];
+  const publicPlaybackId = playbackIds.find((pid) => pid.policy === "public");
+  if (publicPlaybackId?.id) {
+    return { id: publicPlaybackId.id, policy: "public" };
+  }
+  const signedPlaybackId = playbackIds.find((pid) => pid.policy === "signed");
+  if (signedPlaybackId?.id) {
+    return { id: signedPlaybackId.id, policy: "signed" };
+  }
+  throw new Error(
+    "No public or signed playback ID found for this asset. A public or signed playback ID is required. DRM playback IDs are not currently supported."
+  );
+}
+async function getPlaybackIdForAsset(mux, assetId) {
+  const asset = await mux.video.assets.retrieve(assetId);
+  const { id: playbackId, policy } = getPlaybackId(asset);
+  return { asset, playbackId, policy };
+}
+
+// src/lib/prompt-builder.ts
+function renderSection(section) {
+  const { tag, content, attributes } = section;
+  const XML_NAME_PATTERN = /^[A-Z_][\w.:-]*$/i;
+  const assertValidXmlName = (name, context) => {
+    if (!XML_NAME_PATTERN.test(name)) {
+      throw new Error(`Invalid XML ${context} name: "${name}"`);
+    }
+  };
+  const escapeXmlText = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;/");
+  const escapeXmlAttribute = (value) => escapeXmlText(value).replace(/"/g, "&quot;");
+  if (!content.trim()) {
+    return "";
+  }
+  assertValidXmlName(tag, "tag");
+  const attrString = attributes ? ` ${Object.entries(attributes).map(([key, value]) => {
+    assertValidXmlName(key, "attribute");
+    return `${key}="${escapeXmlAttribute(value)}"`;
+  }).join(" ")}` : "";
+  const safeContent = escapeXmlText(content.trim());
+  return `<${tag}${attrString}>
+${safeContent}
+</${tag}>`;
+}
+function resolveSection(defaultSection, override) {
+  if (override === void 0) {
+    return defaultSection;
+  }
+  if (typeof override === "string") {
+    return { ...defaultSection, content: override };
   }
-  const fileResult = await response.json();
+  return override;
+}
+function createPromptBuilder(config2) {
+  const { template, sectionOrder } = config2;
+  const getSection = (section, override) => {
+    const resolved = resolveSection(template[section], override);
+    return renderSection(resolved);
+  };
+  const build = (overrides) => {
+    const sections = sectionOrder.map((sectionKey) => getSection(sectionKey, overrides?.[sectionKey])).filter(Boolean);
+    return sections.join("\n\n");
+  };
+  const buildWithContext = (overrides, additionalSections) => {
+    const basePrompt = build(overrides);
+    if (!additionalSections?.length) {
+      return basePrompt;
+    }
+    const additional = additionalSections.map(renderSection).filter(Boolean).join("\n\n");
+    return additional ? `${basePrompt}
+
+${additional}` : basePrompt;
+  };
   return {
-    fileId: fileResult.id,
-    url: downloadResult.url,
-    contentType: downloadResult.contentType,
-    sizeBytes: downloadResult.sizeBytes
+    template,
+    build,
+    buildWithContext,
+    getSection
   };
 }
-var DEFAULT_OPTIONS;
-var init_image_download = __esm({
-  "src/utils/image-download.ts"() {
-    DEFAULT_OPTIONS = {
-      timeout: 1e4,
-      retries: 3,
-      retryDelay: 1e3,
-      maxRetryDelay: 1e4,
-      exponentialBackoff: true
-    };
-  }
+function createTranscriptSection(transcriptText, format = "plain text") {
+  return {
+    tag: "transcript",
+    content: transcriptText,
+    attributes: { format }
+  };
+}
+function createToneSection(instruction) {
+  return {
+    tag: "tone",
+    content: instruction
+  };
+}
+
+// src/workflows/burned-in-captions.ts
+var burnedInCaptionsSchema = import_zod2.z.object({
+  hasBurnedInCaptions: import_zod2.z.boolean(),
+  confidence: import_zod2.z.number().min(0).max(1),
+  detectedLanguage: import_zod2.z.string().nullable()
 });
+var SYSTEM_PROMPT = dedent_default`
+  <role>
+    You are an expert at analyzing video frames to detect burned-in captions (also called open captions or hardcoded subtitles).
+    These are text overlays that are permanently embedded in the video image, common on TikTok, Instagram Reels, and other social media platforms.
+  </role>
 
-// src/moderation.ts
-init_image_download();
-var DEFAULT_THRESHOLDS = {
-  sexual: 0.7,
-  violence: 0.8
-};
-async function processConcurrently(items, processor, maxConcurrent = 5) {
-  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);
-  }
-  return results;
-}
-var HIVE_SEXUAL_CATEGORIES = [
-  "general_nsfw",
-  "general_suggestive",
+  <critical_note>
+    Burned-in captions must appear consistently across MOST frames in the storyboard.
+    Text appearing in only 1-2 frames at the end is typically marketing copy, taglines, or end-cards - NOT burned-in captions.
+  </critical_note>
+
+  <confidence_scoring>
+    Use this rubric to determine your confidence score (0.0-1.0):
+
+    - Score 1.0: Definitive captions - text overlays visible in most frames, consistent positioning, content changes between frames indicating dialogue/narration, clear caption-style formatting
+    - Score 0.7-0.9: Strong evidence - captions visible across multiple frames with consistent placement, but minor ambiguity (e.g., some frames unclear, atypical styling)
+    - Score 0.4-0.6: Moderate evidence - text present in several frames but uncertain classification (e.g., could be captions or persistent on-screen graphics, ambiguous formatting)
+    - Score 0.1-0.3: Weak evidence - minimal text detected, appears in only a few frames, likely marketing copy or end-cards rather than captions
+    - Score 0.0: No captions - no text overlays detected, or text is clearly not captions (logos, watermarks, scene content, single end-card)
+  </confidence_scoring>
+
+  <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>
+
+  <capabilities>
+    - Detect and analyze text overlays in video frames
+    - Distinguish between captions and other text elements (marketing, logos, UI)
+    - Identify language of detected caption text
+    - Assess confidence in caption detection
+  </capabilities>
+
+  <constraints>
+    - Only classify as burned-in captions when evidence is clear across multiple frames
+    - Base decisions on observable visual evidence
+    - Return structured data matching the requested schema
+  </constraints>`;
+var burnedInCaptionsPromptBuilder = createPromptBuilder({
+  template: {
+    task: {
+      tag: "task",
+      content: dedent_default`
+        Analyze the provided video storyboard to detect burned-in captions (hardcoded subtitles).
+        Count frames with text vs no text, note position consistency and whether text changes across frames.
+        Decide if captions exist, with confidence (0.0-1.0) and detected language if any.`
+    },
+    analysisSteps: {
+      tag: "analysis_steps",
+      content: dedent_default`
+        1. COUNT how many frames contain text overlays vs. how many don't
+        2. Check if text appears in consistent positions across multiple frames
+        3. Verify text changes content between frames (indicating dialogue/narration)
+        4. Ensure text has caption-style formatting (contrasting colors, readable fonts)
+        5. If captions are detected, identify the language of the text`
+    },
+    positiveIndicators: {
+      tag: "classify_as_captions",
+      content: dedent_default`
+        ONLY classify as burned-in captions if:
+        - Text appears in multiple frames (not just 1-2 end frames)
+        - Text positioning is consistent across those frames
+        - Content suggests dialogue, narration, or subtitles (not marketing)
+        - Formatting looks like captions (not graphics/logos)`
+    },
+    negativeIndicators: {
+      tag: "not_captions",
+      content: dedent_default`
+        DO NOT classify as burned-in captions:
+        - Marketing taglines appearing only in final 1-2 frames
+        - Single words or phrases that don't change between frames
+        - Graphics, logos, watermarks, or UI elements
+        - Text that's part of the original scene content
+        - End-cards with calls-to-action or brand messaging`
+    }
+  },
+  sectionOrder: ["task", "analysisSteps", "positiveIndicators", "negativeIndicators"]
+});
+function buildUserPrompt(promptOverrides) {
+  return burnedInCaptionsPromptBuilder.build(promptOverrides);
+}
+var DEFAULT_PROVIDER = "openai";
+async function hasBurnedInCaptions(assetId, options = {}) {
+  const {
+    provider = DEFAULT_PROVIDER,
+    model,
+    imageSubmissionMode = "url",
+    imageDownloadOptions,
+    promptOverrides,
+    ...config2
+  } = options;
+  const userPrompt = buildUserPrompt(promptOverrides);
+  const clients = createWorkflowClients(
+    { ...config2, model },
+    provider
+  );
+  const { playbackId, policy } = await getPlaybackIdForAsset(clients.mux, assetId);
+  const signingContext = resolveSigningContext(options);
+  if (policy === "signed" && !signingContext) {
+    throw new Error(
+      "Signed playback ID requires signing credentials. Provide muxSigningKey and muxPrivateKey in options or set MUX_SIGNING_KEY and MUX_PRIVATE_KEY environment variables."
+    );
+  }
+  const imageUrl = await getStoryboardUrl(playbackId, 640, policy === "signed" ? signingContext : void 0);
+  const analyzeStoryboard = async (imageDataUrl) => {
+    const response = await (0, import_ai.generateObject)({
+      model: clients.languageModel.model,
+      schema: burnedInCaptionsSchema,
+      abortSignal: options.abortSignal,
+      experimental_telemetry: { isEnabled: true },
+      messages: [
+        {
+          role: "system",
+          content: SYSTEM_PROMPT
+        },
+        {
+          role: "user",
+          content: [
+            { type: "text", text: userPrompt },
+            { type: "image", image: imageDataUrl }
+          ]
+        }
+      ]
+    });
+    return {
+      result: response.object,
+      usage: {
+        inputTokens: response.usage.inputTokens,
+        outputTokens: response.usage.outputTokens,
+        totalTokens: response.usage.totalTokens,
+        reasoningTokens: response.usage.reasoningTokens,
+        cachedInputTokens: response.usage.cachedInputTokens
+      }
+    };
+  };
+  let analysisResponse;
+  if (imageSubmissionMode === "base64") {
+    const downloadResult = await downloadImageAsBase64(imageUrl, imageDownloadOptions);
+    analysisResponse = await analyzeStoryboard(downloadResult.base64Data);
+  } else {
+    analysisResponse = await analyzeStoryboard(imageUrl);
+  }
+  if (!analysisResponse.result) {
+    throw new Error("No analysis result received from AI provider");
+  }
+  return {
+    assetId,
+    hasBurnedInCaptions: analysisResponse.result.hasBurnedInCaptions ?? false,
+    confidence: analysisResponse.result.confidence ?? 0,
+    detectedLanguage: analysisResponse.result.detectedLanguage ?? null,
+    storyboardUrl: imageUrl,
+    usage: analysisResponse.usage
+  };
+}
+
+// src/workflows/chapters.ts
+var import_ai2 = require("ai");
+var import_zod3 = require("zod");
+
+// src/lib/retry.ts
+var DEFAULT_RETRY_OPTIONS = {
+  maxRetries: 3,
+  baseDelay: 2e3,
+  maxDelay: 1e4
+};
+function defaultShouldRetry(error, _attempt) {
+  return Boolean(error.message && error.message.includes("Timeout while downloading"));
+}
+function calculateDelay(attempt, baseDelay, maxDelay) {
+  const exponentialDelay = baseDelay * 2 ** (attempt - 1);
+  const delayWithJitter = exponentialDelay * (0.5 + Math.random() * 0.5);
+  return Math.min(delayWithJitter, maxDelay);
+}
+async function withRetry(fn, {
+  maxRetries = DEFAULT_RETRY_OPTIONS.maxRetries,
+  baseDelay = DEFAULT_RETRY_OPTIONS.baseDelay,
+  maxDelay = DEFAULT_RETRY_OPTIONS.maxDelay,
+  shouldRetry = defaultShouldRetry
+} = {}) {
+  let lastError;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+      const isLastAttempt = attempt === maxRetries;
+      if (isLastAttempt || !shouldRetry(lastError, attempt + 1)) {
+        throw lastError;
+      }
+      const delay2 = calculateDelay(attempt + 1, baseDelay, maxDelay);
+      console.warn(
+        `Attempt ${attempt + 1} failed: ${lastError.message}. Retrying in ${Math.round(delay2)}ms...`
+      );
+      await new Promise((resolve) => setTimeout(resolve, delay2));
+    }
+  }
+  throw lastError || new Error("Retry failed with unknown error");
+}
+
+// src/workflows/chapters.ts
+var chapterSchema = import_zod3.z.object({
+  startTime: import_zod3.z.number(),
+  title: import_zod3.z.string()
+});
+var chaptersSchema = import_zod3.z.object({
+  chapters: import_zod3.z.array(chapterSchema)
+});
+var DEFAULT_PROVIDER2 = "openai";
+var SYSTEM_PROMPT2 = `Your role is to segment the following captions into chunked chapters, summarising each chapter with a title.
+
+Analyze the transcript and create logical chapter breaks based on topic changes, major transitions, or distinct sections of content. Each chapter should represent a meaningful segment of the video.
+
+You must respond with valid JSON in exactly this format:
+{
+  "chapters": [
+    {"startTime": 0, "title": "Introduction"},
+    {"startTime": 45.5, "title": "Main Topic Discussion"},
+    {"startTime": 120.0, "title": "Conclusion"}
+  ]
+}
+
+Important rules:
+- startTime must be in seconds (not HH:MM:SS format)
+- Always start with startTime: 0 for the first chapter
+- Create 3-8 chapters depending on content length and natural breaks
+- Chapter titles should be concise and descriptive
+- Do not include any text before or after the JSON
+- The JSON must be valid and parseable`;
+async function generateChapters(assetId, languageCode, options = {}) {
+  const { provider = DEFAULT_PROVIDER2, model, abortSignal } = options;
+  const clients = createWorkflowClients({ ...options, model }, provider);
+  const { asset: assetData, playbackId, policy } = await getPlaybackIdForAsset(clients.mux, assetId);
+  const signingContext = resolveSigningContext(options);
+  if (policy === "signed" && !signingContext) {
+    throw new Error(
+      "Signed playback ID requires signing credentials. Provide muxSigningKey and muxPrivateKey in options or set MUX_SIGNING_KEY and MUX_PRIVATE_KEY environment variables."
+    );
+  }
+  const transcriptResult = await fetchTranscriptForAsset(assetData, playbackId, {
+    languageCode,
+    cleanTranscript: false,
+    // keep timestamps for chapter segmentation
+    signingContext: policy === "signed" ? signingContext : void 0
+  });
+  if (!transcriptResult.track || !transcriptResult.transcriptText) {
+    const availableLanguages = getReadyTextTracks(assetData).map((t) => t.language_code).filter(Boolean).join(", ");
+    throw new Error(
+      `No caption track found for language '${languageCode}'. Available languages: ${availableLanguages || "none"}`
+    );
+  }
+  const timestampedTranscript = extractTimestampedTranscript(transcriptResult.transcriptText);
+  if (!timestampedTranscript) {
+    throw new Error("No usable content found in caption track");
+  }
+  let chaptersData = null;
+  try {
+    const response = await withRetry(
+      () => (0, import_ai2.generateObject)({
+        model: clients.languageModel.model,
+        schema: chaptersSchema,
+        abortSignal,
+        messages: [
+          {
+            role: "system",
+            content: SYSTEM_PROMPT2
+          },
+          {
+            role: "user",
+            content: timestampedTranscript
+          }
+        ]
+      })
+    );
+    chaptersData = response.object;
+  } catch (error) {
+    throw new Error(
+      `Failed to generate chapters with ${provider}: ${error instanceof Error ? error.message : "Unknown error"}`
+    );
+  }
+  if (!chaptersData || !chaptersData.chapters) {
+    throw new Error("No chapters generated from AI response");
+  }
+  const validChapters = chaptersData.chapters.filter((chapter) => typeof chapter.startTime === "number" && typeof chapter.title === "string").sort((a, b) => a.startTime - b.startTime);
+  if (validChapters.length === 0) {
+    throw new Error("No valid chapters found in AI response");
+  }
+  if (validChapters[0].startTime !== 0) {
+    validChapters[0].startTime = 0;
+  }
+  return {
+    assetId,
+    languageCode,
+    chapters: validChapters
+  };
+}
+
+// src/workflows/embeddings.ts
+var import_ai3 = require("ai");
+var DEFAULT_PROVIDER3 = "openai";
+var DEFAULT_CHUNKING_STRATEGY = {
+  type: "token",
+  maxTokens: 500,
+  overlap: 100
+};
+var DEFAULT_BATCH_SIZE = 5;
+function averageEmbeddings(embeddings) {
+  if (embeddings.length === 0) {
+    return [];
+  }
+  const dimensions = embeddings[0].length;
+  const averaged = Array.from({ length: dimensions }, () => 0);
+  for (const embedding of embeddings) {
+    for (let i = 0; i < dimensions; i++) {
+      averaged[i] += embedding[i];
+    }
+  }
+  for (let i = 0; i < dimensions; i++) {
+    averaged[i] /= embeddings.length;
+  }
+  return averaged;
+}
+async function generateChunkEmbeddings(chunks, model, batchSize, abortSignal) {
+  const results = [];
+  for (let i = 0; i < chunks.length; i += batchSize) {
+    const batch = chunks.slice(i, i + batchSize);
+    const batchResults = await Promise.all(
+      batch.map(async (chunk) => {
+        const response = await withRetry(
+          () => (0, import_ai3.embed)({
+            model,
+            value: chunk.text,
+            abortSignal
+          })
+        );
+        return {
+          chunkId: chunk.id,
+          embedding: response.embedding,
+          metadata: {
+            startTime: chunk.startTime,
+            endTime: chunk.endTime,
+            tokenCount: chunk.tokenCount
+          }
+        };
+      })
+    );
+    results.push(...batchResults);
+  }
+  return results;
+}
+async function generateVideoEmbeddings(assetId, options = {}) {
+  const {
+    provider = DEFAULT_PROVIDER3,
+    model,
+    languageCode,
+    chunkingStrategy = DEFAULT_CHUNKING_STRATEGY,
+    batchSize = DEFAULT_BATCH_SIZE,
+    abortSignal
+  } = options;
+  const credentials = validateCredentials(options, provider === "google" ? "google" : "openai");
+  const muxClient = createMuxClient(credentials);
+  const embeddingModel = resolveEmbeddingModel({ ...options, provider, model });
+  const { asset: assetData, playbackId, policy } = await getPlaybackIdForAsset(
+    muxClient,
+    assetId
+  );
+  const signingContext = resolveSigningContext(options);
+  if (policy === "signed" && !signingContext) {
+    throw new Error(
+      "Signed playback ID requires signing credentials. Provide muxSigningKey and muxPrivateKey in options or set MUX_SIGNING_KEY and MUX_PRIVATE_KEY environment variables."
+    );
+  }
+  const useVttChunking = chunkingStrategy.type === "vtt";
+  const transcriptResult = await fetchTranscriptForAsset(assetData, playbackId, {
+    languageCode,
+    cleanTranscript: !useVttChunking,
+    signingContext: policy === "signed" ? signingContext : void 0
+  });
+  if (!transcriptResult.track || !transcriptResult.transcriptText) {
+    const availableLanguages = getReadyTextTracks(assetData).map((t) => t.language_code).filter(Boolean).join(", ");
+    throw new Error(
+      `No caption track found${languageCode ? ` for language '${languageCode}'` : ""}. Available languages: ${availableLanguages || "none"}`
+    );
+  }
+  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");
+  }
+  let chunkEmbeddings;
+  try {
+    chunkEmbeddings = await generateChunkEmbeddings(
+      chunks,
+      embeddingModel.model,
+      batchSize,
+      abortSignal
+    );
+  } catch (error) {
+    throw new Error(
+      `Failed to generate embeddings with ${provider}: ${error instanceof Error ? error.message : "Unknown error"}`
+    );
+  }
+  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,
+    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()
+    }
+  };
+}
+
+// src/workflows/moderation.ts
+var DEFAULT_THRESHOLDS = {
+  sexual: 0.7,
+  violence: 0.8
+};
+var DEFAULT_PROVIDER4 = "openai";
+var HIVE_ENDPOINT = "https://api.thehive.ai/api/v2/task/sync";
+var HIVE_SEXUAL_CATEGORIES = [
+  "general_nsfw",
+  "general_suggestive",
   "yes_sexual_activity",
   "female_underwear",
   "male_underwear",
@@ -216,280 +1363,183 @@ var HIVE_VIOLENCE_CATEGORIES = [
   "fights",
   "garm_death_injury_or_military_conflict"
 ];
-function getThumbnailUrls(playbackId, duration, options = {}) {
-  const { interval = 10, width = 640 } = options;
-  const 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);
-    }
+async function processConcurrently(items, processor, maxConcurrent = 5) {
+  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);
   }
-  return timestamps.map(
-    (time) => `https://image.mux.com/${playbackId}/thumbnail.png?time=${time}&width=${width}`
-  );
+  return results;
 }
-async function requestOpenAIModeration(imageUrls, openaiClient, model, maxConcurrent = 5, submissionMode = "url", downloadOptions) {
-  if (submissionMode === "base64") {
+async function requestOpenAIModeration(imageUrls, apiKey, model, maxConcurrent = 5, submissionMode = "url", downloadOptions) {
+  const targetUrls = submissionMode === "base64" ? (await downloadImagesAsBase64(imageUrls, downloadOptions, maxConcurrent)).map(
+    (img) => ({ url: img.url, image: img.base64Data })
+  ) : imageUrls.map((url) => ({ url, image: url }));
+  const moderate = async (entry) => {
     try {
-      const downloadResults = await downloadImagesAsBase64(imageUrls, downloadOptions, maxConcurrent);
-      const processor2 = async (downloadResult) => {
-        try {
-          const moderation = await openaiClient.moderations.create({
-            model,
-            input: [
-              {
-                type: "image_url",
-                image_url: {
-                  url: downloadResult.base64Data
-                  // Use base64 data URI
-                }
+      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: [
+            {
+              type: "image_url",
+              image_url: {
+                url: entry.image
               }
-            ]
-          });
-          const categoryScores = moderation.results[0].category_scores;
-          return {
-            url: downloadResult.url,
-            // Return original URL for tracking
-            sexual: categoryScores.sexual || 0,
-            violence: categoryScores.violence || 0,
-            error: false
-          };
-        } catch (error) {
-          console.error(`Failed to moderate downloaded image ${downloadResult.url}:`, error);
-          return {
-            url: downloadResult.url,
-            sexual: 0,
-            violence: 0,
-            error: true
-          };
-        }
-      };
-      return processConcurrently(downloadResults, processor2, maxConcurrent);
-    } catch (error) {
-      console.error("Failed to download images for base64 submission:", error);
-      return imageUrls.map((url) => ({
-        url,
-        sexual: 0,
-        violence: 0,
-        error: true
-      }));
-    }
-  }
-  const processor = async (url) => {
-    try {
-      const moderation = await openaiClient.moderations.create({
-        model,
-        input: [
-          {
-            type: "image_url",
-            image_url: {
-              url
             }
-          }
-        ]
+          ]
+        })
       });
-      const categoryScores = moderation.results[0].category_scores;
+      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,
+        url: entry.url,
         sexual: categoryScores.sexual || 0,
         violence: categoryScores.violence || 0,
         error: false
       };
     } catch (error) {
-      console.error("Failed to moderate image:", error);
+      console.error("OpenAI moderation failed:", error);
       return {
-        url,
+        url: entry.url,
         sexual: 0,
         violence: 0,
         error: true
       };
     }
   };
-  return processConcurrently(imageUrls, processor, maxConcurrent);
+  return processConcurrently(targetUrls, moderate, maxConcurrent);
 }
-async function requestHiveModeration(imageUrls, hiveApiKey, maxConcurrent = 5, submissionMode = "url", downloadOptions) {
-  if (submissionMode === "base64") {
-    try {
-      const downloadResults = await downloadImagesAsBase64(imageUrls, downloadOptions, maxConcurrent);
-      const processor2 = async (downloadResult) => {
-        try {
-          const formData = new FormData();
-          const imageBlob = new Blob([downloadResult.buffer], {
-            type: downloadResult.contentType
-          });
-          const extension = downloadResult.contentType.split("/")[1] || "png";
-          formData.append("media", imageBlob, `image.${extension}`);
-          const response = await fetch("https://api.thehive.ai/api/v2/task/sync", {
-            method: "POST",
-            headers: {
-              "Authorization": `Token ${hiveApiKey}`
-              // Don't set Content-Type header - let fetch set it with boundary for multipart
-            },
-            body: formData
-          });
-          if (!response.ok) {
-            throw new Error(`Hive API error: ${response.statusText}`);
-          }
-          const hiveResult = await response.json();
-          const classes = hiveResult.status?.[0]?.response?.output?.[0]?.classes || [];
-          const scoreMap = Object.fromEntries(classes.map((c) => [c.class, c.score]));
-          const sexualScores = HIVE_SEXUAL_CATEGORIES.map(
-            (category) => scoreMap[category] || 0
-          );
-          const violenceScores = HIVE_VIOLENCE_CATEGORIES.map(
-            (category) => scoreMap[category] || 0
-          );
-          return {
-            url: downloadResult.url,
-            // Return original URL for tracking
-            sexual: Math.max(...sexualScores, 0),
-            violence: Math.max(...violenceScores, 0),
-            error: false
-          };
-        } catch (error) {
-          console.error(`Failed to moderate uploaded image ${downloadResult.url}:`, error);
-          return {
-            url: downloadResult.url,
-            sexual: 0,
-            violence: 0,
-            error: true
-          };
-        }
-      };
-      return processConcurrently(downloadResults, processor2, maxConcurrent);
-    } catch (error) {
-      console.error("Failed to download images for Hive multipart upload:", error);
-      return imageUrls.map((url) => ({
-        url,
-        sexual: 0,
-        violence: 0,
-        error: true
-      }));
+function getHiveCategoryScores(classes, categoryNames) {
+  const scoreMap = Object.fromEntries(
+    classes.map((c) => [c.class, c.score])
+  );
+  const scores = categoryNames.map((category) => scoreMap[category] || 0);
+  return Math.max(...scores, 0);
+}
+async function requestHiveModeration(imageUrls, apiKey, maxConcurrent = 5, submissionMode = "url", downloadOptions) {
+  const targets = submissionMode === "base64" ? (await downloadImagesAsBase64(imageUrls, downloadOptions, maxConcurrent)).map((img) => ({
+    url: img.url,
+    source: {
+      kind: "file",
+      buffer: img.buffer,
+      contentType: img.contentType
     }
-  }
-  const processor = async (url) => {
+  })) : imageUrls.map((url) => ({
+    url,
+    source: { kind: "url", value: url }
+  }));
+  const moderate = async (entry) => {
     try {
-      const response = await fetch("https://api.thehive.ai/api/v2/task/sync", {
+      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 res = await fetch(HIVE_ENDPOINT, {
         method: "POST",
         headers: {
-          "Authorization": `Token ${hiveApiKey}`,
-          "Content-Type": "application/json"
+          Accept: "application/json",
+          Authorization: `Token ${apiKey}`
         },
-        body: JSON.stringify({ url })
+        body: formData
       });
-      if (!response.ok) {
-        throw new Error(`Hive API error: ${response.statusText}`);
+      const json = await res.json().catch(() => void 0);
+      if (!res.ok) {
+        throw new Error(
+          `Hive moderation error: ${res.status} ${res.statusText} - ${JSON.stringify(json)}`
+        );
       }
-      const hiveResult = await response.json();
-      const classes = hiveResult.status?.[0]?.response?.output?.[0]?.classes || [];
-      const scoreMap = Object.fromEntries(classes.map((c) => [c.class, c.score]));
-      const sexualScores = HIVE_SEXUAL_CATEGORIES.map(
-        (category) => scoreMap[category] || 0
-      );
-      const violenceScores = HIVE_VIOLENCE_CATEGORIES.map(
-        (category) => scoreMap[category] || 0
-      );
+      const classes = json?.status?.[0]?.response?.output?.[0]?.classes || [];
       return {
-        url,
-        sexual: Math.max(...sexualScores, 0),
-        violence: Math.max(...violenceScores, 0),
+        url: entry.url,
+        sexual: getHiveCategoryScores(classes, HIVE_SEXUAL_CATEGORIES),
+        violence: getHiveCategoryScores(classes, HIVE_VIOLENCE_CATEGORIES),
         error: false
       };
     } catch (error) {
-      console.error("Failed to moderate image with Hive:", error);
+      console.error("Hive moderation failed:", error);
       return {
-        url,
+        url: entry.url,
         sexual: 0,
         violence: 0,
         error: true
       };
     }
   };
-  return processConcurrently(imageUrls, processor, maxConcurrent);
+  return processConcurrently(targets, moderate, maxConcurrent);
 }
 async function getModerationScores(assetId, options = {}) {
   const {
-    provider = "openai",
-    model = "omni-moderation-latest",
+    provider = DEFAULT_PROVIDER4,
+    model = provider === "openai" ? "omni-moderation-latest" : void 0,
     thresholds = DEFAULT_THRESHOLDS,
     thumbnailInterval = 10,
     thumbnailWidth = 640,
     maxConcurrent = 5,
     imageSubmissionMode = "url",
-    imageDownloadOptions,
-    muxTokenId,
-    muxTokenSecret,
-    openaiApiKey,
-    ...config
+    imageDownloadOptions
   } = options;
-  if (provider !== "openai" && provider !== "hive") {
-    throw new Error("Only OpenAI and Hive providers are currently supported");
-  }
-  const muxId = muxTokenId || process.env.MUX_TOKEN_ID;
-  const muxSecret = muxTokenSecret || process.env.MUX_TOKEN_SECRET;
-  const openaiKey = openaiApiKey || process.env.OPENAI_API_KEY;
-  const hiveKey = options.hiveApiKey || process.env.HIVE_API_KEY;
-  if (!muxId || !muxSecret) {
-    throw new Error("Mux credentials are required. Provide muxTokenId and muxTokenSecret in options or set MUX_TOKEN_ID and MUX_TOKEN_SECRET environment variables.");
-  }
-  if (provider === "openai" && !openaiKey) {
-    throw new Error("OpenAI API key is required for OpenAI provider. Provide openaiApiKey in options or set OPENAI_API_KEY environment variable.");
-  }
-  if (provider === "hive" && !hiveKey) {
-    throw new Error("Hive API key is required for Hive provider. Provide hiveApiKey in options or set HIVE_API_KEY environment variable.");
-  }
-  const mux = new Mux({
-    tokenId: muxId,
-    tokenSecret: muxSecret
-  });
-  let openaiClient;
-  if (provider === "openai") {
-    openaiClient = new OpenAI({
-      apiKey: openaiKey
-    });
-  }
-  let assetData;
-  try {
-    const asset = await mux.video.assets.retrieve(assetId);
-    assetData = asset;
-  } catch (error) {
-    throw new Error(`Failed to fetch asset from Mux: ${error instanceof Error ? error.message : "Unknown error"}`);
-  }
-  const publicPlaybackIds = assetData.playback_ids?.filter((pid) => pid.policy === "public") || [];
-  if (publicPlaybackIds.length === 0) {
-    throw new Error("No public playback IDs found for this asset. Moderation requires public playback access.");
+  const credentials = validateCredentials(options, provider === "openai" ? "openai" : void 0);
+  const muxClient = createMuxClient(credentials);
+  const { asset, playbackId, policy } = await getPlaybackIdForAsset(muxClient, assetId);
+  const duration = asset.duration || 0;
+  const signingContext = resolveSigningContext(options);
+  if (policy === "signed" && !signingContext) {
+    throw new Error(
+      "Signed playback ID requires signing credentials. Provide muxSigningKey and muxPrivateKey in options or set MUX_SIGNING_KEY and MUX_PRIVATE_KEY environment variables."
+    );
   }
-  const playbackId = publicPlaybackIds[0].id;
-  const duration = assetData.duration || 0;
-  const thumbnailUrls = getThumbnailUrls(playbackId, duration, {
+  const thumbnailUrls = await getThumbnailUrls(playbackId, duration, {
     interval: thumbnailInterval,
-    width: thumbnailWidth
+    width: thumbnailWidth,
+    signingContext: policy === "signed" ? signingContext : void 0
   });
   let thumbnailScores;
   if (provider === "openai") {
+    const apiKey = credentials.openaiApiKey;
+    if (!apiKey) {
+      throw new Error("OpenAI API key is required for moderation. Set OPENAI_API_KEY or pass openaiApiKey.");
+    }
     thumbnailScores = await requestOpenAIModeration(
       thumbnailUrls,
-      openaiClient,
-      model,
+      apiKey,
+      model || "omni-moderation-latest",
       maxConcurrent,
       imageSubmissionMode,
       imageDownloadOptions
     );
   } else if (provider === "hive") {
+    const hiveApiKey = options.hiveApiKey || env_default.HIVE_API_KEY;
+    if (!hiveApiKey) {
+      throw new Error("Hive API key is required for moderation. Set HIVE_API_KEY or pass hiveApiKey.");
+    }
     thumbnailScores = await requestHiveModeration(
       thumbnailUrls,
-      hiveKey,
+      hiveApiKey,
       maxConcurrent,
       imageSubmissionMode,
       imageDownloadOptions
     );
   } else {
-    throw new Error("Unsupported provider");
+    throw new Error(`Unsupported moderation provider: ${provider}`);
   }
   const maxSexual = Math.max(...thumbnailScores.map((s) => s.sexual));
   const maxViolence = Math.max(...thumbnailScores.map((s) => s.violence));
@@ -506,521 +1556,297 @@ async function getModerationScores(assetId, options = {}) {
   };
 }
 
-// src/summarization.ts
-init_image_download();
+// src/workflows/summarization.ts
+var import_ai4 = require("ai");
+var import_zod4 = require("zod");
+var SUMMARY_KEYWORD_LIMIT = 10;
+var summarySchema = import_zod4.z.object({
+  keywords: import_zod4.z.array(import_zod4.z.string()),
+  title: import_zod4.z.string(),
+  description: import_zod4.z.string()
+});
+var TONE_INSTRUCTIONS = {
+  normal: "Provide a clear, straightforward analysis.",
+  sassy: "Answer with a sassy, playful attitude and personality.",
+  professional: "Provide a professional, executive-level analysis suitable for business reporting."
+};
+var summarizationPromptBuilder = 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: dedent_default`
+        A short, compelling headline that immediately communicates the subject or action.
+        Aim for brevity - typically under 10 words. 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: dedent_default`
+        A concise summary (2-4 sentences) 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: dedent_default`
+        Specific, searchable terms (up to 10) 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: dedent_default`
+        - 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"]
+});
+var SYSTEM_PROMPT3 = dedent_default`
+  <role>
+    You are a video content analyst specializing in storyboard interpretation and multimodal analysis.
+  </role>
 
-// src/utils/vtt-parser.ts
-function extractTextFromVTT(vttContent) {
-  if (!vttContent.trim()) {
-    return "";
-  }
-  const lines = vttContent.split("\n");
-  const textLines = [];
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i].trim();
-    if (!line) continue;
-    if (line === "WEBVTT") continue;
-    if (line.startsWith("NOTE ")) continue;
-    if (line.includes("-->")) continue;
-    if (/^[\d\w-]+$/.test(line) && !line.includes(" ")) continue;
-    if (line.startsWith("STYLE") || line.startsWith("REGION")) continue;
-    const cleanLine = line.replace(/<[^>]*>/g, "").trim();
-    if (cleanLine) {
-      textLines.push(cleanLine);
-    }
-  }
-  return textLines.join(" ").replace(/\s+/g, " ").trim();
-}
+  <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>
 
-// src/summarization.ts
-var summarySchema = z.object({
-  keywords: z.array(z.string()).max(10),
-  title: z.string().max(100),
-  description: z.string().max(1e3)
-});
-var DEFAULT_PROMPT = "Generate a short title (max 100 characters) and description (max 500 characters) for what happens. Start immediately with the action or subject - never reference that this is a video, content, or storyboard. Example: Title: 'Cooking Pasta Tutorial' Description: 'Someone cooks pasta by boiling water and adding noodles.'";
-var ANTHROPIC_JSON_PROMPT = `You must respond with valid JSON in exactly this format:
-{
-  "title": "Your title here (max 100 characters)",
-  "description": "Your description here (max 500 characters)",
-  "keywords": ["keyword1", "keyword2", "keyword3"]
-}
+  <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>
 
-Do not include any text before or after the JSON. The JSON must be valid and parseable.`;
-async function getSummaryAndTags(assetId, promptOrOptions, options) {
-  let prompt;
-  let actualOptions;
-  if (typeof promptOrOptions === "string") {
-    prompt = promptOrOptions;
-    actualOptions = options || {};
-  } else {
-    prompt = DEFAULT_PROMPT;
-    actualOptions = promptOrOptions || {};
+  <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
+  </constraints>`;
+function buildUserPrompt2({
+  tone,
+  transcriptText,
+  isCleanTranscript = true,
+  promptOverrides
+}) {
+  const contextSections = [createToneSection(TONE_INSTRUCTIONS[tone])];
+  if (transcriptText) {
+    const format = isCleanTranscript ? "plain text" : "WebVTT";
+    contextSections.push(createTranscriptSection(transcriptText, format));
+  }
+  return summarizationPromptBuilder.buildWithContext(promptOverrides, contextSections);
+}
+var DEFAULT_PROVIDER5 = "openai";
+var DEFAULT_TONE = "normal";
+function normalizeKeywords(keywords) {
+  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 === SUMMARY_KEYWORD_LIMIT) {
+      break;
+    }
   }
+  return normalized;
+}
+async function getSummaryAndTags(assetId, options) {
   const {
-    provider = "openai",
+    provider = DEFAULT_PROVIDER5,
     model,
-    tone = "normal",
+    tone = DEFAULT_TONE,
     includeTranscript = true,
     cleanTranscript = true,
     imageSubmissionMode = "url",
     imageDownloadOptions,
-    muxTokenId,
-    muxTokenSecret,
-    openaiApiKey,
-    anthropicApiKey,
-    ...config
-  } = actualOptions;
-  const defaultModel = provider === "anthropic" ? "claude-3-5-haiku-20241022" : "gpt-4o-mini";
-  const finalModel = model || defaultModel;
-  const muxId = muxTokenId || process.env.MUX_TOKEN_ID;
-  const muxSecret = muxTokenSecret || process.env.MUX_TOKEN_SECRET;
-  const openaiKey = openaiApiKey || process.env.OPENAI_API_KEY;
-  const anthropicKey = anthropicApiKey || process.env.ANTHROPIC_API_KEY;
-  if (!muxId || !muxSecret) {
-    throw new Error("Mux credentials are required. Provide muxTokenId and muxTokenSecret in options or set MUX_TOKEN_ID and MUX_TOKEN_SECRET environment variables.");
-  }
-  if (provider === "openai" && !openaiKey) {
-    throw new Error("OpenAI API key is required. Provide openaiApiKey in options or set OPENAI_API_KEY environment variable.");
-  }
-  if (provider === "anthropic" && !anthropicKey) {
-    throw new Error("Anthropic API key is required. Provide anthropicApiKey in options or set ANTHROPIC_API_KEY environment variable.");
+    abortSignal,
+    promptOverrides
+  } = options ?? {};
+  const clients = createWorkflowClients(
+    { ...options, model },
+    provider
+  );
+  const { asset: assetData, playbackId, policy } = await getPlaybackIdForAsset(clients.mux, assetId);
+  const signingContext = resolveSigningContext(options ?? {});
+  if (policy === "signed" && !signingContext) {
+    throw new Error(
+      "Signed playback ID requires signing credentials. Provide muxSigningKey and muxPrivateKey in options or set MUX_SIGNING_KEY and MUX_PRIVATE_KEY environment variables."
+    );
   }
-  const mux = new Mux({
-    tokenId: muxId,
-    tokenSecret: muxSecret
+  const transcriptText = includeTranscript ? (await fetchTranscriptForAsset(assetData, playbackId, {
+    cleanTranscript,
+    signingContext: policy === "signed" ? signingContext : void 0
+  })).transcriptText : "";
+  const userPrompt = buildUserPrompt2({
+    tone,
+    transcriptText,
+    isCleanTranscript: cleanTranscript,
+    promptOverrides
   });
-  let openaiClient;
-  let anthropicClient;
-  if (provider === "openai") {
-    openaiClient = new OpenAI({
-      apiKey: openaiKey
-    });
-  } else if (provider === "anthropic") {
-    anthropicClient = new Anthropic({
-      apiKey: anthropicKey
-    });
-  }
-  let assetData;
-  try {
-    const asset = await mux.video.assets.retrieve(assetId);
-    assetData = asset;
-  } catch (error) {
-    throw new Error(`Failed to fetch asset from Mux: ${error instanceof Error ? error.message : "Unknown error"}`);
-  }
-  const playbackId = assetData.playback_ids?.[0]?.id;
-  if (!playbackId) {
-    throw new Error("No playback ID found for this asset");
-  }
-  let transcriptText = "";
-  if (includeTranscript && assetData.tracks) {
-    const textTrack = assetData.tracks.find(
-      (track) => track.type === "text" && track.status === "ready"
-    );
-    if (textTrack) {
-      const transcriptUrl = `https://stream.mux.com/${playbackId}/text/${textTrack.id}.vtt`;
-      try {
-        const transcriptResponse = await fetch(transcriptUrl);
-        if (transcriptResponse.ok) {
-          const rawVttContent = await transcriptResponse.text();
-          transcriptText = cleanTranscript ? extractTextFromVTT(rawVttContent) : rawVttContent;
+  const imageUrl = await getStoryboardUrl(playbackId, 640, policy === "signed" ? signingContext : void 0);
+  const analyzeStoryboard = async (imageDataUrl) => {
+    const response = await (0, import_ai4.generateObject)({
+      model: clients.languageModel.model,
+      schema: summarySchema,
+      abortSignal,
+      messages: [
+        {
+          role: "system",
+          content: SYSTEM_PROMPT3
+        },
+        {
+          role: "user",
+          content: [
+            { type: "text", text: userPrompt },
+            { type: "image", image: imageDataUrl }
+          ]
         }
-      } catch (error) {
-        console.warn("Failed to fetch transcript:", error);
-      }
-    }
-  }
-  let toneInstruction = "";
-  switch (tone) {
-    case "sassy":
-      toneInstruction = " Answer with a sassy, playful attitude and personality.";
-      break;
-    case "professional":
-      toneInstruction = " Provide a professional, executive-level analysis suitable for business reporting.";
-      break;
-    default:
-      toneInstruction = " Provide a clear, straightforward analysis.";
-  }
-  let contextualPrompt = prompt + toneInstruction;
-  if (transcriptText) {
-    const transcriptType = cleanTranscript ? "transcript" : "WebVTT transcript";
-    contextualPrompt += ` Use the following ${transcriptType} for additional context: "${transcriptText}"`;
-  }
-  const imageUrl = `https://image.mux.com/${playbackId}/storyboard.png?width=640`;
+      ]
+    });
+    return response.object;
+  };
   let aiAnalysis = null;
-  let retryAttempt = 0;
-  const maxRetries = 3;
-  if (provider === "openai") {
-    if (imageSubmissionMode === "base64") {
-      try {
-        const downloadResult = await downloadImageAsBase64(imageUrl, imageDownloadOptions);
-        const response = await openaiClient.responses.parse({
-          model: finalModel,
-          input: [
-            {
-              role: "system",
-              content: "You are an image analysis tool. You will be given a storyboard image from a video showing multiple frames/scenes, and be expected to return structured data about the contents across all the frames."
-            },
-            {
-              role: "user",
-              content: [
-                {
-                  type: "input_text",
-                  text: contextualPrompt
-                },
-                {
-                  type: "input_image",
-                  image_url: downloadResult.base64Data,
-                  // Use base64 data URI
-                  detail: "high"
-                }
-              ]
-            }
-          ],
-          text: {
-            format: zodTextFormat(summarySchema, "analysis")
-          }
-        });
-        aiAnalysis = response.output_parsed;
-      } catch (error) {
-        throw new Error(`Failed to analyze video content with OpenAI in base64 mode: ${error instanceof Error ? error.message : "Unknown error"}`);
-      }
-    } else {
-      while (retryAttempt <= maxRetries) {
-        try {
-          const response = await openaiClient.responses.parse({
-            model: finalModel,
-            input: [
-              {
-                role: "system",
-                content: "You are an image analysis tool. You will be given a storyboard image from a video showing multiple frames/scenes, and be expected to return structured data about the contents across all the frames."
-              },
-              {
-                role: "user",
-                content: [
-                  {
-                    type: "input_text",
-                    text: contextualPrompt
-                  },
-                  {
-                    type: "input_image",
-                    image_url: imageUrl,
-                    detail: "high"
-                  }
-                ]
-              }
-            ],
-            text: {
-              format: zodTextFormat(summarySchema, "analysis")
-            }
-          });
-          aiAnalysis = response.output_parsed;
-          break;
-        } catch (error) {
-          const isTimeoutError = error instanceof Error && error.message && error.message.includes("Timeout while downloading");
-          if (isTimeoutError && retryAttempt < maxRetries) {
-            await new Promise((resolve) => setTimeout(resolve, 5e3));
-            retryAttempt++;
-            continue;
-          }
-          throw new Error(`Failed to analyze video content with OpenAI: ${error instanceof Error ? error.message : "Unknown error"}`);
-        }
-      }
-    }
-  } else if (provider === "anthropic") {
-    const anthropicPrompt = `${contextualPrompt}
-
-${ANTHROPIC_JSON_PROMPT}`;
+  try {
     if (imageSubmissionMode === "base64") {
-      try {
-        const fileUploadResult = await uploadImageToAnthropicFiles(imageUrl, anthropicKey, imageDownloadOptions);
-        const response = await anthropicClient.messages.create({
-          model: finalModel,
-          max_tokens: 1e3,
-          messages: [
-            {
-              role: "user",
-              content: [
-                {
-                  type: "image",
-                  source: {
-                    type: "file",
-                    file_id: fileUploadResult.fileId
-                  }
-                  // Type assertion for Files API support
-                },
-                {
-                  type: "text",
-                  text: anthropicPrompt
-                }
-              ]
-            }
-          ]
-        }, {
-          headers: {
-            "anthropic-beta": "files-api-2025-04-14"
-          }
-        });
-        const content = response.content[0];
-        if (content.type === "text") {
-          const jsonText = content.text.trim();
-          try {
-            aiAnalysis = JSON.parse(jsonText);
-          } catch (parseError) {
-            throw new Error(`Failed to parse JSON response from Anthropic: ${parseError instanceof Error ? parseError.message : "Unknown error"}`);
-          }
-        } else {
-          throw new Error("Unexpected response type from Anthropic");
-        }
-      } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : "Unknown error";
-        throw new Error(`Failed to analyze video content with Anthropic Files API: ${errorMessage}`);
-      }
+      const downloadResult = await downloadImageAsBase64(imageUrl, imageDownloadOptions);
+      aiAnalysis = await analyzeStoryboard(downloadResult.base64Data);
     } else {
-      while (retryAttempt <= maxRetries) {
-        try {
-          const response = await anthropicClient.messages.create({
-            model: finalModel,
-            max_tokens: 1e3,
-            messages: [
-              {
-                role: "user",
-                content: [
-                  {
-                    type: "image",
-                    source: {
-                      type: "url",
-                      url: imageUrl
-                    }
-                    // Type assertion to work around SDK type definitions
-                  },
-                  {
-                    type: "text",
-                    text: anthropicPrompt
-                  }
-                ]
-              }
-            ]
-          });
-          const content = response.content[0];
-          if (content.type === "text") {
-            const jsonText = content.text.trim();
-            try {
-              aiAnalysis = JSON.parse(jsonText);
-              break;
-            } catch (parseError) {
-              if (retryAttempt < maxRetries) {
-                console.warn(`Failed to parse JSON from Anthropic (attempt ${retryAttempt + 1}):`, jsonText);
-                retryAttempt++;
-                await new Promise((resolve) => setTimeout(resolve, 2e3));
-                continue;
-              }
-              throw new Error(`Failed to parse JSON response from Anthropic: ${parseError instanceof Error ? parseError.message : "Unknown error"}`);
-            }
-          } else {
-            throw new Error("Unexpected response type from Anthropic");
-          }
-        } catch (error) {
-          if (retryAttempt < maxRetries) {
-            await new Promise((resolve) => setTimeout(resolve, 5e3));
-            retryAttempt++;
-            continue;
-          }
-          throw new Error(`Failed to analyze video content with Anthropic: ${error instanceof Error ? error.message : "Unknown error"}`);
-        }
-      }
+      aiAnalysis = await withRetry(() => analyzeStoryboard(imageUrl));
     }
-  } else {
-    throw new Error(`Unsupported provider: ${provider}`);
+  } catch (error) {
+    throw new Error(
+      `Failed to analyze video content with ${provider}: ${error instanceof Error ? error.message : "Unknown error"}`
+    );
   }
   if (!aiAnalysis) {
-    throw new Error("No analysis result received from AI provider");
+    throw new Error(`Failed to analyze video content for asset ${assetId}`);
+  }
+  if (!aiAnalysis.title) {
+    throw new Error(`Failed to generate title for asset ${assetId}`);
+  }
+  if (!aiAnalysis.description) {
+    throw new Error(`Failed to generate description for asset ${assetId}`);
   }
   return {
     assetId,
-    title: aiAnalysis.title || "No title available",
-    description: aiAnalysis.description || "No description available",
-    tags: aiAnalysis.keywords || [],
+    title: aiAnalysis.title,
+    description: aiAnalysis.description,
+    tags: normalizeKeywords(aiAnalysis.keywords),
     storyboardUrl: imageUrl
   };
 }
-async function translateCaptions(assetId, fromLanguageCode, toLanguageCode, options = {}) {
-  const {
-    provider = "anthropic",
-    model = "claude-sonnet-4-20250514",
-    muxTokenId,
-    muxTokenSecret,
-    anthropicApiKey,
-    ...config
-  } = options;
-  if (provider !== "anthropic") {
-    throw new Error("Only Anthropic provider is currently supported for translation");
-  }
-  const muxId = muxTokenId || process.env.MUX_TOKEN_ID;
-  const muxSecret = muxTokenSecret || process.env.MUX_TOKEN_SECRET;
-  const anthropicKey = anthropicApiKey || process.env.ANTHROPIC_API_KEY;
-  const s3Endpoint = options.s3Endpoint || process.env.S3_ENDPOINT;
-  const s3Region = options.s3Region || process.env.S3_REGION || "auto";
-  const s3Bucket = options.s3Bucket || process.env.S3_BUCKET;
-  const s3AccessKeyId = options.s3AccessKeyId || process.env.S3_ACCESS_KEY_ID;
-  const s3SecretAccessKey = options.s3SecretAccessKey || process.env.S3_SECRET_ACCESS_KEY;
-  const uploadToMux = options.uploadToMux !== false;
-  if (!muxId || !muxSecret) {
-    throw new Error("Mux credentials are required. Provide muxTokenId and muxTokenSecret in options or set MUX_TOKEN_ID and MUX_TOKEN_SECRET environment variables.");
-  }
-  if (!anthropicKey) {
-    throw new Error("Anthropic API key is required. Provide anthropicApiKey in options or set ANTHROPIC_API_KEY environment variable.");
-  }
-  if (uploadToMux && (!s3Endpoint || !s3Bucket || !s3AccessKeyId || !s3SecretAccessKey)) {
-    throw new Error("S3 configuration is required for uploading to Mux. Provide s3Endpoint, s3Bucket, s3AccessKeyId, and s3SecretAccessKey in options or set S3_ENDPOINT, S3_BUCKET, S3_ACCESS_KEY_ID, and S3_SECRET_ACCESS_KEY environment variables.");
-  }
-  const mux = new Mux({
-    tokenId: muxId,
-    tokenSecret: muxSecret
-  });
-  const anthropicClient = new Anthropic({
-    apiKey: anthropicKey
-  });
-  let assetData;
-  try {
-    const asset = await mux.video.assets.retrieve(assetId);
-    assetData = asset;
-  } catch (error) {
-    throw new Error(`Failed to fetch asset from Mux: ${error instanceof Error ? error.message : "Unknown error"}`);
-  }
-  const playbackId = assetData.playback_ids?.[0]?.id;
-  if (!playbackId) {
-    throw new Error("No playback ID found for this asset");
-  }
-  if (!assetData.tracks) {
-    throw new Error("No tracks found for this asset");
-  }
-  const sourceTextTrack = assetData.tracks.find(
-    (track) => track.type === "text" && track.status === "ready" && track.language_code === fromLanguageCode
-  );
-  if (!sourceTextTrack) {
-    throw new Error(`No ready text track found with language code '${fromLanguageCode}' for this asset`);
-  }
-  const vttUrl = `https://stream.mux.com/${playbackId}/text/${sourceTextTrack.id}.vtt`;
-  let vttContent;
-  try {
-    const vttResponse = await fetch(vttUrl);
-    if (!vttResponse.ok) {
-      throw new Error(`Failed to fetch VTT file: ${vttResponse.statusText}`);
-    }
-    vttContent = await vttResponse.text();
-  } catch (error) {
-    throw new Error(`Failed to fetch VTT content: ${error instanceof Error ? error.message : "Unknown error"}`);
-  }
-  console.log(`\u2705 Found VTT content for language '${fromLanguageCode}'`);
-  let translatedVtt;
-  try {
-    const response = await anthropicClient.messages.create({
-      model,
-      max_tokens: 4e3,
-      messages: [
-        {
-          role: "user",
-          content: `Translate the following VTT subtitle file from ${fromLanguageCode} to ${toLanguageCode}. Return the translated VTT in JSON format with the key 'translation'. Preserve all timestamps and VTT formatting exactly as they appear.
 
-${vttContent}`
-        }
-      ]
-    });
-    const content = response.content[0];
-    if (content.type === "text") {
-      const responseText = content.text.trim();
-      try {
-        const cleanedResponse = responseText.replace(/```json/g, "").replace(/```/g, "").trim();
-        const parsed = JSON.parse(cleanedResponse);
-        translatedVtt = parsed.translation;
-      } catch (parseError) {
-        throw new Error(`Failed to parse JSON response from Anthropic: ${parseError instanceof Error ? parseError.message : "Unknown error"}`);
-      }
-    } else {
-      throw new Error("Unexpected response type from Anthropic");
-    }
-  } catch (error) {
-    throw new Error(`Failed to translate VTT with Anthropic: ${error instanceof Error ? error.message : "Unknown error"}`);
-  }
-  console.log(`
-\u2705 Translation completed successfully!`);
-  if (!uploadToMux) {
-    console.log(`\u2705 VTT translated to ${toLanguageCode} successfully!`);
-    return {
-      assetId,
-      sourceLanguageCode: fromLanguageCode,
-      targetLanguageCode: toLanguageCode,
-      originalVtt: vttContent,
-      translatedVtt
-    };
-  }
-  console.log("\u{1F4E4} Uploading translated VTT to S3-compatible storage...");
-  const s3Client = new S3Client({
-    region: s3Region,
-    endpoint: s3Endpoint,
-    credentials: {
-      accessKeyId: s3AccessKeyId,
-      secretAccessKey: s3SecretAccessKey
-    },
-    forcePathStyle: true
-    // Often needed for non-AWS S3 services
-  });
-  const vttKey = `translations/${assetId}/${fromLanguageCode}-to-${toLanguageCode}-${Date.now()}.vtt`;
-  let presignedUrl;
+// src/workflows/translate-audio.ts
+var import_client_s3 = require("@aws-sdk/client-s3");
+var import_lib_storage = require("@aws-sdk/lib-storage");
+var import_s3_request_presigner = require("@aws-sdk/s3-request-presigner");
+var import_mux_node3 = __toESM(require("@mux/mux-node"));
+var STATIC_RENDITION_POLL_INTERVAL_MS = 5e3;
+var STATIC_RENDITION_MAX_ATTEMPTS = 36;
+var delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+function getReadyAudioStaticRendition(asset) {
+  const files = asset.static_renditions?.files;
+  if (!files || files.length === 0) {
+    return void 0;
+  }
+  return files.find(
+    (rendition) => rendition.name === "audio.m4a" && rendition.status === "ready"
+  );
+}
+var hasReadyAudioStaticRendition = (asset) => Boolean(getReadyAudioStaticRendition(asset));
+async function requestStaticRenditionCreation(muxClient, assetId) {
+  console.log("\u{1F4FC} Requesting static rendition from Mux...");
   try {
-    const upload = new Upload({
-      client: s3Client,
-      params: {
-        Bucket: s3Bucket,
-        Key: vttKey,
-        Body: translatedVtt,
-        ContentType: "text/vtt"
-      }
-    });
-    await upload.done();
-    console.log(`\u2705 VTT uploaded successfully to: ${vttKey}`);
-    const getObjectCommand = new GetObjectCommand({
-      Bucket: s3Bucket,
-      Key: vttKey
-    });
-    presignedUrl = await getSignedUrl(s3Client, getObjectCommand, {
-      expiresIn: 3600
-      // 1 hour
+    await muxClient.video.assets.createStaticRendition(assetId, {
+      resolution: "audio-only"
     });
-    console.log(`\u{1F517} Generated presigned URL (expires in 1 hour)`);
+    console.log("\u{1F4FC} Static rendition request accepted by Mux.");
   } catch (error) {
-    throw new Error(`Failed to upload VTT to S3: ${error instanceof Error ? error.message : "Unknown error"}`);
+    const statusCode = error?.status ?? error?.statusCode;
+    const messages = error?.error?.messages;
+    const alreadyDefined = messages?.some((message2) => message2.toLowerCase().includes("already defined")) ?? error?.message?.toLowerCase().includes("already defined");
+    if (statusCode === 409 || alreadyDefined) {
+      console.log("\u2139\uFE0F Static rendition already requested. Waiting for it to finish...");
+      return;
+    }
+    const message = error instanceof Error ? error.message : "Unknown error";
+    throw new Error(`Failed to request static rendition from Mux: ${message}`);
   }
-  console.log("\u{1F4F9} Adding translated track to Mux asset...");
-  let uploadedTrackId;
-  try {
-    const languageName = new Intl.DisplayNames(["en"], { type: "language" }).of(toLanguageCode) || toLanguageCode.toUpperCase();
-    const trackName = `${languageName} (auto-translated)`;
-    const trackResponse = await mux.video.assets.createTrack(assetId, {
-      type: "text",
-      text_type: "subtitles",
-      language_code: toLanguageCode,
-      name: trackName,
-      url: presignedUrl
-    });
-    uploadedTrackId = trackResponse.id;
-    console.log(`\u2705 Track added to Mux asset with ID: ${uploadedTrackId}`);
-    console.log(`\u{1F4CB} Track name: "${trackName}"`);
-  } catch (error) {
-    console.warn(`\u26A0\uFE0F Failed to add track to Mux asset: ${error instanceof Error ? error.message : "Unknown error"}`);
-    console.log("\u{1F517} You can manually add the track using this presigned URL:");
-    console.log(presignedUrl);
+}
+async function waitForAudioStaticRendition({
+  assetId,
+  muxClient,
+  initialAsset
+}) {
+  let currentAsset = initialAsset;
+  if (hasReadyAudioStaticRendition(currentAsset)) {
+    return currentAsset;
+  }
+  const status = currentAsset.static_renditions?.status ?? "not_requested";
+  if (status === "not_requested" || status === void 0) {
+    await requestStaticRenditionCreation(muxClient, assetId);
+  } else if (status === "errored") {
+    console.log("\u26A0\uFE0F Previous static rendition request errored. Creating a new one...");
+    await requestStaticRenditionCreation(muxClient, assetId);
+  } else {
+    console.log(`\u2139\uFE0F Static rendition already ${status}. Waiting for it to finish...`);
+  }
+  for (let attempt = 1; attempt <= STATIC_RENDITION_MAX_ATTEMPTS; attempt++) {
+    await delay(STATIC_RENDITION_POLL_INTERVAL_MS);
+    currentAsset = await muxClient.video.assets.retrieve(assetId);
+    if (hasReadyAudioStaticRendition(currentAsset)) {
+      console.log("\u2705 Audio static rendition is ready!");
+      return currentAsset;
+    }
+    const currentStatus = currentAsset.static_renditions?.status || "unknown";
+    console.log(
+      `\u231B Waiting for static rendition (attempt ${attempt}/${STATIC_RENDITION_MAX_ATTEMPTS}) \u2192 ${currentStatus}`
+    );
+    if (currentStatus === "errored") {
+      throw new Error(
+        "Mux failed to create the static rendition for this asset. Please check the asset in the Mux dashboard."
+      );
+    }
   }
-  return {
-    assetId,
-    sourceLanguageCode: fromLanguageCode,
-    targetLanguageCode: toLanguageCode,
-    originalVtt: vttContent,
-    translatedVtt,
-    uploadedTrackId,
-    presignedUrl
-  };
+  throw new Error(
+    "Timed out waiting for the static rendition to become ready. Please try again in a moment."
+  );
 }
 async function translateAudio(assetId, toLanguageCode, options = {}) {
   const {
@@ -1030,20 +1856,19 @@ async function translateAudio(assetId, toLanguageCode, options = {}) {
     muxTokenId,
     muxTokenSecret,
     elevenLabsApiKey,
-    uploadToMux = true,
-    ...config
+    uploadToMux = true
   } = options;
   if (provider !== "elevenlabs") {
     throw new Error("Only ElevenLabs provider is currently supported for audio translation");
   }
-  const muxId = muxTokenId || process.env.MUX_TOKEN_ID;
-  const muxSecret = muxTokenSecret || process.env.MUX_TOKEN_SECRET;
-  const elevenLabsKey = elevenLabsApiKey || process.env.ELEVENLABS_API_KEY;
-  const s3Endpoint = options.s3Endpoint || process.env.S3_ENDPOINT;
-  const s3Region = options.s3Region || process.env.S3_REGION || "auto";
-  const s3Bucket = options.s3Bucket || process.env.S3_BUCKET;
-  const s3AccessKeyId = options.s3AccessKeyId || process.env.S3_ACCESS_KEY_ID;
-  const s3SecretAccessKey = options.s3SecretAccessKey || process.env.S3_SECRET_ACCESS_KEY;
+  const muxId = muxTokenId ?? env_default.MUX_TOKEN_ID;
+  const muxSecret = muxTokenSecret ?? env_default.MUX_TOKEN_SECRET;
+  const elevenLabsKey = elevenLabsApiKey ?? env_default.ELEVENLABS_API_KEY;
+  const s3Endpoint = options.s3Endpoint ?? env_default.S3_ENDPOINT;
+  const s3Region = options.s3Region ?? env_default.S3_REGION ?? "auto";
+  const s3Bucket = options.s3Bucket ?? env_default.S3_BUCKET;
+  const s3AccessKeyId = options.s3AccessKeyId ?? env_default.S3_ACCESS_KEY_ID;
+  const s3SecretAccessKey = options.s3SecretAccessKey ?? env_default.S3_SECRET_ACCESS_KEY;
   if (!muxId || !muxSecret) {
     throw new Error("Mux credentials are required. Provide muxTokenId and muxTokenSecret in options or set MUX_TOKEN_ID and MUX_TOKEN_SECRET environment variables.");
   }
@@ -1053,33 +1878,38 @@ async function translateAudio(assetId, toLanguageCode, options = {}) {
   if (uploadToMux && (!s3Endpoint || !s3Bucket || !s3AccessKeyId || !s3SecretAccessKey)) {
     throw new Error("S3 configuration is required for uploading to Mux. Provide s3Endpoint, s3Bucket, s3AccessKeyId, and s3SecretAccessKey in options or set S3_ENDPOINT, S3_BUCKET, S3_ACCESS_KEY_ID, and S3_SECRET_ACCESS_KEY environment variables.");
   }
-  const mux = new Mux({
+  const mux = new import_mux_node3.default({
     tokenId: muxId,
     tokenSecret: muxSecret
   });
   console.log(`\u{1F3AC} Fetching Mux asset: ${assetId}`);
-  let assetData;
-  try {
-    const asset = await mux.video.assets.retrieve(assetId);
-    assetData = asset;
-  } catch (error) {
-    throw new Error(`Failed to fetch asset from Mux: ${error instanceof Error ? error.message : "Unknown error"}`);
+  const { asset: initialAsset, playbackId, policy } = await getPlaybackIdForAsset(mux, assetId);
+  const signingContext = resolveSigningContext(options);
+  if (policy === "signed" && !signingContext) {
+    throw new Error(
+      "Signed playback ID requires signing credentials. Provide muxSigningKey and muxPrivateKey in options or set MUX_SIGNING_KEY and MUX_PRIVATE_KEY environment variables."
+    );
   }
   console.log("\u{1F50D} Checking for audio-only static rendition...");
-  if (!assetData.static_renditions || !assetData.static_renditions.files) {
-    throw new Error("No static renditions found for this asset");
-  }
-  const staticRenditionFiles = assetData.static_renditions.files;
-  if (staticRenditionFiles.length === 0) {
-    throw new Error("No static rendition files found for this asset");
+  let currentAsset = initialAsset;
+  if (!hasReadyAudioStaticRendition(currentAsset)) {
+    console.log("\u274C No ready audio static rendition found. Requesting one now...");
+    currentAsset = await waitForAudioStaticRendition({
+      assetId,
+      muxClient: mux,
+      initialAsset: currentAsset
+    });
   }
-  const audioRendition = staticRenditionFiles.find(
-    (rendition) => rendition.name === "audio.m4a" && rendition.status === "ready"
-  );
+  const audioRendition = getReadyAudioStaticRendition(currentAsset);
   if (!audioRendition) {
-    throw new Error("No ready audio-only static rendition found for this asset. Please ensure the asset has an audio.m4a static rendition.");
+    throw new Error(
+      "Unable to obtain an audio-only static rendition for this asset. Please verify static renditions are enabled in Mux."
+    );
+  }
+  let audioUrl = `https://stream.mux.com/${playbackId}/audio.m4a`;
+  if (policy === "signed" && signingContext) {
+    audioUrl = await signUrl(audioUrl, playbackId, signingContext, "video");
   }
-  const audioUrl = `https://stream.mux.com/${assetData.playback_ids?.[0]?.id}/audio.m4a`;
   console.log(`\u2705 Found audio rendition: ${audioUrl}`);
   console.log(`\u{1F399}\uFE0F Creating ElevenLabs dubbing job (auto-detect \u2192 ${toLanguageCode})`);
   let dubbingId;
@@ -1168,7 +1998,7 @@ async function translateAudio(assetId, toLanguageCode, options = {}) {
     throw new Error(`Failed to download dubbed audio: ${error instanceof Error ? error.message : "Unknown error"}`);
   }
   console.log("\u{1F4E4} Uploading dubbed audio to S3-compatible storage...");
-  const s3Client = new S3Client({
+  const s3Client = new import_client_s3.S3Client({
     region: s3Region,
     endpoint: s3Endpoint,
     credentials: {
@@ -1180,7 +2010,7 @@ async function translateAudio(assetId, toLanguageCode, options = {}) {
   const audioKey = `audio-translations/${assetId}/auto-to-${toLanguageCode}-${Date.now()}.m4a`;
   let presignedUrl;
   try {
-    const upload = new Upload({
+    const upload = new import_lib_storage.Upload({
       client: s3Client,
       params: {
         Bucket: s3Bucket,
@@ -1191,11 +2021,11 @@ async function translateAudio(assetId, toLanguageCode, options = {}) {
     });
     await upload.done();
     console.log(`\u2705 Audio uploaded successfully to: ${audioKey}`);
-    const getObjectCommand = new GetObjectCommand({
+    const getObjectCommand = new import_client_s3.GetObjectCommand({
       Bucket: s3Bucket,
       Key: audioKey
     });
-    presignedUrl = await getSignedUrl(s3Client, getObjectCommand, {
+    presignedUrl = await (0, import_s3_request_presigner.getSignedUrl)(s3Client, getObjectCommand, {
       expiresIn: 3600
       // 1 hour
     });
@@ -1230,529 +2060,179 @@ async function translateAudio(assetId, toLanguageCode, options = {}) {
     presignedUrl
   };
 }
-var chaptersSchema = z.object({
-  chapters: z.array(z.object({
-    startTime: z.number(),
-    title: z.string()
-  }))
-});
-var DEFAULT_SYSTEM_PROMPT = `Your role is to segment the following captions into chunked chapters, summarising each chapter with a title. 
-
-Analyze the transcript and create logical chapter breaks based on topic changes, major transitions, or distinct sections of content. Each chapter should represent a meaningful segment of the video.
 
-You must respond with valid JSON in exactly this format:
-{
-  "chapters": [
-    {"startTime": 0, "title": "Introduction"},
-    {"startTime": 45.5, "title": "Main Topic Discussion"},
-    {"startTime": 120.0, "title": "Conclusion"}
-  ]
-}
-
-Important rules:
-- startTime must be in seconds (not HH:MM:SS format)
-- Always start with startTime: 0 for the first chapter
-- Create 3-8 chapters depending on content length and natural breaks
-- Chapter titles should be concise and descriptive
-- Do not include any text before or after the JSON
-- The JSON must be valid and parseable`;
-var ANTHROPIC_JSON_PROMPT2 = `You must respond with valid JSON in exactly this format:
-{
-  "chapters": [
-    {"startTime": 0, "title": "Chapter title here"},
-    {"startTime": 45.5, "title": "Another chapter title"}
-  ]
-}
-
-Do not include any text before or after the JSON. The JSON must be valid and parseable.`;
-function vttTimestampToSeconds(timestamp) {
-  const parts = timestamp.split(":");
-  if (parts.length !== 3) return 0;
-  const hours = parseInt(parts[0], 10) || 0;
-  const minutes = parseInt(parts[1], 10) || 0;
-  const seconds = parseFloat(parts[2]) || 0;
-  return hours * 3600 + minutes * 60 + seconds;
-}
-function extractTimestampsFromVTT(vttContent) {
-  if (!vttContent.trim()) {
-    return "";
-  }
-  const lines = vttContent.split("\n");
-  const segments = [];
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i].trim();
-    if (line.includes("-->")) {
-      const startTime = line.split(" --> ")[0].trim();
-      const timeInSeconds = vttTimestampToSeconds(startTime);
-      let j = i + 1;
-      while (j < lines.length && !lines[j].trim()) {
-        j++;
-      }
-      if (j < lines.length) {
-        const text = lines[j].trim().replace(/<[^>]*>/g, "");
-        if (text) {
-          segments.push({ time: timeInSeconds, text });
-        }
-      }
-    }
-  }
-  return segments.map((segment) => `[${Math.floor(segment.time)}s] ${segment.text}`).join("\n");
-}
-async function generateChapters(assetId, languageCode, options = {}) {
+// src/workflows/translate-captions.ts
+var import_client_s32 = require("@aws-sdk/client-s3");
+var import_lib_storage2 = require("@aws-sdk/lib-storage");
+var import_s3_request_presigner2 = require("@aws-sdk/s3-request-presigner");
+var import_ai5 = require("ai");
+var import_zod5 = require("zod");
+var translationSchema = import_zod5.z.object({
+  translation: import_zod5.z.string()
+});
+var DEFAULT_PROVIDER6 = "openai";
+async function translateCaptions(assetId, fromLanguageCode, toLanguageCode, options) {
   const {
-    provider = "openai",
+    provider = DEFAULT_PROVIDER6,
     model,
-    muxTokenId,
-    muxTokenSecret,
-    openaiApiKey,
-    anthropicApiKey,
-    ...config
+    s3Endpoint: providedS3Endpoint,
+    s3Region: providedS3Region,
+    s3Bucket: providedS3Bucket,
+    s3AccessKeyId: providedS3AccessKeyId,
+    s3SecretAccessKey: providedS3SecretAccessKey,
+    uploadToMux: uploadToMuxOption,
+    ...clientConfig
   } = options;
-  const defaultModel = provider === "anthropic" ? "claude-3-5-haiku-20241022" : "gpt-4o-mini";
-  const finalModel = model || defaultModel;
-  const muxId = muxTokenId || process.env.MUX_TOKEN_ID;
-  const muxSecret = muxTokenSecret || process.env.MUX_TOKEN_SECRET;
-  const openaiKey = openaiApiKey || process.env.OPENAI_API_KEY;
-  const anthropicKey = anthropicApiKey || process.env.ANTHROPIC_API_KEY;
-  if (!muxId || !muxSecret) {
-    throw new Error("Mux credentials are required. Provide muxTokenId and muxTokenSecret in options or set MUX_TOKEN_ID and MUX_TOKEN_SECRET environment variables.");
-  }
-  if (provider === "openai" && !openaiKey) {
-    throw new Error("OpenAI API key is required for OpenAI provider. Provide openaiApiKey in options or set OPENAI_API_KEY environment variable.");
-  }
-  if (provider === "anthropic" && !anthropicKey) {
-    throw new Error("Anthropic API key is required for Anthropic provider. Provide anthropicApiKey in options or set ANTHROPIC_API_KEY environment variable.");
-  }
-  const mux = new Mux({
-    tokenId: muxId,
-    tokenSecret: muxSecret
-  });
-  let openaiClient;
-  let anthropicClient;
-  if (provider === "openai") {
-    openaiClient = new OpenAI({
-      apiKey: openaiKey
-    });
-  } else if (provider === "anthropic") {
-    anthropicClient = new Anthropic({
-      apiKey: anthropicKey
-    });
-  }
-  let assetData;
-  try {
-    const asset = await mux.video.assets.retrieve(assetId);
-    assetData = asset;
-  } catch (error) {
-    throw new Error(`Failed to fetch asset from Mux: ${error instanceof Error ? error.message : "Unknown error"}`);
+  const resolvedProvider = provider;
+  const s3Endpoint = providedS3Endpoint ?? env_default.S3_ENDPOINT;
+  const s3Region = providedS3Region ?? env_default.S3_REGION ?? "auto";
+  const s3Bucket = providedS3Bucket ?? env_default.S3_BUCKET;
+  const s3AccessKeyId = providedS3AccessKeyId ?? env_default.S3_ACCESS_KEY_ID;
+  const s3SecretAccessKey = providedS3SecretAccessKey ?? env_default.S3_SECRET_ACCESS_KEY;
+  const uploadToMux = uploadToMuxOption !== false;
+  const clients = createWorkflowClients(
+    { ...clientConfig, provider: resolvedProvider, model },
+    resolvedProvider
+  );
+  if (uploadToMux && (!s3Endpoint || !s3Bucket || !s3AccessKeyId || !s3SecretAccessKey)) {
+    throw new Error("S3 configuration is required for uploading to Mux. Provide s3Endpoint, s3Bucket, s3AccessKeyId, and s3SecretAccessKey in options or set S3_ENDPOINT, S3_BUCKET, S3_ACCESS_KEY_ID, and S3_SECRET_ACCESS_KEY environment variables.");
   }
-  const playbackId = assetData.playback_ids?.[0]?.id;
-  if (!playbackId) {
-    throw new Error("No playback ID found for this asset");
+  const { asset: assetData, playbackId, policy } = await getPlaybackIdForAsset(clients.mux, assetId);
+  const signingContext = resolveSigningContext(options);
+  if (policy === "signed" && !signingContext) {
+    throw new Error(
+      "Signed playback ID requires signing credentials. Provide muxSigningKey and muxPrivateKey in options or set MUX_SIGNING_KEY and MUX_PRIVATE_KEY environment variables."
+    );
   }
   if (!assetData.tracks) {
     throw new Error("No tracks found for this asset");
   }
-  const captionTrack = assetData.tracks.find(
-    (track) => track.type === "text" && track.status === "ready" && track.text_type === "subtitles" && track.language_code === languageCode
+  const sourceTextTrack = assetData.tracks.find(
+    (track) => track.type === "text" && track.status === "ready" && track.language_code === fromLanguageCode
   );
-  if (!captionTrack) {
-    throw new Error(`No caption track found for language '${languageCode}'. Available languages: ${assetData.tracks.filter((t) => t.type === "text").map((t) => t.language_code).join(", ")}`);
+  if (!sourceTextTrack) {
+    throw new Error(`No ready text track found with language code '${fromLanguageCode}' for this asset`);
+  }
+  let vttUrl = `https://stream.mux.com/${playbackId}/text/${sourceTextTrack.id}.vtt`;
+  if (policy === "signed" && signingContext) {
+    vttUrl = await signUrl(vttUrl, playbackId, signingContext, "video");
   }
-  const transcriptUrl = `https://stream.mux.com/${playbackId}/text/${captionTrack.id}.vtt`;
   let vttContent;
   try {
-    const transcriptResponse = await fetch(transcriptUrl);
-    if (!transcriptResponse.ok) {
-      throw new Error(`Failed to fetch VTT: ${transcriptResponse.statusText}`);
+    const vttResponse = await fetch(vttUrl);
+    if (!vttResponse.ok) {
+      throw new Error(`Failed to fetch VTT file: ${vttResponse.statusText}`);
     }
-    vttContent = await transcriptResponse.text();
+    vttContent = await vttResponse.text();
   } catch (error) {
-    throw new Error(`Failed to fetch caption track: ${error instanceof Error ? error.message : "Unknown error"}`);
-  }
-  const timestampedTranscript = extractTimestampsFromVTT(vttContent);
-  if (!timestampedTranscript) {
-    throw new Error("No usable content found in caption track");
+    throw new Error(`Failed to fetch VTT content: ${error instanceof Error ? error.message : "Unknown error"}`);
   }
-  let chaptersData = null;
-  if (provider === "openai") {
-    try {
-      const response = await openaiClient.responses.parse({
-        model: finalModel,
-        input: [
-          {
-            role: "system",
-            content: DEFAULT_SYSTEM_PROMPT
-          },
-          {
-            role: "user",
-            content: [
-              {
-                type: "input_text",
-                text: timestampedTranscript
-              }
-            ]
-          }
-        ],
-        text: {
-          format: zodTextFormat(chaptersSchema, "chapters")
-        }
-      });
-      chaptersData = response.output_parsed;
-    } catch (error) {
-      throw new Error(`Failed to generate chapters with OpenAI: ${error instanceof Error ? error.message : "Unknown error"}`);
-    }
-  } else if (provider === "anthropic") {
-    const anthropicPrompt = `${DEFAULT_SYSTEM_PROMPT}
-
-${ANTHROPIC_JSON_PROMPT2}
+  console.log(`\u2705 Found VTT content for language '${fromLanguageCode}'`);
+  let translatedVtt;
+  try {
+    const response = await (0, import_ai5.generateObject)({
+      model: clients.languageModel.model,
+      schema: translationSchema,
+      abortSignal: options.abortSignal,
+      messages: [
+        {
+          role: "user",
+          content: `Translate the following VTT subtitle file from ${fromLanguageCode} to ${toLanguageCode}. Preserve all timestamps and VTT formatting exactly as they appear. Return JSON with a single key "translation" containing the translated VTT.
 
-Transcript:
-${timestampedTranscript}`;
-    try {
-      const response = await anthropicClient.messages.create({
-        model: finalModel,
-        max_tokens: 2e3,
-        messages: [
-          {
-            role: "user",
-            content: anthropicPrompt
-          }
-        ]
-      });
-      const content = response.content[0];
-      if (content.type === "text") {
-        const jsonText = content.text.trim();
-        try {
-          chaptersData = JSON.parse(jsonText);
-        } catch (parseError) {
-          throw new Error(`Failed to parse JSON response from Anthropic: ${parseError instanceof Error ? parseError.message : "Unknown error"}`);
+${vttContent}`
         }
-      } else {
-        throw new Error("Unexpected response type from Anthropic");
-      }
-    } catch (error) {
-      throw new Error(`Failed to generate chapters with Anthropic: ${error instanceof Error ? error.message : "Unknown error"}`);
-    }
-  } else {
-    throw new Error(`Unsupported provider: ${provider}`);
-  }
-  if (!chaptersData || !chaptersData.chapters) {
-    throw new Error("No chapters generated from AI response");
-  }
-  const validChapters = chaptersData.chapters.filter((chapter) => typeof chapter.startTime === "number" && typeof chapter.title === "string").sort((a, b) => a.startTime - b.startTime);
-  if (validChapters.length === 0) {
-    throw new Error("No valid chapters found in AI response");
-  }
-  if (validChapters[0].startTime !== 0) {
-    validChapters[0].startTime = 0;
-  }
-  return {
-    assetId,
-    languageCode,
-    chapters: validChapters
-  };
-}
-
-// src/utils/storyboard-processor.ts
-init_image_download();
-async function getAssetInfo(assetId, options) {
-  const muxId = options.muxTokenId || process.env.MUX_TOKEN_ID;
-  const muxSecret = options.muxTokenSecret || process.env.MUX_TOKEN_SECRET;
-  if (!muxId || !muxSecret) {
-    throw new Error("Mux credentials are required. Provide muxTokenId and muxTokenSecret in options or set MUX_TOKEN_ID and MUX_TOKEN_SECRET environment variables.");
+      ]
+    });
+    translatedVtt = response.object.translation;
+  } catch (error) {
+    throw new Error(`Failed to translate VTT with ${resolvedProvider}: ${error instanceof Error ? error.message : "Unknown error"}`);
   }
-  const mux = new Mux({
-    tokenId: muxId,
-    tokenSecret: muxSecret
-  });
-  try {
-    const asset = await mux.video.assets.retrieve(assetId);
-    const playbackId = asset.playback_ids?.[0]?.id;
-    if (!playbackId) {
-      throw new Error("No playback ID found for this asset");
-    }
+  console.log(`
+\u2705 Translation completed successfully!`);
+  if (!uploadToMux) {
+    console.log(`\u2705 VTT translated to ${toLanguageCode} successfully!`);
     return {
-      playbackId,
-      duration: asset.duration || void 0
+      assetId,
+      sourceLanguageCode: fromLanguageCode,
+      targetLanguageCode: toLanguageCode,
+      originalVtt: vttContent,
+      translatedVtt
     };
-  } catch (error) {
-    throw new Error(`Failed to fetch asset from Mux: ${error instanceof Error ? error.message : "Unknown error"}`);
   }
-}
-async function processStoryboardWithAnthropic(imageUrl, prompt, options) {
-  const { apiKey, model, responseParser, imageSubmissionMode = "url", imageDownloadOptions, maxRetries = 3 } = options;
-  const anthropicClient = new Anthropic({ apiKey });
-  let retryAttempt = 0;
-  if (imageSubmissionMode === "base64") {
-    try {
-      const fileUploadResult = await uploadImageToAnthropicFiles(imageUrl, apiKey, imageDownloadOptions);
-      const response = await anthropicClient.messages.create({
-        model,
-        max_tokens: 1e3,
-        messages: [
-          {
-            role: "user",
-            content: [
-              {
-                type: "image",
-                source: {
-                  type: "file",
-                  file_id: fileUploadResult.fileId
-                }
-                // Type assertion for Files API support
-              },
-              {
-                type: "text",
-                text: prompt
-              }
-            ]
-          }
-        ]
-      }, {
-        headers: {
-          "anthropic-beta": "files-api-2025-04-14"
-        }
-      });
-      return responseParser(response);
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : "Unknown error";
-      throw new Error(`Failed to process storyboard with Anthropic Files API: ${errorMessage}`);
-    }
-  } else {
-    while (retryAttempt <= maxRetries) {
-      try {
-        const response = await anthropicClient.messages.create({
-          model,
-          max_tokens: 1e3,
-          messages: [
-            {
-              role: "user",
-              content: [
-                {
-                  type: "image",
-                  source: {
-                    type: "url",
-                    url: imageUrl
-                  }
-                  // Type assertion to work around SDK type definitions
-                },
-                {
-                  type: "text",
-                  text: prompt
-                }
-              ]
-            }
-          ]
-        });
-        return responseParser(response);
-      } catch (error) {
-        if (retryAttempt < maxRetries) {
-          await new Promise((resolve) => setTimeout(resolve, 5e3));
-          retryAttempt++;
-          continue;
-        }
-        throw new Error(`Failed to process storyboard with Anthropic: ${error instanceof Error ? error.message : "Unknown error"}`);
-      }
-    }
-  }
-  throw new Error("All retry attempts failed");
-}
-
-// src/burned-in-captions.ts
-var burnedInCaptionsSchema = z.object({
-  hasBurnedInCaptions: z.boolean(),
-  confidence: z.number().min(0).max(1),
-  detectedLanguage: z.string().nullable()
-});
-var ANTHROPIC_SYSTEM_PROMPT = `You are an expert at analyzing video frames to detect burned-in captions (also called open captions or hardcoded subtitles). These are text overlays permanently embedded in video images, common on social media platforms.
-
-Key principles:
-1. Burned-in captions appear across multiple frames throughout the video timeline
-2. End-cards and marketing text appear only in final frames
-3. Captions have consistent positioning and caption-style formatting
-4. Caption text typically changes between frames (dialogue/narration)
-
-Analysis approach:
-- Look for text overlays distributed across different parts of the timeline
-- Distinguish between dialogue captions vs. marketing end-cards
-- Consider text positioning, formatting, and content patterns`;
-var ANTHROPIC_USER_PROMPT = `Analyze this storyboard for burned-in captions:
-
-1. Examine each frame from left to right (timeline order)
-2. Note which frames have text overlays and their positions
-3. Determine the pattern:
-   - Text scattered across timeline = likely captions
-   - Text only in final 1-2 frames = likely end-card/marketing
-
-Classification rules:
-- If text appears in 3+ frames distributed throughout timeline \u2192 burned-in captions
-- If text appears only in final frames \u2192 NOT burned-in captions
-- Look for dialogue-style content vs. marketing taglines
-
-Analyze and classify with confidence level.`;
-var ANTHROPIC_JSON_PROMPT3 = `Apply the frame analysis above.
-
-Key rule: Text appearing only in final 2-3 frames = NOT captions. Text distributed throughout timeline = captions.
-
-Respond ONLY with valid JSON:
-{
-  "hasBurnedInCaptions": true/false,
-  "confidence": 0.85,
-  "detectedLanguage": "English" (or null if no captions or language unclear)
-}
-
-Do not include any text before or after the JSON. The JSON must be valid and parseable.`;
-async function hasBurnedInCaptions(assetId, options = {}) {
-  const {
-    provider = "openai",
-    model,
-    imageSubmissionMode = "url",
-    imageDownloadOptions,
-    muxTokenId,
-    muxTokenSecret,
-    openaiApiKey,
-    anthropicApiKey,
-    ...config
-  } = options;
-  const defaultModel = provider === "anthropic" ? "claude-3-5-haiku-20241022" : "gpt-4o-mini";
-  const finalModel = model || defaultModel;
-  const openaiKey = openaiApiKey || process.env.OPENAI_API_KEY;
-  const anthropicKey = anthropicApiKey || process.env.ANTHROPIC_API_KEY;
-  if (provider === "openai" && !openaiKey) {
-    throw new Error("OpenAI API key is required for OpenAI provider. Provide openaiApiKey in options or set OPENAI_API_KEY environment variable.");
-  }
-  if (provider === "anthropic" && !anthropicKey) {
-    throw new Error("Anthropic API key is required for Anthropic provider. Provide anthropicApiKey in options or set ANTHROPIC_API_KEY environment variable.");
-  }
-  const storyboardOptions = {
-    muxTokenId,
-    muxTokenSecret};
-  const assetInfo = await getAssetInfo(assetId, storyboardOptions);
-  const imageUrl = `https://image.mux.com/${assetInfo.playbackId}/storyboard.png?width=640`;
-  let analysisResult = null;
-  if (provider === "openai") {
-    const OpenAI5 = __require("openai").default;
-    const openaiClient = new OpenAI5({ apiKey: openaiKey });
-    if (imageSubmissionMode === "base64") {
-      const { downloadImageAsBase64: downloadImageAsBase642 } = (init_image_download(), __toCommonJS(image_download_exports));
-      const downloadResult = await downloadImageAsBase642(imageUrl, imageDownloadOptions);
-      const response = await openaiClient.responses.parse({
-        model: finalModel,
-        input: [
-          {
-            role: "system",
-            content: ANTHROPIC_SYSTEM_PROMPT
-          },
-          {
-            role: "user",
-            content: [
-              {
-                type: "input_text",
-                text: ANTHROPIC_USER_PROMPT
-              },
-              {
-                type: "input_image",
-                image_url: downloadResult.base64Data,
-                detail: "high"
-              }
-            ]
-          }
-        ],
-        text: {
-          format: zodTextFormat(burnedInCaptionsSchema, "analysis")
-        }
-      });
-      analysisResult = response.output_parsed;
-    } else {
-      let retryAttempt = 0;
-      const maxRetries = 3;
-      while (retryAttempt <= maxRetries) {
-        try {
-          const response = await openaiClient.responses.parse({
-            model: finalModel,
-            input: [
-              {
-                role: "system",
-                content: ANTHROPIC_SYSTEM_PROMPT
-              },
-              {
-                role: "user",
-                content: [
-                  {
-                    type: "input_text",
-                    text: ANTHROPIC_USER_PROMPT
-                  },
-                  {
-                    type: "input_image",
-                    image_url: imageUrl,
-                    detail: "high"
-                  }
-                ]
-              }
-            ],
-            text: {
-              format: zodTextFormat(burnedInCaptionsSchema, "analysis")
-            }
-          });
-          analysisResult = response.output_parsed;
-          break;
-        } catch (error) {
-          const isTimeoutError = error instanceof Error && error.message && error.message.includes("Timeout while downloading");
-          if (isTimeoutError && retryAttempt < maxRetries) {
-            await new Promise((resolve) => setTimeout(resolve, 5e3));
-            retryAttempt++;
-            continue;
-          }
-          throw new Error(`Failed to analyze storyboard with OpenAI: ${error instanceof Error ? error.message : "Unknown error"}`);
-        }
-      }
-    }
-  } else if (provider === "anthropic") {
-    const anthropicPrompt = `${ANTHROPIC_USER_PROMPT}
-
-${ANTHROPIC_JSON_PROMPT3}`;
-    const responseParser = (response) => {
-      const content = response.content[0];
-      if (content.type === "text") {
-        const jsonText = content.text.trim();
-        try {
-          return JSON.parse(jsonText);
-        } catch (parseError) {
-          throw new Error(`Failed to parse JSON response from Anthropic: ${parseError instanceof Error ? parseError.message : "Unknown error"}`);
-        }
-      } else {
-        throw new Error("Unexpected response type from Anthropic");
-      }
-    };
-    analysisResult = await processStoryboardWithAnthropic(
-      imageUrl,
-      anthropicPrompt,
-      {
-        apiKey: anthropicKey,
-        model: finalModel,
-        responseParser,
-        imageSubmissionMode,
-        imageDownloadOptions
+  console.log("\u{1F4E4} Uploading translated VTT to S3-compatible storage...");
+  const s3Client = new import_client_s32.S3Client({
+    region: s3Region,
+    endpoint: s3Endpoint,
+    credentials: {
+      accessKeyId: s3AccessKeyId,
+      secretAccessKey: s3SecretAccessKey
+    },
+    forcePathStyle: true
+    // Often needed for non-AWS S3 services
+  });
+  const vttKey = `translations/${assetId}/${fromLanguageCode}-to-${toLanguageCode}-${Date.now()}.vtt`;
+  let presignedUrl;
+  try {
+    const upload = new import_lib_storage2.Upload({
+      client: s3Client,
+      params: {
+        Bucket: s3Bucket,
+        Key: vttKey,
+        Body: translatedVtt,
+        ContentType: "text/vtt"
       }
-    );
-  } else {
-    throw new Error(`Unsupported provider: ${provider}`);
+    });
+    await upload.done();
+    console.log(`\u2705 VTT uploaded successfully to: ${vttKey}`);
+    const getObjectCommand = new import_client_s32.GetObjectCommand({
+      Bucket: s3Bucket,
+      Key: vttKey
+    });
+    presignedUrl = await (0, import_s3_request_presigner2.getSignedUrl)(s3Client, getObjectCommand, {
+      expiresIn: 3600
+      // 1 hour
+    });
+    console.log(`\u{1F517} Generated presigned URL (expires in 1 hour)`);
+  } catch (error) {
+    throw new Error(`Failed to upload VTT to S3: ${error instanceof Error ? error.message : "Unknown error"}`);
   }
-  if (!analysisResult) {
-    throw new Error("No analysis result received from AI provider");
+  console.log("\u{1F4F9} Adding translated track to Mux asset...");
+  let uploadedTrackId;
+  try {
+    const languageName = new Intl.DisplayNames(["en"], { type: "language" }).of(toLanguageCode) || toLanguageCode.toUpperCase();
+    const trackName = `${languageName} (auto-translated)`;
+    const trackResponse = await clients.mux.video.assets.createTrack(assetId, {
+      type: "text",
+      text_type: "subtitles",
+      language_code: toLanguageCode,
+      name: trackName,
+      url: presignedUrl
+    });
+    uploadedTrackId = trackResponse.id;
+    console.log(`\u2705 Track added to Mux asset with ID: ${uploadedTrackId}`);
+    console.log(`\u{1F4CB} Track name: "${trackName}"`);
+  } catch (error) {
+    console.warn(`\u26A0\uFE0F Failed to add track to Mux asset: ${error instanceof Error ? error.message : "Unknown error"}`);
+    console.log("\u{1F517} You can manually add the track using this presigned URL:");
+    console.log(presignedUrl);
   }
   return {
     assetId,
-    hasBurnedInCaptions: analysisResult.hasBurnedInCaptions ?? false,
-    confidence: analysisResult.confidence ?? 0,
-    detectedLanguage: analysisResult.detectedLanguage ?? null,
-    storyboardUrl: imageUrl
+    sourceLanguageCode: fromLanguageCode,
+    targetLanguageCode: toLanguageCode,
+    originalVtt: vttContent,
+    translatedVtt,
+    uploadedTrackId,
+    presignedUrl
   };
 }
 
 // src/index.ts
 var version = "0.1.0";
-
-export { generateChapters, getModerationScores, getSummaryAndTags, hasBurnedInCaptions, translateAudio, translateCaptions, version };
-//# sourceMappingURL=index.js.map
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  primitives,
+  version,
+  workflows
+});
 //# sourceMappingURL=index.js.map