@mrgoonie/multix 0.5.2 → 0.7.0

package/dist/cli.js

@@ -75,6 +75,7 @@ __export(http_client_exports, {
   fetchBytes: () => fetchBytes,
   httpJson: () => httpJson
 });
+import { once } from "events";
 import fs4 from "fs";
 import path4 from "path";
 import { pipeline } from "stream/promises";
@@ -126,7 +127,12 @@ async function downloadFile(url, dest, timeoutMs = DEFAULT_TIMEOUT_MS) {
     throw new HttpError(0, "Response body is null", url);
   }
   const fileStream = fs4.createWriteStream(dest);
-  await pipeline(response.body, fileStream);
+  try {
+    await pipeline(response.body, fileStream);
+  } catch (err2) {
+    if (!fileStream.closed) await once(fileStream, "close");
+    throw err2;
+  }
 }
 async function fetchBytes(urlOrDataUri) {
   if (urlOrDataUri.startsWith("data:")) {
@@ -160,7 +166,7 @@ var init_http_client = __esm({
 });
 
 // src/cli.ts
-import { createRequire } from "module";
+import { createRequire as createRequire2 } from "module";
 import { Command } from "commander";
 
 // src/providers/byteplus/commands/generate-3d.ts
@@ -414,9 +420,9 @@ var BytePlusClient = class {
   }
   apiKey;
   baseUrl;
-  async request(path46, opts = {}) {
+  async request(path49, opts = {}) {
     const base = this.baseUrl.replace(/\/$/, "");
-    const url = new URL(base + path46);
+    const url = new URL(base + path49);
     if (opts.query) {
       for (const [k, v] of Object.entries(opts.query)) {
         if (v !== void 0 && v !== null) url.searchParams.set(k, String(v));
@@ -434,14 +440,14 @@ var BytePlusClient = class {
       timeoutMs: opts.timeoutMs ?? 12e4
     });
   }
-  get(path46, query, logger) {
-    return this.request(path46, { method: "GET", query, logger });
+  get(path49, query, logger) {
+    return this.request(path49, { method: "GET", query, logger });
   }
-  post(path46, body, logger) {
-    return this.request(path46, { method: "POST", body, logger });
+  post(path49, body, logger) {
+    return this.request(path49, { method: "POST", body, logger });
   }
-  delete(path46, logger) {
-    return this.request(path46, { method: "DELETE", logger });
+  delete(path49, logger) {
+    return this.request(path49, { method: "DELETE", logger });
   }
 };
 function createBytePlusClient() {
@@ -569,10 +575,197 @@ Task: ${taskId}`);
   );
 }
 
+// src/core/image-webp-finalize.ts
+init_errors();
+import { spawnSync } from "child_process";
+import fs6 from "fs";
+import path6 from "path";
+import { Option } from "commander";
+
+// src/core/image-header.ts
+import fs5 from "fs";
+function sniffImageKind(buf) {
+  if (buf.length >= 8 && buf.readUInt32BE(0) === 2303741511) return "png";
+  if (buf.length >= 3 && buf[0] === 255 && buf[1] === 216 && buf[2] === 255) return "jpeg";
+  if (buf.length >= 12 && buf.toString("ascii", 0, 4) === "RIFF" && buf.toString("ascii", 8, 12) === "WEBP")
+    return "webp";
+  return void 0;
+}
+function readPng(buf) {
+  if (buf.length < 33) return void 0;
+  const width = buf.readUInt32BE(16);
+  const height = buf.readUInt32BE(20);
+  const colorType = buf[25];
+  let hasAlpha = colorType === 4 || colorType === 6;
+  let offset = 8;
+  while (!hasAlpha && offset + 8 <= buf.length) {
+    const len = buf.readUInt32BE(offset);
+    const type = buf.toString("ascii", offset + 4, offset + 8);
+    if (type === "tRNS") hasAlpha = true;
+    if (type === "IDAT" || type === "IEND") break;
+    offset += 12 + len;
+  }
+  return { kind: "png", width, height, hasAlpha };
+}
+function readJpeg(buf) {
+  let offset = 2;
+  while (offset + 9 < buf.length) {
+    if (buf[offset] !== 255) {
+      offset++;
+      continue;
+    }
+    const marker = buf[offset + 1] ?? 0;
+    if (marker >= 192 && marker <= 207 && ![196, 200, 204].includes(marker)) {
+      return {
+        kind: "jpeg",
+        height: buf.readUInt16BE(offset + 5),
+        width: buf.readUInt16BE(offset + 7),
+        hasAlpha: false
+      };
+    }
+    if (marker === 216 || marker === 1 || marker >= 208 && marker <= 215) {
+      offset += 2;
+      continue;
+    }
+    offset += 2 + buf.readUInt16BE(offset + 2);
+  }
+  return void 0;
+}
+function readWebp(buf) {
+  if (buf.length < 30) return void 0;
+  const chunk = buf.toString("ascii", 12, 16);
+  if (chunk === "VP8X") {
+    const flags = buf[20] ?? 0;
+    return {
+      kind: "webp",
+      width: 1 + buf.readUIntLE(24, 3),
+      height: 1 + buf.readUIntLE(27, 3),
+      hasAlpha: (flags & 16) !== 0
+    };
+  }
+  if (chunk === "VP8L") {
+    const bits = buf.readUInt32LE(21);
+    return {
+      kind: "webp",
+      width: 1 + (bits & 16383),
+      height: 1 + (bits >>> 14 & 16383),
+      hasAlpha: (bits >>> 28 & 1) === 1
+    };
+  }
+  if (chunk === "VP8 ") {
+    return {
+      kind: "webp",
+      width: buf.readUInt16LE(26) & 16383,
+      height: buf.readUInt16LE(28) & 16383,
+      hasAlpha: false
+    };
+  }
+  return void 0;
+}
+function readImageHeader(buf) {
+  const kind = sniffImageKind(buf);
+  if (kind === "png") return readPng(buf);
+  if (kind === "jpeg") return readJpeg(buf);
+  if (kind === "webp") return readWebp(buf);
+  return void 0;
+}
+function readImageHeaderFromFile(file) {
+  return readImageHeader(fs5.readFileSync(file));
+}
+
+// src/core/image-webp-finalize.ts
+var CWEBP_ARGS = ["-q", "85", "-m", "6", "-metadata", "none"];
+var IMAGE_EXTS = /* @__PURE__ */ new Set([".png", ".jpg", ".jpeg", ".webp", ".gif", ".bmp", ".tif", ".tiff"]);
+function imageFormatOption() {
+  return new Option(
+    "--image-format <mode>",
+    "Final image format: webp (default, cwebp -q 85) | original (keep provider format/quality)"
+  );
+}
+function noWebpOption() {
+  return new Option("--no-webp", "Keep the provider's original image format and quality");
+}
+function resolveImageFormatMode(opts, explicitProviderFormat = false) {
+  if (opts.webp === false && opts.imageFormat === void 0) return "original";
+  const raw = opts.imageFormat ?? process.env.MULTIX_IMAGE_FORMAT;
+  if (raw !== void 0 && raw !== "") {
+    const mode = raw.toLowerCase();
+    if (mode !== "webp" && mode !== "original") {
+      throw new ValidationError(`Invalid --image-format: ${raw}. Valid: webp, original`);
+    }
+    return mode;
+  }
+  if (explicitProviderFormat) return "original";
+  const ext = opts.output ? path6.extname(opts.output).toLowerCase() : "";
+  if (ext && ext !== ".webp" && IMAGE_EXTS.has(ext)) return "original";
+  return "webp";
+}
+function hasCwebp() {
+  const res = spawnSync("cwebp", ["-version"], { stdio: "ignore" });
+  return !res.error && res.status === 0;
+}
+function webpTarget(file) {
+  const ext = path6.extname(file);
+  return ext.toLowerCase() === ".webp" ? file : `${file.slice(0, -ext.length || void 0)}.webp`;
+}
+function convertToWebp(file, logger, keepPath = false) {
+  const src = readImageHeaderFromFile(file);
+  if (!src) {
+    logger?.warn(`Skipping WebP conversion (unrecognized image): ${file}`);
+    return file;
+  }
+  if (src.kind === "webp") {
+    const target2 = keepPath ? file : webpTarget(file);
+    if (target2 !== file) fs6.renameSync(file, target2);
+    return target2;
+  }
+  const target = keepPath ? file : webpTarget(file);
+  const tmp = `${target}.tmp-${process.pid}.webp`;
+  const res = spawnSync("cwebp", [...CWEBP_ARGS, file, "-o", tmp], { encoding: "utf8" });
+  if (res.error || res.status !== 0) {
+    fs6.rmSync(tmp, { force: true });
+    logger?.warn(`cwebp failed, keeping original ${file}: ${res.stderr || res.error?.message}`);
+    return file;
+  }
+  const out = fs6.existsSync(tmp) ? readImageHeaderFromFile(tmp) : void 0;
+  const problem = !out ? "output is not a valid WebP" : out.width !== src.width || out.height !== src.height ? `size changed ${src.width}x${src.height} -> ${out.width}x${out.height}` : src.hasAlpha && !out.hasAlpha ? "transparency lost" : void 0;
+  if (problem) {
+    fs6.rmSync(tmp, { force: true });
+    logger?.warn(`WebP verification failed (${problem}), keeping original ${file}`);
+    return file;
+  }
+  if (target !== file) fs6.rmSync(file, { force: true });
+  fs6.renameSync(tmp, target);
+  logger?.debug(`WebP verified ${out?.width}x${out?.height} alpha=${out?.hasAlpha}: ${target}`);
+  return target;
+}
+function finalizeGeneratedImages(files, opts) {
+  const mode = resolveImageFormatMode(opts, opts.explicitProviderFormat);
+  if (mode === "original" || files.length === 0) return files;
+  if (!hasCwebp()) {
+    opts.logger?.warn(
+      "cwebp not found on PATH; keeping original image format (install libwebp, or pass --image-format original)"
+    );
+    return files;
+  }
+  const outputAbs = opts.output ? path6.resolve(opts.output) : void 0;
+  const wroteOutputDirectly = outputAbs !== void 0 && files.some((f) => path6.resolve(f) === outputAbs);
+  const finals = files.map(
+    (f) => convertToWebp(f, opts.logger, outputAbs !== void 0 && path6.resolve(f) === outputAbs)
+  );
+  if (opts.output && outputAbs && !wroteOutputDirectly && finals[0] && fs6.existsSync(outputAbs)) {
+    const outExt = path6.extname(outputAbs).toLowerCase();
+    if ((outExt === ".webp" || outExt === "") && path6.extname(finals[0]).toLowerCase() === ".webp") {
+      fs6.copyFileSync(finals[0], outputAbs);
+    }
+  }
+  return finals;
+}
+
 // src/providers/byteplus/generators/image.ts
 init_http_client();
-import fs5 from "fs";
-import path6 from "path";
+import fs7 from "fs";
+import path7 from "path";
 var ASPECT_TO_SIZE = {
   "1:1": "2048x2048",
   "16:9": "2560x1440",
@@ -636,14 +829,14 @@ async function generateSeedream(client, opts) {
     }
     const ext = (() => {
       try {
-        const e = path6.extname(new URL(url).pathname);
+        const e = path7.extname(new URL(url).pathname);
         return e || ".jpg";
       } catch {
         return ".jpg";
       }
     })();
-    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 });
+    const filename = opts.output && items.length === 1 ? path7.resolve(opts.output) : path7.join(outDir, `byteplus-image-${ts}-${i + 1}${ext}`);
+    fs7.mkdirSync(path7.dirname(filename), { recursive: true });
     await downloadFile(url, filename);
     saved.push({ path: filename, url, seed: item.seed });
     logger?.success(`Saved ${filename}`);
@@ -658,7 +851,7 @@ function registerBytePlusGenerateCommand(parent) {
     "Reference image (URL or local path); repeatable",
     collect,
     []
-  ).option("--output <path>", "Save single image to this path").option("-v, --verbose", "Verbose logging").action(
+  ).option("--output <path>", "Save single image to this path").addOption(imageFormatOption()).addOption(noWebpOption()).option("-v, --verbose", "Verbose logging").action(
     async (opts) => {
       const logger = createLogger({ verbose: opts.verbose ?? false });
       const client = createBytePlusClient();
@@ -674,9 +867,13 @@ function registerBytePlusGenerateCommand(parent) {
         output: opts.output,
         logger
       });
+      const finalImages = finalizeGeneratedImages(
+        saved.map((f) => f.path),
+        { ...opts, logger }
+      );
       console.log(`
-Generated ${saved.length} image(s):`);
-      for (const f of saved) console.log(`  ${f.path}`);
+Generated ${finalImages.length} image(s):`);
+      for (const f of finalImages) console.log(`  ${f}`);
     }
   );
 }
@@ -693,7 +890,7 @@ function registerBytePlusImageToImageCommand(parent) {
     "Reference image (URL or local path); repeatable for multi-ref",
     collect2,
     []
-  ).option("-m, --model <id>", "Model id (default seedream-4-0-250828)").option("--size <size>", "Image size (e.g. 1024x1024, 1K, 2K, 4K)").option("--aspect-ratio <ratio>", "Aspect ratio (e.g. 1:1, 16:9, 9:16); maps to size").option("-n, --num-images <n>", "Number of images", "1").option("--seed <n>", "Fixed seed").option("--no-watermark", "Disable watermark").option("--output <path>", "Save single image to this path").option("-v, --verbose", "Verbose logging").action(
+  ).option("-m, --model <id>", "Model id (default seedream-4-0-250828)").option("--size <size>", "Image size (e.g. 1024x1024, 1K, 2K, 4K)").option("--aspect-ratio <ratio>", "Aspect ratio (e.g. 1:1, 16:9, 9:16); maps to size").option("-n, --num-images <n>", "Number of images", "1").option("--seed <n>", "Fixed seed").option("--no-watermark", "Disable watermark").option("--output <path>", "Save single image to this path").addOption(imageFormatOption()).addOption(noWebpOption()).option("-v, --verbose", "Verbose logging").action(
     async (opts) => {
       if (!opts.ref || opts.ref.length === 0) {
         throw new Error("At least one --ref is required for image-to-image.");
@@ -712,9 +909,13 @@ function registerBytePlusImageToImageCommand(parent) {
         output: opts.output,
         logger
       });
+      const finalImages = finalizeGeneratedImages(
+        saved.map((f) => f.path),
+        { ...opts, logger }
+      );
       console.log(`
-Generated ${saved.length} image(s):`);
-      for (const f of saved) console.log(`  ${f.path}`);
+Generated ${finalImages.length} image(s):`);
+      for (const f of finalImages) console.log(`  ${f}`);
     }
   );
 }
@@ -723,12 +924,12 @@ function collect2(value, prev) {
 }
 
 // src/providers/byteplus/commands/image-to-video.ts
-import path8 from "path";
+import path9 from "path";
 
 // src/core/video-thumb.ts
 init_http_client();
-import fs6 from "fs";
-import path7 from "path";
+import fs8 from "fs";
+import path8 from "path";
 var THUMB_KEYS = /* @__PURE__ */ new Set([
   "cover_image_url",
   "coverImageUrl",
@@ -778,9 +979,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 = path7.dirname(videoPath);
-  const base = path7.basename(videoPath, path7.extname(videoPath));
-  const dest = path7.join(dir, `${base}_thumb.${ext}`);
+  const dir = path8.dirname(videoPath);
+  const base = path8.basename(videoPath, path8.extname(videoPath));
+  const dest = path8.join(dir, `${base}_thumb.${ext}`);
   try {
     await downloadFile(thumbUrl, dest);
     logger?.success(`Saved thumb ${dest}`);
@@ -799,12 +1000,12 @@ async function maybeDownloadThumb(source, videoPath, opts = {}) {
   }
   const saved = await downloadThumbBeside(url, videoPath, opts.logger);
   if (saved && opts.copyTo) {
-    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);
+    const copyExt = path8.extname(saved);
+    const copyBase = path8.basename(opts.copyTo, path8.extname(opts.copyTo));
+    const copyDir = path8.dirname(path8.resolve(opts.copyTo));
+    const copyDest = path8.join(copyDir, `${copyBase}_thumb${copyExt}`);
+    fs8.mkdirSync(copyDir, { recursive: true });
+    fs8.copyFileSync(saved, copyDest);
     opts.logger?.success(`Copied thumb to ${copyDest}`);
   }
   return saved;
@@ -932,7 +1133,7 @@ function registerBytePlusImageToVideoCommand(parent) {
           logger.error(`Task succeeded but no video_url: ${JSON.stringify(final)}`);
           process.exit(1);
         }
-        const outPath = opts.output ?? path8.join(getOutputDir(), `byteplus-i2v-${taskId.slice(0, 8)}-${Date.now()}.mp4`);
+        const outPath = opts.output ?? path9.join(getOutputDir(), `byteplus-i2v-${taskId.slice(0, 8)}-${Date.now()}.mp4`);
         await downloadVideo(url, outPath, logger);
         await maybeDownloadThumb(final, outPath, {
           skip: opts.thumb === false,
@@ -958,7 +1159,7 @@ Task: ${taskId}`);
 }
 
 // src/providers/byteplus/commands/reference-to-video.ts
-import path9 from "path";
+import path10 from "path";
 
 // src/providers/byteplus/reference-input.ts
 var MAX_TOTAL_REFS = 12;
@@ -990,10 +1191,10 @@ function toRef(kind, resolved, role) {
   return { kind, url: resolved.dataUrl, mime: resolved.mime, role };
 }
 async function resolveRefSpec(kind, spec, logger) {
-  const { path: path46, role } = parseRefSpec(spec);
-  if (kind === "image") return toRef(kind, await resolveImageInput(path46, logger), role);
-  if (kind === "video") return toRef(kind, await resolveVideoInput(path46, logger), role);
-  return toRef(kind, await resolveAudioInput(path46, logger), role);
+  const { path: path49, role } = parseRefSpec(spec);
+  if (kind === "image") return toRef(kind, await resolveImageInput(path49, logger), role);
+  if (kind === "video") return toRef(kind, await resolveVideoInput(path49, logger), role);
+  return toRef(kind, await resolveAudioInput(path49, logger), role);
 }
 async function resolveRefSpecs(specs, logger) {
   const out = [];
@@ -1090,7 +1291,7 @@ function registerBytePlusReferenceToVideoCommand(parent) {
           logger.error(`Task succeeded but no video_url: ${JSON.stringify(final)}`);
           process.exit(1);
         }
-        const outPath = opts.output ?? path9.join(getOutputDir(), `byteplus-r2v-${taskId.slice(0, 8)}-${Date.now()}.mp4`);
+        const outPath = opts.output ?? path10.join(getOutputDir(), `byteplus-r2v-${taskId.slice(0, 8)}-${Date.now()}.mp4`);
         await downloadVideo(url, outPath, logger);
         await maybeDownloadThumb(final, outPath, {
           skip: opts.thumb === false,
@@ -1116,7 +1317,7 @@ Task: ${taskId}`);
 }
 
 // src/providers/byteplus/commands/status.ts
-import path10 from "path";
+import path11 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) => {
@@ -1134,7 +1335,7 @@ function registerBytePlusStatusCommand(parent) {
           const videoUrl2 = content?.video_url;
           const fileUrl = content?.file_url;
           if (videoUrl2) {
-            const outPath = opts.output ?? path10.join(getOutputDir(), `byteplus-video-${taskId.slice(0, 8)}.mp4`);
+            const outPath = opts.output ?? path11.join(getOutputDir(), `byteplus-video-${taskId.slice(0, 8)}.mp4`);
             await downloadVideo(videoUrl2, outPath, logger);
             await maybeDownloadThumb(status, outPath, {
               skip: opts.thumb === false,
@@ -1144,7 +1345,7 @@ function registerBytePlusStatusCommand(parent) {
             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}`);
+            const outPath = opts.output ?? path11.join(getOutputDir(), `byteplus-3d-${taskId.slice(0, 8)}.${ext}`);
             await downloadModelFile(fileUrl, outPath, logger);
             console.log(`Saved: ${outPath}`);
           } else {
@@ -1168,7 +1369,7 @@ function registerBytePlusStatusCommand(parent) {
 }
 
 // src/providers/byteplus/commands/video.ts
-import path11 from "path";
+import path12 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>",
@@ -1210,7 +1411,7 @@ function registerBytePlusVideoCommand(parent) {
           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`);
+        const outPath = opts.output ?? path12.join(getOutputDir(), `byteplus-video-${taskId.slice(0, 8)}-${Date.now()}.mp4`);
         await downloadVideo(url, outPath, logger);
         await maybeDownloadThumb(final, outPath, {
           skip: opts.thumb === false,
@@ -1428,15 +1629,15 @@ async function downloadVideo2(url) {
 
 // src/providers/cloudflare/media-output.ts
 init_errors();
-import fs7 from "fs";
-import path12 from "path";
+import fs9 from "fs";
+import path13 from "path";
 function destination(filename, output) {
-  return output ? path12.resolve(output) : path12.join(getOutputDir(), filename);
+  return output ? path13.resolve(output) : path13.join(getOutputDir(), filename);
 }
 function saveBytes(bytes, filename, output) {
   const dest = destination(filename, output);
-  fs7.mkdirSync(path12.dirname(dest), { recursive: true });
-  fs7.writeFileSync(dest, bytes);
+  fs9.mkdirSync(path13.dirname(dest), { recursive: true });
+  fs9.writeFileSync(dest, bytes);
   return dest;
 }
 function saveBase64Image(image, output) {
@@ -1553,7 +1754,7 @@ function registerCloudflareVideoCommand(parent) {
 // src/providers/cloudflare/commands/generate.ts
 init_errors();
 function registerCloudflareGenerateCommand(parent) {
-  parent.command("generate").description("Generate an image with Cloudflare Workers AI FLUX.1 Schnell").requiredOption("--prompt <text>", "Image prompt").option("--model <id>", "Cloudflare image model").option("--steps <n>", "Inference steps (1-8)", "4").option("--seed <n>", "Optional non-negative integer seed").option("--output <path>", "Save image at this path").option("-v, --verbose", "Verbose logging").action(
+  parent.command("generate").description("Generate an image with Cloudflare Workers AI FLUX.1 Schnell").requiredOption("--prompt <text>", "Image prompt").option("--model <id>", "Cloudflare image model").option("--steps <n>", "Inference steps (1-8)", "4").option("--seed <n>", "Optional non-negative integer seed").option("--output <path>", "Save image at this path").addOption(imageFormatOption()).addOption(noWebpOption()).option("-v, --verbose", "Verbose logging").action(
     async (opts) => {
       if (!opts.prompt.trim()) throw new ValidationError("--prompt must not be empty");
       const logger = createLogger({ verbose: opts.verbose ?? false });
@@ -1575,8 +1776,9 @@ function registerCloudflareGenerateCommand(parent) {
       if (typeof result.image !== "string") {
         throw new ProviderError("Cloudflare returned no image result", "Cloudflare");
       }
-      const destination2 = saveBase64Image(result.image, opts.output);
-      logger.success(`Saved ${destination2}`);
+      const saved = saveBase64Image(result.image, opts.output);
+      logger.success(`Saved ${saved}`);
+      const [destination2] = finalizeGeneratedImages([saved], { ...opts, logger });
       console.log(destination2);
     }
   );
@@ -1618,8 +1820,8 @@ function registerCloudflareCommands(program2) {
 }
 
 // src/providers/elevenlabs/client.ts
-import fs8 from "fs";
-import path13 from "path";
+import fs10 from "fs";
+import path14 from "path";
 init_errors();
 init_http_client();
 
@@ -1781,10 +1983,10 @@ async function apiPostMultipart(endpoint2, form, apiKey, opts = {}) {
   return res.json();
 }
 function readFileAsBlob(filePath, fieldFilename) {
-  const abs = path13.resolve(filePath);
-  if (!fs8.existsSync(abs)) throw new ValidationError(`File not found: ${abs}`);
-  const buf = fs8.readFileSync(abs);
-  const name = fieldFilename ?? path13.basename(abs);
+  const abs = path14.resolve(filePath);
+  if (!fs10.existsSync(abs)) throw new ValidationError(`File not found: ${abs}`);
+  const buf = fs10.readFileSync(abs);
+  const name = fieldFilename ?? path14.basename(abs);
   return new File([new Uint8Array(buf)], name);
 }
 async function pollUntil(fetchStatus, isDone, isFailed, opts = {}) {
@@ -1808,12 +2010,12 @@ async function pollUntil(fetchStatus, isDone, isFailed, opts = {}) {
 function saveBytes2(opts) {
   const { bytes, task, ext, outputCopy, logger } = opts;
   const dir = getOutputDir();
-  const dest = path13.join(dir, `elevenlabs_${task}_${Date.now()}.${ext}`);
-  fs8.writeFileSync(dest, bytes);
+  const dest = path14.join(dir, `elevenlabs_${task}_${Date.now()}.${ext}`);
+  fs10.writeFileSync(dest, bytes);
   logger?.success(`Saved: ${dest} (${(bytes.length / 1024).toFixed(1)} KB)`);
   if (outputCopy) {
-    fs8.mkdirSync(path13.dirname(path13.resolve(outputCopy)), { recursive: true });
-    fs8.copyFileSync(dest, outputCopy);
+    fs10.mkdirSync(path14.dirname(path14.resolve(outputCopy)), { recursive: true });
+    fs10.copyFileSync(dest, outputCopy);
   }
   return dest;
 }
@@ -1852,14 +2054,14 @@ ${models.length} models`);
 }
 
 // src/providers/elevenlabs/commands/align.ts
-import fs9 from "fs";
-import path14 from "path";
+import fs11 from "fs";
+import path15 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 = fs9.readFileSync(path14.resolve(opts.textFile), "utf8");
+    if (opts.textFile) text = fs11.readFileSync(path15.resolve(opts.textFile), "utf8");
     const form = new FormData();
     form.append("file", readFileAsBlob(opts.input));
     form.append("text", text);
@@ -1867,9 +2069,9 @@ function registerAlignCommand(parent) {
     const data = await apiPostMultipart("forced-alignment", form, apiKey, {
       timeoutMs: 6e5
     });
-    const dest = opts.output ? path14.resolve(opts.output) : path14.join(getOutputDir(), `elevenlabs_align_${Date.now()}.json`);
-    fs9.mkdirSync(path14.dirname(dest), { recursive: true });
-    fs9.writeFileSync(dest, JSON.stringify(data, null, 2));
+    const dest = opts.output ? path15.resolve(opts.output) : path15.join(getOutputDir(), `elevenlabs_align_${Date.now()}.json`);
+    fs11.mkdirSync(path15.dirname(dest), { recursive: true });
+    fs11.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 ?? "?"})`);
   });
@@ -1912,8 +2114,8 @@ function registerCloneCommand(parent) {
 // src/providers/elevenlabs/commands/dub.ts
 init_errors();
 init_http_client();
-import fs10 from "fs";
-import path15 from "path";
+import fs12 from "fs";
+import path16 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 });
@@ -1956,7 +2158,7 @@ function registerDubCommand(parent) {
     );
     logger.success(`Dub complete: ${start.dubbing_id}`);
     if (opts.download) {
-      const dest = opts.output ? path15.resolve(opts.output) : path15.join(getOutputDir(), `elevenlabs_dub_${start.dubbing_id}_${opts.targetLang}.mp4`);
+      const dest = opts.output ? path16.resolve(opts.output) : path16.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}`);
@@ -1971,7 +2173,7 @@ Dubbed file: ${dest}`);
     const status = await apiGet(`dubbing/${dubbingId}`, apiKey);
     console.log(JSON.stringify(status, null, 2));
     if (opts.download) {
-      const dest = opts.output ? path15.resolve(opts.output) : path15.join(getOutputDir(), `elevenlabs_dub_${dubbingId}_${opts.download}.mp4`);
+      const dest = opts.output ? path16.resolve(opts.output) : path16.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}`);
@@ -1979,7 +2181,7 @@ Dubbed file: ${dest}`);
   });
 }
 async function downloadDub(url, apiKey, dest) {
-  fs10.mkdirSync(path15.dirname(dest), { recursive: true });
+  fs12.mkdirSync(path16.dirname(dest), { recursive: true });
   const res = await globalThis.fetch(url, {
     headers: { "xi-api-key": apiKey },
     signal: AbortSignal.timeout(6e5)
@@ -1988,7 +2190,7 @@ async function downloadDub(url, apiKey, dest) {
     throw new Error(`Failed to download dub: HTTP ${res.status}`);
   }
   const arr = new Uint8Array(await res.arrayBuffer());
-  fs10.writeFileSync(dest, arr);
+  fs12.writeFileSync(dest, arr);
   void downloadFile;
 }
 
@@ -2017,8 +2219,8 @@ Isolated audio: ${dest}`);
 
 // src/providers/elevenlabs/commands/music.ts
 init_errors();
