@steipete/summarize 0.10.0 → 0.11.1

package/dist/esm/slides/extract.js

@@ -1,11 +1,11 @@
-import { createHash, randomUUID } from 'node:crypto';
-import { promises as fs } from 'node:fs';
-import { tmpdir } from 'node:os';
-import path from 'node:path';
-import { extractYouTubeVideoId, isDirectMediaUrl, isYouTubeUrl } from '../content/index.js';
-import { spawnTracked } from '../processes.js';
-import { resolveExecutableInPath } from '../run/env.js';
-import { buildSlidesDirId, readSlidesCacheIfValid, resolveSlidesDir, serializeSlideImagePath, } from './store.js';
+import { createHash, randomUUID } from "node:crypto";
+import { promises as fs } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { extractYouTubeVideoId, isDirectMediaUrl, isYouTubeUrl } from "../content/index.js";
+import { spawnTracked } from "../processes.js";
+import { resolveExecutableInPath } from "../run/env.js";
+import { buildSlidesDirId, readSlidesCacheIfValid, resolveSlidesDir, serializeSlideImagePath, } from "./store.js";
 const FFMPEG_TIMEOUT_FALLBACK_MS = 300_000;
 const slidesLocks = new Map();
 const YT_DLP_TIMEOUT_MS = 300_000;
@@ -14,7 +14,7 @@ const DEFAULT_SLIDES_WORKERS = 8;
 const DEFAULT_SLIDES_SAMPLE_COUNT = 8;
 // Prefer broadly-decodable H.264/MP4 for ffmpeg stability.
 // (Some "bestvideo" picks AV1 which can fail on certain ffmpeg builds / hwaccel setups.)
