npm - ossclip - Versions diffs - 0.1.35 → 0.1.36 - Mend

ossclip 0.1.35 → 0.1.36

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (9) hide show

package/editor-dist/assets/index-pWbFr8vc.js +168 -0
package/editor-dist/index.html +1 -1
package/package.json +4 -4
package/src/cover.ts +18 -0
package/src/edit.ts +67 -2
package/src/interactive/produce-wizard.ts +7 -1
package/src/produce.ts +185 -1
package/src/program.ts +21 -0
package/editor-dist/assets/index-DSB_SCmp.js +0 -166

package/editor-dist/index.html CHANGED Viewed

@@ -4,7 +4,7 @@
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>ossclip editor</title>
-    <script type="module" crossorigin src="/assets/index-DSB_SCmp.js"></script>
+    <script type="module" crossorigin src="/assets/index-pWbFr8vc.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-Bx2VQLP8.css">
   </head>
   <body>

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "ossclip",
-  "version": "0.1.35",
+  "version": "0.1.36",
   "description": "Local-first CLI video producer: cuts silence and fillers, word-timed captions, face-aware framing, and LLM-planned code-rendered graphics — transcription and rendering never leave your machine",
   "type": "module",
   "license": "MIT",
@@ -36,9 +36,9 @@
     "commander": "^12.1.0",
     "tsx": "^4.19.0",
     "zod": "^3.25.76",
-    "@ossclip/core": "0.1.35",
-    "@ossclip/renderer": "0.1.35",
-    "@ossclip/scenes": "0.1.35"
+    "@ossclip/core": "0.1.36",
+    "@ossclip/renderer": "0.1.36",
+    "@ossclip/scenes": "0.1.36"
   },
   "homepage": "https://github.com/AhsanAyaz/ossclip#readme",
   "bugs": {

package/src/cover.ts CHANGED Viewed

@@ -468,6 +468,24 @@ export function coverTextHold(args: {
         `(--cover-text-reset, or deleting ${COVER_PROVENANCE_BASENAME}, goes back to the generated one)`,
     };
   }
+  // The replay-render gap (field report 2026-08-31): a run without --produce
+  // generates NO headline, and letting that empty string win silently
+  // downgraded a banner cover to a bare frame on every render-from-the-
+  // editor. A persisted headline of ANY source outranks an empty generation
+  // — there is no fresher text to prefer. `reset` still goes bare: that is
+  // the user explicitly asking for the generated (here: no) headline.
+  if (
+    !args.reset &&
+    args.generated.trim() === "" &&
+    args.persisted !== null &&
+    args.persisted.text.trim() !== ""
+  ) {
+    return {
+      text: args.persisted.text,
+      textSource: args.persisted.textSource,
+      message: `▸ cover: keeping the previous headline "${args.persisted.text}" (this run generated none)`,
+    };
+  }
   return { text: args.generated, textSource: "beatsheet" };
 }

package/src/edit.ts CHANGED Viewed

@@ -4,7 +4,7 @@ import { createReadStream, existsSync, readFileSync, statSync } from "node:fs";
 import { copyFile, mkdir, readFile, readdir, rename, stat, unlink, writeFile } from "node:fs/promises";
 import { createServer, type IncomingMessage, type ServerResponse } from "node:http";
 import { homedir } from "node:os";
