@mux/ai 0.1.6 → 0.2.0

package/dist/workflows/index.mjs

@@ -1,2168 +0,0 @@
-// src/workflows/burned-in-captions.ts
-import { generateObject } from "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
-import { z as z2 } from "zod";
-
-// src/lib/client-factory.ts
-import Mux from "@mux/mux-node";
-
-// src/env.ts
-import path from "path";
-import { config } from "dotenv";
-import { expand } from "dotenv-expand";
-import { z } from "zod";
-expand(config({
-  path: path.resolve(
-    process.cwd(),
-    process.env.NODE_ENV === "test" ? ".env.test" : ".env"
-  )
-}));
-function optionalString(description, message) {
-  return z.preprocess(
-    (value) => typeof value === "string" && value.trim().length === 0 ? void 0 : value,
-    z.string().trim().min(1, message).optional()
-  ).describe(description);
-}
-function requiredString(description, message) {
-  return z.preprocess(
-    (value) => typeof value === "string" ? value.trim().length > 0 ? value.trim() : void 0 : value,
-    z.string().trim().min(1, message)
-  ).describe(description);
-}
-var EnvSchema = z.object({
-  NODE_ENV: 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
-import { createAnthropic } from "@ai-sdk/anthropic";
-import { createGoogleGenerativeAI } from "@ai-sdk/google";
-import { createOpenAI } from "@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 = 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 = 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 = 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 = 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 = 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 Mux({
-    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
-import { Buffer } from "buffer";
-import pRetry, { AbortError } from "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(
-    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 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/*`);
-        }
-        const arrayBuffer = await response.arrayBuffer();
-        const buffer = Buffer.from(arrayBuffer);
-        if (buffer.length === 0) {
-          throw new 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 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
-import Mux2 from "@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 Mux2({
-    // 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 = z2.object({
-  hasBurnedInCaptions: z2.boolean(),
-  confidence: z2.number().min(0).max(1),
-  detectedLanguage: z2.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 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
-import { generateObject as generateObject2 } from "ai";
-import { z as z3 } from "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 = z3.object({
-  startTime: z3.number(),
-  title: z3.string()
-});
-var chaptersSchema = z3.object({
-  chapters: z3.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(
-      () => generateObject2({
-        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
-import { embed } from "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(
-          () => 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
-import { generateObject as generateObject3 } from "ai";
-import { z as z4 } from "zod";
-var SUMMARY_KEYWORD_LIMIT = 10;
-var summarySchema = z4.object({
-  keywords: z4.array(z4.string()),
-  title: z4.string(),
-  description: z4.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 generateObject3({
-      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
-import { GetObjectCommand, S3Client } from "@aws-sdk/client-s3";
-import { Upload } from "@aws-sdk/lib-storage";
-import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
-import Mux3 from "@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 Mux3({
-    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 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 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 GetObjectCommand({
-      Bucket: s3Bucket,
-      Key: audioKey
-    });
-    presignedUrl = await 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
-import { GetObjectCommand as GetObjectCommand2, S3Client as S3Client2 } from "@aws-sdk/client-s3";
-import { Upload as Upload2 } from "@aws-sdk/lib-storage";
-import { getSignedUrl as getSignedUrl2 } from "@aws-sdk/s3-request-presigner";
-import { generateObject as generateObject4 } from "ai";
-import { z as z5 } from "zod";
-var translationSchema = z5.object({
-  translation: z5.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 generateObject4({
-      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 S3Client2({
-    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 Upload2({
-      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 GetObjectCommand2({
-      Bucket: s3Bucket,
-      Key: vttKey
-    });
-    presignedUrl = await getSignedUrl2(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
-  };
-}
-export {
-  SUMMARY_KEYWORD_LIMIT,
-  burnedInCaptionsSchema,
-  chapterSchema,
-  chaptersSchema,
-  generateChapters,
-  generateVideoEmbeddings,
-  getModerationScores,
-  getSummaryAndTags,
-  hasBurnedInCaptions,
-  summarySchema,
-  translateAudio,
-  translateCaptions,
-  translationSchema
-};
-//# sourceMappingURL=index.mjs.map