@litfamily/litclaude 1.0.10 → 1.0.13

package/plugins/litclaude/skills/lit-typographic-motion/engine/models/word-timing.json

@@ -0,0 +1,198 @@
+{
+  "schema": "litclaude.motion-word-timing/v1",
+  "note": "Tier 3 (MO-A-20..22): opt-in with --word-timing, never from a bare lit. Models download only through `litclaude-ai motion-runtime install --word-timing`, outside any sandboxed session, after the size and these pins are printed. A licence outside allowedLicenses fails closed. The aligner runtime (the Python environment that runs these models) is not part of this release, so a --word-timing render exits 14 until it ships.",
+  "allowedLicenses": [
+    "apache-2.0",
+    "mit",
+    "bsd-2-clause",
+    "bsd-3-clause"
+  ],
+  "deniedLicensePatterns": [
+    "nc",
+    "non-commercial",
+    "noncommercial"
+  ],
+  "neverVendored": [
+    "MMS_FA weights (CC-BY-NC)",
+    "madmom weights (CC-BY-NC-SA)",
+    "aubio (GPLv3)",
+    "essentia (AGPL)"
+  ],
+  "alignerRuntime": {
+    "status": "not-in-this-release"
+  },
+  "models": [
+    {
+      "id": "openai/whisper-small",
+      "revision": "973afd24965f72e36ca33b3055d56a652f456b4d",
+      "license": "apache-2.0",
+      "role": "transcription and word timestamps (multilingual, includes Korean)",
+      "files": [
+        {
+          "path": "added_tokens.json",
+          "bytes": 34604,
+          "url": "https://huggingface.co/openai/whisper-small/resolve/973afd24965f72e36ca33b3055d56a652f456b4d/added_tokens.json",
+          "gitBlobSha1": "e3d256c988462aa153dcabe2aa38b8e9b436c06f"
+        },
+        {
+          "path": "config.json",
+          "bytes": 1967,
+          "url": "https://huggingface.co/openai/whisper-small/resolve/973afd24965f72e36ca33b3055d56a652f456b4d/config.json",
+          "gitBlobSha1": "113bb3efe3a7396f2ea629eef12637bd8085238d"
+        },
+        {
+          "path": "generation_config.json",
+          "bytes": 3868,
+          "url": "https://huggingface.co/openai/whisper-small/resolve/973afd24965f72e36ca33b3055d56a652f456b4d/generation_config.json",
+          "gitBlobSha1": "d3823179a367fa912e3b911b3d2e71ab2a028290"
+        },
+        {
+          "path": "merges.txt",
+          "bytes": 493869,
+          "url": "https://huggingface.co/openai/whisper-small/resolve/973afd24965f72e36ca33b3055d56a652f456b4d/merges.txt",
+          "gitBlobSha1": "6038932a2a1f09a66991b1c2adae0d14066fa29e"
+        },
+        {
+          "path": "model.safetensors",
+          "bytes": 966995080,
+          "url": "https://huggingface.co/openai/whisper-small/resolve/973afd24965f72e36ca33b3055d56a652f456b4d/model.safetensors",
+          "sha256": "1d7734884874f1a1513ed9aa760a4f8e97aaa02fd6d93a3a85d27b2ae9ca596b"
+        },
+        {
+          "path": "normalizer.json",
+          "bytes": 52666,
+          "url": "https://huggingface.co/openai/whisper-small/resolve/973afd24965f72e36ca33b3055d56a652f456b4d/normalizer.json",
+          "gitBlobSha1": "dd6ae819ad738ac1a546e9f9282ef325c33b9ea0"
+        },
+        {
+          "path": "preprocessor_config.json",
+          "bytes": 184990,
+          "url": "https://huggingface.co/openai/whisper-small/resolve/973afd24965f72e36ca33b3055d56a652f456b4d/preprocessor_config.json",
+          "gitBlobSha1": "c2048dfa9fd94a052e62e908d2c4dfb18534b4d2"
+        },
+        {
+          "path": "special_tokens_map.json",
+          "bytes": 2194,
+          "url": "https://huggingface.co/openai/whisper-small/resolve/973afd24965f72e36ca33b3055d56a652f456b4d/special_tokens_map.json",
+          "gitBlobSha1": "bf69932dca4b3719b59fdd8f6cc1978109509f6c"
+        },
+        {
+          "path": "tokenizer.json",
+          "bytes": 2480466,
+          "url": "https://huggingface.co/openai/whisper-small/resolve/973afd24965f72e36ca33b3055d56a652f456b4d/tokenizer.json",
+          "gitBlobSha1": "1e95340ff836fad1b5932e800fb7b8c5e6d78a74"
+        },
+        {
+          "path": "tokenizer_config.json",
+          "bytes": 282683,
+          "url": "https://huggingface.co/openai/whisper-small/resolve/973afd24965f72e36ca33b3055d56a652f456b4d/tokenizer_config.json",
+          "gitBlobSha1": "d13b786c04765fb1a06492b53587752cd67665ea"
+        },
+        {
+          "path": "vocab.json",
+          "bytes": 835550,
+          "url": "https://huggingface.co/openai/whisper-small/resolve/973afd24965f72e36ca33b3055d56a652f456b4d/vocab.json",
+          "gitBlobSha1": "d7016e21da8776c8a9d577d0f559600f09a240eb"
+        }
+      ],
+      "bytes": 971367937
+    },
+    {
+      "id": "kresnik/wav2vec2-large-xlsr-korean",
+      "revision": "629c9a3501c10ba128bf3fa1eebb12af3be03f61",
+      "license": "apache-2.0",
+      "role": "Korean forced alignment (CTC)",
+      "files": [
+        {
+          "path": "config.json",
+          "bytes": 2313,
+          "url": "https://huggingface.co/kresnik/wav2vec2-large-xlsr-korean/resolve/629c9a3501c10ba128bf3fa1eebb12af3be03f61/config.json",
+          "gitBlobSha1": "e3f64a39d0d0c11e6bf6e98fa20a30392e7af823"
+        },
+        {
+          "path": "model.safetensors",
+          "bytes": 1266747952,
+          "url": "https://huggingface.co/kresnik/wav2vec2-large-xlsr-korean/resolve/629c9a3501c10ba128bf3fa1eebb12af3be03f61/model.safetensors",
+          "sha256": "29be111b9247cfc2c72f125c1b1f50021ecfded8f0d947bbfb7e31dc7f0ddd07"
+        },
+        {
+          "path": "preprocessor_config.json",
+          "bytes": 214,
+          "url": "https://huggingface.co/kresnik/wav2vec2-large-xlsr-korean/resolve/629c9a3501c10ba128bf3fa1eebb12af3be03f61/preprocessor_config.json",
+          "gitBlobSha1": "73caa151574001d3d495fae897e1d38968249712"
+        },
+        {
+          "path": "special_tokens_map.config",
+          "bytes": 85,
+          "url": "https://huggingface.co/kresnik/wav2vec2-large-xlsr-korean/resolve/629c9a3501c10ba128bf3fa1eebb12af3be03f61/special_tokens_map.config",
+          "gitBlobSha1": "9abf71998c3e0de2f13c0fd73ed81477c9dae118"
+        },
+        {
+          "path": "tokenizer_config.json",
+          "bytes": 161,
+          "url": "https://huggingface.co/kresnik/wav2vec2-large-xlsr-korean/resolve/629c9a3501c10ba128bf3fa1eebb12af3be03f61/tokenizer_config.json",
+          "gitBlobSha1": "ec5c17ae213d6892cdfe6b97422f86b517efa3a6"
+        },
+        {
+          "path": "vocab.json",
+          "bytes": 18163,
+          "url": "https://huggingface.co/kresnik/wav2vec2-large-xlsr-korean/resolve/629c9a3501c10ba128bf3fa1eebb12af3be03f61/vocab.json",
+          "gitBlobSha1": "f4d2a33e4cfff1c92bca9bbc4f0c5a4df1b459c8"
+        }
+      ],
+      "bytes": 1266768888
+    },
+    {
+      "id": "facebook/wav2vec2-base-960h",
+      "revision": "22aad52d435eb6dbaf354bdad9b0da84ce7d6156",
+      "license": "apache-2.0",
+      "role": "English forced alignment (CTC)",
+      "files": [
+        {
+          "path": "config.json",
+          "bytes": 1596,
+          "url": "https://huggingface.co/facebook/wav2vec2-base-960h/resolve/22aad52d435eb6dbaf354bdad9b0da84ce7d6156/config.json",
+          "gitBlobSha1": "8ca9cc7496e145e37d09cec17d0c3bf9b8523c8e"
+        },
+        {
+          "path": "feature_extractor_config.json",
+          "bytes": 158,
+          "url": "https://huggingface.co/facebook/wav2vec2-base-960h/resolve/22aad52d435eb6dbaf354bdad9b0da84ce7d6156/feature_extractor_config.json",
+          "gitBlobSha1": "52fdd74dc06f40033506e402269fbde5e7adc21d"
+        },
+        {
+          "path": "model.safetensors",
+          "bytes": 377607901,
+          "url": "https://huggingface.co/facebook/wav2vec2-base-960h/resolve/22aad52d435eb6dbaf354bdad9b0da84ce7d6156/model.safetensors",
+          "sha256": "8aa76ab2243c81747a1f832954586bc566090c83a0ac167df6f31f0fa917d74a"
+        },
+        {
+          "path": "preprocessor_config.json",
+          "bytes": 159,
+          "url": "https://huggingface.co/facebook/wav2vec2-base-960h/resolve/22aad52d435eb6dbaf354bdad9b0da84ce7d6156/preprocessor_config.json",
+          "gitBlobSha1": "3f24dc078fcba55ee1d417a413847ead40c093a3"
+        },
+        {
+          "path": "special_tokens_map.json",
+          "bytes": 85,
+          "url": "https://huggingface.co/facebook/wav2vec2-base-960h/resolve/22aad52d435eb6dbaf354bdad9b0da84ce7d6156/special_tokens_map.json",
+          "gitBlobSha1": "25bc39604f72700b3b8e10bd69bb2f227157edd1"
+        },
+        {
+          "path": "tokenizer_config.json",
+          "bytes": 163,
+          "url": "https://huggingface.co/facebook/wav2vec2-base-960h/resolve/22aad52d435eb6dbaf354bdad9b0da84ce7d6156/tokenizer_config.json",
+          "gitBlobSha1": "978a15a96dbb2d23e2afbc70137cae6c5ce38c8d"
+        },
+        {
+          "path": "vocab.json",
+          "bytes": 291,
+          "url": "https://huggingface.co/facebook/wav2vec2-base-960h/resolve/22aad52d435eb6dbaf354bdad9b0da84ce7d6156/vocab.json",
+          "gitBlobSha1": "88181b954aa14df68be9b444b3c36585f3078c0a"
+        }
+      ],
+      "bytes": 377610353
+    }
+  ],
+  "totalBytes": 2615747178
+}

