@ossclip/core 0.1.23 → 0.1.25

package/assets/fonts/OFL.txt

@@ -0,0 +1,93 @@
+Copyright 2022 The Noto Project Authors (https://github.com/notofonts/nastaliq)
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+https://scripts.sil.org/OFL
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded, 
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.

package/assets/fonts/README.md

@@ -0,0 +1,15 @@
+# Bundled fonts
+
+## NotoNastaliqUrdu-Bold.ttf
+
+Noto Nastaliq Urdu Bold, from the notofonts/nastaliq **v3.007** GitHub
+release (`googlefonts/ttf/NotoNastaliqUrdu-Bold.ttf`), © 2022 The Noto
+Project Authors — licensed under the SIL Open Font License 1.1 (`OFL.txt`
+beside this file). The OFL permits bundling and redistribution with the
+license text included, which is why the license ships in this directory.
+
+Why it is bundled at all: caption rendering must be deterministic across
+machines, and a Linux CI box (or a fresh Windows install) has no Nastaliq
+face — Urdu captions there fell back to whatever Arabic-script font the OS
+had, or to tofu. Only the Bold face ships because captions render at
+`fontWeight: 900` and one face keeps the package small (~616 KB).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ossclip/core",
-  "version": "0.1.23",
+  "version": "0.1.25",
   "description": "ossclip's framework-free pipeline: schema, transcription, analysis, cutlist, captions, framing, and the LLM producer",
   "type": "module",
   "license": "MIT",
@@ -20,6 +20,7 @@
   ],
   "dependencies": {
     "@anthropic-ai/sdk": "^0.115.0",
+    "@google/genai": "^2.17.1",
     "zod": "^3.25.0"
   },
   "homepage": "https://github.com/AhsanAyaz/ossclip#readme",

package/src/blooper.ts

@@ -1,7 +1,7 @@
 import { normalizeToken } from "./analyze";
 import { isSentenceStart } from "./clip";
 import { levenshtein } from "./phonetics";
-import type { Transcript } from "./schema";
+import type { Span, Transcript } from "./schema";
 
 /**
  * Blooper removal by SPOKEN MARKER (R27 §122).
@@ -55,8 +55,40 @@ export interface BloopSpan {
    * silently cutting a good take (Task 3, editor-dogfood-fixes plan).
    */
   matched: string[];
+  /**
+   * True when the sentence-start backscan hit MAX_WALKBACK_SEC before it
+   * found punctuation — the span was cut short of a real sentence boundary
+   * and the report must say so out loud (`formatBloopSpan`).
+   */
+  truncated?: boolean;
 }
 
+/**
+ * How far past the marker word's STAMPED end a silence may start and still be
+ * treated as the marker's own trailing dead air. Whisper's `-ml 1` stamps
+ * stretch over pauses (§18, PHASE1-FINDINGS.md), so the stamped end of a
+ * spoken marker routinely lands BEFORE its acoustic end — the 2026-08-16
+ * incident: "blooper." stamped to end at 670.0 while the audio ran to ~670.4
+ * (proven by the bracketing silences 668.09–669.3 and 670.4–671.68), so 0.4s
+ * of audible "blooper" leaked into the output at ~10:02. Extending the cut
+ * through any silence starting within this window swallows the acoustic tail
+ * — and the debris sliver ("And", 670.0–670.4) whisper stamped between the
+ * marker and the pause. 0.75s is deliberately wider than the observed 0.4s
+ * stretch but well under the shortest gap a speaker leaves before a real
+ * next take.
+ */
+const MAX_MARKER_BLEED_SEC = 0.75;
+
+/**
+ * Ceiling on the sentence-start backscan, in source seconds. An ASR stretch
+ * with no terminal punctuation (rambling delivery, a non-English fine-tune,
+ * a hallucinated run-on) lets the scan walk back through MINUTES of good
+ * take from one spoken marker — the same failure shape as §133's 7.08s fuzzy
+ * cut, unbounded. 30s is longer than any real single-sentence flub and short
+ * enough that a capped cut is reviewable in the report.
+ */
+const MAX_WALKBACK_SEC = 30;
+
 // Fuzzy matching only turns on once the marker is long enough that a false
 // positive is unlikely — a short marker like "cut" sound-alikes ("cat") and
 // sits within edit distance 2 of half the dictionary ("but", "gut", "cot"),
