@mediaruntime/cli 1.2.0 → 1.4.0

package/dist/cli.js

@@ -20,6 +20,7 @@ import {
   MediaRuntimeApiError,
   MediaRuntimeConnectionError
 } from "@mediaruntime/node";
+import * as MediaRuntimeSdk from "@mediaruntime/node";
 
 // src/errors.ts
 var CliError = class extends Error {
@@ -78,6 +79,7 @@ async function post(baseUrl, path, body, apiKey) {
   try {
     response = await fetch(endpoint(baseUrl, path), {
       method: "POST",
+      // Never forward a credential or device code through an unexpected redirect.
       redirect: "error",
       headers: {
         "Content-Type": "application/json",
@@ -606,6 +608,93 @@ async function runJobsCommand(args, dependencies) {
   throw new UsageError("Usage: mediaruntime jobs <list|get>");
 }
 
+// src/clipTranscript.ts
+import { open } from "fs/promises";
+var MAX_FILE_BYTES = 1024 * 1024;
+function timestamp(value) {
+  const match = /^(?:(\d{2,}):)?(\d{2}):(\d{2})[.,](\d{3})$/.exec(value);
+  if (!match || Number(match[2]) > 59 || Number(match[3]) > 59) {
+    throw new UsageError("Transcript cue times must use HH:MM:SS,mmm (SRT) or MM:SS.mmm / HH:MM:SS.mmm (VTT)");
+  }
+  return Number(match[1] ?? 0) * 3600 + Number(match[2]) * 60 + Number(match[3]) + Number(match[4]) / 1e3;
+}
+function subtitleSegments(text, vtt) {
+  if (vtt && !/^WEBVTT(?:\s|$)/.test(text)) throw new UsageError("VTT transcripts must begin with WEBVTT");
+  const segments = [];
+  for (const block of text.split(/\n[ \t]*\n/)) {
+    if (vtt && /^(WEBVTT(?:\s|$)|NOTE(?:\s|$)|STYLE(?:\s|$)|REGION(?:\s|$))/.test(block)) continue;
+    const lines = block.split("\n");
+    const timing = lines[0]?.includes("-->") ? 0 : 1;
+    const match = /^(\S+)\s+-->\s+(\S+)(?:\s+.*)?$/.exec(lines[timing] ?? "");
+    if (!match) throw new UsageError("Transcript contains an invalid SRT/VTT cue");
+    const entities = { amp: "&", lt: "<", gt: ">", quot: '"', apos: "'", nbsp: " " };
+    const cue = lines.slice(timing + 1).join("\n").replace(/<[^>]*>/g, "").replace(/&(amp|lt|gt|quot|apos|nbsp);/g, (_, name) => entities[name]);
+    segments.push({ startTimeSec: timestamp(match[1]), endTimeSec: timestamp(match[2]), text: cue });
+  }
+  return segments;
+}
+async function readClipTranscript(path) {
+  if (!/\.(json|srt|vtt)$/i.test(path)) throw new UsageError("--clip-transcript accepts a local .json, .srt, or .vtt file");
+  let data;
+  try {
+    const file = await open(path, "r");
+    try {
+      if (!(await file.stat()).isFile()) throw new UsageError("Clip transcript must be a regular file");
+      const buffer = Buffer.alloc(MAX_FILE_BYTES + 1);
+      let size = 0;
+      while (size < buffer.length) {
+        const read = await file.read(buffer, size, buffer.length - size, null);
+        if (!read.bytesRead) break;
+        size += read.bytesRead;
+      }
+      if (size > MAX_FILE_BYTES) throw new UsageError("Clip transcript file must be at most 1 MiB");
+      data = buffer.subarray(0, size);
+    } finally {
+      await file.close();
+    }
+  } catch (error) {
+    if (error instanceof UsageError) throw error;
+    throw new UsageError("Cannot read clip transcript file; check its path and permissions");
+  }
+  let text;
+  try {
+    text = new TextDecoder("utf-8", { fatal: true }).decode(data).replace(/^\uFEFF/, "").replace(/\r\n?/g, "\n").trim();
+  } catch {
+    throw new UsageError("Clip transcript must be valid UTF-8 text");
+  }
+  let segments;
+  if (/\.json$/i.test(path)) {
+    let value;
+    try {
+      value = JSON.parse(text);
+    } catch {
+      throw new UsageError("Clip transcript must be valid JSON");
+    }
+    segments = Array.isArray(value) ? value : value && typeof value === "object" && "transcript" in value ? value.transcript : void 0;
+  } else segments = subtitleSegments(text, /\.vtt$/i.test(path));
+  if (!Array.isArray(segments) || !segments.length || segments.length > 2e3) {
+    throw new UsageError("Clip transcript must contain 1 to 2000 segments");
+  }
+  let previous = -1;
+  let totalBytes = 0;
+  return segments.map((value) => {
+    const segment = value && typeof value === "object" ? value : {};
+    const start = segment.start_time_sec ?? segment.startTimeSec;
+    const end = segment.end_time_sec ?? segment.endTimeSec;
+    const cue = segment.text;
+    if (typeof start !== "number" || !Number.isFinite(start) || typeof end !== "number" || !Number.isFinite(end) || start < 0 || end <= start || end > 604800 || start < previous) {
+      throw new UsageError("Transcript segments require ordered finite source times with end after start (within 604800 seconds)");
+    }
+    if (typeof cue !== "string" || !cue.trim() || Buffer.byteLength(cue, "utf8") > 2e3) {
+      throw new UsageError("Transcript segments require nonblank text of at most 2000 UTF-8 bytes");
+    }
+    previous = start;
+    totalBytes += Buffer.byteLength(cue, "utf8");
+    if (totalBytes > 256 * 1024) throw new UsageError("Transcript text exceeds 256 KiB");
+    return { startTimeSec: start, endTimeSec: end, text: cue.trim() };
+  });
+}
+
 // src/commands/run.ts
 var UNSUCCESSFUL_TERMINAL_STATUSES2 = /* @__PURE__ */ new Set(["FAILED", "REJECTED", "PARTIAL"]);
 var OUTPUT_ALIASES = /* @__PURE__ */ new Set([
@@ -633,6 +722,20 @@ function parseMetadata(value) {
   }
   return parsed;
 }
+function boundedNumber(args, index, option, minimum, maximum, integer = false) {
+  const value = Number(optionValue2(args, index, option));
+  if (!Number.isFinite(value) || value < minimum || value > maximum || integer && !Number.isInteger(value)) {
+    throw new UsageError(`${option} must be ${integer ? "an integer " : ""}between ${minimum} and ${maximum}`);
+  }
+  return value;
+}
+function hexColor(args, index, option) {
+  const value = optionValue2(args, index, option);
+  if (!/^#[0-9A-Fa-f]{6}$/.test(value)) {
+    throw new UsageError(`${option} must be a six-digit hex colour such as #5B5CFF`);
+  }
+  return value;
+}
 function parseRunOptions(args) {
   let source;
   const outputs = [];
@@ -644,6 +747,16 @@ function parseRunOptions(args) {
   let download;
   let force = false;
   let json = false;
+  const animation = {};
+  const placeholders = {};
+  const contactSheet = {};
+  const image = {};
+  const audiogram = {};
+  const clip = {};
+  const clipAnalysis = {};
+  let clipTranscriptFile;
+  const privacyRedaction = {};
+  const privacyDetectors = [];
   for (let index = 0; index < args.length; index += 1) {
     const argument = args[index];
     if (argument === "--output" || argument === "-o") {
@@ -678,6 +791,234 @@ function parseRunOptions(args) {
       force = true;
     } else if (argument === "--json") {
       json = true;
+    } else if (argument === "--animation-width") {
+      animation.width = boundedNumber(args, index, argument, 1, 1920, true);
+      index += 1;
+    } else if (argument === "--animation-fps") {
+      animation.fps = boundedNumber(args, index, argument, 0.01, 30);
+      index += 1;
+    } else if (argument === "--animation-start") {
+      animation.startTime = boundedNumber(args, index, argument, 0, 604800);
+      index += 1;
+    } else if (argument === "--animation-duration") {
+      animation.duration = boundedNumber(args, index, argument, 0.01, 30);
+      index += 1;
+    } else if (argument === "--animation-loop") {
+      animation.loop = boundedNumber(args, index, argument, 0, 65535, true);
+      index += 1;
+    } else if (argument === "--animation-quality") {
+      animation.quality = boundedNumber(args, index, argument, 1, 100, true);
+      index += 1;
+    } else if (argument === "--placeholder-max-dimension") {
+      placeholders.maxDimension = boundedNumber(args, index, argument, 8, 100, true);
+      index += 1;
+    } else if (argument === "--placeholder-time") {
+      placeholders.sourceTimeSec = boundedNumber(args, index, argument, 0, 604800);
+      index += 1;
+    } else if (argument === "--lqip-quality") {
+      placeholders.lqipQuality = boundedNumber(args, index, argument, 1, 100, true);
+      index += 1;
+    } else if (argument === "--lqip-max-bytes") {
+      placeholders.lqipMaxBytes = boundedNumber(args, index, argument, 256, 16384, true);
+      index += 1;
+    } else if (argument === "--contact-columns") {
+      contactSheet.columns = boundedNumber(args, index, argument, 1, 10, true);
+      index += 1;
+    } else if (argument === "--contact-rows") {
+      contactSheet.rows = boundedNumber(args, index, argument, 1, 10, true);
+      index += 1;
+    } else if (argument === "--contact-tile-width") {
+      contactSheet.tileWidth = boundedNumber(args, index, argument, 64, 640, true);
+      index += 1;
+    } else if (argument === "--contact-tile-height") {
+      contactSheet.tileHeight = boundedNumber(args, index, argument, 36, 640, true);
+      index += 1;
+    } else if (argument === "--contact-interval") {
+      contactSheet.intervalSec = boundedNumber(args, index, argument, 0.5, 3600);
+      index += 1;
+    } else if (argument === "--contact-start") {
+      contactSheet.startTimeSec = boundedNumber(args, index, argument, 0, 604800);
+      index += 1;
+    } else if (argument === "--contact-duration") {
+      contactSheet.durationSec = boundedNumber(args, index, argument, 0, 21600);
+      index += 1;
+    } else if (argument === "--contact-max-sheets") {
+      contactSheet.maxSheets = boundedNumber(args, index, argument, 1, 20, true);
+      index += 1;
+    } else if (argument === "--contact-format") {
+      const value = optionValue2(args, index, argument);
+      if (value !== "jpg" && value !== "png" && value !== "webp") {
+        throw new UsageError("--contact-format must be jpg, png, or webp");
+      }
+      contactSheet.format = value;
+      index += 1;
+    } else if (argument === "--contact-quality") {
+      contactSheet.quality = boundedNumber(args, index, argument, 1, 100, true);
+      index += 1;
+    } else if (argument === "--image-width") {
+      image.width = boundedNumber(args, index, argument, 1, 16384, true);
+      index += 1;
+    } else if (argument === "--image-height") {
+      image.height = boundedNumber(args, index, argument, 1, 16384, true);
+      index += 1;
+    } else if (argument === "--image-mode") {
+      const value = optionValue2(args, index, argument);
+      if (value !== "fit" && value !== "fill" && value !== "cover" && value !== "contain") {
+        throw new UsageError("--image-mode must be fit, fill, cover, or contain");
+      }
+      image.mode = value;
+      index += 1;
+    } else if (argument === "--image-format") {
+      const value = optionValue2(args, index, argument);
+      if (value !== "jpg" && value !== "png" && value !== "webp" && value !== "avif") {
+        throw new UsageError("--image-format must be jpg, png, webp, or avif");
+      }
+      image.format = value;
+      index += 1;
+    } else if (argument === "--image-quality") {
+      image.quality = boundedNumber(args, index, argument, 1, 100, true);
+      index += 1;
+    } else if (argument === "--image-max-bytes") {
+      image.maxBytes = boundedNumber(args, index, argument, 256, 1e8, true);
+      index += 1;
+    } else if (argument === "--image-min-quality") {
+      image.minQuality = boundedNumber(args, index, argument, 1, 100, true);
+      index += 1;
+    } else if (argument === "--clip-start") {
+      clip.startTimeSec = boundedNumber(args, index, argument, 0, 604800);
+      index += 1;
+    } else if (argument === "--clip-duration") {
+      clip.durationSec = boundedNumber(args, index, argument, 0.1, 300);
+      index += 1;
+    } else if (argument === "--clip-layout") {
+      const value = optionValue2(args, index, argument);
+      if (value !== "original" && value !== "vertical_blur") {
+        throw new UsageError("--clip-layout must be original or vertical_blur");
+      }
+      clip.layout = value;
+      index += 1;
+    } else if (argument === "--clip-captions") {
+      clip.burnCaptions = true;
+    } else if (argument === "--clip-transcript") {
+      clipTranscriptFile = optionValue2(args, index, argument);
+      index += 1;
+    } else if (argument === "--clip-min-duration") {
+      clipAnalysis.minDurationSec = boundedNumber(args, index, argument, 1, 300);
+      index += 1;
+    } else if (argument === "--clip-max-duration") {
+      clipAnalysis.maxDurationSec = boundedNumber(args, index, argument, 1, 300);
+      index += 1;
+    } else if (argument === "--clip-count") {
+      clipAnalysis.maxCandidates = boundedNumber(args, index, argument, 1, 20, true);
+      index += 1;
+    } else if (argument === "--clip-keyword") {
+      (clipAnalysis.keywords ??= []).push(optionValue2(args, index, argument));
+      index += 1;
+    } else if (argument === "--audiogram-artwork") {
+      audiogram.artworkSource = optionValue2(args, index, argument);
+      index += 1;
+    } else if (argument === "--audiogram-captions") {
+      audiogram.captionsSource = optionValue2(args, index, argument);
+      audiogram.burnCaptions = true;
+      index += 1;
+    } else if (argument === "--audiogram-layout") {
+      const value = optionValue2(args, index, argument);
+      if (value !== "square" && value !== "portrait" && value !== "landscape") {
+        throw new UsageError("--audiogram-layout must be square, portrait, or landscape");
+      }
+      audiogram.layout = value;
+      index += 1;
+    } else if (argument === "--audiogram-background") {
+      audiogram.backgroundColor = hexColor(args, index, argument);
+      index += 1;
+    } else if (argument === "--audiogram-waveform") {
+      audiogram.waveformColor = hexColor(args, index, argument);
+      index += 1;
+    } else if (argument === "--audiogram-fit") {
+      const value = optionValue2(args, index, argument);
+      if (value !== "contain" && value !== "cover" && value !== "blurred_background") {
+        throw new UsageError("--audiogram-fit must be contain, cover, or blurred_background");
+      }
+      audiogram.artworkFit = value;
+      index += 1;
+    } else if (argument === "--audiogram-waveform-gain") {
+      audiogram.waveformGain = boundedNumber(args, index, argument, 0.5, 4);
+      index += 1;
+    } else if (argument === "--audiogram-caption-position") {
+      const value = optionValue2(args, index, argument);
+      if (value !== "top" && value !== "bottom") {
+        throw new UsageError("--audiogram-caption-position must be top or bottom");
+      }
+      audiogram.captionPosition = value;
+      index += 1;
+    } else if (argument === "--audiogram-caption-scale") {
+      audiogram.captionFontScale = boundedNumber(args, index, argument, 0.75, 1.5);
+      index += 1;
+    } else if (argument === "--audiogram-normalize") {
+      audiogram.normalizeAudio = true;
+    } else if (argument === "--audiogram-loudness-target") {
+      audiogram.loudnessTargetLufs = boundedNumber(args, index, argument, -24, -12);
+      index += 1;
+    } else if (argument === "--audiogram-start") {
+      audiogram.startTimeSec = boundedNumber(args, index, argument, 0, 604800);
+      index += 1;
+    } else if (argument === "--audiogram-duration") {
+      audiogram.durationSec = boundedNumber(args, index, argument, 0.1, 300);
+      index += 1;
+    } else if (argument === "--audiogram-fps") {
+      audiogram.fps = boundedNumber(args, index, argument, 15, 30, true);
+      index += 1;
+    } else if (argument === "--privacy-detector") {
+      const value = optionValue2(args, index, argument);
+      if (value !== "face" && value !== "license_plate" && value !== "text") {
+        throw new UsageError("--privacy-detector must be face, license_plate, or text");
+      }
+      if (privacyDetectors.includes(value)) {
+        throw new UsageError(`Duplicate --privacy-detector: ${value}`);
+      }
+      privacyDetectors.push(value);
+      index += 1;
+    } else if (argument === "--privacy-style") {
+      const value = optionValue2(args, index, argument);
+      if (value !== "blur" && value !== "pixelate" && value !== "solid") {
+        throw new UsageError("--privacy-style must be blur, pixelate, or solid");
+      }
+      privacyRedaction.style = value;
+      index += 1;
+    } else if (argument === "--privacy-failure-mode") {
+      const value = optionValue2(args, index, argument);
+      if (value !== "fail_closed" && value !== "report_only") {
+        throw new UsageError("--privacy-failure-mode must be fail_closed or report_only");
+      }
+      privacyRedaction.failureMode = value;
+      index += 1;
+    } else if (argument === "--privacy-min-confidence") {
+      privacyRedaction.minConfidence = boundedNumber(args, index, argument, 0.3, 0.99);
+      index += 1;
+    } else if (argument === "--privacy-sample-interval") {
+      privacyRedaction.sampleIntervalSec = boundedNumber(args, index, argument, 0.1, 30);
+      index += 1;
+    } else if (argument === "--privacy-max-frames") {
+      privacyRedaction.maxFrames = boundedNumber(args, index, argument, 1, 18e3, true);
+      index += 1;
+    } else if (argument === "--privacy-padding") {
+      privacyRedaction.boxPaddingRatio = boundedNumber(args, index, argument, 0, 0.5);
+      index += 1;
+    } else if (argument === "--privacy-solid-color") {
+      privacyRedaction.solidColor = hexColor(args, index, argument);
+      index += 1;
+    } else if (argument === "--privacy-pixel-block-size") {
+      privacyRedaction.pixelBlockSize = boundedNumber(args, index, argument, 4, 128, true);
+      index += 1;
+    } else if (argument === "--privacy-strength") {
+      const value = optionValue2(args, index, argument);
+      if (value !== "standard" && value !== "strong") {
+        throw new UsageError("--privacy-strength must be standard or strong");
+      }
+      privacyRedaction.privacyStrength = value;
+      index += 1;
+    } else if (argument === "--privacy-debug-observations") {
+      privacyRedaction.includeDebugObservations = true;
     } else if (argument?.startsWith("-")) {
       throw new UsageError(`Unknown run option: ${argument}`);
     } else if (source === void 0) {
@@ -692,11 +1033,126 @@ function parseRunOptions(args) {
   if (recipe && outputs.length > 0) throw new UsageError("--recipe cannot be combined with --output or --preset");
   if (!recipe && outputs.length === 0) throw new UsageError("run requires --recipe or at least one --output or --preset");
   const unsupported = outputs.find(
-    (output2) => output2.kind === "alias" && !OUTPUT_ALIASES.has(output2.value)
+    (output3) => output3.kind === "alias" && !OUTPUT_ALIASES.has(output3.value)
   );
   if (unsupported) throw new UsageError(`Unsupported output alias: ${unsupported.value}`);
   if (force && !download) throw new UsageError("--force requires --download");
   if (timeoutMs !== void 0 && !wait) throw new UsageError("--timeout-ms requires --wait or --download");
+  const hasAnimationOptions = Object.keys(animation).length > 0;
+  if (hasAnimationOptions) {
+    const animationSelections = outputs.filter(
+      (output3) => output3.kind === "preset" && (output3.value === "image_animated_webp_v1" || output3.value === "image_animated_apng_v1")
+    );
+    if (recipe || outputs.length !== 1 || animationSelections.length !== 1) {
+      throw new UsageError("animation options require exactly one animated WebP or APNG --preset");
+    }
+    if (animation.quality !== void 0 && animationSelections[0]?.value === "image_animated_apng_v1") {
+      throw new UsageError("--animation-quality applies to animated WebP only; APNG is lossless");
+    }
+  }
+  const hasPlaceholderOptions = Object.keys(placeholders).length > 0;
+  if (hasPlaceholderOptions) {
+    const placeholderSelections = outputs.filter(
+      (output3) => output3.kind === "preset" && output3.value === "image_placeholders_v1"
+    );
+    if (recipe || outputs.length !== 1 || placeholderSelections.length !== 1) {
+      throw new UsageError("placeholder options require exactly one image_placeholders_v1 --preset");
+    }
+  }
+  const hasContactSheetOptions = Object.keys(contactSheet).length > 0;
+  if (hasContactSheetOptions) {
+    const selections = outputs.filter(
+      (output3) => output3.kind === "preset" && output3.value === "contact_sheet_v1"
+    );
+    if (recipe || outputs.length !== 1 || selections.length !== 1) {
+      throw new UsageError("contact-sheet options require exactly one contact_sheet_v1 --preset");
+    }
+    const geometry = {
+      columns: 4,
+      rows: 4,
+      tileWidth: 320,
+      tileHeight: 180,
+      ...contactSheet
+    };
+    if (geometry.columns * geometry.tileWidth > 4096 || geometry.rows * geometry.tileHeight > 4096) {
+      throw new UsageError("contact-sheet width and height must each be at most 4096 pixels");
+    }
+    if (contactSheet.format === "png" && contactSheet.quality !== void 0) {
+      throw new UsageError("--contact-quality applies to JPG and WebP only; PNG is lossless");
+    }
+  }
+  const hasImageOptions = Object.keys(image).length > 0;
+  if (hasImageOptions) {
+    const selections = outputs.filter(
+      (output3) => output3.kind === "preset" && output3.value === "image_multi_v1"
+    );
+    if (recipe || outputs.length !== 1 || selections.length !== 1) {
+      throw new UsageError("image rendition options require exactly one image_multi_v1 --preset");
+    }
+    if (image.minQuality !== void 0 && image.maxBytes === void 0) {
+      throw new UsageError("--image-min-quality requires --image-max-bytes");
+    }
+    const quality = image.quality ?? 80;
+    if ((image.minQuality ?? 1) > quality) {
+      throw new UsageError("--image-min-quality must not exceed --image-quality");
+    }
+    const format = image.format ?? "webp";
+    if (image.maxBytes !== void 0 && format !== "jpg" && format !== "webp") {
+      throw new UsageError("--image-max-bytes currently supports --image-format jpg or webp only");
+    }
+  }
+  const audiogramSelections = outputs.filter(
+    (output3) => output3.kind === "preset" && output3.value === "audiogram_v1"
+  );
+  const hasAudiogramOptions = Object.keys(audiogram).length > 0;
+  if (hasAudiogramOptions || audiogramSelections.length > 0) {
+    if (recipe || outputs.length !== 1 || audiogramSelections.length !== 1) {
+      throw new UsageError("audiogram options require exactly one audiogram_v1 --preset");
+    }
+    if (!audiogram.artworkSource) {
+      throw new UsageError("audiogram_v1 requires --audiogram-artwork <PNG|JPEG|WebP source>");
+    }
+  }
+  const hasPrivacyOptions = privacyDetectors.length > 0 || Object.keys(privacyRedaction).length > 0;
+  const clipPreset = outputs.length === 1 && outputs[0]?.kind === "preset" ? outputs[0].value : void 0;
+  const hasClip = Object.keys(clip).length > 0 || clipPreset === "video_clip_v1";
+  const hasClipAnalysis = Object.keys(clipAnalysis).length > 0 || clipPreset === "clip_candidates_v1";
+  if (hasClip && (recipe || clipPreset !== "video_clip_v1" || hasClipAnalysis)) {
+    throw new UsageError("clip render options require exactly one video_clip_v1 --preset");
+  }
+  if (hasClip && (clip.startTimeSec === void 0 || clip.durationSec === void 0)) {
+    throw new UsageError("video_clip_v1 requires --clip-start and --clip-duration");
+  }
+  if (hasClipAnalysis && (recipe || clipPreset !== "clip_candidates_v1")) {
+    throw new UsageError("clip analysis options require exactly one clip_candidates_v1 --preset");
+  }
+  if ((clipAnalysis.minDurationSec ?? 15) > (clipAnalysis.maxDurationSec ?? 60)) {
+    throw new UsageError("--clip-min-duration must not exceed --clip-max-duration");
+  }
+  if ((clipAnalysis.keywords?.length ?? 0) > 20) {
+    throw new UsageError("At most 20 --clip-keyword values are supported");
+  }
+  if (clipAnalysis.keywords?.some((keyword) => !keyword.trim() || Buffer.byteLength(keyword, "utf8") > 100)) {
+    throw new UsageError("Each --clip-keyword must contain 1 to 100 UTF-8 bytes of nonblank text");
+  }
+  if (clipTranscriptFile && !hasClip && !hasClipAnalysis) {
+    throw new UsageError("--clip-transcript requires a clipping preset");
+  }
+  if (clip.burnCaptions && !clipTranscriptFile) {
+    throw new UsageError("--clip-captions requires --clip-transcript with source timestamps");
+  }
+  if (hasPrivacyOptions) {
+    if (recipe) throw new UsageError("privacy-redaction options cannot be combined with --recipe");
+    if (privacyDetectors.length === 0) {
+      throw new UsageError("privacy redaction requires at least one --privacy-detector");
+    }
+    if (/\.(?:mp4|mov|mkv|webm|gif|apng)(?:$|[?#])/i.test(source)) {
+      throw new UsageError(
+        "privacy redaction Preview accepts still-image inputs only; video and animated images are not available"
+      );
+    }
+    privacyRedaction.detectors = privacyDetectors;
+  }
   return {
     source,
     outputs,
@@ -707,22 +1163,80 @@ function parseRunOptions(args) {
     ...timeoutMs === void 0 ? {} : { timeoutMs },
     ...download === void 0 ? {} : { download },
     force,
-    json
+    json,
+    ...hasAnimationOptions ? { animation } : {},
+    ...hasPlaceholderOptions ? { placeholders } : {},
+    ...hasContactSheetOptions ? { contactSheet } : {},
+    ...hasImageOptions ? { image } : {},
+    ...hasClip ? { clip } : {},
+    ...hasClipAnalysis ? { clipAnalysis } : {},
+    ...clipTranscriptFile ? { clipTranscriptFile } : {},
+    ...hasAudiogramOptions || audiogramSelections.length > 0 ? { audiogram } : {},
+    ...hasPrivacyOptions ? { privacyRedaction } : {}
   };
 }
-async function resolveOutputs(selections, capabilitiesClient) {
-  if (!selections.some((selection) => selection.kind === "preset")) {
+function isHostedAsset(source) {
+  return /^(?:https?|gs):\/\//i.test(source);
+}
+async function resolveAudiogramAsset(source, label, uploads) {
+  if (isHostedAsset(source)) return source;
+  if (/^[a-z][a-z0-9+.-]*:/i.test(source) && !/^file:\/\//i.test(source)) {
+    throw new UsageError(`Audiogram ${label} must be an HTTP(S) URL, gs:// URI, or local file path`);
+  }
+  if (!uploads) {
+    throw new UsageError(`This client cannot upload local Audiogram ${label}; use an HTTP(S) URL or gs:// URI`);
+  }
+  return await uploads.resolveSource(source);
+}
+async function resolveAudiogram(value, uploads) {
+  const artworkSource = await resolveAudiogramAsset(value.artworkSource, "artwork", uploads);
+  const captionsSource = value.captionsSource === void 0 ? void 0 : await resolveAudiogramAsset(value.captionsSource, "captions", uploads);
+  return {
+    ...value,
+    artworkSource,
+    ...captionsSource === void 0 ? {} : { captionsSource, burnCaptions: true }
+  };
+}
+async function resolveOutputs(selections, capabilitiesClient, animation, placeholders, contactSheet, image, audiogram, privacyRedaction, clip, clipAnalysis) {
+  if (!privacyRedaction && !selections.some((selection) => selection.kind === "preset")) {
     return selections.map((selection) => selection.value);
   }
   const capabilities = await capabilitiesClient.retrieve();
   const publicPresets = new Set(capabilities.publicPresets);
   return selections.map((selection) => {
-    if (selection.kind === "alias") return selection.value;
-    const preset = capabilities.presets[selection.value];
-    if (!publicPresets.has(selection.value) || !preset) {
-      throw new UsageError(`Unknown or non-public preset: ${selection.value}`);
+    if (selection.kind === "alias" && !privacyRedaction) {
+      return selection.value;
+    }
+    const selectedName = selection.kind === "alias" ? capabilities.outputAliases[selection.value]?.preset : selection.value;
+    const preset = selectedName ? capabilities.presets[selectedName] : void 0;
+    if (!selectedName || !publicPresets.has(selectedName) || !preset) {
+      throw new UsageError(selection.kind === "alias" ? `Gateway did not provide a public expansion for alias: ${selection.value}` : `Unknown or non-public preset: ${selection.value}`);
+    }
+    if (privacyRedaction && preset.outputType !== "image") {
+      throw new UsageError(
+        "privacy redaction Preview can be attached to image outputs only"
+      );
     }
-    return { type: preset.outputType, preset: selection.value };
+    const output3 = { type: preset.outputType, preset: selectedName };
+    if (animation) output3.animation = animation;
+    if (placeholders) output3.placeholders = placeholders;
+    if (contactSheet) output3.contactSheet = contactSheet;
+    if (image) {
+      output3.images = [{
+        width: image.width ?? 1280,
+        height: image.height ?? 720,
+        mode: image.mode ?? "fit",
+        format: image.format ?? "webp",
+        quality: image.quality ?? 80,
+        ...image.maxBytes === void 0 ? {} : { maxBytes: image.maxBytes },
+        ...image.maxBytes === void 0 ? {} : { minQuality: image.minQuality ?? 1 }
+      }];
+    }
+    if (audiogram) output3.audiogram = audiogram;
+    if (privacyRedaction) output3.privacyRedaction = privacyRedaction;
+    if (clip) output3.clip = clip;
+    if (clipAnalysis) output3.clipAnalysis = clipAnalysis;
+    return output3;
   });
 }
 function receiptProjection(job) {
@@ -778,19 +1292,40 @@ Bundle: ${job.bundle.available ? "available" : "unavailable"}${error}
 }
 async function runCommand(args, dependencies) {
   const options = parseRunOptions(args);
-  const outputs = options.recipe ? void 0 : await resolveOutputs(options.outputs, dependencies.capabilities);
-  const params = {
-    source: options.source,
-    ...outputs === void 0 ? {} : { outputs },
-    ...options.recipe === void 0 ? {} : { recipe: options.recipe },
-    ...options.metadata === void 0 ? {} : { metadata: options.metadata },
-    ...options.idempotencyKey === void 0 ? {} : { idempotencyKey: options.idempotencyKey }
-  };
-  const isLocalSource = !/^(?:https?|gs):\/\//i.test(options.source);
+  const hasLocalAudiogramAsset = options.audiogram !== void 0 && (!isHostedAsset(options.audiogram.artworkSource) || options.audiogram.captionsSource !== void 0 && !isHostedAsset(options.audiogram.captionsSource));
+  const isLocalSource = !isHostedAsset(options.source);
   dependencies.activity.start(
-    isLocalSource ? "Uploading local source and creating job\u2026" : "Creating job\u2026"
+    isLocalSource || hasLocalAudiogramAsset ? "Uploading local media and creating job\u2026" : "Creating job\u2026"
   );
   try {
+    if ((options.clip || options.clipAnalysis) && !("getClipCandidates" in dependencies.jobs)) {
+      throw new UsageError("Clipping requires the MediaRuntime Node SDK release with getClipCandidates support");
+    }
+    if (options.clipTranscriptFile) {
+      const transcript = await readClipTranscript(options.clipTranscriptFile);
+      if (options.clip) options.clip.transcript = transcript;
+      if (options.clipAnalysis) options.clipAnalysis.transcript = transcript;
+    }
+    const audiogram = options.audiogram === void 0 ? void 0 : await resolveAudiogram(options.audiogram, dependencies.uploads);
+    const outputs = options.recipe ? void 0 : await resolveOutputs(
+      options.outputs,
+      dependencies.capabilities,
+      options.animation,
+      options.placeholders,
+      options.contactSheet,
+      options.image,
+      audiogram,
+      options.privacyRedaction,
+      options.clip,
+      options.clipAnalysis
+    );
+    const params = {
+      source: options.source,
+      ...outputs === void 0 ? {} : { outputs },
+      ...options.recipe === void 0 ? {} : { recipe: options.recipe },
+      ...options.metadata === void 0 ? {} : { metadata: options.metadata },
+      ...options.idempotencyKey === void 0 ? {} : { idempotencyKey: options.idempotencyKey }
+    };
     const submitted = await dependencies.jobs.create(params);
     if (!options.wait) {
       dependencies.activity.stop();
@@ -959,6 +1494,7 @@ async function runRecipesCommand(args, dependencies) {
     const value = await recipeFile(file);
     const template = value.template ?? value;
     output(await dependencies.recipes.createVersion(name, {
+      // Optimistic concurrency prevents two maintainers from replacing the same latest version.
       expectedLatestVersion: expected,
       ...typeof value.description === "string" ? { description: value.description } : {},
       template
@@ -977,6 +1513,452 @@ async function runRecipesCommand(args, dependencies) {
   throw new UsageError("Usage: mediaruntime recipes <list|get|create|version|archive>");
 }
 
+// src/commands/stickers.ts
+var COLLECTION_PATTERN = /^stc_[0-9a-f]{32}$/;
+var TOKEN_SCOPES = /* @__PURE__ */ new Set(["packs:read", "stickers:search", "stickers:read", "assets:resolve"]);
+var STICKER_VARIANTS = /* @__PURE__ */ new Set([
+  "animated",
+  "reduced_motion",
+  "small_80",
+  "small_100",
+  "small_160",
+  "thumbnail"
+]);
+var STICKERS_HELP = `MediaRuntime Hosted Sticker Runtime
+
+Usage:
+  mediaruntime stickers collections list [--include-archived] [--json]
+  mediaruntime stickers collections create --name <name> [--description <text>] [--json]
+  mediaruntime stickers collections get <collection_id> [--json]
+  mediaruntime stickers collections update <collection_id>
+    [--name <name>] [--description <text> | --clear-description]
+    [--status active|archived] [--json]
+  mediaruntime stickers collections archive <collection_id> [--json]
+  mediaruntime stickers collections packs list <collection_id> [--json]
+  mediaruntime stickers collections packs enable <collection_id>
+    (--pack <pack_id> | --activation <activation_id>) [--json]
+  mediaruntime stickers collections packs disable <collection_id> --pack <pack_id> [--json]
+  mediaruntime stickers packs list --collection <collection_id> [--json]
+  mediaruntime stickers search <query> --collection <collection_id>
+    [--pack <pack_id>] [--category <category>] [--animated | --static]
+    [--limit <1..50>] [--json]
+  mediaruntime stickers typeahead <prefix> --collection <collection_id>
+    [--pack <pack_id>] [--locale <locale>] [--limit <1..20>] [--json]
+  mediaruntime stickers get <sticker_id> --collection <collection_id> [--json]
+  mediaruntime stickers resolve <sticker_id> --variant <name>
+    --collection <collection_id> [--json]
+  mediaruntime stickers usage [--json]
+  mediaruntime stickers token create --collection <collection_id>
+    [--expires-in <60..3600>] [--scope <scope>]... [--json]
+
+Authentication:
+  API key or secure browser login is the default and is required for management,
+  pack binding, usage, and token issuance. MEDIARUNTIME_STICKER_CLIENT_TOKEN is
+  accepted only for packs/search/typeahead/get/resolve runtime reads and must match
+  the explicit --collection. Secrets are never accepted as command-line options.
+`;
+function optionValue4(args, index, option) {
+  const value = args[index + 1];
+  if (value === void 0 || value.startsWith("--")) throw new UsageError(`${option} requires a value`);
+  return value;
+}
+function collectionId(value) {
+  if (!value || !COLLECTION_PATTERN.test(value)) {
+    throw new UsageError("--collection must be a MediaRuntime sticker collection ID");
+  }
+  return value;
+}
+function boundedInteger(raw, option, minimum, maximum) {
+  const value = Number(raw);
+  if (!Number.isSafeInteger(value) || value < minimum || value > maximum) {
+    throw new UsageError(`${option} must be an integer between ${minimum} and ${maximum}`);
+  }
+  return value;
+}
+function output2(value, json, writeStdout, human) {
+  writeStdout(json ? `${JSON.stringify(value)}
+` : human);
+}
+function table2(headings, rows) {
+  const widths = headings.map(
+    (heading, index) => Math.max(heading.length, ...rows.map((row) => row[index]?.length ?? 0))
+  );
+  const render = (row) => row.map((cell3, index) => cell3.padEnd(widths[index] ?? cell3.length)).join("  ").trimEnd();
+  return `${[render(headings), render(widths.map((width) => "-".repeat(width))), ...rows.map(render)].join("\n")}
+`;
+}
+function collectionTable(page) {
+  return table2(
+    ["ID", "NAME", "STATUS", "PACKS", "UPDATED"],
+    page.items.map((item) => [
+      item.collectionId,
+      item.name,
+      item.status,
+      String(item.packs.length),
+      item.updatedAt
+    ])
+  );
+}
+function bindingTable(page) {
+  return table2(
+    ["PACK", "NAME", "VERSION", "STATUS", "HISTORICAL", "ACTIVATION"],
+    page.items.map((item) => [
+      item.packId,
+      item.packName,
+      item.packVersion,
+      item.status,
+      item.historicalAccess,
+      item.activationId
+    ])
+  );
+}
+function runtimePackTable(items) {
+  return table2(
+    ["PACK", "NAME", "VERSION", "STICKERS", "ANIMATED"],
+    items.map((item) => [
+      item.packId,
+      item.name,
+      item.version,
+      String(item.assetCount),
+      item.animated ? "yes" : "no"
+    ])
+  );
+}
+function stickerTable(items) {
+  return table2(
+    ["STICKER", "LABEL", "EMOJI", "CATEGORY", "ANIMATED", "VARIANTS"],
+    items.map((item) => [
+      item.stickerId,
+      item.label,
+      item.emoji ?? "-",
+      item.category ?? "-",
+      item.animated ? "yes" : "no",
+      item.variants.map((variant) => variant.name).join(",")
+    ])
+  );
+}
+function hostedClient(dependencies) {
+  if (!dependencies.hosted) {
+    throw new UsageError("This stickers command requires MEDIARUNTIME_API_KEY or mediaruntime login");
+  }
+  return dependencies.hosted;
+}
+function runtimeClient(selectedCollectionId, dependencies) {
+  if (dependencies.runtime) return dependencies.runtime(selectedCollectionId);
+  return hostedClient(dependencies).collection(selectedCollectionId);
+}
+async function collectionsCommand(args, dependencies) {
+  const subcommand = args[0];
+  const rest = args.slice(1);
+  const client = hostedClient(dependencies);
+  const json = rest.includes("--json");
+  if (subcommand === "list") {
+    let includeArchived = false;
+    for (const argument of rest) {
+      if (argument === "--include-archived") includeArchived = true;
+      else if (argument !== "--json") throw new UsageError(`Unknown stickers collections list option: ${argument}`);
+    }
+    const page = await client.listCollections({ includeArchived });
+    output2(page, json, dependencies.writeStdout, collectionTable(page));
+    return 0;
+  }
+  if (subcommand === "create") {
+    let name;
+    let description;
+    for (let index = 0; index < rest.length; index += 1) {
+      const argument = rest[index];
+      if (argument === "--name") {
+        name = optionValue4(rest, index, argument);
+        index += 1;
+      } else if (argument === "--description") {
+        description = optionValue4(rest, index, argument);
+        index += 1;
+      } else if (argument !== "--json") throw new UsageError(`Unknown stickers collections create option: ${argument}`);
+    }
+    if (!name) throw new UsageError("Usage: mediaruntime stickers collections create --name <name> [--description <text>]");
+    const created = await client.createCollection({ name, ...description === void 0 ? {} : { description } });
+    output2(created, json, dependencies.writeStdout, `Created sticker collection ${created.collectionId} (${created.name})
+`);
+    return 0;
+  }
+  if (subcommand === "get" || subcommand === "archive") {
+    const positional = rest.filter((argument) => argument !== "--json");
+    if (positional.length !== 1) {
+      throw new UsageError(`Usage: mediaruntime stickers collections ${subcommand} <collection_id>`);
+    }
+    const selected = collectionId(positional[0]);
+    const result = subcommand === "get" ? await client.getCollection(selected) : await client.archiveCollection(selected);
+    const human = subcommand === "get" ? `${result.name} (${result.collectionId})
+Status: ${result.status}
+Description: ${result.description || "-"}
+Enabled packs: ${result.packs.length}
+` : `Archived sticker collection ${result.collectionId}
+`;
+    output2(result, json, dependencies.writeStdout, human);
+    return 0;
+  }
+  if (subcommand === "update") {
+    let selected;
+    let name;
+    let description;
+    let status;
+    for (let index = 0; index < rest.length; index += 1) {
+      const argument = rest[index];
+      if (argument === "--name") {
+        name = optionValue4(rest, index, argument);
+        index += 1;
+      } else if (argument === "--description") {
+        description = optionValue4(rest, index, argument);
+        index += 1;
+      } else if (argument === "--clear-description") {
+        description = null;
+      } else if (argument === "--status") {
+        const value = optionValue4(rest, index, argument);
+        if (value !== "active" && value !== "archived") throw new UsageError("--status must be active or archived");
+        status = value;
+        index += 1;
+      } else if (argument !== "--json" && !selected) selected = argument;
+      else if (argument !== "--json") throw new UsageError(`Unknown stickers collections update option: ${argument}`);
+    }
+    const id = collectionId(selected);
+    if (name === void 0 && description === void 0 && status === void 0) {
+      throw new UsageError("stickers collections update requires --name, --description, --clear-description, or --status");
+    }
+    const updated = await client.updateCollection(id, {
+      ...name === void 0 ? {} : { name },
+      ...description === void 0 ? {} : { description },
+      ...status === void 0 ? {} : { status }
+    });
+    output2(updated, json, dependencies.writeStdout, `Updated sticker collection ${updated.collectionId}
+`);
+    return 0;
+  }
+  if (subcommand === "packs") return collectionPacksCommand(rest, dependencies);
+  throw new UsageError("Usage: mediaruntime stickers collections <list|create|get|update|archive|packs>");
+}
+async function collectionPacksCommand(args, dependencies) {
+  const action = args[0];
+  const rest = args.slice(1);
+  const json = rest.includes("--json");
+  const client = hostedClient(dependencies);
+  let selected;
+  let packId;
+  let activationId;
+  for (let index = 0; index < rest.length; index += 1) {
+    const argument = rest[index];
+    if (argument === "--pack") {
+      packId = optionValue4(rest, index, argument);
+      index += 1;
+    } else if (argument === "--activation") {
+      activationId = optionValue4(rest, index, argument);
+      index += 1;
+    } else if (argument !== "--json" && !selected) selected = argument;
+    else if (argument !== "--json") throw new UsageError(`Unknown stickers collections packs option: ${argument}`);
+  }
+  const id = collectionId(selected);
+  if (action === "list") {
+    if (packId || activationId) throw new UsageError("stickers collections packs list does not accept a pack selector");
+    const page = await client.listCollectionPacks(id);
+    output2(page, json, dependencies.writeStdout, bindingTable(page));
+    return 0;
+  }
+  if (action === "enable") {
+    if ((packId ? 1 : 0) + (activationId ? 1 : 0) !== 1) {
+      throw new UsageError("stickers collections packs enable requires exactly one of --pack or --activation");
+    }
+    const binding = activationId ? await client.addCollectionPack(id, { activationId }) : await client.enableCollectionPack(id, packId ?? "");
+    output2(binding, json, dependencies.writeStdout, `Enabled pack ${binding.packId} in ${id}
+`);
+    return 0;
+  }
+  if (action === "disable") {
+    if (!packId || activationId) throw new UsageError("stickers collections packs disable requires --pack <pack_id>");
+    const binding = await client.disableCollectionPack(id, packId);
+    output2(binding, json, dependencies.writeStdout, `Disabled pack ${binding.packId} in ${id}; historical references remain ${binding.historicalAccess}
+`);
+    return 0;
+  }
+  throw new UsageError("Usage: mediaruntime stickers collections packs <list|enable|disable> <collection_id>");
+}
+function parseRuntimeOptions(args, command) {
+  const options = { json: false, positional: [] };
+  for (let index = 0; index < args.length; index += 1) {
+    const argument = args[index];
+    if (argument === "--collection") {
+      options.collection = optionValue4(args, index, argument);
+      index += 1;
+    } else if (argument === "--pack") {
+      options.packId = optionValue4(args, index, argument);
+      index += 1;
+    } else if (argument === "--category") {
+      options.category = optionValue4(args, index, argument);
+      index += 1;
+    } else if (argument === "--locale") {
+      options.locale = optionValue4(args, index, argument);
+      index += 1;
+    } else if (argument === "--limit") {
+      const maximum = command === "typeahead" ? 20 : 50;
+      options.limit = boundedInteger(optionValue4(args, index, argument), argument, 1, maximum);
+      index += 1;
+    } else if (argument === "--animated" || argument === "--static") {
+      if (options.animated !== void 0) throw new UsageError("Use only one of --animated or --static");
+      options.animated = argument === "--animated";
+    } else if (argument === "--variant") {
+      options.variant = optionValue4(args, index, argument);
+      index += 1;
+    } else if (argument === "--json") options.json = true;
+    else if (argument?.startsWith("--")) throw new UsageError(`Unknown stickers ${command} option: ${argument}`);
+    else options.positional.push(argument ?? "");
+  }
+  return options;
+}
+async function runtimeCommand(command, args, dependencies) {
+  const options = parseRuntimeOptions(args, command);
+  const id = collectionId(options.collection);
+  const client = runtimeClient(id, dependencies);
+  if (command === "packs") {
+    if (options.packId || options.category || options.locale || options.limit !== void 0 || options.animated !== void 0 || options.variant) {
+      throw new UsageError("stickers packs list accepts only --collection and --json");
+    }
+    if (options.positional.length !== 1 || options.positional[0] !== "list") {
+      throw new UsageError("Usage: mediaruntime stickers packs list --collection <collection_id>");
+    }
+    const items = await client.listPacks();
+    output2({ items, total: items.length }, options.json, dependencies.writeStdout, runtimePackTable(items));
+    return 0;
+  }
+  if (command === "search") {
+    if (options.locale || options.variant) throw new UsageError("stickers search does not accept typeahead or asset options");
+    if (options.positional.length !== 1) throw new UsageError("Usage: mediaruntime stickers search <query> --collection <collection_id>");
+    const result = await client.search(options.positional[0] ?? "", {
+      ...options.packId === void 0 ? {} : { packId: options.packId },
+      ...options.category === void 0 ? {} : { category: options.category },
+      ...options.animated === void 0 ? {} : { animated: options.animated },
+      ...options.limit === void 0 ? {} : { limit: options.limit }
+    });
+    output2(result, options.json, dependencies.writeStdout, stickerTable(result.items));
+    return 0;
+  }
+  if (command === "typeahead") {
+    if (options.category || options.animated !== void 0 || options.variant) {
+      throw new UsageError("stickers typeahead accepts only --pack, --locale, and --limit filters");
+    }
+    if (options.positional.length !== 1) throw new UsageError("Usage: mediaruntime stickers typeahead <prefix> --collection <collection_id>");
+    const result = await client.typeahead(options.positional[0] ?? "", {
+      ...options.packId === void 0 ? {} : { packId: options.packId },
+      ...options.locale === void 0 ? {} : { locale: options.locale },
+      ...options.limit === void 0 ? {} : { limit: options.limit }
+    });
+    const human = table2(
+      ["SUGGESTION", "STICKERS"],
+      result.suggestions.map((suggestion) => [suggestion.text, String(suggestion.assetCount)])
+    );
+    output2(result, options.json, dependencies.writeStdout, human);
+    return 0;
+  }
+  if (command === "get") {
+    if (options.packId || options.category || options.locale || options.limit !== void 0 || options.animated !== void 0 || options.variant) {
+      throw new UsageError("stickers get accepts only --collection and --json");
+    }
+    if (options.positional.length !== 1) throw new UsageError("Usage: mediaruntime stickers get <sticker_id> --collection <collection_id>");
+    const sticker = await client.retrieve(options.positional[0] ?? "");
+    const human = `${sticker.label} (${sticker.stickerId})
+Pack: ${sticker.packId}
+Category: ${sticker.category ?? "-"}
+Variants: ${sticker.variants.map((item) => item.name).join(", ")}
+`;
+    output2(sticker, options.json, dependencies.writeStdout, human);
+    return 0;
+  }
+  if (command === "resolve") {
+    if (options.packId || options.category || options.locale || options.limit !== void 0 || options.animated !== void 0) {
+      throw new UsageError("stickers resolve accepts only --variant, --collection, and --json");
+    }
+    if (options.positional.length !== 1 || !options.variant) {
+      throw new UsageError("Usage: mediaruntime stickers resolve <sticker_id> --variant <name> --collection <collection_id>");
+    }
+    if (!STICKER_VARIANTS.has(options.variant)) {
+      throw new UsageError(`Unsupported sticker variant: ${options.variant}`);
+    }
+    const resolution = await client.resolve(options.positional[0] ?? "", options.variant);
+    const human = `Sticker: ${String(resolution.stickerId ?? "-")}
+Variant: ${String(resolution.variant ?? options.variant)}
+Bytes: ${String(resolution.bytes ?? "-")}
+Expires: ${String(resolution.expiresAt ?? "-")}
+URL: ${String(resolution.url ?? "-")}
+`;
+    output2(resolution, options.json, dependencies.writeStdout, human);
+    return 0;
+  }
+  throw new UsageError("Usage: mediaruntime stickers <packs|search|typeahead|get|resolve>");
+}
+async function tokenCommand(args, dependencies) {
+  if (args[0] !== "create") throw new UsageError("Usage: mediaruntime stickers token create --collection <collection_id>");
+  let selected;
+  let expiresInSeconds;
+  const scopes = [];
+  let json = false;
+  for (let index = 1; index < args.length; index += 1) {
+    const argument = args[index];
+    if (argument === "--collection") {
+      selected = optionValue4(args, index, argument);
+      index += 1;
+    } else if (argument === "--expires-in") {
+      expiresInSeconds = boundedInteger(optionValue4(args, index, argument), argument, 60, 3600);
+      index += 1;
+    } else if (argument === "--scope") {
+      const scope = optionValue4(args, index, argument);
+      if (!TOKEN_SCOPES.has(scope)) throw new UsageError(`Unsupported Sticker Runtime scope: ${scope}`);
+      scopes.push(scope);
+      index += 1;
+    } else if (argument === "--json") json = true;
+    else throw new UsageError(`Unknown stickers token create option: ${argument}`);
+  }
+  const result = await hostedClient(dependencies).createClientToken({
+    collectionId: collectionId(selected),
+    ...expiresInSeconds === void 0 ? {} : { expiresInSeconds },
+    ...scopes.length === 0 ? {} : { scopes: [...new Set(scopes)] }
+  });
+  const human = `Access token: ${String(result.accessToken ?? "")}
+Expires: ${String(result.expiresAt ?? "-")}
+Collection: ${String(result.collectionId ?? "-")}
+Scopes: ${Array.isArray(result.scopes) ? result.scopes.join(", ") : "-"}
+`;
+  output2(result, json, dependencies.writeStdout, human);
+  return 0;
+}
+function isScopedStickerRuntimeCommand(args) {
+  return ["packs", "search", "typeahead", "get", "resolve"].includes(args[0] ?? "");
+}
+function stickerCollectionOption(args) {
+  const index = args.indexOf("--collection");
+  return collectionId(index < 0 ? void 0 : args[index + 1]);
+}
+async function runStickersCommand(args, dependencies) {
+  const command = args[0];
+  if (!command || command === "--help" || command === "-h" || args.includes("--help") || args.includes("-h")) {
+    dependencies.writeStdout(STICKERS_HELP);
+    return 0;
+  }
+  if (command === "collections") return collectionsCommand(args.slice(1), dependencies);
+  if (command === "token") return tokenCommand(args.slice(1), dependencies);
+  if (command === "usage") {
+    const rest = args.slice(1);
+    if (rest.some((argument) => argument !== "--json")) throw new UsageError("Usage: mediaruntime stickers usage [--json]");
+    const result = await hostedClient(dependencies).usage();
+    const human = `Month: ${String(result.month ?? "-")}
+Status: ${String(result.status ?? "-")}
+Operations: ${String(result.operations ?? 0)} / ${String(result.includedOperations ?? 0)}
+Authorized delivery: ${String(result.authorizedDeliveryBytes ?? 0)} / ${String(result.includedDeliveryBytes ?? 0)} bytes
+Overage: ${String(result.overageChargedCents ?? 0)} ${String(result.currency ?? "USD")} cents
+`;
+    output2(result, rest.includes("--json"), dependencies.writeStdout, human);
+    return 0;
+  }
+  if (isScopedStickerRuntimeCommand(args)) return runtimeCommand(command ?? "", args.slice(1), dependencies);
+  throw new UsageError("Usage: mediaruntime stickers <collections|packs|search|typeahead|get|resolve|usage|token>");
+}
+
 // src/commands/trigger.ts
 import { randomBytes as randomBytes2, randomUUID } from "crypto";
 import { readFile as readFile2 } from "fs/promises";
@@ -1050,6 +2032,7 @@ function createSyntheticTerminalEvent(type, options) {
           size_bytes: 0,
           sha256: "0".repeat(64),
           download: {
+            // This marker URL is descriptive only; trigger never serves a synthetic ZIP.
             url: `http://127.0.0.1/__mediaruntime_synthetic__/${encodeURIComponent(options.jobId)}.zip`,
             expiresAt
           }
@@ -1211,7 +2194,7 @@ async function runTriggerCommand(args, dependencies = {}) {
     writeStdout: dependencies.writeStdout ?? ((text) => process.stdout.write(text))
   };
   const secret = await resolveSecret(parsed, deps);
-  const timestamp = Math.floor(deps.now() / 1e3);
+  const timestamp2 = Math.floor(deps.now() / 1e3);
   const unique = deps.randomUUID();
   const eventId = `evt_cli_${unique}`;
   const jobId = parsed.jobId ?? `job_cli_${unique}`;
@@ -1220,9 +2203,9 @@ async function runTriggerCommand(args, dependencies = {}) {
     eventId,
     jobId,
     accountId,
-    timestamp
+    timestamp: timestamp2
   });
-  const signed = signSyntheticWebhook(payload, { eventId, timestamp, secret });
+  const signed = signSyntheticWebhook(payload, { eventId, timestamp: timestamp2, secret });
   const response = await deps.fetch(parsed.destination, {
     method: "POST",
     headers: signed.headers,
@@ -1296,16 +2279,55 @@ function createActivityIndicator(write, enabled) {
 }
 
 // src/cli.ts
-var VERSION = "1.2.0";
+var VERSION = "1.4.0";
 var HELP = `MediaRuntime CLI
 
 Usage:
   mediaruntime run <source> (--recipe <name[@version]> | --output <alias> | --preset <name>) [...] [--wait]
+    Animation presets: [--animation-width N] [--animation-fps N] [--animation-start SEC]
+      [--animation-duration SEC] [--animation-loop N] [--animation-quality N]
+    Placeholder preset: [--placeholder-max-dimension N] [--placeholder-time SEC]
+      [--lqip-quality N] [--lqip-max-bytes N]
+    Contact-sheet preset: [--contact-columns N] [--contact-rows N]
+      [--contact-tile-width N] [--contact-tile-height N] [--contact-interval SEC]
+      [--contact-start SEC] [--contact-duration SEC] [--contact-max-sheets N]
+      [--contact-format jpg|png|webp] [--contact-quality N]
+      [--image-width PX] [--image-height PX] [--image-mode fit|fill|cover|contain]
+      [--image-format jpg|png|webp|avif] [--image-quality N]
+      [--image-max-bytes N] [--image-min-quality N]
+    Clip render: --preset video_clip_v1 --clip-start SEC --clip-duration SEC
+      [--clip-layout original|vertical_blur] [--clip-transcript <plan.json|captions.srt|captions.vtt>] [--clip-captions]
+    Clip suggestions: --preset clip_candidates_v1 [--clip-min-duration SEC]
+      [--clip-max-duration SEC] [--clip-count 1..20] [--clip-keyword TEXT]
+      [--clip-transcript <plan.json|captions.srt|captions.vtt>]
+    Audiogram preset: --audiogram-artwork <source> [--audiogram-captions <source>]
+      [--audiogram-layout square|portrait|landscape]
+      [--audiogram-fit contain|cover|blurred_background]
+      [--audiogram-background #RRGGBB] [--audiogram-waveform #RRGGBB]
+      [--audiogram-waveform-gain 0.5..4]
+      [--audiogram-caption-position top|bottom] [--audiogram-caption-scale 0.75..1.5]
+      [--audiogram-normalize] [--audiogram-loudness-target -24..-12]
+      [--audiogram-start SEC] [--audiogram-duration SEC] [--audiogram-fps 15..30]
+    Privacy redaction Preview (still-image input + image output only):
+      --privacy-detector face|license_plate|text
+      [--privacy-style blur|pixelate|solid] [--privacy-failure-mode fail_closed|report_only]
+      [--privacy-min-confidence 0.30..0.99] [--privacy-sample-interval 0.1..30]
+      [--privacy-max-frames 1..18000] [--privacy-padding 0..0.5]
+      [--privacy-solid-color #RRGGBB] [--privacy-pixel-block-size 4..128]
+      [--privacy-strength standard|strong] [--privacy-debug-observations]
   mediaruntime capabilities [--json]
   mediaruntime presets list [--json]
   mediaruntime jobs list [--status <status>] [--limit <n>] [--cursor <cursor>]
   mediaruntime jobs get <job_id> [--download <bundle.zip>] [--force]
   mediaruntime recipes <list|get|create|version|archive>
+  mediaruntime stickers collections <list|create|get|update|archive|packs>
+  mediaruntime stickers packs list --collection <collection_id>
+  mediaruntime stickers search <query> --collection <collection_id>
+  mediaruntime stickers typeahead <prefix> --collection <collection_id>
+  mediaruntime stickers get <sticker_id> --collection <collection_id>
+  mediaruntime stickers resolve <sticker_id> --variant <name> --collection <collection_id>
+  mediaruntime stickers usage
+  mediaruntime stickers token create --collection <collection_id>
   mediaruntime trigger <job.completed|job.failed|job.rejected> --to <local-url>
   mediaruntime login [--no-browser]
   mediaruntime auth status
@@ -1320,6 +2342,9 @@ Run/jobs options:
   --json            Machine-readable, URL-redacted output
 
 Authentication uses a secure login or MEDIARUNTIME_API_KEY.
+Sticker commands use that API key by default. MEDIARUNTIME_STICKER_CLIENT_TOKEN may
+replace it only for collection-bound packs/search/typeahead/get/resolve reads; it cannot
+manage collections, inspect workspace usage, or mint another token.
 `;
 function isFileExistsError(error) {
   return error instanceof Error && "code" in error && error.code === "EEXIST";
@@ -1499,6 +2524,28 @@ async function executeCli(argv, dependencies = {}) {
       }
       return await runPresetsCommand(global.args.slice(1), publicDependencies);
     }
+    const stickerArguments = global.args.slice(1);
+    const stickerClientToken = process.env.MEDIARUNTIME_STICKER_CLIENT_TOKEN?.trim();
+    if (command === "stickers" && (!stickerArguments[0] || stickerArguments.includes("--help") || stickerArguments.includes("-h"))) {
+      return await runStickersCommand(stickerArguments, { writeStdout });
+    }
+    if (command === "stickers" && stickerClientToken && isScopedStickerRuntimeCommand(stickerArguments)) {
+      const selectedCollectionId = stickerCollectionOption(stickerArguments);
+      const options = {
+        accessToken: stickerClientToken,
+        collectionId: selectedCollectionId,
+        ...baseUrl === void 0 ? {} : { baseUrl }
+      };
+      const constructor = MediaRuntimeSdk.StickerRuntime;
+      const runtime = dependencies.createStickerRuntime?.(options) ?? (constructor ? new constructor(options) : void 0);
+      if (!runtime) {
+        throw new UsageError("The installed @mediaruntime/node SDK does not support scoped Sticker Runtime tokens");
+      }
+      return await runStickersCommand(stickerArguments, {
+        runtime: () => runtime,
+        writeStdout
+      });
+    }
     let apiKey = process.env.MEDIARUNTIME_API_KEY?.trim();
     if (!apiKey && (!dependencies.createClient || dependencies.credentialStore)) {
       apiKey = (await resolveCredential(authBaseUrl, authDependencies))?.apiKey;
@@ -1517,6 +2564,7 @@ async function executeCli(argv, dependencies = {}) {
     const commandDependencies = {
       jobs: client.jobs,
       capabilities: client.capabilities,
+      ...client.uploads ? { uploads: client.uploads } : {},
       writeStdout,
       downloadBundle,
       activity: createActivityIndicator(writeStderr, isStderrTTY && !json)
@@ -1532,6 +2580,14 @@ async function executeCli(argv, dependencies = {}) {
         writeStdout
       });
     }
+    if (command === "stickers") {
+      const stickers = client.stickers;
+      if (!stickers) throw new UsageError("This MediaRuntime client does not support Hosted Sticker Runtime");
+      return await runStickersCommand(stickerArguments, {
+        hosted: stickers,
+        writeStdout
+      });
+    }
     throw new UsageError(`Unknown command: ${command}`);
   } catch (error) {
     const exitCode = exitCodeFor(error);