package/plugins/litclaude/skills/lit-typographic-motion/engine/node/analysis.mjs

@@ -0,0 +1,108 @@
+// Per-frame analysis of the exact bytes that leave the renderer. The page writes the glyph-coverage
+// mask into the alpha channel; this reads it (ink pixel count, optional 8-bit mask), then forces
+// alpha to 255 so the bytes hashed (rgbaSha256, MO-C-09), audited (MO-C-03) and encoded are one
+// and the same buffer. It also computes the 99.5th-percentile luminance for the empty-frame rule
+// (MO-D-03) and the flash-audit cell grid.
+import { createHash } from "node:crypto";
+import { GATE } from "../core/constants.mjs";
+import { LINEAR_LUT, gridFor } from "../core/flash.mjs";
+
+const HIST = 2048;
+
+/** Analyse and normalise one RGBA frame in place. Returns ink count, mask (optional), cells, p99.5 L. */
+export function analyzeFrame(bytes, width, height, { keepMask = false } = {}) {
+  const { gw: GW, gh: GH } = gridFor(width, height);
+  const cells = GW * GH;
+  const R = new Float32Array(cells);
+  const G = new Float32Array(cells);
+  const B = new Float32Array(cells);
+  const count = new Float32Array(cells);
+  const hist = new Uint32Array(HIST);
+  const mask = keepMask ? Buffer.alloc(width * height) : null;
+  let inkPx = 0;
+  for (let y = 0; y < height; y++) {
+    const cy = Math.min(GH - 1, Math.floor((y * GH) / height)) * GW;
+    for (let x = 0; x < width; x++) {
+      const o = (y * width + x) * 4;
+      const a = bytes[o + 3];
+      if (a >= 128) inkPx += 1;
+      if (mask) mask[y * width + x] = a;
+      bytes[o + 3] = 255;
+      const r = LINEAR_LUT[bytes[o]];
+      const g = LINEAR_LUT[bytes[o + 1]];
+      const b = LINEAR_LUT[bytes[o + 2]];
+      const c = cy + Math.min(GW - 1, Math.floor((x * GW) / width));
+      R[c] += r;
+      G[c] += g;
+      B[c] += b;
+      count[c] += 1;
+      const l = 0.2126 * r + 0.7152 * g + 0.0722 * b;
+      hist[Math.min(HIST - 1, Math.floor(l * HIST))] += 1;
+    }
+  }
+  for (let i = 0; i < cells; i++) {
+    const n = count[i] || 1;
+    R[i] /= n;
+    G[i] /= n;
+    B[i] /= n;
+  }
+  const target = GATE.nearBlackPercentile * width * height;
+  let seen = 0;
+  let p995 = 1;
+  for (let i = 0; i < HIST; i++) {
+    seen += hist[i];
+    if (seen >= target) {
+      p995 = (i + 1) / HIST;
+      break;
+    }
+  }
+  const rgbaSha256 = createHash("sha256").update(bytes).digest("hex");
+  return { inkPx, mask, cells: { R, G, B }, luminanceP995: +p995.toFixed(5), rgbaSha256 };
+}
+
+/** Area-average downscale of RGBA8 (display-referred, like ffmpeg's area filter). */
+export function areaDownscale(src, sw, sh, dw, dh) {
+  const tmp = new Float32Array(dw * sh * 4);
+  const sx = sw / dw;
+  for (let y = 0; y < sh; y++) {
+    for (let x = 0; x < dw; x++) {
+      const x0 = x * sx;
+      const x1 = x0 + sx;
+      const acc = [0, 0, 0, 0];
+      for (let xi = Math.floor(x0); xi < Math.ceil(x1); xi++) {
+        const w = Math.min(x1, xi + 1) - Math.max(x0, xi);
+        const o = (y * sw + xi) * 4;
+        acc[0] += src[o] * w; acc[1] += src[o + 1] * w; acc[2] += src[o + 2] * w; acc[3] += src[o + 3] * w;
+      }
+      const t = (y * dw + x) * 4;
+      tmp[t] = acc[0] / sx; tmp[t + 1] = acc[1] / sx; tmp[t + 2] = acc[2] / sx; tmp[t + 3] = acc[3] / sx;
+    }
+  }
+  const out = Buffer.alloc(dw * dh * 4);
+  const sy = sh / dh;
+  for (let y = 0; y < dh; y++) {
+    const y0 = y * sy;
+    const y1 = y0 + sy;
+    for (let x = 0; x < dw; x++) {
+      const acc = [0, 0, 0, 0];
+      for (let yi = Math.floor(y0); yi < Math.ceil(y1); yi++) {
+        const w = Math.min(y1, yi + 1) - Math.max(y0, yi);
+        const o = (yi * dw + x) * 4;
+        acc[0] += tmp[o] * w; acc[1] += tmp[o + 1] * w; acc[2] += tmp[o + 2] * w; acc[3] += tmp[o + 3] * w;
+      }
+      const t = (y * dw + x) * 4;
+      out[t] = Math.round(acc[0] / sy); out[t + 1] = Math.round(acc[1] / sy); out[t + 2] = Math.round(acc[2] / sy); out[t + 3] = 255;
+    }
+  }
+  return out;
+}
+
+/** Nearest-neighbour resample of an 8-bit mask. */
+export function resizeMask(mask, sw, sh, dw, dh) {
+  const out = Buffer.alloc(dw * dh);
+  for (let y = 0; y < dh; y++) {
+    const yy = Math.min(sh - 1, Math.floor(((y + 0.5) * sh) / dh));
+    for (let x = 0; x < dw; x++) out[y * dw + x] = mask[yy * sw + Math.min(sw - 1, Math.floor(((x + 0.5) * sw) / dw))];
+  }
+  return out;
+}