@@ -120,9 +152,18 @@ function isPluralPair(a: string, b: string): boolean {
  * marker of at least `FUZZY_MIN_MARKER_LEN` characters also matches an ASR
  * mishearing — see `matchMarker`.
  *
+ * `silences` (source seconds, `analysis.silences`' shape) lets a span's end
+ * extend through the marker's own trailing dead air — the §18 stamp-stretch
+ * bleed `MAX_MARKER_BLEED_SEC` documents. Omitting it reproduces the
+ * stamped-end behavior exactly.
+ *
  * Returns spans in transcript order, non-overlapping.
  */
-export function findBloopSpans(transcript: Transcript, marker: string): BloopSpan[] {
+export function findBloopSpans(
+  transcript: Transcript,
+  marker: string,
+  silences?: readonly Span[],
+): BloopSpan[] {
   const want = normalizeToken(marker);
   if (!want) return [];
   const words = transcript.words;
@@ -138,31 +179,67 @@ export function findBloopSpans(transcript: Transcript, marker: string): BloopSpa
 
     // Walk back over the attempt this marker spoiled, to the start of its
     // sentence. The marker's own text usually ENDS a sentence ("blooper."), so
-    // the scan starts at the word before it.
+    // the scan starts at the word before it. Capped at MAX_WALKBACK_SEC of
+    // source time (rationale on the constant); a capped span is flagged so
+    // the report can shout about it.
     let start = i;
-    while (start > 0 && !isSentenceStart(transcript, start)) start--;
+    let truncated = false;
+    while (start > 0 && !isSentenceStart(transcript, start)) {
+      if (words[i]!.end - words[start - 1]!.start > MAX_WALKBACK_SEC) {
+        truncated = true;
+        break;
+      }
+      start--;
+    }
+
+    // Extend the end through the marker's trailing dead air (2026-08-16
+    // incident, see MAX_MARKER_BLEED_SEC): repeatedly absorb any silence that
+    // starts within the bleed window and ends past the current end. The loop
+    // re-scans because absorbing one silence can bring the next within reach
+    // — the chained-silence shape.
+    let endSec = words[i]!.end;
+    if (silences && silences.length > 0) {
+      let extended = true;
+      while (extended) {
+        extended = false;
+        for (const s of silences) {
+          if (s.start <= endSec + MAX_MARKER_BLEED_SEC && s.end > endSec) {
+            endSec = s.end;
+            extended = true;
+          }
+        }
+      }
+    }
 
     // Consecutive attempts: if everything between the previous span's end and
     // this attempt's start is already being dropped, merge rather than leave a
-    // one-word island of a sentence nobody finished.
+    // one-word island of a sentence nobody finished. The seconds arm exists
+    // because the previous span's EXTENDED end can reach past word stamps the
+    // index arm never sees — the incident's "And" debris sat between two
+    // attempts that were not word-index adjacent once the first end grew.
     const prev = spans[spans.length - 1];
     let markers = 1;
     let matched = match.exact ? [] : [match.surface];
-    if (prev && start <= prev.endWord + 1) {
+    if (prev && (start <= prev.endWord + 1 || words[start]!.start <= prev.endSec)) {
       spans.pop();
       start = prev.startWord;
       markers = prev.markers + 1;
       matched = [...prev.matched, ...matched];
+      truncated = truncated || prev.truncated === true;
+      // A merged span must never shrink: the previous extension already
+      // proved that audio dead.
+      endSec = Math.max(endSec, prev.endSec);
     }
 
     spans.push({
       startWord: start,
       endWord: i,
       startSec: words[start]!.start,
-      endSec: words[i]!.end,
+      endSec,
       markers,
       marker: want,
       matched,
+      ...(truncated ? { truncated: true } : {}),
     });
   }
   return spans;
@@ -187,5 +264,11 @@ export function formatBloopSpan(transcript: Transcript, span: BloopSpan): string
     span.matched.length > 0
       ? " " + span.matched.map((m) => `matched "${m}" ~ "${span.marker}"`).join(", ")
       : "";
-  return `"${said}"${attempts}${fuzzy}`;
+  // A capped walk-back is a cut whose start the code chose by fiat, not by
+  // punctuation — the one case where the span boundary is a guess, so the
+  // report line must be loud about it.
+  const capped = span.truncated
+    ? " (walk-back capped at 30s — unpunctuated stretch; check this cut)"
+    : "";
+  return `"${said}"${attempts}${fuzzy}${capped}`;
 }

package/src/browser.ts

@@ -18,6 +18,7 @@ export {
   cropFilter,
   type ContentRect,
   type ContentRectSegment,
+  type FramingSegment,
 } from "./content-rect";
 // lineDirection is a VALUE export but stays browser-safe: captions.ts
 // imports types only. CaptionTrack needs it at render time (Urdu field test
@@ -27,9 +28,16 @@ export {
 // a caption key from it (§137), and the editor imports this surface. Pure, and
 // captions.ts stays browser-safe — it imports types plus timemap, which is
 // itself type-only against ./schema.
+// The Nastaliq trio rides the same browser-safe surface: CaptionTrack needs
+// the family name + served path for its @font-face, and `captionsNeedNastaliq`
+// is the ONE predicate produce and the render share for "does this caption
+// set need the bundled font" (2026-08-17 — two conditions would drift).
 export {
   backfillSrcStart,
+  captionsNeedNastaliq,
   lineDirection,
+  NASTALIQ_FONT_NAME,
+  NASTALIQ_FONT_REL,
   type CaptionLine,
   type CaptionWord,
 } from "./captions";

package/src/captions.ts

@@ -92,6 +92,31 @@ export function lineDirection(text: string): "rtl" | "ltr" {
   return "ltr";
 }
 
+/**
+ * The bundled Nastaliq face (Urdu captions, 2026-08-17): rendering must not
+ * depend on the render machine having an Arabic-script font — a Linux CI box
+ * has none, and macOS/Windows each substitute a DIFFERENT one, so the same
+ * render-props drew three different caption sets. The family name is what
+ * the render-side @font-face registers; the REL path is the served URL under
+ * the render's public dir, POSIX-literal like `sideImageDestRel` (produce.ts:
+ * `staticFile()` splits only on `/`, so `path.join` would break every
+ * Windows render of it).
+ */
+export const NASTALIQ_FONT_NAME = "Noto Nastaliq Urdu";
+export const NASTALIQ_FONT_REL = "fonts/NotoNastaliqUrdu-Bold.ttf";
+
+/**
+ * Whether this caption set needs the bundled Nastaliq face at all — some
+ * line lays out RTL. ONE predicate shared by produce (copies the font into
+ * the public dir) and CaptionTrack (injects the @font-face): if the two
+ * sides tested different conditions, one could fetch a file the other never
+ * wrote. Pure-Latin runs — the overwhelmingly common case — copy nothing and
+ * fetch nothing, so their renders stay byte-identical.
+ */
+export function captionsNeedNastaliq(lines: readonly CaptionLine[]): boolean {
+  return lines.some((l) => lineDirection(l.words.map((w) => w.text).join(" ")) === "rtl");
+}
+
 export interface CaptionOptions {
   maxWordsPerLine?: number;
   maxLineDuration?: number;
@@ -109,6 +134,18 @@ export interface CaptionOptions {
   breakpoints?: number[];
 }
 
+/**
+ * No spoken word takes this long; a stamped interval longer than it is the
+ * §18 contiguous-stamp stretch (`parseWhisperJson` clamps
+ * `next.start = w.end`, so non-speech audio is smeared into the next word's
+ * START — field case 2026-08-17: 21s of played-back video audio put "Okay,"
+ * on screen 21 seconds early). The END stamp is the trustworthy edge — clamp
+ * the start toward it. Display-only: cuts, analysis and the transcript
+ * itself never see this, and `srcStart` keeps the RAW source stamp so the
+ * §137 edit anchor does not move.
+ */
+export const MAX_CAPTION_WORD_LEAD_SEC = 2;
+
 export function buildCaptionLines(
   transcript: Transcript,
   map: TimeMap,
@@ -124,8 +161,14 @@ export function buildCaptionLines(
   for (const w of transcript.words) {
     const m = map.mapWord(w as Word);
     // `w.start` is source time, `m.start` output — both are needed, and only
-    // the source one is stable across a re-cut (§137).
-    if (m) mapped.push({ text: w.text, start: m.start, end: m.end, srcStart: w.start });
+    // the source one is stable across a re-cut (§137). The display start is
+    // clamped toward the end stamp (MAX_CAPTION_WORD_LEAD_SEC above); the
+    // clamped gap to the previous word then exceeds `maxGap`, so the packer
+    // naturally breaks the line and nothing renders during the dead span.
+    if (m) {
+      const start = Math.max(m.start, m.end - MAX_CAPTION_WORD_LEAD_SEC);
+      mapped.push({ text: w.text, start, end: m.end, srcStart: w.start });
+    }
   }
 
   const lines: CaptionLine[] = [];

package/src/concat.ts

@@ -424,11 +424,11 @@ export async function concatFolder(
 
   const filter = buildConcatFilter(order.length, target);
   const inputArgs = order.flatMap((name) => ["-i", join(folder, name)]);
-  // Encode to a sibling temp path, rename only on success — same reasoning as
-  // `bakeNormalizedSource` in normalize.ts (R27 §125): ffmpeg writes the
-  // container header as it goes, so a bake that dies mid-graph leaves a file
-  // with no `moov` atom, and a cache keyed on EXISTENCE would reuse that
-  // corpse forever. Rename is atomic on a POSIX filesystem.
+  // Encode to a sibling temp path, rename only on success (R27 §125, learned
+  // on the since-removed normalization bake): ffmpeg writes the container
+  // header as it goes, so an encode that dies mid-graph leaves a file with no
+  // `moov` atom, and a cache keyed on EXISTENCE would reuse that corpse
+  // forever. Rename is atomic on a POSIX filesystem.
   const partial = `${outPath}.partial.mp4`;
   try {
     await run(tools.ffmpegPath, [

package/src/config.ts

@@ -3,6 +3,7 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 
 import type { ModelPrice } from "./producer/usage";
+import type { Theme } from "./scene-schema";
 
 /** Whether a finished `produce` offers to open the editor. */
 export type OpenEditorPref = "ask" | "always" | "never";
@@ -18,6 +19,24 @@ export interface OssclipConfig {
    * sheet always uses the main model. "same" disables tiering (FINDINGS §37).
    */
   fastModel?: string;
+  /**
+   * Download URLs for models the ggerganov mirror doesn't host, keyed by the
+   * bare model name — a user's own fine-tune needs one line:
+   * `"modelSources": {"my-model": "https://…/ggml-my-model.bin"}`. Wins over
+   * the curated table and the default mirror (`modelUrl` in the CLI's setup
+   * manifest). File-only like `dictionary`; validated at the consumer
+   * (`validModelSources`), so a hand-edited non-record is one warning and an
+   * ignored key, never a crash or a coerced URL.
+   */
+  modelSources?: Record<string, string>;
+  /**
+   * Default whisper language code ("ur", "auto", …) — the durable spelling
+   * of `--whisper-language` for someone whose recordings are always in one
+   * language. The flag beats this per run, and this beats the model table's
+   * implied language. File-only like `audience`; validated at the consumer
+   * (`resolveWhisperLanguage` in produce.ts), never coerced.
+   */
+  language?: string;
   /**
    * Who is in the video — "Ahsan, host of the Code with Ahsan channel".
    * Lets the repair pass recognise a mangled proper noun instead of inventing
@@ -38,7 +57,72 @@ export interface OssclipConfig {
    * `--watermark` / `--no-watermark` win over this per run.
    */
   watermark?: boolean;
+  /**
+   * Terms of art the speaker uses — "JSON", "ossclip", "Genkit" — biasing
+   * transcription (whisper `--prompt`), vouching repair corrections, and
+   * canonicalizing caption casing on every run (F4, 2026-08-16: "Jason" for
+   * JSON). `--dictionary` on a run wholesale replaces this, never merges.
+   * File-only like `watermark`; validated at the consumer
+   * (`validDictionary` in produce.ts), so a hand-edited non-array is one
+   * warning and an ignored key, never a crash or a coerced term.
+   */
+  dictionary?: string[];
+  /**
+   * Global base-theme overrides — caption/graphic colors and fonts applied to
+   * every run (F6, 2026-08-16). Partial on purpose: set `accent` alone and
+   * every other token keeps its default. Precedence per run:
+   * overrides.json (the editor's per-project doc) > this > defaultTheme.
+   * File-only; validated at the consumer (`configuredBaseTheme` in
+   * produce.ts) all-or-nothing, so one malformed key voids the whole theme
+   * with a warning instead of silently half-applying.
+   */
+  theme?: Partial<Theme>;
+  /**
+   * Run the `--youtube` pack (SEO metadata + AI thumbnail) on every produce,
+   * so the preference is a one-time config write like `watermark`.
+   * `--youtube` / `--no-youtube` win over this per run (`resolveYoutube`).
+   */
+  youtube?: boolean;
+  /**
+   * Path to the creator's portrait photo, fed to the AI thumbnail as the
+   * likeness reference — a path in the config like `browserExecutable`, set
+   * once rather than typed per run. `--portrait` wins over this. Existence
+   * is checked where the thumbnail is generated, not at load: an absent file
+   * there means a loud skip and the frame-grab cover stands.
+   */
+  portrait?: string;
+  /**
+   * Who watches the channel — "junior web devs learning AI tooling". Feeds
+   * BOTH the `--youtube` pack prompt (titles/tags for the right viewer) and
+   * the AI thumbnail's concept call, so it is set once here rather than
+   * retyped per run. `--audience` wins over this per run. File-only like
+   * `portrait`; validated at the consumer (`typeof === "string"` at use),
+   * never coerced.
+   */
+  audience?: string;
+  /**
+   * The durable thumbnail steer — "always show the terminal, never stock
+   * imagery". Fed to the AI thumbnail's concept call as a must-honor creator
+   * brief on every run. `--thumbnail-brief` wins over this per run.
+   * File-only like `audience`, validated the same way at use.
+   */
+  thumbnailBrief?: string;
+  /**
+   * Image model for the AI thumbnail (Y3). Overrides the built-in default
+   * slug; the GEMINI_API_KEY itself stays in the environment — secrets never
+   * live in config.json (env.ts's documented rule).
+   */
+  thumbnailModel?: string;
   browserExecutable?: string;
+  /**
+   * Browser tabs the render runs in parallel (2026-08-17 render-speed pass).
+   * Unset means cpus-2 with a floor of 2 — the render is decode-bound, and
+   * two cores stay free for OffthreadVideo's ffmpeg extract workers. File-only
+   * like `dictionary`; validated at the consumer (`resolveRenderConcurrency`
+   * in produce.ts) as a positive integer, so a hand-edited `"4"` or `-1` is
+   * one warning and the default, never a coerced tab count.
+   */
+  renderConcurrency?: number;
   /**
    * USD per million tokens, keyed by model id or family substring — overrides
    * the built-in assumptions in `producer/usage.ts` so a run's cost line
@@ -122,6 +206,32 @@ export function loadConfig(): OssclipConfig {
     // resolveWatermark), so a hand-edited non-boolean stays OFF, the safe
     // default for a credit.
     watermark: fileCfg.watermark,
+    // File-only for the same reason as `watermark`: these are structured
+    // values a hand-editable JSON file supplies, and parse-don't-coerce says
+    // the strict checks live at the consumer — `validDictionary` /
+    // `configuredBaseTheme` in produce.ts — where a malformed value earns a
+    // warning naming the problem and the safe default, never a coercion.
+    dictionary: fileCfg.dictionary,
+    theme: fileCfg.theme,
+    // File-only, the same posture: both are validated where they are USED —
+    // `validModelSources` / `resolveWhisperLanguage` — so a hand-edited
+    // non-record or non-string earns one warning there, never a coercion.
+    modelSources: fileCfg.modelSources,
+    language: fileCfg.language,
+    // File-only, the `watermark` posture again: `youtube` gets the strict
+    // `=== true` check at its consumer (produce's resolveYoutube), and
+    // `portrait`/`thumbnailModel` are validated where they are USED — a
+    // malformed value earns a loud skip there, never a coercion here.
+    youtube: fileCfg.youtube,
+    // File-only, the `dictionary` posture: a structured value from hand-edited
+    // JSON, validated where it is USED (`resolveRenderConcurrency`) — a
+    // malformed count earns one warning there and the cpus-2 default, never a
+    // coerced concurrency.
+    renderConcurrency: fileCfg.renderConcurrency,
+    portrait: fileCfg.portrait,
+    audience: fileCfg.audience,
+    thumbnailBrief: fileCfg.thumbnailBrief,
+    thumbnailModel: fileCfg.thumbnailModel,
     pricing: fileCfg.pricing,
   };
 }

package/src/content-rect-detect.ts

@@ -4,6 +4,7 @@ import { join } from "node:path";
 import { run } from "./exec";
 import {
   contentRectTimeline,
+  materializeTimeline,
   parseCropdetect,
   pickTransition,
   type ContentRect,
@@ -70,7 +71,7 @@ export async function detectContentRect(
       timeline?: ContentRectSegment[];
     };
     if (cached.version === CACHE_VERSION && cached.timeline?.length) {
-      return withUniform(cached.timeline);
+      return withUniform(cached.timeline, probe);
     }
   }
 
@@ -95,7 +96,7 @@ export async function detectContentRect(
   if (cachePath) {
     await writeFile(cachePath, JSON.stringify({ version: CACHE_VERSION, timeline }, null, 2));
   }
-  return withUniform(timeline);
+  return withUniform(timeline, probe);
 }
 
 /** How far around a coarse boundary the refinement pass looks. Must exceed the
@@ -152,8 +153,19 @@ async function refineBoundaries(
   }
 }
 
-function withUniform(timeline: ContentRectSegment[]): ContentRectDetection {
-  return { timeline, uniform: timeline.length === 1 ? timeline[0]!.rect : null };
+function withUniform(
+  timeline: ContentRectSegment[],
+  probe: { width: number; height: number; duration: number },
+): ContentRectDetection {
+  // Materialize BEFORE the single-segment uniform test, and on the cache-hit
+  // path too: the cache stores the RAW measurement, so re-judging it here is
+  // what lets the 2026-08-16 incident's cached content-rect.json re-classify
+  // as uniform on replay without a CACHE_VERSION bump (no re-measure).
+  const materialized = materializeTimeline(timeline, probe.width, probe.height, probe.duration);
+  return {
+    timeline: materialized,
+    uniform: materialized.length === 1 ? materialized[0]!.rect : null,
+  };
 }
 
 /** Total source seconds the framing is NOT the full frame — for reporting. */