-import { dirname, extname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { basename, dirname, extname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
 import { z } from "zod/v4";
 import {
@@ -56,6 +56,14 @@ import {
   // Resolved here too, not just in produce: an editor that offered stock sounds
   // the config excludes would let a user pick one the next render drops.
   resolveSfxBundledPack,
+  // The Color panel's .cube menu (2026-08-30): the same loader produce's LUT
+  // bake resolves against, the loadSfxLibrary rule for grades.
+  loadLutLibrary,
+  // …and the validator every grade layer goes through — the /api/luts payload
+  // carries the CONFIG grade so the panel can label its "Default" entry, and
+  // a malformed config value must read as "no default" there exactly as it
+  // reads in produce (`resolveProductionColorGrade` falls through to off).
+  resolveColorGrade,
   outInsideInputFolderMessage,
   outPathInsideInput,
   PORTRAIT_MIME_TYPES,
@@ -119,6 +127,7 @@ import { lastFlagValue, thumbnailPanelState } from "./thumbnail-panel";
 import { captionRegenProvider } from "./caption-regen-panel";
 import { binOnPath } from "./llm-detect";
 import {
+  YOUTUBE_PRIVACIES,
   attachDeliveryMedia,
   buildPublishPosts,
   publishConfigured,
@@ -436,6 +445,10 @@ export async function startEditServer(
        * `unknown` because it is file-only and typed at the consumer
        * (`resolveSfxBundledPack`), the `audience` rule. */
       sfxBundledPack?: unknown;
+      /** The config-level default grade the Color panel's "Default" entry
+       * names — `unknown` because it is file-only and typed at the consumer
+       * (`resolveColorGrade`), the `sfxBundledPack` rule. */
+      colorGrade?: unknown;
     } & RetranscribeConfig;
     /** Env seam for the publish endpoints — tests inject their own so the
      * runner's real OSSCLIP_POSTIZ_API_KEY (or its absence) never decides a
@@ -481,6 +494,10 @@ export async function startEditServer(
      * loader rather than only that the routes serve what they were handed.
      */
     loadSfx?: typeof loadSfxLibrary;
+    /** The LUT library `/api/luts` serves — the `loadSfx` seam for grades:
+     * tests inject a hand-written library instead of depending on whatever
+     * the developer keeps in ~/.ossclip/luts. */
+    loadLuts?: typeof loadLutLibrary;
   } = {},
 ): Promise<EditServer> {
   // MUTABLE since R17 §83: the server can start with no project (the page
@@ -1971,6 +1988,14 @@ export async function startEditServer(
               // What uploads (the CLI's --delivery): auto (default) builds
               // the cached delivery encode, master sends the untouched render.
               delivery: z.enum(["auto", "master"]).optional(),
+              // YouTube's privacy status (the CLI's --youtube-privacy),
+              // spelled ONCE — the flag's own value list, so the panel and
+              // the CLI can never accept different words. Absent leaves
+              // buildPostsPayload's safe private default alone: until this
+              // rode along, every panel publish landed private with no way
+              // to say otherwise, and two videos the user believed were
+              // published sat private on the channel (2026-08-29).
+              youtubePrivacy: z.enum(YOUTUBE_PRIVACIES).optional(),
             })
             .safeParse(JSON.parse(Buffer.concat(chunks).toString() || "{}"));
           if (!parsed.success) return send(400, { error: parsed.error.message });
@@ -2077,7 +2102,14 @@ export async function startEditServer(
               }
               capGroups = sizeCapGroups(picked);
             }
-            const posts = buildPublishPosts(pack, picked).map((p) => ({
+            // Same options object the CLI's publish path passes — undefined
+            // stays undefined so buildPostsPayload's safe private default is
+            // still the ONE place that decides an absent privacy.
+            const posts = buildPublishPosts(pack, picked, {
+              ...(parsed.data.youtubePrivacy !== undefined
+                ? { youtubePrivacy: parsed.data.youtubePrivacy }
+                : {}),
+            }).map((p) => ({
               ...p,
               caption: parsed.data.captions?.[p.target.id] ?? p.caption,
             }));
@@ -2624,6 +2656,39 @@ export async function startEditServer(
           });
         }
+        if (url.pathname === "/api/luts" && req.method === "GET") {
+          // The Color panel's .cube menu plus the config-level default grade.
+          // NO workdir guard, /api/sfx/library's rule: both halves are
+          // machine-global (~/.ossclip/luts and config.json), so the panel can
+          // build its dropdown before a project is open. Read per request like
+          // every other loadCfg consumer — a LUT dropped while the editor is
+          // up appears on the next refresh, not on a restart.
+          const library = (opts.loadLuts ?? loadLutLibrary)();
+          // The config grade rides along VALIDATED, not raw: a malformed
+          // config value is what produce ignores (`resolveProductionColorGrade`
+          // warns and proceeds without it), so a "Default (…)" entry built
+          // from it would offer an inherit that renders as nothing. Null means
+          // the panel shows no Default entry, and the warning is dropped for
+          // the sfxLibrary helper's reason — no console here, produce prints
+          // it on the run that grades.
+          const configGrade = resolveColorGrade(
+            (opts.loadCfg ?? loadConfig)().colorGrade,
+            "config",
+          ).grade;
+          return send(200, {
+            // METADATA only, the sfx library rule: the absolute `path` stays
+            // server-side. `file` (the basename, extension and all) is what an
+            // editor-written override must carry — `ColorGrade.lut` documents
+            // the basename, produce joins it against ~/.ossclip/luts verbatim,
+            // and a stem-only id would drop the `.CUBE` an exporter spelled.
+            items: library.items.map((l) => ({ id: l.id, title: l.title, file: basename(l.path) })),
+            // A ~/.ossclip/luts author's only surface, like the sfx panel:
+            // the loader degraded instead of throwing, so show the reason.
+            issues: library.issues,
+            configGrade: configGrade ?? null,
+          });
+        }
         if (url.pathname === "/api/sfx/audio" && req.method === "GET") {
           // Click-to-preview. The path comes from the LOADED LIBRARY, never
           // from the client: the query carries an id, the id is looked up, and

package/src/interactive/produce-wizard.ts CHANGED Viewed

@@ -10,7 +10,7 @@ import { produceArgv, type ProduceAnswers, type ProduceExtras } from "./produce-
 import { assertInteractive, confirm, intro, multiselect, select, text, unwrap } from "./prompts";
 /**
- * The produce wizard. Forty-one flags (plus the positional input path)
+ * The produce wizard. Forty-three flags (plus the positional input path)
  * sorted into three tiers: six prompts asked directly — the input path, plus
  * five flags (--out, --cleanup, --aspect, --produce, --intent) — twelve
  * behind one "anything else?" multiselect (--sfx being the twelfth, with
@@ -18,6 +18,12 @@ import { assertInteractive, confirm, intro, multiselect, select, text, unwrap }
  * debug/internal surfaces, replay-only fields, --no-watermark (the
  * multiselect only turns the credit ON; off is already the default),
  * --no-youtube (the same shape: the pack entry only turns it ON),
+ * --color-grade (2026-08-30, the --resolution shape: a channel's look is a
+ * durable machine preference, set once as `colorGrade` in
+ * ~/.ossclip/config.json rather than re-picked per wizard run — and an
+ * honest prompt would need to enumerate ~/.ossclip/luts and preview five
+ * presets, a design nobody has made; --no-color-grade then mirrors
+ * --no-watermark's tier for the same off-is-default reason),
  * --captions (the mirror case: ON is already the default, so the
  * multiselect entry is the OFF switch and the positive flag exists only for
  * replay pinning), --add-jump-cuts (same mirror: auto already punches, the

package/src/produce.ts CHANGED Viewed

@@ -124,6 +124,18 @@ import {
   makeMezzanine,
   mezzanineFileName,
   mezzanineScale,
+  // The color-grade pipeline (2026-08-30): validation, the preset/LUT split,
+  // the SVG filter spec preset grades ride render-props as, and the .cube
+  // bake+hash LUT grades ride the mezzanine as.
+  CONFIG_DIR,
+  resolveColorGrade,
+  resolveGradeToLook,
+  gradeToSvgFilterSpec,
+  parseCubeLut,
+  bakeCube,
+  lutHash,
+  type ColorGrade,
+  type SvgGradeFilterSpec,
   scaleContentTimeline,
   scaleFramingWindows,
   measureFace,
@@ -725,6 +737,16 @@ export interface ProduceOptions {
    * ignore an uploaded cover.
    */
   coverInVideo?: boolean;
+  /**
+   * `--color-grade <look>` / `--no-color-grade` — the watermark's tri-state
+   * carrying a VALUE: a string when typed (a preset id, or a `.cube`
+   * filename — `colorGradeFlagValue` classifies by extension), `false` for a
+   * typed --no-color-grade, undefined when neither so overrides.json and
+   * then the config's `colorGrade` decide (`resolveProductionColorGrade`).
+   * Deliberately unparsed in transit: validation warns-and-proceeds at the
+   * use site, because a grade typo must cost the look, never the run.
+   */
+  colorGrade?: string | false;
   /**
    * `--youtube` / `--no-youtube` tri-state, the watermark's exact contract:
    * true/false when TYPED, undefined when not — undefined lets the config's
@@ -861,6 +883,71 @@ export function resolveCoverInVideo(
   return flag ?? configValue === true;
 }
+/**
+ * `--color-grade`'s value classified into the ColorGradeSchema shape: a value
+ * ending in `.cube` names a LUT file in `~/.ossclip/luts`, anything else
+ * names a preset. Sniffed by extension rather than split into two flags
+ * because the user already knows which they typed — `kodak.cube` cannot be a
+ * preset id (presets never carry a dot) and a preset id cannot be a LUT
+ * (`.cube` is the one format the parser reads), so the classification is
+ * lossless. Case-insensitive on the extension: `KODAK.CUBE` is the same file
+ * on the case-preserving filesystems the LUT dir lives on. Validation is NOT
+ * here — the shape goes through `resolveColorGrade` like every other layer.
+ */
+export function colorGradeFlagValue(value: string): { preset?: string; lut?: string } {
+  return value.toLowerCase().endsWith(".cube") ? { lut: value } : { preset: value };
+}
+/**
+ * The effective color grade across all three surfaces — override > flag >
+ * config, `resolveWatermark`'s typed-beats-config precedence grown one layer:
+ * the overrides doc is the editor's per-project say, so it beats even a typed
+ * flag (the `resolveSrcTimingPins` rationale — a per-project decision made in
+ * the editor outranks a per-run flag, never merges with it). An explicit
+ * `false` at a switching layer (`colorGrade: false` in the doc, or a typed
+ * `--no-color-grade`) is OFF, not fall-through: "no grade" is a decision, and
+ * letting a lower layer overrule it would make the disable impossible to
+ * express.
+ *
+ * Every layer is validated through `resolveColorGrade`, and an INVALID layer
+ * is ignored — warned about by name, then the NEXT layer applies (decision
+ * 2026-08-30): the alternative, an invalid override going all the way to
+ * "off", would let one stale editor write silently strip the config grade a
+ * channel's whole look depends on. Warnings are RETURNED, not printed
+ * (`resolveSfxLevel`'s shape), so the whole matrix is testable without a TTY.
+ * `source` names the winning layer so the ▸ line can say where a grade came
+ * from — the watermark's "(from config; --no-… overrides)" visibility rule.
+ */
+export function resolveProductionColorGrade(p: {
+  override: ColorGrade | false | undefined;
+  flag: string | false | undefined;
+  config: unknown;
+}): { grade?: ColorGrade; source?: "override" | "flag" | "config"; warnings: string[] } {
+  const warnings: string[] = [];
+  if (p.override === false) return { warnings };
+  if (p.override !== undefined) {
+    // Schema-valid already (OverrideDocSchema parsed the doc), but the
+    // unknown-preset check lives in resolveColorGrade, not the schema — this
+    // is the layer where a preset the editor knew and this build doesn't
+    // falls through instead of failing the doc.
+    const r = resolveColorGrade(p.override, "overrides.json");
+    if (r.grade) return { grade: r.grade, source: "override", warnings };
+    if (r.warning) warnings.push(r.warning);
+  }
+  if (p.flag === false) return { warnings };
+  if (p.flag !== undefined) {
+    const r = resolveColorGrade(colorGradeFlagValue(p.flag), "--color-grade");
+    if (r.grade) return { grade: r.grade, source: "flag", warnings };
+    if (r.warning) warnings.push(r.warning);
+  }
+  // "config", not "config colorGrade": resolveColorGrade's warning already
+  // spells the key (`⚠ <source> colorGrade ignored — …`).
+  const r = resolveColorGrade(p.config, "config");
+  if (r.grade) return { grade: r.grade, source: "config", warnings };
+  if (r.warning) warnings.push(r.warning);
+  return { warnings };
+}
 /**
  * `--sfx-level` implies `--sfx`: typing a level is asking for sound effects,
  * and a run that quietly did nothing because the boolean was missing is the
@@ -4714,6 +4801,88 @@ export async function produce(inputArg: string, opts: ProduceOptions): Promise<P
   // on a bar-free source): there is no re-encode to scale, the render plays
   // the source itself, and the window emissions below must then stay in true
   // source pixels — which the identity `mezzFactor` below guarantees.
+  // ---- Color grade (`--color-grade` / config `colorGrade` / the editor's
+  // overrides.json) ---------------------------------------------------------
+  // Resolved HERE, before the mezzanine encode, because the feature's two
+  // halves split at exactly this seam: a PRESET grade rides render-props as
+  // an SVG filter spec (the props assembly below), while a LUT grade is baked
+  // INTO the mezzanine (ingest.ts's `lut` option) — ffmpeg's lut3d on the
+  // encode pass costs nothing per rendered frame, where a 33³ trilinear
+  // lookup in the browser would. Precedence and validation live in
+  // `resolveProductionColorGrade`; every warning it returns prints once here,
+  // and every failure path proceeds UNGRADED — a grade must cost the look at
+  // worst, never the run.
+  const gradeResolution = resolveProductionColorGrade({
+    override: overrideDoc.colorGrade,
+    flag: opts.colorGrade,
+    config: cfg.colorGrade,
+  });
+  for (const w of gradeResolution.warnings) console.log(w);
+  /** Preset grades: the spec render-props carries (absent = no grade). */
+  let colorGradeSpec: SvgGradeFilterSpec | undefined;
+  /** LUT grades: the baked .cube the mezzanine encode applies (absent = none). */
+  let gradeLut: { path: string; hash: string } | undefined;
+  if (gradeResolution.grade !== undefined) {
+    // The watermark's visibility rule: a grade sourced anywhere but the
+    // typed flag says so, so a config- or editor-sourced look never
+    // surprises the author on upload.
+    const gradeFromNote =
+      gradeResolution.source === "config"
+        ? " (from config; --no-color-grade overrides)"
+        : gradeResolution.source === "override"
+          ? " (editor override)"
+          : "";
+    const resolvedLook = resolveGradeToLook(gradeResolution.grade);
+    if (resolvedLook.kind === "preset") {
+      colorGradeSpec = gradeToSvgFilterSpec(resolvedLook);
+      console.log(`▸ color grade: ${gradeResolution.grade.preset}${gradeFromNote}`);
+    } else if (!mezzanineWillBuild) {
+      // --no-mezzanine on a bar-free source: the render plays the source
+      // file itself, so there is no encode to bake the LUT into. Warn and
+      // proceed ungraded rather than force a mezzanine the user refused.
+      console.log(
+        `⚠ color grade skipped — a .cube LUT is baked into the mezzanine, ` +
+          `and --no-mezzanine means this run doesn't build one`,
+      );
+    } else {
+      try {
+        // Basename only, enforced before any path math: `lut` is a NAME the
+        // schema documents as living in ~/.ossclip/luts, and resolving a
+        // separator-carrying value would turn a config key into a file probe
+        // (the SfxAddedPlacement id's "nothing may ever resolve a path
+        // against it" rule, applied at the one place this name meets the
+        // filesystem).
+        if (basename(resolvedLook.lutRef) !== resolvedLook.lutRef) {
+          throw new Error(
+            `"${resolvedLook.lutRef}" is not a bare filename — LUTs live in ${join(CONFIG_DIR, "luts")}`,
+          );
+        }
+        const lutPath = join(CONFIG_DIR, "luts", resolvedLook.lutRef);
+        const baseLut = parseCubeLut(readFileSync(lutPath, "utf8"));
+        // Tweaks + intensity are baked into the cube (bakeCube composes
+        // `params` on top of the base sample), so the hash keys the WHOLE
+        // grade: change the intensity and the mezzanine filename changes
+        // with it (`mezzanineFileName`'s existence-keyed cache).
+        const cubeText = bakeCube({
+          base: baseLut,
+          params: resolvedLook.tweaks,
+          intensity: resolvedLook.intensity,
+        });
+        const hash = lutHash(cubeText);
+        const bakedPath = join(work, `grade-${hash}.cube`);
+        await writeFile(bakedPath, cubeText);
+        gradeLut = { path: bakedPath, hash };
+        console.log(`▸ color grade: LUT ${resolvedLook.lutRef}${gradeFromNote}`);
+      } catch (err) {
+        // ENOENT and a malformed .cube land here alike: name the problem,
+        // proceed ungraded. parseCubeLut's errors already carry the line.
+        console.log(
+          `⚠ color grade skipped — ${err instanceof Error ? err.message : String(err)}`,
+        );
+      }
+    }
+  }
   const mezzScale = mezzanineWillBuild
     ? mezzanineScale(
         { width: contentRect.w, height: contentRect.h, fps: sourceProbe.fps },
@@ -4726,7 +4895,10 @@ export async function produce(inputArg: string, opts: ProduceOptions): Promise<P
     // why): mezzanine caching is existence-keyed, so a pre-pass full-res
     // mezzanine.mp4 must not satisfy a run that emits mezzanine-sized
     // windows — the scaled file rebuilds once under its own name.
-    const mezz = join(work, mezzanineFileName(!contentRect.full, mezzScale));
+    // `gradeLut?.hash` rides the name so a graded mezzanine can never satisfy
+    // an ungraded run (or vice versa) — the LUT is pixels in the file, and
+    // the cache is existence-keyed.
+    const mezz = join(work, mezzanineFileName(!contentRect.full, mezzScale, gradeLut?.hash));
     if (!existsSync(mezz)) {
       const mezzAnim = isInteractive()
         ? new StageAnimator(
@@ -4747,6 +4919,10 @@ export async function produce(inputArg: string, opts: ProduceOptions): Promise<P
       await makeMezzanine(tools, input, mezz, {
         cropVf: cropVf || undefined,
         scale: mezzScale ?? undefined,
+        // The LUT grade's whole delivery: baked into the encode, so the
+        // render (and the editor's preview, which plays the same file) see
+        // graded pixels with no per-frame cost.
+        lut: gradeLut,
       });
       if (mezzAnim) mezzAnim.stop();
     }
@@ -5069,6 +5245,14 @@ export async function produce(inputArg: string, opts: ProduceOptions): Promise<P
     // one, and the composition reads an absent key as silence, not as an empty
     // track it still has to mount.
     ...(sfxCues.length > 0 ? { sfxCues } : {}),
+    // `--color-grade` PRESET looks, written only when one resolved (the
+    // watermark's absent-means-off contract): the two-stage SVG filter spec
+    // ({tableR, tableG, tableB, colorMatrix}, gradeToSvgFilterSpec) the
+    // composition mounts over the video. A LUT grade deliberately writes
+    // NOTHING here — it was baked into the mezzanine above, so the pixels
+    // the renderer plays already carry it, and a spec on top would grade
+    // twice.
+    ...(colorGradeSpec ? { colorGrade: colorGradeSpec } : {}),
   };
   await writeFile(join(work, "render-props.json"), JSON.stringify(props, null, 2));

package/src/program.ts CHANGED Viewed

@@ -472,6 +472,21 @@ export function buildProgram(): Command {
         "(set it once with coverInVideo: true in ~/.ossclip/config.json)",
     )
     .option("--no-cover-in-video", "no cover overlay, even when the config turns it on")
+    // The watermark's tri-state carrying a VALUE: commander folds the pair
+    // onto one key (string when typed, false for --no-color-grade, undefined
+    // when neither — which is what lets overrides.json and then the config's
+    // `colorGrade` decide). The value is NOT parsed here, unlike --sfx-level:
+    // it may be a preset id OR a .cube filename, so an enum parse can't hold
+    // it — classification and validation live at the consumer
+    // (colorGradeFlagValue / resolveProductionColorGrade in produce.ts),
+    // where a typo warns and the run proceeds ungraded rather than dying.
+    .option(
+      "--color-grade <look>",
+      "color grade the footage: a preset (talking-head | teal-orange | filmic-fade | " +
+        "cwa | punchy | mono) or a .cube LUT filename from ~/.ossclip/luts " +
+        '(set it once with colorGrade: {"preset": "..."} in ~/.ossclip/config.json)',
+    )
+    .option("--no-color-grade", "no color grade, even when the config sets one")
     // Same tri-state shape as --watermark above (positive declared first so
     // commander's default stays undefined = "not typed"): the config's
     // `youtube` key supplies the default (resolveYoutube), and a typed
@@ -722,6 +737,12 @@ export function buildProgram(): Command {
           // The watermark's tri-state again, resolved by resolveCoverInVideo
           // at the use site against the config's `coverInVideo`.
           coverInVideo: opts.coverInVideo,
+          // string | false | undefined straight through: undefined = "not
+          // typed" lets overrides.json and then the config's `colorGrade`
+          // decide, and the value itself is classified and validated at the
+          // use site (resolveProductionColorGrade) — see the option's own
+          // comment for why no parse happens here.
+          colorGrade: opts.colorGrade,
           // The same tri-state contract as watermark, resolved by
           // resolveYoutube at the use site; --portrait rides along untyped =
           // undefined so the config's path can supply it.