@mux/ai 0.1.2 → 0.1.4

package/dist/workflows/index.js

@@ -0,0 +1,2217 @@
+"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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  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/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
+});
+module.exports = __toCommonJS(workflows_exports);
+
+// 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_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/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_node.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 (0, import_p_retry.default)(
+    async () => {
+      attemptCount++;
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), opts.timeout);
+      try {
+        const response = await fetch(url, {
+          signal: controller.signal,
+          headers: {
+            "User-Agent": "@mux/ai image downloader"
+          }
+        });
+        clearTimeout(timeoutId);
+        if (!response.ok) {
+          if (response.status >= 400 && response.status < 500 && response.status !== 429) {
+            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 import_p_retry.AbortError(`Invalid content type: ${contentType}. Expected image/*`);
+        }
+        const arrayBuffer = await response.arrayBuffer();
+        const buffer = import_node_buffer.Buffer.from(arrayBuffer);
+        if (buffer.length === 0) {
+          throw new import_p_retry.AbortError("Downloaded image is empty");
+        }
+        const base64Data = `data:${contentType};base64,${buffer.toString("base64")}`;
+        return {
+          base64Data,
+          buffer,
+          url,
+          contentType,
+          sizeBytes: buffer.length,
+          attempts: attemptCount
+        };
+      } catch (error) {
+        clearTimeout(timeoutId);
+        if (error instanceof import_p_retry.AbortError) {
+          throw error;
+        }
+        if (error instanceof Error) {
+          if (error.name === "AbortError") {
+            throw new Error(`Request timeout after ${opts.timeout}ms`);
+          }
+          throw new Error(`Download failed: ${error.message}`);
+        }
+        throw new Error("Unknown download error");
+      }
+    },
+    {
+      retries: opts.retries,
+      minTimeout: opts.retryDelay,
+      maxTimeout: opts.maxRetryDelay,
+      factor: opts.exponentialBackoff ? 2 : 1,
+      randomize: true,
+      // Add jitter to prevent thundering herd
+      onFailedAttempt: (error) => {
+        console.warn(`Image download attempt ${error.attemptNumber} failed for ${url}`);
+        if (error.retriesLeft > 0) {
+          console.warn(`Retrying... (${error.retriesLeft} attempts left)`);
+        }
+      }
+    }
+  );
+}
+async function downloadImagesAsBase64(urls, options = {}, maxConcurrent = 5) {
+  const results = [];
+  for (let i = 0; i < urls.length; i += maxConcurrent) {
+    const batch = urls.slice(i, i + maxConcurrent);
+    const batchPromises = batch.map((url) => downloadImageAsBase64(url, options));
+    const batchResults = await Promise.all(batchPromises);
+    results.push(...batchResults);
+  }
+  return results;
+}
+
+// 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 };
+  }
+  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 {
+    template,
+    build,
+    buildWithContext,
+    getSection
+  };
+}
+function createTranscriptSection(transcriptText, format = "plain text") {
+  return {
+    tag: "transcript",
+    content: transcriptText,
+    attributes: { format }
+  };
+}
+function createToneSection(instruction) {
+  return {
+    tag: "tone",
+    content: instruction
+  };
+}
+
+// src/lib/url-signing.ts
+var import_mux_node2 = __toESM(require("@mux/mux-node"));
+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_node2.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/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>
+
+  <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/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/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");
+
+// 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/workflows/embeddings.ts
+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/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/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",
+  "bra",
+  "panties",
+  "sex_toys",
+  "nudity_female",
+  "nudity_male",
+  "cleavage",
+  "swimwear"
+];
+var HIVE_VIOLENCE_CATEGORIES = [
+  "gun_in_hand",
+  "gun_not_in_hand",
+  "animated_gun",
+  "knife_in_hand",
+  "knife_not_in_hand",
+  "culinary_knife_not_in_hand",
+  "culinary_knife_in_hand",
+  "very_bloody",
+  "a_little_bloody",
+  "other_blood",
+  "hanging",
+  "noose",
+  "human_corpse",
+  "animated_corpse",
+  "emaciated_body",
+  "self_harm",
+  "animal_abuse",
+  "fights",
+  "garm_death_injury_or_military_conflict"
+];
+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;
+}
+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 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 json = await res.json();
+      if (!res.ok) {
+        throw new Error(
+          `OpenAI moderation error: ${res.status} ${res.statusText} - ${JSON.stringify(json)}`
+        );
+      }
+      const categoryScores = json.results?.[0]?.category_scores || {};
+      return {
+        url: entry.url,
+        sexual: categoryScores.sexual || 0,
+        violence: categoryScores.violence || 0,
+        error: false
+      };
+    } catch (error) {
+      console.error("OpenAI moderation failed:", error);
+      return {
+        url: entry.url,
+        sexual: 0,
+        violence: 0,
+        error: true
+      };
+    }
+  };
+  return processConcurrently(targetUrls, moderate, maxConcurrent);
+}
+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
+    }
+  })) : imageUrls.map((url) => ({
+    url,
+    source: { kind: "url", value: url }
+  }));
+  const moderate = async (entry) => {
+    try {
+      const formData = new FormData();
+      if (entry.source.kind === "url") {
+        formData.append("url", entry.source.value);
+      } else {
+        const extension = entry.source.contentType.split("/")[1] || "jpg";
+        const blob = new Blob([entry.source.buffer], {
+          type: entry.source.contentType
+        });
+        formData.append("media", blob, `thumbnail.${extension}`);
+      }
+      const res = await fetch(HIVE_ENDPOINT, {
+        method: "POST",
+        headers: {
+          Accept: "application/json",
+          Authorization: `Token ${apiKey}`
+        },
+        body: formData
+      });
+      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 classes = json?.status?.[0]?.response?.output?.[0]?.classes || [];
+      return {
+        url: entry.url,
+        sexual: getHiveCategoryScores(classes, HIVE_SEXUAL_CATEGORIES),
+        violence: getHiveCategoryScores(classes, HIVE_VIOLENCE_CATEGORIES),
+        error: false
+      };
+    } catch (error) {
+      console.error("Hive moderation failed:", error);
+      return {
+        url: entry.url,
+        sexual: 0,
+        violence: 0,
+        error: true
+      };
+    }
+  };
+  return processConcurrently(targets, moderate, maxConcurrent);
+}
+async function getModerationScores(assetId, options = {}) {
+  const {
+    provider = DEFAULT_PROVIDER4,
+    model = provider === "openai" ? "omni-moderation-latest" : void 0,
+    thresholds = DEFAULT_THRESHOLDS,
+    thumbnailInterval = 10,
+    thumbnailWidth = 640,
+    maxConcurrent = 5,
+    imageSubmissionMode = "url",
+    imageDownloadOptions
+  } = options;
+  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 thumbnailUrls = await getThumbnailUrls(playbackId, duration, {
+    interval: thumbnailInterval,
+    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,
+      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,
+      hiveApiKey,
+      maxConcurrent,
+      imageSubmissionMode,
+      imageDownloadOptions
+    );
+  } else {
+    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));
+  const finalThresholds = { ...DEFAULT_THRESHOLDS, ...thresholds };
+  return {
+    assetId,
+    thumbnailScores,
+    maxScores: {
+      sexual: maxSexual,
+      violence: maxViolence
+    },
+    exceedsThreshold: maxSexual > finalThresholds.sexual || maxViolence > finalThresholds.violence,
+    thresholds: finalThresholds
+  };
+}
+
+// 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>
+
+  <context>
+    You receive storyboard images containing multiple sequential frames extracted from a video.
+    These frames are arranged in a grid and represent the visual progression of the content over time.
+    Read frames left-to-right, top-to-bottom to understand the temporal sequence.
+  </context>
+
+  <transcript_guidance>
+    When a transcript is provided alongside the storyboard:
+    - Use it to understand spoken content, dialogue, narration, and audio context
+    - Correlate transcript content with visual frames to build a complete picture
+    - Extract key terminology, names, and specific language used by speakers
+    - Let the transcript inform keyword selection, especially for topics not visually obvious
+    - Prioritize visual content for the description, but enrich it with transcript insights
+    - If transcript and visuals conflict, trust the visual evidence
+  </transcript_guidance>
+
+  <capabilities>
+    - Extract meaning from visual sequences
+    - Identify subjects, actions, settings, and narrative arcs
+    - Generate accurate, searchable metadata
+    - Synthesize visual and transcript information when provided
+  </capabilities>
+
+  <constraints>
+    - Only describe what is clearly observable in the frames or explicitly stated in the transcript
+    - Do not fabricate details or make unsupported assumptions
+    - Return structured data matching the requested schema
+  </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 = DEFAULT_PROVIDER5,
+    model,
+    tone = DEFAULT_TONE,
+    includeTranscript = true,
+    cleanTranscript = true,
+    imageSubmissionMode = "url",
+    imageDownloadOptions,
+    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 transcriptText = includeTranscript ? (await fetchTranscriptForAsset(assetData, playbackId, {
+    cleanTranscript,
+    signingContext: policy === "signed" ? signingContext : void 0
+  })).transcriptText : "";
+  const userPrompt = buildUserPrompt2({
+    tone,
+    transcriptText,
+    isCleanTranscript: cleanTranscript,
+    promptOverrides
+  });
+  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 }
+          ]
+        }
+      ]
+    });
+    return response.object;
+  };
+  let aiAnalysis = null;
+  try {
+    if (imageSubmissionMode === "base64") {
+      const downloadResult = await downloadImageAsBase64(imageUrl, imageDownloadOptions);
+      aiAnalysis = await analyzeStoryboard(downloadResult.base64Data);
+    } else {
+      aiAnalysis = await withRetry(() => analyzeStoryboard(imageUrl));
+    }
+  } catch (error) {
+    throw new Error(
+      `Failed to analyze video content with ${provider}: ${error instanceof Error ? error.message : "Unknown error"}`
+    );
+  }
+  if (!aiAnalysis) {
+    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,
+    description: aiAnalysis.description,
+    tags: normalizeKeywords(aiAnalysis.keywords),
+    storyboardUrl: imageUrl
+  };
+}
+
+// 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 {
+    await muxClient.video.assets.createStaticRendition(assetId, {
+      resolution: "audio-only"
+    });
+    console.log("\u{1F4FC} Static rendition request accepted by Mux.");
+  } catch (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}`);
+  }
+}
+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."
+      );
+    }
+  }
+  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 {
+    provider = "elevenlabs",
+    numSpeakers = 0,
+    // 0 = auto-detect
+    muxTokenId,
+    muxTokenSecret,
+    elevenLabsApiKey,
+    uploadToMux = true
+  } = options;
+  if (provider !== "elevenlabs") {
+    throw new Error("Only ElevenLabs provider is currently supported for audio translation");
+  }
+  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.");
+  }
+  if (!elevenLabsKey) {
+    throw new Error("ElevenLabs API key is required. Provide elevenLabsApiKey in options or set ELEVENLABS_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 import_mux_node3.default({
+    tokenId: muxId,
+    tokenSecret: muxSecret
+  });
+  console.log(`\u{1F3AC} Fetching Mux asset: ${assetId}`);
+  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...");
+  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 = getReadyAudioStaticRendition(currentAsset);
+  if (!audioRendition) {
+    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");
+  }
+  console.log(`\u2705 Found audio rendition: ${audioUrl}`);
+  console.log(`\u{1F399}\uFE0F Creating ElevenLabs dubbing job (auto-detect \u2192 ${toLanguageCode})`);
+  let dubbingId;
+  try {
+    const audioResponse = await fetch(audioUrl);
+    if (!audioResponse.ok) {
+      throw new Error(`Failed to fetch audio file: ${audioResponse.statusText}`);
+    }
+    const audioBuffer = await audioResponse.arrayBuffer();
+    const audioBlob = new Blob([audioBuffer], { type: "audio/mp4" });
+    const audioFile = audioBlob;
+    const formData = new FormData();
+    formData.append("file", audioFile);
+    formData.append("target_lang", toLanguageCode);
+    formData.append("num_speakers", numSpeakers.toString());
+    formData.append("name", `Mux Asset ${assetId} - auto to ${toLanguageCode}`);
+    const dubbingResponse = await fetch("https://api.elevenlabs.io/v1/dubbing", {
+      method: "POST",
+      headers: {
+        "xi-api-key": elevenLabsKey
+      },
+      body: formData
+    });
+    if (!dubbingResponse.ok) {
+      throw new Error(`ElevenLabs API error: ${dubbingResponse.statusText}`);
+    }
+    const dubbingData = await dubbingResponse.json();
+    dubbingId = dubbingData.dubbing_id;
+    console.log(`\u2705 Dubbing job created: ${dubbingId}`);
+    console.log(`\u23F1\uFE0F Expected duration: ${dubbingData.expected_duration_sec}s`);
+  } catch (error) {
+    throw new Error(`Failed to create ElevenLabs dubbing job: ${error instanceof Error ? error.message : "Unknown error"}`);
+  }
+  console.log("\u23F3 Waiting for dubbing to complete...");
+  let dubbingStatus = "dubbing";
+  let pollAttempts = 0;
+  const maxPollAttempts = 180;
+  while (dubbingStatus === "dubbing" && pollAttempts < maxPollAttempts) {
+    await new Promise((resolve) => setTimeout(resolve, 1e4));
+    pollAttempts++;
+    try {
+      const statusResponse = await fetch(`https://api.elevenlabs.io/v1/dubbing/${dubbingId}`, {
+        headers: {
+          "xi-api-key": elevenLabsKey
+        }
+      });
+      if (!statusResponse.ok) {
+        throw new Error(`Status check failed: ${statusResponse.statusText}`);
+      }
+      const statusData = await statusResponse.json();
+      dubbingStatus = statusData.status;
+      console.log(`\u{1F4CA} Status check ${pollAttempts}: ${dubbingStatus}`);
+      if (dubbingStatus === "failed") {
+        throw new Error("ElevenLabs dubbing job failed");
+      }
+    } catch (error) {
+      throw new Error(`Failed to check dubbing status: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  if (dubbingStatus !== "dubbed") {
+    throw new Error(`Dubbing job timed out or failed. Final status: ${dubbingStatus}`);
+  }
+  console.log("\u2705 Dubbing completed successfully!");
+  if (!uploadToMux) {
+    return {
+      assetId,
+      targetLanguageCode: toLanguageCode,
+      dubbingId
+    };
+  }
+  console.log("\u{1F4E5} Downloading dubbed audio from ElevenLabs...");
+  let dubbedAudioBuffer;
+  try {
+    const audioUrl2 = `https://api.elevenlabs.io/v1/dubbing/${dubbingId}/audio/${toLanguageCode}`;
+    const audioResponse = await fetch(audioUrl2, {
+      headers: {
+        "xi-api-key": elevenLabsKey
+      }
+    });
+    if (!audioResponse.ok) {
+      throw new Error(`Failed to fetch dubbed audio: ${audioResponse.statusText}`);
+    }
+    dubbedAudioBuffer = await audioResponse.arrayBuffer();
+    console.log(`\u2705 Downloaded dubbed audio (${dubbedAudioBuffer.byteLength} bytes)`);
+  } catch (error) {
+    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 import_client_s3.S3Client({
+    region: s3Region,
+    endpoint: s3Endpoint,
+    credentials: {
+      accessKeyId: s3AccessKeyId,
+      secretAccessKey: s3SecretAccessKey
+    },
+    forcePathStyle: true
+  });
+  const audioKey = `audio-translations/${assetId}/auto-to-${toLanguageCode}-${Date.now()}.m4a`;
+  let presignedUrl;
+  try {
+    const upload = new import_lib_storage.Upload({
+      client: s3Client,
+      params: {
+        Bucket: s3Bucket,
+        Key: audioKey,
+        Body: new Uint8Array(dubbedAudioBuffer),
+        ContentType: "audio/mp4"
+      }
+    });
+    await upload.done();
+    console.log(`\u2705 Audio uploaded successfully to: ${audioKey}`);
+    const getObjectCommand = new import_client_s3.GetObjectCommand({
+      Bucket: s3Bucket,
+      Key: audioKey
+    });
+    presignedUrl = await (0, import_s3_request_presigner.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 audio to S3: ${error instanceof Error ? error.message : "Unknown error"}`);
+  }
+  console.log("\u{1F3AC} Adding translated audio track to Mux asset...");
+  let uploadedTrackId;
+  try {
+    const languageName = new Intl.DisplayNames(["en"], { type: "language" }).of(toLanguageCode) || toLanguageCode.toUpperCase();
+    const trackName = `${languageName} (auto-dubbed)`;
+    const trackResponse = await mux.video.assets.createTrack(assetId, {
+      type: "audio",
+      language_code: toLanguageCode,
+      name: trackName,
+      url: presignedUrl
+    });
+    uploadedTrackId = trackResponse.id;
+    console.log(`\u2705 Audio track added to Mux asset with ID: ${uploadedTrackId}`);
+    console.log(`\u{1F3B5} Track name: "${trackName}"`);
+  } catch (error) {
+    console.warn(`\u26A0\uFE0F Failed to add audio 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,
+    targetLanguageCode: toLanguageCode,
+    dubbingId,
+    uploadedTrackId,
+    presignedUrl
+  };
+}
+
+// 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 = DEFAULT_PROVIDER6,
+    model,
+    s3Endpoint: providedS3Endpoint,
+    s3Region: providedS3Region,
+    s3Bucket: providedS3Bucket,
+    s3AccessKeyId: providedS3AccessKeyId,
+    s3SecretAccessKey: providedS3SecretAccessKey,
+    uploadToMux: uploadToMuxOption,
+    ...clientConfig
+  } = options;
+  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 { 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 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`);
+  }
+  let vttUrl = `https://stream.mux.com/${playbackId}/text/${sourceTextTrack.id}.vtt`;
+  if (policy === "signed" && signingContext) {
+    vttUrl = await signUrl(vttUrl, playbackId, signingContext, "video");
+  }
+  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 (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.
+
+${vttContent}`
+        }
+      ]
+    });
+    translatedVtt = response.object.translation;
+  } catch (error) {
+    throw new Error(`Failed to translate VTT with ${resolvedProvider}: ${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 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"
+      }
+    });
+    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"}`);
+  }
+  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,
+    sourceLanguageCode: fromLanguageCode,
+    targetLanguageCode: toLanguageCode,
+    originalVtt: vttContent,
+    translatedVtt,
+    uploadedTrackId,
+    presignedUrl
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SUMMARY_KEYWORD_LIMIT,
+  burnedInCaptionsSchema,
+  chapterSchema,
+  chaptersSchema,
+  generateChapters,
+  generateVideoEmbeddings,
+  getModerationScores,
+  getSummaryAndTags,
+  hasBurnedInCaptions,
+  summarySchema,
+  translateAudio,
+  translateCaptions,
+  translationSchema
+});
+//# sourceMappingURL=index.js.map