@mrgoonie/multix 0.1.0-beta → 0.1.0-beta.1

package/dist/cli.js

@@ -110,11 +110,14 @@ async function httpJson(opts) {
   }
   return response.json();
 }
-async function downloadFile(url, dest, timeoutMs = DEFAULT_TIMEOUT_MS) {
+async function downloadFile(url, dest, timeoutMs = DEFAULT_TIMEOUT_MS, headers = {}) {
   fs4.mkdirSync(path4.dirname(dest), { recursive: true });
   let response;
   try {
-    response = await globalThis.fetch(url, { signal: AbortSignal.timeout(timeoutMs) });
+    response = await globalThis.fetch(url, {
+      headers,
+      signal: AbortSignal.timeout(timeoutMs)
+    });
   } catch (cause) {
     const msg = cause instanceof Error ? cause.message : String(cause);
     throw new HttpError(0, msg, url);
@@ -414,9 +417,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 +437,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 +993,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 = [];
@@ -2076,7 +2079,7 @@ function requiresProcessingWait(mimeType) {
 var BASE = "https://generativelanguage.googleapis.com";
 var FILES_BASE = `${BASE}/upload/v1beta/files`;
 var GENERATE_BASE = `${BASE}/v1beta/models`;
-function requireApiKey() {
+function requireGeminiApiKey() {
   const key = resolveKey("GEMINI_API_KEY");
   if (!key)
     throw new ConfigError(
@@ -2084,11 +2087,14 @@ function requireApiKey() {
     );
   return key;
 }
-function authHeaders2(apiKey) {
+function geminiAuthHeaders(apiKey) {
   return { "x-goog-api-key": apiKey };
 }
+function unwrapGeminiFileRef(response) {
+  return "file" in response ? response.file : response;
+}
 async function uploadFile(filePath, opts = {}) {
-  const apiKey = requireApiKey();
+  const apiKey = requireGeminiApiKey();
   const { timeoutMs = 3e5, logger } = opts;
   const mimeType = getMimeType(filePath);
   const fileBytes = fs12.readFileSync(filePath);
@@ -2137,8 +2143,8 @@ Content-Type: ${mimeType}\r
       await sleep(2e3);
       fileRef = await httpJson({
         url: `${BASE}/v1beta/${fileRef.name}`,
-        headers: authHeaders2(apiKey)
-      }).then((r) => r.file);
+        headers: geminiAuthHeaders(apiKey)
+      }).then(unwrapGeminiFileRef);
       logger?.debug(`Processing... state=${fileRef.state}`);
     }
     if (fileRef.state === "FAILED")
@@ -2150,11 +2156,11 @@ Content-Type: ${mimeType}\r
   return fileRef;
 }
 async function generateContent(req) {
-  const apiKey = requireApiKey();
+  const apiKey = requireGeminiApiKey();
   return httpJson({
     url: `${GENERATE_BASE}/${req.model}:generateContent`,
     method: "POST",
-    headers: authHeaders2(apiKey),
+    headers: geminiAuthHeaders(apiKey),
     body: {
       contents: req.contents,
       ...req.generationConfig ? { generationConfig: req.generationConfig } : {}
@@ -2196,10 +2202,12 @@ function sleep(ms) {
 // src/providers/gemini/models.ts
 var IMAGE_MODEL_DEFAULT = "gemini-3.1-flash-image-preview";
 var IMAGE_MODEL_FALLBACK = "gemini-2.5-flash-image";
+var IMAGE_MODEL_LITE = "gemini-3.1-flash-lite-image";
 var VIDEO_MODEL_DEFAULT = "veo-3.1-generate-preview";
-var ANALYSIS_MODEL_DEFAULT = "gemini-2.5-flash";
+var TEXT_MODEL_DEFAULT = "gemini-3.5-flash";
+var ANALYSIS_MODEL_DEFAULT = TEXT_MODEL_DEFAULT;
 var TTS_MODEL_DEFAULT = "gemini-3.1-flash-tts-preview";
-var DOC_MODEL_DEFAULT = "gemini-2.5-flash";
+var DOC_MODEL_DEFAULT = TEXT_MODEL_DEFAULT;
 var IMAGEN_MODELS = /* @__PURE__ */ new Set([
   "imagen-4.0-generate-001",
   "imagen-4.0-ultra-generate-001",
@@ -2210,6 +2218,7 @@ var GEMINI_IMAGE_MODELS = /* @__PURE__ */ new Set([
   "gemini-3-pro-image-preview",
   "gemini-2.5-flash-image",
   "gemini-2.5-flash-image-preview",
+  IMAGE_MODEL_LITE,
   ...IMAGEN_MODELS
 ]);
 var ASPECT_RATIOS = [
@@ -2225,6 +2234,15 @@ var ASPECT_RATIOS = [
   "21:9"
 ];
 var IMAGE_SIZES = ["1K", "2K", "4K"];
+function resolveImageOptions(model, aspectRatio, requestedSize) {
+  if (model !== IMAGE_MODEL_LITE) {
+    return { aspectRatio, ...requestedSize ? { imageSize: requestedSize } : {} };
+  }
+  if (requestedSize && requestedSize !== "1K") {
+    throw new Error(`${IMAGE_MODEL_LITE} supports only 1K image output.`);
+  }
+  return { aspectRatio, imageSize: "1K" };
+}
 function getDefaultModel(task) {
   if (task === "generate") {
     return process.env.IMAGE_GEN_MODEL ?? process.env.GEMINI_IMAGE_GEN_MODEL ?? IMAGE_MODEL_DEFAULT;
@@ -2709,6 +2727,13 @@ function sleep2(ms) {
 init_errors();
 import fs18 from "fs";
 import path22 from "path";
+function buildImageGenerationConfig(model, aspectRatio, size) {
+  const imageOptions = resolveImageOptions(model, aspectRatio, size);
+  return {
+    responseModalities: ["IMAGE"],
+    imageConfig: imageOptions
+  };
+}
 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) => {
@@ -2725,12 +2750,11 @@ function registerGenerateCommand(parent) {
       }
       logger.debug(`Generating ${numImages} image(s) with model: ${model}`);
       logger.debug(`Aspect ratio: ${opts.aspectRatio}${opts.size ? `, size: ${opts.size}` : ""}`);
-      const imageConfig = { aspectRatio: opts.aspectRatio };
-      if (opts.size) imageConfig.imageSize = opts.size;
-      const generationConfig = {
-        responseModalities: ["IMAGE"],
-        imageConfig
-      };
+      const generationConfig = buildImageGenerationConfig(
+        model,
+        opts.aspectRatio,
+        opts.size
+      );
       const savedFiles = [];
       for (let i = 0; i < numImages; i++) {
         try {
@@ -2782,6 +2806,10 @@ import fs19 from "fs";
 import path23 from "path";
 var SOFT_LIMIT_BYTES = 5 * 1024 * 1024;
 var HARD_LIMIT_BYTES = 7 * 1024 * 1024;
+function buildImageToImageGenerationConfig(model, aspectRatio, size) {
+  const imageOptions = resolveImageOptions(model, aspectRatio, size);
+  return imageOptions.imageSize ? { responseModalities: ["IMAGE"], imageConfig: imageOptions } : void 0;
+}
 function registerGeminiImageToImageCommand(parent) {
   parent.command("image-to-image").alias("i2i").description(
     "Edit/compose images with Gemini 2.5 Flash Image (Nano Banana) using one or more reference images"
@@ -2790,13 +2818,26 @@ 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("--aspect-ratio <ratio>", `Aspect ratio (${ASPECT_RATIOS.join("|")})`, "1:1").option("--size <sz>", `Image size (${IMAGE_SIZES.join("|")})`).option("--output <path>", "Save first generated image to this path").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.");
       }
       const logger = createLogger({ verbose: opts.verbose ?? false });
       const model = opts.model ?? IMAGE_MODEL_FALLBACK;
+      if (model === IMAGE_MODEL_LITE && opts.ref.length > 1) {
+        logger.warn(
+          `${IMAGE_MODEL_LITE} is not optimized for multiple reference images; use one when possible.`
+        );
+      }
+      if (!ASPECT_RATIOS.includes(opts.aspectRatio)) {
+        throw new Error(
+          `Invalid aspect ratio: ${opts.aspectRatio}. Valid: ${ASPECT_RATIOS.join(", ")}`
+        );
+      }
+      if (opts.size && !IMAGE_SIZES.includes(opts.size)) {
+        throw new Error(`Invalid size: ${opts.size}. Valid: ${IMAGE_SIZES.join(", ")}`);
+      }
       const parts = [];
       for (const r of opts.ref) {
         const resolved = await resolveImageInput(r, {
@@ -2820,10 +2861,15 @@ function registerGeminiImageToImageCommand(parent) {
       }
       parts.push({ text: opts.prompt });
       logger.debug(`Calling ${model} with ${opts.ref.length} reference image(s)`);
+      const generationConfig = buildImageToImageGenerationConfig(
+        model,
+        opts.aspectRatio,
+        opts.size
+      );
       const req = {
         model,
         contents: [{ parts }],
-        generationConfig: { responseModalities: ["IMAGE"] }
+        ...generationConfig ? { generationConfig } : {}
       };
       const resp = await generateContent(req);
       const images = extractImages(resp);
@@ -2984,16 +3030,186 @@ Generated video: ${dest}`);
   );
 }
 
-// src/providers/gemini/commands/transcribe.ts
+// src/providers/gemini/commands/omni-video.ts
 init_errors();
 import fs21 from "fs";
+import path25 from "path";
+
+// src/providers/gemini/interactions.ts
+init_errors();
+init_http_client();
+var BASE4 = "https://generativelanguage.googleapis.com/v1beta";
+var OMNI_MODEL = "gemini-omni-flash-preview";
+function buildOmniInteractionPayload(request) {
+  return {
+    model: OMNI_MODEL,
+    input: buildOmniInput(request),
+    response_format: { type: "video", delivery: "uri" },
+    store: true,
+    ...request.previousInteractionId ? { previous_interaction_id: request.previousInteractionId } : {}
+  };
+}
+async function createOmniInteraction(request) {
+  const apiKey = requireGeminiApiKey();
+  const raw = await httpJson({
+    url: `${BASE4}/interactions`,
+    method: "POST",
+    headers: geminiAuthHeaders(apiKey),
+    body: buildOmniInteractionPayload(request)
+  });
+  if (!raw.id)
+    throw new ProviderError("Omni response did not include an interaction ID.", "gemini");
+  return { interactionId: raw.id, video: extractOmniVideo(raw) };
+}
+function buildOmniInput(request) {
+  const parts = [{ type: "text", text: request.prompt }];
+  for (const image of request.images ?? []) {
+    parts.push({ type: "image", data: image.data, mime_type: image.mimeType });
+  }
+  if (request.videoFileUri) parts.push({ type: "document", uri: request.videoFileUri });
+  return parts;
+}
+function extractOmniVideo(raw) {
+  for (const step of raw.steps ?? []) {
+    if (step.type !== "model_output") continue;
+    for (const content of step.content ?? []) {
+      if (content.type !== "video") continue;
+      const mimeType = content.mime_type ?? "video/mp4";
+      if (content.data) return { kind: "inline", data: content.data, mimeType };
+      if (content.uri) return { kind: "uri", uri: content.uri, mimeType };
+    }
+  }
+  throw new ProviderError("Omni response did not include a generated video.", "gemini");
+}
+async function waitForGeminiFile(fileUri, timeoutMs = 3e5) {
+  const apiKey = requireGeminiApiKey();
+  const name = fileNameFromUri(fileUri);
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const response = await httpJson({
+      url: `${BASE4}/${name}`,
+      headers: geminiAuthHeaders(apiKey)
+    });
+    const file = unwrapGeminiFile(response);
+    if (file.state === "ACTIVE") return file;
+    if (file.state === "FAILED") throw new ProviderError("Generated Omni video failed.", "gemini");
+    await sleep4(5e3);
+  }
+  throw new ProviderError("Timed out waiting for generated Omni video.", "gemini");
+}
+async function downloadGeminiFile(fileUri, destination) {
+  const apiKey = requireGeminiApiKey();
+  await downloadFile(fileUri, destination, void 0, geminiAuthHeaders(apiKey));
+}
+function fileNameFromUri(fileUri) {
+  const pathname = new URL(fileUri).pathname;
+  const match = pathname.match(/\/(files\/[^/:]+)(?::download)?$/);
+  if (!match?.[1]) throw new ProviderError(`Unexpected Gemini file URI: ${fileUri}`, "gemini");
+  return match[1];
+}
+function unwrapGeminiFile(response) {
+  return "file" in response ? response.file : response;
+}
+function selectGeminiDownloadUri(file, fallbackUri) {
+  return file.downloadUri ?? fallbackUri;
+}
+function sleep4(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/providers/gemini/commands/omni-video.ts
+function registerOmniVideoCommand(parent) {
+  parent.command("omni-video").description("Generate or edit video with Gemini Omni Flash [PAID PREVIEW]").requiredOption("--prompt <text>", "Video prompt or concise edit instruction").option("--image <paths...>", "Local image guidance files").option("--video <path>", "One local video to edit (not available in EEA/CH/UK)").option("--previous-interaction-id <id>", "Continue a prior Gemini-stored interaction").option("--upload-timeout <ms>", "Files API processing timeout in ms", "300000").option("--output <path>", "Copy generated video to this path").option("-v, --verbose", "Verbose logging").addHelpText(
+    "after",
+    "\nPreview, paid-tier API. Outputs 3-10 second 720p videos. Audio references, video extension/interpolation, voice editing, and multiple videos are unsupported. Follow-up edits require provider-side stored interactions; no local history is kept."
+  ).action(async (opts) => {
+    const logger = createLogger({ verbose: opts.verbose ?? false });
+    validateInputs(opts);
+    const images = (opts.image ?? []).map(readImage);
+    const videoFile = opts.video ? await uploadFile(opts.video, { timeoutMs: parseTimeout(opts.uploadTimeout), logger }) : void 0;
+    const result = await createOmniInteraction({
+      prompt: opts.prompt,
+      images,
+      videoFileUri: videoFile?.uri,
+      previousInteractionId: opts.previousInteractionId
+    });
+    const destination = path25.join(getOutputDir(), `gemini_omni_${Date.now()}.mp4`);
+    if (result.video.kind === "inline") {
+      fs21.writeFileSync(destination, Buffer.from(result.video.data, "base64"));
+    } else {
+      const generated = await waitForGeminiFile(result.video.uri);
+      await downloadGeminiFile(selectGeminiDownloadUri(generated, result.video.uri), destination);
+    }
+    const metadataPath = `${destination}.json`;
+    fs21.writeFileSync(
+      metadataPath,
+      `${JSON.stringify(buildOmniVideoMetadata(opts, result.interactionId), null, 2)}
+`
+    );
+    if (opts.output) {
+      fs21.mkdirSync(path25.dirname(path25.resolve(opts.output)), { recursive: true });
+      fs21.copyFileSync(destination, opts.output);
+      fs21.copyFileSync(metadataPath, `${opts.output}.json`);
+    }
+    logger.success(`Saved video: ${destination}`);
+    logger.success(`Saved metadata: ${metadataPath}`);
+    if (opts.output) logger.success(`Copied to: ${opts.output}`);
+    console.log(`Interaction ID: ${result.interactionId}`);
+  });
+}
+function buildOmniVideoMetadata(opts, interactionId) {
+  return {
+    provider: "gemini",
+    model: "gemini-omni-flash-preview",
+    prompt: opts.prompt,
+    inputFiles: [...opts.image ?? [], ...opts.video ? [opts.video] : []].map(
+      (filePath) => path25.basename(filePath)
+    ),
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    interactionId
+  };
+}
+function validateInputs(opts) {
+  if (opts.video && opts.image?.length) {
+    throw new ValidationError("Use either --video or --image guidance, not both.");
+  }
+  if (opts.video) {
+    requireLocalFile(opts.video, "video");
+    if (!getMimeType(opts.video).startsWith("video/")) {
+      throw new ValidationError(`Unsupported video file: ${opts.video}`);
+    }
+  }
+  for (const imagePath of opts.image ?? []) {
+    requireLocalFile(imagePath, "image");
+    if (!getMimeType(imagePath).startsWith("image/")) {
+      throw new ValidationError(`Unsupported image file: ${imagePath}`);
+    }
+  }
+}
+function requireLocalFile(filePath, label) {
+  if (/^https?:\/\//i.test(filePath)) throw new ValidationError(`${label} URLs are not supported.`);
+  if (!fs21.existsSync(filePath)) throw new ValidationError(`${label} file not found: ${filePath}`);
+}
+function readImage(filePath) {
+  return { data: fs21.readFileSync(filePath).toString("base64"), mimeType: getMimeType(filePath) };
+}
+function parseTimeout(value) {
+  const timeout = Number.parseInt(value, 10);
+  if (!Number.isFinite(timeout) || timeout <= 0)
+    throw new ValidationError("--upload-timeout must be positive.");
+  return timeout;
+}
+
+// src/providers/gemini/commands/transcribe.ts
+init_errors();
+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++) {
@@ -3046,13 +3262,14 @@ function registerGeminiCommands(program2) {
   registerGeminiImageToImageCommand(gemini);
   registerGenerateVideoCommand(gemini);
   registerGeminiImageToVideoCommand(gemini);
+  registerOmniVideoCommand(gemini);
   registerGeminiGenerateSpeechCommand(gemini);
 }
 
 // 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 +3343,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 +3366,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 +3384,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 +3469,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 +3479,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 +3493,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 +3559,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 +3569,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 +3583,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 };
@@ -3477,7 +3694,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 ?? path27.join(getOutputDir(), `${opts.basename}-${jobId.slice(0, 8)}.mp4`);
+  const outPath = opts.output ?? path28.join(getOutputDir(), `${opts.basename}-${jobId.slice(0, 8)}.mp4`);
   await downloadFile(videoUrl, outPath);
   logger.success(`Saved ${outPath}`);
   await maybeDownloadThumb(gen, outPath, {
@@ -3584,7 +3801,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 +3866,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 +3879,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++;
@@ -3750,7 +3967,7 @@ function requireMinimaxKey() {
   }
   return key;
 }
-function authHeaders3(apiKey) {
+function authHeaders2(apiKey) {
   return {
     Authorization: `Bearer ${apiKey}`,
     "Content-Type": "application/json"
@@ -3762,7 +3979,7 @@ async function apiPost(endpoint2, payload, apiKey, opts = {}) {
   const data = await httpJson({
     url,
     method: "POST",
-    headers: authHeaders3(apiKey),
+    headers: authHeaders2(apiKey),
     body: payload,
     timeoutMs: opts.timeoutMs ?? 12e4
   });
@@ -3778,7 +3995,7 @@ async function apiPost(endpoint2, payload, apiKey, opts = {}) {
 async function apiGet2(endpoint2, params, apiKey) {
   const url = new URL(`${MINIMAX_BASE_URL}/${endpoint2}`);
   for (const [k, v] of Object.entries(params)) url.searchParams.set(k, v);
-  return httpJson({ url: url.toString(), headers: authHeaders3(apiKey) });
+  return httpJson({ url: url.toString(), headers: authHeaders2(apiKey) });
 }
 async function pollAsyncTask(taskId, taskType, apiKey, opts = {}) {
   const { intervalMs = 1e4, timeoutMs = 6e5, logger } = opts;
@@ -3794,7 +4011,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");
@@ -3813,14 +4030,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 fs24 from "fs";
-import path29 from "path";
+import fs25 from "fs";
+import path30 from "path";
 async function generateMinimaxMusic(opts) {
   const {
     apiKey,
@@ -3865,14 +4082,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 {
@@ -3883,8 +4100,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 };
 }
@@ -3958,8 +4175,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,
@@ -4006,12 +4223,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 };
 }
@@ -4058,8 +4275,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,
@@ -4105,18 +4322,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,
@@ -4179,8 +4396,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,
@@ -4218,8 +4435,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) {
@@ -4230,8 +4447,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 };
 }
@@ -4267,8 +4484,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."
@@ -4323,8 +4540,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) {
@@ -4335,8 +4552,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(`
@@ -4470,12 +4687,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;
@@ -4491,14 +4708,14 @@ function requireOpenAIKey() {
 function endpoint(pathname) {
   return `${OPENAI_BASE_URL}/${pathname.replace(/^\//, "")}`;
 }
-function authHeaders4(apiKey, extra) {
+function authHeaders3(apiKey, extra) {
   return { Authorization: `Bearer ${apiKey}`, ...extra ?? {} };
 }
 function postOpenAIJson(pathname, body, apiKey, timeoutMs = DEFAULT_TIMEOUT_MS3) {
   return httpJson({
     url: endpoint(pathname),
     method: "POST",
-    headers: authHeaders4(apiKey, { "Content-Type": "application/json" }),
+    headers: authHeaders3(apiKey, { "Content-Type": "application/json" }),
     body,
     timeoutMs
   });
@@ -4509,7 +4726,7 @@ async function postOpenAIForm(pathname, form, apiKey, timeoutMs = DEFAULT_TIMEOU
   try {
     res = await globalThis.fetch(url, {
       method: "POST",
-      headers: authHeaders4(apiKey),
+      headers: authHeaders3(apiKey),
       body: form,
       signal: AbortSignal.timeout(timeoutMs)
     });
@@ -4528,7 +4745,7 @@ async function postOpenAIBinary(pathname, body, apiKey, timeoutMs = DEFAULT_TIME
   try {
     res = await globalThis.fetch(url, {
       method: "POST",
-      headers: authHeaders4(apiKey, { "Content-Type": "application/json" }),
+      headers: authHeaders3(apiKey, { "Content-Type": "application/json" }),
       body: JSON.stringify(body),
       signal: AbortSignal.timeout(timeoutMs)
     });
@@ -4542,10 +4759,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
@@ -4584,7 +4801,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";
@@ -4603,12 +4820,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;
 }
@@ -4630,9 +4847,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 };
 }
@@ -4659,9 +4876,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) => {
@@ -4710,12 +4927,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",
@@ -4745,7 +4962,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 };
@@ -4763,8 +4980,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,
@@ -4797,14 +5014,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;
@@ -4813,7 +5030,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);
@@ -4858,7 +5075,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";
@@ -4984,8 +5201,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();
 
@@ -5150,8 +5367,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) {
@@ -5162,8 +5379,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 };
 }
@@ -5198,8 +5415,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";
@@ -5289,14 +5506,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;
@@ -5305,7 +5522,7 @@ async function runImageToImage(opts) {
 // src/providers/openrouter/video-client.ts
 init_http_client();
 var OPENROUTER_VIDEOS_URL = "https://openrouter.ai/api/v1/videos";
-function authHeaders5(apiKey) {
+function authHeaders4(apiKey) {
   const headers = {
     Authorization: `Bearer ${apiKey}`,
     "Content-Type": "application/json"
@@ -5320,7 +5537,7 @@ async function submitVideoJob(body, apiKey = requireOpenRouterKey()) {
   return httpJson({
     url: OPENROUTER_VIDEOS_URL,
     method: "POST",
-    headers: authHeaders5(apiKey),
+    headers: authHeaders4(apiKey),
     body,
     timeoutMs: 12e4
   });
@@ -5328,7 +5545,7 @@ async function submitVideoJob(body, apiKey = requireOpenRouterKey()) {
 async function pollVideoJob(jobId, apiKey = requireOpenRouterKey()) {
   return httpJson({
     url: `${OPENROUTER_VIDEOS_URL}/${jobId}`,
-    headers: authHeaders5(apiKey)
+    headers: authHeaders4(apiKey)
   });
 }
 function videoContentUrl(jobId) {
@@ -5337,18 +5554,18 @@ function videoContentUrl(jobId) {
 async function listVideoModels(apiKey = requireOpenRouterKey()) {
   return httpJson({
     url: `${OPENROUTER_VIDEOS_URL}/models`,
-    headers: authHeaders5(apiKey)
+    headers: authHeaders4(apiKey)
   });
 }
 
 // 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}`);
@@ -5358,14 +5575,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, {
@@ -5746,8 +5963,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.
@@ -5768,18 +5985,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];
@@ -5811,7 +6028,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);
         }
       }
     }
@@ -5830,7 +6047,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}
@@ -5843,7 +6060,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)}`);
@@ -5859,7 +6076,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));
 }
 
@@ -5889,12 +6106,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"]);
@@ -6090,10 +6307,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) {
@@ -6104,9 +6321,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 {
@@ -6143,8 +6360,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;
@@ -6155,10 +6372,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",
@@ -6177,8 +6394,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;
@@ -6192,9 +6409,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);
@@ -6234,7 +6451,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,
@@ -6250,7 +6467,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,