-const DEFAULT_YT_DLP_FORMAT_EXTRACT = 'bestvideo[height<=720][vcodec^=avc1][ext=mp4]/best[height<=720][vcodec^=avc1][ext=mp4]/bestvideo[height<=720][ext=mp4]/best[height<=720]';
+const DEFAULT_YT_DLP_FORMAT_EXTRACT = "bestvideo[height<=720][vcodec^=avc1][ext=mp4]/best[height<=720][vcodec^=avc1][ext=mp4]/bestvideo[height<=720][ext=mp4]/best[height<=720]";
 function createSlidesLogger(logger) {
     const logSlides = (message) => {
         if (!logger)
@@ -53,17 +53,21 @@ function resolveSlidesYtDlpExtractFormat(env) {
 }
 function resolveSlidesStreamFallback(env) {
     const raw = env.SLIDES_EXTRACT_STREAM?.trim().toLowerCase();
-    return raw === '1' || raw === 'true' || raw === 'yes';
+    return raw === "1" || raw === "true" || raw === "yes";
+}
+function buildYtDlpCookiesArgs(cookiesFromBrowser) {
+    const value = typeof cookiesFromBrowser === "string" ? cookiesFromBrowser.trim() : "";
+    return value.length > 0 ? ["--cookies-from-browser", value] : [];
 }
 function buildSlidesMediaCacheKey(url) {
     return `${url}#summarize-slides`;
 }
 function formatBytes(bytes) {
     if (!Number.isFinite(bytes) || bytes <= 0)
-        return '0B';
-    const units = ['B', 'KB', 'MB', 'GB', 'TB'];
+        return "0B";
+    const units = ["B", "KB", "MB", "GB", "TB"];
     let value = bytes;
-    let unit = units[0] ?? 'B';
+    let unit = units[0] ?? "B";
     for (let i = 1; i < units.length && value >= 1024; i += 1) {
         value /= 1024;
         unit = units[i] ?? unit;
@@ -72,28 +76,28 @@ function formatBytes(bytes) {
     return `${rounded}${unit}`;
 }
 function resolveToolPath(binary, env, explicitEnvKey) {
-    const explicit = explicitEnvKey && typeof env[explicitEnvKey] === 'string' ? env[explicitEnvKey]?.trim() : '';
+    const explicit = explicitEnvKey && typeof env[explicitEnvKey] === "string" ? env[explicitEnvKey]?.trim() : "";
     if (explicit)
         return resolveExecutableInPath(explicit, env);
     return resolveExecutableInPath(binary, env);
 }
 export function resolveSlideSource({ url, extracted, }) {
     const directUrl = extracted.video?.url ?? extracted.url;
-    const youtubeCandidate = extractYouTubeVideoId(extracted.video?.url ?? '') ??
+    const youtubeCandidate = extractYouTubeVideoId(extracted.video?.url ?? "") ??
         extractYouTubeVideoId(extracted.url) ??
         extractYouTubeVideoId(url);
     if (youtubeCandidate) {
         return {
             url: `https://www.youtube.com/watch?v=${youtubeCandidate}`,
-            kind: 'youtube',
+            kind: "youtube",
             sourceId: buildYoutubeSourceId(youtubeCandidate),
         };
     }
-    if (extracted.video?.kind === 'direct' || isDirectMediaUrl(directUrl) || isDirectMediaUrl(url)) {
+    if (extracted.video?.kind === "direct" || isDirectMediaUrl(directUrl) || isDirectMediaUrl(url)) {
         const normalized = directUrl || url;
         return {
             url: normalized,
-            kind: 'direct',
+            kind: "direct",
             sourceId: buildDirectSourceId(normalized),
         };
     }
@@ -102,7 +106,7 @@ export function resolveSlideSource({ url, extracted, }) {
         if (fallbackId) {
             return {
                 url: `https://www.youtube.com/watch?v=${fallbackId}`,
-                kind: 'youtube',
+                kind: "youtube",
                 sourceId: buildYoutubeSourceId(fallbackId),
             };
         }
@@ -114,14 +118,14 @@ export function resolveSlideSourceFromUrl(url) {
     if (youtubeCandidate) {
         return {
             url: `https://www.youtube.com/watch?v=${youtubeCandidate}`,
-            kind: 'youtube',
+            kind: "youtube",
             sourceId: buildYoutubeSourceId(youtubeCandidate),
         };
     }
     if (isDirectMediaUrl(url)) {
         return {
             url,
-            kind: 'direct',
+            kind: "direct",
             sourceId: buildDirectSourceId(url),
         };
     }
@@ -130,14 +134,14 @@ export function resolveSlideSourceFromUrl(url) {
         if (fallbackId) {
             return {
                 url: `https://www.youtube.com/watch?v=${fallbackId}`,
-                kind: 'youtube',
+                kind: "youtube",
                 sourceId: buildYoutubeSourceId(fallbackId),
             };
         }
     }
     return null;
 }
-export async function extractSlidesForSource({ source, settings, noCache = false, mediaCache = null, env, timeoutMs, ytDlpPath, ffmpegPath, tesseractPath, hooks, }) {
+export async function extractSlidesForSource({ source, settings, noCache = false, mediaCache = null, env, timeoutMs, ytDlpPath, ytDlpCookiesFromBrowser, ffmpegPath, tesseractPath, hooks, }) {
     const slidesDir = resolveSlidesDir(settings.outputDir, source.sourceId);
     return withSlidesLock(slidesDir, async () => {
         const { logSlides, logSlidesTiming } = createSlidesLogger(hooks?.onSlidesLog ?? null);
@@ -152,12 +156,12 @@ export async function extractSlidesForSource({ source, settings, noCache = false
             const onSlidesProgress = hooks?.onSlidesProgress;
             if (!onSlidesProgress)
                 return null;
-            let lastText = '';
+            let lastText = "";
             let lastPercent = 0;
             return (label, percent, detail) => {
                 const clamped = clamp(Math.round(percent), 0, 100);
                 const nextPercent = Math.max(lastPercent, clamped);
-                const suffix = detail ? ` ${detail}` : '';
+                const suffix = detail ? ` ${detail}` : "";
                 const text = `Slides: ${label}${suffix} ${nextPercent}%`;
                 if (text === lastText)
                     return;
@@ -170,20 +174,20 @@ export async function extractSlidesForSource({ source, settings, noCache = false
         const workers = resolveSlidesWorkers(env);
         const totalStartedAt = Date.now();
         logSlides(`pipeline=ingest(sequential)->scene-detect(parallel:${workers})->extract-frames(parallel:${workers})->ocr(parallel:${workers})`);
-        const ffmpegBinary = ffmpegPath ?? resolveToolPath('ffmpeg', env, 'FFMPEG_PATH');
+        const ffmpegBinary = ffmpegPath ?? resolveToolPath("ffmpeg", env, "FFMPEG_PATH");
         if (!ffmpegBinary) {
-            throw new Error('Missing ffmpeg (install ffmpeg or add it to PATH).');
+            throw new Error("Missing ffmpeg (install ffmpeg or add it to PATH).");
         }
-        const ffprobeBinary = resolveToolPath('ffprobe', env, 'FFPROBE_PATH');
+        const ffprobeBinary = resolveToolPath("ffprobe", env, "FFPROBE_PATH");
         if (settings.ocr && !tesseractPath) {
-            const resolved = resolveToolPath('tesseract', env, 'TESSERACT_PATH');
+            const resolved = resolveToolPath("tesseract", env, "TESSERACT_PATH");
             if (!resolved) {
-                throw new Error('Missing tesseract OCR (install tesseract or skip --slides-ocr).');
+                throw new Error("Missing tesseract OCR (install tesseract or skip --slides-ocr).");
             }
             tesseractPath = resolved;
         }
         const ocrEnabled = Boolean(settings.ocr && tesseractPath);
-        const ocrAvailable = Boolean(tesseractPath ?? resolveToolPath('tesseract', env, 'TESSERACT_PATH'));
+        const ocrAvailable = Boolean(tesseractPath ?? resolveToolPath("tesseract", env, "TESSERACT_PATH"));
         const P_PREPARE = 2;
         const P_FETCH_VIDEO = 6;
         const P_DOWNLOAD_VIDEO = 35;
@@ -194,9 +198,9 @@ export async function extractSlidesForSource({ source, settings, noCache = false
         {
             const prepareStartedAt = Date.now();
             await prepareSlidesDir(slidesDir);
-            logSlidesTiming('prepare output dir', prepareStartedAt);
+            logSlidesTiming("prepare output dir", prepareStartedAt);
         }
-        reportSlidesProgress?.('preparing source', P_PREPARE);
+        reportSlidesProgress?.("preparing source", P_PREPARE);
         const allowStreamFallback = resolveSlidesStreamFallback(env);
         let inputPath = source.url;
         let inputCleanup = null;
@@ -204,18 +208,18 @@ export async function extractSlidesForSource({ source, settings, noCache = false
         const cachedMedia = mediaCacheKey ? await mediaCache?.get({ url: mediaCacheKey }) : null;
         if (cachedMedia) {
             inputPath = cachedMedia.filePath;
-            const detail = typeof cachedMedia.sizeBytes === 'number'
+            const detail = typeof cachedMedia.sizeBytes === "number"
                 ? `(${formatBytes(cachedMedia.sizeBytes)})`
                 : undefined;
-            reportSlidesProgress?.('using cached video', P_DOWNLOAD_VIDEO, detail);
+            reportSlidesProgress?.("using cached video", P_DOWNLOAD_VIDEO, detail);
         }
-        else if (source.kind === 'youtube') {
+        else if (source.kind === "youtube") {
             if (!ytDlpPath) {
-                throw new Error('Slides for YouTube require yt-dlp (set YT_DLP_PATH or install yt-dlp).');
+                throw new Error("Slides for YouTube require yt-dlp (set YT_DLP_PATH or install yt-dlp).");
             }
             const ytDlp = ytDlpPath;
             const format = resolveSlidesYtDlpExtractFormat(env);
-            reportSlidesProgress?.('downloading video', P_FETCH_VIDEO);
+            reportSlidesProgress?.("downloading video", P_FETCH_VIDEO);
             const downloadStartedAt = Date.now();
             try {
                 const downloaded = await downloadYoutubeVideo({
@@ -223,10 +227,11 @@ export async function extractSlidesForSource({ source, settings, noCache = false
                     url: source.url,
                     timeoutMs,
                     format,
+                    cookiesFromBrowser: ytDlpCookiesFromBrowser,
                     onProgress: (percent, detail) => {
                         const ratio = clamp(percent / 100, 0, 1);
                         const mapped = P_FETCH_VIDEO + ratio * (P_DOWNLOAD_VIDEO - P_FETCH_VIDEO);
-                        reportSlidesProgress?.('downloading video', mapped, detail);
+                        reportSlidesProgress?.("downloading video", mapped, detail);
                     },
                 });
                 const cached = mediaCacheKey
@@ -245,27 +250,28 @@ export async function extractSlidesForSource({ source, settings, noCache = false
                     throw error;
                 }
                 warnings.push(`Failed to download video; falling back to stream URL: ${String(error)}`);
-                reportSlidesProgress?.('fetching video', P_FETCH_VIDEO);
+                reportSlidesProgress?.("fetching video", P_FETCH_VIDEO);
                 const streamStartedAt = Date.now();
                 const streamUrl = await resolveYoutubeStreamUrl({
                     ytDlpPath: ytDlp,
                     url: source.url,
                     format,
                     timeoutMs,
+                    cookiesFromBrowser: ytDlpCookiesFromBrowser,
                 });
                 inputPath = streamUrl;
                 logSlidesTiming(`yt-dlp stream url (detect+extract, format=${format})`, streamStartedAt);
             }
         }
-        else if (source.kind === 'direct') {
+        else if (source.kind === "direct") {
             const shouldUseYtDlp = !isDirectMediaUrl(source.url);
             if (shouldUseYtDlp) {
                 if (!ytDlpPath) {
-                    throw new Error('Slides for remote videos require yt-dlp (set YT_DLP_PATH or install yt-dlp).');
+                    throw new Error("Slides for remote videos require yt-dlp (set YT_DLP_PATH or install yt-dlp).");
                 }
                 const ytDlp = ytDlpPath;
                 const format = resolveSlidesYtDlpExtractFormat(env);
-                reportSlidesProgress?.('downloading video', P_FETCH_VIDEO);
+                reportSlidesProgress?.("downloading video", P_FETCH_VIDEO);
                 const downloadStartedAt = Date.now();
                 try {
                     const downloaded = await downloadYoutubeVideo({
@@ -273,10 +279,11 @@ export async function extractSlidesForSource({ source, settings, noCache = false
                         url: source.url,
                         timeoutMs,
                         format,
+                        cookiesFromBrowser: ytDlpCookiesFromBrowser,
                         onProgress: (percent, detail) => {
                             const ratio = clamp(percent / 100, 0, 1);
                             const mapped = P_FETCH_VIDEO + ratio * (P_DOWNLOAD_VIDEO - P_FETCH_VIDEO);
-                            reportSlidesProgress?.('downloading video', mapped, detail);
+                            reportSlidesProgress?.("downloading video", mapped, detail);
                         },
                     });
                     const cached = mediaCacheKey
@@ -295,20 +302,21 @@ export async function extractSlidesForSource({ source, settings, noCache = false
                         throw error;
                     }
                     warnings.push(`Failed to download video; falling back to stream URL: ${String(error)}`);
-                    reportSlidesProgress?.('fetching video', P_FETCH_VIDEO);
+                    reportSlidesProgress?.("fetching video", P_FETCH_VIDEO);
                     const streamStartedAt = Date.now();
                     const streamUrl = await resolveYoutubeStreamUrl({
                         ytDlpPath: ytDlp,
                         url: source.url,
                         format,
                         timeoutMs,
+                        cookiesFromBrowser: ytDlpCookiesFromBrowser,
                     });
                     inputPath = streamUrl;
                     logSlidesTiming(`yt-dlp stream url (direct source, format=${format})`, streamStartedAt);
                 }
             }
             else {
-                reportSlidesProgress?.('downloading video', P_FETCH_VIDEO);
+                reportSlidesProgress?.("downloading video", P_FETCH_VIDEO);
                 const downloadStartedAt = Date.now();
                 try {
                     const downloaded = await downloadRemoteVideo({
@@ -317,7 +325,7 @@ export async function extractSlidesForSource({ source, settings, noCache = false
                         onProgress: (percent, detail) => {
                             const ratio = clamp(percent / 100, 0, 1);
                             const mapped = P_FETCH_VIDEO + ratio * (P_DOWNLOAD_VIDEO - P_FETCH_VIDEO);
-                            reportSlidesProgress?.('downloading video', mapped, detail);
+                            reportSlidesProgress?.("downloading video", mapped, detail);
                         },
                     });
                     const cached = mediaCacheKey
@@ -329,7 +337,7 @@ export async function extractSlidesForSource({ source, settings, noCache = false
                         : null;
                     inputPath = cached?.filePath ?? downloaded.filePath;
                     inputCleanup = downloaded.cleanup;
-                    logSlidesTiming('download direct video (detect+extract)', downloadStartedAt);
+                    logSlidesTiming("download direct video (detect+extract)", downloadStartedAt);
                 }
                 catch (error) {
                     if (!allowStreamFallback) {
@@ -342,7 +350,7 @@ export async function extractSlidesForSource({ source, settings, noCache = false
         }
         try {
             const ffmpegStartedAt = Date.now();
-            reportSlidesProgress?.('detecting scenes', P_FETCH_VIDEO + 2);
+            reportSlidesProgress?.("detecting scenes", P_FETCH_VIDEO + 2);
             const detection = await detectSlideTimestamps({
                 ffmpegPath: ffmpegBinary,
                 ffprobePath: ffprobeBinary,
@@ -357,13 +365,13 @@ export async function extractSlidesForSource({ source, settings, noCache = false
                 onSegmentProgress: (completed, total) => {
                     const ratio = total > 0 ? completed / total : 0;
                     const mapped = P_FETCH_VIDEO + 2 + ratio * (P_DETECT_SCENES - (P_FETCH_VIDEO + 2));
-                    reportSlidesProgress?.('detecting scenes', mapped, total > 0 ? `(${completed}/${total})` : undefined);
+                    reportSlidesProgress?.("detecting scenes", mapped, total > 0 ? `(${completed}/${total})` : undefined);
                 },
                 logSlides,
                 logSlidesTiming,
             });
-            reportSlidesProgress?.('detecting scenes', P_DETECT_SCENES);
-            logSlidesTiming('ffmpeg scene-detect', ffmpegStartedAt);
+            reportSlidesProgress?.("detecting scenes", P_DETECT_SCENES);
+            logSlidesTiming("ffmpeg scene-detect", ffmpegStartedAt);
             const interval = buildIntervalTimestamps({
                 durationSeconds: detection.durationSeconds,
                 minDurationSeconds: settings.minDurationSeconds,
@@ -371,7 +379,7 @@ export async function extractSlidesForSource({ source, settings, noCache = false
             });
             const combined = mergeTimestamps(detection.timestamps, interval?.timestamps ?? [], settings.minDurationSeconds);
             if (combined.length === 0) {
-                throw new Error('No slides detected; try adjusting slide extraction settings.');
+                throw new Error("No slides detected; try adjusting slide extraction settings.");
             }
             const sceneSegments = buildSceneSegments(detection.timestamps, detection.durationSeconds);
             const selected = interval?.timestamps.length
@@ -386,7 +394,7 @@ export async function extractSlidesForSource({ source, settings, noCache = false
             const trimmed = applyMaxSlidesFilter(spaced.map((timestamp, index) => {
                 const segment = findSceneSegment(sceneSegments, timestamp);
                 const adjusted = adjustTimestampWithinSegment(timestamp, segment);
-                return { index: index + 1, timestamp: adjusted, imagePath: '', segment };
+                return { index: index + 1, timestamp: adjusted, imagePath: "", segment };
             }), settings.maxSlides, warnings);
             const timelineSlides = {
                 sourceUrl: source.url,
@@ -416,13 +424,13 @@ export async function extractSlidesForSource({ source, settings, noCache = false
                 };
                 for (const slide of trimmed) {
                     const { segment: _segment, ...payload } = slide;
-                    hooks.onSlideChunk({ slide: { ...payload, imagePath: '' }, meta });
+                    hooks.onSlideChunk({ slide: { ...payload, imagePath: "" }, meta });
                 }
             }
-            const formatProgressCount = (completed, total) => total > 0 ? `(${completed}/${total})` : '';
+            const formatProgressCount = (completed, total) => total > 0 ? `(${completed}/${total})` : "";
             const reportFrameProgress = (completed, total) => {
                 const ratio = total > 0 ? completed / total : 0;
-                reportSlidesProgress?.('extracting frames', P_DETECT_SCENES + ratio * (P_EXTRACT_FRAMES - P_DETECT_SCENES), formatProgressCount(completed, total));
+                reportSlidesProgress?.("extracting frames", P_DETECT_SCENES + ratio * (P_EXTRACT_FRAMES - P_DETECT_SCENES), formatProgressCount(completed, total));
             };
             reportFrameProgress(0, trimmed.length);
             const onSlideChunk = hooks?.onSlideChunk;
@@ -455,15 +463,15 @@ export async function extractSlidesForSource({ source, settings, noCache = false
             const extractFramesStartedAt = Date.now();
             const extractedSlides = await extractFrames();
             const extractElapsedMs = logSlidesTiming?.(`extract frames (count=${trimmed.length}, parallel=${workers})`, extractFramesStartedAt);
-            if (trimmed.length > 0 && typeof extractElapsedMs === 'number') {
+            if (trimmed.length > 0 && typeof extractElapsedMs === "number") {
                 logSlides?.(`extract frames avgMsPerFrame=${Math.round(extractElapsedMs / trimmed.length)}`);
             }
             const rawSlides = applyMinDurationFilter(extractedSlides, settings.minDurationSeconds, warnings);
             const renameStartedAt = Date.now();
             const renamedSlides = await renameSlidesWithTimestamps(rawSlides, slidesDir);
-            logSlidesTiming?.('rename slides', renameStartedAt);
+            logSlidesTiming?.("rename slides", renameStartedAt);
             if (renamedSlides.length === 0) {
-                throw new Error('No slides extracted; try lowering --slides-scene-threshold.');
+                throw new Error("No slides extracted; try lowering --slides-scene-threshold.");
             }
             let slidesWithOcr = renamedSlides;
             if (ocrEnabled && tesseractPath) {
@@ -472,16 +480,16 @@ export async function extractSlidesForSource({ source, settings, noCache = false
                 const ocrStartPercent = P_OCR - 3;
                 const reportOcrProgress = (completed, total) => {
                     const ratio = total > 0 ? completed / total : 0;
-                    reportSlidesProgress?.('running OCR', ocrStartPercent + ratio * (P_OCR - ocrStartPercent), formatProgressCount(completed, total));
+                    reportSlidesProgress?.("running OCR", ocrStartPercent + ratio * (P_OCR - ocrStartPercent), formatProgressCount(completed, total));
                 };
                 reportOcrProgress(0, renamedSlides.length);
                 slidesWithOcr = await runOcrOnSlides(renamedSlides, tesseractPath, workers, reportOcrProgress);
-                const elapsedMs = logSlidesTiming?.('ocr done', ocrStartedAt);
-                if (renamedSlides.length > 0 && typeof elapsedMs === 'number') {
+                const elapsedMs = logSlidesTiming?.("ocr done", ocrStartedAt);
+                if (renamedSlides.length > 0 && typeof elapsedMs === "number") {
                     logSlides?.(`ocr avgMsPerSlide=${Math.round(elapsedMs / renamedSlides.length)}`);
                 }
             }
-            reportSlidesProgress?.('finalizing', P_FINAL - 1);
+            reportSlidesProgress?.("finalizing", P_FINAL - 1);
             if (hooks?.onSlideChunk) {
                 for (const slide of slidesWithOcr) {
                     hooks.onSlideChunk({
@@ -513,8 +521,8 @@ export async function extractSlidesForSource({ source, settings, noCache = false
                 warnings,
             };
             await writeSlidesJson(result, slidesDir);
-            reportSlidesProgress?.('finalizing', P_FINAL);
-            logSlidesTiming('slides total', totalStartedAt);
+            reportSlidesProgress?.("finalizing", P_FINAL);
+            logSlidesTiming("slides total", totalStartedAt);
             return result;
         }
         finally {
@@ -523,11 +531,11 @@ export async function extractSlidesForSource({ source, settings, noCache = false
             }
         }
     }, () => {
-        hooks?.onSlidesProgress?.('Slides: queued');
+        hooks?.onSlidesProgress?.("Slides: queued");
     });
 }
 export function parseShowinfoTimestamp(line) {
-    if (!line.includes('showinfo'))
+    if (!line.includes("showinfo"))
         return null;
     const match = /pts_time:(\d+\.?\d*)/.exec(line);
     if (!match)
@@ -542,7 +550,7 @@ export function resolveExtractedTimestamp({ requested, actual, seekBase, }) {
         return 0;
     if (actual == null || !Number.isFinite(actual) || actual < 0)
         return requested;
-    const base = typeof seekBase === 'number' && Number.isFinite(seekBase) && seekBase > 0 ? seekBase : null;
+    const base = typeof seekBase === "number" && Number.isFinite(seekBase) && seekBase > 0 ? seekBase : null;
     if (!base) {
         // With -ss before -i, showinfo PTS resets near 0. Treat small values as offsets.
         if (actual <= 5)
@@ -559,27 +567,28 @@ async function prepareSlidesDir(slidesDir) {
     await fs.mkdir(slidesDir, { recursive: true });
     const entries = await fs.readdir(slidesDir);
     await Promise.all(entries.map(async (entry) => {
-        if (entry.startsWith('slide_') && entry.endsWith('.png')) {
+        if (entry.startsWith("slide_") && entry.endsWith(".png")) {
             await fs.rm(path.join(slidesDir, entry), { force: true });
         }
-        if (entry === 'slides.json') {
+        if (entry === "slides.json") {
             await fs.rm(path.join(slidesDir, entry), { force: true });
         }
     }));
 }
-async function downloadYoutubeVideo({ ytDlpPath, url, timeoutMs, format, onProgress, }) {
+async function downloadYoutubeVideo({ ytDlpPath, url, timeoutMs, format, cookiesFromBrowser, onProgress, }) {
     const dir = await fs.mkdtemp(path.join(tmpdir(), `summarize-slides-${randomUUID()}-`));
-    const outputTemplate = path.join(dir, 'video.%(ext)s');
-    const progressTemplate = 'progress:%(progress.downloaded_bytes)s|%(progress.total_bytes)s|%(progress.total_bytes_estimate)s';
+    const outputTemplate = path.join(dir, "video.%(ext)s");
+    const progressTemplate = "progress:%(progress.downloaded_bytes)s|%(progress.total_bytes)s|%(progress.total_bytes_estimate)s";
     const args = [
-        '-f',
+        "-f",
         format,
-        '--no-playlist',
-        '--no-warnings',
-        '--concurrent-fragments',
-        '4',
-        ...(onProgress ? ['--progress', '--newline', '--progress-template', progressTemplate] : []),
-        '-o',
+        "--no-playlist",
+        "--no-warnings",
+        "--concurrent-fragments",
+        "4",
+        ...buildYtDlpCookiesArgs(cookiesFromBrowser),
+        ...(onProgress ? ["--progress", "--newline", "--progress-template", progressTemplate] : []),
+        "-o",
         outputTemplate,
         url,
     ];
@@ -587,14 +596,14 @@ async function downloadYoutubeVideo({ ytDlpPath, url, timeoutMs, format, onProgr
         command: ytDlpPath,
         args,
         timeoutMs: Math.max(timeoutMs, YT_DLP_TIMEOUT_MS),
-        errorLabel: 'yt-dlp',
+        errorLabel: "yt-dlp",
         onStderrLine: (line, handle) => {
             if (!onProgress)
                 return;
             const trimmed = line.trim();
-            if (trimmed.startsWith('progress:')) {
-                const payload = trimmed.slice('progress:'.length);
-                const [downloadedRaw, totalRaw, estimateRaw] = payload.split('|');
+            if (trimmed.startsWith("progress:")) {
+                const payload = trimmed.slice("progress:".length);
+                const [downloadedRaw, totalRaw, estimateRaw] = payload.split("|");
                 const downloaded = Number.parseFloat(downloadedRaw);
                 if (!Number.isFinite(downloaded) || downloaded < 0)
                     return;
@@ -613,7 +622,7 @@ async function downloadYoutubeVideo({ ytDlpPath, url, timeoutMs, format, onProgr
                 handle?.setProgress(percent, detail);
                 return;
             }
-            if (!trimmed.startsWith('[download]'))
+            if (!trimmed.startsWith("[download]"))
                 return;
             const percentMatch = trimmed.match(/\b(\d{1,3}(?:\.\d+)?)%\b/);
             if (!percentMatch)
@@ -627,16 +636,16 @@ async function downloadYoutubeVideo({ ytDlpPath, url, timeoutMs, format, onProgr
                 speedMatch?.[1] ? `at ${speedMatch[1]}` : null,
                 etaMatch?.[1] ? `ETA ${etaMatch[1]}` : null,
             ].filter(Boolean);
-            const detail = detailParts.length ? detailParts.join(' ') : undefined;
+            const detail = detailParts.length ? detailParts.join(" ") : undefined;
             onProgress(percent, detail);
             handle?.setProgress(percent, detail ?? null);
         },
         onStdoutLine: onProgress
             ? (line, handle) => {
-                if (!line.trim().startsWith('progress:'))
+                if (!line.trim().startsWith("progress:"))
                     return;
-                const payload = line.trim().slice('progress:'.length);
-                const [downloadedRaw, totalRaw, estimateRaw] = payload.split('|');
+                const payload = line.trim().slice("progress:".length);
+                const [downloadedRaw, totalRaw, estimateRaw] = payload.split("|");
                 const downloaded = Number.parseFloat(downloadedRaw);
                 if (!Number.isFinite(downloaded) || downloaded < 0)
                     return;
@@ -659,7 +668,7 @@ async function downloadYoutubeVideo({ ytDlpPath, url, timeoutMs, format, onProgr
     const files = await fs.readdir(dir);
     const candidates = [];
     for (const entry of files) {
-        if (entry.endsWith('.part') || entry.endsWith('.ytdl'))
+        if (entry.endsWith(".part") || entry.endsWith(".ytdl"))
             continue;
         const filePath = path.join(dir, entry);
         const stat = await fs.stat(filePath).catch(() => null);
@@ -669,7 +678,7 @@ async function downloadYoutubeVideo({ ytDlpPath, url, timeoutMs, format, onProgr
     }
     if (candidates.length === 0) {
         await fs.rm(dir, { recursive: true, force: true });
-        throw new Error('yt-dlp completed but no video file was downloaded.');
+        throw new Error("yt-dlp completed but no video file was downloaded.");
     }
     candidates.sort((a, b) => b.size - a.size);
     const filePath = candidates[0].filePath;
@@ -682,7 +691,7 @@ async function downloadYoutubeVideo({ ytDlpPath, url, timeoutMs, format, onProgr
 }
 async function downloadRemoteVideo({ url, timeoutMs, onProgress, }) {
     const dir = await fs.mkdtemp(path.join(tmpdir(), `summarize-slides-${randomUUID()}-`));
-    let suffix = '.bin';
+    let suffix = ".bin";
     try {
         const parsed = new URL(url);
         const ext = path.extname(parsed.pathname);
@@ -700,14 +709,14 @@ async function downloadRemoteVideo({ url, timeoutMs, onProgress, }) {
         if (!res.ok) {
             throw new Error(`Download failed: ${res.status} ${res.statusText}`);
         }
-        const totalRaw = res.headers.get('content-length');
+        const totalRaw = res.headers.get("content-length");
         const total = totalRaw ? Number(totalRaw) : 0;
         const hasTotal = Number.isFinite(total) && total > 0;
         const reader = res.body?.getReader();
         if (!reader) {
-            throw new Error('Download failed: missing response body');
+            throw new Error("Download failed: missing response body");
         }
-        const handle = await fs.open(filePath, 'w');
+        const handle = await fs.open(filePath, "w");
         let downloaded = 0;
         let lastPercent = -1;
         let lastReportedBytes = 0;
@@ -761,20 +770,20 @@ async function downloadRemoteVideo({ url, timeoutMs, onProgress, }) {
         clearTimeout(timeout);
     }
 }
-async function resolveYoutubeStreamUrl({ ytDlpPath, url, timeoutMs, format, }) {
-    const args = ['-f', format, '-g', url];
+async function resolveYoutubeStreamUrl({ ytDlpPath, url, timeoutMs, format, cookiesFromBrowser, }) {
+    const args = ["-f", format, ...buildYtDlpCookiesArgs(cookiesFromBrowser), "-g", url];
     const output = await runProcessCapture({
         command: ytDlpPath,
         args,
         timeoutMs: Math.max(timeoutMs, YT_DLP_TIMEOUT_MS),
-        errorLabel: 'yt-dlp',
+        errorLabel: "yt-dlp",
     });
     const lines = output
-        .split('\n')
+        .split("\n")
         .map((line) => line.trim())
         .filter(Boolean);
     if (lines.length === 0) {
-        throw new Error('yt-dlp did not return a stream URL.');
+        throw new Error("yt-dlp did not return a stream URL.");
     }
     return lines[0];
 }
@@ -786,7 +795,7 @@ async function detectSlideTimestamps({ ffmpegPath, ffprobePath, inputPath, scene
         inputPath,
         timeoutMs,
     });
-    logSlidesTiming?.('ffprobe video info', probeStartedAt);
+    logSlidesTiming?.("ffprobe video info", probeStartedAt);
     const calibration = await calibrateSceneThreshold({
         ffmpegPath,
         inputPath,
@@ -839,13 +848,13 @@ async function detectSlideTimestamps({ ffmpegPath, ffprobePath, inputPath, scene
             enabled: true,
             chosenThreshold: timestamps.length > 0 ? effectiveThreshold : baseThreshold,
             confidence: calibration.confidence,
-            strategy: 'hash',
+            strategy: "hash",
         }
         : {
             enabled: false,
             chosenThreshold: baseThreshold,
             confidence: 0,
-            strategy: 'none',
+            strategy: "none",
         };
     return { timestamps, autoTune, durationSeconds: videoInfo.durationSeconds };
 }
@@ -856,7 +865,7 @@ async function extractFramesAtTimestamps({ ffmpegPath, inputPath, outputDir, tim
     const FRAME_MIN_CONTRAST = 0.16;
     const SEEK_PAD_SECONDS = 8;
     const clampTimestamp = (value) => {
-        const upper = typeof durationSeconds === 'number' && Number.isFinite(durationSeconds) && durationSeconds > 0
+        const upper = typeof durationSeconds === "number" && Number.isFinite(durationSeconds) && durationSeconds > 0
             ? Math.max(0, durationSeconds - 0.1)
             : Number.POSITIVE_INFINITY;
         return clamp(value, 0, upper);
@@ -865,7 +874,7 @@ async function extractFramesAtTimestamps({ ffmpegPath, inputPath, outputDir, tim
         if (!segment)
             return null;
         const start = Math.max(0, segment.start);
-        const end = typeof segment.end === 'number' && Number.isFinite(segment.end) ? segment.end : null;
+        const end = typeof segment.end === "number" && Number.isFinite(segment.end) ? segment.end : null;
         if (end != null && end <= start)
             return null;
         return { start, end };
@@ -879,7 +888,7 @@ async function extractFramesAtTimestamps({ ffmpegPath, inputPath, outputDir, tim
         return Math.min(1.5, Math.max(0.2, duration * 0.08));
     };
     const parseSignalstats = (line, stats) => {
-        if (!line.includes('lavfi.signalstats.'))
+        if (!line.includes("lavfi.signalstats."))
             return;
         const match = line.match(/lavfi\.signalstats\.(YMIN|YMAX|YAVG)=(\d+(?:\.\d+)?)/);
         if (!match)
@@ -887,11 +896,11 @@ async function extractFramesAtTimestamps({ ffmpegPath, inputPath, outputDir, tim
         const value = Number(match[2]);
         if (!Number.isFinite(value))
             return;
-        if (match[1] === 'YMIN')
+        if (match[1] === "YMIN")
             stats.ymin = value;
-        if (match[1] === 'YMAX')
+        if (match[1] === "YMAX")
             stats.ymax = value;
-        if (match[1] === 'YAVG')
+        if (match[1] === "YAVG")
             stats.yavg = value;
     };
     const toQuality = (stats) => {
@@ -909,34 +918,34 @@ async function extractFramesAtTimestamps({ ffmpegPath, inputPath, outputDir, tim
     const extractFrame = async (timestamp, outputPath, opts) => {
         const stats = { ymin: null, ymax: null, yavg: null };
         let actualTimestamp = null;
-        const effectiveTimeoutMs = typeof opts?.timeoutMs === 'number' && Number.isFinite(opts.timeoutMs) && opts.timeoutMs > 0
+        const effectiveTimeoutMs = typeof opts?.timeoutMs === "number" && Number.isFinite(opts.timeoutMs) && opts.timeoutMs > 0
             ? opts.timeoutMs
             : timeoutMs;
         const seekBase = Math.max(0, timestamp - SEEK_PAD_SECONDS);
         const seekOffset = Math.max(0, timestamp - seekBase);
         const args = [
-            '-hide_banner',
-            ...(seekBase > 0 ? ['-ss', String(seekBase)] : []),
-            '-i',
+            "-hide_banner",
+            ...(seekBase > 0 ? ["-ss", String(seekBase)] : []),
+            "-i",
             inputPath,
-            ...(seekOffset > 0 ? ['-ss', String(seekOffset)] : []),
-            '-vf',
-            'signalstats,showinfo,metadata=print',
-            '-vframes',
-            '1',
-            '-q:v',
-            '2',
-            '-an',
-            '-sn',
-            '-update',
-            '1',
+            ...(seekOffset > 0 ? ["-ss", String(seekOffset)] : []),
+            "-vf",
+            "signalstats,showinfo,metadata=print",
+            "-vframes",
+            "1",
+            "-q:v",
+            "2",
+            "-an",
+            "-sn",
+            "-update",
+            "1",
             outputPath,
         ];
         await runProcess({
             command: ffmpegPath,
             args,
             timeoutMs: effectiveTimeoutMs,
-            errorLabel: 'ffmpeg',
+            errorLabel: "ffmpeg",
             onStderrLine: (line) => {
                 if (actualTimestamp == null) {
                     const parsed = parseShowinfoTimestamp(line);
@@ -972,7 +981,7 @@ async function extractFramesAtTimestamps({ ffmpegPath, inputPath, outputDir, tim
             : bounds
                 ? Math.max(bounds.start + padding, clampedTimestamp)
                 : clampedTimestamp;
-        const outputPath = path.join(outputDir, `slide_${String(index + 1).padStart(4, '0')}.png`);
+        const outputPath = path.join(outputDir, `slide_${String(index + 1).padStart(4, "0")}.png`);
         const extracted = await extractFrame(safeTimestamp, outputPath);
         const resolvedTimestamp = resolveExtractedTimestamp({
             requested: safeTimestamp,
@@ -983,7 +992,7 @@ async function extractFramesAtTimestamps({ ffmpegPath, inputPath, outputDir, tim
         if (Math.abs(delta) >= 0.25) {
             const actualLabel = extracted.actualTimestamp != null && Number.isFinite(extracted.actualTimestamp)
                 ? extracted.actualTimestamp.toFixed(2)
-                : 'n/a';
+                : "n/a";
             logSlides?.(`frame pts slide=${index + 1} req=${safeTimestamp.toFixed(2)}s actual=${actualLabel}s base=${extracted.seekBase.toFixed(2)}s -> ${resolvedTimestamp.toFixed(2)}s delta=${delta.toFixed(2)}s`);
         }
         const imageVersion = Date.now();
@@ -1056,7 +1065,7 @@ async function extractFramesAtTimestamps({ ffmpegPath, inputPath, outputDir, tim
                 const candidateTimestamp = clamp(baseTimestamp + offsetSeconds, minTs, maxTs);
                 if (Math.abs(candidateTimestamp - baseTimestamp) < 0.01)
                     continue;
-                const tempPath = path.join(outputDir, `slide_${String(frame.index).padStart(4, '0')}_alt.png`);
+                const tempPath = path.join(outputDir, `slide_${String(frame.index).padStart(4, "0")}_alt.png`);
                 try {
                     const candidate = await extractFrame(candidateTimestamp, tempPath, {
                         timeoutMs: Math.min(timeoutMs, 12_000),
@@ -1080,8 +1089,8 @@ async function extractFramesAtTimestamps({ ffmpegPath, inputPath, outputDir, tim
                             await fs.rename(tempPath, frame.imagePath);
                         }
                         catch (err) {
-                            const code = err && typeof err === 'object' && 'code' in err ? String(err.code) : '';
-                            if (code === 'EEXIST') {
+                            const code = err && typeof err === "object" && "code" in err ? String(err.code) : "";
+                            if (code === "EEXIST") {
                                 await fs.rm(frame.imagePath, { force: true }).catch(() => null);
                                 await fs.rename(tempPath, frame.imagePath);
                             }
@@ -1137,7 +1146,7 @@ async function extractFramesAtTimestamps({ ffmpegPath, inputPath, outputDir, tim
             onStatus?.(`Slides: improving thumbnails ${percent}%`);
         });
         onStatus?.(`Slides: improving thumbnails ${THUMB_END}%`);
-        logSlidesTiming?.('thumbnail adjust done', fixStartedAt);
+        logSlidesTiming?.("thumbnail adjust done", fixStartedAt);
     }
     logSlidesTiming?.(`extract frame loop (count=${timestamps.length}, workers=${workers})`, startedAt);
     return slides;
@@ -1241,28 +1250,28 @@ async function detectSceneTimestamps({ ffmpegPath, inputPath, threshold, timeout
     const concurrency = workers && workers > 0 ? workers : 1;
     const tasks = usedSegments.map((segment) => async () => {
         const args = [
-            '-hide_banner',
+            "-hide_banner",
             ...(segment.duration > 0
-                ? ['-ss', String(segment.start), '-t', String(segment.duration)]
+                ? ["-ss", String(segment.start), "-t", String(segment.duration)]
                 : []),
-            '-i',
+            "-i",
             inputPath,
-            '-vf',
+            "-vf",
             filter,
-            '-fps_mode',
-            'vfr',
-            '-an',
-            '-sn',
-            '-f',
-            'null',
-            '-',
+            "-fps_mode",
+            "vfr",
+            "-an",
+            "-sn",
+            "-f",
+            "null",
+            "-",
         ];
         const timestamps = [];
         await runProcess({
             command: ffmpegPath,
             args,
             timeoutMs: Math.max(timeoutMs, FFMPEG_TIMEOUT_FALLBACK_MS),
-            errorLabel: 'ffmpeg',
+            errorLabel: "ffmpeg",
             onStderrLine: (line) => {
                 const ts = parseShowinfoTimestamp(line);
                 if (ts != null)
@@ -1277,29 +1286,29 @@ async function detectSceneTimestamps({ ffmpegPath, inputPath, threshold, timeout
     return merged;
 }
 async function hashFrameAtTimestamp({ ffmpegPath, inputPath, timestamp, timeoutMs, }) {
-    const filter = 'scale=32:32,format=gray';
+    const filter = "scale=32:32,format=gray";
     const args = [
-        '-hide_banner',
-        '-ss',
+        "-hide_banner",
+        "-ss",
         String(timestamp),
-        '-i',
+        "-i",
         inputPath,
-        '-frames:v',
-        '1',
-        '-vf',
+        "-frames:v",
+        "1",
+        "-vf",
         filter,
-        '-f',
-        'rawvideo',
-        '-pix_fmt',
-        'gray',
-        '-',
+        "-f",
+        "rawvideo",
+        "-pix_fmt",
+        "gray",
+        "-",
     ];
     try {
         const buffer = await runProcessCaptureBuffer({
             command: ffmpegPath,
             args,
             timeoutMs,
-            errorLabel: 'ffmpeg',
+            errorLabel: "ffmpeg",
         });
         if (buffer.length < 1024)
             return null;
@@ -1331,26 +1340,26 @@ function computeHashDistanceRatio(a, b) {
     return len === 0 ? 0 : diff / len;
 }
 async function probeVideoInfo({ ffprobePath, env, inputPath, timeoutMs, }) {
-    const probeBin = ffprobePath ?? resolveExecutableInPath('ffprobe', env);
+    const probeBin = ffprobePath ?? resolveExecutableInPath("ffprobe", env);
     if (!probeBin)
         return { durationSeconds: null, width: null, height: null };
-    const args = ['-v', 'quiet', '-print_format', 'json', '-show_format', '-show_streams', inputPath];
+    const args = ["-v", "quiet", "-print_format", "json", "-show_format", "-show_streams", inputPath];
     try {
         const output = await runProcessCapture({
             command: probeBin,
             args,
             timeoutMs: Math.min(timeoutMs, 30_000),
-            errorLabel: 'ffprobe',
+            errorLabel: "ffprobe",
         });
         const parsed = JSON.parse(output);
         let durationSeconds = null;
         let width = null;
         let height = null;
         for (const stream of parsed.streams ?? []) {
-            if (stream.codec_type === 'video') {
-                if (width == null && typeof stream.width === 'number')
+            if (stream.codec_type === "video") {
+                if (width == null && typeof stream.width === "number")
                     width = stream.width;
-                if (height == null && typeof stream.height === 'number')
+                if (height == null && typeof stream.height === "number")
                     height = stream.height;
                 const duration = Number(stream.duration);
                 if (Number.isFinite(duration) && duration > 0)
@@ -1371,30 +1380,30 @@ async function probeVideoInfo({ ffprobePath, env, inputPath, timeoutMs, }) {
 async function runProcess({ command, args, timeoutMs, errorLabel, onStderrLine, onStdoutLine, }) {
     await new Promise((resolve, reject) => {
         const { proc, handle } = spawnTracked(command, args, {
-            stdio: ['ignore', 'pipe', 'pipe'],
+            stdio: ["ignore", "pipe", "pipe"],
             label: errorLabel,
             kind: errorLabel,
             captureOutput: false,
         });
-        let stderr = '';
-        let stderrBuffer = '';
-        let stdoutBuffer = '';
+        let stderr = "";
+        let stderrBuffer = "";
+        let stdoutBuffer = "";
         const flushLine = (line) => {
             if (onStderrLine)
                 onStderrLine(line, handle);
-            handle?.appendOutput('stderr', line);
+            handle?.appendOutput("stderr", line);
             if (stderr.length < 8192) {
                 stderr += line;
-                if (!line.endsWith('\n'))
-                    stderr += '\n';
+                if (!line.endsWith("\n"))
+                    stderr += "\n";
             }
         };
         if (proc.stderr) {
-            proc.stderr.setEncoding('utf8');
-            proc.stderr.on('data', (chunk) => {
+            proc.stderr.setEncoding("utf8");
+            proc.stderr.on("data", (chunk) => {
                 stderrBuffer += chunk;
                 const lines = stderrBuffer.split(/\r?\n/);
-                stderrBuffer = lines.pop() ?? '';
+                stderrBuffer = lines.pop() ?? "";
                 for (const line of lines) {
                     if (line)
                         flushLine(line);
@@ -1404,29 +1413,29 @@ async function runProcess({ command, args, timeoutMs, errorLabel, onStderrLine,
         if (proc.stdout) {
             const handleStdoutLine = onStdoutLine ?? onStderrLine;
             if (handleStdoutLine) {
-                proc.stdout.setEncoding('utf8');
-                proc.stdout.on('data', (chunk) => {
+                proc.stdout.setEncoding("utf8");
+                proc.stdout.on("data", (chunk) => {
                     stdoutBuffer += chunk;
                     const lines = stdoutBuffer.split(/\r?\n/);
-                    stdoutBuffer = lines.pop() ?? '';
+                    stdoutBuffer = lines.pop() ?? "";
                     for (const line of lines) {
                         if (!line)
                             continue;
                         handleStdoutLine(line, handle);
-                        handle?.appendOutput('stdout', line);
+                        handle?.appendOutput("stdout", line);
                     }
                 });
             }
         }
         const timeout = setTimeout(() => {
-            proc.kill('SIGKILL');
+            proc.kill("SIGKILL");
             reject(new Error(`${errorLabel} timed out`));
         }, timeoutMs);
-        proc.on('error', (error) => {
+        proc.on("error", (error) => {
             clearTimeout(timeout);
             reject(error);
         });
-        proc.on('close', (code) => {
+        proc.on("close", (code) => {
             clearTimeout(timeout);
             if (stderrBuffer.trim().length > 0) {
                 flushLine(stderrBuffer.trim());
@@ -1435,13 +1444,13 @@ async function runProcess({ command, args, timeoutMs, errorLabel, onStderrLine,
                 const handleStdoutLine = onStdoutLine ?? onStderrLine;
                 if (handleStdoutLine)
                     handleStdoutLine(stdoutBuffer.trim(), handle);
-                handle?.appendOutput('stdout', stdoutBuffer.trim());
+                handle?.appendOutput("stdout", stdoutBuffer.trim());
             }
             if (code === 0) {
                 resolve();
                 return;
             }
-            const suffix = stderr.trim() ? `: ${stderr.trim()}` : '';
+            const suffix = stderr.trim() ? `: ${stderr.trim()}` : "";
             reject(new Error(`${errorLabel} exited with code ${code}${suffix}`));
         });
     });
@@ -1513,7 +1522,7 @@ function buildSceneSegments(sceneTimestamps, durationSeconds) {
     for (let i = 0; i < starts.length; i += 1) {
         const start = starts[i];
         const rawEnd = ends[i];
-        const end = typeof rawEnd === 'number' && Number.isFinite(rawEnd) && rawEnd > start ? rawEnd : null;
+        const end = typeof rawEnd === "number" && Number.isFinite(rawEnd) && rawEnd > start ? rawEnd : null;
         segments.push({ start, end });
     }
     return segments;
@@ -1595,62 +1604,62 @@ function buildIntervalTimestamps({ durationSeconds, minDurationSeconds, maxSlide
 async function runProcessCapture({ command, args, timeoutMs, errorLabel, }) {
     return new Promise((resolve, reject) => {
         const { proc, handle } = spawnTracked(command, args, {
-            stdio: ['ignore', 'pipe', 'pipe'],
+            stdio: ["ignore", "pipe", "pipe"],
             label: errorLabel,
             kind: errorLabel,
             captureOutput: false,
         });
-        let stdout = '';
-        let stderr = '';
-        let stdoutBuffer = '';
-        let stderrBuffer = '';
+        let stdout = "";
+        let stderr = "";
+        let stdoutBuffer = "";
+        let stderrBuffer = "";
         const timeout = setTimeout(() => {
-            proc.kill('SIGKILL');
+            proc.kill("SIGKILL");
             reject(new Error(`${errorLabel} timed out`));
         }, timeoutMs);
         if (proc.stdout) {
-            proc.stdout.setEncoding('utf8');
-            proc.stdout.on('data', (chunk) => {
+            proc.stdout.setEncoding("utf8");
+            proc.stdout.on("data", (chunk) => {
                 stdout += chunk;
                 stdoutBuffer += chunk;
                 const lines = stdoutBuffer.split(/\r?\n/);
-                stdoutBuffer = lines.pop() ?? '';
+                stdoutBuffer = lines.pop() ?? "";
                 for (const line of lines) {
                     if (line)
-                        handle?.appendOutput('stdout', line);
+                        handle?.appendOutput("stdout", line);
                 }
             });
         }
         if (proc.stderr) {
-            proc.stderr.setEncoding('utf8');
-            proc.stderr.on('data', (chunk) => {
+            proc.stderr.setEncoding("utf8");
+            proc.stderr.on("data", (chunk) => {
                 if (stderr.length < 8192) {
                     stderr += chunk;
                 }
                 stderrBuffer += chunk;
                 const lines = stderrBuffer.split(/\r?\n/);
-                stderrBuffer = lines.pop() ?? '';
+                stderrBuffer = lines.pop() ?? "";
                 for (const line of lines) {
                     if (line)
-                        handle?.appendOutput('stderr', line);
+                        handle?.appendOutput("stderr", line);
                 }
             });
         }
-        proc.on('error', (error) => {
+        proc.on("error", (error) => {
             clearTimeout(timeout);
             reject(error);
         });
-        proc.on('close', (code) => {
+        proc.on("close", (code) => {
             clearTimeout(timeout);
             if (stdoutBuffer.trim())
-                handle?.appendOutput('stdout', stdoutBuffer.trim());
+                handle?.appendOutput("stdout", stdoutBuffer.trim());
             if (stderrBuffer.trim())
-                handle?.appendOutput('stderr', stderrBuffer.trim());
+                handle?.appendOutput("stderr", stderrBuffer.trim());
             if (code === 0) {
                 resolve(stdout);
                 return;
             }
-            const suffix = stderr.trim() ? `: ${stderr.trim()}` : '';
+            const suffix = stderr.trim() ? `: ${stderr.trim()}` : "";
             reject(new Error(`${errorLabel} exited with code ${code}${suffix}`));
         });
     });
@@ -1658,51 +1667,51 @@ async function runProcessCapture({ command, args, timeoutMs, errorLabel, }) {
 async function runProcessCaptureBuffer({ command, args, timeoutMs, errorLabel, }) {
     return new Promise((resolve, reject) => {
         const { proc, handle } = spawnTracked(command, args, {
-            stdio: ['ignore', 'pipe', 'pipe'],
+            stdio: ["ignore", "pipe", "pipe"],
             label: errorLabel,
             kind: errorLabel,
             captureOutput: false,
         });
         const chunks = [];
-        let stderr = '';
-        let stderrBuffer = '';
+        let stderr = "";
+        let stderrBuffer = "";
         const timeout = setTimeout(() => {
-            proc.kill('SIGKILL');
+            proc.kill("SIGKILL");
             reject(new Error(`${errorLabel} timed out`));
         }, timeoutMs);
         if (proc.stdout) {
-            proc.stdout.on('data', (chunk) => {
+            proc.stdout.on("data", (chunk) => {
                 chunks.push(chunk);
             });
         }
         if (proc.stderr) {
-            proc.stderr.setEncoding('utf8');
-            proc.stderr.on('data', (chunk) => {
+            proc.stderr.setEncoding("utf8");
+            proc.stderr.on("data", (chunk) => {
                 if (stderr.length < 8192) {
                     stderr += chunk;
                 }
                 stderrBuffer += chunk;
                 const lines = stderrBuffer.split(/\r?\n/);
-                stderrBuffer = lines.pop() ?? '';
+                stderrBuffer = lines.pop() ?? "";
                 for (const line of lines) {
                     if (line)
-                        handle?.appendOutput('stderr', line);
+                        handle?.appendOutput("stderr", line);
                 }
             });
         }
-        proc.on('error', (error) => {
+        proc.on("error", (error) => {
             clearTimeout(timeout);
             reject(error);
         });
-        proc.on('close', (code) => {
+        proc.on("close", (code) => {
             clearTimeout(timeout);
             if (stderrBuffer.trim())
-                handle?.appendOutput('stderr', stderrBuffer.trim());
+                handle?.appendOutput("stderr", stderrBuffer.trim());
             if (code === 0) {
                 resolve(Buffer.concat(chunks));
                 return;
             }
-            const suffix = stderr.trim() ? `: ${stderr.trim()}` : '';
+            const suffix = stderr.trim() ? `: ${stderr.trim()}` : "";
             reject(new Error(`${errorLabel} exited with code ${code}${suffix}`));
         });
     });
@@ -1724,7 +1733,7 @@ async function renameSlidesWithTimestamps(slides, slidesDir) {
     const renamed = [];
     for (const slide of slides) {
         const timestampLabel = slide.timestamp.toFixed(2);
-        const filename = `slide_${slide.index.toString().padStart(4, '0')}_${timestampLabel}s.png`;
+        const filename = `slide_${slide.index.toString().padStart(4, "0")}_${timestampLabel}s.png`;
         const nextPath = path.join(slidesDir, filename);
         if (slide.imagePath !== nextPath) {
             await fs.rename(slide.imagePath, nextPath).catch(async () => {
@@ -1795,7 +1804,7 @@ async function runOcrOnSlides(slides, tesseractPath, workers, onProgress) {
             };
         }
         catch {
-            return { ...slide, ocrText: '', ocrConfidence: 0 };
+            return { ...slide, ocrText: "", ocrConfidence: 0 };
         }
     });
     const results = await runWithConcurrency(tasks, workers, onProgress ?? undefined);
@@ -1803,54 +1812,54 @@ async function runOcrOnSlides(slides, tesseractPath, workers, onProgress) {
 }
 async function runTesseract(tesseractPath, imagePath) {
     return new Promise((resolve, reject) => {
-        const args = [imagePath, 'stdout', '--oem', '3', '--psm', '6'];
+        const args = [imagePath, "stdout", "--oem", "3", "--psm", "6"];
         const { proc, handle } = spawnTracked(tesseractPath, args, {
-            stdio: ['ignore', 'pipe', 'pipe'],
-            label: 'tesseract',
-            kind: 'tesseract',
+            stdio: ["ignore", "pipe", "pipe"],
+            label: "tesseract",
+            kind: "tesseract",
             captureOutput: false,
         });
-        let stdout = '';
-        let stderr = '';
-        let stderrBuffer = '';
+        let stdout = "";
+        let stderr = "";
+        let stderrBuffer = "";
         const timeout = setTimeout(() => {
-            proc.kill('SIGKILL');
-            reject(new Error('tesseract timed out'));
+            proc.kill("SIGKILL");
+            reject(new Error("tesseract timed out"));
         }, TESSERACT_TIMEOUT_MS);
         if (proc.stdout) {
-            proc.stdout.setEncoding('utf8');
-            proc.stdout.on('data', (chunk) => {
+            proc.stdout.setEncoding("utf8");
+            proc.stdout.on("data", (chunk) => {
                 stdout += chunk;
             });
         }
         if (proc.stderr) {
-            proc.stderr.setEncoding('utf8');
-            proc.stderr.on('data', (chunk) => {
+            proc.stderr.setEncoding("utf8");
+            proc.stderr.on("data", (chunk) => {
                 if (stderr.length < 8192) {
                     stderr += chunk;
                 }
                 stderrBuffer += chunk;
                 const lines = stderrBuffer.split(/\r?\n/);
-                stderrBuffer = lines.pop() ?? '';
+                stderrBuffer = lines.pop() ?? "";
                 for (const line of lines) {
                     if (line)
-                        handle?.appendOutput('stderr', line);
+                        handle?.appendOutput("stderr", line);
                 }
             });
         }
-        proc.on('error', (error) => {
+        proc.on("error", (error) => {
             clearTimeout(timeout);
             reject(error);
         });
-        proc.on('close', (code) => {
+        proc.on("close", (code) => {
             clearTimeout(timeout);
             if (stderrBuffer.trim())
-                handle?.appendOutput('stderr', stderrBuffer.trim());
+                handle?.appendOutput("stderr", stderrBuffer.trim());
             if (code === 0) {
                 resolve(stdout);
                 return;
             }
-            const suffix = stderr.trim() ? `: ${stderr.trim()}` : '';
+            const suffix = stderr.trim() ? `: ${stderr.trim()}` : "";
             reject(new Error(`tesseract exited with code ${code}${suffix}`));
         });
     });
@@ -1860,9 +1869,9 @@ function cleanOcrText(text) {
         .split(/\r?\n/)
         .map((line) => line.trim())
         .filter((line) => line.length >= 2)
-        .filter((line) => !(line.length > 20 && !line.includes(' ')))
+        .filter((line) => !(line.length > 20 && !line.includes(" ")))
         .filter((line) => /[a-z0-9]/i.test(line));
-    return lines.join('\n');
+    return lines.join("\n");
 }
 function estimateOcrConfidence(text) {
     if (!text)
@@ -1895,7 +1904,7 @@ async function writeSlidesJson(result, slidesDir) {
             imagePath: serializeSlideImagePath(slidesDir, slide.imagePath),
         })),
     };
-    await fs.writeFile(path.join(slidesDir, 'slides.json'), JSON.stringify(payload, null, 2), 'utf8');
+    await fs.writeFile(path.join(slidesDir, "slides.json"), JSON.stringify(payload, null, 2), "utf8");
 }
 function buildDirectSourceId(url) {
     const parsed = (() => {
@@ -1907,11 +1916,11 @@ function buildDirectSourceId(url) {
         }
     })();
     const hostSlug = resolveHostSlug(parsed);
-    const rawName = parsed ? path.basename(parsed.pathname) : 'video';
-    const base = rawName.replace(/\.[a-z0-9]+$/i, '').trim() || 'video';
+    const rawName = parsed ? path.basename(parsed.pathname) : "video";
+    const base = rawName.replace(/\.[a-z0-9]+$/i, "").trim() || "video";
     const slug = toSlug(base);
-    const combined = [hostSlug, slug].filter(Boolean).join('-');
-    const hash = createHash('sha1').update(url).digest('hex').slice(0, 8);
+    const combined = [hostSlug, slug].filter(Boolean).join("-");
+    const hash = createHash("sha1").update(url).digest("hex").slice(0, 8);
     return combined ? `${combined}-${hash}` : `video-${hash}`;
 }
 function buildYoutubeSourceId(videoId) {
@@ -1921,8 +1930,8 @@ function resolveHostSlug(parsed) {
     if (!parsed?.hostname)
         return null;
     const host = parsed.hostname.toLowerCase();
-    if (host.includes('youtube.com') || host === 'youtu.be' || host.includes('youtu.be')) {
-        return 'youtube';
+    if (host.includes("youtube.com") || host === "youtu.be" || host.includes("youtu.be")) {
+        return "youtube";
     }
     const slug = toSlug(host);
     return slug || null;
@@ -1930,13 +1939,13 @@ function resolveHostSlug(parsed) {
 function toSlug(value) {
     const normalized = value
         .toLowerCase()
-        .replace(/[^a-z0-9]+/g, '-')
-        .replace(/^-+|-+$/g, '');
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
     if (!normalized)
-        return '';
+        return "";
     const max = 64;
     if (normalized.length <= max)
         return normalized;
-    return normalized.slice(0, max).replace(/-+$/g, '');
+    return normalized.slice(0, max).replace(/-+$/g, "");
 }
 //# sourceMappingURL=extract.js.map