@odori/cli 0.0.2 → 0.0.3

package/dist/{chunk-7XJL2BYO.js → chunk-RXLB2CXH.js}

@@ -22,7 +22,7 @@ var log = {
 // src/commands/add.ts
 import { mkdir as mkdir4, readFile as readFile5, writeFile as writeFile5 } from "fs/promises";
 import { existsSync as existsSync6 } from "fs";
-import { relative as relative3, resolve as resolve6 } from "path";
+import { relative as relative4, resolve as resolve6 } from "path";
 import { hashString as hashString2 } from "odori";
 
 // src/config.ts
@@ -121,7 +121,7 @@ ${indent}"${cue.name}": ${cue.export}(),`;
 import { createHash } from "crypto";
 import { existsSync as existsSync4 } from "fs";
 import { mkdir as mkdir2, readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
-import { dirname as dirname2, resolve as resolve4 } from "path";
+import { dirname as dirname2, isAbsolute, relative as relative2, resolve as resolve4, sep } from "path";
 
 // src/binaries.ts
 import { spawn } from "child_process";
@@ -268,6 +268,24 @@ var installCommand = async () => {
 
 // src/registry-source.ts
 var normalizeComponentName = (name) => name.replace(/^@odori\//, "");
+var assertSafeName = (name) => {
+  if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(name)) {
+    throw new Error(
+      `Refusing component name ${JSON.stringify(name)}: a name must be a lowercase slug (letters, digits, and single dashes). This registry is malformed or tampered with.`
+    );
+  }
+  return name;
+};
+var resolveWithinRoot = (root, target) => {
+  const destination = resolve4(root, target);
+  const rel = relative2(root, destination);
+  if (rel === "" || rel === ".." || rel.startsWith(`..${sep}`) || isAbsolute(rel)) {
+    throw new Error(
+      `Refusing to write ${JSON.stringify(target)}: it resolves outside the project. Nothing was written.`
+    );
+  }
+  return destination;
+};
 var DEFAULT_URL = "https://odori.dev/r/v1";
 var registryUrl = (config) => (config.registryUrl ?? process.env.ODORI_REGISTRY ?? DEFAULT_URL).replace(/\/$/, "");
 var cacheDir = (url) => resolve4(cacheRoot(), "registry", createHash("sha256").update(url).digest("hex").slice(0, 16));
@@ -284,7 +302,7 @@ var toComponent = (item) => ({
 });
 var snapshotItems = async () => {
   try {
-    const loaded = await import("./registry-snapshot-NIH2JMQ6.js");
+    const loaded = await import("./registry-snapshot-BDP6PVYB.js");
     return loaded.default.items;
   } catch {
     throw new Error(
@@ -327,6 +345,7 @@ var resolveRegistry = async (config, options = {}) => {
   return { items: await bundled(), origin: "bundled", detail: "the copy built into this CLI" };
 };
 var resolveItem = async (config, name, options = {}) => {
+  assertSafeName(name);
   const url = registryUrl(config);
   const cache = resolve4(cacheDir(url), `${name}.json`);
   if (options.allowNetwork !== false) {
@@ -349,9 +368,14 @@ var resolveItem = async (config, name, options = {}) => {
   if (!item) throw new Error(`No component named "${name}" in the registry at ${url}, in the cache, or in this CLI.`);
   return { item, origin: "bundled" };
 };
-var verifyIntegrity = (item) => {
+var verifyIntegrity = (item, origin = "network") => {
   const expected = item.meta?.integrity;
-  if (!expected) return;
+  if (!expected) {
+    if (origin === "bundled") return;
+    throw new Error(
+      `The registry document for "${item.name}" carries no integrity hash. A fetched item must be verifiable; refusing to write it. Nothing was written.`
+    );
+  }
   const hash = createHash("sha256");
   for (const file of [...item.files].sort((left, right) => left.path.localeCompare(right.path))) {
     hash.update(file.path);
@@ -372,7 +396,7 @@ Nothing was written. This is a truncated download, a stale proxy, or a tampered
 // src/commands/update.ts
 import { mkdir as mkdir3, readFile as readFile4, writeFile as writeFile4 } from "fs/promises";
 import { existsSync as existsSync5 } from "fs";
-import { relative as relative2, resolve as resolve5 } from "path";
+import { relative as relative3, resolve as resolve5 } from "path";
 import { hashString } from "odori";
 
 // src/diff.ts
@@ -499,7 +523,7 @@ var diffCommand = async (names, options = {}) => {
     log.title(`@odori/${status.name}  ${LABELS[status.state]}`);
     for (const file of status.files) {
       if (file.local === null) {
-        log.error(`  ${file.file} is missing from ${relative2(config.root, resolve5(file.localPath, ".."))}`);
+        log.error(`  ${file.file} is missing from ${relative3(config.root, resolve5(file.localPath, ".."))}`);
         continue;
       }
       if (file.local === file.upstream) {
@@ -557,7 +581,7 @@ var updateCommand = async (names, options = {}) => {
 
 // src/commands/add.ts
 var addCommand = async (names, options = {}) => {
-  if (names.length === 0) throw new Error("Name at least one component, for example @odori/title-reveal.");
+  if (names.length === 0) throw new Error("Name at least one component, for example title-reveal.");
   const config = await loadConfig(process.cwd());
   const source = await resolveRegistry(config);
   const registry = source.items;
@@ -580,14 +604,14 @@ var addCommand = async (names, options = {}) => {
       if (provider) queue.push(provider.name);
       else log.warn(`${component.namespaced} needs a "${cue}" cue and no registry entry provides one.`);
     }
-    const { item } = await resolveItem(config, component.name);
-    verifyIntegrity(item);
-    const target = resolve6(config.root, config.componentsDir, component.name);
+    const { item, origin } = await resolveItem(config, component.name);
+    verifyIntegrity(item, origin);
+    const target = resolve6(config.root, config.componentsDir, assertSafeName(component.name));
     const hashes = {};
     for (const file of item.files) {
-      const destination = resolve6(config.root, file.target);
+      const destination = resolveWithinRoot(config.root, file.target);
       const exists = existsSync6(destination);
-      log.detail(`  ${exists ? "replace" : "create "} ${relative3(config.root, destination)}`);
+      log.detail(`  ${exists ? "replace" : "create "} ${relative4(config.root, destination)}`);
     }
     if (options.dryRun) {
       installed.push(component.name);
@@ -596,13 +620,13 @@ var addCommand = async (names, options = {}) => {
     await mkdir4(target, { recursive: true });
     for (const file of item.files) {
       const name2 = file.path.split("/").pop() ?? file.path;
-      const destination = resolve6(config.root, file.target);
+      const destination = resolveWithinRoot(config.root, file.target);
       hashes[name2] = hashString2(file.content);
       if (existsSync6(destination) && !options.force) {
         const current = hashString2(await readFile5(destination, "utf8"));
         const recorded = provenance[component.name]?.hashes[name2];
         if (current !== recorded) {
-          log.warn(`${relative3(config.root, destination)} was modified locally. Keeping your version. Use --force to replace it.`);
+          log.warn(`${relative4(config.root, destination)} was modified locally. Keeping your version. Use --force to replace it.`);
           continue;
         }
       }
@@ -616,7 +640,7 @@ var addCommand = async (names, options = {}) => {
       hashes
     };
     installed.push(component.name);
-    log.success(`${component.namespaced} to ${relative3(config.root, target)}/`);
+    log.success(`${component.namespaced} to ${relative4(config.root, target)}/`);
     if (component.kind === "cue" && component.cue) {
       log.detail(
         `  ${component.family} \xB7 ${component.contract.recommendedDurationInFrames} frames \xB7 registers "${component.cue.name}"`
@@ -665,6 +689,8 @@ var registryCommand = async () => {
 
 // src/commands/dev.ts
 import { resolve as resolve18 } from "path";
+import { homedir as homedir2 } from "os";
+import { existsSync as existsSync15 } from "fs";
 import { readFile as readFile12 } from "fs/promises";
 
 // src/jobs.ts
@@ -673,7 +699,7 @@ import { existsSync as existsSync7 } from "fs";
 import { join as join2, resolve as resolve7 } from "path";
 var buildsDir = (config) => resolve7(config.root, config.outDir, "builds");
 var jobFile = (config, id) => join2(buildsDir(config), `${id}.json`);
-var createJob = async (config, manifest, output) => {
+var createJob = async (config, manifest, output, render) => {
   await mkdir5(buildsDir(config), { recursive: true });
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const job = {
@@ -687,7 +713,7 @@ var createJob = async (config, manifest, output) => {
     createdAt: now,
     updatedAt: now
   };
-  const record = { job, manifest, output };
+  const record = { job, manifest, output, ...render ? { render } : {} };
   await writeFile6(jobFile(config, job.id), `${JSON.stringify(record, null, 2)}
 `, "utf8");
   return record;
@@ -779,7 +805,7 @@ var JobQueue = class {
 // src/discovery.ts
 import { mkdir as mkdir6, readdir as readdir3, readFile as readFile7, stat, writeFile as writeFile7 } from "fs/promises";
 import { existsSync as existsSync8 } from "fs";
-import { join as join3, relative as relative4, resolve as resolve8, sep } from "path";
+import { join as join3, relative as relative5, resolve as resolve8, sep as sep2 } from "path";
 import { hashString as hashString3 } from "odori";
 var IGNORED = /* @__PURE__ */ new Set(["node_modules", ".git", ".odori", "out", "dist", ".next"]);
 var walk = async (directory2, files = []) => {
@@ -807,9 +833,9 @@ var discoverAudio = async (config) => {
   const files = (await walk(root)).filter((file) => AUDIO_EXTENSIONS.test(file)).sort();
   return Promise.all(
     files.map(async (file) => ({
-      name: relative4(root, file).replace(AUDIO_EXTENSIONS, "").split(sep).join("/"),
-      url: file.startsWith(`${publicRoot}${sep}`) ? `/${relative4(publicRoot, file).split(sep).join("/")}` : `/${relative4(config.root, file).split(sep).join("/")}`,
-      relativeFile: relative4(config.root, file),
+      name: relative5(root, file).replace(AUDIO_EXTENSIONS, "").split(sep2).join("/"),
+      url: file.startsWith(`${publicRoot}${sep2}`) ? `/${relative5(publicRoot, file).split(sep2).join("/")}` : `/${relative5(config.root, file).split(sep2).join("/")}`,
+      relativeFile: relative5(config.root, file),
       bytes: (await stat(file)).size
     }))
   );
@@ -825,15 +851,17 @@ var discoverProject = async (config) => {
   const previews = [];
   const brands = [];
   const hashParts = [];
+  const componentsRoot = resolve8(config.root, config.componentsDir);
   for (const file of files) {
-    const relativeFile = relative4(config.root, file);
+    const relativeFile = relative5(config.root, file);
+    let contents = "";
     if (/\.(tsx|ts|css|json)$/.test(file)) {
-      const contents = await readFile7(file, "utf8");
+      contents = await readFile7(file, "utf8");
       hashParts.push(`${relativeFile}:${hashString3(contents)}`);
     }
-    const base = file.split(sep).pop() ?? "";
+    const base = file.split(sep2).pop() ?? "";
     if (base === "video.tsx") {
-      const slug = relative4(videosRoot, file).replace(/\/?video\.tsx$/, "").split(sep).join("/") || "video";
+      const slug = relative5(videosRoot, file).replace(/\/?video\.tsx$/, "").split(sep2).join("/") || "video";
       videos.push({
         slug,
         file,
@@ -841,13 +869,27 @@ var discoverProject = async (config) => {
         importPath: file,
         identifier: toIdentifier(slug, "video")
       });
-    } else if (file.split(sep).includes("brands") && /\.tsx?$/.test(base) && !base.endsWith(".preview.tsx")) {
+    } else if (
+      // A brand module is recognized by what it does, not where it sits. The
+      // scaffold defines its brand in videos/layout.tsx, so a directory-name
+      // rule alone left the default project's brand invisible to everything
+      // that reads this list — most visibly the dev server's cue registry,
+      // which then answered new cue URLs with 404s until a restart. Installed
+      // component source is excluded the way brand-file.ts excludes it: a
+      // component may mention defineBrand without being where a brand lives.
+      /\.tsx?$/.test(base) && !base.endsWith(".preview.tsx") && !file.startsWith(componentsRoot + sep2) && (file.split(sep2).includes("brands") || contents.includes("defineBrand("))
+    ) {
       const name = base.replace(/\.tsx?$/, "");
       brands.push({
         name,
         file,
         relativeFile,
-        identifier: toIdentifier(`${name}-module`, "brands")
+        // From the whole relative path, like previews: basenames repeat
+        // (`layout.tsx` beside `brands/layout.ts`), identifiers cannot.
+        identifier: toIdentifier(
+          `${relative5(videosRoot, file).replace(/\.tsx?$/, "").split(sep2).join("-")}-module`,
+          "brands"
+        )
       });
     } else if (base.endsWith(".preview.tsx")) {
       const name = base.replace(/\.preview\.tsx$/, "");
@@ -856,7 +898,7 @@ var discoverProject = async (config) => {
         file,
         relativeFile,
         importPath: file,
-        identifier: toIdentifier(`${relative4(videosRoot, file).split(sep).join("-")}`, "preview")
+        identifier: toIdentifier(`${relative5(videosRoot, file).split(sep2).join("-")}`, "preview")
       });
     }
   }
@@ -864,7 +906,7 @@ var discoverProject = async (config) => {
 };
 var generateImports = (graph, outDir) => {
   const importPath = (file) => {
-    const relativePath = relative4(outDir, file).split(sep).join("/");
+    const relativePath = relative5(outDir, file).split(sep2).join("/");
     return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
   };
   const lines = [
@@ -1162,6 +1204,119 @@ var freezeManifest = async (video, graph, config, rawInput, options = {}) => {
   return { manifest, input, prepared };
 };
 
+// src/formats.ts
+var QUALITIES = ["studio", "social", "web"];
+var scaleFilter = (scale) => `scale=trunc(iw*${scale}/2)*2:trunc(ih*${scale}/2)*2:flags=lanczos`;
+var scaleArgs = (scale) => scale === 1 ? [] : ["-vf", scaleFilter(scale)];
+var FORMATS = {
+  mp4: {
+    name: "mp4",
+    extension: ".mp4",
+    alpha: false,
+    chunked: true,
+    audio: true,
+    description: "H.264 in MP4. Plays everywhere; the default.",
+    args: ({ preset, quality, scale }) => [
+      ...scaleArgs(scale),
+      "-c:v",
+      "libx264",
+      "-crf",
+      { studio: "17", social: "21", web: "27" }[quality],
+      "-preset",
+      preset,
+      "-pix_fmt",
+      "yuv420p"
+    ]
+  },
+  webm: {
+    name: "webm",
+    extension: ".webm",
+    alpha: true,
+    // VP9 in WebM concatenates cleanly through the demuxer, same as H.264.
+    chunked: true,
+    audio: true,
+    description: "VP9 in WebM, with alpha. For the web, and for overlays.",
+    args: ({ quality, scale }) => [
+      ...scaleArgs(scale),
+      "-c:v",
+      "libvpx-vp9",
+      "-crf",
+      { studio: "24", social: "31", web: "38" }[quality],
+      "-b:v",
+      "0",
+      "-pix_fmt",
+      "yuva420p",
+      "-row-mt",
+      "1"
+    ]
+  },
+  prores: {
+    name: "prores",
+    extension: ".mov",
+    alpha: true,
+    chunked: true,
+    audio: true,
+    description: "ProRes 4444 in MOV, with alpha. For handing to an editor.",
+    // Quality is the profile here, and the profile is the point: an editor
+    // format that quietly compressed would defeat its own reason to exist.
+    args: ({ scale }) => [
+      ...scaleArgs(scale),
+      "-c:v",
+      "prores_ks",
+      "-profile:v",
+      "4444",
+      "-pix_fmt",
+      "yuva444p10le",
+      "-alpha_bits",
+      "8"
+    ]
+  },
+  gif: {
+    name: "gif",
+    extension: ".gif",
+    alpha: false,
+    // A GIF's palette is computed across the whole animation, so chunks would
+    // each invent their own and the result would flicker between them.
+    chunked: false,
+    audio: false,
+    description: "An animated GIF, palette optimised. Silent, by the format.",
+    // The palette pass is a filter graph already, so scaling joins it rather
+    // than adding a second -vf that ffmpeg would silently drop.
+    args: ({ scale }) => [
+      "-vf",
+      `${scale === 1 ? "" : `${scaleFilter(scale)},`}split[a][b];[a]palettegen=stats_mode=diff[p];[b][p]paletteuse=dither=bayer:bayer_scale=3`,
+      "-loop",
+      "0"
+    ]
+  },
+  png: {
+    name: "png",
+    extension: ".png",
+    alpha: true,
+    chunked: false,
+    audio: false,
+    description: "A numbered PNG sequence, with alpha. For a compositor.",
+    args: ({ scale }) => [...scaleArgs(scale), "-c:v", "png", "-pix_fmt", "rgba"]
+  }
+};
+var formatNames = () => Object.keys(FORMATS);
+var resolveFormat = (requested, output) => {
+  if (requested) {
+    const format = FORMATS[requested.toLowerCase()];
+    if (!format) {
+      throw new Error(`Unknown format "${requested}". Available: ${formatNames().join(", ")}`);
+    }
+    return format;
+  }
+  if (output) {
+    const extension = output.slice(output.lastIndexOf(".")).toLowerCase();
+    const matched = Object.values(FORMATS).find((format) => format.extension === extension);
+    if (matched) return matched;
+  }
+  return FORMATS.mp4;
+};
+var alphaWarning = (format, transparent) => transparent && !format.alpha ? `${format.name} has no alpha channel, so the transparent background will render black. Use webm, prores, or png.` : null;
+
 // src/render.ts
 import { spawn as spawn2 } from "child_process";
 import { copyFile as copyFile2, mkdir as mkdir11, rm as rm2, writeFile as writeFile12 } from "fs/promises";
@@ -1234,23 +1389,28 @@ var renderedCue = (url) => {
   return wav;
 };
 var isBrand = (value) => typeof value === "object" && value !== null && value.kind === "odori-brand";
+var isLayout = (value) => typeof value === "object" && value !== null && value.kind === "odori-layout";
 var importFresh = async (file) => await import(`${pathToFileURL3(file).href}?odori=${statSync(file).mtimeMs}`);
-var registerProjectCues = async (graph) => {
+var registerProjectCues = async (graph, load = importFresh) => {
   for (const discovered of graph.brands) {
     try {
-      const module = await importFresh(discovered.file);
-      registerCues(Object.values(module).filter(isBrand), defaultLayout.format.fps);
+      const values = Object.values(await load(discovered.file));
+      registerCues(values.filter(isBrand), defaultLayout.format.fps);
+      for (const layout of values.filter(isLayout)) registerCues([layout.brand], layout.format.fps);
     } catch (error) {
       log.warn(`[odori] could not read cues from ${discovered.relativeFile}: ${message(error)}`);
     }
   }
-  try {
-    for (const video of await loadVideos(graph)) {
-      const layout = resolveEntryLayout2(video.entry);
+  for (const video of graph.videos) {
+    try {
+      const module = await load(video.file);
+      if (!module.default || !module.metadata) continue;
+      const entry = { component: module.default, metadata: module.metadata };
+      const layout = resolveEntryLayout2(entry);
       registerCues([layout.brand], layout.format.fps);
+    } catch (error) {
+      log.warn(`[odori] generated cues in ${video.relativeFile} may use the default frame rate: ${message(error)}`);
     }
-  } catch (error) {
-    log.warn(`[odori] generated cues may use the default frame rate: ${message(error)}`);
   }
   return known.size;
 };
@@ -1409,6 +1569,8 @@ var chunkKey = (identity) => hashValue2({
   height: identity.height,
   fps: identity.fps,
   preset: identity.preset,
+  quality: identity.quality ?? null,
+  scale: identity.scale ?? null,
   input: identity.input ?? null
 });
 var readChunkRecord = async (config, key) => {
@@ -1434,80 +1596,6 @@ var writeChunkRecord = async (config, key, signatures, file) => {
 };
 var signaturesMatch = (recorded, observed) => recorded.length === observed.length && recorded.every((signature, index) => signature === observed[index]);
 
-// src/formats.ts
-var FORMATS = {
-  mp4: {
-    name: "mp4",
-    extension: ".mp4",
-    alpha: false,
-    chunked: true,
-    audio: true,
-    description: "H.264 in MP4. Plays everywhere; the default.",
-    args: (preset) => ["-c:v", "libx264", "-crf", "17", "-preset", preset, "-pix_fmt", "yuv420p"]
-  },
-  webm: {
-    name: "webm",
-    extension: ".webm",
-    alpha: true,
-    // VP9 in WebM concatenates cleanly through the demuxer, same as H.264.
-    chunked: true,
-    audio: true,
-    description: "VP9 in WebM, with alpha. For the web, and for overlays.",
-    args: () => ["-c:v", "libvpx-vp9", "-crf", "24", "-b:v", "0", "-pix_fmt", "yuva420p", "-row-mt", "1"]
-  },
-  prores: {
-    name: "prores",
-    extension: ".mov",
-    alpha: true,
-    chunked: true,
-    audio: true,
-    description: "ProRes 4444 in MOV, with alpha. For handing to an editor.",
-    args: () => ["-c:v", "prores_ks", "-profile:v", "4444", "-pix_fmt", "yuva444p10le", "-alpha_bits", "8"]
-  },
-  gif: {
-    name: "gif",
-    extension: ".gif",
-    alpha: false,
-    // A GIF's palette is computed across the whole animation, so chunks would
-    // each invent their own and the result would flicker between them.
-    chunked: false,
-    audio: false,
-    description: "An animated GIF, palette optimised. Silent, by the format.",
-    args: () => [
-      "-vf",
-      "split[a][b];[a]palettegen=stats_mode=diff[p];[b][p]paletteuse=dither=bayer:bayer_scale=3",
-      "-loop",
-      "0"
-    ]
-  },
-  png: {
-    name: "png",
-    extension: ".png",
-    alpha: true,
-    chunked: false,
-    audio: false,
-    description: "A numbered PNG sequence, with alpha. For a compositor.",
-    args: () => ["-c:v", "png", "-pix_fmt", "rgba"]
-  }
-};
-var formatNames = () => Object.keys(FORMATS);
-var resolveFormat = (requested, output) => {
-  if (requested) {
-    const format = FORMATS[requested.toLowerCase()];
-    if (!format) {
-      throw new Error(`Unknown format "${requested}". Available: ${formatNames().join(", ")}`);
-    }
-    return format;
-  }
-  if (output) {
-    const extension = output.slice(output.lastIndexOf(".")).toLowerCase();
-    const matched = Object.values(FORMATS).find((format) => format.extension === extension);
-    if (matched) return matched;
-  }
-  return FORMATS.mp4;
-};
-var alphaWarning = (format, transparent) => transparent && !format.alpha ? `${format.name} has no alpha channel, so the transparent background will render black. Use webm, prores, or png.` : null;
-
 // src/render.ts
 var encodeParam = (value) => Buffer.from(JSON.stringify(value), "utf8").toString("base64");
 var renderUrl = (origin, target, frame) => {
@@ -1675,10 +1763,19 @@ var sequencePattern = (output) => {
   const extension = dot > 0 ? output.slice(dot) : ".png";
   return join6(stem, `%05d${extension}`);
 };
-var openChunkEncoder = (ffmpeg, file, fps, preset, format, signal) => {
+var LOSSLESS = {
+  name: "lossless",
+  extension: ".mkv",
+  alpha: true,
+  chunked: true,
+  audio: false,
+  description: "FFV1 in MKV, the lossless intermediate for one-pass formats.",
+  args: () => ["-c:v", "ffv1", "-level", "3"]
+};
+var openChunkEncoder = (ffmpeg, file, fps, encode, format, signal) => {
   const child = spawn2(
     ffmpeg,
-    ["-y", "-f", "image2pipe", "-framerate", String(fps), "-i", "pipe:0", ...format.args(preset), file],
+    ["-y", "-f", "image2pipe", "-framerate", String(fps), "-i", "pipe:0", ...format.args(encode), file],
     { stdio: ["pipe", "ignore", "pipe"] }
   );
   let stderr = "";
@@ -1728,7 +1825,7 @@ var captureLane = async (origin, target, config, lane, stats, options) => {
         }
       }
       const file = options.chunkFile(chunk);
-      const encoder = openChunkEncoder(options.ffmpeg, file, target.fps, options.preset, options.format, options.signal);
+      const encoder = openChunkEncoder(options.ffmpeg, file, target.fps, options.encode, options.format, options.signal);
       const signatures = [];
       let previousSignature = null;
       let previousFrame = null;
@@ -1788,9 +1885,14 @@ var renderMovie = async (origin, target, output, config, onProgress, options = {
   const browserPath = await browserExecutable(config);
   const renderer = (await resolveBrowser(config))?.version ?? browserPath;
   const requested = Math.max(1, Math.min(options.concurrency ?? config.concurrency ?? defaultConcurrency(), 16));
-  const preset = options.preset ?? config.preset ?? "medium";
+  const encode = {
+    preset: options.preset ?? config.preset ?? "medium",
+    quality: options.quality ?? "studio",
+    scale: options.scale ?? 1
+  };
   const format = options.format ?? FORMATS.mp4;
   const chunkable = format.chunked;
+  const chunkFormat = chunkable ? format : LOSSLESS;
   const skipUnchanged = options.skipUnchangedFrames ?? config.skipUnchangedFrames ?? true;
   const cache = options.cache ?? config.cacheChunks ?? true;
   const work = options.workDir ?? resolve15(config.root, config.outDir, "frames", `${target.videoId.split("/").join("-")}-${Date.now().toString(36)}`);
@@ -1812,8 +1914,8 @@ var renderMovie = async (origin, target, output, config, onProgress, options = {
         (lane) => captureLane(origin, target, config, lane, stats, {
           skipUnchanged,
           signal: options.signal,
-          preset,
-          format,
+          encode,
+          format: chunkFormat,
           ffmpeg,
           workDir: work,
           chunkFile,
@@ -1821,11 +1923,17 @@ var renderMovie = async (origin, target, output, config, onProgress, options = {
             videoId: target.videoId,
             chunk,
             renderer,
-            format: format.name,
+            format: chunkFormat.name,
             width: target.width,
             height: target.height,
             fps: target.fps,
-            preset,
+            preset: encode.preset,
+            // Both change the encoded bytes, so both are part of what a
+            // chunk is: a half-size chunk must never answer for a full
+            // one. A lossless intermediate is the exception by design —
+            // the final pass applies them, so one capture serves all.
+            quality: chunkable ? encode.quality : void 0,
+            scale: chunkable ? encode.scale : void 0,
             input: target.input
           }) : void 0,
           onFrame: () => onProgress?.(stats.captured / Math.max(1, target.durationInFrames), "rendering")
@@ -1852,7 +1960,7 @@ var renderMovie = async (origin, target, output, config, onProgress, options = {
     if (!chunkable) {
       const destination = format.name === "png" && !output.includes("%") ? sequencePattern(output) : output;
       if (destination !== output) await mkdir11(dirname4(destination), { recursive: true });
-      await run(ffmpeg, ["-y", "-i", silent, ...format.args(preset), destination], options.signal);
+      await run(ffmpeg, ["-y", "-i", silent, ...format.args(encode), destination], options.signal);
       if (mixInputs.length > 0) {
         log.detail(`${format.name} carries no audio track; ${mixInputs.length} cue(s) were not mixed in.`);
       }
@@ -1943,7 +2051,7 @@ import { fileURLToPath } from "url";
 import { createServer } from "vite";
 import react from "@vitejs/plugin-react";
 import { readFile as readFile11 } from "fs/promises";
-import { dirname as dirname5, resolve as resolve16, sep as sep2 } from "path";
+import { dirname as dirname5, resolve as resolve16, sep as sep3 } from "path";
 var cliRoot = resolve16(dirname5(fileURLToPath(import.meta.url)), "..");
 var studioRoot = resolve16(cliRoot, "studio");
 var studioEntry = resolve16(studioRoot, "index.html");
@@ -2014,7 +2122,6 @@ var startStudioServer = async (initialConfig, options = {}) => {
   const odoriSrc = runtimeSource(config.root);
   let graph = await discoverProject(config);
   await writeGenerated(config, graph);
-  await registerProjectCues(graph);
   const vite = await createServer({
     root: studioRoot,
     configFile: false,
@@ -2093,14 +2200,31 @@ var startStudioServer = async (initialConfig, options = {}) => {
     },
     optimizeDeps: { include: ["react", "react-dom", "react/jsx-dev-runtime"] }
   });
+  const loadModule = (file) => vite.ssrLoadModule(`/@fs${file}`);
+  await registerProjectCues(graph, loadModule);
+  let refreshTimer;
+  let refreshChain = Promise.resolve();
+  const enqueueRefresh = (task) => {
+    const next = refreshChain.then(task, task);
+    refreshChain = next.catch(() => void 0);
+    return next;
+  };
+  const scheduleCueRefresh = () => {
+    clearTimeout(refreshTimer);
+    refreshTimer = setTimeout(() => {
+      void enqueueRefresh(() => registerProjectCues(graph, loadModule)).catch((error) => {
+        vite.config.logger.warn(`[odori] cue refresh skipped: ${error instanceof Error ? error.message : String(error)}`);
+      });
+    }, 150);
+  };
   const rediscover = async (file) => {
     if (!file.startsWith(resolve16(config.root, config.videosDir))) return;
-    const isEntry = file.endsWith("video.tsx") || file.endsWith(".preview.tsx") || file.includes(`${sep2}brands${sep2}`);
+    const isEntry = file.endsWith("video.tsx") || file.endsWith(".preview.tsx") || file.includes(`${sep3}brands${sep3}`);
     if (!isEntry) return;
     try {
       graph = await discoverProject(config);
       await writeGenerated(config, graph);
-      await registerProjectCues(graph);
+      await enqueueRefresh(() => registerProjectCues(graph, loadModule));
     } catch (error) {
       vite.config.logger.warn(`[odori] rediscovery skipped: ${error instanceof Error ? error.message : String(error)}`);
       return;
@@ -2118,7 +2242,7 @@ var startStudioServer = async (initialConfig, options = {}) => {
       config = await loadConfig(config.root);
       graph = await discoverProject(config);
       await writeGenerated(config, graph);
-      await registerProjectCues(graph);
+      await enqueueRefresh(() => registerProjectCues(graph, loadModule));
     } catch (error) {
       vite.config.logger.warn(`[odori] config reload skipped: ${error instanceof Error ? error.message : String(error)}`);
       return;
@@ -2127,11 +2251,12 @@ var startStudioServer = async (initialConfig, options = {}) => {
     if (module) vite.moduleGraph.invalidateModule(module);
     vite.ws.send({ type: "full-reload" });
   };
-  const refreshCues = async (file) => {
-    if (!file.startsWith(resolve16(config.root, config.videosDir)) || !file.split(sep2).includes("brands")) return;
-    await registerProjectCues(graph);
+  const refreshCues = (file) => {
+    if (!file.startsWith(resolve16(config.root, config.videosDir) + sep3)) return;
+    if (!/\.tsx?$/.test(file)) return;
+    scheduleCueRefresh();
   };
-  vite.watcher.on("change", (file) => void refreshCues(file));
+  vite.watcher.on("change", (file) => refreshCues(file));
   vite.watcher.on("change", (file) => void reloadConfig(file));
   for (const name of ["odori.config.ts", "odori.config.mjs", "odori.config.js"]) {
     vite.watcher.add(resolve16(config.root, name));
@@ -2274,8 +2399,12 @@ var runJob = async (config, origin, record, video, options = {}) => exportQueue.
       },
       {
         concurrency: options.concurrency,
-        preset: options.preset,
-        format: options.format,
+        // The record freezes how it should be encoded alongside what, so a
+        // retry from any surface produces the same file the first run would.
+        preset: options.preset ?? record.render?.preset,
+        quality: options.quality ?? record.render?.quality,
+        scale: options.scale ?? record.render?.scale,
+        format: options.format ?? (record.render?.format ? resolveFormat(record.render.format, record.output) : void 0),
         skipUnchangedFrames: options.skipUnchangedFrames,
         signal: controller.signal,
         onTimings: (timings) => {
@@ -2302,9 +2431,23 @@ var runJob = async (config, origin, record, video, options = {}) => exportQueue.
     running.delete(record.job.id);
   }
 });
+var resolveQuality = (requested) => {
+  if (!requested) return "studio";
+  if (QUALITIES.includes(requested)) return requested;
+  throw new Error(`Unknown quality "${requested}". Available: ${QUALITIES.join(", ")}`);
+};
+var resolveScale = (requested) => {
+  if (requested === void 0) return 1;
+  if (!Number.isFinite(requested) || requested < 0.25 || requested > 2) {
+    throw new Error(`Scale ${requested} is out of range. Use a value between 0.25 and 2.`);
+  }
+  return requested;
+};
 var exportCommand = async (id, options = {}) => {
   const { config, graph, videos } = await createContext();
   const format = resolveFormat(options.format ?? config.format, options.output);
+  const quality = resolveQuality(options.quality);
+  const scale = resolveScale(options.scale);
   return withServer(config, async (server) => {
     const record = options.retry ? await readJob(config, options.retry) : await (async () => {
       const video2 = findVideo(videos, id);
@@ -2320,7 +2463,12 @@ var exportCommand = async (id, options = {}) => {
         config.root,
         options.output ?? `${config.exportDir}/${outputName(id)}${format.extension}`
       );
-      return createJob(config, manifest, output);
+      return createJob(config, manifest, output, {
+        format: format.name,
+        quality,
+        scale,
+        ...options.preset ? { preset: options.preset } : {}
+      });
     })();
     const video = findVideo(videos, record.manifest.videoId);
     log.detail(`job ${record.job.id} manifest ${record.manifest.manifestHash}`);
@@ -2331,7 +2479,10 @@ var exportCommand = async (id, options = {}) => {
     const job = await runJob(config, server.url, record, video, {
       concurrency: options.concurrency,
       preset: options.preset,
-      format,
+      // A retry keeps what its record froze; an explicit flag still wins.
+      quality: options.retry && options.quality === void 0 ? void 0 : quality,
+      scale: options.retry && options.scale === void 0 ? void 0 : scale,
+      format: options.retry ? void 0 : format,
       skipUnchangedFrames: options.skipUnchangedFrames,
       onProgress: (next) => {
         if (next.status === "rendering" || next.status === "encoding") {
@@ -2373,6 +2524,35 @@ var json = (response, status, payload) => {
   response.setHeader("content-type", "application/json");
   response.end(JSON.stringify(payload));
 };
+var exportDestination = (config) => {
+  const downloads = resolve18(homedir2(), "Downloads");
+  return existsSync15(downloads) ? downloads : resolve18(config.root, config.exportDir);
+};
+var LOOPBACK = /* @__PURE__ */ new Set(["127.0.0.1", "localhost", "[::1]", "::1"]);
+var hostOf = (value) => {
+  if (!value) return null;
+  const withoutPort = value.startsWith("[") ? value.slice(0, value.indexOf("]") + 1) : value.split(":")[0];
+  return withoutPort || null;
+};
+var isLocalRequest = (request) => {
+  const host = hostOf(request.headers.host);
+  if (!host || !LOOPBACK.has(host)) return false;
+  const origin = request.headers.origin;
+  if (origin) {
+    try {
+      if (!LOOPBACK.has(hostOf(new URL(origin).host) ?? "")) return false;
+    } catch {
+      return false;
+    }
+  }
+  return true;
+};
+var safeJobId = (id) => {
+  if (!/^[a-zA-Z0-9._-]+$/.test(id) || id.includes("..")) {
+    throw new Error(`Invalid job id ${JSON.stringify(id)}.`);
+  }
+  return id;
+};
 var devCommand = async (options = {}) => {
   const config = await loadConfig(options.root ?? process.cwd());
   const context = async () => {
@@ -2384,6 +2564,10 @@ var devCommand = async (options = {}) => {
     middleware: (vite) => {
       vite.middlewares.use("/__odori", (request, response, next) => {
         const url = request.url ?? "/";
+        if (!isLocalRequest(request)) {
+          json(response, 403, { error: "This endpoint only answers same-origin requests from Studio on localhost." });
+          return;
+        }
         void (async () => {
           try {
             if (request.method === "POST" && url.startsWith("/still")) {
@@ -2401,8 +2585,7 @@ var devCommand = async (options = {}) => {
               );
               const frame = Number(body.frame ?? 0);
               const inline = body.inline === true;
-              const directory2 = inline ? config.outDir : config.exportDir;
-              const file = resolve18(config.root, `${directory2}/${outputName(video.entry.metadata.id)}-${frame}.png`);
+              const file = inline ? resolve18(config.root, config.outDir, `${outputName(video.entry.metadata.id)}-${frame}.png`) : resolve18(exportDestination(config), `${outputName(video.entry.metadata.id)}-${frame}.png`);
               await renderStill(
                 origin,
                 targetFor(
@@ -2426,6 +2609,9 @@ var devCommand = async (options = {}) => {
             }
             if (request.method === "POST" && url.startsWith("/exports")) {
               const body = await readBody(request);
+              const format = resolveFormat(typeof body.format === "string" ? body.format : void 0, void 0);
+              const quality = resolveQuality(typeof body.quality === "string" ? body.quality : void 0);
+              const scale = resolveScale(typeof body.scale === "number" ? body.scale : void 0);
               const { graph, videos } = await context();
               const video = findVideo(videos, String(body.videoId));
               const input = body.input ?? {};
@@ -2437,8 +2623,11 @@ var devCommand = async (options = {}) => {
                 input,
                 { scenes: compiled.scenes, audio: compiled.audio }
               );
-              const output = resolve18(config.root, `${config.exportDir}/${outputName(video.entry.metadata.id)}.mp4`);
-              const record = await createJob(config, manifest, output);
+              const output = resolve18(
+                exportDestination(config),
+                `${outputName(video.entry.metadata.id)}${format.extension}`
+              );
+              const record = await createJob(config, manifest, output, { format: format.name, quality, scale });
               json(response, 202, record.job);
               void runJob(config, origin, record, video).catch((error) => {
                 log.error(`Export failed: ${error instanceof Error ? error.message : String(error)}`);
@@ -2446,7 +2635,7 @@ var devCommand = async (options = {}) => {
               return;
             }
             if (request.method === "POST" && url.startsWith("/retry/")) {
-              const id = url.replace("/retry/", "").split("?")[0];
+              const id = safeJobId(url.replace("/retry/", "").split("?")[0]);
               const record = await readJob(config, id);
               const { videos } = await context();
               const video = findVideo(videos, record.manifest.videoId);
@@ -2457,13 +2646,13 @@ var devCommand = async (options = {}) => {
               return;
             }
             if (request.method === "POST" && url.startsWith("/cancel/")) {
-              const id = url.replace("/cancel/", "").split("?")[0];
+              const id = safeJobId(url.replace("/cancel/", "").split("?")[0]);
               const cancelled = cancelJob(id);
               json(response, cancelled ? 202 : 404, { id, cancelled });
               return;
             }
             if (request.method === "GET" && url.startsWith("/jobs/")) {
-              const id = url.replace("/jobs/", "").split("?")[0];
+              const id = safeJobId(url.replace("/jobs/", "").split("?")[0]);
               json(response, 200, (await readJob(config, id)).job);
               return;
             }
@@ -2480,7 +2669,7 @@ var devCommand = async (options = {}) => {
     }
   });
   const origin = server.url;
-  const entry = `${origin}/videos`;
+  const entry = `${origin}/`;
   log.title("Odori Studio");
   log.info(`  ${entry}`);
   log.detail(`  ${server.graph.videos.length} videos, ${server.graph.previews.length} component previews`);
@@ -2492,9 +2681,9 @@ var devCommand = async (options = {}) => {
 // src/commands/doctor.ts
 import { constants } from "fs";
 import { access, mkdir as mkdir12, readFile as readFile13, rm as rm3, writeFile as writeFile13 } from "fs/promises";
-import { existsSync as existsSync15 } from "fs";
+import { existsSync as existsSync16 } from "fs";
 import { createRequire as createRequire3 } from "module";
-import { relative as relative5, resolve as resolve19 } from "path";
+import { relative as relative6, resolve as resolve19 } from "path";
 var MINIMUM_NODE = 20;
 var version = (value) => value.replace(/^v/, "").split(".").map(Number);
 var runChecks = async (root) => {
@@ -2526,13 +2715,13 @@ var runChecks = async (root) => {
   const videosDir = resolve19(config.root, config.videosDir);
   checks.push({
     name: "Source root",
-    detail: existsSync15(videosDir) ? relative5(config.root, videosDir) + "/" : `no ${config.videosDir}/`,
-    ok: existsSync15(videosDir),
+    detail: existsSync16(videosDir) ? relative6(config.root, videosDir) + "/" : `no ${config.videosDir}/`,
+    ok: existsSync16(videosDir),
     fix: 'Run "odori init" to add the videos source root.'
   });
   checks.push({
     name: "Config",
-    detail: config.configPath ? relative5(config.root, config.configPath) : "defaults (no odori.config.ts)",
+    detail: config.configPath ? relative6(config.root, config.configPath) : "defaults (no odori.config.ts)",
     // Loading got this far, so a config that exists also parsed.
     ok: true
   });
@@ -2574,7 +2763,7 @@ var runChecks = async (root) => {
     name: "Generated cache",
     detail: writable ? ".odori/ is writable" : ".odori/ cannot be written",
     ok: writable,
-    fix: `Odori writes its import graph and render cache to ${relative5(process.cwd(), generated) || ".odori"}. Check the directory's permissions.`
+    fix: `Odori writes its import graph and render cache to ${relative6(process.cwd(), generated) || ".odori"}. Check the directory's permissions.`
   });
   return checks;
 };
