@mux/ai 0.1.6 → 0.3.0

package/dist/index.js

@@ -1,40 +1,8 @@
-"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/index.ts
-var index_exports = {};
-__export(index_exports, {
-  primitives: () => primitives_exports,
-  version: () => version,
-  workflows: () => workflows_exports
-});
-module.exports = __toCommonJS(index_exports);
 
 // src/primitives/index.ts
 var primitives_exports = {};
@@ -57,33 +25,25 @@ __export(primitives_exports, {
 });
 
 // src/lib/url-signing.ts
-var import_mux_node = __toESM(require("@mux/mux-node"));
+import Mux from "@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"
-  )
-}));
+import { z } from "zod";
+import "dotenv/config";
 function optionalString(description, message) {
-  return import_zod.z.preprocess(
+  return z.preprocess(
     (value) => typeof value === "string" && value.trim().length === 0 ? void 0 : value,
-    import_zod.z.string().trim().min(1, message).optional()
+    z.string().trim().min(1, message).optional()
   ).describe(description);
 }
 function requiredString(description, message) {
-  return import_zod.z.preprocess(
+  return z.preprocess(
     (value) => typeof value === "string" ? value.trim().length > 0 ? value.trim() : void 0 : value,
-    import_zod.z.string().trim().min(1, message)
+    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."),
+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"),
@@ -112,16 +72,16 @@ var env = parseEnv();
 var env_default = env;
 
 // src/lib/url-signing.ts
-function resolveSigningContext(config2) {
-  const keyId = config2.muxSigningKey ?? env_default.MUX_SIGNING_KEY;
-  const keySecret = config2.muxPrivateKey ?? env_default.MUX_PRIVATE_KEY;
+function getMuxSigningContextFromEnv() {
+  const keyId = env_default.MUX_SIGNING_KEY;
+  const keySecret = env_default.MUX_PRIVATE_KEY;
   if (!keyId || !keySecret) {
     return void 0;
   }
   return { keyId, keySecret };
 }
 function createSigningClient(context) {
-  return new import_mux_node.default({
+  return new Mux({
     // 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 || "",
@@ -131,6 +91,7 @@ function createSigningClient(context) {
   });
 }
 async function signPlaybackId(playbackId, context, type = "video", params) {
+  "use step";
   const client = createSigningClient(context);
   const stringParams = params ? Object.fromEntries(
     Object.entries(params).map(([key, value]) => [key, String(value)])
@@ -142,6 +103,7 @@ async function signPlaybackId(playbackId, context, type = "video", params) {
   });
 }
 async function signUrl(url, playbackId, context, type = "video", params) {
+  "use step";
   const token = await signPlaybackId(playbackId, context, type, params);
   const separator = url.includes("?") ? "&" : "?";
   return `${url}${separator}token=${token}`;
@@ -149,9 +111,11 @@ async function signUrl(url, playbackId, context, type = "video", params) {
 
 // src/primitives/storyboards.ts
 var DEFAULT_STORYBOARD_WIDTH = 640;
-async function getStoryboardUrl(playbackId, width = DEFAULT_STORYBOARD_WIDTH, signingContext) {
+async function getStoryboardUrl(playbackId, width = DEFAULT_STORYBOARD_WIDTH, shouldSign = false) {
+  "use step";
   const baseUrl = `https://image.mux.com/${playbackId}/storyboard.png`;
-  if (signingContext) {
+  if (shouldSign) {
+    const signingContext = getMuxSigningContextFromEnv();
     return signUrl(baseUrl, playbackId, signingContext, "storyboard", { width });
   }
   return `${baseUrl}?width=${width}`;
@@ -244,7 +208,8 @@ function chunkText(text, strategy) {
 
 // src/primitives/thumbnails.ts
 async function getThumbnailUrls(playbackId, duration, options = {}) {
-  const { interval = 10, width = 640, signingContext } = options;
+  "use step";
+  const { interval = 10, width = 640, shouldSign = false } = options;
   const timestamps = [];
   if (duration <= 50) {
     const spacing = duration / 6;
@@ -258,7 +223,8 @@ async function getThumbnailUrls(playbackId, duration, options = {}) {
   }
   const baseUrl = `https://image.mux.com/${playbackId}/thumbnail.png`;
   const urlPromises = timestamps.map(async (time) => {
-    if (signingContext) {
+    if (shouldSign) {
+      const signingContext = getMuxSigningContextFromEnv();
       return signUrl(baseUrl, playbackId, signingContext, "thumbnail", { time, width });
     }
     return `${baseUrl}?time=${time}&width=${width}`;
@@ -374,15 +340,18 @@ function parseVTTCues(vttContent) {
   }
   return cues;
 }
-async function buildTranscriptUrl(playbackId, trackId, signingContext) {
+async function buildTranscriptUrl(playbackId, trackId, shouldSign = false) {
+  "use step";
   const baseUrl = `https://stream.mux.com/${playbackId}/text/${trackId}.vtt`;
-  if (signingContext) {
+  if (shouldSign) {
+    const signingContext = getMuxSigningContextFromEnv();
     return signUrl(baseUrl, playbackId, signingContext, "video");
   }
   return baseUrl;
 }
 async function fetchTranscriptForAsset(asset, playbackId, options = {}) {
-  const { languageCode, cleanTranscript = true, signingContext } = options;
+  "use step";
+  const { languageCode, cleanTranscript = true, shouldSign } = options;
   const track = findCaptionTrack(asset, languageCode);
   if (!track) {
     return { transcriptText: "" };
@@ -390,7 +359,7 @@ async function fetchTranscriptForAsset(asset, playbackId, options = {}) {
   if (!track.id) {
     return { transcriptText: "", track };
   }
-  const transcriptUrl = await buildTranscriptUrl(playbackId, track.id, signingContext);
+  const transcriptUrl = await buildTranscriptUrl(playbackId, track.id, shouldSign);
   try {
     const response = await fetch(transcriptUrl);
     if (!response.ok) {
@@ -424,130 +393,17 @@ __export(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_node2 = __toESM(require("@mux/mux-node"));
+import { generateObject } from "ai";
+import dedent from "dedent";
+import { z as z2 } from "zod";
 
 // 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");
+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",
+  openai: "gpt-5.1",
+  anthropic: "claude-sonnet-4-5",
   google: "gemini-2.5-flash"
 };
 var DEFAULT_EMBEDDING_MODELS = {
@@ -560,14 +416,60 @@ function requireEnv(value, name) {
   }
   return value;
 }
+function createLanguageModelFromConfig(provider, modelId) {
+  switch (provider) {
+    case "openai": {
+      const apiKey = env_default.OPENAI_API_KEY;
+      requireEnv(apiKey, "OPENAI_API_KEY");
+      const openai = createOpenAI({ apiKey });
+      return openai(modelId);
+    }
+    case "anthropic": {
+      const apiKey = env_default.ANTHROPIC_API_KEY;
+      requireEnv(apiKey, "ANTHROPIC_API_KEY");
+      const anthropic = createAnthropic({ apiKey });
+      return anthropic(modelId);
+    }
+    case "google": {
+      const apiKey = env_default.GOOGLE_GENERATIVE_AI_API_KEY;
+      requireEnv(apiKey, "GOOGLE_GENERATIVE_AI_API_KEY");
+      const google = createGoogleGenerativeAI({ apiKey });
+      return google(modelId);
+    }
+    default: {
+      const exhaustiveCheck = provider;
+      throw new Error(`Unsupported provider: ${exhaustiveCheck}`);
+    }
+  }
+}
+function createEmbeddingModelFromConfig(provider, modelId) {
+  switch (provider) {
+    case "openai": {
+      const apiKey = env_default.OPENAI_API_KEY;
+      requireEnv(apiKey, "OPENAI_API_KEY");
+      const openai = createOpenAI({ apiKey });
+      return openai.embedding(modelId);
+    }
+    case "google": {
+      const apiKey = env_default.GOOGLE_GENERATIVE_AI_API_KEY;
+      requireEnv(apiKey, "GOOGLE_GENERATIVE_AI_API_KEY");
+      const google = createGoogleGenerativeAI({ apiKey });
+      return google.textEmbeddingModel(modelId);
+    }
+    default: {
+      const exhaustiveCheck = provider;
+      throw new Error(`Unsupported embedding provider: ${exhaustiveCheck}`);
+    }
+  }
+}
 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;
+      const apiKey = env_default.OPENAI_API_KEY;
       requireEnv(apiKey, "OPENAI_API_KEY");
-      const openai = (0, import_openai.createOpenAI)({
+      const openai = createOpenAI({
         apiKey
       });
       return {
@@ -577,9 +479,9 @@ function resolveLanguageModel(options = {}) {
       };
     }
     case "anthropic": {
-      const apiKey = options.anthropicApiKey ?? env_default.ANTHROPIC_API_KEY;
+      const apiKey = env_default.ANTHROPIC_API_KEY;
       requireEnv(apiKey, "ANTHROPIC_API_KEY");
-      const anthropic = (0, import_anthropic.createAnthropic)({
+      const anthropic = createAnthropic({
         apiKey
       });
       return {
@@ -589,9 +491,9 @@ function resolveLanguageModel(options = {}) {
       };
     }
     case "google": {
-      const apiKey = options.googleApiKey ?? env_default.GOOGLE_GENERATIVE_AI_API_KEY;
+      const apiKey = env_default.GOOGLE_GENERATIVE_AI_API_KEY;
       requireEnv(apiKey, "GOOGLE_GENERATIVE_AI_API_KEY");
-      const google = (0, import_google.createGoogleGenerativeAI)({
+      const google = createGoogleGenerativeAI({
         apiKey
       });
       return {
@@ -611,9 +513,9 @@ function resolveEmbeddingModel(options = {}) {
   const modelId = options.model || DEFAULT_EMBEDDING_MODELS[provider];
   switch (provider) {
     case "openai": {
-      const apiKey = options.openaiApiKey ?? env_default.OPENAI_API_KEY;
+      const apiKey = env_default.OPENAI_API_KEY;
       requireEnv(apiKey, "OPENAI_API_KEY");
-      const openai = (0, import_openai.createOpenAI)({
+      const openai = createOpenAI({
         apiKey
       });
       return {
@@ -623,9 +525,9 @@ function resolveEmbeddingModel(options = {}) {
       };
     }
     case "google": {
-      const apiKey = options.googleApiKey ?? env_default.GOOGLE_GENERATIVE_AI_API_KEY;
+      const apiKey = env_default.GOOGLE_GENERATIVE_AI_API_KEY;
       requireEnv(apiKey, "GOOGLE_GENERATIVE_AI_API_KEY");
-      const google = (0, import_google.createGoogleGenerativeAI)({
+      const google = createGoogleGenerativeAI({
         apiKey
       });
       return {
@@ -642,12 +544,45 @@ function resolveEmbeddingModel(options = {}) {
 }
 
 // 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;
+function getMuxCredentialsFromEnv() {
+  const muxTokenId = env_default.MUX_TOKEN_ID;
+  const muxTokenSecret = env_default.MUX_TOKEN_SECRET;
+  if (!muxTokenId || !muxTokenSecret) {
+    throw new Error(
+      "Mux credentials are required. Set MUX_TOKEN_ID and MUX_TOKEN_SECRET environment variables."
+    );
+  }
+  return { muxTokenId, muxTokenSecret };
+}
+function getApiKeyFromEnv(provider) {
+  const envVarMap = {
+    openai: env_default.OPENAI_API_KEY,
+    anthropic: env_default.ANTHROPIC_API_KEY,
+    google: env_default.GOOGLE_GENERATIVE_AI_API_KEY,
+    hive: env_default.HIVE_API_KEY,
+    elevenlabs: env_default.ELEVENLABS_API_KEY
+  };
+  const apiKey = envVarMap[provider];
+  if (!apiKey) {
+    const envVarNames = {
+      openai: "OPENAI_API_KEY",
+      anthropic: "ANTHROPIC_API_KEY",
+      google: "GOOGLE_GENERATIVE_AI_API_KEY",
+      hive: "HIVE_API_KEY",
+      elevenlabs: "ELEVENLABS_API_KEY"
+    };
+    throw new Error(
+      `${provider} API key is required. Set ${envVarNames[provider]} environment variable.`
+    );
+  }
+  return apiKey;
+}
+async function validateCredentials(requiredProvider) {
+  const muxTokenId = env_default.MUX_TOKEN_ID;
+  const muxTokenSecret = env_default.MUX_TOKEN_SECRET;
+  const openaiApiKey = env_default.OPENAI_API_KEY;
+  const anthropicApiKey = env_default.ANTHROPIC_API_KEY;
+  const 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."
@@ -676,32 +611,23 @@ function validateCredentials(options, requiredProvider) {
     googleApiKey
   };
 }
-function createMuxClient(credentials) {
-  if (!credentials.muxTokenId || !credentials.muxTokenSecret) {
-    throw new Error("Mux credentials are required. Provide muxTokenId and muxTokenSecret in options or set MUX_TOKEN_ID and MUX_TOKEN_SECRET environment variables.");
-  }
-  return new import_mux_node2.default({
-    tokenId: credentials.muxTokenId,
-    tokenSecret: credentials.muxTokenSecret
-  });
-}
-function createWorkflowClients(options, provider) {
+async function createWorkflowConfig(options, provider) {
   const providerToUse = provider || options.provider || "openai";
-  const credentials = validateCredentials(options, providerToUse);
-  const languageModel = resolveLanguageModel({
+  const credentials = await validateCredentials(providerToUse);
+  const resolved = resolveLanguageModel({
     ...options,
     provider: providerToUse
   });
   return {
-    mux: createMuxClient(credentials),
-    languageModel,
-    credentials
+    credentials,
+    provider: resolved.provider,
+    modelId: resolved.modelId
   };
 }
 
 // src/lib/image-download.ts
-var import_node_buffer = require("buffer");
-var import_p_retry = __toESM(require("p-retry"));
+import { Buffer as Buffer2 } from "buffer";
+import pRetry, { AbortError } from "p-retry";
 var DEFAULT_OPTIONS = {
   timeout: 1e4,
   retries: 3,
@@ -710,9 +636,10 @@ var DEFAULT_OPTIONS = {
   exponentialBackoff: true
 };
 async function downloadImageAsBase64(url, options = {}) {
+  "use step";
   const opts = { ...DEFAULT_OPTIONS, ...options };
   let attemptCount = 0;
-  return (0, import_p_retry.default)(
+  return pRetry(
     async () => {
       attemptCount++;
       const controller = new AbortController();
@@ -727,18 +654,18 @@ async function downloadImageAsBase64(url, options = {}) {
         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 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/*`);
+          throw new AbortError(`Invalid content type: ${contentType}. Expected image/*`);
         }
         const arrayBuffer = await response.arrayBuffer();
-        const buffer = import_node_buffer.Buffer.from(arrayBuffer);
+        const buffer = Buffer2.from(arrayBuffer);
         if (buffer.length === 0) {
-          throw new import_p_retry.AbortError("Downloaded image is empty");
+          throw new AbortError("Downloaded image is empty");
         }
         const base64Data = `data:${contentType};base64,${buffer.toString("base64")}`;
         return {
@@ -751,7 +678,7 @@ async function downloadImageAsBase64(url, options = {}) {
         };
       } catch (error) {
         clearTimeout(timeoutId);
-        if (error instanceof import_p_retry.AbortError) {
+        if (error instanceof AbortError) {
           throw error;
         }
         if (error instanceof Error) {
@@ -780,6 +707,7 @@ async function downloadImageAsBase64(url, options = {}) {
   );
 }
 async function downloadImagesAsBase64(urls, options = {}, maxConcurrent = 5) {
+  "use step";
   const results = [];
   for (let i = 0; i < urls.length; i += maxConcurrent) {
     const batch = urls.slice(i, i + maxConcurrent);
@@ -791,6 +719,7 @@ async function downloadImagesAsBase64(urls, options = {}, maxConcurrent = 5) {
 }
 
 // src/lib/mux-assets.ts
+import Mux2 from "@mux/mux-node";
 function getPlaybackId(asset) {
   const playbackIds = asset.playback_ids || [];
   const publicPlaybackId = playbackIds.find((pid) => pid.policy === "public");
@@ -805,7 +734,13 @@ function getPlaybackId(asset) {
     "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) {
+async function getPlaybackIdForAsset(assetId) {
+  "use step";
+  const { muxTokenId, muxTokenSecret } = getMuxCredentialsFromEnv();
+  const mux = new Mux2({
+    tokenId: muxTokenId,
+    tokenSecret: muxTokenSecret
+  });
   const asset = await mux.video.assets.retrieve(assetId);
   const { id: playbackId, policy } = getPlaybackId(asset);
   return { asset, playbackId, policy };
@@ -844,8 +779,8 @@ function resolveSection(defaultSection, override) {
   }
   return override;
 }
-function createPromptBuilder(config2) {
-  const { template, sectionOrder } = config2;
+function createPromptBuilder(config) {
+  const { template, sectionOrder } = config;
   const getSection = (section, override) => {
     const resolved = resolveSection(template[section], override);
     return renderSection(resolved);
@@ -886,12 +821,12 @@ function createToneSection(instruction) {
 }
 
 // src/workflows/burned-in-captions.ts
-var burnedInCaptionsSchema = import_zod2.z.object({
-  hasBurnedInCaptions: import_zod2.z.boolean(),
-  confidence: import_zod2.z.number().min(0).max(1),
-  detectedLanguage: import_zod2.z.string().nullable()
+var burnedInCaptionsSchema = z2.object({
+  hasBurnedInCaptions: z2.boolean(),
+  confidence: z2.number().min(0).max(1),
+  detectedLanguage: z2.string().nullable()
 });
-var SYSTEM_PROMPT = dedent_default`
+var SYSTEM_PROMPT = dedent`
   <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.
@@ -934,14 +869,14 @@ var burnedInCaptionsPromptBuilder = createPromptBuilder({
   template: {
     task: {
       tag: "task",
-      content: dedent_default`
+      content: dedent`
         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`
+      content: dedent`
         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)
@@ -950,7 +885,7 @@ var burnedInCaptionsPromptBuilder = createPromptBuilder({
     },
     positiveIndicators: {
       tag: "classify_as_captions",
-      content: dedent_default`
+      content: dedent`
         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
@@ -959,7 +894,7 @@ var burnedInCaptionsPromptBuilder = createPromptBuilder({
     },
     negativeIndicators: {
       tag: "not_captions",
-      content: dedent_default`
+      content: dedent`
         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
@@ -974,65 +909,90 @@ function buildUserPrompt(promptOverrides) {
   return burnedInCaptionsPromptBuilder.build(promptOverrides);
 }
 var DEFAULT_PROVIDER = "openai";
+async function fetchImageAsBase64(imageUrl, imageDownloadOptions) {
+  "use step";
+  const downloadResult = await downloadImageAsBase64(imageUrl, imageDownloadOptions);
+  return downloadResult.base64Data;
+}
+async function analyzeStoryboard({
+  imageDataUrl,
+  provider,
+  modelId,
+  userPrompt,
+  systemPrompt
+}) {
+  "use step";
+  const model = createLanguageModelFromConfig(provider, modelId);
+  const response = await generateObject({
+    model,
+    schema: burnedInCaptionsSchema,
+    experimental_telemetry: { isEnabled: true },
+    messages: [
+      {
+        role: "system",
+        content: systemPrompt
+      },
+      {
+        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
+    }
+  };
+}
 async function hasBurnedInCaptions(assetId, options = {}) {
+  "use workflow";
   const {
     provider = DEFAULT_PROVIDER,
     model,
     imageSubmissionMode = "url",
     imageDownloadOptions,
     promptOverrides,
-    ...config2
+    ...config
   } = options;
   const userPrompt = buildUserPrompt(promptOverrides);
-  const clients = createWorkflowClients(
-    { ...config2, model },
+  const workflowConfig = await createWorkflowConfig(
+    { ...config, model },
     provider
   );
-  const { playbackId, policy } = await getPlaybackIdForAsset(clients.mux, assetId);
-  const signingContext = resolveSigningContext(options);
+  const { playbackId, policy } = await getPlaybackIdForAsset(assetId);
+  const signingContext = getMuxSigningContextFromEnv();
   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
-      }
-    };
-  };
+  const imageUrl = await getStoryboardUrl(playbackId, 640, policy === "signed");
   let analysisResponse;
   if (imageSubmissionMode === "base64") {
-    const downloadResult = await downloadImageAsBase64(imageUrl, imageDownloadOptions);
-    analysisResponse = await analyzeStoryboard(downloadResult.base64Data);
+    const base64Data = await fetchImageAsBase64(imageUrl, imageDownloadOptions);
+    analysisResponse = await analyzeStoryboard({
+      imageDataUrl: base64Data,
+      provider: workflowConfig.provider,
+      modelId: workflowConfig.modelId,
+      userPrompt,
+      systemPrompt: SYSTEM_PROMPT
+    });
   } else {
-    analysisResponse = await analyzeStoryboard(imageUrl);
+    analysisResponse = await analyzeStoryboard({
+      imageDataUrl: imageUrl,
+      provider: workflowConfig.provider,
+      modelId: workflowConfig.modelId,
+      userPrompt,
+      systemPrompt: SYSTEM_PROMPT
+    });
   }
   if (!analysisResponse.result) {
     throw new Error("No analysis result received from AI provider");
@@ -1048,8 +1008,8 @@ async function hasBurnedInCaptions(assetId, options = {}) {
 }
 
 // src/workflows/chapters.ts
-var import_ai2 = require("ai");
-var import_zod3 = require("zod");
+import { generateObject as generateObject2 } from "ai";
+import { z as z3 } from "zod";
 
 // src/lib/retry.ts
 var DEFAULT_RETRY_OPTIONS = {
@@ -1081,25 +1041,50 @@ async function withRetry(fn, {
       if (isLastAttempt || !shouldRetry(lastError, attempt + 1)) {
         throw lastError;
       }
-      const delay2 = calculateDelay(attempt + 1, baseDelay, maxDelay);
+      const delay = calculateDelay(attempt + 1, baseDelay, maxDelay);
       console.warn(
-        `Attempt ${attempt + 1} failed: ${lastError.message}. Retrying in ${Math.round(delay2)}ms...`
+        `Attempt ${attempt + 1} failed: ${lastError.message}. Retrying in ${Math.round(delay)}ms...`
       );
-      await new Promise((resolve) => setTimeout(resolve, delay2));
+      await new Promise((resolve) => setTimeout(resolve, delay));
     }
   }
   throw lastError || new Error("Retry failed with unknown error");
 }
 
 // src/workflows/chapters.ts
-var chapterSchema = import_zod3.z.object({
-  startTime: import_zod3.z.number(),
-  title: import_zod3.z.string()
+var chapterSchema = z3.object({
+  startTime: z3.number(),
+  title: z3.string()
 });
-var chaptersSchema = import_zod3.z.object({
-  chapters: import_zod3.z.array(chapterSchema)
+var chaptersSchema = z3.object({
+  chapters: z3.array(chapterSchema)
 });
-var DEFAULT_PROVIDER2 = "openai";
+async function generateChaptersWithAI({
+  provider,
+  modelId,
+  timestampedTranscript,
+  systemPrompt
+}) {
+  "use step";
+  const model = createLanguageModelFromConfig(provider, modelId);
+  const response = await withRetry(
+    () => generateObject2({
+      model,
+      schema: chaptersSchema,
+      messages: [
+        {
+          role: "system",
+          content: systemPrompt
+        },
+        {
+          role: "user",
+          content: timestampedTranscript
+        }
+      ]
+    })
+  );
+  return response.object;
+}
 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.
@@ -1121,10 +1106,11 @@ Important rules:
 - 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);
+  "use workflow";
+  const { provider = "openai", model } = options;
+  const config = await createWorkflowConfig({ ...options, model }, provider);
+  const { asset: assetData, playbackId, policy } = await getPlaybackIdForAsset(assetId);
+  const signingContext = getMuxSigningContextFromEnv();
   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."
@@ -1134,7 +1120,7 @@ async function generateChapters(assetId, languageCode, options = {}) {
     languageCode,
     cleanTranscript: false,
     // keep timestamps for chapter segmentation
-    signingContext: policy === "signed" ? signingContext : void 0
+    shouldSign: policy === "signed"
   });
   if (!transcriptResult.track || !transcriptResult.transcriptText) {
     const availableLanguages = getReadyTextTracks(assetData).map((t) => t.language_code).filter(Boolean).join(", ");
@@ -1148,24 +1134,12 @@ async function generateChapters(assetId, languageCode, options = {}) {
   }
   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;
+    chaptersData = await generateChaptersWithAI({
+      provider: config.provider,
+      modelId: config.modelId,
+      timestampedTranscript,
+      systemPrompt: SYSTEM_PROMPT2
+    });
   } catch (error) {
     throw new Error(
       `Failed to generate chapters with ${provider}: ${error instanceof Error ? error.message : "Unknown error"}`
@@ -1189,14 +1163,7 @@ async function generateChapters(assetId, languageCode, options = {}) {
 }
 
 // src/workflows/embeddings.ts
-var import_ai3 = require("ai");
-var DEFAULT_PROVIDER3 = "openai";
-var DEFAULT_CHUNKING_STRATEGY = {
-  type: "token",
-  maxTokens: 500,
-  overlap: 100
-};
-var DEFAULT_BATCH_SIZE = 5;
+import { embed } from "ai";
 function averageEmbeddings(embeddings) {
   if (embeddings.length === 0) {
     return [];
@@ -1213,51 +1180,41 @@ function averageEmbeddings(embeddings) {
   }
   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 generateSingleChunkEmbedding({
+  chunk,
+  provider,
+  modelId
+}) {
+  "use step";
+  const model = createEmbeddingModelFromConfig(provider, modelId);
+  const response = await withRetry(
+    () => embed({
+      model,
+      value: chunk.text
+    })
+  );
+  return {
+    chunkId: chunk.id,
+    embedding: response.embedding,
+    metadata: {
+      startTime: chunk.startTime,
+      endTime: chunk.endTime,
+      tokenCount: chunk.tokenCount
+    }
+  };
 }
 async function generateVideoEmbeddings(assetId, options = {}) {
+  "use workflow";
   const {
-    provider = DEFAULT_PROVIDER3,
+    provider = "openai",
     model,
     languageCode,
-    chunkingStrategy = DEFAULT_CHUNKING_STRATEGY,
-    batchSize = DEFAULT_BATCH_SIZE,
-    abortSignal
+    chunkingStrategy = { type: "token", maxTokens: 500, overlap: 100 },
+    batchSize = 5
   } = 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);
+  const { asset: assetData, playbackId, policy } = await getPlaybackIdForAsset(assetId);
+  const signingContext = getMuxSigningContextFromEnv();
   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."
@@ -1267,7 +1224,7 @@ async function generateVideoEmbeddings(assetId, options = {}) {
   const transcriptResult = await fetchTranscriptForAsset(assetData, playbackId, {
     languageCode,
     cleanTranscript: !useVttChunking,
-    signingContext: policy === "signed" ? signingContext : void 0
+    shouldSign: policy === "signed"
   });
   if (!transcriptResult.track || !transcriptResult.transcriptText) {
     const availableLanguages = getReadyTextTracks(assetData).map((t) => t.language_code).filter(Boolean).join(", ");
@@ -1287,14 +1244,21 @@ async function generateVideoEmbeddings(assetId, options = {}) {
   if (chunks.length === 0) {
     throw new Error("No chunks generated from transcript");
   }
-  let chunkEmbeddings;
+  const chunkEmbeddings = [];
   try {
-    chunkEmbeddings = await generateChunkEmbeddings(
-      chunks,
-      embeddingModel.model,
-      batchSize,
-      abortSignal
-    );
+    for (let i = 0; i < chunks.length; i += batchSize) {
+      const batch = chunks.slice(i, i + batchSize);
+      const batchResults = await Promise.all(
+        batch.map(
+          (chunk) => generateSingleChunkEmbedding({
+            chunk,
+            provider: embeddingModel.provider,
+            modelId: embeddingModel.modelId
+          })
+        )
+      );
+      chunkEmbeddings.push(...batchResults);
+    }
   } catch (error) {
     throw new Error(
       `Failed to generate embeddings with ${provider}: ${error instanceof Error ? error.message : "Unknown error"}`
@@ -1326,7 +1290,7 @@ var DEFAULT_THRESHOLDS = {
   sexual: 0.7,
   violence: 0.8
 };
-var DEFAULT_PROVIDER4 = "openai";
+var DEFAULT_PROVIDER2 = "openai";
 var HIVE_ENDPOINT = "https://api.thehive.ai/api/v2/task/sync";
 var HIVE_SEXUAL_CATEGORIES = [
   "general_nsfw",
@@ -1364,6 +1328,7 @@ var HIVE_VIOLENCE_CATEGORIES = [
   "garm_death_injury_or_military_conflict"
 ];
 async function processConcurrently(items, processor, maxConcurrent = 5) {
+  "use step";
   const results = [];
   for (let i = 0; i < items.length; i += maxConcurrent) {
     const batch = items.slice(i, i + maxConcurrent);
@@ -1373,11 +1338,14 @@ async function processConcurrently(items, processor, maxConcurrent = 5) {
   }
   return results;
 }
-async function requestOpenAIModeration(imageUrls, apiKey, model, maxConcurrent = 5, submissionMode = "url", downloadOptions) {
+async function requestOpenAIModeration(imageUrls, model, maxConcurrent = 5, submissionMode = "url", downloadOptions) {
+  "use step";
   const targetUrls = submissionMode === "base64" ? (await downloadImagesAsBase64(imageUrls, downloadOptions, maxConcurrent)).map(
-    (img) => ({ url: img.url, image: img.base64Data })
-  ) : imageUrls.map((url) => ({ url, image: url }));
+    (img) => ({ url: img.url, image: img.base64Data, model })
+  ) : imageUrls.map((url) => ({ url, image: url, model }));
   const moderate = async (entry) => {
+    "use step";
+    const apiKey = getApiKeyFromEnv("openai");
     try {
       const res = await fetch("https://api.openai.com/v1/moderations", {
         method: "POST",
@@ -1386,7 +1354,7 @@ async function requestOpenAIModeration(imageUrls, apiKey, model, maxConcurrent =
           "Authorization": `Bearer ${apiKey}`
         },
         body: JSON.stringify({
-          model,
+          model: entry.model,
           input: [
             {
               type: "image_url",
@@ -1429,7 +1397,8 @@ function getHiveCategoryScores(classes, categoryNames) {
   const scores = categoryNames.map((category) => scoreMap[category] || 0);
   return Math.max(...scores, 0);
 }
-async function requestHiveModeration(imageUrls, apiKey, maxConcurrent = 5, submissionMode = "url", downloadOptions) {
+async function requestHiveModeration(imageUrls, maxConcurrent = 5, submissionMode = "url", downloadOptions) {
+  "use step";
   const targets = submissionMode === "base64" ? (await downloadImagesAsBase64(imageUrls, downloadOptions, maxConcurrent)).map((img) => ({
     url: img.url,
     source: {
@@ -1442,6 +1411,8 @@ async function requestHiveModeration(imageUrls, apiKey, maxConcurrent = 5, submi
     source: { kind: "url", value: url }
   }));
   const moderate = async (entry) => {
+    "use step";
+    const apiKey = getApiKeyFromEnv("hive");
     try {
       const formData = new FormData();
       if (entry.source.kind === "url") {
@@ -1487,8 +1458,9 @@ async function requestHiveModeration(imageUrls, apiKey, maxConcurrent = 5, submi
   return processConcurrently(targets, moderate, maxConcurrent);
 }
 async function getModerationScores(assetId, options = {}) {
+  "use workflow";
   const {
-    provider = DEFAULT_PROVIDER4,
+    provider = DEFAULT_PROVIDER2,
     model = provider === "openai" ? "omni-moderation-latest" : void 0,
     thresholds = DEFAULT_THRESHOLDS,
     thumbnailInterval = 10,
@@ -1497,11 +1469,9 @@ async function getModerationScores(assetId, options = {}) {
     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 { asset, playbackId, policy } = await getPlaybackIdForAsset(assetId);
   const duration = asset.duration || 0;
-  const signingContext = resolveSigningContext(options);
+  const signingContext = getMuxSigningContextFromEnv();
   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."
@@ -1510,30 +1480,20 @@ async function getModerationScores(assetId, options = {}) {
   const thumbnailUrls = await getThumbnailUrls(playbackId, duration, {
     interval: thumbnailInterval,
     width: thumbnailWidth,
-    signingContext: policy === "signed" ? signingContext : void 0
+    shouldSign: policy === "signed"
   });
   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
@@ -1557,17 +1517,18 @@ async function getModerationScores(assetId, options = {}) {
 }
 
 // src/workflows/summarization.ts
-var import_ai4 = require("ai");
-var import_zod4 = require("zod");
+import { generateObject as generateObject3 } from "ai";
+import dedent2 from "dedent";
+import { z as z4 } from "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 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.",
+  neutral: "Provide a clear, straightforward analysis.",
+  playful: "Channel your inner diva! Answer with maximum sass, wit, and playful attitude. Don't hold back - be cheeky, clever, and delightfully snarky. Make it pop!",
   professional: "Provide a professional, executive-level analysis suitable for business reporting."
 };
 var summarizationPromptBuilder = createPromptBuilder({
@@ -1578,7 +1539,7 @@ var summarizationPromptBuilder = createPromptBuilder({
     },
     title: {
       tag: "title_requirements",
-      content: dedent_default`
+      content: dedent2`
         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.
@@ -1586,7 +1547,7 @@ var summarizationPromptBuilder = createPromptBuilder({
     },
     description: {
       tag: "description_requirements",
-      content: dedent_default`
+      content: dedent2`
         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.
@@ -1594,7 +1555,7 @@ var summarizationPromptBuilder = createPromptBuilder({
     },
     keywords: {
       tag: "keywords_requirements",
-      content: dedent_default`
+      content: dedent2`
         Specific, searchable terms (up to 10) that capture:
         - Primary subjects (people, animals, objects)
         - Actions and activities being performed
@@ -1606,7 +1567,7 @@ var summarizationPromptBuilder = createPromptBuilder({
     },
     qualityGuidelines: {
       tag: "quality_guidelines",
-      content: dedent_default`
+      content: dedent2`
         - 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
@@ -1615,7 +1576,7 @@ var summarizationPromptBuilder = createPromptBuilder({
   },
   sectionOrder: ["task", "title", "description", "keywords", "qualityGuidelines"]
 });
-var SYSTEM_PROMPT3 = dedent_default`
+var SYSTEM_PROMPT3 = dedent2`
   <role>
     You are a video content analyst specializing in storyboard interpretation and multimodal analysis.
   </role>
@@ -1647,7 +1608,29 @@ var SYSTEM_PROMPT3 = dedent_default`
     - 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>`;
+  </constraints>
+
+  <tone_guidance>
+    Pay special attention to the <tone> section and lean heavily into those instructions.
+    Adapt your entire analysis and writing style to match the specified tone - this should influence
+    your word choice, personality, formality level, and overall presentation of the content.
+    The tone instructions are not suggestions but core requirements for how you should express yourself.
+  </tone_guidance>
+
+  <language_guidelines>
+    AVOID these meta-descriptive phrases that reference the medium rather than the content:
+    - "The image shows..." / "The storyboard shows..."
+    - "In this video..." / "This video features..."
+    - "The frames depict..." / "The footage shows..."
+    - "We can see..." / "You can see..."
+    - "The clip shows..." / "The scene shows..."
+
+    INSTEAD, describe the content directly:
+    - BAD: "The video shows a chef preparing a meal"
+    - GOOD: "A chef prepares a meal in a professional kitchen"
+
+    Write as if describing reality, not describing a recording of reality.
+  </language_guidelines>`;
 function buildUserPrompt2({
   tone,
   transcriptText,
@@ -1661,8 +1644,37 @@ function buildUserPrompt2({
   }
   return summarizationPromptBuilder.buildWithContext(promptOverrides, contextSections);
 }
-var DEFAULT_PROVIDER5 = "openai";
-var DEFAULT_TONE = "normal";
+async function analyzeStoryboard2(imageDataUrl, provider, modelId, userPrompt, systemPrompt) {
+  "use step";
+  const model = createLanguageModelFromConfig(provider, modelId);
+  const response = await generateObject3({
+    model,
+    schema: summarySchema,
+    messages: [
+      {
+        role: "system",
+        content: systemPrompt
+      },
+      {
+        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
+    }
+  };
+}
 function normalizeKeywords(keywords) {
   if (!Array.isArray(keywords) || keywords.length === 0) {
     return [];
@@ -1687,23 +1699,24 @@ function normalizeKeywords(keywords) {
   return normalized;
 }
 async function getSummaryAndTags(assetId, options) {
+  "use workflow";
   const {
-    provider = DEFAULT_PROVIDER5,
+    provider = "openai",
     model,
-    tone = DEFAULT_TONE,
+    tone = "neutral",
     includeTranscript = true,
     cleanTranscript = true,
     imageSubmissionMode = "url",
     imageDownloadOptions,
-    abortSignal,
+    abortSignal: _abortSignal,
     promptOverrides
   } = options ?? {};
-  const clients = createWorkflowClients(
+  const config = await createWorkflowConfig(
     { ...options, model },
     provider
   );
-  const { asset: assetData, playbackId, policy } = await getPlaybackIdForAsset(clients.mux, assetId);
-  const signingContext = resolveSigningContext(options ?? {});
+  const { asset: assetData, playbackId, policy } = await getPlaybackIdForAsset(assetId);
+  const signingContext = getMuxSigningContextFromEnv();
   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."
@@ -1711,7 +1724,7 @@ async function getSummaryAndTags(assetId, options) {
   }
   const transcriptText = includeTranscript ? (await fetchTranscriptForAsset(assetData, playbackId, {
     cleanTranscript,
-    signingContext: policy === "signed" ? signingContext : void 0
+    shouldSign: policy === "signed"
   })).transcriptText : "";
   const userPrompt = buildUserPrompt2({
     tone,
@@ -1719,67 +1732,214 @@ async function getSummaryAndTags(assetId, options) {
     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;
+  const imageUrl = await getStoryboardUrl(playbackId, 640, policy === "signed");
+  let analysisResponse;
   try {
     if (imageSubmissionMode === "base64") {
       const downloadResult = await downloadImageAsBase64(imageUrl, imageDownloadOptions);
-      aiAnalysis = await analyzeStoryboard(downloadResult.base64Data);
+      analysisResponse = await analyzeStoryboard2(
+        downloadResult.base64Data,
+        config.provider,
+        config.modelId,
+        userPrompt,
+        SYSTEM_PROMPT3
+      );
     } else {
-      aiAnalysis = await withRetry(() => analyzeStoryboard(imageUrl));
+      analysisResponse = await withRetry(() => analyzeStoryboard2(imageUrl, config.provider, config.modelId, userPrompt, SYSTEM_PROMPT3));
     }
   } catch (error) {
     throw new Error(
       `Failed to analyze video content with ${provider}: ${error instanceof Error ? error.message : "Unknown error"}`
     );
   }
-  if (!aiAnalysis) {
+  if (!analysisResponse.result) {
     throw new Error(`Failed to analyze video content for asset ${assetId}`);
   }
-  if (!aiAnalysis.title) {
+  if (!analysisResponse.result.title) {
     throw new Error(`Failed to generate title for asset ${assetId}`);
   }
-  if (!aiAnalysis.description) {
+  if (!analysisResponse.result.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
+    title: analysisResponse.result.title,
+    description: analysisResponse.result.description,
+    tags: normalizeKeywords(analysisResponse.result.keywords),
+    storyboardUrl: imageUrl,
+    usage: analysisResponse.usage,
+    transcriptText: transcriptText || void 0
   };
 }
 
 // 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"));
+import Mux3 from "@mux/mux-node";
+
+// src/lib/language-codes.ts
+var ISO639_1_TO_3 = {
+  // Major world languages
+  en: "eng",
+  // English
+  es: "spa",
+  // Spanish
+  fr: "fra",
+  // French
+  de: "deu",
+  // German
+  it: "ita",
+  // Italian
+  pt: "por",
+  // Portuguese
+  ru: "rus",
+  // Russian
+  zh: "zho",
+  // Chinese
+  ja: "jpn",
+  // Japanese
+  ko: "kor",
+  // Korean
+  ar: "ara",
+  // Arabic
+  hi: "hin",
+  // Hindi
+  // European languages
+  nl: "nld",
+  // Dutch
+  pl: "pol",
+  // Polish
+  sv: "swe",
+  // Swedish
+  da: "dan",
+  // Danish
+  no: "nor",
+  // Norwegian
+  fi: "fin",
+  // Finnish
+  el: "ell",
+  // Greek
+  cs: "ces",
+  // Czech
+  hu: "hun",
+  // Hungarian
+  ro: "ron",
+  // Romanian
+  bg: "bul",
+  // Bulgarian
+  hr: "hrv",
+  // Croatian
+  sk: "slk",
+  // Slovak
+  sl: "slv",
+  // Slovenian
+  uk: "ukr",
+  // Ukrainian
+  tr: "tur",
+  // Turkish
+  // Asian languages
+  th: "tha",
+  // Thai
+  vi: "vie",
+  // Vietnamese
+  id: "ind",
+  // Indonesian
+  ms: "msa",
+  // Malay
+  tl: "tgl",
+  // Tagalog/Filipino
+  // Other languages
+  he: "heb",
+  // Hebrew
+  fa: "fas",
+  // Persian/Farsi
+  bn: "ben",
+  // Bengali
+  ta: "tam",
+  // Tamil
+  te: "tel",
+  // Telugu
+  mr: "mar",
+  // Marathi
+  gu: "guj",
+  // Gujarati
+  kn: "kan",
+  // Kannada
+  ml: "mal",
+  // Malayalam
+  pa: "pan",
+  // Punjabi
+  ur: "urd",
+  // Urdu
+  sw: "swa",
+  // Swahili
+  af: "afr",
+  // Afrikaans
+  ca: "cat",
+  // Catalan
+  eu: "eus",
+  // Basque
+  gl: "glg",
+  // Galician
+  is: "isl",
+  // Icelandic
+  et: "est",
+  // Estonian
+  lv: "lav",
+  // Latvian
+  lt: "lit"
+  // Lithuanian
+};
+var ISO639_3_TO_1 = Object.fromEntries(
+  Object.entries(ISO639_1_TO_3).map(([iso1, iso3]) => [iso3, iso1])
+);
+function toISO639_3(code) {
+  const normalized = code.toLowerCase().trim();
+  if (normalized.length === 3) {
+    return normalized;
+  }
+  return ISO639_1_TO_3[normalized] ?? normalized;
+}
+function toISO639_1(code) {
+  const normalized = code.toLowerCase().trim();
+  if (normalized.length === 2) {
+    return normalized;
+  }
+  return ISO639_3_TO_1[normalized] ?? normalized;
+}
+function getLanguageCodePair(code) {
+  const normalized = code.toLowerCase().trim();
+  if (normalized.length === 2) {
+    return {
+      iso639_1: normalized,
+      iso639_3: toISO639_3(normalized)
+    };
+  } else if (normalized.length === 3) {
+    return {
+      iso639_1: toISO639_1(normalized),
+      iso639_3: normalized
+    };
+  }
+  return {
+    iso639_1: normalized,
+    iso639_3: normalized
+  };
+}
+function getLanguageName(code) {
+  const iso639_1 = toISO639_1(code);
+  try {
+    const displayNames = new Intl.DisplayNames(["en"], { type: "language" });
+    return displayNames.of(iso639_1) ?? code.toUpperCase();
+  } catch {
+    return code.toUpperCase();
+  }
+}
+
+// src/workflows/translate-audio.ts
 var STATIC_RENDITION_POLL_INTERVAL_MS = 5e3;
 var STATIC_RENDITION_MAX_ATTEMPTS = 36;
-var delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+async function sleep(ms) {
+  "use step";
+  await new Promise((resolve) => setTimeout(resolve, ms));
+}
 function getReadyAudioStaticRendition(asset) {
   const files = asset.static_renditions?.files;
   if (!files || files.length === 0) {
@@ -1790,19 +1950,22 @@ function getReadyAudioStaticRendition(asset) {
   );
 }
 var hasReadyAudioStaticRendition = (asset) => Boolean(getReadyAudioStaticRendition(asset));
-async function requestStaticRenditionCreation(muxClient, assetId) {
-  console.log("\u{1F4FC} Requesting static rendition from Mux...");
+async function requestStaticRenditionCreation(assetId) {
+  "use step";
+  const { muxTokenId, muxTokenSecret } = getMuxCredentialsFromEnv();
+  const mux = new Mux3({
+    tokenId: muxTokenId,
+    tokenSecret: muxTokenSecret
+  });
   try {
-    await muxClient.video.assets.createStaticRendition(assetId, {
+    await mux.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";
@@ -1811,31 +1974,34 @@ async function requestStaticRenditionCreation(muxClient, assetId) {
 }
 async function waitForAudioStaticRendition({
   assetId,
-  muxClient,
   initialAsset
 }) {
+  "use step";
+  const { muxTokenId, muxTokenSecret } = getMuxCredentialsFromEnv();
+  const mux = new Mux3({
+    tokenId: muxTokenId,
+    tokenSecret: muxTokenSecret
+  });
   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);
+    await requestStaticRenditionCreation(assetId);
   } else if (status === "errored") {
-    console.log("\u26A0\uFE0F Previous static rendition request errored. Creating a new one...");
-    await requestStaticRenditionCreation(muxClient, assetId);
+    await requestStaticRenditionCreation(assetId);
   } else {
-    console.log(`\u2139\uFE0F Static rendition already ${status}. Waiting for it to finish...`);
+    console.warn(`\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);
+    await sleep(STATIC_RENDITION_POLL_INTERVAL_MS);
+    currentAsset = await mux.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(
+    console.warn(
       `\u231B Waiting for static rendition (attempt ${attempt}/${STATIC_RENDITION_MAX_ATTEMPTS}) \u2192 ${currentStatus}`
     );
     if (currentStatus === "errored") {
@@ -1848,55 +2014,179 @@ async function waitForAudioStaticRendition({
     "Timed out waiting for the static rendition to become ready. Please try again in a moment."
   );
 }
+async function fetchAudioFromMux(audioUrl) {
+  "use step";
+  const audioResponse = await fetch(audioUrl);
+  if (!audioResponse.ok) {
+    throw new Error(`Failed to fetch audio file: ${audioResponse.statusText}`);
+  }
+  return audioResponse.arrayBuffer();
+}
+async function createElevenLabsDubbingJob({
+  audioBuffer,
+  assetId,
+  elevenLabsLangCode,
+  numSpeakers
+}) {
+  "use step";
+  const elevenLabsApiKey = getApiKeyFromEnv("elevenlabs");
+  const audioBlob = new Blob([audioBuffer], { type: "audio/mp4" });
+  const formData = new FormData();
+  formData.append("file", audioBlob);
+  formData.append("target_lang", elevenLabsLangCode);
+  formData.append("num_speakers", numSpeakers.toString());
+  formData.append("name", `Mux Asset ${assetId} - auto to ${elevenLabsLangCode}`);
+  const dubbingResponse = await fetch("https://api.elevenlabs.io/v1/dubbing", {
+    method: "POST",
+    headers: {
+      "xi-api-key": elevenLabsApiKey
+    },
+    body: formData
+  });
+  if (!dubbingResponse.ok) {
+    throw new Error(`ElevenLabs API error: ${dubbingResponse.statusText}`);
+  }
+  const dubbingData = await dubbingResponse.json();
+  return dubbingData.dubbing_id;
+}
+async function checkElevenLabsDubbingStatus({
+  dubbingId
+}) {
+  "use step";
+  const elevenLabsApiKey = getApiKeyFromEnv("elevenlabs");
+  const statusResponse = await fetch(`https://api.elevenlabs.io/v1/dubbing/${dubbingId}`, {
+    headers: {
+      "xi-api-key": elevenLabsApiKey
+    }
+  });
+  if (!statusResponse.ok) {
+    throw new Error(`Status check failed: ${statusResponse.statusText}`);
+  }
+  const statusData = await statusResponse.json();
+  return {
+    status: statusData.status,
+    targetLanguages: statusData.target_languages ?? []
+  };
+}
+async function downloadDubbedAudioFromElevenLabs({
+  dubbingId,
+  languageCode
+}) {
+  "use step";
+  const elevenLabsApiKey = getApiKeyFromEnv("elevenlabs");
+  const audioUrl = `https://api.elevenlabs.io/v1/dubbing/${dubbingId}/audio/${languageCode}`;
+  const audioResponse = await fetch(audioUrl, {
+    headers: {
+      "xi-api-key": elevenLabsApiKey
+    }
+  });
+  if (!audioResponse.ok) {
+    throw new Error(`Failed to fetch dubbed audio: ${audioResponse.statusText}`);
+  }
+  return audioResponse.arrayBuffer();
+}
+async function uploadDubbedAudioToS3({
+  dubbedAudioBuffer,
+  assetId,
+  toLanguageCode,
+  s3Endpoint,
+  s3Region,
+  s3Bucket
+}) {
+  "use step";
+  const { S3Client, GetObjectCommand } = await import("@aws-sdk/client-s3");
+  const { Upload } = await import("@aws-sdk/lib-storage");
+  const { getSignedUrl } = await import("@aws-sdk/s3-request-presigner");
+  const s3AccessKeyId = env_default.S3_ACCESS_KEY_ID;
+  const s3SecretAccessKey = env_default.S3_SECRET_ACCESS_KEY;
+  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`;
+  const upload = new Upload({
+    client: s3Client,
+    params: {
+      Bucket: s3Bucket,
+      Key: audioKey,
+      Body: new Uint8Array(dubbedAudioBuffer),
+      ContentType: "audio/mp4"
+    }
+  });
+  await upload.done();
+  const getObjectCommand = new GetObjectCommand({
+    Bucket: s3Bucket,
+    Key: audioKey
+  });
+  const presignedUrl = await getSignedUrl(s3Client, getObjectCommand, {
+    expiresIn: 3600
+    // 1 hour
+  });
+  console.warn(`\u2705 Audio uploaded successfully to: ${audioKey}`);
+  console.warn(`\u{1F517} Generated presigned URL (expires in 1 hour)`);
+  return presignedUrl;
+}
+async function createAudioTrackOnMux(assetId, languageCode, presignedUrl) {
+  "use step";
+  const { muxTokenId, muxTokenSecret } = getMuxCredentialsFromEnv();
+  const mux = new Mux3({
+    tokenId: muxTokenId,
+    tokenSecret: muxTokenSecret
+  });
+  const languageName = new Intl.DisplayNames(["en"], { type: "language" }).of(languageCode) || languageCode.toUpperCase();
+  const trackName = `${languageName} (auto-dubbed)`;
+  const trackResponse = await mux.video.assets.createTrack(assetId, {
+    type: "audio",
+    language_code: languageCode,
+    name: trackName,
+    url: presignedUrl
+  });
+  if (!trackResponse.id) {
+    throw new Error("Failed to create audio track: no track ID returned from Mux");
+  }
+  return trackResponse.id;
+}
 async function translateAudio(assetId, toLanguageCode, options = {}) {
+  "use workflow";
   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.");
-  }
+  const s3AccessKeyId = env_default.S3_ACCESS_KEY_ID;
+  const s3SecretAccessKey = env_default.S3_SECRET_ACCESS_KEY;
   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);
+  const { asset: initialAsset, playbackId, policy } = await getPlaybackIdForAsset(assetId);
+  const signingContext = getMuxSigningContextFromEnv();
   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...");
+    console.warn("\u274C No ready audio static rendition found. Requesting one now...");
     currentAsset = await waitForAudioStaticRendition({
       assetId,
-      muxClient: mux,
       initialAsset: currentAsset
     });
   }
@@ -1910,58 +2200,42 @@ async function translateAudio(assetId, toLanguageCode, options = {}) {
   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})`);
+  console.warn("\u{1F399}\uFE0F Fetching audio from Mux...");
+  let audioBuffer;
+  try {
+    audioBuffer = await fetchAudioFromMux(audioUrl);
+  } catch (error) {
+    throw new Error(`Failed to fetch audio from Mux: ${error instanceof Error ? error.message : "Unknown error"}`);
+  }
+  console.warn("\u{1F399}\uFE0F Creating dubbing job in ElevenLabs...");
+  const elevenLabsLangCode = toISO639_3(toLanguageCode);
+  console.warn(`\u{1F50D} Creating dubbing job for asset ${assetId} with language code: ${elevenLabsLangCode}`);
   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
+    dubbingId = await createElevenLabsDubbingJob({
+      audioBuffer,
+      assetId,
+      elevenLabsLangCode,
+      numSpeakers
     });
-    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`);
+    console.warn(`\u2705 Dubbing job created with ID: ${dubbingId}`);
   } 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...");
+  console.warn("\u23F3 Waiting for dubbing to complete...");
   let dubbingStatus = "dubbing";
   let pollAttempts = 0;
   const maxPollAttempts = 180;
+  let targetLanguages = [];
   while (dubbingStatus === "dubbing" && pollAttempts < maxPollAttempts) {
-    await new Promise((resolve) => setTimeout(resolve, 1e4));
+    await sleep(1e4);
     pollAttempts++;
     try {
-      const statusResponse = await fetch(`https://api.elevenlabs.io/v1/dubbing/${dubbingId}`, {
-        headers: {
-          "xi-api-key": elevenLabsKey
-        }
+      const statusResult = await checkElevenLabsDubbingStatus({
+        dubbingId
       });
-      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}`);
+      dubbingStatus = statusResult.status;
+      targetLanguages = statusResult.targetLanguages;
       if (dubbingStatus === "failed") {
         throw new Error("ElevenLabs dubbing job failed");
       }
@@ -1972,89 +2246,74 @@ async function translateAudio(assetId, toLanguageCode, options = {}) {
   if (dubbingStatus !== "dubbed") {
     throw new Error(`Dubbing job timed out or failed. Final status: ${dubbingStatus}`);
   }
-  console.log("\u2705 Dubbing completed successfully!");
+  console.warn("\u2705 Dubbing completed successfully!");
   if (!uploadToMux) {
+    const targetLanguage2 = getLanguageCodePair(toLanguageCode);
     return {
       assetId,
-      targetLanguageCode: toLanguageCode,
+      targetLanguageCode: targetLanguage2.iso639_1,
+      targetLanguage: targetLanguage2,
       dubbingId
     };
   }
-  console.log("\u{1F4E5} Downloading dubbed audio from ElevenLabs...");
+  console.warn("\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}`);
+    const requestedLangCode = toISO639_3(toLanguageCode);
+    let downloadLangCode = targetLanguages.find(
+      (lang) => lang === requestedLangCode
+    ) ?? targetLanguages.find(
+      (lang) => lang.toLowerCase() === requestedLangCode.toLowerCase()
+    );
+    if (!downloadLangCode && targetLanguages.length > 0) {
+      downloadLangCode = targetLanguages[0];
+      console.warn(`\u26A0\uFE0F Requested language "${requestedLangCode}" not found in target_languages. Using "${downloadLangCode}" instead.`);
+    }
+    if (!downloadLangCode) {
+      downloadLangCode = requestedLangCode;
+      console.warn(`\u26A0\uFE0F No target_languages available from ElevenLabs status. Using requested language code: ${requestedLangCode}`);
     }
-    dubbedAudioBuffer = await audioResponse.arrayBuffer();
-    console.log(`\u2705 Downloaded dubbed audio (${dubbedAudioBuffer.byteLength} bytes)`);
+    dubbedAudioBuffer = await downloadDubbedAudioFromElevenLabs({
+      dubbingId,
+      languageCode: downloadLangCode
+    });
+    console.warn("\u2705 Dubbed audio downloaded successfully!");
   } 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`;
+  console.warn("\u{1F4E4} Uploading dubbed audio to S3-compatible storage...");
   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
+    presignedUrl = await uploadDubbedAudioToS3({
+      dubbedAudioBuffer,
+      assetId,
+      toLanguageCode,
+      s3Endpoint,
+      s3Region,
+      s3Bucket
     });
-    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...");
+  console.warn("\u{1F4F9} Adding dubbed audio track to Mux asset...");
   let uploadedTrackId;
+  const muxLangCode = toISO639_1(toLanguageCode);
   try {
-    const languageName = new Intl.DisplayNames(["en"], { type: "language" }).of(toLanguageCode) || toLanguageCode.toUpperCase();
+    uploadedTrackId = await createAudioTrackOnMux(assetId, muxLangCode, presignedUrl);
+    const languageName = new Intl.DisplayNames(["en"], { type: "language" }).of(muxLangCode) || muxLangCode.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}"`);
+    console.warn(`\u2705 Track added to Mux asset with ID: ${uploadedTrackId}`);
+    console.warn(`\u{1F4CB} 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);
+    console.warn("\u{1F517} You can manually add the track using this presigned URL:");
+    console.warn(presignedUrl);
   }
+  const targetLanguage = getLanguageCodePair(toLanguageCode);
   return {
     assetId,
-    targetLanguageCode: toLanguageCode,
+    targetLanguageCode: targetLanguage.iso639_1,
+    targetLanguage,
     dubbingId,
     uploadedTrackId,
     presignedUrl
@@ -2062,43 +2321,143 @@ async function translateAudio(assetId, toLanguageCode, options = {}) {
 }
 
 // src/workflows/translate-captions.ts
-var import_client_s32 = require("@aws-sdk/client-s3");
-var import_lib_storage2 = require("@aws-sdk/lib-storage");
-var import_s3_request_presigner2 = require("@aws-sdk/s3-request-presigner");
-var import_ai5 = require("ai");
-var import_zod5 = require("zod");
-var translationSchema = import_zod5.z.object({
-  translation: import_zod5.z.string()
+import Mux4 from "@mux/mux-node";
+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 fetchVttFromMux(vttUrl) {
+  "use step";
+  const vttResponse = await fetch(vttUrl);
+  if (!vttResponse.ok) {
+    throw new Error(`Failed to fetch VTT file: ${vttResponse.statusText}`);
+  }
+  return vttResponse.text();
+}
+async function translateVttWithAI({
+  vttContent,
+  fromLanguageCode,
+  toLanguageCode,
+  provider,
+  modelId,
+  abortSignal
+}) {
+  "use step";
+  const languageModel = createLanguageModelFromConfig(provider, modelId);
+  const response = await generateObject4({
+    model: languageModel,
+    schema: translationSchema,
+    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}`
+      }
+    ]
+  });
+  return {
+    translatedVtt: response.object.translation,
+    usage: {
+      inputTokens: response.usage.inputTokens,
+      outputTokens: response.usage.outputTokens,
+      totalTokens: response.usage.totalTokens,
+      reasoningTokens: response.usage.reasoningTokens,
+      cachedInputTokens: response.usage.cachedInputTokens
+    }
+  };
+}
+async function uploadVttToS3({
+  translatedVtt,
+  assetId,
+  fromLanguageCode,
+  toLanguageCode,
+  s3Endpoint,
+  s3Region,
+  s3Bucket
+}) {
+  "use step";
+  const { S3Client, GetObjectCommand } = await import("@aws-sdk/client-s3");
+  const { Upload } = await import("@aws-sdk/lib-storage");
+  const { getSignedUrl } = await import("@aws-sdk/s3-request-presigner");
+  const s3AccessKeyId = env_default.S3_ACCESS_KEY_ID;
+  const s3SecretAccessKey = env_default.S3_SECRET_ACCESS_KEY;
+  const s3Client = new S3Client({
+    region: s3Region,
+    endpoint: s3Endpoint,
+    credentials: {
+      accessKeyId: s3AccessKeyId,
+      secretAccessKey: s3SecretAccessKey
+    },
+    forcePathStyle: true
+  });
+  const vttKey = `translations/${assetId}/${fromLanguageCode}-to-${toLanguageCode}-${Date.now()}.vtt`;
+  const upload = new Upload({
+    client: s3Client,
+    params: {
+      Bucket: s3Bucket,
+      Key: vttKey,
+      Body: translatedVtt,
+      ContentType: "text/vtt"
+    }
+  });
+  await upload.done();
+  const getObjectCommand = new GetObjectCommand({
+    Bucket: s3Bucket,
+    Key: vttKey
+  });
+  const presignedUrl = await getSignedUrl(s3Client, getObjectCommand, {
+    expiresIn: 3600
+    // 1 hour
+  });
+  return presignedUrl;
+}
+async function createTextTrackOnMux(assetId, languageCode, trackName, presignedUrl) {
+  "use step";
+  const { muxTokenId, muxTokenSecret } = getMuxCredentialsFromEnv();
+  const mux = new Mux4({
+    tokenId: muxTokenId,
+    tokenSecret: muxTokenSecret
+  });
+  const trackResponse = await mux.video.assets.createTrack(assetId, {
+    type: "text",
+    text_type: "subtitles",
+    language_code: languageCode,
+    name: trackName,
+    url: presignedUrl
+  });
+  if (!trackResponse.id) {
+    throw new Error("Failed to create text track: no track ID returned from Mux");
+  }
+  return trackResponse.id;
+}
 async function translateCaptions(assetId, fromLanguageCode, toLanguageCode, options) {
+  "use workflow";
   const {
-    provider = DEFAULT_PROVIDER6,
+    provider = "openai",
     model,
     s3Endpoint: providedS3Endpoint,
     s3Region: providedS3Region,
     s3Bucket: providedS3Bucket,
-    s3AccessKeyId: providedS3AccessKeyId,
-    s3SecretAccessKey: providedS3SecretAccessKey,
-    uploadToMux: uploadToMuxOption,
-    ...clientConfig
+    uploadToMux: uploadToMuxOption
   } = 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 s3AccessKeyId = env_default.S3_ACCESS_KEY_ID;
+  const s3SecretAccessKey = env_default.S3_SECRET_ACCESS_KEY;
   const uploadToMux = uploadToMuxOption !== false;
-  const clients = createWorkflowClients(
-    { ...clientConfig, provider: resolvedProvider, model },
-    resolvedProvider
+  const config = await createWorkflowConfig(
+    { ...options, model },
+    provider
   );
   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);
+  const { asset: assetData, playbackId, policy } = await getPlaybackIdForAsset(assetId);
+  const signingContext = getMuxSigningContextFromEnv();
   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."
@@ -2119,120 +2478,81 @@ async function translateCaptions(assetId, fromLanguageCode, toLanguageCode, opti
   }
   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();
+    vttContent = await fetchVttFromMux(vttUrl);
   } 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;
+  let usage;
   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}`
-        }
-      ]
+    const result = await translateVttWithAI({
+      vttContent,
+      fromLanguageCode,
+      toLanguageCode,
+      provider: config.provider,
+      modelId: config.modelId,
+      abortSignal: options.abortSignal
     });
-    translatedVtt = response.object.translation;
+    translatedVtt = result.translatedVtt;
+    usage = result.usage;
   } catch (error) {
-    throw new Error(`Failed to translate VTT with ${resolvedProvider}: ${error instanceof Error ? error.message : "Unknown error"}`);
+    throw new Error(`Failed to translate VTT with ${config.provider}: ${error instanceof Error ? error.message : "Unknown error"}`);
   }
-  console.log(`
-\u2705 Translation completed successfully!`);
+  const sourceLanguage = getLanguageCodePair(fromLanguageCode);
+  const targetLanguage = getLanguageCodePair(toLanguageCode);
   if (!uploadToMux) {
-    console.log(`\u2705 VTT translated to ${toLanguageCode} successfully!`);
     return {
       assetId,
       sourceLanguageCode: fromLanguageCode,
       targetLanguageCode: toLanguageCode,
+      sourceLanguage,
+      targetLanguage,
       originalVtt: vttContent,
-      translatedVtt
+      translatedVtt,
+      usage
     };
   }
-  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
+    presignedUrl = await uploadVttToS3({
+      translatedVtt,
+      assetId,
+      fromLanguageCode,
+      toLanguageCode,
+      s3Endpoint,
+      s3Region,
+      s3Bucket
     });
-    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 languageName = getLanguageName(toLanguageCode);
     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}"`);
+    uploadedTrackId = await createTextTrackOnMux(assetId, toLanguageCode, trackName, presignedUrl);
   } 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);
+    console.warn(`Failed to add track to Mux asset: ${error instanceof Error ? error.message : "Unknown error"}`);
   }
   return {
     assetId,
     sourceLanguageCode: fromLanguageCode,
     targetLanguageCode: toLanguageCode,
+    sourceLanguage,
+    targetLanguage,
     originalVtt: vttContent,
     translatedVtt,
     uploadedTrackId,
-    presignedUrl
+    presignedUrl,
+    usage
   };
 }
 
 // src/index.ts
 var version = "0.1.0";
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  primitives,
+export {
+  primitives_exports as primitives,
   version,
-  workflows
-});
+  workflows_exports as workflows
+};
 //# sourceMappingURL=index.js.map