ossclip 0.1.33 → 0.1.34

package/src/produce.ts

@@ -166,7 +166,12 @@ import {
   AGY_PRINT_TIMEOUT,
   type Production,
   ossclipOutputPathFor,
+  resolveOutputFrame,
+  RESOLUTION_CHOICES,
+  smallestSource,
+  ResolutionChoiceSchema,
   type ProviderName,
+  type ResolutionChoice,
   type Scene,
   type SceneComponentId,
   type Segment,
@@ -256,6 +261,14 @@ export const TranscriptKeySchema = z.object({
    * runs) means "no biasing".
    */
   dictionary: z.array(z.string()).optional(),
+  /**
+   * Whether whisper ran its TRANSLATE task (`-tr`, 2026-08-29). It changes
+   * the decoded TEXT — Urdu speech comes back as English words — so it
+   * re-keys the cache exactly like the language does, or a warm workdir
+   * serves the Urdu-script transcript to a translate run. Absent (old key
+   * files) means "no translation", the `dictionary` contract.
+   */
+  translate: z.boolean().optional(),
 });
 export type TranscriptKey = z.infer<typeof TranscriptKeySchema>;
 
@@ -280,6 +293,9 @@ export function transcriptCacheReusable(
       // "" and absent both mean whisper's en default — program.ts rejects an
       // empty code, but a key file predating that guard must not wedge.
       (effective.language ?? "") === (requested.language ?? "") &&
+      // Absent and false are the same "no translation", so pre-flag key
+      // files reuse under a non-translate request.
+      (effective.translate ?? false) === (requested.translate ?? false) &&
       // ORDER-SENSITIVE by choice: the dictionary becomes whisper's --prompt
       // text verbatim, so a reordered list genuinely is a different decoder
       // input — treating it as equal would serve a transcript biased by a
@@ -537,6 +553,13 @@ export interface ProduceOptions {
    * decodes garbage (Urdu field test 2026-08-05).
    */
   whisperLanguage?: string;
+  /**
+   * `--whisper-translate`: whisper's TRANSLATE task (`-tr`) — non-English
+   * speech decoded straight to ENGLISH text. Distinct from
+   * `whisperLanguage`, which says what is SPOKEN; the two are passed
+   * together (whisper decodes better knowing the source language).
+   */
+  whisperTranslate?: boolean;
   /**
    * Vocabulary terms for this run (`--dictionary`, F4 2026-08-16), already
    * split/trimmed by the action. Wholesale beats the config's `dictionary`
@@ -584,6 +607,16 @@ export interface ProduceOptions {
    * platform chrome to dodge and a landscape source needs no cropping at all.
    */
   aspect?: "9:16" | "16:9";
+  /**
+   * `--resolution <height>`: how big the output actually renders. `auto`
+   * keeps what the source has (capped at 2160); an explicit height scales the
+   * 1080-wide composition to it. Already validated by commander (or by
+   * `ResolutionChoiceSchema` when it comes from the config), so this is a
+   * choice, never a raw string. `resolveOutputFrame` owns the math and the
+   * why; the value reaches THREE stages that would otherwise each pin 1080p:
+   * the folder-concat target, the mezzanine, and the render's own scale.
+   */
+  resolution?: ResolutionChoice;
   /**
    * `--concurrency <n>`: how many browser tabs the render opens at once,
    * beating the config's `renderConcurrency` and the cpus-2 default
@@ -709,6 +742,32 @@ export function resolveWatermark(
   return flag ?? configValue === true;
 }
 
+/**
+ * The effective `--resolution` — `resolveWatermark`'s precedence verbatim: a
+ * TYPED flag always wins, and only then does the config supply the default.
+ *
+ * The config side is ZOD-PARSED rather than trusted: `loadConfig` hands back
+ * whatever the hand-editable JSON held, and an unparsed `"4k"` would reach
+ * `Number("4k")` inside `resolveOutputFrame` as NaN and size the whole render
+ * off it. A malformed value earns one warning naming the key and falls back
+ * to 1080 — the value every existing run already produces, so a typo costs a
+ * message rather than a surprise 4K render (CLAUDE.md: parse, never coerce).
+ * Pure, so the flag × config matrix is testable without a config file.
+ */
+export function resolveResolution(
+  flag: ResolutionChoice | undefined,
+  configValue: unknown,
+): ResolutionChoice {
+  if (flag !== undefined) return flag;
+  if (configValue === undefined) return "1080";
+  const parsed = ResolutionChoiceSchema.safeParse(configValue);
+  if (parsed.success) return parsed.data;
+  console.log(
+    `⚠ config resolution ignored — expected one of ${RESOLUTION_CHOICES.join(", ")}, using 1080`,
+  );
+  return "1080";
+}
+
 /**
  * The effective `--cover-in-video` switch — resolveWatermark's semantics
  * verbatim: a TYPED flag always wins (so `--no-cover-in-video` beats a
@@ -2078,6 +2137,46 @@ export async function produce(inputArg: string, opts: ProduceOptions): Promise<P
 
   const tools = { ffmpegPath: cfg.ffmpegPath, ffprobePath: cfg.ffprobePath };
 
+  // `--resolution` (2026-08-27), resolved before ANY stage that sizes pixels:
+  // the folder concat, the mezzanine and the render each used to pin 1080p
+  // independently, so a 4K take lost three quarters of its pixels before
+  // anything looked at it. `auto` needs the SOURCE's size, which for a folder
+  // means probing the clips here — the concat target is chosen before the
+  // concatenated file (and its probe) exists.
+  const resolution = resolveResolution(opts.resolution, cfg.resolution);
+  const autoSource = async (): Promise<{ width: number; height: number } | null> => {
+    if (resolution !== "auto") return null;
+    if (isFolder && folderListing) {
+      // Metadata-only probes, and only under `auto`: the default path adds no
+      // ffprobe calls at all (the 4m32s probe-storm lesson, concat.ts:272).
+      const sizes: Array<{ width: number; height: number }> = [];
+      for (const entry of folderListing.entries) {
+        try {
+          const p = await probe(tools, join(input, entry.name));
+          sizes.push({ width: p.width, height: p.height });
+        } catch {
+          // A clip that will not probe is the concat guard's problem, not
+          // this sizing pass's — skip it rather than fail the run here.
+        }
+      }
+      return smallestSource(sizes);
+    }
+    try {
+      const p = await probe(tools, input);
+      return { width: p.width, height: p.height };
+    } catch {
+      return null;
+    }
+  };
+  const output = resolveOutputFrame({
+    frame,
+    source: (await autoSource()) ?? { width: 0, height: 0 },
+    resolution,
+  });
+  if (output.scale !== 1) {
+    console.log(`▸ resolution: ${output.width}x${output.height} (${resolution})`);
+  }
+
   // Resolved ONCE for the whole run — whisper biasing, repair vouching and
   // caption casing must all see the same list, or the passes disagree about
   // what a term is spelled like. A typed --dictionary wholesale beats the
@@ -2182,9 +2281,12 @@ export async function produce(inputArg: string, opts: ProduceOptions): Promise<P
   if (isFolder && folderListing) {
     const sort = opts.sort ?? "name";
     const result = await phases.time("ffmpeg", () =>
+      // The concat target carries the RESOLVED size, not the base frame:
+      // letterboxing every take into 1080p here would throw the pixels away
+      // before the mezzanine or the render ever saw them (`--resolution`).
       concatFolder(tools, input, folderListing!, work, sort, {
-        w: frame.width,
-        h: frame.height,
+        w: output.width,
+        h: output.height,
       }),
     );
     console.log(
@@ -2304,6 +2406,9 @@ export async function produce(inputArg: string, opts: ProduceOptions): Promise<P
   const requestedKey: TranscriptKey = {
     model: requestedModel,
     ...(whisperLang.language !== undefined ? { language: whisperLang.language } : {}),
+    // Omitted when off, so a non-translate run's key stays byte-identical to
+    // every pre-flag key file (the dictionary posture).
+    ...(opts.whisperTranslate === true ? { translate: true } : {}),
     // Omitted when empty, not written as [] — pre-dictionary key files have
     // no `dictionary` at all, and transcriptCacheReusable reads absent and
     // empty as the same "no biasing", so old workdirs must not re-transcribe.
@@ -2374,6 +2479,9 @@ export async function produce(inputArg: string, opts: ProduceOptions): Promise<P
           language: requestedKey.language,
           // Vocabulary biasing (F4) — undefined for an empty dictionary, so
           // the spawned args stay byte-identical to every pre-dictionary run.
+          // From the KEY, like the language: whatever re-keys the cache is
+          // what actually ran, so the two can never disagree.
+          ...(requestedKey.translate === true ? { translate: true } : {}),
           prompt: whisperPromptFor(dictionary),
         },
         audioPath,
@@ -3829,7 +3937,11 @@ export async function produce(inputArg: string, opts: ProduceOptions): Promise<P
     scenes: scenes.length > 0 ? scenes : undefined,
     producer: producerStamp,
     theme,
-    render: { ...frame, fps: 30 },
+    // The EFFECTIVE output size, not the base frame (`--resolution`): this is
+    // what the file on disk actually is, and it is read downstream by the
+    // mezzanine's scale decision, the NLE exports and the editor — all of
+    // which would otherwise describe a 1080p file that isn't there.
+    render: { width: output.width, height: output.height, fps: 30 },
   };
   await writeFile(join(work, "production.json"), JSON.stringify(production, null, 2));
 
@@ -4383,7 +4495,15 @@ export async function produce(inputArg: string, opts: ProduceOptions): Promise<P
     // ~/.ossclip/config.json's theme the first time anyone touched a color.
     baseTheme: configBaseTheme,
     baseCaptionLines,
-    settings: production.render,
+    // The COMPOSITION's size, which is the BASE frame — never
+    // `production.render` (2026-08-27). `production.render` describes the
+    // FILE, and under `--resolution` those differ by the render's `scale`:
+    // Remotion enlarges this composition by that factor, so sizing the
+    // composition from the scaled dims applies it TWICE (2160×3840 became
+    // 4320×7680 frames, which h264_videotoolbox refuses outright, at stitch
+    // time, after every frame had been paid for). The Player reads these too,
+    // and previewing at the base size is what keeps the editor cheap.
+    settings: { ...frame, fps: production.render.fps },
     outputDurationSec: map.outputDuration,
     // The aspect travels with the measurement because the crop math needs it:
     // `object-fit: cover` spills vertically for a portrait source and
@@ -4890,6 +5010,10 @@ export async function produce(inputArg: string, opts: ProduceOptions): Promise<P
         outPath: rawPath,
         browserExecutable: cfg.browserExecutable,
         concurrency: renderConcurrency.concurrency,
+        // The composition stays 1080-wide and Remotion renders it larger
+        // (`--resolution`) — rebuilding the stage at 2160 would keep
+        // `captionFontSizeFor`'s absolute 64px and draw quarter-size captions.
+        scale: output.scale,
         cancelSignal: renderCancel.cancelSignal,
         onPhase: (phase: RenderPhase) => {
           signalPhase = renderSignalPhaseOf(phase);

package/src/program.ts

@@ -3,14 +3,20 @@ import { existsSync, readFileSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 import { Command, InvalidArgumentError } from "commander";
 import { z } from "zod/v4";
-import { CleanupLevelSchema, COVER_MAX_WORDS, SceneComponentIdSchema } from "@ossclip/core";
+import {
+  CleanupLevelSchema,
+  COVER_MAX_WORDS,
+  RESOLUTION_CHOICES,
+  ResolutionChoiceSchema,
+  SceneComponentIdSchema,
+} from "@ossclip/core";
 import { STUDIO_ENTRY } from "@ossclip/renderer";
 import { loadEnvFiles } from "./env";
 import { ExportFormatSchema, runAnalyze } from "./analyze";
 import { expandHome } from "./paths";
 import { phaseBucketProps } from "./phase-timing";
 import { dictionaryFlag, jumpCutsFlag, produce, reviewFlag } from "./produce";
-import { accountsFlag, atFlag, platformsFlag } from "./publish";
+import { accountsFlag, atFlag, deliveryFlag, platformsFlag, youtubePrivacyFlag } from "./publish";
 // The one interactive import that is STATIC rather than `await import()`: the
 // `resetInputSource()` run boundary in `buildProgram` has to run synchronously
 // while the program is being built, and `buildProgram` cannot await. The graph
@@ -300,6 +306,22 @@ export function buildProgram(): Command {
       "output shape: 9:16 (vertical, default) or 16:9 (landscape, 1920x1080)",
       "9:16",
     )
+    .option(
+      "--resolution <height>",
+      "output height: 1080 (default), 1440, 2160, or auto (keep what the source has, " +
+        "capped at 2160). Config key: \"resolution\"",
+      (v: string) => {
+        // Parse, never coerce (CLAUDE.md): a typo'd `--resolution 2610` must
+        // not silently render 1080p, and `Number()` on "auto" is NaN.
+        const parsed = ResolutionChoiceSchema.safeParse(v.trim());
+        if (!parsed.success) {
+          throw new InvalidArgumentError(
+            `--resolution wants one of ${RESOLUTION_CHOICES.join(", ")}, got "${v}"`,
+          );
+        }
+        return parsed.data;
+      },
+    )
     .option("--produce", "run the LLM producer brain to plan title cards & graphics", false)
     .option(
       "--clip <seconds>",
@@ -357,6 +379,12 @@ export function buildProgram(): Command {
       "--whisper-language <code>",
       "transcription language code for a multilingual model, e.g. ur | de | auto (whisper defaults to en)",
     )
+    .option(
+      "--whisper-translate",
+      "translate the speech to ENGLISH captions instead of transcribing it verbatim " +
+        "(whisper's -tr; pair with --whisper-language for the SOURCE language)",
+      false,
+    )
     // COMMA-SEPARATED in one value, not variadic: a variadic option swallows
     // the optional positional [input] whenever the flag precedes the path,
     // and commander offers no way to give the positional priority.
@@ -644,6 +672,7 @@ export function buildProgram(): Command {
           repair: opts.repair,
           whisperModel: opts.whisperModel,
           whisperLanguage,
+          whisperTranslate: opts.whisperTranslate === true,
           // Split/trim/drop-empties (dictionaryFlag) — undefined stays
           // undefined so the config's dictionary can supply the default.
           dictionary: dictionaryFlag(opts.dictionary),
@@ -687,6 +716,9 @@ export function buildProgram(): Command {
           // Validated by concurrencyFlag at parse time; undefined = "not
           // typed", which is what lets the config supply it.
           concurrency: opts.concurrency,
+          // Same contract: validated by the flag's own parser, and undefined
+          // means "not typed" so the config's `resolution` can supply it.
+          resolution: opts.resolution,
         });
         // Counts, buckets and names only — the duration crosses the wire as a
         // bucket, and nothing here can carry a path (assertSafeProps enforces
@@ -758,6 +790,12 @@ export function buildProgram(): Command {
       "--whisper-language <code>",
       "transcription language code for a multilingual model, e.g. ur | de | auto (whisper defaults to en)",
     )
+    .option(
+      "--whisper-translate",
+      "translate the speech to ENGLISH captions instead of transcribing it verbatim " +
+        "(whisper's -tr; pair with --whisper-language for the SOURCE language)",
+      false,
+    )
     .action(async (input: string, opts) => {
       const cleanup = CleanupLevelSchema.parse(opts.cleanup);
       const result = await produce(input, {
@@ -769,6 +807,7 @@ export function buildProgram(): Command {
         noiseDb: opts.noiseDb,
         whisperModel: opts.whisperModel,
         // Same guard as produce's: empty must error, not become a bare `-l`.
+        whisperTranslate: opts.whisperTranslate === true,
         whisperLanguage:
           opts.whisperLanguage !== undefined
             ? z.string().trim().min(1, "--whisper-language needs a code, e.g. ur").parse(opts.whisperLanguage)
@@ -1035,6 +1074,18 @@ export function buildProgram(): Command {
     .option("--dry-run", "print the targets and the exact payload; send nothing", false)
     .option("-y, --yes", "skip the confirmation prompt", false)
     .option("--force", "publish again even though this workdir already has a publish receipt", false)
+    .option(
+      "--youtube-privacy <level>",
+      "YouTube visibility: private (default), unlisted or public",
+      youtubePrivacyFlag,
+    )
+    .option(
+      "--delivery <mode>",
+      "what to upload — auto: a ≤1080p ~10 Mbps delivery encode, built once and " +
+        "cached in the workdir; master: the untouched render",
+      deliveryFlag,
+      "auto",
+    )
     .action(async (workdir: string | undefined, opts) => {
       const { runPublish } = await import("./publish");
       const target = await resolveWorkdirArgument(workdir ?? ".", "publish");
@@ -1046,6 +1097,10 @@ export function buildProgram(): Command {
         dryRun: opts.dryRun,
         yes: opts.yes,
         force: opts.force,
+        // Validated by youtubePrivacyFlag at parse time; undefined means the
+        // payload's own safe default (private).
+        youtubePrivacy: opts.youtubePrivacy,
+        delivery: opts.delivery,
       });
       telemetry.record("publish_run", {
         scheduled: opts.at !== undefined,