@@ -2599,13 +2788,13 @@ var doctorCommand = async (root = process.cwd()) => {
 
 // src/commands/init.ts
 import { mkdir as mkdir14, writeFile as writeFile15 } from "fs/promises";
-import { existsSync as existsSync17 } from "fs";
-import { relative as relative7, resolve as resolve21 } from "path";
+import { existsSync as existsSync18 } from "fs";
+import { relative as relative8, resolve as resolve21 } from "path";
 
 // src/commands/new.ts
 import { mkdir as mkdir13, readdir as readdir5, writeFile as writeFile14 } from "fs/promises";
-import { existsSync as existsSync16 } from "fs";
-import { relative as relative6, resolve as resolve20 } from "path";
+import { existsSync as existsSync17 } from "fs";
+import { relative as relative7, resolve as resolve20 } from "path";
 var titleCase = (value) => value.split(/[-_\s]+/).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ");
 var pascalCase = (value) => titleCase(value).replace(/\s+/g, "");
 var videoTemplate = (name, hasLayout) => `import {Scene, Video, defineVideoMetadata} from "odori";
@@ -2664,7 +2853,7 @@ ${closing}
 };
 var installedParts = async (config) => {
   const componentsDir = resolve20(config.root, config.componentsDir);
-  if (!existsSync16(componentsDir)) return { title: false, end: false };
+  if (!existsSync17(componentsDir)) return { title: false, end: false };
   const entries = (await readdir5(componentsDir, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
   return { title: entries.includes("title-reveal"), end: entries.includes("end-card") };
 };
@@ -2673,8 +2862,8 @@ var newCommand = async (name, options = {}) => {
   const config = await loadConfig(process.cwd());
   const directory2 = resolve20(config.root, config.videosDir, name);
   const file = resolve20(directory2, "video.tsx");
-  if (existsSync16(file)) throw new Error(`${relative6(config.root, file)} already exists.`);
-  const hasLayout = existsSync16(resolve20(config.root, config.videosDir, "layout.tsx"));
+  if (existsSync17(file)) throw new Error(`${relative7(config.root, file)} already exists.`);
+  const hasLayout = existsSync17(resolve20(config.root, config.videosDir, "layout.tsx"));
   const parts = options.blank === true ? { title: false, end: false } : await installedParts(config);
   const composed = parts.title || parts.end;
   await mkdir13(directory2, { recursive: true });
@@ -2683,10 +2872,10 @@ var newCommand = async (name, options = {}) => {
     composed ? composedTemplate(name, hasLayout, parts) : videoTemplate(name, hasLayout),
     "utf8"
   );
-  log.success(`Created ${relative6(config.root, file)}`);
+  log.success(`Created ${relative7(config.root, file)}`);
   if (composed) log.detail("Composed from the components this project has installed.");
   else if (options.blank !== true) {
-    log.detail("No registry components installed yet: odori add @odori/title-reveal @odori/end-card");
+    log.detail("No registry components installed yet: odori add title-reveal end-card");
   }
   log.detail("Run odori dev to preview it.");
 };
@@ -2725,15 +2914,15 @@ var initCommand = async (root = process.cwd()) => {
     [resolve21(videosDir, "launch", "video.tsx"), videoTemplate("launch", true)]
   ];
   for (const [file, contents] of files) {
-    if (existsSync17(file)) {
-      log.detail(`Kept existing ${relative7(root, file)}`);
+    if (existsSync18(file)) {
+      log.detail(`Kept existing ${relative8(root, file)}`);
       continue;
     }
     await mkdir14(resolve21(file, ".."), { recursive: true });
     await writeFile15(file, contents, "utf8");
-    log.success(`Created ${relative7(root, file)}`);
+    log.success(`Created ${relative8(root, file)}`);
   }
-  log.detail("Next: odori doctor, then odori add @odori/title-reveal @odori/end-card, then odori dev.");
+  log.detail("Next: odori doctor, then odori add title-reveal end-card, then odori dev.");
 };
 
 // src/commands/inspect.ts
@@ -2855,7 +3044,7 @@ var stillCommand = async (id, options = {}) => {
 import { isOdoriSchema as isOdoriSchema2, resolveEntryLayout as resolveEntryLayout8 } from "odori";
 
 // src/contracts.ts
-import { existsSync as existsSync18 } from "fs";
+import { existsSync as existsSync19 } from "fs";
 import { readdir as readdir6 } from "fs/promises";
 import { resolve as resolve23 } from "path";
 import { cueUrl as cueUrl2, isCueDefinition as isCueDefinition2, resolveEntryLayout as resolveEntryLayout7 } from "odori";
@@ -2925,7 +3114,7 @@ var checkAudioWindows = (cues, brand, videoId) => {
 };
 var checkInstalledContracts = async (config, videos) => {
   const componentsDir = resolve23(config.root, config.componentsDir);
-  const onDisk = existsSync18(componentsDir) ? (await readdir6(componentsDir, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => entry.name) : [];
+  const onDisk = existsSync19(componentsDir) ? (await readdir6(componentsDir, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => entry.name) : [];
   const names = /* @__PURE__ */ new Set([...Object.keys(await readProvenance(config)), ...onDisk]);
   if (names.size === 0) return [];
   const { items } = await resolveRegistry(config, { allowNetwork: false });
@@ -2947,8 +3136,8 @@ var checkInstalledContracts = async (config, videos) => {
 
 // src/determinism.ts
 import { readdir as readdir7, readFile as readFile14 } from "fs/promises";
-import { existsSync as existsSync19 } from "fs";
-import { join as join7, relative as relative8, resolve as resolve24 } from "path";
+import { existsSync as existsSync20 } from "fs";
+import { join as join7, relative as relative9, resolve as resolve24 } from "path";
 var FORBIDDEN = [
   {
     pattern: /\bMath\.random\s*\(/,
@@ -2990,10 +3179,10 @@ var walk2 = async (directory2, files = []) => {
 };
 var checkDeterminism = async (config) => {
   const root = resolve24(config.root, config.videosDir);
-  if (!existsSync19(root)) return [];
+  if (!existsSync20(root)) return [];
   const files = await walk2(root);
   const findings = await Promise.all(
-    files.map(async (file) => scanSource(await readFile14(file, "utf8"), relative8(config.root, file)))
+    files.map(async (file) => scanSource(await readFile14(file, "utf8"), relative9(config.root, file)))
   );
   return findings.flat();
 };
@@ -3259,7 +3448,7 @@ var COMMAND_FLAGS = {
   inspect: ["json", "input"],
   still: ["frame", "output", "input"],
   test: ["json"],
-  export: ["output", "input", "concurrency", "preset", "format", "no-frame-skip", "retry"],
+  export: ["output", "input", "concurrency", "preset", "format", "quality", "scale", "no-frame-skip", "retry"],
   jobs: [],
   help: []
 };
@@ -3326,9 +3515,12 @@ var USAGE = {
   Validate contracts and representative frames. --json emits one object per
   check, for CI.`,
   export: `odori export <id> [--output <path>] [--input <json>] [--concurrency <n>]
-             [--preset <name>] [--format <name>] [--no-frame-skip] [--retry <job>]
+             [--preset <name>] [--format <name>] [--quality <tier>] [--scale <n>]
+             [--no-frame-skip] [--retry <job>]
   Render and encode a distributable file. --format is mp4, webm, prores, gif,
-  or png; without it the output's extension decides, and mp4 is the default.`,
+  or png; without it the output's extension decides, and mp4 is the default.
+  --quality is studio, social, or web. --scale multiplies the output size,
+  0.25 to 2. A retry keeps the settings its job was created with.`,
   jobs: `odori jobs
   List export jobs and their status.`
 };
@@ -3358,6 +3550,8 @@ Options
   --concurrency <n>                Parallel render workers for export
   --preset <name>                  x264 preset for export, default medium
   --format <name>                  mp4, webm, prores, gif, or png
+  --quality <tier>                 studio, social, or web compression
+  --scale <n>                      Output size multiplier, 0.25 to 2
   --no-frame-skip                  Capture every frame, even unchanged ones
   --retry <job id>                 Re-run a recorded job from its frozen manifest
   --no-open                        Start dev without opening Studio in a browser
@@ -3444,6 +3638,8 @@ var run2 = async (argv) => {
           input: parseInput(flags),
           concurrency: numberFlag(flags, "concurrency"),
           preset: typeof flags.preset === "string" ? flags.preset : void 0,
+          quality: typeof flags.quality === "string" ? flags.quality : void 0,
+          scale: numberFlag(flags, "scale"),
           format: typeof flags.format === "string" ? flags.format : void 0,
           skipUnchangedFrames: flags["no-frame-skip"] === true ? false : void 0,
           retry: typeof flags.retry === "string" ? flags.retry : void 0
@@ -3478,6 +3674,7 @@ export {
   discoverProject,
   generateImports,
   writeGenerated,
+  startStudioServer,
   localCandidates,
   createIntegrityResolver,
   outputName,
@@ -3497,7 +3694,6 @@ export {
   findVideo,
   runPrepare,
   freezeManifest,
-  startStudioServer,
   resolveCueFile,
   buildAudioFilter,
   planChunks,