-import fs11 from "fs";
-import path16 from "path";
+import fs13 from "fs";
+import path17 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>",
@@ -2033,9 +2235,9 @@ function registerMusicCommand(parent) {
     const payload = { model_id: opts.model };
     if (opts.prompt) payload.prompt = opts.prompt;
     if (opts.plan) {
-      const planPath = path16.resolve(opts.plan);
-      if (!fs11.existsSync(planPath)) throw new ValidationError(`Plan file not found: ${planPath}`);
-      const planJson = JSON.parse(fs11.readFileSync(planPath, "utf8"));
+      const planPath = path17.resolve(opts.plan);
+      if (!fs13.existsSync(planPath)) throw new ValidationError(`Plan file not found: ${planPath}`);
+      const planJson = JSON.parse(fs13.readFileSync(planPath, "utf8"));
       payload.composition_plan = planJson;
     }
     if (opts.musicLengthMs) payload.music_length_ms = Number.parseInt(opts.musicLengthMs, 10);
@@ -2094,8 +2296,8 @@ Generated SFX: ${dest}`);
 }
 
 // src/providers/elevenlabs/commands/transcribe.ts
-import fs12 from "fs";
-import path17 from "path";
+import fs14 from "fs";
+import path18 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>",
@@ -2118,7 +2320,7 @@ function registerTranscribeCommand(parent) {
     });
     const ext = opts.format === "json" ? "json" : opts.format === "srt" ? "srt" : opts.format === "vtt" ? "vtt" : "txt";
     const dir = getOutputDir();
-    const dest = opts.output ? path17.resolve(opts.output) : path17.join(dir, `elevenlabs_transcribe_${Date.now()}.${ext}`);
+    const dest = opts.output ? path18.resolve(opts.output) : path18.join(dir, `elevenlabs_transcribe_${Date.now()}.${ext}`);
     let body;
     switch (opts.format) {
       case "json":
@@ -2133,8 +2335,8 @@ function registerTranscribeCommand(parent) {
       default:
         body = data.text ?? "";
     }
-    fs12.mkdirSync(path17.dirname(dest), { recursive: true });
-    fs12.writeFileSync(dest, body);
+    fs14.mkdirSync(path18.dirname(dest), { recursive: true });
+    fs14.writeFileSync(dest, body);
     logger.success(`Saved transcript: ${dest}`);
     if (data.language_code) {
       logger.info(
@@ -2379,18 +2581,455 @@ function registerElevenLabsCommands(program2) {
   registerAccountCommands(el);
 }
 
-// src/providers/gemini/commands/analyze.ts
+// src/providers/fal/commands/image.ts
+import fs16 from "fs";
+import path20 from "path";
+
+// src/providers/fal/models.ts
+var DEFAULT_FAL_BASE_URL = "https://queue.fal.run";
+var FAL_DEFAULTS = {
+  // FLUX.1 [schnell] — fast, low-cost default text-to-image model.
+  imageModel: process.env.FAL_IMAGE_MODEL ?? "fal-ai/flux/schnell",
+  // Stable, widely available default text-to-video model.
+  videoModel: process.env.FAL_VIDEO_MODEL ?? "fal-ai/kling-video/v1.6/standard/text-to-video",
+  // Matching image-to-video model — used when --image-url is passed without -m.
+  videoImageModel: process.env.FAL_VIDEO_IMAGE_MODEL ?? "fal-ai/kling-video/v1.6/standard/image-to-video"
+};
+
+// src/providers/fal/run-helpers.ts
 init_errors();
+init_http_client();
 import fs15 from "fs";
+import path19 from "path";
+
+// src/providers/fal/client.ts
+init_errors();
+init_errors();
+init_http_client();
+function requireFalKey() {
+  const key = resolveKey("FAL_KEY");
+  if (!key) {
+    throw new ConfigError("FAL_KEY is not set. Get one at https://fal.ai/dashboard/keys");
+  }
+  return key;
+}
+function falBaseUrl() {
+  return resolveKey("FAL_BASE_URL") ?? DEFAULT_FAL_BASE_URL;
+}
+var FalClient = class {
+  constructor(apiKey, baseUrl = falBaseUrl()) {
+    this.apiKey = apiKey;
+    this.baseUrl = baseUrl;
+  }
+  apiKey;
+  baseUrl;
+  /** `path` is appended verbatim to the base queue URL, e.g. "/fal-ai/flux/schnell". */
+  async request(path49, opts = {}) {
+    const base = this.baseUrl.replace(/\/$/, "");
+    const suffix = path49.startsWith("/") ? path49 : `/${path49}`;
+    return this.requestAbsolute(base + suffix, opts);
+  }
+  /** Same auth/headers as `request`, but `url` is used verbatim (e.g. a status_url/response_url returned by submit). */
+  async requestAbsolute(url, opts = {}) {
+    opts.logger?.debug(`${opts.method ?? "GET"} ${url}`);
+    return httpJson({
+      url,
+      method: opts.method ?? "GET",
+      headers: {
+        accept: "application/json",
+        authorization: `Key ${this.apiKey}`
+      },
+      body: opts.body,
+      timeoutMs: opts.timeoutMs ?? 12e4
+    });
+  }
+  get(path49, logger) {
+    return this.request(path49, { method: "GET", logger });
+  }
+  post(path49, body, logger) {
+    return this.request(path49, { method: "POST", body, logger });
+  }
+  getAbsolute(url, logger) {
+    return this.requestAbsolute(url, { method: "GET", logger });
+  }
+};
+function createFalClient() {
+  return new FalClient(requireFalKey(), falBaseUrl());
+}
+function submitPath(model) {
+  return `/${model.replace(/^\/+/, "")}`;
+}
+function appIdFromModel(model) {
+  const segments = model.replace(/^\/+|\/+$/g, "").split("/");
+  if (segments.length < 2 || !segments[0] || !segments[1]) {
+    throw new ValidationError(
+      `Invalid fal model id "${model}" \u2014 expected at least "owner/alias" (e.g. fal-ai/flux)`
+    );
+  }
+  return `${segments[0]}/${segments[1]}`;
+}
+function statusPath(model, requestId) {
+  return `/${appIdFromModel(model)}/requests/${requestId}/status`;
+}
+function resultPath(model, requestId) {
+  return `/${appIdFromModel(model)}/requests/${requestId}`;
+}
+
+// src/providers/fal/run-helpers.ts
+function parseInputArg(raw) {
+  const text = raw.startsWith("@") ? fs15.readFileSync(raw.slice(1), "utf8") : raw;
+  try {
+    const parsed = JSON.parse(text);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      throw new Error("input must be a JSON object");
+    }
+    return parsed;
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    throw new ValidationError(`Invalid --input JSON: ${msg}`);
+  }
+}
+function isTransientError(e) {
+  if (e instanceof HttpError) return e.status === 0 || e.status >= 500;
+  return false;
+}
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    const t = setTimeout(resolve, ms);
+    signal?.addEventListener("abort", () => {
+      clearTimeout(t);
+      reject(new Error("Aborted"));
+    });
+  });
+}
+async function submitAndWait(opts) {
+  const { model, input, logger } = opts;
+  const client = createFalClient();
+  const submitRes = await client.post(submitPath(model), input, logger);
+  const requestId = submitRes.request_id;
+  logger.debug(`request_id: ${requestId}`);
+  logger.info("Polling for completion...");
+  const waitTimeoutMs = opts.waitTimeoutMs ?? 48e4;
+  const intervalMs = opts.pollIntervalMs ?? 3e3;
+  const deadline = Date.now() + waitTimeoutMs;
+  const resumeHint = `Resume with: multix fal status ${model} ${requestId}  or  multix fal result ${model} ${requestId}`;
+  let attempt = 0;
+  for (; ; ) {
+    if (Date.now() >= deadline) {
+      throw new Error(
+        `Timed out waiting for fal request ${requestId} after ${waitTimeoutMs}ms. ${resumeHint}`
+      );
+    }
+    attempt++;
+    let statusRes;
+    try {
+      statusRes = await client.getAbsolute(submitRes.status_url, logger);
+    } catch (e) {
+      if (isTransientError(e)) {
+        const msg2 = e instanceof Error ? e.message : String(e);
+        logger.debug(`attempt ${attempt} \u2014 transient error, retrying: ${msg2}`);
+        await sleep(intervalMs);
+        continue;
+      }
+      const msg = e instanceof Error ? e.message : String(e);
+      throw new Error(`Failed to poll status for fal request ${requestId}: ${msg}. ${resumeHint}`);
+    }
+    logger.debug(`attempt ${attempt} \u2014 status: ${statusRes.status}`);
+    if (statusRes.status === "COMPLETED") break;
+    await sleep(intervalMs);
+  }
+  try {
+    const result = await client.getAbsolute(submitRes.response_url, logger);
+    return { requestId, result };
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    throw new Error(`Failed to fetch result for fal request ${requestId}: ${msg}. ${resumeHint}`);
+  }
+}
+var MEDIA_URL_RE = /^https?:\/\//i;
+function isHttpUrl2(v) {
+  return typeof v === "string" && MEDIA_URL_RE.test(v);
+}
+function urlOf(item) {
+  if (isHttpUrl2(item)) return item;
+  if (item !== null && typeof item === "object" && "url" in item) {
+    const u = item.url;
+    if (isHttpUrl2(u)) return u;
+  }
+  return void 0;
+}
+function extractKnownMediaUrls(result) {
+  const urls = [];
+  const images = result.images;
+  if (Array.isArray(images)) {
+    for (const img of images) {
+      const u = urlOf(img);
+      if (u) urls.push(u);
+    }
+  }
+  for (const key of ["video", "image", "audio"]) {
+    const u = urlOf(result[key]);
+    if (u) urls.push(u);
+  }
+  return urls;
+}
+function extractMediaUrlsGeneric(value, acc = [], seen = /* @__PURE__ */ new Set()) {
+  if (value === null || typeof value !== "object") return acc;
+  if (seen.has(value)) return acc;
+  seen.add(value);
+  if (Array.isArray(value)) {
+    for (const item of value) extractMediaUrlsGeneric(item, acc, seen);
+    return acc;
+  }
+  for (const [key, val] of Object.entries(value)) {
+    if (key === "url" && isHttpUrl2(val)) {
+      acc.push(val);
+    } else if (typeof val === "object" && val !== null) {
+      extractMediaUrlsGeneric(val, acc, seen);
+    }
+  }
+  return acc;
+}
+function extractMediaUrls(result) {
+  if (result === null || typeof result !== "object") return [];
+  const known = extractKnownMediaUrls(result);
+  if (known.length > 0) return known;
+  return extractMediaUrlsGeneric(result);
+}
+function extFromUrl(url, fallback = ".bin") {
+  try {
+    const u = new URL(url);
+    const e = path19.extname(u.pathname);
+    return e.length > 0 ? e : fallback;
+  } catch {
+    return fallback;
+  }
+}
+async function downloadResultMedia(urls, outDir, requestId, logger) {
+  const saved = [];
+  for (let i = 0; i < urls.length; i++) {
+    const url = urls[i];
+    if (!url) continue;
+    const ext = extFromUrl(url);
+    const filename = `fal-${requestId.slice(0, 8)}-${String(i + 1).padStart(2, "0")}${ext}`;
+    const filepath = path19.join(outDir, filename);
+    try {
+      await downloadFile(url, filepath);
+      saved.push(filepath);
+      logger.success(`Saved ${filepath}`);
+    } catch (e) {
+      fs15.rmSync(filepath, { force: true });
+      logger.warn(`Download failed for ${url}: ${e instanceof Error ? e.message : e}`);
+    }
+  }
+  return saved;
+}
+
+// src/providers/fal/commands/image.ts
+function registerFalImageCommand(parent) {
+  parent.command("image <prompt>").description(
+    `Generate images from a text prompt via fal.ai (default: ${FAL_DEFAULTS.imageModel})`
+  ).option("-m, --model <id>", "fal model id", FAL_DEFAULTS.imageModel).option("--image-size <size>", "e.g. square_hd, portrait_16_9, landscape_16_9, or WxH").option("-n, --num-images <n>", "Number of images", "1").option("--seed <n>", "Seed").option("--negative-prompt <text>", "Negative prompt").option("--output <path>", "Copy first image to this path (single-image only)").addOption(imageFormatOption()).addOption(noWebpOption()).option("--no-download", "Skip downloading; print URLs only").option("--wait-timeout <ms>", "Polling timeout in milliseconds", "480000").option("-v, --verbose", "Verbose logging").action(
+    async (prompt, opts) => {
+      const logger = createLogger({ verbose: opts.verbose ?? false });
+      const input = {
+        prompt,
+        num_images: Number.parseInt(opts.numImages, 10) || 1,
+        ...opts.imageSize ? { image_size: opts.imageSize } : {},
+        ...opts.seed ? { seed: Number.parseInt(opts.seed, 10) } : {},
+        ...opts.negativePrompt ? { negative_prompt: opts.negativePrompt } : {}
+      };
+      logger.info(`Submitting to ${opts.model}...`);
+      const { requestId, result } = await submitAndWait({
+        model: opts.model,
+        input,
+        logger,
+        waitTimeoutMs: Number.parseInt(opts.waitTimeout, 10) || 48e4
+      });
+      const urls = extractMediaUrls(result);
+      if (urls.length === 0) {
+        logger.warn("No image URLs found in result.");
+        console.log(JSON.stringify(result, null, 2));
+        return;
+      }
+      if (opts.download === false) {
+        for (const u of urls) console.log(u);
+        return;
+      }
+      const outDir = getOutputDir();
+      const saved = await downloadResultMedia(urls, outDir, requestId, logger);
+      if (saved.length === 0) {
+        logger.error(`Found ${urls.length} image URL(s) but none downloaded successfully.`);
+        process.exit(1);
+      }
+      if (opts.output && saved[0]) {
+        const dest = path20.resolve(opts.output);
+        fs16.mkdirSync(path20.dirname(dest), { recursive: true });
+        fs16.copyFileSync(saved[0], dest);
+        logger.success(`Copied to ${dest}`);
+      }
+      const finalImages = finalizeGeneratedImages(saved, { ...opts, logger });
+      console.log(`
+Generated ${finalImages.length} image(s):`);
+      for (const f of finalImages) console.log(`  ${f}`);
+    }
+  );
+}
+
+// src/providers/fal/commands/result.ts
+function registerFalResultCommand(parent) {
+  parent.command("result <model> <requestId>").description("Fetch a completed fal.ai request's result").option("--download", "Download media URLs found in the result to the output dir").option("-v, --verbose", "Verbose logging").action(
+    async (model, requestId, opts) => {
+      const logger = createLogger({ verbose: opts.verbose ?? false });
+      const client = createFalClient();
+      let result;
+      try {
+        result = await client.get(resultPath(model, requestId), logger);
+      } catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        logger.error(`Failed to fetch result for fal request ${requestId}: ${msg}`);
+        process.exit(1);
+      }
+      if (!opts.download) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+      }
+      const urls = extractMediaUrls(result);
+      if (urls.length === 0) {
+        logger.warn("No media URLs found in result.");
+        console.log(JSON.stringify(result, null, 2));
+        return;
+      }
+      const outDir = getOutputDir();
+      const saved = await downloadResultMedia(urls, outDir, requestId, logger);
+      if (saved.length === 0) {
+        logger.error(`Found ${urls.length} media URL(s) but none downloaded successfully.`);
+        process.exit(1);
+      }
+      console.log(`
+Downloaded ${saved.length} file(s):`);
+      for (const f of saved) console.log(`  ${f}`);
+    }
+  );
+}
+
+// src/providers/fal/commands/run.ts
+function registerFalRunCommand(parent) {
+  parent.command("run <model>").description("Run any fal.ai model by id (e.g. fal-ai/flux/schnell)").requiredOption("--input <json>", "JSON input, or @path/to/file.json").option("--no-download", "Skip downloading media; print result JSON only").option("--wait-timeout <ms>", "Polling timeout in milliseconds", "480000").option("-v, --verbose", "Verbose logging").action(
+    async (model, opts) => {
+      const logger = createLogger({ verbose: opts.verbose ?? false });
+      const input = parseInputArg(opts.input);
+      logger.info(`Submitting to ${model}...`);
+      const { requestId, result } = await submitAndWait({
+        model,
+        input,
+        logger,
+        waitTimeoutMs: Number.parseInt(opts.waitTimeout, 10) || 48e4
+      });
+      if (opts.download === false) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+      }
+      const urls = extractMediaUrls(result);
+      if (urls.length === 0) {
+        logger.warn("No media URLs found in result; printing raw JSON.");
+        console.log(JSON.stringify(result, null, 2));
+        return;
+      }
+      const outDir = getOutputDir();
+      const saved = await downloadResultMedia(urls, outDir, requestId, logger);
+      if (saved.length === 0) {
+        logger.error(`Found ${urls.length} media URL(s) but none downloaded successfully.`);
+        process.exit(1);
+      }
+      console.log(`
+Downloaded ${saved.length} file(s):`);
+      for (const f of saved) console.log(`  ${f}`);
+    }
+  );
+}
+
+// src/providers/fal/commands/status.ts
+function registerFalStatusCommand(parent) {
+  parent.command("status <model> <requestId>").description("Get a fal.ai request's queue status").option("-v, --verbose", "Verbose logging").action(async (model, requestId, opts) => {
+    const logger = createLogger({ verbose: opts.verbose ?? false });
+    const client = createFalClient();
+    const res = await client.get(statusPath(model, requestId), logger);
+    console.log(JSON.stringify(res, null, 2));
+  });
+}
+
+// src/providers/fal/commands/video.ts
+function registerFalVideoCommand(parent) {
+  parent.command("video <prompt>").description(
+    `Generate video via fal.ai (default text-to-video: ${FAL_DEFAULTS.videoModel}; default image-to-video: ${FAL_DEFAULTS.videoImageModel})`
+  ).option(
+    "-m, --model <id>",
+    "fal model id (default depends on --image-url: text-to-video vs. image-to-video default)"
+  ).option("--image-url <url>", "First-frame image URL \u2014 switches to image-to-video input").option("--duration <n>", "Duration in seconds (model-dependent)").option("--aspect-ratio <r>", "Aspect ratio hint (e.g. 16:9, 9:16)").option("--seed <n>", "Seed").option("--no-download", "Skip downloading; print URLs only").option("--wait-timeout <ms>", "Polling timeout in milliseconds", "900000").option("-v, --verbose", "Verbose logging").action(
+    async (prompt, opts) => {
+      const logger = createLogger({ verbose: opts.verbose ?? false });
+      const model = opts.model ?? (opts.imageUrl ? FAL_DEFAULTS.videoImageModel : FAL_DEFAULTS.videoModel);
+      appIdFromModel(model);
+      const input = {
+        prompt,
+        ...opts.imageUrl ? { image_url: opts.imageUrl } : {},
+        ...opts.duration ? { duration: opts.duration } : {},
+        ...opts.aspectRatio ? { aspect_ratio: opts.aspectRatio } : {},
+        ...opts.seed ? { seed: Number.parseInt(opts.seed, 10) } : {}
+      };
+      logger.info(`Submitting to ${model}...`);
+      const { requestId, result } = await submitAndWait({
+        model,
+        input,
+        logger,
+        waitTimeoutMs: Number.parseInt(opts.waitTimeout, 10) || 9e5
+      });
+      const urls = extractMediaUrls(result);
+      if (urls.length === 0) {
+        logger.warn("No video URLs found in result.");
+        console.log(JSON.stringify(result, null, 2));
+        return;
+      }
+      if (opts.download === false) {
+        for (const u of urls) console.log(u);
+        return;
+      }
+      const outDir = getOutputDir();
+      const saved = await downloadResultMedia(urls, outDir, requestId, logger);
+      if (saved.length === 0) {
+        logger.error(`Found ${urls.length} video URL(s) but none downloaded successfully.`);
+        process.exit(1);
+      }
+      console.log(`
+Generated ${saved.length} file(s):`);
+      for (const f of saved) console.log(`  ${f}`);
+    }
+  );
+}
+
+// src/providers/fal/commands/index.ts
+function registerFalCommands(program2) {
+  const fal = program2.command("fal").description("fal.ai: generic model runner, image, video, and queue status/result");
+  registerFalRunCommand(fal);
+  registerFalImageCommand(fal);
+  registerFalVideoCommand(fal);
+  registerFalStatusCommand(fal);
+  registerFalResultCommand(fal);
+}
+
+// src/providers/gemini/commands/analyze.ts
+init_errors();
+import fs19 from "fs";
 
 // src/providers/gemini/client.ts
-import fs13 from "fs";
-import path19 from "path";
+import fs17 from "fs";
+import path22 from "path";
 init_errors();
 init_http_client();
 
 // src/providers/gemini/task-resolver.ts
-import path18 from "path";
+import path21 from "path";
 var MIME_MAP = {
   // Audio
   ".mp3": "audio/mp3",
@@ -2431,7 +3070,7 @@ var MIME_MAP = {
   ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation"
 };
 function getMimeType(filePath) {
-  const ext = path18.extname(filePath).toLowerCase();
+  const ext = path21.extname(filePath).toLowerCase();
   return MIME_MAP[ext] ?? "application/octet-stream";
 }
 function requiresProcessingWait(mimeType) {
@@ -2457,8 +3096,8 @@ async function uploadFile(filePath, opts = {}) {
   const apiKey = requireApiKey();
   const { timeoutMs = 3e5, logger } = opts;
   const mimeType = getMimeType(filePath);
-  const fileBytes = fs13.readFileSync(filePath);
-  const displayName = path19.basename(filePath);
+  const fileBytes = fs17.readFileSync(filePath);
+  const displayName = path22.basename(filePath);
   const boundary = `multix_${Date.now()}`;
   const metaJson = JSON.stringify({ file: { displayName, mimeType } });
   const body = Buffer.concat([
@@ -2500,7 +3139,7 @@ Content-Type: ${mimeType}\r
   if (requiresProcessingWait(mimeType)) {
     const deadline = Date.now() + timeoutMs;
     while (fileRef.state === "PROCESSING" && Date.now() < deadline) {
-      await sleep(2e3);
+      await sleep2(2e3);
       fileRef = await httpJson({
         url: `${BASE}/v1beta/${fileRef.name}`,
         headers: authHeaders2(apiKey)
@@ -2527,6 +3166,33 @@ async function generateContent(req) {
     }
   });
 }
+async function createInteraction(body) {
+  const apiKey = requireApiKey();
+  return httpJson({
+    url: `${BASE}/v1beta/interactions`,
+    method: "POST",
+    headers: authHeaders2(apiKey),
+    body
+  });
+}
+function extractInteractionAudio(resp) {
+  let found = null;
+  const walk = (node) => {
+    if (Array.isArray(node)) {
+      for (const n of node) walk(n);
+      return;
+    }
+    if (!node || typeof node !== "object") return;
+    const o = node;
+    if (o.type === "audio" && typeof o.data === "string") {
+      const mime = o.mime_type ?? o.mimeType ?? "audio/wav";
+      found = { mimeType: mime, data: o.data };
+    }
+    for (const v of Object.values(o)) walk(v);
+  };
+  walk(resp);
+  return found;
+}
 function extractText(resp) {
   const parts = resp.candidates?.[0]?.content?.parts ?? [];
   return parts.filter((p) => p.text !== void 0).map((p) => p.text ?? "").join("");
@@ -2547,15 +3213,15 @@ function extractImages(resp) {
   ).map((p) => ({ mimeType: p.inlineData.mimeType, data: p.inlineData.data }));
 }
 function inlinePart(filePath) {
-  const data = fs13.readFileSync(filePath).toString("base64");
+  const data = fs17.readFileSync(filePath).toString("base64");
   const mimeType = getMimeType(filePath);
   return { inlineData: { mimeType, data } };
 }
 function shouldUseFileApi(filePath) {
-  const stat = fs13.statSync(filePath);
+  const stat = fs17.statSync(filePath);
   return stat.size > 20 * 1024 * 1024;
 }
-function sleep(ms) {
+function sleep2(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
@@ -2565,7 +3231,7 @@ var IMAGE_MODEL_FALLBACK = "gemini-2.5-flash-image";
 var VIDEO_MODEL_DEFAULT = "veo-3.1-generate-preview";
 var TEXT_MODEL_DEFAULT = "gemini-3.6-flash";
 var ANALYSIS_MODEL_DEFAULT = TEXT_MODEL_DEFAULT;
-var TTS_MODEL_DEFAULT = "gemini-3.1-flash-tts-preview";
+var TTS_MODEL_DEFAULT = "gemini-3.8-flash-lite-tts";
 var DOC_MODEL_DEFAULT = TEXT_MODEL_DEFAULT;
 var IMAGEN_MODELS = /* @__PURE__ */ new Set([
   "imagen-4.0-generate-001",
@@ -2606,13 +3272,13 @@ function getDefaultModel(task) {
 }
 
 // src/providers/gemini/result-formatter.ts
-import fs14 from "fs";
-import path20 from "path";
+import fs18 from "fs";
+import path23 from "path";
 function formatResults(results, format, outputPath) {
   const content = renderFormat(results, format);
   if (outputPath) {
-    fs14.mkdirSync(path20.dirname(path20.resolve(outputPath)), { recursive: true });
-    fs14.writeFileSync(outputPath, content, "utf8");
+    fs18.mkdirSync(path23.dirname(path23.resolve(outputPath)), { recursive: true });
+    fs18.writeFileSync(outputPath, content, "utf8");
   } else {
     process.stdout.write(content);
   }
@@ -2679,7 +3345,7 @@ function registerAnalyzeCommand(parent) {
       const logger = createLogger({ verbose: opts.verbose ?? false });
       const model = opts.model ?? getDefaultModel("analyze");
       for (const f of opts.files) {
-        if (!fs15.existsSync(f)) throw new ValidationError(`File not found: ${f}`);
+        if (!fs19.existsSync(f)) throw new ValidationError(`File not found: ${f}`);
       }
       const results = [];
       for (let i = 0; i < opts.files.length; i++) {
@@ -2725,14 +3391,14 @@ function registerAnalyzeCommand(parent) {
 
 // src/providers/gemini/commands/extract.ts
 init_errors();
-import fs16 from "fs";
+import fs20 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 (!fs16.existsSync(f)) throw new ValidationError(`File not found: ${f}`);
+        if (!fs20.existsSync(f)) throw new ValidationError(`File not found: ${f}`);
       }
       const generationConfig = opts.format === "json" ? { responseMimeType: "application/json" } : void 0;
       const results = [];
@@ -2774,8 +3440,8 @@ function registerExtractCommand(parent) {
 init_errors();
 
 // src/providers/gemini/generators/speech.ts
-import fs17 from "fs";
-import path21 from "path";
+import fs21 from "fs";
+import path24 from "path";
 
 // src/providers/gemini/voices.ts
 var GEMINI_TTS_VOICES = [
@@ -2811,10 +3477,16 @@ var GEMINI_TTS_VOICES = [
   "Sulafat"
 ];
 var GEMINI_TTS_MODELS = /* @__PURE__ */ new Set([
+  "gemini-3.8-flash-lite-tts",
+  "gemini-3.8-flash-tts",
   "gemini-3.1-flash-tts-preview",
   "gemini-2.5-flash-preview-tts",
   "gemini-2.5-pro-preview-tts"
 ]);
+var GEMINI_INTERACTIONS_TTS_MODELS = /* @__PURE__ */ new Set([
+  "gemini-3.8-flash-lite-tts",
+  "gemini-3.8-flash-tts"
+]);
 var TTS_VOICE_DEFAULT = "Kore";
 var TTS_PCM_SAMPLE_RATE = 24e3;
 var TTS_PCM_CHANNELS = 1;
@@ -2823,10 +3495,19 @@ var TTS_OUTPUT_FORMATS = ["wav", "pcm"];
 function isValidGeminiVoice(name) {
   return GEMINI_TTS_VOICES.includes(name);
 }
+function isCustomGeminiVoiceId(name) {
+  return /^(voice|voicekey)_[A-Za-z0-9_-]+$/.test(name);
+}
+function isVoiceAllowedForModel(voice, model) {
+  return isValidGeminiVoice(voice) || GEMINI_INTERACTIONS_TTS_MODELS.has(model) && isCustomGeminiVoiceId(voice);
+}
 
 // src/providers/gemini/generators/speech.ts
 async function generateGeminiSpeech(opts) {
   const { text, model, voice, speakers, outputFormat, output, logger } = opts;
+  if (GEMINI_INTERACTIONS_TTS_MODELS.has(model)) {
+    return generateInteractionsSpeech(opts);
+  }
   const speechConfig = speakers && speakers.length > 0 ? {
     multiSpeakerVoiceConfig: {
       speakerVoiceConfigs: speakers.map((s) => ({
@@ -2857,16 +3538,81 @@ async function generateGeminiSpeech(opts) {
   const pcmBytes = Buffer.from(audio.data, "base64");
   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 dest = saveSpeech(outBytes, outputFormat, output, logger);
+  return { status: "success", generatedAudio: dest, model, mimeType: audio.mimeType };
+}
+function buildInteractionsSpeechBody(opts) {
+  const { text, model, voice, speakers, style } = opts;
+  const speechConfig = speakers && speakers.length > 0 ? { mode: "conversational", speakers: speakers.map((s) => ({ ...s })) } : [{ voice }];
+  const content = { type: "text", text };
+  if (style) content.annotations = [{ type: "speech_metadata", style }];
+  return {
+    model,
+    input: [{ type: "user_input", content: [content] }],
+    response_format: { type: "audio", mime_type: "audio/wav" },
+    generation_config: { speech_config: speechConfig }
+  };
+}
+async function generateInteractionsSpeech(opts) {
+  const { model, speakers, outputFormat, output, logger, text, style } = opts;
+  logger?.debug(
+    `Gemini TTS (interactions) model=${model} mode=${speakers?.length ? "multi" : "single"}`
+  );
+  if (!style && /^\s*(say|read|speak)\b[^:\n]{0,80}:/i.test(text)) {
+    logger?.warn(
+      `${model} reads text verbatim; move delivery directions like "Say cheerfully:" into --style`
+    );
+  }
+  let resp;
+  try {
+    resp = await createInteraction(buildInteractionsSpeechBody(opts));
+  } catch (e) {
+    return { status: "error", error: e instanceof Error ? e.message : String(e) };
+  }
+  const interaction = resp;
+  if (typeof interaction?.status === "string" && interaction.status !== "completed") {
+    const detail = typeof interaction.error?.message === "string" ? `: ${interaction.error.message}` : "";
+    return { status: "error", error: `Interaction ${interaction.status}${detail}` };
+  }
+  const audio = extractInteractionAudio(resp);
+  if (!audio) return { status: "error", error: "No audio in response" };
+  const bytes = Buffer.from(audio.data, "base64");
+  const isWav = bytes.subarray(0, 4).toString("ascii") === "RIFF";
+  let outBytes;
+  if (outputFormat === "wav") {
+    outBytes = isWav ? bytes : wrapPcmInWav(
+      bytes,
+      parseSampleRate(audio.mimeType) ?? TTS_PCM_SAMPLE_RATE,
+      TTS_PCM_CHANNELS,
+      TTS_PCM_BITS_PER_SAMPLE
+    );
+  } else {
+    outBytes = isWav ? extractWavData(bytes) : bytes;
+  }
+  const dest = saveSpeech(outBytes, outputFormat, output, logger);
+  return { status: "success", generatedAudio: dest, model, mimeType: audio.mimeType };
+}
+function extractWavData(wav) {
+  let offset = 12;
+  while (offset + 8 <= wav.length) {
+    const id = wav.subarray(offset, offset + 4).toString("ascii");
+    const size = wav.readUInt32LE(offset + 4);
+    if (id === "data") return wav.subarray(offset + 8, Math.min(offset + 8 + size, wav.length));
+    offset += 8 + size + size % 2;
+  }
+  throw new Error("WAV response has no data chunk");
+}
+function saveSpeech(outBytes, outputFormat, output, logger) {
   const outDir = getOutputDir();
-  const dest = path21.join(outDir, `gemini_speech_${Date.now()}.${outputFormat}`);
-  fs17.writeFileSync(dest, outBytes);
+  const dest = path24.join(outDir, `gemini_speech_${Date.now()}.${outputFormat}`);
+  fs21.writeFileSync(dest, outBytes);
   logger?.success(`Saved: ${dest} (${(outBytes.length / 1024).toFixed(1)} KB)`);
   if (output) {
-    fs17.mkdirSync(path21.dirname(path21.resolve(output)), { recursive: true });
-    fs17.copyFileSync(dest, output);
+    fs21.mkdirSync(path24.dirname(path24.resolve(output)), { recursive: true });
+    fs21.copyFileSync(dest, output);
     logger?.success(`Copied to: ${output}`);
   }
-  return { status: "success", generatedAudio: dest, model, mimeType: audio.mimeType };
+  return dest;
 }
 function parseSampleRate(mimeType) {
   const m = mimeType.match(/rate=(\d+)/i);
@@ -2895,7 +3641,14 @@ function wrapPcmInWav(pcm, sampleRate, channels, bitsPerSample) {
 
 // src/providers/gemini/commands/generate-speech.ts
 function registerGeminiGenerateSpeechCommand(parent) {
-  parent.command("generate-speech").description("Generate speech (TTS) with Gemini Flash TTS").option("--text <str>", "Text to speak (use --text or --prompt)").option("--prompt <str>", "Alias for --text").option("--model <id>", `TTS model (${[...GEMINI_TTS_MODELS].join("|")})`).option("--voice <name>", "Prebuilt voice for single-speaker mode", TTS_VOICE_DEFAULT).option(
+  parent.command("generate-speech").description("Generate speech (TTS) with Gemini Flash TTS").option("--text <str>", "Text to speak (use --text or --prompt)").option("--prompt <str>", "Alias for --text").option("--model <id>", `TTS model (${[...GEMINI_TTS_MODELS].join("|")})`).option(
+    "--voice <name>",
+    "Prebuilt voice for single-speaker mode (3.8 models also accept voice_/voicekey_ ids)",
+    TTS_VOICE_DEFAULT
+  ).option(
+    "--style <text>",
+    'Delivery direction for Gemini 3.8 models, e.g. "cheerful and friendly"'
+  ).option(
     "--speaker <name:voice>",
     "Speaker mapping (repeatable, max 2 \u2014 switches to multi-speaker mode)",
     collectSpeakers,
@@ -2918,13 +3671,18 @@ function registerGeminiGenerateSpeechCommand(parent) {
       if (speakers.length > 2) {
         throw new ValidationError("Gemini TTS supports max 2 speakers in multi-speaker mode");
       }
-      if (speakers.length === 0 && !isValidGeminiVoice(opts.voice)) {
+      if (opts.style && !GEMINI_INTERACTIONS_TTS_MODELS.has(model)) {
+        throw new ValidationError(
+          `--style requires a Gemini 3.8 TTS model (${[...GEMINI_INTERACTIONS_TTS_MODELS].join(", ")}); put directions in the text for ${model}`
+        );
+      }
+      if (speakers.length === 0 && !isVoiceAllowedForModel(opts.voice, model)) {
         throw new ValidationError(
           `Invalid --voice "${opts.voice}". Valid: ${GEMINI_TTS_VOICES.join(", ")}`
         );
       }
       for (const sv of speakers) {
-        if (!isValidGeminiVoice(sv.voice)) {
+        if (!isVoiceAllowedForModel(sv.voice, model)) {
           throw new ValidationError(
             `Invalid voice "${sv.voice}" for speaker "${sv.speaker}". Valid: ${GEMINI_TTS_VOICES.join(", ")}`
           );
@@ -2935,6 +3693,7 @@ function registerGeminiGenerateSpeechCommand(parent) {
         model,
         voice: speakers.length === 0 ? opts.voice : void 0,
         speakers: speakers.length > 0 ? speakers : void 0,
+        style: opts.style,
         outputFormat: opts.outputFormat,
         output: opts.output,
         logger
@@ -2962,8 +3721,8 @@ function collectSpeakers(value, prev) {
 }
 
 // src/providers/gemini/commands/generate-video.ts
-import fs18 from "fs";
-import path22 from "path";
+import fs22 from "fs";
+import path25 from "path";
 init_errors();
 init_http_client();
 var BASE2 = "https://generativelanguage.googleapis.com";
@@ -2997,10 +3756,10 @@ function registerGenerateVideoCommand(parent) {
       const contentParts = [{ text: opts.prompt }];
       if (opts.referenceImages?.length) {
         for (const imgPath of opts.referenceImages.slice(0, 2)) {
-          if (!fs18.existsSync(imgPath))
+          if (!fs22.existsSync(imgPath))
             throw new ValidationError(`Reference image not found: ${imgPath}`);
-          const data = fs18.readFileSync(imgPath).toString("base64");
-          const ext = path22.extname(imgPath).toLowerCase();
+          const data = fs22.readFileSync(imgPath).toString("base64");
+          const ext = path25.extname(imgPath).toLowerCase();
           const mimeType = ext === ".png" ? "image/png" : "image/jpeg";
           contentParts.push({ inlineData: { mimeType, data } });
         }
@@ -3027,7 +3786,7 @@ function registerGenerateVideoCommand(parent) {
       let done = false;
       let finalOp = operation;
       while (!done && Date.now() < deadline) {
-        await sleep2(1e4);
+        await sleep3(1e4);
         finalOp = await httpJson({
           url: `${BASE2}/v1beta/${operationName}`,
           headers
@@ -3049,13 +3808,13 @@ function registerGenerateVideoCommand(parent) {
         );
       }
       const outDir = getOutputDir();
-      const dest = path22.join(outDir, `veo_generated_${Date.now()}.mp4`);
+      const dest = path25.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) {
-        fs18.mkdirSync(path22.dirname(path22.resolve(opts.output)), { recursive: true });
-        fs18.copyFileSync(dest, opts.output);
+        fs22.mkdirSync(path25.dirname(path25.resolve(opts.output)), { recursive: true });
+        fs22.copyFileSync(dest, opts.output);
         logger.success(`Copied to: ${opts.output}`);
       }
       await maybeDownloadThumb(finalOp.response, dest, {
@@ -3068,16 +3827,16 @@ Generated video: ${dest}`);
     }
   );
 }
