@mrgoonie/multix 0.2.0 → 0.3.0

package/dist/cli.js

@@ -414,9 +414,9 @@ var BytePlusClient = class {
   }
   apiKey;
   baseUrl;
-  async request(path45, opts = {}) {
+  async request(path46, opts = {}) {
     const base = this.baseUrl.replace(/\/$/, "");
-    const url = new URL(base + path45);
+    const url = new URL(base + path46);
     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 +434,14 @@ var BytePlusClient = class {
       timeoutMs: opts.timeoutMs ?? 12e4
     });
   }
-  get(path45, query, logger) {
-    return this.request(path45, { method: "GET", query, logger });
+  get(path46, query, logger) {
+    return this.request(path46, { method: "GET", query, logger });
   }
-  post(path45, body, logger) {
-    return this.request(path45, { method: "POST", body, logger });
+  post(path46, body, logger) {
+    return this.request(path46, { method: "POST", body, logger });
   }
-  delete(path45, logger) {
-    return this.request(path45, { method: "DELETE", logger });
+  delete(path46, logger) {
+    return this.request(path46, { method: "DELETE", logger });
   }
 };
 function createBytePlusClient() {
@@ -990,10 +990,10 @@ function toRef(kind, resolved, role) {
   return { kind, url: resolved.dataUrl, mime: resolved.mime, role };
 }
 async function resolveRefSpec(kind, spec, logger) {
-  const { path: path45, role } = parseRefSpec(spec);
-  if (kind === "image") return toRef(kind, await resolveImageInput(path45, logger), role);
-  if (kind === "video") return toRef(kind, await resolveVideoInput(path45, logger), role);
-  return toRef(kind, await resolveAudioInput(path45, logger), role);
+  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);
 }
 async function resolveRefSpecs(specs, logger) {
   const out = [];
@@ -1131,11 +1131,11 @@ function registerBytePlusStatusCommand(parent) {
         console.log(JSON.stringify(status, null, 2));
         if (opts.download && status.status === "succeeded") {
           const content = status.content;
-          const videoUrl = content?.video_url;
+          const videoUrl2 = content?.video_url;
           const fileUrl = content?.file_url;
-          if (videoUrl) {
+          if (videoUrl2) {
             const outPath = opts.output ?? path10.join(getOutputDir(), `byteplus-video-${taskId.slice(0, 8)}.mp4`);
-            await downloadVideo(videoUrl, outPath, logger);
+            await downloadVideo(videoUrl2, outPath, logger);
             await maybeDownloadThumb(status, outPath, {
               skip: opts.thumb === false,
               copyTo: opts.output,
@@ -1251,9 +1251,375 @@ function registerBytePlusCommands(program2) {
   registerBytePlusStatusCommand(byteplus);
 }
 
-// src/providers/elevenlabs/client.ts
+// src/providers/cloudflare/commands/generate-speech.ts
+init_errors();
+
+// src/providers/cloudflare/client.ts
+init_errors();
+
+// src/providers/cloudflare/models.ts
+init_errors();
+var CLOUDFLARE_IMAGE_MODEL = "@cf/black-forest-labs/flux-1-schnell";
+var CLOUDFLARE_TTS_MODEL = "@cf/myshell-ai/melotts";
+var CLOUDFLARE_VIDEO_MODEL = "prunaai/p-video";
+function required(name) {
+  const value = resolveKey(name)?.trim();
+  if (!value) throw new ConfigError(`${name} is required for Cloudflare media generation`);
+  return value;
+}
+function getCloudflareModel(kind, requested) {
+  const expected = kind === "image" ? CLOUDFLARE_IMAGE_MODEL : CLOUDFLARE_TTS_MODEL;
+  const overrideName = kind === "image" ? "CLOUDFLARE_AI_IMAGE_MODEL" : "CLOUDFLARE_AI_TTS_MODEL";
+  const model = requested ?? resolveKey(overrideName) ?? expected;
+  if (model !== expected) {
+    throw new ValidationError(`Unsupported Cloudflare ${kind} model: ${model}`);
+  }
+  return model;
+}
+function validateImageSteps(value) {
+  if (!/^\d+$/.test(value)) {
+    throw new ValidationError("--steps must be an integer from 1 to 8 for flux-1-schnell");
+  }
+  const steps = Number.parseInt(value, 10);
+  if (!Number.isInteger(steps) || steps < 1 || steps > 8) {
+    throw new ValidationError("--steps must be an integer from 1 to 8 for flux-1-schnell");
+  }
+  return steps;
+}
+function requireCloudflareConfig() {
+  return {
+    accountId: required("CLOUDFLARE_ACCOUNT_ID"),
+    apiToken: required("CLOUDFLARE_API_TOKEN"),
+    gatewayId: resolveKey("CLOUDFLARE_AI_GATEWAY_ID")?.trim() || void 0
+  };
+}
+function requireCloudflareVideoConfig() {
+  const config = requireCloudflareConfig();
+  if (!config.gatewayId) {
+    throw new ConfigError("CLOUDFLARE_AI_GATEWAY_ID is required for Cloudflare video generation");
+  }
+  return {
+    ...config,
+    gatewayId: config.gatewayId,
+    replicateApiToken: required("REPLICATE_API_TOKEN")
+  };
+}
+
+// src/providers/cloudflare/client.ts
+function collectPayloadHeader() {
+  const envName = ["CLOUDFLARE", "AI", "GATEWAY", "COLLECT", "LOG", "PAYLOAD"].join("_");
+  return resolveKey(envName) === "true" ? "true" : "false";
+}
+function gatewayHeaders(config) {
+  return {
+    Authorization: `Bearer ${config.apiToken}`,
+    "Content-Type": "application/json",
+    "cf-aig-gateway-id": config.gatewayId ?? "",
+    "cf-aig-collect-log-payload": collectPayloadHeader()
+  };
+}
+function providerFailure(status) {
+  return new ProviderError(`Cloudflare request failed with HTTP ${status}`, "Cloudflare");
+}
+async function readJson(response) {
+  if (!response.ok) throw providerFailure(response.status);
+  try {
+    return await response.json();
+  } catch {
+    throw new ProviderError("Cloudflare returned an invalid JSON response", "Cloudflare");
+  }
+}
+function nativeUrl(accountId, model) {
+  return `https://api.cloudflare.com/client/v4/accounts/${encodeURIComponent(accountId)}/ai/run/${model}`;
+}
+function gatewayUrl(accountId) {
+  return `https://api.cloudflare.com/client/v4/accounts/${encodeURIComponent(accountId)}/ai/run`;
+}
+async function runCloudflareJson(model, input) {
+  const config = requireCloudflareConfig();
+  const useGateway = Boolean(config.gatewayId);
+  const response = await globalThis.fetch(
+    useGateway ? gatewayUrl(config.accountId) : nativeUrl(config.accountId, model),
+    {
+      method: "POST",
+      headers: useGateway ? gatewayHeaders(config) : { Authorization: `Bearer ${config.apiToken}`, "Content-Type": "application/json" },
+      body: JSON.stringify(useGateway ? { model, input } : input)
+    }
+  );
+  const payload = await readJson(response);
+  if (payload.success === false || payload.result === void 0) {
+    throw new ProviderError("Cloudflare returned no usable result", "Cloudflare");
+  }
+  return payload.result;
+}
+async function runCloudflareBytes(model, input) {
+  const config = requireCloudflareConfig();
+  const useGateway = Boolean(config.gatewayId);
+  const response = await globalThis.fetch(
+    useGateway ? gatewayUrl(config.accountId) : nativeUrl(config.accountId, model),
+    {
+      method: "POST",
+      headers: useGateway ? gatewayHeaders(config) : { Authorization: `Bearer ${config.apiToken}`, "Content-Type": "application/json" },
+      body: JSON.stringify(useGateway ? { model, input } : input)
+    }
+  );
+  if (!response.ok) throw providerFailure(response.status);
+  const contentType = response.headers.get("content-type") ?? "";
+  if (!contentType.includes("audio/mpeg")) {
+    throw new ProviderError("Cloudflare did not return MPEG audio", "Cloudflare");
+  }
+  return new Uint8Array(await response.arrayBuffer());
+}
+function videoUrl(config, suffix = "") {
+  return `https://gateway.ai.cloudflare.com/v1/${encodeURIComponent(config.accountId)}/${encodeURIComponent(config.gatewayId)}/replicate/predictions${suffix}`;
+}
+function videoHeaders(config, wait = false) {
+  return {
+    Authorization: `Bearer ${config.replicateApiToken}`,
+    "cf-aig-authorization": `Bearer ${config.apiToken}`,
+    "cf-aig-collect-log-payload": collectPayloadHeader(),
+    "Content-Type": "application/json",
+    ...wait ? { Prefer: "wait" } : {}
+  };
+}
+function prediction(value) {
+  if (!value || typeof value !== "object") {
+    throw new ProviderError("Cloudflare returned an invalid video prediction", "Cloudflare");
+  }
+  const result = value;
+  if (typeof result.id !== "string" || typeof result.status !== "string") {
+    throw new ProviderError("Cloudflare returned an invalid video prediction", "Cloudflare");
+  }
+  if (result.output !== void 0 && typeof result.output !== "string" && (!Array.isArray(result.output) || !result.output.every((item) => typeof item === "string"))) {
+    throw new ProviderError("Cloudflare returned an invalid video output", "Cloudflare");
+  }
+  return { id: result.id, status: result.status, output: result.output };
+}
+async function createVideoPrediction(input, wait = false) {
+  const config = requireCloudflareVideoConfig();
+  const response = await globalThis.fetch(videoUrl(config), {
+    method: "POST",
+    headers: videoHeaders(config, wait),
+    body: JSON.stringify({ version: CLOUDFLARE_VIDEO_MODEL, input })
+  });
+  return prediction(await readJson(response));
+}
+async function getVideoPrediction(id) {
+  const config = requireCloudflareVideoConfig();
+  const response = await globalThis.fetch(videoUrl(config, `/${encodeURIComponent(id)}`), {
+    headers: videoHeaders(config)
+  });
+  return prediction(await readJson(response));
+}
+async function downloadVideo2(url) {
+  let response;
+  try {
+    response = await globalThis.fetch(url);
+  } catch {
+    throw new ProviderError("Cloudflare video download could not be started", "Cloudflare");
+  }
+  if (!response.ok)
+    throw new ProviderError(
+      `Cloudflare video download failed with HTTP ${response.status}`,
+      "Cloudflare"
+    );
+  return new Uint8Array(await response.arrayBuffer());
+}
+
+// src/providers/cloudflare/media-output.ts
+init_errors();
 import fs7 from "fs";
 import path12 from "path";
+function destination(filename, output) {
+  return output ? path12.resolve(output) : path12.join(getOutputDir(), filename);
+}
+function saveBytes(bytes, filename, output) {
+  const dest = destination(filename, output);
+  fs7.mkdirSync(path12.dirname(dest), { recursive: true });
+  fs7.writeFileSync(dest, bytes);
+  return dest;
+}
+function saveBase64Image(image, output) {
+  if (!/^[A-Za-z0-9+/]*={0,2}$/.test(image) || image.length === 0 || image.length % 4 !== 0) {
+    throw new ProviderError("Cloudflare returned an invalid image result", "Cloudflare");
+  }
+  let bytes;
+  try {
+    bytes = Buffer.from(image, "base64");
+  } catch {
+    throw new ProviderError("Cloudflare returned an invalid image result", "Cloudflare");
+  }
+  if (bytes.length === 0)
+    throw new ProviderError("Cloudflare returned an empty image result", "Cloudflare");
+  return saveBytes(bytes, `cloudflare_image_${Date.now()}.jpg`, output);
+}
+
+// src/providers/cloudflare/commands/generate-speech.ts
+function registerCloudflareSpeechCommand(parent) {
+  parent.command("generate-speech").description("Generate MPEG speech with Cloudflare Workers AI MeloTTS").requiredOption("--text <text>", "Text to speak").option("--lang <code>", "MeloTTS language code").option("--model <id>", "Cloudflare TTS model").option("--output <path>", "Save MP3 at this path").option("-v, --verbose", "Verbose logging").action(
+    async (opts) => {
+      if (!opts.text.trim()) throw new ValidationError("--text must not be empty");
+      if (opts.lang !== void 0 && !opts.lang.trim())
+        throw new ValidationError("--lang must not be empty");
+      const logger = createLogger({ verbose: opts.verbose ?? false });
+      const model = getCloudflareModel("speech", opts.model);
+      const input = { prompt: opts.text };
+      if (opts.lang) input.lang = opts.lang;
+      logger.debug(`Cloudflare speech model=${model}`);
+      const bytes = await runCloudflareBytes(model, input);
+      const destination2 = saveBytes(bytes, `cloudflare_speech_${Date.now()}.mp3`, opts.output);
+      logger.success(`Saved ${destination2}`);
+      console.log(destination2);
+    }
+  );
+}
+
+// src/providers/cloudflare/commands/generate-video.ts
+init_errors();
+
+// src/providers/cloudflare/commands/video-helpers.ts
+init_errors();
+function positiveInteger(value, flag) {
+  if (!/^\d+$/.test(value)) throw new ValidationError(`${flag} must be a positive integer`);
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isInteger(parsed) || parsed < 1)
+    throw new ValidationError(`${flag} must be a positive integer`);
+  return parsed;
+}
+function outputUrl(prediction2) {
+  if (typeof prediction2.output === "string") return prediction2.output;
+  return prediction2.output?.find((value) => typeof value === "string");
+}
+async function saveCompletedVideo(prediction2, output) {
+  const url = outputUrl(prediction2);
+  if (!url)
+    throw new ProviderError("Cloudflare completed the video without an output", "Cloudflare");
+  const bytes = await downloadVideo2(url);
+  return saveBytes(bytes, `cloudflare_video_${prediction2.id}.mp4`, output);
+}
+async function waitForVideo(prediction2, timeoutMs, onTick) {
+  const deadline = Date.now() + timeoutMs;
+  let current = prediction2;
+  while (!isTerminalVideoStatus(current.status)) {
+    if (Date.now() >= deadline)
+      throw new ProviderError("Cloudflare video polling timed out", "Cloudflare");
+    await new Promise((resolve) => setTimeout(resolve, 5e3));
+    current = await getVideoPrediction(current.id);
+    onTick?.(current.status);
+  }
+  if (current.status !== "succeeded")
+    throw new ProviderError("Cloudflare video generation failed", "Cloudflare");
+  return current;
+}
+function isTerminalVideoStatus(status) {
+  return status === "succeeded" || status === "failed" || status === "canceled" || status === "cancelled" || status === "aborted";
+}
+
+// src/providers/cloudflare/commands/generate-video.ts
+function registerCloudflareVideoCommand(parent) {
+  parent.command("generate-video").description("Create a prunaai/p-video prediction through Cloudflare AI Gateway").requiredOption("--prompt <text>", "Video prompt").option("--duration <seconds>", "Video duration in seconds", "5").option("--aspect-ratio <ratio>", "Aspect ratio", "16:9").option("--resolution <value>", "Resolution", "720p").option("--fps <n>", "Frames per second", "24").option("--wait", "Poll until the prediction succeeds or fails").option("--wait-timeout <ms>", "Polling timeout in ms", "600000").option("--download", "Download the completed video (implies --wait)").option("--output <path>", "Save video at this path").option("-v, --verbose", "Verbose logging").action(
+    async (opts) => {
+      if (!opts.prompt.trim()) throw new ValidationError("--prompt must not be empty");
+      if (!opts.aspectRatio.trim()) throw new ValidationError("--aspect-ratio must not be empty");
+      if (!opts.resolution.trim()) throw new ValidationError("--resolution must not be empty");
+      const logger = createLogger({ verbose: opts.verbose ?? false });
+      const input = {
+        prompt: opts.prompt,
+        duration: positiveInteger(opts.duration, "--duration"),
+        aspect_ratio: opts.aspectRatio,
+        resolution: opts.resolution,
+        fps: positiveInteger(opts.fps, "--fps")
+      };
+      const shouldWait = Boolean(opts.wait || opts.download);
+      const prediction2 = await createVideoPrediction(input, shouldWait);
+      logger.success(`Video job ${prediction2.id} (${prediction2.status})`);
+      if (!shouldWait) {
+        console.log(prediction2.id);
+        console.error(`Poll with: multix cloudflare video-status ${prediction2.id}`);
+        return;
+      }
+      const completed = prediction2.status === "succeeded" ? prediction2 : await waitForVideo(
+        prediction2,
+        positiveInteger(opts.waitTimeout, "--wait-timeout"),
+        (status) => logger.debug(`Video status: ${status}`)
+      );
+      const destination2 = await saveCompletedVideo(completed, opts.output);
+      logger.success(`Saved ${destination2}`);
+      console.log(destination2);
+    }
+  );
+}
+
+// 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(
+    async (opts) => {
+      if (!opts.prompt.trim()) throw new ValidationError("--prompt must not be empty");
+      const logger = createLogger({ verbose: opts.verbose ?? false });
+      const model = getCloudflareModel("image", opts.model);
+      const steps = validateImageSteps(opts.steps);
+      const input = { prompt: opts.prompt, steps };
+      if (opts.seed !== void 0) {
+        if (!/^\d+$/.test(opts.seed)) {
+          throw new ValidationError("--seed must be a non-negative integer");
+        }
+        const seed = Number.parseInt(opts.seed, 10);
+        if (!Number.isInteger(seed) || seed < 0) {
+          throw new ValidationError("--seed must be a non-negative integer");
+        }
+        input.seed = seed;
+      }
+      logger.debug(`Cloudflare image model=${model} steps=${steps}`);
+      const result = await runCloudflareJson(model, input);
+      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}`);
+      console.log(destination2);
+    }
+  );
+}
+
+// src/providers/cloudflare/commands/video-status.ts
+function registerCloudflareVideoStatusCommand(parent) {
+  parent.command("video-status <id>").description("Check, wait for, or download a Cloudflare AI Gateway video prediction").option("--wait", "Poll until the prediction succeeds or fails").option("--wait-timeout <ms>", "Polling timeout in ms", "600000").option("--download", "Download the completed video (implies --wait)").option("--output <path>", "Save video at this path").option("-v, --verbose", "Verbose logging").action(
+    async (id, opts) => {
+      const logger = createLogger({ verbose: opts.verbose ?? false });
+      const shouldWait = Boolean(opts.wait || opts.download);
+      const prediction2 = await getVideoPrediction(id);
+      const completed = shouldWait && prediction2.status !== "succeeded" ? await waitForVideo(
+        prediction2,
+        positiveInteger(opts.waitTimeout, "--wait-timeout"),
+        (status) => logger.debug(`Video status: ${status}`)
+      ) : prediction2;
+      console.log(`${completed.id}: ${completed.status}`);
+      if (opts.download) {
+        if (completed.status !== "succeeded") {
+          logger.warn(`Cannot download while status is ${completed.status}`);
+          return;
+        }
+        const destination2 = await saveCompletedVideo(completed, opts.output);
+        logger.success(`Saved ${destination2}`);
+        console.log(destination2);
+      }
+    }
+  );
+}
+
+// src/providers/cloudflare/commands/index.ts
+function registerCloudflareCommands(program2) {
+  const cloudflare = program2.command("cloudflare").description("Cloudflare Workers AI image and speech, plus AI Gateway video generation");
+  registerCloudflareGenerateCommand(cloudflare);
+  registerCloudflareSpeechCommand(cloudflare);
+  registerCloudflareVideoCommand(cloudflare);
+  registerCloudflareVideoStatusCommand(cloudflare);
+}
+
+// src/providers/elevenlabs/client.ts
+import fs8 from "fs";
+import path13 from "path";
 init_errors();
 init_http_client();
 
@@ -1415,10 +1781,10 @@ async function apiPostMultipart(endpoint2, form, apiKey, opts = {}) {
   return res.json();
 }
 function readFileAsBlob(filePath, fieldFilename) {
-  const abs = path12.resolve(filePath);
-  if (!fs7.existsSync(abs)) throw new ValidationError(`File not found: ${abs}`);
-  const buf = fs7.readFileSync(abs);
-  const name = fieldFilename ?? path12.basename(abs);
+  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);
   return new File([new Uint8Array(buf)], name);
 }
 async function pollUntil(fetchStatus, isDone, isFailed, opts = {}) {
@@ -1439,15 +1805,15 @@ async function pollUntil(fetchStatus, isDone, isFailed, opts = {}) {
   }
   throw new ProviderError(`${label} timed out after ${timeoutMs / 1e3}s`, "elevenlabs");
 }
-function saveBytes(opts) {
+function saveBytes2(opts) {
   const { bytes, task, ext, outputCopy, logger } = opts;
   const dir = getOutputDir();
-  const dest = path12.join(dir, `elevenlabs_${task}_${Date.now()}.${ext}`);
-  fs7.writeFileSync(dest, bytes);
+  const dest = path13.join(dir, `elevenlabs_${task}_${Date.now()}.${ext}`);
+  fs8.writeFileSync(dest, bytes);
   logger?.success(`Saved: ${dest} (${(bytes.length / 1024).toFixed(1)} KB)`);
   if (outputCopy) {
-    fs7.mkdirSync(path12.dirname(path12.resolve(outputCopy)), { recursive: true });
-    fs7.copyFileSync(dest, outputCopy);
+    fs8.mkdirSync(path13.dirname(path13.resolve(outputCopy)), { recursive: true });
+    fs8.copyFileSync(dest, outputCopy);
   }
   return dest;
 }
@@ -1486,14 +1852,14 @@ ${models.length} models`);
 }
 
 // src/providers/elevenlabs/commands/align.ts
-import fs8 from "fs";
-import path13 from "path";
+import fs9 from "fs";
+import path14 from "path";
 function registerAlignCommand(parent) {
   parent.command("align").description("Forced alignment of audio to a transcript (returns word/char timestamps)").requiredOption("--input <path>", "Source audio file").requiredOption("--text <str>", "Transcript text (or pass --text-file)").option("--text-file <path>", "Read transcript from file").option("--output <path>", "Save JSON to this path (default: multix-output)").option("-v, --verbose", "Verbose logging").action(async (opts) => {
     const logger = createLogger({ verbose: opts.verbose ?? false });
     const apiKey = requireElevenLabsKey();
     let text = opts.text;
-    if (opts.textFile) text = fs8.readFileSync(path13.resolve(opts.textFile), "utf8");
+    if (opts.textFile) text = fs9.readFileSync(path14.resolve(opts.textFile), "utf8");
     const form = new FormData();
     form.append("file", readFileAsBlob(opts.input));
     form.append("text", text);
@@ -1501,9 +1867,9 @@ function registerAlignCommand(parent) {
     const data = await apiPostMultipart("forced-alignment", form, apiKey, {
       timeoutMs: 6e5
     });
-    const dest = opts.output ? path13.resolve(opts.output) : path13.join(getOutputDir(), `elevenlabs_align_${Date.now()}.json`);
-    fs8.mkdirSync(path13.dirname(dest), { recursive: true });
-    fs8.writeFileSync(dest, JSON.stringify(data, null, 2));
+    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));
     logger.success(`Saved alignment: ${dest}`);
     if (data.words) console.log(`Aligned ${data.words.length} words (loss=${data.loss ?? "?"})`);
   });
@@ -1546,8 +1912,8 @@ function registerCloneCommand(parent) {
 // src/providers/elevenlabs/commands/dub.ts
 init_errors();
 init_http_client();
-import fs9 from "fs";
-import path14 from "path";
+import fs10 from "fs";
+import path15 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 });
@@ -1590,7 +1956,7 @@ function registerDubCommand(parent) {
     );
     logger.success(`Dub complete: ${start.dubbing_id}`);
     if (opts.download) {
-      const dest = opts.output ? path14.resolve(opts.output) : path14.join(getOutputDir(), `elevenlabs_dub_${start.dubbing_id}_${opts.targetLang}.mp4`);
+      const dest = opts.output ? path15.resolve(opts.output) : path15.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}`);
@@ -1605,7 +1971,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 ? path14.resolve(opts.output) : path14.join(getOutputDir(), `elevenlabs_dub_${dubbingId}_${opts.download}.mp4`);
+      const dest = opts.output ? path15.resolve(opts.output) : path15.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}`);
@@ -1613,7 +1979,7 @@ Dubbed file: ${dest}`);
   });
 }
 async function downloadDub(url, apiKey, dest) {
-  fs9.mkdirSync(path14.dirname(dest), { recursive: true });
+  fs10.mkdirSync(path15.dirname(dest), { recursive: true });
   const res = await globalThis.fetch(url, {
     headers: { "xi-api-key": apiKey },
     signal: AbortSignal.timeout(6e5)
@@ -1622,7 +1988,7 @@ async function downloadDub(url, apiKey, dest) {
     throw new Error(`Failed to download dub: HTTP ${res.status}`);
   }
   const arr = new Uint8Array(await res.arrayBuffer());
-  fs9.writeFileSync(dest, arr);
+  fs10.writeFileSync(dest, arr);
   void downloadFile;
 }
 
@@ -1637,7 +2003,7 @@ function registerIsolateCommand(parent) {
     const bytes = await apiPostBinary("audio-isolation", form, apiKey, {
       timeoutMs: 6e5
     });
-    const dest = saveBytes({
+    const dest = saveBytes2({
       bytes,
       task: "isolate",
       ext: "mp3",
@@ -1651,8 +2017,8 @@ Isolated audio: ${dest}`);
 
 // src/providers/elevenlabs/commands/music.ts
 init_errors();
-import fs10 from "fs";
-import path15 from "path";
+import fs11 from "fs";
+import path16 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>",
@@ -1667,9 +2033,9 @@ function registerMusicCommand(parent) {
     const payload = { model_id: opts.model };
     if (opts.prompt) payload.prompt = opts.prompt;
     if (opts.plan) {
-      const planPath = path15.resolve(opts.plan);
-      if (!fs10.existsSync(planPath)) throw new ValidationError(`Plan file not found: ${planPath}`);
-      const planJson = JSON.parse(fs10.readFileSync(planPath, "utf8"));
+      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"));
       payload.composition_plan = planJson;
     }
     if (opts.musicLengthMs) payload.music_length_ms = Number.parseInt(opts.musicLengthMs, 10);
@@ -1678,7 +2044,7 @@ function registerMusicCommand(parent) {
       query: { output_format: opts.format },
       timeoutMs: 6e5
     });
-    const dest = saveBytes({
+    const dest = saveBytes2({
       bytes,
       task: "music",
       ext: extFromFormat(opts.format),
@@ -1715,7 +2081,7 @@ function registerSfxCommand(parent) {
       query: { output_format: opts.format },
       timeoutMs: 3e5
     });
-    const dest = saveBytes({
+    const dest = saveBytes2({
       bytes,
       task: "sfx",
       ext: extFromFormat(opts.format),
@@ -1728,8 +2094,8 @@ Generated SFX: ${dest}`);
 }
 
 // src/providers/elevenlabs/commands/transcribe.ts
-import fs11 from "fs";
-import path16 from "path";
+import fs12 from "fs";
+import path17 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>",
@@ -1752,7 +2118,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 ? path16.resolve(opts.output) : path16.join(dir, `elevenlabs_transcribe_${Date.now()}.${ext}`);
+    const dest = opts.output ? path17.resolve(opts.output) : path17.join(dir, `elevenlabs_transcribe_${Date.now()}.${ext}`);
     let body;
     switch (opts.format) {
       case "json":
@@ -1767,8 +2133,8 @@ function registerTranscribeCommand(parent) {
       default:
         body = data.text ?? "";
     }
-    fs11.mkdirSync(path16.dirname(dest), { recursive: true });
-    fs11.writeFileSync(dest, body);
+    fs12.mkdirSync(path17.dirname(dest), { recursive: true });
+    fs12.writeFileSync(dest, body);
     logger.success(`Saved transcript: ${dest}`);
     if (data.language_code) {
       logger.info(
@@ -1846,7 +2212,7 @@ function registerTtsCommand(parent) {
     const bytes = await apiPostBinary(`text-to-speech/${opts.voice}`, payload, apiKey, {
       query: { output_format: opts.format }
     });
-    const dest = saveBytes({
+    const dest = saveBytes2({
       bytes,
       task: "tts",
       ext: extFromFormat(opts.format),
@@ -1888,7 +2254,7 @@ function registerVoiceChangerCommand(parent) {
     if (!bytes || bytes.length === 0) {
       throw new ValidationError("Empty response from voice-changer");
     }
-    const dest = saveBytes({
+    const dest = saveBytes2({
       bytes,
       task: "voice_changer",
       ext: extFromFormat(opts.format),
@@ -1959,7 +2325,7 @@ ${data.voices.length} voices${data.has_more ? " (more available)" : ""}`);
     logger.success(`${data.previews.length} previews generated`);
     data.previews.forEach((p, i) => {
       const bytes = Buffer.from(p.audio_base_64, "base64");
-      const dest = saveBytes({
+      const dest = saveBytes2({
         bytes,
         task: `${opts.outputPrefix}_${i + 1}_${p.generated_voice_id}`,
         ext: extFromFormat(TASK_DEFAULTS.ttsFormat),
@@ -2015,16 +2381,16 @@ function registerElevenLabsCommands(program2) {
 
 // src/providers/gemini/commands/analyze.ts
 init_errors();
-import fs14 from "fs";
+import fs15 from "fs";
 
 // src/providers/gemini/client.ts
-import fs12 from "fs";
-import path18 from "path";
+import fs13 from "fs";
+import path19 from "path";
 init_errors();
 init_http_client();
 
 // src/providers/gemini/task-resolver.ts
-import path17 from "path";
+import path18 from "path";
 var MIME_MAP = {
   // Audio
   ".mp3": "audio/mp3",
@@ -2065,7 +2431,7 @@ var MIME_MAP = {
   ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation"
 };
 function getMimeType(filePath) {
-  const ext = path17.extname(filePath).toLowerCase();
+  const ext = path18.extname(filePath).toLowerCase();
   return MIME_MAP[ext] ?? "application/octet-stream";
 }
 function requiresProcessingWait(mimeType) {
@@ -2091,8 +2457,8 @@ async function uploadFile(filePath, opts = {}) {
   const apiKey = requireApiKey();
   const { timeoutMs = 3e5, logger } = opts;
   const mimeType = getMimeType(filePath);
-  const fileBytes = fs12.readFileSync(filePath);
-  const displayName = path18.basename(filePath);
+  const fileBytes = fs13.readFileSync(filePath);
+  const displayName = path19.basename(filePath);
   const boundary = `multix_${Date.now()}`;
   const metaJson = JSON.stringify({ file: { displayName, mimeType } });
   const body = Buffer.concat([
@@ -2181,12 +2547,12 @@ function extractImages(resp) {
   ).map((p) => ({ mimeType: p.inlineData.mimeType, data: p.inlineData.data }));
 }
 function inlinePart(filePath) {
-  const data = fs12.readFileSync(filePath).toString("base64");
+  const data = fs13.readFileSync(filePath).toString("base64");
   const mimeType = getMimeType(filePath);
   return { inlineData: { mimeType, data } };
 }
 function shouldUseFileApi(filePath) {
-  const stat = fs12.statSync(filePath);
+  const stat = fs13.statSync(filePath);
   return stat.size > 20 * 1024 * 1024;
 }
 function sleep(ms) {
@@ -2239,13 +2605,13 @@ function getDefaultModel(task) {
 }
 
 // src/providers/gemini/result-formatter.ts
-import fs13 from "fs";
-import path19 from "path";
+import fs14 from "fs";
+import path20 from "path";
 function formatResults(results, format, outputPath) {
   const content = renderFormat(results, format);
   if (outputPath) {
-    fs13.mkdirSync(path19.dirname(path19.resolve(outputPath)), { recursive: true });
-    fs13.writeFileSync(outputPath, content, "utf8");
+    fs14.mkdirSync(path20.dirname(path20.resolve(outputPath)), { recursive: true });
+    fs14.writeFileSync(outputPath, content, "utf8");
   } else {
     process.stdout.write(content);
   }
@@ -2312,7 +2678,7 @@ function registerAnalyzeCommand(parent) {
       const logger = createLogger({ verbose: opts.verbose ?? false });
       const model = opts.model ?? getDefaultModel("analyze");
       for (const f of opts.files) {
-        if (!fs14.existsSync(f)) throw new ValidationError(`File not found: ${f}`);
+        if (!fs15.existsSync(f)) throw new ValidationError(`File not found: ${f}`);
       }
       const results = [];
       for (let i = 0; i < opts.files.length; i++) {
@@ -2358,14 +2724,14 @@ function registerAnalyzeCommand(parent) {
 
 // src/providers/gemini/commands/extract.ts
 init_errors();
-import fs15 from "fs";
+import fs16 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 (!fs15.existsSync(f)) throw new ValidationError(`File not found: ${f}`);
+        if (!fs16.existsSync(f)) throw new ValidationError(`File not found: ${f}`);
       }
       const generationConfig = opts.format === "json" ? { responseMimeType: "application/json" } : void 0;
       const results = [];
@@ -2407,8 +2773,8 @@ function registerExtractCommand(parent) {
 init_errors();
 
 // src/providers/gemini/generators/speech.ts
-import fs16 from "fs";
-import path20 from "path";
+import fs17 from "fs";
+import path21 from "path";
 
 // src/providers/gemini/voices.ts
 var GEMINI_TTS_VOICES = [
@@ -2491,12 +2857,12 @@ async function generateGeminiSpeech(opts) {
   const sampleRate = parseSampleRate(audio.mimeType) ?? TTS_PCM_SAMPLE_RATE;
   const outBytes = outputFormat === "wav" ? wrapPcmInWav(pcmBytes, sampleRate, TTS_PCM_CHANNELS, TTS_PCM_BITS_PER_SAMPLE) : pcmBytes;
   const outDir = getOutputDir();
-  const dest = path20.join(outDir, `gemini_speech_${Date.now()}.${outputFormat}`);
-  fs16.writeFileSync(dest, outBytes);
+  const dest = path21.join(outDir, `gemini_speech_${Date.now()}.${outputFormat}`);
+  fs17.writeFileSync(dest, outBytes);
   logger?.success(`Saved: ${dest} (${(outBytes.length / 1024).toFixed(1)} KB)`);
   if (output) {
-    fs16.mkdirSync(path20.dirname(path20.resolve(output)), { recursive: true });
-    fs16.copyFileSync(dest, output);
+    fs17.mkdirSync(path21.dirname(path21.resolve(output)), { recursive: true });
+    fs17.copyFileSync(dest, output);
     logger?.success(`Copied to: ${output}`);
   }
   return { status: "success", generatedAudio: dest, model, mimeType: audio.mimeType };
@@ -2595,8 +2961,8 @@ function collectSpeakers(value, prev) {
 }
 
 // src/providers/gemini/commands/generate-video.ts
-import fs17 from "fs";
-import path21 from "path";
+import fs18 from "fs";
+import path22 from "path";
 init_errors();
 init_http_client();
 var BASE2 = "https://generativelanguage.googleapis.com";
@@ -2630,10 +2996,10 @@ function registerGenerateVideoCommand(parent) {
       const contentParts = [{ text: opts.prompt }];
       if (opts.referenceImages?.length) {
         for (const imgPath of opts.referenceImages.slice(0, 2)) {
-          if (!fs17.existsSync(imgPath))
+          if (!fs18.existsSync(imgPath))
             throw new ValidationError(`Reference image not found: ${imgPath}`);
-          const data = fs17.readFileSync(imgPath).toString("base64");
-          const ext = path21.extname(imgPath).toLowerCase();
+          const data = fs18.readFileSync(imgPath).toString("base64");
+          const ext = path22.extname(imgPath).toLowerCase();
           const mimeType = ext === ".png" ? "image/png" : "image/jpeg";
           contentParts.push({ inlineData: { mimeType, data } });
         }
@@ -2682,13 +3048,13 @@ function registerGenerateVideoCommand(parent) {
         );
       }
       const outDir = getOutputDir();
-      const dest = path21.join(outDir, `veo_generated_${Date.now()}.mp4`);
+      const dest = path22.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) {
-        fs17.mkdirSync(path21.dirname(path21.resolve(opts.output)), { recursive: true });
-        fs17.copyFileSync(dest, opts.output);
+        fs18.mkdirSync(path22.dirname(path22.resolve(opts.output)), { recursive: true });
+        fs18.copyFileSync(dest, opts.output);
         logger.success(`Copied to: ${opts.output}`);
       }
       await maybeDownloadThumb(finalOp.response, dest, {
@@ -2707,8 +3073,8 @@ function sleep2(ms) {
 
 // src/providers/gemini/commands/generate.ts
 init_errors();
-import fs18 from "fs";
-import path22 from "path";
+import fs19 from "fs";
+import path23 from "path";
 function registerGenerateCommand(parent) {
   parent.command("generate").description("Generate images with Gemini (Nano Banana / Imagen 4)").requiredOption("--prompt <text>", "Image generation prompt").option("--model <id>", "Gemini image model to use").option("--aspect-ratio <ratio>", `Aspect ratio (${ASPECT_RATIOS.join("|")})`, "1:1").option("--num-images <n>", "Number of images to generate (1-4)", "1").option("--size <sz>", `Image size (${IMAGE_SIZES.join("|")})`).option("--output <path>", "Copy first generated image to this path").option("-v, --verbose", "Verbose logging").action(
     async (opts) => {
@@ -2750,8 +3116,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 = path22.join(outDir, fname);
-            fs18.writeFileSync(dest, Buffer.from(img.data, "base64"));
+            const dest = path23.join(outDir, fname);
+            fs19.writeFileSync(dest, Buffer.from(img.data, "base64"));
             savedFiles.push(dest);
             logger.success(`Saved: ${dest}`);
           }
@@ -2766,8 +3132,8 @@ function registerGenerateCommand(parent) {
         process.exit(1);
       }
       if (opts.output && savedFiles[0]) {
-        fs18.mkdirSync(path22.dirname(path22.resolve(opts.output)), { recursive: true });
-        fs18.copyFileSync(savedFiles[0], opts.output);
+        fs19.mkdirSync(path23.dirname(path23.resolve(opts.output)), { recursive: true });
+        fs19.copyFileSync(savedFiles[0], opts.output);
         logger.success(`Copied to: ${opts.output}`);
       }
       console.log(`
@@ -2778,8 +3144,8 @@ Generated ${savedFiles.length} image(s):`);
 }
 
 // src/providers/gemini/commands/image-to-image.ts
-import fs19 from "fs";
-import path23 from "path";
+import fs20 from "fs";
+import path24 from "path";
 var SOFT_LIMIT_BYTES = 5 * 1024 * 1024;
 var HARD_LIMIT_BYTES = 7 * 1024 * 1024;
 function registerGeminiImageToImageCommand(parent) {
@@ -2840,14 +3206,14 @@ function registerGeminiImageToImageCommand(parent) {
         const img = images[i];
         if (!img) continue;
         const ext = img.mimeType.includes("png") ? "png" : "jpg";
-        const dest = path23.join(outDir, `gemini-i2i-${ts}-${i + 1}.${ext}`);
-        fs19.writeFileSync(dest, Buffer.from(img.data, "base64"));
+        const dest = path24.join(outDir, `gemini-i2i-${ts}-${i + 1}.${ext}`);
+        fs20.writeFileSync(dest, Buffer.from(img.data, "base64"));
         saved.push(dest);
         logger.success(`Saved: ${dest}`);
       }
       if (opts.output && saved[0]) {
-        fs19.mkdirSync(path23.dirname(path23.resolve(opts.output)), { recursive: true });
-        fs19.copyFileSync(saved[0], opts.output);
+        fs20.mkdirSync(path24.dirname(path24.resolve(opts.output)), { recursive: true });
+        fs20.copyFileSync(saved[0], opts.output);
         logger.success(`Copied to: ${opts.output}`);
       }
       console.log(`
@@ -2874,7 +3240,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 = path23.extname(new URL(url).pathname).toLowerCase();
+  const ext = path24.extname(new URL(url).pathname).toLowerCase();
   if (ext === ".png") return "image/png";
   if (ext === ".webp") return "image/webp";
   if (ext === ".gif") return "image/gif";
@@ -2882,17 +3248,17 @@ function sniffImageMime(buf, url) {
 }
 
 // src/providers/gemini/commands/image-to-video.ts
-import fs20 from "fs";
-import path24 from "path";
+import fs21 from "fs";
+import path25 from "path";
 init_errors();
 init_http_client();
 var BASE3 = "https://generativelanguage.googleapis.com";
 function imagePart(imgPath) {
-  if (!fs20.existsSync(imgPath)) {
+  if (!fs21.existsSync(imgPath)) {
     throw new ValidationError(`Image not found: ${imgPath}`);
   }
-  const data = fs20.readFileSync(imgPath).toString("base64");
-  const ext = path24.extname(imgPath).toLowerCase();
+  const data = fs21.readFileSync(imgPath).toString("base64");
+  const ext = path25.extname(imgPath).toLowerCase();
   const mimeType = ext === ".png" ? "image/png" : "image/jpeg";
   return { inlineData: { mimeType, data } };
 }
@@ -2965,12 +3331,12 @@ function registerGeminiImageToVideoCommand(parent) {
           "gemini"
         );
       }
-      const dest = path24.join(getOutputDir(), `veo_i2v_${Date.now()}.mp4`);
+      const dest = path25.join(getOutputDir(), `veo_i2v_${Date.now()}.mp4`);
       await downloadFile(videoUri, dest);
       logger.success(`Saved video: ${dest}`);
       if (opts.output) {
-        fs20.mkdirSync(path24.dirname(path24.resolve(opts.output)), { recursive: true });
-        fs20.copyFileSync(dest, opts.output);
+        fs21.mkdirSync(path25.dirname(path25.resolve(opts.output)), { recursive: true });
+        fs21.copyFileSync(dest, opts.output);
         logger.success(`Copied to: ${opts.output}`);
       }
       await maybeDownloadThumb(finalOp.response, dest, {
@@ -2986,14 +3352,14 @@ Generated video: ${dest}`);
 
 // src/providers/gemini/commands/transcribe.ts
 init_errors();
-import fs21 from "fs";
+import fs22 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 (!fs21.existsSync(f)) throw new ValidationError(`File not found: ${f}`);
+        if (!fs22.existsSync(f)) throw new ValidationError(`File not found: ${f}`);
       }
       const results = [];
       for (let i = 0; i < opts.files.length; i++) {
@@ -3051,8 +3417,8 @@ function registerGeminiCommands(program2) {
 
 // src/providers/leonardo/commands/generate.ts
 init_http_client();
-import fs22 from "fs";
-import path25 from "path";
+import fs23 from "fs";
+import path26 from "path";
 
 // src/providers/leonardo/client.ts
 init_errors();
@@ -3126,11 +3492,11 @@ var LeonardoClient = class {
   }
   apiKey;
   baseUrl;
-  async request(path45, opts = {}) {
+  async request(path46, opts = {}) {
     const base = this.baseUrl.replace(/\/$/, "");
-    const v2Override = path45.startsWith("v2:");
+    const v2Override = path46.startsWith("v2:");
     const finalBase = v2Override ? base.replace(/\/v1$/, "/v2") : base;
-    const finalPath = v2Override ? path45.slice(3) : path45;
+    const finalPath = v2Override ? path46.slice(3) : path46;
     const url = new URL(finalBase + finalPath);
     if (opts.query) {
       for (const [k, v] of Object.entries(opts.query)) {
@@ -3149,14 +3515,14 @@ var LeonardoClient = class {
       timeoutMs: opts.timeoutMs ?? 12e4
     });
   }
-  get(path45, query, logger) {
-    return this.request(path45, { method: "GET", query, logger });
+  get(path46, query, logger) {
+    return this.request(path46, { method: "GET", query, logger });
   }
-  post(path45, body, logger) {
-    return this.request(path45, { method: "POST", body, logger });
+  post(path46, body, logger) {
+    return this.request(path46, { method: "POST", body, logger });
   }
-  delete(path45, logger) {
-    return this.request(path45, { method: "DELETE", logger });
+  delete(path46, logger) {
+    return this.request(path46, { method: "DELETE", logger });
   }
 };
 function createLeonardoClient() {
@@ -3167,7 +3533,7 @@ function createLeonardoClient() {
 function extFromUrl(url, fallback = ".png") {
   try {
     const u = new URL(url);
-    const e = path25.extname(u.pathname);
+    const e = path26.extname(u.pathname);
     return e.length > 0 ? e : fallback;
   } catch {
     return fallback;
@@ -3252,7 +3618,7 @@ function registerLeonardoGenerateCommand(parent) {
         if (!img) continue;
         const ext = extFromUrl(img.url);
         const filename = autoFilename(generationId, i + 1, ext);
-        const filepath = path25.join(outDir, filename);
+        const filepath = path26.join(outDir, filename);
         try {
           await downloadFile(img.url, filepath);
           saved.push(filepath);
@@ -3262,9 +3628,9 @@ function registerLeonardoGenerateCommand(parent) {
         }
       }
       if (opts.output && saved[0]) {
-        const dest = path25.resolve(opts.output);
-        fs22.mkdirSync(path25.dirname(dest), { recursive: true });
-        fs22.copyFileSync(saved[0], dest);
+        const dest = path26.resolve(opts.output);
+        fs23.mkdirSync(path26.dirname(dest), { recursive: true });
+        fs23.copyFileSync(saved[0], dest);
         logger.success(`Copied to ${dest}`);
       }
       console.log(`
@@ -3276,11 +3642,11 @@ Generated ${saved.length} image(s):`);
 
 // src/providers/leonardo/commands/image-to-image.ts
 init_http_client();
-import fs23 from "fs";
-import path26 from "path";
+import fs24 from "fs";
+import path27 from "path";
 function extFromUrl2(url, fallback = ".png") {
   try {
-    return path26.extname(new URL(url).pathname) || fallback;
+    return path27.extname(new URL(url).pathname) || fallback;
   } catch {
     return fallback;
   }
@@ -3342,7 +3708,7 @@ function registerLeonardoImageToImageCommand(parent) {
         if (!img) continue;
         const ext = extFromUrl2(img.url);
         const filename = `leonardo-i2i-${generationId.slice(0, 8)}-${String(i + 1).padStart(2, "0")}${ext}`;
-        const filepath = path26.join(outDir, filename);
+        const filepath = path27.join(outDir, filename);
         try {
           await downloadFile(img.url, filepath);
           saved.push(filepath);
@@ -3352,9 +3718,9 @@ function registerLeonardoImageToImageCommand(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 = path27.resolve(opts.output);
+        fs24.mkdirSync(path27.dirname(dest), { recursive: true });
+        fs24.copyFileSync(saved[0], dest);
         logger.success(`Copied to ${dest}`);
       }
       console.log(`
@@ -3366,7 +3732,7 @@ Generated ${saved.length} image(s):`);
 
 // src/providers/leonardo/commands/video.ts
 init_http_client();
-import path27 from "path";
+import path28 from "path";
 function v2DimsFor(resolution) {
   if (resolution === "RESOLUTION_1080") return { width: 1920, height: 1080 };
   if (resolution === "RESOLUTION_480") return { width: 854, height: 480 };
@@ -3466,19 +3832,19 @@ async function pollAndDownload(client, jobId, opts) {
     logger.error("No generation in response");
     process.exit(1);
   }
-  const videoUrl = gen.generated_images?.find(
+  const videoUrl2 = gen.generated_images?.find(
     (img) => typeof img.url === "string" && /\.(mp4|webm|mov)(\?|$)/i.test(img.url)
   )?.url ?? gen.generated_images?.[0]?.motionMP4URL;
   if (!opts.download) {
-    if (typeof videoUrl === "string") console.log(videoUrl);
+    if (typeof videoUrl2 === "string") console.log(videoUrl2);
     return;
   }
-  if (typeof videoUrl !== "string") {
+  if (typeof videoUrl2 !== "string") {
     logger.error(`No video URL in completed generation: ${JSON.stringify(gen)}`);
     process.exit(1);
   }
-  const outPath = opts.output ?? path27.join(getOutputDir(), `${opts.basename}-${jobId.slice(0, 8)}.mp4`);
-  await downloadFile(videoUrl, outPath);
+  const outPath = opts.output ?? path28.join(getOutputDir(), `${opts.basename}-${jobId.slice(0, 8)}.mp4`);
+  await downloadFile(videoUrl2, outPath);
   logger.success(`Saved ${outPath}`);
   await maybeDownloadThumb(gen, outPath, {
     skip: !opts.thumb,
@@ -3584,7 +3950,7 @@ function registerLeonardoModelsCommand(parent) {
 
 // src/providers/leonardo/commands/status.ts
 init_http_client();
-import path28 from "path";
+import path29 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;
@@ -3649,7 +4015,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 : path28.join(outDir, `leonardo-${generationId.slice(0, 8)}-${idx}.mp4`);
+        const dest = opts.output && videos.length === 1 && images.length === 0 ? opts.output : path29.join(outDir, `leonardo-${generationId.slice(0, 8)}-${idx}.mp4`);
         await downloadFile(url, dest);
         logger.success(`Saved ${dest}`);
         await maybeDownloadThumb(gen, dest, {
@@ -3662,7 +4028,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 = path28.join(outDir, `leonardo-${generationId.slice(0, 8)}-${idx}.${ext}`);
+        const dest = path29.join(outDir, `leonardo-${generationId.slice(0, 8)}-${idx}.${ext}`);
         await downloadFile(url, dest);
         logger.success(`Saved ${dest}`);
         idx++;
@@ -3821,8 +4187,8 @@ function sleep4(ms) {
 
 // src/providers/minimax/generators/music.ts
 init_http_client();
-import fs24 from "fs";
-import path29 from "path";
+import fs25 from "fs";
+import path30 from "path";
 async function generateMinimaxMusic(opts) {
   const {
     apiKey,
@@ -3867,14 +4233,14 @@ async function generateMinimaxMusic(opts) {
   }
   const durationMs = resp.extra_info?.music_duration ?? 0;
   const outDir = getOutputDir();
-  const dest = path29.join(outDir, `minimax_music_${Date.now()}.${outputFormat}`);
+  const dest = path30.join(outDir, `minimax_music_${Date.now()}.${outputFormat}`);
   try {
     if (audioData.startsWith("http")) {
       const bytes = await fetchBytes(audioData);
-      fs24.writeFileSync(dest, bytes);
+      fs25.writeFileSync(dest, bytes);
     } else {
       const audioBytes = Buffer.from(audioData, "hex");
-      fs24.writeFileSync(dest, audioBytes);
+      fs25.writeFileSync(dest, audioBytes);
     }
   } catch (e) {
     return {
@@ -3885,8 +4251,8 @@ async function generateMinimaxMusic(opts) {
   const durSec = durationMs / 1e3;
   logger?.success(`Saved: ${dest} (${durSec.toFixed(1)}s)`);
   if (output) {
-    fs24.mkdirSync(path29.dirname(path29.resolve(output)), { recursive: true });
-    fs24.copyFileSync(dest, output);
+    fs25.mkdirSync(path30.dirname(path30.resolve(output)), { recursive: true });
+    fs25.copyFileSync(dest, output);
   }
   return { status: "success", generatedAudio: dest, durationMs, model };
 }
@@ -3960,8 +4326,8 @@ Generated music: ${result.generatedAudio}`);
 init_errors();
 
 // src/providers/minimax/generators/speech.ts
-import fs25 from "fs";
-import path30 from "path";
+import fs26 from "fs";
+import path31 from "path";
 async function generateMinimaxSpeech(opts) {
   const {
     apiKey,
@@ -4008,12 +4374,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 = path30.join(outDir, `minimax_speech_${Date.now()}.${ext}`);
-  fs25.writeFileSync(dest, audioBytes);
+  const dest = path31.join(outDir, `minimax_speech_${Date.now()}.${ext}`);
+  fs26.writeFileSync(dest, audioBytes);
   logger?.success(`Saved: ${dest} (${(audioBytes.length / 1024).toFixed(1)} KB)`);
   if (output) {
-    fs25.mkdirSync(path30.dirname(path30.resolve(output)), { recursive: true });
-    fs25.copyFileSync(dest, output);
+    fs26.mkdirSync(path31.dirname(path31.resolve(output)), { recursive: true });
+    fs26.copyFileSync(dest, output);
   }
   return { status: "success", generatedAudio: dest, model };
 }
@@ -4060,8 +4426,8 @@ Generated audio: ${result.generatedAudio}`);
 init_errors();
 
 // src/providers/minimax/generators/video.ts
-import fs26 from "fs";
-import path31 from "path";
+import fs27 from "fs";
+import path32 from "path";
 async function generateMinimaxVideo(opts) {
   const {
     apiKey,
@@ -4107,18 +4473,18 @@ async function generateMinimaxVideo(opts) {
     return { status: "error", error: `No file_id in poll result: ${JSON.stringify(pollResult)}` };
   }
   const outDir = getOutputDir();
-  const dest = path31.join(outDir, `minimax_video_${Date.now()}.mp4`);
+  const dest = path32.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 = fs26.statSync(dest);
+  const stat = fs27.statSync(dest);
   const fileSizeMb = stat.size / (1024 * 1024);
   if (output) {
-    fs26.mkdirSync(path31.dirname(path31.resolve(output)), { recursive: true });
-    fs26.copyFileSync(dest, output);
+    fs27.mkdirSync(path32.dirname(path32.resolve(output)), { recursive: true });
+    fs27.copyFileSync(dest, output);
   }
   await maybeDownloadThumb(pollResult, dest, {
     skip: thumb === false,
@@ -4181,8 +4547,8 @@ Generated video: ${result.generatedVideo}`);
 // src/providers/minimax/generators/image.ts
 init_errors();
 init_http_client();
-import fs27 from "fs";
-import path32 from "path";
+import fs28 from "fs";
+import path33 from "path";
 async function generateMinimaxImage(opts) {
   const {
     apiKey,
@@ -4220,8 +4586,8 @@ async function generateMinimaxImage(opts) {
     try {
       const bytes = await fetchBytes(url);
       const fname = `minimax_image_${Date.now()}_${i}.png`;
-      const dest = path32.join(outDir, fname);
-      fs27.writeFileSync(dest, bytes);
+      const dest = path33.join(outDir, fname);
+      fs28.writeFileSync(dest, bytes);
       savedFiles.push(dest);
       logger?.success(`Saved: ${dest}`);
     } catch (e) {
@@ -4232,8 +4598,8 @@ async function generateMinimaxImage(opts) {
     }
   }
   if (output && savedFiles[0]) {
-    fs27.mkdirSync(path32.dirname(path32.resolve(output)), { recursive: true });
-    fs27.copyFileSync(savedFiles[0], output);
+    fs28.mkdirSync(path33.dirname(path33.resolve(output)), { recursive: true });
+    fs28.copyFileSync(savedFiles[0], output);
   }
   return { status: "success", generatedImages: savedFiles, model };
 }
@@ -4269,8 +4635,8 @@ Generated ${result.generatedImages?.length ?? 0} image(s):`);
 // src/providers/minimax/commands/image-to-image.ts
 init_errors();
 init_http_client();
-import fs28 from "fs";
-import path33 from "path";
+import fs29 from "fs";
+import path34 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."
@@ -4325,8 +4691,8 @@ function registerMinimaxImageToImageCommand(parent) {
         if (!url) continue;
         try {
           const bytes = await fetchBytes(url);
-          const dest = path33.join(outDir, `minimax-i2i-${ts}-${i + 1}.png`);
-          fs28.writeFileSync(dest, bytes);
+          const dest = path34.join(outDir, `minimax-i2i-${ts}-${i + 1}.png`);
+          fs29.writeFileSync(dest, bytes);
           saved.push(dest);
           logger.success(`Saved: ${dest}`);
         } catch (e) {
@@ -4337,8 +4703,8 @@ function registerMinimaxImageToImageCommand(parent) {
         }
       }
       if (opts.output && saved[0]) {
-        fs28.mkdirSync(path33.dirname(path33.resolve(opts.output)), { recursive: true });
-        fs28.copyFileSync(saved[0], opts.output);
+        fs29.mkdirSync(path34.dirname(path34.resolve(opts.output)), { recursive: true });
+        fs29.copyFileSync(saved[0], opts.output);
         logger.success(`Copied to: ${opts.output}`);
       }
       console.log(`
@@ -4472,12 +4838,12 @@ function validateKnownSpeakerPairing(names = [], refs = []) {
 
 // src/providers/openai/openai-audio.ts
 init_http_client();
-import fs30 from "fs";
-import path35 from "path";
+import fs31 from "fs";
+import path36 from "path";
 
 // src/providers/openai/client.ts
-import fs29 from "fs";
-import path34 from "path";
+import fs30 from "fs";
+import path35 from "path";
 init_errors();
 init_http_client();
 var DEFAULT_TIMEOUT_MS3 = 24e4;
@@ -4544,10 +4910,10 @@ async function postOpenAIBinary(pathname, body, apiKey, timeoutMs = DEFAULT_TIME
   return Buffer.from(await res.arrayBuffer());
 }
 function fileFromPath(filePath) {
-  const abs = path34.resolve(filePath);
-  if (!fs29.existsSync(abs)) throw new ValidationError(`File not found: ${abs}`);
-  const bytes = fs29.readFileSync(abs);
-  return new File([new Uint8Array(bytes)], path34.basename(abs));
+  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));
 }
 
 // src/providers/openai/openai-audio.ts
@@ -4586,7 +4952,7 @@ async function resolveAudioReferenceDataUrl(ref) {
 }
 function audioMimeFromReference(ref) {
   const pathname = new URL(ref).pathname;
-  const ext = path35.extname(pathname).toLowerCase();
+  const ext = path36.extname(pathname).toLowerCase();
   switch (ext) {
     case ".mp3":
       return "audio/mpeg";
@@ -4605,12 +4971,12 @@ function audioMimeFromReference(ref) {
 async function generateOpenAISpeech(opts) {
   const bytes = await postOpenAIBinary("/audio/speech", buildSpeechBody(opts), requireOpenAIKey());
   const ext = extFromAudioFormat(opts.outputFormat);
-  const dest = path35.join(getOutputDir(), `openai-speech-${Date.now()}.${ext}`);
-  fs30.writeFileSync(dest, bytes);
+  const dest = path36.join(getOutputDir(), `openai-speech-${Date.now()}.${ext}`);
+  fs31.writeFileSync(dest, bytes);
   opts.logger?.success(`Saved: ${dest} (${(bytes.length / 1024).toFixed(1)} KB)`);
   if (opts.output) {
-    fs30.mkdirSync(path35.dirname(path35.resolve(opts.output)), { recursive: true });
-    fs30.copyFileSync(dest, opts.output);
+    fs31.mkdirSync(path36.dirname(path36.resolve(opts.output)), { recursive: true });
+    fs31.copyFileSync(dest, opts.output);
   }
   return dest;
 }
@@ -4632,9 +4998,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 ? path35.resolve(opts.output) : path35.join(getOutputDir(), `openai-transcribe-${Date.now()}.${ext}`);
-  fs30.mkdirSync(path35.dirname(dest), { recursive: true });
-  fs30.writeFileSync(dest, opts.format === "text" ? text ?? "" : JSON.stringify(data, null, 2));
+  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));
   opts.logger?.success(`Saved transcript: ${dest}`);
   return { path: dest, text };
 }
@@ -4661,9 +5027,9 @@ Generated audio: ${dest}`);
 }
 
 // src/providers/openai/codex-image-driver.ts
-import fs31 from "fs";
+import fs32 from "fs";
 import os2 from "os";
-import path36 from "path";
+import path37 from "path";
 import { execa } from "execa";
 init_errors();
 var defaultRunner = async (cmd, args, opts) => {
@@ -4712,12 +5078,12 @@ function sanitizeCodexEnv() {
 async function runCodexImageGeneration(opts) {
   const runner = opts.runner ?? defaultRunner;
   const ext = extFromImageFormat(opts.outputFormat);
-  const dest = opts.output ? path36.resolve(opts.output) : path36.join(getOutputDir(), `codex-image-${Date.now()}.${ext}`);
-  fs31.mkdirSync(path36.dirname(dest), { recursive: true });
-  const tmp = fs31.mkdtempSync(path36.join(os2.tmpdir(), "multix-codex-image-"));
-  const schema = path36.join(tmp, "schema.json");
-  const result = path36.join(tmp, "result.json");
-  fs31.writeFileSync(
+  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(
     schema,
     JSON.stringify({
       type: "object",
@@ -4747,7 +5113,7 @@ async function runCodexImageGeneration(opts) {
   if (res.exitCode !== 0) {
     throw new ProviderError(`Codex image driver failed: ${res.stderr || res.stdout}`, "openai");
   }
-  if (!fs31.existsSync(dest) || fs31.statSync(dest).size === 0) {
+  if (!fs32.existsSync(dest) || fs32.statSync(dest).size === 0) {
     throw new ProviderError(`Codex did not create a non-empty image at ${dest}`, "openai");
   }
   return { path: dest };
@@ -4765,8 +5131,8 @@ function buildCodexPrompt(userPrompt, outputPath) {
 // src/providers/openai/openai-image.ts
 init_errors();
 init_http_client();
-import fs32 from "fs";
-import path37 from "path";
+import fs33 from "fs";
+import path38 from "path";
 function buildImageGenerationBody(opts) {
   return {
     model: opts.model ?? DEFAULT_OPENAI_IMAGE_MODEL,
@@ -4799,14 +5165,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 = path37.join(outDir, `openai-${opts.task}-${ts}-${i + 1}.${ext}`);
-    fs32.writeFileSync(dest, Buffer.from(b64, "base64"));
+    const dest = path38.join(outDir, `openai-${opts.task}-${ts}-${i + 1}.${ext}`);
+    fs33.writeFileSync(dest, Buffer.from(b64, "base64"));
     saved.push(dest);
     opts.logger?.success(`Saved: ${dest}`);
   }
   if (opts.output && saved[0]) {
-    fs32.mkdirSync(path37.dirname(path37.resolve(opts.output)), { recursive: true });
-    fs32.copyFileSync(saved[0], opts.output);
+    fs33.mkdirSync(path38.dirname(path38.resolve(opts.output)), { recursive: true });
+    fs33.copyFileSync(saved[0], opts.output);
     opts.logger?.success(`Copied to: ${opts.output}`);
   }
   return saved;
@@ -4815,7 +5181,7 @@ async function resolveImageRefBytes(ref) {
   if (isHttpUrl(ref)) {
     const bytes2 = await fetchBytes(ref);
     const pathname = new URL(ref).pathname;
-    const filename = path37.basename(pathname) || "reference.png";
+    const filename = path38.basename(pathname) || "reference.png";
     return { filename, bytes: bytes2, mime: sniffImageMime2(bytes2, filename) };
   }
   const file = fileFromPath(ref);
@@ -4860,7 +5226,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 = path37.extname(name).toLowerCase();
+  const ext = path38.extname(name).toLowerCase();
   if (ext === ".jpg" || ext === ".jpeg") return "image/jpeg";
   if (ext === ".webp") return "image/webp";
   return "image/png";
@@ -4988,8 +5354,8 @@ function registerOpenAICommands(program2) {
 }
 
 // src/providers/openrouter/client.ts
-import fs33 from "fs";
-import path38 from "path";
+import fs34 from "fs";
+import path39 from "path";
 init_errors();
 init_http_client();
 
@@ -5154,8 +5520,8 @@ async function generateOpenRouterImage(opts) {
     if (!url) continue;
     try {
       const bytes = await fetchBytes(url);
-      const dest = path38.join(outDir, `openrouter_image_${Date.now()}_${i}.png`);
-      fs33.writeFileSync(dest, bytes);
+      const dest = path39.join(outDir, `openrouter_image_${Date.now()}_${i}.png`);
+      fs34.writeFileSync(dest, bytes);
       savedFiles.push(dest);
       logger?.success(`Saved: ${dest}`);
     } catch (e) {
@@ -5166,8 +5532,8 @@ async function generateOpenRouterImage(opts) {
     }
   }
   if (output && savedFiles[0]) {
-    fs33.mkdirSync(path38.dirname(path38.resolve(output)), { recursive: true });
-    fs33.writeFileSync(output, fs33.readFileSync(savedFiles[0]));
+    fs34.mkdirSync(path39.dirname(path39.resolve(output)), { recursive: true });
+    fs34.writeFileSync(output, fs34.readFileSync(savedFiles[0]));
   }
   return { status: "success", generatedImages: savedFiles, model: usedModel };
 }
@@ -5204,8 +5570,8 @@ Generated ${result.generatedImages?.length ?? 0} image(s):`);
 }
 
 // src/providers/openrouter/commands/image-to-image.ts
-import fs34 from "fs";
-import path39 from "path";
+import fs35 from "fs";
+import path40 from "path";
 init_errors();
 init_http_client();
 var DEFAULT_MODEL = "google/gemini-2.5-flash-image";
@@ -5297,14 +5663,14 @@ async function runImageToImage(opts) {
     const url = parsed.urls[i];
     if (!url) continue;
     const bytes = await fetchBytes(url);
-    const dest = path39.join(outDir, `openrouter-i2i-${ts}-${i + 1}.png`);
-    fs34.writeFileSync(dest, bytes);
+    const dest = path40.join(outDir, `openrouter-i2i-${ts}-${i + 1}.png`);
+    fs35.writeFileSync(dest, bytes);
     saved.push(dest);
     opts.logger.success(`Saved: ${dest}`);
   }
   if (opts.output && saved[0]) {
-    fs34.mkdirSync(path39.dirname(path39.resolve(opts.output)), { recursive: true });
-    fs34.copyFileSync(saved[0], opts.output);
+    fs35.mkdirSync(path40.dirname(path40.resolve(opts.output)), { recursive: true });
+    fs35.copyFileSync(saved[0], opts.output);
     opts.logger.success(`Copied to: ${opts.output}`);
   }
   return saved;
@@ -5350,13 +5716,13 @@ async function listVideoModels(apiKey = requireOpenRouterKey()) {
 }
 
 // src/providers/openrouter/commands/video-status.ts
-import fs35 from "fs";
-import path40 from "path";
+import fs36 from "fs";
+import path41 from "path";
 async function downloadOpenRouterVideo(opts) {
   const { jobId, logger, source } = opts;
   const apiKey = requireOpenRouterKey();
   const url = videoContentUrl(jobId);
-  const dest = path40.join(getOutputDir(), `openrouter_video_${jobId}.mp4`);
+  const dest = path41.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}`);
@@ -5366,14 +5732,14 @@ async function downloadOpenRouterVideo(opts) {
     logger.error("Empty response body");
     process.exit(1);
   }
-  fs35.mkdirSync(path40.dirname(dest), { recursive: true });
-  const ws = fs35.createWriteStream(dest);
+  fs36.mkdirSync(path41.dirname(dest), { recursive: true });
+  const ws = fs36.createWriteStream(dest);
   const { pipeline: pipeline2 } = await import("stream/promises");
   await pipeline2(r.body, ws);
   logger.success(`Saved ${dest}`);
   if (opts.output) {
-    fs35.mkdirSync(path40.dirname(path40.resolve(opts.output)), { recursive: true });
-    fs35.copyFileSync(dest, opts.output);
+    fs36.mkdirSync(path41.dirname(path41.resolve(opts.output)), { recursive: true });
+    fs36.copyFileSync(dest, opts.output);
     logger.success(`Copied to ${opts.output}`);
   }
   await maybeDownloadThumb(source, dest, {
@@ -5664,6 +6030,16 @@ function resolveProviderKey(p) {
   }
   return {};
 }
+function cloudflareReadiness() {
+  const accountId = resolveKey("CLOUDFLARE_ACCOUNT_ID")?.trim();
+  const apiToken = resolveKey("CLOUDFLARE_API_TOKEN")?.trim();
+  const gatewayId = resolveKey("CLOUDFLARE_AI_GATEWAY_ID")?.trim();
+  const replicateToken = resolveKey("REPLICATE_API_TOKEN")?.trim();
+  return {
+    native: Boolean(accountId && apiToken),
+    video: Boolean(accountId && apiToken && gatewayId && replicateToken)
+  };
+}
 async function checkCodexImageReadiness(hasAnyProviderKey, verbose = false, checker = checkCodexAuthenticated) {
   if (hasAnyProviderKey && !verbose) return false;
   return checker();
@@ -5704,6 +6080,20 @@ function registerCheckCommand(program2) {
         logger.warn(`${p.envPrimary} not set (${p.name} features unavailable)`);
       }
     }
+    const cloudflare = cloudflareReadiness();
+    if (cloudflare.native) {
+      anyKey = true;
+      logger.success("Cloudflare Workers AI credentials configured (image and speech)");
+      if (cloudflare.video) {
+        logger.success("Cloudflare AI Gateway video credentials configured");
+      } else {
+        logger.info("Cloudflare video needs CLOUDFLARE_AI_GATEWAY_ID and REPLICATE_API_TOKEN");
+      }
+    } else {
+      logger.info(
+        "Cloudflare media needs CLOUDFLARE_ACCOUNT_ID and CLOUDFLARE_API_TOKEN (optional)"
+      );
+    }
     const shouldCheckCodex = !anyKey || opts.verbose;
     let codexReady = false;
     if (shouldCheckCodex) {
@@ -5760,8 +6150,8 @@ function registerCheckCommand(program2) {
 
 // src/commands/doc/convert.ts
 init_errors();
-import fs36 from "fs";
-import path41 from "path";
+import fs37 from "fs";
+import path42 from "path";
 
 // src/commands/doc/default-prompt.ts
 var DEFAULT_CONVERT_PROMPT = `Convert this document to clean, well-formatted Markdown.
@@ -5782,18 +6172,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 (!fs36.existsSync(f)) throw new ValidationError(`Input file not found: ${f}`);
+    if (!fs37.existsSync(f)) throw new ValidationError(`Input file not found: ${f}`);
   }
   let outputPath;
   if (output) {
-    outputPath = path41.resolve(output);
+    outputPath = path42.resolve(output);
   } else if (autoName && inputs.length === 1 && inputs[0]) {
-    const base = path41.basename(inputs[0], path41.extname(inputs[0]));
-    outputPath = path41.join(getOutputDir(), `${base}-extraction.md`);
+    const base = path42.basename(inputs[0], path42.extname(inputs[0]));
+    outputPath = path42.join(getOutputDir(), `${base}-extraction.md`);
   } else {
-    outputPath = path41.join(getOutputDir(), "document-extraction.md");
+    outputPath = path42.join(getOutputDir(), "document-extraction.md");
   }
-  fs36.mkdirSync(path41.dirname(outputPath), { recursive: true });
+  fs37.mkdirSync(path42.dirname(outputPath), { recursive: true });
   const results = [];
   for (let i = 0; i < inputs.length; i++) {
     const filePath = inputs[i];
@@ -5844,7 +6234,7 @@ async function convertDocuments(opts) {
 `);
   for (const r of results) {
     lines.push(`
-## ${path41.basename(r.file)}
+## ${path42.basename(r.file)}
 `);
     if (r.status === "success" && r.markdown) {
       lines.push(`${r.markdown}
@@ -5857,7 +6247,7 @@ async function convertDocuments(opts) {
     }
     lines.push("\n---\n");
   }
-  fs36.writeFileSync(outputPath, lines.join("\n"), "utf8");
+  fs37.writeFileSync(outputPath, lines.join("\n"), "utf8");
   const succeeded = results.filter((r) => r.status === "success").length;
   console.log(`
 ${"=".repeat(50)}`);
@@ -5905,12 +6295,12 @@ function registerDocCommands(program2) {
 
 // src/commands/media/index.ts
 init_errors();
-import fs39 from "fs";
-import path44 from "path";
+import fs40 from "fs";
+import path45 from "path";
 
 // src/commands/media/batch.ts
-import fs37 from "fs";
-import path42 from "path";
+import fs38 from "fs";
+import path43 from "path";
 
 // src/commands/media/detect-type.ts
 var VIDEO_EXTS = /* @__PURE__ */ new Set([".mp4", ".mov", ".avi", ".mkv", ".webm", ".flv", ".mpg", ".mpeg"]);
@@ -6106,10 +6496,10 @@ async function batchOptimize(opts) {
     verbose,
     logger
   } = opts;
-  fs37.mkdirSync(outputDir, { recursive: true });
-  const entries = fs37.readdirSync(inputDir);
+  fs38.mkdirSync(outputDir, { recursive: true });
+  const entries = fs38.readdirSync(inputDir);
   const mediaFiles = entries.filter((f) => {
-    const ext = path42.extname(f).toLowerCase();
+    const ext = path43.extname(f).toLowerCase();
     return ALL_EXTS.has(ext);
   });
   if (mediaFiles.length === 0) {
@@ -6120,9 +6510,9 @@ async function batchOptimize(opts) {
   let succeeded = 0;
   const errors = [];
   for (const file of mediaFiles) {
-    const inputPath = path42.join(inputDir, file);
-    const outputPath = path42.join(outputDir, file);
-    const ext = path42.extname(file).toLowerCase();
+    const inputPath = path43.join(inputDir, file);
+    const outputPath = path43.join(outputDir, file);
+    const ext = path43.extname(file).toLowerCase();
     const kind = extToKind(ext);
     logger?.debug(`Processing: ${file}`);
     try {
@@ -6159,8 +6549,8 @@ async function batchOptimize(opts) {
 
 // src/commands/media/split-video.ts
 init_errors();
-import fs38 from "fs";
-import path43 from "path";
+import fs39 from "fs";
+import path44 from "path";
 async function splitVideo(opts) {
   await assertFfmpeg();
   const { input, outputDir, chunkDuration = 3600, verbose, logger } = opts;
@@ -6171,10 +6561,10 @@ async function splitVideo(opts) {
     logger?.info("Video is short enough \u2014 no splitting needed");
     return [input];
   }
-  fs38.mkdirSync(outputDir, { recursive: true });
-  const ext = path43.extname(input) || ".mp4";
-  const baseName = path43.basename(input, ext);
-  const outputPattern = path43.join(outputDir, `${baseName}_chunk_%03d${ext}`);
+  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}`);
   logger?.debug(`Splitting into ~${numChunks} chunks of ${chunkDuration}s each`);
   const args = [
     "-i",
@@ -6193,8 +6583,8 @@ async function splitVideo(opts) {
   await runFfmpeg(args, { verbose, logger });
   const files = [];
   for (let i = 0; i < numChunks + 1; i++) {
-    const fname = path43.join(outputDir, `${baseName}_chunk_${String(i).padStart(3, "0")}${ext}`);
-    if (fs38.existsSync(fname)) files.push(fname);
+    const fname = path44.join(outputDir, `${baseName}_chunk_${String(i).padStart(3, "0")}${ext}`);
+    if (fs39.existsSync(fname)) files.push(fname);
   }
   logger?.success(`Created ${files.length} chunks in ${outputDir}`);
   return files;
@@ -6208,9 +6598,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 (!fs39.existsSync(opts.input)) throw new ValidationError(`Input not found: ${opts.input}`);
-      fs39.mkdirSync(path44.dirname(path44.resolve(opts.output)), { recursive: true });
-      const ext = path44.extname(opts.input).toLowerCase();
+      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();
       const kind = extToKind(ext);
       if (!kind) throw new ValidationError(`Unsupported file type: ${ext}`);
       const quality = Number.parseInt(opts.quality, 10);
@@ -6250,7 +6640,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 (!fs39.existsSync(opts.input)) throw new ValidationError(`Input not found: ${opts.input}`);
+      if (!fs40.existsSync(opts.input)) throw new ValidationError(`Input not found: ${opts.input}`);
       const chunks = await splitVideo({
         input: opts.input,
         outputDir: opts.outputDir,
@@ -6266,7 +6656,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 (!fs39.existsSync(opts.inputDir))
+      if (!fs40.existsSync(opts.inputDir))
         throw new ValidationError(`Input dir not found: ${opts.inputDir}`);
       const result = await batchOptimize({
         inputDir: opts.inputDir,
@@ -6296,6 +6686,7 @@ function registerCommands(program2) {
   registerOpenRouterCommands(program2);
   registerLeonardoCommands(program2);
   registerBytePlusCommands(program2);
+  registerCloudflareCommands(program2);
   registerElevenLabsCommands(program2);
   registerMediaCommands(program2);
   registerDocCommands(program2);