@mrgoonie/multix 0.12.0 → 0.14.0

package/dist/cli.js

@@ -862,13 +862,13 @@ var AtlasCloudClient = class {
   }
   /** Submit a generation job. `body` holds `model` plus the model's own fields, flattened. */
   async submit(kind, body) {
-    const path54 = SUBMIT_PATHS[kind];
-    if (!path54) throw new ValidationError(`Unknown Atlas Cloud media type: ${String(kind)}`);
+    const path57 = SUBMIT_PATHS[kind];
+    if (!path57) throw new ValidationError(`Unknown Atlas Cloud media type: ${String(kind)}`);
     if (typeof body.model !== "string" || !body.model.trim()) {
       throw new ValidationError("Atlas Cloud request body needs a non-empty `model`");
     }
     const env = await fetchJson({
-      url: `${this.baseUrl}${path54}`,
+      url: `${this.baseUrl}${path57}`,
       method: "POST",
       headers: this.authHeaders(),
       body,
@@ -1428,14 +1428,14 @@ function detectThumbUrl(obj) {
   }
   return null;
 }
-async function downloadThumbBeside(thumbUrl, videoPath, logger) {
+async function downloadThumbBeside(thumbUrl, videoPath, logger, download = downloadFile) {
   const match = thumbUrl.match(IMAGE_EXT_RE);
   const ext = match?.[1] ? match[1].toLowerCase().replace("jpeg", "jpg") : "jpg";
   const dir = path6.dirname(videoPath);
   const base = path6.basename(videoPath, path6.extname(videoPath));
   const dest = path6.join(dir, `${base}_thumb.${ext}`);
   try {
-    await downloadFile(thumbUrl, dest);
+    await download(thumbUrl, dest);
     logger?.success(`Saved thumb ${dest}`);
     return dest;
   } catch (e) {
@@ -1450,7 +1450,7 @@ async function maybeDownloadThumb(source, videoPath, opts = {}) {
     opts.logger?.debug("No thumbnail URL detected in provider response");
     return null;
   }
-  const saved = await downloadThumbBeside(url, videoPath, opts.logger);
+  const saved = await downloadThumbBeside(url, videoPath, opts.logger, opts.download);
   if (saved && opts.copyTo) {
     const copyExt = path6.extname(saved);
     const copyBase = path6.basename(opts.copyTo, path6.extname(opts.copyTo));
@@ -2182,9 +2182,9 @@ var BytePlusClient = class {
   }
   apiKey;
   baseUrl;
-  async request(path54, opts = {}) {
+  async request(path57, opts = {}) {
     const base = this.baseUrl.replace(/\/$/, "");
-    const url = new URL(base + path54);
+    const url = new URL(base + path57);
     if (opts.query) {
       for (const [k, v] of Object.entries(opts.query)) {
         if (v !== void 0 && v !== null) url.searchParams.set(k, String(v));
@@ -2202,14 +2202,14 @@ var BytePlusClient = class {
       timeoutMs: opts.timeoutMs ?? 12e4
     });
   }
-  get(path54, query, logger) {
-    return this.request(path54, { method: "GET", query, logger });
+  get(path57, query, logger) {
+    return this.request(path57, { method: "GET", query, logger });
   }
-  post(path54, body, logger) {
-    return this.request(path54, { method: "POST", body, logger });
+  post(path57, body, logger) {
+    return this.request(path57, { method: "POST", body, logger });
   }
-  delete(path54, logger) {
-    return this.request(path54, { method: "DELETE", logger });
+  delete(path57, logger) {
+    return this.request(path57, { method: "DELETE", logger });
   }
 };
 function createBytePlusClient() {
@@ -2678,10 +2678,10 @@ function toRef(kind, resolved, role) {
   return { kind, url: resolved.dataUrl, mime: resolved.mime, role };
 }
 async function resolveRefSpec(kind, spec, logger) {
-  const { path: path54, role } = parseRefSpec(spec);
-  if (kind === "image") return toRef(kind, await resolveImageInput(path54, logger), role);
-  if (kind === "video") return toRef(kind, await resolveVideoInput(path54, logger), role);
-  return toRef(kind, await resolveAudioInput(path54, logger), role);
+  const { path: path57, role } = parseRefSpec(spec);
+  if (kind === "image") return toRef(kind, await resolveImageInput(path57, logger), role);
+  if (kind === "video") return toRef(kind, await resolveVideoInput(path57, logger), role);
+  return toRef(kind, await resolveAudioInput(path57, logger), role);
 }
 async function resolveRefSpecs(specs, logger) {
   const out = [];
@@ -4108,9 +4108,9 @@ var FalClient = class {
   apiKey;
   baseUrl;
   /** `path` is appended verbatim to the base queue URL, e.g. "/fal-ai/flux/schnell". */
-  async request(path54, opts = {}) {
+  async request(path57, opts = {}) {
     const base = this.baseUrl.replace(/\/$/, "");
-    const suffix = path54.startsWith("/") ? path54 : `/${path54}`;
+    const suffix = path57.startsWith("/") ? path57 : `/${path57}`;
     return this.requestAbsolute(base + suffix, opts);
   }
   /** Same auth/headers as `request`, but `url` is used verbatim (e.g. a status_url/response_url returned by submit). */
@@ -4127,11 +4127,11 @@ var FalClient = class {
       timeoutMs: opts.timeoutMs ?? 12e4
     });
   }
-  get(path54, logger) {
-    return this.request(path54, { method: "GET", logger });
+  get(path57, logger) {
+    return this.request(path57, { method: "GET", logger });
   }
-  post(path54, body, logger) {
-    return this.request(path54, { method: "POST", body, logger });
+  post(path57, body, logger) {
+    return this.request(path57, { method: "POST", body, logger });
   }
   getAbsolute(url, logger) {
     return this.requestAbsolute(url, { method: "GET", logger });
@@ -4611,11 +4611,15 @@ function trackTempDir(dir) {
   for (const s of SIGNALS) process.once(s, onSignal);
   return dispose;
 }
+var DEFAULT_FLAG = "--files";
+var DEFAULT_EXAMPLE = "cat clip.mp3 | multix gemini transcribe --files -";
+var DEFAULT_EXT_EXAMPLE = "mp3";
 async function stdinToTempFile(opts = {}) {
   const input = opts.input ?? process.stdin;
+  const flag = opts.flag ?? DEFAULT_FLAG;
   if (input.isTTY) {
     throw new ValidationError(
-      "`--files -` reads piped input, but stdin is a terminal. Example: cat clip.mp3 | multix gemini transcribe --files -"
+      `\`${flag} -\` reads piped input, but stdin is a terminal. Example: ${opts.example ?? DEFAULT_EXAMPLE}`
     );
   }
   const forcedExt = opts.ext ? normalizeExt(opts.ext) : void 0;
@@ -4624,7 +4628,8 @@ async function stdinToTempFile(opts = {}) {
   const cleanup = trackTempDir(dir);
   const rawPath = path23.join(dir, "input");
   const hint = setTimeout(() => {
-    process.stderr.write("Waiting for data on stdin (`--files -`)... press Ctrl+C to cancel\n");
+    process.stderr.write(`Waiting for data on stdin (\`${flag} -\`)... press Ctrl+C to cancel
+`);
   }, WAIT_HINT_MS);
   hint.unref?.();
   let head = Buffer.alloc(0);
@@ -4651,7 +4656,7 @@ async function stdinToTempFile(opts = {}) {
       clearTimeout(hint);
       fs20.closeSync(fd);
     }
-    if (size === 0) throw new ValidationError("`--files -` was given but stdin was empty");
+    if (size === 0) throw new ValidationError(`\`${flag} -\` was given but stdin was empty`);
     const detectedExt = forcedExt ?? detectExtension(head);
     const finalPath = path23.join(dir, `stdin${detectedExt ?? ".bin"}`);
     fs20.renameSync(rawPath, finalPath);
@@ -4665,10 +4670,11 @@ function labelError(message, input) {
   return input.path === input.label ? message : message.split(input.path).join(input.label);
 }
 async function resolveFileInputs(files, opts = {}) {
+  const flag = opts.flag ?? DEFAULT_FLAG;
   const stdinCount = files.filter((f) => f === STDIN_ARG).length;
-  if (stdinCount > 1) throw new ValidationError("`-` (stdin) can only be passed once to --files");
+  if (stdinCount > 1) throw new ValidationError(`\`-\` (stdin) can only be passed once to ${flag}`);
   if (opts.stdinExt && stdinCount === 0) {
-    throw new ValidationError("--stdin-ext only applies when --files includes `-`");
+    throw new ValidationError(`--stdin-ext only applies when ${flag} includes \`-\``);
   }
   for (const f of files) {
     if (f !== STDIN_ARG && !fs20.existsSync(f)) throw new ValidationError(`File not found: ${f}`);
@@ -4680,12 +4686,14 @@ async function resolveFileInputs(files, opts = {}) {
   const stdin = await stdinToTempFile({
     input: opts.input,
     ext: opts.stdinExt,
-    maxBytes: opts.maxBytes
+    maxBytes: opts.maxBytes,
+    flag: opts.flag,
+    example: opts.example
   });
   if (!stdin.detected) {
     stdin.cleanup();
     throw new ValidationError(
-      "Could not detect the type of piped stdin; pass --stdin-ext (e.g. --stdin-ext mp3)"
+      `Could not detect the type of piped stdin; pass --stdin-ext (e.g. --stdin-ext ${opts.extExample ?? DEFAULT_EXT_EXAMPLE})`
     );
   }
   return {
@@ -5933,40 +5941,1961 @@ function registerTranscribeCommand2(parent) {
             response: extractText(resp)
           });
         } catch (e) {
-          const msg = labelError(
-            e instanceof Error ? e.message : String(e),
-            inputs[i]
-          );
-          logger.error(`Failed: ${label} \u2014 ${msg}`);
-          results.push({ file: label, status: "error", error: msg });
+          const msg = labelError(
+            e instanceof Error ? e.message : String(e),
+            inputs[i]
+          );
+          logger.error(`Failed: ${label} \u2014 ${msg}`);
+          results.push({ file: label, status: "error", error: msg });
+        }
+      }
+      formatResults(results, opts.format, opts.output);
+      cleanup();
+      const failed = results.filter((r) => r.status === "error").length;
+      if (failed > 0) process.exit(1);
+    }
+  );
+}
+
+// src/providers/gemini/commands/index.ts
+function registerGeminiCommands(program2) {
+  const gemini = program2.command("gemini").description(
+    "Gemini: analyze, transcribe, extract data, generate images (Imagen/Nano Banana), video (Veo), and speech (Flash TTS)"
+  );
+  registerAnalyzeCommand(gemini);
+  registerTranscribeCommand2(gemini);
+  registerExtractCommand(gemini);
+  registerGenerateCommand(gemini);
+  registerGeminiImageToImageCommand(gemini);
+  registerGenerateVideoCommand(gemini);
+  registerGeminiImageToVideoCommand(gemini);
+  registerGeminiGenerateSpeechCommand(gemini);
+}
+
+// src/providers/heygen/models.ts
+var DEFAULT_HEYGEN_BASE_URL = "https://api.heygen.com";
+var HEYGEN_API_SETTINGS_URL = "https://app.heygen.com/developers/api";
+var HEYGEN_USAGE_URL = "https://app.heygen.com/developers/usage";
+var AVATAR_VIDEO_RESOLUTIONS = ["4k", "1080p", "720p"];
+var AVATAR_VIDEO_ASPECT_RATIOS = ["16:9", "9:16", "4:5", "5:4", "1:1", "auto"];
+var AVATAR_ENGINES = ["avatar_iv", "avatar_v", "avatar_iii"];
+var EXPRESSIVENESS_LEVELS = ["high", "medium", "low"];
+var AVATAR_TYPES = ["studio_avatar", "digital_twin", "photo_avatar"];
+var OWNERSHIP_VALUES = ["public", "private"];
+var AGENT_ORIENTATIONS = ["landscape", "portrait"];
+var QUALITY_MODES = ["speed", "precision"];
+var SPEECH_ENGINES = ["starfish", "orca", "elevenlabs"];
+var HEYGEN_VIDEO_MODEL = "heygen-video-1";
+var MODEL_VIDEO_MODES = ["text_to_video", "image_to_video", "reference_to_video"];
+var MODEL_VIDEO_RESOLUTIONS = ["480p", "768p", "1080p", "2k"];
+var MODEL_VIDEO_ASPECT_RATIOS = [
+  "21:9",
+  "16:9",
+  "4:3",
+  "1:1",
+  "3:4",
+  "9:16",
+  "adaptive"
+];
+var MODEL_VIDEO_PROMPT_ENHANCEMENT = ["turbo", "quality", "disabled"];
+var LIMITS = {
+  agentPromptMax: 1e4,
+  agentFilesMax: 20,
+  scriptMax: 5e3,
+  speechTextMax: 5e3,
+  /** POST /v3/assets single-request upload cap (32 MB). */
+  assetUploadMaxBytes: 32 * 1024 * 1024,
+  modelVideoPromptMax: 32e3,
+  modelVideoMinDuration: 5,
+  modelVideoMaxDuration: 15,
+  modelVideoReferenceImagesMax: 9,
+  modelVideoReferenceVideosMax: 3,
+  modelVideoReferenceAudioMax: 3,
+  /** Combined cap across reference images, videos and audio. */
+  modelVideoReferenceTotalMax: 12,
+  avatarListMax: 50,
+  voiceListMax: 100,
+  stylesListMax: 100
+};
+var ASSET_MIME_BY_EXT = {
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  mp4: "video/mp4",
+  webm: "video/webm",
+  mp3: "audio/mpeg",
+  wav: "audio/wav",
+  pdf: "application/pdf",
+  srt: "application/x-subrip"
+};
+var JOB_KINDS = [
+  "agent",
+  "video",
+  "translation",
+  "lipsync",
+  "model-video"
+];
+var HEYGEN_OPERATIONS = {
+  "video-agent": {
+    description: "POST /v3/video-agents (prompt-to-video session)",
+    path: "/v3/video-agents",
+    kind: "agent",
+    idField: "session_id",
+    idempotent: false
+  },
+  video: {
+    description: "POST /v3/videos (avatar | image | cinematic_avatar | studio)",
+    path: "/v3/videos",
+    kind: "video",
+    idField: "video_id",
+    idempotent: true
+  },
+  "video-translation": {
+    description: "POST /v3/video-translations",
+    path: "/v3/video-translations",
+    kind: "translation",
+    idsField: "video_translation_ids",
+    idempotent: true
+  },
+  lipsync: {
+    description: "POST /v3/lipsyncs",
+    path: "/v3/lipsyncs",
+    kind: "lipsync",
+    idField: "lipsync_id",
+    idempotent: true
+  },
+  "model-video": {
+    description: "POST /v3/models/videos (HeyGen Video model)",
+    path: "/v3/models/videos",
+    kind: "model-video",
+    idField: "video_id",
+    idempotent: true
+  },
+  speech: {
+    description: "POST /v3/voices/speech (synchronous text-to-speech)",
+    path: "/v3/voices/speech",
+    kind: null,
+    idempotent: false
+  }
+};
+
+// src/providers/heygen/node-helpers.ts
+import { once as once2 } from "events";
+import fs29 from "fs";
+import path32 from "path";
+import { pipeline as pipeline2 } from "stream/promises";
+init_errors();
+init_redact();
+
+// src/providers/heygen/client.ts
+init_errors();
+init_redact();
+
+// src/providers/heygen/heygen-errors.ts
+init_errors();
+var HeygenApiError = class extends HttpError {
+  constructor(status, snippet, url, retryAfterMs, apiCode, apiMessage, param) {
+    super(status, snippet, url, retryAfterMs);
+    this.apiCode = apiCode;
+    this.apiMessage = apiMessage;
+    this.param = param;
+    this.name = "HeygenApiError";
+    this.message = describeHeygenError(status, apiCode, apiMessage, param, retryAfterMs);
+  }
+  apiCode;
+  apiMessage;
+  param;
+};
+var HeygenJobFailedError = class extends ProviderError {
+  constructor(message, failureCode) {
+    super(message, "heygen");
+    this.failureCode = failureCode;
+    this.name = "HeygenJobFailedError";
+  }
+  failureCode;
+};
+function parseHeygenErrorBody(snippet) {
+  try {
+    const parsed = JSON.parse(snippet);
+    if (parsed && typeof parsed.error === "object" && parsed.error !== null) return parsed.error;
+    if (parsed && typeof parsed.error === "string") return { message: parsed.error };
+  } catch {
+  }
+  const field = (name) => snippet.match(new RegExp(`"${name}"\\s*:\\s*"((?:[^"\\\\]|\\\\.)*)"`))?.[1];
+  const out = {};
+  const code = field("code");
+  const message = field("message");
+  const param = field("param");
+  if (code) out.code = code;
+  if (message) out.message = message;
+  if (param) out.param = param;
+  return out;
+}
+function toHeygenApiError(error) {
+  if (error instanceof HeygenApiError) return error;
+  const body = error.status === 0 ? {} : parseHeygenErrorBody(error.snippet);
+  return new HeygenApiError(
+    error.status,
+    error.snippet,
+    error.url,
+    error.retryAfterMs,
+    body.code,
+    body.message ?? (error.status === 0 ? error.snippet : void 0),
+    body.param ?? void 0
+  );
+}
+function hintFor(status, code) {
+  if (status === 0) return "Network error reaching HeyGen \u2014 check connectivity and retry.";
+  if (status === 401)
+    return `Check HEYGEN_API_KEY (sent as the X-Api-Key header) or create a new key at ${HEYGEN_API_SETTINGS_URL}.`;
+  if (status === 402)
+    return `Add API credits or upgrade the API plan at ${HEYGEN_USAGE_URL}. HeyGen API usage is billed separately from web/app subscriptions.`;
+  if (status === 403) {
+    if (code === "insufficient_api_key_scope")
+      return "The API key lacks the scope this operation needs \u2014 create a key with the required scopes.";
+    return "The API key, workspace, or plan is not entitled to this feature (some avatar and digital-twin features require Enterprise access).";
+  }
+  if (status === 404) return "Check the ID. For `heygen status`, make sure --type matches the ID.";
+  if (status === 409 && code === "request_in_progress")
+    return "An identical request is still being processed \u2014 wait and retry.";
+  if (status === 409) return "The resource is not ready or conflicts with existing state.";
+  if (status === 400 || status === 422) return "Fix the request parameters and retry.";
+  if (status === 429)
+    return code === "quota_exceeded" ? `Usage quota exceeded \u2014 see ${HEYGEN_USAGE_URL}.` : "Rate or concurrency limit reached \u2014 wait and retry, or reduce parallel jobs.";
+  if (status >= 500) return "HeyGen server error \u2014 retry later.";
+  return "";
+}
+function describeHeygenError(status, code, message, param, retryAfterMs) {
+  const label = status === 0 ? "HeyGen request failed" : `HeyGen API error ${status}`;
+  const codePart = code ? ` (${code})` : "";
+  const msgPart = message ? `: ${message}` : "";
+  const paramPart = param ? ` (param: ${param})` : "";
+  const retryPart = retryAfterMs !== void 0 ? ` Retry after ${Math.ceil(retryAfterMs / 1e3)}s.` : "";
+  const hint = hintFor(status, code);
+  const base = `${label}${codePart}${msgPart}${paramPart}`;
+  const sentence = /[.!?]$/.test(base) ? base : `${base}.`;
+  return `${sentence}${retryPart}${hint ? ` ${hint}` : ""}`;
+}
+
+// src/providers/heygen/client.ts
+var MAX_RETRY_WAIT_MS = 6e4;
+var defaultSleep2 = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+function seg(id, label) {
+  if (typeof id !== "string") throw new ValidationError(`${label} must be a string`);
+  const trimmed = id.trim();
+  if (!trimmed) throw new ValidationError(`${label} must not be empty`);
+  if (trimmed === "." || trimmed === "..") {
+    throw new ValidationError(`Invalid ${label}: "${trimmed}"`);
+  }
+  return encodeURIComponent(trimmed);
+}
+function describePayload(data) {
+  const text = JSON.stringify(
+    data,
+    (_k, v) => typeof v === "string" && /^https?:\/\//i.test(v) ? redactUrl(v) : v
+  );
+  return (text ?? String(data)).slice(0, 500);
+}
+function requireJobId(data, field, path57) {
+  const value = data?.[field];
+  const ok2 = Array.isArray(value) ? value.length > 0 && value.every((v) => typeof v === "string" && v.length > 0) : typeof value === "string" && value.length > 0;
+  if (!ok2) {
+    throw new ProviderError(
+      `HeyGen ${path57} returned no ${field}; a job may still have been created, so check the HeyGen dashboard. Response: ${describePayload(data)}`,
+      "heygen"
+    );
+  }
+  return data;
+}
+var HeygenClient = class {
+  apiKey;
+  baseUrl;
+  fetchImpl;
+  timeoutMs;
+  maxAttempts;
+  sleep;
+  newIdempotencyKey;
+  constructor(opts) {
+    if (!opts.apiKey?.trim()) throw new ValidationError("HeyGen apiKey is required");
+    this.apiKey = opts.apiKey.trim();
+    this.baseUrl = (opts.baseUrl ?? DEFAULT_HEYGEN_BASE_URL).replace(/\/+$/, "");
+    this.fetchImpl = opts.fetch;
+    this.timeoutMs = opts.timeoutMs ?? 12e4;
+    this.maxAttempts = Math.max(1, opts.maxAttempts ?? 3);
+    this.sleep = opts.sleep ?? defaultSleep2;
+    this.newIdempotencyKey = opts.newIdempotencyKey ?? (() => crypto.randomUUID());
+  }
+  /** Build an absolute URL for a v3 path plus query parameters. */
+  url(path57, query) {
+    const suffix = path57.startsWith("/") ? path57 : `/${path57}`;
+    const params = new URLSearchParams();
+    for (const [k, v] of Object.entries(query ?? {})) {
+      if (v !== void 0 && v !== "") params.set(k, String(v));
+    }
+    const qs = params.toString();
+    return `${this.baseUrl}${suffix}${qs ? `?${qs}` : ""}`;
+  }
+  headers(idempotencyKey) {
+    return {
+      Accept: "application/json",
+      "X-Api-Key": this.apiKey,
+      ...idempotencyKey ? { "Idempotency-Key": idempotencyKey } : {}
+    };
+  }
+  /**
+   * Send a request and return the raw parsed JSON (envelope included).
+   * Retries are bounded and only where safe: a 429 carrying Retry-After was
+   * rejected before processing; 5xx/network failures and 409
+   * `request_in_progress` are retried only when an Idempotency-Key makes the
+   * replay safe. GET requests are left to the caller's polling loop.
+   */
+  async send(path57, opts = {}) {
+    const method = opts.method ?? "GET";
+    const key = typeof opts.idempotencyKey === "string" ? opts.idempotencyKey : opts.idempotencyKey ? this.newIdempotencyKey() : void 0;
+    const url = this.url(path57, opts.query);
+    for (let attempt = 1; ; attempt++) {
+      try {
+        return await fetchJson({
+          url,
+          method,
+          headers: this.headers(key),
+          body: opts.body,
+          timeoutMs: Math.max(1, Math.min(this.timeoutMs, opts.timeoutMs ?? this.timeoutMs)),
+          fetch: this.fetchImpl
+        });
+      } catch (error) {
+        const apiError = error instanceof HttpError ? toHeygenApiError(error) : error;
+        if (method === "GET" || attempt >= this.maxAttempts || !(apiError instanceof HttpError)) {
+          throw apiError;
+        }
+        const wait = this.retryDelay(apiError, key, attempt);
+        if (wait === void 0) throw apiError;
+        await this.sleep(wait);
+      }
+    }
+  }
+  retryDelay(error, key, attempt) {
+    const code = error instanceof HeygenApiError ? error.apiCode : void 0;
+    if (error.status === 429 && error.retryAfterMs !== void 0 && code !== "quota_exceeded") {
+      return Math.min(error.retryAfterMs, MAX_RETRY_WAIT_MS);
+    }
+    if (!key) return void 0;
+    if (error.status === 0 || error.status >= 500 || code === "request_in_progress") {
+      return Math.min(1e3 * 2 ** (attempt - 1), MAX_RETRY_WAIT_MS);
+    }
+    return void 0;
+  }
+  /** Send and unwrap `{ data }`. A 2xx body carrying `error` is treated as a failure. */
+  async request(path57, opts = {}) {
+    const json = await this.send(path57, opts);
+    return unwrapData(json, path57);
+  }
+  async page(path57, query) {
+    const json = await this.send(path57, {
+      query
+    });
+    const items = unwrapData(json, path57);
+    if (!Array.isArray(items)) {
+      throw new ProviderError(
+        `Unexpected HeyGen response from ${path57}: data is not a list`,
+        "heygen"
+      );
+    }
+    const next = json.next_token;
+    return {
+      items,
+      hasMore: json.has_more === true,
+      nextToken: typeof next === "string" && next ? next : null
+    };
+  }
+  // ── Account ───────────────────────────────────────────────────────────
+  getCurrentUser() {
+    return this.request("/v3/users/me");
+  }
+  // ── Video Agent ───────────────────────────────────────────────────────
+  /** POST /v3/video-agents. No Idempotency-Key: the endpoint does not document one. */
+  async createVideoAgent(body) {
+    const path57 = "/v3/video-agents";
+    const data = await this.request(path57, { method: "POST", body });
+    return requireJobId(data, "session_id", path57);
+  }
+  async getVideoAgentSession(sessionId, opts = {}) {
+    return this.request(`/v3/video-agents/${seg(sessionId, "session id")}`, opts);
+  }
+  listVideoAgentStyles(query = {}) {
+    return this.page("/v3/video-agents/styles", { ...query });
+  }
+  // ── Videos ────────────────────────────────────────────────────────────
+  async createVideo(body, idempotencyKey = true) {
+    const path57 = "/v3/videos";
+    const data = await this.request(path57, {
+      method: "POST",
+      body,
+      idempotencyKey
+    });
+    return requireJobId(data, "video_id", path57);
+  }
+  async getVideo(videoId, opts = {}) {
+    return this.request(`/v3/videos/${seg(videoId, "video id")}`, opts);
+  }
+  /** POST /v3/templates/{id}. Returns the created video's `VideoDetail`. */
+  async generateFromTemplate(templateId, body, idempotencyKey = true) {
+    const path57 = `/v3/templates/${seg(templateId, "template id")}`;
+    const data = await this.request(path57, {
+      method: "POST",
+      body,
+      idempotencyKey
+    });
+    return requireJobId(data, "id", path57);
+  }
+  // ── HeyGen Video model ────────────────────────────────────────────────
+  async createModelVideo(body, idempotencyKey = true) {
+    const path57 = "/v3/models/videos";
+    const data = await this.request(path57, {
+      method: "POST",
+      body,
+      idempotencyKey
+    });
+    return requireJobId(data, "video_id", path57);
+  }
+  async getModelVideo(videoId, opts = {}) {
+    return this.request(`/v3/models/videos/${seg(videoId, "video id")}`, opts);
+  }
+  // ── Catalog ───────────────────────────────────────────────────────────
+  listAvatarGroups(query = {}) {
+    return this.page("/v3/avatars", { ...query });
+  }
+  /** Looks are what video generation needs: a look `id` is the `avatar_id`. */
+  listAvatarLooks(query = {}) {
+    return this.page("/v3/avatars/looks", { ...query });
+  }
+  listVoices(query = {}) {
+    return this.page("/v3/voices", { ...query });
+  }
+  // ── Speech ────────────────────────────────────────────────────────────
+  createSpeech(body) {
+    return this.request("/v3/voices/speech", { method: "POST", body });
+  }
+  // ── Translation & lipsync ─────────────────────────────────────────────
+  async createVideoTranslation(body, idempotencyKey = true) {
+    const path57 = "/v3/video-translations";
+    const data = await this.request(path57, {
+      method: "POST",
+      body,
+      idempotencyKey
+    });
+    return requireJobId(data, "video_translation_ids", path57);
+  }
+  async getVideoTranslation(id, opts = {}) {
+    return this.request(`/v3/video-translations/${seg(id, "video translation id")}`, opts);
+  }
+  async listTranslationLanguages() {
+    const data = await this.request("/v3/video-translations/languages");
+    if (!Array.isArray(data.languages)) {
+      throw new ProviderError("Unexpected HeyGen response: languages is not a list", "heygen");
+    }
+    return data.languages.filter((l) => typeof l === "string");
+  }
+  async createLipsync(body, idempotencyKey = true) {
+    const path57 = "/v3/lipsyncs";
+    const data = await this.request(path57, {
+      method: "POST",
+      body,
+      idempotencyKey
+    });
+    return requireJobId(data, "lipsync_id", path57);
+  }
+  async getLipsync(id, opts = {}) {
+    return this.request(`/v3/lipsyncs/${seg(id, "lipsync id")}`, opts);
+  }
+  // ── Assets ────────────────────────────────────────────────────────────
+  /**
+   * POST /v3/assets (multipart, max 32 MB). Accepts bytes or a Blob so it works
+   * without a filesystem; for remote files prefer passing `{type:"url"}` inputs.
+   */
+  async uploadAsset(input) {
+    const blob = input.data instanceof Blob ? input.data : new Blob([input.data], { type: input.mimeType });
+    if (blob.size === 0) throw new ValidationError(`Cannot upload empty file ${input.filename}`);
+    if (blob.size > LIMITS.assetUploadMaxBytes) {
+      throw new ValidationError(
+        `${input.filename} is ${(blob.size / 1024 / 1024).toFixed(1)} MB; POST /v3/assets accepts at most 32 MB. Host the file at a public HTTPS URL and pass the URL instead.`
+      );
+    }
+    const typed = blob.type ? blob : new Blob([blob], { type: input.mimeType });
+    const key = this.newIdempotencyKey();
+    const url = this.url("/v3/assets");
+    const doFetch = this.fetchImpl ?? ((u, init) => globalThis.fetch(u, init));
+    for (let attempt = 1; ; attempt++) {
+      const form = new FormData();
+      form.append("file", typed, input.filename);
+      let response;
+      try {
+        response = await doFetch(url, {
+          method: "POST",
+          headers: this.headers(key),
+          body: form,
+          signal: AbortSignal.timeout(this.timeoutMs)
+        });
+      } catch (cause) {
+        const msg = cause instanceof Error ? cause.message : String(cause);
+        const err3 = toHeygenApiError(new HttpError(0, msg, url));
+        if (attempt >= this.maxAttempts) throw err3;
+        await this.sleep(this.retryDelay(err3, key, attempt) ?? 1e3);
+        continue;
+      }
+      if (response.ok) {
+        let json;
+        try {
+          json = await response.json();
+        } catch {
+          throw new ProviderError(
+            `HeyGen /v3/assets returned a non-JSON response (HTTP ${response.status}) for ${input.filename}`,
+            "heygen"
+          );
+        }
+        const data = unwrapData(json, "/v3/assets");
+        return requireJobId(data, "asset_id", "/v3/assets");
+      }
+      const err2 = toHeygenApiError(await httpErrorFromResponse(response, url));
+      const wait = attempt < this.maxAttempts ? this.retryDelay(err2, key, attempt) : void 0;
+      if (wait === void 0) throw err2;
+      await this.sleep(wait);
+    }
+  }
+};
+function unwrapData(json, path57) {
+  if (json === null || typeof json !== "object") {
+    throw new ProviderError(`Unexpected HeyGen response from ${path57}: not a JSON object`, "heygen");
+  }
+  const record = json;
+  const error = record.error;
+  if (error && typeof error === "object") {
+    const e = error;
+    throw new ProviderError(
+      `HeyGen API error${e.code ? ` (${e.code})` : ""}: ${e.message ?? "unknown error"}`,
+      "heygen"
+    );
+  }
+  if (!("data" in record) || record.data === null || record.data === void 0) {
+    throw new ProviderError(`Unexpected HeyGen response from ${path57}: missing data`, "heygen");
+  }
+  return record.data;
+}
+
+// src/providers/heygen/jobs.ts
+var str = (v) => typeof v === "string" && v ? v : void 0;
+function videoState(video, kind = "video", id = video.id, opts = {}) {
+  const done = video.status === "completed" || video.status === "failed";
+  const captioned = str(video.captioned_video_url);
+  const state = {
+    kind,
+    id,
+    status: video.status,
+    done,
+    succeeded: video.status === "completed",
+    videoId: video.id,
+    outputUrl: opts.burnCaptions ? captioned : str(video.video_url) ?? captioned,
+    captionedVideoUrl: captioned,
+    thumbnailUrl: str(video.thumbnail_url),
+    captionUrl: str(video.subtitle_url),
+    failureCode: str(video.failure_code),
+    failureMessage: str(video.failure_message),
+    raw: { video }
+  };
+  if (opts.burnCaptions && state.succeeded && !captioned) {
+    return {
+      ...state,
+      succeeded: false,
+      failureCode: "captioned_video_missing",
+      failureMessage: "Burned-in captions were requested but HeyGen returned no captioned_video_url. The uncaptioned render is available via `heygen status --raw`."
+    };
+  }
+  return state;
+}
+function translationState(t) {
+  const audioOnly = !str(t.video_url) && !!str(t.audio_url);
+  return {
+    kind: "translation",
+    id: t.id,
+    status: t.status,
+    done: t.status === "completed" || t.status === "failed",
+    succeeded: t.status === "completed",
+    outputUrl: str(t.video_url) ?? str(t.audio_url),
+    ...audioOnly ? { outputIsAudio: true } : {},
+    captionUrl: str(t.srt_caption_url) ?? str(t.vtt_caption_url),
+    outputLanguage: str(t.output_language),
+    failureMessage: str(t.failure_message),
+    raw: { translation: t }
+  };
+}
+function lipsyncState(l) {
+  return {
+    kind: "lipsync",
+    id: l.id,
+    status: l.status,
+    done: l.status === "completed" || l.status === "failed",
+    succeeded: l.status === "completed",
+    outputUrl: str(l.video_url),
+    captionUrl: str(l.caption_url),
+    failureMessage: str(l.failure_message),
+    raw: { lipsync: l }
+  };
+}
+function modelVideoState(v) {
+  const done = v.status === "completed" || v.status === "failed" || v.status === "cancelled";
+  return {
+    kind: "model-video",
+    id: v.video_id,
+    status: v.status,
+    done,
+    succeeded: v.status === "completed",
+    videoId: v.video_id,
+    outputUrl: str(v.video_url),
+    failureCode: str(v.failure_code),
+    failureMessage: str(v.failure_message),
+    raw: { video: v }
+  };
+}
+function agentState(session, video) {
+  const base = {
+    kind: "agent",
+    id: session.session_id,
+    sessionId: session.session_id,
+    sessionStatus: session.status,
+    progress: session.progress
+  };
+  const sessionError = session.error ?? void 0;
+  if (video) {
+    const v = videoState(video, "agent", session.session_id);
+    if (!v.done && session.status === "failed" && sessionError?.code !== "context_limit_exceeded") {
+      return {
+        ...v,
+        ...base,
+        status: "failed",
+        done: true,
+        succeeded: false,
+        failureCode: sessionError?.code,
+        failureMessage: sessionError?.message ?? "Video Agent session failed",
+        raw: { session, video }
+      };
+    }
+    if (v.done && !v.succeeded && session.status === "waiting_for_input") {
+      return {
+        ...v,
+        ...base,
+        failureCode: v.failureCode ?? "waiting_for_input",
+        failureMessage: v.failureMessage ?? "Video Agent paused for input; continue the session in the HeyGen app or start a new prompt.",
+        raw: { session, video }
+      };
+    }
+    return { ...v, ...base, raw: { session, video } };
+  }
+  const pending2 = { ...base, status: session.status, raw: { session } };
+  if (session.status === "failed") {
+    return {
+      ...pending2,
+      done: true,
+      succeeded: false,
+      failureCode: sessionError?.code,
+      failureMessage: sessionError?.message ?? "Video Agent session failed"
+    };
+  }
+  if (session.status === "waiting_for_input") {
+    return {
+      ...pending2,
+      done: true,
+      succeeded: false,
+      failureCode: "waiting_for_input",
+      failureMessage: "Video Agent paused for input before rendering; continue the session in the HeyGen app or start a new prompt."
+    };
+  }
+  if (session.status === "completed") {
+    return {
+      ...pending2,
+      done: true,
+      succeeded: false,
+      failureCode: "no_video",
+      failureMessage: "Video Agent session completed without a video_id."
+    };
+  }
+  return { ...pending2, done: false, succeeded: false };
+}
+function createJobStatusReader(client, kind, id, opts = {}) {
+  return async (ctx) => {
+    const call = { timeoutMs: ctx?.remainingMs };
+    switch (kind) {
+      case "video":
+        return videoState(await client.getVideo(id, call), "video", id, opts);
+      case "translation":
+        return translationState(await client.getVideoTranslation(id, call));
+      case "lipsync":
+        return lipsyncState(await client.getLipsync(id, call));
+      case "model-video":
+        return modelVideoState(await client.getModelVideo(id, call));
+      case "agent": {
+        const session = await client.getVideoAgentSession(id, call);
+        if (!session.video_id) return agentState(session);
+        return agentState(session, await client.getVideo(session.video_id, call));
+      }
+    }
+  };
+}
+function getJobState(client, kind, id, opts = {}) {
+  return createJobStatusReader(client, kind, id, opts)();
+}
+var DEFAULT_POLL_INTERVAL_MS = 1e4;
+var STAGGER_STEP_MS = 500;
+var STAGGER_MAX_MS = 5e3;
+function staggerOffsetMs(index, intervalMs) {
+  if (!Number.isFinite(index) || index <= 0) return 0;
+  const step = Math.min(STAGGER_STEP_MS, Math.max(0, intervalMs));
+  return Math.min(index * step, STAGGER_MAX_MS);
+}
+var defaultSleep3 = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+async function waitForJob(client, kind, id, opts) {
+  const { burnCaptions, startDelayMs = 0, ...poll2 } = opts;
+  let pendingDelay = Math.min(Math.max(0, startDelayMs), Math.floor(poll2.timeoutMs / 2));
+  const read = createJobStatusReader(client, kind, id, { burnCaptions });
+  return pollUntil({
+    intervalMs: DEFAULT_POLL_INTERVAL_MS,
+    maxIntervalMs: 3e4,
+    ...poll2,
+    fetchStatus: async (ctx) => {
+      const delay = pendingDelay;
+      if (delay <= 0) return read(ctx);
+      pendingDelay = 0;
+      await (poll2.sleep ?? defaultSleep3)(delay);
+      return read({ remainingMs: Math.max(1, ctx.remainingMs - delay) });
+    },
+    isTerminal: (s) => s.done
+  });
+}
+function assertJobSucceeded(state) {
+  if (state.succeeded) return;
+  const label = state.kind === "agent" ? `Video Agent session ${state.id}` : `${state.kind} ${state.id}`;
+  const code = state.failureCode ? ` (${state.failureCode})` : "";
+  const msg = state.failureMessage ? `: ${state.failureMessage}` : "";
+  throw new HeygenJobFailedError(
+    `HeyGen ${label} ended with status "${state.status}"${code}${msg}`,
+    state.failureCode
+  );
+}
+function shellArg(value) {
+  return /^[A-Za-z0-9_-]+$/.test(value) ? value : `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function resumeCommand2(kind, id, opts = {}) {
+  const captions = opts.burnCaptions ? " --burn-captions" : "";
+  return `multix heygen status ${shellArg(id)} --type ${kind} --wait --download${captions}`;
+}
+
+// src/providers/heygen/request-builders.ts
+init_errors();
+init_redact();
+function oneOf(value, allowed, flag) {
+  if (value === void 0) return void 0;
+  if (!allowed.includes(value)) {
+    throw new ValidationError(`${flag} must be one of: ${allowed.join(", ")} (got "${value}")`);
+  }
+  return value;
+}
+function numberInRange(value, flag, min, max, integer = false) {
+  if (value === void 0 || value === "") return void 0;
+  const n = typeof value === "number" ? value : Number(value);
+  if (!Number.isFinite(n) || n < min || n > max || integer && !Number.isInteger(n)) {
+    throw new ValidationError(
+      `${flag} must be ${integer ? "an integer" : "a number"} between ${min} and ${max} (got "${value}")`
+    );
+  }
+  return n;
+}
+function requireHttps(url, flag) {
+  if (!/^https:\/\//i.test(url)) throw new ValidationError(`${flag} must be an https:// URL`);
+  return url;
+}
+function isHttpsUrl(url) {
+  try {
+    return new URL(url).protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+var LOOPBACK_HOSTS = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "[::1]"]);
+function checkBaseUrl(raw, variable) {
+  const value = raw.trim();
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    throw new ConfigError(`${variable} must be an absolute https:// URL`);
+  }
+  const loopbackHttp = url.protocol === "http:" && LOOPBACK_HOSTS.has(url.hostname);
+  if (url.protocol !== "https:" && !loopbackHttp) {
+    throw new ConfigError(
+      `${variable} must use https:// (got ${redactUrl(value)}); plain http:// is only allowed for localhost, 127.0.0.1, or [::1]`
+    );
+  }
+  return value;
+}
+function classifyMediaRef(value) {
+  const v = value.trim();
+  if (!v) throw new ValidationError("Media reference must not be empty");
+  if (/^https?:\/\//i.test(v)) return { kind: "url", url: requireHttps(v, "Media URL") };
+  const asset = v.match(/^asset(?:_id)?:(.+)$/i);
+  if (asset?.[1]) return { kind: "asset", assetId: asset[1].trim() };
+  return { kind: "path", path: v };
+}
+function splitLanguages(raw) {
+  const out = [];
+  let depth = 0;
+  let current = "";
+  for (const ch of raw) {
+    if (ch === "(") depth++;
+    if (ch === ")") depth = Math.max(0, depth - 1);
+    if (ch === "," && depth === 0) {
+      out.push(current);
+      current = "";
+    } else {
+      current += ch;
+    }
+  }
+  out.push(current);
+  const langs = out.map((s) => s.trim()).filter(Boolean);
+  if (langs.length === 0) throw new ValidationError("--languages must list at least one language");
+  return [...new Set(langs)];
+}
+function checkCallback(url) {
+  return url === void 0 ? void 0 : requireHttps(url, "--callback-url");
+}
+function buildVideoAgentRequest(input) {
+  const prompt = input.prompt?.trim() ?? "";
+  if (prompt.length < 1 || prompt.length > LIMITS.agentPromptMax) {
+    throw new ValidationError(`Prompt must be 1-${LIMITS.agentPromptMax} characters`);
+  }
+  const files = input.files ?? [];
+  if (files.length > LIMITS.agentFilesMax) {
+    throw new ValidationError(`Video Agent accepts at most ${LIMITS.agentFilesMax} files`);
+  }
+  const body = { prompt, mode: "generate" };
+  if (input.avatarId) body.avatar_id = input.avatarId;
+  if (input.voiceId) body.voice_id = input.voiceId;
+  if (input.styleId) body.style_id = input.styleId;
+  if (input.brandKitId) body.brand_kit_id = input.brandKitId;
+  if (input.brandGlossaryId) body.brand_glossary_id = input.brandGlossaryId;
+  const orientation = oneOf(input.orientation, AGENT_ORIENTATIONS, "--orientation");
+  if (orientation) body.orientation = orientation;
+  if (files.length > 0) body.files = files;
+  const callbackUrl = checkCallback(input.callbackUrl);
+  if (callbackUrl) body.callback_url = callbackUrl;
+  if (input.callbackId) body.callback_id = input.callbackId;
+  return body;
+}
+function buildAvatarVideoRequest(input) {
+  if (!input.avatarId?.trim()) throw new ValidationError("--avatar <look-id> is required");
+  const script = input.script?.trim();
+  if (script && input.audio) {
+    throw new ValidationError("Provide either a script or --audio, not both");
+  }
+  if (!script && !input.audio) {
+    throw new ValidationError("Provide a script argument or --audio <url|asset:id|file>");
+  }
+  if (script && script.length > LIMITS.scriptMax) {
+    throw new ValidationError(`Script must be at most ${LIMITS.scriptMax} characters`);
+  }
+  const body = { type: "avatar", avatar_id: input.avatarId.trim() };
+  if (script) {
+    body.script = script;
+    if (input.voiceId) body.voice_id = input.voiceId;
+  } else if (input.audio) {
+    if (input.voiceId) throw new ValidationError("--voice applies to scripts, not --audio");
+    if (input.audio.type === "url") body.audio_url = input.audio.url;
+    else if (input.audio.type === "asset_id") body.audio_asset_id = input.audio.asset_id;
+    else throw new ValidationError("--audio must be a URL, asset id, or uploaded file");
+  }
+  const resolution = oneOf(input.resolution, AVATAR_VIDEO_RESOLUTIONS, "--resolution");
+  if (resolution) body.resolution = resolution;
+  const aspect = oneOf(input.aspectRatio, AVATAR_VIDEO_ASPECT_RATIOS, "--aspect-ratio");
+  if (aspect) body.aspect_ratio = aspect;
+  const fit = oneOf(input.fit, ["contain", "cover"], "--fit");
+  if (fit) body.fit = fit;
+  const outputFormat = oneOf(input.outputFormat, ["mp4", "webm"], "--output-format");
+  if (outputFormat) body.output_format = outputFormat;
+  if (input.backgroundColor && input.backgroundImage) {
+    throw new ValidationError("Use either --background-color or --background-image, not both");
+  }
+  if (outputFormat === "webm" && (input.backgroundColor || input.backgroundImage)) {
+    throw new ValidationError(
+      "--output-format webm renders a transparent background; drop --background-*"
+    );
+  }
+  if (input.backgroundColor) {
+    if (!/^#[0-9a-f]{6}$/i.test(input.backgroundColor)) {
+      throw new ValidationError("--background-color must be a hex color like #112233");
+    }
+    body.background = { type: "color", value: input.backgroundColor };
+  } else if (input.backgroundImage) {
+    const bg = input.backgroundImage;
+    if (bg.type === "url") body.background = { type: "image", url: bg.url };
+    else if (bg.type === "asset_id") body.background = { type: "image", asset_id: bg.asset_id };
+  }
+  if (input.removeBackground) body.remove_background = true;
+  if (input.captions || input.burnCaptions) {
+    body.caption = {
+      file_format: "srt",
+      ...input.burnCaptions ? { style: "default" } : {}
+    };
+  }
+  const speed = numberInRange(input.speed, "--speed", 0.5, 1.5);
+  const pitch = numberInRange(input.pitch, "--pitch", -50, 50);
+  const volume = numberInRange(input.volume, "--volume", 0, 1);
+  if (speed !== void 0 || pitch !== void 0 || volume !== void 0 || input.locale) {
+    if (!script) throw new ValidationError("Voice settings apply only to scripted videos");
+    body.voice_settings = {
+      ...speed !== void 0 ? { speed } : {},
+      ...pitch !== void 0 ? { pitch } : {},
+      ...volume !== void 0 ? { volume } : {},
+      ...input.locale ? { locale: input.locale } : {}
+    };
+  }
+  const engine = oneOf(input.engine, AVATAR_ENGINES, "--engine");
+  if (input.referenceLookId && engine !== "avatar_v") {
+    throw new ValidationError("--reference-look requires --engine avatar_v");
+  }
+  if (engine) {
+    body.engine = {
+      type: engine,
+      ...input.referenceLookId ? { reference_look_id: input.referenceLookId } : {}
+    };
+  }
+  if (input.motionPrompt) {
+    if (engine === "avatar_iii") {
+      throw new ValidationError("--motion-prompt is not supported with --engine avatar_iii");
+    }
+    body.motion_prompt = input.motionPrompt;
+  }
+  const expressiveness = oneOf(input.expressiveness, EXPRESSIVENESS_LEVELS, "--expressiveness");
+  if (expressiveness) {
+    if (engine === "avatar_v" || engine === "avatar_iii") {
+      throw new ValidationError("--expressiveness is Avatar IV only (photo avatars)");
+    }
+    body.expressiveness = expressiveness;
+  }
+  if (resolution === "4k" && engine !== "avatar_iii") {
+    throw new ValidationError(
+      "--resolution 4k requires --engine avatar_iii (digital twins and studio avatars)"
+    );
+  }
+  if (input.title) body.title = input.title;
+  if (input.folderId) body.folder_id = input.folderId;
+  if (input.brandGlossaryId) body.brand_glossary_id = input.brandGlossaryId;
+  const callbackUrl = checkCallback(input.callbackUrl);
+  if (callbackUrl) body.callback_url = callbackUrl;
+  if (input.callbackId) body.callback_id = input.callbackId;
+  return body;
+}
+function buildSpeechRequest(input) {
+  const text = input.text ?? "";
+  if (text.trim().length < 1 || text.length > LIMITS.speechTextMax) {
+    throw new ValidationError(`Text must be 1-${LIMITS.speechTextMax} characters`);
+  }
+  if (!input.voiceId?.trim()) throw new ValidationError("--voice <voice-id> is required");
+  const body = { text, voice_id: input.voiceId.trim() };
+  if (input.ssml) body.input_type = "ssml";
+  const speed = numberInRange(input.speed, "--speed", 0.5, 2);
+  if (speed !== void 0) body.speed = speed;
+  if (input.language) body.language = input.language;
+  if (input.locale) body.locale = input.locale;
+  const engine = oneOf(input.engine, SPEECH_ENGINES, "--engine");
+  if (engine) body.engine = engine;
+  return body;
+}
+function buildModelVideoRequest(input) {
+  const prompt = input.prompt?.trim() ?? "";
+  if (prompt.length < 1 || prompt.length > LIMITS.modelVideoPromptMax) {
+    throw new ValidationError(`Prompt must be 1-${LIMITS.modelVideoPromptMax} characters`);
+  }
+  const refImages = input.referenceImages ?? [];
+  const refVideos = input.referenceVideos ?? [];
+  const refAudio = input.referenceAudio ?? [];
+  const hasRefs = refImages.length + refVideos.length + refAudio.length > 0;
+  const inferred = input.image ? "image_to_video" : hasRefs ? "reference_to_video" : "text_to_video";
+  const mode = oneOf(input.mode, MODEL_VIDEO_MODES, "--mode") ?? inferred;
+  if (mode === "image_to_video" && !input.image) {
+    throw new ValidationError("image_to_video requires --image");
+  }
+  if (mode !== "image_to_video" && input.image) {
+    throw new ValidationError("--image is only valid with --mode image_to_video");
+  }
+  if (mode === "reference_to_video" && refImages.length + refVideos.length === 0) {
+    throw new ValidationError(
+      "reference_to_video needs at least one --reference-image or --reference-video"
+    );
+  }
+  if (mode !== "reference_to_video" && hasRefs) {
+    throw new ValidationError("--reference-* inputs are only valid with --mode reference_to_video");
+  }
+  if (refImages.length > LIMITS.modelVideoReferenceImagesMax) {
+    throw new ValidationError(`At most ${LIMITS.modelVideoReferenceImagesMax} reference images`);
+  }
+  if (refVideos.length > LIMITS.modelVideoReferenceVideosMax) {
+    throw new ValidationError(`At most ${LIMITS.modelVideoReferenceVideosMax} reference videos`);
+  }
+  if (refAudio.length > LIMITS.modelVideoReferenceAudioMax) {
+    throw new ValidationError(
+      `At most ${LIMITS.modelVideoReferenceAudioMax} reference audio files`
+    );
+  }
+  const refTotal = refImages.length + refVideos.length + refAudio.length;
+  if (refTotal > LIMITS.modelVideoReferenceTotalMax) {
+    throw new ValidationError(
+      `At most ${LIMITS.modelVideoReferenceTotalMax} reference files in total (got ${refTotal})`
+    );
+  }
+  const body = { model: HEYGEN_VIDEO_MODEL, mode, prompt };
+  const duration = numberInRange(
+    input.duration,
+    "--duration",
+    LIMITS.modelVideoMinDuration,
+    LIMITS.modelVideoMaxDuration,
+    true
+  );
+  if (duration !== void 0) body.duration = duration;
+  const resolution = oneOf(input.resolution, MODEL_VIDEO_RESOLUTIONS, "--resolution");
+  if (resolution) body.resolution = resolution;
+  const aspect = oneOf(input.aspectRatio, MODEL_VIDEO_ASPECT_RATIOS, "--aspect-ratio");
+  if (aspect === "adaptive" && mode !== "reference_to_video") {
+    throw new ValidationError("--aspect-ratio adaptive is only valid for reference_to_video");
+  }
+  if (aspect && mode === "image_to_video") {
+    throw new ValidationError("image_to_video follows the first frame; drop --aspect-ratio");
+  }
+  if (aspect) body.aspect_ratio = aspect;
+  const enhancement = oneOf(
+    input.promptEnhancement,
+    MODEL_VIDEO_PROMPT_ENHANCEMENT,
+    "--prompt-enhancement"
+  );
+  if (enhancement) body.prompt_enhancement = enhancement;
+  const seed = numberInRange(input.seed, "--seed", 0, 4294967295, true);
+  if (seed !== void 0) body.seed = seed;
+  if (input.image) body.image = input.image;
+  if (refImages.length) body.reference_images = refImages;
+  if (refVideos.length) body.reference_videos = refVideos;
+  if (refAudio.length) body.reference_audio = refAudio;
+  const callbackUrl = checkCallback(input.callbackUrl);
+  if (callbackUrl) body.callback_url = callbackUrl;
+  if (input.callbackId) body.callback_id = input.callbackId;
+  return body;
+}
+function qualityMode(value) {
+  return oneOf(value, QUALITY_MODES, "--mode");
+}
+
+// src/providers/heygen/node-helpers.ts
+function requireHeygenKey() {
+  const key = resolveKey("HEYGEN_API_KEY")?.trim();
+  if (!key) {
+    throw new ConfigError(
+      `HEYGEN_API_KEY is not set. Create an API key at ${HEYGEN_API_SETTINGS_URL} (API usage is billed separately from HeyGen web plans).`
+    );
+  }
+  return key;
+}
+function createHeygenClientFromEnv() {
+  const apiKey = requireHeygenKey();
+  const override = resolveKey("HEYGEN_BASE_URL")?.trim();
+  return new HeygenClient({
+    apiKey,
+    baseUrl: override ? checkBaseUrl(override, "HEYGEN_BASE_URL") : DEFAULT_HEYGEN_BASE_URL
+  });
+}
+async function uploadLocalFile(client, filePath, logger) {
+  const abs = path32.resolve(filePath);
+  let stat;
+  try {
+    stat = fs29.statSync(abs);
+  } catch {
+    throw new ValidationError(
+      `File not found: ${filePath}. Use an https:// URL, asset:<asset_id>, or an existing file.`
+    );
+  }
+  if (!stat.isFile()) throw new ValidationError(`Not a file: ${filePath}`);
+  const ext = path32.extname(abs).slice(1).toLowerCase();
+  const mimeType = ASSET_MIME_BY_EXT[ext];
+  if (!mimeType) {
+    throw new ValidationError(
+      `Unsupported file type ".${ext}" for HeyGen upload. Supported: ${Object.keys(ASSET_MIME_BY_EXT).join(", ")}`
+    );
+  }
+  if (stat.size > LIMITS.assetUploadMaxBytes) {
+    throw new ValidationError(
+      `${filePath} is ${(stat.size / 1024 / 1024).toFixed(1)} MB; HeyGen asset upload accepts at most 32 MB. Host it at a public https:// URL instead.`
+    );
+  }
+  logger.info(`Uploading ${path32.basename(abs)} to HeyGen assets...`);
+  const res = await client.uploadAsset({
+    data: new Uint8Array(fs29.readFileSync(abs)),
+    filename: path32.basename(abs),
+    mimeType
+  });
+  logger.debug(`Uploaded asset ${res.asset_id} (${res.mime_type}, ${res.size_bytes} bytes)`);
+  return { type: "asset_id", asset_id: res.asset_id };
+}
+async function resolveMediaInput(client, value, logger) {
+  const ref = classifyMediaRef(value);
+  if (ref.kind === "url") return { type: "url", url: ref.url };
+  if (ref.kind === "asset") return { type: "asset_id", asset_id: ref.assetId };
+  return uploadLocalFile(client, ref.path, logger);
+}
+async function resolveMediaInputs(client, values, logger) {
+  const out = [];
+  for (const v of values ?? []) out.push(await resolveMediaInput(client, v, logger));
+  return out;
+}
+function collect5(value, previous = []) {
+  return [...previous, value];
+}
+function parsePositiveInt(raw, flag, fallback) {
+  if (raw === void 0) return fallback;
+  const n = Number(raw);
+  if (!Number.isInteger(n) || n <= 0)
+    throw new ValidationError(`${flag} must be a positive integer`);
+  return n;
+}
+var DEFAULT_WAIT_TIMEOUT_MS = 18e5;
+function addWaitOptions(cmd, defaultTimeoutMs = DEFAULT_WAIT_TIMEOUT_MS) {
+  return cmd.option("--async", "Return job IDs and a resume command immediately (no polling)").option("--wait-timeout <ms>", "Max time to wait for completion", String(defaultTimeoutMs)).option(
+    "--poll-interval <ms>",
+    "Initial poll interval (backs off to 30s)",
+    String(DEFAULT_POLL_INTERVAL_MS)
+  ).option("--no-download", "Do not download outputs; print output URLs instead").option(
+    "--output <path>",
+    "Output file or directory. A path ending in / or \\, an existing directory, or a path without an extension is a directory; with several outputs, a media file name gets a per-language suffix (dub.mp4 -> dub-Spanish.mp4)"
+  ).option("--captions", "Also download the caption/subtitle file when one is available").option("--no-thumb", "Skip downloading the video thumbnail").option("--json", "Print a JSON summary instead of human-readable output").option("-v, --verbose", "Verbose logging");
+}
+var VIDEO_EXTS = /* @__PURE__ */ new Set(["mp4", "webm", "mov"]);
+var AUDIO_EXTS = /* @__PURE__ */ new Set(["mp3", "wav", "m4a", "aac"]);
+var MEDIA_EXTS = /* @__PURE__ */ new Set([...VIDEO_EXTS, ...AUDIO_EXTS]);
+var OUTPUT_EXTS = /* @__PURE__ */ new Set([...MEDIA_EXTS, "srt", "vtt"]);
+function inferExtension(url, fallback) {
+  try {
+    const ext = path32.extname(new URL(url).pathname).slice(1).toLowerCase();
+    return OUTPUT_EXTS.has(ext) ? ext : fallback;
+  } catch {
+    return fallback;
+  }
+}
+function safeSlug(value) {
+  return value.replace(/[^A-Za-z0-9_-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40) || "out";
+}
+var MAX_REDIRECTS = 5;
+var isRedirect = (status) => [301, 302, 303, 307, 308].includes(status);
+async function downloadHttpsOnly(url, dest, timeoutMs) {
+  const signal = AbortSignal.timeout(timeoutMs);
+  let current = url;
+  for (let hop = 0; ; hop++) {
+    if (!isHttpsUrl(current)) {
+      throw new HttpError(0, "refusing to follow a redirect to a non-https URL", current);
+    }
+    let response;
+    try {
+      response = await globalThis.fetch(current, { signal, redirect: "manual" });
+    } catch (cause) {
+      throw new HttpError(0, cause instanceof Error ? cause.message : String(cause), current);
+    }
+    if (response.url && !isHttpsUrl(response.url)) {
+      await response.body?.cancel();
+      throw new HttpError(0, "redirected to a non-https URL", response.url);
+    }
+    const location = response.headers.get("location");
+    if (isRedirect(response.status) && location) {
+      await response.body?.cancel();
+      if (hop >= MAX_REDIRECTS) throw new HttpError(0, "too many redirects", url);
+      current = new URL(location, current).href;
+      continue;
+    }
+    if (!response.ok) throw new HttpError(response.status, "(download failed)", current);
+    if (!response.body) throw new HttpError(0, "Response body is null", current);
+    fs29.mkdirSync(path32.dirname(dest), { recursive: true });
+    const fileStream = fs29.createWriteStream(dest);
+    try {
+      await pipeline2(response.body, fileStream);
+    } catch (err2) {
+      if (!fileStream.closed) await once2(fileStream, "close");
+      throw err2;
+    }
+    return;
+  }
+}
+async function downloadOutput(url, dest, resumeHint) {
+  if (!url) {
+    throw new ValidationError(`HeyGen reported success but returned no output URL. ${resumeHint}`);
+  }
+  if (!isHttpsUrl(url)) {
+    throw new ValidationError(
+      `Refusing to download HeyGen output from a non-https URL (${redactUrl(url)})`
+    );
+  }
+  const tmp = `${dest}.${process.pid}-${Date.now()}.part`;
+  try {
+    await downloadHttpsOnly(url, tmp, 6e5);
+    fs29.renameSync(tmp, dest);
+  } catch (e) {
+    fs29.rmSync(tmp, { force: true });
+    const status = e instanceof HttpError ? e.status : 0;
+    const expired = status === 403 || status === 404 || status === 410;
+    const reason = e instanceof Error ? e.message : String(e);
+    throw new ValidationError(
+      `Failed to download HeyGen output from ${redactUrl(url)}: ${reason}.${expired ? " The signed URL may have expired." : ""} ${resumeHint}`
+    );
+  }
+  return dest;
+}
+function defaultOutputPath(state, ext) {
+  const lang = state.outputLanguage ? `-${safeSlug(state.outputLanguage)}` : "";
+  return path32.join(getOutputDir(), `heygen-${state.kind}${lang}-${safeSlug(state.id)}.${ext}`);
+}
+function statOrUndefined(p) {
+  try {
+    return fs29.statSync(p);
+  } catch {
+    return void 0;
+  }
+}
+function isDirectoryOutput2(output, target) {
+  if (/[\\/]$/.test(output)) return true;
+  const stat = statOrUndefined(target);
+  if (stat) return stat.isDirectory();
+  return path32.extname(target) === "";
+}
+function withMediaExt(file, ext) {
+  const given = path32.extname(file).slice(1).toLowerCase();
+  const mismatch = VIDEO_EXTS.has(given) && AUDIO_EXTS.has(ext) || AUDIO_EXTS.has(given) && VIDEO_EXTS.has(ext);
+  return mismatch ? `${file.slice(0, -(given.length + 1))}.${ext}` : file;
+}
+function outputPathFor(state, ext, output, count) {
+  if (!output) return defaultOutputPath(state, ext);
+  const target = path32.resolve(output);
+  const givenExt = path32.extname(target);
+  const isTemplate = count > 1 && MEDIA_EXTS.has(givenExt.slice(1).toLowerCase());
+  if (isDirectoryOutput2(output, target) || count > 1 && !isTemplate) {
+    fs29.mkdirSync(target, { recursive: true });
+    return path32.join(target, path32.basename(defaultOutputPath(state, ext)));
+  }
+  if (!isTemplate) return withMediaExt(target, ext);
+  const base = path32.basename(target, givenExt);
+  const suffix = safeSlug(state.outputLanguage ?? state.id);
+  return withMediaExt(path32.join(path32.dirname(target), `${base}-${suffix}${givenExt}`), ext);
+}
+function claimPath(dest, state, used) {
+  const ext = path32.extname(dest);
+  const stem = dest.slice(0, dest.length - ext.length);
+  let candidate = dest;
+  for (let n = 1; used.has(candidate.toLowerCase()); n++) {
+    const id = safeSlug(state.id);
+    candidate = n === 1 ? `${stem}-${id}${ext}` : `${stem}-${id}-${n}${ext}`;
+  }
+  used.add(candidate.toLowerCase());
+  return candidate;
+}
+function captionPathFor(dest, capExt) {
+  const stem = path32.join(path32.dirname(dest), path32.basename(dest, path32.extname(dest)));
+  const capDest = `${stem}.${capExt}`;
+  return capDest.toLowerCase() === dest.toLowerCase() ? `${stem}.captions.${capExt}` : capDest;
+}
+var downloadThumbHttpsOnly = (url, dest) => downloadHttpsOnly(url, dest, 12e4);
+function summarizeState(state) {
+  const out = {
+    kind: state.kind,
+    id: state.id,
+    status: state.status
+  };
+  if (state.sessionId) out.session_id = state.sessionId;
+  if (state.sessionStatus) out.session_status = state.sessionStatus;
+  if (state.videoId) out.video_id = state.videoId;
+  if (state.progress !== void 0) out.progress = state.progress;
+  if (state.outputLanguage) out.output_language = state.outputLanguage;
+  if (state.outputUrl) out.output_url = redactUrl(state.outputUrl);
+  if (state.captionedVideoUrl) out.captioned_video_url = redactUrl(state.captionedVideoUrl);
+  if (state.failureCode) out.failure_code = state.failureCode;
+  if (state.failureMessage) out.failure_message = state.failureMessage;
+  return out;
+}
+async function deliverOne(state, opts, count, logger, files, usedPaths) {
+  const hint = `Refresh with: ${resumeCommand2(state.kind, state.id, opts)}`;
+  if (opts.download === false) {
+    if (!state.outputUrl) {
+      throw new ValidationError(`No output URL for ${state.kind} ${state.id}. ${hint}`);
+    }
+    if (!opts.json) console.log(state.outputUrl);
+    const urls = {
+      output_url: state.outputUrl,
+      ...state.captionUrl ? { caption_url: state.captionUrl } : {}
+    };
+    return { state, files, urls };
+  }
+  const ext = inferExtension(state.outputUrl ?? "", state.outputIsAudio ? "mp3" : "mp4");
+  const dest = claimPath(outputPathFor(state, ext, opts.output, count), state, usedPaths);
+  await downloadOutput(state.outputUrl, dest, hint);
+  logger.success(`Saved ${dest}`);
+  files.push(dest);
+  if (opts.captions && state.captionUrl) {
+    const capExt = inferExtension(state.captionUrl, "srt");
+    const capDest = claimPath(captionPathFor(dest, capExt), state, usedPaths);
+    await downloadOutput(state.captionUrl, capDest, hint);
+    logger.success(`Saved ${capDest}`);
+    files.push(capDest);
+  } else if (opts.captions) {
+    logger.warn(`No caption file available for ${state.kind} ${state.id}`);
+  }
+  if ((state.kind === "video" || state.kind === "agent") && opts.thumb !== false) {
+    const thumbUrl = detectThumbUrl(state.raw);
+    if (thumbUrl && !isHttpsUrl(thumbUrl)) {
+      logger.warn(`Skipping thumbnail from a non-https URL (${redactUrl(thumbUrl)})`);
+    } else {
+      const thumb = await maybeDownloadThumb(state.raw, dest, {
+        logger,
+        download: downloadThumbHttpsOnly
+      });
+      if (thumb) files.push(thumb);
+    }
+  }
+  return { state, files };
+}
+async function deliverOutputs(states, opts, logger) {
+  const finished = [];
+  const failures = [];
+  const usedPaths = /* @__PURE__ */ new Set();
+  for (const state of states) {
+    const files = [];
+    try {
+      finished.push(await deliverOne(state, opts, states.length, logger, files, usedPaths));
+    } catch (e) {
+      failures.push(`${state.kind} ${state.id}: ${e instanceof Error ? e.message : String(e)}`);
+      if (files.length > 0) finished.push({ state, files });
+    }
+  }
+  return { finished, failures };
+}
+function printFinished(results, opts) {
+  if (opts.json) {
+    const jobs = results.map((r) => ({ ...summarizeState(r.state), ...r.urls, files: r.files }));
+    if (jobs.length > 0) console.log(JSON.stringify(jobs.length === 1 ? jobs[0] : jobs, null, 2));
+    return;
+  }
+  for (const r of results) {
+    for (const f of r.files) console.log(`Saved: ${f}`);
+  }
+}
+function printSubmitted(kind, ids, opts) {
+  if (opts.json) {
+    const jobs = ids.map((id) => ({
+      kind,
+      id,
+      status: "submitted",
+      resume: resumeCommand2(kind, id, opts)
+    }));
+    console.log(JSON.stringify(jobs.length === 1 ? jobs[0] : jobs, null, 2));
+    return;
+  }
+  for (const id of ids) {
+    console.log(`Submitted ${kind} job: ${id}`);
+    console.log(`  Resume with: ${resumeCommand2(kind, id, opts)}`);
+  }
+}
+async function completeJobs(client, kind, ids, opts, logger) {
+  if (!Array.isArray(ids) || ids.length === 0 || ids.some((id) => typeof id !== "string" || !id)) {
+    throw new ValidationError(`HeyGen returned no usable ${kind} job ID`);
+  }
+  if (opts.async) {
+    printSubmitted(kind, ids, opts);
+    return [];
+  }
+  const timeoutMs = parsePositiveInt(opts.waitTimeout, "--wait-timeout", DEFAULT_WAIT_TIMEOUT_MS);
+  const intervalMs = parsePositiveInt(
+    opts.pollInterval,
+    "--poll-interval",
+    DEFAULT_POLL_INTERVAL_MS
+  );
+  logger.info(
+    `Waiting for ${ids.length > 1 ? `${ids.length} ${kind} jobs` : `${kind} ${ids[0]}`}...`
+  );
+  const settled = await Promise.allSettled(
+    ids.map(
+      (id, index) => waitForJob(client, kind, id, {
+        timeoutMs,
+        intervalMs,
+        startDelayMs: staggerOffsetMs(index, intervalMs),
+        maxIntervalMs: Math.max(intervalMs, 3e4),
+        burnCaptions: opts.burnCaptions,
+        resumeHint: `Resume with: ${resumeCommand2(kind, id, opts)}`,
+        onPoll: (s, attempt) => logger.debug(
+          `${kind} ${id} poll #${attempt}: ${s.status}${s.videoId ? ` (video ${s.videoId})` : ""}`
+        )
+      })
+    )
+  );
+  const states = [];
+  const failures = [];
+  for (const [i, r] of settled.entries()) {
+    if (r.status === "fulfilled") {
+      if (r.value.succeeded) states.push(r.value);
+      else {
+        try {
+          assertJobSucceeded(r.value);
+        } catch (e) {
+          failures.push(e instanceof Error ? e.message : String(e));
         }
       }
-      formatResults(results, opts.format, opts.output);
-      cleanup();
-      const failed = results.filter((r) => r.status === "error").length;
-      if (failed > 0) process.exit(1);
+    } else {
+      const err2 = r.reason;
+      const msg = err2 instanceof Error ? err2.message : String(err2);
+      failures.push(err2 instanceof PollTimeoutError ? msg : `${kind} ${ids[i]}: ${msg}`);
+    }
+  }
+  const delivery = states.length > 0 ? await deliverOutputs(states, opts, logger) : { finished: [], failures: [] };
+  failures.push(...delivery.failures);
+  printFinished(delivery.finished, opts);
+  if (failures.length > 0) {
+    const total = ids.length;
+    const ok2 = total - failures.length;
+    const header = total > 1 ? `${ok2} of ${total} ${kind} jobs delivered; ${failures.length} failed:
+` : "";
+    throw new HeygenJobFailedError(`${header}${failures.join("\n")}`);
+  }
+  return delivery.finished;
+}
+
+// src/providers/heygen/commands/catalog.ts
+function pageLimit(raw, max) {
+  return numberInRange(raw, "--limit", 1, max, true);
+}
+function printTable(page, columns) {
+  if (page.items.length === 0) {
+    console.log("No results.");
+  } else {
+    const cells = page.items.map(
+      (row) => columns.map(([, get]) => {
+        const v = get(row);
+        return Array.isArray(v) ? v.join(",") : v === null || v === void 0 ? "-" : String(v);
+      })
+    );
+    const widths = columns.map(
+      ([h], i) => Math.min(48, Math.max(h.length, ...cells.map((c2) => (c2[i] ?? "").length)))
+    );
+    const fmt = (vals) => vals.map((v, i) => v.padEnd(widths[i] ?? 0)).join("  ").trimEnd();
+    console.log(fmt(columns.map(([h]) => h)));
+    for (const c2 of cells) console.log(fmt(c2));
+  }
+  if (page.hasMore && page.nextToken) console.log(`
+More results: --cursor ${page.nextToken}`);
+}
+function printPage(page, json, columns) {
+  if (json) {
+    console.log(
+      JSON.stringify(
+        { data: page.items, has_more: page.hasMore, next_token: page.nextToken },
+        null,
+        2
+      )
+    );
+  } else {
+    printTable(page, columns);
+  }
+}
+function registerHeygenCatalogCommands(parent) {
+  parent.command("avatars").description(
+    "List avatar looks (the look ID is the --avatar for videos); --groups lists characters instead"
+  ).option("--groups", "List avatar groups (characters) instead of looks").option("--group <group-id>", "Only looks in this avatar group").option("--type <t>", `Look type: ${AVATAR_TYPES.join(" | ")}`).option("--ownership <o>", "public (presets) | private (yours)").option("--limit <n>", `Page size (1-${LIMITS.avatarListMax})`).option("--cursor <token>", "Next-page cursor from a previous call").option("--json", "Print JSON").action(
+    async (opts) => {
+      const ownership = oneOf(opts.ownership, OWNERSHIP_VALUES, "--ownership");
+      const avatarType = oneOf(opts.type, AVATAR_TYPES, "--type");
+      const limit = pageLimit(opts.limit, LIMITS.avatarListMax);
+      const client = createHeygenClientFromEnv();
+      if (opts.groups) {
+        const page2 = await client.listAvatarGroups({ ownership, limit, token: opts.cursor });
+        printPage(page2, opts.json, [
+          ["GROUP_ID", (g) => g.id],
+          ["NAME", (g) => g.name],
+          ["LOOKS", (g) => g.looks_count],
+          ["GENDER", (g) => g.gender],
+          ["DEFAULT_VOICE", (g) => g.default_voice_id]
+        ]);
+        if (!opts.json)
+          console.log("\nUse `heygen avatars --group <GROUP_ID>` to list its looks.");
+        return;
+      }
+      const page = await client.listAvatarLooks({
+        group_id: opts.group,
+        avatar_type: avatarType,
+        ownership,
+        limit,
+        token: opts.cursor
+      });
+      printPage(page, opts.json, [
+        ["LOOK_ID", (l) => l.id],
+        ["NAME", (l) => l.name],
+        ["TYPE", (l) => l.avatar_type],
+        ["GROUP_ID", (l) => l.group_id],
+        ["ENGINES", (l) => l.supported_api_engines],
+        ["DEFAULT_VOICE", (l) => l.default_voice_id]
+      ]);
+    }
+  );
+  parent.command("voices").description("List voices (voice_id for `heygen video`, `video-agent`, and `tts`)").option("--language <name>", "Filter by language, e.g. English").option("--gender <g>", "male | female").option("--engine <e>", "Filter by engine, e.g. starfish | orca | elevenlabs").option("--type <t>", "public (default) | private (your cloned voices)").option("--limit <n>", `Page size (1-${LIMITS.voiceListMax})`).option("--cursor <token>", "Next-page cursor from a previous call").option("--json", "Print JSON").action(
+    async (opts) => {
+      const type = oneOf(opts.type, OWNERSHIP_VALUES, "--type");
+      const limit = pageLimit(opts.limit, LIMITS.voiceListMax);
+      const client = createHeygenClientFromEnv();
+      const page = await client.listVoices({
+        language: opts.language,
+        gender: opts.gender,
+        engine: opts.engine,
+        type,
+        limit,
+        token: opts.cursor
+      });
+      printPage(page, opts.json, [
+        ["VOICE_ID", (v) => v.voice_id],
+        ["NAME", (v) => v.name],
+        ["LANGUAGE", (v) => v.language],
+        ["GENDER", (v) => v.gender],
+        ["ENGINES", (v) => v.available_engines]
+      ]);
     }
   );
+  parent.command("styles").description("List Video Agent visual styles (style_id for `heygen video-agent --style`)").option("--tag <tag>", "Filter by tag, e.g. cinematic").option("--limit <n>", `Page size (1-${LIMITS.stylesListMax})`).option("--cursor <token>", "Next-page cursor from a previous call").option("--json", "Print JSON").action(async (opts) => {
+    const limit = pageLimit(opts.limit, LIMITS.stylesListMax);
+    const client = createHeygenClientFromEnv();
+    const page = await client.listVideoAgentStyles({ tag: opts.tag, limit, token: opts.cursor });
+    printPage(page, opts.json, [
+      ["STYLE_ID", (s) => s.style_id],
+      ["NAME", (s) => s.name],
+      ["TAGS", (s) => s.tags],
+      ["ASPECT", (s) => s.aspect_ratio]
+    ]);
+  });
+  parent.command("languages").description("List supported video translation target languages").option("--json", "Print JSON").action(async (opts) => {
+    const client = createHeygenClientFromEnv();
+    const languages = await client.listTranslationLanguages();
+    if (opts.json) console.log(JSON.stringify(languages, null, 2));
+    else for (const l of languages) console.log(l);
+  });
+  parent.command("me").description("Show the HeyGen account for the API key (billing type, API credits/balance)").option("--json", "Print JSON").action(async (opts) => {
+    const client = createHeygenClientFromEnv();
+    const me = await client.getCurrentUser();
+    if (opts.json) {
+      console.log(JSON.stringify(me, null, 2));
+      return;
+    }
+    const name = [me.first_name, me.last_name].filter(Boolean).join(" ") || me.username || "-";
+    console.log(`User:         ${name}`);
+    if (me.billing_type) console.log(`Billing type: ${me.billing_type}`);
+    for (const key of ["wallet", "subscription", "usage_based"]) {
+      if (me[key] !== void 0 && me[key] !== null) {
+        console.log(`${key}: ${JSON.stringify(me[key])}`);
+      }
+    }
+  });
 }
 
-// src/providers/gemini/commands/index.ts
-function registerGeminiCommands(program2) {
-  const gemini = program2.command("gemini").description(
-    "Gemini: analyze, transcribe, extract data, generate images (Imagen/Nano Banana), video (Veo), and speech (Flash TTS)"
+// src/providers/heygen/commands/lipsync.ts
+init_errors();
+function registerHeygenLipsyncCommand(parent) {
+  const cmd = parent.command("lipsync").description(
+    "Lip-sync an existing video to new audio (refs: https:// URL, asset:<id>, or file)"
+  ).requiredOption("--video <ref>", "Source video").requiredOption("--audio <ref>", "Replacement audio").option("--mode <m>", "speed (default) | precision").option("--keep-format", "Preserve source resolution/bitrate").option("--no-dynamic-duration", "Disable dynamic duration adjustment").option("--disable-music", "Remove the background music track").option("--enhance-speech", "Enhance speech quality").option("--start <s>", "Start time in seconds").option("--end <s>", "End time in seconds").option("--title <text>", "Job title").option("--folder <id>", "Destination folder ID").option("--callback-url <url>", "HTTPS webhook URL notified on completion").option("--callback-id <id>", "Caller ID echoed in the webhook payload");
+  addWaitOptions(cmd).action(async (opts) => {
+    const logger = createLogger({ verbose: opts.verbose ?? false });
+    const mode = qualityMode(opts.mode);
+    const start = numberInRange(opts.start, "--start", 0, Number.MAX_SAFE_INTEGER);
+    const end = numberInRange(opts.end, "--end", 0, Number.MAX_SAFE_INTEGER);
+    if (start !== void 0 && end !== void 0 && end <= start) {
+      throw new ValidationError("--end must be greater than --start");
+    }
+    const callbackUrl = checkCallback(opts.callbackUrl);
+    const client = createHeygenClientFromEnv();
+    const body = {
+      video: await resolveMediaInput(client, opts.video, logger),
+      audio: await resolveMediaInput(client, opts.audio, logger)
+    };
+    if (mode) body.mode = mode;
+    if (opts.keepFormat) body.keep_the_same_format = true;
+    if (opts.dynamicDuration === false) body.enable_dynamic_duration = false;
+    if (opts.disableMusic) body.disable_music_track = true;
+    if (opts.enhanceSpeech) body.enable_speech_enhancement = true;
+    if (start !== void 0) body.start_time = start;
+    if (end !== void 0) body.end_time = end;
+    if (opts.title) body.title = opts.title;
+    if (opts.folder) body.folder_id = opts.folder;
+    if (callbackUrl) body.callback_url = callbackUrl;
+    if (opts.callbackId) body.callback_id = opts.callbackId;
+    logger.info("Submitting lipsync...");
+    const created = await client.createLipsync(body);
+    await completeJobs(client, "lipsync", [created.lipsync_id], opts, logger);
+  });
+}
+
+// src/providers/heygen/commands/model-video.ts
+var PENDING = { type: "asset_id", asset_id: "pending" };
+var pending = (refs) => (refs ?? []).map(() => PENDING);
+function registerHeygenModelVideoCommand(parent) {
+  const cmd = parent.command("model-video <prompt>").description(
+    "HeyGen Video model (heygen-video-1): 5-15 s scene with audio from a prompt (not an avatar video)"
+  ).option("--mode <m>", "text_to_video | image_to_video | reference_to_video (inferred)").option("--image <ref>", "First frame for image_to_video: https:// URL, asset:<id>, or file").option("--reference-image <ref>", "Reference image (repeatable, max 9)", collect5).option("--reference-video <ref>", "Reference video (repeatable, max 3)", collect5).option("--reference-audio <ref>", "Reference audio (repeatable, max 3)", collect5).option("--duration <s>", "Clip length 5-15 seconds").option("--resolution <r>", "480p | 768p | 1080p | 2k").option("--aspect-ratio <r>", "21:9 | 16:9 | 4:3 | 1:1 | 3:4 | 9:16 | adaptive").option("--prompt-enhancement <p>", "turbo | quality | disabled").option("--seed <n>", "Seed for repeatable output").option("--callback-url <url>", "HTTPS webhook URL notified on completion").option("--callback-id <id>", "Caller ID echoed in the webhook payload");
+  addWaitOptions(cmd).action(async (prompt, opts) => {
+    const logger = createLogger({ verbose: opts.verbose ?? false });
+    const input = {
+      prompt,
+      mode: opts.mode,
+      duration: opts.duration,
+      resolution: opts.resolution,
+      aspectRatio: opts.aspectRatio,
+      promptEnhancement: opts.promptEnhancement,
+      seed: opts.seed,
+      callbackUrl: opts.callbackUrl,
+      callbackId: opts.callbackId
+    };
+    buildModelVideoRequest({
+      ...input,
+      image: opts.image ? PENDING : void 0,
+      referenceImages: pending(opts.referenceImage),
+      referenceVideos: pending(opts.referenceVideo),
+      referenceAudio: pending(opts.referenceAudio)
+    });
+    const client = createHeygenClientFromEnv();
+    if (opts.image) input.image = await resolveMediaInput(client, opts.image, logger);
+    input.referenceImages = await resolveMediaInputs(client, opts.referenceImage, logger);
+    input.referenceVideos = await resolveMediaInputs(client, opts.referenceVideo, logger);
+    input.referenceAudio = await resolveMediaInputs(client, opts.referenceAudio, logger);
+    const body = buildModelVideoRequest(input);
+    logger.info(`Submitting HeyGen Video (${body.mode})...`);
+    const created = await client.createModelVideo(body);
+    await completeJobs(client, "model-video", [created.video_id], opts, logger);
+  });
+}
+
+// src/providers/heygen/commands/run.ts
+init_errors();
+import path33 from "path";
+function extractJobIds(operation, data) {
+  const op = HEYGEN_OPERATIONS[operation];
+  if (!op) return [];
+  if (op.idsField) {
+    const ids = data[op.idsField];
+    return Array.isArray(ids) ? ids.filter((x) => typeof x === "string" && !!x) : [];
+  }
+  const id = op.idField ? data[op.idField] : void 0;
+  return typeof id === "string" && id ? [id] : [];
+}
+function registerHeygenRunCommand(parent) {
+  const names = Object.keys(HEYGEN_OPERATIONS);
+  const cmd = parent.command("run <operation>").description(`Send a raw v3 payload to a documented create operation: ${names.join(", ")}`).requiredOption("--input <json>", "Request body, inline JSON or @path/to/payload.json");
+  addWaitOptions(cmd).action(async (operation, opts) => {
+    const logger = createLogger({ verbose: opts.verbose ?? false });
+    const op = HEYGEN_OPERATIONS[operation];
+    if (!op) {
+      throw new ValidationError(
+        `Unknown operation "${operation}". Supported: ${names.map((n) => `${n} (${HEYGEN_OPERATIONS[n]?.description})`).join("; ")}`
+      );
+    }
+    const body = parseJsonInput(opts.input);
+    const client = createHeygenClientFromEnv();
+    logger.info(`Calling ${op.description}...`);
+    const json = await client.send(op.path, {
+      method: "POST",
+      body,
+      idempotencyKey: op.idempotent
+    });
+    const data = unwrapData(json, op.path);
+    if (op.kind === null) {
+      const audioUrl = typeof data.audio_url === "string" ? data.audio_url : void 0;
+      if (opts.download === false || !audioUrl) {
+        console.log(JSON.stringify(data, null, 2));
+        return;
+      }
+      const ext = inferExtension(audioUrl, "mp3");
+      const dest = opts.output ? path33.resolve(opts.output) : path33.join(getOutputDir(), `heygen-speech-${Date.now()}.${ext}`);
+      await downloadOutput(audioUrl, dest, "Re-run the command to generate a fresh URL.");
+      console.log(`Saved: ${dest}`);
+      return;
+    }
+    const ids = extractJobIds(operation, data);
+    if (ids.length === 0) {
+      throw new ValidationError(
+        `HeyGen response for ${operation} had no job ID: ${JSON.stringify(data).slice(0, 300)}`
+      );
+    }
+    await completeJobs(client, op.kind, ids, opts, logger);
+  });
+}
+
+// src/providers/heygen/commands/status.ts
+function registerHeygenStatusCommand(parent) {
+  parent.command("status <id>").description("Check (or wait for and download) a HeyGen job by ID").option(
+    "--type <type>",
+    "agent (session ID) | video | translation | lipsync | model-video",
+    "video"
+  ).option("--wait", "Poll until the job finishes").option("--download", "Download the output when complete (implies --wait)").option("--wait-timeout <ms>", "Max time to wait", "1800000").option(
+    "--poll-interval <ms>",
+    "Initial poll interval (backs off to 30s)",
+    String(DEFAULT_POLL_INTERVAL_MS)
+  ).option("--output <path>", "Output file path (with --download)").option("--captions", "Also download the caption/subtitle file when available").option(
+    "--burn-captions",
+    "Video: use the burned-in caption render (captioned_video_url); fails if absent"
+  ).option("--no-thumb", "Skip downloading the video thumbnail").option("--json", "Print a JSON summary").option("--raw", "Print the raw API payload (includes signed URLs) instead of the summary").option("-v, --verbose", "Verbose logging").action(async (id, opts) => {
+    const logger = createLogger({ verbose: opts.verbose ?? false });
+    const kind = oneOf(opts.type, JOB_KINDS, "--type") ?? "video";
+    const client = createHeygenClientFromEnv();
+    if (opts.download) {
+      await completeJobs(client, kind, [id], { ...opts, async: false, download: true }, logger);
+      return;
+    }
+    const read = { burnCaptions: opts.burnCaptions };
+    const state = opts.wait ? await waitForJob(client, kind, id, {
+      ...read,
+      timeoutMs: parsePositiveInt(
+        opts.waitTimeout,
+        "--wait-timeout",
+        DEFAULT_WAIT_TIMEOUT_MS
+      ),
+      intervalMs: parsePositiveInt(
+        opts.pollInterval,
+        "--poll-interval",
+        DEFAULT_POLL_INTERVAL_MS
+      ),
+      resumeHint: `Resume with: ${resumeCommand2(kind, id, read)}`
+    }) : await getJobState(client, kind, id, read);
+    console.log(JSON.stringify(opts.raw ? state.raw : summarizeState(state), null, 2));
+    if (state.done) assertJobSucceeded(state);
+    else if (!opts.json) logger.info(`Still ${state.status}. Re-run with --wait to poll.`);
+  });
+}
+
+// src/providers/heygen/commands/template.ts
+init_errors();
+function templateBody(input, title) {
+  const body = "variables" in input ? { ...input } : { variables: input };
+  const vars = body.variables;
+  if (vars === null || typeof vars !== "object" || Array.isArray(vars)) {
+    throw new ValidationError("Template input must contain a `variables` object");
+  }
+  if (title) body.title = title;
+  return body;
+}
+function registerHeygenTemplateCommand(parent) {
+  const cmd = parent.command("template <template-id>").description("Generate a video from a HeyGen Studio template by filling its variables").requiredOption(
+    "--input <json>",
+    "Variables map or full request body, inline JSON or @path/to/vars.json"
+  ).option("--title <text>", "Video title");
+  addWaitOptions(cmd).action(async (templateId, opts) => {
+    const logger = createLogger({ verbose: opts.verbose ?? false });
+    const body = templateBody(parseJsonInput(opts.input), opts.title);
+    const client = createHeygenClientFromEnv();
+    logger.info(`Generating from template ${templateId}...`);
+    const video = await client.generateFromTemplate(templateId, body);
+    await completeJobs(client, "video", [video.id], opts, logger);
+  });
+}
+
+// src/providers/heygen/commands/translate.ts
+init_errors();
+function registerHeygenTranslateCommand(parent) {
+  const cmd = parent.command("translate <source>").description(
+    "Translate a video (voice clone + lip-sync). Source: https:// URL, asset:<id>, or local file"
+  ).requiredOption(
+    "--languages <list>",
+    'Comma-separated target language names from `heygen languages`, e.g. "Spanish (Spain),English"'
+  ).option("--mode <m>", "speed (default) | precision (higher lip-sync quality)").option("--input-language <code>", "Source language (auto-detected when omitted)").option("--audio-only", "Translate audio only and keep the original video frames").option("--audio <ref>", "Custom dubbing audio: https:// URL, asset:<id>, or file").option("--speakers <n>", "Number of speakers (improves separation)").option("--keep-format", "Preserve source resolution/bitrate").option("--no-dynamic-duration", "Disable dynamic duration adjustment").option("--disable-music", "Remove the background music track").option("--enhance-speech", "Enhance speech quality").option("--start <s>", "Start time in seconds (partial translation)").option("--end <s>", "End time in seconds (partial translation)").option("--brand-glossary <id>", "Brand glossary ID (term translations)").option("--title <text>", "Job title").option("--folder <id>", "Destination folder ID").option("--callback-url <url>", "HTTPS webhook URL notified on completion").option("--callback-id <id>", "Caller ID echoed in the webhook payload");
+  addWaitOptions(cmd).action(async (source, opts) => {
+    const logger = createLogger({ verbose: opts.verbose ?? false });
+    const languages = splitLanguages(opts.languages);
+    const mode = qualityMode(opts.mode);
+    const speakers = numberInRange(opts.speakers, "--speakers", 1, 100, true);
+    const start = numberInRange(opts.start, "--start", 0, Number.MAX_SAFE_INTEGER);
+    const end = numberInRange(opts.end, "--end", 0, Number.MAX_SAFE_INTEGER);
+    if (start !== void 0 && end !== void 0 && end <= start) {
+      throw new ValidationError("--end must be greater than --start");
+    }
+    const callbackUrl = checkCallback(opts.callbackUrl);
+    const client = createHeygenClientFromEnv();
+    const video = await resolveMediaInput(client, source, logger);
+    const audio = opts.audio ? await resolveMediaInput(client, opts.audio, logger) : void 0;
+    const body = { video, output_languages: languages };
+    if (audio) body.audio = audio;
+    if (mode) body.mode = mode;
+    if (opts.inputLanguage) body.input_language = opts.inputLanguage;
+    if (opts.audioOnly) body.translate_audio_only = true;
+    if (speakers !== void 0) body.speaker_num = speakers;
+    if (opts.keepFormat) body.keep_the_same_format = true;
+    if (opts.dynamicDuration === false) body.enable_dynamic_duration = false;
+    if (opts.disableMusic) body.disable_music_track = true;
+    if (opts.enhanceSpeech) body.enable_speech_enhancement = true;
+    if (start !== void 0) body.start_time = start;
+    if (end !== void 0) body.end_time = end;
+    if (opts.brandGlossary) body.brand_glossary_id = opts.brandGlossary;
+    if (opts.title) body.title = opts.title;
+    if (opts.folder) body.folder_id = opts.folder;
+    if (callbackUrl) body.callback_url = callbackUrl;
+    if (opts.callbackId) body.callback_id = opts.callbackId;
+    logger.info(`Submitting translation into ${languages.length} language(s)...`);
+    const created = await client.createVideoTranslation(body);
+    await completeJobs(client, "translation", created.video_translation_ids, opts, logger);
+  });
+}
+
+// src/providers/heygen/commands/tts.ts
+import path34 from "path";
+init_redact();
+function registerHeygenTtsCommand(parent) {
+  parent.command("tts <text>").description("Text-to-speech with a HeyGen catalog voice (1-5000 characters)").requiredOption("--voice <voice-id>", "Voice ID from `heygen voices`").option("--ssml", "Treat the text as SSML").option("--speed <n>", "Speed multiplier 0.5-2.0").option("--language <code>", "Base language code, e.g. en (auto-detected when omitted)").option("--locale <tag>", "Locale tag for Starfish voices, e.g. zh-HK").option("--engine <e>", "starfish | orca | elevenlabs (defaults to the voice's engine)").option("--output <path>", "Output audio path").option("--no-download", "Print the audio URL instead of downloading").option("--json", "Print a JSON summary").option("-v, --verbose", "Verbose logging").action(async (text, opts) => {
+    const logger = createLogger({ verbose: opts.verbose ?? false });
+    const body = buildSpeechRequest({
+      text,
+      voiceId: opts.voice,
+      ssml: opts.ssml,
+      speed: opts.speed,
+      language: opts.language,
+      locale: opts.locale,
+      engine: opts.engine
+    });
+    const client = createHeygenClientFromEnv();
+    logger.info("Generating speech...");
+    const res = await client.createSpeech(body);
+    const summary = {
+      duration: res.duration,
+      engine: res.engine,
+      request_id: res.request_id ?? null,
+      audio_url: redactUrl(res.audio_url)
+    };
+    if (opts.download === false) {
+      if (opts.json)
+        console.log(JSON.stringify({ ...summary, audio_url: res.audio_url }, null, 2));
+      else console.log(res.audio_url);
+      return;
+    }
+    const ext = inferExtension(res.audio_url, "mp3");
+    const name = `heygen-tts-${res.request_id ?? Date.now()}.${ext}`.replace(/[^\w.-]+/g, "-");
+    const dest = opts.output ? path34.resolve(opts.output) : path34.join(getOutputDir(), name);
+    await downloadOutput(res.audio_url, dest, "Re-run the command to generate a fresh URL.");
+    if (opts.json) console.log(JSON.stringify({ ...summary, file: dest }, null, 2));
+    else console.log(`Saved: ${dest} (${res.duration}s, ${res.engine})`);
+  });
+}
+
+// src/providers/heygen/commands/video-agent.ts
+function registerHeygenVideoAgentCommand(parent) {
+  const cmd = parent.command("video-agent <prompt>").description(
+    "Prompt-to-video with HeyGen Video Agent (agent writes the script and picks avatar/voice/scenes)"
+  ).option("--avatar <look-id>", "Avatar look ID to feature (see `heygen avatars`)").option("--voice <voice-id>", "Narration voice ID (see `heygen voices`)").option("--style <style-id>", "Visual style ID (see `heygen styles`)").option("--brand-kit <id>", "Brand kit ID (colors, fonts, logos)").option("--brand-glossary <id>", "Brand glossary ID (pronunciations)").option("--orientation <o>", "landscape | portrait (auto-detected when omitted)").option(
+    "--file <ref>",
+    "Attachment: https:// URL, asset:<asset_id>, or local file to upload (repeatable, max 20)",
+    collect5
+  ).option("--callback-url <url>", "HTTPS webhook URL notified on completion/failure").option("--callback-id <id>", "Caller ID echoed in the webhook payload");
+  addWaitOptions(cmd).action(async (prompt, opts) => {
+    const logger = createLogger({ verbose: opts.verbose ?? false });
+    buildVideoAgentRequest({
+      prompt,
+      orientation: opts.orientation,
+      callbackUrl: opts.callbackUrl
+    });
+    const client = createHeygenClientFromEnv();
+    const files = await resolveMediaInputs(client, opts.file, logger);
+    const body = buildVideoAgentRequest({
+      prompt,
+      avatarId: opts.avatar,
+      voiceId: opts.voice,
+      styleId: opts.style,
+      brandKitId: opts.brandKit,
+      brandGlossaryId: opts.brandGlossary,
+      orientation: opts.orientation,
+      files,
+      callbackUrl: opts.callbackUrl,
+      callbackId: opts.callbackId
+    });
+    logger.info("Creating Video Agent session...");
+    const created = await client.createVideoAgent(body);
+    logger.debug(`session ${created.session_id} status=${created.status}`);
+    await completeJobs(client, "agent", [created.session_id], opts, logger);
+  });
+}
+
+// src/providers/heygen/commands/video.ts
+function toInput(script, opts) {
+  return {
+    avatarId: opts.avatar,
+    script,
+    voiceId: opts.voice,
+    resolution: opts.resolution,
+    aspectRatio: opts.aspectRatio,
+    engine: opts.engine,
+    referenceLookId: opts.referenceLook,
+    motionPrompt: opts.motionPrompt,
+    expressiveness: opts.expressiveness,
+    fit: opts.fit,
+    backgroundColor: opts.backgroundColor,
+    removeBackground: opts.removeBackground,
+    outputFormat: opts.outputFormat,
+    captions: opts.captions,
+    burnCaptions: opts.burnCaptions,
+    speed: opts.speed,
+    pitch: opts.pitch,
+    volume: opts.volume,
+    locale: opts.locale,
+    title: opts.title,
+    folderId: opts.folder,
+    brandGlossaryId: opts.brandGlossary,
+    callbackUrl: opts.callbackUrl,
+    callbackId: opts.callbackId
+  };
+}
+var PENDING_UPLOAD = { type: "asset_id", asset_id: "pending" };
+function registerHeygenVideoCommand(parent) {
+  const cmd = parent.command("video [script]").description(
+    "Scripted avatar video: your avatar look + voice speak your exact script (or lip-sync --audio)"
+  ).requiredOption("--avatar <look-id>", "Avatar look ID (from `heygen avatars`, not a group ID)").option("--voice <voice-id>", "Voice ID (defaults to the look's default voice)").option(
+    "--audio <ref>",
+    "Recorded audio instead of a script: https:// URL, asset:<id>, or file"
+  ).option("--resolution <r>", "4k | 1080p | 720p (4k: Avatar III digital twins/studio avatars)").option("--aspect-ratio <r>", "16:9 | 9:16 | 4:5 | 5:4 | 1:1 | auto", "auto").option("--engine <e>", "avatar_iv (default) | avatar_v | avatar_iii").option("--reference-look <look-id>", "Avatar V animation reference (digital_twin look)").option("--motion-prompt <text>", "Body motion/gesture prompt (photo avatars, or Avatar V)").option("--expressiveness <level>", "high | medium | low (photo avatars, Avatar IV)").option("--fit <f>", "contain | cover").option("--background-color <hex>", "Solid background color, e.g. #ffffff").option("--background-image <ref>", "Background image: https:// URL, asset:<id>, or file").option("--remove-background", "Remove the avatar background (matting-enabled avatars)").option("--output-format <f>", "mp4 (default) | webm (transparent background)").option("--burn-captions", "Burn captions into the video (subtitle file is always produced)").option("--speed <n>", "Voice speed 0.5-1.5").option("--pitch <n>", "Voice pitch -50..50 semitones").option("--volume <n>", "Voice volume 0-1").option("--locale <code>", "Voice locale hint, e.g. en-US").option("--title <text>", "Video title in the HeyGen dashboard").option("--folder <id>", "Destination folder ID").option("--brand-glossary <id>", "Brand glossary ID (pronunciations)").option("--callback-url <url>", "HTTPS webhook URL notified on completion/failure").option("--callback-id <id>", "Caller ID echoed in the webhook payload");
+  addWaitOptions(cmd).action(async (script, opts) => {
+    const logger = createLogger({ verbose: opts.verbose ?? false });
+    const input = toInput(script, opts);
+    buildAvatarVideoRequest({
+      ...input,
+      audio: opts.audio ? PENDING_UPLOAD : void 0,
+      backgroundImage: opts.backgroundImage ? PENDING_UPLOAD : void 0
+    });
+    const client = createHeygenClientFromEnv();
+    if (opts.audio) input.audio = await resolveMediaInput(client, opts.audio, logger);
+    if (opts.backgroundImage) {
+      input.backgroundImage = await resolveMediaInput(client, opts.backgroundImage, logger);
+    }
+    const body = buildAvatarVideoRequest(input);
+    logger.info("Submitting avatar video...");
+    const created = await client.createVideo(body);
+    await completeJobs(client, "video", [created.video_id], opts, logger);
+  });
+}
+
+// src/providers/heygen/commands/index.ts
+function registerHeygenCommands(program2) {
+  const heygen = program2.command("heygen").description(
+    "HeyGen v3: Video Agent prompt-to-video, scripted avatar videos, translation, lipsync, TTS"
   );
-  registerAnalyzeCommand(gemini);
-  registerTranscribeCommand2(gemini);
-  registerExtractCommand(gemini);
-  registerGenerateCommand(gemini);
-  registerGeminiImageToImageCommand(gemini);
-  registerGenerateVideoCommand(gemini);
-  registerGeminiImageToVideoCommand(gemini);
-  registerGeminiGenerateSpeechCommand(gemini);
+  registerHeygenVideoAgentCommand(heygen);
+  registerHeygenVideoCommand(heygen);
+  registerHeygenStatusCommand(heygen);
+  registerHeygenCatalogCommands(heygen);
+  registerHeygenTranslateCommand(heygen);
+  registerHeygenLipsyncCommand(heygen);
+  registerHeygenTtsCommand(heygen);
+  registerHeygenTemplateCommand(heygen);
+  registerHeygenModelVideoCommand(heygen);
+  registerHeygenRunCommand(heygen);
 }
 
 // src/providers/leonardo/commands/generate.ts
-import fs29 from "fs";
-import path32 from "path";
+import fs30 from "fs";
+import path35 from "path";
 
 // src/providers/leonardo/client.ts
 init_errors();
@@ -6039,11 +7968,11 @@ var LeonardoClient = class {
   }
   apiKey;
   baseUrl;
-  async request(path54, opts = {}) {
+  async request(path57, opts = {}) {
     const base = this.baseUrl.replace(/\/$/, "");
-    const v2Override = path54.startsWith("v2:");
+    const v2Override = path57.startsWith("v2:");
     const finalBase = v2Override ? base.replace(/\/v1$/, "/v2") : base;
-    const finalPath = v2Override ? path54.slice(3) : path54;
+    const finalPath = v2Override ? path57.slice(3) : path57;
     const url = new URL(finalBase + finalPath);
     if (opts.query) {
       for (const [k, v] of Object.entries(opts.query)) {
@@ -6062,14 +7991,14 @@ var LeonardoClient = class {
       timeoutMs: opts.timeoutMs ?? 12e4
     });
   }
-  get(path54, query, logger) {
-    return this.request(path54, { method: "GET", query, logger });
+  get(path57, query, logger) {
+    return this.request(path57, { method: "GET", query, logger });
   }
-  post(path54, body, logger) {
-    return this.request(path54, { method: "POST", body, logger });
+  post(path57, body, logger) {
+    return this.request(path57, { method: "POST", body, logger });
   }
-  delete(path54, logger) {
-    return this.request(path54, { method: "DELETE", logger });
+  delete(path57, logger) {
+    return this.request(path57, { method: "DELETE", logger });
   }
 };
 function createLeonardoClient() {
@@ -6080,7 +8009,7 @@ function createLeonardoClient() {
 function extFromUrl2(url, fallback = ".png") {
   try {
     const u = new URL(url);
-    const e = path32.extname(u.pathname);
+    const e = path35.extname(u.pathname);
     return e.length > 0 ? e : fallback;
   } catch {
     return fallback;
@@ -6165,7 +8094,7 @@ function registerLeonardoGenerateCommand(parent) {
         if (!img) continue;
         const ext = extFromUrl2(img.url);
         const filename = autoFilename(generationId, i + 1, ext);
-        const filepath = path32.join(outDir, filename);
+        const filepath = path35.join(outDir, filename);
         try {
           await downloadFile(img.url, filepath);
           saved.push(filepath);
@@ -6175,9 +8104,9 @@ function registerLeonardoGenerateCommand(parent) {
         }
       }
       if (opts.output && saved[0]) {
-        const dest = path32.resolve(opts.output);
-        fs29.mkdirSync(path32.dirname(dest), { recursive: true });
-        fs29.copyFileSync(saved[0], dest);
+        const dest = path35.resolve(opts.output);
+        fs30.mkdirSync(path35.dirname(dest), { recursive: true });
+        fs30.copyFileSync(saved[0], dest);
         logger.success(`Copied to ${dest}`);
       }
       const finalImages = finalizeGeneratedImages(saved, { ...opts, logger });
@@ -6189,11 +8118,11 @@ Generated ${finalImages.length} image(s):`);
 }
 
 // src/providers/leonardo/commands/image-to-image.ts
-import fs30 from "fs";
-import path33 from "path";
+import fs31 from "fs";
+import path36 from "path";
 function extFromUrl3(url, fallback = ".png") {
   try {
-    return path33.extname(new URL(url).pathname) || fallback;
+    return path36.extname(new URL(url).pathname) || fallback;
   } catch {
     return fallback;
   }
@@ -6255,7 +8184,7 @@ function registerLeonardoImageToImageCommand(parent) {
         if (!img) continue;
         const ext = extFromUrl3(img.url);
         const filename = `leonardo-i2i-${generationId.slice(0, 8)}-${String(i + 1).padStart(2, "0")}${ext}`;
-        const filepath = path33.join(outDir, filename);
+        const filepath = path36.join(outDir, filename);
         try {
           await downloadFile(img.url, filepath);
           saved.push(filepath);
@@ -6265,9 +8194,9 @@ function registerLeonardoImageToImageCommand(parent) {
         }
       }
       if (opts.output && saved[0]) {
-        const dest = path33.resolve(opts.output);
-        fs30.mkdirSync(path33.dirname(dest), { recursive: true });
-        fs30.copyFileSync(saved[0], dest);
+        const dest = path36.resolve(opts.output);
+        fs31.mkdirSync(path36.dirname(dest), { recursive: true });
+        fs31.copyFileSync(saved[0], dest);
         logger.success(`Copied to ${dest}`);
       }
       const finalImages = finalizeGeneratedImages(saved, { ...opts, logger });
@@ -6279,7 +8208,7 @@ Generated ${finalImages.length} image(s):`);
 }
 
 // src/providers/leonardo/commands/video.ts
-import path34 from "path";
+import path37 from "path";
 function v2DimsFor(resolution) {
   if (resolution === "RESOLUTION_1080") return { width: 1920, height: 1080 };
   if (resolution === "RESOLUTION_480") return { width: 854, height: 480 };
@@ -6390,7 +8319,7 @@ async function pollAndDownload(client, jobId, opts) {
     logger.error(`No video URL in completed generation: ${JSON.stringify(gen)}`);
     process.exit(1);
   }
-  const outPath = opts.output ?? path34.join(getOutputDir(), `${opts.basename}-${jobId.slice(0, 8)}.mp4`);
+  const outPath = opts.output ?? path37.join(getOutputDir(), `${opts.basename}-${jobId.slice(0, 8)}.mp4`);
   await downloadFile(videoUrl2, outPath);
   logger.success(`Saved ${outPath}`);
   await maybeDownloadThumb(gen, outPath, {
@@ -6496,7 +8425,7 @@ function registerLeonardoModelsCommand(parent) {
 }
 
 // src/providers/leonardo/commands/status.ts
-import path35 from "path";
+import path38 from "path";
 var VIDEO_KEYS = ["motionMP4URL", "url"];
 var IMAGE_EXT_RE2 = /\.(jpe?g|png|webp|gif)(\?|$)/i;
 var VIDEO_EXT_RE = /\.(mp4|webm|mov|m4v)(\?|$)/i;
@@ -6561,7 +8490,7 @@ function registerLeonardoStatusCommand(parent) {
       const outDir = getOutputDir();
       let idx = 0;
       for (const url of videos) {
-        const dest = opts.output && videos.length === 1 && images.length === 0 ? opts.output : path35.join(outDir, `leonardo-${generationId.slice(0, 8)}-${idx}.mp4`);
+        const dest = opts.output && videos.length === 1 && images.length === 0 ? opts.output : path38.join(outDir, `leonardo-${generationId.slice(0, 8)}-${idx}.mp4`);
         await downloadFile(url, dest);
         logger.success(`Saved ${dest}`);
         await maybeDownloadThumb(gen, dest, {
@@ -6574,7 +8503,7 @@ function registerLeonardoStatusCommand(parent) {
       for (const url of images) {
         const m = url.match(IMAGE_EXT_RE2);
         const ext = m?.[1] ? m[1].toLowerCase().replace("jpeg", "jpg") : "png";
-        const dest = path35.join(outDir, `leonardo-${generationId.slice(0, 8)}-${idx}.${ext}`);
+        const dest = path38.join(outDir, `leonardo-${generationId.slice(0, 8)}-${idx}.${ext}`);
         await downloadFile(url, dest);
         logger.success(`Saved ${dest}`);
         idx++;
@@ -6731,8 +8660,8 @@ function sleep3(ms) {
 }
 
 // src/providers/minimax/generators/music.ts
-import fs31 from "fs";
-import path36 from "path";
+import fs32 from "fs";
+import path39 from "path";
 async function generateMinimaxMusic(opts) {
   const {
     apiKey,
@@ -6777,14 +8706,14 @@ async function generateMinimaxMusic(opts) {
   }
   const durationMs = resp.extra_info?.music_duration ?? 0;
   const outDir = getOutputDir();
-  const dest = path36.join(outDir, `minimax_music_${Date.now()}.${outputFormat}`);
+  const dest = path39.join(outDir, `minimax_music_${Date.now()}.${outputFormat}`);
   try {
     if (audioData.startsWith("http")) {
       const bytes = await fetchBytes(audioData);
-      fs31.writeFileSync(dest, bytes);
+      fs32.writeFileSync(dest, bytes);
     } else {
       const audioBytes = Buffer.from(audioData, "hex");
-      fs31.writeFileSync(dest, audioBytes);
+      fs32.writeFileSync(dest, audioBytes);
     }
   } catch (e) {
     return {
@@ -6795,8 +8724,8 @@ async function generateMinimaxMusic(opts) {
   const durSec = durationMs / 1e3;
   logger?.success(`Saved: ${dest} (${durSec.toFixed(1)}s)`);
   if (output) {
-    fs31.mkdirSync(path36.dirname(path36.resolve(output)), { recursive: true });
-    fs31.copyFileSync(dest, output);
+    fs32.mkdirSync(path39.dirname(path39.resolve(output)), { recursive: true });
+    fs32.copyFileSync(dest, output);
   }
   return { status: "success", generatedAudio: dest, durationMs, model };
 }
@@ -6870,8 +8799,8 @@ Generated music: ${result.generatedAudio}`);
 init_errors();
 
 // src/providers/minimax/generators/speech.ts
-import fs32 from "fs";
-import path37 from "path";
+import fs33 from "fs";
+import path40 from "path";
 async function generateMinimaxSpeech(opts) {
   const {
     apiKey,
@@ -6918,12 +8847,12 @@ async function generateMinimaxSpeech(opts) {
   const audioBytes = Buffer.from(audioHex, "hex");
   const ext = ["mp3", "wav", "flac"].includes(outputFormat) ? outputFormat : "mp3";
   const outDir = getOutputDir();
-  const dest = path37.join(outDir, `minimax_speech_${Date.now()}.${ext}`);
-  fs32.writeFileSync(dest, audioBytes);
+  const dest = path40.join(outDir, `minimax_speech_${Date.now()}.${ext}`);
+  fs33.writeFileSync(dest, audioBytes);
   logger?.success(`Saved: ${dest} (${(audioBytes.length / 1024).toFixed(1)} KB)`);
   if (output) {
-    fs32.mkdirSync(path37.dirname(path37.resolve(output)), { recursive: true });
-    fs32.copyFileSync(dest, output);
+    fs33.mkdirSync(path40.dirname(path40.resolve(output)), { recursive: true });
+    fs33.copyFileSync(dest, output);
   }
   return { status: "success", generatedAudio: dest, model };
 }
@@ -6970,8 +8899,8 @@ Generated audio: ${result.generatedAudio}`);
 init_errors();
 
 // src/providers/minimax/generators/video.ts
-import fs33 from "fs";
-import path38 from "path";
+import fs34 from "fs";
+import path41 from "path";
 async function generateMinimaxVideo(opts) {
   const {
     apiKey,
@@ -7017,18 +8946,18 @@ async function generateMinimaxVideo(opts) {
     return { status: "error", error: `No file_id in poll result: ${JSON.stringify(pollResult)}` };
   }
   const outDir = getOutputDir();
-  const dest = path38.join(outDir, `minimax_video_${Date.now()}.mp4`);
+  const dest = path41.join(outDir, `minimax_video_${Date.now()}.mp4`);
   try {
     await downloadMinimaxFile(fileId, apiKey, dest, logger);
   } catch (e) {
     return { status: "error", error: e instanceof Error ? e.message : String(e) };
   }
   const elapsed = (Date.now() - start) / 1e3;
-  const stat = fs33.statSync(dest);
+  const stat = fs34.statSync(dest);
   const fileSizeMb = stat.size / (1024 * 1024);
   if (output) {
-    fs33.mkdirSync(path38.dirname(path38.resolve(output)), { recursive: true });
-    fs33.copyFileSync(dest, output);
+    fs34.mkdirSync(path41.dirname(path41.resolve(output)), { recursive: true });
+    fs34.copyFileSync(dest, output);
   }
   await maybeDownloadThumb(pollResult, dest, {
     skip: thumb === false,
@@ -7090,8 +9019,8 @@ Generated video: ${result.generatedVideo}`);
 
 // src/providers/minimax/generators/image.ts
 init_errors();
-import fs34 from "fs";
-import path39 from "path";
+import fs35 from "fs";
+import path42 from "path";
 async function generateMinimaxImage(opts) {
   const {
     apiKey,
@@ -7129,8 +9058,8 @@ async function generateMinimaxImage(opts) {
     try {
       const bytes = await fetchBytes(url);
       const fname = `minimax_image_${Date.now()}_${i}.png`;
-      const dest = path39.join(outDir, fname);
-      fs34.writeFileSync(dest, bytes);
+      const dest = path42.join(outDir, fname);
+      fs35.writeFileSync(dest, bytes);
       savedFiles.push(dest);
       logger?.success(`Saved: ${dest}`);
     } catch (e) {
@@ -7141,8 +9070,8 @@ async function generateMinimaxImage(opts) {
     }
   }
   if (output && savedFiles[0]) {
-    fs34.mkdirSync(path39.dirname(path39.resolve(output)), { recursive: true });
-    fs34.copyFileSync(savedFiles[0], output);
+    fs35.mkdirSync(path42.dirname(path42.resolve(output)), { recursive: true });
+    fs35.copyFileSync(savedFiles[0], output);
   }
   return { status: "success", generatedImages: savedFiles, model };
 }
@@ -7181,8 +9110,8 @@ Generated ${finalImages.length} image(s):`);
 
 // src/providers/minimax/commands/image-to-image.ts
 init_errors();
-import fs35 from "fs";
-import path40 from "path";
+import fs36 from "fs";
+import path43 from "path";
 function registerMinimaxImageToImageCommand(parent) {
   parent.command("image-to-image").alias("i2i").description(
     "MiniMax character/subject preservation. CAVEAT: NOT free-form image editing \u2014 the --ref image is used only as a character/face reference for a NEW scene described by --prompt."
@@ -7237,8 +9166,8 @@ function registerMinimaxImageToImageCommand(parent) {
         if (!url) continue;
         try {
           const bytes = await fetchBytes(url);
-          const dest = path40.join(outDir, `minimax-i2i-${ts}-${i + 1}.png`);
-          fs35.writeFileSync(dest, bytes);
+          const dest = path43.join(outDir, `minimax-i2i-${ts}-${i + 1}.png`);
+          fs36.writeFileSync(dest, bytes);
           saved.push(dest);
           logger.success(`Saved: ${dest}`);
         } catch (e) {
@@ -7249,8 +9178,8 @@ function registerMinimaxImageToImageCommand(parent) {
         }
       }
       if (opts.output && saved[0]) {
-        fs35.mkdirSync(path40.dirname(path40.resolve(opts.output)), { recursive: true });
-        fs35.copyFileSync(saved[0], opts.output);
+        fs36.mkdirSync(path43.dirname(path43.resolve(opts.output)), { recursive: true });
+        fs36.copyFileSync(saved[0], opts.output);
         logger.success(`Copied to: ${opts.output}`);
       }
       const finalImages = finalizeGeneratedImages(saved, { ...opts, logger });
@@ -7384,12 +9313,12 @@ function validateKnownSpeakerPairing(names = [], refs = []) {
 }
 
 // src/providers/openai/openai-audio.ts
-import fs37 from "fs";
-import path42 from "path";
+import fs38 from "fs";
+import path45 from "path";
 
 // src/providers/openai/client.ts
-import fs36 from "fs";
-import path41 from "path";
+import fs37 from "fs";
+import path44 from "path";
 init_errors();
 var DEFAULT_TIMEOUT_MS3 = 24e4;
 function requireOpenAIKey() {
@@ -7455,10 +9384,10 @@ async function postOpenAIBinary(pathname, body, apiKey, timeoutMs = DEFAULT_TIME
   return Buffer.from(await res.arrayBuffer());
 }
 function fileFromPath(filePath) {
-  const abs = path41.resolve(filePath);
-  if (!fs36.existsSync(abs)) throw new ValidationError(`File not found: ${abs}`);
-  const bytes = fs36.readFileSync(abs);
-  return new File([new Uint8Array(bytes)], path41.basename(abs));
+  const abs = path44.resolve(filePath);
+  if (!fs37.existsSync(abs)) throw new ValidationError(`File not found: ${abs}`);
+  const bytes = fs37.readFileSync(abs);
+  return new File([new Uint8Array(bytes)], path44.basename(abs));
 }
 
 // src/providers/openai/openai-audio.ts
@@ -7497,7 +9426,7 @@ async function resolveAudioReferenceDataUrl(ref) {
 }
 function audioMimeFromReference(ref) {
   const pathname = new URL(ref).pathname;
-  const ext = path42.extname(pathname).toLowerCase();
+  const ext = path45.extname(pathname).toLowerCase();
   switch (ext) {
     case ".mp3":
       return "audio/mpeg";
@@ -7516,12 +9445,12 @@ function audioMimeFromReference(ref) {
 async function generateOpenAISpeech(opts) {
   const bytes = await postOpenAIBinary("/audio/speech", buildSpeechBody(opts), requireOpenAIKey());
   const ext = extFromAudioFormat(opts.outputFormat);
-  const dest = path42.join(getOutputDir(), `openai-speech-${Date.now()}.${ext}`);
-  fs37.writeFileSync(dest, bytes);
+  const dest = path45.join(getOutputDir(), `openai-speech-${Date.now()}.${ext}`);
+  fs38.writeFileSync(dest, bytes);
   opts.logger?.success(`Saved: ${dest} (${(bytes.length / 1024).toFixed(1)} KB)`);
   if (opts.output) {
-    fs37.mkdirSync(path42.dirname(path42.resolve(opts.output)), { recursive: true });
-    fs37.copyFileSync(dest, opts.output);
+    fs38.mkdirSync(path45.dirname(path45.resolve(opts.output)), { recursive: true });
+    fs38.copyFileSync(dest, opts.output);
   }
   return dest;
 }
@@ -7543,9 +9472,9 @@ async function transcribeOpenAIAudio(opts) {
   );
   const text = typeof data.text === "string" ? data.text : void 0;
   const ext = opts.format === "text" ? "txt" : "json";
-  const dest = opts.output ? path42.resolve(opts.output) : path42.join(getOutputDir(), `openai-transcribe-${Date.now()}.${ext}`);
-  fs37.mkdirSync(path42.dirname(dest), { recursive: true });
-  fs37.writeFileSync(dest, opts.format === "text" ? text ?? "" : JSON.stringify(data, null, 2));
+  const dest = opts.output ? path45.resolve(opts.output) : path45.join(getOutputDir(), `openai-transcribe-${Date.now()}.${ext}`);
+  fs38.mkdirSync(path45.dirname(dest), { recursive: true });
+  fs38.writeFileSync(dest, opts.format === "text" ? text ?? "" : JSON.stringify(data, null, 2));
   opts.logger?.success(`Saved transcript: ${dest}`);
   return { path: dest, text };
 }
@@ -7572,9 +9501,9 @@ Generated audio: ${dest}`);
 }
 
 // src/providers/openai/codex-image-driver.ts
-import fs38 from "fs";
+import fs39 from "fs";
 import os3 from "os";
-import path43 from "path";
+import path46 from "path";
 import { execa } from "execa";
 init_errors();
 var defaultRunner = async (cmd, args, opts) => {
@@ -7623,12 +9552,12 @@ function sanitizeCodexEnv() {
 async function runCodexImageGeneration(opts) {
   const runner = opts.runner ?? defaultRunner;
   const ext = extFromImageFormat(opts.outputFormat);
-  const dest = opts.output ? path43.resolve(opts.output) : path43.join(getOutputDir(), `codex-image-${Date.now()}.${ext}`);
-  fs38.mkdirSync(path43.dirname(dest), { recursive: true });
-  const tmp = fs38.mkdtempSync(path43.join(os3.tmpdir(), "multix-codex-image-"));
-  const schema = path43.join(tmp, "schema.json");
-  const result = path43.join(tmp, "result.json");
-  fs38.writeFileSync(
+  const dest = opts.output ? path46.resolve(opts.output) : path46.join(getOutputDir(), `codex-image-${Date.now()}.${ext}`);
+  fs39.mkdirSync(path46.dirname(dest), { recursive: true });
+  const tmp = fs39.mkdtempSync(path46.join(os3.tmpdir(), "multix-codex-image-"));
+  const schema = path46.join(tmp, "schema.json");
+  const result = path46.join(tmp, "result.json");
+  fs39.writeFileSync(
     schema,
     JSON.stringify({
       type: "object",
@@ -7658,7 +9587,7 @@ async function runCodexImageGeneration(opts) {
   if (res.exitCode !== 0) {
     throw new ProviderError(`Codex image driver failed: ${res.stderr || res.stdout}`, "openai");
   }
-  if (!fs38.existsSync(dest) || fs38.statSync(dest).size === 0) {
+  if (!fs39.existsSync(dest) || fs39.statSync(dest).size === 0) {
     throw new ProviderError(`Codex did not create a non-empty image at ${dest}`, "openai");
   }
   return { path: dest };
@@ -7675,8 +9604,8 @@ function buildCodexPrompt(userPrompt, outputPath) {
 
 // src/providers/openai/openai-image.ts
 init_errors();
-import fs39 from "fs";
-import path44 from "path";
+import fs40 from "fs";
+import path47 from "path";
 function buildImageGenerationBody(opts) {
   return {
     model: opts.model ?? DEFAULT_OPENAI_IMAGE_MODEL,
@@ -7709,14 +9638,14 @@ function saveOpenAIImages(opts) {
   for (let i = 0; i < items.length; i++) {
     const b64 = items[i]?.b64_json;
     if (!b64) throw new ProviderError("No b64_json in OpenAI image response", "openai");
-    const dest = path44.join(outDir, `openai-${opts.task}-${ts}-${i + 1}.${ext}`);
-    fs39.writeFileSync(dest, Buffer.from(b64, "base64"));
+    const dest = path47.join(outDir, `openai-${opts.task}-${ts}-${i + 1}.${ext}`);
+    fs40.writeFileSync(dest, Buffer.from(b64, "base64"));
     saved.push(dest);
     opts.logger?.success(`Saved: ${dest}`);
   }
   if (opts.output && saved[0]) {
-    fs39.mkdirSync(path44.dirname(path44.resolve(opts.output)), { recursive: true });
-    fs39.copyFileSync(saved[0], opts.output);
+    fs40.mkdirSync(path47.dirname(path47.resolve(opts.output)), { recursive: true });
+    fs40.copyFileSync(saved[0], opts.output);
     opts.logger?.success(`Copied to: ${opts.output}`);
   }
   return saved;
@@ -7725,7 +9654,7 @@ async function resolveImageRefBytes(ref) {
   if (isHttpUrl(ref)) {
     const bytes2 = await fetchBytes(ref);
     const pathname = new URL(ref).pathname;
-    const filename = path44.basename(pathname) || "reference.png";
+    const filename = path47.basename(pathname) || "reference.png";
     return { filename, bytes: bytes2, mime: sniffImageMime2(bytes2, filename) };
   }
   const file = fileFromPath(ref);
@@ -7770,7 +9699,7 @@ function sniffImageMime2(buf, name) {
   if (buf[0] === 137 && buf[1] === 80 && buf[2] === 78 && buf[3] === 71) return "image/png";
   if (buf.slice(0, 4).toString() === "RIFF" && buf.slice(8, 12).toString() === "WEBP")
     return "image/webp";
-  const ext = path44.extname(name).toLowerCase();
+  const ext = path47.extname(name).toLowerCase();
   if (ext === ".jpg" || ext === ".jpeg") return "image/jpeg";
   if (ext === ".webp") return "image/webp";
   return "image/png";
@@ -7822,7 +9751,7 @@ function registerOpenAIImageToImageCommand(parent) {
   parent.command("image-to-image").alias("i2i").description("Edit images with OpenAI Image API or experimental Codex driver").requiredOption("--prompt <text>", "Text prompt describing the edit").requiredOption(
     "--ref <path>",
     "Reference image path or URL; repeatable",
-    collect5,
+    collect6,
     []
   ).option("--driver <driver>", "api|codex|auto", "auto").option(
     "-m, --model <id>",
@@ -7865,7 +9794,7 @@ Generated ${finalImages.length} image(s):`);
     for (const f of finalImages) console.log(`  ${f}`);
   });
 }
-function collect5(value, prev) {
+function collect6(value, prev) {
   return [...prev, value];
 }
 
@@ -7874,12 +9803,12 @@ function registerOpenAITranscribeCommand(parent) {
   parent.command("transcribe").description("Transcribe audio/video with OpenAI STT").requiredOption("--input <path>", "Audio or video file").option("--model <id>", "STT model", process.env.OPENAI_STT_MODEL ?? DEFAULT_OPENAI_STT_MODEL).option("--format <fmt>", "json|text|diarized_json", "text").option("--language <code>", "ISO language code").option("--chunking-strategy <strategy>", "e.g. auto").option(
     "--known-speaker-name <name>",
     "Known speaker name; repeatable",
-    collect6,
+    collect7,
     []
   ).option(
     "--known-speaker-reference <path>",
     "2-10s reference audio; repeatable",
-    collect6,
+    collect7,
     []
   ).option("--output <path>", "Save transcript to this path").option("-v, --verbose", "Verbose logging").action(async (opts) => {
     const logger = createLogger({ verbose: opts.verbose ?? false });
@@ -7898,7 +9827,7 @@ function registerOpenAITranscribeCommand(parent) {
 ${result.text.trim()}`);
   });
 }
-function collect6(value, prev) {
+function collect7(value, prev) {
   return [...prev, value];
 }
 
@@ -7914,8 +9843,8 @@ function registerOpenAICommands(program2) {
 }
 
 // src/providers/openrouter/client.ts
-import fs40 from "fs";
-import path45 from "path";
+import fs41 from "fs";
+import path48 from "path";
 init_errors();
 
 // src/providers/openrouter/payload.ts
@@ -8079,8 +10008,8 @@ async function generateOpenRouterImage(opts) {
     if (!url) continue;
     try {
       const bytes = await fetchBytes(url);
-      const dest = path45.join(outDir, `openrouter_image_${Date.now()}_${i}.png`);
-      fs40.writeFileSync(dest, bytes);
+      const dest = path48.join(outDir, `openrouter_image_${Date.now()}_${i}.png`);
+      fs41.writeFileSync(dest, bytes);
       savedFiles.push(dest);
       logger?.success(`Saved: ${dest}`);
     } catch (e) {
@@ -8091,8 +10020,8 @@ async function generateOpenRouterImage(opts) {
     }
   }
   if (output && savedFiles[0]) {
-    fs40.mkdirSync(path45.dirname(path45.resolve(output)), { recursive: true });
-    fs40.writeFileSync(output, fs40.readFileSync(savedFiles[0]));
+    fs41.mkdirSync(path48.dirname(path48.resolve(output)), { recursive: true });
+    fs41.writeFileSync(output, fs41.readFileSync(savedFiles[0]));
   }
   return { status: "success", generatedImages: savedFiles, model: usedModel };
 }
@@ -8133,8 +10062,8 @@ Generated ${finalImages.length} image(s):`);
 }
 
 // src/providers/openrouter/commands/image-to-image.ts
-import fs41 from "fs";
-import path46 from "path";
+import fs42 from "fs";
+import path49 from "path";
 init_errors();
 var DEFAULT_MODEL = "google/gemini-2.5-flash-image";
 var SOFT_LIMIT_BYTES2 = 5 * 1024 * 1024;
@@ -8145,7 +10074,7 @@ function registerOpenRouterImageToImageCommand(parent) {
   ).requiredOption("--prompt <text>", "Text prompt describing the edit").requiredOption(
     "--ref <path>",
     "Reference image (URL or local path); repeatable (most models accept 1)",
-    collect7,
+    collect8,
     []
   ).option("-m, --model <id>", `OpenRouter model id (default ${DEFAULT_MODEL})`).option("--strength <n>", "Recraft init-image strength 0..1 (Recraft models only)").option("--output <path>", "Save first generated image to this path").addOption(imageFormatOption()).addOption(noWebpOption()).option("-v, --verbose", "Verbose logging").action(
     async (opts) => {
@@ -8187,7 +10116,7 @@ Generated ${finalImages.length} image(s):`);
     }
   );
 }
-function collect7(value, prev) {
+function collect8(value, prev) {
   return [...prev, value];
 }
 function parseStrength(raw) {
@@ -8226,14 +10155,14 @@ async function runImageToImage(opts) {
     const url = parsed.urls[i];
     if (!url) continue;
     const bytes = await fetchBytes(url);
-    const dest = path46.join(outDir, `openrouter-i2i-${ts}-${i + 1}.png`);
-    fs41.writeFileSync(dest, bytes);
+    const dest = path49.join(outDir, `openrouter-i2i-${ts}-${i + 1}.png`);
+    fs42.writeFileSync(dest, bytes);
     saved.push(dest);
     opts.logger.success(`Saved: ${dest}`);
   }
   if (opts.output && saved[0]) {
-    fs41.mkdirSync(path46.dirname(path46.resolve(opts.output)), { recursive: true });
-    fs41.copyFileSync(saved[0], opts.output);
+    fs42.mkdirSync(path49.dirname(path49.resolve(opts.output)), { recursive: true });
+    fs42.copyFileSync(saved[0], opts.output);
     opts.logger.success(`Copied to: ${opts.output}`);
   }
   return saved;
@@ -8278,13 +10207,13 @@ async function listVideoModels(apiKey = requireOpenRouterKey()) {
 }
 
 // src/providers/openrouter/commands/video-status.ts
-import fs42 from "fs";
-import path47 from "path";
+import fs43 from "fs";
+import path50 from "path";
 async function downloadOpenRouterVideo(opts) {
   const { jobId, logger, source } = opts;
   const apiKey = requireOpenRouterKey();
   const url = videoContentUrl(jobId);
-  const dest = path47.join(getOutputDir(), `openrouter_video_${jobId}.mp4`);
+  const dest = path50.join(getOutputDir(), `openrouter_video_${jobId}.mp4`);
   const r = await globalThis.fetch(url, { headers: { Authorization: `Bearer ${apiKey}` } });
   if (!r.ok) {
     logger.error(`Download HTTP ${r.status}`);
@@ -8294,14 +10223,14 @@ async function downloadOpenRouterVideo(opts) {
     logger.error("Empty response body");
     process.exit(1);
   }
-  fs42.mkdirSync(path47.dirname(dest), { recursive: true });
-  const ws = fs42.createWriteStream(dest);
-  const { pipeline: pipeline3 } = await import("stream/promises");
-  await pipeline3(r.body, ws);
+  fs43.mkdirSync(path50.dirname(dest), { recursive: true });
+  const ws = fs43.createWriteStream(dest);
+  const { pipeline: pipeline4 } = await import("stream/promises");
+  await pipeline4(r.body, ws);
   logger.success(`Saved ${dest}`);
   if (opts.output) {
-    fs42.mkdirSync(path47.dirname(path47.resolve(opts.output)), { recursive: true });
-    fs42.copyFileSync(dest, opts.output);
+    fs43.mkdirSync(path50.dirname(path50.resolve(opts.output)), { recursive: true });
+    fs43.copyFileSync(dest, opts.output);
     logger.success(`Copied to ${opts.output}`);
   }
   await maybeDownloadThumb(source, dest, {
@@ -8494,8 +10423,8 @@ function parseModelRef(ref, explicitVersion) {
     }
     return { kind: "version", version: trimmed };
   }
-  const [path54, inlineVersion, ...rest] = trimmed.split(":");
-  const [owner, name, ...extra] = (path54 ?? "").split("/");
+  const [path57, inlineVersion, ...rest] = trimmed.split(":");
+  const [owner, name, ...extra] = (path57 ?? "").split("/");
   if (rest.length > 0 || extra.length > 0 || !owner || !name) {
     throw new ValidationError(
       `Invalid Replicate model "${ref}" \u2014 expected owner/name, owner/name:version, or a 64-char version id`
@@ -8625,7 +10554,7 @@ function assertSucceeded(prediction2) {
     PROVIDER
   );
 }
-var defaultSleep2 = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var defaultSleep4 = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 var ReplicateClient = class {
   apiKey;
   baseUrl;
@@ -8636,15 +10565,15 @@ var ReplicateClient = class {
     this.apiKey = opts.apiKey;
     this.baseUrl = (opts.baseUrl || DEFAULT_REPLICATE_BASE_URL).replace(/\/+$/, "");
     this.doFetch = opts.fetch ?? ((input, init) => globalThis.fetch(input, init));
-    this.sleep = opts.sleep ?? defaultSleep2;
+    this.sleep = opts.sleep ?? defaultSleep4;
   }
   headers(extra = {}) {
     return { accept: "application/json", authorization: `Bearer ${this.apiKey}`, ...extra };
   }
   /** Raw request: throws HttpError so polling can classify transient failures. */
-  raw(path54, method, body, headers2, timeoutMs = REQUEST_TIMEOUT_MS) {
+  raw(path57, method, body, headers2, timeoutMs = REQUEST_TIMEOUT_MS) {
     return fetchJson({
-      url: `${this.baseUrl}${path54}`,
+      url: `${this.baseUrl}${path57}`,
       method,
       headers: this.headers(headers2),
       body,
@@ -8656,7 +10585,7 @@ var ReplicateClient = class {
   async createPrediction(opts) {
     const { model, input } = opts;
     const isOfficial = model.kind === "official";
-    const path54 = isOfficial ? `/models/${model.owner}/${model.name}/predictions` : "/predictions";
+    const path57 = isOfficial ? `/models/${model.owner}/${model.name}/predictions` : "/predictions";
     const body = isOfficial ? { input } : { version: model.version, input };
     const subject = isOfficial ? `model ${model.owner}/${model.name}` : `model version ${model.version}`;
     const headers2 = {};
@@ -8668,7 +10597,7 @@ var ReplicateClient = class {
     }
     for (let attempt = 0; ; attempt++) {
       try {
-        const res = await this.raw(path54, "POST", body, headers2, timeoutMs);
+        const res = await this.raw(path57, "POST", body, headers2, timeoutMs);
         return validatePrediction(res);
       } catch (error) {
         if (error instanceof HttpError && error.status === 429 && attempt < CREATE_MAX_RETRIES) {
@@ -8827,11 +10756,11 @@ init_errors();
 // src/providers/replicate/node-outputs.ts
 init_errors();
 init_redact();
-import { once as once2 } from "events";
-import fs43 from "fs";
-import path48 from "path";
+import { once as once3 } from "events";
+import fs44 from "fs";
+import path51 from "path";
 import { Readable } from "stream";
-import { pipeline as pipeline2 } from "stream/promises";
+import { pipeline as pipeline3 } from "stream/promises";
 
 // src/providers/replicate/output.ts
 init_redact();
@@ -8843,15 +10772,15 @@ function isMediaRef(value) {
 function extractOutput(output) {
   const result = { media: [], texts: [] };
   const seen = /* @__PURE__ */ new Set();
-  const visit = (value, path54) => {
+  const visit = (value, path57) => {
     if (value === null || value === void 0) return;
     if (typeof value === "string") {
-      if (isMediaRef(value)) result.media.push({ url: value, path: path54 || "output" });
-      else if (value.length > 0) result.texts.push(path54 ? `${path54}: ${value}` : value);
+      if (isMediaRef(value)) result.media.push({ url: value, path: path57 || "output" });
+      else if (value.length > 0) result.texts.push(path57 ? `${path57}: ${value}` : value);
       return;
     }
     if (typeof value !== "object") {
-      result.texts.push(path54 ? `${path54}: ${String(value)}` : String(value));
+      result.texts.push(path57 ? `${path57}: ${String(value)}` : String(value));
       return;
     }
     if (seen.has(value)) return;
@@ -8859,14 +10788,14 @@ function extractOutput(output) {
     if (Array.isArray(value)) {
       if (value.length > 0 && value.every((v) => typeof v === "string" && !isMediaRef(v))) {
         const joined = value.join("");
-        if (joined.length > 0) result.texts.push(path54 ? `${path54}: ${joined}` : joined);
+        if (joined.length > 0) result.texts.push(path57 ? `${path57}: ${joined}` : joined);
         return;
       }
-      value.forEach((item, i) => visit(item, `${path54}[${i}]`));
+      value.forEach((item, i) => visit(item, `${path57}[${i}]`));
       return;
     }
     for (const [key, val] of Object.entries(value)) {
-      visit(val, path54 ? `${path54}.${key}` : key);
+      visit(val, path57 ? `${path57}.${key}` : key);
     }
   };
   visit(output, "");
@@ -8984,30 +10913,30 @@ var DOWNLOAD_TIMEOUT_MS = 3e5;
 function isDirTarget(output) {
   if (/[\\/]$/.test(output)) return true;
   try {
-    return fs43.statSync(output).isDirectory();
+    return fs44.statSync(output).isDirectory();
   } catch {
     return false;
   }
 }
 function resolveDestination(predictionId, index, count, ext, opts) {
-  if (!opts.output) return path48.join(opts.outDir, outputFilename(predictionId, index, ext));
-  const output = path48.resolve(opts.output);
-  if (isDirTarget(opts.output)) return path48.join(output, outputFilename(predictionId, index, ext));
-  const givenExt = path48.extname(output);
+  if (!opts.output) return path51.join(opts.outDir, outputFilename(predictionId, index, ext));
+  const output = path51.resolve(opts.output);
+  if (isDirTarget(opts.output)) return path51.join(output, outputFilename(predictionId, index, ext));
+  const givenExt = path51.extname(output);
   if (count === 1) return givenExt ? output : `${output}${ext}`;
   const base = givenExt ? output.slice(0, -givenExt.length) : output;
   return `${base}-${String(index + 1).padStart(2, "0")}${ext}`;
 }
 async function writeResponse(response, dest) {
   if (!response.body) throw new HttpError(0, "Response body is null", response.url);
-  const fileStream = fs43.createWriteStream(dest);
+  const fileStream = fs44.createWriteStream(dest);
   try {
-    await pipeline2(
+    await pipeline3(
       Readable.fromWeb(response.body),
       fileStream
     );
   } catch (err2) {
-    if (!fileStream.closed) await once2(fileStream, "close");
+    if (!fileStream.closed) await once3(fileStream, "close");
     throw err2;
   }
 }
@@ -9024,8 +10953,8 @@ async function saveOne(item, predictionId, index, count, opts) {
       extFromUrl4(item.url) ?? ".bin",
       opts
     );
-    fs43.mkdirSync(path48.dirname(dest2), { recursive: true });
-    fs43.writeFileSync(dest2, bytes);
+    fs44.mkdirSync(path51.dirname(dest2), { recursive: true });
+    fs44.writeFileSync(dest2, bytes);
     return dest2;
   }
   const doFetch = opts.fetch ?? ((url, init) => globalThis.fetch(url, init));
@@ -9041,11 +10970,11 @@ async function saveOne(item, predictionId, index, count, opts) {
   }
   const ext = extFromUrl4(item.url) ?? extFromContentType(response.headers.get("content-type")) ?? ".bin";
   const dest = resolveDestination(predictionId, index, count, ext, opts);
-  fs43.mkdirSync(path48.dirname(dest), { recursive: true });
+  fs44.mkdirSync(path51.dirname(dest), { recursive: true });
   try {
     await writeResponse(response, dest);
   } catch (err2) {
-    fs43.rmSync(dest, { force: true });
+    fs44.rmSync(dest, { force: true });
     throw err2;
   }
   return dest;
@@ -9081,7 +11010,7 @@ function addFlowOptions(cmd, defaultTimeoutMs) {
     "Ask Replicate to hold the create request open (1-60s, default 60); keeps polling if still running"
   ).option("--wait-timeout <ms>", "Polling timeout in milliseconds", String(defaultTimeoutMs)).option("--download", "Download media outputs (default)").option("--no-download", "Print output URLs instead of downloading").option("--output <path>", "Output file path, or a directory for multiple outputs").option("-v, --verbose", "Verbose logging");
 }
-function parsePositiveInt(raw, flag, max) {
+function parsePositiveInt2(raw, flag, max) {
   const n = Number(raw);
   if (!Number.isInteger(n) || n <= 0 || max !== void 0 && n > max) {
     throw new ValidationError(
@@ -9093,15 +11022,15 @@ function parsePositiveInt(raw, flag, max) {
 function parsePreferWait(value) {
   if (value === void 0 || value === false) return void 0;
   if (value === true) return 60;
-  return parsePositiveInt(value, "--prefer-wait", 60);
+  return parsePositiveInt2(value, "--prefer-wait", 60);
 }
-function resumeCommand2(id) {
+function resumeCommand3(id) {
   return `multix replicate status ${id} --wait --download`;
 }
 function printAsyncHandle(prediction2) {
   console.log(`Prediction submitted: ${prediction2.id} (status: ${prediction2.status})`);
   console.log(`  Check:  multix replicate status ${prediction2.id}`);
-  console.log(`  Resume: ${resumeCommand2(prediction2.id)}`);
+  console.log(`  Resume: ${resumeCommand3(prediction2.id)}`);
   console.log(`  Cancel: multix replicate cancel ${prediction2.id}`);
 }
 async function reportOutputs(prediction2, opts) {
@@ -9135,7 +11064,7 @@ async function completePrediction(client, prediction2, opts) {
   }
   const final = await client.waitForPrediction(prediction2, {
     timeoutMs: opts.waitTimeoutMs,
-    resumeHint: `Resume with: ${resumeCommand2(id)}`,
+    resumeHint: `Resume with: ${resumeCommand3(id)}`,
     onPoll: (p, attempt) => {
       if (p.status !== lastStatus) opts.logger.debug(`attempt ${attempt}: ${p.status}`);
       lastStatus = p.status;
@@ -9152,7 +11081,7 @@ async function executePrediction2(params) {
   if (opts.async && opts.preferWait) {
     throw new ValidationError("--async and --prefer-wait are mutually exclusive");
   }
-  const waitTimeoutMs = parsePositiveInt(opts.waitTimeout, "--wait-timeout");
+  const waitTimeoutMs = parsePositiveInt2(opts.waitTimeout, "--wait-timeout");
   const preferWaitSeconds = parsePreferWait(opts.preferWait);
   logger.info(`Submitting to Replicate ${describeModelRef(model)}...`);
   const prediction2 = await client.createPrediction({ model, input, preferWaitSeconds });
@@ -9186,7 +11115,7 @@ function buildImageInput(prompt, opts) {
     ...extra,
     prompt,
     ...opts.aspectRatio ? { aspect_ratio: opts.aspectRatio } : {},
-    ...opts.numOutputs ? { num_outputs: parsePositiveInt(opts.numOutputs, "--num-outputs", 10) } : {},
+    ...opts.numOutputs ? { num_outputs: parsePositiveInt2(opts.numOutputs, "--num-outputs", 10) } : {},
     ...opts.seed !== void 0 ? { seed: parseSeed(opts.seed) } : {},
     ...opts.outputFormat ? { output_format: opts.outputFormat } : {}
   };
@@ -9223,8 +11152,8 @@ function registerReplicateImageCommand(parent) {
 
 // src/providers/replicate/node-input-files.ts
 init_errors();
-import fs44 from "fs";
-import path49 from "path";
+import fs45 from "fs";
+import path52 from "path";
 var DATA_URI_MAX_BYTES = 256 * 1024;
 var UPLOAD_MAX_BYTES = 100 * 1024 * 1024;
 function formatMb2(bytes) {
@@ -9232,10 +11161,10 @@ function formatMb2(bytes) {
 }
 async function resolveFileInput(value, client, logger) {
   if (isMediaRef(value)) return value;
-  const filePath = path49.resolve(value);
+  const filePath = path52.resolve(value);
   let stat;
   try {
-    stat = fs44.statSync(filePath);
+    stat = fs45.statSync(filePath);
   } catch {
     throw new ValidationError(`Input file not found: ${value} (pass a local path or an https URL)`);
   }
@@ -9246,9 +11175,9 @@ async function resolveFileInput(value, client, logger) {
       `Input file ${value} is ${formatMb2(stat.size)}; Replicate accepts uploads under 100MB. Host it and pass an https URL instead.`
     );
   }
-  const filename = path49.basename(filePath);
+  const filename = path52.basename(filePath);
   const contentType = mimeFromFilename(filename);
-  const bytes = fs44.readFileSync(filePath);
+  const bytes = fs45.readFileSync(filePath);
   if (stat.size <= DATA_URI_MAX_BYTES) {
     logger.debug(`Inlining ${filename} (${stat.size} bytes) as a data URI`);
     return `data:${contentType};base64,${bytes.toString("base64")}`;
@@ -9275,14 +11204,14 @@ function parseFileAssignments(values) {
 }
 
 // src/providers/replicate/commands/run.ts
-var collect8 = (value, previous = []) => [...previous, value];
+var collect9 = (value, previous = []) => [...previous, value];
 function registerReplicateRunCommand(parent) {
   const cmd = parent.command("run <model>").description(
     "Run any Replicate model: owner/name (official), owner/name:version, or a version id"
   ).requiredOption("--input <json>", "Model input as JSON, or @path/to/input.json").option("--version <id>", "Explicit model version id (uses the versioned endpoint)").option(
     "--file <key=path>",
     "Set input <key> to a local file or URL (uploaded if needed); repeatable",
-    collect8
+    collect9
   );
   addFlowOptions(cmd, 6e5).action(
     async (model, opts) => {
@@ -9306,7 +11235,7 @@ function registerReplicateStatusCommand(parent) {
     const client = createReplicateClient();
     if (opts.wait) {
       await completePrediction(client, predictionId, {
-        waitTimeoutMs: parsePositiveInt(opts.waitTimeout, "--wait-timeout"),
+        waitTimeoutMs: parsePositiveInt2(opts.waitTimeout, "--wait-timeout"),
         logger,
         download: Boolean(opts.download),
         output: opts.output
@@ -9320,7 +11249,7 @@ function registerReplicateStatusCommand(parent) {
     }
     console.log(JSON.stringify(summarizePrediction(prediction2), null, 2));
     if (!isTerminalStatus2(prediction2.status)) {
-      logger.info(`Still running. Resume with: ${resumeCommand2(prediction2.id)}`);
+      logger.info(`Still running. Resume with: ${resumeCommand3(prediction2.id)}`);
     } else if (prediction2.status !== "succeeded") {
       throw new ReplicatePredictionError(prediction2);
     }
@@ -9346,7 +11275,7 @@ function buildVideoInput(prompt, opts) {
   return {
     ...extra,
     prompt,
-    ...opts.duration ? { duration: parsePositiveInt(opts.duration, "--duration", 60) } : {},
+    ...opts.duration ? { duration: parsePositiveInt2(opts.duration, "--duration", 60) } : {},
     ...opts.aspectRatio ? { aspect_ratio: opts.aspectRatio } : {},
     ...opts.resolution ? { resolution: opts.resolution } : {},
     ...opts.seed !== void 0 ? { seed: parseSeed(opts.seed) } : {}
@@ -9375,7 +11304,7 @@ function registerReplicateCommands(program2) {
 }
 
 // src/commands/check.ts
-import fs45 from "fs";
+import fs46 from "fs";
 import os4 from "os";
 
 // src/commands/check-helpers/binary-check.ts
@@ -9434,6 +11363,7 @@ To configure multix, set at least one provider API key:
     fal.ai             : https://fal.ai/dashboard/keys
     Atlas Cloud        : https://www.atlascloud.ai/console/api-keys
     Replicate          : https://replicate.com/account/api-tokens
+    HeyGen             : https://app.heygen.com/developers/api
 
   Option A \u2014 user global config (recommended):
     echo 'GEMINI_API_KEY=your-key' >> ~/.multix/.env
@@ -9515,6 +11445,12 @@ var PROVIDERS = [
     envFallback: "REPLICATE_API_KEY",
     optional: true,
     link: "https://replicate.com/account/api-tokens"
+  },
+  {
+    name: "HeyGen",
+    envPrimary: "HEYGEN_API_KEY",
+    optional: true,
+    link: "https://app.heygen.com/developers/api"
   }
 ];
 function resolveProviderKey(p) {
@@ -9566,7 +11502,7 @@ function registerCheckCommand(program2) {
     }
     if (!legacyClaudeEnvEnabled()) {
       const home = process.env.MULTIX_DISABLE_HOME_ENV ? void 0 : os4.homedir();
-      const legacy = legacyClaudeEnvFiles(process.cwd(), home).filter((f) => fs45.existsSync(f));
+      const legacy = legacyClaudeEnvFiles(process.cwd(), home).filter((f) => fs46.existsSync(f));
       if (legacy.length > 0) {
         logger.info(
           `Found ${legacy.length} legacy .claude env file(s); set MULTIX_LEGACY_CLAUDE_ENV=1 to load them`
@@ -9670,9 +11606,8 @@ function registerCheckCommand(program2) {
 }
 
 // src/commands/doc/convert.ts
-init_errors();
-import fs46 from "fs";
-import path50 from "path";
+import fs47 from "fs";
+import path53 from "path";
 
 // src/commands/doc/default-prompt.ts
 var DEFAULT_CONVERT_PROMPT = `Convert this document to clean, well-formatted Markdown.
@@ -9688,27 +11623,45 @@ Requirements:
 Output only the markdown content without any preamble or explanation.`;
 
 // src/commands/doc/convert.ts
+function autoNameBase(input) {
+  if (input === STDIN_ARG) return "stdin";
+  return path53.basename(input, path53.extname(input));
+}
 async function convertDocuments(opts) {
-  const { inputs, output, autoName = false, verbose, logger } = opts;
+  const { output, autoName = false, verbose, logger } = opts;
   const model = opts.model ?? DOC_MODEL_DEFAULT;
   const prompt = opts.prompt ?? DEFAULT_CONVERT_PROMPT;
-  for (const f of inputs) {
-    if (!fs46.existsSync(f)) throw new ValidationError(`Input file not found: ${f}`);
-  }
-  let outputPath;
-  if (output) {
-    outputPath = path50.resolve(output);
-  } else if (autoName && inputs.length === 1 && inputs[0]) {
-    const base = path50.basename(inputs[0], path50.extname(inputs[0]));
-    outputPath = path50.join(getOutputDir(), `${base}-extraction.md`);
-  } else {
-    outputPath = path50.join(getOutputDir(), "document-extraction.md");
+  const { inputs, cleanup } = await resolveFileInputs(opts.inputs, {
+    stdinExt: opts.stdinExt,
+    input: opts.stdin,
+    flag: "--input",
+    example: "cat report.pdf | multix doc convert --input -",
+    extExample: "pdf"
+  });
+  let failed;
+  try {
+    let outputPath;
+    if (output) {
+      outputPath = path53.resolve(output);
+    } else if (autoName && opts.inputs.length === 1 && opts.inputs[0]) {
+      outputPath = path53.join(getOutputDir(), `${autoNameBase(opts.inputs[0])}-extraction.md`);
+    } else {
+      outputPath = path53.join(getOutputDir(), "document-extraction.md");
+    }
+    fs47.mkdirSync(path53.dirname(outputPath), { recursive: true });
+    failed = await convertResolved(inputs, { outputPath, model, prompt, verbose, logger });
+  } finally {
+    cleanup();
   }
-  fs46.mkdirSync(path50.dirname(outputPath), { recursive: true });
+  if (failed > 0) process.exit(1);
+}
+async function convertResolved(inputs, ctx) {
+  const { outputPath, model, prompt, verbose, logger } = ctx;
   const results = [];
   for (let i = 0; i < inputs.length; i++) {
-    const filePath = inputs[i];
-    logger?.debug(`[${i + 1}/${inputs.length}] Converting: ${filePath}`);
+    const input = inputs[i];
+    const filePath = input.path;
+    logger?.debug(`[${i + 1}/${inputs.length}] Converting: ${input.label}`);
     let markdown;
     let errorMsg;
     for (let attempt = 0; attempt < 3; attempt++) {
@@ -9740,7 +11693,7 @@ async function convertDocuments(opts) {
         markdown = extractText(resp);
         break;
       } catch (e) {
-        errorMsg = e instanceof Error ? e.message : String(e);
+        errorMsg = labelError(e instanceof Error ? e.message : String(e), input);
         if (isGeminiRateLimitError(e)) break;
         if (attempt < 2) {
           const wait = 2 ** attempt * 1e3;
@@ -9749,8 +11702,11 @@ async function convertDocuments(opts) {
         }
       }
     }
+    if (markdown === void 0) {
+      logger?.error(`Failed: ${input.label} \u2014 ${errorMsg}`);
+    }
     results.push({
-      file: filePath,
+      file: input.label,
       status: markdown !== void 0 ? "success" : "error",
       markdown,
       error: errorMsg
@@ -9764,7 +11720,7 @@ async function convertDocuments(opts) {
 `);
   for (const r of results) {
     lines.push(`
-## ${path50.basename(r.file)}
+## ${path53.basename(r.file).replace(/[<>]/g, "\\$&")}
 `);
     if (r.status === "success" && r.markdown) {
       lines.push(`${r.markdown}
@@ -9777,7 +11733,7 @@ async function convertDocuments(opts) {
     }
     lines.push("\n---\n");
   }
-  fs46.writeFileSync(outputPath, lines.join("\n"), "utf8");
+  fs47.writeFileSync(outputPath, lines.join("\n"), "utf8");
   const succeeded = results.filter((r) => r.status === "success").length;
   console.log(`
 ${"=".repeat(50)}`);
@@ -9790,8 +11746,7 @@ ${"=".repeat(50)}`);
       console.log(`  [${r.status}] ${r.file}`);
     }
   }
-  const failed = results.filter((r) => r.status === "error").length;
-  if (failed > 0) process.exit(1);
+  return results.length - succeeded;
 }
 function sleep4(ms) {
   return new Promise((r) => setTimeout(r, ms));
@@ -9804,14 +11759,21 @@ function registerDocCommands(program2) {
   );
   doc.command("convert").description("Convert documents to Markdown using Gemini Files API").requiredOption(
     "--input <files...>",
-    "Input file(s) to convert",
+    "Input file(s) to convert (use - to read piped stdin)",
     (val, prev) => [...prev, val],
     []
-  ).alias("-i").option("--output <path>", "Output markdown file path").option("--auto-name", "Derive output filename from input basename (single file only)").option("--model <id>", `Gemini model to use (default: ${DOC_MODEL_DEFAULT})`).option("--prompt <text>", "Custom conversion prompt").option("-v, --verbose", "Verbose logging").action(
+  ).alias("-i").option(
+    "--stdin-ext <ext>",
+    "Extension for piped stdin when auto-detection fails (e.g. pdf, txt)"
+  ).option("--output <path>", "Output markdown file path").option(
+    "--auto-name",
+    "Derive output filename from input basename (single file only; stdin becomes stdin-extraction.md)"
+  ).option("--model <id>", `Gemini model to use (default: ${DOC_MODEL_DEFAULT})`).option("--prompt <text>", "Custom conversion prompt").option("-v, --verbose", "Verbose logging").action(
     async (opts) => {
       const logger = createLogger({ verbose: opts.verbose ?? false });
       await convertDocuments({
         inputs: opts.input,
+        stdinExt: opts.stdinExt,
         output: opts.output,
         autoName: opts.autoName,
         model: opts.model,
@@ -9825,21 +11787,21 @@ function registerDocCommands(program2) {
 
 // src/commands/media/index.ts
 init_errors();
-import fs49 from "fs";
-import path53 from "path";
+import fs50 from "fs";
+import path56 from "path";
 
 // src/commands/media/batch.ts
-import fs47 from "fs";
-import path51 from "path";
+import fs48 from "fs";
+import path54 from "path";
 
 // src/commands/media/detect-type.ts
-var VIDEO_EXTS = /* @__PURE__ */ new Set([".mp4", ".mov", ".avi", ".mkv", ".webm", ".flv", ".mpg", ".mpeg"]);
-var AUDIO_EXTS = /* @__PURE__ */ new Set([".mp3", ".wav", ".m4a", ".flac", ".aac", ".ogg", ".aiff"]);
+var VIDEO_EXTS2 = /* @__PURE__ */ new Set([".mp4", ".mov", ".avi", ".mkv", ".webm", ".flv", ".mpg", ".mpeg"]);
+var AUDIO_EXTS2 = /* @__PURE__ */ new Set([".mp3", ".wav", ".m4a", ".flac", ".aac", ".ogg", ".aiff"]);
 var IMAGE_EXTS2 = /* @__PURE__ */ new Set([".jpg", ".jpeg", ".png", ".webp", ".heic", ".heif", ".gif", ".bmp"]);
 function extToKind(ext) {
   const lower = ext.toLowerCase();
-  if (VIDEO_EXTS.has(lower)) return "video";
-  if (AUDIO_EXTS.has(lower)) return "audio";
+  if (VIDEO_EXTS2.has(lower)) return "video";
+  if (AUDIO_EXTS2.has(lower)) return "audio";
   if (IMAGE_EXTS2.has(lower)) return "image";
   return void 0;
 }
@@ -10015,7 +11977,7 @@ async function optimizeVideo(opts) {
 }
 
 // src/commands/media/batch.ts
-var ALL_EXTS = /* @__PURE__ */ new Set([...VIDEO_EXTS, ...AUDIO_EXTS, ...IMAGE_EXTS2]);
+var ALL_EXTS = /* @__PURE__ */ new Set([...VIDEO_EXTS2, ...AUDIO_EXTS2, ...IMAGE_EXTS2]);
 async function batchOptimize(opts) {
   const {
     inputDir,
@@ -10026,10 +11988,10 @@ async function batchOptimize(opts) {
     verbose,
     logger
   } = opts;
-  fs47.mkdirSync(outputDir, { recursive: true });
-  const entries = fs47.readdirSync(inputDir);
+  fs48.mkdirSync(outputDir, { recursive: true });
+  const entries = fs48.readdirSync(inputDir);
   const mediaFiles = entries.filter((f) => {
-    const ext = path51.extname(f).toLowerCase();
+    const ext = path54.extname(f).toLowerCase();
     return ALL_EXTS.has(ext);
   });
   if (mediaFiles.length === 0) {
@@ -10040,9 +12002,9 @@ async function batchOptimize(opts) {
   let succeeded = 0;
   const errors = [];
   for (const file of mediaFiles) {
-    const inputPath = path51.join(inputDir, file);
-    const outputPath = path51.join(outputDir, file);
-    const ext = path51.extname(file).toLowerCase();
+    const inputPath = path54.join(inputDir, file);
+    const outputPath = path54.join(outputDir, file);
+    const ext = path54.extname(file).toLowerCase();
     const kind = extToKind(ext);
     logger?.debug(`Processing: ${file}`);
     try {
@@ -10079,8 +12041,8 @@ async function batchOptimize(opts) {
 
 // src/commands/media/split-video.ts
 init_errors();
-import fs48 from "fs";
-import path52 from "path";
+import fs49 from "fs";
+import path55 from "path";
 async function splitVideo(opts) {
   await assertFfmpeg();
   const { input, outputDir, chunkDuration = 3600, verbose, logger } = opts;
@@ -10091,10 +12053,10 @@ async function splitVideo(opts) {
     logger?.info("Video is short enough \u2014 no splitting needed");
     return [input];
   }
-  fs48.mkdirSync(outputDir, { recursive: true });
-  const ext = path52.extname(input) || ".mp4";
-  const baseName = path52.basename(input, ext);
-  const outputPattern = path52.join(outputDir, `${baseName}_chunk_%03d${ext}`);
+  fs49.mkdirSync(outputDir, { recursive: true });
+  const ext = path55.extname(input) || ".mp4";
+  const baseName = path55.basename(input, ext);
+  const outputPattern = path55.join(outputDir, `${baseName}_chunk_%03d${ext}`);
   logger?.debug(`Splitting into ~${numChunks} chunks of ${chunkDuration}s each`);
   const args = [
     "-i",
@@ -10113,8 +12075,8 @@ async function splitVideo(opts) {
   await runFfmpeg(args, { verbose, logger });
   const files = [];
   for (let i = 0; i < numChunks + 1; i++) {
-    const fname = path52.join(outputDir, `${baseName}_chunk_${String(i).padStart(3, "0")}${ext}`);
-    if (fs48.existsSync(fname)) files.push(fname);
+    const fname = path55.join(outputDir, `${baseName}_chunk_${String(i).padStart(3, "0")}${ext}`);
+    if (fs49.existsSync(fname)) files.push(fname);
   }
   logger?.success(`Created ${files.length} chunks in ${outputDir}`);
   return files;
@@ -10128,9 +12090,9 @@ function registerMediaCommands(program2) {
   media.command("optimize").description("Optimize a single media file (video, audio, or image)").requiredOption("--input <file>", "Input media file").requiredOption("--output <file>", "Output file path").option("--target-size <MB>", "Target file size in MB").option("--quality <n>", "Quality: video CRF (0-51) or image (1-100)", "85").option("--max-width <px>", "Max image/video width in pixels", "1920").option("--bitrate <rate>", "Audio bitrate (e.g. 64k)", "64k").option("--resolution <WxH>", "Force video resolution (e.g. 1920x1080)").option("-v, --verbose", "Verbose logging").action(
     async (opts) => {
       const logger = createLogger({ verbose: opts.verbose ?? false });
-      if (!fs49.existsSync(opts.input)) throw new ValidationError(`Input not found: ${opts.input}`);
-      fs49.mkdirSync(path53.dirname(path53.resolve(opts.output)), { recursive: true });
-      const ext = path53.extname(opts.input).toLowerCase();
+      if (!fs50.existsSync(opts.input)) throw new ValidationError(`Input not found: ${opts.input}`);
+      fs50.mkdirSync(path56.dirname(path56.resolve(opts.output)), { recursive: true });
+      const ext = path56.extname(opts.input).toLowerCase();
       const kind = extToKind(ext);
       if (!kind) throw new ValidationError(`Unsupported file type: ${ext}`);
       const quality = Number.parseInt(opts.quality, 10);
@@ -10170,7 +12132,7 @@ function registerMediaCommands(program2) {
   media.command("split").description("Split a long video into fixed-duration chunks").requiredOption("--input <file>", "Input video file").option("--output-dir <dir>", "Output directory for chunks", "./chunks").option("--chunk-duration <sec>", "Chunk duration in seconds", "3600").option("-v, --verbose", "Verbose logging").action(
     async (opts) => {
       const logger = createLogger({ verbose: opts.verbose ?? false });
-      if (!fs49.existsSync(opts.input)) throw new ValidationError(`Input not found: ${opts.input}`);
+      if (!fs50.existsSync(opts.input)) throw new ValidationError(`Input not found: ${opts.input}`);
       const chunks = await splitVideo({
         input: opts.input,
         outputDir: opts.outputDir,
@@ -10186,7 +12148,7 @@ Created ${chunks.length} chunk(s) in ${opts.outputDir}`);
   media.command("batch").description("Batch optimize all media files in a directory").requiredOption("--input-dir <dir>", "Input directory").requiredOption("--output-dir <dir>", "Output directory").option("--quality <n>", "Quality setting", "85").option("--max-width <px>", "Max image/video width", "1920").option("--bitrate <rate>", "Audio bitrate", "64k").option("-v, --verbose", "Verbose logging").action(
     async (opts) => {
       const logger = createLogger({ verbose: opts.verbose ?? false });
-      if (!fs49.existsSync(opts.inputDir))
+      if (!fs50.existsSync(opts.inputDir))
         throw new ValidationError(`Input dir not found: ${opts.inputDir}`);
       const result = await batchOptimize({
         inputDir: opts.inputDir,
@@ -10368,6 +12330,7 @@ function registerCommands(program2) {
   registerFalCommands(program2);
   registerAtlasCloudCommands(program2);
   registerReplicateCommands(program2);
+  registerHeygenCommands(program2);
   registerMediaCommands(program2);
   registerDocCommands(program2);
 }
@@ -10381,7 +12344,7 @@ loadEnv();
 var require3 = createRequire2(import.meta.url);
 var pkg = require3("../package.json");
 var program = new Command().name("multix").description(
-  "AI multimodal CLI \u2014 image/video/audio/3D generation, editing, transcription, and media processing via OpenAI, Gemini, MiniMax, OpenRouter, Leonardo, BytePlus, ElevenLabs, fal.ai, Atlas Cloud, Replicate, ffmpeg, and ImageMagick"
+  "AI multimodal CLI \u2014 image/video/audio/3D generation, editing, transcription, and media processing via OpenAI, Gemini, MiniMax, OpenRouter, Leonardo, BytePlus, ElevenLabs, fal.ai, Atlas Cloud, Replicate, HeyGen, ffmpeg, and ImageMagick"
 ).version(pkg.version).enablePositionalOptions();
 registerCommands(program);
 program.parseAsync(process.argv).catch((err2) => {