-function sleep2(ms) {
+function sleep3(ms) {
   return new Promise((r) => setTimeout(r, ms));
 }
 
 // src/providers/gemini/commands/generate.ts
 init_errors();
-import fs19 from "fs";
-import path23 from "path";
+import fs23 from "fs";
+import path26 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(
+  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").addOption(imageFormatOption()).addOption(noWebpOption()).option("-v, --verbose", "Verbose logging").action(
     async (opts) => {
       const logger = createLogger({ verbose: opts.verbose ?? false });
       const model = opts.model ?? getDefaultModel("generate");
@@ -3117,8 +3876,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 = path23.join(outDir, fname);
-            fs19.writeFileSync(dest, Buffer.from(img.data, "base64"));
+            const dest = path26.join(outDir, fname);
+            fs23.writeFileSync(dest, Buffer.from(img.data, "base64"));
             savedFiles.push(dest);
             logger.success(`Saved: ${dest}`);
           }
@@ -3133,20 +3892,21 @@ function registerGenerateCommand(parent) {
         process.exit(1);
       }
       if (opts.output && savedFiles[0]) {
-        fs19.mkdirSync(path23.dirname(path23.resolve(opts.output)), { recursive: true });
-        fs19.copyFileSync(savedFiles[0], opts.output);
+        fs23.mkdirSync(path26.dirname(path26.resolve(opts.output)), { recursive: true });
+        fs23.copyFileSync(savedFiles[0], opts.output);
         logger.success(`Copied to: ${opts.output}`);
       }
+      const finalImages = finalizeGeneratedImages(savedFiles, { ...opts, logger });
       console.log(`
-Generated ${savedFiles.length} image(s):`);
-      for (const f of savedFiles) console.log(`  ${f}`);
+Generated ${finalImages.length} image(s):`);
+      for (const f of finalImages) console.log(`  ${f}`);
     }
   );
 }
 
 // src/providers/gemini/commands/image-to-image.ts
-import fs20 from "fs";
-import path24 from "path";
+import fs24 from "fs";
+import path27 from "path";
 var SOFT_LIMIT_BYTES = 5 * 1024 * 1024;
 var HARD_LIMIT_BYTES = 7 * 1024 * 1024;
 function registerGeminiImageToImageCommand(parent) {
@@ -3157,7 +3917,7 @@ function registerGeminiImageToImageCommand(parent) {
     "Reference image (URL or local path); repeatable for multi-ref",
     collect4,
     []
-  ).option("-m, --model <id>", `Gemini image model (default ${IMAGE_MODEL_FALLBACK})`).option("--output <path>", "Save first generated image to this path").option("-v, --verbose", "Verbose logging").action(
+  ).option("-m, --model <id>", `Gemini image model (default ${IMAGE_MODEL_FALLBACK})`).option("--output <path>", "Save first generated image to this path").addOption(imageFormatOption()).addOption(noWebpOption()).option("-v, --verbose", "Verbose logging").action(
     async (opts) => {
       if (!opts.ref || opts.ref.length === 0) {
         throw new Error("At least one --ref is required for image-to-image.");
@@ -3207,19 +3967,20 @@ function registerGeminiImageToImageCommand(parent) {
         const img = images[i];
         if (!img) continue;
         const ext = img.mimeType.includes("png") ? "png" : "jpg";
-        const dest = path24.join(outDir, `gemini-i2i-${ts}-${i + 1}.${ext}`);
-        fs20.writeFileSync(dest, Buffer.from(img.data, "base64"));
+        const dest = path27.join(outDir, `gemini-i2i-${ts}-${i + 1}.${ext}`);
+        fs24.writeFileSync(dest, Buffer.from(img.data, "base64"));
         saved.push(dest);
         logger.success(`Saved: ${dest}`);
       }
       if (opts.output && saved[0]) {
-        fs20.mkdirSync(path24.dirname(path24.resolve(opts.output)), { recursive: true });
-        fs20.copyFileSync(saved[0], opts.output);
+        fs24.mkdirSync(path27.dirname(path27.resolve(opts.output)), { recursive: true });
+        fs24.copyFileSync(saved[0], opts.output);
         logger.success(`Copied to: ${opts.output}`);
       }
+      const finalImages = finalizeGeneratedImages(saved, { ...opts, logger });
       console.log(`
-Generated ${saved.length} image(s):`);
-      for (const f of saved) console.log(`  ${f}`);
+Generated ${finalImages.length} image(s):`);
+      for (const f of finalImages) console.log(`  ${f}`);
     }
   );
 }