package/plugins/litclaude/skills/lit-typographic-motion/engine/node/brief.mjs

@@ -0,0 +1,158 @@
+// Brief -> render plan. A brief is a small JSON the skill writes from the user's request
+// (schema litclaude.motion-brief/v1). It either lists shots explicitly or gives plain `lines`, which
+// are composed into a default film: a title slam, the middle lines as reveals, and an end card.
+// Every display string goes through smart() (MO-A-34); the timeline comes from core/timeline.mjs.
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { PRESETS, pickPreset, resolvePalette } from "../core/presets.mjs";
+import { buildTimeline } from "../core/timeline.mjs";
+import { smart, plain, eojeol } from "../core/text.mjs";
+import { TIMELINE } from "../core/constants.mjs";
+import { TreatmentError } from "./treatment.mjs";
+
+export const BRIEF_SCHEMA = "litclaude.motion-brief/v1";
+const SCENE_IDS = ["title-slam", "karaoke-line", "kinetic-list", "number-counter", "signature", "end-card"];
+
+export class BriefError extends Error {}
+
+const str = (v) => (typeof v === "string" ? v : v == null ? "" : String(v));
+
+// A running shot index ("01 / 05") is on screen only when the treatment asks for one (RC8b).
+const SHOT_INDEX = /^\s*\d{1,3}\s*[/／|·]\s*\d{1,3}\s*$/u;
+
+function composeFromLines(lines, title) {
+  const clean = lines.map((l) => str(l).trim()).filter(Boolean);
+  if (clean.length === 0) throw new BriefError("brief has no text: give `lines` or `shots`");
+  const shots = [];
+  const first = title ? { text: title } : { text: clean.shift() };
+  shots.push({ scene: "title-slam", ...first });
+  // The last line is the end card; a single line (with no title) closes on itself.
+  const last = clean.length > 0 ? clean.pop() : null;
+  for (const line of clean) {
+    if (eojeol(line).length >= 2) shots.push({ scene: "karaoke-line", text: line });
+    else shots.push({ scene: "title-slam", text: line });
+  }
+  shots.push({ scene: "end-card", text: last ?? first.text });
+  return shots;
+}
+
+function normalizeShot(raw, i) {
+  const scene = str(raw.scene);
+  if (!SCENE_IDS.includes(scene)) throw new BriefError(`shot ${i}: unknown scene "${scene}" (use ${SCENE_IDS.join(", ")})`);
+  const shot = { scene };
+  if (raw.text !== undefined) shot.text = smart(str(raw.text).trim());
+  if (raw.sub !== undefined) shot.sub = plain(str(raw.sub).trim());
+  if (raw.heading !== undefined) shot.heading = smart(str(raw.heading).trim());
+  if (Array.isArray(raw.items)) shot.items = raw.items.map((x) => smart(str(x).trim())).filter(Boolean);
+  if (raw.label !== undefined) shot.label = smart(str(raw.label).trim());
+  if (raw.hold !== undefined) shot.hold = Number(raw.hold);
+  if (raw.font !== undefined) shot.font = str(raw.font);
+  if (raw.post && typeof raw.post === "object") shot.post = raw.post;
+  if (scene === "number-counter") {
+    shot.from = Number(raw.from ?? 0);
+    shot.to = Number(raw.to ?? 0);
+    shot.prefix = str(raw.prefix ?? "");
+    shot.suffix = str(raw.suffix ?? "");
+    shot.display = `${shot.prefix}${Math.round(shot.to).toLocaleString("en-US")}${shot.suffix}`;
+  }
+  const needsText = ["title-slam", "karaoke-line", "signature", "end-card"].includes(scene);
+  if (needsText && !shot.text) throw new BriefError(`shot ${i} (${scene}) needs "text"`);
+  if (scene === "kinetic-list" && !(shot.items?.length)) throw new BriefError(`shot ${i} (kinetic-list) needs "items"`);
+  if (scene === "signature" && /[가-힣ᄀ-ᇿ㄰-㆏]/u.test(shot.text)) {
+    throw new BriefError(`shot ${i} (signature): the single-stroke fonts are Latin-only; use title-slam for Hangul`);
+  }
+  return shot;
+}
+
+export function loadBrief(file) {
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync(file, "utf8"));
+  } catch (error) {
+    throw new BriefError(`cannot read brief ${file}: ${error.message}`);
+  }
+  return { ...raw, _dir: path.dirname(path.resolve(file)) };
+}
+
+/** All text the brief shows, for the preset auto-pick and the glyph-coverage pre-flight. */
+export function briefText(shots, extra = []) {
+  return [...extra, ...shots.flatMap((s) => [s.text, s.sub, s.heading, s.label, s.display, ...(s.items ?? [])])].filter(Boolean).join("\n");
+}
+
+/**
+ * Normalize a brief into { presetId, reason, palette, shots, timeline, ... }. `beatGrid` (Tier 2) is
+ * passed in by the caller after audio analysis.
+ */
+export function planFromBrief(brief, { fps = TIMELINE.defaultFps, beatGrid = null, targetSec = null, treatment = null } = {}) {
+  if (brief.schema && brief.schema !== BRIEF_SCHEMA) throw new BriefError(`brief schema must be ${BRIEF_SCHEMA}`);
+  const rawShots = Array.isArray(brief.shots) && brief.shots.length ? brief.shots : composeFromLines(brief.lines ?? [], brief.title);
+  const shots = rawShots.map(normalizeShot);
+  const text = briefText(shots, [str(brief.title), str(brief.request)]);
+  const { presetId, reason } = pickPreset({ style: brief.style, text, request: treatment?.request ?? brief.request ?? "" });
+  const preset = PRESETS[presetId];
+  // The terminal look is a typed-input voice: it keeps typewriter punctuation (MO-A-34 plain()).
+  if (presetId === "terminalcore") {
+    for (const shot of shots) {
+      for (const field of ["text", "heading", "label"]) if (shot[field]) shot[field] = plain(shot[field]);
+      if (shot.items) shot.items = shot.items.map(plain);
+    }
+  }
+  for (const [i, shot] of shots.entries()) {
+    const placeholder = briefText([shot]).split("\n").find((v) => /<[^<>\n]{1,80}>/u.test(v));
+    if (placeholder) throw new TreatmentError("brief", `shot ${i} still shows a placeholder "${placeholder}"; write the film's own copy`);
+  }
+  if (!treatment?.typePlan?.index) {
+    for (const [i, shot] of shots.entries()) {
+      const hit = [shot.text, shot.sub, shot.heading, shot.label, ...(shot.items ?? [])].find((v) => v && SHOT_INDEX.test(v));
+      if (hit) throw new TreatmentError("typePlan.index", `shot ${i} shows a running index "${hit}"; set typePlan.index: true only when the film should show one`);
+    }
+  }
+  const bpm = Number(brief.bpm) > 0 ? Number(brief.bpm) : TIMELINE.defaultBpm;
+  const warnings = [];
+  const { timeline, shots: placed, durationSec } = fitToTarget({ shots, fps, bpm, beatGrid, targetSec, warnings });
+  const palette = resolvePalette(preset, { signalHue: brief.signalHue });
+  return {
+    presetId, reason, preset, palette, bpm, beatGrid, fps, seed: Number.isInteger(brief.seed) ? brief.seed >>> 0 : TIMELINE.defaultSeed,
+    signalHue: brief.signalHue ?? null, timeline, shots: placed, durationSec, frameCount: Math.round(durationSec * fps),
+    // Only the film's own name, set on purpose as `label`, is ever drawn as a window label (RC8b).
+    label: str(brief.label).slice(0, 40), text, warnings,
+    passParams: brief.passParams ?? {}, post: brief.post ?? {},
+  };
+}
+
+/**
+ * Honour the treatment's length (section 3 of the director brief): holds scale up until the film
+ * reaches the target, never below any reading floor. When the floors alone make the film longer
+ * than the target, keep the floors and say so.
+ */
+function fitToTarget({ shots, fps, bpm, beatGrid, targetSec, warnings }) {
+  const natural = buildTimeline({ shots, fps, bpm, beatGrid });
+  if (!(targetSec > 0)) return natural;
+  if (natural.durationSec > targetSec * 1.1) {
+    warnings.push(`the reading floors make the film ${natural.durationSec.toFixed(1)} s, longer than the treatment's ${targetSec} s`);
+    return natural;
+  }
+  if (natural.durationSec >= targetSec - 1 / fps) return natural;
+  const at = (scale) => buildTimeline({
+    shots: shots.map((s, i) => ({ ...s, hold: Math.max(s.hold ?? 0, (natural.shots[i].end - natural.shots[i].start) * scale) })),
+    fps, bpm, beatGrid,
+  });
+  // The length is monotone in the scale; bisect for the smallest scale that reaches the target, so a
+  // beat snap overshoots by at most one beat.
+  let lo = 1;
+  let hi = targetSec / natural.durationSec;
+  let best = at(hi);
+  while (best.durationSec < targetSec - 1 / fps) {
+    hi *= 1.1;
+    best = at(hi);
+  }
+  for (let k = 0; k < 24; k++) {
+    const mid = (lo + hi) / 2;
+    const built = at(mid);
+    if (built.durationSec >= targetSec - 1 / fps) {
+      hi = mid;
+      best = built;
+    } else lo = mid;
+  }
+  return best;
+}