ossclip 0.1.25 → 0.1.26

package/src/produce.ts

@@ -1,7 +1,15 @@
 import { createHash } from "node:crypto";
 import { createReadStream } from "node:fs";
 import { copyFile, mkdir, readFile, writeFile, rm } from "node:fs/promises";
-import { copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, statSync } from "node:fs";
+import {
+  copyFileSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  rmSync,
+  statSync,
+} from "node:fs";
 import { cpus } from "node:os";
 import { basename, dirname, isAbsolute, join, resolve } from "node:path";
 import { z } from "zod/v4";
@@ -29,6 +37,8 @@ import {
   concatFolder,
   folderManifestKey,
   listFolderVideos,
+  outInsideInputFolderMessage,
+  outPathInsideInput,
   coverDecision,
   coverHeadline,
   cropFilter,
@@ -79,6 +89,7 @@ import {
   thumbnailDecision,
   thumbnailImageCacheName,
   applyUserCuts,
+  pruneHidesInsideCuts,
   loadConfig,
   loudnorm,
   MAX_NORMALIZE_UPSCALE,
@@ -132,6 +143,7 @@ import {
   type Layout,
   type LlmProvider,
   type Production,
+  ossclipOutputPathFor,
   type ProviderName,
   type Scene,
   type SceneComponentId,
@@ -161,7 +173,8 @@ import { RenderTimelineHUD, StageAnimator, printProductionCompleteBanner } from
 import { reconcileCaptionEdits } from "./caption-report";
 import { overridesWriteLine, writeOverrideDoc } from "./overrides-write";
 import { recordedProduceArgs } from "./replay-argv";
-import { renderCover, renderProduction } from "@ossclip/renderer";
+import { makeCancelSignal, renderCover, renderProduction } from "@ossclip/renderer";
+import type { RenderPhase } from "@ossclip/renderer";
 import {
   DEFAULT_FACE,
   coverTextRect,
@@ -321,6 +334,13 @@ export interface ProduceOptions {
    * platform chrome to dodge and a landscape source needs no cropping at all.
    */
   aspect?: "9:16" | "16:9";
+  /**
+   * `--concurrency <n>`: how many browser tabs the render opens at once,
+   * beating the config's `renderConcurrency` and the cpus-2 default
+   * (`resolveRenderConcurrency`). Already validated by commander
+   * (`concurrencyFlag`), so a number here is always a positive integer.
+   */
+  concurrency?: number;
   /**
    * `--clip <seconds>` (R19 §93): produce only the strongest ~N-second window
    * of a long take, chosen by the producer in the same editorial call as the
@@ -449,21 +469,37 @@ export function resolveYoutube(
 
 /**
  * How many browser tabs the render runs in parallel (2026-08-17 render-speed
- * pass). Default is cpus-2 with a floor of 2: the render is decode-bound —
- * every tab waits on OffthreadVideo's ffmpeg extract workers — so saturating
- * all cores with tabs starves the very processes the tabs block on. The
- * config's `renderConcurrency` overrides for machines where that guess is
- * wrong; validated here at the consumer (the `dictionary` posture: the value
- * comes from hand-editable JSON loadConfig doesn't zod-parse), a positive
- * integer or one warning and the default — never a coerced tab count. Pure
- * so the config × cpu matrix is testable without a config file or real
+ * pass). Precedence: `--concurrency` beats the config's `renderConcurrency`
+ * beats the cpus-2 default (floor 2). The default is cpus-2 because the
+ * render is decode-bound — every tab waits on OffthreadVideo's ffmpeg extract
+ * workers — so saturating all cores with tabs starves the very processes the
+ * tabs block on.
+ *
+ * The flag exists because cpus-2 is a CPU guess with no memory term in it
+ * (2026-08-19 field case): a 14-core / 36GB Mac resolved to 12 tabs on a
+ * 1080×1920 source and Chrome died WHOLE, twelve in-flight frames at a time.
+ * `offthreadVideoCacheSizeInBytes` bounds the cache side of that
+ * (render-options.ts); this is the hatch for the tab side, typed per run
+ * rather than edited into a config file mid-investigation.
+ *
+ * The flag arrives already validated by commander (`concurrencyFlag` in
+ * program.ts rejects a non-positive/non-integer at the front door, §93a), so
+ * only the config value is checked here — the `dictionary` posture, since it
+ * comes from hand-editable JSON loadConfig doesn't zod-parse: a positive
+ * integer, or one warning and the default, never a coerced tab count. Pure so
+ * the flag × config × cpu matrix is testable without a config file or real
  * cpus().
  */
 export function resolveRenderConcurrency(
+  flagValue: number | undefined,
   configValue: unknown,
   cpuCount: number,
 ): { concurrency: number; warning?: string } {
   const fallback = Math.max(2, cpuCount - 2);
+  // Typed-beats-config, and typed also beats a MALFORMED config: the user
+  // asking for 4 tabs on the command line gets 4, not a warning about a
+  // config key they did not touch this run.
+  if (flagValue !== undefined) return { concurrency: flagValue };
   if (configValue === undefined) return { concurrency: fallback };
   if (typeof configValue === "number" && Number.isInteger(configValue) && configValue > 0) {
     return { concurrency: configValue };
@@ -474,6 +510,119 @@ export function resolveRenderConcurrency(
   };
 }
 
+/** What a signal that interrupted the render phase costs the caller. */
+export interface RenderCancellation {
+  /** Partial render output to delete before exiting. */
+  removePaths: string[];
+  /** Shell convention: 128 + the signal's number (SIGINT 2, SIGTERM 15). */
+  exitCode: number;
+  message: string;
+}
+
+/**
+ * The decision half of Ctrl-C-cancels-the-render (2026-08-19 field report:
+ * "Cancelling rerendering doesn't work" — nothing in the CLI handled SIGINT,
+ * and no cancelSignal reached Remotion, so the browser and its ffmpeg
+ * children kept going after the process was told to stop). The signal wiring
+ * itself is I/O and lives at the render call site; what to delete and what to
+ * exit with is decided here so it can be tested without a real render.
+ *
+ * `rawPath` is the workdir's `render-raw.mp4`, which a finished run
+ * loudnorms and only THEN moves to the user's --out — so a cancel never has
+ * an output file to mistake for a finished render. The raw partial is deleted
+ * anyway: it is a truncated mp4 sitting in the workdir under the name the
+ * next run reads, and a stale one there is the kind of thing that gets picked
+ * up by hand and mailed to someone.
+ *
+ * Non-zero exit, because a cancelled render did not produce the video the
+ * caller asked for — but 130/143 rather than 1, so a script can tell a
+ * deliberate stop from a failure (the same distinction the editor's
+ * /api/render/cancel draws, R16 §60).
+ */
+export function renderCancellation(
+  signal: "SIGINT" | "SIGTERM",
+  rawPath: string,
+): RenderCancellation {
+  return {
+    removePaths: [rawPath],
+    exitCode: signal === "SIGINT" ? 130 : 143,
+    message: "▸ cancelled — partial output discarded",
+  };
+}
+
+/**
+ * Where the run is when a signal lands, collapsed to the three cases that
+ * behave differently. `RenderPhase`'s "bundling" and "selecting" both collapse
+ * to "pre-render": neither takes a cancelSignal, so neither can be stopped
+ * cooperatively. "post-render" is the window between `renderMedia` resolving
+ * and the handlers coming off in the `finally`.
+ */
+export type RenderSignalPhase = "pre-render" | "rendering" | "post-render";
+
+/** Map the renderer's phase report onto what a signal can do about it. */
+export function renderSignalPhaseOf(phase: RenderPhase): RenderSignalPhase {
+  return phase === "rendering" ? "rendering" : "pre-render";
+}
+
+/** What the SIGINT/SIGTERM handler should do about the signal it just got. */
+export interface RenderSignalAction {
+  /** Fire the Remotion cancel signal. Free, and only `renderMedia` listens. */
+  cancel: boolean;
+  /**
+   * Tear down and `process.exit` from INSIDE the handler, because nothing
+   * downstream is going to stop on its own.
+   */
+  exitNow: boolean;
+  /** Printed above the cancellation message when the exit needs explaining. */
+  note?: string;
+}
+
+/**
+ * The decision half of "Ctrl-C must never be a no-op" (2026-08-19 review of
+ * the cancel feature). Registering a SIGINT listener SUPPRESSES node's default
+ * terminate, so the cancel feature as first written made Ctrl-C *worse* than
+ * before it existed in every phase the cancelSignal does not reach:
+ *
+ *  - "pre-render" — `bundle()` and `selectComposition()` take no cancelSignal
+ *    in @remotion/renderer 4.0.499 (verified against the installed types; see
+ *    RenderPhase in @ossclip/renderer). A cold bundle is tens of seconds, and
+ *    minutes when Chrome is downloaded on first run, and for all of it Ctrl-C
+ *    did NOTHING while the terminal looked hung. The handler must exit itself.
+ *    That can orphan the Chrome `selectComposition` opened — but a bare Ctrl-C
+ *    before the cancel feature did exactly the same, so it is not a
+ *    regression, and a terminal that ignores Ctrl-C is worse than a stray
+ *    browser process.
+ *  - "rendering" — the one phase that IS cooperative: fire the signal and let
+ *    Remotion tear the browser and its ffmpeg children down.
+ *  - "post-render" — HONORED, not ignored: the caller stops before mastering
+ *    and discards the raw render (see the tail check at the render call site).
+ *
+ * SECOND SIGNAL ALWAYS EXITS, in every phase. If Remotion's teardown wedges,
+ * the user's only remaining move must not be `kill -9` from another terminal.
+ */
+export function renderSignalAction(
+  phase: RenderSignalPhase,
+  signalCount: number,
+): RenderSignalAction {
+  if (signalCount >= 2) {
+    return {
+      cancel: true,
+      exitNow: true,
+      note: "▸ second signal — exiting without waiting for the render to shut down",
+    };
+  }
+  if (phase === "pre-render") {
+    return {
+      cancel: true,
+      exitNow: true,
+      note:
+        "▸ cancelled while preparing the render — that phase cannot be interrupted " +
+        "cleanly, so stopping the process",
+    };
+  }
+  return { cancel: true, exitNow: false };
+}
+
 // Moved to paths.ts (2026-08-17, editor thumbnail panel): the edit server
 // derives `<out>.thumbnail.png` from command.json's recorded out and must not
 // import this module — produce.ts imports edit.ts (recordRecentProject), so
@@ -1209,7 +1358,34 @@ function deriveWorkdir(
  * file input's equivalent default already lands.
  */
 export function defaultOutPath(originalInput: string): string {
-  return originalInput.replace(/(\.[^.]+)?$/, ".ossclip.mp4");
+  // Delegates to core so the refusal message's suggestion and the actual
+  // default can never drift apart (and both strip the tab-completed trailing
+  // slash — the 2026-08-18 hidden-dotfile-inside-the-folder field case).
+  return ossclipOutputPathFor(originalInput);
+}
+
+/**
+ * The ⚠ line a REPLAYED produce prints when it keys to a different workdir
+ * than the one the editor launched it for (2026-08-18 field cascade, part
+ * 3): the edit server sets OSSCLIP_REPLAY_WORKDIR to the workdir whose
+ * command.json it is replaying; if the run then derives another workdir —
+ * the folder's content changed since the record — the edits saved in the
+ * old workdir's overrides.json silently stop applying, and nothing else in
+ * the run says so. Pure (drift decision in, line out) so the comparison is
+ * testable without spawning a replay; null when this isn't a replay or
+ * nothing drifted.
+ */
+export function replayWorkdirWarning(
+  replayedWorkdir: string | undefined,
+  derivedWorkdir: string,
+): string | null {
+  if (replayedWorkdir === undefined || replayedWorkdir === "") return null;
+  if (resolve(replayedWorkdir) === resolve(derivedWorkdir)) return null;
+  return (
+    `⚠ this run's workdir differs from the one the editor replayed — edits ` +
+    `saved in ${join(replayedWorkdir, "overrides.json")} will NOT apply to ` +
+    `this render (the input's content changed since that command was recorded)`
+  );
 }
 
 /**
@@ -1415,6 +1591,9 @@ export async function produce(inputArg: string, opts: ProduceOptions): Promise<P
     : resolve(baseCwd, expandHome(inputArg));
   let input = originalInput;
   if (!existsSync(input)) throw new Error(`input not found: ${input}`);
+  // Decided once, here — the out-path gate below and the folder pipeline
+  // further down must read the same answer to "is this a folder run".
+  const isFolder = statSync(input).isDirectory();
 
   // §93b: the window is an editorial judgement, and there is deliberately no
   // heuristic fallback — an automatically-guessed 60 seconds reads as a bug,
@@ -1449,6 +1628,17 @@ export async function produce(inputArg: string, opts: ProduceOptions): Promise<P
       ? outArg
       : resolve(baseCwd, outArg)
     : resolve(defaultOutPath(originalInput));
+  // 2026-08-18 field cascade: an --out pointed INSIDE the input folder became
+  // a 7th source clip on the next run — new content hash, fresh workdir,
+  // EMPTY overrides — so the render silently dropped the user's saved edits
+  // and the output duration doubled, three runs in a row. Refused BEFORE
+  // ensureParentDir so the gate can't first mkdir a stray subfolder inside
+  // the very input it is about to refuse. (Unreachable via the default out —
+  // defaultOutPath lands BESIDE the folder — so only a typed --out can trip
+  // it.)
+  if (isFolder && outPathInsideInput(outPath, originalInput)) {
+    throw new Error(outInsideInputFolderMessage(originalInput));
+  }
   ensureParentDir(outPath);
 
   await preflight(cfg.ffmpegPath, "Run `ossclip setup`, install ffmpeg yourself (brew/apt/winget), or set OSSCLIP_FFMPEG.");
@@ -1489,7 +1679,7 @@ export async function produce(inputArg: string, opts: ProduceOptions): Promise<P
   // video with captions transcribed against a different edit. Hashing the
   // manifest content gives a folder input the same invariant a file input
   // already has via `sha1File`: content changes ⇒ a fresh workdir.
-  const isFolder = statSync(input).isDirectory();
+  // (`isFolder` itself is decided up top, beside the out-path gate.)
   // Final-review fix wave, cheap minor c: --sort only means anything for a
   // folder input; on a file it did nothing, silently. Gated on `sortExplicit`
   // (whether the user TYPED it) rather than on `opts.sort` itself, since
@@ -1518,6 +1708,10 @@ export async function produce(inputArg: string, opts: ProduceOptions): Promise<P
   );
   await mkdir(work, { recursive: true });
   console.log(`▸ workdir ${work}`);
+  // See replayWorkdirWarning — set only by the edit server's /api/render
+  // spawn, so a terminal run never sees it.
+  const replayWarning = replayWorkdirWarning(process.env.OSSCLIP_REPLAY_WORKDIR, work);
+  if (replayWarning !== null) console.log(replayWarning);
 
   // §131 residue: a folder re-key (clips renamed/added/removed → new content
   // hash) correctly lands in a fresh workdir, but any editor edits saved in
@@ -1566,6 +1760,17 @@ export async function produce(inputArg: string, opts: ProduceOptions): Promise<P
         `  ${result.nonVideoCount} non-video file${result.nonVideoCount === 1 ? "" : "s"} ignored`,
       );
     }
+    // Loud, not folded into the non-video count (2026-08-18 field cascade):
+    // an ossclip output sitting in the clips folder means an earlier run
+    // wrote it there, and the user should learn that before it surprises
+    // them elsewhere. The filter itself is pure (isOssclipOutputName) and
+    // runs inside listFolderVideos, before the workdir hash is derived.
+    if (result.ossclipOutputCount > 0) {
+      console.log(
+        `▸ folder: skipped ${result.ossclipOutputCount} ossclip output ` +
+          `file${result.ossclipOutputCount === 1 ? "" : "s"}`,
+      );
+    }
     // Order visible immediately (folder-input-brief.md) — a wrong order is a
     // silent bug otherwise, invisible until someone watches the whole thing.
     result.clips.forEach((c, i) => {
@@ -1893,17 +2098,37 @@ export async function produce(inputArg: string, opts: ProduceOptions): Promise<P
       .slice(0, 8);
     const repairCache = join(work, `repairs-${rawKey}.json`);
     if (existsSync(repairCache)) {
-      repairs = JSON.parse(await readFile(repairCache, "utf8")) as AppliedRepair[];
-      transcript = applyRepairs(
+      const cached = JSON.parse(await readFile(repairCache, "utf8")) as AppliedRepair[];
+      // Re-DECIDE from the cached PROPOSALS; never replay the stored verdicts
+      // (field case 2026-08-18). What this cache exists to avoid is the LLM
+      // CALL — the gates are code, and code gets fixed. Filtering to
+      // `r.applied` here meant a gate fix could never reach a workdir that had
+      // already cached a refusal: the Urdu run whose 11 correct repairs stayed
+      // refused after the Latin-only `norm` was fixed, because produce replayed
+      // the old verdicts instead of recomputing them. The vouched set rides
+      // along for the same reason it always did — a dictionary-vouched
+      // correction must clear the phonetic gate on replay too.
+      const decided = applyRepairs(
         rawTranscript,
-        repairs.filter((r) => r.applied),
-        // The vouched set must survive the cache: a dictionary-vouched
-        // correction re-runs applyRepairs' guards here, and without the
-        // dictionary the phonetic gate would refuse on replay what it
-        // accepted on the first run.
+        cached.map(({ startWord, endWord, heard, correction }) => ({
+          startWord,
+          endWord,
+          heard,
+          correction,
+        })),
         { dictionary },
-      ).transcript;
-      console.log(`▸ repairs cached (${repairs.filter((r) => r.applied).length})`);
+      );
+      repairs = decided.applied;
+      transcript = decided.transcript;
+      const now = repairs.filter((r) => r.applied).length;
+      const before = cached.filter((r) => r.applied).length;
+      // Re-decided verdicts are the truth from here on: persist them so the
+      // report, the next run and this run cannot disagree about what applied.
+      if (now !== before) await writeFile(repairCache, JSON.stringify(repairs, null, 2));
+      console.log(
+        `▸ repairs cached (${now} applied of ${cached.length} proposed` +
+          `${now === before ? "" : `, re-decided from ${before}`})`,
+      );
     } else {
       const repairAnim = isInteractive()
         ? new StageAnimator(
@@ -2431,6 +2656,23 @@ export async function produce(inputArg: string, opts: ProduceOptions): Promise<P
   // beside `render-props.json`'s own write (see the comment there for why).
   for (const r of cutResult.reports) console.log(`  ⚠ ${r}`);
 
+  // Retire hides whose words this run's FINAL cutlist removes (§59b
+  // revisited): the "captions + video" delete writes a hide (instant
+  // preview) plus a cut (this run), and once the cut lands the cut
+  // supersedes the hide — see `pruneHidesInsideCuts`. Pruned HERE, before
+  // `reconcileCaptionEdits` applies the hide layer, so the retired keys
+  // never surface as "the cut removed it" drop lines on this or any later
+  // run. The doc write itself goes through the one sanctioned overrides.json
+  // write further down, gated alongside `cutResult.changed`.
+  const hidePrune = pruneHidesInsideCuts(overrideDoc, cutlist);
+  overrideDoc = hidePrune.doc;
+  const hidesPruned = hidePrune.pruned.length > 0;
+  if (hidesPruned) {
+    console.log(
+      `▸ captions: ${hidePrune.pruned.length} hidden-word override(s) retired — their words are cut`,
+    );
+  }
+
   const { cues: assembled, dropped } = assembleScenes(scenes, transcript, map);
   for (const d of dropped) console.log(`  ⚠ scene ${d.id} dropped: ${d.reason}`);
 
@@ -3537,7 +3779,13 @@ export async function produce(inputArg: string, opts: ProduceOptions): Promise<P
   // recovered from (`legacySplitId`). Repairing the captions would destroy the
   // evidence for the split. `writeOverrideDoc` carries the full argument for
   // why a caption-only write has nothing worth backing up.
-  if (cutResult.changed || captionKeysReanchored) {
+  // `hidesPruned` joins the gate for the same reason `captionKeysReanchored`
+  // did: a hide retired by its own cut (`pruneHidesInsideCuts`) changes the
+  // doc without changing the cut entries, and skipping the write would
+  // re-report "the cut removed it" on every later run. It does NOT spend the
+  // `.bak` — retiring a redundant key is not the cut re-anchoring the backup
+  // exists to survive.
+  if (cutResult.changed || captionKeysReanchored || hidesPruned) {
     await writeOverrideDoc(overridesPath, overrideDoc, { refreshBackup: cutResult.changed });
     console.log(overridesWriteLine(cutResult.changed));
   }
@@ -3664,6 +3912,18 @@ export async function produce(inputArg: string, opts: ProduceOptions): Promise<P
     }
   }
 
+  // --concurrency, else config renderConcurrency, else cpus-2 with a floor of
+  // 2 (resolveRenderConcurrency has the precedence and the why: leave cores
+  // for the ffmpeg decode workers every tab waits on). Resolved BEFORE the log
+  // line below so the count can go INTO it — the 2026-08-19 whole-browser OOM
+  // took a machine spec and arithmetic to diagnose, because no line of the
+  // render's own output ever said how many tabs it opened.
+  const renderConcurrency = resolveRenderConcurrency(
+    opts.concurrency,
+    cfg.renderConcurrency,
+    cpus().length,
+  );
+  if (renderConcurrency.warning) console.log(renderConcurrency.warning);
   let renderHud: RenderTimelineHUD | null = null;
   if (interactive) {
     renderHud = new RenderTimelineHUD({
@@ -3673,33 +3933,109 @@ export async function produce(inputArg: string, opts: ProduceOptions): Promise<P
       aspect: landscape ? "16:9" : "9:16",
     }).start();
   } else {
-    console.log("▸ rendering…");
+    console.log(`▸ rendering… (${renderConcurrency.concurrency} parallel tabs)`);
   }
   let lastPct = -10;
-  // cpus-2 with a floor of 2 (resolveRenderConcurrency has the why: leave
-  // cores for the ffmpeg decode workers every tab waits on). Resolved here,
-  // next to the call it feeds, so the warning prints once per run.
-  const renderConcurrency = resolveRenderConcurrency(cfg.renderConcurrency, cpus().length);
-  if (renderConcurrency.warning) console.log(renderConcurrency.warning);
-  await phases.time("render", () =>
-    renderProduction(props, {
-      publicDir: dirname(renderVideo),
-      outPath: rawPath,
-      browserExecutable: cfg.browserExecutable,
-      concurrency: renderConcurrency.concurrency,
-      onProgress: (p) => {
-        if (renderHud) {
-          renderHud.setProgress(p);
-        } else {
-          const pct = Math.floor(p * 100);
-          if (pct >= lastPct + 10) {
-            lastPct = pct;
-            process.stdout.write(`  ${pct}%\n`);
+  // Ctrl-C must actually stop the render (2026-08-19 field report). Remotion
+  // owns a browser and ffmpeg children that outlive a bare process death, so
+  // stopping means handing renderMedia a cancelSignal and firing it — node's
+  // default SIGINT handling would leave those orphaned.
+  //
+  // Registered around the RENDER PHASE ONLY, and removed in the finally: a
+  // handler that outlived this phase would swallow Ctrl-C during the LLM and
+  // whisper phases, which exit promptly today and must keep doing so.
+  //
+  // SIGTERM is wired for the same reason as SIGINT, plus one of its own: the
+  // editor's /api/render/cancel (edit.ts) kills this process as a child, and
+  // before this handler that kill left the browser behind. That path is
+  // otherwise untouched — it already reports its own cancel. It also inherits
+  // the dead-window fix below: the editor's Cancel button now kills the child
+  // DURING bundling too, where the SIGTERM used to be swallowed and
+  // /api/render kept answering 409 until the bundle finished on its own.
+  const renderCancel = makeCancelSignal();
+  // An array, not a `let`: the handler assigns from inside a closure, and TS's
+  // flow analysis would still read a `let` as null in the catch below (it
+  // narrowed the branch to `never`). First signal wins — hammering Ctrl-C must
+  // not rewrite the verdict while the teardown is already running.
+  const cancellations: RenderCancellation[] = [];
+  // Where renderProduction is, so the handler knows whether the cancel signal
+  // has anyone listening (renderSignalAction has the whole reasoning).
+  // "pre-render" from the start: the handlers go on before the call.
+  let signalPhase: RenderSignalPhase = "pre-render";
+  let signalCount = 0;
+  // Shared by all three places a cancel is finalised — the handler, the
+  // rejected-render catch, and the post-render tail check.
+  const finishCancel = (c: RenderCancellation, note?: string): never => {
+    if (renderHud) renderHud.stop();
+    if (note) console.log(note);
+    // rmSync, not fs/promises rm: the handler path calls this and exits on the
+    // next statement, and an awaited unlink would never get its turn.
+    for (const path of c.removePaths) rmSync(path, { force: true });
+    console.log(c.message);
+    // Exits here rather than throwing: program.ts's catch would record this as
+    // produce_failed and print "✗ <message>", dressing a deliberate stop as a
+    // bug (R16 §60's distinction).
+    process.exit(c.exitCode);
+  };
+  const onCancelSignal = (signal: "SIGINT" | "SIGTERM") => {
+    signalCount += 1;
+    if (cancellations.length === 0) cancellations.push(renderCancellation(signal, rawPath));
+    const action = renderSignalAction(signalPhase, signalCount);
+    if (action.cancel) renderCancel.cancel();
+    if (action.exitNow) finishCancel(cancellations[0]!, action.note);
+  };
+  const onSigint = () => onCancelSignal("SIGINT");
+  const onSigterm = () => onCancelSignal("SIGTERM");
+  process.on("SIGINT", onSigint);
+  process.on("SIGTERM", onSigterm);
+  try {
+    await phases.time("render", () =>
+      renderProduction(props, {
+        publicDir: dirname(renderVideo),
+        outPath: rawPath,
+        browserExecutable: cfg.browserExecutable,
+        concurrency: renderConcurrency.concurrency,
+        cancelSignal: renderCancel.cancelSignal,
+        onPhase: (phase: RenderPhase) => {
+          signalPhase = renderSignalPhaseOf(phase);
+        },
+        onProgress: (p) => {
+          if (renderHud) {
+            renderHud.setProgress(p);
+          } else {
+            const pct = Math.floor(p * 100);
+            if (pct >= lastPct + 10) {
+              lastPct = pct;
+              process.stdout.write(`  ${pct}%\n`);
+            }
           }
-        }
-      },
-    }),
-  );
+        },
+      }),
+    );
+    // renderMedia resolved, so nothing is left to cancel cooperatively. Not a
+    // phase the handler can exit from either — see the tail check below.
+    signalPhase = "post-render";
+  } catch (err) {
+    // A cancelled renderMedia rejects like any other failure; only the
+    // handler above can tell the two apart.
+    const cancellation = cancellations[0];
+    if (!cancellation) throw err;
+    finishCancel(cancellation);
+  } finally {
+    process.off("SIGINT", onSigint);
+    process.off("SIGTERM", onSigterm);
+  }
+  // The TAIL CASE (2026-08-19 review): a signal landing after renderMedia
+  // resolved but before the `finally` above took the handlers off used to be
+  // swallowed outright — nothing threw, the run went on to loudnorm and
+  // mastering, and the user got a complete video having pressed Ctrl-C. We
+  // HONOR it: the user asked to stop, and stopping here costs only the
+  // mastering pass, whereas ignoring it hands them the file they just said
+  // they did not want. Nothing has been written to --out yet (moveFile is
+  // below), so honoring here is still "no output", the same promise every
+  // other cancel makes.
+  const tailCancellation = cancellations[0];
+  if (tailCancellation) finishCancel(tailCancellation);
   if (renderHud) renderHud.stop();
 
   const masterAnim = interactive

package/src/program.ts

@@ -39,6 +39,27 @@ import {
 // order in `defaultProviderName`, which decides which model runs.
 const envFiles = loadEnvFiles();
 
+/**
+ * `--concurrency <n>` → a positive whole number of browser tabs (§93a: reject
+ * rather than coerce, the `--clip` idiom). A typo'd `--concurrency 4x` must
+ * not become NaN and reach Remotion as "however many you like" — the flag
+ * exists precisely because the automatic count killed a browser (2026-08-19
+ * field case; `resolveRenderConcurrency` has it). `Number`, not `parseInt`,
+ * so "4.5" and "" are errors rather than a silent 4 and a silent 0.
+ *
+ * Exported so the rejection matrix is testable without commander's exit
+ * behaviour in the way.
+ */
+export function concurrencyFlag(v: string): number {
+  const n = Number(v);
+  if (!Number.isInteger(n) || n <= 0) {
+    throw new InvalidArgumentError(
+      `--concurrency wants a positive whole number of browser tabs, got "${v}"`,
+    );
+  }
+  return n;
+}
+
 /**
  * Every command this CLI has, built onto a fresh instance.
  *
@@ -418,6 +439,20 @@ export function buildProgram(): Command {
     )
     .option("--editor-port <n>", "port for the editor started by --open-editor",
       (v) => Number.parseInt(v, 10), 5174)
+    // No default: undefined = "not typed" is what lets the config's
+    // renderConcurrency (and then the cpus-2 guess) supply the value —
+    // resolveRenderConcurrency owns the precedence. Recorded runs need nothing
+    // special to replay it: command.json stores the argv verbatim
+    // (recordedProduceArgs), so a typed --concurrency is already in there, and
+    // the editor's Render replays it through THIS parse.
+    .option(
+      "--concurrency <n>",
+      "how many browser tabs render frames in parallel (default: CPU cores - 2, " +
+        "floor 2). Turn it DOWN if the render logs 'The browser crashed while " +
+        "rendering frame N' — that is the whole browser running out of memory, " +
+        "not one frame failing",
+      concurrencyFlag,
+    )
     .action(async (input: string | undefined, opts, command: Command) => {
       if (input === undefined) {
         // commander 12's parseAsync does not reset option state between calls,
@@ -553,6 +588,9 @@ export function buildProgram(): Command {
           coverPath: typeof opts.cover === "string" ? opts.cover : undefined,
           clip: opts.clip,
           clipWindow: opts.clipWindow,
+          // Validated by concurrencyFlag at parse time; undefined = "not
+          // typed", which is what lets the config supply it.
+          concurrency: opts.concurrency,
         });
         // Counts, buckets and names only — the duration crosses the wire as a
         // bucket, and nothing here can carry a path (assertSafeProps enforces