@mediaruntime/cli 1.1.0 → 1.3.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",
@@ -467,6 +469,7 @@ function detailsProjection(job) {
       retentionDays: job.bundle.retentionDays
     },
     media: job.media,
+    recipe: job.recipe,
     metadata: job.metadata,
     error: job.error,
     createdAt: job.createdAt,
@@ -632,16 +635,38 @@ 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 = [];
   let metadata;
+  let recipe;
   let idempotencyKey;
   let wait = false;
   let timeoutMs;
   let download;
   let force = false;
   let json = false;
+  const animation = {};
+  const placeholders = {};
+  const contactSheet = {};
+  const image = {};
+  const audiogram = {};
+  const privacyRedaction = {};
+  const privacyDetectors = [];
   for (let index = 0; index < args.length; index += 1) {
     const argument = args[index];
     if (argument === "--output" || argument === "-o") {
@@ -650,6 +675,9 @@ function parseRunOptions(args) {
     } else if (argument === "--preset") {
       outputs.push({ kind: "preset", value: optionValue2(args, index, argument) });
       index += 1;
+    } else if (argument === "--recipe") {
+      recipe = optionValue2(args, index, argument);
+      index += 1;
     } else if (argument === "--metadata") {
       metadata = parseMetadata(optionValue2(args, index, argument));
       index += 1;
@@ -673,6 +701,204 @@ 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 === "--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) {
@@ -682,40 +908,183 @@ function parseRunOptions(args) {
     }
   }
   if (!source) {
-    throw new UsageError("Usage: mediaruntime run <source> (--output <alias> | --preset <name>) [--wait]");
+    throw new UsageError("Usage: mediaruntime run <source> (--recipe <name[@version]> | --output <alias> | --preset <name>) [--wait]");
   }
-  if (outputs.length === 0) throw new UsageError("run requires at least one --output or --preset");
+  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(
-    (output) => output.kind === "alias" && !OUTPUT_ALIASES.has(output.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;
+  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,
+    ...recipe === void 0 ? {} : { recipe },
     ...metadata === void 0 ? {} : { metadata },
     ...idempotencyKey === void 0 ? {} : { idempotencyKey },
     wait,
     ...timeoutMs === void 0 ? {} : { timeoutMs },
     ...download === void 0 ? {} : { download },
     force,
-    json
+    json,
+    ...hasAnimationOptions ? { animation } : {},
+    ...hasPlaceholderOptions ? { placeholders } : {},
+    ...hasContactSheetOptions ? { contactSheet } : {},
+    ...hasImageOptions ? { image } : {},
+    ...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) {
+  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;
+    return output3;
   });
 }
 function receiptProjection(job) {
@@ -725,6 +1094,7 @@ function receiptProjection(job) {
     tier: job.tier,
     requiredTier: job.requiredTier,
     outputs: job.outputs,
+    recipe: job.recipe,
     message: job.message
   };
 }
@@ -743,6 +1113,7 @@ function detailsProjection2(job) {
       retentionDays: job.bundle.retentionDays
     },
     media: job.media,
+    recipe: job.recipe,
     metadata: job.metadata,
     error: job.error,
     createdAt: job.createdAt,
@@ -769,18 +1140,30 @@ Bundle: ${job.bundle.available ? "available" : "unavailable"}${error}
 }
 async function runCommand(args, dependencies) {
   const options = parseRunOptions(args);
-  const outputs = await resolveOutputs(options.outputs, dependencies.capabilities);
-  const params = {
-    source: options.source,
-    outputs,
-    ...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 {
+    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
+    );
+    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();
@@ -831,9 +1214,592 @@ async function runCommand(args, dependencies) {
   }
 }
 
+// src/commands/recipes.ts
+import { readFile } from "fs/promises";
+function optionValue3(args, index, option) {
+  const value = args[index + 1];
+  if (!value || value.startsWith("--")) throw new UsageError(`${option} requires a value`);
+  return value;
+}
+function positiveInteger(value, option) {
+  const parsed = Number(value);
+  if (!Number.isSafeInteger(parsed) || parsed < 1) {
+    throw new UsageError(`${option} must be a positive integer`);
+  }
+  return parsed;
+}
+async function recipeFile(path) {
+  let raw;
+  try {
+    raw = await readFile(path, "utf8");
+  } catch (error) {
+    throw new UsageError(`Could not read recipe file: ${path}`, { cause: error });
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error();
+    return parsed;
+  } catch {
+    throw new UsageError("Recipe file must contain one JSON object");
+  }
+}
+function humanRecipe(recipe) {
+  const kind = recipe.builtIn ? "built-in" : "custom";
+  return `${recipe.reference}
+${recipe.description || "No description"}
+Type: ${kind}
+Status: ${recipe.status}
+`;
+}
+function humanList2(recipes) {
+  const headings = ["REFERENCE", "TYPE", "DESCRIPTION"];
+  const rows = recipes.map((recipe) => [
+    recipe.reference,
+    recipe.builtIn ? "built-in" : "custom",
+    recipe.description || "-"
+  ]);
+  const widths = headings.map(
+    (heading, index) => Math.max(heading.length, ...rows.map((row) => row[index]?.length ?? 0))
+  );
+  const render = (row) => row.map((value, index) => value.padEnd(widths[index] ?? value.length)).join("  ").trimEnd();
+  return `${[render(headings), render(widths.map((width) => "-".repeat(width))), ...rows.map(render)].join("\n")}
+`;
+}
+function output(recipe, json, write) {
+  write(json ? `${JSON.stringify(recipe)}
+` : humanRecipe(recipe));
+}
+async function runRecipesCommand(args, dependencies) {
+  const subcommand = args[0];
+  const rest = args.slice(1);
+  const json = rest.includes("--json");
+  if (subcommand === "list") {
+    if (rest.some((value) => value !== "--json")) throw new UsageError("Usage: mediaruntime recipes list [--json]");
+    const recipes = await dependencies.recipes.list();
+    dependencies.writeStdout(json ? `${JSON.stringify({ recipes })}
+` : humanList2(recipes));
+    return 0;
+  }
+  if (subcommand === "get") {
+    let name;
+    let version;
+    for (let index = 0; index < rest.length; index += 1) {
+      const value = rest[index];
+      if (value === "--version") {
+        version = positiveInteger(optionValue3(rest, index, value), value);
+        index += 1;
+      } else if (value !== "--json" && !name) name = value;
+      else if (value !== "--json") throw new UsageError("recipes get accepts one name");
+    }
+    if (!name) throw new UsageError("Usage: mediaruntime recipes get <name> [--version <n>]");
+    output(await dependencies.recipes.get(name, version ? { version } : {}), json, dependencies.writeStdout);
+    return 0;
+  }
+  if (subcommand === "create") {
+    let file;
+    for (let index = 0; index < rest.length; index += 1) {
+      if (rest[index] === "--file") {
+        file = optionValue3(rest, index, "--file");
+        index += 1;
+      } else if (rest[index] !== "--json") throw new UsageError(`Unknown recipes create option: ${rest[index]}`);
+    }
+    if (!file) throw new UsageError("Usage: mediaruntime recipes create --file <recipe.json>");
+    const value = await recipeFile(file);
+    if (typeof value.name !== "string" || typeof value.template !== "object") {
+      throw new UsageError("Recipe JSON requires name and template");
+    }
+    output(await dependencies.recipes.create(value), json, dependencies.writeStdout);
+    return 0;
+  }
+  if (subcommand === "version") {
+    let name;
+    let file;
+    let expected;
+    for (let index = 0; index < rest.length; index += 1) {
+      const value2 = rest[index];
+      if (value2 === "--file") {
+        file = optionValue3(rest, index, value2);
+        index += 1;
+      } else if (value2 === "--expected") {
+        expected = positiveInteger(optionValue3(rest, index, value2), value2);
+        index += 1;
+      } else if (value2 !== "--json" && !name) name = value2;
+      else if (value2 !== "--json") throw new UsageError(`Unknown recipes version option: ${value2}`);
+    }
+    if (!name || !file || !expected) {
+      throw new UsageError("Usage: mediaruntime recipes version <name> --file <recipe.json> --expected <n>");
+    }
+    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
+    }), json, dependencies.writeStdout);
+    return 0;
+  }
+  if (subcommand === "archive") {
+    const values = rest.filter((value) => value !== "--json");
+    if (values.length !== 1) throw new UsageError("Usage: mediaruntime recipes archive <name>");
+    await dependencies.recipes.archive(values[0] ?? "");
+    dependencies.writeStdout(json ? `${JSON.stringify({ name: values[0], status: "archived" })}
+` : `Archived recipe ${values[0]}
+`);
+    return 0;
+  }
+  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 } from "fs/promises";
+import { readFile as readFile2 } from "fs/promises";
 
 // src/trigger/destination.ts
 function isLoopbackDestination(value) {
@@ -904,6 +1870,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
           }
