@steipete/summarize 0.11.1 → 0.13.0

package/dist/types/run/run-settings.d.ts

@@ -1,7 +1,7 @@
 import type { CliProvider } from "../config.js";
 import type { FirecrawlMode, LengthArg, MarkdownMode, PreprocessMode, VideoMode, YoutubeMode } from "../flags.js";
 import type { OutputLanguage } from "../language.js";
-import type { SummaryLengthTarget } from "../prompts/index.js";
+import { type SummaryLengthTarget } from "../prompts/index.js";
 export type ResolvedRunSettings = {
     lengthArg: LengthArg;
     firecrawlMode: FirecrawlMode;
@@ -50,6 +50,7 @@ export declare function resolveSummaryLength(raw: unknown, fallback?: string): {
     lengthArg: LengthArg;
     summaryLength: SummaryLengthTarget;
 };
+export declare function buildPromptLengthInstruction(lengthArg: LengthArg): string;
 export declare function resolveOutputLanguageSetting({ raw, fallback, }: {
     raw: unknown;
     fallback: OutputLanguage;

package/dist/types/run/runner-contexts.d.ts

@@ -0,0 +1,37 @@
+import type { CacheState } from "../cache.js";
+import type { MediaCache } from "../content/index.js";
+import { type SummarizeAssetArgs } from "./flows/asset/summary.js";
+import { type UrlFlowContext } from "./flows/url/types.js";
+type SummarizeMediaFile = typeof import("./flows/asset/media.js").summarizeMediaFile;
+export declare function createRunnerFlowContexts(options: {
+    summarizeMediaFileImpl: SummarizeMediaFile;
+    cacheState: CacheState;
+    mediaCache: MediaCache | null;
+    io: UrlFlowContext["io"];
+    flags: UrlFlowContext["flags"];
+    model: UrlFlowContext["model"];
+    setTranscriptionCost: UrlFlowContext["hooks"]["setTranscriptionCost"];
+    writeViaFooter: UrlFlowContext["hooks"]["writeViaFooter"];
+    clearProgressForStdout: UrlFlowContext["hooks"]["clearProgressForStdout"];
+    restoreProgressAfterStdout: UrlFlowContext["hooks"]["restoreProgressAfterStdout"];
+    setClearProgressBeforeStdout: UrlFlowContext["hooks"]["setClearProgressBeforeStdout"];
+    clearProgressIfCurrent: UrlFlowContext["hooks"]["clearProgressIfCurrent"];
+    buildReport: UrlFlowContext["hooks"]["buildReport"];
+    estimateCostUsd: UrlFlowContext["hooks"]["estimateCostUsd"];
+}): {
+    summarizeAsset: (args: SummarizeAssetArgs) => Promise<void>;
+    assetInputContext: {
+        env: Record<string, string | undefined>;
+        envForRun: Record<string, string | undefined>;
+        stderr: NodeJS.WritableStream;
+        progressEnabled: boolean;
+        timeoutMs: number;
+        trackedFetch: typeof fetch;
+        summarizeAsset: (args: SummarizeAssetArgs) => Promise<void>;
+        summarizeMediaFile: (args: Parameters<SummarizeMediaFile>[1]) => Promise<void>;
+        setClearProgressBeforeStdout: (fn: (() => undefined | (() => void)) | null) => void;
+        clearProgressIfCurrent: (fn: () => void) => void;
+    };
+    urlFlowContext: UrlFlowContext;
+};
+export {};

package/dist/types/run/runner-execution.d.ts

@@ -0,0 +1,58 @@
+import type { InputTarget } from "../content/asset.js";
+import type { RunMetricsReport } from "../costs.js";
+import type { ExecFileFn } from "../markitdown.js";
+import type { AssetExtractContext } from "./flows/asset/extract.js";
+import type { SummarizeAssetArgs } from "./flows/asset/summary.js";
+export declare function executeRunnerInput(options: {
+    inputTarget: InputTarget;
+    stdin: NodeJS.ReadableStream;
+    handleFileInputContext: unknown;
+    url: string | null;
+    isYoutubeUrl: boolean;
+    withUrlAssetContext: unknown;
+    slidesEnabled: boolean;
+    extractMode: boolean;
+    progressEnabled: boolean;
+    renderSpinnerStatus: (label: string, detail?: string) => string;
+    renderSpinnerStatusWithModel: (label: string, modelId: string) => string;
+    extractAssetContext: AssetExtractContext & {
+        execFileImpl: ExecFileFn;
+    };
+    outputExtractedAssetContext: {
+        io: {
+            env: Record<string, string | undefined>;
+            envForRun: Record<string, string | undefined>;
+            stdout: NodeJS.WritableStream;
+            stderr: NodeJS.WritableStream;
+        };
+        flags: {
+            timeoutMs: number;
+            preprocessMode: "off" | "auto" | "always";
+            format: "text" | "markdown";
+            plain: boolean;
+            json: boolean;
+            metricsEnabled: boolean;
+            metricsDetailed: boolean;
+            shouldComputeReport: boolean;
+            runStartedAtMs: number;
+            verboseColor: boolean;
+        };
+        hooks: {
+            clearProgressForStdout: () => void;
+            restoreProgressAfterStdout?: (() => void) | null;
+            buildReport: () => Promise<RunMetricsReport>;
+            estimateCostUsd: () => Promise<number | null>;
+        };
+        apiStatus: {
+            xaiApiKey: string | null;
+            apiKey: string | null;
+            openrouterApiKey: string | null;
+            apifyToken: string | null;
+            firecrawlConfigured: boolean;
+            googleConfigured: boolean;
+            anthropicConfigured: boolean;
+        };
+    };
+    summarizeAsset: (args: SummarizeAssetArgs) => Promise<void>;
+    runUrlFlowContext: unknown;
+}): Promise<void>;

package/dist/types/run/runner-flags.d.ts

@@ -0,0 +1,41 @@
+import { type FirecrawlMode, type LengthArg, type MarkdownMode, type PreprocessMode, parseExtractFormat, parseMaxExtractCharactersArg, parseMetricsMode, parseStreamMode, type YoutubeMode } from "../flags.js";
+type Transcriber = "auto" | "whisper" | "parakeet" | "canary";
+export type RunnerFlagResolution = {
+    videoModeExplicitlySet: boolean;
+    lengthExplicitlySet: boolean;
+    languageExplicitlySet: boolean;
+    noCacheFlag: boolean;
+    noMediaCacheFlag: boolean;
+    extractMode: boolean;
+    json: boolean;
+    forceSummary: boolean;
+    slidesDebug: boolean;
+    streamMode: ReturnType<typeof parseStreamMode>;
+    plain: boolean;
+    debug: boolean;
+    verbose: boolean;
+    transcriber: Transcriber;
+    maxExtractCharacters: ReturnType<typeof parseMaxExtractCharactersArg>;
+    isYoutubeUrl: boolean;
+    format: ReturnType<typeof parseExtractFormat>;
+    youtubeMode: YoutubeMode;
+    lengthArg: LengthArg;
+    maxOutputTokensArg: number | null;
+    timeoutMs: number;
+    retries: number;
+    preprocessMode: PreprocessMode;
+    requestedFirecrawlMode: FirecrawlMode;
+    markdownMode: MarkdownMode;
+    metricsMode: ReturnType<typeof parseMetricsMode>;
+    metricsEnabled: boolean;
+    metricsDetailed: boolean;
+    shouldComputeReport: boolean;
+    markdownModeExplicitlySet: boolean;
+};
+export declare function resolveRunnerFlags({ normalizedArgv, programOpts, envForRun, url, }: {
+    normalizedArgv: readonly string[];
+    programOpts: Record<string, unknown>;
+    envForRun: Record<string, string | undefined>;
+    url: string | null;
+}): RunnerFlagResolution;
+export {};

package/dist/types/run/runner-plan.d.ts

@@ -0,0 +1,19 @@
+import type { Command } from "commander";
+import { type CacheState } from "../cache.js";
+import type { ExecFileFn } from "../markitdown.js";
+export type RunnerPlan = {
+    cacheState: CacheState;
+    execute: () => Promise<void>;
+};
+export declare function createRunnerPlan(options: {
+    normalizedArgv: string[];
+    program: Command;
+    env: Record<string, string | undefined>;
+    envForRun: Record<string, string | undefined>;
+    fetchImpl: typeof fetch;
+    execFileImpl: ExecFileFn;
+    stdin?: NodeJS.ReadableStream;
+    stdout: NodeJS.WritableStream;
+    stderr: NodeJS.WritableStream;
+    promptOverride: string | null;
+}): Promise<RunnerPlan>;

package/dist/types/run/runner-setup.d.ts

@@ -0,0 +1,21 @@
+export declare function prepareRunEnvironment(argv: string[], inputEnv: Record<string, string | undefined>): {
+    normalizedArgv: string[];
+    envForRun: Record<string, string | undefined>;
+};
+export declare function handleVersionFlag({ versionRequested, stdout, }: {
+    versionRequested: boolean;
+    stdout: NodeJS.WritableStream;
+}): boolean;
+export declare function applyWidthOverride({ width, env, }: {
+    width: unknown;
+    env: Record<string, string | undefined>;
+}): void;
+export declare function resolvePromptOverride({ prompt, promptFile, }: {
+    prompt: unknown;
+    promptFile: unknown;
+}): Promise<string | null>;
+export declare function handleCacheUtilityFlags({ normalizedArgv, envForRun, stdout, }: {
+    normalizedArgv: string[];
+    envForRun: Record<string, string | undefined>;
+    stdout: NodeJS.WritableStream;
+}): Promise<boolean>;

package/dist/types/run/runner-slides.d.ts

@@ -0,0 +1,9 @@
+import type { SummarizeConfig } from "../config.js";
+import type { InputTarget } from "../content/asset.js";
+import { type SlideSettings } from "../slides/index.js";
+export declare function resolveRunnerSlidesSettings(options: {
+    normalizedArgv: string[];
+    programOpts: Record<string, unknown>;
+    config: SummarizeConfig | null;
+    inputTarget: InputTarget;
+}): SlideSettings | null;

package/dist/types/run/streaming.d.ts

@@ -1,8 +1,9 @@
+import type { LlmProvider } from "../llm/model-id.js";
 export { mergeStreamingChunk } from "../shared/streaming-merge.js";
 export declare function isGoogleStreamingUnsupportedError(error: unknown): boolean;
 export declare function isStreamingTimeoutError(error: unknown): boolean;
 export declare function canStream({ provider, prompt, transport, }: {
-    provider: "xai" | "openai" | "google" | "anthropic" | "zai";
+    provider: LlmProvider;
     prompt: {
         attachments?: Array<{
             kind: "text" | "image" | "document";

package/dist/types/run/summary-engine.d.ts

@@ -1,9 +1,9 @@
 import type { CliProvider } from "../config.js";
-import type { Prompt } from "../llm/prompt.js";
-import type { ModelAttempt, ModelMeta } from "./types.js";
 import { runCliModel } from "../llm/cli.js";
+import type { Prompt } from "../llm/prompt.js";
 import { type StreamOutputMode } from "./stream-output.js";
 import { summarizeWithModelId } from "./summary-llm.js";
+import type { ModelAttempt, ModelMeta } from "./types.js";
 export type SummaryEngineDeps = {
     env: Record<string, string | undefined>;
     envForRun: Record<string, string | undefined>;
@@ -24,7 +24,7 @@ export type SummaryEngineDeps = {
     resolveMaxOutputTokensForCall: (modelId: string) => Promise<number | null>;
     resolveMaxInputTokensForCall: (modelId: string) => Promise<number | null>;
     llmCalls: Array<{
-        provider: "xai" | "openai" | "google" | "anthropic" | "zai" | "cli";
+        provider: "xai" | "openai" | "google" | "anthropic" | "zai" | "nvidia" | "github-copilot" | "cli";
         model: string;
         usage: Awaited<ReturnType<typeof summarizeWithModelId>>["usage"] | null;
         costUsd?: number | null;
@@ -48,6 +48,10 @@ export type SummaryEngineDeps = {
         apiKey: string | null;
         baseUrl: string;
     };
+    nvidia: {
+        apiKey: string | null;
+        baseUrl: string;
+    };
     providerBaseUrls: {
         openai: string | null;
         anthropic: string | null;
@@ -64,7 +68,7 @@ export type SummaryStreamHandler = {
     onDone?: ((finalText: string) => void | Promise<void>) | null;
 };
 export declare function createSummaryEngine(deps: SummaryEngineDeps): {
-    applyZaiOverrides: (attempt: ModelAttempt) => ModelAttempt;
+    applyOpenAiGatewayOverrides: (attempt: ModelAttempt) => ModelAttempt;
     envHasKeyFor: (requiredEnv: ModelAttempt["requiredEnv"]) => boolean;
     formatMissingModelError: (attempt: ModelAttempt) => string;
     runSummaryAttempt: ({ attempt, prompt, allowStreaming, onModelChosen, cli, streamHandler, }: {

package/dist/types/run/summary-llm.d.ts

@@ -1,6 +1,7 @@
+import { generateTextWithModelId } from "../llm/generate-text.js";
+import type { LlmProvider } from "../llm/model-id.js";
 import type { parseGatewayStyleModelId } from "../llm/model-id.js";
 import type { Prompt } from "../llm/prompt.js";
-import { generateTextWithModelId } from "../llm/generate-text.js";
 export declare function resolveModelIdForLlmCall({ parsedModel, apiKeys, fetchImpl, timeoutMs, }: {
     parsedModel: ReturnType<typeof parseGatewayStyleModelId>;
     apiKeys: {
@@ -13,7 +14,7 @@ export declare function resolveModelIdForLlmCall({ parsedModel, apiKeys, fetchIm
     note: string | null;
     forceStreamOff: boolean;
 }>;
-export declare function summarizeWithModelId({ modelId, prompt, maxOutputTokens, timeoutMs, fetchImpl, apiKeys, forceOpenRouter, openaiBaseUrlOverride, anthropicBaseUrlOverride, googleBaseUrlOverride, xaiBaseUrlOverride, forceChatCompletions, retries, onRetry, }: {
+export declare function summarizeWithModelId({ modelId, prompt, maxOutputTokens, timeoutMs, fetchImpl, apiKeys, forceOpenRouter, openaiBaseUrlOverride, anthropicBaseUrlOverride, googleBaseUrlOverride, xaiBaseUrlOverride, zaiBaseUrlOverride, forceChatCompletions, retries, onRetry, }: {
     modelId: string;
     prompt: Prompt;
     maxOutputTokens?: number;
@@ -31,6 +32,7 @@ export declare function summarizeWithModelId({ modelId, prompt, maxOutputTokens,
     anthropicBaseUrlOverride?: string | null;
     googleBaseUrlOverride?: string | null;
     xaiBaseUrlOverride?: string | null;
+    zaiBaseUrlOverride?: string | null;
     forceChatCompletions?: boolean;
     retries: number;
     onRetry?: (notice: {
@@ -41,7 +43,7 @@ export declare function summarizeWithModelId({ modelId, prompt, maxOutputTokens,
     }) => void;
 }): Promise<{
     text: string;
-    provider: "xai" | "openai" | "google" | "anthropic" | "zai";
+    provider: LlmProvider;
     canonicalModelId: string;
     usage: Awaited<ReturnType<typeof generateTextWithModelId>>["usage"];
 }>;

package/dist/types/run/terminal.d.ts

@@ -2,5 +2,7 @@ export declare function isRichTty(stream: NodeJS.WritableStream): boolean;
 export declare function supportsColor(stream: NodeJS.WritableStream, env: Record<string, string | undefined>): boolean;
 export declare function terminalWidth(stream: NodeJS.WritableStream, env: Record<string, string | undefined>): number;
 export declare function terminalHeight(stream: NodeJS.WritableStream, env: Record<string, string | undefined>): number;
+/** Default max width for markdown rendering to keep text readable on wide terminals. */
+export declare const DEFAULT_MAX_RENDER_WIDTH = 120;
 export declare function markdownRenderWidth(stream: NodeJS.WritableStream, env: Record<string, string | undefined>): number;
 export declare function ansi(code: string, input: string, enabled: boolean): string;

package/dist/types/run/types.d.ts

@@ -1,5 +1,6 @@
 import type { CliProvider } from "../config.js";
-export type ModelAttemptRequiredEnv = "XAI_API_KEY" | "OPENAI_API_KEY" | "GEMINI_API_KEY" | "ANTHROPIC_API_KEY" | "OPENROUTER_API_KEY" | "Z_AI_API_KEY" | "CLI_CLAUDE" | "CLI_CODEX" | "CLI_GEMINI" | "CLI_AGENT";
+import type { LlmProvider } from "../llm/model-id.js";
+export type ModelAttemptRequiredEnv = "XAI_API_KEY" | "OPENAI_API_KEY" | "NVIDIA_API_KEY" | "GEMINI_API_KEY" | "ANTHROPIC_API_KEY" | "OPENROUTER_API_KEY" | "Z_AI_API_KEY" | "GITHUB_TOKEN" | "CLI_CLAUDE" | "CLI_CODEX" | "CLI_GEMINI" | "CLI_AGENT" | "CLI_OPENCLAW" | "CLI_OPENCODE";
 export type ModelAttempt = {
     transport: "native" | "openrouter" | "cli";
     userModelId: string;
@@ -14,7 +15,7 @@ export type ModelAttempt = {
     cliModel?: string | null;
 };
 export type ModelMeta = {
-    provider: "xai" | "openai" | "google" | "anthropic" | "zai" | "cli";
+    provider: LlmProvider | "cli";
     canonical: string;
 };
 export type MarkdownModel = {

package/dist/types/shared/slides-text.d.ts

@@ -0,0 +1 @@
+export { buildSlideTextFallback, coerceSummaryWithSlides, parseSlideSummariesFromMarkdown, parseTranscriptTimedText, resolveSlideTextBudget, splitSlideTitleFromText, splitSummaryFromSlides, type SlideTimelineEntry, } from "../run/flows/url/slides-text.js";

package/dist/types/slides/download.d.ts

@@ -0,0 +1,29 @@
+export declare function buildYtDlpCookiesArgs(cookiesFromBrowser?: string | null): string[];
+export declare function buildSlidesMediaCacheKey(url: string): string;
+export declare function formatBytes(bytes: number): string;
+export declare function downloadYoutubeVideo(options: {
+    ytDlpPath: string;
+    url: string;
+    timeoutMs: number;
+    format: string;
+    cookiesFromBrowser?: string | null;
+    onProgress?: ((percent: number, detail?: string) => void) | null;
+}): Promise<{
+    filePath: string;
+    cleanup: () => Promise<void>;
+}>;
+export declare function downloadRemoteVideo(options: {
+    url: string;
+    timeoutMs: number;
+    onProgress?: ((percent: number, detail?: string) => void) | null;
+}): Promise<{
+    filePath: string;
+    cleanup: () => Promise<void>;
+}>;
+export declare function resolveYoutubeStreamUrl(options: {
+    ytDlpPath: string;
+    url: string;
+    timeoutMs: number;
+    format: string;
+    cookiesFromBrowser?: string | null;
+}): Promise<string>;

package/dist/types/slides/extract-finalize.d.ts

@@ -0,0 +1,57 @@
+import type { SlideAutoTune, SlideExtractionResult, SlideImage, SlideSource, SlideSourceKind } from "./types.js";
+export declare const SLIDES_PROGRESS: {
+    readonly PREPARE: 2;
+    readonly FETCH_VIDEO: 6;
+    readonly DOWNLOAD_VIDEO: 35;
+    readonly DETECT_SCENES: 60;
+    readonly EXTRACT_FRAMES: 90;
+    readonly OCR: 99;
+    readonly FINAL: 100;
+};
+export type SlidesChunkMeta = {
+    slidesDir: string;
+    sourceUrl: string;
+    sourceId: string;
+    sourceKind: SlideSourceKind;
+    ocrAvailable: boolean;
+};
+export declare function buildSlidesChunkMeta(args: {
+    slidesDir: string;
+    source: SlideSource;
+    ocrAvailable: boolean;
+}): SlidesChunkMeta;
+export declare function buildSlideTimeline(args: {
+    source: SlideSource;
+    slidesDir: string;
+    sceneThreshold: number;
+    autoTuneThreshold: boolean;
+    autoTune: SlideAutoTune;
+    maxSlides: number;
+    minSlideDuration: number;
+    ocrRequested: boolean;
+    ocrAvailable: boolean;
+    warnings: string[];
+    slides: Array<SlideImage & {
+        segment?: unknown;
+    }>;
+}): SlideExtractionResult;
+export declare function emitPlaceholderSlides(args: {
+    slides: Array<SlideImage & {
+        segment?: unknown;
+    }>;
+    meta: SlidesChunkMeta;
+    onSlideChunk?: ((value: {
+        slide: SlideImage;
+        meta: SlidesChunkMeta;
+    }) => void) | null;
+}): void;
+export declare function emitFinalSlides(args: {
+    slides: SlideImage[];
+    meta: SlidesChunkMeta;
+    onSlideChunk?: ((value: {
+        slide: SlideImage;
+        meta: SlidesChunkMeta;
+    }) => void) | null;
+}): void;
+export declare function renameSlidesWithTimestamps(slides: SlideImage[], slidesDir: string): Promise<SlideImage[]>;
+export declare function writeSlidesJson(result: SlideExtractionResult, slidesDir: string): Promise<void>;

package/dist/types/slides/extract.d.ts

@@ -1,6 +1,7 @@
-import type { ExtractedLinkContent, MediaCache } from "../content/index.js";
+import type { MediaCache } from "../content/index.js";
 import type { SlideSettings } from "./settings.js";
 import type { SlideExtractionResult, SlideImage, SlideSource, SlideSourceKind } from "./types.js";
+export { parseShowinfoTimestamp, resolveExtractedTimestamp } from "./scene-detection.js";
 type ExtractSlidesArgs = {
     source: SlideSource;
     settings: SlideSettings;
@@ -28,16 +29,4 @@ type ExtractSlidesArgs = {
         onSlidesLog?: ((message: string) => void) | null;
     } | null;
 };
-export declare function resolveSlideSource({ url, extracted, }: {
-    url: string;
-    extracted: ExtractedLinkContent;
-}): SlideSource | null;
-export declare function resolveSlideSourceFromUrl(url: string): SlideSource | null;
 export declare function extractSlidesForSource({ source, settings, noCache, mediaCache, env, timeoutMs, ytDlpPath, ytDlpCookiesFromBrowser, ffmpegPath, tesseractPath, hooks, }: ExtractSlidesArgs): Promise<SlideExtractionResult>;
-export declare function parseShowinfoTimestamp(line: string): number | null;
-export declare function resolveExtractedTimestamp({ requested, actual, seekBase, }: {
-    requested: number;
-    actual: number | null;
-    seekBase?: number | null;
-}): number;
-export {};

package/dist/types/slides/frame-extraction.d.ts

@@ -0,0 +1,38 @@
+import type { SlideAutoTune, SlideImage } from "./types.js";
+export declare function detectSlideTimestamps({ ffmpegPath, ffprobePath, inputPath, sceneThreshold, autoTuneThreshold, env, timeoutMs, warnings, workers, sampleCount, onSegmentProgress, logSlides, logSlidesTiming, }: {
+    ffmpegPath: string;
+    ffprobePath: string | null;
+    inputPath: string;
+    sceneThreshold: number;
+    autoTuneThreshold: boolean;
+    env: Record<string, string | undefined>;
+    timeoutMs: number;
+    warnings: string[];
+    workers: number;
+    sampleCount: number;
+    onSegmentProgress?: ((completed: number, total: number) => void) | null;
+    logSlides?: ((message: string) => void) | null;
+    logSlidesTiming?: ((label: string, startedAt: number) => number) | null;
+}): Promise<{
+    timestamps: number[];
+    autoTune: SlideAutoTune;
+    durationSeconds: number | null;
+}>;
+export declare function extractFramesAtTimestamps({ ffmpegPath, inputPath, outputDir, timestamps, segments, durationSeconds, timeoutMs, workers, onProgress, onStatus, onSlide, logSlides, logSlidesTiming, }: {
+    ffmpegPath: string;
+    inputPath: string;
+    outputDir: string;
+    timestamps: number[];
+    segments?: Array<{
+        start: number;
+        end: number | null;
+    } | null>;
+    durationSeconds?: number | null;
+    timeoutMs: number;
+    workers: number;
+    onProgress?: ((completed: number, total: number) => void) | null;
+    onStatus?: ((text: string) => void) | null;
+    onSlide?: ((slide: SlideImage) => void) | null;
+    logSlides?: ((message: string) => void) | null;
+    logSlidesTiming?: ((label: string, startedAt: number) => number) | null;
+}): Promise<SlideImage[]>;

package/dist/types/slides/index.d.ts

@@ -1,4 +1,5 @@
-export { extractSlidesForSource, parseShowinfoTimestamp, resolveExtractedTimestamp, resolveSlideSource, resolveSlideSourceFromUrl, } from "./extract.js";
+export { extractSlidesForSource, parseShowinfoTimestamp, resolveExtractedTimestamp, } from "./extract.js";
+export { isDirectVideoInput, resolveSlideSource, resolveSlideSourceFromUrl } from "./source.js";
 export type { SlideSettings, SlideSettingsInput } from "./settings.js";
 export { resolveSlideSettings } from "./settings.js";
 export { buildSlidesDirId, readSlidesCacheIfValid, resolveSlideImagePath, resolveSlidesDir, serializeSlideImagePath, validateSlidesCache, } from "./store.js";

package/dist/types/slides/ingest.d.ts

@@ -0,0 +1,47 @@
+import type { MediaCache } from "../content/index.js";
+import type { SlideSource } from "./types.js";
+export type SlidesIngestProgress = (label: string, percent: number, detail?: string) => void;
+export declare function prepareSlidesInput({ source, mediaCache, timeoutMs, ytDlpPath, ytDlpCookiesFromBrowser, resolveSlidesYtDlpExtractFormat, resolveSlidesStreamFallback, buildSlidesMediaCacheKey, formatBytes, reportSlidesProgress, logSlidesTiming, downloadYoutubeVideo, downloadRemoteVideo, resolveYoutubeStreamUrl, }: {
+    source: SlideSource;
+    mediaCache: MediaCache | null;
+    timeoutMs: number;
+    ytDlpPath: string | null;
+    ytDlpCookiesFromBrowser?: string | null;
+    resolveSlidesYtDlpExtractFormat: () => string;
+    resolveSlidesStreamFallback: () => boolean;
+    buildSlidesMediaCacheKey: (url: string) => string;
+    formatBytes: (bytes: number) => string;
+    reportSlidesProgress?: SlidesIngestProgress | null;
+    logSlidesTiming?: ((label: string, startedAt: number) => number) | null;
+    downloadYoutubeVideo: (args: {
+        ytDlpPath: string;
+        url: string;
+        timeoutMs: number;
+        format: string;
+        cookiesFromBrowser?: string | null;
+        onProgress?: ((percent: number, detail?: string) => void) | null;
+    }) => Promise<{
+        filePath: string;
+        cleanup: () => Promise<void>;
+    }>;
+    downloadRemoteVideo: (args: {
+        url: string;
+        timeoutMs: number;
+        onProgress?: ((percent: number, detail?: string) => void) | null;
+    }) => Promise<{
+        filePath: string;
+        cleanup: () => Promise<void>;
+    }>;
+    resolveYoutubeStreamUrl: (args: {
+        ytDlpPath: string;
+        url: string;
+        timeoutMs: number;
+        format: string;
+        cookiesFromBrowser?: string | null;
+    }) => Promise<string>;
+}): Promise<{
+    inputPath: string;
+    inputCleanup: (() => Promise<void>) | null;
+    cachedMedia: Awaited<ReturnType<NonNullable<MediaCache>["get"]>> | null;
+    warnings: string[];
+}>;

package/dist/types/slides/ocr.d.ts

@@ -0,0 +1,5 @@
+import type { SlideImage } from "./types.js";
+export declare function cleanOcrText(text: string): string;
+export declare function estimateOcrConfidence(text: string): number;
+export declare function runTesseract(tesseractPath: string, imagePath: string): Promise<string>;
+export declare function runOcrOnSlides(slides: SlideImage[], tesseractPath: string, workers: number, onProgress?: ((completed: number, total: number) => void) | null): Promise<SlideImage[]>;

package/dist/types/slides/process.d.ts

@@ -0,0 +1,22 @@
+import type { ProcessHandle } from "../processes.js";
+export declare function runProcess({ command, args, timeoutMs, errorLabel, onStderrLine, onStdoutLine, }: {
+    command: string;
+    args: string[];
+    timeoutMs: number;
+    errorLabel: string;
+    onStderrLine?: (line: string, handle: ProcessHandle | null) => void;
+    onStdoutLine?: (line: string, handle: ProcessHandle | null) => void;
+}): Promise<void>;
+export declare function runProcessCapture({ command, args, timeoutMs, errorLabel, }: {
+    command: string;
+    args: string[];
+    timeoutMs: number;
+    errorLabel: string;
+}): Promise<string>;
+export declare function runProcessCaptureBuffer({ command, args, timeoutMs, errorLabel, }: {
+    command: string;
+    args: string[];
+    timeoutMs: number;
+    errorLabel: string;
+}): Promise<Buffer>;
+export declare function runWithConcurrency<T>(tasks: Array<() => Promise<T>>, workers: number, onProgress?: ((completed: number, total: number) => void) | null): Promise<T[]>;

package/dist/types/slides/scene-detection.d.ts

@@ -0,0 +1,75 @@
+import type { SlideImage } from "./types.js";
+export type SceneSegment = {
+    start: number;
+    end: number | null;
+};
+export declare function clamp(value: number, min: number, max: number): number;
+export declare function parseShowinfoTimestamp(line: string): number | null;
+export declare function resolveExtractedTimestamp({ requested, actual, seekBase, }: {
+    requested: number;
+    actual: number | null;
+    seekBase?: number | null;
+}): number;
+export declare function roundThreshold(value: number): number;
+export declare function calibrateSceneThreshold({ ffmpegPath, inputPath, durationSeconds, sampleCount, timeoutMs, logSlides, }: {
+    ffmpegPath: string;
+    inputPath: string;
+    durationSeconds: number | null;
+    sampleCount: number;
+    timeoutMs: number;
+    logSlides?: ((message: string) => void) | null;
+}): Promise<{
+    threshold: number;
+    confidence: number;
+}>;
+export declare function buildSegments(durationSeconds: number | null, workers: number): Array<{
+    start: number;
+    duration: number;
+}>;
+export declare function detectSceneTimestamps({ ffmpegPath, inputPath, threshold, timeoutMs, segments, workers, onSegmentProgress, runWithConcurrency, }: {
+    ffmpegPath: string;
+    inputPath: string;
+    threshold: number;
+    timeoutMs: number;
+    segments?: Array<{
+        start: number;
+        duration: number;
+    }>;
+    workers?: number;
+    onSegmentProgress?: ((completed: number, total: number) => void) | null;
+    runWithConcurrency: <T>(tasks: Array<() => Promise<T>>, workers: number, onProgress?: ((completed: number, total: number) => void) | null) => Promise<T[]>;
+}): Promise<number[]>;
+export declare function applyMinDurationFilter(slides: SlideImage[], minDurationSeconds: number, warnings: string[], removeFile: (path: string) => void): SlideImage[];
+export declare function mergeTimestamps(sceneTimestamps: number[], intervalTimestamps: number[], minDurationSeconds: number): number[];
+export declare function filterTimestampsByMinDuration(timestamps: number[], minDurationSeconds: number): number[];
+export declare function buildSceneSegments(sceneTimestamps: number[], durationSeconds: number | null): SceneSegment[];
+export declare function findSceneSegment(segments: SceneSegment[], timestamp: number): SceneSegment | null;
+export declare function adjustTimestampWithinSegment(timestamp: number, segment: SceneSegment | null): number;
+export declare function selectTimestampTargets({ targets, sceneTimestamps, minDurationSeconds, intervalSeconds, }: {
+    targets: number[];
+    sceneTimestamps: number[];
+    minDurationSeconds: number;
+    intervalSeconds: number;
+}): number[];
+export declare function buildIntervalTimestamps({ durationSeconds, minDurationSeconds, maxSlides, }: {
+    durationSeconds: number | null;
+    minDurationSeconds: number;
+    maxSlides: number;
+}): {
+    timestamps: number[];
+    intervalSeconds: number;
+} | null;
+export declare function probeVideoInfo({ ffprobePath, inputPath, timeoutMs, }: {
+    ffprobePath: string;
+    inputPath: string;
+    timeoutMs: number;
+}): Promise<{
+    durationSeconds: number | null;
+    width: number | null;
+    height: number | null;
+}>;
+export declare function applyMaxSlidesFilter<T extends {
+    index: number;
+    timestamp: number;
+    imagePath: string;
+}>(slides: T[], maxSlides: number, warnings: string[], removeFile: (path: string) => void): T[];

package/dist/types/slides/source-id.d.ts

@@ -0,0 +1,2 @@
+export declare function buildYoutubeSourceId(videoId: string): string;
+export declare function buildDirectSourceId(url: string): string;

package/dist/types/slides/source.d.ts

@@ -0,0 +1,8 @@
+import type { ExtractedLinkContent } from "../content/index.js";
+import type { SlideSource } from "./types.js";
+export { isDirectVideoInput } from "../content/index.js";
+export declare function resolveSlideSource({ url, extracted, }: {
+    url: string;
+    extracted: ExtractedLinkContent;
+}): SlideSource | null;
+export declare function resolveSlideSourceFromUrl(url: string): SlideSource | null;