@spark-apps/quickpeek 1.2.3 → 1.2.5

package/dist/index.mjs

@@ -38,8 +38,19 @@ function parsePartial(partial) {
 function getErrorMessage(err) {
   return err instanceof Error ? err.message : String(err);
 }
+function deStock(text) {
+  let out = text;
+  for (const [re, replacement] of STOCK_PHRASES) out = out.replace(re, replacement);
+  return out.replace(/\s{2,}/g, " ").replace(/\s+([,.!?])/g, "$1").trim();
+}
+function stripLongDashes(text) {
+  return text.replace(/(\d)\s*[\u2013\u2014]\s*(\d)/g, "$1-$2").replace(/\s*[\u2013\u2014]\s*/g, ", ").replace(/,\s*,/g, ",").replace(/\s+([,.!?])/g, "$1").replace(/\s{2,}/g, " ").trim();
+}
 function toTitleCase(text) {
-  return text.replace(/\w+(?:'\w+)*/g, (word, index) => {
+  return deStock(stripLongDashes(text)).replace(/\w+(?:'\w+)*/g, (word, index) => {
+    if (/[A-Z]/.test(word.slice(1))) {
+      return word;
+    }
     if (index === 0) {
       return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
     }
@@ -49,7 +60,17 @@ function toTitleCase(text) {
     return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
   });
 }
-var LANGUAGE_NAMES, LOWERCASE_WORDS;
+async function runPooled(count, size, task) {
+  let cursor = 0;
+  const worker = async () => {
+    while (cursor < count) {
+      const index = cursor++;
+      await task(index);
+    }
+  };
+  await Promise.all(Array.from({ length: Math.max(1, Math.min(size, count)) }, worker));
+}
+var LANGUAGE_NAMES, LOWERCASE_WORDS, STOCK_PHRASES;
 var init_utils = __esm({
   "src/lib/utils.ts"() {
     "use strict";
@@ -99,13 +120,21 @@ var init_utils = __esm({
       "under",
       "than"
     ]);
+    STOCK_PHRASES = [
+      [/\bfree to start\b/gi, "free to try"],
+      [/\bget started today\b/gi, "start now"],
+      [/\bsay goodbye to\b/gi, "no more"],
+      [/\bsupercharge\b/gi, "speed up"],
+      [/\beffortlessly\b/gi, "easily"],
+      [/\bseamlessly\b/gi, ""]
+    ];
   }
 });
 
 // src/lib/watermark.ts
 function buildWatermarkFilters(opts) {
-  const { tier, videoDuration } = opts;
-  if (tier === "pro") {
+  const { tier, videoDuration, endsOnCreditsCard = false } = opts;
+  if (tier !== "free") {
     return "";
   }
   if (videoDuration <= WATERMARK_THRESHOLD_SECONDS) {
@@ -113,6 +142,7 @@ function buildWatermarkFilters(opts) {
   }
   const filters = [];
   filters.push(`drawtext=text='qp':fontsize=24:fontcolor=white@0.3:x=w-tw-20:y=h-th-20`);
+  if (endsOnCreditsCard) return filters.join(",");
   const endTextStart = Math.max(0, videoDuration - END_TEXT_DURATION);
   const fadeEndTime = endTextStart + END_TEXT_FADE_IN;
   const alphaExpr = `if(lt(t,${endTextStart}),0,if(lt(t,${fadeEndTime}),(t-${endTextStart})*0.6,0.6))`;
@@ -131,8 +161,226 @@ var init_watermark = __esm({
   }
 });
 
-// src/lib/ffmpeg/spawn.ts
+// src/lib/lifecycle.ts
+function trackChild(child) {
+  installLifecycle();
+  children.add(child);
+  const drop = () => children.delete(child);
+  child.once("close", drop);
+  child.once("error", drop);
+  return child;
+}
+function teardown() {
+  tearingDown ??= (async () => {
+    for (const child of children) {
+      try {
+        child.kill("SIGKILL");
+      } catch {
+      }
+    }
+    children.clear();
+    const pending = [...cleanups];
+    cleanups.clear();
+    await Promise.allSettled(pending.map((fn) => fn()));
+  })();
+  return tearingDown;
+}
+function installLifecycle() {
+  if (installed) return;
+  installed = true;
+  process.once("beforeExit", () => {
+    void teardown();
+  });
+  process.on("exit", () => {
+    for (const child of children) {
+      try {
+        child.kill("SIGKILL");
+      } catch {
+      }
+    }
+  });
+  for (const signal of ["SIGINT", "SIGTERM", "SIGHUP"]) {
+    process.once(signal, () => {
+      void teardown().finally(() => {
+        process.removeAllListeners(signal);
+        process.kill(process.pid, signal);
+      });
+    });
+  }
+  process.once("uncaughtException", (err) => {
+    void teardown().finally(() => {
+      console.error(err);
+      process.exit(1);
+    });
+  });
+  process.once("unhandledRejection", (err) => {
+    void teardown().finally(() => {
+      console.error(err);
+      process.exit(1);
+    });
+  });
+}
+var cleanups, children, installed, tearingDown;
+var init_lifecycle = __esm({
+  "src/lib/lifecycle.ts"() {
+    "use strict";
+    cleanups = /* @__PURE__ */ new Set();
+    children = /* @__PURE__ */ new Set();
+    installed = false;
+    tearingDown = null;
+  }
+});
+
+// src/lib/ffmpeg/hwaccel.ts
+import { cpus } from "os";
 import { spawn } from "child_process";
+function softwareEncoder(crf, preset) {
+  return {
+    input: [],
+    output: ["-c:v", "libx264", "-preset", preset, "-crf", String(crf), "-pix_fmt", "yuv420p"],
+    filter: null,
+    name: `libx264 ${preset}`
+  };
+}
+function detectHardwareEncoder(quality = 24) {
+  probed ??= (async () => {
+    for (const build of CANDIDATES) {
+      const encoder = build(quality);
+      if (await canEncode(encoder)) return encoder;
+    }
+    return null;
+  })();
+  return probed;
+}
+async function resolveEncoder(opts = {
+  crf: 23,
+  preset: "medium"
+}) {
+  if (opts.allowHardware !== false) {
+    const hw = await detectHardwareEncoder(opts.quality ?? opts.crf);
+    if (hw) {
+      if (opts.width && opts.height) {
+        const sw = softwareEncoder(opts.crf, opts.preset);
+        const won = await faster(hw, sw, opts.width, opts.height);
+        return announce(won, won === hw ? "hardware" : "software (faster than the GPU at this size)");
+      }
+      return announce(hw, "hardware");
+    }
+  }
+  return announce(softwareEncoder(opts.crf, opts.preset), "software (no usable GPU encoder found)");
+}
+async function faster(hw, sw, width, height) {
+  raced ??= (async () => {
+    const decided = Promise.all([timeEncode(hw, width, height), timeEncode(sw, width, height)]).then(
+      ([hwMs, swMs]) => hwMs === null ? false : swMs === null ? true : hwMs <= swMs
+    );
+    const bailout = new Promise((r) => setTimeout(() => r(true), 8e3).unref?.());
+    return Promise.race([decided, bailout]);
+  })();
+  return await raced ? hw : sw;
+}
+async function timeEncode(encoder, width, height) {
+  const args = [
+    "-hide_banner",
+    "-loglevel",
+    "error",
+    ...encoder.input,
+    "-f",
+    "lavfi",
+    "-i",
+    `testsrc2=size=${width}x${height}:rate=30:duration=1`,
+    ...encoder.filter ? ["-vf", encoder.filter] : [],
+    ...encoder.output,
+    "-frames:v",
+    "12",
+    "-f",
+    "null",
+    "-"
+  ];
+  const began = Date.now();
+  const ok = await run(args);
+  return ok ? Date.now() - began : null;
+}
+function announce(encoder, how) {
+  if (announced) return encoder;
+  announced = true;
+  console.log(`   Video encoder: ${encoder.name} - ${how}`);
+  return encoder;
+}
+function canEncode(encoder) {
+  return run([
+    "-hide_banner",
+    "-loglevel",
+    "error",
+    ...encoder.input,
+    "-f",
+    "lavfi",
+    "-i",
+    "testsrc2=size=128x128:rate=2:duration=1",
+    ...encoder.filter ? ["-vf", encoder.filter] : [],
+    ...encoder.output,
+    "-frames:v",
+    "2",
+    "-f",
+    "null",
+    "-"
+  ]);
+}
+function run(args) {
+  return new Promise((resolve3) => {
+    let settled = false;
+    const done = (ok) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve3(ok);
+    };
+    const proc = trackChild(spawn("ffmpeg", args, { stdio: "ignore" }));
+    const timer = setTimeout(() => {
+      proc.kill("SIGKILL");
+      done(false);
+    }, 1e4);
+    proc.on("close", (code) => done(code === 0));
+    proc.on("error", () => done(false));
+  });
+}
+function filterThreadArgs() {
+  const cores = Math.max(1, cpus().length);
+  return ["-filter_threads", String(cores), "-filter_complex_threads", String(cores)];
+}
+var CANDIDATES, probed, raced, announced;
+var init_hwaccel = __esm({
+  "src/lib/ffmpeg/hwaccel.ts"() {
+    "use strict";
+    init_lifecycle();
+    CANDIDATES = [
+      (q) => ({
+        input: ["-init_hw_device", "vaapi=hw:/dev/dri/renderD128", "-filter_hw_device", "hw"],
+        output: ["-c:v", "h264_vaapi", "-qp", String(q)],
+        filter: "format=nv12,hwupload",
+        name: "h264_vaapi"
+      }),
+      (q) => ({
+        input: [],
+        output: ["-c:v", "h264_nvenc", "-preset", "p1", "-cq", String(q), "-pix_fmt", "yuv420p"],
+        filter: null,
+        name: "h264_nvenc"
+      }),
+      (q) => ({
+        input: [],
+        output: ["-c:v", "h264_qsv", "-global_quality", String(q), "-pix_fmt", "nv12"],
+        filter: null,
+        name: "h264_qsv"
+      })
+    ];
+    probed = null;
+    raced = null;
+    announced = false;
+  }
+});
+
+// src/lib/ffmpeg/spawn.ts
+import { spawn as spawn2 } from "child_process";
 function toWSLPath(path) {
   if (!isWindowsRuntime) return path;
   return windowsDrivePathToWsl(path) ?? path.replace(/\\/g, "/");
@@ -146,16 +394,16 @@ function convertArgToWSL(arg) {
 function spawnFFmpeg(cmd, args) {
   if (isWindowsRuntime) {
     const wslArgs = args.map(convertArgToWSL);
-    return spawn("wsl", ["-e", cmd, ...wslArgs]);
+    return trackChild(spawn2("wsl", ["-e", cmd, ...wslArgs]));
   }
-  return spawn(cmd, args);
+  return trackChild(spawn2(cmd, args));
 }
 function runFFmpeg(args, errorLabel) {
   return new Promise((resolve3, reject) => {
     const proc = spawnFFmpeg("ffmpeg", args);
     let stderr = "";
     proc.stderr.on("data", (d) => {
-      stderr += d.toString();
+      stderr = (stderr + d.toString()).slice(-STDERR_TAIL);
     });
     proc.on("close", (code) => {
       if (code !== 0) reject(new Error(`${errorLabel}: ${stderr.slice(-500)}`));
@@ -164,112 +412,170 @@ function runFFmpeg(args, errorLabel) {
     proc.on("error", reject);
   });
 }
-var isWindowsRuntime;
+var isWindowsRuntime, STDERR_TAIL;
 var init_spawn = __esm({
   "src/lib/ffmpeg/spawn.ts"() {
     "use strict";
+    init_lifecycle();
     init_utils();
     isWindowsRuntime = process.platform === "win32";
+    STDERR_TAIL = 4e3;
   }
 });
 
 // src/lib/ffmpeg/compose.ts
 import { MASTER_CHAIN } from "@spark-apps/video-kit";
-function composeVideo(opts) {
-  return new Promise((resolve3, reject) => {
-    const {
-      videoPath,
-      assPath,
-      outputPath,
-      voiceoverPath,
-      musicPath,
-      musicVolume = 0.3,
-      musicFadeIn = 2,
-      musicFadeOut = 2,
-      width,
-      height,
-      fps,
-      preset,
-      quality,
-      fadeIn,
-      fadeOut,
-      videoDuration,
-      audioBitrate = "192k",
-      contrast = 0,
-      trimStart = 0,
-      userTier = "free"
-    } = opts;
-    const args = ["-y"];
-    if (trimStart > 0) {
-      args.push("-ss", String(trimStart));
-    }
-    args.push("-i", videoPath);
-    const effectiveDuration = videoDuration - trimStart;
-    const voiceoverDuration = opts.mainContentDuration ?? effectiveDuration;
-    if (voiceoverPath) args.push("-i", voiceoverPath);
-    if (musicPath) args.push("-i", musicPath);
-    const vf = [`scale=${width}:${height}`, `fps=${fps}`];
-    if (contrast > 0) {
-      const ffmpegContrast = 1 + contrast;
-      vf.push(`eq=contrast=${ffmpegContrast.toFixed(2)}`);
-    }
-    const watermarkFilters = buildWatermarkFilters({ tier: userTier, videoDuration: effectiveDuration });
-    if (watermarkFilters) {
-      vf.push(watermarkFilters);
-    }
+async function composeVideo(opts) {
+  const {
+    videoPath,
+    assPath,
+    outputPath,
+    voiceoverPath,
+    musicPath,
+    musicVolume = 0.3,
+    musicTargetLufs = MUSIC_BED_LUFS,
+    // Sized for the outro window: the song has 5.5s, so a 2s fade at each end
+    // left 1.5s of music anyone could actually hear. Up fast, hold, out slow.
+    musicFadeIn = 1,
+    musicFadeOut = 1.5,
+    tempo = 1,
+    musicStartSecs = 0,
+    musicDurationSecs = 0,
+    width,
+    height,
+    fps,
+    preset,
+    quality,
+    fadeIn,
+    fadeOut,
+    videoDuration,
+    audioBitrate = "192k",
+    contrast = 0,
+    trimStart = 0,
+    userTier = "free",
+    endsOnCreditsCard = false
+  } = opts;
+  const crf = Math.round(28 - quality * 10);
+  const encoder = await resolveEncoder({
+    crf,
+    preset,
+    quality: Math.max(16, crf - 4),
+    allowHardware: opts.hwaccel !== "off",
+    // The race is only meaningful at the size actually being rendered: the
+    // GPU's per-frame upload is a fixed cost that a draft's ninth of the
+    // pixels cannot amortise.
+    width,
+    height
+  });
+  const args = ["-y", ...filterThreadArgs(), ...encoder.input];
+  if (trimStart > 0) {
+    args.push("-ss", String(trimStart));
+  }
+  args.push("-i", videoPath);
+  const effectiveDuration = videoDuration - trimStart;
+  const voiceoverDuration = opts.mainContentDuration ?? effectiveDuration;
+  if (voiceoverPath) args.push("-i", voiceoverPath);
+  if (musicPath) args.push("-i", musicPath);
+  const vf = [`scale=${width}:${height}`, `fps=${fps}`];
+  if (contrast > 0) {
+    const ffmpegContrast = 1 + contrast;
+    vf.push(`eq=contrast=${ffmpegContrast.toFixed(2)}`);
+  }
+  const watermarkFilters = buildWatermarkFilters({
+    tier: userTier,
+    videoDuration: effectiveDuration,
+    endsOnCreditsCard
+  });
+  if (watermarkFilters) {
+    vf.push(watermarkFilters);
+  }
+  if (assPath) {
     const assPathForFilter = toWSLPath(assPath).replace(/:/g, "\\:");
     vf.push(`ass=${assPathForFilter}`);
-    if (fadeIn > 0) vf.push(`fade=t=in:st=0:d=${fadeIn}:c=black`);
-    if (fadeOut > 0) {
-      const videoFadeOutStart = Math.max(0, effectiveDuration - fadeOut);
-      vf.push(`fade=t=out:st=${videoFadeOutStart}:d=${fadeOut}:c=black`);
-    }
-    const crf = Math.round(28 - quality * 10);
-    const hasVoiceover = !!voiceoverPath;
-    const hasMusic = !!musicPath;
-    const musicFadeOutStart = Math.max(0, effectiveDuration - musicFadeOut);
-    const vfStr = vf.join(",");
-    if (hasVoiceover && hasMusic) {
-      const complexFilter = [
-        // Voiceover: fade in only (no fade out - stays clear until end)
-        `[1:a]apad=whole_dur=${voiceoverDuration},afade=t=in:st=0:d=${fadeIn}[voice]`,
-        // Music: fade in and fade out
-        `[2:a]aloop=loop=-1:size=2e+09,atrim=0:${effectiveDuration},volume=${musicVolume},afade=t=in:st=0:d=${musicFadeIn},afade=t=out:st=${musicFadeOutStart}:d=${musicFadeOut}[music]`,
-        // Normalise the MIX and hard-limit its true peak - ported from
-        // VidLet, where single-pass loudnorm alone measured +0.9 dBTP on
-        // sharp TTS consonants. -14 LUFS is the YouTube/IG/TikTok playback
-        // target, so the platform leaves the audio untouched.
-        `[voice][music]amix=inputs=2:duration=longest,${MASTER_CHAIN}[aout]`
-      ].join(";");
-      args.push("-vf", vfStr);
-      args.push("-filter_complex", complexFilter, "-map", "0:v", "-map", "[aout]");
-      args.push("-c:v", "libx264", "-preset", preset, "-crf", String(crf), "-pix_fmt", "yuv420p");
-      args.push("-c:a", "aac", "-b:a", audioBitrate);
-    } else if (hasVoiceover) {
-      const af = `apad=whole_dur=${voiceoverDuration},afade=t=in:st=0:d=${fadeIn},${MASTER_CHAIN}`;
-      args.push("-vf", vfStr);
-      args.push("-map", "0:v", "-map", "1:a", "-af", af);
-      args.push("-c:v", "libx264", "-preset", preset, "-crf", String(crf), "-pix_fmt", "yuv420p");
-      args.push("-c:a", "aac", "-b:a", audioBitrate);
-    } else if (hasMusic) {
-      const musicFilter = `aloop=loop=-1:size=2e+09,atrim=0:${effectiveDuration},volume=${musicVolume},afade=t=in:st=0:d=${musicFadeIn},afade=t=out:st=${musicFadeOutStart}:d=${musicFadeOut},${MASTER_CHAIN}`;
-      args.push("-vf", vfStr);
-      args.push("-map", "0:v", "-map", "1:a", "-af", musicFilter);
-      args.push("-c:v", "libx264", "-preset", preset, "-crf", String(crf), "-pix_fmt", "yuv420p");
-      args.push("-c:a", "aac", "-b:a", "192k");
-    } else {
-      args.push("-vf", vfStr);
-      args.push("-c:v", "libx264", "-preset", preset, "-crf", String(crf), "-pix_fmt", "yuv420p");
-    }
-    args.push(outputPath);
-    runFFmpeg(args, "ffmpeg compose failed").then(resolve3, reject);
-  });
+  }
+  if (fadeIn > 0) vf.push(`fade=t=in:st=0:d=${fadeIn}:c=black`);
+  if (fadeOut > 0 && !endsOnCreditsCard) {
+    const videoFadeOutStart = Math.max(0, effectiveDuration - fadeOut);
+    vf.push(`fade=t=out:st=${videoFadeOutStart}:d=${fadeOut}:c=black`);
+  }
+  const clipAudioLabel = opts.hasClipAudio ? "[0:a]" : "";
+  const hasVoiceover = !!voiceoverPath;
+  const hasMusic = !!musicPath;
+  const bedStart = Math.max(0, Math.min(musicStartSecs, Math.max(0, effectiveDuration - 0.5)));
+  const bedLength = Math.max(0.5, effectiveDuration - bedStart);
+  const bedDelay = bedStart > 0 ? `adelay=${Math.round(bedStart * 1e3)}|${Math.round(bedStart * 1e3)},` : "";
+  const bedTempo = tempo > 1 ? 1 / tempo : 1;
+  const bedSlow = bedTempo === 1 ? "" : `atempo=${bedTempo.toFixed(6)},`;
+  const bedSource = bedLength * bedTempo;
+  const bedSeek = musicDurationSecs > bedSource + 0.05 ? musicDurationSecs - bedSource : 0;
+  const bedTrimIn = bedSeek > 0 ? `atrim=start=${bedSeek.toFixed(3)},asetpts=PTS-STARTPTS,` : "";
+  const bedFadeOut = bedSeek > 0 ? 0 : musicFadeOut * tempo;
+  const bedLoop = bedSeek > 0 ? "" : "aloop=loop=-1:size=2e+09,";
+  const bedFadeIn = musicFadeIn * tempo;
+  const musicFadeOutStart = Math.max(0, bedLength - bedFadeOut);
+  const bedFadeOutFilter = bedFadeOut > 0 ? `afade=t=out:st=${musicFadeOutStart}:d=${bedFadeOut},` : "";
+  const vfStr = [...vf, ...encoder.filter ? [encoder.filter] : []].join(",");
+  if (hasVoiceover && hasMusic) {
+    const mixInputs = clipAudioLabel ? 3 : 2;
+    const complexFilter = [
+      // Voiceover: fade in only (no fade out - stays clear until end). Split,
+      // because one copy is mixed and the other is only listened to, by the
+      // compressor that pulls the bed down under it.
+      `[1:a]adelay=${VOICE_LEAD_MS}|${VOICE_LEAD_MS},apad=whole_dur=${voiceoverDuration},asplit=2[voice][voicekey0]`,
+      // The detector's copy runs the length of the PICTURE, not the length of
+      // the narration. sidechaincompress is a framesync filter and ends at its
+      // shorter input, so a key that stops when the voice does takes the bed
+      // with it - and the stretch it would have taken is exactly the closing
+      // card, which is the one place the bed is the only thing playing.
+      `[voicekey0]apad=whole_dur=${effectiveDuration}[voicekey]`,
+      // Music: normalised to a known level, trimmed, then faded.
+      `[2:a]${bedTrimIn}${bedLoop}${bedSlow}atrim=0:${bedLength},loudnorm=I=${musicTargetLufs}:TP=-9:LRA=11,volume=${musicVolume},afade=t=in:st=0:d=${bedFadeIn},${bedFadeOutFilter}${bedDelay}apad=whole_dur=${effectiveDuration}[bed]`,
+      `[bed][voicekey]${DUCK}[music]`,
+      // normalize=0, because amix's default divides every input by the number
+      // of them: adding the bed used to quietly take 6 dB off the narration,
+      // and the master loudnorm then put it back by turning everything up,
+      // bed included. Levels set deliberately upstream should survive the mix.
+      //
+      // Normalise the MIX and hard-limit its true peak - ported from
+      // VidLet, where single-pass loudnorm alone measured +0.9 dBTP on
+      // sharp TTS consonants. -14 LUFS is the YouTube/IG/TikTok playback
+      // target, so the platform leaves the audio untouched.
+      `[voice][music]${clipAudioLabel}amix=inputs=${mixInputs}:duration=longest:normalize=0,${MASTER_CHAIN}[aout]`
+    ].join(";");
+    args.push("-vf", vfStr);
+    args.push("-filter_complex", complexFilter, "-map", "0:v", "-map", "[aout]");
+    args.push(...encoder.output);
+    args.push("-c:a", "aac", "-b:a", audioBitrate);
+  } else if (hasVoiceover) {
+    const af = `adelay=${VOICE_LEAD_MS}|${VOICE_LEAD_MS},apad=whole_dur=${voiceoverDuration},${MASTER_CHAIN}`;
+    args.push("-vf", vfStr);
+    args.push("-map", "0:v", "-map", "1:a", "-af", af);
+    args.push(...encoder.output);
+    args.push("-c:a", "aac", "-b:a", audioBitrate);
+  } else if (hasMusic) {
+    const musicFilter = `${bedTrimIn}${bedLoop}${bedSlow}atrim=0:${bedLength},volume=${musicVolume},afade=t=in:st=0:d=${bedFadeIn},${bedFadeOutFilter}${bedDelay}apad=whole_dur=${effectiveDuration},${MASTER_CHAIN}`;
+    args.push("-vf", vfStr);
+    args.push("-map", "0:v", "-map", "1:a", "-af", musicFilter);
+    args.push(...encoder.output);
+    args.push("-c:a", "aac", "-b:a", "192k");
+  } else {
+    args.push("-vf", vfStr);
+    args.push(...encoder.output);
+  }
+  args.push("-movflags", "+faststart");
+  args.push(outputPath);
+  await runFFmpeg(args, "ffmpeg compose failed");
 }
+var VOICE_LEAD_MS, MUSIC_BED_LUFS, DUCK;
 var init_compose = __esm({
   "src/lib/ffmpeg/compose.ts"() {
     "use strict";
     init_watermark();
+    init_hwaccel();
     init_spawn();
+    VOICE_LEAD_MS = 200;
+    MUSIC_BED_LUFS = -34;
+    DUCK = "sidechaincompress=threshold=0.05:ratio=8:attack=20:release=420:level_sc=4:makeup=1";
   }
 });
 
@@ -315,8 +621,130 @@ var init_compress = __esm({
   }
 });
 
+// src/lib/ffmpeg/gif.ts
+import { unlink } from "fs/promises";
+import { tmpdir } from "os";
+import { join } from "path";
+function buildPaletteArgs(input, palettePath, fps, width, statsMode) {
+  return [
+    "-y",
+    "-i",
+    input,
+    "-vf",
+    `fps=${fps},scale=${width}:-1:flags=lanczos,palettegen=stats_mode=${statsMode}`,
+    palettePath
+  ];
+}
+function buildGifArgs(input, palettePath, output, fps, width, dither) {
+  return [
+    "-y",
+    "-i",
+    input,
+    "-i",
+    palettePath,
+    "-lavfi",
+    `fps=${fps},scale=${width}:-1:flags=lanczos[x];[x][1:v]paletteuse=dither=${dither}`,
+    output
+  ];
+}
+async function convertToGif(options) {
+  const { input, output } = options;
+  const fps = options.fps ?? GIF_DEFAULTS.fps;
+  const width = options.width ?? GIF_DEFAULTS.width;
+  const dither = options.dither ?? GIF_DEFAULTS.dither;
+  const statsMode = options.statsMode ?? GIF_DEFAULTS.statsMode;
+  const palettePath = join(tmpdir(), `quickpeek_palette_${Date.now()}.png`);
+  try {
+    await runFFmpeg(buildPaletteArgs(input, palettePath, fps, width, statsMode), "GIF palette generation failed");
+    await runFFmpeg(buildGifArgs(input, palettePath, output, fps, width, dither), "GIF conversion failed");
+    return output;
+  } finally {
+    try {
+      await unlink(palettePath);
+    } catch {
+    }
+  }
+}
+var GIF_DEFAULTS;
+var init_gif = __esm({
+  "src/lib/ffmpeg/gif.ts"() {
+    "use strict";
+    init_spawn();
+    GIF_DEFAULTS = { fps: 15, width: 480, dither: "sierra2_4a", statsMode: "full" };
+  }
+});
+
 // src/lib/ffmpeg/media.ts
+import { statSync } from "fs";
+function cacheKey(filePath) {
+  try {
+    const { size, mtimeMs } = statSync(filePath);
+    return `${filePath}:${size}:${mtimeMs}`;
+  } catch {
+    return null;
+  }
+}
+function getVideoDimensions(filePath) {
+  return new Promise((resolve3, reject) => {
+    const args = [
+      "-v",
+      "error",
+      "-select_streams",
+      "v:0",
+      "-show_entries",
+      "stream=width,height",
+      "-of",
+      "csv=p=0",
+      filePath
+    ];
+    const proc = spawnFFmpeg("ffprobe", args);
+    let stdout = "";
+    let stderr = "";
+    proc.stdout.on("data", (d) => {
+      stdout += d;
+    });
+    proc.stderr.on("data", (d) => {
+      stderr += d;
+    });
+    proc.on("close", (code) => {
+      if (code !== 0) {
+        reject(new Error(`ffprobe failed: ${stderr}`));
+        return;
+      }
+      const [w, h] = stdout.trim().split(",").map(Number);
+      if (!w || !h) {
+        reject(new Error(`ffprobe returned no dimensions for ${filePath}`));
+        return;
+      }
+      resolve3({ width: w, height: h });
+    });
+  });
+}
+function hasAudioStream(filePath) {
+  return new Promise((resolve3) => {
+    const proc = spawnFFmpeg("ffprobe", [
+      "-v",
+      "error",
+      "-select_streams",
+      "a:0",
+      "-show_entries",
+      "stream=codec_type",
+      "-of",
+      "csv=p=0",
+      filePath
+    ]);
+    let out = "";
+    proc.stdout.on("data", (d) => {
+      out += d;
+    });
+    proc.on("close", () => resolve3(out.trim().length > 0));
+    proc.on("error", () => resolve3(false));
+  });
+}
 function getMediaDuration(filePath) {
+  const key = cacheKey(filePath);
+  const cached = key === null ? void 0 : durationCache.get(key);
+  if (cached !== void 0) return Promise.resolve(cached);
   return new Promise((resolve3, reject) => {
     const args = [
       "-v",
@@ -341,8 +769,10 @@ function getMediaDuration(filePath) {
         reject(new Error(`ffprobe failed: ${stderr}`));
         return;
       }
-      const duration = parseFloat(stdout.trim());
-      resolve3(Math.ceil(duration * 1e3));
+      const ms = Math.ceil(parseFloat(stdout.trim()) * 1e3);
+      const freshKey = cacheKey(filePath);
+      if (freshKey !== null && Number.isFinite(ms)) durationCache.set(freshKey, ms);
+      resolve3(ms);
     });
     proc.on("error", reject);
   });
@@ -381,6 +811,12 @@ function buildConcatArgs(listPath, output) {
 function concatMedia(listPath, output) {
   return runFFmpeg(buildConcatArgs(listPath, output), "ffmpeg concat failed");
 }
+async function trimEdgeSilence(filePath) {
+  const trimmed = filePath.replace(/\.mp3$/i, "-trim.mp3");
+  await runFFmpeg(["-y", "-i", filePath, "-af", TRIM_EDGE_SILENCE, trimmed], "ffmpeg silence trim failed");
+  const { rename } = await import("fs/promises");
+  await rename(trimmed, filePath);
+}
 function generateSilence(outputPath, durationMs) {
   return runFFmpeg(
     [
@@ -411,7 +847,23 @@ function speedUpVideo(opts) {
     remaining /= tempo;
   }
   return runFFmpeg(
-    ["-y", "-i", inputPath, "-vf", videoFilter, "-af", audioFilters.join(","), "-preset", preset, outputPath],
+    // faststart for the same reason as compose: this pass can be the last
+    // thing to touch the delivered file, and a moov atom written after the
+    // payload makes it unplayable in a browser preview.
+    [
+      "-y",
+      "-i",
+      inputPath,
+      "-vf",
+      videoFilter,
+      "-af",
+      audioFilters.join(","),
+      "-preset",
+      preset,
+      "-movflags",
+      "+faststart",
+      outputPath
+    ],
     "ffmpeg speedup failed"
   );
 }
@@ -434,43 +886,581 @@ function concatVideoWithOutro(opts) {
       "-y",
       "-i",
       inputPath,
-      "-i",
-      outroPath,
+      "-i",
+      outroPath,
+      "-filter_complex",
+      filterComplex,
+      "-map",
+      "[outv]",
+      "-c:v",
+      "libx264",
+      "-preset",
+      preset,
+      "-crf",
+      "18",
+      "-pix_fmt",
+      "yuv420p",
+      "-an",
+      outputPath
+    ],
+    "ffmpeg concat video failed"
+  );
+}
+function concatVideoWithFullFrameOutro(opts) {
+  const { inputPath, outroPath, outputPath, width, height, preset } = opts;
+  const filterComplex = [
+    `[0:v]scale=${width}:${height},setsar=1,fps=30[v0]`,
+    `[1:v]scale=${width}:${height},setsar=1,fps=30[v1]`,
+    "[v0][v1]concat=n=2:v=1:a=0[outv]"
+  ].join(";");
+  return runFFmpeg(
+    [
+      "-y",
+      "-i",
+      inputPath,
+      "-i",
+      outroPath,
+      "-filter_complex",
+      filterComplex,
+      "-map",
+      "[outv]",
+      "-c:v",
+      "libx264",
+      "-preset",
+      preset,
+      "-crf",
+      "18",
+      "-pix_fmt",
+      "yuv420p",
+      "-an",
+      outputPath
+    ],
+    "ffmpeg full-frame outro concat failed"
+  );
+}
+var durationCache, TRIM_EDGE_SILENCE;
+var init_media = __esm({
+  "src/lib/ffmpeg/media.ts"() {
+    "use strict";
+    init_spawn();
+    durationCache = /* @__PURE__ */ new Map();
+    TRIM_EDGE_SILENCE = "silenceremove=start_periods=1:start_silence=0:start_threshold=-45dB:detection=peak,areverse,silenceremove=start_periods=1:start_silence=0:start_threshold=-45dB:detection=peak,areverse";
+  }
+});
+
+// src/lib/ffmpeg/silence.ts
+function getVideoStreamDuration(inputPath) {
+  return new Promise((resolve3) => {
+    const proc = spawnFFmpeg("ffprobe", [
+      "-v",
+      "error",
+      "-select_streams",
+      "v:0",
+      "-show_entries",
+      "stream=duration",
+      "-of",
+      "csv=p=0",
+      inputPath
+    ]);
+    proc.stderr?.resume();
+    let out = "";
+    proc.stdout.on("data", (d) => {
+      out += d;
+    });
+    proc.on("error", () => resolve3(0));
+    proc.on("close", () => resolve3(Number.parseFloat(out.trim()) || 0));
+  });
+}
+function detectSilences(inputPath, minDurSecs) {
+  return new Promise((resolve3) => {
+    const proc = spawnFFmpeg("ffmpeg", [
+      "-hide_banner",
+      "-nostats",
+      // Audio-only analysis: without -vn ffmpeg's default stream selection
+      // decodes the video too, for a filter that cannot see it.
+      "-vn",
+      "-i",
+      inputPath,
+      "-af",
+      `silencedetect=noise=-40dB:d=${minDurSecs}`,
+      "-f",
+      "null",
+      "-"
+    ]);
+    let err = "";
+    proc.stderr.on("data", (d) => {
+      err += d;
+    });
+    proc.on("error", () => resolve3([]));
+    proc.on("close", () => {
+      const spans = [];
+      let start = null;
+      for (const line of err.split("\n")) {
+        const s = line.match(/silence_start:\s*(-?[\d.]+)/);
+        if (s?.[1]) start = Math.max(0, Number.parseFloat(s[1]));
+        const e = line.match(/silence_end:\s*([\d.]+)/);
+        if (e?.[1] && start !== null) {
+          const from = start + SPEECH_GUARD_SECS;
+          const to = Number.parseFloat(e[1]) - SPEECH_GUARD_SECS;
+          if (to > from) spans.push({ start: from, end: to });
+          start = null;
+        }
+      }
+      resolve3(spans);
+    });
+  });
+}
+function detectFrozenSpans(inputPath, minDurSecs) {
+  return new Promise((resolve3) => {
+    const proc = spawnFFmpeg("ffmpeg", [
+      "-hide_banner",
+      "-nostats",
+      // The mirror of detectSilences: a video-only filter, so skip the audio.
+      "-an",
+      "-sn",
+      "-i",
+      inputPath,
+      "-vf",
+      // A generous noise floor: video is lossy, so a "still" frame still
+      // differs from the last one by a little.
+      `freezedetect=n=-55dB:d=${minDurSecs}`,
+      "-f",
+      "null",
+      "-"
+    ]);
+    let err = "";
+    proc.stderr.on("data", (d) => {
+      err += d;
+    });
+    proc.on("error", () => resolve3([]));
+    proc.on("close", () => {
+      const spans = [];
+      let start = null;
+      for (const line of err.split("\n")) {
+        const s = line.match(/freeze_start:\s*(-?[\d.]+)/);
+        if (s?.[1]) start = Math.max(0, Number.parseFloat(s[1]));
+        const e = line.match(/freeze_end:\s*([\d.]+)/);
+        if (e?.[1] && start !== null) {
+          spans.push({ start, end: Number.parseFloat(e[1]) });
+          start = null;
+        }
+      }
+      resolve3(spans);
+    });
+  });
+}
+function detectBlackSpans(inputPath, minDurSecs) {
+  return new Promise((resolve3) => {
+    const proc = spawnFFmpeg("ffmpeg", [
+      "-hide_banner",
+      "-nostats",
+      "-an",
+      "-sn",
+      "-i",
+      inputPath,
+      "-vf",
+      // Strict on purpose. Loosening these to catch a lingering spinner
+      // (pic_th 0.96, pix_th 0.14) cut 37 seconds out of a 95 second
+      // recording: it was matching real dark-themed pages, and 80s of
+      // narration was left with 58s of picture to play over. A missed second
+      // of loading screen is a blemish; a false positive desyncs the video.
+      `blackdetect=d=${minDurSecs}:pic_th=0.98:pix_th=0.10`,
+      "-f",
+      "null",
+      "-"
+    ]);
+    let err = "";
+    proc.stderr.on("data", (d) => {
+      err += d;
+    });
+    proc.on("error", () => resolve3([]));
+    proc.on("close", () => {
+      const spans = [];
+      for (const line of err.split("\n")) {
+        const m = line.match(/black_start:\s*([\d.]+)\s+black_end:\s*([\d.]+)/);
+        if (m?.[1] && m[2]) spans.push({ start: Number.parseFloat(m[1]), end: Number.parseFloat(m[2]) });
+      }
+      resolve3(spans);
+    });
+  });
+}
+function detectWhiteSpans(inputPath, minDurSecs) {
+  return new Promise((resolve3) => {
+    const proc = spawnFFmpeg("ffmpeg", [
+      "-hide_banner",
+      "-nostats",
+      "-an",
+      "-sn",
+      "-i",
+      inputPath,
+      "-vf",
+      `negate,blackdetect=d=${minDurSecs}:pic_th=0.98:pix_th=0.10`,
+      "-f",
+      "null",
+      "-"
+    ]);
+    let err = "";
+    proc.stderr.on("data", (d) => {
+      err += d;
+    });
+    proc.on("error", () => resolve3([]));
+    proc.on("close", () => {
+      const spans = [];
+      for (const line of err.split("\n")) {
+        const m = line.match(/black_start:\s*([\d.]+)\s+black_end:\s*([\d.]+)/);
+        if (m?.[1] && m[2]) spans.push({ start: Number.parseFloat(m[1]), end: Number.parseFloat(m[2]) });
+      }
+      resolve3(spans);
+    });
+  });
+}
+function intersectSpans(a, b) {
+  const out = [];
+  for (const x of a) {
+    for (const y of b) {
+      const start = Math.max(x.start, y.start);
+      const end = Math.min(x.end, y.end);
+      if (end > start) out.push({ start, end });
+    }
+  }
+  return out.sort((p, q) => p.start - q.start);
+}
+function mergeSpans(spans) {
+  const sorted = [...spans].sort((a, b) => a.start - b.start);
+  const out = [];
+  for (const span of sorted) {
+    const last = out[out.length - 1];
+    if (last && span.start <= last.end + 0.01) {
+      last.end = Math.max(last.end, span.end);
+      if (span.cap !== void 0) last.cap = Math.min(last.cap ?? span.cap, span.cap);
+    } else out.push({ ...span });
+  }
+  return out;
+}
+function atempoChain(factor) {
+  const steps = [];
+  let remaining = factor;
+  while (remaining > 2) {
+    steps.push(2);
+    remaining /= 2;
+  }
+  if (remaining > 1.001) steps.push(remaining);
+  return steps.map((s) => `atempo=${s.toFixed(4)}`).join(",");
+}
+function buildCompressionFilter(spans, totalSecs, maxSecs, protectAfterSecs, protectBeforeSecs) {
+  const limit = protectAfterSecs ?? totalSecs;
+  const floor = Math.max(0, protectBeforeSecs ?? 0);
+  const usable = spans.map((s) => ({
+    start: Math.max(floor, s.start),
+    end: Math.min(totalSecs, Math.min(s.end, limit)),
+    cap: Math.min(s.cap ?? maxSecs, maxSecs)
+  })).filter((s) => s.start < limit && s.end - s.start > s.cap + 0.05).sort((a, b) => a.start - b.start);
+  if (usable.length === 0) return null;
+  const parts = [];
+  const labels = [];
+  let cursor = 0;
+  let n = 0;
+  const keep = (from, to) => {
+    if (to - from < 0.04) return;
+    parts.push(`[0:v]trim=${from.toFixed(3)}:${to.toFixed(3)},setpts=PTS-STARTPTS[v${n}]`);
+    parts.push(`[0:a]atrim=${from.toFixed(3)}:${to.toFixed(3)},asetpts=PTS-STARTPTS[a${n}]`);
+    labels.push(`[v${n}][a${n}]`);
+    n++;
+  };
+  for (const span of usable) {
+    keep(cursor, span.start);
+    const factor = (span.end - span.start) / span.cap;
+    const tempo = atempoChain(factor);
+    parts.push(
+      `[0:v]trim=${span.start.toFixed(3)}:${span.end.toFixed(3)},setpts=(PTS-STARTPTS)/${factor.toFixed(4)}[v${n}]`
+    );
+    parts.push(
+      `[0:a]atrim=${span.start.toFixed(3)}:${span.end.toFixed(3)},asetpts=PTS-STARTPTS${tempo ? `,${tempo}` : ""}[a${n}]`
+    );
+    labels.push(`[v${n}][a${n}]`);
+    n++;
+    cursor = span.end;
+  }
+  keep(cursor, totalSecs);
+  if (n < 2) return null;
+  return `${parts.join(";")};${labels.join("")}concat=n=${n}:v=1:a=1[outv][outa]`;
+}
+async function passEncoder(preset) {
+  const encoder = await resolveEncoder({ crf: 18, preset, quality: 20 });
+  return {
+    input: encoder.input,
+    output: encoder.output,
+    filterSuffix: encoder.filter ? `;[outv]${encoder.filter}[outvhw]` : "",
+    videoLabel: encoder.filter ? "[outvhw]" : "[outv]"
+  };
+}
+async function cutSpansFromVideo(inputPath, outputPath, spans, preset) {
+  const keep = mergeSpans(spans.map((s) => ({ ...s }))).filter((s) => s.end - s.start > 0.15);
+  if (keep.length === 0) return false;
+  const drop = keep.map((s) => `between(t,${s.start.toFixed(3)},${s.end.toFixed(3)})`).join("+");
+  const filter = `[0:v]select='not(${drop})',setpts=N/FRAME_RATE/TB[outv]`;
+  const enc = await passEncoder(preset);
+  return new Promise((resolve3) => {
+    const proc = spawnFFmpeg("ffmpeg", [
+      "-y",
+      ...filterThreadArgs(),
+      ...enc.input,
+      "-i",
+      inputPath,
+      "-filter_complex",
+      enc.filterSuffix ? filter + enc.filterSuffix : filter,
+      "-map",
+      enc.videoLabel,
+      "-an",
+      ...enc.output,
+      "-movflags",
+      "+faststart",
+      outputPath
+    ]);
+    proc.stderr.resume();
+    proc.on("error", () => resolve3(false));
+    proc.on("close", (code) => resolve3(code === 0));
+  });
+}
+function buildRetimeFilter(spans, stepBounds, speed, fps) {
+  const all = mergeSpans(spans.map((s) => ({ ...s })));
+  const totalSecs = stepBounds[stepBounds.length - 1]?.to ?? 0;
+  const frame = 1 / Math.max(1, fps);
+  const parts = [];
+  const labels = [];
+  let n = 0;
+  let reclaimed = 0;
+  let pendingFrom = null;
+  const flush = (to) => {
+    if (pendingFrom === null) return;
+    const from = pendingFrom;
+    pendingFrom = null;
+    if (to - from < 0.04) return;
+    parts.push(`[0:v]trim=${from.toFixed(3)}:${to.toFixed(3)},setpts=PTS-STARTPTS,fps=${fps}[v${n}]`);
+    labels.push(`[v${n}]`);
+    n++;
+  };
+  const segment = (from, to, factor) => {
+    if (to - from < 0.04) return;
+    const pts = factor === 1 ? "PTS-STARTPTS" : `(PTS-STARTPTS)*${factor.toFixed(5)}`;
+    parts.push(`[0:v]trim=${from.toFixed(3)}:${to.toFixed(3)},setpts=${pts},fps=${fps}[v${n}]`);
+    labels.push(`[v${n}]`);
+    n++;
+  };
+  const freeze = (from, to, sourceAt) => {
+    const dur = to - from;
+    if (dur < 0.04) return;
+    const at = sourceAt + frame <= totalSecs ? sourceAt : Math.max(0, from - frame);
+    parts.push(
+      `[0:v]trim=${at.toFixed(3)}:${(at + frame).toFixed(3)},setpts=PTS-STARTPTS,loop=loop=${Math.ceil(dur * fps) + 1}:size=1:start=0,setpts=N/FRAME_RATE/TB,trim=0:${dur.toFixed(3)},setpts=PTS-STARTPTS,fps=${fps}[v${n}]`
+    );
+    labels.push(`[v${n}]`);
+    n++;
+  };
+  for (const step of stepBounds) {
+    const local = all.map((s) => ({ start: Math.max(s.start, step.from), end: Math.min(s.end, step.to), sourceAt: s.end })).filter((s) => s.end - s.start >= MIN_RETIME_SPAN);
+    if (local.length === 0) {
+      if (pendingFrom === null) pendingFrom = step.from;
+      continue;
+    }
+    const window = step.to - step.from;
+    const emptyTotal = local.reduce((a, s) => a + (s.end - s.start), 0);
+    const keepTotal = window - emptyTotal;
+    let recovered = emptyTotal * (1 - 1 / speed);
+    let stretch = keepTotal > 0 ? (keepTotal + recovered) / keepTotal : Number.POSITIVE_INFINITY;
+    if (stretch > MAX_STRETCH) {
+      recovered = keepTotal * (MAX_STRETCH - 1);
+      stretch = MAX_STRETCH;
+    }
+    const effective = emptyTotal / Math.max(0.01, emptyTotal - recovered);
+    flush(step.from);
+    let cursor = step.from;
+    if (keepTotal >= MIN_KEEP_SECS && effective >= MIN_EFFECTIVE_SPEED) {
+      for (const span of local) {
+        segment(cursor, span.start, stretch);
+        segment(span.start, span.end, 1 / effective);
+        cursor = span.end;
+      }
+      segment(cursor, step.to, stretch);
+      reclaimed += emptyTotal - emptyTotal / effective;
+    } else {
+      for (const span of local) {
+        segment(cursor, span.start, 1);
+        freeze(span.start, span.end, span.sourceAt);
+        cursor = span.end;
+      }
+      segment(cursor, step.to, 1);
+      reclaimed += emptyTotal;
+    }
+  }
+  flush(totalSecs);
+  if (n < 2 || reclaimed < 0.5) return null;
+  return `${parts.join(";")};${labels.join("")}concat=n=${n}:v=1:a=0[outv]`;
+}
+async function retimeSpansInVideo(inputPath, outputPath, spans, stepBounds, speed, fps, preset) {
+  const filter = buildRetimeFilter(spans, stepBounds, speed, fps);
+  if (!filter) return false;
+  const enc = await passEncoder(preset);
+  return new Promise((resolve3) => {
+    const proc = spawnFFmpeg("ffmpeg", [
+      "-y",
+      ...filterThreadArgs(),
+      ...enc.input,
+      "-i",
+      inputPath,
+      "-filter_complex",
+      enc.filterSuffix ? filter + enc.filterSuffix : filter,
+      "-map",
+      enc.videoLabel,
+      "-an",
+      ...enc.output,
+      "-movflags",
+      "+faststart",
+      outputPath
+    ]);
+    proc.stderr.resume();
+    proc.on("error", () => resolve3(false));
+    proc.on("close", (code) => resolve3(code === 0));
+  });
+}
+async function compressSilentSpans(inputPath, outputPath, totalSecs, maxSecs, preset, protectAfterSecs, narrationPath, protectBeforeSecs, leadSpans, keepSpans) {
+  const audioSource = narrationPath || inputPath;
+  const frozenMax = Math.min(maxSecs, FROZEN_MAX_SECS);
+  const [detected, frozen, black, white] = await Promise.all([
+    detectSilences(audioSource, frozenMax + 0.05),
+    detectFrozenSpans(inputPath, frozenMax + 0.05),
+    // Shorter threshold than the other two: a page transition is often only a
+    // second, and a second of black in a 60s Short is a second too many.
+    detectBlackSpans(inputPath, 0.3),
+    detectWhiteSpans(inputPath, 0.3)
+  ]);
+  const silent = detected.filter((span) => span.end - span.start > maxSecs + 0.05);
+  const stuck = intersectSpans(frozen, detected).filter((span) => span.end - span.start > frozenMax).map((span) => ({ ...span, cap: frozenMax }));
+  const cardFloor = Math.max(0, protectBeforeSecs ?? 0);
+  const cardCeiling = protectAfterSecs ?? totalSecs;
+  const empty = intersectSpans(mergeSpans([...black, ...white]), detected).filter((span) => span.end - span.start > BLACK_KEEP_SECS * 2).filter((span) => span.start >= cardFloor && span.end <= cardCeiling).map((span) => ({ ...span, cap: BLACK_KEEP_SECS }));
+  const known = (leadSpans ?? []).filter((span) => span.end - span.start > BLACK_KEEP_SECS * 2).map((span) => ({ ...span, cap: BLACK_KEEP_SECS }));
+  const merged = mergeSpans([...silent, ...stuck, ...empty, ...known]);
+  const overlapsContent = (span) => (keepSpans ?? []).some((keep) => span.start < keep.end && span.end > keep.start);
+  const spans = merged.filter((span) => !overlapsContent(span));
+  const filter = buildCompressionFilter(spans, totalSecs, maxSecs, protectAfterSecs, protectBeforeSecs);
+  if (!filter) return false;
+  const enc = await passEncoder(preset);
+  return new Promise((resolve3) => {
+    const proc = spawnFFmpeg("ffmpeg", [
+      "-y",
+      ...filterThreadArgs(),
+      ...enc.input,
+      "-i",
+      inputPath,
+      "-filter_complex",
+      filter + enc.filterSuffix,
+      "-map",
+      enc.videoLabel,
+      "-map",
+      "[outa]",
+      ...enc.output,
+      "-c:a",
+      "aac",
+      // No -shortest here. The overhang it was added for is already handled by
+      // bounding every segment to the VIDEO stream's length, and the flag cut
+      // the other way once an outro existed: a credits card carries no
+      // narration, so the audio runs out before the picture does and the card
+      // was truncated away.
+      "-movflags",
+      "+faststart",
+      outputPath
+    ]);
+    proc.stderr.resume();
+    proc.on("error", () => resolve3(false));
+    proc.on("close", (code) => resolve3(code === 0));
+  });
+}
+async function speedUpMiddle(inputPath, outputPath, totalSecs, targetSecs, introSecs, outroSecs, maxFactor, preset) {
+  const ends = introSecs + outroSecs;
+  const middle = totalSecs - ends;
+  const budget = targetSecs - ends - FIT_UNDERSHOOT_SECS;
+  if (middle <= 0.5 || budget <= 0.5 || middle <= budget) {
+    return { ok: false, factor: 1, reachedTarget: totalSecs <= targetSecs };
+  }
+  const needed = middle / budget;
+  const factor = Math.min(needed, maxFactor);
+  const tempo = atempoChain(factor);
+  const midEnd = totalSecs - outroSecs;
+  const filter = [
+    `[0:v]trim=0:${introSecs.toFixed(3)},setpts=PTS-STARTPTS[v0]`,
+    `[0:a]atrim=0:${introSecs.toFixed(3)},asetpts=PTS-STARTPTS[a0]`,
+    `[0:v]trim=${introSecs.toFixed(3)}:${midEnd.toFixed(3)},setpts=(PTS-STARTPTS)/${factor.toFixed(4)}[v1]`,
+    `[0:a]atrim=${introSecs.toFixed(3)}:${midEnd.toFixed(3)},asetpts=PTS-STARTPTS${tempo ? `,${tempo}` : ""}[a1]`,
+    `[0:v]trim=${midEnd.toFixed(3)}:${totalSecs.toFixed(3)},setpts=PTS-STARTPTS[v2]`,
+    `[0:a]atrim=${midEnd.toFixed(3)}:${totalSecs.toFixed(3)},asetpts=PTS-STARTPTS[a2]`,
+    "[v0][a0][v1][a1][v2][a2]concat=n=3:v=1:a=1[outv][outa]"
+  ].join(";");
+  const enc = await passEncoder(preset);
+  const ok = await new Promise((resolve3) => {
+    const proc = spawnFFmpeg("ffmpeg", [
+      "-y",
+      ...filterThreadArgs(),
+      ...enc.input,
+      "-i",
+      inputPath,
       "-filter_complex",
-      filterComplex,
+      filter + enc.filterSuffix,
       "-map",
-      "[outv]",
-      "-c:v",
-      "libx264",
-      "-preset",
-      preset,
-      "-crf",
-      "18",
-      "-pix_fmt",
-      "yuv420p",
-      "-an",
+      enc.videoLabel,
+      "-map",
+      "[outa]",
+      ...enc.output,
+      "-c:a",
+      "aac",
+      "-movflags",
+      "+faststart",
       outputPath
-    ],
-    "ffmpeg concat video failed"
-  );
+    ]);
+    proc.stderr.resume();
+    proc.on("error", () => resolve3(false));
+    proc.on("close", (code) => resolve3(code === 0));
+  });
+  return { ok, factor, reachedTarget: needed <= maxFactor };
 }
-var init_media = __esm({
-  "src/lib/ffmpeg/media.ts"() {
+var SPEECH_GUARD_SECS, BLACK_KEEP_SECS, FROZEN_MAX_SECS, EMPTY_SPAN_SPEED, MAX_STRETCH, MIN_EFFECTIVE_SPEED, MIN_KEEP_SECS, MIN_RETIME_SPAN, FIT_UNDERSHOOT_SECS;
+var init_silence = __esm({
+  "src/lib/ffmpeg/silence.ts"() {
     "use strict";
+    init_hwaccel();
     init_spawn();
+    SPEECH_GUARD_SECS = 0.12;
+    BLACK_KEEP_SECS = 0.12;
+    FROZEN_MAX_SECS = 0.6;
+    EMPTY_SPAN_SPEED = 5;
+    MAX_STRETCH = 2.5;
+    MIN_EFFECTIVE_SPEED = 1.3;
+    MIN_KEEP_SECS = 0.3;
+    MIN_RETIME_SPAN = 0.2;
+    FIT_UNDERSHOOT_SECS = 0.35;
   }
 });
 
 // src/lib/ffmpeg/splice.ts
-function spliceVideos(opts) {
+function coverFilterChain(inputIdx, width, height) {
+  const bg = `cov${inputIdx}bg`;
+  const fg = `cov${inputIdx}fg`;
+  return `split=2[${bg}][${fg}];[${bg}]scale=${width}:${height}:force_original_aspect_ratio=increase,crop=${width}:${height},scale=${COVER_WASH_W}:${COVER_WASH_H},scale=${width}:${height},gblur=sigma=${COVER_BLUR_SIGMA},eq=brightness=-0.12:saturation=0.75[${bg}b];[${fg}]scale=${width}:${height}:force_original_aspect_ratio=decrease[${fg}s];[${bg}b][${fg}s]overlay=(W-w)/2:(H-h)/2`;
+}
+async function spliceVideos(opts) {
+  const { inputPath, outputPath, overlays, width, height, preset } = opts;
+  if (overlays.length === 0) {
+    return runFFmpeg(["-y", "-i", inputPath, "-c", "copy", outputPath], "ffmpeg copy failed");
+  }
+  const audioPresent = await Promise.all(
+    overlays.map((o) => o.still ? Promise.resolve(false) : hasAudioStream(o.path))
+  );
   return new Promise((resolve3, reject) => {
-    const { inputPath, outputPath, overlays, width, height, preset } = opts;
-    if (overlays.length === 0) {
-      runFFmpeg(["-y", "-i", inputPath, "-c", "copy", outputPath], "ffmpeg copy failed").then(resolve3, reject);
-      return;
-    }
     const args = ["-y", "-i", inputPath];
     for (const overlay of overlays) {
+      if (overlay.still) {
+        args.push("-loop", "1", "-framerate", String(STILL_FRAMERATE), "-t", overlay.duration.toFixed(3));
+      }
       args.push("-i", overlay.path);
     }
     const filterParts = [];
@@ -490,13 +1480,18 @@ function spliceVideos(opts) {
         }
       }
       if (overlay.mode === "stretch") {
-        filters.push(`scale=${width}:${height}:force_original_aspect_ratio=increase`);
+        filters.push(`scale=${width}:-2`);
+        filters.push(`pad=${width}:max(ih\\,${height}):0:(oh-ih)/2:color=#1a1a2e`);
         filters.push(`crop=${width}:${height}`);
+      } else if (overlay.mode === "cover") {
+        filters.push(coverFilterChain(inputIdx, width, height));
       } else {
-        filters.push(`scale=${width}:${height}:force_original_aspect_ratio=decrease`);
+        filters.push(
+          `scale=${Math.round(width * 0.9)}:${Math.round(height * 0.9)}:force_original_aspect_ratio=decrease`
+        );
         filters.push(`pad=${width}:${height}:(ow-iw)/2:(oh-ih)/2:color=#1a1a2e`);
       }
-      filters.push("setpts=PTS-STARTPTS");
+      filters.push(`setpts=PTS-STARTPTS+${overlay.startTime.toFixed(3)}/TB`);
       filterParts.push(`[${inputIdx}:v]${filters.join(",")}[v${inputIdx}]`);
       const nextStream = i === overlays.length - 1 ? "outv" : `tmp${i}`;
       filterParts.push(
@@ -504,19 +1499,39 @@ function spliceVideos(opts) {
       );
       currentStream = nextStream;
     }
+    const clipAudio = overlays.map((overlay, i) => ({ overlay, inputIdx: i + 1 })).filter(({ inputIdx }) => audioPresent[inputIdx - 1]);
+    for (const { overlay, inputIdx } of clipAudio) {
+      const delayMs = Math.round(overlay.startTime * 1e3);
+      filterParts.push(
+        `[${inputIdx}:a]atrim=0:${overlay.duration.toFixed(3)},asetpts=PTS-STARTPTS,adelay=${delayMs}|${delayMs},volume=${CLIP_AUDIO_GAIN}[a${inputIdx}]`
+      );
+    }
+    if (clipAudio.length === 1) {
+      filterParts.push(`[a${clipAudio[0].inputIdx}]anull[outa]`);
+    } else if (clipAudio.length > 1) {
+      const labels = clipAudio.map(({ inputIdx }) => `[a${inputIdx}]`).join("");
+      filterParts.push(`${labels}amix=inputs=${clipAudio.length}:normalize=0:dropout_transition=0[outa]`);
+    }
     args.push("-filter_complex", filterParts.join(";"));
     args.push("-map", "[outv]");
-    args.push("-map", "0:a?");
+    if (clipAudio.length > 0) args.push("-map", "[outa]");
     args.push("-c:v", "libx264", "-preset", preset, "-crf", "18", "-pix_fmt", "yuv420p");
-    args.push("-c:a", "copy");
+    if (clipAudio.length > 0) args.push("-c:a", "aac");
     args.push(outputPath);
     runFFmpeg(args, "ffmpeg splice failed").then(resolve3, reject);
   });
 }
+var CLIP_AUDIO_GAIN, STILL_FRAMERATE, COVER_WASH_W, COVER_WASH_H, COVER_BLUR_SIGMA;
 var init_splice = __esm({
   "src/lib/ffmpeg/splice.ts"() {
     "use strict";
+    init_media();
     init_spawn();
+    CLIP_AUDIO_GAIN = 0.55;
+    STILL_FRAMERATE = 30;
+    COVER_WASH_W = 6;
+    COVER_WASH_H = 10;
+    COVER_BLUR_SIGMA = 40;
   }
 });
 
@@ -613,7 +1628,9 @@ var init_ffmpeg = __esm({
     "use strict";
     init_compose();
     init_compress();
+    init_gif();
     init_media();
+    init_silence();
     init_splice();
     init_transitions();
     init_types();
@@ -630,8 +1647,8 @@ var init_ffmpeg2 = __esm({
 
 // src/lib/tts/helpers.ts
 import { existsSync } from "fs";
-import { readFile, unlink, writeFile } from "fs/promises";
-import { isAbsolute, join, resolve } from "path";
+import { readFile, unlink as unlink2, writeFile } from "fs/promises";
+import { isAbsolute, join as join2, resolve } from "path";
 function toWSLPathForTTS(path) {
   return windowsDrivePathToWsl(path) ?? path;
 }
@@ -684,7 +1701,7 @@ async function getMediaStepDuration(step, baseDir) {
   }
 }
 async function loadVoiceoverMeta(outputDir) {
-  const metaPath = join(outputDir, "voiceover.json");
+  const metaPath = join2(outputDir, "voiceover.json");
   try {
     if (!existsSync(metaPath)) return null;
     const content = await readFile(metaPath, "utf-8");
@@ -694,7 +1711,7 @@ async function loadVoiceoverMeta(outputDir) {
   }
 }
 async function saveVoiceoverMeta(outputDir, meta) {
-  const metaPath = join(outputDir, "voiceover.json");
+  const metaPath = join2(outputDir, "voiceover.json");
   await writeFile(metaPath, JSON.stringify(meta, null, 2));
 }
 async function concatenateAudio(inputs, output, workDir) {
@@ -703,19 +1720,21 @@ async function concatenateAudio(inputs, output, workDir) {
     return isWindows ? windowsDrivePathToWsl(resolved) ?? resolved : resolved;
   };
   const listContent = inputs.map((f) => `file '${formatPath(f)}'`).join("\n");
-  const listPath = join(workDir, "concat.txt");
+  const listPath = join2(workDir, "concat.txt");
   await writeFile(listPath, listContent);
   await concatMedia(listPath, output);
-  await unlink(listPath).catch(() => {
+  await unlink2(listPath).catch(() => {
   });
 }
-var isWindows;
+var isWindows, NARRATION_LEAD_IN_MS, LEAD_IN_CLIP;
 var init_helpers = __esm({
   "src/lib/tts/helpers.ts"() {
     "use strict";
     init_ffmpeg2();
     init_utils();
     isWindows = process.platform === "win32";
+    NARRATION_LEAD_IN_MS = 300;
+    LEAD_IN_CLIP = "lead-in.mp3";
   }
 });
 
@@ -723,10 +1742,12 @@ var init_helpers = __esm({
 var timing_exports = {};
 __export(timing_exports, {
   alignVoiceoverToRecording: () => alignVoiceoverToRecording,
-  estimateWordTimings: () => estimateWordTimings
+  alignWordsToCaption: () => alignWordsToCaption,
+  estimateWordTimings: () => estimateWordTimings,
+  spokenWordTimings: () => spokenWordTimings
 });
 import { existsSync as existsSync2 } from "fs";
-import { join as join2 } from "path";
+import { join as join3 } from "path";
 function estimateWordTimings(caption, duration) {
   const words = caption.split(/\s+/).filter((w) => w.length > 0);
   const wordDuration = duration / words.length;
@@ -736,6 +1757,36 @@ function estimateWordTimings(caption, duration) {
     end: Math.round((i + 1) * wordDuration)
   }));
 }
+function alignWordsToCaption(caption, spoken) {
+  const captionWords = caption.split(/\s+/).filter((w) => w.length > 0);
+  if (captionWords.length === 0 || spoken.length === 0) return [];
+  if (spoken.length === captionWords.length) {
+    return captionWords.map((word, i) => ({
+      word,
+      start: Math.round(spoken[i].start),
+      end: Math.round(spoken[i].end)
+    }));
+  }
+  const speechStart = spoken[0].start;
+  const speechEnd = spoken[spoken.length - 1].end;
+  const wordDuration = (speechEnd - speechStart) / captionWords.length;
+  return captionWords.map((word, i) => ({
+    word,
+    start: Math.round(speechStart + i * wordDuration),
+    end: Math.round(speechStart + (i + 1) * wordDuration)
+  }));
+}
+function spokenWordTimings(caption, spoken) {
+  if (!spoken || spoken.length === 0) return null;
+  const leadTrim = spoken[0].start;
+  const rebased = spoken.map((w) => ({
+    word: w.word,
+    start: Math.max(0, w.start - leadTrim),
+    end: Math.max(0, w.end - leadTrim)
+  }));
+  const aligned = alignWordsToCaption(caption, rebased);
+  return aligned.length > 0 ? aligned : null;
+}
 async function alignVoiceoverToRecording(stepAudio, actualRecordingDurations, workDir, outputDir) {
   let needsRealignment = false;
   for (let i = 0; i < actualRecordingDurations.length; i++) {
@@ -750,31 +1801,35 @@ async function alignVoiceoverToRecording(stepAudio, actualRecordingDurations, wo
   if (!needsRealignment) {
     return stepAudio;
   }
-  const audioDir = join2(workDir, "audio");
+  const audioDir = join3(workDir, "audio");
   const segments = [];
   const alignedStepAudio = /* @__PURE__ */ new Map();
+  const leadInPath = join3(audioDir, LEAD_IN_CLIP);
+  const leadIn = existsSync2(leadInPath) ? NARRATION_LEAD_IN_MS : 0;
+  if (leadIn) segments.push(leadInPath);
   for (let i = 0; i < actualRecordingDurations.length; i++) {
     const stepNum = i + 1;
     const voiceData = stepAudio.get(stepNum);
     const voiceDuration = voiceData?.duration ?? 0;
     const recordingDuration = actualRecordingDurations[i] ?? 0;
     const targetDuration = Math.max(voiceDuration, recordingDuration);
-    const audioPath = join2(audioDir, `step-${stepNum}.mp3`);
-    const originalPaddingPath = join2(audioDir, `step-${stepNum}-padding.mp3`);
-    const silencePath = join2(audioDir, `step-${stepNum}-silence.mp3`);
+    const audioPath = join3(audioDir, `step-${stepNum}.mp3`);
+    const originalPaddingPath = join3(audioDir, `step-${stepNum}-padding.mp3`);
+    const silencePath = join3(audioDir, `step-${stepNum}-silence.mp3`);
     if (existsSync2(audioPath)) {
       segments.push(audioPath);
       if (existsSync2(originalPaddingPath)) {
         segments.push(originalPaddingPath);
       }
       if (recordingDuration > voiceDuration) {
-        const alignPaddingPath = join2(audioDir, `step-${stepNum}-align-padding.mp3`);
+        const alignPaddingPath = join3(audioDir, `step-${stepNum}-align-padding.mp3`);
         await generateSilence(alignPaddingPath, recordingDuration - voiceDuration);
         segments.push(alignPaddingPath);
       }
     } else if (existsSync2(silencePath)) {
-      if (targetDuration !== voiceDuration) {
-        await generateSilence(silencePath, targetDuration);
+      const own = targetDuration - (stepNum === 1 ? leadIn : 0);
+      if (targetDuration !== voiceDuration && own > 0) {
+        await generateSilence(silencePath, own);
       }
       segments.push(silencePath);
     }
@@ -783,10 +1838,14 @@ async function alignVoiceoverToRecording(stepAudio, actualRecordingDurations, wo
       words: voiceData?.words ?? []
     });
   }
-  if (segments.length > 0) {
-    const voiceoverPath = join2(outputDir, "voiceover.wav");
-    await concatenateAudio(segments, voiceoverPath, workDir);
+  if (segments.length === 0) {
+    console.log(
+      `   No per-step audio in ${audioDir}: keeping the narration's own timeline, so the captions still follow the voice.`
+    );
+    return stepAudio;
   }
+  const voiceoverPath = join3(outputDir, "voiceover.wav");
+  await concatenateAudio(segments, voiceoverPath, workDir);
   const existingMeta = await loadVoiceoverMeta(outputDir);
   if (existingMeta) {
     existingMeta.stepDurations = Object.fromEntries(
@@ -806,6 +1865,7 @@ var init_timing = __esm({
 
 // src/lib/api-client.ts
 init_utils();
+var PLAN_MAX_TOKENS = 1500;
 var SERVER_BACKOFF_MS = [2e3, 4e3];
 var CLI_BACKOFF_MS = [1e4, 3e4];
 var SPARK_AI_BASE = "https://sparkbrain.app";
@@ -885,7 +1945,7 @@ async function getOrRefreshRelayToken(email) {
   }
 }
 async function executeChat(chatUrl, bearerToken, systemPrompt, userPrompt, tier, opts = {}) {
-  const { onRetry, backoffMs = SERVER_BACKOFF_MS } = opts;
+  const { onRetry, backoffMs = SERVER_BACKOFF_MS, maxTokens } = opts;
   let lastRetriableError = null;
   const host = hostOf(chatUrl);
   for (let attempt = 1; attempt <= 3; attempt++) {
@@ -900,7 +1960,11 @@ async function executeChat(chatUrl, bearerToken, systemPrompt, userPrompt, tier,
           messages: [
             { role: "system", content: systemPrompt },
             { role: "user", content: userPrompt }
-          ]
+          ],
+          // Explicit numeric test, not truthiness: a 0 or negative budget is a
+          // caller bug, and silently falling back to the tiny backend default
+          // reproduces exactly the failure this option exists to prevent.
+          ...typeof maxTokens === "number" && maxTokens > 0 ? { max_tokens: Math.floor(maxTokens) } : {}
         })
       });
       const bodyText = await response.text().catch(() => "");
@@ -1039,26 +2103,23 @@ var APP_ID = process.env.SPARK_APP_ID ?? "quickpeek";
 var OWNER_SLUG = process.env.SPARK_OWNER_SLUG ?? "spark";
 var BASE = "https://sparkpay.dev";
 var TIERS = {
-  price_1TADnPEf9opkuWid9NtqOYON: "pro",
-  price_1TADnPEf9opkuWidgbvvX9ma: "pro",
+  // Essentials
+  price_1TCREmEf9opkuWidvhuqzqDM: "pro",
+  // live monthly
+  price_1TCREmEf9opkuWidacf1tiC7: "pro",
+  // live yearly
   price_1TADm7Ef9opkuWid3I9tquIB: "pro",
+  // test monthly
   price_1TADm8Ef9opkuWid1RSA2wCa: "pro",
-  price_1TCREmEf9opkuWidvhuqzqDM: "pro",
-  price_1TCREmEf9opkuWidacf1tiC7: "pro"
-};
-var RANK = {
-  free: 0,
-  pro: 1
-};
-var FEATURES = {
-  free: [],
-  pro: [
-    "Everything in Free",
-    "No watermark",
-    "Full video composition (voiceover + captions + music + transitions)",
-    "Unlimited videos",
-    "Priority support"
-  ]
+  // test yearly
+  // Elite. These were missing entirely, so an Elite subscriber fell through
+  // the `?? 'pro'` fallback below and got Essentials limits for $29.
+  price_1TrHz8Ef9opkuWid6lh2opD8: "elite",
+  // live monthly
+  price_1TrHz9Ef9opkuWid1qS26iMu: "elite",
+  // live yearly
+  price_1TGPCREf9opkuWidR0iJeJNe: "elite"
+  // test monthly
 };
 async function _fetch(email, init) {
   const r = await fetch(
@@ -1083,7 +2144,6 @@ function getTier(d) {
   return TIERS[d.subscription.price_id] ?? "pro";
 }
 var isPaid = (d) => getTier(d) !== "free";
-var hasAccess = (d, min) => (RANK[getTier(d)] ?? 0) >= (RANK[min] ?? 0);
 var hasTrialRemaining = (d) => isPaid(d) || !!d.trial && !d.trial.is_expired && d.trial.uses_remaining > 0;
 var showPaywall = (d) => !isPaid(d) && !hasTrialRemaining(d);
 var isCanceling = (d) => !!d.subscription && d.subscription.cancel_at_period_end && d.subscription.status !== "canceled";
@@ -1109,21 +2169,26 @@ function pricingUrl(opts) {
 }
 
 // src/lib/billing.ts
-function shouldWatermark(tier, videoDurationSeconds) {
-  return tier === "free" && videoDurationSeconds > 20;
-}
 function getUpgradeUrl(userEmail) {
   return pricingUrl(userEmail ? { email: userEmail } : void 0);
 }
 
 // src/lib/config.ts
-var VERSION = "1.2.3";
+var VERSION = "1.2.5";
 var CONFIG_FILE = "quickpeek.config.json";
+var SIZE_PRESETS = {
+  wide: { width: 1920, height: 1080, zoom: 1 },
+  short: { width: 1080, height: 1920, zoom: 2 }
+};
+var RATE_FACTOR = { slow: 0.8, normal: 1, fast: 1.25 };
+var NO_CLIP_OUTRO = "@card-step";
 var DEFAULT_CONFIG = {
   plan: { maxSteps: 8 },
   video: {
-    width: 1080,
-    height: 1920,
+    size: "short",
+    width: SIZE_PRESETS.short.width,
+    height: SIZE_PRESETS.short.height,
+    zoom: SIZE_PRESETS.short.zoom,
     format: "mp4",
     preset: "fast",
     quality: 0.5,
@@ -1136,20 +2201,71 @@ var DEFAULT_CONFIG = {
     // ms
     transitions: "none",
     contrast: 0.25,
+    // The recording plays at the pace it was filmed at. A tempo above 1 is
+    // multiplied by the narration speed in VIDEO_PROFILES and by the fit
+    // pass's squeeze, and the three together read as frantic rather than
+    // brisk. Speed belongs in one place, so it lives in audioSpeed; set a
+    // tempo in quickpeek.config.json to push the picture on top of that.
     tempo: 1,
     stepDelay: 200
     // ms delay between steps
   },
-  audio: { format: "mp3", bitrate: "192k" },
+  audio: { gender: "female", rate: "normal", format: "mp3", bitrate: "192k" },
   timing: { minStepDuration: 1500 },
   output: { dir: "./demo" }
 };
+var VIDEO_PROFILES = {
+  // preset 'veryfast' over 'fast': measured ~20s faster on a 77s 1080p
+  // compose, with identical duration and audio and no visible difference at
+  // these bitrates - the encode is pure wall-clock tax on every run.
+  wide: {
+    video: { width: 1920, height: 1080, zoom: 1.5, fitLimitSecs: 0, maxSpeedup: 1, preset: "veryfast" },
+    // A tutorial is watched to learn something, so the narrator is allowed to
+    // be brisk but never hurried.
+    audioSpeed: 1.15
+  },
+  short: {
+    // fadeOut 0: the video ends on a card the viewer is meant to read,
+    // and a fade takes it away mid-sentence.
+    video: { width: 1080, height: 1920, zoom: 3, fitLimitSecs: 60, maxSpeedup: 1.7, preset: "veryfast", fadeOut: 0 },
+    // 1.8 was unwatchable: stacked on tempo 1.2 and the outro speedup it ran
+    // the voice at better than twice its natural rate. A short wants energy,
+    // which is the voice and the cutting, not the tape running fast.
+    audioSpeed: 1,
+    // A short lives or dies on energy. Ava is the warmest, most animated of
+    // the free neural voices; Sonia reads a short like the shipping forecast.
+    voice: "en-US-AvaMultilingualNeural"
+  }
+};
+function applyProfile(config, profile) {
+  const preset = VIDEO_PROFILES[profile];
+  return {
+    ...config,
+    profile,
+    video: { ...config.video, ...preset.video },
+    audio: {
+      format: "mp3",
+      bitrate: "192k",
+      ...config.audio,
+      // outroOnly is on unless turned off, matching the video phase. The
+      // speedup buys the song its window, so it applies to the profile's own
+      // pace only: a speed somebody set by hand is the speed they wanted.
+      speed: config.audio?.speed ?? preset.audioSpeed * (config.music?.outroOnly !== false ? OUTRO_SONG_SPEEDUP : 1),
+      ...config.audio?.voice || !preset.voice ? {} : { voice: preset.voice }
+    }
+  };
+}
+var OUTRO_SONG_SPEEDUP = 1.13;
 var DEFAULT_CAPTIONS = {
   font: "Arial",
   outline: "#000000",
   outlineWidth: 3,
   shadow: 2,
   marginBottom: 80,
+  // The IG/TikTok look is what a demo short is for; karaoke remains available
+  // by name for anyone who wants the sweep instead.
+  preset: "shorts",
+  position: "bottom",
   regular: {
     color: "#FFFFFF",
     size: 56,
@@ -1159,8 +2275,41 @@ var DEFAULT_CAPTIONS = {
     color: "#FFFF00",
     size: 64,
     bold: true
-  }
+  },
+  maxChars: 28
 };
+function defaultCaptionsFor(width, height) {
+  const portrait = height > width;
+  if (!portrait) {
+    return {
+      ...DEFAULT_CAPTIONS,
+      preset: "karaoke",
+      position: "bottom",
+      marginBottom: Math.round(height * 0.083),
+      regular: { color: "#FFFFFF", size: Math.round(width * 0.033), bold: true },
+      highlight: { color: "#FFE100", size: Math.round(width * 0.036), bold: true },
+      outlineWidth: 4,
+      shadow: 2,
+      maxChars: 34
+    };
+  }
+  const size = Math.round(width * 0.104);
+  return {
+    ...DEFAULT_CAPTIONS,
+    // The whole line stays up and the spoken word recolours: the social-video
+    // convention, and the one that survives being watched muted.
+    preset: "hormozi",
+    position: "bottom",
+    marginBottom: Math.round(height * 0.156),
+    // Equal sizes on purpose. A larger highlight reflows the line every time
+    // the spoken word moves, which on a full-line preset is a visible twitch.
+    regular: { color: "#FFFFFF", size, bold: true },
+    highlight: { color: "#FFE100", size, bold: true },
+    outlineWidth: 8,
+    shadow: 5,
+    maxChars: 20
+  };
+}
 
 // src/lib/crawl.ts
 import { chromium } from "playwright";
@@ -1262,9 +2411,81 @@ function shouldSkipLink(text, href, currentPath) {
 }
 
 // src/lib/crawl.ts
+var SETTLE_POLL_MS = 400;
+var SETTLE_STABLE_POLLS = 2;
+var SETTLE_CAP_MS = 2e4;
+async function waitForDomStable(page, cap = SETTLE_CAP_MS) {
+  const deadline = Date.now() + cap;
+  let previous = -1;
+  let unchanged = 0;
+  while (Date.now() < deadline) {
+    const count = await page.evaluate(() => document.getElementsByTagName("*").length).catch(() => -1);
+    if (count < 0) return;
+    if (count === previous) {
+      if (++unchanged >= SETTLE_STABLE_POLLS) return;
+    } else {
+      unchanged = 0;
+      previous = count;
+    }
+    await page.waitForTimeout(SETTLE_POLL_MS);
+  }
+}
+var PLACEHOLDER_POLL_MS = 250;
+var PLACEHOLDER_CAP_MS = 8e3;
+var PLACEHOLDER_STATIC_POLLS = 4;
+var PLACEHOLDER_CLEAR_POLLS = 3;
+var PLACEHOLDER_SELECTOR = [
+  '[aria-busy="true"]',
+  '[role="progressbar"]',
+  '[data-loading="true"]',
+  '[class*="skeleton" i]',
+  '[class*="animate-pulse" i]',
+  '[class*="spinner" i]'
+].join(",");
+async function waitForPlaceholdersGone(page, cap = PLACEHOLDER_CAP_MS) {
+  const deadline = Date.now() + cap;
+  let previous = -1;
+  let unchanged = 0;
+  let clear = 0;
+  while (Date.now() < deadline) {
+    const count = await page.evaluate((selector) => {
+      let visible = 0;
+      for (const el of Array.from(document.querySelectorAll(selector))) {
+        const rect = el.getBoundingClientRect();
+        if (rect.width > 0 && rect.height > 0) visible++;
+      }
+      return visible;
+    }, PLACEHOLDER_SELECTOR).catch(() => 0);
+    if (count === 0) {
+      if (++clear >= PLACEHOLDER_CLEAR_POLLS) return;
+      await page.waitForTimeout(PLACEHOLDER_POLL_MS);
+      continue;
+    }
+    clear = 0;
+    if (count === previous) {
+      if (++unchanged >= PLACEHOLDER_STATIC_POLLS) return;
+    } else {
+      unchanged = 0;
+      previous = count;
+    }
+    await page.waitForTimeout(PLACEHOLDER_POLL_MS);
+  }
+}
+async function gotoSettled(page, url, timeout = 3e4) {
+  await page.goto(url, { waitUntil: "domcontentloaded", timeout });
+  await page.waitForLoadState("networkidle", { timeout: 2500 }).catch(() => {
+  });
+  await waitForDomStable(page).catch(() => {
+  });
+  await waitForPlaceholdersGone(page).catch(() => {
+  });
+}
 function idSelector(id) {
   return /^[A-Za-z_-][\w-]*$/.test(id) ? `#${id}` : `[id="${id.replace(/(["\\])/g, "\\$1")}"]`;
 }
+function ariaLabelSelector(label) {
+  return `[aria-label="${label.replace(/(["\\])/g, "\\$1")}"]`;
+}
 function getActionForType(type) {
   switch (type) {
     case "button":
@@ -1282,169 +2503,228 @@ function getActionForType(type) {
       return "type";
   }
 }
+async function sitemapRoutes(pageUrl) {
+  let origin;
+  try {
+    origin = new URL(pageUrl).origin;
+  } catch {
+    return [];
+  }
+  try {
+    const res = await fetch(`${origin}/sitemap.xml`, { signal: AbortSignal.timeout(4e3) });
+    if (!res.ok) return [];
+    const xml = await res.text();
+    const seen = /* @__PURE__ */ new Set();
+    const routes = [];
+    for (const m of xml.matchAll(/<loc>([^<]+)<\/loc>/g)) {
+      const raw = (m[1] ?? "").trim();
+      let u;
+      try {
+        u = new URL(raw);
+      } catch {
+        continue;
+      }
+      if (u.origin !== origin) continue;
+      if (/\.(txt|xml|json|png|jpg|svg|ico|pdf)$/i.test(u.pathname)) continue;
+      const path = u.pathname.replace(/\/+$/, "");
+      if (!path || seen.has(u.href)) continue;
+      seen.add(u.href);
+      routes.push({ text: path.slice(1), href: u.href });
+      if (routes.length >= 20) break;
+    }
+    return routes;
+  } catch {
+    return [];
+  }
+}
 var noopTask = () => ({ succeed: () => {
 } });
 var CRAWL_CACHE_TTL_MS = 5 * 60 * 1e3;
 var CRAWL_CACHE_MAX_ENTRIES = 50;
 var crawlCache = /* @__PURE__ */ new Map();
 async function crawlPage(url, task = noopTask, storageStatePath, viewport) {
-  const cacheKey = viewport ? `${url}@${viewport.width}x${viewport.height}` : url;
-  const cached = crawlCache.get(cacheKey);
+  const cacheKey2 = viewport ? `${url}@${viewport.width}x${viewport.height}` : url;
+  const cached = crawlCache.get(cacheKey2);
   if (cached && Date.now() - cached.timestamp < CRAWL_CACHE_TTL_MS) {
     task("Using cached crawl").succeed(`Found ${cached.elements.length} interactive elements (cached)`);
     return { title: cached.title, elements: [...cached.elements], scrollable: cached.scrollable };
   }
   const browserTask = task("Launching browser");
   const browser = await chromium.launch({ headless: true });
-  const context = await browser.newContext({
-    ...storageStatePath ? { storageState: storageStatePath } : {},
-    // Crawl at the size we will record at, or the measurements below describe
-    // a page nobody will ever see.
-    ...viewport ? { viewport } : {}
-  });
-  const page = await context.newPage();
-  browserTask.succeed(storageStatePath ? "Browser launched (signed in)" : "Browser launched");
-  const crawlTask = task("Crawling page");
-  await page.goto(url, { waitUntil: "networkidle", timeout: 3e4 });
-  const title = await page.title();
-  const scrollable = await page.evaluate(
-    "Math.max(0, document.documentElement.scrollHeight - window.innerHeight)"
-  );
-  const rawElements = await page.evaluate(`
-    (() => {
-      const items = [];
-
-      // Helper to get parent context
-      const getCtx = (el) => {
-        let p = el.parentElement;
-        while (p && p !== document.body) {
-          if (p.id) return '#' + p.id;
-          const cls = Array.from(p.classList).find(c =>
-            /toolbar|header|footer|sidebar|panel|modal|dialog|nav|menu|controls|actions/i.test(c)
-          );
-          if (cls) return '.' + cls;
-          if (['header', 'footer', 'nav', 'main', 'aside', 'form'].includes(p.tagName.toLowerCase())) {
-            return p.tagName.toLowerCase();
+  try {
+    const context = await browser.newContext({
+      ...storageStatePath ? { storageState: storageStatePath } : {},
+      // Crawl at the size we will record at, or the measurements below describe
+      // a page nobody will ever see.
+      ...viewport ? { viewport } : {}
+    });
+    const page = await context.newPage();
+    browserTask.succeed(storageStatePath ? "Browser launched (signed in)" : "Browser launched");
+    const crawlTask = task("Crawling page");
+    await gotoSettled(page, url, 3e4);
+    const title = await page.title();
+    const scrollable = await page.evaluate(
+      "Math.max(0, document.documentElement.scrollHeight - window.innerHeight)"
+    );
+    const rawElements = await page.evaluate(`
+      (() => {
+        const items = [];
+
+        // Helper to get parent context
+        const getCtx = (el) => {
+          let p = el.parentElement;
+          while (p && p !== document.body) {
+            if (p.id) return '#' + p.id;
+            const cls = Array.from(p.classList).find(c =>
+              /toolbar|header|footer|sidebar|panel|modal|dialog|nav|menu|controls|actions/i.test(c)
+            );
+            if (cls) return '.' + cls;
+            if (['header', 'footer', 'nav', 'main', 'aside', 'form'].includes(p.tagName.toLowerCase())) {
+              return p.tagName.toLowerCase();
+            }
+            p = p.parentElement;
           }
-          p = p.parentElement;
-        }
-        return '';
-      };
+          return '';
+        };
 
-      // Buttons (use textContent to catch hidden elements too)
-      document.querySelectorAll('button, [role="button"]').forEach(el => {
-        const text = (el.textContent || el.innerText || '').trim().replace(/\\s+/g, ' ').slice(0, 40);
-        const testId = el.getAttribute('data-testid');
-        const ariaLabel = el.getAttribute('aria-label');
-        if (!text && !testId && !ariaLabel) return;
-        items.push({ type: 'button', text: text || ariaLabel || testId, testId, ctx: getCtx(el) });
-      });
+        // Buttons (use textContent to catch hidden elements too)
+        document.querySelectorAll('button, [role="button"]').forEach(el => {
+          const text = (el.textContent || el.innerText || '').trim().replace(/\\s+/g, ' ').slice(0, 40);
+          const testId = el.getAttribute('data-testid');
+          const ariaLabel = el.getAttribute('aria-label');
+          if (!text && !testId && !ariaLabel) return;
+          items.push({ type: 'button', text: text || ariaLabel || testId, testId, ctx: getCtx(el) });
+        });
 
-      // Inputs (including file inputs, range sliders, checkboxes, selects)
-      document.querySelectorAll('input, textarea, select').forEach(el => {
-        if (el.type === 'hidden') return;
-        const testId = el.getAttribute('data-testid');
-        const inputType = el.type || 'text';
-
-        // Get label text for any input type
-        let labelText = '';
-        if (el.labels?.[0]) {
-          labelText = el.labels[0].textContent?.trim() || '';
-        } else if (el.id) {
-          const label = document.querySelector('label[for="' + el.id + '"]');
-          if (label) labelText = label.textContent?.trim() || '';
-        }
+        // Inputs (including file inputs, range sliders, checkboxes, selects)
+        document.querySelectorAll('input, textarea, select').forEach(el => {
+          if (el.type === 'hidden') return;
+          const testId = el.getAttribute('data-testid');
+          const inputType = el.type || 'text';
+
+          // Get label text for any input type
+          let labelText = '';
+          if (el.labels?.[0]) {
+            labelText = el.labels[0].textContent?.trim() || '';
+          } else if (el.id) {
+            const label = document.querySelector('label[for="' + el.id + '"]');
+            if (label) labelText = label.textContent?.trim() || '';
+          }
 
-        const text = labelText || el.placeholder || el.name || el.id || '';
+          const text = labelText || el.placeholder || el.name || el.id || '';
 
-        // Include file, range, and checkbox inputs even without text
-        const alwaysInclude = ['file', 'range', 'checkbox'].includes(inputType);
-        if (!text && !testId && !alwaysInclude) return;
+          // Include file, range, and checkbox inputs even without text
+          const alwaysInclude = ['file', 'range', 'checkbox'].includes(inputType);
+          if (!text && !testId && !alwaysInclude) return;
 
-        items.push({
-          type: inputType,
-          text: text || (inputType === 'file' ? 'file upload' : inputType === 'range' ? 'slider' : inputType === 'checkbox' ? 'checkbox' : testId),
-          testId,
-          id: el.id,
-          name: el.name,
-          placeholder: el.placeholder,
-          isFile: inputType === 'file'
+          items.push({
+            type: inputType,
+            text: text || (inputType === 'file' ? 'file upload' : inputType === 'range' ? 'slider' : inputType === 'checkbox' ? 'checkbox' : testId),
+            testId,
+            id: el.id,
+            name: el.name,
+            placeholder: el.placeholder,
+            isFile: inputType === 'file'
+          });
         });
-      });
 
-      // Links (use textContent to catch hidden elements too)
-      document.querySelectorAll('a[href]').forEach(el => {
-        const text = (el.textContent || el.innerText || '').trim().replace(/\\s+/g, ' ').slice(0, 40);
-        if (text && text.length >= 2) items.push({ type: 'link', text });
-      });
+        // Links (use textContent to catch hidden elements too)
+        document.querySelectorAll('a[href]').forEach(el => {
+          const text = (el.textContent || el.innerText || '').trim().replace(/\\s+/g, ' ').slice(0, 40);
+          if (!text || text.length < 2) return;
+          // Keep the destination, not just the label. Without it the planner
+          // can name a page in a caption but has no way to go there, so every
+          // line gets forced onto whatever is already on screen.
+          let href = '';
+          try {
+            const u = new URL(el.getAttribute('href') || '', location.href);
+            if (u.origin === location.origin) href = u.href;
+          } catch { /* a javascript: or mailto: href is not somewhere to go */ }
+          items.push({ type: 'link', text, href });
+        });
 
-      return items.slice(0, 40);
-    })()
-  `);
-  const filteredElements = rawElements.filter((el) => {
-    if (!el.text) return true;
-    const text = el.text.toLowerCase().trim();
-    return !EXCLUDED_LINK_PATTERNS.some((pattern) => text.includes(pattern));
-  });
-  const btnTexts = {};
-  for (const el of filteredElements) {
-    if (el.type === "button" && el.text) {
-      btnTexts[el.text] = (btnTexts[el.text] || 0) + 1;
-    }
-  }
-  const elements = filteredElements.map((el) => {
-    let selector;
-    if (el.testId) {
-      selector = `[data-testid="${el.testId}"]`;
-    } else if (el.isFile || el.type === "file") {
-      selector = 'input[type="file"]';
-    } else if (el.type === "range") {
-      selector = el.id ? idSelector(el.id) : 'input[type="range"]';
-    } else if (el.type === "checkbox") {
-      selector = el.id ? idSelector(el.id) : 'input[type="checkbox"]';
-    } else if (el.type === "button") {
-      if (btnTexts[el.text] === 1) {
+        return items.slice(0, 40);
+      })()
+    `);
+    const filteredElements = rawElements.filter((el) => {
+      if (!el.text) return true;
+      const text = el.text.toLowerCase().trim();
+      return !EXCLUDED_LINK_PATTERNS.some((pattern) => text.includes(pattern));
+    });
+    const btnTexts = {};
+    for (const el of filteredElements) {
+      if (el.type === "button" && el.text) {
+        btnTexts[el.text] = (btnTexts[el.text] || 0) + 1;
+      }
+    }
+    const elements = filteredElements.map((el) => {
+      let selector;
+      if (el.testId) {
+        selector = `[data-testid="${el.testId}"]`;
+      } else if (el.isFile || el.type === "file") {
+        selector = 'input[type="file"]';
+      } else if (el.type === "range") {
+        selector = el.id ? idSelector(el.id) : 'input[type="range"]';
+      } else if (el.type === "checkbox") {
+        selector = el.id ? idSelector(el.id) : 'input[type="checkbox"]';
+      } else if (el.type === "button") {
+        if (btnTexts[el.text] === 1) {
+          selector = `text="${el.text}"`;
+        } else {
+          selector = el.ctx ? `${el.ctx} >> text="${el.text}"` : `button:has-text("${el.text}")`;
+        }
+      } else if (el.type === "link") {
         selector = `text="${el.text}"`;
+      } else if (el.id) {
+        selector = idSelector(el.id);
+      } else if (el.name) {
+        selector = `[name="${el.name}"]`;
+      } else if (el.placeholder) {
+        selector = `[placeholder="${el.placeholder}"]`;
       } else {
-        selector = el.ctx ? `${el.ctx} >> text="${el.text}"` : `button:has-text("${el.text}")`;
+        selector = `text="${el.text}"`;
       }
-    } else if (el.type === "link") {
-      selector = `text="${el.text}"`;
-    } else if (el.id) {
-      selector = idSelector(el.id);
-    } else if (el.name) {
-      selector = `[name="${el.name}"]`;
-    } else if (el.placeholder) {
-      selector = `[placeholder="${el.placeholder}"]`;
-    } else {
-      selector = `text="${el.text}"`;
-    }
-    let normalizedType;
-    if (el.isFile || el.type === "file") {
-      normalizedType = "file";
-    } else if (el.type === "range") {
-      normalizedType = "range";
-    } else if (el.type === "checkbox") {
-      normalizedType = "checkbox";
-    } else if (el.type === "select" || el.type === "select-one" || el.type === "select-multiple") {
-      normalizedType = "select";
-    } else if (el.type === "button" || el.type === "link") {
-      normalizedType = el.type;
-    } else {
-      normalizedType = "input";
+      let normalizedType;
+      if (el.isFile || el.type === "file") {
+        normalizedType = "file";
+      } else if (el.type === "range") {
+        normalizedType = "range";
+      } else if (el.type === "checkbox") {
+        normalizedType = "checkbox";
+      } else if (el.type === "select" || el.type === "select-one" || el.type === "select-multiple") {
+        normalizedType = "select";
+      } else if (el.type === "button" || el.type === "link") {
+        normalizedType = el.type;
+      } else {
+        normalizedType = "input";
+      }
+      const action = getActionForType(normalizedType);
+      const target = normalizedType === "file" ? selector : (el.text || "").toLowerCase();
+      return { type: normalizedType, text: el.text, selector, action, target, href: el.href };
+    });
+    await browser.close();
+    for (const route of await sitemapRoutes(url)) {
+      if (elements.some((e) => e.href === route.href)) continue;
+      elements.push({
+        type: "link",
+        text: route.text,
+        selector: "",
+        action: "click",
+        target: route.text,
+        href: route.href
+      });
     }
-    const action = getActionForType(normalizedType);
-    const target = normalizedType === "file" ? selector : (el.text || "").toLowerCase();
-    return { type: normalizedType, text: el.text, selector, action, target };
-  });
-  await browser.close();
-  crawlTask.succeed(`Found ${elements.length} interactive elements`);
-  crawlCache.set(cacheKey, { timestamp: Date.now(), title, elements: [...elements], scrollable });
-  if (crawlCache.size > CRAWL_CACHE_MAX_ENTRIES) {
-    const oldest = crawlCache.keys().next().value;
-    if (oldest !== void 0) crawlCache.delete(oldest);
+    crawlTask.succeed(`Found ${elements.length} interactive elements`);
+    crawlCache.set(cacheKey2, { timestamp: Date.now(), title, elements: [...elements], scrollable });
+    if (crawlCache.size > CRAWL_CACHE_MAX_ENTRIES) {
+      const oldest = crawlCache.keys().next().value;
+      if (oldest !== void 0) crawlCache.delete(oldest);
+    }
+    return { title, elements, scrollable };
+  } finally {
+    await browser.close().catch(() => {
+    });
   }
-  return { title, elements, scrollable };
 }
 
 // src/lib/cursor.ts
@@ -1557,9 +2837,13 @@ function parseAIJson(content) {
 
 // src/lib/prompts.ts
 init_utils();
-function buildSystemPrompt(maxSteps) {
+function buildSystemPrompt(maxSteps, profile) {
   let scope;
-  if (maxSteps <= 5) {
+  if (profile === "wide") {
+    scope = `SCOPE: Educational tutorial (${maxSteps} steps max) - comprehensive, structured coverage of every major feature area, in a logical teaching order`;
+  } else if (profile === "short") {
+    scope = `SCOPE: Quick-paced short (${maxSteps} steps max) - cover every interesting detail with fast cuts and terse captions; running long is fine, the video is compressed afterwards`;
+  } else if (maxSteps <= 5) {
     scope = `SCOPE: Minimal demo (${maxSteps} steps max) - ONE complete user journey only`;
   } else if (maxSteps <= 8) {
     scope = `SCOPE: Standard demo (${maxSteps} steps max) - One journey with 1-2 options`;
@@ -1571,9 +2855,47 @@ function buildSystemPrompt(maxSteps) {
 ${scope}
 
 CORE FLOW (always follow this structure):
-1. wait - Intro (what does this app do?)
+1. wait - the hook, over the app's own card (see OPENING AND CLOSING)
 2. Actions - Complete ONE user journey (upload\u2192process\u2192result)
-3. wait - Outro (what was accomplished?)
+3. Stop. The closing card is appended for you - do not write one
+
+NARRATION STYLE:
+\u2022 Professional and direct, like a good tutorial - never condescending, never explaining as if to a child
+\u2022 NEVER mention step numbers or sequencing ("step one", "first step", "in this step") - just say what is happening
+\u2022 NEVER build the demo out of marketing surfaces. The landing page and the PRICING page are not the product: a viewer wants to see the thing working, not read plans and prices. If the app is behind a sign-in, demo the signed-in app; if that is impossible, demo its functional public pages (tools, docs, editors), not its sales pages
+\u2022 A marketing/landing page earns ONE brief opening caption of about a SECOND - a title card, nothing more. Never scroll it, never hover or highlight anything on it, never describe its sections. Optionally return to it for the closing call to action. The demo lives in the app itself, behind the login when a session exists. Never return to the landing page mid-demo to describe a feature the app can show you doing
+\u2022 NARRATE ONLY WHAT IS ON SCREEN: every caption must describe what the viewer can see at that moment. To talk about a specific component, make it the step's target (hover it, click it, or scroll with that target) so the recorder brings it into frame first
+\u2022 A blind scroll (no target) lands wherever it lands - use it only for "there is more below", never to reveal something the caption names
+\u2022 Never combine scrolling with pointing: a step either moves the page or holds still on a component, so the highlight is never dragged across the screen mid-scroll
+\u2022 A step that starts something asynchronous (processing, generating, analyzing) must WAIT for the result on screen before moving on: give the wait step a "duration" in seconds long enough to show the outcome
+\u2022 Caption length drives step length - keep captions tight so the video moves
+
+OPENING AND CLOSING (a fixed template - both cards are built for you):
+\u2022 Step 1 is ALWAYS a bare { "action": "wait" } with no target. Its caption is the HOOK, and the recorder puts the app's own OG card behind it
+\u2022 The hook names the VIEWER'S problem in the viewer's words - the cost of not having this app, in one line someone would recognise as their own situation. It is the reason to keep watching
+\u2022 NEVER open the hook with the product: no "This is X", no "Meet X", no "X helps you..." and no feature. The problem comes first
+\u2022 Then, in that SAME caption, say the app's address once - "<problem>. <domain> fixes that." A viewer who leaves halfway has to have heard where to go, and the closing card is too late for them. The opening card is both spoken AND captioned, so write the hook to read as well as it sounds: short words, no spelled-out punctuation, and the domain written the way it is typed
+\u2022 The closing card is appended for you: the app's name, tagline, domain and any live offer, narrated. Never write a sign-off step and never end back on the landing page. Apart from the hook, keep the domain and any discount code out of captions - the card carries both, and repeating them mid-demo is the most common way these scripts read as padding
+
+HOW IT SHOULD SOUND (this is read aloud, not printed on a slide):
+\u2022 Write the way a person talks about something they actually like. Warm, quick, a bit of a grin. Never the voice of a landing page
+\u2022 BANNED, because they are what marketing copy sounds like when nobody meant it: "free to start", "get started today", "unlock", "empower", "seamlessly", "effortlessly", "revolutionise", "supercharge", "take your X to the next level", "say goodbye to". If a line could sit on any product's homepage unchanged, it is not about this product
+\u2022 The free tier is "try it free", or just "free". Never "free to start", which reads as a pricing table talking
+\u2022 Short sentences beat long ones out loud. A comma is a breath; a full stop is a beat. Read it back before shipping it
+\u2022 Say the thing, do not build up to it. No "in this video we will", no "let's take a look at"
+
+WHAT TO COVER (a tour of tabs is a menu, not a demo):
+\u2022 Lead with the outcome the app produces, not the screens it has
+\u2022 Say where that outcome ENDS UP when the app puts it somewhere - search results, AI assistant answers, directories, an app store
+\u2022 Name any integration that removes work rather than adding a screen - an MCP server, a browser extension that fills the forms, an API, a CLI. An app that can be driven from an assistant is a headline feature, not a footnote
+\u2022 Do NOT write a pricing step. When the app has a free tier the closing card says so for you, narrated, at the end where it belongs. Never navigate to the pricing page for it
+\u2022 Cover what surrounds the product as well as the product: a community, a network its users list each other on, a support channel, anything published on the user's behalf. These are reasons to sign up and they are never on screen by themselves
+\u2022 Say what a feature DOES, never what it is implemented as. Filenames, formats and protocols are not benefits: "so AI assistants can read your product" lands, "it writes llms.txt and robots.txt" is a changelog line read aloud. Same for sitemap.xml, JSON-LD, schema markup, API endpoints and anything ending in .txt, .xml or .json. If a viewer would have to already know what it is, it is not a selling point
+\u2022 Prefer one feature shown working over three named in passing
+\u2022 When a step types into a URL or domain field, type a REAL domain, never example.com or example.org. A demo that audits "example.com" on camera shows the tool working on nothing. Use a real site the viewer might recognise, or the demo subject's own domain if nothing better is on the page
+\u2022 A plan that is mostly bare wait steps is a failed plan. One real run came back 22 waits out of 26: a slideshow of one static screen, narrating pages it never visited. If a caption names a page, NAVIGATE to it; if it names a control, CLICK it. Use wait only for the opening and closing cards
+\u2022 NEVER narrate a screen you are not on. If a line describes a page the demo has not reached, navigate to it first. A caption saying "start with a free roast" over the dashboard is worse than cutting the line: it makes the whole video look faked
+\u2022 Cover everything worth covering and let it run long. Length is fixed afterwards by playing the demo faster, never by dropping a feature - a plan trimmed to hit a target is the one mistake the compressor cannot undo
 
 TARGET SYNTAX (simplified):
 \u2022 Buttons/Links: Use plain text like "extract frame", "download" (case insensitive, partial match OK)
@@ -1596,9 +2918,12 @@ FORBIDDEN:
 
 ACTION FORMATS (STRICT - follow exactly):
 \u2022 click: { "action": "click", "target": "extract frame" } - use simplified button text
+\u2022 hover: { "action": "hover", "target": "pricing card" } - point the cursor at a feature while the caption explains it, without clicking
 \u2022 type: { "action": "type", "target": "input[name=\\"field\\"]", "value": "text to type" }
 \u2022 upload: { "action": "upload", "target": "input[type=\\"file\\"]", "value": "[file]" }
+\u2022 navigate: { "action": "navigate", "target": "https://example.com/roast" } - GO TO ANOTHER PAGE. Use it whenever the caption describes something that is not on the current screen. Any path on the SAME ORIGIN as the demo URL is allowed, not only the NAVIGATE targets listed below: an app's own routes are frequently reached by client-side buttons rather than links, so the list is a hint, not the limit. Never navigate off-origin.
 \u2022 wait: { "action": "wait" } - for intro/outro captions
+\u2022 scroll to a component: { "action": "scroll", "target": "seo files", "value": "down" } - brings that element into frame; PREFER this over a blind scroll whenever the caption names something
 \u2022 scroll: { "action": "scroll", "value": "-80" } - negative=zoom out, positive=zoom in
 \u2022 drag: { "action": "drag", "target": "input[type=\\"range\\"]", "value": "50" }
 \u2022 select: { "action": "select", "target": "select[name=\\"..\\"]", "value": "option" }
@@ -1623,6 +2948,17 @@ Purpose: ${description}` : "";
   const selectables = elements.filter((e) => e.action === "select");
   const checkables = elements.filter((e) => e.action === "check");
   const elementDict = [];
+  const navigables = elements.filter((e) => e.href);
+  const seenHref = /* @__PURE__ */ new Set();
+  const linkTargets = navigables.filter((e) => {
+    if (!e.href || seenHref.has(e.href)) return false;
+    seenHref.add(e.href);
+    return true;
+  });
+  if (linkTargets.length > 0) {
+    elementDict.push(`NAVIGATE targets (links found on the page; same-origin paths not listed here are also allowed):
+${linkTargets.map((e) => `\u2022 "${e.text}" -> ${e.href}`).join("\n")}`);
+  }
   if (clickables.length > 0) {
     elementDict.push(`CLICK targets (use simplified text):
 ${clickables.map((e) => `\u2022 "${e.target || e.text.toLowerCase()}"`).join("\n")}`);
@@ -1689,7 +3025,16 @@ TARGET SYNTAX:
 }
 
 // src/lib/styles.ts
-import { buildAssHeader } from "@spark-apps/video-kit";
+import {
+  assTimeFromMs,
+  buildAssHeader,
+  chunkWordsToLines,
+  fittingMaxChars,
+  hexToAss as hexToAss2,
+  mergePunctuationTokens,
+  scaleToFit,
+  toCaptionCase
+} from "@spark-apps/video-kit";
 var CURSOR_MOVE_DURATION = 800;
 var CURSOR_CSS = `
   #qp-cursor {
@@ -1728,16 +3073,250 @@ var CURSOR_SCRIPT = `
     cursor.style.top = window.innerHeight / 2 + 'px';
   })();
 `;
-function generateASSHeader(width, height, font, size, primaryColor, secondaryColor, outlineColor, backColor, bold, outlineWidth, shadow, marginBottom) {
+function generateASSHeader(width, height, font, size, primaryColor, secondaryColor, outlineColor, backColor, bold, outlineWidth, shadow, marginBottom, alignment = 2) {
   return buildAssHeader({
     title: "QuickPeek Demo",
     width,
     height,
     styles: [
-      `Style: Karaoke,${font},${size},${primaryColor},${secondaryColor},${outlineColor},${backColor},${bold ? 1 : 0},0,0,0,100,100,0,0,1,${outlineWidth},${shadow},2,40,40,${marginBottom},1`
+      `Style: Karaoke,${font},${size},${primaryColor},${secondaryColor},${outlineColor},${backColor},${bold ? 1 : 0},0,0,0,100,100,0,0,1,${outlineWidth},${shadow},${alignment},40,40,${marginBottom},1`
     ]
   });
 }
+var SIDE_MARGIN = 40;
+function resolveCaptionFont(font) {
+  if (process.platform === "linux" && font === "Arial Black") return "DejaVu Sans";
+  return font;
+}
+function boldOverride(captions) {
+  if (captions.highlight.bold === captions.regular.bold) return { lit: "", rest: "" };
+  return {
+    lit: captions.highlight.bold ? "\\b1" : "\\b0",
+    rest: captions.regular.bold ? "\\b1" : "\\b0"
+  };
+}
+function positionToAlignment(position, leftAligned = false) {
+  const base = leftAligned ? 1 : 2;
+  if (position === "center") return base + 3;
+  if (position === "top") return base + 6;
+  return base;
+}
+function positionMarginV(position, margin) {
+  return position === "center" ? 0 : margin;
+}
+function packLines(words, maxChars) {
+  return chunkWordsToLines(mergePunctuationTokens(words), maxChars).filter((line) => line.length > 0);
+}
+function renderKaraokeAss(ctx) {
+  const { captions, width, height } = ctx;
+  const regularColor = hexToAss2(captions.regular.color);
+  const highlightColor = hexToAss2(captions.highlight.color);
+  const outline = hexToAss2(captions.outline);
+  const back = hexToAss2(captions.outline, 128);
+  const highlightScale = Math.round(captions.highlight.size / captions.regular.size * 100);
+  const header = generateASSHeader(
+    width,
+    height,
+    resolveCaptionFont(captions.font),
+    captions.regular.size,
+    highlightColor,
+    regularColor,
+    outline,
+    back,
+    captions.regular.bold,
+    captions.outlineWidth,
+    captions.shadow,
+    positionMarginV(captions.position, captions.marginBottom),
+    positionToAlignment(captions.position)
+  );
+  const usable = width - SIDE_MARGIN * 2;
+  const maxChars = fittingMaxChars(width, captions.regular.size, SIDE_MARGIN, captions.maxChars, true);
+  const lines = [];
+  for (const cue of ctx.cues) {
+    for (const line of packLines(cue.words, maxChars)) {
+      const plain = line.map((w) => w.word).join(" ");
+      const lineScale = scaleToFit(plain, captions.regular.size, usable, true);
+      const popScale = Math.round(highlightScale * lineScale / 100);
+      const boldTags = boldOverride(captions);
+      let karaokeText = "";
+      for (const word of line) {
+        const duration = Math.round((word.end - word.start) / 10);
+        karaokeText += `{\\kf${duration}\\fscx${popScale}\\fscy${popScale}${boldTags.lit}}${word.word}{\\fscx${lineScale}\\fscy${lineScale}${boldTags.rest}} `;
+      }
+      const start = assTimeFromMs(line[0].start);
+      const end = assTimeFromMs(line[line.length - 1].end);
+      lines.push(`Dialogue: 0,${start},${end},Karaoke,,0,0,0,,${karaokeText.trim()}`);
+    }
+  }
+  return `${header}${lines.join("\n")}
+`;
+}
+function renderHormoziAss(ctx) {
+  const { captions, width, height } = ctx;
+  const font = resolveCaptionFont(captions.font);
+  const primary = hexToAss2(captions.regular.color);
+  const highlight = hexToAss2(captions.highlight.color);
+  const outline = hexToAss2(captions.outline);
+  const back = hexToAss2(captions.outline, 128);
+  const alignment = positionToAlignment(captions.position);
+  const marginV = positionMarginV(captions.position, captions.marginBottom);
+  const bold = captions.regular.bold ? -1 : 0;
+  const header = buildAssHeader({
+    title: "QuickPeek Demo",
+    width,
+    height,
+    styles: [
+      `Style: Default,${font},${captions.regular.size},${primary},${highlight},${outline},${back},${bold},0,0,0,100,100,0,0,1,${captions.outlineWidth},${captions.shadow},${alignment},${SIDE_MARGIN},${SIDE_MARGIN},${marginV},1`
+    ],
+    scaledBorderAndShadow: true
+  });
+  const maxChars = fittingMaxChars(width, captions.regular.size, SIDE_MARGIN, captions.maxChars, true);
+  const lines = [];
+  for (const cue of ctx.cues) {
+    for (const line of packLines(cue.words, maxChars)) {
+      const plain = line.map((w) => w.word).join(" ");
+      const lineScale = scaleToFit(plain, captions.regular.size, width - SIDE_MARGIN * 2, true);
+      const scaleTag = lineScale < 100 ? `{\\fscx${lineScale}\\fscy${lineScale}}` : "";
+      const boldTags = boldOverride(captions);
+      for (let i = 0; i < line.length; i++) {
+        const word = line[i];
+        const nextStart = i + 1 < line.length ? line[i + 1].start : line[line.length - 1].end;
+        const text = line.map(
+          (other, j) => j === i ? `{\\1c${highlight}${boldTags.lit}}${other.word}{\\1c${primary}${boldTags.rest}}` : other.word
+        ).join(" ");
+        lines.push(
+          `Dialogue: 0,${assTimeFromMs(word.start)},${assTimeFromMs(nextStart)},Default,,0,0,0,,${scaleTag}${text}`
+        );
+      }
+    }
+  }
+  return `${header}${lines.join("\n")}
+`;
+}
+function looksLikeAddress(token) {
+  return /^(?:https?:\/\/)?(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z]{2,}(?:\/[^\s]*)?[.,!?]?$/i.test(token);
+}
+function renderShortsAss(ctx) {
+  const { captions, width, height } = ctx;
+  const font = resolveCaptionFont(captions.font === "Arial" ? "Arial Black" : captions.font);
+  const primary = hexToAss2(captions.regular.color);
+  const highlight = hexToAss2(captions.highlight.color);
+  const fontSize = Math.max(captions.regular.size, Math.round(height / 20));
+  const marginV = captions.position === "bottom" ? Math.round(height * 0.24) : captions.position === "top" ? Math.round(height * 0.1) : 0;
+  const alignment = positionToAlignment(captions.position);
+  const outline = Math.max(2, Math.round(fontSize / 22));
+  const upper = true;
+  const caseOf = (t) => looksLikeAddress(t) ? t : toCaptionCase(t, upper);
+  const maxChars = fittingMaxChars(width, fontSize, SIDE_MARGIN, captions.maxChars, upper);
+  const header = `[Script Info]
+Title: QuickPeek Demo
+ScriptType: v4.00+
+PlayResX: ${width}
+PlayResY: ${height}
+ScaledBorderAndShadow: yes
+WrapStyle: 0
+
+[V4+ Styles]
+Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding
+Style: Shorts,${font},${fontSize},${primary},${primary},&H00000000,&H00000000,${captions.regular.bold ? -1 : 0},0,0,0,100,100,0,0,1,${outline},2,${alignment},${SIDE_MARGIN},${SIDE_MARGIN},${marginV},1
+
+[Events]
+Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
+`;
+  const lines = [];
+  for (const cue of ctx.cues) {
+    for (const lineWords of packLines(cue.words, maxChars)) {
+      const plain = lineWords.map((w) => caseOf(w.word)).join(" ");
+      const scale = scaleToFit(plain, fontSize, width - SIDE_MARGIN * 2, upper);
+      const scaleTag = scale < 100 ? `{\\fscx${scale}\\fscy${scale}}` : "";
+      const boldTags = boldOverride(captions);
+      for (let i = 0; i < lineWords.length; i++) {
+        const text = lineWords.map(
+          (w, j) => j === i ? `{\\c${highlight}${boldTags.lit}}${caseOf(w.word)}{\\c${primary}${boldTags.rest}}` : caseOf(w.word)
+        ).join(" ");
+        const end = i === lineWords.length - 1 ? lineWords[i].end : lineWords[i + 1].start;
+        lines.push(
+          `Dialogue: 0,${assTimeFromMs(lineWords[i].start)},${assTimeFromMs(end)},Shorts,,0,0,0,,${scaleTag}${text}`
+        );
+      }
+    }
+  }
+  return `${header}${lines.join("\n")}
+`;
+}
+function renderMinimalAss(ctx) {
+  const { captions, width, height } = ctx;
+  const font = resolveCaptionFont(captions.font);
+  const primary = hexToAss2(captions.regular.color);
+  const fontSize = Math.round(captions.regular.size * 0.6);
+  const alignment = positionToAlignment(captions.position, true);
+  const marginV = positionMarginV(captions.position, 30);
+  const header = buildAssHeader({
+    title: "QuickPeek Demo",
+    width,
+    height,
+    styles: [
+      // BorderStyle 3 draws an opaque box (&HB0...: mostly-opaque black) behind the text
+      `Style: MinimalBg,${font},${fontSize},${primary},${primary},&H00000000,&HB0000000,${captions.regular.bold ? -1 : 0},0,0,0,100,100,0,0,3,0,0,${alignment},20,20,${marginV},1`
+    ],
+    scaledBorderAndShadow: true
+  });
+  const maxChars = fittingMaxChars(width, fontSize, 20, captions.maxChars * 2, true);
+  const lines = [];
+  for (const cue of ctx.cues) {
+    for (const line of packLines(cue.words, maxChars)) {
+      const start = assTimeFromMs(line[0].start);
+      const end = assTimeFromMs(line[line.length - 1].end);
+      lines.push(`Dialogue: 0,${start},${end},MinimalBg,,0,0,0,,${line.map((w) => w.word).join(" ")}`);
+    }
+  }
+  return `${header}${lines.join("\n")}
+`;
+}
+var CAPTION_DESIGN_LONG_EDGE = 1920;
+function captionCanvas(width, height) {
+  const longEdge = Math.max(width, height);
+  if (!Number.isFinite(longEdge) || longEdge <= 0) return { width, height };
+  const scale = CAPTION_DESIGN_LONG_EDGE / longEdge;
+  return { width: Math.round(width * scale), height: Math.round(height * scale) };
+}
+function resolveCaptions(css, video) {
+  const { width, height } = captionCanvas(video.width, video.height);
+  const canvas = defaultCaptionsFor(width, height);
+  const base = {
+    ...canvas,
+    font: css.font,
+    outline: css.outline,
+    regular: { ...canvas.regular, color: css.regular.color },
+    highlight: { ...canvas.highlight, color: css.highlight.color }
+  };
+  const over = video.captions;
+  if (!over) return base;
+  return {
+    ...base,
+    ...over,
+    regular: { ...base.regular, ...over.regular },
+    highlight: { ...base.highlight, ...over.highlight }
+  };
+}
+function renderCaptionsAss(context) {
+  const { width, height } = captionCanvas(context.width, context.height);
+  const cues = context.cues.map((cue) => ({
+    ...cue,
+    words: cue.words.map((w) => ({ ...w, word: toCaptionCase(w.word, true) }))
+  }));
+  const ctx = { ...context, width, height, cues };
+  switch (ctx.captions.preset) {
+    case "hormozi":
+      return renderHormoziAss(ctx);
+    case "shorts":
+      return renderShortsAss(ctx);
+    case "minimal":
+      return renderMinimalAss(ctx);
+    default:
+      return renderKaraokeAss(ctx);
+  }
+}
 
 // src/lib/subscription-client.ts
 async function registerFreeUser(email) {
@@ -1774,14 +3353,17 @@ async function registerFreeUser(email) {
 
 // src/lib/tts/cache.ts
 init_helpers();
-import { join as join3 } from "path";
-function canReuseVoiceover(steps, voice, existingMeta) {
+import { join as join4 } from "path";
+function canReuseVoiceover(steps, voice, rate, existingMeta) {
   if (!existingMeta) {
     return { canReuse: false, reason: "No existing voiceover found" };
   }
   if (existingMeta.voice !== voice) {
     return { canReuse: false, reason: `Voice changed (${existingMeta.voice} \u2192 ${voice})` };
   }
+  if (existingMeta.rate !== rate) {
+    return { canReuse: false, reason: `Narration speed changed (${existingMeta.rate ?? "unknown"} \u2192 ${rate})` };
+  }
   if (existingMeta.stepCount !== steps.length) {
     return { canReuse: false, reason: `Step count changed (${existingMeta.stepCount} \u2192 ${steps.length})` };
   }
@@ -1789,37 +3371,54 @@ function canReuseVoiceover(steps, voice, existingMeta) {
   if (existingMeta.captionsHash === currentHash) {
     return { canReuse: true };
   }
-  const currentLength = steps.reduce((sum, s) => sum + (s.caption?.length || 0), 0);
-  const lengthDiff = Math.abs(currentLength - existingMeta.totalCaptionLength);
-  const threshold = existingMeta.totalCaptionLength * 0.1;
-  if (lengthDiff <= threshold) {
-    return { canReuse: true, reason: "Captions similar enough" };
-  }
-  return { canReuse: false, reason: "Captions changed significantly" };
+  return { canReuse: false, reason: "Captions changed" };
 }
 async function loadExistingVoiceover(steps, outputDir, meta, config) {
   const { estimateWordTimings: estimateWordTimings2 } = await Promise.resolve().then(() => (init_timing(), timing_exports));
-  const voiceoverPath = join3(outputDir, "voiceover.wav");
+  const voiceoverPath = join4(outputDir, "voiceover.wav");
   const stepAudio = /* @__PURE__ */ new Map();
+  const captionsUnchanged = meta.captionsHash === getCaptionsHash(steps);
   for (let i = 0; i < steps.length; i++) {
     const step = steps[i];
     const stepNum = i + 1;
     const duration = meta.stepDurations[stepNum] || config.timing.minStepDuration;
+    const savedWords = captionsUnchanged ? meta.stepWords?.[stepNum] : void 0;
     stepAudio.set(stepNum, {
       duration,
-      words: estimateWordTimings2(step.caption || "", duration)
+      words: savedWords && savedWords.length > 0 ? savedWords : estimateWordTimings2(step.caption || "", duration)
     });
   }
   return { voiceoverPath, stepAudio };
 }
 
 // src/lib/tts/generate.ts
+import { createHash } from "crypto";
+import { existsSync as existsSync3 } from "fs";
+import { copyFile, mkdir, readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
+import { join as join6 } from "path";
+import { toSpokenForm } from "@spark-apps/video-kit";
 init_ffmpeg2();
-import { mkdir } from "fs/promises";
-import { join as join5 } from "path";
+init_utils();
 
 // src/lib/voices.ts
-import { WIDE_VOICES } from "@spark-apps/video-kit";
+import { MALE_VOICES, MULTILINGUAL_VOICES, resolveVoice, WIDE_VOICES } from "@spark-apps/video-kit";
+import { MALE_VOICES as MALE_VOICES2, MULTILINGUAL_VOICES as MULTILINGUAL_VOICES2, WIDE_VOICES as WIDE_VOICES2 } from "@spark-apps/video-kit";
+var INTERNATIONAL_VOICE = "international";
+function internationalVoiceFor(lang, gender = "female") {
+  if (!hasVoice(lang)) return null;
+  const raw = lang.trim().toLowerCase();
+  const multilingual = MULTILINGUAL_VOICES[raw] ?? MULTILINGUAL_VOICES[raw.slice(0, 2)];
+  if (gender === "male") return voiceFor(lang, gender);
+  return multilingual ?? voiceFor(lang, gender);
+}
+function hasVoice(lang) {
+  const raw = lang.trim().toLowerCase();
+  return Boolean(WIDE_VOICES[raw] ?? WIDE_VOICES[raw.slice(0, 2)]);
+}
+function voiceFor(lang, gender = "female") {
+  if (!hasVoice(lang)) return null;
+  return resolveVoice(lang, { gender, table: WIDE_VOICES, maleTable: MALE_VOICES });
+}
 
 // src/lib/tts/generate.ts
 init_helpers();
@@ -1828,39 +3427,78 @@ init_helpers();
 init_helpers();
 import { exec } from "child_process";
 import { createWriteStream } from "fs";
-import { stat, unlink as unlink2, writeFile as writeFile2 } from "fs/promises";
-import { join as join4, resolve as resolve2 } from "path";
+import { readFile as readFile2, stat, unlink as unlink3, writeFile as writeFile2 } from "fs/promises";
+import { join as join5, resolve as resolve2 } from "path";
 import { pipeline } from "stream/promises";
 import { promisify } from "util";
 var execAsync = promisify(exec);
 var PYTHON_ATTEMPTS = 2;
-async function synthesizeSpeech(text, outputPath, voice) {
-  let pythonMsg = "";
-  for (let attempt = 0; attempt < PYTHON_ATTEMPTS; attempt++) {
-    try {
-      await synthesizeWithPython(text, outputPath, voice);
-      return;
-    } catch (err) {
-      pythonMsg = err instanceof Error ? err.message : String(err);
-      if (attempt < PYTHON_ATTEMPTS - 1) await new Promise((r) => setTimeout(r, 500));
+var TICKS_PER_MS = 1e4;
+var wordsSidecar = (audioPath) => `${audioPath}.words.json`;
+var pythonEdgeTts = null;
+function pythonEdgeTtsAvailable() {
+  pythonEdgeTts ??= execAsync(isWindows ? 'wsl python3 -c "import edge_tts"' : 'python3 -c "import edge_tts"', {
+    timeout: 1e4
+  }).then(
+    () => true,
+    () => false
+  );
+  return pythonEdgeTts;
+}
+var lockedEngine = null;
+function resetVoiceEngine() {
+  lockedEngine = null;
+}
+function xmlSafe(text) {
+  return text.replace(/[&<>]/g, (c) => c === "&" ? " and " : " ").replace(/\s{2,}/g, " ");
+}
+async function synthesizeSpeech(rawText, outputPath, voice, rate) {
+  const text = xmlSafe(rawText);
+  let pythonMsg = "python edge-tts not installed";
+  const tryPython = lockedEngine !== "node" && await pythonEdgeTtsAvailable();
+  if (tryPython) {
+    const attempts = lockedEngine === "python" ? PYTHON_ATTEMPTS * 2 : PYTHON_ATTEMPTS;
+    for (let attempt = 0; attempt < attempts; attempt++) {
+      try {
+        const words2 = await synthesizeWithPython(text, outputPath, voice, rate);
+        lockedEngine = "python";
+        return words2;
+      } catch (err) {
+        pythonMsg = err instanceof Error ? err.message : String(err);
+        if (attempt < attempts - 1) await new Promise((r) => setTimeout(r, 500));
+      }
     }
   }
-  await synthesizeWithNode(text, outputPath, voice, pythonMsg);
+  const words = await synthesizeWithNode(text, outputPath, voice, pythonMsg, rate);
+  lockedEngine = "node";
+  return words;
 }
-async function synthesizeWithPython(text, outputPath, voice) {
-  const tempScriptPath = join4(resolve2(outputPath, ".."), `tts-${Date.now()}.py`);
+async function synthesizeWithPython(text, outputPath, voice, rate) {
+  const tempScriptPath = join5(resolve2(outputPath, ".."), `tts-${Date.now()}.py`);
   const wslScriptPath = isWindows ? toWSLPathForTTS(resolve2(tempScriptPath)) : tempScriptPath;
   const wslOutputPath = isWindows ? toWSLPathForTTS(resolve2(outputPath)) : outputPath;
   const pythonScript = `
-import asyncio
+import asyncio, json
 from edge_tts import Communicate
 
 async def main():
     text = ${JSON.stringify(text)}
     voice = ${JSON.stringify(voice)}
     output = ${JSON.stringify(wslOutputPath)}
-    communicate = Communicate(text, voice)
-    await communicate.save(output)
+    communicate = Communicate(text, voice${rate ? `, rate=${JSON.stringify(rate)}` : ""})
+    words = []
+    with open(output, "wb") as f:
+        async for chunk in communicate.stream():
+            if chunk["type"] == "audio":
+                f.write(chunk["data"])
+            elif chunk["type"] == "WordBoundary":
+                words.append({
+                    "word": chunk["text"],
+                    "start": chunk["offset"] / ${TICKS_PER_MS},
+                    "end": (chunk["offset"] + chunk["duration"]) / ${TICKS_PER_MS},
+                })
+    with open(output + ".words.json", "w") as f:
+        json.dump(words, f)
 
 asyncio.run(main())
 `;
@@ -1868,24 +3506,42 @@ asyncio.run(main())
     await writeFile2(tempScriptPath, pythonScript);
     const pythonCmd = isWindows ? `wsl python3 "${wslScriptPath}"` : `python3 "${wslScriptPath}"`;
     await execAsync(pythonCmd, { timeout: 3e4 });
+    const written = await stat(outputPath).catch(() => null);
+    if (!written?.size) throw new Error("edge-tts produced no audio");
+    return await readWordsSidecar(outputPath);
+  } finally {
+    await unlink3(tempScriptPath).catch(() => {
+    });
+  }
+}
+async function readWordsSidecar(outputPath) {
+  const sidecar = wordsSidecar(outputPath);
+  try {
+    const parsed = JSON.parse(await readFile2(sidecar, "utf-8"));
+    return parsed.length > 0 ? parsed : null;
+  } catch {
+    return null;
   } finally {
-    await unlink2(tempScriptPath).catch(() => {
+    await unlink3(sidecar).catch(() => {
     });
   }
 }
-async function synthesizeWithNode(text, outputPath, voice, pythonMsg, maxRetries = 2) {
+async function synthesizeWithNode(text, outputPath, voice, pythonMsg, rate, maxRetries = 2) {
   for (let attempt = 0; attempt <= maxRetries; attempt++) {
     try {
       const { MsEdgeTTS, OUTPUT_FORMAT } = await import("msedge-tts");
       const tts = new MsEdgeTTS();
-      await tts.setMetadata(voice, OUTPUT_FORMAT.AUDIO_24KHZ_96KBITRATE_MONO_MP3);
-      const { audioStream } = tts.toStream(text);
+      await tts.setMetadata(voice, OUTPUT_FORMAT.AUDIO_24KHZ_96KBITRATE_MONO_MP3, { wordBoundaryEnabled: true });
+      const { audioStream, metadataStream } = tts.toStream(text, rate ? { rate } : void 0);
+      const metadata = [];
+      metadataStream?.on("data", (chunk) => metadata.push(chunk.toString()));
       await pipeline(audioStream, createWriteStream(outputPath));
+      await new Promise((r) => setTimeout(r, 250));
       const { size } = await stat(outputPath);
       if (size === 0) throw new Error("No audio data received");
-      return;
+      return parseWordBoundaries(metadata.join(""));
     } catch (nodeErr) {
-      await unlink2(outputPath).catch(() => {
+      await unlink3(outputPath).catch(() => {
       });
       if (attempt === maxRetries) {
         const nodeMsg = nodeErr instanceof Error ? nodeErr.message : String(nodeErr);
@@ -1894,21 +3550,206 @@ async function synthesizeWithNode(text, outputPath, voice, pythonMsg, maxRetries
       await new Promise((r) => setTimeout(r, 500));
     }
   }
+  return null;
+}
+function parseWordBoundaries(raw) {
+  const words = [];
+  for (const frame of splitJsonObjects(raw)) {
+    let parsed;
+    try {
+      parsed = JSON.parse(frame);
+    } catch {
+      continue;
+    }
+    for (const entry of parsed.Metadata ?? []) {
+      if (entry.Type !== "WordBoundary") continue;
+      const word = entry.Data?.text?.Text;
+      const offset = entry.Data?.Offset;
+      const duration = entry.Data?.Duration;
+      if (!word || offset === void 0 || duration === void 0) continue;
+      words.push({
+        word,
+        start: offset / TICKS_PER_MS,
+        end: (offset + duration) / TICKS_PER_MS
+      });
+    }
+  }
+  return words.length > 0 ? words : null;
+}
+function splitJsonObjects(raw) {
+  const out = [];
+  let depth = 0;
+  let start = -1;
+  let inString = false;
+  let escaped = false;
+  for (let i = 0; i < raw.length; i++) {
+    const ch = raw[i];
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (inString) {
+      if (ch === "\\") escaped = true;
+      else if (ch === '"') inString = false;
+      continue;
+    }
+    if (ch === '"') inString = true;
+    else if (ch === "{") {
+      if (depth === 0) start = i;
+      depth++;
+    } else if (ch === "}") {
+      depth--;
+      if (depth === 0 && start >= 0) {
+        out.push(raw.slice(start, i + 1));
+        start = -1;
+      }
+    }
+  }
+  return out;
 }
 
 // src/lib/tts/generate.ts
 init_timing();
+init_helpers();
+function clipKey(spokenText, voice, rate) {
+  return createHash("sha1").update(`${spokenText}\0${voice}\0${rate}`).digest("hex");
+}
+async function reuseClip(cacheDir, key, audioPath) {
+  const mp3 = join6(cacheDir, `${key}.mp3`);
+  const meta = join6(cacheDir, `${key}.json`);
+  if (!existsSync3(mp3) || !existsSync3(meta)) return null;
+  try {
+    const boundaries = JSON.parse(await readFile3(meta, "utf-8"));
+    await copyFile(mp3, audioPath);
+    return boundaries;
+  } catch {
+    return null;
+  }
+}
+async function storeClip(cacheDir, key, audioPath, spoken) {
+  try {
+    await mkdir(cacheDir, { recursive: true });
+    await copyFile(audioPath, join6(cacheDir, `${key}.mp3`));
+    await writeFile3(join6(cacheDir, `${key}.json`), JSON.stringify(spoken ?? null));
+  } catch {
+  }
+}
+var TTS_POOL = 4;
+function capStep(config, ms) {
+  const cap = config.timing.maxStepDuration;
+  return cap && cap > 0 ? Math.min(ms, cap) : ms;
+}
 function estimateDurationFromText(text, wordsPerMinute = 150) {
   const words = text.split(/\s+/).filter((w) => w.length > 0).length;
   return Math.max(Math.round(words / wordsPerMinute * 60 * 1e3), 1500);
 }
-function resolveVoice(config) {
-  if (config.audio?.voice) return config.audio.voice;
-  if (config.lang) return WIDE_VOICES[config.lang] || null;
+function resolveVoice2(config) {
+  const named = config.audio?.voice;
+  if (named === INTERNATIONAL_VOICE) {
+    return internationalVoiceFor(config.lang ?? "en", config.audio?.gender);
+  }
+  if (named) return named;
+  if (config.lang) return voiceFor(config.lang, config.audio?.gender);
   return null;
 }
+function resolveRate(config) {
+  return config.audio?.rate ?? "normal";
+}
+var ONES = [
+  "zero",
+  "one",
+  "two",
+  "three",
+  "four",
+  "five",
+  "six",
+  "seven",
+  "eight",
+  "nine",
+  "ten",
+  "eleven",
+  "twelve",
+  "thirteen",
+  "fourteen",
+  "fifteen",
+  "sixteen",
+  "seventeen",
+  "eighteen",
+  "nineteen"
+];
+var TENS = ["", "", "twenty", "thirty", "forty", "fifty", "sixty", "seventy", "eighty", "ninety"];
+function speakInteger(n) {
+  if (!Number.isInteger(n) || n < 0 || n > 999) return null;
+  if (n < 20) return ONES[n];
+  if (n < 100) {
+    const t = TENS[Math.floor(n / 10)];
+    const r2 = n % 10;
+    return r2 ? `${t}-${ONES[r2]}` : t;
+  }
+  const h = `${ONES[Math.floor(n / 100)]} hundred`;
+  const r = n % 100;
+  return r ? `${h} and ${speakInteger(r)}` : h;
+}
+function speakNumbers(text) {
+  return text.replace(/(\d+)\s*%/g, (m, d) => {
+    const spoken = speakInteger(Number(d));
+    return spoken ? `${spoken} percent` : m;
+  }).replace(/(?<![\d.,£$€])\b(\d{1,3})\b(?![\d.,%])/g, (m, d) => speakInteger(Number(d)) ?? m);
+}
+var SPELLED_OUT = /\b([A-Z]{2,5})\b/g;
+var LETTER_SOUNDS = {
+  A: "ay",
+  B: "bee",
+  C: "see",
+  D: "dee",
+  E: "ee",
+  F: "ef",
+  G: "gee",
+  H: "aitch",
+  I: "eye",
+  J: "jay",
+  K: "kay",
+  L: "el",
+  M: "em",
+  N: "en",
+  O: "oh",
+  P: "pee",
+  Q: "cue",
+  R: "ar",
+  S: "ess",
+  T: "tee",
+  U: "you",
+  V: "vee",
+  W: "double-you",
+  X: "ex",
+  Y: "why",
+  Z: "zed"
+};
+function spellAcronyms(text) {
+  return text.replace(
+    SPELLED_OUT,
+    (m) => m.split("").map((c) => LETTER_SOUNDS[c] ?? c).join(" ")
+  );
+}
+var SPOKEN_TLD = {
+  ai: "ay-eye"
+};
+function bindDomains(text) {
+  return text.replace(/\b([a-z0-9][a-z0-9._+-]*)@(?=[a-z0-9][a-z0-9-]*\.[a-z]{2,24}\b)/gi, "$1-at-").replace(
+    /\b([a-z0-9][a-z0-9-]*)\.([a-z]{2,24})\b/gi,
+    (_m, host, tld) => `${host}-dot-${SPOKEN_TLD[tld.toLowerCase()] ?? tld}`
+  );
+}
+function speakSymbols(text) {
+  return text.replace(/\s*&\s*/g, " and ").replace(/[<>]/g, " ").replace(/\s{2,}/g, " ").trim();
+}
+function spokenForm(caption) {
+  return speakNumbers(spellAcronyms(toSpokenForm(bindDomains(speakSymbols(caption)))));
+}
 async function generateVoiceover(steps, config, workDir, outputDir, logError, task, info) {
-  const voice = resolveVoice(config);
+  resetVoiceEngine();
+  const voice = resolveVoice2(config);
+  const rate = resolveRate(config);
   if (!voice) {
     const stepAudio2 = /* @__PURE__ */ new Map();
     for (let i = 0; i < steps.length; i++) {
@@ -1917,72 +3758,105 @@ async function generateVoiceover(steps, config, workDir, outputDir, logError, ta
       const actionDuration = estimateActionDuration(step);
       const manualDuration = (step.duration ?? 0) * 1e3;
       const mediaDuration = await getMediaStepDuration(step, outputDir);
-      const duration = Math.max(
-        textDuration,
-        actionDuration,
-        manualDuration,
-        mediaDuration,
-        config.timing.minStepDuration
+      const duration = capStep(
+        config,
+        Math.max(textDuration, actionDuration, manualDuration, mediaDuration, config.timing.minStepDuration)
       );
       stepAudio2.set(i + 1, { duration, words: step.caption ? estimateWordTimings(step.caption, duration) : [] });
     }
     info("No voice configured");
     return { voiceoverPath: "", stepAudio: stepAudio2 };
   }
-  const audioDir = join5(workDir, "audio");
+  const audioDir = join6(workDir, "audio");
   await mkdir(audioDir, { recursive: true });
-  const segments = [];
-  const stepAudio = /* @__PURE__ */ new Map();
   const ttsTask = task("Generating voiceover");
-  for (let idx = 0; idx < steps.length; idx++) {
+  const speed = config.audio?.speed ?? 1;
+  const factor = speed * RATE_FACTOR[rate];
+  const ratePercent = Math.abs(factor - 1) < 5e-3 ? void 0 : `${factor > 1 ? "+" : ""}${Math.round((factor - 1) * 100)}%`;
+  const perStep = new Array(steps.length);
+  const buildStep = async (idx) => {
     const step = steps[idx];
     const stepNum = idx + 1;
     if (!step.caption) {
       const actionDuration = estimateActionDuration(step);
       const manualDuration = (step.duration ?? 0) * 1e3;
       const mediaDuration = await getMediaStepDuration(step, outputDir);
-      const silenceDuration = Math.max(actionDuration, manualDuration, mediaDuration, config.timing.minStepDuration);
-      const silencePath = join5(audioDir, `step-${stepNum}-silence.mp3`);
+      const silenceDuration = capStep(
+        config,
+        Math.max(actionDuration, manualDuration, mediaDuration, config.timing.minStepDuration)
+      );
+      const silencePath = join6(audioDir, `step-${stepNum}-silence.mp3`);
       await generateSilence(silencePath, silenceDuration);
-      segments.push(silencePath);
-      stepAudio.set(stepNum, { duration: silenceDuration, words: [] });
-      continue;
+      perStep[idx] = { segments: [silencePath], audio: { duration: silenceDuration, words: [] } };
+      return;
     }
-    const audioPath = join5(audioDir, `step-${stepNum}.mp3`);
-    if (segments.length > 0) await new Promise((r) => setTimeout(r, 200));
+    const audioPath = join6(audioDir, `step-${stepNum}.mp3`);
     try {
-      await synthesizeSpeech(step.caption, audioPath, voice);
-      segments.push(audioPath);
+      const spokenText = spokenForm(step.caption);
+      const key = clipKey(spokenText, voice, ratePercent ?? "");
+      const cacheDir = join6(outputDir, ".tts-clips");
+      const cached = await reuseClip(cacheDir, key, audioPath);
+      let spoken;
+      if (cached) {
+        spoken = cached;
+      } else {
+        spoken = await synthesizeSpeech(spokenText, audioPath, voice, ratePercent);
+        await trimEdgeSilence(audioPath).catch(() => {
+        });
+        await storeClip(cacheDir, key, audioPath, spoken);
+      }
+      const clips = [audioPath];
       const audioDuration = await getMediaDuration(audioPath);
       const actionDuration = estimateActionDuration(step);
       const manualDuration = (step.duration ?? 0) * 1e3;
       const mediaDuration = await getMediaStepDuration(step, outputDir);
-      const stepDuration = Math.max(
-        audioDuration,
-        config.timing.minStepDuration,
-        actionDuration,
-        manualDuration,
-        mediaDuration
+      const stepDuration = capStep(
+        config,
+        Math.max(audioDuration, config.timing.minStepDuration, actionDuration, manualDuration, mediaDuration)
       );
       if (stepDuration > audioDuration) {
-        const paddingPath = join5(audioDir, `step-${stepNum}-padding.mp3`);
+        const paddingPath = join6(audioDir, `step-${stepNum}-padding.mp3`);
         await generateSilence(paddingPath, stepDuration - audioDuration);
-        segments.push(paddingPath);
+        clips.push(paddingPath);
       }
-      stepAudio.set(stepNum, { duration: stepDuration, words: estimateWordTimings(step.caption, audioDuration) });
+      const words = (config.audio?.transcribe === false ? null : spokenWordTimings(step.caption, spoken)) ?? estimateWordTimings(step.caption, audioDuration);
+      perStep[idx] = { segments: clips, audio: { duration: stepDuration, words } };
     } catch (err) {
       await logError(`TTS Step ${stepNum}`, err);
-      stepAudio.set(stepNum, { duration: config.timing.minStepDuration, words: [] });
+      perStep[idx] = { segments: [], audio: { duration: config.timing.minStepDuration, words: [] } };
     }
+  };
+  await runPooled(steps.length, TTS_POOL, buildStep);
+  const segments = [];
+  const stepAudio = /* @__PURE__ */ new Map();
+  for (let idx = 0; idx < steps.length; idx++) {
+    const built = perStep[idx];
+    if (!built) continue;
+    segments.push(...built.segments);
+    stepAudio.set(idx + 1, built.audio);
   }
   const stepsWithCaptions = steps.filter((s) => s.caption).length;
   ttsTask.succeed(`${segments.length}/${stepsWithCaptions} clips`);
   if (segments.length === 0) {
     return { voiceoverPath: "", stepAudio };
   }
+  const leadInPath = join6(audioDir, LEAD_IN_CLIP);
+  await generateSilence(leadInPath, NARRATION_LEAD_IN_MS);
+  segments.unshift(leadInPath);
+  const firstStep = stepAudio.get(1);
+  if (firstStep) {
+    stepAudio.set(1, {
+      duration: firstStep.duration + NARRATION_LEAD_IN_MS,
+      words: firstStep.words.map((w) => ({
+        ...w,
+        start: w.start + NARRATION_LEAD_IN_MS,
+        end: w.end + NARRATION_LEAD_IN_MS
+      }))
+    });
+  }
   const concatTask = task("Combining audio");
   await mkdir(outputDir, { recursive: true });
-  const voiceoverPath = join5(outputDir, "voiceover.wav");
+  const voiceoverPath = join6(outputDir, "voiceover.wav");
   await concatenateAudio(segments, voiceoverPath, workDir);
   concatTask.succeed("Done");
   const meta = {
@@ -1990,7 +3864,11 @@ async function generateVoiceover(steps, config, workDir, outputDir, logError, ta
     totalCaptionLength: steps.reduce((sum, s) => sum + (s.caption?.length || 0), 0),
     stepCount: steps.length,
     voice,
-    stepDurations: Object.fromEntries(Array.from(stepAudio.entries()).map(([k, v]) => [k, v.duration]))
+    rate,
+    stepDurations: Object.fromEntries(Array.from(stepAudio.entries()).map(([k, v]) => [k, v.duration])),
+    stepWords: Object.fromEntries(
+      Array.from(stepAudio.entries()).filter(([, v]) => v.words.length > 0).map(([k, v]) => [k, v.words])
+    )
   };
   await saveVoiceoverMeta(outputDir, meta);
   return { voiceoverPath, stepAudio };
@@ -2010,16 +3888,38 @@ export {
   CURSOR_SCRIPT,
   DEFAULT_CAPTIONS,
   DEFAULT_CONFIG,
+  EMPTY_SPAN_SPEED,
   EXCLUDED_LINK_PATTERNS,
-  FEATURES,
+  GIF_DEFAULTS,
   INTERACTIVE_SELECTORS,
-  WIDE_VOICES as LANGUAGE_VOICES,
+  INTERNATIONAL_VOICE,
+  MALE_VOICES2 as MALE_VOICES,
+  MULTILINGUAL_VOICES2 as MULTILINGUAL_VOICES,
+  MUSIC_BED_LUFS,
+  NARRATION_LEAD_IN_MS,
+  NO_CLIP_OUTRO,
+  PLAN_MAX_TOKENS,
+  RATE_FACTOR,
+  RELAY_BASE,
   SERVER_BACKOFF_MS,
+  SIZE_PRESETS,
+  TRIM_EDGE_SILENCE,
   VERSION,
+  VIDEO_PROFILES,
+  VOICE_LEAD_MS,
+  WIDE_VOICES2 as WIDE_VOICES,
   alignVoiceoverToRecording,
+  alignWordsToCaption,
+  applyProfile,
   applyTransitions,
+  ariaLabelSelector,
+  atempoChain,
+  buildCompressionFilter,
   buildConcatArgs,
+  buildGifArgs,
   buildKeepSegments,
+  buildPaletteArgs,
+  buildRetimeFilter,
   buildStepTransitions,
   buildSystemPrompt,
   buildUserPrompt,
@@ -2027,10 +3927,22 @@ export {
   callAI,
   callAIViaRelay,
   canReuseVoiceover,
+  captionCanvas,
   composeVideo,
+  compressSilentSpans,
   concatMedia,
+  concatVideoWithFullFrameOutro,
   concatVideoWithOutro,
+  convertToGif,
+  coverFilterChain,
   crawlPage,
+  cutSpansFromVideo,
+  deStock,
+  defaultCaptionsFor,
+  detectBlackSpans,
+  detectFrozenSpans,
+  detectSilences,
+  detectWhiteSpans,
   estimateWordTimings,
   extractJsonCandidates,
   generateASSHeader,
@@ -2040,14 +3952,21 @@ export {
   getErrorMessage,
   getLanguageName,
   getMediaDuration,
+  getOrRefreshRelayToken,
   getStatus,
   getStatusCached,
   getTierByEmail,
   getUpgradeUrl,
-  hasAccess,
+  getVideoDimensions,
+  getVideoStreamDuration,
+  gotoSettled,
+  hasAudioStream,
   hasTrialRemaining,
+  hasVoice,
   hexToAss as hexToASS,
   idSelector,
+  internationalVoiceFor,
+  intersectSpans,
   isCanceling,
   isExcludedLink,
   isHonestWav,
@@ -2056,22 +3975,39 @@ export {
   loadExistingVoiceover,
   loadVoiceoverMeta,
   mapTimestampsAfterCompression,
+  mergeSpans,
   normalizeUrl,
   parseAIJson,
   parseAIPlanResponse,
   parsePartial,
+  parseWordBoundaries,
+  positionToAlignment,
   pricingUrl,
   registerFreeUser,
+  renderCaptionsAss,
   repairUnicodeEscapes,
-  resolveVoice,
+  resetVoiceEngine,
+  resolveCaptionFont,
+  resolveCaptions,
+  resolveRate,
+  resolveVoice2 as resolveVoice,
+  retimeSpansInVideo,
   rgbaToHex,
+  runPooled,
   salvageTruncatedJson,
   shouldSkipLink,
-  shouldWatermark,
   showPaywall,
+  speakSymbols,
+  speedUpMiddle,
   speedUpVideo,
   spliceVideos,
+  spokenForm,
+  spokenWordTimings,
+  stripLongDashes,
   synthesizeSpeech,
   toTitleCase,
+  trimEdgeSilence,
+  voiceFor,
+  waitForPlaceholdersGone,
   windowsDrivePathToWsl as windowsPathToWSL
 };