@@ -1061,7 +2028,7 @@ async function runTriggerCommand(args, dependencies = {}) {
     now: dependencies.now ?? Date.now,
     randomUUID: dependencies.randomUUID ?? randomUUID,
     randomBytes: dependencies.randomBytes ?? randomBytes2,
-    readFile: dependencies.readFile ?? readFile,
+    readFile: dependencies.readFile ?? readFile2,
     writeStdout: dependencies.writeStdout ?? ((text) => process.stdout.write(text))
   };
   const secret = await resolveSecret(parsed, deps);
@@ -1150,15 +2117,50 @@ function createActivityIndicator(write, enabled) {
 }
 
 // src/cli.ts
-var VERSION = "1.1.0";
+var VERSION = "1.2.0";
 var HELP = `MediaRuntime CLI
 
 Usage:
-  mediaruntime run <source> (--output <alias> | --preset <name>) [...] [--wait]
+  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]
+    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
@@ -1173,6 +2175,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";
@@ -1352,12 +2357,34 @@ 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;
     }
     if (!dependencies.createClient && !apiKey) {
-      throw new UsageError("Run mediaruntime login or set MEDIARUNTIME_API_KEY before using run or jobs");
+      throw new UsageError("Run mediaruntime login or set MEDIARUNTIME_API_KEY before using this command");
     }
     const client = dependencies.createClient?.({
       ...baseUrl === void 0 ? {} : { baseUrl },
@@ -1370,6 +2397,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)
@@ -1378,6 +2406,21 @@ async function executeCli(argv, dependencies = {}) {
     if (command === "jobs") {
       return await runJobsCommand(global.args.slice(1), commandDependencies);
     }
+    if (command === "recipes") {
+      if (!client.recipes) throw new UsageError("This MediaRuntime client does not support hosted recipes");
+      return await runRecipesCommand(global.args.slice(1), {
+        recipes: client.recipes,
+        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);