@mrgoonie/multix 0.0.5 → 0.0.7

package/dist/cli.js

@@ -10,6 +10,14 @@ var __export = (target, all) => {
 };
 
 // src/core/errors.ts
+var errors_exports = {};
+__export(errors_exports, {
+  ConfigError: () => ConfigError,
+  HttpError: () => HttpError,
+  MultixError: () => MultixError,
+  ProviderError: () => ProviderError,
+  ValidationError: () => ValidationError
+});
 var MultixError, ConfigError, ProviderError, ValidationError, HttpError;
 var init_errors = __esm({
   "src/core/errors.ts"() {
@@ -67,8 +75,8 @@ __export(http_client_exports, {
   fetchBytes: () => fetchBytes,
   httpJson: () => httpJson
 });
-import fs2 from "fs";
-import path2 from "path";
+import fs4 from "fs";
+import path4 from "path";
 import { pipeline } from "stream/promises";
 async function httpJson(opts) {
   const { url, method = "GET", headers = {}, body, timeoutMs = DEFAULT_TIMEOUT_MS } = opts;
@@ -103,7 +111,7 @@ async function httpJson(opts) {
   return response.json();
 }
 async function downloadFile(url, dest, timeoutMs = DEFAULT_TIMEOUT_MS) {
-  fs2.mkdirSync(path2.dirname(dest), { recursive: true });
+  fs4.mkdirSync(path4.dirname(dest), { recursive: true });
   let response;
   try {
     response = await globalThis.fetch(url, { signal: AbortSignal.timeout(timeoutMs) });
@@ -117,7 +125,7 @@ async function downloadFile(url, dest, timeoutMs = DEFAULT_TIMEOUT_MS) {
   if (!response.body) {
     throw new HttpError(0, "Response body is null", url);
   }
-  const fileStream = fs2.createWriteStream(dest);
+  const fileStream = fs4.createWriteStream(dest);
   await pipeline(response.body, fileStream);
 }
 async function fetchBytes(urlOrDataUri) {
@@ -155,6 +163,90 @@ var init_http_client = __esm({
 import { createRequire } from "module";
 import { Command } from "commander";
 
+// src/providers/byteplus/commands/generate-3d.ts
+import path5 from "path";
+
+// src/core/image-input.ts
+import fs from "fs/promises";
+import path from "path";
+var IMAGE_MIME_BY_EXT = {
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".png": "image/png",
+  ".webp": "image/webp",
+  ".gif": "image/gif"
+};
+var VIDEO_MIME_BY_EXT = {
+  ".mp4": "video/mp4",
+  ".webm": "video/webm",
+  ".mov": "video/quicktime",
+  ".m4v": "video/x-m4v"
+};
+var AUDIO_MIME_BY_EXT = {
+  ".mp3": "audio/mpeg",
+  ".wav": "audio/wav",
+  ".m4a": "audio/mp4",
+  ".flac": "audio/flac",
+  ".ogg": "audio/ogg"
+};
+var DEFAULT_SOFT_LIMIT_BYTES = 10 * 1024 * 1024;
+var DEFAULT_HARD_LIMIT_BYTES = 25 * 1024 * 1024;
+function isHttpUrl(input) {
+  return /^https?:\/\//i.test(input);
+}
+async function readAsDataUrl(filePath, mimeTable, kindLabel, opts = {}) {
+  const ext = path.extname(filePath).toLowerCase();
+  const mime = mimeTable[ext];
+  if (!mime) {
+    throw new Error(
+      `Unsupported ${kindLabel} extension '${ext}'. Allowed: ${Object.keys(mimeTable).join(", ")}`
+    );
+  }
+  const hard = opts.hardLimitBytes ?? DEFAULT_HARD_LIMIT_BYTES;
+  const soft = opts.softLimitBytes ?? DEFAULT_SOFT_LIMIT_BYTES;
+  const buf = await fs.readFile(filePath);
+  if (buf.byteLength > hard) {
+    throw new Error(
+      `${kindLabel} file ${filePath} is ${(buf.byteLength / 1024 / 1024).toFixed(1)}MB \u2014 exceeds ${(hard / 1024 / 1024).toFixed(0)}MB limit. Upload to a URL instead.`
+    );
+  }
+  if (buf.byteLength > soft) {
+    opts.logger?.warn(
+      `${kindLabel} payload ${(buf.byteLength / 1024 / 1024).toFixed(1)}MB is large; consider URL input.`
+    );
+  }
+  const dataUrl = `data:${mime};base64,${buf.toString("base64")}`;
+  return { dataUrl, mime, bytes: buf.byteLength };
+}
+async function resolveImageInput(input, opts = {}) {
+  const o = normalizeOpts(opts);
+  if (isHttpUrl(input)) return { kind: "url", url: input };
+  const { dataUrl, mime, bytes } = await readAsDataUrl(input, IMAGE_MIME_BY_EXT, "image", o);
+  return { kind: "data", dataUrl, mime, bytes };
+}
+async function resolveVideoInput(input, opts = {}) {
+  const o = normalizeOpts(opts);
+  if (isHttpUrl(input)) return { kind: "url", url: input };
+  const { dataUrl, mime, bytes } = await readAsDataUrl(input, VIDEO_MIME_BY_EXT, "video", o);
+  return { kind: "data", dataUrl, mime, bytes };
+}
+async function resolveAudioInput(input, opts = {}) {
+  const o = normalizeOpts(opts);
+  if (isHttpUrl(input)) return { kind: "url", url: input };
+  const { dataUrl, mime, bytes } = await readAsDataUrl(input, AUDIO_MIME_BY_EXT, "audio", o);
+  return { kind: "data", dataUrl, mime, bytes };
+}
+function refUrl(r) {
+  return r.kind === "url" ? r.url : r.dataUrl;
+}
+function normalizeOpts(opts) {
+  if (!opts) return {};
+  if (typeof opts.info === "function" && typeof opts.warn === "function") {
+    return { logger: opts };
+  }
+  return opts;
+}
+
 // src/core/logger.ts
 var ANSI = {
   reset: "\x1B[0m",
@@ -200,22 +292,69 @@ ${line}
 }
 var defaultLogger = createLogger({ verbose: false });
 
+// src/core/output-dir.ts
+import fs2 from "fs";
+import path2 from "path";
+var cachedOutputDir;
+function getOutputDir() {
+  if (cachedOutputDir) return cachedOutputDir;
+  const dir = process.env.MULTIX_OUTPUT_DIR ? path2.resolve(process.env.MULTIX_OUTPUT_DIR) : path2.resolve(process.cwd(), "multix-output");
+  fs2.mkdirSync(dir, { recursive: true });
+  cachedOutputDir = dir;
+  return dir;
+}
+
+// src/providers/leonardo/poll.ts
+var PollTimeoutError = class extends Error {
+  constructor() {
+    super("Polling timed out before the operation completed.");
+    this.name = "PollTimeoutError";
+  }
+};
+var PollFailedError = class extends Error {
+  constructor(value) {
+    super("Operation failed.");
+    this.value = value;
+    this.name = "PollFailedError";
+  }
+  value;
+};
+async function poll(opts) {
+  const interval = opts.intervalMs ?? 4e3;
+  const max = opts.maxAttempts ?? 120;
+  for (let attempt = 1; attempt <= max; attempt++) {
+    if (opts.signal?.aborted) throw new Error("Aborted");
+    const value = await opts.fetch();
+    opts.onTick?.(attempt, value);
+    if (opts.failed?.(value)) throw new PollFailedError(value);
+    if (opts.done(value)) return value;
+    await new Promise((resolve, reject) => {
+      const t = setTimeout(resolve, interval);
+      opts.signal?.addEventListener("abort", () => {
+        clearTimeout(t);
+        reject(new Error("Aborted"));
+      });
+    });
+  }
+  throw new PollTimeoutError();
+}
+
 // src/core/env-loader.ts
-import fs from "fs";
+import fs3 from "fs";
 import os from "os";
-import path from "path";
+import path3 from "path";
 import { config as dotenvConfig } from "dotenv";
 var loaded = false;
 function loadEnv() {
   if (loaded) return;
   loaded = true;
-  const cwdEnv = path.resolve(process.cwd(), ".env");
-  if (fs.existsSync(cwdEnv)) {
+  const cwdEnv = path3.resolve(process.cwd(), ".env");
+  if (fs3.existsSync(cwdEnv)) {
     dotenvConfig({ path: cwdEnv, override: false });
   }
   if (!process.env.MULTIX_DISABLE_HOME_ENV) {
-    const homeEnv = path.join(os.homedir(), ".multix", ".env");
-    if (fs.existsSync(homeEnv)) {
+    const homeEnv = path3.join(os.homedir(), ".multix", ".env");
+    if (fs3.existsSync(homeEnv)) {
       dotenvConfig({ path: homeEnv, override: false });
     }
   }
@@ -236,9 +375,15 @@ init_http_client();
 var DEFAULT_BYTEPLUS_BASE_URL = "https://ark.ap-southeast.bytepluses.com/api/v3";
 var DEFAULT_BYTEPLUS_IMAGE_MODEL = "seedream-4-0-250828";
 var DEFAULT_BYTEPLUS_VIDEO_MODEL = "seedance-2.0";
+var DEFAULT_BYTEPLUS_3D_MODEL = "hyper3d-gen2-260112";
+var BYTEPLUS_3D_MODELS = [
+  { id: "hyper3d-gen2-260112", name: "Hyper3D Gen2", family: "hyper3d" },
+  { id: "hitem3d-2-0-251223", name: "Hitem3d 2.0", family: "hitem3d" }
+];
 var BYTEPLUS_DEFAULTS = {
   imageModel: process.env.BYTEPLUS_IMAGE_MODEL ?? DEFAULT_BYTEPLUS_IMAGE_MODEL,
   videoModel: process.env.BYTEPLUS_VIDEO_MODEL ?? DEFAULT_BYTEPLUS_VIDEO_MODEL,
+  threeDModel: process.env.BYTEPLUS_3D_MODEL ?? DEFAULT_BYTEPLUS_3D_MODEL,
   videoResolution: "1080p",
   videoDuration: 8,
   videoAspectRatio: "16:9",
@@ -269,9 +414,9 @@ var BytePlusClient = class {
   }
   apiKey;
   baseUrl;
-  async request(path35, opts = {}) {
+  async request(path41, opts = {}) {
     const base = this.baseUrl.replace(/\/$/, "");
-    const url = new URL(base + path35);
+    const url = new URL(base + path41);
     if (opts.query) {
       for (const [k, v] of Object.entries(opts.query)) {
         if (v !== void 0 && v !== null) url.searchParams.set(k, String(v));
@@ -289,141 +434,167 @@ var BytePlusClient = class {
       timeoutMs: opts.timeoutMs ?? 12e4
     });
   }
-  get(path35, query, logger) {
-    return this.request(path35, { method: "GET", query, logger });
+  get(path41, query, logger) {
+    return this.request(path41, { method: "GET", query, logger });
   }
-  post(path35, body, logger) {
-    return this.request(path35, { method: "POST", body, logger });
+  post(path41, body, logger) {
+    return this.request(path41, { method: "POST", body, logger });
   }
-  delete(path35, logger) {
-    return this.request(path35, { method: "DELETE", logger });
+  delete(path41, logger) {
+    return this.request(path41, { method: "DELETE", logger });
   }
 };
 function createBytePlusClient() {
   return new BytePlusClient(requireBytePlusKey(), bytePlusBaseUrl());
 }
 
-// src/providers/byteplus/generators/image.ts
+// src/providers/byteplus/generators/three-d.ts
 init_http_client();
-import fs5 from "fs";
-import path5 from "path";
-
-// src/core/image-input.ts
-import fs3 from "fs/promises";
-import path3 from "path";
-var IMAGE_MIME_BY_EXT = {
-  ".jpg": "image/jpeg",
-  ".jpeg": "image/jpeg",
-  ".png": "image/png",
-  ".webp": "image/webp",
-  ".gif": "image/gif"
-};
-var VIDEO_MIME_BY_EXT = {
-  ".mp4": "video/mp4",
-  ".webm": "video/webm",
-  ".mov": "video/quicktime",
-  ".m4v": "video/x-m4v"
-};
-var AUDIO_MIME_BY_EXT = {
-  ".mp3": "audio/mpeg",
-  ".wav": "audio/wav",
-  ".m4a": "audio/mp4",
-  ".flac": "audio/flac",
-  ".ogg": "audio/ogg"
-};
-var DEFAULT_SOFT_LIMIT_BYTES = 10 * 1024 * 1024;
-var DEFAULT_HARD_LIMIT_BYTES = 25 * 1024 * 1024;
-function isHttpUrl(input) {
-  return /^https?:\/\//i.test(input);
-}
-async function readAsDataUrl(filePath, mimeTable, kindLabel, opts = {}) {
-  const ext = path3.extname(filePath).toLowerCase();
-  const mime = mimeTable[ext];
-  if (!mime) {
-    throw new Error(
-      `Unsupported ${kindLabel} extension '${ext}'. Allowed: ${Object.keys(mimeTable).join(", ")}`
-    );
-  }
-  const hard = opts.hardLimitBytes ?? DEFAULT_HARD_LIMIT_BYTES;
-  const soft = opts.softLimitBytes ?? DEFAULT_SOFT_LIMIT_BYTES;
-  const buf = await fs3.readFile(filePath);
-  if (buf.byteLength > hard) {
-    throw new Error(
-      `${kindLabel} file ${filePath} is ${(buf.byteLength / 1024 / 1024).toFixed(1)}MB \u2014 exceeds ${(hard / 1024 / 1024).toFixed(0)}MB limit. Upload to a URL instead.`
-    );
+function buildThreeDTaskBody(opts) {
+  const promptText = (opts.prompt ?? "").trim();
+  const flagPart = opts.flags?.trim() ?? "";
+  const text = [promptText, flagPart].filter((s) => s.length > 0).join(" ");
+  const content = [];
+  if (text.length > 0) content.push({ type: "text", text });
+  for (const img of opts.imageInputs ?? []) {
+    content.push({ type: "image_url", image_url: { url: refUrl(img) } });
   }
-  if (buf.byteLength > soft) {
-    opts.logger?.warn(
-      `${kindLabel} payload ${(buf.byteLength / 1024 / 1024).toFixed(1)}MB is large; consider URL input.`
-    );
+  if (content.length === 0) {
+    throw new Error("3D task requires either a prompt or at least one image input.");
   }
-  const dataUrl = `data:${mime};base64,${buf.toString("base64")}`;
-  return { dataUrl, mime, bytes: buf.byteLength };
-}
-async function resolveImageInput(input, opts = {}) {
-  const o = normalizeOpts(opts);
-  if (isHttpUrl(input)) return { kind: "url", url: input };
-  const { dataUrl, mime, bytes } = await readAsDataUrl(input, IMAGE_MIME_BY_EXT, "image", o);
-  return { kind: "data", dataUrl, mime, bytes };
+  const body = { model: opts.model, content };
+  if (opts.seed !== void 0) body.seed = opts.seed;
+  return body;
 }
-async function resolveVideoInput(input, opts = {}) {
-  const o = normalizeOpts(opts);
-  if (isHttpUrl(input)) return { kind: "url", url: input };
-  const { dataUrl, mime, bytes } = await readAsDataUrl(input, VIDEO_MIME_BY_EXT, "video", o);
-  return { kind: "data", dataUrl, mime, bytes };
+async function submitThreeDTask(client, body, logger) {
+  return client.post("/contents/generations/tasks", body, logger);
 }
-async function resolveAudioInput(input, opts = {}) {
-  const o = normalizeOpts(opts);
-  if (isHttpUrl(input)) return { kind: "url", url: input };
-  const { dataUrl, mime, bytes } = await readAsDataUrl(input, AUDIO_MIME_BY_EXT, "audio", o);
-  return { kind: "data", dataUrl, mime, bytes };
+async function getThreeDTaskStatus(client, id, logger) {
+  return client.get(`/contents/generations/tasks/${id}`, void 0, logger);
 }
-function refUrl(r) {
-  return r.kind === "url" ? r.url : r.dataUrl;
+async function waitForThreeDTask(client, id, opts = {}) {
+  const intervalMs = opts.intervalMs ?? 4e3;
+  const maxAttempts = opts.maxAttempts ?? (opts.waitTimeoutMs ? Math.max(1, Math.ceil(opts.waitTimeoutMs / intervalMs)) : 180);
+  return poll({
+    fetch: () => getThreeDTaskStatus(client, id, opts.logger),
+    done: (v) => v.status === "succeeded",
+    failed: (v) => v.status === "failed" || v.status === "cancelled",
+    intervalMs,
+    maxAttempts,
+    onTick: (attempt, v) => opts.logger?.debug(`attempt ${attempt} \u2014 status: ${v.status}`)
+  });
 }
-function normalizeOpts(opts) {
-  if (!opts) return {};
-  if (typeof opts.info === "function" && typeof opts.warn === "function") {
-    return { logger: opts };
-  }
-  return opts;
+function inferModelFileExt(url) {
+  const m = url.match(/\.(glb|gltf|obj|fbx|usdz|stl|ply|zip)(?:\?|#|$)/i);
+  return m?.[1] ? m[1].toLowerCase() : "glb";
 }
-
-// src/core/output-dir.ts
-import fs4 from "fs";
-import path4 from "path";
-var cachedOutputDir;
-function getOutputDir() {
-  if (cachedOutputDir) return cachedOutputDir;
-  const dir = process.env.MULTIX_OUTPUT_DIR ? path4.resolve(process.env.MULTIX_OUTPUT_DIR) : path4.resolve(process.cwd(), "multix-output");
-  fs4.mkdirSync(dir, { recursive: true });
-  cachedOutputDir = dir;
-  return dir;
+async function downloadModelFile(url, outputPath, logger) {
+  await downloadFile(url, outputPath);
+  logger?.success(`Saved ${outputPath}`);
 }
 
-// src/providers/byteplus/generators/image.ts
-var ASPECT_TO_SIZE = {
-  "1:1": "2048x2048",
-  "16:9": "2560x1440",
-  "9:16": "1440x2560",
-  "4:3": "2048x1536",
-  "3:4": "1536x2048",
-  "21:9": "2560x1080",
-  "3:2": "2048x1365",
-  "2:3": "1365x2048"
-};
-function resolveSize(opts) {
-  if (opts.size && opts.aspectRatio) {
-    opts.logger?.warn("Both --size and --aspect-ratio given; using --size.");
-    return opts.size;
-  }
-  if (opts.size) return opts.size;
-  if (opts.aspectRatio) {
-    const mapped = ASPECT_TO_SIZE[opts.aspectRatio];
-    if (!mapped) {
-      throw new Error(
-        `Unsupported --aspect-ratio '${opts.aspectRatio}'. Supported: ${Object.keys(ASPECT_TO_SIZE).join(", ")}`
-      );
+// src/providers/byteplus/commands/generate-3d.ts
+function registerBytePlusGenerate3DCommand(parent) {
+  parent.command("generate-3d").alias("3d").description(
+    `Generate a 3D model via BytePlus (Hyper3D / Hitem3d). Models: ${BYTEPLUS_3D_MODELS.map((m) => m.id).join(", ")}`
+  ).option("--prompt <text>", "Text prompt (text-to-3D or to guide image-to-3D)").option(
+    "-m, --model <id>",
+    `Model id (default ${BYTEPLUS_DEFAULTS.threeDModel})`,
+    BYTEPLUS_DEFAULTS.threeDModel
+  ).option("--input-image <path|url...>", "1\u20135 reference images for image-to-3D (path or URL)").option(
+    "--flags <raw>",
+    "Raw flags appended to the prompt (e.g. '--mesh_mode Raw --hd_texture true' for Hyper3D, '--ff 2 --resolution 1536pro' for Hitem3d)"
+  ).option("--seed <n>", "Fixed seed").option("--async", "Submit task and exit; print taskId only").option("--wait-timeout <ms>", "Poll timeout in ms", "900000").option("--output <path>", "Output file path (extension auto-detected from URL if omitted)").option("-v, --verbose", "Verbose logging").action(
+    async (opts) => {
+      const logger = createLogger({ verbose: opts.verbose ?? false });
+      const client = createBytePlusClient();
+      const images = opts.inputImage ?? [];
+      if (images.length > 5) {
+        logger.error("BytePlus 3D supports at most 5 reference images.");
+        process.exit(1);
+      }
+      const imageInputs = await Promise.all(images.map((src) => resolveImageInput(src, logger)));
+      if (!opts.prompt && imageInputs.length === 0) {
+        logger.error("Provide --prompt and/or --input-image to describe the 3D content.");
+        process.exit(1);
+      }
+      const body = buildThreeDTaskBody({
+        model: opts.model,
+        prompt: opts.prompt,
+        flags: opts.flags,
+        seed: opts.seed ? Number.parseInt(opts.seed, 10) : void 0,
+        imageInputs
+      });
+      logger.info(
+        `Submitting 3D task (${opts.model}${imageInputs.length > 0 ? `, ${imageInputs.length} image ref${imageInputs.length === 1 ? "" : "s"}` : ""})`
+      );
+      const submitted = await submitThreeDTask(client, body, logger);
+      const taskId = submitted.id;
+      logger.debug(`taskId: ${taskId}`);
+      if (opts.async) {
+        console.log(taskId);
+        console.error(`Poll with: multix byteplus status ${taskId} --wait --download`);
+        return;
+      }
+      try {
+        const final = await waitForThreeDTask(client, taskId, {
+          waitTimeoutMs: Number.parseInt(opts.waitTimeout, 10) || 9e5,
+          logger
+        });
+        const url = final.content?.file_url;
+        if (!url) {
+          logger.error(`Task succeeded but no file_url in response: ${JSON.stringify(final)}`);
+          process.exit(1);
+        }
+        const ext = inferModelFileExt(url);
+        const outPath = opts.output ?? path5.join(getOutputDir(), `byteplus-3d-${taskId.slice(0, 8)}-${Date.now()}.${ext}`);
+        await downloadModelFile(url, outPath, logger);
+        console.log(`
+Task: ${taskId}`);
+        console.log(`Saved: ${outPath}`);
+      } catch (e) {
+        if (e instanceof PollTimeoutError) {
+          logger.error(
+            `Polling timed out \u2014 keep the task and check later: multix byteplus status ${taskId} --wait --download`
+          );
+          process.exit(1);
+        }
+        if (e instanceof PollFailedError) {
+          logger.error(`Task failed: ${JSON.stringify(e.value)}`);
+          process.exit(1);
+        }
+        throw e;
+      }
+    }
+  );
+}
+
+// src/providers/byteplus/generators/image.ts
+init_http_client();
+import fs5 from "fs";
+import path6 from "path";
+var ASPECT_TO_SIZE = {
+  "1:1": "2048x2048",
+  "16:9": "2560x1440",
+  "9:16": "1440x2560",
+  "4:3": "2048x1536",
+  "3:4": "1536x2048",
+  "21:9": "2560x1080",
+  "3:2": "2048x1365",
+  "2:3": "1365x2048"
+};
+function resolveSize(opts) {
+  if (opts.size && opts.aspectRatio) {
+    opts.logger?.warn("Both --size and --aspect-ratio given; using --size.");
+    return opts.size;
+  }
+  if (opts.size) return opts.size;
+  if (opts.aspectRatio) {
+    const mapped = ASPECT_TO_SIZE[opts.aspectRatio];
+    if (!mapped) {
+      throw new Error(
+        `Unsupported --aspect-ratio '${opts.aspectRatio}'. Supported: ${Object.keys(ASPECT_TO_SIZE).join(", ")}`
+      );
     }
     return mapped;
   }
@@ -465,14 +636,14 @@ async function generateSeedream(client, opts) {
     }
     const ext = (() => {
       try {
-        const e = path5.extname(new URL(url).pathname);
+        const e = path6.extname(new URL(url).pathname);
         return e || ".jpg";
       } catch {
         return ".jpg";
       }
     })();
-    const filename = opts.output && items.length === 1 ? path5.resolve(opts.output) : path5.join(outDir, `byteplus-image-${ts}-${i + 1}${ext}`);
-    fs5.mkdirSync(path5.dirname(filename), { recursive: true });
+    const filename = opts.output && items.length === 1 ? path6.resolve(opts.output) : path6.join(outDir, `byteplus-image-${ts}-${i + 1}${ext}`);
+    fs5.mkdirSync(path6.dirname(filename), { recursive: true });
     await downloadFile(url, filename);
     saved.push({ path: filename, url, seed: item.seed });
     logger?.success(`Saved ${filename}`);
@@ -552,12 +723,12 @@ function collect2(value, prev) {
 }
 
 // src/providers/byteplus/commands/image-to-video.ts
-import path7 from "path";
+import path8 from "path";
 
 // src/core/video-thumb.ts
 init_http_client();
 import fs6 from "fs";
-import path6 from "path";
+import path7 from "path";
 var THUMB_KEYS = /* @__PURE__ */ new Set([
   "cover_image_url",
   "coverImageUrl",
@@ -607,9 +778,9 @@ function detectThumbUrl(obj) {
 async function downloadThumbBeside(thumbUrl, videoPath, logger) {
   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}`);
+  const dir = path7.dirname(videoPath);
+  const base = path7.basename(videoPath, path7.extname(videoPath));
+  const dest = path7.join(dir, `${base}_thumb.${ext}`);
   try {
     await downloadFile(thumbUrl, dest);
     logger?.success(`Saved thumb ${dest}`);
@@ -628,10 +799,10 @@ async function maybeDownloadThumb(source, videoPath, opts = {}) {
   }
   const saved = await downloadThumbBeside(url, videoPath, opts.logger);
   if (saved && opts.copyTo) {
-    const copyExt = path6.extname(saved);
-    const copyBase = path6.basename(opts.copyTo, path6.extname(opts.copyTo));
-    const copyDir = path6.dirname(path6.resolve(opts.copyTo));
-    const copyDest = path6.join(copyDir, `${copyBase}_thumb${copyExt}`);
+    const copyExt = path7.extname(saved);
+    const copyBase = path7.basename(opts.copyTo, path7.extname(opts.copyTo));
+    const copyDir = path7.dirname(path7.resolve(opts.copyTo));
+    const copyDest = path7.join(copyDir, `${copyBase}_thumb${copyExt}`);
     fs6.mkdirSync(copyDir, { recursive: true });
     fs6.copyFileSync(saved, copyDest);
     opts.logger?.success(`Copied thumb to ${copyDest}`);
@@ -639,41 +810,6 @@ async function maybeDownloadThumb(source, videoPath, opts = {}) {
   return saved;
 }
 
-// src/providers/leonardo/poll.ts
-var PollTimeoutError = class extends Error {
-  constructor() {
-    super("Polling timed out before the operation completed.");
-    this.name = "PollTimeoutError";
-  }
-};
-var PollFailedError = class extends Error {
-  constructor(value) {
-    super("Operation failed.");
-    this.value = value;
-    this.name = "PollFailedError";
-  }
-  value;
-};
-async function poll(opts) {
-  const interval = opts.intervalMs ?? 4e3;
-  const max = opts.maxAttempts ?? 120;
-  for (let attempt = 1; attempt <= max; attempt++) {
-    if (opts.signal?.aborted) throw new Error("Aborted");
-    const value = await opts.fetch();
-    opts.onTick?.(attempt, value);
-    if (opts.failed?.(value)) throw new PollFailedError(value);
-    if (opts.done(value)) return value;
-    await new Promise((resolve, reject) => {
-      const t = setTimeout(resolve, interval);
-      opts.signal?.addEventListener("abort", () => {
-        clearTimeout(t);
-        reject(new Error("Aborted"));
-      });
-    });
-  }
-  throw new PollTimeoutError();
-}
-
 // src/providers/byteplus/generators/video.ts
 init_http_client();
 function buildFlagSuffix(opts) {
@@ -796,7 +932,7 @@ function registerBytePlusImageToVideoCommand(parent) {
           logger.error(`Task succeeded but no video_url: ${JSON.stringify(final)}`);
           process.exit(1);
         }
-        const outPath = opts.output ?? path7.join(getOutputDir(), `byteplus-i2v-${taskId.slice(0, 8)}-${Date.now()}.mp4`);
+        const outPath = opts.output ?? path8.join(getOutputDir(), `byteplus-i2v-${taskId.slice(0, 8)}-${Date.now()}.mp4`);
         await downloadVideo(url, outPath, logger);
         await maybeDownloadThumb(final, outPath, {
           skip: opts.thumb === false,
@@ -822,7 +958,7 @@ Task: ${taskId}`);
 }
 
 // src/providers/byteplus/commands/reference-to-video.ts
-import path8 from "path";
+import path9 from "path";
 
 // src/providers/byteplus/reference-input.ts
 var MAX_TOTAL_REFS = 12;
@@ -854,10 +990,10 @@ function toRef(kind, resolved, role) {
   return { kind, url: resolved.dataUrl, mime: resolved.mime, role };
 }
 async function resolveRefSpec(kind, spec, logger) {
-  const { path: path35, role } = parseRefSpec(spec);
-  if (kind === "image") return toRef(kind, await resolveImageInput(path35, logger), role);
-  if (kind === "video") return toRef(kind, await resolveVideoInput(path35, logger), role);
-  return toRef(kind, await resolveAudioInput(path35, logger), role);
+  const { path: path41, role } = parseRefSpec(spec);
+  if (kind === "image") return toRef(kind, await resolveImageInput(path41, logger), role);
+  if (kind === "video") return toRef(kind, await resolveVideoInput(path41, logger), role);
+  return toRef(kind, await resolveAudioInput(path41, logger), role);
 }
 async function resolveRefSpecs(specs, logger) {
   const out = [];
@@ -954,7 +1090,7 @@ function registerBytePlusReferenceToVideoCommand(parent) {
           logger.error(`Task succeeded but no video_url: ${JSON.stringify(final)}`);
           process.exit(1);
         }
-        const outPath = opts.output ?? path8.join(getOutputDir(), `byteplus-r2v-${taskId.slice(0, 8)}-${Date.now()}.mp4`);
+        const outPath = opts.output ?? path9.join(getOutputDir(), `byteplus-r2v-${taskId.slice(0, 8)}-${Date.now()}.mp4`);
         await downloadVideo(url, outPath, logger);
         await maybeDownloadThumb(final, outPath, {
           skip: opts.thumb === false,
@@ -976,146 +1112,919 @@ Task: ${taskId}`);
         throw e;
       }
     }
-  );
+  );
+}
+
+// src/providers/byteplus/commands/status.ts
+import path10 from "path";
+function registerBytePlusStatusCommand(parent) {
+  parent.command("status <taskId>").description("Get a Seedance task's status; --wait + --download to fetch the result MP4").option("--wait", "Poll until terminal status").option("--wait-timeout <ms>", "Poll timeout in ms (with --wait)", "600000").option("--download", "Download MP4 on success (implies --wait)").option("--output <path>", "Output MP4 path (with --download)").option("--no-thumb", "Skip downloading the thumbnail if the API returns one").option("-v, --verbose", "Verbose logging").action(
+    async (taskId, opts) => {
+      const logger = createLogger({ verbose: opts.verbose ?? false });
+      const client = createBytePlusClient();
+      const shouldWait = !!(opts.wait || opts.download);
+      try {
+        const status = shouldWait ? await waitForVideoTask(client, taskId, {
+          waitTimeoutMs: Number.parseInt(opts.waitTimeout, 10) || 6e5,
+          logger
+        }) : await getVideoTaskStatus(client, taskId, logger);
+        console.log(JSON.stringify(status, null, 2));
+        if (opts.download && status.status === "succeeded") {
+          const content = status.content;
+          const videoUrl = content?.video_url;
+          const fileUrl = content?.file_url;
+          if (videoUrl) {
+            const outPath = opts.output ?? path10.join(getOutputDir(), `byteplus-video-${taskId.slice(0, 8)}.mp4`);
+            await downloadVideo(videoUrl, outPath, logger);
+            await maybeDownloadThumb(status, outPath, {
+              skip: opts.thumb === false,
+              copyTo: opts.output,
+              logger
+            });
+            console.log(`Saved: ${outPath}`);
+          } else if (fileUrl) {
+            const ext = inferModelFileExt(fileUrl);
+            const outPath = opts.output ?? path10.join(getOutputDir(), `byteplus-3d-${taskId.slice(0, 8)}.${ext}`);
+            await downloadModelFile(fileUrl, outPath, logger);
+            console.log(`Saved: ${outPath}`);
+          } else {
+            logger.error("Task succeeded but no video_url or file_url present");
+            process.exit(1);
+          }
+        }
+      } catch (e) {
+        if (e instanceof PollTimeoutError) {
+          logger.error(`Timed out waiting for task ${taskId}`);
+          process.exit(1);
+        }
+        if (e instanceof PollFailedError) {
+          logger.error(`Task failed: ${JSON.stringify(e.value)}`);
+          process.exit(1);
+        }
+        throw e;
+      }
+    }
+  );
+}
+
+// src/providers/byteplus/commands/video.ts
+import path11 from "path";
+function registerBytePlusVideoCommand(parent) {
+  parent.command("video").description("Generate a video from a text prompt via BytePlus Seedance 2.0").requiredOption("--prompt <text>", "Text prompt").option("-m, --model <id>", "Model id", BYTEPLUS_DEFAULTS.videoModel).option("--resolution <r>", "480p|720p|1080p|2k", BYTEPLUS_DEFAULTS.videoResolution).option("--duration <n>", "Duration seconds (4-15)", String(BYTEPLUS_DEFAULTS.videoDuration)).option(
+    "--aspect-ratio <r>",
+    "Aspect ratio (16:9, 9:16, 1:1, ...)",
+    BYTEPLUS_DEFAULTS.videoAspectRatio
+  ).option("--audio", "Enable audio track").option("--no-audio", "Disable audio track").option("--seed <n>", "Fixed seed").option("--negative <text>", "Negative prompt").option("--camera-fixed", "Lock camera (no motion)").option("--async", "Submit task and exit; print taskId only").option("--wait-timeout <ms>", "Poll timeout in ms", "600000").option("--output <path>", "Output MP4 path").option("--no-thumb", "Skip downloading the thumbnail if the API returns one").option("-v, --verbose", "Verbose logging").action(
+    async (opts) => {
+      const logger = createLogger({ verbose: opts.verbose ?? false });
+      const client = createBytePlusClient();
+      const body = buildVideoTaskBody({
+        model: opts.model,
+        prompt: opts.prompt,
+        resolution: opts.resolution,
+        duration: Number.parseInt(opts.duration, 10),
+        aspectRatio: opts.aspectRatio,
+        audio: opts.audio,
+        seed: opts.seed ? Number.parseInt(opts.seed, 10) : void 0,
+        negativePrompt: opts.negative,
+        cameraFixed: opts.cameraFixed
+      });
+      logger.info(
+        `Submitting Seedance task (${opts.model}, ${opts.resolution}, ${opts.duration}s)`
+      );
+      const submitted = await submitVideoTask(client, body, logger);
+      const taskId = submitted.id;
+      logger.debug(`taskId: ${taskId}`);
+      if (opts.async) {
+        console.log(taskId);
+        console.error(`Poll with: multix byteplus status ${taskId}`);
+        return;
+      }
+      try {
+        const final = await waitForVideoTask(client, taskId, {
+          waitTimeoutMs: Number.parseInt(opts.waitTimeout, 10) || 6e5,
+          logger
+        });
+        const url = final.content?.video_url;
+        if (!url) {
+          logger.error(`Task succeeded but no video_url in response: ${JSON.stringify(final)}`);
+          process.exit(1);
+        }
+        const outPath = opts.output ?? path11.join(getOutputDir(), `byteplus-video-${taskId.slice(0, 8)}-${Date.now()}.mp4`);
+        await downloadVideo(url, outPath, logger);
+        await maybeDownloadThumb(final, outPath, {
+          skip: opts.thumb === false,
+          copyTo: opts.output,
+          logger
+        });
+        console.log(`
+Task: ${taskId}`);
+        console.log(`Saved: ${outPath}`);
+      } catch (e) {
+        if (e instanceof PollTimeoutError) {
+          logger.error(
+            `Polling timed out \u2014 try --async to keep the task and check later: multix byteplus status ${taskId}`
+          );
+          process.exit(1);
+        }
+        if (e instanceof PollFailedError) {
+          logger.error(`Task failed: ${JSON.stringify(e.value)}`);
+          process.exit(1);
+        }
+        throw e;
+      }
+    }
+  );
+}
+
+// src/providers/byteplus/commands/index.ts
+function registerBytePlusCommands(program2) {
+  const byteplus = program2.command("byteplus").description(
+    "BytePlus ModelArk: Seedream image, Seedance video, Hyper3D / Hitem3d 3D generation"
+  );
+  registerBytePlusGenerateCommand(byteplus);
+  registerBytePlusImageToImageCommand(byteplus);
+  registerBytePlusVideoCommand(byteplus);
+  registerBytePlusImageToVideoCommand(byteplus);
+  registerBytePlusReferenceToVideoCommand(byteplus);
+  registerBytePlusGenerate3DCommand(byteplus);
+  registerBytePlusStatusCommand(byteplus);
+}
+
+// src/providers/elevenlabs/client.ts
+import fs7 from "fs";
+import path12 from "path";
+init_errors();
+init_http_client();
+
+// src/providers/elevenlabs/models.ts
+var ELEVENLABS_BASE_URL = "https://api.elevenlabs.io/v1";
+var ELEVENLABS_TTS_MODELS = [
+  "eleven_v3",
+  "eleven_multilingual_v2",
+  "eleven_flash_v2_5",
+  "eleven_flash_v2",
+  "eleven_turbo_v2_5",
+  "eleven_turbo_v2"
+];
+var ELEVENLABS_STT_MODELS = ["scribe_v1", "scribe_v1_experimental"];
+var ELEVENLABS_OUTPUT_FORMATS = [
+  "mp3_22050_32",
+  "mp3_44100_32",
+  "mp3_44100_64",
+  "mp3_44100_96",
+  "mp3_44100_128",
+  "mp3_44100_192",
+  "pcm_8000",
+  "pcm_16000",
+  "pcm_22050",
+  "pcm_24000",
+  "pcm_44100",
+  "ulaw_8000"
+];
+var ELEVENLABS_RECOMMENDED_VOICES = {
+  alexandra: "kdmDKE6EkgrWrrykO9Qt",
+  archer: "L0Dsvb3SLTyegXwtm47J",
+  jessica_anne_bogart: "g6xIsTj2HwM6VR4iXFCw",
+  hope: "OYTbf65OHHFELVut7v2H",
+  eryn: "dj3G1R1ilKoFKhBnWOzG",
+  stuart: "HDA9tsk27wYi3uq0fPcK",
+  mark: "1SM7GgM6IMuvQlz2BwM3",
+  angela: "PT4nqlKZfc06VW1BuClj",
+  finn: "vBKc2FfBKJfcZNyEt1n6",
+  cassidy: "56AoDkrOh6qfVPDXZ7Pt",
+  grandpa_spuds_oxley: "NOpBlnGInO9m6vDvFkFC"
+};
+var TASK_DEFAULTS = {
+  ttsModel: "eleven_multilingual_v2",
+  ttsVoice: ELEVENLABS_RECOMMENDED_VOICES.alexandra,
+  ttsFormat: "mp3_44100_128",
+  sttModel: "scribe_v1",
+  voiceChangerModel: "eleven_multilingual_sts_v2",
+  sfxFormat: "mp3_44100_128",
+  musicFormat: "mp3_44100_128"
+};
+function extFromFormat(fmt) {
+  if (fmt.startsWith("mp3")) return "mp3";
+  if (fmt.startsWith("pcm")) return "pcm";
+  if (fmt.startsWith("ulaw")) return "ulaw";
+  return "mp3";
+}
+
+// src/providers/elevenlabs/client.ts
+var DEFAULT_TIMEOUT_MS2 = 12e4;
+function requireElevenLabsKey() {
+  const key = resolveKey("ELEVENLABS_API_KEY");
+  if (!key) {
+    throw new ConfigError(
+      "ELEVENLABS_API_KEY is not set. Get one at https://elevenlabs.io/app/settings/api-keys"
+    );
+  }
+  return key;
+}
+function authHeaders(apiKey, extra) {
+  return { "xi-api-key": apiKey, ...extra ?? {} };
+}
+function apiGet(endpoint, apiKey, query) {
+  const url = new URL(`${ELEVENLABS_BASE_URL}/${endpoint.replace(/^\//, "")}`);
+  if (query) {
+    for (const [k, v] of Object.entries(query)) {
+      if (v !== void 0 && v !== null) url.searchParams.set(k, String(v));
+    }
+  }
+  return httpJson({ url: url.toString(), headers: authHeaders(apiKey) });
+}
+function apiPostJson(endpoint, payload, apiKey, opts = {}) {
+  const url = new URL(`${ELEVENLABS_BASE_URL}/${endpoint.replace(/^\//, "")}`);
+  if (opts.query) {
+    for (const [k, v] of Object.entries(opts.query)) url.searchParams.set(k, v);
+  }
+  return httpJson({
+    url: url.toString(),
+    method: "POST",
+    headers: authHeaders(apiKey, { "Content-Type": "application/json" }),
+    body: payload,
+    timeoutMs: opts.timeoutMs ?? DEFAULT_TIMEOUT_MS2
+  });
+}
+async function apiDelete(endpoint, apiKey) {
+  const url = `${ELEVENLABS_BASE_URL}/${endpoint.replace(/^\//, "")}`;
+  const res = await globalThis.fetch(url, {
+    method: "DELETE",
+    headers: authHeaders(apiKey),
+    signal: AbortSignal.timeout(DEFAULT_TIMEOUT_MS2)
+  });
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    throw new HttpError(res.status, text.slice(0, 500), url);
+  }
+}
+async function apiPostBinary(endpoint, body, apiKey, opts = {}) {
+  const url = new URL(`${ELEVENLABS_BASE_URL}/${endpoint.replace(/^\//, "")}`);
+  if (opts.query) {
+    for (const [k, v] of Object.entries(opts.query)) url.searchParams.set(k, v);
+  }
+  const headers = authHeaders(apiKey);
+  let init;
+  if (body instanceof FormData) {
+    init = {
+      method: "POST",
+      headers,
+      body,
+      signal: AbortSignal.timeout(opts.timeoutMs ?? DEFAULT_TIMEOUT_MS2)
+    };
+  } else {
+    init = {
+      method: "POST",
+      headers: { ...headers, "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(opts.timeoutMs ?? DEFAULT_TIMEOUT_MS2)
+    };
+  }
+  let res;
+  try {
+    res = await globalThis.fetch(url.toString(), init);
+  } catch (cause) {
+    const msg = cause instanceof Error ? cause.message : String(cause);
+    throw new HttpError(0, msg, url.toString());
+  }
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    throw new HttpError(res.status, text.slice(0, 500), url.toString());
+  }
+  return Buffer.from(await res.arrayBuffer());
+}
+async function apiPostMultipart(endpoint, form, apiKey, opts = {}) {
+  const url = `${ELEVENLABS_BASE_URL}/${endpoint.replace(/^\//, "")}`;
+  let res;
+  try {
+    res = await globalThis.fetch(url, {
+      method: "POST",
+      headers: authHeaders(apiKey),
+      body: form,
+      signal: AbortSignal.timeout(opts.timeoutMs ?? DEFAULT_TIMEOUT_MS2)
+    });
+  } catch (cause) {
+    const msg = cause instanceof Error ? cause.message : String(cause);
+    throw new HttpError(0, msg, url);
+  }
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    throw new HttpError(res.status, text.slice(0, 500), url);
+  }
+  return res.json();
+}
+function readFileAsBlob(filePath, fieldFilename) {
+  const abs = path12.resolve(filePath);
+  if (!fs7.existsSync(abs)) throw new ValidationError(`File not found: ${abs}`);
+  const buf = fs7.readFileSync(abs);
+  const name = fieldFilename ?? path12.basename(abs);
+  return new File([new Uint8Array(buf)], name);
+}
+async function pollUntil(fetchStatus, isDone, isFailed, opts = {}) {
+  const { intervalMs = 5e3, timeoutMs = 6e5, logger, label = "task" } = opts;
+  const deadline = Date.now() + timeoutMs;
+  let elapsed = 0;
+  while (Date.now() < deadline) {
+    const cur = await fetchStatus();
+    if (isDone(cur)) return cur;
+    if (isFailed(cur)) {
+      throw new ProviderError(`${label} failed: ${JSON.stringify(cur)}`, "elevenlabs");
+    }
+    if (elapsed > 0 && elapsed % 3e4 < intervalMs) {
+      logger?.debug(`Polling ${label}... ${Math.round(elapsed / 1e3)}s, status=${cur.status}`);
+    }
+    await new Promise((r) => setTimeout(r, intervalMs));
+    elapsed += intervalMs;
+  }
+  throw new ProviderError(`${label} timed out after ${timeoutMs / 1e3}s`, "elevenlabs");
+}
+function saveBytes(opts) {
+  const { bytes, task, ext, outputCopy, logger } = opts;
+  const dir = getOutputDir();
+  const dest = path12.join(dir, `elevenlabs_${task}_${Date.now()}.${ext}`);
+  fs7.writeFileSync(dest, bytes);
+  logger?.success(`Saved: ${dest} (${(bytes.length / 1024).toFixed(1)} KB)`);
+  if (outputCopy) {
+    fs7.mkdirSync(path12.dirname(path12.resolve(outputCopy)), { recursive: true });
+    fs7.copyFileSync(dest, outputCopy);
+  }
+  return dest;
+}
+
+// src/providers/elevenlabs/commands/account.ts
+function registerAccountCommands(parent) {
+  parent.command("account").description("Show ElevenLabs account info, subscription tier, and usage").action(async () => {
+    const apiKey = requireElevenLabsKey();
+    const user = await apiGet("user", apiKey);
+    const sub = user.subscription ?? {};
+    console.log(`Tier:           ${sub.tier ?? "?"}`);
+    console.log(`Characters:     ${sub.character_count ?? "?"} / ${sub.character_limit ?? "?"}`);
+    if (sub.next_character_count_reset_unix) {
+      console.log(
+        `Resets:         ${new Date(sub.next_character_count_reset_unix * 1e3).toISOString()}`
+      );
+    }
+    console.log(
+      `Voice slots:    ${sub.voice_limit ?? "?"} (PVC: ${sub.professional_voice_limit ?? 0})`
+    );
+    if (user.first_name) console.log(`Name:           ${user.first_name}`);
+  });
+  parent.command("models").description("List available ElevenLabs models").action(async () => {
+    const apiKey = requireElevenLabsKey();
+    const models = await apiGet("models", apiKey);
+    for (const m of models) {
+      const caps = [];
+      if (m.can_do_text_to_speech) caps.push("tts");
+      if (m.can_do_voice_conversion) caps.push("vc");
+      const langs = m.languages?.length ? `${m.languages.length} langs` : "";
+      console.log(`${m.model_id}	${m.name ?? ""}	[${caps.join(",")}] ${langs}`);
+    }
+    console.log(`
+${models.length} models`);
+  });
+}
+
+// src/providers/elevenlabs/commands/align.ts
+import fs8 from "fs";
+import path13 from "path";
+function registerAlignCommand(parent) {
+  parent.command("align").description("Forced alignment of audio to a transcript (returns word/char timestamps)").requiredOption("--input <path>", "Source audio file").requiredOption("--text <str>", "Transcript text (or pass --text-file)").option("--text-file <path>", "Read transcript from file").option("--output <path>", "Save JSON to this path (default: multix-output)").option("-v, --verbose", "Verbose logging").action(async (opts) => {
+    const logger = createLogger({ verbose: opts.verbose ?? false });
+    const apiKey = requireElevenLabsKey();
+    let text = opts.text;
+    if (opts.textFile) text = fs8.readFileSync(path13.resolve(opts.textFile), "utf8");
+    const form = new FormData();
+    form.append("file", readFileAsBlob(opts.input));
+    form.append("text", text);
+    logger.debug(`Aligning ${opts.input} (${text.length} chars)`);
+    const data = await apiPostMultipart("forced-alignment", form, apiKey, {
+      timeoutMs: 6e5
+    });
+    const dest = opts.output ? path13.resolve(opts.output) : path13.join(getOutputDir(), `elevenlabs_align_${Date.now()}.json`);
+    fs8.mkdirSync(path13.dirname(dest), { recursive: true });
+    fs8.writeFileSync(dest, JSON.stringify(data, null, 2));
+    logger.success(`Saved alignment: ${dest}`);
+    if (data.words) console.log(`Aligned ${data.words.length} words (loss=${data.loss ?? "?"})`);
+  });
+}
+
+// src/providers/elevenlabs/commands/clone.ts
+init_errors();
+function registerCloneCommand(parent) {
+  parent.command("clone").description("Instant voice cloning from local audio samples").requiredOption("--name <n>", "Display name for the new voice").option("--files <paths...>", "One or more audio sample files (1-3 minutes total)").option("--audio <path>", "Single sample file (alias for --files)").option("--description <d>", "Voice description").option("--labels <kv>", `JSON object of labels, e.g. '{"accent":"american"}'`).option("--remove-background-noise", "Server-side noise removal", false).option("-v, --verbose", "Verbose logging").action(async (opts) => {
+    const logger = createLogger({ verbose: opts.verbose ?? false });
+    const apiKey = requireElevenLabsKey();
+    const files = opts.files ?? (opts.audio ? [opts.audio] : []);
+    if (files.length === 0) {
+      throw new ValidationError("Provide --files <p1> <p2>... or --audio <path>");
+    }
+    const form = new FormData();
+    form.append("name", opts.name);
+    if (opts.description) form.append("description", opts.description);
+    if (opts.labels) {
+      try {
+        JSON.parse(opts.labels);
+        form.append("labels", opts.labels);
+      } catch {
+        throw new ValidationError("--labels must be valid JSON");
+      }
+    }
+    if (opts.removeBackgroundNoise) form.append("remove_background_noise", "true");
+    for (const f of files) form.append("files", readFileAsBlob(f));
+    logger.debug(`Cloning ${files.length} sample(s) as "${opts.name}"`);
+    const data = await apiPostMultipart("voices/add", form, apiKey, {
+      timeoutMs: 3e5
+    });
+    console.log(`Created voice: ${data.voice_id}`);
+    if (data.requires_verification) {
+      console.warn("Voice requires verification before use (PVC pipeline).");
+    }
+  });
+}
+
+// src/providers/elevenlabs/commands/dub.ts
+init_errors();
+init_http_client();
+import fs9 from "fs";
+import path14 from "path";
+function registerDubCommand(parent) {
+  parent.command("dub").description("Dub a video/audio file into target languages (async)").option("--input <path>", "Source media file (use --input or --source-url)").option("--source-url <url>", "Public URL of source media").requiredOption("--target-lang <code>", "Target language ISO code (e.g. es, fr, de)").option("--source-lang <code>", "Source language (auto if omitted)").option("--num-speakers <n>", "Speaker count (auto if omitted)").option("--watermark", "Add ElevenLabs watermark", false).option("--start-time <s>", "Start time in seconds").option("--end-time <s>", "End time in seconds").option("--highest-resolution", "Use highest resolution video", false).option("--name <n>", "Project display name").option("--async", "Return job id immediately, do not wait", false).option("--wait", "Wait until status=dubbed (implied by --download)", false).option("--download", "Download dubbed media when ready", false).option("--poll-interval <s>", "Poll interval seconds", "10").option("--wait-timeout <ms>", "Poll timeout", "1800000").option("--output <path>", "Output path for downloaded dub").option("-v, --verbose", "Verbose logging").action(async (opts) => {
+    const logger = createLogger({ verbose: opts.verbose ?? false });
+    const apiKey = requireElevenLabsKey();
+    if (!opts.input && !opts.sourceUrl) {
+      throw new ValidationError("Provide --input <path> or --source-url <url>");
+    }
+    const form = new FormData();
+    if (opts.input) form.append("file", readFileAsBlob(opts.input));
+    if (opts.sourceUrl) form.append("source_url", opts.sourceUrl);
+    form.append("target_lang", opts.targetLang);
+    if (opts.sourceLang) form.append("source_lang", opts.sourceLang);
+    if (opts.numSpeakers) form.append("num_speakers", opts.numSpeakers);
+    if (opts.watermark) form.append("watermark", "true");
+    if (opts.startTime) form.append("start_time", opts.startTime);
+    if (opts.endTime) form.append("end_time", opts.endTime);
+    if (opts.highestResolution) form.append("highest_resolution", "true");
+    if (opts.name) form.append("name", opts.name);
+    logger.debug(`Submitting dub -> ${opts.targetLang}`);
+    const start = await apiPostMultipart("dubbing", form, apiKey, {
+      timeoutMs: 6e5
+    });
+    console.log(
+      `Dubbing job: ${start.dubbing_id} (expected ~${start.expected_duration_sec ?? "?"}s)`
+    );
+    if (opts.async && !opts.wait && !opts.download) {
+      console.log("Run `multix elevenlabs dub-status <id>` to check progress.");
+      return;
+    }
+    const final = await pollUntil(
+      () => apiGet(`dubbing/${start.dubbing_id}`, apiKey),
+      (s) => s.status === "dubbed",
+      (s) => s.status === "failed",
+      {
+        intervalMs: Number.parseInt(opts.pollInterval, 10) * 1e3,
+        timeoutMs: Number.parseInt(opts.waitTimeout, 10),
+        logger,
+        label: `dub ${start.dubbing_id}`
+      }
+    );
+    logger.success(`Dub complete: ${start.dubbing_id}`);
+    if (opts.download) {
+      const dest = opts.output ? path14.resolve(opts.output) : path14.join(getOutputDir(), `elevenlabs_dub_${start.dubbing_id}_${opts.targetLang}.mp4`);
+      const url = `${ELEVENLABS_BASE_URL}/dubbing/${start.dubbing_id}/audio/${opts.targetLang}`;
+      await downloadDub(url, apiKey, dest);
+      logger.success(`Saved: ${dest}`);
+      console.log(`
+Dubbed file: ${dest}`);
+    } else {
+      console.log(`Languages ready: ${(final.target_languages ?? []).join(", ")}`);
+    }
+  });
+  parent.command("dub-status <dubbingId>").description("Check dubbing status / list available languages").option("--download <lang>", "Download dubbed file for a language code").option("--output <path>", "Output path").action(async (dubbingId, opts) => {
+    const apiKey = requireElevenLabsKey();
+    const status = await apiGet(`dubbing/${dubbingId}`, apiKey);
+    console.log(JSON.stringify(status, null, 2));
+    if (opts.download) {
+      const dest = opts.output ? path14.resolve(opts.output) : path14.join(getOutputDir(), `elevenlabs_dub_${dubbingId}_${opts.download}.mp4`);
+      const url = `${ELEVENLABS_BASE_URL}/dubbing/${dubbingId}/audio/${opts.download}`;
+      await downloadDub(url, apiKey, dest);
+      console.log(`Saved: ${dest}`);
+    }
+  });
+}
+async function downloadDub(url, apiKey, dest) {
+  fs9.mkdirSync(path14.dirname(dest), { recursive: true });
+  const res = await globalThis.fetch(url, {
+    headers: { "xi-api-key": apiKey },
+    signal: AbortSignal.timeout(6e5)
+  });
+  if (!res.ok || !res.body) {
+    throw new Error(`Failed to download dub: HTTP ${res.status}`);
+  }
+  const arr = new Uint8Array(await res.arrayBuffer());
+  fs9.writeFileSync(dest, arr);
+  void downloadFile;
+}
+
+// src/providers/elevenlabs/commands/isolate.ts
+function registerIsolateCommand(parent) {
+  parent.command("isolate").description("Voice isolator: strip background noise from audio").requiredOption("--input <path>", "Source audio/video file").option("--output <path>", "Copy isolated audio to this path").option("-v, --verbose", "Verbose logging").action(async (opts) => {
+    const logger = createLogger({ verbose: opts.verbose ?? false });
+    const apiKey = requireElevenLabsKey();
+    const form = new FormData();
+    form.append("audio", readFileAsBlob(opts.input));
+    logger.debug(`Isolating ${opts.input}`);
+    const bytes = await apiPostBinary("audio-isolation", form, apiKey, {
+      timeoutMs: 6e5
+    });
+    const dest = saveBytes({
+      bytes,
+      task: "isolate",
+      ext: "mp3",
+      outputCopy: opts.output,
+      logger
+    });
+    console.log(`
+Isolated audio: ${dest}`);
+  });
+}
+
+// src/providers/elevenlabs/commands/music.ts
+init_errors();
+import fs10 from "fs";
+import path15 from "path";
+function registerMusicCommand(parent) {
+  parent.command("music").description("Generate music from a text prompt or composition plan").option("--prompt <str>", "Music prompt (mutually exclusive with --plan)").option("--plan <path>", "Path to composition plan JSON file").option("--music-length-ms <n>", "Total length in milliseconds (default 30000)").option("--model <id>", "Music model", "music_v1").option(
+    "--format <fmt>",
+    `Output format (${[...ELEVENLABS_OUTPUT_FORMATS].join("|")})`,
+    TASK_DEFAULTS.musicFormat
+  ).option("--output <path>", "Copy to this path").option("-v, --verbose", "Verbose logging").action(async (opts) => {
+    const logger = createLogger({ verbose: opts.verbose ?? false });
+    const apiKey = requireElevenLabsKey();
+    if (!opts.prompt && !opts.plan) {
+      throw new ValidationError("Provide --prompt or --plan");
+    }
+    const payload = { model_id: opts.model };
+    if (opts.prompt) payload.prompt = opts.prompt;
+    if (opts.plan) {
+      const planPath = path15.resolve(opts.plan);
+      if (!fs10.existsSync(planPath)) throw new ValidationError(`Plan file not found: ${planPath}`);
+      const planJson = JSON.parse(fs10.readFileSync(planPath, "utf8"));
+      payload.composition_plan = planJson;
+    }
+    if (opts.musicLengthMs) payload.music_length_ms = Number.parseInt(opts.musicLengthMs, 10);
+    logger.debug(`Music gen with model ${opts.model}`);
+    const bytes = await apiPostBinary("music", payload, apiKey, {
+      query: { output_format: opts.format },
+      timeoutMs: 6e5
+    });
+    const dest = saveBytes({
+      bytes,
+      task: "music",
+      ext: extFromFormat(opts.format),
+      outputCopy: opts.output,
+      logger
+    });
+    console.log(`
+Generated music: ${dest}`);
+  });
+}
+
+// src/providers/elevenlabs/commands/sfx.ts
+function registerSfxCommand(parent) {
+  parent.command("sfx").description("Generate sound effects from a text prompt").option("--text <str>", "Sound description (alias: --prompt)").option("--prompt <str>", "Alias for --text").option("--duration-seconds <n>", "Target duration 0.5..30 (auto if omitted)").option("--prompt-influence <n>", "0..1 (default 0.3)", "0.3").option("--loop", "Loop-friendly output", false).option(
+    "--format <fmt>",
+    `Output format (${[...ELEVENLABS_OUTPUT_FORMATS].join("|")})`,
+    TASK_DEFAULTS.sfxFormat
+  ).option("--output <path>", "Copy to this path").option("-v, --verbose", "Verbose logging").action(async (opts) => {
+    const logger = createLogger({ verbose: opts.verbose ?? false });
+    const apiKey = requireElevenLabsKey();
+    const text = opts.text ?? opts.prompt;
+    if (!text) {
+      const { ValidationError: ValidationError2 } = await Promise.resolve().then(() => (init_errors(), errors_exports));
+      throw new ValidationError2("--text or --prompt is required");
+    }
+    const payload = {
+      text,
+      prompt_influence: Number.parseFloat(opts.promptInfluence),
+      loop: opts.loop
+    };
+    if (opts.durationSeconds) payload.duration_seconds = Number.parseFloat(opts.durationSeconds);
+    logger.debug(`SFX: "${text.slice(0, 60)}..."`);
+    const bytes = await apiPostBinary("sound-generation", payload, apiKey, {
+      query: { output_format: opts.format },
+      timeoutMs: 3e5
+    });
+    const dest = saveBytes({
+      bytes,
+      task: "sfx",
+      ext: extFromFormat(opts.format),
+      outputCopy: opts.output,
+      logger
+    });
+    console.log(`
+Generated SFX: ${dest}`);
+  });
+}
+
+// src/providers/elevenlabs/commands/transcribe.ts
+import fs11 from "fs";
+import path16 from "path";
+function registerTranscribeCommand(parent) {
+  parent.command("transcribe").description("Speech-to-text transcription with Scribe").requiredOption("--input <path>", "Audio or video file to transcribe").option(
+    "--model <id>",
+    `STT model (${[...ELEVENLABS_STT_MODELS].join("|")})`,
+    TASK_DEFAULTS.sttModel
+  ).option("--language <code>", "ISO language code (e.g. en); auto-detect if omitted").option("--diarize", "Speaker diarization", false).option("--num-speakers <n>", "Hint for speaker count").option("--tag-audio-events", "Tag laughter/applause/etc.", false).option("--timestamps-granularity <g>", "none|word|character", "word").option("--format <f>", "text|json|srt|vtt", "text").option("--output <path>", "Save to this path (defaults to multix-output)").option("-v, --verbose", "Verbose logging").action(async (opts) => {
+    const logger = createLogger({ verbose: opts.verbose ?? false });
+    const apiKey = requireElevenLabsKey();
+    const form = new FormData();
+    form.append("file", readFileAsBlob(opts.input));
+    form.append("model_id", opts.model);
+    if (opts.language) form.append("language_code", opts.language);
+    if (opts.diarize) form.append("diarize", "true");
+    if (opts.numSpeakers) form.append("num_speakers", opts.numSpeakers);
+    if (opts.tagAudioEvents) form.append("tag_audio_events", "true");
+    form.append("timestamps_granularity", opts.timestampsGranularity);
+    logger.debug(`Transcribing ${opts.input} (model=${opts.model})`);
+    const data = await apiPostMultipart("speech-to-text", form, apiKey, {
+      timeoutMs: 6e5
+    });
+    const ext = opts.format === "json" ? "json" : opts.format === "srt" ? "srt" : opts.format === "vtt" ? "vtt" : "txt";
+    const dir = getOutputDir();
+    const dest = opts.output ? path16.resolve(opts.output) : path16.join(dir, `elevenlabs_transcribe_${Date.now()}.${ext}`);
+    let body;
+    switch (opts.format) {
+      case "json":
+        body = JSON.stringify(data, null, 2);
+        break;
+      case "srt":
+        body = wordsToSrt(data.words ?? []);
+        break;
+      case "vtt":
+        body = wordsToVtt(data.words ?? []);
+        break;
+      default:
+        body = data.text ?? "";
+    }
+    fs11.mkdirSync(path16.dirname(dest), { recursive: true });
+    fs11.writeFileSync(dest, body);
+    logger.success(`Saved transcript: ${dest}`);
+    if (data.language_code) {
+      logger.info(
+        `Detected language: ${data.language_code} (p=${data.language_probability ?? "?"})`
+      );
+    }
+    if (opts.format === "text") console.log(`
+${body.trim()}`);
+  });
+}
+function fmtTimeSrt(s) {
+  const hh = Math.floor(s / 3600).toString().padStart(2, "0");
+  const mm = Math.floor(s % 3600 / 60).toString().padStart(2, "0");
+  const ss = Math.floor(s % 60).toString().padStart(2, "0");
+  const ms = Math.round((s - Math.floor(s)) * 1e3).toString().padStart(3, "0");
+  return `${hh}:${mm}:${ss},${ms}`;
+}
+function fmtTimeVtt(s) {
+  return fmtTimeSrt(s).replace(",", ".");
+}
+function wordsToSrt(words) {
+  const lines = [];
+  words.forEach((w, i) => {
+    if (w.start === void 0 || w.end === void 0) return;
+    lines.push(`${i + 1}
+${fmtTimeSrt(w.start)} --> ${fmtTimeSrt(w.end)}
+${w.text}
+`);
+  });
+  return lines.join("\n");
+}
+function wordsToVtt(words) {
+  const lines = ["WEBVTT", ""];
+  for (const w of words) {
+    if (w.start === void 0 || w.end === void 0) continue;
+    lines.push(`${fmtTimeVtt(w.start)} --> ${fmtTimeVtt(w.end)}`);
+    lines.push(w.text);
+    lines.push("");
+  }
+  return lines.join("\n");
 }
 
-// src/providers/byteplus/commands/status.ts
-import path9 from "path";
-function registerBytePlusStatusCommand(parent) {
-  parent.command("status <taskId>").description("Get a Seedance task's status; --wait + --download to fetch the result MP4").option("--wait", "Poll until terminal status").option("--wait-timeout <ms>", "Poll timeout in ms (with --wait)", "600000").option("--download", "Download MP4 on success (implies --wait)").option("--output <path>", "Output MP4 path (with --download)").option("--no-thumb", "Skip downloading the thumbnail if the API returns one").option("-v, --verbose", "Verbose logging").action(
-    async (taskId, opts) => {
-      const logger = createLogger({ verbose: opts.verbose ?? false });
-      const client = createBytePlusClient();
-      const shouldWait = !!(opts.wait || opts.download);
-      try {
-        const status = shouldWait ? await waitForVideoTask(client, taskId, {
-          waitTimeoutMs: Number.parseInt(opts.waitTimeout, 10) || 6e5,
-          logger
-        }) : await getVideoTaskStatus(client, taskId, logger);
-        console.log(JSON.stringify(status, null, 2));
-        if (opts.download && status.status === "succeeded") {
-          const url = status.content?.video_url;
-          if (!url) {
-            logger.error("Task succeeded but no video_url present");
-            process.exit(1);
-          }
-          const outPath = opts.output ?? path9.join(getOutputDir(), `byteplus-video-${taskId.slice(0, 8)}.mp4`);
-          await downloadVideo(url, outPath, logger);
-          await maybeDownloadThumb(status, outPath, {
-            skip: opts.thumb === false,
-            copyTo: opts.output,
-            logger
-          });
-          console.log(`Saved: ${outPath}`);
-        }
-      } catch (e) {
-        if (e instanceof PollTimeoutError) {
-          logger.error(`Timed out waiting for task ${taskId}`);
-          process.exit(1);
-        }
-        if (e instanceof PollFailedError) {
-          logger.error(`Task failed: ${JSON.stringify(e.value)}`);
-          process.exit(1);
-        }
-        throw e;
+// src/providers/elevenlabs/commands/tts.ts
+init_errors();
+function registerTtsCommand(parent) {
+  parent.command("tts").description("Text-to-speech (returns audio synchronously)").option("--text <str>", "Text to speak (use --text or --prompt)").option("--prompt <str>", "Alias for --text").option("--voice <id>", "Voice ID", TASK_DEFAULTS.ttsVoice).option(
+    "--model <id>",
+    `TTS model (${[...ELEVENLABS_TTS_MODELS].join("|")})`,
+    TASK_DEFAULTS.ttsModel
+  ).option(
+    "--format <fmt>",
+    `Output format (${[...ELEVENLABS_OUTPUT_FORMATS].join("|")})`,
+    TASK_DEFAULTS.ttsFormat
+  ).option("--stability <n>", "Voice stability 0..1", "0.5").option("--similarity-boost <n>", "Voice similarity boost 0..1", "0.75").option("--style <n>", "Style exaggeration 0..1", "0.0").option("--no-speaker-boost", "Disable speaker boost (default: enabled)").option("--language-code <code>", "ISO language code (Flash/Turbo/v3 only)").option("--seed <n>", "Determinism seed (0..4294967295)").option("--previous-text <str>", "Preceding text for context continuity").option("--next-text <str>", "Following text for context continuity").option("--output <path>", "Copy generated audio to this path").option("-v, --verbose", "Verbose logging").action(async (opts) => {
+    const logger = createLogger({ verbose: opts.verbose ?? false });
+    const apiKey = requireElevenLabsKey();
+    const text = opts.text ?? opts.prompt;
+    if (!text) throw new ValidationError("Either --text or --prompt is required");
+    if (!opts.voice) throw new ValidationError("--voice <id> is required");
+    const payload = {
+      text,
+      model_id: opts.model,
+      voice_settings: {
+        stability: Number.parseFloat(opts.stability),
+        similarity_boost: Number.parseFloat(opts.similarityBoost),
+        style: Number.parseFloat(opts.style),
+        use_speaker_boost: opts.speakerBoost
       }
+    };
+    if (opts.languageCode) payload.language_code = opts.languageCode;
+    if (opts.seed !== void 0) payload.seed = Number.parseInt(opts.seed, 10);
+    if (opts.previousText) payload.previous_text = opts.previousText;
+    if (opts.nextText) payload.next_text = opts.nextText;
+    logger.debug(`TTS voice=${opts.voice} model=${opts.model} fmt=${opts.format}`);
+    const bytes = await apiPostBinary(`text-to-speech/${opts.voice}`, payload, apiKey, {
+      query: { output_format: opts.format }
+    });
+    const dest = saveBytes({
+      bytes,
+      task: "tts",
+      ext: extFromFormat(opts.format),
+      outputCopy: opts.output,
+      logger
+    });
+    console.log(`
+Generated audio: ${dest}`);
+  });
+}
+
+// src/providers/elevenlabs/commands/voice-changer.ts
+init_errors();
+function registerVoiceChangerCommand(parent) {
+  parent.command("voice-changer").description("Speech-to-speech: transform an audio file to use a different voice").requiredOption("--input <path>", "Source audio file").requiredOption("--voice <id>", "Target voice ID").option("--model <id>", "Voice changer model", TASK_DEFAULTS.voiceChangerModel).option(
+    "--format <fmt>",
+    `Output format (${[...ELEVENLABS_OUTPUT_FORMATS].join("|")})`,
+    TASK_DEFAULTS.ttsFormat
+  ).option("--remove-background-noise", "Server-side noise removal", false).option("--stability <n>", "0..1", "0.5").option("--similarity-boost <n>", "0..1", "0.75").option("--style <n>", "0..1", "0.0").option("--output <path>", "Copy output to this path").option("-v, --verbose", "Verbose logging").action(async (opts) => {
+    const logger = createLogger({ verbose: opts.verbose ?? false });
+    const apiKey = requireElevenLabsKey();
+    const form = new FormData();
+    form.append("audio", readFileAsBlob(opts.input));
+    form.append("model_id", opts.model);
+    form.append(
+      "voice_settings",
+      JSON.stringify({
+        stability: Number.parseFloat(opts.stability),
+        similarity_boost: Number.parseFloat(opts.similarityBoost),
+        style: Number.parseFloat(opts.style)
+      })
+    );
+    if (opts.removeBackgroundNoise) form.append("remove_background_noise", "true");
+    logger.debug(`Voice changer voice=${opts.voice} input=${opts.input}`);
+    const bytes = await apiPostBinary(`speech-to-speech/${opts.voice}`, form, apiKey, {
+      query: { output_format: opts.format },
+      timeoutMs: 3e5
+    });
+    if (!bytes || bytes.length === 0) {
+      throw new ValidationError("Empty response from voice-changer");
     }
-  );
+    const dest = saveBytes({
+      bytes,
+      task: "voice_changer",
+      ext: extFromFormat(opts.format),
+      outputCopy: opts.output,
+      logger
+    });
+    console.log(`
+Generated audio: ${dest}`);
+  });
 }
 
-// src/providers/byteplus/commands/video.ts
-import path10 from "path";
-function registerBytePlusVideoCommand(parent) {
-  parent.command("video").description("Generate a video from a text prompt via BytePlus Seedance 2.0").requiredOption("--prompt <text>", "Text prompt").option("-m, --model <id>", "Model id", BYTEPLUS_DEFAULTS.videoModel).option("--resolution <r>", "480p|720p|1080p|2k", BYTEPLUS_DEFAULTS.videoResolution).option("--duration <n>", "Duration seconds (4-15)", String(BYTEPLUS_DEFAULTS.videoDuration)).option(
-    "--aspect-ratio <r>",
-    "Aspect ratio (16:9, 9:16, 1:1, ...)",
-    BYTEPLUS_DEFAULTS.videoAspectRatio
-  ).option("--audio", "Enable audio track").option("--no-audio", "Disable audio track").option("--seed <n>", "Fixed seed").option("--negative <text>", "Negative prompt").option("--camera-fixed", "Lock camera (no motion)").option("--async", "Submit task and exit; print taskId only").option("--wait-timeout <ms>", "Poll timeout in ms", "600000").option("--output <path>", "Output MP4 path").option("--no-thumb", "Skip downloading the thumbnail if the API returns one").option("-v, --verbose", "Verbose logging").action(
-    async (opts) => {
-      const logger = createLogger({ verbose: opts.verbose ?? false });
-      const client = createBytePlusClient();
-      const body = buildVideoTaskBody({
-        model: opts.model,
-        prompt: opts.prompt,
-        resolution: opts.resolution,
-        duration: Number.parseInt(opts.duration, 10),
-        aspectRatio: opts.aspectRatio,
-        audio: opts.audio,
-        seed: opts.seed ? Number.parseInt(opts.seed, 10) : void 0,
-        negativePrompt: opts.negative,
-        cameraFixed: opts.cameraFixed
+// src/providers/elevenlabs/commands/voices.ts
+init_errors();
+function registerVoicesCommand(parent) {
+  const voices = parent.command("voices").description("Voice library: list, get, search, design");
+  voices.command("list").description("List voices in your account").option("--category <c>", "Filter category (cloned, generated, premade, professional)").option("--page-size <n>", "Voices per page", "100").option("-v, --verbose", "Verbose logging").action(async (opts) => {
+    const apiKey = requireElevenLabsKey();
+    const data = await apiGet("voices", apiKey, {
+      category: opts.category,
+      page_size: opts.pageSize
+    });
+    for (const v of data.voices) {
+      const labels = v.labels ? ` [${Object.values(v.labels).join(", ")}]` : "";
+      console.log(`${v.voice_id}	${v.name}	(${v.category ?? "?"})${labels}`);
+    }
+    console.log(`
+${data.voices.length} voices`);
+  });
+  voices.command("get <voiceId>").description("Get a voice's metadata").action(async (voiceId) => {
+    const apiKey = requireElevenLabsKey();
+    const data = await apiGet(`voices/${voiceId}`, apiKey);
+    console.log(JSON.stringify(data, null, 2));
+  });
+  voices.command("search").description("Search the public Voices Library (shared voices)").option("--search <term>", "Search query").option("--language <code>", "Language filter, e.g. en, es").option("--gender <g>", "male|female|neutral").option("--age <a>", "young|middle_aged|old").option("--accent <a>", "Accent filter, e.g. american, british").option("--category <c>", "Category filter").option("--page-size <n>", "Results per page", "30").action(async (opts) => {
+    const apiKey = requireElevenLabsKey();
+    const data = await apiGet("shared-voices", apiKey, {
+      search: opts.search,
+      language: opts.language,
+      gender: opts.gender,
+      age: opts.age,
+      accent: opts.accent,
+      category: opts.category,
+      page_size: opts.pageSize
+    });
+    for (const v of data.voices) {
+      console.log(`${v.voice_id}	${v.name}	${v.description ?? ""}`);
+    }
+    console.log(`
+${data.voices.length} voices${data.has_more ? " (more available)" : ""}`);
+  });
+  voices.command("design").description("Design a voice from text description (returns previews)").requiredOption("--description <str>", "Voice description (e.g. 'friendly female narrator')").option("--text <str>", "Sample text to generate previews from").option("--auto-text", "Let ElevenLabs generate sample text", false).option("--model <id>", "Voice design model", "eleven_multilingual_ttv_v2").option("--output-prefix <p>", "Filename prefix (default: design)", "design").option("-v, --verbose", "Verbose logging").action(async (opts) => {
+    const logger = createLogger({ verbose: opts.verbose ?? false });
+    const apiKey = requireElevenLabsKey();
+    if (!opts.autoText && !opts.text) {
+      throw new ValidationError("Provide --text or pass --auto-text");
+    }
+    const payload = {
+      voice_description: opts.description,
+      model_id: opts.model,
+      auto_generate_text: opts.autoText
+    };
+    if (opts.text) payload.text = opts.text;
+    const data = await apiPostJson(
+      "text-to-voice/create-previews",
+      payload,
+      apiKey
+    );
+    logger.success(`${data.previews.length} previews generated`);
+    data.previews.forEach((p, i) => {
+      const bytes = Buffer.from(p.audio_base_64, "base64");
+      const dest = saveBytes({
+        bytes,
+        task: `${opts.outputPrefix}_${i + 1}_${p.generated_voice_id}`,
+        ext: extFromFormat(TASK_DEFAULTS.ttsFormat),
+        logger
       });
-      logger.info(
-        `Submitting Seedance task (${opts.model}, ${opts.resolution}, ${opts.duration}s)`
-      );
-      const submitted = await submitVideoTask(client, body, logger);
-      const taskId = submitted.id;
-      logger.debug(`taskId: ${taskId}`);
-      if (opts.async) {
-        console.log(taskId);
-        console.error(`Poll with: multix byteplus status ${taskId}`);
-        return;
-      }
-      try {
-        const final = await waitForVideoTask(client, taskId, {
-          waitTimeoutMs: Number.parseInt(opts.waitTimeout, 10) || 6e5,
-          logger
-        });
-        const url = final.content?.video_url;
-        if (!url) {
-          logger.error(`Task succeeded but no video_url in response: ${JSON.stringify(final)}`);
-          process.exit(1);
-        }
-        const outPath = opts.output ?? path10.join(getOutputDir(), `byteplus-video-${taskId.slice(0, 8)}-${Date.now()}.mp4`);
-        await downloadVideo(url, outPath, logger);
-        await maybeDownloadThumb(final, outPath, {
-          skip: opts.thumb === false,
-          copyTo: opts.output,
-          logger
-        });
-        console.log(`
-Task: ${taskId}`);
-        console.log(`Saved: ${outPath}`);
-      } catch (e) {
-        if (e instanceof PollTimeoutError) {
-          logger.error(
-            `Polling timed out \u2014 try --async to keep the task and check later: multix byteplus status ${taskId}`
-          );
-          process.exit(1);
-        }
-        if (e instanceof PollFailedError) {
-          logger.error(`Task failed: ${JSON.stringify(e.value)}`);
-          process.exit(1);
-        }
-        throw e;
-      }
+      console.log(`Preview ${i + 1}: voice_id=${p.generated_voice_id}  file=${dest}`);
+    });
+    console.log(
+      '\nTo finalize: multix elevenlabs voices create-from-preview --generated-voice-id <id> --name "..." --description "..."'
+    );
+  });
+  voices.command("create-from-preview").description("Persist a designed voice into your library").requiredOption("--generated-voice-id <id>", "ID returned by `voices design`").requiredOption("--name <n>", "Display name").requiredOption("--description <d>", "Voice description").option("--played-not-selected-voice-ids <csv>", "Other previews you considered (CSV)").action(async (opts) => {
+    const apiKey = requireElevenLabsKey();
+    const payload = {
+      generated_voice_id: opts.generatedVoiceId,
+      voice_name: opts.name,
+      voice_description: opts.description
+    };
+    if (opts.playedNotSelectedVoiceIds) {
+      payload.played_not_selected_voice_ids = opts.playedNotSelectedVoiceIds.split(",");
     }
-  );
+    const data = await apiPostJson(
+      "text-to-voice/create-voice-from-preview",
+      payload,
+      apiKey
+    );
+    console.log(`Created voice: ${data.voice_id}`);
+  });
+  voices.command("delete <voiceId>").description("Delete a voice from your library").action(async (voiceId) => {
+    const apiKey = requireElevenLabsKey();
+    await apiDelete(`voices/${voiceId}`, apiKey);
+    console.log(`Deleted: ${voiceId}`);
+  });
 }
 
-// src/providers/byteplus/commands/index.ts
-function registerBytePlusCommands(program2) {
-  const byteplus = program2.command("byteplus").description("BytePlus ModelArk: Seedream image generation, Seedance video generation");
-  registerBytePlusGenerateCommand(byteplus);
-  registerBytePlusImageToImageCommand(byteplus);
-  registerBytePlusVideoCommand(byteplus);
-  registerBytePlusImageToVideoCommand(byteplus);
-  registerBytePlusReferenceToVideoCommand(byteplus);
-  registerBytePlusStatusCommand(byteplus);
+// src/providers/elevenlabs/commands/index.ts
+function registerElevenLabsCommands(program2) {
+  const el = program2.command("elevenlabs").description(
+    "ElevenLabs: TTS, voices, cloning, STT, voice changer, SFX, music, dubbing, isolation, alignment"
+  );
+  registerTtsCommand(el);
+  registerVoicesCommand(el);
+  registerCloneCommand(el);
+  registerVoiceChangerCommand(el);
+  registerTranscribeCommand(el);
+  registerSfxCommand(el);
+  registerMusicCommand(el);
+  registerDubCommand(el);
+  registerIsolateCommand(el);
+  registerAlignCommand(el);
+  registerAccountCommands(el);
 }
 
 // src/providers/gemini/commands/analyze.ts
 init_errors();
-import fs9 from "fs";
+import fs14 from "fs";
 
 // src/providers/gemini/client.ts
-import fs7 from "fs";
-import path12 from "path";
+import fs12 from "fs";
+import path18 from "path";
 init_errors();
 init_http_client();
 
 // src/providers/gemini/task-resolver.ts
-import path11 from "path";
+import path17 from "path";
 var MIME_MAP = {
   // Audio
   ".mp3": "audio/mp3",
@@ -1156,7 +2065,7 @@ var MIME_MAP = {
   ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation"
 };
 function getMimeType(filePath) {
-  const ext = path11.extname(filePath).toLowerCase();
+  const ext = path17.extname(filePath).toLowerCase();
   return MIME_MAP[ext] ?? "application/octet-stream";
 }
 function requiresProcessingWait(mimeType) {
@@ -1175,15 +2084,15 @@ function requireApiKey() {
     );
   return key;
 }
-function authHeaders(apiKey) {
+function authHeaders2(apiKey) {
   return { "x-goog-api-key": apiKey };
 }
 async function uploadFile(filePath, opts = {}) {
   const apiKey = requireApiKey();
   const { timeoutMs = 3e5, logger } = opts;
   const mimeType = getMimeType(filePath);
-  const fileBytes = fs7.readFileSync(filePath);
-  const displayName = path12.basename(filePath);
+  const fileBytes = fs12.readFileSync(filePath);
+  const displayName = path18.basename(filePath);
   const boundary = `multix_${Date.now()}`;
   const metaJson = JSON.stringify({ file: { displayName, mimeType } });
   const body = Buffer.concat([
@@ -1228,7 +2137,7 @@ Content-Type: ${mimeType}\r
       await sleep(2e3);
       fileRef = await httpJson({
         url: `${BASE}/v1beta/${fileRef.name}`,
-        headers: authHeaders(apiKey)
+        headers: authHeaders2(apiKey)
       }).then((r) => r.file);
       logger?.debug(`Processing... state=${fileRef.state}`);
     }
@@ -1245,7 +2154,7 @@ async function generateContent(req) {
   return httpJson({
     url: `${GENERATE_BASE}/${req.model}:generateContent`,
     method: "POST",
-    headers: authHeaders(apiKey),
+    headers: authHeaders2(apiKey),
     body: {
       contents: req.contents,
       ...req.generationConfig ? { generationConfig: req.generationConfig } : {}
@@ -1272,12 +2181,12 @@ function extractImages(resp) {
   ).map((p) => ({ mimeType: p.inlineData.mimeType, data: p.inlineData.data }));
 }
 function inlinePart(filePath) {
-  const data = fs7.readFileSync(filePath).toString("base64");
+  const data = fs12.readFileSync(filePath).toString("base64");
   const mimeType = getMimeType(filePath);
   return { inlineData: { mimeType, data } };
 }
 function shouldUseFileApi(filePath) {
-  const stat = fs7.statSync(filePath);
+  const stat = fs12.statSync(filePath);
   return stat.size > 20 * 1024 * 1024;
 }
 function sleep(ms) {
@@ -1330,13 +2239,13 @@ function getDefaultModel(task) {
 }
 
 // src/providers/gemini/result-formatter.ts
-import fs8 from "fs";
-import path13 from "path";
+import fs13 from "fs";
+import path19 from "path";
 function formatResults(results, format, outputPath) {
   const content = renderFormat(results, format);
   if (outputPath) {
-    fs8.mkdirSync(path13.dirname(path13.resolve(outputPath)), { recursive: true });
-    fs8.writeFileSync(outputPath, content, "utf8");
+    fs13.mkdirSync(path19.dirname(path19.resolve(outputPath)), { recursive: true });
+    fs13.writeFileSync(outputPath, content, "utf8");
   } else {
     process.stdout.write(content);
   }
@@ -1403,7 +2312,7 @@ function registerAnalyzeCommand(parent) {
       const logger = createLogger({ verbose: opts.verbose ?? false });
       const model = opts.model ?? getDefaultModel("analyze");
       for (const f of opts.files) {
-        if (!fs9.existsSync(f)) throw new ValidationError(`File not found: ${f}`);
+        if (!fs14.existsSync(f)) throw new ValidationError(`File not found: ${f}`);
       }
       const results = [];
       for (let i = 0; i < opts.files.length; i++) {
@@ -1449,14 +2358,14 @@ function registerAnalyzeCommand(parent) {
 
 // src/providers/gemini/commands/extract.ts
 init_errors();
-import fs10 from "fs";
+import fs15 from "fs";
 function registerExtractCommand(parent) {
   parent.command("extract").description("Extract structured information from files with Gemini").requiredOption("--files <paths...>", "Input file paths").requiredOption("--prompt <text>", "Extraction prompt (required)").option("--model <id>", "Gemini model to use").option("--format <fmt>", "Output format: text|json|csv|markdown", "text").option("--output <path>", "Write results to file").option("-v, --verbose", "Verbose logging").action(
     async (opts) => {
       const logger = createLogger({ verbose: opts.verbose ?? false });
       const model = opts.model ?? getDefaultModel("extract");
       for (const f of opts.files) {
-        if (!fs10.existsSync(f)) throw new ValidationError(`File not found: ${f}`);
+        if (!fs15.existsSync(f)) throw new ValidationError(`File not found: ${f}`);
       }
       const generationConfig = opts.format === "json" ? { responseMimeType: "application/json" } : void 0;
       const results = [];
@@ -1498,8 +2407,8 @@ function registerExtractCommand(parent) {
 init_errors();
 
 // src/providers/gemini/generators/speech.ts
-import fs11 from "fs";
-import path14 from "path";
+import fs16 from "fs";
+import path20 from "path";
 
 // src/providers/gemini/voices.ts
 var GEMINI_TTS_VOICES = [
@@ -1582,12 +2491,12 @@ async function generateGeminiSpeech(opts) {
   const sampleRate = parseSampleRate(audio.mimeType) ?? TTS_PCM_SAMPLE_RATE;
   const outBytes = outputFormat === "wav" ? wrapPcmInWav(pcmBytes, sampleRate, TTS_PCM_CHANNELS, TTS_PCM_BITS_PER_SAMPLE) : pcmBytes;
   const outDir = getOutputDir();
-  const dest = path14.join(outDir, `gemini_speech_${Date.now()}.${outputFormat}`);
-  fs11.writeFileSync(dest, outBytes);
+  const dest = path20.join(outDir, `gemini_speech_${Date.now()}.${outputFormat}`);
+  fs16.writeFileSync(dest, outBytes);
   logger?.success(`Saved: ${dest} (${(outBytes.length / 1024).toFixed(1)} KB)`);
   if (output) {
-    fs11.mkdirSync(path14.dirname(path14.resolve(output)), { recursive: true });
-    fs11.copyFileSync(dest, output);
+    fs16.mkdirSync(path20.dirname(path20.resolve(output)), { recursive: true });
+    fs16.copyFileSync(dest, output);
     logger?.success(`Copied to: ${output}`);
   }
   return { status: "success", generatedAudio: dest, model, mimeType: audio.mimeType };
@@ -1686,8 +2595,8 @@ function collectSpeakers(value, prev) {
 }
 
 // src/providers/gemini/commands/generate-video.ts
-import fs12 from "fs";
-import path15 from "path";
+import fs17 from "fs";
+import path21 from "path";
 init_errors();
 init_http_client();
 var BASE2 = "https://generativelanguage.googleapis.com";
@@ -1721,10 +2630,10 @@ function registerGenerateVideoCommand(parent) {
       const contentParts = [{ text: opts.prompt }];
       if (opts.referenceImages?.length) {
         for (const imgPath of opts.referenceImages.slice(0, 2)) {
-          if (!fs12.existsSync(imgPath))
+          if (!fs17.existsSync(imgPath))
             throw new ValidationError(`Reference image not found: ${imgPath}`);
-          const data = fs12.readFileSync(imgPath).toString("base64");
-          const ext = path15.extname(imgPath).toLowerCase();
+          const data = fs17.readFileSync(imgPath).toString("base64");
+          const ext = path21.extname(imgPath).toLowerCase();
           const mimeType = ext === ".png" ? "image/png" : "image/jpeg";
           contentParts.push({ inlineData: { mimeType, data } });
         }
@@ -1773,13 +2682,13 @@ function registerGenerateVideoCommand(parent) {
         );
       }
       const outDir = getOutputDir();
-      const dest = path15.join(outDir, `veo_generated_${Date.now()}.mp4`);
+      const dest = path21.join(outDir, `veo_generated_${Date.now()}.mp4`);
       const { downloadFile: downloadFile2 } = await Promise.resolve().then(() => (init_http_client(), http_client_exports));
       await downloadFile2(videoUri, dest);
       logger.success(`Saved video: ${dest}`);
       if (opts.output) {
-        fs12.mkdirSync(path15.dirname(path15.resolve(opts.output)), { recursive: true });
-        fs12.copyFileSync(dest, opts.output);
+        fs17.mkdirSync(path21.dirname(path21.resolve(opts.output)), { recursive: true });
+        fs17.copyFileSync(dest, opts.output);
         logger.success(`Copied to: ${opts.output}`);
       }
       await maybeDownloadThumb(finalOp.response, dest, {
@@ -1798,8 +2707,8 @@ function sleep2(ms) {
 
 // src/providers/gemini/commands/generate.ts
 init_errors();
-import fs13 from "fs";
-import path16 from "path";
+import fs18 from "fs";
+import path22 from "path";
 function registerGenerateCommand(parent) {
   parent.command("generate").description("Generate images with Gemini (Nano Banana / Imagen 4)").requiredOption("--prompt <text>", "Image generation prompt").option("--model <id>", "Gemini image model to use").option("--aspect-ratio <ratio>", `Aspect ratio (${ASPECT_RATIOS.join("|")})`, "1:1").option("--num-images <n>", "Number of images to generate (1-4)", "1").option("--size <sz>", `Image size (${IMAGE_SIZES.join("|")})`).option("--output <path>", "Copy first generated image to this path").option("-v, --verbose", "Verbose logging").action(
     async (opts) => {
@@ -1841,8 +2750,8 @@ function registerGenerateCommand(parent) {
             const outDir = getOutputDir();
             const ext = img.mimeType.includes("png") ? "png" : "jpg";
             const fname = `gemini_generated_${Date.now()}_${i}.${ext}`;
-            const dest = path16.join(outDir, fname);
-            fs13.writeFileSync(dest, Buffer.from(img.data, "base64"));
+            const dest = path22.join(outDir, fname);
+            fs18.writeFileSync(dest, Buffer.from(img.data, "base64"));
             savedFiles.push(dest);
             logger.success(`Saved: ${dest}`);
           }
@@ -1857,8 +2766,8 @@ function registerGenerateCommand(parent) {
         process.exit(1);
       }
       if (opts.output && savedFiles[0]) {
-        fs13.mkdirSync(path16.dirname(path16.resolve(opts.output)), { recursive: true });
-        fs13.copyFileSync(savedFiles[0], opts.output);
+        fs18.mkdirSync(path22.dirname(path22.resolve(opts.output)), { recursive: true });
+        fs18.copyFileSync(savedFiles[0], opts.output);
         logger.success(`Copied to: ${opts.output}`);
       }
       console.log(`
@@ -1869,8 +2778,8 @@ Generated ${savedFiles.length} image(s):`);
 }
 
 // src/providers/gemini/commands/image-to-image.ts
-import fs14 from "fs";
-import path17 from "path";
+import fs19 from "fs";
+import path23 from "path";
 var SOFT_LIMIT_BYTES = 5 * 1024 * 1024;
 var HARD_LIMIT_BYTES = 7 * 1024 * 1024;
 function registerGeminiImageToImageCommand(parent) {
@@ -1931,14 +2840,14 @@ function registerGeminiImageToImageCommand(parent) {
         const img = images[i];
         if (!img) continue;
         const ext = img.mimeType.includes("png") ? "png" : "jpg";
-        const dest = path17.join(outDir, `gemini-i2i-${ts}-${i + 1}.${ext}`);
-        fs14.writeFileSync(dest, Buffer.from(img.data, "base64"));
+        const dest = path23.join(outDir, `gemini-i2i-${ts}-${i + 1}.${ext}`);
+        fs19.writeFileSync(dest, Buffer.from(img.data, "base64"));
         saved.push(dest);
         logger.success(`Saved: ${dest}`);
       }
       if (opts.output && saved[0]) {
-        fs14.mkdirSync(path17.dirname(path17.resolve(opts.output)), { recursive: true });
-        fs14.copyFileSync(saved[0], opts.output);
+        fs19.mkdirSync(path23.dirname(path23.resolve(opts.output)), { recursive: true });
+        fs19.copyFileSync(saved[0], opts.output);
         logger.success(`Copied to: ${opts.output}`);
       }
       console.log(`
@@ -1965,7 +2874,7 @@ function sniffImageMime(buf, url) {
     if (buf.length >= 12 && buf.slice(0, 4).toString() === "RIFF" && buf.slice(8, 12).toString() === "WEBP")
       return "image/webp";
   }
-  const ext = path17.extname(new URL(url).pathname).toLowerCase();
+  const ext = path23.extname(new URL(url).pathname).toLowerCase();
   if (ext === ".png") return "image/png";
   if (ext === ".webp") return "image/webp";
   if (ext === ".gif") return "image/gif";
@@ -1973,17 +2882,17 @@ function sniffImageMime(buf, url) {
 }
 
 // src/providers/gemini/commands/image-to-video.ts
-import fs15 from "fs";
-import path18 from "path";
+import fs20 from "fs";
+import path24 from "path";
 init_errors();
 init_http_client();
 var BASE3 = "https://generativelanguage.googleapis.com";
 function imagePart(imgPath) {
-  if (!fs15.existsSync(imgPath)) {
+  if (!fs20.existsSync(imgPath)) {
     throw new ValidationError(`Image not found: ${imgPath}`);
   }
-  const data = fs15.readFileSync(imgPath).toString("base64");
-  const ext = path18.extname(imgPath).toLowerCase();
+  const data = fs20.readFileSync(imgPath).toString("base64");
+  const ext = path24.extname(imgPath).toLowerCase();
   const mimeType = ext === ".png" ? "image/png" : "image/jpeg";
   return { inlineData: { mimeType, data } };
 }
@@ -2056,12 +2965,12 @@ function registerGeminiImageToVideoCommand(parent) {
           "gemini"
         );
       }
-      const dest = path18.join(getOutputDir(), `veo_i2v_${Date.now()}.mp4`);
+      const dest = path24.join(getOutputDir(), `veo_i2v_${Date.now()}.mp4`);
       await downloadFile(videoUri, dest);
       logger.success(`Saved video: ${dest}`);
       if (opts.output) {
-        fs15.mkdirSync(path18.dirname(path18.resolve(opts.output)), { recursive: true });
-        fs15.copyFileSync(dest, opts.output);
+        fs20.mkdirSync(path24.dirname(path24.resolve(opts.output)), { recursive: true });
+        fs20.copyFileSync(dest, opts.output);
         logger.success(`Copied to: ${opts.output}`);
       }
       await maybeDownloadThumb(finalOp.response, dest, {
@@ -2077,14 +2986,14 @@ Generated video: ${dest}`);
 
 // src/providers/gemini/commands/transcribe.ts
 init_errors();
-import fs16 from "fs";
-function registerTranscribeCommand(parent) {
+import fs21 from "fs";
+function registerTranscribeCommand2(parent) {
   parent.command("transcribe").description("Transcribe audio or video files with Gemini").requiredOption("--files <paths...>", "Audio/video file paths to transcribe").option("--prompt <text>", "Transcription prompt", "Generate a transcript with timestamps").option("--model <id>", "Gemini model to use").option("--format <fmt>", "Output format: text|json|csv|markdown", "text").option("--output <path>", "Write results to file").option("-v, --verbose", "Verbose logging").action(
     async (opts) => {
       const logger = createLogger({ verbose: opts.verbose ?? false });
       const model = opts.model ?? getDefaultModel("transcribe");
       for (const f of opts.files) {
-        if (!fs16.existsSync(f)) throw new ValidationError(`File not found: ${f}`);
+        if (!fs21.existsSync(f)) throw new ValidationError(`File not found: ${f}`);
       }
       const results = [];
       for (let i = 0; i < opts.files.length; i++) {
@@ -2131,7 +3040,7 @@ function registerGeminiCommands(program2) {
     "Gemini AI operations: analyze, transcribe, extract, generate images/video/speech"
   );
   registerAnalyzeCommand(gemini);
-  registerTranscribeCommand(gemini);
+  registerTranscribeCommand2(gemini);
   registerExtractCommand(gemini);
   registerGenerateCommand(gemini);
   registerGeminiImageToImageCommand(gemini);
@@ -2142,8 +3051,8 @@ function registerGeminiCommands(program2) {
 
 // src/providers/leonardo/commands/generate.ts
 init_http_client();
-import fs17 from "fs";
-import path19 from "path";
+import fs22 from "fs";
+import path25 from "path";
 
 // src/providers/leonardo/client.ts
 init_errors();
@@ -2217,11 +3126,11 @@ var LeonardoClient = class {
   }
   apiKey;
   baseUrl;
-  async request(path35, opts = {}) {
+  async request(path41, opts = {}) {
     const base = this.baseUrl.replace(/\/$/, "");
-    const v2Override = path35.startsWith("v2:");
+    const v2Override = path41.startsWith("v2:");
     const finalBase = v2Override ? base.replace(/\/v1$/, "/v2") : base;
-    const finalPath = v2Override ? path35.slice(3) : path35;
+    const finalPath = v2Override ? path41.slice(3) : path41;
     const url = new URL(finalBase + finalPath);
     if (opts.query) {
       for (const [k, v] of Object.entries(opts.query)) {
@@ -2240,14 +3149,14 @@ var LeonardoClient = class {
       timeoutMs: opts.timeoutMs ?? 12e4
     });
   }
-  get(path35, query, logger) {
-    return this.request(path35, { method: "GET", query, logger });
+  get(path41, query, logger) {
+    return this.request(path41, { method: "GET", query, logger });
   }
-  post(path35, body, logger) {
-    return this.request(path35, { method: "POST", body, logger });
+  post(path41, body, logger) {
+    return this.request(path41, { method: "POST", body, logger });
   }
-  delete(path35, logger) {
-    return this.request(path35, { method: "DELETE", logger });
+  delete(path41, logger) {
+    return this.request(path41, { method: "DELETE", logger });
   }
 };
 function createLeonardoClient() {
@@ -2258,7 +3167,7 @@ function createLeonardoClient() {
 function extFromUrl(url, fallback = ".png") {
   try {
     const u = new URL(url);
-    const e = path19.extname(u.pathname);
+    const e = path25.extname(u.pathname);
     return e.length > 0 ? e : fallback;
   } catch {
     return fallback;
@@ -2343,7 +3252,7 @@ function registerLeonardoGenerateCommand(parent) {
         if (!img) continue;
         const ext = extFromUrl(img.url);
         const filename = autoFilename(generationId, i + 1, ext);
-        const filepath = path19.join(outDir, filename);
+        const filepath = path25.join(outDir, filename);
         try {
           await downloadFile(img.url, filepath);
           saved.push(filepath);
@@ -2353,9 +3262,9 @@ function registerLeonardoGenerateCommand(parent) {
         }
       }
       if (opts.output && saved[0]) {
-        const dest = path19.resolve(opts.output);
-        fs17.mkdirSync(path19.dirname(dest), { recursive: true });
-        fs17.copyFileSync(saved[0], dest);
+        const dest = path25.resolve(opts.output);
+        fs22.mkdirSync(path25.dirname(dest), { recursive: true });
+        fs22.copyFileSync(saved[0], dest);
         logger.success(`Copied to ${dest}`);
       }
       console.log(`
@@ -2367,11 +3276,11 @@ Generated ${saved.length} image(s):`);
 
 // src/providers/leonardo/commands/image-to-image.ts
 init_http_client();
-import fs18 from "fs";
-import path20 from "path";
+import fs23 from "fs";
+import path26 from "path";
 function extFromUrl2(url, fallback = ".png") {
   try {
-    return path20.extname(new URL(url).pathname) || fallback;
+    return path26.extname(new URL(url).pathname) || fallback;
   } catch {
     return fallback;
   }
@@ -2433,7 +3342,7 @@ function registerLeonardoImageToImageCommand(parent) {
         if (!img) continue;
         const ext = extFromUrl2(img.url);
         const filename = `leonardo-i2i-${generationId.slice(0, 8)}-${String(i + 1).padStart(2, "0")}${ext}`;
-        const filepath = path20.join(outDir, filename);
+        const filepath = path26.join(outDir, filename);
         try {
           await downloadFile(img.url, filepath);
           saved.push(filepath);
@@ -2443,9 +3352,9 @@ function registerLeonardoImageToImageCommand(parent) {
         }
       }
       if (opts.output && saved[0]) {
-        const dest = path20.resolve(opts.output);
-        fs18.mkdirSync(path20.dirname(dest), { recursive: true });
-        fs18.copyFileSync(saved[0], dest);
+        const dest = path26.resolve(opts.output);
+        fs23.mkdirSync(path26.dirname(dest), { recursive: true });
+        fs23.copyFileSync(saved[0], dest);
         logger.success(`Copied to ${dest}`);
       }
       console.log(`
@@ -2457,7 +3366,7 @@ Generated ${saved.length} image(s):`);
 
 // src/providers/leonardo/commands/video.ts
 init_http_client();
-import path21 from "path";
+import path27 from "path";
 function v2DimsFor(resolution) {
   if (resolution === "RESOLUTION_1080") return { width: 1920, height: 1080 };
   if (resolution === "RESOLUTION_480") return { width: 854, height: 480 };
@@ -2568,7 +3477,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 ?? path21.join(getOutputDir(), `${opts.basename}-${jobId.slice(0, 8)}.mp4`);
+  const outPath = opts.output ?? path27.join(getOutputDir(), `${opts.basename}-${jobId.slice(0, 8)}.mp4`);
   await downloadFile(videoUrl, outPath);
   logger.success(`Saved ${outPath}`);
   await maybeDownloadThumb(gen, outPath, {
@@ -2675,7 +3584,7 @@ function registerLeonardoModelsCommand(parent) {
 
 // src/providers/leonardo/commands/status.ts
 init_http_client();
-import path22 from "path";
+import path28 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;
@@ -2740,7 +3649,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 : path22.join(outDir, `leonardo-${generationId.slice(0, 8)}-${idx}.mp4`);
+        const dest = opts.output && videos.length === 1 && images.length === 0 ? opts.output : path28.join(outDir, `leonardo-${generationId.slice(0, 8)}-${idx}.mp4`);
         await downloadFile(url, dest);
         logger.success(`Saved ${dest}`);
         await maybeDownloadThumb(gen, dest, {
@@ -2753,7 +3662,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 = path22.join(outDir, `leonardo-${generationId.slice(0, 8)}-${idx}.${ext}`);
+        const dest = path28.join(outDir, `leonardo-${generationId.slice(0, 8)}-${idx}.${ext}`);
         await downloadFile(url, dest);
         logger.success(`Saved ${dest}`);
         idx++;
@@ -2841,7 +3750,7 @@ function requireMinimaxKey() {
   }
   return key;
 }
-function authHeaders2(apiKey) {
+function authHeaders3(apiKey) {
   return {
     Authorization: `Bearer ${apiKey}`,
     "Content-Type": "application/json"
@@ -2853,7 +3762,7 @@ async function apiPost(endpoint, payload, apiKey, opts = {}) {
   const data = await httpJson({
     url,
     method: "POST",
-    headers: authHeaders2(apiKey),
+    headers: authHeaders3(apiKey),
     body: payload,
     timeoutMs: opts.timeoutMs ?? 12e4
   });
@@ -2866,17 +3775,17 @@ async function apiPost(endpoint, payload, apiKey, opts = {}) {
   }
   return data;
 }
-async function apiGet(endpoint, params, apiKey) {
+async function apiGet2(endpoint, params, apiKey) {
   const url = new URL(`${MINIMAX_BASE_URL}/${endpoint}`);
   for (const [k, v] of Object.entries(params)) url.searchParams.set(k, v);
-  return httpJson({ url: url.toString(), headers: authHeaders2(apiKey) });
+  return httpJson({ url: url.toString(), headers: authHeaders3(apiKey) });
 }
 async function pollAsyncTask(taskId, taskType, apiKey, opts = {}) {
   const { intervalMs = 1e4, timeoutMs = 6e5, logger } = opts;
   const deadline = Date.now() + timeoutMs;
   let elapsed = 0;
   while (Date.now() < deadline) {
-    const result = await apiGet(`query/${taskType}`, { task_id: taskId }, apiKey);
+    const result = await apiGet2(`query/${taskType}`, { task_id: taskId }, apiKey);
     const status = result.status ?? "Unknown";
     if (elapsed > 0 && elapsed % 3e4 < intervalMs) {
       logger?.debug(`Polling... ${Math.round(elapsed / 1e3)}s elapsed, status: ${status}`);
@@ -2891,7 +3800,7 @@ async function pollAsyncTask(taskId, taskType, apiKey, opts = {}) {
   throw new ProviderError(`Task ${taskId} timed out after ${timeoutMs / 1e3}s`, "minimax");
 }
 async function downloadMinimaxFile(fileId, apiKey, dest, logger) {
-  const result = await apiGet(
+  const result = await apiGet2(
     "files/retrieve",
     { file_id: fileId },
     apiKey
@@ -2910,8 +3819,8 @@ function sleep4(ms) {
 
 // src/providers/minimax/generators/music.ts
 init_http_client();
-import fs19 from "fs";
-import path23 from "path";
+import fs24 from "fs";
+import path29 from "path";
 async function generateMinimaxMusic(opts) {
   const {
     apiKey,
@@ -2956,14 +3865,14 @@ async function generateMinimaxMusic(opts) {
   }
   const durationMs = resp.extra_info?.music_duration ?? 0;
   const outDir = getOutputDir();
-  const dest = path23.join(outDir, `minimax_music_${Date.now()}.${outputFormat}`);
+  const dest = path29.join(outDir, `minimax_music_${Date.now()}.${outputFormat}`);
   try {
     if (audioData.startsWith("http")) {
       const bytes = await fetchBytes(audioData);
-      fs19.writeFileSync(dest, bytes);
+      fs24.writeFileSync(dest, bytes);
     } else {
       const audioBytes = Buffer.from(audioData, "hex");
-      fs19.writeFileSync(dest, audioBytes);
+      fs24.writeFileSync(dest, audioBytes);
     }
   } catch (e) {
     return {
@@ -2974,8 +3883,8 @@ async function generateMinimaxMusic(opts) {
   const durSec = durationMs / 1e3;
   logger?.success(`Saved: ${dest} (${durSec.toFixed(1)}s)`);
   if (output) {
-    fs19.mkdirSync(path23.dirname(path23.resolve(output)), { recursive: true });
-    fs19.copyFileSync(dest, output);
+    fs24.mkdirSync(path29.dirname(path29.resolve(output)), { recursive: true });
+    fs24.copyFileSync(dest, output);
   }
   return { status: "success", generatedAudio: dest, durationMs, model };
 }
@@ -3003,7 +3912,7 @@ var ALL_MINIMAX_MODELS = /* @__PURE__ */ new Set([
   ...MINIMAX_SPEECH_MODELS,
   ...MINIMAX_MUSIC_MODELS
 ]);
-var TASK_DEFAULTS = {
+var TASK_DEFAULTS2 = {
   image: process.env.MINIMAX_IMAGE_MODEL ?? "image-01",
   video: process.env.MINIMAX_VIDEO_MODEL ?? "MiniMax-Hailuo-2.3",
   speech: process.env.MINIMAX_SPEECH_MODEL ?? "speech-2.8-hd",
@@ -3022,7 +3931,7 @@ function registerMinimaxGenerateMusicCommand(parent) {
       if (!opts.lyrics && !opts.prompt) {
         throw new ValidationError("Either --lyrics or --prompt is required");
       }
-      const model = opts.model ?? TASK_DEFAULTS.music;
+      const model = opts.model ?? TASK_DEFAULTS2.music;
       const result = await generateMinimaxMusic({
         apiKey,
         lyrics: opts.lyrics,
@@ -3049,8 +3958,8 @@ Generated music: ${result.generatedAudio}`);
 init_errors();
 
 // src/providers/minimax/generators/speech.ts
-import fs20 from "fs";
-import path24 from "path";
+import fs25 from "fs";
+import path30 from "path";
 async function generateMinimaxSpeech(opts) {
   const {
     apiKey,
@@ -3097,12 +4006,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 = path24.join(outDir, `minimax_speech_${Date.now()}.${ext}`);
-  fs20.writeFileSync(dest, audioBytes);
+  const dest = path30.join(outDir, `minimax_speech_${Date.now()}.${ext}`);
+  fs25.writeFileSync(dest, audioBytes);
   logger?.success(`Saved: ${dest} (${(audioBytes.length / 1024).toFixed(1)} KB)`);
   if (output) {
-    fs20.mkdirSync(path24.dirname(path24.resolve(output)), { recursive: true });
-    fs20.copyFileSync(dest, output);
+    fs25.mkdirSync(path30.dirname(path30.resolve(output)), { recursive: true });
+    fs25.copyFileSync(dest, output);
   }
   return { status: "success", generatedAudio: dest, model };
 }
@@ -3122,7 +4031,7 @@ function registerMinimaxGenerateSpeechCommand(parent) {
       if (!SPEECH_FORMATS.includes(opts.outputFormat)) {
         throw new ValidationError(`--output-format must be one of: ${SPEECH_FORMATS.join(", ")}`);
       }
-      const model = opts.model ?? TASK_DEFAULTS.speech;
+      const model = opts.model ?? TASK_DEFAULTS2.speech;
       const rate = Number.parseFloat(opts.rate);
       const result = await generateMinimaxSpeech({
         apiKey,
@@ -3149,8 +4058,8 @@ Generated audio: ${result.generatedAudio}`);
 init_errors();
 
 // src/providers/minimax/generators/video.ts
-import fs21 from "fs";
-import path25 from "path";
+import fs26 from "fs";
+import path31 from "path";
 async function generateMinimaxVideo(opts) {
   const {
     apiKey,
@@ -3196,18 +4105,18 @@ async function generateMinimaxVideo(opts) {
     return { status: "error", error: `No file_id in poll result: ${JSON.stringify(pollResult)}` };
   }
   const outDir = getOutputDir();
-  const dest = path25.join(outDir, `minimax_video_${Date.now()}.mp4`);
+  const dest = path31.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 = fs21.statSync(dest);
+  const stat = fs26.statSync(dest);
   const fileSizeMb = stat.size / (1024 * 1024);
   if (output) {
-    fs21.mkdirSync(path25.dirname(path25.resolve(output)), { recursive: true });
-    fs21.copyFileSync(dest, output);
+    fs26.mkdirSync(path31.dirname(path31.resolve(output)), { recursive: true });
+    fs26.copyFileSync(dest, output);
   }
   await maybeDownloadThumb(pollResult, dest, {
     skip: thumb === false,
@@ -3230,7 +4139,7 @@ function registerMinimaxGenerateVideoCommand(parent) {
     async (opts) => {
       const logger = createLogger({ verbose: opts.verbose ?? false });
       const apiKey = requireMinimaxKey();
-      const model = opts.model ?? TASK_DEFAULTS.video;
+      const model = opts.model ?? TASK_DEFAULTS2.video;
       const duration = Number.parseInt(opts.duration, 10);
       if (!VIDEO_DURATIONS.includes(duration)) {
         throw new ValidationError(`--duration must be one of: ${VIDEO_DURATIONS.join(", ")}`);
@@ -3270,8 +4179,8 @@ Generated video: ${result.generatedVideo}`);
 // src/providers/minimax/generators/image.ts
 init_errors();
 init_http_client();
-import fs22 from "fs";
-import path26 from "path";
+import fs27 from "fs";
+import path32 from "path";
 async function generateMinimaxImage(opts) {
   const {
     apiKey,
@@ -3309,8 +4218,8 @@ async function generateMinimaxImage(opts) {
     try {
       const bytes = await fetchBytes(url);
       const fname = `minimax_image_${Date.now()}_${i}.png`;
-      const dest = path26.join(outDir, fname);
-      fs22.writeFileSync(dest, bytes);
+      const dest = path32.join(outDir, fname);
+      fs27.writeFileSync(dest, bytes);
       savedFiles.push(dest);
       logger?.success(`Saved: ${dest}`);
     } catch (e) {
@@ -3321,8 +4230,8 @@ async function generateMinimaxImage(opts) {
     }
   }
   if (output && savedFiles[0]) {
-    fs22.mkdirSync(path26.dirname(path26.resolve(output)), { recursive: true });
-    fs22.copyFileSync(savedFiles[0], output);
+    fs27.mkdirSync(path32.dirname(path32.resolve(output)), { recursive: true });
+    fs27.copyFileSync(savedFiles[0], output);
   }
   return { status: "success", generatedImages: savedFiles, model };
 }
@@ -3333,7 +4242,7 @@ function registerMinimaxGenerateCommand(parent) {
     async (opts) => {
       const logger = createLogger({ verbose: opts.verbose ?? false });
       const apiKey = requireMinimaxKey();
-      const model = opts.model ?? TASK_DEFAULTS.image;
+      const model = opts.model ?? TASK_DEFAULTS2.image;
       const numImages = Math.min(Math.max(Number.parseInt(opts.numImages, 10) || 1, 1), 9);
       const result = await generateMinimaxImage({
         apiKey,
@@ -3358,8 +4267,8 @@ Generated ${result.generatedImages?.length ?? 0} image(s):`);
 // src/providers/minimax/commands/image-to-image.ts
 init_errors();
 init_http_client();
-import fs23 from "fs";
-import path27 from "path";
+import fs28 from "fs";
+import path33 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."
@@ -3370,7 +4279,7 @@ function registerMinimaxImageToImageCommand(parent) {
     async (opts) => {
       const logger = createLogger({ verbose: opts.verbose ?? false });
       const apiKey = requireMinimaxKey();
-      const model = opts.model ?? TASK_DEFAULTS.image;
+      const model = opts.model ?? TASK_DEFAULTS2.image;
       const numImages = Math.min(Math.max(Number.parseInt(opts.numImages, 10) || 1, 1), 9);
       logger.warn(
         "MiniMax i2i preserves a CHARACTER reference only. It does not edit the input image. If you need free-form edits, use byteplus, gemini, openrouter, or leonardo image-to-image."
@@ -3414,8 +4323,8 @@ function registerMinimaxImageToImageCommand(parent) {
         if (!url) continue;
         try {
           const bytes = await fetchBytes(url);
-          const dest = path27.join(outDir, `minimax-i2i-${ts}-${i + 1}.png`);
-          fs23.writeFileSync(dest, bytes);
+          const dest = path33.join(outDir, `minimax-i2i-${ts}-${i + 1}.png`);
+          fs28.writeFileSync(dest, bytes);
           saved.push(dest);
           logger.success(`Saved: ${dest}`);
         } catch (e) {
@@ -3426,8 +4335,8 @@ function registerMinimaxImageToImageCommand(parent) {
         }
       }
       if (opts.output && saved[0]) {
-        fs23.mkdirSync(path27.dirname(path27.resolve(opts.output)), { recursive: true });
-        fs23.copyFileSync(saved[0], opts.output);
+        fs28.mkdirSync(path33.dirname(path33.resolve(opts.output)), { recursive: true });
+        fs28.copyFileSync(saved[0], opts.output);
         logger.success(`Copied to: ${opts.output}`);
       }
       console.log(`
@@ -3448,8 +4357,8 @@ function registerMinimaxCommands(program2) {
 }
 
 // src/providers/openrouter/client.ts
-import fs24 from "fs";
-import path28 from "path";
+import fs29 from "fs";
+import path34 from "path";
 init_errors();
 init_http_client();
 var OPENROUTER_API_URL = "https://openrouter.ai/api/v1/chat/completions";
@@ -3538,8 +4447,8 @@ async function generateOpenRouterImage(opts) {
     if (!url) continue;
     try {
       const bytes = await fetchBytes(url);
-      const dest = path28.join(outDir, `openrouter_image_${Date.now()}_${i}.png`);
-      fs24.writeFileSync(dest, bytes);
+      const dest = path34.join(outDir, `openrouter_image_${Date.now()}_${i}.png`);
+      fs29.writeFileSync(dest, bytes);
       savedFiles.push(dest);
       logger?.success(`Saved: ${dest}`);
     } catch (e) {
@@ -3550,8 +4459,8 @@ async function generateOpenRouterImage(opts) {
     }
   }
   if (output && savedFiles[0]) {
-    fs24.mkdirSync(path28.dirname(path28.resolve(output)), { recursive: true });
-    fs24.writeFileSync(output, fs24.readFileSync(savedFiles[0]));
+    fs29.mkdirSync(path34.dirname(path34.resolve(output)), { recursive: true });
+    fs29.writeFileSync(output, fs29.readFileSync(savedFiles[0]));
   }
   return { status: "success", generatedImages: savedFiles, model: usedModel };
 }
@@ -3586,8 +4495,8 @@ Generated ${result.generatedImages?.length ?? 0} image(s):`);
 }
 
 // src/providers/openrouter/commands/image-to-image.ts
-import fs25 from "fs";
-import path29 from "path";
+import fs30 from "fs";
+import path35 from "path";
 init_errors();
 init_http_client();
 var DEFAULT_MODEL = "google/gemini-2.5-flash-image";
@@ -3674,14 +4583,14 @@ async function runImageToImage(opts) {
     const url = messageImages[i]?.image_url?.url;
     if (!url) continue;
     const bytes = await fetchBytes(url);
-    const dest = path29.join(outDir, `openrouter-i2i-${ts}-${i + 1}.png`);
-    fs25.writeFileSync(dest, bytes);
+    const dest = path35.join(outDir, `openrouter-i2i-${ts}-${i + 1}.png`);
+    fs30.writeFileSync(dest, bytes);
     saved.push(dest);
     opts.logger.success(`Saved: ${dest}`);
   }
   if (opts.output && saved[0]) {
-    fs25.mkdirSync(path29.dirname(path29.resolve(opts.output)), { recursive: true });
-    fs25.copyFileSync(saved[0], opts.output);
+    fs30.mkdirSync(path35.dirname(path35.resolve(opts.output)), { recursive: true });
+    fs30.copyFileSync(saved[0], opts.output);
     opts.logger.success(`Copied to: ${opts.output}`);
   }
   return saved;
@@ -3690,7 +4599,7 @@ async function runImageToImage(opts) {
 // src/providers/openrouter/video-client.ts
 init_http_client();
 var OPENROUTER_VIDEOS_URL = "https://openrouter.ai/api/v1/videos";
-function authHeaders3(apiKey) {
+function authHeaders4(apiKey) {
   const headers = {
     Authorization: `Bearer ${apiKey}`,
     "Content-Type": "application/json"
@@ -3705,7 +4614,7 @@ async function submitVideoJob(body, apiKey = requireOpenRouterKey()) {
   return httpJson({
     url: OPENROUTER_VIDEOS_URL,
     method: "POST",
-    headers: authHeaders3(apiKey),
+    headers: authHeaders4(apiKey),
     body,
     timeoutMs: 12e4
   });
@@ -3713,7 +4622,7 @@ async function submitVideoJob(body, apiKey = requireOpenRouterKey()) {
 async function pollVideoJob(jobId, apiKey = requireOpenRouterKey()) {
   return httpJson({
     url: `${OPENROUTER_VIDEOS_URL}/${jobId}`,
-    headers: authHeaders3(apiKey)
+    headers: authHeaders4(apiKey)
   });
 }
 function videoContentUrl(jobId) {
@@ -3722,18 +4631,18 @@ function videoContentUrl(jobId) {
 async function listVideoModels(apiKey = requireOpenRouterKey()) {
   return httpJson({
     url: `${OPENROUTER_VIDEOS_URL}/models`,
-    headers: authHeaders3(apiKey)
+    headers: authHeaders4(apiKey)
   });
 }
 
 // src/providers/openrouter/commands/video-status.ts
-import fs26 from "fs";
-import path30 from "path";
+import fs31 from "fs";
+import path36 from "path";
 async function downloadOpenRouterVideo(opts) {
   const { jobId, logger, source } = opts;
   const apiKey = requireOpenRouterKey();
   const url = videoContentUrl(jobId);
-  const dest = path30.join(getOutputDir(), `openrouter_video_${jobId}.mp4`);
+  const dest = path36.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}`);
@@ -3743,14 +4652,14 @@ async function downloadOpenRouterVideo(opts) {
     logger.error("Empty response body");
     process.exit(1);
   }
-  fs26.mkdirSync(path30.dirname(dest), { recursive: true });
-  const ws = fs26.createWriteStream(dest);
+  fs31.mkdirSync(path36.dirname(dest), { recursive: true });
+  const ws = fs31.createWriteStream(dest);
   const { pipeline: pipeline2 } = await import("stream/promises");
   await pipeline2(r.body, ws);
   logger.success(`Saved ${dest}`);
   if (opts.output) {
-    fs26.mkdirSync(path30.dirname(path30.resolve(opts.output)), { recursive: true });
-    fs26.copyFileSync(dest, opts.output);
+    fs31.mkdirSync(path36.dirname(path36.resolve(opts.output)), { recursive: true });
+    fs31.copyFileSync(dest, opts.output);
     logger.success(`Copied to ${opts.output}`);
   }
   await maybeDownloadThumb(source, dest, {
@@ -4012,6 +4921,12 @@ var PROVIDERS = [
     envFallback: "ARK_API_KEY",
     optional: true,
     link: "https://console.byteplus.com/auth/api-keys"
+  },
+  {
+    name: "ElevenLabs",
+    envPrimary: "ELEVENLABS_API_KEY",
+    optional: true,
+    link: "https://elevenlabs.io/app/settings/api-keys"
   }
 ];
 function resolveProviderKey(p) {
@@ -4098,8 +5013,8 @@ function registerCheckCommand(program2) {
 
 // src/commands/doc/convert.ts
 init_errors();
-import fs27 from "fs";
-import path31 from "path";
+import fs32 from "fs";
+import path37 from "path";
 
 // src/commands/doc/default-prompt.ts
 var DEFAULT_CONVERT_PROMPT = `Convert this document to clean, well-formatted Markdown.
@@ -4120,18 +5035,18 @@ async function convertDocuments(opts) {
   const model = opts.model ?? DOC_MODEL_DEFAULT;
   const prompt = opts.prompt ?? DEFAULT_CONVERT_PROMPT;
   for (const f of inputs) {
-    if (!fs27.existsSync(f)) throw new ValidationError(`Input file not found: ${f}`);
+    if (!fs32.existsSync(f)) throw new ValidationError(`Input file not found: ${f}`);
   }
   let outputPath;
   if (output) {
-    outputPath = path31.resolve(output);
+    outputPath = path37.resolve(output);
   } else if (autoName && inputs.length === 1 && inputs[0]) {
-    const base = path31.basename(inputs[0], path31.extname(inputs[0]));
-    outputPath = path31.join(getOutputDir(), `${base}-extraction.md`);
+    const base = path37.basename(inputs[0], path37.extname(inputs[0]));
+    outputPath = path37.join(getOutputDir(), `${base}-extraction.md`);
   } else {
-    outputPath = path31.join(getOutputDir(), "document-extraction.md");
+    outputPath = path37.join(getOutputDir(), "document-extraction.md");
   }
-  fs27.mkdirSync(path31.dirname(outputPath), { recursive: true });
+  fs32.mkdirSync(path37.dirname(outputPath), { recursive: true });
   const results = [];
   for (let i = 0; i < inputs.length; i++) {
     const filePath = inputs[i];
@@ -4182,7 +5097,7 @@ async function convertDocuments(opts) {
 `);
   for (const r of results) {
     lines.push(`
-## ${path31.basename(r.file)}
+## ${path37.basename(r.file)}
 `);
     if (r.status === "success" && r.markdown) {
       lines.push(`${r.markdown}
@@ -4195,7 +5110,7 @@ async function convertDocuments(opts) {
     }
     lines.push("\n---\n");
   }
-  fs27.writeFileSync(outputPath, lines.join("\n"), "utf8");
+  fs32.writeFileSync(outputPath, lines.join("\n"), "utf8");
   const succeeded = results.filter((r) => r.status === "success").length;
   console.log(`
 ${"=".repeat(50)}`);
@@ -4241,12 +5156,12 @@ function registerDocCommands(program2) {
 
 // src/commands/media/index.ts
 init_errors();
-import fs30 from "fs";
-import path34 from "path";
+import fs35 from "fs";
+import path40 from "path";
 
 // src/commands/media/batch.ts
-import fs28 from "fs";
-import path32 from "path";
+import fs33 from "fs";
+import path38 from "path";
 
 // src/commands/media/detect-type.ts
 var VIDEO_EXTS = /* @__PURE__ */ new Set([".mp4", ".mov", ".avi", ".mkv", ".webm", ".flv", ".mpg", ".mpeg"]);
@@ -4442,10 +5357,10 @@ async function batchOptimize(opts) {
     verbose,
     logger
   } = opts;
-  fs28.mkdirSync(outputDir, { recursive: true });
-  const entries = fs28.readdirSync(inputDir);
+  fs33.mkdirSync(outputDir, { recursive: true });
+  const entries = fs33.readdirSync(inputDir);
   const mediaFiles = entries.filter((f) => {
-    const ext = path32.extname(f).toLowerCase();
+    const ext = path38.extname(f).toLowerCase();
     return ALL_EXTS.has(ext);
   });
   if (mediaFiles.length === 0) {
@@ -4456,9 +5371,9 @@ async function batchOptimize(opts) {
   let succeeded = 0;
   const errors = [];
   for (const file of mediaFiles) {
-    const inputPath = path32.join(inputDir, file);
-    const outputPath = path32.join(outputDir, file);
-    const ext = path32.extname(file).toLowerCase();
+    const inputPath = path38.join(inputDir, file);
+    const outputPath = path38.join(outputDir, file);
+    const ext = path38.extname(file).toLowerCase();
     const kind = extToKind(ext);
     logger?.debug(`Processing: ${file}`);
     try {
@@ -4495,8 +5410,8 @@ async function batchOptimize(opts) {
 
 // src/commands/media/split-video.ts
 init_errors();
-import fs29 from "fs";
-import path33 from "path";
+import fs34 from "fs";
+import path39 from "path";
 async function splitVideo(opts) {
   await assertFfmpeg();
   const { input, outputDir, chunkDuration = 3600, verbose, logger } = opts;
@@ -4507,10 +5422,10 @@ async function splitVideo(opts) {
     logger?.info("Video is short enough \u2014 no splitting needed");
     return [input];
   }
-  fs29.mkdirSync(outputDir, { recursive: true });
-  const ext = path33.extname(input) || ".mp4";
-  const baseName = path33.basename(input, ext);
-  const outputPattern = path33.join(outputDir, `${baseName}_chunk_%03d${ext}`);
+  fs34.mkdirSync(outputDir, { recursive: true });
+  const ext = path39.extname(input) || ".mp4";
+  const baseName = path39.basename(input, ext);
+  const outputPattern = path39.join(outputDir, `${baseName}_chunk_%03d${ext}`);
   logger?.debug(`Splitting into ~${numChunks} chunks of ${chunkDuration}s each`);
   const args = [
     "-i",
@@ -4529,8 +5444,8 @@ async function splitVideo(opts) {
   await runFfmpeg(args, { verbose, logger });
   const files = [];
   for (let i = 0; i < numChunks + 1; i++) {
-    const fname = path33.join(outputDir, `${baseName}_chunk_${String(i).padStart(3, "0")}${ext}`);
-    if (fs29.existsSync(fname)) files.push(fname);
+    const fname = path39.join(outputDir, `${baseName}_chunk_${String(i).padStart(3, "0")}${ext}`);
+    if (fs34.existsSync(fname)) files.push(fname);
   }
   logger?.success(`Created ${files.length} chunks in ${outputDir}`);
   return files;
@@ -4544,9 +5459,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 (!fs30.existsSync(opts.input)) throw new ValidationError(`Input not found: ${opts.input}`);
-      fs30.mkdirSync(path34.dirname(path34.resolve(opts.output)), { recursive: true });
-      const ext = path34.extname(opts.input).toLowerCase();
+      if (!fs35.existsSync(opts.input)) throw new ValidationError(`Input not found: ${opts.input}`);
+      fs35.mkdirSync(path40.dirname(path40.resolve(opts.output)), { recursive: true });
+      const ext = path40.extname(opts.input).toLowerCase();
       const kind = extToKind(ext);
       if (!kind) throw new ValidationError(`Unsupported file type: ${ext}`);
       const quality = Number.parseInt(opts.quality, 10);
@@ -4586,7 +5501,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 (!fs30.existsSync(opts.input)) throw new ValidationError(`Input not found: ${opts.input}`);
+      if (!fs35.existsSync(opts.input)) throw new ValidationError(`Input not found: ${opts.input}`);
       const chunks = await splitVideo({
         input: opts.input,
         outputDir: opts.outputDir,
@@ -4602,7 +5517,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 (!fs30.existsSync(opts.inputDir))
+      if (!fs35.existsSync(opts.inputDir))
         throw new ValidationError(`Input dir not found: ${opts.inputDir}`);
       const result = await batchOptimize({
         inputDir: opts.inputDir,
@@ -4631,6 +5546,7 @@ function registerCommands(program2) {
   registerOpenRouterCommands(program2);
   registerLeonardoCommands(program2);
   registerBytePlusCommands(program2);
+  registerElevenLabsCommands(program2);
   registerMediaCommands(program2);
   registerDocCommands(program2);
 }