@@ -3241,7 +4002,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 = path24.extname(new URL(url).pathname).toLowerCase();
+  const ext = path27.extname(new URL(url).pathname).toLowerCase();
   if (ext === ".png") return "image/png";
   if (ext === ".webp") return "image/webp";
   if (ext === ".gif") return "image/gif";
@@ -3249,21 +4010,21 @@ function sniffImageMime(buf, url) {
 }
 
 // src/providers/gemini/commands/image-to-video.ts
-import fs21 from "fs";
-import path25 from "path";
+import fs25 from "fs";
+import path28 from "path";
 init_errors();
 init_http_client();
 var BASE3 = "https://generativelanguage.googleapis.com";
 function imagePart(imgPath) {
-  if (!fs21.existsSync(imgPath)) {
+  if (!fs25.existsSync(imgPath)) {
     throw new ValidationError(`Image not found: ${imgPath}`);
   }
-  const data = fs21.readFileSync(imgPath).toString("base64");
-  const ext = path25.extname(imgPath).toLowerCase();
+  const data = fs25.readFileSync(imgPath).toString("base64");
+  const ext = path28.extname(imgPath).toLowerCase();
   const mimeType = ext === ".png" ? "image/png" : "image/jpeg";
   return { inlineData: { mimeType, data } };
 }
-function sleep3(ms) {
+function sleep4(ms) {
   return new Promise((r) => setTimeout(r, ms));
 }
 function registerGeminiImageToVideoCommand(parent) {
@@ -3315,7 +4076,7 @@ function registerGeminiImageToVideoCommand(parent) {
       const deadline = Date.now() + 10 * 60 * 1e3;
       let finalOp = operation;
       while (!finalOp.done && Date.now() < deadline) {
-        await sleep3(1e4);
+        await sleep4(1e4);
         finalOp = await httpJson({ url: `${BASE3}/v1beta/${operationName}`, headers });
         if (!finalOp.done) {
           logger.debug(`Still generating... ${Math.round((deadline - Date.now()) / 1e3)}s left`);
@@ -3332,12 +4093,12 @@ function registerGeminiImageToVideoCommand(parent) {
           "gemini"
         );
       }
-      const dest = path25.join(getOutputDir(), `veo_i2v_${Date.now()}.mp4`);
+      const dest = path28.join(getOutputDir(), `veo_i2v_${Date.now()}.mp4`);
       await downloadFile(videoUri, dest);
       logger.success(`Saved video: ${dest}`);
       if (opts.output) {
-        fs21.mkdirSync(path25.dirname(path25.resolve(opts.output)), { recursive: true });
-        fs21.copyFileSync(dest, opts.output);
+        fs25.mkdirSync(path28.dirname(path28.resolve(opts.output)), { recursive: true });
+        fs25.copyFileSync(dest, opts.output);
         logger.success(`Copied to: ${opts.output}`);
       }
       await maybeDownloadThumb(finalOp.response, dest, {
@@ -3353,14 +4114,14 @@ Generated video: ${dest}`);
 
 // src/providers/gemini/commands/transcribe.ts
 init_errors();
-import fs22 from "fs";
+import fs26 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 (!fs22.existsSync(f)) throw new ValidationError(`File not found: ${f}`);
+        if (!fs26.existsSync(f)) throw new ValidationError(`File not found: ${f}`);
       }
       const results = [];
       for (let i = 0; i < opts.files.length; i++) {
@@ -3418,8 +4179,8 @@ function registerGeminiCommands(program2) {
 
 // src/providers/leonardo/commands/generate.ts
 init_http_client();
-import fs23 from "fs";
-import path26 from "path";
+import fs27 from "fs";
+import path29 from "path";
 
 // src/providers/leonardo/client.ts
 init_errors();
@@ -3493,11 +4254,11 @@ var LeonardoClient = class {
   }
   apiKey;
   baseUrl;
-  async request(path46, opts = {}) {
+  async request(path49, opts = {}) {
     const base = this.baseUrl.replace(/\/$/, "");
-    const v2Override = path46.startsWith("v2:");
+    const v2Override = path49.startsWith("v2:");
     const finalBase = v2Override ? base.replace(/\/v1$/, "/v2") : base;
-    const finalPath = v2Override ? path46.slice(3) : path46;
+    const finalPath = v2Override ? path49.slice(3) : path49;
     const url = new URL(finalBase + finalPath);
     if (opts.query) {
       for (const [k, v] of Object.entries(opts.query)) {
@@ -3516,14 +4277,14 @@ var LeonardoClient = class {
       timeoutMs: opts.timeoutMs ?? 12e4
     });
   }
-  get(path46, query, logger) {
-    return this.request(path46, { method: "GET", query, logger });
+  get(path49, query, logger) {
+    return this.request(path49, { method: "GET", query, logger });
   }
-  post(path46, body, logger) {
-    return this.request(path46, { method: "POST", body, logger });
+  post(path49, body, logger) {
+    return this.request(path49, { method: "POST", body, logger });
   }
-  delete(path46, logger) {
-    return this.request(path46, { method: "DELETE", logger });
+  delete(path49, logger) {
+    return this.request(path49, { method: "DELETE", logger });
   }
 };
 function createLeonardoClient() {
@@ -3531,10 +4292,10 @@ function createLeonardoClient() {
 }
 
 // src/providers/leonardo/commands/generate.ts
-function extFromUrl(url, fallback = ".png") {
+function extFromUrl2(url, fallback = ".png") {
   try {
     const u = new URL(url);
-    const e = path26.extname(u.pathname);
+    const e = path29.extname(u.pathname);
     return e.length > 0 ? e : fallback;
   } catch {
     return fallback;
@@ -3545,7 +4306,7 @@ function autoFilename(generationId, index, ext) {
   return `leonardo-${generationId.slice(0, 8)}-${String(index).padStart(2, "0")}${e}`;
 }
 function registerLeonardoGenerateCommand(parent) {
-  parent.command("generate <prompt>").alias("gen").description("Generate images from a text prompt via Leonardo").option("-m, --model <id>", "Model UUID or GPT-image id").option("-w, --width <n>", "Image width").option("-h, --height <n>", "Image height").option("-n, --num <n>", "Number of images").option("--alchemy", "Enable Alchemy").option("--ultra", "Enable Ultra mode").option("--contrast <n>", "Contrast").option("--style <uuid>", "Style UUID").option("--seed <n>", "Seed").option("--negative <text>", "Negative prompt").option("--enhance", "Enhance prompt").option("--quality <level>", "GPT Image quality: LOW|MEDIUM|HIGH", "HIGH").option("--output <path>", "Copy first image to this path (single-image only)").option("--no-download", "Skip downloading; print URLs only").option("--wait-timeout <ms>", "Polling timeout in milliseconds", "480000").option("-v, --verbose", "Verbose logging").action(
+  parent.command("generate <prompt>").alias("gen").description("Generate images from a text prompt via Leonardo").option("-m, --model <id>", "Model UUID or GPT-image id").option("-w, --width <n>", "Image width").option("-h, --height <n>", "Image height").option("-n, --num <n>", "Number of images").option("--alchemy", "Enable Alchemy").option("--ultra", "Enable Ultra mode").option("--contrast <n>", "Contrast").option("--style <uuid>", "Style UUID").option("--seed <n>", "Seed").option("--negative <text>", "Negative prompt").option("--enhance", "Enhance prompt").option("--quality <level>", "GPT Image quality: LOW|MEDIUM|HIGH", "HIGH").option("--output <path>", "Copy first image to this path (single-image only)").addOption(imageFormatOption()).addOption(noWebpOption()).option("--no-download", "Skip downloading; print URLs only").option("--wait-timeout <ms>", "Polling timeout in milliseconds", "480000").option("-v, --verbose", "Verbose logging").action(
     async (prompt, opts) => {
       const logger = createLogger({ verbose: opts.verbose ?? false });
       const client = createLeonardoClient();
@@ -3617,9 +4378,9 @@ function registerLeonardoGenerateCommand(parent) {
       for (let i = 0; i < images.length; i++) {
         const img = images[i];
         if (!img) continue;
-        const ext = extFromUrl(img.url);
+        const ext = extFromUrl2(img.url);
         const filename = autoFilename(generationId, i + 1, ext);
-        const filepath = path26.join(outDir, filename);
+        const filepath = path29.join(outDir, filename);
         try {
           await downloadFile(img.url, filepath);
           saved.push(filepath);
@@ -3629,31 +4390,32 @@ function registerLeonardoGenerateCommand(parent) {
         }
       }
       if (opts.output && saved[0]) {
-        const dest = path26.resolve(opts.output);
-        fs23.mkdirSync(path26.dirname(dest), { recursive: true });
-        fs23.copyFileSync(saved[0], dest);
+        const dest = path29.resolve(opts.output);
+        fs27.mkdirSync(path29.dirname(dest), { recursive: true });
+        fs27.copyFileSync(saved[0], dest);
         logger.success(`Copied to ${dest}`);
       }
+      const finalImages = finalizeGeneratedImages(saved, { ...opts, logger });
       console.log(`
-Generated ${saved.length} image(s):`);
-      for (const f of saved) console.log(`  ${f}`);
+Generated ${finalImages.length} image(s):`);
+      for (const f of finalImages) console.log(`  ${f}`);
     }
   );
 }
 
 // src/providers/leonardo/commands/image-to-image.ts
 init_http_client();
-import fs24 from "fs";
-import path27 from "path";
-function extFromUrl2(url, fallback = ".png") {
+import fs28 from "fs";
+import path30 from "path";
+function extFromUrl3(url, fallback = ".png") {
   try {
-    return path27.extname(new URL(url).pathname) || fallback;
+    return path30.extname(new URL(url).pathname) || fallback;
   } catch {
     return fallback;
   }
 }
 function registerLeonardoImageToImageCommand(parent) {
-  parent.command("image-to-image").alias("i2i").description("Generate an image conditioned on an existing Leonardo image id (init image)").requiredOption("--prompt <text>", "Text prompt describing the desired output").requiredOption("--ref <imageId>", "Existing Leonardo image id to use as init image").option("--image-type <type>", "GENERATED | UPLOADED", "GENERATED").option("--init-strength <n>", "Init image strength (0.0-0.9)", "0.5").option("-m, --model <id>", "Model UUID").option("-w, --width <n>", "Image width").option("-h, --height <n>", "Image height").option("-n, --num <n>", "Number of images").option("--seed <n>", "Seed").option("--negative <text>", "Negative prompt").option("--output <path>", "Copy first image to this path (single-image only)").option("--no-download", "Skip downloading; print URLs only").option("--wait-timeout <ms>", "Polling timeout in milliseconds", "480000").option("-v, --verbose", "Verbose logging").action(
+  parent.command("image-to-image").alias("i2i").description("Generate an image conditioned on an existing Leonardo image id (init image)").requiredOption("--prompt <text>", "Text prompt describing the desired output").requiredOption("--ref <imageId>", "Existing Leonardo image id to use as init image").option("--image-type <type>", "GENERATED | UPLOADED", "GENERATED").option("--init-strength <n>", "Init image strength (0.0-0.9)", "0.5").option("-m, --model <id>", "Model UUID").option("-w, --width <n>", "Image width").option("-h, --height <n>", "Image height").option("-n, --num <n>", "Number of images").option("--seed <n>", "Seed").option("--negative <text>", "Negative prompt").option("--output <path>", "Copy first image to this path (single-image only)").addOption(imageFormatOption()).addOption(noWebpOption()).option("--no-download", "Skip downloading; print URLs only").option("--wait-timeout <ms>", "Polling timeout in milliseconds", "480000").option("-v, --verbose", "Verbose logging").action(
     async (opts) => {
       const logger = createLogger({ verbose: opts.verbose ?? false });
       const imageType = opts.imageType.toUpperCase();
@@ -3707,9 +4469,9 @@ function registerLeonardoImageToImageCommand(parent) {
       for (let i = 0; i < images.length; i++) {
         const img = images[i];
         if (!img) continue;
-        const ext = extFromUrl2(img.url);
+        const ext = extFromUrl3(img.url);
         const filename = `leonardo-i2i-${generationId.slice(0, 8)}-${String(i + 1).padStart(2, "0")}${ext}`;
-        const filepath = path27.join(outDir, filename);
+        const filepath = path30.join(outDir, filename);
         try {
           await downloadFile(img.url, filepath);
           saved.push(filepath);
@@ -3719,21 +4481,22 @@ function registerLeonardoImageToImageCommand(parent) {
         }
       }
       if (opts.output && saved[0]) {
-        const dest = path27.resolve(opts.output);
-        fs24.mkdirSync(path27.dirname(dest), { recursive: true });
-        fs24.copyFileSync(saved[0], dest);
+        const dest = path30.resolve(opts.output);
+        fs28.mkdirSync(path30.dirname(dest), { recursive: true });
+        fs28.copyFileSync(saved[0], dest);
         logger.success(`Copied to ${dest}`);
       }
+      const finalImages = finalizeGeneratedImages(saved, { ...opts, logger });
       console.log(`
-Generated ${saved.length} image(s):`);
-      for (const f of saved) console.log(`  ${f}`);
+Generated ${finalImages.length} image(s):`);
+      for (const f of finalImages) console.log(`  ${f}`);
     }
   );
 }
 
 // src/providers/leonardo/commands/video.ts
 init_http_client();
-import path28 from "path";
+import path31 from "path";
 function v2DimsFor(resolution) {
   if (resolution === "RESOLUTION_1080") return { width: 1920, height: 1080 };
   if (resolution === "RESOLUTION_480") return { width: 854, height: 480 };
@@ -3844,7 +4607,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 ?? path28.join(getOutputDir(), `${opts.basename}-${jobId.slice(0, 8)}.mp4`);
+  const outPath = opts.output ?? path31.join(getOutputDir(), `${opts.basename}-${jobId.slice(0, 8)}.mp4`);
   await downloadFile(videoUrl2, outPath);
   logger.success(`Saved ${outPath}`);
   await maybeDownloadThumb(gen, outPath, {
@@ -3951,7 +4714,7 @@ function registerLeonardoModelsCommand(parent) {
 
 // src/providers/leonardo/commands/status.ts
 init_http_client();
-import path29 from "path";
+import path32 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;
@@ -4016,7 +4779,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 : path29.join(outDir, `leonardo-${generationId.slice(0, 8)}-${idx}.mp4`);
+        const dest = opts.output && videos.length === 1 && images.length === 0 ? opts.output : path32.join(outDir, `leonardo-${generationId.slice(0, 8)}-${idx}.mp4`);
         await downloadFile(url, dest);
         logger.success(`Saved ${dest}`);
         await maybeDownloadThumb(gen, dest, {
@@ -4029,7 +4792,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 = path29.join(outDir, `leonardo-${generationId.slice(0, 8)}-${idx}.${ext}`);
+        const dest = path32.join(outDir, `leonardo-${generationId.slice(0, 8)}-${idx}.${ext}`);
         await downloadFile(url, dest);
         logger.success(`Saved ${dest}`);
         idx++;
@@ -4163,7 +4926,7 @@ async function pollAsyncTask(taskId, taskType, apiKey, opts = {}) {
     if (status === "Failed" || status === "Error") {
       throw new ProviderError(`Task ${taskId} failed: ${JSON.stringify(result)}`, "minimax");
     }
-    await sleep4(intervalMs);
+    await sleep5(intervalMs);
     elapsed += intervalMs;
   }
   throw new ProviderError(`Task ${taskId} timed out after ${timeoutMs / 1e3}s`, "minimax");
@@ -4182,14 +4945,14 @@ async function downloadMinimaxFile(fileId, apiKey, dest, logger) {
   await downloadFile(downloadUrl, dest);
   return dest;
 }
-function sleep4(ms) {
+function sleep5(ms) {
   return new Promise((r) => setTimeout(r, ms));
 }
 
 // src/providers/minimax/generators/music.ts
 init_http_client();
-import fs25 from "fs";
-import path30 from "path";
+import fs29 from "fs";
+import path33 from "path";
 async function generateMinimaxMusic(opts) {
   const {
     apiKey,
@@ -4234,14 +4997,14 @@ async function generateMinimaxMusic(opts) {
   }
   const durationMs = resp.extra_info?.music_duration ?? 0;
   const outDir = getOutputDir();
-  const dest = path30.join(outDir, `minimax_music_${Date.now()}.${outputFormat}`);
+  const dest = path33.join(outDir, `minimax_music_${Date.now()}.${outputFormat}`);
   try {
     if (audioData.startsWith("http")) {
       const bytes = await fetchBytes(audioData);
-      fs25.writeFileSync(dest, bytes);
+      fs29.writeFileSync(dest, bytes);
     } else {
       const audioBytes = Buffer.from(audioData, "hex");
-      fs25.writeFileSync(dest, audioBytes);
+      fs29.writeFileSync(dest, audioBytes);
     }
   } catch (e) {
     return {
@@ -4252,8 +5015,8 @@ async function generateMinimaxMusic(opts) {
   const durSec = durationMs / 1e3;
   logger?.success(`Saved: ${dest} (${durSec.toFixed(1)}s)`);
   if (output) {
-    fs25.mkdirSync(path30.dirname(path30.resolve(output)), { recursive: true });
-    fs25.copyFileSync(dest, output);
+    fs29.mkdirSync(path33.dirname(path33.resolve(output)), { recursive: true });
+    fs29.copyFileSync(dest, output);
   }
   return { status: "success", generatedAudio: dest, durationMs, model };
 }
@@ -4327,8 +5090,8 @@ Generated music: ${result.generatedAudio}`);
 init_errors();
 
 // src/providers/minimax/generators/speech.ts
-import fs26 from "fs";
-import path31 from "path";
+import fs30 from "fs";
+import path34 from "path";
 async function generateMinimaxSpeech(opts) {
   const {
     apiKey,
@@ -4375,12 +5138,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 = path31.join(outDir, `minimax_speech_${Date.now()}.${ext}`);
-  fs26.writeFileSync(dest, audioBytes);
+  const dest = path34.join(outDir, `minimax_speech_${Date.now()}.${ext}`);
+  fs30.writeFileSync(dest, audioBytes);
   logger?.success(`Saved: ${dest} (${(audioBytes.length / 1024).toFixed(1)} KB)`);
   if (output) {
-    fs26.mkdirSync(path31.dirname(path31.resolve(output)), { recursive: true });
-    fs26.copyFileSync(dest, output);
+    fs30.mkdirSync(path34.dirname(path34.resolve(output)), { recursive: true });
+    fs30.copyFileSync(dest, output);
   }
   return { status: "success", generatedAudio: dest, model };
 }
@@ -4427,8 +5190,8 @@ Generated audio: ${result.generatedAudio}`);
 init_errors();
 
 // src/providers/minimax/generators/video.ts
-import fs27 from "fs";
-import path32 from "path";
+import fs31 from "fs";
+import path35 from "path";
 async function generateMinimaxVideo(opts) {
   const {
     apiKey,
@@ -4474,18 +5237,18 @@ async function generateMinimaxVideo(opts) {
     return { status: "error", error: `No file_id in poll result: ${JSON.stringify(pollResult)}` };
   }
   const outDir = getOutputDir();
-  const dest = path32.join(outDir, `minimax_video_${Date.now()}.mp4`);
+  const dest = path35.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 = fs27.statSync(dest);
+  const stat = fs31.statSync(dest);
   const fileSizeMb = stat.size / (1024 * 1024);
   if (output) {
-    fs27.mkdirSync(path32.dirname(path32.resolve(output)), { recursive: true });
-    fs27.copyFileSync(dest, output);
+    fs31.mkdirSync(path35.dirname(path35.resolve(output)), { recursive: true });
+    fs31.copyFileSync(dest, output);
   }
   await maybeDownloadThumb(pollResult, dest, {
     skip: thumb === false,
@@ -4548,8 +5311,8 @@ Generated video: ${result.generatedVideo}`);
 // src/providers/minimax/generators/image.ts
 init_errors();
 init_http_client();
-import fs28 from "fs";
-import path33 from "path";
+import fs32 from "fs";
+import path36 from "path";
 async function generateMinimaxImage(opts) {
   const {
     apiKey,
@@ -4587,8 +5350,8 @@ async function generateMinimaxImage(opts) {
     try {
       const bytes = await fetchBytes(url);
       const fname = `minimax_image_${Date.now()}_${i}.png`;
-      const dest = path33.join(outDir, fname);
-      fs28.writeFileSync(dest, bytes);
+      const dest = path36.join(outDir, fname);
+      fs32.writeFileSync(dest, bytes);
       savedFiles.push(dest);
       logger?.success(`Saved: ${dest}`);
     } catch (e) {
@@ -4599,15 +5362,15 @@ async function generateMinimaxImage(opts) {
     }
   }
   if (output && savedFiles[0]) {
-    fs28.mkdirSync(path33.dirname(path33.resolve(output)), { recursive: true });
-    fs28.copyFileSync(savedFiles[0], output);
+    fs32.mkdirSync(path36.dirname(path36.resolve(output)), { recursive: true });
+    fs32.copyFileSync(savedFiles[0], output);
   }
   return { status: "success", generatedImages: savedFiles, model };
 }
 
 // src/providers/minimax/commands/generate.ts
 function registerMinimaxGenerateCommand(parent) {
-  parent.command("generate").description("Generate images with MiniMax").requiredOption("--prompt <text>", "Image generation prompt").option("--model <id>", `Model (${[...MINIMAX_IMAGE_MODELS].join("|")})`).option("--aspect-ratio <ratio>", "Aspect ratio (e.g. 1:1, 16:9)", "1:1").option("--num-images <n>", "Number of images (1-9)", "1").option("--output <path>", "Copy first image to this path").option("-v, --verbose", "Verbose logging").action(
+  parent.command("generate").description("Generate images with MiniMax").requiredOption("--prompt <text>", "Image generation prompt").option("--model <id>", `Model (${[...MINIMAX_IMAGE_MODELS].join("|")})`).option("--aspect-ratio <ratio>", "Aspect ratio (e.g. 1:1, 16:9)", "1:1").option("--num-images <n>", "Number of images (1-9)", "1").option("--output <path>", "Copy first image to this path").addOption(imageFormatOption()).addOption(noWebpOption()).option("-v, --verbose", "Verbose logging").action(
     async (opts) => {
       const logger = createLogger({ verbose: opts.verbose ?? false });
       const apiKey = requireMinimaxKey();
@@ -4626,9 +5389,13 @@ function registerMinimaxGenerateCommand(parent) {
         logger.error(result.error ?? "Unknown error");
         process.exit(1);
       }
+      const finalImages = finalizeGeneratedImages(result.generatedImages ?? [], {
+        ...opts,
+        logger
+      });
       console.log(`
-Generated ${result.generatedImages?.length ?? 0} image(s):`);
-      for (const f of result.generatedImages ?? []) console.log(`  ${f}`);
+Generated ${finalImages.length} image(s):`);
+      for (const f of finalImages) console.log(`  ${f}`);
     }
   );
 }
@@ -4636,15 +5403,15 @@ Generated ${result.generatedImages?.length ?? 0} image(s):`);
 // src/providers/minimax/commands/image-to-image.ts
 init_errors();
 init_http_client();
-import fs29 from "fs";
-import path34 from "path";
+import fs33 from "fs";
+import path37 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."
   ).requiredOption("--prompt <text>", "Prompt describing the desired NEW scene/composition").requiredOption(
     "--ref <path>",
     "Subject reference image (URL or local path) \u2014 character/face reference only, single image"
-  ).option("--model <id>", "Model id (default image-01)").option("--aspect-ratio <ratio>", "Aspect ratio (e.g. 1:1, 16:9)", "1:1").option("--num-images <n>", "Number of images (1-9)", "1").option("--output <path>", "Copy first image to this path").option("-v, --verbose", "Verbose logging").action(
+  ).option("--model <id>", "Model id (default image-01)").option("--aspect-ratio <ratio>", "Aspect ratio (e.g. 1:1, 16:9)", "1:1").option("--num-images <n>", "Number of images (1-9)", "1").option("--output <path>", "Copy first image to this path").addOption(imageFormatOption()).addOption(noWebpOption()).option("-v, --verbose", "Verbose logging").action(
     async (opts) => {
       const logger = createLogger({ verbose: opts.verbose ?? false });
       const apiKey = requireMinimaxKey();
@@ -4692,8 +5459,8 @@ function registerMinimaxImageToImageCommand(parent) {
         if (!url) continue;
         try {
           const bytes = await fetchBytes(url);
-          const dest = path34.join(outDir, `minimax-i2i-${ts}-${i + 1}.png`);
-          fs29.writeFileSync(dest, bytes);
+          const dest = path37.join(outDir, `minimax-i2i-${ts}-${i + 1}.png`);
+          fs33.writeFileSync(dest, bytes);
           saved.push(dest);
           logger.success(`Saved: ${dest}`);
         } catch (e) {
@@ -4704,13 +5471,14 @@ function registerMinimaxImageToImageCommand(parent) {
         }
       }
       if (opts.output && saved[0]) {
-        fs29.mkdirSync(path34.dirname(path34.resolve(opts.output)), { recursive: true });
-        fs29.copyFileSync(saved[0], opts.output);
+        fs33.mkdirSync(path37.dirname(path37.resolve(opts.output)), { recursive: true });
+        fs33.copyFileSync(saved[0], opts.output);
         logger.success(`Copied to: ${opts.output}`);
       }
+      const finalImages = finalizeGeneratedImages(saved, { ...opts, logger });
       console.log(`
-Generated ${saved.length} image(s):`);
-      for (const f of saved) console.log(`  ${f}`);
+Generated ${finalImages.length} image(s):`);
+      for (const f of finalImages) console.log(`  ${f}`);
     }
   );
 }
@@ -4839,12 +5607,12 @@ function validateKnownSpeakerPairing(names = [], refs = []) {
 
 // src/providers/openai/openai-audio.ts
 init_http_client();
-import fs31 from "fs";
-import path36 from "path";
+import fs35 from "fs";
+import path39 from "path";
 
 // src/providers/openai/client.ts
-import fs30 from "fs";
-import path35 from "path";
+import fs34 from "fs";
+import path38 from "path";
 init_errors();
 init_http_client();
 var DEFAULT_TIMEOUT_MS3 = 24e4;
@@ -4911,10 +5679,10 @@ async function postOpenAIBinary(pathname, body, apiKey, timeoutMs = DEFAULT_TIME
   return Buffer.from(await res.arrayBuffer());
 }
 function fileFromPath(filePath) {
-  const abs = path35.resolve(filePath);
-  if (!fs30.existsSync(abs)) throw new ValidationError(`File not found: ${abs}`);
-  const bytes = fs30.readFileSync(abs);
-  return new File([new Uint8Array(bytes)], path35.basename(abs));
+  const abs = path38.resolve(filePath);
+  if (!fs34.existsSync(abs)) throw new ValidationError(`File not found: ${abs}`);
+  const bytes = fs34.readFileSync(abs);
+  return new File([new Uint8Array(bytes)], path38.basename(abs));
 }
 
 // src/providers/openai/openai-audio.ts
@@ -4953,7 +5721,7 @@ async function resolveAudioReferenceDataUrl(ref) {
 }
 function audioMimeFromReference(ref) {
   const pathname = new URL(ref).pathname;
-  const ext = path36.extname(pathname).toLowerCase();
+  const ext = path39.extname(pathname).toLowerCase();
   switch (ext) {
     case ".mp3":
       return "audio/mpeg";
@@ -4972,12 +5740,12 @@ function audioMimeFromReference(ref) {
 async function generateOpenAISpeech(opts) {
   const bytes = await postOpenAIBinary("/audio/speech", buildSpeechBody(opts), requireOpenAIKey());
   const ext = extFromAudioFormat(opts.outputFormat);
-  const dest = path36.join(getOutputDir(), `openai-speech-${Date.now()}.${ext}`);
-  fs31.writeFileSync(dest, bytes);
+  const dest = path39.join(getOutputDir(), `openai-speech-${Date.now()}.${ext}`);
+  fs35.writeFileSync(dest, bytes);
   opts.logger?.success(`Saved: ${dest} (${(bytes.length / 1024).toFixed(1)} KB)`);
   if (opts.output) {
-    fs31.mkdirSync(path36.dirname(path36.resolve(opts.output)), { recursive: true });
-    fs31.copyFileSync(dest, opts.output);
+    fs35.mkdirSync(path39.dirname(path39.resolve(opts.output)), { recursive: true });
+    fs35.copyFileSync(dest, opts.output);
   }
   return dest;
 }
@@ -4999,9 +5767,9 @@ async function transcribeOpenAIAudio(opts) {
   );
   const text = typeof data.text === "string" ? data.text : void 0;
   const ext = opts.format === "text" ? "txt" : "json";
-  const dest = opts.output ? path36.resolve(opts.output) : path36.join(getOutputDir(), `openai-transcribe-${Date.now()}.${ext}`);
-  fs31.mkdirSync(path36.dirname(dest), { recursive: true });
-  fs31.writeFileSync(dest, opts.format === "text" ? text ?? "" : JSON.stringify(data, null, 2));
+  const dest = opts.output ? path39.resolve(opts.output) : path39.join(getOutputDir(), `openai-transcribe-${Date.now()}.${ext}`);
+  fs35.mkdirSync(path39.dirname(dest), { recursive: true });
+  fs35.writeFileSync(dest, opts.format === "text" ? text ?? "" : JSON.stringify(data, null, 2));
   opts.logger?.success(`Saved transcript: ${dest}`);
   return { path: dest, text };
 }
@@ -5028,9 +5796,9 @@ Generated audio: ${dest}`);
 }
 
 // src/providers/openai/codex-image-driver.ts
-import fs32 from "fs";
+import fs36 from "fs";
 import os2 from "os";
-import path37 from "path";
+import path40 from "path";
 import { execa } from "execa";
 init_errors();
 var defaultRunner = async (cmd, args, opts) => {
@@ -5079,12 +5847,12 @@ function sanitizeCodexEnv() {
 async function runCodexImageGeneration(opts) {
   const runner = opts.runner ?? defaultRunner;
   const ext = extFromImageFormat(opts.outputFormat);
-  const dest = opts.output ? path37.resolve(opts.output) : path37.join(getOutputDir(), `codex-image-${Date.now()}.${ext}`);
-  fs32.mkdirSync(path37.dirname(dest), { recursive: true });
-  const tmp = fs32.mkdtempSync(path37.join(os2.tmpdir(), "multix-codex-image-"));
-  const schema = path37.join(tmp, "schema.json");
-  const result = path37.join(tmp, "result.json");
-  fs32.writeFileSync(
+  const dest = opts.output ? path40.resolve(opts.output) : path40.join(getOutputDir(), `codex-image-${Date.now()}.${ext}`);
+  fs36.mkdirSync(path40.dirname(dest), { recursive: true });
+  const tmp = fs36.mkdtempSync(path40.join(os2.tmpdir(), "multix-codex-image-"));
+  const schema = path40.join(tmp, "schema.json");
+  const result = path40.join(tmp, "result.json");
+  fs36.writeFileSync(
     schema,
     JSON.stringify({
       type: "object",
@@ -5114,7 +5882,7 @@ async function runCodexImageGeneration(opts) {
   if (res.exitCode !== 0) {
     throw new ProviderError(`Codex image driver failed: ${res.stderr || res.stdout}`, "openai");
   }
-  if (!fs32.existsSync(dest) || fs32.statSync(dest).size === 0) {
+  if (!fs36.existsSync(dest) || fs36.statSync(dest).size === 0) {
     throw new ProviderError(`Codex did not create a non-empty image at ${dest}`, "openai");
   }
   return { path: dest };
@@ -5132,8 +5900,8 @@ function buildCodexPrompt(userPrompt, outputPath) {
 // src/providers/openai/openai-image.ts
 init_errors();
 init_http_client();
-import fs33 from "fs";
-import path38 from "path";
+import fs37 from "fs";
+import path41 from "path";
 function buildImageGenerationBody(opts) {
   return {
     model: opts.model ?? DEFAULT_OPENAI_IMAGE_MODEL,
@@ -5166,14 +5934,14 @@ function saveOpenAIImages(opts) {
   for (let i = 0; i < items.length; i++) {
     const b64 = items[i]?.b64_json;
     if (!b64) throw new ProviderError("No b64_json in OpenAI image response", "openai");
-    const dest = path38.join(outDir, `openai-${opts.task}-${ts}-${i + 1}.${ext}`);
-    fs33.writeFileSync(dest, Buffer.from(b64, "base64"));
+    const dest = path41.join(outDir, `openai-${opts.task}-${ts}-${i + 1}.${ext}`);
+    fs37.writeFileSync(dest, Buffer.from(b64, "base64"));
     saved.push(dest);
     opts.logger?.success(`Saved: ${dest}`);
   }
   if (opts.output && saved[0]) {
-    fs33.mkdirSync(path38.dirname(path38.resolve(opts.output)), { recursive: true });
-    fs33.copyFileSync(saved[0], opts.output);
+    fs37.mkdirSync(path41.dirname(path41.resolve(opts.output)), { recursive: true });
+    fs37.copyFileSync(saved[0], opts.output);
     opts.logger?.success(`Copied to: ${opts.output}`);
   }
   return saved;
@@ -5182,7 +5950,7 @@ async function resolveImageRefBytes(ref) {
   if (isHttpUrl(ref)) {
     const bytes2 = await fetchBytes(ref);
     const pathname = new URL(ref).pathname;
-    const filename = path38.basename(pathname) || "reference.png";
+    const filename = path41.basename(pathname) || "reference.png";
     return { filename, bytes: bytes2, mime: sniffImageMime2(bytes2, filename) };
   }
   const file = fileFromPath(ref);
@@ -5227,7 +5995,7 @@ function sniffImageMime2(buf, name) {
   if (buf[0] === 137 && buf[1] === 80 && buf[2] === 78 && buf[3] === 71) return "image/png";
   if (buf.slice(0, 4).toString() === "RIFF" && buf.slice(8, 12).toString() === "WEBP")
     return "image/webp";
-  const ext = path38.extname(name).toLowerCase();
+  const ext = path41.extname(name).toLowerCase();
   if (ext === ".jpg" || ext === ".jpeg") return "image/jpeg";
   if (ext === ".webp") return "image/webp";
   return "image/png";
@@ -5239,9 +6007,12 @@ function registerOpenAIGenerateCommand(parent) {
     "-m, --model <id>",
     "Image model",
     resolveKey("OPENAI_IMAGE_MODEL") ?? DEFAULT_OPENAI_IMAGE_MODEL
-  ).option("--size <size>", "1024x1024|1024x1536|1536x1024|auto", "1024x1024").option("--quality <q>", "low|medium|high", "medium").option("--format <fmt>", "png|jpeg|webp", "png").option("-n, --num-images <n>", "Number of images for API driver", "1").option("--output <path>", "Save first image to this path").option("-v, --verbose", "Verbose logging").action(async (opts) => {
+  ).option("--size <size>", "1024x1024|1024x1536|1536x1024|auto", "1024x1024").option("--quality <q>", "low|medium|high", "medium").option(
+    "--format <fmt>",
+    "Provider output format png|jpeg|webp (explicit value keeps it; default png then WebP)"
+  ).option("-n, --num-images <n>", "Number of images for API driver", "1").option("--output <path>", "Save first image to this path").addOption(imageFormatOption()).addOption(noWebpOption()).option("-v, --verbose", "Verbose logging").action(async (opts) => {
     const logger = createLogger({ verbose: opts.verbose ?? false });
-    const outputFormat = parseImageFormat(opts.format);
+    const outputFormat = parseImageFormat(opts.format ?? "png");
     const driver = await resolveImageDriver({ requested: parseDriver(opts.driver) });
     const saved = driver === "codex" ? [
       (await runCodexImageGeneration({
@@ -5259,9 +6030,14 @@ function registerOpenAIGenerateCommand(parent) {
       output: opts.output,
       logger
     });
+    const finalImages = finalizeGeneratedImages(saved, {
+      ...opts,
+      logger,
+      explicitProviderFormat: opts.format !== void 0
+    });
     console.log(`
-Generated ${saved.length} image(s):`);
-    for (const file of saved) console.log(`  ${file}`);
+Generated ${finalImages.length} image(s):`);
+    for (const f of finalImages) console.log(`  ${f}`);
   });
 }
 
@@ -5277,12 +6053,15 @@ function registerOpenAIImageToImageCommand(parent) {
     "-m, --model <id>",
     "Image model",
     resolveKey("OPENAI_IMAGE_MODEL") ?? DEFAULT_OPENAI_IMAGE_MODEL
-  ).option("--size <size>", "1024x1024|1024x1536|1536x1024|auto", "1024x1024").option("--quality <q>", "low|medium|high", "medium").option("--format <fmt>", "png|jpeg|webp", "png").option("--output <path>", "Save first image to this path").option("-v, --verbose", "Verbose logging").action(async (opts) => {
+  ).option("--size <size>", "1024x1024|1024x1536|1536x1024|auto", "1024x1024").option("--quality <q>", "low|medium|high", "medium").option(
+    "--format <fmt>",
+    "Provider output format png|jpeg|webp (explicit value keeps it; default png then WebP)"
+  ).option("--output <path>", "Save first image to this path").addOption(imageFormatOption()).addOption(noWebpOption()).option("-v, --verbose", "Verbose logging").action(async (opts) => {
     if (!opts.ref || opts.ref.length === 0) {
       throw new ValidationError("At least one --ref is required for image-to-image.");
     }
     const logger = createLogger({ verbose: opts.verbose ?? false });
-    const outputFormat = parseImageFormat(opts.format);
+    const outputFormat = parseImageFormat(opts.format ?? "png");
     const driver = await resolveImageDriver({ requested: parseDriver(opts.driver) });
     const saved = driver === "codex" ? [
       (await runCodexImageGeneration({
@@ -5301,9 +6080,14 @@ function registerOpenAIImageToImageCommand(parent) {
       output: opts.output,
       logger
     });
+    const finalImages = finalizeGeneratedImages(saved, {
+      ...opts,
+      logger,
+      explicitProviderFormat: opts.format !== void 0
+    });
     console.log(`
-Generated ${saved.length} image(s):`);
-    for (const file of saved) console.log(`  ${file}`);
+Generated ${finalImages.length} image(s):`);
+    for (const f of finalImages) console.log(`  ${f}`);
   });
 }
 function collect5(value, prev) {
@@ -5355,8 +6139,8 @@ function registerOpenAICommands(program2) {
 }
 
 // src/providers/openrouter/client.ts
-import fs34 from "fs";
-import path39 from "path";
+import fs38 from "fs";
+import path42 from "path";
 init_errors();
 init_http_client();
 
@@ -5521,8 +6305,8 @@ async function generateOpenRouterImage(opts) {
     if (!url) continue;
     try {
       const bytes = await fetchBytes(url);
-      const dest = path39.join(outDir, `openrouter_image_${Date.now()}_${i}.png`);
-      fs34.writeFileSync(dest, bytes);
+      const dest = path42.join(outDir, `openrouter_image_${Date.now()}_${i}.png`);
+      fs38.writeFileSync(dest, bytes);
       savedFiles.push(dest);
       logger?.success(`Saved: ${dest}`);
     } catch (e) {
@@ -5533,8 +6317,8 @@ async function generateOpenRouterImage(opts) {
     }
   }
   if (output && savedFiles[0]) {
-    fs34.mkdirSync(path39.dirname(path39.resolve(output)), { recursive: true });
-    fs34.writeFileSync(output, fs34.readFileSync(savedFiles[0]));
+    fs38.mkdirSync(path42.dirname(path42.resolve(output)), { recursive: true });
+    fs38.writeFileSync(output, fs38.readFileSync(savedFiles[0]));
   }
   return { status: "success", generatedImages: savedFiles, model: usedModel };
 }
@@ -5543,7 +6327,7 @@ async function generateOpenRouterImage(opts) {
 function registerOpenRouterGenerateCommand(parent) {
   parent.command("generate").description(
     "Generate images via OpenRouter (text-to-image); models: Gemini, GPT-Image, Flux, Recraft, Seedream"
-  ).requiredOption("--prompt <text>", "Image generation prompt").option("--model <id>", "OpenRouter model id (e.g. google/gemini-3.1-flash-image-preview)").option("--aspect-ratio <ratio>", "Aspect ratio (e.g. 1:1, 16:9)", "1:1").option("--image-size <size>", "Image size hint (e.g. 1K, 2K)").option("--num-images <n>", "Number of images to generate", "1").option("--output <path>", "Copy first image to this path").option("-v, --verbose", "Verbose logging").action(
+  ).requiredOption("--prompt <text>", "Image generation prompt").option("--model <id>", "OpenRouter model id (e.g. google/gemini-3.1-flash-image-preview)").option("--aspect-ratio <ratio>", "Aspect ratio (e.g. 1:1, 16:9)", "1:1").option("--image-size <size>", "Image size hint (e.g. 1K, 2K)").option("--num-images <n>", "Number of images to generate", "1").option("--output <path>", "Copy first image to this path").addOption(imageFormatOption()).addOption(noWebpOption()).option("-v, --verbose", "Verbose logging").action(
     async (opts) => {
       const logger = createLogger({ verbose: opts.verbose ?? false });
       const model = opts.model ?? resolveKey("OPENROUTER_IMAGE_MODEL") ?? DEFAULT_OPENROUTER_MODEL;
@@ -5562,17 +6346,21 @@ function registerOpenRouterGenerateCommand(parent) {
         logger.error(result.error ?? "Unknown error");
         process.exit(1);
       }
+      const finalImages = finalizeGeneratedImages(result.generatedImages ?? [], {
+        ...opts,
+        logger
+      });
       console.log(`
-Generated ${result.generatedImages?.length ?? 0} image(s):`);
-      for (const f of result.generatedImages ?? []) console.log(`  ${f}`);
+Generated ${finalImages.length} image(s):`);
+      for (const f of finalImages) console.log(`  ${f}`);
       if (result.model) console.log(`Model used: ${result.model}`);
     }
   );
 }
 
 // src/providers/openrouter/commands/image-to-image.ts
-import fs35 from "fs";
-import path40 from "path";
+import fs39 from "fs";
+import path43 from "path";
 init_errors();
 init_http_client();
 var DEFAULT_MODEL = "google/gemini-2.5-flash-image";
@@ -5586,7 +6374,7 @@ function registerOpenRouterImageToImageCommand(parent) {
     "Reference image (URL or local path); repeatable (most models accept 1)",
     collect7,
     []
-  ).option("-m, --model <id>", `OpenRouter model id (default ${DEFAULT_MODEL})`).option("--strength <n>", "Recraft init-image strength 0..1 (Recraft models only)").option("--output <path>", "Save first generated image to this path").option("-v, --verbose", "Verbose logging").action(
+  ).option("-m, --model <id>", `OpenRouter model id (default ${DEFAULT_MODEL})`).option("--strength <n>", "Recraft init-image strength 0..1 (Recraft models only)").option("--output <path>", "Save first generated image to this path").addOption(imageFormatOption()).addOption(noWebpOption()).option("-v, --verbose", "Verbose logging").action(
     async (opts) => {
       if (!opts.ref || opts.ref.length === 0) {
         throw new ValidationError("At least one --ref is required for image-to-image.");
@@ -5618,9 +6406,10 @@ function registerOpenRouterImageToImageCommand(parent) {
         output: opts.output,
         logger
       });
+      const finalImages = finalizeGeneratedImages(saved, { ...opts, logger });
       console.log(`
-Generated ${saved.length} image(s):`);
-      for (const f of saved) console.log(`  ${f}`);
+Generated ${finalImages.length} image(s):`);
+      for (const f of finalImages) console.log(`  ${f}`);
       console.log(`Model used: ${model}`);
     }
   );
@@ -5664,14 +6453,14 @@ async function runImageToImage(opts) {
     const url = parsed.urls[i];
     if (!url) continue;
     const bytes = await fetchBytes(url);
-    const dest = path40.join(outDir, `openrouter-i2i-${ts}-${i + 1}.png`);
-    fs35.writeFileSync(dest, bytes);
+    const dest = path43.join(outDir, `openrouter-i2i-${ts}-${i + 1}.png`);
+    fs39.writeFileSync(dest, bytes);
     saved.push(dest);
     opts.logger.success(`Saved: ${dest}`);
   }
   if (opts.output && saved[0]) {
-    fs35.mkdirSync(path40.dirname(path40.resolve(opts.output)), { recursive: true });
-    fs35.copyFileSync(saved[0], opts.output);
+    fs39.mkdirSync(path43.dirname(path43.resolve(opts.output)), { recursive: true });
+    fs39.copyFileSync(saved[0], opts.output);
     opts.logger.success(`Copied to: ${opts.output}`);
   }
   return saved;
@@ -5717,13 +6506,13 @@ async function listVideoModels(apiKey = requireOpenRouterKey()) {
 }
 
 // src/providers/openrouter/commands/video-status.ts
-import fs36 from "fs";
-import path41 from "path";
+import fs40 from "fs";
+import path44 from "path";
 async function downloadOpenRouterVideo(opts) {
   const { jobId, logger, source } = opts;
   const apiKey = requireOpenRouterKey();
   const url = videoContentUrl(jobId);
-  const dest = path41.join(getOutputDir(), `openrouter_video_${jobId}.mp4`);
+  const dest = path44.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}`);
@@ -5733,14 +6522,14 @@ async function downloadOpenRouterVideo(opts) {
     logger.error("Empty response body");
     process.exit(1);
   }
-  fs36.mkdirSync(path41.dirname(dest), { recursive: true });
-  const ws = fs36.createWriteStream(dest);
+  fs40.mkdirSync(path44.dirname(dest), { recursive: true });
+  const ws = fs40.createWriteStream(dest);
   const { pipeline: pipeline2 } = await import("stream/promises");
   await pipeline2(r.body, ws);
   logger.success(`Saved ${dest}`);
   if (opts.output) {
-    fs36.mkdirSync(path41.dirname(path41.resolve(opts.output)), { recursive: true });
-    fs36.copyFileSync(dest, opts.output);
+    fs40.mkdirSync(path44.dirname(path44.resolve(opts.output)), { recursive: true });
+    fs40.copyFileSync(dest, opts.output);
     logger.success(`Copied to ${opts.output}`);
   }
   await maybeDownloadThumb(source, dest, {
@@ -5958,6 +6747,7 @@ To configure multix, set at least one provider API key:
     MiniMax            : https://platform.minimax.io/user-center/basic-information/interface-key
     Leonardo.Ai        : https://app.leonardo.ai/settings/api-keys
     BytePlus           : https://console.byteplus.com/auth/api-keys
+    fal.ai             : https://fal.ai/dashboard/keys
 
   Option A \u2014 user global config (recommended):
     echo 'GEMINI_API_KEY=your-key' >> ~/.multix/.env
@@ -6020,6 +6810,12 @@ var PROVIDERS = [
     envPrimary: "ELEVENLABS_API_KEY",
     optional: true,
     link: "https://elevenlabs.io/app/settings/api-keys"
+  },
+  {
+    name: "fal.ai",
+    envPrimary: "FAL_KEY",
+    optional: true,
+    link: "https://fal.ai/dashboard/keys"
   }
 ];
 function resolveProviderKey(p) {
@@ -6151,8 +6947,8 @@ function registerCheckCommand(program2) {
 
 // src/commands/doc/convert.ts
 init_errors();
-import fs37 from "fs";
-import path42 from "path";
+import fs41 from "fs";
+import path45 from "path";
 
 // src/commands/doc/default-prompt.ts
 var DEFAULT_CONVERT_PROMPT = `Convert this document to clean, well-formatted Markdown.
@@ -6173,18 +6969,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 (!fs37.existsSync(f)) throw new ValidationError(`Input file not found: ${f}`);
+    if (!fs41.existsSync(f)) throw new ValidationError(`Input file not found: ${f}`);
   }
   let outputPath;
   if (output) {
-    outputPath = path42.resolve(output);
+    outputPath = path45.resolve(output);
   } else if (autoName && inputs.length === 1 && inputs[0]) {
-    const base = path42.basename(inputs[0], path42.extname(inputs[0]));
-    outputPath = path42.join(getOutputDir(), `${base}-extraction.md`);
+    const base = path45.basename(inputs[0], path45.extname(inputs[0]));
+    outputPath = path45.join(getOutputDir(), `${base}-extraction.md`);
   } else {
-    outputPath = path42.join(getOutputDir(), "document-extraction.md");
+    outputPath = path45.join(getOutputDir(), "document-extraction.md");
   }
-  fs37.mkdirSync(path42.dirname(outputPath), { recursive: true });
+  fs41.mkdirSync(path45.dirname(outputPath), { recursive: true });
   const results = [];
   for (let i = 0; i < inputs.length; i++) {
     const filePath = inputs[i];
@@ -6216,7 +7012,7 @@ async function convertDocuments(opts) {
         if (attempt < 2) {
           const wait = 2 ** attempt * 1e3;
           logger?.debug(`Retry ${attempt + 1} after ${wait / 1e3}s: ${errorMsg}`);
-          await sleep5(wait);
+          await sleep6(wait);
         }
       }
     }
@@ -6235,7 +7031,7 @@ async function convertDocuments(opts) {
 `);
   for (const r of results) {
     lines.push(`
-## ${path42.basename(r.file)}
+## ${path45.basename(r.file)}
 `);
     if (r.status === "success" && r.markdown) {
       lines.push(`${r.markdown}
@@ -6248,7 +7044,7 @@ async function convertDocuments(opts) {
     }
     lines.push("\n---\n");
   }
-  fs37.writeFileSync(outputPath, lines.join("\n"), "utf8");
+  fs41.writeFileSync(outputPath, lines.join("\n"), "utf8");
   const succeeded = results.filter((r) => r.status === "success").length;
   console.log(`
 ${"=".repeat(50)}`);
@@ -6264,7 +7060,7 @@ ${"=".repeat(50)}`);
   const failed = results.filter((r) => r.status === "error").length;
   if (failed > 0) process.exit(1);
 }
-function sleep5(ms) {
+function sleep6(ms) {
   return new Promise((r) => setTimeout(r, ms));
 }
 
@@ -6296,22 +7092,22 @@ function registerDocCommands(program2) {
 
 // src/commands/media/index.ts
 init_errors();
-import fs40 from "fs";
-import path45 from "path";
+import fs44 from "fs";
+import path48 from "path";
 
 // src/commands/media/batch.ts
-import fs38 from "fs";
-import path43 from "path";
+import fs42 from "fs";
+import path46 from "path";
 
 // src/commands/media/detect-type.ts
 var VIDEO_EXTS = /* @__PURE__ */ new Set([".mp4", ".mov", ".avi", ".mkv", ".webm", ".flv", ".mpg", ".mpeg"]);
 var AUDIO_EXTS = /* @__PURE__ */ new Set([".mp3", ".wav", ".m4a", ".flac", ".aac", ".ogg", ".aiff"]);
-var IMAGE_EXTS = /* @__PURE__ */ new Set([".jpg", ".jpeg", ".png", ".webp", ".heic", ".heif", ".gif", ".bmp"]);
+var IMAGE_EXTS2 = /* @__PURE__ */ new Set([".jpg", ".jpeg", ".png", ".webp", ".heic", ".heif", ".gif", ".bmp"]);
 function extToKind(ext) {
   const lower = ext.toLowerCase();
   if (VIDEO_EXTS.has(lower)) return "video";
   if (AUDIO_EXTS.has(lower)) return "audio";
-  if (IMAGE_EXTS.has(lower)) return "image";
+  if (IMAGE_EXTS2.has(lower)) return "image";
   return void 0;
 }
 
@@ -6486,7 +7282,7 @@ async function optimizeVideo(opts) {
 }
 
 // src/commands/media/batch.ts
-var ALL_EXTS = /* @__PURE__ */ new Set([...VIDEO_EXTS, ...AUDIO_EXTS, ...IMAGE_EXTS]);
+var ALL_EXTS = /* @__PURE__ */ new Set([...VIDEO_EXTS, ...AUDIO_EXTS, ...IMAGE_EXTS2]);
 async function batchOptimize(opts) {
   const {
     inputDir,
@@ -6497,10 +7293,10 @@ async function batchOptimize(opts) {
     verbose,
     logger
   } = opts;
-  fs38.mkdirSync(outputDir, { recursive: true });
-  const entries = fs38.readdirSync(inputDir);
+  fs42.mkdirSync(outputDir, { recursive: true });
+  const entries = fs42.readdirSync(inputDir);
   const mediaFiles = entries.filter((f) => {
-    const ext = path43.extname(f).toLowerCase();
+    const ext = path46.extname(f).toLowerCase();
     return ALL_EXTS.has(ext);
   });
   if (mediaFiles.length === 0) {
@@ -6511,9 +7307,9 @@ async function batchOptimize(opts) {
   let succeeded = 0;
   const errors = [];
   for (const file of mediaFiles) {
-    const inputPath = path43.join(inputDir, file);
-    const outputPath = path43.join(outputDir, file);
-    const ext = path43.extname(file).toLowerCase();
+    const inputPath = path46.join(inputDir, file);
+    const outputPath = path46.join(outputDir, file);
+    const ext = path46.extname(file).toLowerCase();
     const kind = extToKind(ext);
     logger?.debug(`Processing: ${file}`);
     try {
@@ -6550,8 +7346,8 @@ async function batchOptimize(opts) {
 
 // src/commands/media/split-video.ts
 init_errors();
-import fs39 from "fs";
-import path44 from "path";
+import fs43 from "fs";
+import path47 from "path";
 async function splitVideo(opts) {
   await assertFfmpeg();
   const { input, outputDir, chunkDuration = 3600, verbose, logger } = opts;
@@ -6562,10 +7358,10 @@ async function splitVideo(opts) {
     logger?.info("Video is short enough \u2014 no splitting needed");
     return [input];
   }
-  fs39.mkdirSync(outputDir, { recursive: true });
-  const ext = path44.extname(input) || ".mp4";
-  const baseName = path44.basename(input, ext);
-  const outputPattern = path44.join(outputDir, `${baseName}_chunk_%03d${ext}`);
+  fs43.mkdirSync(outputDir, { recursive: true });
+  const ext = path47.extname(input) || ".mp4";
+  const baseName = path47.basename(input, ext);
+  const outputPattern = path47.join(outputDir, `${baseName}_chunk_%03d${ext}`);
   logger?.debug(`Splitting into ~${numChunks} chunks of ${chunkDuration}s each`);
   const args = [
     "-i",
@@ -6584,8 +7380,8 @@ async function splitVideo(opts) {
   await runFfmpeg(args, { verbose, logger });
   const files = [];
   for (let i = 0; i < numChunks + 1; i++) {
-    const fname = path44.join(outputDir, `${baseName}_chunk_${String(i).padStart(3, "0")}${ext}`);
-    if (fs39.existsSync(fname)) files.push(fname);
+    const fname = path47.join(outputDir, `${baseName}_chunk_${String(i).padStart(3, "0")}${ext}`);
+    if (fs43.existsSync(fname)) files.push(fname);
   }
   logger?.success(`Created ${files.length} chunks in ${outputDir}`);
   return files;
@@ -6599,9 +7395,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 (!fs40.existsSync(opts.input)) throw new ValidationError(`Input not found: ${opts.input}`);
-      fs40.mkdirSync(path45.dirname(path45.resolve(opts.output)), { recursive: true });
-      const ext = path45.extname(opts.input).toLowerCase();
+      if (!fs44.existsSync(opts.input)) throw new ValidationError(`Input not found: ${opts.input}`);
+      fs44.mkdirSync(path48.dirname(path48.resolve(opts.output)), { recursive: true });
+      const ext = path48.extname(opts.input).toLowerCase();
       const kind = extToKind(ext);
       if (!kind) throw new ValidationError(`Unsupported file type: ${ext}`);
       const quality = Number.parseInt(opts.quality, 10);
@@ -6641,7 +7437,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 (!fs40.existsSync(opts.input)) throw new ValidationError(`Input not found: ${opts.input}`);
+      if (!fs44.existsSync(opts.input)) throw new ValidationError(`Input not found: ${opts.input}`);
       const chunks = await splitVideo({
         input: opts.input,
         outputDir: opts.outputDir,
@@ -6657,7 +7453,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 (!fs40.existsSync(opts.inputDir))
+      if (!fs44.existsSync(opts.inputDir))
         throw new ValidationError(`Input dir not found: ${opts.inputDir}`);
       const result = await batchOptimize({
         inputDir: opts.inputDir,
@@ -6678,9 +7474,157 @@ Processed: ${result.succeeded}/${result.total} files`);
   );
 }
 
+// src/commands/update.ts
+init_errors();
+init_http_client();
+import { createRequire } from "module";
+import { execa as execa5 } from "execa";
+
+// src/core/package-manager.ts
+var PACKAGE_NAME = "@mrgoonie/multix";
+function detectPackageManager(execPath, env = process.env) {
+  const normalized = execPath.replace(/\\/g, "/").toLowerCase();
+  if (normalized.includes("/.bun/") || normalized.includes("/bun/install/")) return "bun";
+  if (normalized.includes("/.pnpm/") || normalized.includes("/pnpm/") || normalized.includes("/pnpm-global/"))
+    return "pnpm";
+  if (normalized.includes("/yarn/") || normalized.includes("/.yarn/")) return "yarn";
+  if (normalized.includes("/.npm/") || normalized.includes("/npm/") || normalized.includes("/node_modules/"))
+    return "npm";
+  const userAgent = env.npm_config_user_agent ?? "";
+  if (userAgent.startsWith("bun")) return "bun";
+  if (userAgent.startsWith("pnpm")) return "pnpm";
+  if (userAgent.startsWith("yarn")) return "yarn";
+  if (userAgent.startsWith("npm")) return "npm";
+  return "npm";
+}
+function buildUpdateCommand(pm, tag = "latest") {
+  const spec = `${PACKAGE_NAME}@${tag}`;
+  switch (pm) {
+    case "pnpm":
+      return { command: "pnpm", args: ["add", "-g", spec] };
+    case "yarn":
+      return { command: "yarn", args: ["global", "add", spec] };
+    case "bun":
+      return { command: "bun", args: ["add", "-g", spec] };
+    default:
+      return { command: "npm", args: ["i", "-g", spec] };
+  }
+}
+function formatUpdateCommand(cmd) {
+  return [cmd.command, ...cmd.args].join(" ");
+}
+function compareVersions(a, b) {
+  const parse = (v) => {
+    const [core, prerelease] = v.replace(/^v/, "").split("-", 2);
+    const parts = (core ?? "").split(".").map((n) => Number.parseInt(n, 10) || 0);
+    return { parts, prerelease };
+  };
+  const pa = parse(a);
+  const pb = parse(b);
+  for (let i = 0; i < 3; i++) {
+    const na = pa.parts[i] ?? 0;
+    const nb = pb.parts[i] ?? 0;
+    if (na !== nb) return na < nb ? -1 : 1;
+  }
+  if (pa.prerelease === pb.prerelease) return 0;
+  if (pa.prerelease === void 0) return 1;
+  if (pb.prerelease === void 0) return -1;
+  return pa.prerelease < pb.prerelease ? -1 : 1;
+}
+
+// src/commands/update.ts
+var PACKAGE_NAME2 = "@mrgoonie/multix";
+var REGISTRY_BASE = "https://registry.npmjs.org";
+var require2 = createRequire(import.meta.url);
+function getCurrentVersion() {
+  const pkg2 = require2("../../package.json");
+  return pkg2.version;
+}
+async function fetchRegistryVersion(tag = "latest") {
+  try {
+    const doc = await httpJson({
+      url: `${REGISTRY_BASE}/${PACKAGE_NAME2}/${encodeURIComponent(tag)}`
+    });
+    if (!doc.version) {
+      throw new Error(`Registry response for tag "${tag}" is missing a version field`);
+    }
+    return doc.version;
+  } catch (e) {
+    if (e instanceof HttpError) {
+      if (e.status === 404) {
+        throw new Error(`Dist-tag "${tag}" does not exist for ${PACKAGE_NAME2}`);
+      }
+      throw new Error(`Failed to reach npm registry: ${e.message}`);
+    }
+    const msg = e instanceof Error ? e.message : String(e);
+    throw new Error(`Failed to reach npm registry: ${msg}`);
+  }
+}
+function registerUpdateCommand(program2) {
+  program2.command("update").description("Update multix to the latest (or a given dist-tag) published version").option("--check", "Only compare current vs. latest version; do not install").option(
+    "--tag <tag>",
+    "Install a specific dist-tag instead of latest (always installs, skipping the up-to-date check)"
+  ).option("--dry-run", "Print the install command instead of running it").option("-v, --verbose", "Verbose logging").action(
+    async (opts) => {
+      const logger = createLogger({ verbose: opts.verbose ?? false });
+      const currentVersion = getCurrentVersion();
+      const explicitTag = opts.tag !== void 0;
+      const tag = opts.tag ?? "latest";
+      logger.info(`Current version: ${currentVersion}`);
+      logger.info(`Checking npm registry for "${tag}"...`);
+      let latestVersion;
+      try {
+        latestVersion = await fetchRegistryVersion(tag);
+      } catch (e) {
+        logger.error(e instanceof Error ? e.message : String(e));
+        process.exit(1);
+      }
+      const cmp = compareVersions(latestVersion, currentVersion);
+      if (opts.check) {
+        if (cmp > 0) {
+          logger.info(`Update available: ${currentVersion} -> ${latestVersion}`);
+          console.log(`Run \`multix update\` to install ${latestVersion}.`);
+        } else {
+          logger.success(`Already up to date (${currentVersion}).`);
+        }
+        return;
+      }
+      if (!explicitTag && cmp <= 0) {
+        logger.success(`Already up to date (${currentVersion}).`);
+        return;
+      }
+      if (explicitTag && cmp <= 0) {
+        logger.info(
+          `Requested tag "${tag}" (${latestVersion}) \u2014 installing regardless of current version (${currentVersion}).`
+        );
+      }
+      const pm = detectPackageManager(process.argv[1] ?? process.execPath);
+      const updateCmd = buildUpdateCommand(pm, tag);
+      const commandStr = formatUpdateCommand(updateCmd);
+      logger.info(`Detected package manager: ${pm}`);
+      logger.info(`Updating ${currentVersion} -> ${latestVersion}`);
+      if (opts.dryRun) {
+        console.log(commandStr);
+        return;
+      }
+      logger.info(`Running: ${commandStr}`);
+      try {
+        await execa5(updateCmd.command, updateCmd.args, { stdio: "inherit" });
+      } catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        logger.error(`Update command failed: ${msg}`);
+        logger.info(`You can run it manually: ${commandStr}`);
+        process.exit(1);
+      }
+      logger.success(`Updated to ${latestVersion}.`);
+    }
+  );
+}
+
 // src/commands/index.ts
 function registerCommands(program2) {
   registerCheckCommand(program2);
+  registerUpdateCommand(program2);
   registerGeminiCommands(program2);
   registerMinimaxCommands(program2);
   registerOpenAICommands(program2);
@@ -6689,6 +7633,7 @@ function registerCommands(program2) {
   registerBytePlusCommands(program2);
   registerCloudflareCommands(program2);
   registerElevenLabsCommands(program2);
+  registerFalCommands(program2);
   registerMediaCommands(program2);
   registerDocCommands(program2);
 }
@@ -6699,10 +7644,10 @@ init_http_client();
 
 // src/cli.ts
 loadEnv();
-var require2 = createRequire(import.meta.url);
-var pkg = require2("../package.json");
+var require3 = createRequire2(import.meta.url);
+var pkg = require3("../package.json");
 var program = new Command().name("multix").description(
-  "AI multimodal CLI \u2014 image/video/audio/3D generation, editing, transcription, and media processing via OpenAI, Gemini, MiniMax, OpenRouter, Leonardo, BytePlus, ElevenLabs, ffmpeg, and ImageMagick"
+  "AI multimodal CLI \u2014 image/video/audio/3D generation, editing, transcription, and media processing via OpenAI, Gemini, MiniMax, OpenRouter, Leonardo, BytePlus, ElevenLabs, fal.ai, ffmpeg, and ImageMagick"
 ).version(pkg.version);
 registerCommands(program);
 program.parseAsync(process.argv).catch((err2) => {