@mrgoonie/multix 0.9.0 → 0.11.0

package/dist/cli.js

@@ -99,12 +99,1923 @@ var init_errors = __esm({
 import { createRequire as createRequire2 } from "module";
 import { Command } from "commander";
 
+// src/providers/atlascloud/commands/audio.ts
+init_errors();
+
+// src/providers/atlascloud/model-input.ts
+init_errors();
+var SUBMIT_PATH_RE = /\/model\/generate(Image|Video|Audio)$/;
+function resolveRef(doc, ref) {
+  if (typeof ref !== "string" || !ref.startsWith("#/")) return void 0;
+  let node = doc;
+  for (const part of ref.slice(2).split("/")) {
+    node = node?.[part];
+    if (node === void 0) return void 0;
+  }
+  return node;
+}
+function parseModelSpec(model, doc) {
+  if (!doc || typeof doc !== "object") return void 0;
+  const d = doc;
+  let endpoint2;
+  let input;
+  for (const [p, ops] of Object.entries(d.paths ?? {})) {
+    const m = SUBMIT_PATH_RE.exec(p);
+    if (!m?.[1] || !ops?.post) continue;
+    endpoint2 = m[1].toLowerCase();
+    const schema = ops.post.requestBody?.content?.["application/json"]?.schema;
+    input = schema?.$ref ? resolveRef(d, schema.$ref) : schema;
+    break;
+  }
+  input ??= d.components?.schemas?.Input;
+  if (!input || typeof input.properties !== "object") return void 0;
+  return {
+    model,
+    endpoint: endpoint2,
+    properties: input.properties,
+    required: Array.isArray(input.required) ? input.required.filter((r) => typeof r === "string") : []
+  };
+}
+var FIELD_CANDIDATES = {
+  prompt: ["prompt"],
+  negativePrompt: ["negative_prompt"],
+  seed: ["seed"],
+  size: ["size", "image_size"],
+  aspectRatio: ["aspect_ratio"],
+  resolution: ["resolution"],
+  duration: ["duration"],
+  numImages: ["num_images"],
+  editImages: [
+    "images",
+    "image",
+    "image_urls",
+    "reference_images",
+    "image_url",
+    "reference_image_urls"
+  ],
+  primaryImage: [
+    "image",
+    "image_url",
+    "images",
+    "image_urls",
+    "reference_images",
+    "reference_image_urls"
+  ],
+  speechText: ["text", "prompt"],
+  audioInput: ["audio_url", "audio"],
+  voice: ["voice_id", "voice"],
+  audioFormat: ["format", "codec", "output_format"],
+  language: ["language"],
+  modelFormat: ["format", "output_format", "target_formats"]
+};
+var FALLBACK_FIELD_TYPES = {
+  seed: "integer",
+  num_images: "integer",
+  duration: "number",
+  images: "array"
+};
+function coerce(flag, field, prop, value) {
+  const type = prop.type;
+  if (Array.isArray(value)) {
+    if (type === "array") return value;
+    if (value.length === 1) return coerceScalar(flag, field, type, value[0]);
+    throw new ValidationError(
+      `${flag}: field "${field}" of this model accepts a single value, got ${value.length}`
+    );
+  }
+  if (type === "array") return [coerceScalar(flag, field, prop.items?.type, value)];
+  return coerceScalar(flag, field, type, value);
+}
+function coerceScalar(flag, field, type, value) {
+  if (type === "integer" || type === "number") {
+    const n = typeof value === "number" ? value : Number(String(value).trim());
+    if (!Number.isFinite(n) || type === "integer" && !Number.isInteger(n)) {
+      throw new ValidationError(`${flag}: "${value}" is not a valid ${type} for "${field}"`);
+    }
+    return n;
+  }
+  if (type === "boolean") {
+    if (typeof value === "boolean") return value;
+    const s = String(value).toLowerCase();
+    if (s === "true") return true;
+    if (s === "false") return false;
+    throw new ValidationError(`${flag}: "${value}" is not a boolean for "${field}"`);
+  }
+  if (type === "string") return String(value);
+  return value;
+}
+function checkConstraints(flag, field, prop, v) {
+  const values = Array.isArray(v) ? v : [v];
+  if (Array.isArray(prop.enum) && prop.enum.length > 0 && !Array.isArray(v)) {
+    if (!prop.enum.some((e) => e === v || String(e) === String(v))) {
+      throw new ValidationError(
+        `${flag}: "${String(v)}" is not supported by this model. Valid ${field}: ${prop.enum.map(String).join(", ")}`
+      );
+    }
+  }
+  for (const item of values) {
+    if (typeof item !== "number") continue;
+    if (prop.minimum !== void 0 && item < prop.minimum) {
+      throw new ValidationError(
+        `${flag}: ${item} is below the minimum ${prop.minimum} for "${field}"`
+      );
+    }
+    if (prop.maximum !== void 0 && item > prop.maximum) {
+      throw new ValidationError(
+        `${flag}: ${item} exceeds the maximum ${prop.maximum} for "${field}"`
+      );
+    }
+  }
+  if (Array.isArray(v) && prop.maxItems !== void 0 && v.length > prop.maxItems) {
+    throw new ValidationError(
+      `${flag}: this model accepts at most ${prop.maxItems} item(s) for "${field}", got ${v.length}`
+    );
+  }
+}
+function pickField(spec, req) {
+  const declared = req.candidates.filter((c2) => spec.properties[c2] !== void 0);
+  const compatible = declared.filter((c2) => {
+    if (spec.properties[c2]?.type !== "boolean") return true;
+    const v = req.value;
+    return typeof v === "boolean" || typeof v === "string" && /^(true|false)$/i.test(v);
+  });
+  if (Array.isArray(req.value) && req.value.length > 1) {
+    return compatible.find((c2) => spec.properties[c2]?.type === "array") ?? compatible[0];
+  }
+  return compatible[0];
+}
+function buildModelInput(spec, requests, base = {}) {
+  const body = { ...base };
+  for (const req of requests) {
+    if (req.value === void 0 || Array.isArray(req.value) && req.value.length === 0) continue;
+    if (!spec) {
+      const field2 = req.candidates[0];
+      if (field2) {
+        const type = FALLBACK_FIELD_TYPES[field2] ?? "string";
+        body[field2] = coerce(req.flag, field2, { type }, req.value);
+      }
+      continue;
+    }
+    const field = pickField(spec, req);
+    if (!field) {
+      throw new ValidationError(
+        `Model ${spec.model} does not accept ${req.flag}. Its inputs: ${listInputs(spec)}. Use \`multix atlas run ${spec.model} --input '{...}'\` for model-specific fields.`
+      );
+    }
+    const prop = spec.properties[field];
+    const value = coerce(req.flag, field, prop, req.value);
+    checkConstraints(req.flag, field, prop, value);
+    body[field] = value;
+  }
+  if (spec) finalizeAgainstSpec(spec, body, requests);
+  return body;
+}
+function listInputs(spec) {
+  return Object.keys(spec.properties).filter((k) => k !== "model").join(", ");
+}
+var CONTENT_FIELDS = /* @__PURE__ */ new Set(["prompt", "text", "lyrics"]);
+function finalizeAgainstSpec(spec, body, requests = []) {
+  const missing = [];
+  for (const field of spec.required) {
+    if (field === "model" || body[field] !== void 0) continue;
+    const def = spec.properties[field]?.default;
+    if (def !== void 0 && def !== "" && !CONTENT_FIELDS.has(field)) {
+      body[field] = def;
+      continue;
+    }
+    const flag = requests.find((r) => r.candidates.includes(field))?.flag;
+    missing.push(flag ? `${field} (pass ${flag})` : field);
+  }
+  if (missing.length > 0) {
+    throw new ValidationError(`Model ${spec.model} requires: ${missing.join(", ")}`);
+  }
+}
+function validateRawInput(spec, body) {
+  const unknown = [];
+  for (const [field, value] of Object.entries(body)) {
+    if (field === "model") continue;
+    const prop = spec.properties[field];
+    if (!prop) {
+      unknown.push(field);
+      continue;
+    }
+    checkConstraints(`--input.${field}`, field, prop, value);
+  }
+  finalizeAgainstSpec(spec, body);
+  return unknown;
+}
+
+// src/providers/atlascloud/models.ts
+var DEFAULT_ATLAS_BASE_URL = "https://api.atlascloud.ai/api/v1";
+var SUBMIT_PATHS = {
+  image: "/model/generateImage",
+  video: "/model/generateVideo",
+  audio: "/model/generateAudio"
+};
+var ATLAS_MEDIA_KINDS = ["image", "video", "audio"];
+var ATLAS_DEFAULT_MODELS = {
+  /** FLUX.1 [schnell], $0.003/image — fastest, cheapest text-to-image. */
+  image: "black-forest-labs/flux-schnell",
+  /** GPT Image 1 Mini edit — cheapest image edit; takes `images[]`. */
+  imageEdit: "openai/gpt-image-1-mini/edit",
+  /** Seedance 1.0 Pro Fast — low-cost text-to-video, 2-12s, 480p-1080p. */
+  video: "bytedance/seedance-v1-pro-fast/text-to-video",
+  /** Matching image-to-video model; takes a single `image`. */
+  imageToVideo: "bytedance/seedance-v1-pro-fast/image-to-video",
+  /** xAI TTS v1 — cheapest text-to-speech. */
+  tts: "xai/tts-v1",
+  /** Seed ASR 2.0 — documented speech-to-text example; returns text. */
+  stt: "bytedance/seed-asr-2.0",
+  /** Hunyuan 3D Rapid — low-cost text-to-3D (GLB by default). */
+  textTo3d: "tencent/hunyuan3d-rapid/text-to-3d",
+  /** Hunyuan 3D Rapid — low-cost image-to-3D (GLB by default). */
+  imageTo3d: "tencent/hunyuan3d-rapid/image-to-3d"
+};
+
+// src/providers/atlascloud/commands/env.ts
+import { openAsBlob } from "fs";
+import fs2 from "fs/promises";
+import path2 from "path";
+
+// src/core/env-loader.ts
+init_redact();
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { config as dotenvConfig, parse as dotenvParse } from "dotenv";
+var loaded = false;
+var loadedFiles = [];
+var LEGACY_SKILL_DIRS = ["ai-multimodal", "ak-ai-multimodal"];
+function legacyFilesUnder(root) {
+  const claude = path.join(root, ".claude");
+  return [
+    ...LEGACY_SKILL_DIRS.map((dir) => path.join(claude, "skills", dir, ".env")),
+    path.join(claude, "skills", ".env"),
+    path.join(claude, ".env")
+  ];
+}
+function samePath(a, b) {
+  const norm2 = (p) => {
+    const r = path.resolve(p);
+    return process.platform === "win32" ? r.toLowerCase() : r;
+  };
+  return norm2(a) === norm2(b);
+}
+function legacyClaudeEnvFiles(cwd, home) {
+  const files = legacyFilesUnder(cwd);
+  if (home && !samePath(home, cwd)) files.push(...legacyFilesUnder(home));
+  return files;
+}
+function legacyClaudeEnvEnabled(env = process.env) {
+  const value = env.MULTIX_LEGACY_CLAUDE_ENV;
+  return value !== void 0 && ["1", "true", "yes", "on"].includes(value.trim().toLowerCase());
+}
+var LEGACY_ALLOWED_NAME = /^[A-Z][A-Z0-9_]*_(API_KEY(_\d+)?|API_TOKEN|ACCOUNT_ID|GATEWAY_ID)$|^(FAL_KEY|ARK_API_KEY)$/;
+function isLegacyAllowedName(name) {
+  return LEGACY_ALLOWED_NAME.test(name);
+}
+function isReadableFile(file) {
+  try {
+    return fs.statSync(file).isFile();
+  } catch {
+    return false;
+  }
+}
+function loadFile(file) {
+  if (!isReadableFile(file)) return;
+  const result = dotenvConfig({ path: file, override: false });
+  if (!result.error) loadedFiles.push(file);
+}
+function loadLegacyFile(file) {
+  if (!isReadableFile(file)) return;
+  let parsed;
+  try {
+    parsed = dotenvParse(fs.readFileSync(file));
+  } catch {
+    return;
+  }
+  for (const [name, value] of Object.entries(parsed)) {
+    if (isLegacyAllowedName(name) && process.env[name] === void 0) process.env[name] = value;
+  }
+  loadedFiles.push(file);
+}
+function loadEnv() {
+  if (loaded) return;
+  loaded = true;
+  loadedFiles = [];
+  const cwd = process.cwd();
+  const home = process.env.MULTIX_DISABLE_HOME_ENV ? void 0 : os.homedir();
+  loadFile(path.resolve(cwd, ".env"));
+  if (home) loadFile(path.join(home, ".multix", ".env"));
+  if (legacyClaudeEnvEnabled()) {
+    for (const file of legacyClaudeEnvFiles(cwd, home)) loadLegacyFile(file);
+  }
+}
+function getLoadedEnvFiles() {
+  return [...loadedFiles];
+}
+function resolveKey(name) {
+  return process.env[name] || void 0;
+}
+
+// src/providers/atlascloud/commands/env.ts
+init_errors();
+
+// src/core/logger.ts
+var ANSI = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  red: "\x1B[31m",
+  blue: "\x1B[34m",
+  cyan: "\x1B[36m",
+  dim: "\x1B[2m"
+};
+function c(color, text) {
+  if (process.env.NO_COLOR || !process.stdout.isTTY) return text;
+  return `${color}${text}${ANSI.reset}`;
+}
+function createLogger(opts) {
+  const { verbose } = opts;
+  return {
+    info(msg) {
+      console.log(c(ANSI.blue, `  ${msg}`));
+    },
+    success(msg) {
+      console.log(c(ANSI.green, `\u2713 ${msg}`));
+    },
+    warn(msg) {
+      console.warn(c(ANSI.yellow, `\u26A0 ${msg}`));
+    },
+    error(msg) {
+      console.error(c(ANSI.red, `\u2717 ${msg}`));
+    },
+    debug(msg) {
+      if (verbose) console.log(c(ANSI.dim, `  [debug] ${msg}`));
+    },
+    header(msg) {
+      const line = "=".repeat(60);
+      console.log(c(ANSI.bold + ANSI.cyan, `
+${line}
+${msg}
+${line}
+`));
+    }
+  };
+}
+var defaultLogger = createLogger({ verbose: false });
+
+// src/providers/atlascloud/commands/env.ts
+init_redact();
+
+// src/core/async-poll.ts
+init_errors();
+var PollTimeoutError = class extends MultixError {
+  constructor(message, lastStatus) {
+    super(message, "POLL_TIMEOUT");
+    this.lastStatus = lastStatus;
+    this.name = "PollTimeoutError";
+  }
+  lastStatus;
+};
+function isTransientHttpError(error) {
+  if (!(error instanceof HttpError)) return false;
+  return error.status === 0 || error.status === 429 || error.status >= 500;
+}
+var defaultSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+async function pollUntil(opts) {
+  const now = opts.now ?? Date.now;
+  const sleep5 = opts.sleep ?? defaultSleep;
+  const random = opts.random ?? Math.random;
+  const isTransient = opts.isTransientError ?? isTransientHttpError;
+  const maxInterval = opts.maxIntervalMs ?? 15e3;
+  const minInterval = opts.minIntervalMs ?? 500;
+  const factor = opts.backoffFactor ?? 1.5;
+  const jitter = opts.jitter ?? true;
+  const deadline = now() + opts.timeoutMs;
+  let interval = opts.intervalMs ?? 3e3;
+  let attempt = 0;
+  let last;
+  let lastError;
+  for (; ; ) {
+    attempt++;
+    let retryAfterMs;
+    try {
+      last = await opts.fetchStatus({ remainingMs: Math.max(1, deadline - now()), attempt });
+      lastError = void 0;
+      opts.onPoll?.(last, attempt);
+      if (opts.isTerminal(last)) return last;
+    } catch (error) {
+      if (!isTransient(error)) throw error;
+      lastError = error;
+      if (error instanceof HttpError) retryAfterMs = error.retryAfterMs;
+    }
+    const remaining = deadline - now();
+    if (remaining <= 0) {
+      const hint = opts.resumeHint ? ` ${opts.resumeHint}` : "";
+      const cause = lastError instanceof Error ? ` Last error: ${lastError.message}.` : "";
+      throw new PollTimeoutError(
+        `Timed out after ${opts.timeoutMs}ms waiting for job.${cause}${hint}`,
+        last
+      );
+    }
+    let delay = retryAfterMs ?? interval;
+    if (jitter && retryAfterMs === void 0) delay *= 0.8 + random() * 0.4;
+    await sleep5(Math.min(Math.max(delay, minInterval), remaining));
+    interval = Math.min(interval * factor, maxInterval);
+  }
+}
+
+// src/providers/atlascloud/client.ts
+init_errors();
+
+// src/core/fetch-json.ts
+init_errors();
+var DEFAULT_TIMEOUT_MS = 12e4;
+var SNIPPET_MAX = 500;
+function parseRetryAfter(value, now = Date.now()) {
+  if (!value) return void 0;
+  const trimmed = value.trim();
+  if (/^\d+(\.\d+)?$/.test(trimmed)) return Math.round(Number(trimmed) * 1e3);
+  const date = Date.parse(trimmed);
+  if (Number.isNaN(date)) return void 0;
+  return Math.max(0, date - now);
+}
+async function httpErrorFromResponse(response, url) {
+  let snippet = "";
+  try {
+    const text = await response.text();
+    snippet = text.slice(0, SNIPPET_MAX);
+  } catch {
+    snippet = "(could not read body)";
+  }
+  return new HttpError(
+    response.status,
+    snippet,
+    url,
+    parseRetryAfter(response.headers.get("retry-after"))
+  );
+}
+async function fetchJson(opts) {
+  const { url, method = "GET", headers: headers2 = {}, body, timeoutMs = DEFAULT_TIMEOUT_MS } = opts;
+  const doFetch = opts.fetch ?? ((input, init2) => globalThis.fetch(input, init2));
+  const init = {
+    method,
+    headers: {
+      "Content-Type": "application/json",
+      ...headers2
+    },
+    signal: AbortSignal.timeout(timeoutMs)
+  };
+  if (body !== void 0) {
+    init.body = JSON.stringify(body);
+  }
+  let response;
+  try {
+    response = await doFetch(url, init);
+  } catch (cause) {
+    const msg = cause instanceof Error ? cause.message : String(cause);
+    throw new HttpError(0, msg, url);
+  }
+  if (!response.ok) {
+    throw await httpErrorFromResponse(response, url);
+  }
+  let text;
+  try {
+    text = await response.text();
+  } catch (cause) {
+    const msg = cause instanceof Error ? cause.message : String(cause);
+    throw new HttpError(0, `Failed to read response body: ${msg}`, url);
+  }
+  if (text.trim() === "") return void 0;
+  try {
+    return JSON.parse(text);
+  } catch {
+    throw new HttpError(
+      response.status,
+      `Invalid JSON response: ${text.slice(0, SNIPPET_MAX)}`,
+      url
+    );
+  }
+}
+
+// src/providers/atlascloud/prediction-output.ts
+var SUCCESS_STATUSES = /* @__PURE__ */ new Set(["completed", "succeeded", "success"]);
+var FAILURE_STATUSES = /* @__PURE__ */ new Set(["failed", "error", "canceled", "cancelled", "timeout"]);
+function norm(status) {
+  return typeof status === "string" ? status.trim().toLowerCase() : "";
+}
+function isSuccessStatus(status) {
+  return SUCCESS_STATUSES.has(norm(status));
+}
+function isFailureStatus(status) {
+  return FAILURE_STATUSES.has(norm(status));
+}
+function isTerminalStatus(status) {
+  return isSuccessStatus(status) || isFailureStatus(status);
+}
+function predictionErrorMessage(error) {
+  if (error === null || error === void 0) return "";
+  if (typeof error === "string") return error.trim();
+  if (typeof error === "number" || typeof error === "boolean") return String(error);
+  if (typeof error === "object") {
+    const obj = error;
+    for (const key of ["message", "msg", "error", "detail", "reason"]) {
+      const v = obj[key];
+      if (typeof v === "string" && v.trim()) return v.trim();
+    }
+    try {
+      return JSON.stringify(error);
+    } catch {
+      return "";
+    }
+  }
+  return "";
+}
+function collectOutputs(prediction2) {
+  const raw = prediction2.outputs ?? prediction2.output;
+  const list = Array.isArray(raw) ? raw : raw ? [raw] : [];
+  const out = [];
+  for (const item of list) {
+    if (typeof item === "string") {
+      if (item.trim()) out.push(item);
+      continue;
+    }
+    if (item && typeof item === "object") {
+      const obj = item;
+      const url = ["url", "download_url", "audio_url", "video_url"].map((k) => obj[k]).find((v) => typeof v === "string" && v.length > 0);
+      out.push(url ?? JSON.stringify(item));
+    }
+  }
+  return out;
+}
+function isMediaOutput(value) {
+  const s = value.trim();
+  return /^https?:\/\//i.test(s) || /^data:[^,]*,/i.test(s);
+}
+var EXT_CATEGORY = {
+  png: "image",
+  jpg: "image",
+  jpeg: "image",
+  webp: "image",
+  gif: "image",
+  bmp: "image",
+  avif: "image",
+  mp4: "video",
+  webm: "video",
+  mov: "video",
+  mkv: "video",
+  avi: "video",
+  mp3: "audio",
+  wav: "audio",
+  aac: "audio",
+  m4a: "audio",
+  flac: "audio",
+  ogg: "audio",
+  opus: "audio",
+  pcm: "audio",
+  glb: "3d",
+  gltf: "3d",
+  obj: "3d",
+  fbx: "3d",
+  stl: "3d",
+  ply: "3d",
+  usdz: "3d",
+  usdc: "3d",
+  usd: "3d",
+  zip: "3d"
+};
+var MIME_EXT = {
+  "image/png": "png",
+  "image/jpeg": "jpg",
+  "image/webp": "webp",
+  "image/gif": "gif",
+  "video/mp4": "mp4",
+  "video/webm": "webm",
+  "audio/mpeg": "mp3",
+  "audio/mp3": "mp3",
+  "audio/wav": "wav",
+  "audio/x-wav": "wav",
+  "audio/ogg": "ogg",
+  "audio/flac": "flac",
+  "model/gltf-binary": "glb",
+  "video/quicktime": "mov",
+  "audio/aac": "aac",
+  "audio/mp4": "m4a",
+  "application/zip": "zip"
+};
+function extensionForContentType(contentType) {
+  const mime = contentType?.split(";")[0]?.trim().toLowerCase();
+  return mime ? MIME_EXT[mime] : void 0;
+}
+function outputExtension(value) {
+  const s = value.trim();
+  const dataMatch = /^data:([^;,]+)/i.exec(s);
+  if (dataMatch?.[1]) return MIME_EXT[dataMatch[1].toLowerCase()];
+  let pathname;
+  try {
+    pathname = new URL(s).pathname;
+  } catch {
+    pathname = s.split(/[?#]/)[0] ?? s;
+  }
+  const m = /\.([a-z0-9]{2,5})$/i.exec(pathname);
+  if (!m?.[1]) return void 0;
+  const ext = m[1].toLowerCase();
+  return ext === "jpeg" ? "jpg" : ext;
+}
+function outputCategory(value) {
+  const ext = outputExtension(value);
+  return ext ? EXT_CATEGORY[ext] ?? "unknown" : "unknown";
+}
+function defaultExtensionFor(category) {
+  switch (category) {
+    case "image":
+      return "png";
+    case "video":
+      return "mp4";
+    case "audio":
+      return "mp3";
+    case "3d":
+      return "glb";
+    case "text":
+      return "txt";
+    default:
+      return "bin";
+  }
+}
+function classifyOutputs(prediction2) {
+  const outputs = collectOutputs(prediction2);
+  if (outputs.length === 0) return { mode: "empty" };
+  const urls = outputs.filter(isMediaOutput);
+  const texts = outputs.filter((o) => !isMediaOutput(o));
+  if (urls.length === 0) return { mode: "text", texts };
+  return { mode: "media", urls, texts };
+}
+function hasNsfwFlag(prediction2) {
+  return Array.isArray(prediction2.has_nsfw_contents) && prediction2.has_nsfw_contents.some(Boolean);
+}
+function outputFileName(predictionId, index, ext) {
+  const prefix = predictionId.replace(/[^a-zA-Z0-9_-]/g, "").slice(0, 8) || "output";
+  return `atlas-${prefix}-${String(index + 1).padStart(2, "0")}.${ext}`;
+}
+
+// src/providers/atlascloud/client.ts
+var ATLAS_PROVIDER = "atlascloud";
+var DEFAULT_UPLOAD_TIMEOUT_MS = 3e5;
+var CATALOG_TIMEOUT_MS = 15e3;
+var PREDICTION_ID_RE = /^[A-Za-z0-9_-]{1,128}$/;
+var AtlasPredictionFailedError = class extends ProviderError {
+  constructor(prediction2) {
+    const reason = predictionErrorMessage(prediction2.error) || `status "${prediction2.status}"`;
+    super(`Atlas Cloud prediction ${prediction2.id} failed: ${reason}`, ATLAS_PROVIDER);
+    this.prediction = prediction2;
+    this.name = "AtlasPredictionFailedError";
+  }
+  prediction;
+};
+function assertValidPredictionId(id) {
+  if (!PREDICTION_ID_RE.test(id)) {
+    throw new ValidationError(`Invalid Atlas Cloud prediction id: "${id}"`);
+  }
+}
+function assertPredictionSucceeded(prediction2) {
+  if (isFailureStatus(prediction2.status)) throw new AtlasPredictionFailedError(prediction2);
+  if (!isSuccessStatus(prediction2.status)) {
+    throw new ProviderError(
+      `Atlas Cloud prediction ${prediction2.id} is not finished (status "${prediction2.status}")`,
+      ATLAS_PROVIDER
+    );
+  }
+}
+function terminalPredictionFromError(error, id) {
+  if (!(error instanceof HttpError) || error.status < 500) return null;
+  const snippet = error.snippet;
+  try {
+    const parsed = JSON.parse(snippet);
+    const data = parsed?.data;
+    if (data && typeof data === "object" && isTerminalStatus(data.status)) {
+      return { ...data, id: data.id || id };
+    }
+    return null;
+  } catch {
+  }
+  const dataAt = snippet.search(/"data"\s*:\s*\{/);
+  if (dataAt === -1) return null;
+  const inData = snippet.slice(dataAt);
+  const status = /"status"\s*:\s*"([^"]+)"/.exec(inData)?.[1];
+  if (status?.toLowerCase() !== "failed") return null;
+  const err2 = /"error"\s*:\s*"((?:[^"\\]|\\.)*)"/.exec(inData)?.[1];
+  return { id, status, error: err2 ?? snippet };
+}
+function envelopeData(env, what) {
+  if (!env || typeof env !== "object") {
+    throw new ProviderError(`Atlas Cloud ${what}: empty response`, ATLAS_PROVIDER);
+  }
+  if (env.code !== void 0 && env.code !== 200 && env.code !== 0 && env.data === void 0) {
+    throw new ProviderError(
+      `Atlas Cloud ${what} failed (code ${env.code}): ${env.msg || env.message || "unknown error"}`,
+      ATLAS_PROVIDER
+    );
+  }
+  if (env.data === void 0 || env.data === null) {
+    throw new ProviderError(`Atlas Cloud ${what}: response has no data`, ATLAS_PROVIDER);
+  }
+  return env.data;
+}
+var AtlasCloudClient = class {
+  baseUrl;
+  apiKey;
+  fetchImpl;
+  timeoutMs;
+  uploadTimeoutMs;
+  catalog;
+  constructor(opts) {
+    if (!opts.apiKey?.trim()) {
+      throw new ConfigError(
+        "ATLASCLOUD_API_KEY is not set. Get one at https://www.atlascloud.ai/console/api-keys"
+      );
+    }
+    this.apiKey = opts.apiKey.trim();
+    this.baseUrl = (opts.baseUrl?.trim() || DEFAULT_ATLAS_BASE_URL).replace(/\/+$/, "");
+    this.fetchImpl = opts.fetch;
+    this.timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    this.uploadTimeoutMs = opts.uploadTimeoutMs ?? DEFAULT_UPLOAD_TIMEOUT_MS;
+  }
+  doFetch(input, init) {
+    const f = this.fetchImpl;
+    return f ? f(input, init) : globalThis.fetch(input, init);
+  }
+  /** Catalog and schema lookups are advisory; fail fast so a slow catalog cannot stall a command. */
+  catalogTimeoutMs() {
+    return Math.min(this.timeoutMs, CATALOG_TIMEOUT_MS);
+  }
+  authHeaders() {
+    return { Authorization: `Bearer ${this.apiKey}`, Accept: "application/json" };
+  }
+  /** Submit a generation job. `body` holds `model` plus the model's own fields, flattened. */
+  async submit(kind, body) {
+    const path52 = SUBMIT_PATHS[kind];
+    if (!path52) throw new ValidationError(`Unknown Atlas Cloud media type: ${String(kind)}`);
+    if (typeof body.model !== "string" || !body.model.trim()) {
+      throw new ValidationError("Atlas Cloud request body needs a non-empty `model`");
+    }
+    const env = await fetchJson({
+      url: `${this.baseUrl}${path52}`,
+      method: "POST",
+      headers: this.authHeaders(),
+      body,
+      timeoutMs: this.timeoutMs,
+      fetch: this.fetchImpl
+    });
+    const data = envelopeData(env, "submit");
+    if (typeof data.id !== "string" || !data.id) {
+      throw new ProviderError("Atlas Cloud submit returned no prediction id", ATLAS_PROVIDER);
+    }
+    return data;
+  }
+  /** Fetch a prediction once. A failed task reported as HTTP 5xx is returned, not thrown. */
+  async getPrediction(id, timeoutMs) {
+    assertValidPredictionId(id);
+    try {
+      const env = await fetchJson({
+        url: `${this.baseUrl}/model/prediction/${id}`,
+        headers: this.authHeaders(),
+        timeoutMs: timeoutMs ?? this.timeoutMs,
+        fetch: this.fetchImpl
+      });
+      const data = envelopeData(env, "prediction");
+      return { ...data, id: data.id || id };
+    } catch (error) {
+      const terminal = terminalPredictionFromError(error, id);
+      if (terminal) return terminal;
+      throw error;
+    }
+  }
+  /**
+   * Poll until the prediction is terminal (success or failure) or the deadline
+   * passes. Network errors, 429 (honouring Retry-After) and 5xx are retried.
+   * Throws PollTimeoutError on timeout; returns the terminal prediction otherwise.
+   */
+  async waitForPrediction(id, opts) {
+    assertValidPredictionId(id);
+    return pollUntil({
+      // Cap each request at the time left so one hung poll cannot overrun the deadline.
+      fetchStatus: ({ remainingMs }) => this.getPrediction(id, Math.ceil(Math.max(1e3, Math.min(this.timeoutMs, remainingMs)))),
+      isTerminal: (p) => isTerminalStatus(p.status),
+      timeoutMs: opts.timeoutMs,
+      intervalMs: opts.intervalMs ?? 3e3,
+      maxIntervalMs: opts.maxIntervalMs ?? 15e3,
+      isTransientError: isTransientHttpError,
+      onPoll: opts.onPoll,
+      resumeHint: opts.resumeHint,
+      sleep: opts.sleep,
+      now: opts.now
+    });
+  }
+  /**
+   * Upload bytes and return a temporary URL usable as model input.
+   * The filename extension matters: Atlas and downstream models classify by it.
+   */
+  async uploadMedia(file, filename, mimeType) {
+    if (!filename.trim()) throw new ValidationError("uploadMedia needs a filename");
+    const blob = file instanceof Blob ? file : new Blob([file], { type: mimeType ?? "application/octet-stream" });
+    const form = new FormData();
+    form.append("file", blob, filename);
+    const url = `${this.baseUrl}/model/uploadMedia`;
+    let response;
+    try {
+      response = await this.doFetch(url, {
+        method: "POST",
+        headers: this.authHeaders(),
+        body: form,
+        signal: AbortSignal.timeout(this.uploadTimeoutMs)
+      });
+    } catch (cause) {
+      throw new HttpError(0, cause instanceof Error ? cause.message : String(cause), url);
+    }
+    if (!response.ok) throw await httpErrorFromResponse(response, url);
+    const json = await response.json();
+    const data = json.data ?? {};
+    const fileUrl = [data.download_url, data.url, json.url].find(
+      (v) => typeof v === "string" && /^https?:\/\//i.test(v)
+    );
+    if (!fileUrl) {
+      throw new ProviderError(
+        `Atlas Cloud upload returned no URL (code ${json.code ?? "?"}: ${json.msg ?? json.message ?? "no message"})`,
+        ATLAS_PROVIDER
+      );
+    }
+    return {
+      url: fileUrl,
+      filename: typeof data.filename === "string" ? data.filename : void 0,
+      size: typeof data.size === "number" ? data.size : void 0,
+      type: typeof data.type === "string" ? data.type : void 0
+    };
+  }
+  /** Public model catalog, fetched once per client. */
+  listModels() {
+    this.catalog ??= fetchJson({
+      url: `${this.baseUrl}/models`,
+      timeoutMs: this.catalogTimeoutMs(),
+      fetch: this.fetchImpl
+    }).then((env) => {
+      const data = envelopeData(env, "model catalog");
+      if (!Array.isArray(data)) {
+        throw new ProviderError("Atlas Cloud model catalog is not a list", ATLAS_PROVIDER);
+      }
+      return data.filter((m) => m && typeof m.model === "string");
+    }).catch((error) => {
+      this.catalog = void 0;
+      throw error;
+    });
+    return this.catalog;
+  }
+  /** Exact (case-sensitive) catalog lookup; model ids are never rewritten. */
+  async findModel(model) {
+    return (await this.listModels()).find((m) => m.model === model);
+  }
+  /**
+   * Load the model's published request schema and submit endpoint.
+   * Returns undefined when the model is not in the public catalog or publishes no schema.
+   */
+  async getModelSpec(model) {
+    const entry = await this.findModel(model);
+    if (!entry?.schema || !/^https:\/\//i.test(entry.schema)) return void 0;
+    const doc = await fetchJson({
+      url: entry.schema,
+      timeoutMs: this.catalogTimeoutMs(),
+      fetch: this.fetchImpl
+    });
+    return parseModelSpec(model, doc);
+  }
+};
+
+// src/providers/atlascloud/upload-mime.ts
+var UPLOAD_MIME_TYPES = {
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  webp: "image/webp",
+  gif: "image/gif",
+  bmp: "image/bmp",
+  avif: "image/avif",
+  heic: "image/heic",
+  mp4: "video/mp4",
+  mov: "video/quicktime",
+  webm: "video/webm",
+  mkv: "video/x-matroska",
+  avi: "video/x-msvideo",
+  mp3: "audio/mpeg",
+  wav: "audio/wav",
+  m4a: "audio/mp4",
+  aac: "audio/aac",
+  ogg: "audio/ogg",
+  flac: "audio/flac",
+  opus: "audio/opus"
+};
+var UPLOAD_EXTENSIONS = Object.keys(UPLOAD_MIME_TYPES);
+function uploadMimeTypeFor(filename) {
+  const ext = /\.([a-z0-9]+)$/i.exec(filename)?.[1]?.toLowerCase() ?? "";
+  return UPLOAD_MIME_TYPES[ext];
+}
+
+// src/providers/atlascloud/commands/env.ts
+var ATLAS_KEY_URL = "https://www.atlascloud.ai/console/api-keys";
+var MODEL_ENV = {
+  image: "ATLASCLOUD_IMAGE_MODEL",
+  imageEdit: "ATLASCLOUD_IMAGE_EDIT_MODEL",
+  video: "ATLASCLOUD_VIDEO_MODEL",
+  imageToVideo: "ATLASCLOUD_IMAGE_TO_VIDEO_MODEL",
+  tts: "ATLASCLOUD_TTS_MODEL",
+  stt: "ATLASCLOUD_STT_MODEL",
+  textTo3d: "ATLASCLOUD_TEXT_TO_3D_MODEL",
+  imageTo3d: "ATLASCLOUD_IMAGE_TO_3D_MODEL"
+};
+function atlasDefaultModel(key) {
+  return resolveKey(MODEL_ENV[key])?.trim() || ATLAS_DEFAULT_MODELS[key];
+}
+function createAtlasClientFromEnv() {
+  const apiKey = resolveKey("ATLASCLOUD_API_KEY")?.trim();
+  if (!apiKey) {
+    throw new ConfigError(`ATLASCLOUD_API_KEY is not set. Get one at ${ATLAS_KEY_URL}`);
+  }
+  return new AtlasCloudClient({ apiKey, baseUrl: resolveKey("ATLASCLOUD_BASE_URL") });
+}
+async function resolveMediaRef(client, ref, logger) {
+  const trimmed = ref.trim();
+  if (/^https?:\/\//i.test(trimmed) || /^data:/i.test(trimmed)) return trimmed;
+  const abs = path2.resolve(trimmed);
+  const name = path2.basename(abs);
+  const mime = uploadMimeTypeFor(name);
+  if (!mime) {
+    throw new ValidationError(
+      `Refusing to upload ${trimmed}: not a supported media file. Allowed extensions: ${UPLOAD_EXTENSIONS.join(", ")}`
+    );
+  }
+  let stat;
+  try {
+    stat = await fs2.stat(abs);
+  } catch {
+    throw new ValidationError(`Reference file not found: ${trimmed}`);
+  }
+  if (!stat.isFile()) throw new ValidationError(`Reference is not a file: ${trimmed}`);
+  if (stat.size === 0) throw new ValidationError(`Reference file is empty: ${trimmed}`);
+  const maxBytes = maxUploadBytes();
+  if (stat.size > maxBytes) {
+    throw new ValidationError(
+      `${trimmed} is ${formatMb(stat.size)}, above the ${formatMb(maxBytes)} upload limit (set ${MAX_UPLOAD_ENV} to change it)`
+    );
+  }
+  logger.info(`Uploading ${name} (${Math.ceil(stat.size / 1024)} KB) to Atlas Cloud...`);
+  const blob = await openAsBlob(abs, { type: mime });
+  const uploaded = await client.uploadMedia(blob, name, mime);
+  logger.debug(`Uploaded ${name} -> ${redactUrl(uploaded.url)}`);
+  return uploaded.url;
+}
+var MAX_UPLOAD_ENV = "ATLASCLOUD_MAX_UPLOAD_MB";
+var DEFAULT_MAX_UPLOAD_MB = 200;
+function maxUploadBytes() {
+  const raw = resolveKey(MAX_UPLOAD_ENV)?.trim();
+  if (!raw) return DEFAULT_MAX_UPLOAD_MB * 1024 * 1024;
+  const mb = Number(raw);
+  if (!Number.isFinite(mb) || mb <= 0) {
+    throw new ConfigError(`${MAX_UPLOAD_ENV} must be a positive number of megabytes, got "${raw}"`);
+  }
+  return Math.floor(mb * 1024 * 1024);
+}
+function formatMb(bytes) {
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+function createAtlasLogger(opts) {
+  const verbose = opts.verbose ?? false;
+  const base = createLogger({ verbose });
+  if (!opts.stdoutReserved) return base;
+  return {
+    ...base,
+    info: (msg) => console.error(`  ${msg}`),
+    success: (msg) => console.error(`\u2713 ${msg}`),
+    debug: (msg) => {
+      if (verbose) console.error(`  [debug] ${msg}`);
+    },
+    header: (msg) => console.error(msg)
+  };
+}
+async function resolveMediaRefs(client, refs, logger) {
+  const urls = [];
+  for (const ref of refs) urls.push(await resolveMediaRef(client, ref, logger));
+  return urls;
+}
+
+// src/providers/atlascloud/commands/prediction-runner.ts
+init_errors();
+import fs8 from "fs";
+import path7 from "path";
+
+// src/core/http-client.ts
+init_errors();
+import { once } from "events";
+import fs3 from "fs";
+import path3 from "path";
+import { pipeline } from "stream/promises";
+async function httpJson(opts) {
+  return fetchJson(opts);
+}
+async function downloadFile(url, dest, timeoutMs = DEFAULT_TIMEOUT_MS, headers2) {
+  fs3.mkdirSync(path3.dirname(dest), { recursive: true });
+  let response;
+  try {
+    response = await globalThis.fetch(url, {
+      signal: AbortSignal.timeout(timeoutMs),
+      ...headers2 ? { headers: headers2 } : {}
+    });
+  } catch (cause) {
+    const msg = cause instanceof Error ? cause.message : String(cause);
+    throw new HttpError(0, msg, url);
+  }
+  if (!response.ok) {
+    throw new HttpError(response.status, "(download failed)", url);
+  }
+  if (!response.body) {
+    throw new HttpError(0, "Response body is null", url);
+  }
+  const fileStream = fs3.createWriteStream(dest);
+  try {
+    await pipeline(response.body, fileStream);
+  } catch (err2) {
+    if (!fileStream.closed) await once(fileStream, "close");
+    throw err2;
+  }
+  return response.headers.get("content-type") ?? void 0;
+}
+async function fetchBytes(urlOrDataUri) {
+  if (urlOrDataUri.startsWith("data:")) {
+    const commaIdx = urlOrDataUri.indexOf(",");
+    if (commaIdx === -1) throw new Error("Malformed data URI: missing comma");
+    const encoded = urlOrDataUri.slice(commaIdx + 1);
+    return Buffer.from(encoded, "base64");
+  }
+  let response;
+  try {
+    response = await globalThis.fetch(urlOrDataUri, {
+      signal: AbortSignal.timeout(DEFAULT_TIMEOUT_MS)
+    });
+  } catch (cause) {
+    const msg = cause instanceof Error ? cause.message : String(cause);
+    throw new HttpError(0, msg, urlOrDataUri);
+  }
+  if (!response.ok) {
+    throw new HttpError(response.status, "(bytes fetch failed)", urlOrDataUri);
+  }
+  return Buffer.from(await response.arrayBuffer());
+}
+
+// src/core/image-webp-finalize.ts
+init_errors();
+import { spawnSync } from "child_process";
+import fs5 from "fs";
+import path4 from "path";
+import { Option } from "commander";
+
+// src/core/image-header.ts
+import fs4 from "fs";
+function sniffImageKind(buf) {
+  if (buf.length >= 8 && buf.readUInt32BE(0) === 2303741511) return "png";
+  if (buf.length >= 3 && buf[0] === 255 && buf[1] === 216 && buf[2] === 255) return "jpeg";
+  if (buf.length >= 12 && buf.toString("ascii", 0, 4) === "RIFF" && buf.toString("ascii", 8, 12) === "WEBP")
+    return "webp";
+  return void 0;
+}
+function readPng(buf) {
+  if (buf.length < 33) return void 0;
+  const width = buf.readUInt32BE(16);
+  const height = buf.readUInt32BE(20);
+  const colorType = buf[25];
+  let hasAlpha = colorType === 4 || colorType === 6;
+  let offset = 8;
+  while (!hasAlpha && offset + 8 <= buf.length) {
+    const len = buf.readUInt32BE(offset);
+    const type = buf.toString("ascii", offset + 4, offset + 8);
+    if (type === "tRNS") hasAlpha = true;
+    if (type === "IDAT" || type === "IEND") break;
+    offset += 12 + len;
+  }
+  return { kind: "png", width, height, hasAlpha };
+}
+function readJpeg(buf) {
+  let offset = 2;
+  while (offset + 9 < buf.length) {
+    if (buf[offset] !== 255) {
+      offset++;
+      continue;
+    }
+    const marker = buf[offset + 1] ?? 0;
+    if (marker >= 192 && marker <= 207 && ![196, 200, 204].includes(marker)) {
+      return {
+        kind: "jpeg",
+        height: buf.readUInt16BE(offset + 5),
+        width: buf.readUInt16BE(offset + 7),
+        hasAlpha: false
+      };
+    }
+    if (marker === 216 || marker === 1 || marker >= 208 && marker <= 215) {
+      offset += 2;
+      continue;
+    }
+    offset += 2 + buf.readUInt16BE(offset + 2);
+  }
+  return void 0;
+}
+function readWebp(buf) {
+  if (buf.length < 30) return void 0;
+  const chunk = buf.toString("ascii", 12, 16);
+  if (chunk === "VP8X") {
+    const flags = buf[20] ?? 0;
+    return {
+      kind: "webp",
+      width: 1 + buf.readUIntLE(24, 3),
+      height: 1 + buf.readUIntLE(27, 3),
+      hasAlpha: (flags & 16) !== 0
+    };
+  }
+  if (chunk === "VP8L") {
+    const bits = buf.readUInt32LE(21);
+    return {
+      kind: "webp",
+      width: 1 + (bits & 16383),
+      height: 1 + (bits >>> 14 & 16383),
+      hasAlpha: (bits >>> 28 & 1) === 1
+    };
+  }
+  if (chunk === "VP8 ") {
+    return {
+      kind: "webp",
+      width: buf.readUInt16LE(26) & 16383,
+      height: buf.readUInt16LE(28) & 16383,
+      hasAlpha: false
+    };
+  }
+  return void 0;
+}
+function readImageHeader(buf) {
+  const kind = sniffImageKind(buf);
+  if (kind === "png") return readPng(buf);
+  if (kind === "jpeg") return readJpeg(buf);
+  if (kind === "webp") return readWebp(buf);
+  return void 0;
+}
+function readImageHeaderFromFile(file) {
+  return readImageHeader(fs4.readFileSync(file));
+}
+
+// src/core/image-webp-finalize.ts
+var CWEBP_ARGS = ["-q", "85", "-m", "6", "-metadata", "none"];
+var IMAGE_EXTS = /* @__PURE__ */ new Set([".png", ".jpg", ".jpeg", ".webp", ".gif", ".bmp", ".tif", ".tiff"]);
+function imageFormatOption() {
+  return new Option(
+    "--image-format <mode>",
+    "Final image format: webp (default, cwebp -q 85) | original (keep provider format/quality)"
+  );
+}
+function noWebpOption() {
+  return new Option("--no-webp", "Keep the provider's original image format and quality");
+}
+function resolveImageFormatMode(opts, explicitProviderFormat = false) {
+  if (opts.webp === false && opts.imageFormat === void 0) return "original";
+  const raw = opts.imageFormat ?? process.env.MULTIX_IMAGE_FORMAT;
+  if (raw !== void 0 && raw !== "") {
+    const mode = raw.toLowerCase();
+    if (mode !== "webp" && mode !== "original") {
+      throw new ValidationError(`Invalid --image-format: ${raw}. Valid: webp, original`);
+    }
+    return mode;
+  }
+  if (explicitProviderFormat) return "original";
+  const ext = opts.output ? path4.extname(opts.output).toLowerCase() : "";
+  if (ext && ext !== ".webp" && IMAGE_EXTS.has(ext)) return "original";
+  return "webp";
+}
+function hasCwebp() {
+  const res = spawnSync("cwebp", ["-version"], { stdio: "ignore" });
+  return !res.error && res.status === 0;
+}
+function webpTarget(file) {
+  const ext = path4.extname(file);
+  return ext.toLowerCase() === ".webp" ? file : `${file.slice(0, -ext.length || void 0)}.webp`;
+}
+function convertToWebp(file, logger, keepPath = false) {
+  const src = readImageHeaderFromFile(file);
+  if (!src) {
+    logger?.warn(`Skipping WebP conversion (unrecognized image): ${file}`);
+    return file;
+  }
+  if (src.kind === "webp") {
+    const target2 = keepPath ? file : webpTarget(file);
+    if (target2 !== file) fs5.renameSync(file, target2);
+    return target2;
+  }
+  const target = keepPath ? file : webpTarget(file);
+  const tmp = `${target}.tmp-${process.pid}.webp`;
+  const res = spawnSync("cwebp", [...CWEBP_ARGS, file, "-o", tmp], { encoding: "utf8" });
+  if (res.error || res.status !== 0) {
+    fs5.rmSync(tmp, { force: true });
+    logger?.warn(`cwebp failed, keeping original ${file}: ${res.stderr || res.error?.message}`);
+    return file;
+  }
+  const out = fs5.existsSync(tmp) ? readImageHeaderFromFile(tmp) : void 0;
+  const problem = !out ? "output is not a valid WebP" : out.width !== src.width || out.height !== src.height ? `size changed ${src.width}x${src.height} -> ${out.width}x${out.height}` : src.hasAlpha && !out.hasAlpha ? "transparency lost" : void 0;
+  if (problem) {
+    fs5.rmSync(tmp, { force: true });
+    logger?.warn(`WebP verification failed (${problem}), keeping original ${file}`);
+    return file;
+  }
+  if (target !== file) fs5.rmSync(file, { force: true });
+  fs5.renameSync(tmp, target);
+  logger?.debug(`WebP verified ${out?.width}x${out?.height} alpha=${out?.hasAlpha}: ${target}`);
+  return target;
+}
+function finalizeGeneratedImages(files, opts) {
+  const mode = resolveImageFormatMode(opts, opts.explicitProviderFormat);
+  if (mode === "original" || files.length === 0) return files;
+  if (!hasCwebp()) {
+    opts.logger?.warn(
+      "cwebp not found on PATH; keeping original image format (install libwebp, or pass --image-format original)"
+    );
+    return files;
+  }
+  const outputAbs = opts.output ? path4.resolve(opts.output) : void 0;
+  const wroteOutputDirectly = outputAbs !== void 0 && files.some((f) => path4.resolve(f) === outputAbs);
+  const finals = files.map(
+    (f) => convertToWebp(f, opts.logger, outputAbs !== void 0 && path4.resolve(f) === outputAbs)
+  );
+  if (opts.output && outputAbs && !wroteOutputDirectly && finals[0] && fs5.existsSync(outputAbs)) {
+    const outExt = path4.extname(outputAbs).toLowerCase();
+    if ((outExt === ".webp" || outExt === "") && path4.extname(finals[0]).toLowerCase() === ".webp") {
+      fs5.copyFileSync(finals[0], outputAbs);
+    }
+  }
+  return finals;
+}
+
+// src/core/output-dir.ts
+import fs6 from "fs";
+import path5 from "path";
+var cachedOutputDir;
+function getOutputDir() {
+  if (cachedOutputDir) return cachedOutputDir;
+  const dir = process.env.MULTIX_OUTPUT_DIR ? path5.resolve(process.env.MULTIX_OUTPUT_DIR) : path5.resolve(process.cwd(), "multix-output");
+  fs6.mkdirSync(dir, { recursive: true });
+  cachedOutputDir = dir;
+  return dir;
+}
+
+// src/providers/atlascloud/commands/prediction-runner.ts
+init_redact();
+
+// src/core/video-thumb.ts
+import fs7 from "fs";
+import path6 from "path";
+var THUMB_KEYS = /* @__PURE__ */ new Set([
+  "cover_image_url",
+  "coverImageUrl",
+  "cover_url",
+  "coverUrl",
+  "thumbnail_url",
+  "thumbnailUrl",
+  "thumb_url",
+  "thumbUrl",
+  "preview_url",
+  "previewUrl",
+  "first_frame_url",
+  "firstFrameUrl",
+  "poster_url",
+  "posterUrl",
+  "image_url",
+  "imageUrl"
+]);
+var IMAGE_EXT_RE = /\.(jpe?g|png|webp|gif|bmp)(\?|$)/i;
+function isImageUrl(value) {
+  if (typeof value !== "string") return false;
+  if (!/^https?:\/\//i.test(value)) return false;
+  return IMAGE_EXT_RE.test(value);
+}
+function detectThumbUrl(obj) {
+  if (obj === null || obj === void 0) return null;
+  if (Array.isArray(obj)) {
+    for (const item of obj) {
+      const found = detectThumbUrl(item);
+      if (found) return found;
+    }
+    return null;
+  }
+  if (typeof obj !== "object") return null;
+  const record = obj;
+  for (const [key, value] of Object.entries(record)) {
+    if (THUMB_KEYS.has(key) && isImageUrl(value)) return value;
+  }
+  for (const value of Object.values(record)) {
+    if (value && typeof value === "object") {
+      const found = detectThumbUrl(value);
+      if (found) return found;
+    }
+  }
+  return null;
+}
+async function downloadThumbBeside(thumbUrl, videoPath, logger) {
+  const match = thumbUrl.match(IMAGE_EXT_RE);
+  const ext = match?.[1] ? match[1].toLowerCase().replace("jpeg", "jpg") : "jpg";
+  const dir = path6.dirname(videoPath);
+  const base = path6.basename(videoPath, path6.extname(videoPath));
+  const dest = path6.join(dir, `${base}_thumb.${ext}`);
+  try {
+    await downloadFile(thumbUrl, dest);
+    logger?.success(`Saved thumb ${dest}`);
+    return dest;
+  } catch (e) {
+    logger?.warn(`Thumb download failed: ${e instanceof Error ? e.message : String(e)}`);
+    return null;
+  }
+}
+async function maybeDownloadThumb(source, videoPath, opts = {}) {
+  if (opts.skip) return null;
+  const url = detectThumbUrl(source);
+  if (!url) {
+    opts.logger?.debug("No thumbnail URL detected in provider response");
+    return null;
+  }
+  const saved = await downloadThumbBeside(url, videoPath, opts.logger);
+  if (saved && opts.copyTo) {
+    const copyExt = path6.extname(saved);
+    const copyBase = path6.basename(opts.copyTo, path6.extname(opts.copyTo));
+    const copyDir = path6.dirname(path6.resolve(opts.copyTo));
+    const copyDest = path6.join(copyDir, `${copyBase}_thumb${copyExt}`);
+    fs7.mkdirSync(copyDir, { recursive: true });
+    fs7.copyFileSync(saved, copyDest);
+    opts.logger?.success(`Copied thumb to ${copyDest}`);
+  }
+  return saved;
+}
+
+// src/providers/atlascloud/commands/prediction-runner.ts
+function addRunOptions(cmd, cfg) {
+  cmd.option("--async", "Submit and exit; print the prediction id (resume with `atlas status`)").option("--wait-timeout <ms>", "Max time to wait for completion", String(cfg.waitTimeoutMs)).option("--output <path>", "Output file (single output) or directory (path without extension)").option("--no-download", "Do not download media; print output URLs instead").option("--no-validate", "Skip client-side validation against the model's published schema");
+  if (cfg.images) cmd.addOption(imageFormatOption()).addOption(noWebpOption());
+  if (cfg.video) cmd.option("--no-thumb", "Skip downloading the video thumbnail if present");
+  return cmd.option("-v, --verbose", "Verbose logging");
+}
+function addRefOption(cmd, description) {
+  return cmd.option(
+    "--ref <pathOrUrl>",
+    `${description} (repeat --ref for several)`,
+    (value, prev) => [...prev, value],
+    []
+  );
+}
+function requireRefs(refs) {
+  if (!refs || refs.length === 0) {
+    throw new ValidationError("Missing required option --ref <pathOrUrl>");
+  }
+  return refs;
+}
+function parseTimeoutMs(raw, fallback) {
+  if (raw === void 0) return fallback;
+  const n = Number(raw);
+  if (!Number.isInteger(n) || n <= 0) {
+    throw new ValidationError(`--wait-timeout must be a positive integer (ms), got "${raw}"`);
+  }
+  return n;
+}
+var KIND_COMMAND = {
+  image: "image",
+  video: "video",
+  audio: "audio"
+};
+async function loadModelSpec(client, model, logger, validate) {
+  if (validate === false) return void 0;
+  try {
+    const spec = await client.getModelSpec(model);
+    if (!spec) {
+      logger.warn(
+        `Model ${model} is not in the Atlas Cloud public catalog or has no published schema; sending without validation.`
+      );
+    }
+    return spec;
+  } catch (e) {
+    logger.warn(
+      `Could not load the schema for ${model} (${e instanceof Error ? e.message : String(e)}); sending without validation.`
+    );
+    return void 0;
+  }
+}
+function assertEndpoint(spec, expected, model) {
+  if (!spec?.endpoint || spec.endpoint === expected) return;
+  throw new ValidationError(
+    `Model ${model} is a ${spec.endpoint} model (served by generate${capitalize(spec.endpoint)}), not ${expected}. Use \`multix atlas ${KIND_COMMAND[spec.endpoint]} ...\` or \`multix atlas run ${model} --type ${spec.endpoint} --input '{...}'\`.`
+  );
+}
+function capitalize(s) {
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}
+function resumeCommand(id) {
+  return `multix atlas status ${id} --wait --download`;
+}
+async function executePrediction(o) {
+  const { client, logger, opts } = o;
+  const timeoutMs = parseTimeoutMs(opts.waitTimeout, o.defaultWaitTimeoutMs);
+  logger.info(`Submitting to ${o.model} (generate${capitalize(o.kind)})...`);
+  const submitted = await client.submit(o.kind, { ...o.body, model: o.model });
+  const id = submitted.id;
+  if (opts.async) {
+    console.log(id);
+    console.error(`Prediction submitted. Resume with: ${resumeCommand(id)}`);
+    return { predictionId: id, files: [], texts: [] };
+  }
+  logger.info(`Prediction ${id} \u2014 waiting up to ${Math.round(timeoutMs / 1e3)}s...`);
+  const final = isTerminalStatus(submitted.status) ? submitted : await client.waitForPrediction(id, {
+    timeoutMs,
+    intervalMs: o.pollIntervalMs,
+    resumeHint: `Resume with: ${resumeCommand(id)}`,
+    onPoll: (p, n) => logger.debug(`poll ${n}: ${p.status}`)
+  });
+  assertPredictionSucceeded(final);
+  const delivered = await deliverPrediction(final, { logger, opts, hint: o.hint });
+  return { predictionId: id, prediction: final, ...delivered };
+}
+function isDirectoryOutput(output) {
+  return /[\\/]$/.test(output) || path7.extname(output) === "" || fs8.existsSync(output) && fs8.statSync(output).isDirectory();
+}
+function planOutputPaths(urls, cfg) {
+  const exts = urls.map((u) => {
+    const cat = outputCategory(u);
+    return outputExtension(u) ?? defaultExtensionFor(cat !== "unknown" ? cat : cfg.hint ?? "unknown");
+  });
+  const output = cfg.output;
+  if (!output || isDirectoryOutput(output)) {
+    const dir = output ? path7.resolve(output) : cfg.outDir();
+    return exts.map((ext, i) => path7.join(dir, outputFileName(cfg.predictionId, i, ext)));
+  }
+  const abs = path7.resolve(output);
+  if (urls.length === 1) return [abs];
+  const base = abs.slice(0, -path7.extname(abs).length);
+  return exts.map((ext, i) => `${base}-${String(i + 1).padStart(2, "0")}.${ext}`);
+}
+async function deliverPrediction(prediction2, cfg) {
+  const { logger, opts } = cfg;
+  if (prediction2.price !== void 0 && prediction2.price !== "") {
+    logger.info(`Cost: $${prediction2.price}`);
+  }
+  const classified = classifyOutputs(prediction2);
+  if (classified.mode === "empty") {
+    throw new ProviderError(
+      hasNsfwFlag(prediction2) ? `Prediction ${prediction2.id} returned no output: blocked by content safety (has_nsfw_contents). Try a different prompt or input.` : `Prediction ${prediction2.id} completed but returned no outputs.`,
+      ATLAS_PROVIDER
+    );
+  }
+  for (const text of classified.texts) console.log(text);
+  if (classified.mode === "text") {
+    if (opts.output) {
+      const dest = isDirectoryOutput(opts.output) ? path7.resolve(opts.output, outputFileName(prediction2.id, 0, "txt")) : path7.resolve(opts.output);
+      fs8.mkdirSync(path7.dirname(dest), { recursive: true });
+      fs8.writeFileSync(dest, `${classified.texts.join("\n\n")}
+`, "utf8");
+      logger.success(`Saved text output to ${dest}`);
+      return { files: [dest], texts: classified.texts };
+    }
+    return { files: [], texts: classified.texts };
+  }
+  if (opts.download === false) {
+    for (const u of classified.urls) console.log(u);
+    return { files: [], texts: classified.texts };
+  }
+  const dests = planOutputPaths(classified.urls, {
+    predictionId: prediction2.id,
+    outDir: getOutputDir,
+    output: opts.output,
+    hint: cfg.hint
+  });
+  const explicitFile = classified.urls.length === 1 && opts.output !== void 0 && !isDirectoryOutput(opts.output);
+  const saved = [];
+  let failed = 0;
+  for (let i = 0; i < classified.urls.length; i++) {
+    const url = classified.urls[i];
+    const planned = dests[i];
+    const part = `${planned}.part`;
+    try {
+      const contentType = await downloadFile(url, part);
+      const dest = explicitFile || outputExtension(url) ? planned : withContentTypeExtension(planned, contentType);
+      fs8.renameSync(part, dest);
+      saved.push(dest);
+      logger.debug(`Downloaded ${redactUrl(url)} -> ${dest}`);
+    } catch (e) {
+      fs8.rmSync(part, { force: true });
+      failed++;
+      logger.warn(
+        `Download failed (${redactUrl(url)}): ${e instanceof Error ? e.message : String(e)}`
+      );
+    }
+  }
+  if (saved.length === 0) {
+    throw new ProviderError(
+      `Prediction ${prediction2.id} produced ${classified.urls.length} output(s) but none downloaded. Retry with: ${resumeCommand(prediction2.id)}`,
+      ATLAS_PROVIDER
+    );
+  }
+  const images = saved.filter((f) => outputCategory(f) === "image");
+  const fileOutput = opts.output && !isDirectoryOutput(opts.output) ? opts.output : void 0;
+  const finalImages = finalizeGeneratedImages(images, {
+    imageFormat: opts.imageFormat,
+    webp: opts.webp,
+    output: fileOutput,
+    logger
+  });
+  const files = saved.map((f) => finalImages[images.indexOf(f)] ?? f);
+  const firstVideo = files.find((f) => outputCategory(f) === "video");
+  if (firstVideo) {
+    await maybeDownloadThumb(prediction2, firstVideo, { skip: opts.thumb === false, logger });
+  }
+  console.log(`
+Prediction ${prediction2.id}: saved ${files.length} file(s)`);
+  for (const f of files) console.log(`  ${f}`);
+  if (failed > 0) {
+    throw new ProviderError(
+      `Prediction ${prediction2.id}: downloaded ${saved.length} of ${classified.urls.length} output(s); ${failed} failed. Saved: ${files.join(", ")}. Retry with: ${resumeCommand(prediction2.id)}`,
+      ATLAS_PROVIDER
+    );
+  }
+  return { files, texts: classified.texts };
+}
+function withContentTypeExtension(planned, contentType) {
+  const ext = extensionForContentType(contentType);
+  if (!ext) return planned;
+  const current = path7.extname(planned);
+  return `${current ? planned.slice(0, -current.length) : planned}.${ext}`;
+}
+
+// src/providers/atlascloud/commands/generation-command.ts
+async function runGenerationCommand(cfg) {
+  const logger = createAtlasLogger({
+    verbose: cfg.opts.verbose,
+    stdoutReserved: cfg.opts.async
+  });
+  const client = createAtlasClientFromEnv();
+  const spec = await loadModelSpec(client, cfg.model, logger, cfg.opts.validate);
+  const kind = cfg.endpointFromSchema ? spec?.endpoint ?? cfg.kind : cfg.kind;
+  assertEndpoint(spec, kind, cfg.model);
+  const refs = cfg.refs ?? [];
+  buildModelInput(spec, cfg.requests(refs));
+  const refUrls = refs.length > 0 ? await resolveMediaRefs(client, refs, logger) : [];
+  const body = buildModelInput(spec, cfg.requests(refUrls));
+  logger.debug(`Request fields: ${Object.keys(body).join(", ")}`);
+  await executePrediction({
+    client,
+    logger,
+    kind,
+    model: cfg.model,
+    body,
+    opts: cfg.opts,
+    hint: cfg.hint,
+    defaultWaitTimeoutMs: cfg.defaultWaitTimeoutMs,
+    pollIntervalMs: cfg.pollIntervalMs
+  });
+}
+
+// src/providers/atlascloud/commands/audio.ts
+var AUDIO_WAIT_MS = 6e5;
+var AUDIO_POLL_MS = 3e3;
+function registerAtlasAudioCommand(parent) {
+  const audio = parent.command("audio [text]").description(
+    `Speech, music, lyrics or transcription via Atlas Cloud (default TTS: ${ATLAS_DEFAULT_MODELS.tts}; with --audio, STT: ${ATLAS_DEFAULT_MODELS.stt})`
+  ).option(
+    "-m, --model <id>",
+    "Atlas Cloud audio model id (env: ATLASCLOUD_TTS_MODEL / ATLASCLOUD_STT_MODEL)"
+  ).option("--audio <pathOrUrl>", "Input audio for speech-to-text (local files are uploaded)").option("--voice <id>", "Voice id (model-dependent)").option("--format <fmt>", "Output audio format, e.g. mp3, wav (model-dependent)").option("--language <code>", "Language (model-dependent)");
+  addRunOptions(audio, { waitTimeoutMs: AUDIO_WAIT_MS }).action(
+    async (text, opts) => {
+      if (!text && !opts.audio) {
+        throw new ValidationError(
+          "Provide text to synthesize, or --audio <pathOrUrl> to transcribe"
+        );
+      }
+      const model = opts.model ?? atlasDefaultModel(opts.audio ? "stt" : "tts");
+      await runGenerationCommand({
+        model,
+        kind: "audio",
+        refs: opts.audio ? [opts.audio] : [],
+        requests: (refs) => [
+          { flag: "[text]", value: text, candidates: FIELD_CANDIDATES.speechText },
+          { flag: "--audio", value: refs[0], candidates: FIELD_CANDIDATES.audioInput },
+          { flag: "--voice", value: opts.voice, candidates: FIELD_CANDIDATES.voice },
+          { flag: "--format", value: opts.format, candidates: FIELD_CANDIDATES.audioFormat },
+          { flag: "--language", value: opts.language, candidates: FIELD_CANDIDATES.language }
+        ],
+        opts,
+        hint: "audio",
+        defaultWaitTimeoutMs: AUDIO_WAIT_MS,
+        pollIntervalMs: AUDIO_POLL_MS
+      });
+    }
+  );
+}
+
+// src/providers/atlascloud/commands/image.ts
+var IMAGE_WAIT_MS = 3e5;
+var IMAGE_POLL_MS = 2e3;
+function imageRequests(prompt, o) {
+  return [
+    { flag: "--prompt", value: prompt, candidates: FIELD_CANDIDATES.prompt },
+    { flag: "--size", value: o.size, candidates: FIELD_CANDIDATES.size },
+    { flag: "--aspect-ratio", value: o.aspectRatio, candidates: FIELD_CANDIDATES.aspectRatio },
+    { flag: "--resolution", value: o.resolution, candidates: FIELD_CANDIDATES.resolution },
+    { flag: "--num-images", value: o.numImages, candidates: FIELD_CANDIDATES.numImages },
+    { flag: "--seed", value: o.seed, candidates: FIELD_CANDIDATES.seed },
+    { flag: "--negative-prompt", value: o.negativePrompt, candidates: FIELD_CANDIDATES.negativePrompt }
+  ];
+}
+function addImageFlags(cmd) {
+  return cmd.option("--size <size>", "Output size in the model's format (e.g. 1024*1024 or 1024x1024)").option("--aspect-ratio <ratio>", "Aspect ratio, e.g. 1:1, 16:9 (model-dependent)").option("--resolution <res>", "Resolution tier, e.g. 1k, 2k (model-dependent)").option("-n, --num-images <n>", "Number of images (model-dependent)").option("--seed <n>", "Seed").option("--negative-prompt <text>", "Negative prompt (model-dependent)");
+}
+function registerAtlasImageCommands(parent) {
+  const image = parent.command("image <prompt>").description(`Text-to-image via Atlas Cloud (default: ${ATLAS_DEFAULT_MODELS.image})`).option("-m, --model <id>", "Atlas Cloud image model id (env: ATLASCLOUD_IMAGE_MODEL)");
+  addImageFlags(image);
+  addRunOptions(image, { waitTimeoutMs: IMAGE_WAIT_MS, images: true }).action(
+    async (prompt, opts) => {
+      await runGenerationCommand({
+        model: opts.model ?? atlasDefaultModel("image"),
+        kind: "image",
+        requests: () => imageRequests(prompt, opts),
+        opts,
+        hint: "image",
+        defaultWaitTimeoutMs: IMAGE_WAIT_MS,
+        pollIntervalMs: IMAGE_POLL_MS
+      });
+    }
+  );
+  const edit = parent.command("image-to-image").description(
+    `Edit or restyle reference images via Atlas Cloud (default: ${ATLAS_DEFAULT_MODELS.imageEdit})`
+  ).requiredOption("--prompt <text>", "Edit instruction");
+  addRefOption(edit, "Reference image; local files are uploaded first; required").option(
+    "-m, --model <id>",
+    "Atlas Cloud image-edit model id (env: ATLASCLOUD_IMAGE_EDIT_MODEL)"
+  );
+  addImageFlags(edit);
+  addRunOptions(edit, { waitTimeoutMs: IMAGE_WAIT_MS, images: true }).action(
+    async (opts) => {
+      await runGenerationCommand({
+        model: opts.model ?? atlasDefaultModel("imageEdit"),
+        kind: "image",
+        refs: requireRefs(opts.ref),
+        requests: (refs) => [
+          ...imageRequests(opts.prompt, opts),
+          { flag: "--ref", value: refs, candidates: FIELD_CANDIDATES.editImages }
+        ],
+        opts,
+        hint: "image",
+        defaultWaitTimeoutMs: IMAGE_WAIT_MS,
+        pollIntervalMs: IMAGE_POLL_MS
+      });
+    }
+  );
+}
+
+// src/providers/atlascloud/commands/run.ts
+init_errors();
+
+// src/core/json-input.ts
+init_errors();
+import fs9 from "fs";
+function parseJsonInput(raw, flag = "--input") {
+  let text;
+  if (raw.startsWith("@")) {
+    try {
+      text = fs9.readFileSync(raw.slice(1), "utf8");
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      throw new ValidationError(`Cannot read ${flag} file: ${msg}`);
+    }
+  } else {
+    text = raw;
+  }
+  try {
+    const parsed = JSON.parse(text);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      throw new Error("input must be a JSON object");
+    }
+    return parsed;
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    throw new ValidationError(`Invalid ${flag} JSON: ${msg}`);
+  }
+}
+
+// src/providers/atlascloud/commands/run.ts
+var RUN_WAIT_MS = 6e5;
+function parseMediaKind(raw) {
+  if (raw === void 0) return void 0;
+  const kind = raw.toLowerCase();
+  if (!ATLAS_MEDIA_KINDS.includes(kind)) {
+    throw new ValidationError(`Invalid --type "${raw}". Valid: ${ATLAS_MEDIA_KINDS.join(", ")}`);
+  }
+  return kind;
+}
+function registerAtlasRunCommand(parent) {
+  const run = parent.command("run <modelId>").description("Run any Atlas Cloud model with a raw JSON payload (fields per the model's docs)").requiredOption("--input <json>", "Model input as JSON, or @path/to/input.json").option(
+    "--type <type>",
+    "Endpoint: image | video | audio (default: from the model's published schema; 3D uses image). Required with --no-validate or for models without a schema"
+  );
+  addRunOptions(run, { waitTimeoutMs: RUN_WAIT_MS, images: true, video: true }).action(
+    async (modelId, opts) => {
+      const logger = createAtlasLogger({ verbose: opts.verbose, stdoutReserved: opts.async });
+      const input = parseJsonInput(opts.input);
+      if (input.model !== void 0 && input.model !== modelId) {
+        throw new ValidationError(
+          `--input.model "${String(input.model)}" does not match <modelId> "${modelId}"`
+        );
+      }
+      const explicit = parseMediaKind(opts.type);
+      const client = createAtlasClientFromEnv();
+      const spec = await loadModelSpec(client, modelId, logger, opts.validate);
+      const kind = explicit ?? spec?.endpoint;
+      if (!kind) {
+        throw new ValidationError(
+          `Cannot determine the endpoint for ${modelId}; pass --type ${ATLAS_MEDIA_KINDS.join("|")}`
+        );
+      }
+      assertEndpoint(spec, kind, modelId);
+      if (spec) {
+        const unknown = validateRawInput(spec, input);
+        if (unknown.length > 0) {
+          logger.warn(
+            `Fields not in ${modelId}'s published schema (sent anyway): ${unknown.join(", ")}`
+          );
+        }
+      }
+      await executePrediction({
+        client,
+        logger,
+        kind,
+        model: modelId,
+        body: input,
+        opts,
+        defaultWaitTimeoutMs: RUN_WAIT_MS,
+        pollIntervalMs: kind === "video" ? 5e3 : 3e3
+      });
+    }
+  );
+}
+
+// src/providers/atlascloud/commands/status.ts
+var STATUS_WAIT_MS = 6e5;
+function registerAtlasStatusCommand(parent) {
+  parent.command("status <predictionId>").description("Get an Atlas Cloud prediction; --wait to poll, --download to save outputs").option("--wait", "Poll until the prediction finishes").option("--wait-timeout <ms>", "Max time to wait (with --wait)", String(STATUS_WAIT_MS)).option("--download", "Save outputs when finished (implies --wait)").option("--output <path>", "Output file (single output) or directory (path without extension)").addOption(imageFormatOption()).addOption(noWebpOption()).option("--no-thumb", "Skip downloading the video thumbnail if present").option("-v, --verbose", "Verbose logging").action(async (predictionId, opts) => {
+    const logger = createLogger({ verbose: opts.verbose ?? false });
+    const client = createAtlasClientFromEnv();
+    const wait = Boolean(opts.wait || opts.download);
+    const prediction2 = wait ? await client.waitForPrediction(predictionId, {
+      timeoutMs: parseTimeoutMs(opts.waitTimeout, STATUS_WAIT_MS),
+      resumeHint: `Resume with: ${resumeCommand(predictionId)}`,
+      onPoll: (p, n) => logger.debug(`poll ${n}: ${p.status}`)
+    }) : await client.getPrediction(predictionId);
+    if (!opts.download) {
+      console.log(JSON.stringify(prediction2, null, 2));
+      if (isFailureStatus(prediction2.status)) throw new AtlasPredictionFailedError(prediction2);
+      return;
+    }
+    assertPredictionSucceeded(prediction2);
+    await deliverPrediction(prediction2, { logger, opts: { ...opts, download: true } });
+  });
+}
+
+// src/providers/atlascloud/commands/three-d.ts
+init_errors();
+var THREE_D_WAIT_MS = 9e5;
+var THREE_D_POLL_MS = 5e3;
+function registerAtlas3dCommand(parent) {
+  const cmd = parent.command("3d [prompt]").alias("generate-3d").description(
+    `Text- or image-to-3D via Atlas Cloud (defaults: ${ATLAS_DEFAULT_MODELS.textTo3d}; with --ref ${ATLAS_DEFAULT_MODELS.imageTo3d})`
+  );
+  addRefOption(cmd, "Reference image for image-to-3D (local files are uploaded)").option(
+    "-m, --model <id>",
+    "Atlas Cloud 3D model id (env: ATLASCLOUD_TEXT_TO_3D_MODEL / ATLASCLOUD_IMAGE_TO_3D_MODEL)"
+  ).option("--format <fmt>", "Mesh format, e.g. GLB, OBJ, FBX (model-dependent)").option("--seed <n>", "Seed (model-dependent)");
+  addRunOptions(cmd, { waitTimeoutMs: THREE_D_WAIT_MS }).action(
+    async (prompt, opts) => {
+      const refs = opts.ref ?? [];
+      if (!prompt && refs.length === 0) {
+        throw new ValidationError("Provide a prompt (text-to-3D) or --ref <image> (image-to-3D)");
+      }
+      await runGenerationCommand({
+        model: opts.model ?? atlasDefaultModel(refs.length > 0 ? "imageTo3d" : "textTo3d"),
+        kind: "image",
+        endpointFromSchema: true,
+        refs,
+        requests: (urls) => [
+          { flag: "[prompt]", value: prompt, candidates: FIELD_CANDIDATES.prompt },
+          { flag: "--ref", value: urls, candidates: FIELD_CANDIDATES.primaryImage },
+          { flag: "--format", value: opts.format, candidates: FIELD_CANDIDATES.modelFormat },
+          { flag: "--seed", value: opts.seed, candidates: FIELD_CANDIDATES.seed }
+        ],
+        opts,
+        hint: "3d",
+        defaultWaitTimeoutMs: THREE_D_WAIT_MS,
+        pollIntervalMs: THREE_D_POLL_MS
+      });
+    }
+  );
+}
+
+// src/providers/atlascloud/commands/upload.ts
+function registerAtlasUploadCommand(parent) {
+  parent.command("upload <file>").description("Upload a local file to Atlas Cloud and print its temporary URL").option("-v, --verbose", "Verbose logging").action(async (file, opts) => {
+    const logger = createAtlasLogger({ verbose: opts.verbose, stdoutReserved: true });
+    if (/^(https?|data):/i.test(file.trim())) {
+      logger.warn("Input is already a URL; nothing to upload.");
+      console.log(file.trim());
+      return;
+    }
+    const client = createAtlasClientFromEnv();
+    console.log(await resolveMediaRef(client, file, logger));
+  });
+}
+
+// src/providers/atlascloud/commands/video.ts
+var VIDEO_WAIT_MS = 9e5;
+var VIDEO_POLL_MS = 5e3;
+function videoRequests(prompt, o) {
+  return [
+    { flag: "--prompt", value: prompt, candidates: FIELD_CANDIDATES.prompt },
+    { flag: "--duration", value: o.duration, candidates: FIELD_CANDIDATES.duration },
+    { flag: "--resolution", value: o.resolution, candidates: FIELD_CANDIDATES.resolution },
+    { flag: "--aspect-ratio", value: o.aspectRatio, candidates: FIELD_CANDIDATES.aspectRatio },
+    { flag: "--negative-prompt", value: o.negativePrompt, candidates: FIELD_CANDIDATES.negativePrompt },
+    { flag: "--seed", value: o.seed, candidates: FIELD_CANDIDATES.seed }
+  ];
+}
+function addVideoFlags(cmd) {
+  return cmd.option("--duration <s>", "Duration in seconds (model-dependent values)").option("--resolution <res>", "Resolution, e.g. 480p, 720p, 1080p (model-dependent)").option("--aspect-ratio <ratio>", "Aspect ratio, e.g. 16:9, 9:16 (model-dependent)").option("--negative-prompt <text>", "Negative prompt (model-dependent)").option("--seed <n>", "Seed");
+}
+function registerAtlasVideoCommands(parent) {
+  const video = parent.command("video <prompt>").description(`Text-to-video via Atlas Cloud (default: ${ATLAS_DEFAULT_MODELS.video})`).option("-m, --model <id>", "Atlas Cloud video model id (env: ATLASCLOUD_VIDEO_MODEL)");
+  addVideoFlags(video);
+  addRunOptions(video, { waitTimeoutMs: VIDEO_WAIT_MS, video: true }).action(
+    async (prompt, opts) => {
+      await runGenerationCommand({
+        model: opts.model ?? atlasDefaultModel("video"),
+        kind: "video",
+        requests: () => videoRequests(prompt, opts),
+        opts,
+        hint: "video",
+        defaultWaitTimeoutMs: VIDEO_WAIT_MS,
+        pollIntervalMs: VIDEO_POLL_MS
+      });
+    }
+  );
+  const i2v = parent.command("image-to-video").description(
+    `Animate reference image(s) via Atlas Cloud (default: ${ATLAS_DEFAULT_MODELS.imageToVideo})`
+  ).option("--prompt <text>", "Motion / scene prompt");
+  addRefOption(i2v, "Reference image; local files are uploaded first; required").option(
+    "-m, --model <id>",
+    "Atlas Cloud image-to-video model id (env: ATLASCLOUD_IMAGE_TO_VIDEO_MODEL)"
+  );
+  addVideoFlags(i2v);
+  addRunOptions(i2v, { waitTimeoutMs: VIDEO_WAIT_MS, video: true }).action(
+    async (opts) => {
+      await runGenerationCommand({
+        model: opts.model ?? atlasDefaultModel("imageToVideo"),
+        kind: "video",
+        refs: requireRefs(opts.ref),
+        requests: (refs) => [
+          ...videoRequests(opts.prompt, opts),
+          { flag: "--ref", value: refs, candidates: FIELD_CANDIDATES.primaryImage }
+        ],
+        opts,
+        hint: "video",
+        defaultWaitTimeoutMs: VIDEO_WAIT_MS,
+        pollIntervalMs: VIDEO_POLL_MS
+      });
+    }
+  );
+}
+
+// src/providers/atlascloud/commands/index.ts
+function registerAtlasCloudCommands(program2) {
+  const atlas = program2.command("atlas").alias("atlascloud").description(
+    "Atlas Cloud: image, image-to-image, video, image-to-video, audio (TTS/STT/music), 3D, generic model runner, async status"
+  );
+  registerAtlasImageCommands(atlas);
+  registerAtlasVideoCommands(atlas);
+  registerAtlasAudioCommand(atlas);
+  registerAtlas3dCommand(atlas);
+  registerAtlasRunCommand(atlas);
+  registerAtlasStatusCommand(atlas);
+  registerAtlasUploadCommand(atlas);
+}
+
 // src/providers/byteplus/commands/generate-3d.ts
-import path5 from "path";
+import path9 from "path";
 
 // src/core/image-input.ts
-import fs from "fs/promises";
-import path from "path";
+import fs10 from "fs/promises";
+import path8 from "path";
 var IMAGE_MIME_BY_EXT = {
   ".jpg": "image/jpeg",
   ".jpeg": "image/jpeg",
@@ -131,7 +2042,7 @@ function isHttpUrl(input) {
   return /^https?:\/\//i.test(input);
 }
 async function readAsDataUrl(filePath, mimeTable, kindLabel, opts = {}) {
-  const ext = path.extname(filePath).toLowerCase();
+  const ext = path8.extname(filePath).toLowerCase();
   const mime = mimeTable[ext];
   if (!mime) {
     throw new Error(
@@ -140,7 +2051,7 @@ async function readAsDataUrl(filePath, mimeTable, kindLabel, opts = {}) {
   }
   const hard = opts.hardLimitBytes ?? DEFAULT_HARD_LIMIT_BYTES;
   const soft = opts.softLimitBytes ?? DEFAULT_SOFT_LIMIT_BYTES;
-  const buf = await fs.readFile(filePath);
+  const buf = await fs10.readFile(filePath);
   if (buf.byteLength > hard) {
     throw new Error(
       `${kindLabel} file ${filePath} is ${(buf.byteLength / 1024 / 1024).toFixed(1)}MB \u2014 exceeds ${(hard / 1024 / 1024).toFixed(0)}MB limit. Upload to a URL instead.`
@@ -183,65 +2094,8 @@ function normalizeOpts(opts) {
   return opts;
 }
 
-// src/core/logger.ts
-var ANSI = {
-  reset: "\x1B[0m",
-  bold: "\x1B[1m",
-  green: "\x1B[32m",
-  yellow: "\x1B[33m",
-  red: "\x1B[31m",
-  blue: "\x1B[34m",
-  cyan: "\x1B[36m",
-  dim: "\x1B[2m"
-};
-function c(color, text) {
-  if (process.env.NO_COLOR || !process.stdout.isTTY) return text;
-  return `${color}${text}${ANSI.reset}`;
-}
-function createLogger(opts) {
-  const { verbose } = opts;
-  return {
-    info(msg) {
-      console.log(c(ANSI.blue, `  ${msg}`));
-    },
-    success(msg) {
-      console.log(c(ANSI.green, `\u2713 ${msg}`));
-    },
-    warn(msg) {
-      console.warn(c(ANSI.yellow, `\u26A0 ${msg}`));
-    },
-    error(msg) {
-      console.error(c(ANSI.red, `\u2717 ${msg}`));
-    },
-    debug(msg) {
-      if (verbose) console.log(c(ANSI.dim, `  [debug] ${msg}`));
-    },
-    header(msg) {
-      const line = "=".repeat(60);
-      console.log(c(ANSI.bold + ANSI.cyan, `
-${line}
-${msg}
-${line}
-`));
-    }
-  };
-}
-var defaultLogger = createLogger({ verbose: false });
-
-// src/core/output-dir.ts
-import fs2 from "fs";
-import path2 from "path";
-var cachedOutputDir;
-function getOutputDir() {
-  if (cachedOutputDir) return cachedOutputDir;
-  const dir = process.env.MULTIX_OUTPUT_DIR ? path2.resolve(process.env.MULTIX_OUTPUT_DIR) : path2.resolve(process.cwd(), "multix-output");
-  fs2.mkdirSync(dir, { recursive: true });
-  cachedOutputDir = dir;
-  return dir;
-}
-
 // src/providers/leonardo/poll.ts
-var PollTimeoutError = class extends Error {
+var PollTimeoutError2 = class extends Error {
   constructor() {
     super("Polling timed out before the operation completed.");
     this.name = "PollTimeoutError";
@@ -272,221 +2126,11 @@ async function poll(opts) {
       });
     });
   }
-  throw new PollTimeoutError();
-}
-
-// src/core/env-loader.ts
-init_redact();
-import fs3 from "fs";
-import os from "os";
-import path3 from "path";
-import { config as dotenvConfig, parse as dotenvParse } from "dotenv";
-var loaded = false;
-var loadedFiles = [];
-var LEGACY_SKILL_DIRS = ["ai-multimodal", "ak-ai-multimodal"];
-function legacyFilesUnder(root) {
-  const claude = path3.join(root, ".claude");
-  return [
-    ...LEGACY_SKILL_DIRS.map((dir) => path3.join(claude, "skills", dir, ".env")),
-    path3.join(claude, "skills", ".env"),
-    path3.join(claude, ".env")
-  ];
-}
-function samePath(a, b) {
-  const norm = (p) => {
-    const r = path3.resolve(p);
-    return process.platform === "win32" ? r.toLowerCase() : r;
-  };
-  return norm(a) === norm(b);
-}
-function legacyClaudeEnvFiles(cwd, home) {
-  const files = legacyFilesUnder(cwd);
-  if (home && !samePath(home, cwd)) files.push(...legacyFilesUnder(home));
-  return files;
-}
-function legacyClaudeEnvEnabled(env = process.env) {
-  const value = env.MULTIX_LEGACY_CLAUDE_ENV;
-  return value !== void 0 && ["1", "true", "yes", "on"].includes(value.trim().toLowerCase());
-}
-var LEGACY_ALLOWED_NAME = /^[A-Z][A-Z0-9_]*_(API_KEY(_\d+)?|API_TOKEN|ACCOUNT_ID|GATEWAY_ID)$|^(FAL_KEY|ARK_API_KEY)$/;
-function isLegacyAllowedName(name) {
-  return LEGACY_ALLOWED_NAME.test(name);
-}
-function isReadableFile(file) {
-  try {
-    return fs3.statSync(file).isFile();
-  } catch {
-    return false;
-  }
-}
-function loadFile(file) {
-  if (!isReadableFile(file)) return;
-  const result = dotenvConfig({ path: file, override: false });
-  if (!result.error) loadedFiles.push(file);
-}
-function loadLegacyFile(file) {
-  if (!isReadableFile(file)) return;
-  let parsed;
-  try {
-    parsed = dotenvParse(fs3.readFileSync(file));
-  } catch {
-    return;
-  }
-  for (const [name, value] of Object.entries(parsed)) {
-    if (isLegacyAllowedName(name) && process.env[name] === void 0) process.env[name] = value;
-  }
-  loadedFiles.push(file);
-}
-function loadEnv() {
-  if (loaded) return;
-  loaded = true;
-  loadedFiles = [];
-  const cwd = process.cwd();
-  const home = process.env.MULTIX_DISABLE_HOME_ENV ? void 0 : os.homedir();
-  loadFile(path3.resolve(cwd, ".env"));
-  if (home) loadFile(path3.join(home, ".multix", ".env"));
-  if (legacyClaudeEnvEnabled()) {
-    for (const file of legacyClaudeEnvFiles(cwd, home)) loadLegacyFile(file);
-  }
-}
-function getLoadedEnvFiles() {
-  return [...loadedFiles];
-}
-function resolveKey(name) {
-  return process.env[name] || void 0;
+  throw new PollTimeoutError2();
 }
 
 // src/providers/byteplus/client.ts
-init_errors();
-
-// src/core/http-client.ts
-init_errors();
-import { once } from "events";
-import fs4 from "fs";
-import path4 from "path";
-import { pipeline } from "stream/promises";
-
-// src/core/fetch-json.ts
-init_errors();
-var DEFAULT_TIMEOUT_MS = 12e4;
-var SNIPPET_MAX = 500;
-function parseRetryAfter(value, now = Date.now()) {
-  if (!value) return void 0;
-  const trimmed = value.trim();
-  if (/^\d+(\.\d+)?$/.test(trimmed)) return Math.round(Number(trimmed) * 1e3);
-  const date = Date.parse(trimmed);
-  if (Number.isNaN(date)) return void 0;
-  return Math.max(0, date - now);
-}
-async function httpErrorFromResponse(response, url) {
-  let snippet = "";
-  try {
-    const text = await response.text();
-    snippet = text.slice(0, SNIPPET_MAX);
-  } catch {
-    snippet = "(could not read body)";
-  }
-  return new HttpError(
-    response.status,
-    snippet,
-    url,
-    parseRetryAfter(response.headers.get("retry-after"))
-  );
-}
-async function fetchJson(opts) {
-  const { url, method = "GET", headers: headers2 = {}, body, timeoutMs = DEFAULT_TIMEOUT_MS } = opts;
-  const doFetch = opts.fetch ?? ((input, init2) => globalThis.fetch(input, init2));
-  const init = {
-    method,
-    headers: {
-      "Content-Type": "application/json",
-      ...headers2
-    },
-    signal: AbortSignal.timeout(timeoutMs)
-  };
-  if (body !== void 0) {
-    init.body = JSON.stringify(body);
-  }
-  let response;
-  try {
-    response = await doFetch(url, init);
-  } catch (cause) {
-    const msg = cause instanceof Error ? cause.message : String(cause);
-    throw new HttpError(0, msg, url);
-  }
-  if (!response.ok) {
-    throw await httpErrorFromResponse(response, url);
-  }
-  let text;
-  try {
-    text = await response.text();
-  } catch (cause) {
-    const msg = cause instanceof Error ? cause.message : String(cause);
-    throw new HttpError(0, `Failed to read response body: ${msg}`, url);
-  }
-  if (text.trim() === "") return void 0;
-  try {
-    return JSON.parse(text);
-  } catch {
-    throw new HttpError(
-      response.status,
-      `Invalid JSON response: ${text.slice(0, SNIPPET_MAX)}`,
-      url
-    );
-  }
-}
-
-// src/core/http-client.ts
-async function httpJson(opts) {
-  return fetchJson(opts);
-}
-async function downloadFile(url, dest, timeoutMs = DEFAULT_TIMEOUT_MS, headers2) {
-  fs4.mkdirSync(path4.dirname(dest), { recursive: true });
-  let response;
-  try {
-    response = await globalThis.fetch(url, {
-      signal: AbortSignal.timeout(timeoutMs),
-      ...headers2 ? { headers: headers2 } : {}
-    });
-  } catch (cause) {
-    const msg = cause instanceof Error ? cause.message : String(cause);
-    throw new HttpError(0, msg, url);
-  }
-  if (!response.ok) {
-    throw new HttpError(response.status, "(download failed)", url);
-  }
-  if (!response.body) {
-    throw new HttpError(0, "Response body is null", url);
-  }
-  const fileStream = fs4.createWriteStream(dest);
-  try {
-    await pipeline(response.body, fileStream);
-  } catch (err2) {
-    if (!fileStream.closed) await once(fileStream, "close");
-    throw err2;
-  }
-}
-async function fetchBytes(urlOrDataUri) {
-  if (urlOrDataUri.startsWith("data:")) {
-    const commaIdx = urlOrDataUri.indexOf(",");
-    if (commaIdx === -1) throw new Error("Malformed data URI: missing comma");
-    const encoded = urlOrDataUri.slice(commaIdx + 1);
-    return Buffer.from(encoded, "base64");
-  }
-  let response;
-  try {
-    response = await globalThis.fetch(urlOrDataUri, {
-      signal: AbortSignal.timeout(DEFAULT_TIMEOUT_MS)
-    });
-  } catch (cause) {
-    const msg = cause instanceof Error ? cause.message : String(cause);
-    throw new HttpError(0, msg, urlOrDataUri);
-  }
-  if (!response.ok) {
-    throw new HttpError(response.status, "(bytes fetch failed)", urlOrDataUri);
-  }
-  return Buffer.from(await response.arrayBuffer());
-}
+init_errors();
 
 // src/providers/byteplus/models.ts
 var DEFAULT_BYTEPLUS_BASE_URL = "https://ark.ap-southeast.bytepluses.com/api/v3";
@@ -531,9 +2175,9 @@ var BytePlusClient = class {
   }
   apiKey;
   baseUrl;
-  async request(path49, opts = {}) {
+  async request(path52, opts = {}) {
     const base = this.baseUrl.replace(/\/$/, "");
-    const url = new URL(base + path49);
+    const url = new URL(base + path52);
     if (opts.query) {
       for (const [k, v] of Object.entries(opts.query)) {
         if (v !== void 0 && v !== null) url.searchParams.set(k, String(v));
@@ -551,14 +2195,14 @@ var BytePlusClient = class {
       timeoutMs: opts.timeoutMs ?? 12e4
     });
   }
-  get(path49, query, logger) {
-    return this.request(path49, { method: "GET", query, logger });
+  get(path52, query, logger) {
+    return this.request(path52, { method: "GET", query, logger });
   }
-  post(path49, body, logger) {
-    return this.request(path49, { method: "POST", body, logger });
+  post(path52, body, logger) {
+    return this.request(path52, { method: "POST", body, logger });
   }
-  delete(path49, logger) {
-    return this.request(path49, { method: "DELETE", logger });
+  delete(path52, logger) {
+    return this.request(path52, { method: "DELETE", logger });
   }
 };
 function createBytePlusClient() {
@@ -663,13 +2307,13 @@ function registerBytePlusGenerate3DCommand(parent) {
           process.exit(1);
         }
         const ext = inferModelFileExt(url);
-        const outPath = opts.output ?? path5.join(getOutputDir(), `byteplus-3d-${taskId.slice(0, 8)}-${Date.now()}.${ext}`);
+        const outPath = opts.output ?? path9.join(getOutputDir(), `byteplus-3d-${taskId.slice(0, 8)}-${Date.now()}.${ext}`);
         await downloadModelFile(url, outPath, logger);
         console.log(`
 Task: ${taskId}`);
         console.log(`Saved: ${outPath}`);
       } catch (e) {
-        if (e instanceof PollTimeoutError) {
+        if (e instanceof PollTimeoutError2) {
           logger.error(
             `Polling timed out \u2014 keep the task and check later: multix byteplus status ${taskId} --wait --download`
           );
@@ -685,196 +2329,9 @@ Task: ${taskId}`);
   );
 }
 
-// src/core/image-webp-finalize.ts
-init_errors();
-import { spawnSync } from "child_process";
-import fs6 from "fs";
-import path6 from "path";
-import { Option } from "commander";
-
-// src/core/image-header.ts
-import fs5 from "fs";
-function sniffImageKind(buf) {
-  if (buf.length >= 8 && buf.readUInt32BE(0) === 2303741511) return "png";
-  if (buf.length >= 3 && buf[0] === 255 && buf[1] === 216 && buf[2] === 255) return "jpeg";
-  if (buf.length >= 12 && buf.toString("ascii", 0, 4) === "RIFF" && buf.toString("ascii", 8, 12) === "WEBP")
-    return "webp";
-  return void 0;
-}
-function readPng(buf) {
-  if (buf.length < 33) return void 0;
-  const width = buf.readUInt32BE(16);
-  const height = buf.readUInt32BE(20);
-  const colorType = buf[25];
-  let hasAlpha = colorType === 4 || colorType === 6;
-  let offset = 8;
-  while (!hasAlpha && offset + 8 <= buf.length) {
-    const len = buf.readUInt32BE(offset);
-    const type = buf.toString("ascii", offset + 4, offset + 8);
-    if (type === "tRNS") hasAlpha = true;
-    if (type === "IDAT" || type === "IEND") break;
-    offset += 12 + len;
-  }
-  return { kind: "png", width, height, hasAlpha };
-}
-function readJpeg(buf) {
-  let offset = 2;
-  while (offset + 9 < buf.length) {
-    if (buf[offset] !== 255) {
-      offset++;
-      continue;
-    }
-    const marker = buf[offset + 1] ?? 0;
-    if (marker >= 192 && marker <= 207 && ![196, 200, 204].includes(marker)) {
-      return {
-        kind: "jpeg",
-        height: buf.readUInt16BE(offset + 5),
-        width: buf.readUInt16BE(offset + 7),
-        hasAlpha: false
-      };
-    }
-    if (marker === 216 || marker === 1 || marker >= 208 && marker <= 215) {
-      offset += 2;
-      continue;
-    }
-    offset += 2 + buf.readUInt16BE(offset + 2);
-  }
-  return void 0;
-}
-function readWebp(buf) {
-  if (buf.length < 30) return void 0;
-  const chunk = buf.toString("ascii", 12, 16);
-  if (chunk === "VP8X") {
-    const flags = buf[20] ?? 0;
-    return {
-      kind: "webp",
-      width: 1 + buf.readUIntLE(24, 3),
-      height: 1 + buf.readUIntLE(27, 3),
-      hasAlpha: (flags & 16) !== 0
-    };
-  }
-  if (chunk === "VP8L") {
-    const bits = buf.readUInt32LE(21);
-    return {
-      kind: "webp",
-      width: 1 + (bits & 16383),
-      height: 1 + (bits >>> 14 & 16383),
-      hasAlpha: (bits >>> 28 & 1) === 1
-    };
-  }
-  if (chunk === "VP8 ") {
-    return {
-      kind: "webp",
-      width: buf.readUInt16LE(26) & 16383,
-      height: buf.readUInt16LE(28) & 16383,
-      hasAlpha: false
-    };
-  }
-  return void 0;
-}
-function readImageHeader(buf) {
-  const kind = sniffImageKind(buf);
-  if (kind === "png") return readPng(buf);
-  if (kind === "jpeg") return readJpeg(buf);
-  if (kind === "webp") return readWebp(buf);
-  return void 0;
-}
-function readImageHeaderFromFile(file) {
-  return readImageHeader(fs5.readFileSync(file));
-}
-
-// src/core/image-webp-finalize.ts
-var CWEBP_ARGS = ["-q", "85", "-m", "6", "-metadata", "none"];
-var IMAGE_EXTS = /* @__PURE__ */ new Set([".png", ".jpg", ".jpeg", ".webp", ".gif", ".bmp", ".tif", ".tiff"]);
-function imageFormatOption() {
-  return new Option(
-    "--image-format <mode>",
-    "Final image format: webp (default, cwebp -q 85) | original (keep provider format/quality)"
-  );
-}
-function noWebpOption() {
-  return new Option("--no-webp", "Keep the provider's original image format and quality");
-}
-function resolveImageFormatMode(opts, explicitProviderFormat = false) {
-  if (opts.webp === false && opts.imageFormat === void 0) return "original";
-  const raw = opts.imageFormat ?? process.env.MULTIX_IMAGE_FORMAT;
-  if (raw !== void 0 && raw !== "") {
-    const mode = raw.toLowerCase();
-    if (mode !== "webp" && mode !== "original") {
-      throw new ValidationError(`Invalid --image-format: ${raw}. Valid: webp, original`);
-    }
-    return mode;
-  }
-  if (explicitProviderFormat) return "original";
-  const ext = opts.output ? path6.extname(opts.output).toLowerCase() : "";
-  if (ext && ext !== ".webp" && IMAGE_EXTS.has(ext)) return "original";
-  return "webp";
-}
-function hasCwebp() {
-  const res = spawnSync("cwebp", ["-version"], { stdio: "ignore" });
-  return !res.error && res.status === 0;
-}
-function webpTarget(file) {
-  const ext = path6.extname(file);
-  return ext.toLowerCase() === ".webp" ? file : `${file.slice(0, -ext.length || void 0)}.webp`;
-}
-function convertToWebp(file, logger, keepPath = false) {
-  const src = readImageHeaderFromFile(file);
-  if (!src) {
-    logger?.warn(`Skipping WebP conversion (unrecognized image): ${file}`);
-    return file;
-  }
-  if (src.kind === "webp") {
-    const target2 = keepPath ? file : webpTarget(file);
-    if (target2 !== file) fs6.renameSync(file, target2);
-    return target2;
-  }
-  const target = keepPath ? file : webpTarget(file);
-  const tmp = `${target}.tmp-${process.pid}.webp`;
-  const res = spawnSync("cwebp", [...CWEBP_ARGS, file, "-o", tmp], { encoding: "utf8" });
-  if (res.error || res.status !== 0) {
-    fs6.rmSync(tmp, { force: true });
-    logger?.warn(`cwebp failed, keeping original ${file}: ${res.stderr || res.error?.message}`);
-    return file;
-  }
-  const out = fs6.existsSync(tmp) ? readImageHeaderFromFile(tmp) : void 0;
-  const problem = !out ? "output is not a valid WebP" : out.width !== src.width || out.height !== src.height ? `size changed ${src.width}x${src.height} -> ${out.width}x${out.height}` : src.hasAlpha && !out.hasAlpha ? "transparency lost" : void 0;
-  if (problem) {
-    fs6.rmSync(tmp, { force: true });
-    logger?.warn(`WebP verification failed (${problem}), keeping original ${file}`);
-    return file;
-  }
-  if (target !== file) fs6.rmSync(file, { force: true });
-  fs6.renameSync(tmp, target);
-  logger?.debug(`WebP verified ${out?.width}x${out?.height} alpha=${out?.hasAlpha}: ${target}`);
-  return target;
-}
-function finalizeGeneratedImages(files, opts) {
-  const mode = resolveImageFormatMode(opts, opts.explicitProviderFormat);
-  if (mode === "original" || files.length === 0) return files;
-  if (!hasCwebp()) {
-    opts.logger?.warn(
-      "cwebp not found on PATH; keeping original image format (install libwebp, or pass --image-format original)"
-    );
-    return files;
-  }
-  const outputAbs = opts.output ? path6.resolve(opts.output) : void 0;
-  const wroteOutputDirectly = outputAbs !== void 0 && files.some((f) => path6.resolve(f) === outputAbs);
-  const finals = files.map(
-    (f) => convertToWebp(f, opts.logger, outputAbs !== void 0 && path6.resolve(f) === outputAbs)
-  );
-  if (opts.output && outputAbs && !wroteOutputDirectly && finals[0] && fs6.existsSync(outputAbs)) {
-    const outExt = path6.extname(outputAbs).toLowerCase();
-    if ((outExt === ".webp" || outExt === "") && path6.extname(finals[0]).toLowerCase() === ".webp") {
-      fs6.copyFileSync(finals[0], outputAbs);
-    }
-  }
-  return finals;
-}
-
 // src/providers/byteplus/generators/image.ts
-import fs7 from "fs";
-import path7 from "path";
+import fs11 from "fs";
+import path10 from "path";
 var ASPECT_TO_SIZE = {
   "1:1": "2048x2048",
   "16:9": "2560x1440",
@@ -938,14 +2395,14 @@ async function generateSeedream(client, opts) {
     }
     const ext = (() => {
       try {
-        const e = path7.extname(new URL(url).pathname);
+        const e = path10.extname(new URL(url).pathname);
         return e || ".jpg";
       } catch {
         return ".jpg";
       }
     })();
-    const filename = opts.output && items.length === 1 ? path7.resolve(opts.output) : path7.join(outDir, `byteplus-image-${ts}-${i + 1}${ext}`);
-    fs7.mkdirSync(path7.dirname(filename), { recursive: true });
+    const filename = opts.output && items.length === 1 ? path10.resolve(opts.output) : path10.join(outDir, `byteplus-image-${ts}-${i + 1}${ext}`);
+    fs11.mkdirSync(path10.dirname(filename), { recursive: true });
     await downloadFile(url, filename);
     saved.push({ path: filename, url, seed: item.seed });
     logger?.success(`Saved ${filename}`);
@@ -1028,97 +2485,13 @@ Generated ${finalImages.length} image(s):`);
     }
   );
 }
-function collect2(value, prev) {
-  return [...prev, value];
-}
-
-// src/providers/byteplus/commands/image-to-video.ts
-import path9 from "path";
-
-// src/core/video-thumb.ts
-import fs8 from "fs";
-import path8 from "path";
-var THUMB_KEYS = /* @__PURE__ */ new Set([
-  "cover_image_url",
-  "coverImageUrl",
-  "cover_url",
-  "coverUrl",
-  "thumbnail_url",
-  "thumbnailUrl",
-  "thumb_url",
-  "thumbUrl",
-  "preview_url",
-  "previewUrl",
-  "first_frame_url",
-  "firstFrameUrl",
-  "poster_url",
-  "posterUrl",
-  "image_url",
-  "imageUrl"
-]);
-var IMAGE_EXT_RE = /\.(jpe?g|png|webp|gif|bmp)(\?|$)/i;
-function isImageUrl(value) {
-  if (typeof value !== "string") return false;
-  if (!/^https?:\/\//i.test(value)) return false;
-  return IMAGE_EXT_RE.test(value);
-}
-function detectThumbUrl(obj) {
-  if (obj === null || obj === void 0) return null;
-  if (Array.isArray(obj)) {
-    for (const item of obj) {
-      const found = detectThumbUrl(item);
-      if (found) return found;
-    }
-    return null;
-  }
-  if (typeof obj !== "object") return null;
-  const record = obj;
-  for (const [key, value] of Object.entries(record)) {
-    if (THUMB_KEYS.has(key) && isImageUrl(value)) return value;
-  }
-  for (const value of Object.values(record)) {
-    if (value && typeof value === "object") {
-      const found = detectThumbUrl(value);
-      if (found) return found;
-    }
-  }
-  return null;
-}
-async function downloadThumbBeside(thumbUrl, videoPath, logger) {
-  const match = thumbUrl.match(IMAGE_EXT_RE);
-  const ext = match?.[1] ? match[1].toLowerCase().replace("jpeg", "jpg") : "jpg";
-  const dir = path8.dirname(videoPath);
-  const base = path8.basename(videoPath, path8.extname(videoPath));
-  const dest = path8.join(dir, `${base}_thumb.${ext}`);
-  try {
-    await downloadFile(thumbUrl, dest);
-    logger?.success(`Saved thumb ${dest}`);
-    return dest;
-  } catch (e) {
-    logger?.warn(`Thumb download failed: ${e instanceof Error ? e.message : String(e)}`);
-    return null;
-  }
-}
-async function maybeDownloadThumb(source, videoPath, opts = {}) {
-  if (opts.skip) return null;
-  const url = detectThumbUrl(source);
-  if (!url) {
-    opts.logger?.debug("No thumbnail URL detected in provider response");
-    return null;
-  }
-  const saved = await downloadThumbBeside(url, videoPath, opts.logger);
-  if (saved && opts.copyTo) {
-    const copyExt = path8.extname(saved);
-    const copyBase = path8.basename(opts.copyTo, path8.extname(opts.copyTo));
-    const copyDir = path8.dirname(path8.resolve(opts.copyTo));
-    const copyDest = path8.join(copyDir, `${copyBase}_thumb${copyExt}`);
-    fs8.mkdirSync(copyDir, { recursive: true });
-    fs8.copyFileSync(saved, copyDest);
-    opts.logger?.success(`Copied thumb to ${copyDest}`);
-  }
-  return saved;
+function collect2(value, prev) {
+  return [...prev, value];
 }
 
+// src/providers/byteplus/commands/image-to-video.ts
+import path11 from "path";
+
 // src/providers/byteplus/generators/video.ts
 function buildFlagSuffix(opts) {
   const parts = [];
@@ -1240,7 +2613,7 @@ function registerBytePlusImageToVideoCommand(parent) {
           logger.error(`Task succeeded but no video_url: ${JSON.stringify(final)}`);
           process.exit(1);
         }
-        const outPath = opts.output ?? path9.join(getOutputDir(), `byteplus-i2v-${taskId.slice(0, 8)}-${Date.now()}.mp4`);
+        const outPath = opts.output ?? path11.join(getOutputDir(), `byteplus-i2v-${taskId.slice(0, 8)}-${Date.now()}.mp4`);
         await downloadVideo(url, outPath, logger);
         await maybeDownloadThumb(final, outPath, {
           skip: opts.thumb === false,
@@ -1251,7 +2624,7 @@ function registerBytePlusImageToVideoCommand(parent) {
 Task: ${taskId}`);
         console.log(`Saved: ${outPath}`);
       } catch (e) {
-        if (e instanceof PollTimeoutError) {
+        if (e instanceof PollTimeoutError2) {
           logger.error(`Timed out \u2014 multix byteplus status ${taskId}`);
           process.exit(1);
         }
@@ -1266,7 +2639,7 @@ Task: ${taskId}`);
 }
 
 // src/providers/byteplus/commands/reference-to-video.ts
-import path10 from "path";
+import path12 from "path";
 
 // src/providers/byteplus/reference-input.ts
 var MAX_TOTAL_REFS = 12;
@@ -1298,10 +2671,10 @@ function toRef(kind, resolved, role) {
   return { kind, url: resolved.dataUrl, mime: resolved.mime, role };
 }
 async function resolveRefSpec(kind, spec, logger) {
-  const { path: path49, role } = parseRefSpec(spec);
-  if (kind === "image") return toRef(kind, await resolveImageInput(path49, logger), role);
-  if (kind === "video") return toRef(kind, await resolveVideoInput(path49, logger), role);
-  return toRef(kind, await resolveAudioInput(path49, logger), role);
+  const { path: path52, role } = parseRefSpec(spec);
+  if (kind === "image") return toRef(kind, await resolveImageInput(path52, logger), role);
+  if (kind === "video") return toRef(kind, await resolveVideoInput(path52, logger), role);
+  return toRef(kind, await resolveAudioInput(path52, logger), role);
 }
 async function resolveRefSpecs(specs, logger) {
   const out = [];
@@ -1398,7 +2771,7 @@ function registerBytePlusReferenceToVideoCommand(parent) {
           logger.error(`Task succeeded but no video_url: ${JSON.stringify(final)}`);
           process.exit(1);
         }
-        const outPath = opts.output ?? path10.join(getOutputDir(), `byteplus-r2v-${taskId.slice(0, 8)}-${Date.now()}.mp4`);
+        const outPath = opts.output ?? path12.join(getOutputDir(), `byteplus-r2v-${taskId.slice(0, 8)}-${Date.now()}.mp4`);
         await downloadVideo(url, outPath, logger);
         await maybeDownloadThumb(final, outPath, {
           skip: opts.thumb === false,
@@ -1409,7 +2782,7 @@ function registerBytePlusReferenceToVideoCommand(parent) {
 Task: ${taskId}`);
         console.log(`Saved: ${outPath}`);
       } catch (e) {
-        if (e instanceof PollTimeoutError) {
+        if (e instanceof PollTimeoutError2) {
           logger.error(`Timed out \u2014 multix byteplus status ${taskId}`);
           process.exit(1);
         }
@@ -1424,7 +2797,7 @@ Task: ${taskId}`);
 }
 
 // src/providers/byteplus/commands/status.ts
-import path11 from "path";
+import path13 from "path";
 function registerBytePlusStatusCommand(parent) {
   parent.command("status <taskId>").description("Get a Seedance task's status; --wait + --download to fetch the result MP4").option("--wait", "Poll until terminal status").option("--wait-timeout <ms>", "Poll timeout in ms (with --wait)", "600000").option("--download", "Download MP4 on success (implies --wait)").option("--output <path>", "Output MP4 path (with --download)").option("--no-thumb", "Skip downloading the thumbnail if the API returns one").option("-v, --verbose", "Verbose logging").action(
     async (taskId, opts) => {
@@ -1442,7 +2815,7 @@ function registerBytePlusStatusCommand(parent) {
           const videoUrl2 = content?.video_url;
           const fileUrl = content?.file_url;
           if (videoUrl2) {
-            const outPath = opts.output ?? path11.join(getOutputDir(), `byteplus-video-${taskId.slice(0, 8)}.mp4`);
+            const outPath = opts.output ?? path13.join(getOutputDir(), `byteplus-video-${taskId.slice(0, 8)}.mp4`);
             await downloadVideo(videoUrl2, outPath, logger);
             await maybeDownloadThumb(status, outPath, {
               skip: opts.thumb === false,
@@ -1452,7 +2825,7 @@ function registerBytePlusStatusCommand(parent) {
             console.log(`Saved: ${outPath}`);
           } else if (fileUrl) {
             const ext = inferModelFileExt(fileUrl);
-            const outPath = opts.output ?? path11.join(getOutputDir(), `byteplus-3d-${taskId.slice(0, 8)}.${ext}`);
+            const outPath = opts.output ?? path13.join(getOutputDir(), `byteplus-3d-${taskId.slice(0, 8)}.${ext}`);
             await downloadModelFile(fileUrl, outPath, logger);
             console.log(`Saved: ${outPath}`);
           } else {
@@ -1461,7 +2834,7 @@ function registerBytePlusStatusCommand(parent) {
           }
         }
       } catch (e) {
-        if (e instanceof PollTimeoutError) {
+        if (e instanceof PollTimeoutError2) {
           logger.error(`Timed out waiting for task ${taskId}`);
           process.exit(1);
         }
@@ -1476,7 +2849,7 @@ function registerBytePlusStatusCommand(parent) {
 }
 
 // src/providers/byteplus/commands/video.ts
-import path12 from "path";
+import path14 from "path";
 function registerBytePlusVideoCommand(parent) {
   parent.command("video").description("Generate a video from a text prompt via BytePlus Seedance 2.0").requiredOption("--prompt <text>", "Text prompt").option("-m, --model <id>", "Model id", BYTEPLUS_DEFAULTS.videoModel).option("--resolution <r>", "480p|720p|1080p|2k", BYTEPLUS_DEFAULTS.videoResolution).option("--duration <n>", "Duration seconds (4-15)", String(BYTEPLUS_DEFAULTS.videoDuration)).option(
     "--aspect-ratio <r>",
@@ -1518,7 +2891,7 @@ function registerBytePlusVideoCommand(parent) {
           logger.error(`Task succeeded but no video_url in response: ${JSON.stringify(final)}`);
           process.exit(1);
         }
-        const outPath = opts.output ?? path12.join(getOutputDir(), `byteplus-video-${taskId.slice(0, 8)}-${Date.now()}.mp4`);
+        const outPath = opts.output ?? path14.join(getOutputDir(), `byteplus-video-${taskId.slice(0, 8)}-${Date.now()}.mp4`);
         await downloadVideo(url, outPath, logger);
         await maybeDownloadThumb(final, outPath, {
           skip: opts.thumb === false,
@@ -1529,7 +2902,7 @@ function registerBytePlusVideoCommand(parent) {
 Task: ${taskId}`);
         console.log(`Saved: ${outPath}`);
       } catch (e) {
-        if (e instanceof PollTimeoutError) {
+        if (e instanceof PollTimeoutError2) {
           logger.error(
             `Polling timed out \u2014 try --async to keep the task and check later: multix byteplus status ${taskId}`
           );
@@ -1736,15 +3109,15 @@ async function downloadVideo2(url) {
 
 // src/providers/cloudflare/media-output.ts
 init_errors();
-import fs9 from "fs";
-import path13 from "path";
+import fs12 from "fs";
+import path15 from "path";
 function destination(filename, output) {
-  return output ? path13.resolve(output) : path13.join(getOutputDir(), filename);
+  return output ? path15.resolve(output) : path15.join(getOutputDir(), filename);
 }
 function saveBytes(bytes, filename, output) {
   const dest = destination(filename, output);
-  fs9.mkdirSync(path13.dirname(dest), { recursive: true });
-  fs9.writeFileSync(dest, bytes);
+  fs12.mkdirSync(path15.dirname(dest), { recursive: true });
+  fs12.writeFileSync(dest, bytes);
   return dest;
 }
 function saveBase64Image(image, output) {
@@ -1927,8 +3300,8 @@ function registerCloudflareCommands(program2) {
 }
 
 // src/providers/elevenlabs/client.ts
-import fs10 from "fs";
-import path14 from "path";
+import fs13 from "fs";
+import path16 from "path";
 init_errors();
 
 // src/providers/elevenlabs/models.ts
@@ -2089,13 +3462,13 @@ async function apiPostMultipart(endpoint2, form, apiKey, opts = {}) {
   return res.json();
 }
 function readFileAsBlob(filePath, fieldFilename) {
-  const abs = path14.resolve(filePath);
-  if (!fs10.existsSync(abs)) throw new ValidationError(`File not found: ${abs}`);
-  const buf = fs10.readFileSync(abs);
-  const name = fieldFilename ?? path14.basename(abs);
+  const abs = path16.resolve(filePath);
+  if (!fs13.existsSync(abs)) throw new ValidationError(`File not found: ${abs}`);
+  const buf = fs13.readFileSync(abs);
+  const name = fieldFilename ?? path16.basename(abs);
   return new File([new Uint8Array(buf)], name);
 }
-async function pollUntil(fetchStatus, isDone, isFailed, opts = {}) {
+async function pollUntil2(fetchStatus, isDone, isFailed, opts = {}) {
   const { intervalMs = 5e3, timeoutMs = 6e5, logger, label = "task" } = opts;
   const deadline = Date.now() + timeoutMs;
   let elapsed = 0;
@@ -2116,12 +3489,12 @@ async function pollUntil(fetchStatus, isDone, isFailed, opts = {}) {
 function saveBytes2(opts) {
   const { bytes, task, ext, outputCopy, logger } = opts;
   const dir = getOutputDir();
-  const dest = path14.join(dir, `elevenlabs_${task}_${Date.now()}.${ext}`);
-  fs10.writeFileSync(dest, bytes);
+  const dest = path16.join(dir, `elevenlabs_${task}_${Date.now()}.${ext}`);
+  fs13.writeFileSync(dest, bytes);
   logger?.success(`Saved: ${dest} (${(bytes.length / 1024).toFixed(1)} KB)`);
   if (outputCopy) {
-    fs10.mkdirSync(path14.dirname(path14.resolve(outputCopy)), { recursive: true });
-    fs10.copyFileSync(dest, outputCopy);
+    fs13.mkdirSync(path16.dirname(path16.resolve(outputCopy)), { recursive: true });
+    fs13.copyFileSync(dest, outputCopy);
   }
   return dest;
 }
@@ -2160,14 +3533,14 @@ ${models.length} models`);
 }
 
 // src/providers/elevenlabs/commands/align.ts
-import fs11 from "fs";
-import path15 from "path";
+import fs14 from "fs";
+import path17 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 = fs11.readFileSync(path15.resolve(opts.textFile), "utf8");
+    if (opts.textFile) text = fs14.readFileSync(path17.resolve(opts.textFile), "utf8");
     const form = new FormData();
     form.append("file", readFileAsBlob(opts.input));
     form.append("text", text);
@@ -2175,9 +3548,9 @@ function registerAlignCommand(parent) {
     const data = await apiPostMultipart("forced-alignment", form, apiKey, {
       timeoutMs: 6e5
     });
-    const dest = opts.output ? path15.resolve(opts.output) : path15.join(getOutputDir(), `elevenlabs_align_${Date.now()}.json`);
-    fs11.mkdirSync(path15.dirname(dest), { recursive: true });
-    fs11.writeFileSync(dest, JSON.stringify(data, null, 2));
+    const dest = opts.output ? path17.resolve(opts.output) : path17.join(getOutputDir(), `elevenlabs_align_${Date.now()}.json`);
+    fs14.mkdirSync(path17.dirname(dest), { recursive: true });
+    fs14.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 ?? "?"})`);
   });
@@ -2219,8 +3592,8 @@ function registerCloneCommand(parent) {
 
 // src/providers/elevenlabs/commands/dub.ts
 init_errors();
-import fs12 from "fs";
-import path16 from "path";
+import fs15 from "fs";
+import path18 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 });
@@ -2250,7 +3623,7 @@ function registerDubCommand(parent) {
       console.log("Run `multix elevenlabs dub-status <id>` to check progress.");
       return;
     }
-    const final = await pollUntil(
+    const final = await pollUntil2(
       () => apiGet(`dubbing/${start.dubbing_id}`, apiKey),
       (s) => s.status === "dubbed",
       (s) => s.status === "failed",
@@ -2263,7 +3636,7 @@ function registerDubCommand(parent) {
     );
     logger.success(`Dub complete: ${start.dubbing_id}`);
     if (opts.download) {
-      const dest = opts.output ? path16.resolve(opts.output) : path16.join(getOutputDir(), `elevenlabs_dub_${start.dubbing_id}_${opts.targetLang}.mp4`);
+      const dest = opts.output ? path18.resolve(opts.output) : path18.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}`);
@@ -2278,7 +3651,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 ? path16.resolve(opts.output) : path16.join(getOutputDir(), `elevenlabs_dub_${dubbingId}_${opts.download}.mp4`);
+      const dest = opts.output ? path18.resolve(opts.output) : path18.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}`);
@@ -2286,7 +3659,7 @@ Dubbed file: ${dest}`);
   });
 }
 async function downloadDub(url, apiKey, dest) {
-  fs12.mkdirSync(path16.dirname(dest), { recursive: true });
+  fs15.mkdirSync(path18.dirname(dest), { recursive: true });
   const res = await globalThis.fetch(url, {
     headers: { "xi-api-key": apiKey },
     signal: AbortSignal.timeout(6e5)
@@ -2295,7 +3668,7 @@ async function downloadDub(url, apiKey, dest) {
     throw new Error(`Failed to download dub: HTTP ${res.status}`);
   }
   const arr = new Uint8Array(await res.arrayBuffer());
-  fs12.writeFileSync(dest, arr);
+  fs15.writeFileSync(dest, arr);
   void downloadFile;
 }
 
@@ -2324,8 +3697,8 @@ Isolated audio: ${dest}`);
 
 // src/providers/elevenlabs/commands/music.ts
 init_errors();
-import fs13 from "fs";
-import path17 from "path";
+import fs16 from "fs";
+import path19 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>",
@@ -2340,9 +3713,9 @@ function registerMusicCommand(parent) {
     const payload = { model_id: opts.model };
     if (opts.prompt) payload.prompt = opts.prompt;
     if (opts.plan) {
-      const planPath = path17.resolve(opts.plan);
-      if (!fs13.existsSync(planPath)) throw new ValidationError(`Plan file not found: ${planPath}`);
-      const planJson = JSON.parse(fs13.readFileSync(planPath, "utf8"));
+      const planPath = path19.resolve(opts.plan);
+      if (!fs16.existsSync(planPath)) throw new ValidationError(`Plan file not found: ${planPath}`);
+      const planJson = JSON.parse(fs16.readFileSync(planPath, "utf8"));
       payload.composition_plan = planJson;
     }
     if (opts.musicLengthMs) payload.music_length_ms = Number.parseInt(opts.musicLengthMs, 10);
@@ -2401,8 +3774,8 @@ Generated SFX: ${dest}`);
 }
 
 // src/providers/elevenlabs/commands/transcribe.ts
-import fs14 from "fs";
-import path18 from "path";
+import fs17 from "fs";
+import path20 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>",
@@ -2425,7 +3798,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 ? path18.resolve(opts.output) : path18.join(dir, `elevenlabs_transcribe_${Date.now()}.${ext}`);
+    const dest = opts.output ? path20.resolve(opts.output) : path20.join(dir, `elevenlabs_transcribe_${Date.now()}.${ext}`);
     let body;
     switch (opts.format) {
       case "json":
@@ -2440,8 +3813,8 @@ function registerTranscribeCommand(parent) {
       default:
         body = data.text ?? "";
     }
-    fs14.mkdirSync(path18.dirname(dest), { recursive: true });
-    fs14.writeFileSync(dest, body);
+    fs17.mkdirSync(path20.dirname(dest), { recursive: true });
+    fs17.writeFileSync(dest, body);
     logger.success(`Saved transcript: ${dest}`);
     if (data.language_code) {
       logger.info(
@@ -2687,8 +4060,8 @@ function registerElevenLabsCommands(program2) {
 }
 
 // src/providers/fal/commands/image.ts
-import fs17 from "fs";
-import path20 from "path";
+import fs19 from "fs";
+import path22 from "path";
 
 // src/providers/fal/models.ts
 var DEFAULT_FAL_BASE_URL = "https://queue.fal.run";
@@ -2702,37 +4075,8 @@ var FAL_DEFAULTS = {
 };
 
 // src/providers/fal/run-helpers.ts
-import fs16 from "fs";
-import path19 from "path";
-
-// src/core/json-input.ts
-init_errors();
-import fs15 from "fs";
-function parseJsonInput(raw, flag = "--input") {
-  let text;
-  if (raw.startsWith("@")) {
-    try {
-      text = fs15.readFileSync(raw.slice(1), "utf8");
-    } catch (e) {
-      const msg = e instanceof Error ? e.message : String(e);
-      throw new ValidationError(`Cannot read ${flag} file: ${msg}`);
-    }
-  } else {
-    text = raw;
-  }
-  try {
-    const parsed = JSON.parse(text);
-    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-      throw new Error("input must be a JSON object");
-    }
-    return parsed;
-  } catch (e) {
-    const msg = e instanceof Error ? e.message : String(e);
-    throw new ValidationError(`Invalid ${flag} JSON: ${msg}`);
-  }
-}
-
-// src/providers/fal/run-helpers.ts
+import fs18 from "fs";
+import path21 from "path";
 init_redact();
 
 // src/providers/fal/client.ts
@@ -2757,9 +4101,9 @@ var FalClient = class {
   apiKey;
   baseUrl;
   /** `path` is appended verbatim to the base queue URL, e.g. "/fal-ai/flux/schnell". */
-  async request(path49, opts = {}) {
+  async request(path52, opts = {}) {
     const base = this.baseUrl.replace(/\/$/, "");
-    const suffix = path49.startsWith("/") ? path49 : `/${path49}`;
+    const suffix = path52.startsWith("/") ? path52 : `/${path52}`;
     return this.requestAbsolute(base + suffix, opts);
   }
   /** Same auth/headers as `request`, but `url` is used verbatim (e.g. a status_url/response_url returned by submit). */
@@ -2776,11 +4120,11 @@ var FalClient = class {
       timeoutMs: opts.timeoutMs ?? 12e4
     });
   }
-  get(path49, logger) {
-    return this.request(path49, { method: "GET", logger });
+  get(path52, logger) {
+    return this.request(path52, { method: "GET", logger });
   }
-  post(path49, body, logger) {
-    return this.request(path49, { method: "POST", body, logger });
+  post(path52, body, logger) {
+    return this.request(path52, { method: "POST", body, logger });
   }
   getAbsolute(url, logger) {
     return this.requestAbsolute(url, { method: "GET", logger });
@@ -2922,7 +4266,7 @@ function extractMediaUrls(result) {
 function extFromUrl(url, fallback = ".bin") {
   try {
     const u = new URL(url);
-    const e = path19.extname(u.pathname);
+    const e = path21.extname(u.pathname);
     return e.length > 0 ? e : fallback;
   } catch {
     return fallback;
@@ -2935,13 +4279,13 @@ async function downloadResultMedia(urls, outDir, requestId, logger) {
     if (!url) continue;
     const ext = extFromUrl(url);
     const filename = `fal-${requestId.slice(0, 8)}-${String(i + 1).padStart(2, "0")}${ext}`;
-    const filepath = path19.join(outDir, filename);
+    const filepath = path21.join(outDir, filename);
     try {
       await downloadFile(url, filepath);
       saved.push(filepath);
       logger.success(`Saved ${filepath}`);
     } catch (e) {
-      fs16.rmSync(filepath, { force: true });
+      fs18.rmSync(filepath, { force: true });
       logger.warn(`Download failed for ${redactUrl(url)}: ${e instanceof Error ? e.message : e}`);
     }
   }
@@ -2986,9 +4330,9 @@ function registerFalImageCommand(parent) {
         process.exit(1);
       }
       if (opts.output && saved[0]) {
-        const dest = path20.resolve(opts.output);
-        fs17.mkdirSync(path20.dirname(dest), { recursive: true });
-        fs17.copyFileSync(saved[0], dest);
+        const dest = path22.resolve(opts.output);
+        fs19.mkdirSync(path22.dirname(dest), { recursive: true });
+        fs19.copyFileSync(saved[0], dest);
         logger.success(`Copied to ${dest}`);
       }
       const finalImages = finalizeGeneratedImages(saved, { ...opts, logger });
@@ -3141,14 +4485,214 @@ function registerFalCommands(program2) {
   registerFalResultCommand(fal);
 }
 
-// src/providers/gemini/commands/analyze.ts
+// src/core/stdin-file.ts
 init_errors();
 import fs20 from "fs";
+import os2 from "os";
+import path23 from "path";
+var STDIN_ARG = "-";
+var STDIN_LABEL = "<stdin>";
+var HEAD_BYTES = 4096;
+var MAX_STDIN_BYTES = 2 * 1024 ** 3;
+var WAIT_HINT_MS = 2e3;
+var ascii = (buf, start, end) => buf.toString("latin1", start, end);
+var HEIF_BRANDS = /* @__PURE__ */ new Set([
+  "heic",
+  "heix",
+  "hevc",
+  "hevx",
+  "heim",
+  "heis",
+  "hevm",
+  "hevs",
+  "mif1",
+  "msf1"
+]);
+var AVIF_BRANDS = /* @__PURE__ */ new Set(["avif", "avis"]);
+function isMpegAudioFrame(head) {
+  if (head.length < 4 || head[0] !== 255) return false;
+  const b1 = head[1] ?? 0;
+  const b2 = head[2] ?? 0;
+  if ((b1 & 224) !== 224) return false;
+  const version = b1 >> 3 & 3;
+  const layer = b1 >> 1 & 3;
+  const bitrate = b2 >> 4;
+  const sampleRate = b2 >> 2 & 3;
+  return version !== 1 && layer !== 0 && bitrate !== 15 && bitrate !== 0 && sampleRate !== 3;
+}
+function detectExtension(head) {
+  if (head.length >= 3 && head[0] === 239 && head[1] === 187 && head[2] === 191) return ".txt";
+  if (head.length >= 2 && (head[0] === 255 && head[1] === 254 || head[0] === 254 && head[1] === 255)) {
+    return void 0;
+  }
+  if (head.length >= 8 && head.readUInt32BE(0) === 2303741511) return ".png";
+  if (head.length >= 3 && head[0] === 255 && head[1] === 216 && head[2] === 255) return ".jpg";
+  if (ascii(head, 0, 4) === "GIF8") return ".gif";
+  if (ascii(head, 0, 5) === "%PDF-") return ".pdf";
+  if (ascii(head, 0, 2) === "BM" && head.length >= 26 && head.readUInt32LE(14) >= 12) return ".bmp";
+  if (ascii(head, 0, 4) === "RIFF") {
+    const kind = ascii(head, 8, 12);
+    if (kind === "WEBP") return ".webp";
+    if (kind === "WAVE") return ".wav";
+    if (kind === "AVI ") return ".avi";
+  }
+  if (ascii(head, 0, 4) === "OggS") return ".ogg";
+  if (ascii(head, 0, 4) === "fLaC") return ".flac";
+  if (ascii(head, 0, 4) === "FORM" && ascii(head, 8, 12) === "AIFF") return ".aiff";
+  if (ascii(head, 0, 3) === "ID3" && (head[3] ?? 0) >= 2 && (head[3] ?? 0) <= 4 && head[4] !== 255) {
+    return ".mp3";
+  }
+  if (ascii(head, 4, 8) === "ftyp") {
+    const brand = ascii(head, 8, 12);
+    if (HEIF_BRANDS.has(brand)) return ".heic";
+    if (AVIF_BRANDS.has(brand)) return void 0;
+    if (brand.startsWith("M4A") || brand.startsWith("M4B")) return ".m4a";
+    if (brand === "qt  ") return ".mov";
+    if (brand.startsWith("3g")) return ".3gpp";
+    return ".mp4";
+  }
+  if (head.length >= 4 && head.readUInt32BE(0) === 440786851) {
+    return head.includes("webm", 0, "latin1") ? ".webm" : void 0;
+  }
+  if (head.length >= 2 && head[0] === 255 && ((head[1] ?? 0) & 246) === 240) return ".aac";
+  if (isMpegAudioFrame(head)) return ".mp3";
+  if (looksLikeText(head)) return ".txt";
+  return void 0;
+}
+function looksLikeText(head) {
+  if (head.length === 0) return false;
+  for (const byte of head) {
+    if (byte < 32 && byte !== 9 && byte !== 10 && byte !== 12 && byte !== 13 && byte !== 27) {
+      return false;
+    }
+  }
+  try {
+    new TextDecoder("utf-8", { fatal: true }).decode(head, { stream: true });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function normalizeExt(ext) {
+  const clean = ext.trim().toLowerCase();
+  if (!/^\.?[a-z0-9]{1,10}$/.test(clean)) {
+    throw new ValidationError(`Invalid --stdin-ext: ${ext} (expected e.g. .mp3 or txt)`);
+  }
+  return clean.startsWith(".") ? clean : `.${clean}`;
+}
+var SIGNALS = ["SIGINT", "SIGTERM", "SIGHUP"];
+function trackTempDir(dir) {
+  let done = false;
+  const remove = () => {
+    try {
+      fs20.rmSync(dir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
+    } catch {
+    }
+  };
+  const onSignal = (signal) => {
+    dispose();
+    process.kill(process.pid, signal);
+  };
+  const dispose = () => {
+    if (done) return;
+    done = true;
+    process.removeListener("exit", dispose);
+    for (const s of SIGNALS) process.removeListener(s, onSignal);
+    remove();
+  };
+  process.once("exit", dispose);
+  for (const s of SIGNALS) process.once(s, onSignal);
+  return dispose;
+}
+async function stdinToTempFile(opts = {}) {
+  const input = opts.input ?? process.stdin;
+  if (input.isTTY) {
+    throw new ValidationError(
+      "`--files -` reads piped input, but stdin is a terminal. Example: cat clip.mp3 | multix gemini transcribe --files -"
+    );
+  }
+  const forcedExt = opts.ext ? normalizeExt(opts.ext) : void 0;
+  const maxBytes = opts.maxBytes ?? MAX_STDIN_BYTES;
+  const dir = fs20.mkdtempSync(path23.join(os2.tmpdir(), "multix-stdin-"));
+  const cleanup = trackTempDir(dir);
+  const rawPath = path23.join(dir, "input");
+  const hint = setTimeout(() => {
+    process.stderr.write("Waiting for data on stdin (`--files -`)... press Ctrl+C to cancel\n");
+  }, WAIT_HINT_MS);
+  hint.unref?.();
+  let head = Buffer.alloc(0);
+  let size = 0;
+  try {
+    const fd = fs20.openSync(rawPath, "w", 384);
+    try {
+      for await (const chunk of input) {
+        clearTimeout(hint);
+        const buf = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
+        if (size + buf.length > maxBytes) {
+          throw new ValidationError(
+            `Piped stdin exceeds ${Math.floor(maxBytes / 1024 ** 2)} MB; save it to a file instead`
+          );
+        }
+        if (head.length < HEAD_BYTES) {
+          head = Buffer.concat([head, buf.subarray(0, HEAD_BYTES - head.length)]);
+        }
+        let offset = 0;
+        while (offset < buf.length) offset += fs20.writeSync(fd, buf, offset);
+        size += buf.length;
+      }
+    } finally {
+      clearTimeout(hint);
+      fs20.closeSync(fd);
+    }
+    if (size === 0) throw new ValidationError("`--files -` was given but stdin was empty");
+    const detectedExt = forcedExt ?? detectExtension(head);
+    const finalPath = path23.join(dir, `stdin${detectedExt ?? ".bin"}`);
+    fs20.renameSync(rawPath, finalPath);
+    return { path: finalPath, size, detected: detectedExt !== void 0, cleanup };
+  } catch (error) {
+    cleanup();
+    throw error;
+  }
+}
+function labelError(message, input) {
+  return input.path === input.label ? message : message.split(input.path).join(input.label);
+}
+async function resolveFileInputs(files, opts = {}) {
+  const stdinCount = files.filter((f) => f === STDIN_ARG).length;
+  if (stdinCount > 1) throw new ValidationError("`-` (stdin) can only be passed once to --files");
+  if (opts.stdinExt && stdinCount === 0) {
+    throw new ValidationError("--stdin-ext only applies when --files includes `-`");
+  }
+  for (const f of files) {
+    if (f !== STDIN_ARG && !fs20.existsSync(f)) throw new ValidationError(`File not found: ${f}`);
+  }
+  if (stdinCount === 0) {
+    return { inputs: files.map((f) => ({ path: f, label: f })), cleanup: () => {
+    } };
+  }
+  const stdin = await stdinToTempFile({
+    input: opts.input,
+    ext: opts.stdinExt,
+    maxBytes: opts.maxBytes
+  });
+  if (!stdin.detected) {
+    stdin.cleanup();
+    throw new ValidationError(
+      "Could not detect the type of piped stdin; pass --stdin-ext (e.g. --stdin-ext mp3)"
+    );
+  }
+  return {
+    inputs: files.map(
+      (f) => f === STDIN_ARG ? { path: stdin.path, label: STDIN_LABEL } : { path: f, label: f }
+    ),
+    cleanup: stdin.cleanup
+  };
+}
 
 // src/providers/gemini/client.ts
 init_errors();
-import fs18 from "fs";
-import path22 from "path";
+import fs21 from "fs";
+import path25 from "path";
 
 // src/providers/gemini/key-pool.ts
 init_errors();
@@ -3214,7 +4758,7 @@ async function withGeminiKey(fn, opts = {}) {
 }
 
 // src/providers/gemini/task-resolver.ts
-import path21 from "path";
+import path24 from "path";
 var MIME_MAP = {
   // Audio
   ".mp3": "audio/mp3",
@@ -3255,7 +4799,7 @@ var MIME_MAP = {
   ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation"
 };
 function getMimeType(filePath) {
-  const ext = path21.extname(filePath).toLowerCase();
+  const ext = path24.extname(filePath).toLowerCase();
   return MIME_MAP[ext] ?? "application/octet-stream";
 }
 function requiresProcessingWait(mimeType) {
@@ -3278,8 +4822,8 @@ async function uploadFile(filePath, opts = {}) {
 async function uploadFileWithKey(filePath, apiKey, opts) {
   const { timeoutMs = 3e5, logger } = opts;
   const mimeType = getMimeType(filePath);
-  const fileBytes = fs18.readFileSync(filePath);
-  const displayName = path22.basename(filePath);
+  const fileBytes = fs21.readFileSync(filePath);
+  const displayName = path25.basename(filePath);
   const boundary = `multix_${Date.now()}`;
   const metaJson = JSON.stringify({ file: { displayName, mimeType } });
   const body = Buffer.concat([
@@ -3396,12 +4940,12 @@ function extractImages(resp) {
   ).map((p) => ({ mimeType: p.inlineData.mimeType, data: p.inlineData.data }));
 }
 function inlinePart(filePath) {
-  const data = fs18.readFileSync(filePath).toString("base64");
+  const data = fs21.readFileSync(filePath).toString("base64");
   const mimeType = getMimeType(filePath);
   return { inlineData: { mimeType, data } };
 }
 function shouldUseFileApi(filePath) {
-  const stat = fs18.statSync(filePath);
+  const stat = fs21.statSync(filePath);
   return stat.size > 20 * 1024 * 1024;
 }
 function sleep2(ms) {
@@ -3455,13 +4999,13 @@ function getDefaultModel(task) {
 }
 
 // src/providers/gemini/result-formatter.ts
-import fs19 from "fs";
-import path23 from "path";
+import fs22 from "fs";
+import path26 from "path";
 function formatResults(results, format, outputPath) {
   const content = renderFormat(results, format);
   if (outputPath) {
-    fs19.mkdirSync(path23.dirname(path23.resolve(outputPath)), { recursive: true });
-    fs19.writeFileSync(outputPath, content, "utf8");
+    fs22.mkdirSync(path26.dirname(path26.resolve(outputPath)), { recursive: true });
+    fs22.writeFileSync(outputPath, content, "utf8");
   } else {
     process.stdout.write(content);
   }
@@ -3523,17 +5067,17 @@ ${r.response}
 
 // src/providers/gemini/commands/analyze.ts
 function registerAnalyzeCommand(parent) {
-  parent.command("analyze").description("Analyze files with Gemini (images, video, audio, documents)").requiredOption("--files <paths...>", "Input file paths to analyze").option("--prompt <text>", "Analysis prompt", "Analyze this content").option("--model <id>", "Gemini model to use").option("--format <fmt>", "Output format: text|json|csv|markdown", "text").option("--output <path>", "Write results to file instead of stdout").option("-v, --verbose", "Verbose logging").action(
+  parent.command("analyze").description("Analyze files with Gemini (images, video, audio, documents)").requiredOption("--files <paths...>", "Input file paths to analyze (use - to read piped stdin)").option("--stdin-ext <ext>", "Extension for piped stdin when auto-detection fails (e.g. mp3)").option("--prompt <text>", "Analysis prompt", "Analyze this content").option("--model <id>", "Gemini model to use").option("--format <fmt>", "Output format: text|json|csv|markdown", "text").option("--output <path>", "Write results to file instead of stdout").option("-v, --verbose", "Verbose logging").action(
     async (opts) => {
       const logger = createLogger({ verbose: opts.verbose ?? false });
       const model = opts.model ?? getDefaultModel("analyze");
-      for (const f of opts.files) {
-        if (!fs20.existsSync(f)) throw new ValidationError(`File not found: ${f}`);
-      }
+      const { inputs, cleanup } = await resolveFileInputs(opts.files, {
+        stdinExt: opts.stdinExt
+      });
       const results = [];
-      for (let i = 0; i < opts.files.length; i++) {
-        const filePath = opts.files[i];
-        logger.debug(`[${i + 1}/${opts.files.length}] Processing: ${filePath}`);
+      for (let i = 0; i < inputs.length; i++) {
+        const { path: filePath, label } = inputs[i];
+        logger.debug(`[${i + 1}/${inputs.length}] Processing: ${label}`);
         try {
           const resp = await withGeminiKey(
             async (apiKey) => {
@@ -3560,17 +5104,21 @@ function registerAnalyzeCommand(parent) {
             { logger }
           );
           results.push({
-            file: filePath,
+            file: label,
             status: "success",
             response: extractText(resp)
           });
         } catch (e) {
-          const msg = e instanceof Error ? e.message : String(e);
-          logger.error(`Failed: ${filePath} \u2014 ${msg}`);
-          results.push({ file: filePath, status: "error", error: msg });
+          const msg = labelError(
+            e instanceof Error ? e.message : String(e),
+            inputs[i]
+          );
+          logger.error(`Failed: ${label} \u2014 ${msg}`);
+          results.push({ file: label, status: "error", error: msg });
         }
       }
       formatResults(results, opts.format, opts.output);
+      cleanup();
       logger.debug(
         `Done: ${results.filter((r) => r.status === "success").length}/${results.length} succeeded`
       );
@@ -3581,21 +5129,19 @@ function registerAnalyzeCommand(parent) {
 }
 
 // src/providers/gemini/commands/extract.ts
-init_errors();
-import fs21 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(
+  parent.command("extract").description("Extract structured information from files with Gemini").requiredOption("--files <paths...>", "Input file paths (use - to read piped stdin)").option("--stdin-ext <ext>", "Extension for piped stdin when auto-detection fails (e.g. mp3)").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 (!fs21.existsSync(f)) throw new ValidationError(`File not found: ${f}`);
-      }
+      const { inputs, cleanup } = await resolveFileInputs(opts.files, {
+        stdinExt: opts.stdinExt
+      });
       const generationConfig = opts.format === "json" ? { responseMimeType: "application/json" } : void 0;
       const results = [];
-      for (let i = 0; i < opts.files.length; i++) {
-        const filePath = opts.files[i];
-        logger.debug(`[${i + 1}/${opts.files.length}] Extracting: ${filePath}`);
+      for (let i = 0; i < inputs.length; i++) {
+        const { path: filePath, label } = inputs[i];
+        logger.debug(`[${i + 1}/${inputs.length}] Extracting: ${label}`);
         try {
           const resp = await withGeminiKey(
             async (apiKey) => {
@@ -3621,14 +5167,18 @@ function registerExtractCommand(parent) {
             },
             { logger }
           );
-          results.push({ file: filePath, status: "success", response: extractText(resp) });
+          results.push({ file: label, status: "success", response: extractText(resp) });
         } catch (e) {
-          const msg = e instanceof Error ? e.message : String(e);
-          logger.error(`Failed: ${filePath} \u2014 ${msg}`);
-          results.push({ file: filePath, status: "error", error: msg });
+          const msg = labelError(
+            e instanceof Error ? e.message : String(e),
+            inputs[i]
+          );
+          logger.error(`Failed: ${label} \u2014 ${msg}`);
+          results.push({ file: label, status: "error", error: msg });
         }
       }
       formatResults(results, opts.format, opts.output);
+      cleanup();
       const failed = results.filter((r) => r.status === "error").length;
       if (failed > 0) process.exit(1);
     }
@@ -3639,8 +5189,8 @@ function registerExtractCommand(parent) {
 init_errors();
 
 // src/providers/gemini/generators/speech.ts
-import fs22 from "fs";
-import path24 from "path";
+import fs23 from "fs";
+import path27 from "path";
 
 // src/providers/gemini/voices.ts
 var GEMINI_TTS_VOICES = [
@@ -3806,12 +5356,12 @@ function extractWavData(wav) {
 }
 function saveSpeech(outBytes, outputFormat, output, logger) {
   const outDir = getOutputDir();
-  const dest = path24.join(outDir, `gemini_speech_${Date.now()}.${outputFormat}`);
-  fs22.writeFileSync(dest, outBytes);
+  const dest = path27.join(outDir, `gemini_speech_${Date.now()}.${outputFormat}`);
+  fs23.writeFileSync(dest, outBytes);
   logger?.success(`Saved: ${dest} (${(outBytes.length / 1024).toFixed(1)} KB)`);
   if (output) {
-    fs22.mkdirSync(path24.dirname(path24.resolve(output)), { recursive: true });
-    fs22.copyFileSync(dest, output);
+    fs23.mkdirSync(path27.dirname(path27.resolve(output)), { recursive: true });
+    fs23.copyFileSync(dest, output);
     logger?.success(`Copied to: ${output}`);
   }
   return dest;
@@ -3924,84 +5474,24 @@ function collectSpeakers(value, prev) {
 
 // src/providers/gemini/commands/generate-video.ts
 init_errors();
-import fs24 from "fs";
-import path25 from "path";
-
-// src/providers/gemini/veo.ts
-import fs23 from "fs";
-
-// src/core/async-poll.ts
-init_errors();
-var PollTimeoutError2 = class extends MultixError {
-  constructor(message, lastStatus) {
-    super(message, "POLL_TIMEOUT");
-    this.lastStatus = lastStatus;
-    this.name = "PollTimeoutError";
-  }
-  lastStatus;
-};
-function isTransientHttpError(error) {
-  if (!(error instanceof HttpError)) return false;
-  return error.status === 0 || error.status === 429 || error.status >= 500;
-}
-var defaultSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-async function pollUntil2(opts) {
-  const now = opts.now ?? Date.now;
-  const sleep5 = opts.sleep ?? defaultSleep;
-  const random = opts.random ?? Math.random;
-  const isTransient = opts.isTransientError ?? isTransientHttpError;
-  const maxInterval = opts.maxIntervalMs ?? 15e3;
-  const minInterval = opts.minIntervalMs ?? 500;
-  const factor = opts.backoffFactor ?? 1.5;
-  const jitter = opts.jitter ?? true;
-  const deadline = now() + opts.timeoutMs;
-  let interval = opts.intervalMs ?? 3e3;
-  let attempt = 0;
-  let last;
-  let lastError;
-  for (; ; ) {
-    attempt++;
-    let retryAfterMs;
-    try {
-      last = await opts.fetchStatus({ remainingMs: Math.max(1, deadline - now()), attempt });
-      lastError = void 0;
-      opts.onPoll?.(last, attempt);
-      if (opts.isTerminal(last)) return last;
-    } catch (error) {
-      if (!isTransient(error)) throw error;
-      lastError = error;
-      if (error instanceof HttpError) retryAfterMs = error.retryAfterMs;
-    }
-    const remaining = deadline - now();
-    if (remaining <= 0) {
-      const hint = opts.resumeHint ? ` ${opts.resumeHint}` : "";
-      const cause = lastError instanceof Error ? ` Last error: ${lastError.message}.` : "";
-      throw new PollTimeoutError2(
-        `Timed out after ${opts.timeoutMs}ms waiting for job.${cause}${hint}`,
-        last
-      );
-    }
-    let delay = retryAfterMs ?? interval;
-    if (jitter && retryAfterMs === void 0) delay *= 0.8 + random() * 0.4;
-    await sleep5(Math.min(Math.max(delay, minInterval), remaining));
-    interval = Math.min(interval * factor, maxInterval);
-  }
-}
+import fs25 from "fs";
+import path28 from "path";
 
 // src/providers/gemini/veo.ts
+import fs24 from "fs";
 init_errors();
 var API_HOST = "generativelanguage.googleapis.com";
 var BASE2 = `https://${API_HOST}/v1beta`;
 var VEO_IMAGE_TYPES = /* @__PURE__ */ new Set(["image/jpeg", "image/png", "image/webp"]);
 var VEO_TIMEOUT_MS = 10 * 60 * 1e3;
 function veoImageFromFile(imgPath) {
-  if (!fs23.existsSync(imgPath)) throw new ValidationError(`Image not found: ${imgPath}`);
+  if (!fs24.existsSync(imgPath)) throw new ValidationError(`Image not found: ${imgPath}`);
   const detected = getMimeType(imgPath);
   const mimeType = detected === "application/octet-stream" ? "image/jpeg" : detected;
   if (!VEO_IMAGE_TYPES.has(mimeType)) {
     throw new ValidationError(`Veo accepts JPEG, PNG or WebP images: ${imgPath} (${mimeType})`);
   }
-  return { bytesBase64Encoded: fs23.readFileSync(imgPath).toString("base64"), mimeType };
+  return { bytesBase64Encoded: fs24.readFileSync(imgPath).toString("base64"), mimeType };
 }
 function veoFramesFromPaths(paths = []) {
   if (paths.length > 2) {
@@ -4050,7 +5540,7 @@ async function submitVeo(apiKey, model, body) {
 }
 async function waitForVeo(apiKey, operation, logger, opts = {}) {
   if (operation.done) return checkVeoResult(operation);
-  const finalOp = await pollUntil2({
+  const finalOp = await pollUntil({
     fetchStatus: ({ remainingMs }) => httpJson({
       url: `${BASE2}/${operation.name}`,
       headers: headers(apiKey),
@@ -4126,7 +5616,7 @@ function registerGenerateVideoCommand(parent) {
       logger.debug(`Submitting video generation with ${model}...`);
       logger.info("This may take 30s\u20136 minutes. Veo requires billing.");
       const frames = veoFramesFromPaths(opts.referenceImages);
-      const dest = path25.join(getOutputDir(), `veo_generated_${Date.now()}.mp4`);
+      const dest = path28.join(getOutputDir(), `veo_generated_${Date.now()}.mp4`);
       const finalOp = await runVeo(
         model,
         {
@@ -4140,8 +5630,8 @@ function registerGenerateVideoCommand(parent) {
       );
       logger.success(`Saved video: ${dest}`);
       if (opts.output) {
-        fs24.mkdirSync(path25.dirname(path25.resolve(opts.output)), { recursive: true });
-        fs24.copyFileSync(dest, opts.output);
+        fs25.mkdirSync(path28.dirname(path28.resolve(opts.output)), { recursive: true });
+        fs25.copyFileSync(dest, opts.output);
         logger.success(`Copied to: ${opts.output}`);
       }
       await maybeDownloadThumb(finalOp.response, dest, {
@@ -4157,8 +5647,8 @@ Generated video: ${dest}`);
 
 // src/providers/gemini/commands/generate.ts
 init_errors();
-import fs25 from "fs";
-import path26 from "path";
+import fs26 from "fs";
+import path29 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").addOption(imageFormatOption()).addOption(noWebpOption()).option("-v, --verbose", "Verbose logging").action(
     async (opts) => {
@@ -4203,8 +5693,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 = path26.join(outDir, fname);
-            fs25.writeFileSync(dest, Buffer.from(img.data, "base64"));
+            const dest = path29.join(outDir, fname);
+            fs26.writeFileSync(dest, Buffer.from(img.data, "base64"));
             savedFiles.push(dest);
             logger.success(`Saved: ${dest}`);
           }
@@ -4219,8 +5709,8 @@ function registerGenerateCommand(parent) {
         process.exit(1);
       }
       if (opts.output && savedFiles[0]) {
-        fs25.mkdirSync(path26.dirname(path26.resolve(opts.output)), { recursive: true });
-        fs25.copyFileSync(savedFiles[0], opts.output);
+        fs26.mkdirSync(path29.dirname(path29.resolve(opts.output)), { recursive: true });
+        fs26.copyFileSync(savedFiles[0], opts.output);
         logger.success(`Copied to: ${opts.output}`);
       }
       const finalImages = finalizeGeneratedImages(savedFiles, { ...opts, logger });
@@ -4232,8 +5722,8 @@ Generated ${finalImages.length} image(s):`);
 }
 
 // src/providers/gemini/commands/image-to-image.ts
-import fs26 from "fs";
-import path27 from "path";
+import fs27 from "fs";
+import path30 from "path";
 var SOFT_LIMIT_BYTES = 5 * 1024 * 1024;
 var HARD_LIMIT_BYTES = 7 * 1024 * 1024;
 function registerGeminiImageToImageCommand(parent) {
@@ -4294,14 +5784,14 @@ function registerGeminiImageToImageCommand(parent) {
         const img = images[i];
         if (!img) continue;
         const ext = img.mimeType.includes("png") ? "png" : "jpg";
-        const dest = path27.join(outDir, `gemini-i2i-${ts}-${i + 1}.${ext}`);
-        fs26.writeFileSync(dest, Buffer.from(img.data, "base64"));
+        const dest = path30.join(outDir, `gemini-i2i-${ts}-${i + 1}.${ext}`);
+        fs27.writeFileSync(dest, Buffer.from(img.data, "base64"));
         saved.push(dest);
         logger.success(`Saved: ${dest}`);
       }
       if (opts.output && saved[0]) {
-        fs26.mkdirSync(path27.dirname(path27.resolve(opts.output)), { recursive: true });
-        fs26.copyFileSync(saved[0], opts.output);
+        fs27.mkdirSync(path30.dirname(path30.resolve(opts.output)), { recursive: true });
+        fs27.copyFileSync(saved[0], opts.output);
         logger.success(`Copied to: ${opts.output}`);
       }
       const finalImages = finalizeGeneratedImages(saved, { ...opts, logger });
@@ -4329,7 +5819,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 = path27.extname(new URL(url).pathname).toLowerCase();
+  const ext = path30.extname(new URL(url).pathname).toLowerCase();
   if (ext === ".png") return "image/png";
   if (ext === ".webp") return "image/webp";
   if (ext === ".gif") return "image/gif";
@@ -4338,8 +5828,8 @@ function sniffImageMime(buf, url) {
 
 // src/providers/gemini/commands/image-to-video.ts
 init_errors();
-import fs27 from "fs";
-import path28 from "path";
+import fs28 from "fs";
+import path31 from "path";
 function registerGeminiImageToVideoCommand(parent) {
   parent.command("image-to-video <imagePath>").alias("i2v").description("Generate video from a starting image with Veo (image-to-video) [EXPERIMENTAL]").requiredOption("--prompt <text>", "Motion/scene prompt").option("--last-frame <path>", "Optional closing frame image (Veo 3.1)").option("--model <id>", "Veo model id").option("--resolution <res>", "720p|1080p", "1080p").option("--aspect-ratio <ratio>", "Aspect ratio", "16:9").option("--output <path>", "Copy generated video to this path").option("--no-thumb", "Skip downloading the thumbnail if the API returns one").option("-v, --verbose", "Verbose logging").action(
     async (imagePath, opts) => {
@@ -4359,7 +5849,7 @@ function registerGeminiImageToVideoCommand(parent) {
       logger.info(
         "Submitting image-to-video. This may take 30s\u20136 minutes. Veo requires billing."
       );
-      const dest = path28.join(getOutputDir(), `veo_i2v_${Date.now()}.mp4`);
+      const dest = path31.join(getOutputDir(), `veo_i2v_${Date.now()}.mp4`);
       const finalOp = await runVeo(
         model,
         {
@@ -4374,8 +5864,8 @@ function registerGeminiImageToVideoCommand(parent) {
       );
       logger.success(`Saved video: ${dest}`);
       if (opts.output) {
-        fs27.mkdirSync(path28.dirname(path28.resolve(opts.output)), { recursive: true });
-        fs27.copyFileSync(dest, opts.output);
+        fs28.mkdirSync(path31.dirname(path31.resolve(opts.output)), { recursive: true });
+        fs28.copyFileSync(dest, opts.output);
         logger.success(`Copied to: ${opts.output}`);
       }
       await maybeDownloadThumb(finalOp.response, dest, {
@@ -4390,20 +5880,21 @@ Generated video: ${dest}`);
 }
 
 // src/providers/gemini/commands/transcribe.ts
-init_errors();
-import fs28 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(
+  parent.command("transcribe").description("Transcribe audio or video files with Gemini").requiredOption(
+    "--files <paths...>",
+    "Audio/video file paths to transcribe (use - to read piped stdin)"
+  ).option("--stdin-ext <ext>", "Extension for piped stdin when auto-detection fails (e.g. mp3)").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 (!fs28.existsSync(f)) throw new ValidationError(`File not found: ${f}`);
-      }
+      const { inputs, cleanup } = await resolveFileInputs(opts.files, {
+        stdinExt: opts.stdinExt
+      });
       const results = [];
-      for (let i = 0; i < opts.files.length; i++) {
-        const filePath = opts.files[i];
-        logger.debug(`[${i + 1}/${opts.files.length}] Transcribing: ${filePath}`);
+      for (let i = 0; i < inputs.length; i++) {
+        const { path: filePath, label } = inputs[i];
+        logger.debug(`[${i + 1}/${inputs.length}] Transcribing: ${label}`);
         try {
           const resp = await withGeminiKey(
             async (apiKey) => {
@@ -4430,17 +5921,21 @@ function registerTranscribeCommand2(parent) {
             { logger }
           );
           results.push({
-            file: filePath,
+            file: label,
             status: "success",
             response: extractText(resp)
           });
         } catch (e) {
-          const msg = e instanceof Error ? e.message : String(e);
-          logger.error(`Failed: ${filePath} \u2014 ${msg}`);
-          results.push({ file: filePath, status: "error", error: msg });
+          const msg = labelError(
+            e instanceof Error ? e.message : String(e),
+            inputs[i]
+          );
+          logger.error(`Failed: ${label} \u2014 ${msg}`);
+          results.push({ file: label, status: "error", error: msg });
         }
       }
       formatResults(results, opts.format, opts.output);
+      cleanup();
       const failed = results.filter((r) => r.status === "error").length;
       if (failed > 0) process.exit(1);
     }
@@ -4464,7 +5959,7 @@ function registerGeminiCommands(program2) {
 
 // src/providers/leonardo/commands/generate.ts
 import fs29 from "fs";
-import path29 from "path";
+import path32 from "path";
 
 // src/providers/leonardo/client.ts
 init_errors();
@@ -4537,11 +6032,11 @@ var LeonardoClient = class {
   }
   apiKey;
   baseUrl;
-  async request(path49, opts = {}) {
+  async request(path52, opts = {}) {
     const base = this.baseUrl.replace(/\/$/, "");
-    const v2Override = path49.startsWith("v2:");
+    const v2Override = path52.startsWith("v2:");
     const finalBase = v2Override ? base.replace(/\/v1$/, "/v2") : base;
-    const finalPath = v2Override ? path49.slice(3) : path49;
+    const finalPath = v2Override ? path52.slice(3) : path52;
     const url = new URL(finalBase + finalPath);
     if (opts.query) {
       for (const [k, v] of Object.entries(opts.query)) {
@@ -4560,14 +6055,14 @@ var LeonardoClient = class {
       timeoutMs: opts.timeoutMs ?? 12e4
     });
   }
-  get(path49, query, logger) {
-    return this.request(path49, { method: "GET", query, logger });
+  get(path52, query, logger) {
+    return this.request(path52, { method: "GET", query, logger });
   }
-  post(path49, body, logger) {
-    return this.request(path49, { method: "POST", body, logger });
+  post(path52, body, logger) {
+    return this.request(path52, { method: "POST", body, logger });
   }
-  delete(path49, logger) {
-    return this.request(path49, { method: "DELETE", logger });
+  delete(path52, logger) {
+    return this.request(path52, { method: "DELETE", logger });
   }
 };
 function createLeonardoClient() {
@@ -4578,7 +6073,7 @@ function createLeonardoClient() {
 function extFromUrl2(url, fallback = ".png") {
   try {
     const u = new URL(url);
-    const e = path29.extname(u.pathname);
+    const e = path32.extname(u.pathname);
     return e.length > 0 ? e : fallback;
   } catch {
     return fallback;
@@ -4663,7 +6158,7 @@ function registerLeonardoGenerateCommand(parent) {
         if (!img) continue;
         const ext = extFromUrl2(img.url);
         const filename = autoFilename(generationId, i + 1, ext);
-        const filepath = path29.join(outDir, filename);
+        const filepath = path32.join(outDir, filename);
         try {
           await downloadFile(img.url, filepath);
           saved.push(filepath);
@@ -4673,8 +6168,8 @@ function registerLeonardoGenerateCommand(parent) {
         }
       }
       if (opts.output && saved[0]) {
-        const dest = path29.resolve(opts.output);
-        fs29.mkdirSync(path29.dirname(dest), { recursive: true });
+        const dest = path32.resolve(opts.output);
+        fs29.mkdirSync(path32.dirname(dest), { recursive: true });
         fs29.copyFileSync(saved[0], dest);
         logger.success(`Copied to ${dest}`);
       }
@@ -4688,10 +6183,10 @@ Generated ${finalImages.length} image(s):`);
 
 // src/providers/leonardo/commands/image-to-image.ts
 import fs30 from "fs";
-import path30 from "path";
+import path33 from "path";
 function extFromUrl3(url, fallback = ".png") {
   try {
-    return path30.extname(new URL(url).pathname) || fallback;
+    return path33.extname(new URL(url).pathname) || fallback;
   } catch {
     return fallback;
   }
@@ -4753,7 +6248,7 @@ function registerLeonardoImageToImageCommand(parent) {
         if (!img) continue;
         const ext = extFromUrl3(img.url);
         const filename = `leonardo-i2i-${generationId.slice(0, 8)}-${String(i + 1).padStart(2, "0")}${ext}`;
-        const filepath = path30.join(outDir, filename);
+        const filepath = path33.join(outDir, filename);
         try {
           await downloadFile(img.url, filepath);
           saved.push(filepath);
@@ -4763,8 +6258,8 @@ function registerLeonardoImageToImageCommand(parent) {
         }
       }
       if (opts.output && saved[0]) {
-        const dest = path30.resolve(opts.output);
-        fs30.mkdirSync(path30.dirname(dest), { recursive: true });
+        const dest = path33.resolve(opts.output);
+        fs30.mkdirSync(path33.dirname(dest), { recursive: true });
         fs30.copyFileSync(saved[0], dest);
         logger.success(`Copied to ${dest}`);
       }
@@ -4777,7 +6272,7 @@ Generated ${finalImages.length} image(s):`);
 }
 
 // src/providers/leonardo/commands/video.ts
-import path31 from "path";
+import path34 from "path";
 function v2DimsFor(resolution) {
   if (resolution === "RESOLUTION_1080") return { width: 1920, height: 1080 };
   if (resolution === "RESOLUTION_480") return { width: 854, height: 480 };
@@ -4862,7 +6357,7 @@ async function pollAndDownload(client, jobId, opts) {
       onTick: (n, v) => logger.debug(`attempt ${n} \u2014 status: ${v.generations_by_pk?.status}`)
     });
   } catch (e) {
-    if (e instanceof PollTimeoutError) {
+    if (e instanceof PollTimeoutError2) {
       logger.error(`Timed out \u2014 multix leonardo status ${jobId}`);
       process.exit(1);
     }
@@ -4888,7 +6383,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 ?? path31.join(getOutputDir(), `${opts.basename}-${jobId.slice(0, 8)}.mp4`);
+  const outPath = opts.output ?? path34.join(getOutputDir(), `${opts.basename}-${jobId.slice(0, 8)}.mp4`);
   await downloadFile(videoUrl2, outPath);
   logger.success(`Saved ${outPath}`);
   await maybeDownloadThumb(gen, outPath, {
@@ -4994,7 +6489,7 @@ function registerLeonardoModelsCommand(parent) {
 }
 
 // src/providers/leonardo/commands/status.ts
-import path32 from "path";
+import path35 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;
@@ -5034,7 +6529,7 @@ function registerLeonardoStatusCommand(parent) {
           onTick: (n, v) => logger.debug(`attempt ${n} \u2014 status: ${v.generations_by_pk?.status}`)
         }) : await fetchOnce();
       } catch (e) {
-        if (e instanceof PollTimeoutError) {
+        if (e instanceof PollTimeoutError2) {
           logger.error(`Timed out waiting for generation ${generationId}`);
           process.exit(1);
         }
@@ -5059,7 +6554,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 : path32.join(outDir, `leonardo-${generationId.slice(0, 8)}-${idx}.mp4`);
+        const dest = opts.output && videos.length === 1 && images.length === 0 ? opts.output : path35.join(outDir, `leonardo-${generationId.slice(0, 8)}-${idx}.mp4`);
         await downloadFile(url, dest);
         logger.success(`Saved ${dest}`);
         await maybeDownloadThumb(gen, dest, {
@@ -5072,7 +6567,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 = path32.join(outDir, `leonardo-${generationId.slice(0, 8)}-${idx}.${ext}`);
+        const dest = path35.join(outDir, `leonardo-${generationId.slice(0, 8)}-${idx}.${ext}`);
         await downloadFile(url, dest);
         logger.success(`Saved ${dest}`);
         idx++;
@@ -5230,7 +6725,7 @@ function sleep3(ms) {
 
 // src/providers/minimax/generators/music.ts
 import fs31 from "fs";
-import path33 from "path";
+import path36 from "path";
 async function generateMinimaxMusic(opts) {
   const {
     apiKey,
@@ -5275,7 +6770,7 @@ async function generateMinimaxMusic(opts) {
   }
   const durationMs = resp.extra_info?.music_duration ?? 0;
   const outDir = getOutputDir();
-  const dest = path33.join(outDir, `minimax_music_${Date.now()}.${outputFormat}`);
+  const dest = path36.join(outDir, `minimax_music_${Date.now()}.${outputFormat}`);
   try {
     if (audioData.startsWith("http")) {
       const bytes = await fetchBytes(audioData);
@@ -5293,7 +6788,7 @@ async function generateMinimaxMusic(opts) {
   const durSec = durationMs / 1e3;
   logger?.success(`Saved: ${dest} (${durSec.toFixed(1)}s)`);
   if (output) {
-    fs31.mkdirSync(path33.dirname(path33.resolve(output)), { recursive: true });
+    fs31.mkdirSync(path36.dirname(path36.resolve(output)), { recursive: true });
     fs31.copyFileSync(dest, output);
   }
   return { status: "success", generatedAudio: dest, durationMs, model };
@@ -5369,7 +6864,7 @@ init_errors();
 
 // src/providers/minimax/generators/speech.ts
 import fs32 from "fs";
-import path34 from "path";
+import path37 from "path";
 async function generateMinimaxSpeech(opts) {
   const {
     apiKey,
@@ -5416,11 +6911,11 @@ async function generateMinimaxSpeech(opts) {
   const audioBytes = Buffer.from(audioHex, "hex");
   const ext = ["mp3", "wav", "flac"].includes(outputFormat) ? outputFormat : "mp3";
   const outDir = getOutputDir();
-  const dest = path34.join(outDir, `minimax_speech_${Date.now()}.${ext}`);
+  const dest = path37.join(outDir, `minimax_speech_${Date.now()}.${ext}`);
   fs32.writeFileSync(dest, audioBytes);
   logger?.success(`Saved: ${dest} (${(audioBytes.length / 1024).toFixed(1)} KB)`);
   if (output) {
-    fs32.mkdirSync(path34.dirname(path34.resolve(output)), { recursive: true });
+    fs32.mkdirSync(path37.dirname(path37.resolve(output)), { recursive: true });
     fs32.copyFileSync(dest, output);
   }
   return { status: "success", generatedAudio: dest, model };
@@ -5469,7 +6964,7 @@ init_errors();
 
 // src/providers/minimax/generators/video.ts
 import fs33 from "fs";
-import path35 from "path";
+import path38 from "path";
 async function generateMinimaxVideo(opts) {
   const {
     apiKey,
@@ -5515,7 +7010,7 @@ async function generateMinimaxVideo(opts) {
     return { status: "error", error: `No file_id in poll result: ${JSON.stringify(pollResult)}` };
   }
   const outDir = getOutputDir();
-  const dest = path35.join(outDir, `minimax_video_${Date.now()}.mp4`);
+  const dest = path38.join(outDir, `minimax_video_${Date.now()}.mp4`);
   try {
     await downloadMinimaxFile(fileId, apiKey, dest, logger);
   } catch (e) {
@@ -5525,7 +7020,7 @@ async function generateMinimaxVideo(opts) {
   const stat = fs33.statSync(dest);
   const fileSizeMb = stat.size / (1024 * 1024);
   if (output) {
-    fs33.mkdirSync(path35.dirname(path35.resolve(output)), { recursive: true });
+    fs33.mkdirSync(path38.dirname(path38.resolve(output)), { recursive: true });
     fs33.copyFileSync(dest, output);
   }
   await maybeDownloadThumb(pollResult, dest, {
@@ -5589,7 +7084,7 @@ Generated video: ${result.generatedVideo}`);
 // src/providers/minimax/generators/image.ts
 init_errors();
 import fs34 from "fs";
-import path36 from "path";
+import path39 from "path";
 async function generateMinimaxImage(opts) {
   const {
     apiKey,
@@ -5627,7 +7122,7 @@ async function generateMinimaxImage(opts) {
     try {
       const bytes = await fetchBytes(url);
       const fname = `minimax_image_${Date.now()}_${i}.png`;
-      const dest = path36.join(outDir, fname);
+      const dest = path39.join(outDir, fname);
       fs34.writeFileSync(dest, bytes);
       savedFiles.push(dest);
       logger?.success(`Saved: ${dest}`);
@@ -5639,7 +7134,7 @@ async function generateMinimaxImage(opts) {
     }
   }
   if (output && savedFiles[0]) {
-    fs34.mkdirSync(path36.dirname(path36.resolve(output)), { recursive: true });
+    fs34.mkdirSync(path39.dirname(path39.resolve(output)), { recursive: true });
     fs34.copyFileSync(savedFiles[0], output);
   }
   return { status: "success", generatedImages: savedFiles, model };
@@ -5680,7 +7175,7 @@ Generated ${finalImages.length} image(s):`);
 // src/providers/minimax/commands/image-to-image.ts
 init_errors();
 import fs35 from "fs";
-import path37 from "path";
+import path40 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."
@@ -5735,7 +7230,7 @@ function registerMinimaxImageToImageCommand(parent) {
         if (!url) continue;
         try {
           const bytes = await fetchBytes(url);
-          const dest = path37.join(outDir, `minimax-i2i-${ts}-${i + 1}.png`);
+          const dest = path40.join(outDir, `minimax-i2i-${ts}-${i + 1}.png`);
           fs35.writeFileSync(dest, bytes);
           saved.push(dest);
           logger.success(`Saved: ${dest}`);
@@ -5747,7 +7242,7 @@ function registerMinimaxImageToImageCommand(parent) {
         }
       }
       if (opts.output && saved[0]) {
-        fs35.mkdirSync(path37.dirname(path37.resolve(opts.output)), { recursive: true });
+        fs35.mkdirSync(path40.dirname(path40.resolve(opts.output)), { recursive: true });
         fs35.copyFileSync(saved[0], opts.output);
         logger.success(`Copied to: ${opts.output}`);
       }
@@ -5883,11 +7378,11 @@ function validateKnownSpeakerPairing(names = [], refs = []) {
 
 // src/providers/openai/openai-audio.ts
 import fs37 from "fs";
-import path39 from "path";
+import path42 from "path";
 
 // src/providers/openai/client.ts
 import fs36 from "fs";
-import path38 from "path";
+import path41 from "path";
 init_errors();
 var DEFAULT_TIMEOUT_MS3 = 24e4;
 function requireOpenAIKey() {
@@ -5953,10 +7448,10 @@ async function postOpenAIBinary(pathname, body, apiKey, timeoutMs = DEFAULT_TIME
   return Buffer.from(await res.arrayBuffer());
 }
 function fileFromPath(filePath) {
-  const abs = path38.resolve(filePath);
+  const abs = path41.resolve(filePath);
   if (!fs36.existsSync(abs)) throw new ValidationError(`File not found: ${abs}`);
   const bytes = fs36.readFileSync(abs);
-  return new File([new Uint8Array(bytes)], path38.basename(abs));
+  return new File([new Uint8Array(bytes)], path41.basename(abs));
 }
 
 // src/providers/openai/openai-audio.ts
@@ -5995,7 +7490,7 @@ async function resolveAudioReferenceDataUrl(ref) {
 }
 function audioMimeFromReference(ref) {
   const pathname = new URL(ref).pathname;
-  const ext = path39.extname(pathname).toLowerCase();
+  const ext = path42.extname(pathname).toLowerCase();
   switch (ext) {
     case ".mp3":
       return "audio/mpeg";
@@ -6014,11 +7509,11 @@ function audioMimeFromReference(ref) {
 async function generateOpenAISpeech(opts) {
   const bytes = await postOpenAIBinary("/audio/speech", buildSpeechBody(opts), requireOpenAIKey());
   const ext = extFromAudioFormat(opts.outputFormat);
-  const dest = path39.join(getOutputDir(), `openai-speech-${Date.now()}.${ext}`);
+  const dest = path42.join(getOutputDir(), `openai-speech-${Date.now()}.${ext}`);
   fs37.writeFileSync(dest, bytes);
   opts.logger?.success(`Saved: ${dest} (${(bytes.length / 1024).toFixed(1)} KB)`);
   if (opts.output) {
-    fs37.mkdirSync(path39.dirname(path39.resolve(opts.output)), { recursive: true });
+    fs37.mkdirSync(path42.dirname(path42.resolve(opts.output)), { recursive: true });
     fs37.copyFileSync(dest, opts.output);
   }
   return dest;
@@ -6041,8 +7536,8 @@ 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 ? path39.resolve(opts.output) : path39.join(getOutputDir(), `openai-transcribe-${Date.now()}.${ext}`);
-  fs37.mkdirSync(path39.dirname(dest), { recursive: true });
+  const dest = opts.output ? path42.resolve(opts.output) : path42.join(getOutputDir(), `openai-transcribe-${Date.now()}.${ext}`);
+  fs37.mkdirSync(path42.dirname(dest), { recursive: true });
   fs37.writeFileSync(dest, opts.format === "text" ? text ?? "" : JSON.stringify(data, null, 2));
   opts.logger?.success(`Saved transcript: ${dest}`);
   return { path: dest, text };
@@ -6071,8 +7566,8 @@ Generated audio: ${dest}`);
 
 // src/providers/openai/codex-image-driver.ts
 import fs38 from "fs";
-import os2 from "os";
-import path40 from "path";
+import os3 from "os";
+import path43 from "path";
 import { execa } from "execa";
 init_errors();
 var defaultRunner = async (cmd, args, opts) => {
@@ -6121,11 +7616,11 @@ function sanitizeCodexEnv() {
 async function runCodexImageGeneration(opts) {
   const runner = opts.runner ?? defaultRunner;
   const ext = extFromImageFormat(opts.outputFormat);
-  const dest = opts.output ? path40.resolve(opts.output) : path40.join(getOutputDir(), `codex-image-${Date.now()}.${ext}`);
-  fs38.mkdirSync(path40.dirname(dest), { recursive: true });
-  const tmp = fs38.mkdtempSync(path40.join(os2.tmpdir(), "multix-codex-image-"));
-  const schema = path40.join(tmp, "schema.json");
-  const result = path40.join(tmp, "result.json");
+  const dest = opts.output ? path43.resolve(opts.output) : path43.join(getOutputDir(), `codex-image-${Date.now()}.${ext}`);
+  fs38.mkdirSync(path43.dirname(dest), { recursive: true });
+  const tmp = fs38.mkdtempSync(path43.join(os3.tmpdir(), "multix-codex-image-"));
+  const schema = path43.join(tmp, "schema.json");
+  const result = path43.join(tmp, "result.json");
   fs38.writeFileSync(
     schema,
     JSON.stringify({
@@ -6174,7 +7669,7 @@ function buildCodexPrompt(userPrompt, outputPath) {
 // src/providers/openai/openai-image.ts
 init_errors();
 import fs39 from "fs";
-import path41 from "path";
+import path44 from "path";
 function buildImageGenerationBody(opts) {
   return {
     model: opts.model ?? DEFAULT_OPENAI_IMAGE_MODEL,
@@ -6207,13 +7702,13 @@ 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 = path41.join(outDir, `openai-${opts.task}-${ts}-${i + 1}.${ext}`);
+    const dest = path44.join(outDir, `openai-${opts.task}-${ts}-${i + 1}.${ext}`);
     fs39.writeFileSync(dest, Buffer.from(b64, "base64"));
     saved.push(dest);
     opts.logger?.success(`Saved: ${dest}`);
   }
   if (opts.output && saved[0]) {
-    fs39.mkdirSync(path41.dirname(path41.resolve(opts.output)), { recursive: true });
+    fs39.mkdirSync(path44.dirname(path44.resolve(opts.output)), { recursive: true });
     fs39.copyFileSync(saved[0], opts.output);
     opts.logger?.success(`Copied to: ${opts.output}`);
   }
@@ -6223,7 +7718,7 @@ async function resolveImageRefBytes(ref) {
   if (isHttpUrl(ref)) {
     const bytes2 = await fetchBytes(ref);
     const pathname = new URL(ref).pathname;
-    const filename = path41.basename(pathname) || "reference.png";
+    const filename = path44.basename(pathname) || "reference.png";
     return { filename, bytes: bytes2, mime: sniffImageMime2(bytes2, filename) };
   }
   const file = fileFromPath(ref);
@@ -6268,7 +7763,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 = path41.extname(name).toLowerCase();
+  const ext = path44.extname(name).toLowerCase();
   if (ext === ".jpg" || ext === ".jpeg") return "image/jpeg";
   if (ext === ".webp") return "image/webp";
   return "image/png";
@@ -6413,7 +7908,7 @@ function registerOpenAICommands(program2) {
 
 // src/providers/openrouter/client.ts
 import fs40 from "fs";
-import path42 from "path";
+import path45 from "path";
 init_errors();
 
 // src/providers/openrouter/payload.ts
@@ -6577,7 +8072,7 @@ async function generateOpenRouterImage(opts) {
     if (!url) continue;
     try {
       const bytes = await fetchBytes(url);
-      const dest = path42.join(outDir, `openrouter_image_${Date.now()}_${i}.png`);
+      const dest = path45.join(outDir, `openrouter_image_${Date.now()}_${i}.png`);
       fs40.writeFileSync(dest, bytes);
       savedFiles.push(dest);
       logger?.success(`Saved: ${dest}`);
@@ -6589,7 +8084,7 @@ async function generateOpenRouterImage(opts) {
     }
   }
   if (output && savedFiles[0]) {
-    fs40.mkdirSync(path42.dirname(path42.resolve(output)), { recursive: true });
+    fs40.mkdirSync(path45.dirname(path45.resolve(output)), { recursive: true });
     fs40.writeFileSync(output, fs40.readFileSync(savedFiles[0]));
   }
   return { status: "success", generatedImages: savedFiles, model: usedModel };
@@ -6632,7 +8127,7 @@ Generated ${finalImages.length} image(s):`);
 
 // src/providers/openrouter/commands/image-to-image.ts
 import fs41 from "fs";
-import path43 from "path";
+import path46 from "path";
 init_errors();
 var DEFAULT_MODEL = "google/gemini-2.5-flash-image";
 var SOFT_LIMIT_BYTES2 = 5 * 1024 * 1024;
@@ -6724,13 +8219,13 @@ async function runImageToImage(opts) {
     const url = parsed.urls[i];
     if (!url) continue;
     const bytes = await fetchBytes(url);
-    const dest = path43.join(outDir, `openrouter-i2i-${ts}-${i + 1}.png`);
+    const dest = path46.join(outDir, `openrouter-i2i-${ts}-${i + 1}.png`);
     fs41.writeFileSync(dest, bytes);
     saved.push(dest);
     opts.logger.success(`Saved: ${dest}`);
   }
   if (opts.output && saved[0]) {
-    fs41.mkdirSync(path43.dirname(path43.resolve(opts.output)), { recursive: true });
+    fs41.mkdirSync(path46.dirname(path46.resolve(opts.output)), { recursive: true });
     fs41.copyFileSync(saved[0], opts.output);
     opts.logger.success(`Copied to: ${opts.output}`);
   }
@@ -6777,12 +8272,12 @@ async function listVideoModels(apiKey = requireOpenRouterKey()) {
 
 // src/providers/openrouter/commands/video-status.ts
 import fs42 from "fs";
-import path44 from "path";
+import path47 from "path";
 async function downloadOpenRouterVideo(opts) {
   const { jobId, logger, source } = opts;
   const apiKey = requireOpenRouterKey();
   const url = videoContentUrl(jobId);
-  const dest = path44.join(getOutputDir(), `openrouter_video_${jobId}.mp4`);
+  const dest = path47.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}`);
@@ -6792,13 +8287,13 @@ async function downloadOpenRouterVideo(opts) {
     logger.error("Empty response body");
     process.exit(1);
   }
-  fs42.mkdirSync(path44.dirname(dest), { recursive: true });
+  fs42.mkdirSync(path47.dirname(dest), { recursive: true });
   const ws = fs42.createWriteStream(dest);
   const { pipeline: pipeline2 } = await import("stream/promises");
   await pipeline2(r.body, ws);
   logger.success(`Saved ${dest}`);
   if (opts.output) {
-    fs42.mkdirSync(path44.dirname(path44.resolve(opts.output)), { recursive: true });
+    fs42.mkdirSync(path47.dirname(path47.resolve(opts.output)), { recursive: true });
     fs42.copyFileSync(dest, opts.output);
     logger.success(`Copied to ${opts.output}`);
   }
@@ -6828,7 +8323,7 @@ function registerOpenRouterVideoStatusCommand(parent) {
           onTick: (n, v) => logger.debug(`attempt ${n} \u2014 status: ${v.status}`)
         }) : await pollVideoJob(jobId);
       } catch (e) {
-        if (e instanceof PollTimeoutError) {
+        if (e instanceof PollTimeoutError2) {
           logger.error(`Timed out waiting for job ${jobId}`);
           process.exit(1);
         }
@@ -6912,7 +8407,7 @@ function registerOpenRouterImageToVideoCommand(parent) {
           onTick: (n, v) => logger.debug(`attempt ${n} \u2014 status: ${v.status}`)
         });
       } catch (e) {
-        if (e instanceof PollTimeoutError) {
+        if (e instanceof PollTimeoutError2) {
           logger.error(`Timed out \u2014 multix openrouter video-status ${res.id}`);
           process.exit(1);
         }
@@ -6966,7 +8461,7 @@ function registerOpenRouterCommands(program2) {
 
 // src/commands/check.ts
 import fs43 from "fs";
-import os3 from "os";
+import os4 from "os";
 
 // src/commands/check-helpers/binary-check.ts
 import { execa as execa2 } from "execa";
@@ -7022,6 +8517,7 @@ To configure multix, set at least one provider API key:
     Leonardo.Ai        : https://app.leonardo.ai/settings/api-keys
     BytePlus           : https://console.byteplus.com/auth/api-keys
     fal.ai             : https://fal.ai/dashboard/keys
+    Atlas Cloud        : https://www.atlascloud.ai/console/api-keys
 
   Option A \u2014 user global config (recommended):
     echo 'GEMINI_API_KEY=your-key' >> ~/.multix/.env
@@ -7090,6 +8586,12 @@ var PROVIDERS = [
     envPrimary: "FAL_KEY",
     optional: true,
     link: "https://fal.ai/dashboard/keys"
+  },
+  {
+    name: "Atlas Cloud",
+    envPrimary: "ATLASCLOUD_API_KEY",
+    optional: true,
+    link: "https://www.atlascloud.ai/console/api-keys"
   }
 ];
 function resolveProviderKey(p) {
@@ -7144,7 +8646,7 @@ function registerCheckCommand(program2) {
       logger.info(`Env files loaded: ${files.length > 0 ? files.join(", ") : "none"}`);
     }
     if (!legacyClaudeEnvEnabled()) {
-      const home = process.env.MULTIX_DISABLE_HOME_ENV ? void 0 : os3.homedir();
+      const home = process.env.MULTIX_DISABLE_HOME_ENV ? void 0 : os4.homedir();
       const legacy = legacyClaudeEnvFiles(process.cwd(), home).filter((f) => fs43.existsSync(f));
       if (legacy.length > 0) {
         logger.info(
@@ -7251,7 +8753,7 @@ function registerCheckCommand(program2) {
 // src/commands/doc/convert.ts
 init_errors();
 import fs44 from "fs";
-import path45 from "path";
+import path48 from "path";
 
 // src/commands/doc/default-prompt.ts
 var DEFAULT_CONVERT_PROMPT = `Convert this document to clean, well-formatted Markdown.
@@ -7276,14 +8778,14 @@ async function convertDocuments(opts) {
   }
   let outputPath;
   if (output) {
-    outputPath = path45.resolve(output);
+    outputPath = path48.resolve(output);
   } else if (autoName && inputs.length === 1 && inputs[0]) {
-    const base = path45.basename(inputs[0], path45.extname(inputs[0]));
-    outputPath = path45.join(getOutputDir(), `${base}-extraction.md`);
+    const base = path48.basename(inputs[0], path48.extname(inputs[0]));
+    outputPath = path48.join(getOutputDir(), `${base}-extraction.md`);
   } else {
-    outputPath = path45.join(getOutputDir(), "document-extraction.md");
+    outputPath = path48.join(getOutputDir(), "document-extraction.md");
   }
-  fs44.mkdirSync(path45.dirname(outputPath), { recursive: true });
+  fs44.mkdirSync(path48.dirname(outputPath), { recursive: true });
   const results = [];
   for (let i = 0; i < inputs.length; i++) {
     const filePath = inputs[i];
@@ -7343,7 +8845,7 @@ async function convertDocuments(opts) {
 `);
   for (const r of results) {
     lines.push(`
-## ${path45.basename(r.file)}
+## ${path48.basename(r.file)}
 `);
     if (r.status === "success" && r.markdown) {
       lines.push(`${r.markdown}
@@ -7405,11 +8907,11 @@ function registerDocCommands(program2) {
 // src/commands/media/index.ts
 init_errors();
 import fs47 from "fs";
-import path48 from "path";
+import path51 from "path";
 
 // src/commands/media/batch.ts
 import fs45 from "fs";
-import path46 from "path";
+import path49 from "path";
 
 // src/commands/media/detect-type.ts
 var VIDEO_EXTS = /* @__PURE__ */ new Set([".mp4", ".mov", ".avi", ".mkv", ".webm", ".flv", ".mpg", ".mpeg"]);
@@ -7608,7 +9110,7 @@ async function batchOptimize(opts) {
   fs45.mkdirSync(outputDir, { recursive: true });
   const entries = fs45.readdirSync(inputDir);
   const mediaFiles = entries.filter((f) => {
-    const ext = path46.extname(f).toLowerCase();
+    const ext = path49.extname(f).toLowerCase();
     return ALL_EXTS.has(ext);
   });
   if (mediaFiles.length === 0) {
@@ -7619,9 +9121,9 @@ async function batchOptimize(opts) {
   let succeeded = 0;
   const errors = [];
   for (const file of mediaFiles) {
-    const inputPath = path46.join(inputDir, file);
-    const outputPath = path46.join(outputDir, file);
-    const ext = path46.extname(file).toLowerCase();
+    const inputPath = path49.join(inputDir, file);
+    const outputPath = path49.join(outputDir, file);
+    const ext = path49.extname(file).toLowerCase();
     const kind = extToKind(ext);
     logger?.debug(`Processing: ${file}`);
     try {
@@ -7659,7 +9161,7 @@ async function batchOptimize(opts) {
 // src/commands/media/split-video.ts
 init_errors();
 import fs46 from "fs";
-import path47 from "path";
+import path50 from "path";
 async function splitVideo(opts) {
   await assertFfmpeg();
   const { input, outputDir, chunkDuration = 3600, verbose, logger } = opts;
@@ -7671,9 +9173,9 @@ async function splitVideo(opts) {
     return [input];
   }
   fs46.mkdirSync(outputDir, { recursive: true });
-  const ext = path47.extname(input) || ".mp4";
-  const baseName = path47.basename(input, ext);
-  const outputPattern = path47.join(outputDir, `${baseName}_chunk_%03d${ext}`);
+  const ext = path50.extname(input) || ".mp4";
+  const baseName = path50.basename(input, ext);
+  const outputPattern = path50.join(outputDir, `${baseName}_chunk_%03d${ext}`);
   logger?.debug(`Splitting into ~${numChunks} chunks of ${chunkDuration}s each`);
   const args = [
     "-i",
@@ -7692,7 +9194,7 @@ async function splitVideo(opts) {
   await runFfmpeg(args, { verbose, logger });
   const files = [];
   for (let i = 0; i < numChunks + 1; i++) {
-    const fname = path47.join(outputDir, `${baseName}_chunk_${String(i).padStart(3, "0")}${ext}`);
+    const fname = path50.join(outputDir, `${baseName}_chunk_${String(i).padStart(3, "0")}${ext}`);
     if (fs46.existsSync(fname)) files.push(fname);
   }
   logger?.success(`Created ${files.length} chunks in ${outputDir}`);
@@ -7708,8 +9210,8 @@ function registerMediaCommands(program2) {
     async (opts) => {
       const logger = createLogger({ verbose: opts.verbose ?? false });
       if (!fs47.existsSync(opts.input)) throw new ValidationError(`Input not found: ${opts.input}`);
-      fs47.mkdirSync(path48.dirname(path48.resolve(opts.output)), { recursive: true });
-      const ext = path48.extname(opts.input).toLowerCase();
+      fs47.mkdirSync(path51.dirname(path51.resolve(opts.output)), { recursive: true });
+      const ext = path51.extname(opts.input).toLowerCase();
       const kind = extToKind(ext);
       if (!kind) throw new ValidationError(`Unsupported file type: ${ext}`);
       const quality = Number.parseInt(opts.quality, 10);
@@ -7945,6 +9447,7 @@ function registerCommands(program2) {
   registerCloudflareCommands(program2);
   registerElevenLabsCommands(program2);
   registerFalCommands(program2);
+  registerAtlasCloudCommands(program2);
   registerMediaCommands(program2);
   registerDocCommands(program2);
 }
@@ -7958,7 +9461,7 @@ loadEnv();
 var require3 = createRequire2(import.meta.url);
 var pkg = require3("../package.json");
 var program = new Command().name("multix").description(
-  "AI multimodal CLI \u2014 image/video/audio/3D generation, editing, transcription, and media processing via OpenAI, Gemini, MiniMax, OpenRouter, Leonardo, BytePlus, ElevenLabs, fal.ai, ffmpeg, and ImageMagick"
+  "AI multimodal CLI \u2014 image/video/audio/3D generation, editing, transcription, and media processing via OpenAI, Gemini, MiniMax, OpenRouter, Leonardo, BytePlus, ElevenLabs, fal.ai, Atlas Cloud, ffmpeg, and ImageMagick"
 ).version(pkg.version);
 registerCommands(program);
 program.parseAsync(process.argv).catch((err2) => {