@steipete/summarize 0.8.2 → 0.10.0

package/dist/types/run/flows/url/summary.d.ts

@@ -1,15 +1,18 @@
 import type { ExtractedLinkContent } from '../../../content/index.js';
 import type { UrlExtractionUi } from './extract.js';
+import type { SlidesTerminalOutput } from './slides-output.js';
 import type { UrlFlowContext } from './types.js';
-export declare function buildUrlPrompt({ extracted, outputLanguage, lengthArg, promptOverride, lengthInstruction, languageInstruction, }: {
+type SlidesResult = Awaited<ReturnType<typeof import('../../../slides/index.js').extractSlidesForSource>>;
+export declare function buildUrlPrompt({ extracted, outputLanguage, lengthArg, promptOverride, lengthInstruction, languageInstruction, slides, }: {
     extracted: ExtractedLinkContent;
     outputLanguage: UrlFlowContext['flags']['outputLanguage'];
     lengthArg: UrlFlowContext['flags']['lengthArg'];
     promptOverride?: string | null;
     lengthInstruction?: string | null;
     languageInstruction?: string | null;
+    slides?: SlidesResult | null;
 }): string;
-export declare function outputExtractedUrl({ ctx, url, extracted, extractionUi, prompt, effectiveMarkdownMode, transcriptionCostLabel, }: {
+export declare function outputExtractedUrl({ ctx, url, extracted, extractionUi, prompt, effectiveMarkdownMode, transcriptionCostLabel, slides, slidesOutput, }: {
     ctx: UrlFlowContext;
     url: string;
     extracted: ExtractedLinkContent;
@@ -17,8 +20,10 @@ export declare function outputExtractedUrl({ ctx, url, extracted, extractionUi,
     prompt: string;
     effectiveMarkdownMode: 'off' | 'auto' | 'llm' | 'readability';
     transcriptionCostLabel: string | null;
+    slides?: Awaited<ReturnType<typeof import('../../../slides/index.js').extractSlidesForSource>> | null;
+    slidesOutput?: SlidesTerminalOutput | null;
 }): Promise<void>;
-export declare function summarizeExtractedUrl({ ctx, url, extracted, extractionUi, prompt, effectiveMarkdownMode, transcriptionCostLabel, onModelChosen, }: {
+export declare function summarizeExtractedUrl({ ctx, url, extracted, extractionUi, prompt, effectiveMarkdownMode, transcriptionCostLabel, onModelChosen, slides, slidesOutput, }: {
     ctx: UrlFlowContext;
     url: string;
     extracted: ExtractedLinkContent;
@@ -27,4 +32,7 @@ export declare function summarizeExtractedUrl({ ctx, url, extracted, extractionU
     effectiveMarkdownMode: 'off' | 'auto' | 'llm' | 'readability';
     transcriptionCostLabel: string | null;
     onModelChosen?: ((modelId: string) => void) | null;
+    slides?: Awaited<ReturnType<typeof import('../../../slides/index.js').extractSlidesForSource>> | null;
+    slidesOutput?: SlidesTerminalOutput | null;
 }): Promise<void>;
+export {};

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

@@ -1,11 +1,13 @@
 import type { CacheState } from '../../../cache.js';
 import type { SummarizeConfig } from '../../../config.js';
-import type { ExtractedLinkContent, LinkPreviewProgressEvent } from '../../../content/index.js';
+import type { ExtractedLinkContent, LinkPreviewProgressEvent, MediaCache } from '../../../content/index.js';
 import type { LlmCall, RunMetricsReport } from '../../../costs.js';
+import type { StreamMode } from '../../../flags.js';
 import type { OutputLanguage } from '../../../language.js';
 import type { ExecFileFn } from '../../../markitdown.js';
 import type { FixedModelSpec, RequestedModel } from '../../../model-spec.js';
 import type { SummaryLength } from '../../../shared/contracts.js';
+import type { SlideExtractionResult, SlideImage, SlideSettings, SlideSourceKind } from '../../../slides/index.js';
 import type { createSummaryEngine } from '../../summary-engine.js';
 import type { SummarizeAssetArgs } from '../asset/summary.js';
 export type UrlFlowIo = {
@@ -26,6 +28,7 @@ export type UrlFlowFlags = {
     youtubeMode: 'auto' | 'web' | 'yt-dlp' | 'apify' | 'no-auto';
     firecrawlMode: 'off' | 'auto' | 'always';
     videoMode: 'auto' | 'transcript' | 'understand';
+    transcriptTimestamps: boolean;
     outputLanguage: OutputLanguage;
     lengthArg: {
         kind: 'preset';
@@ -34,9 +37,11 @@ export type UrlFlowFlags = {
         kind: 'chars';
         maxCharacters: number;
     };
+    forceSummary: boolean;
     promptOverride?: string | null;
     lengthInstruction?: string | null;
     languageInstruction?: string | null;
+    summaryCacheBypass: boolean;
     maxOutputTokensArg: number | null;
     json: boolean;
     extractMode: boolean;
@@ -47,10 +52,14 @@ export type UrlFlowFlags = {
     verbose: boolean;
     verboseColor: boolean;
     progressEnabled: boolean;
+    streamMode: StreamMode;
     streamingEnabled: boolean;
     plain: boolean;
     configPath: string | null;
     configModelLabel: string | null;
+    slides: SlideSettings | null;
+    slidesDebug: boolean;
+    slidesOutput?: boolean;
 };
 export type UrlFlowModel = {
     requestedModel: RequestedModel;
@@ -97,13 +106,30 @@ export type UrlFlowModel = {
 export type UrlFlowHooks = {
     onModelChosen?: ((modelId: string) => void) | null;
     onExtracted?: ((extracted: ExtractedLinkContent) => void) | null;
+    onSlidesExtracted?: ((slides: SlideExtractionResult) => void) | null;
+    onSlidesProgress?: ((text: string) => void) | null;
+    onSlidesDone?: ((result: {
+        ok: boolean;
+        error?: string | null;
+    }) => void) | null;
+    onSlideChunk?: (chunk: {
+        slide: SlideImage;
+        meta: {
+            slidesDir: string;
+            sourceUrl: string;
+            sourceId: string;
+            sourceKind: SlideSourceKind;
+            ocrAvailable: boolean;
+        };
+    }) => void;
     onLinkPreviewProgress?: ((event: LinkPreviewProgressEvent) => void) | null;
     onSummaryCached?: ((cached: boolean) => void) | null;
     setTranscriptionCost: (costUsd: number | null, label: string | null) => void;
     summarizeAsset: (args: SummarizeAssetArgs) => Promise<void>;
     writeViaFooter: (parts: string[]) => void;
     clearProgressForStdout: () => void;
-    setClearProgressBeforeStdout: (fn: (() => void) | null) => void;
+    restoreProgressAfterStdout?: (() => void) | null;
+    setClearProgressBeforeStdout: (fn: (() => undefined | (() => void)) | null) => void;
     clearProgressIfCurrent: (fn: () => void) => void;
     buildReport: () => Promise<RunMetricsReport>;
     estimateCostUsd: () => Promise<number | null>;
@@ -118,5 +144,6 @@ export type UrlFlowContext = {
     flags: UrlFlowFlags;
     model: UrlFlowModel;
     cache: CacheState;
+    mediaCache: MediaCache | null;
     hooks: UrlFlowHooks;
 };

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

@@ -1,6 +1,9 @@
 import { Command } from 'commander';
 export declare function buildProgram(): Command;
+export declare function applyHelpStyle(program: Command, env: Record<string, string | undefined>, stdout: NodeJS.WritableStream): void;
+export declare function buildSlidesProgram(): Command;
 export declare function attachRichHelp(program: Command, env: Record<string, string | undefined>, stdout: NodeJS.WritableStream): void;
 export declare function buildConciseHelp(): string;
 export declare function buildRefreshFreeHelp(): string;
 export declare function buildDaemonHelp(): string;
+export declare function buildTranscriberHelp(): string;

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

@@ -1,9 +1,10 @@
-export declare function writeVerbose(stderr: NodeJS.WritableStream, verbose: boolean, message: string, color: boolean): void;
-export declare function createRetryLogger({ stderr, verbose, color, modelId, }: {
+export declare function writeVerbose(stderr: NodeJS.WritableStream, verbose: boolean, message: string, color: boolean, env?: Record<string, string | undefined>): void;
+export declare function createRetryLogger({ stderr, verbose, color, modelId, env, }: {
     stderr: NodeJS.WritableStream;
     verbose: boolean;
     color: boolean;
     modelId: string;
+    env?: Record<string, string | undefined>;
 }): (notice: {
     attempt: number;
     maxRetries: number;

package/dist/types/run/media-cache-state.d.ts

@@ -0,0 +1,7 @@
+import type { SummarizeConfig } from '../config.js';
+import type { MediaCache } from '../content/index.js';
+export declare function createMediaCacheFromConfig({ envForRun, config, noMediaCacheFlag, }: {
+    envForRun: Record<string, string | undefined>;
+    config: SummarizeConfig | null;
+    noMediaCacheFlag?: boolean;
+}): Promise<MediaCache | null>;

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

@@ -1,6 +1,7 @@
 export type ProgressGate = {
-    setClearProgressBeforeStdout: (fn: (() => void) | null) => void;
+    setClearProgressBeforeStdout: (fn: (() => undefined | (() => void)) | null) => void;
     clearProgressForStdout: () => void;
+    restoreProgressAfterStdout: () => void;
     clearProgressIfCurrent: (fn: () => void) => void;
 };
 export declare function createProgressGate(): ProgressGate;

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

@@ -0,0 +1,44 @@
+import type { CliProvider } from '../config.js';
+export declare function resolveRunContextState({ env, envForRun, programOpts, languageExplicitlySet, videoModeExplicitlySet, cliFlagPresent, cliProviderArg, }: {
+    env: Record<string, string | undefined>;
+    envForRun: Record<string, string | undefined>;
+    programOpts: Record<string, unknown>;
+    languageExplicitlySet: boolean;
+    videoModeExplicitlySet: boolean;
+    cliFlagPresent: boolean;
+    cliProviderArg: CliProvider | null;
+}): {
+    apiKey: string | null;
+    openrouterApiKey: string | null;
+    openrouterConfigured: boolean;
+    openaiTranscriptionKey: string | null;
+    xaiApiKey: string | null;
+    googleApiKey: string | null;
+    anthropicApiKey: string | null;
+    zaiApiKey: string | null;
+    zaiBaseUrl: string;
+    firecrawlApiKey: string | null;
+    firecrawlConfigured: boolean;
+    googleConfigured: boolean;
+    anthropicConfigured: boolean;
+    apifyToken: string | null;
+    ytDlpPath: string | null;
+    falApiKey: string | null;
+    cliAvailability: Partial<Record<CliProvider, boolean>>;
+    envForAuto: Record<string, string | undefined>;
+    providerBaseUrls: {
+        openai: string | null;
+        anthropic: string | null;
+        google: string | null;
+        xai: string | null;
+    };
+    config: import("../config.js").SummarizeConfig | null;
+    configPath: string | null;
+    outputLanguage: import("@steipete/summarize-core/language").OutputLanguage;
+    openaiWhisperUsdPerMinute: number;
+    videoMode: ReturnType<typeof import("../flags.js").parseVideoMode>;
+    cliConfigForRun: import("../config.js").SummarizeConfig["cli"] | undefined;
+    configForCli: import("../config.js").SummarizeConfig | null;
+    openaiUseChatCompletions: boolean;
+    configModelLabel: string | null;
+};

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

@@ -0,0 +1,62 @@
+import type { FirecrawlMode, LengthArg, MarkdownMode, PreprocessMode, VideoMode, YoutubeMode } from '../flags.js';
+import type { OutputLanguage } from '../language.js';
+import type { SummaryLengthTarget } from '../prompts/index.js';
+export type ResolvedRunSettings = {
+    lengthArg: LengthArg;
+    firecrawlMode: FirecrawlMode;
+    markdownMode: MarkdownMode;
+    preprocessMode: PreprocessMode;
+    youtubeMode: YoutubeMode;
+    timeoutMs: number;
+    retries: number;
+    maxOutputTokensArg: number | null;
+};
+export type RunOverrides = {
+    firecrawlMode: FirecrawlMode | null;
+    markdownMode: MarkdownMode | null;
+    preprocessMode: PreprocessMode | null;
+    youtubeMode: YoutubeMode | null;
+    videoMode: VideoMode | null;
+    transcriptTimestamps: boolean | null;
+    forceSummary: boolean | null;
+    timeoutMs: number | null;
+    retries: number | null;
+    maxOutputTokensArg: number | null;
+    transcriber: 'auto' | 'whisper' | 'parakeet' | 'canary' | null;
+};
+export type RunOverridesInput = {
+    firecrawl?: unknown;
+    markdownMode?: unknown;
+    preprocess?: unknown;
+    youtube?: unknown;
+    videoMode?: unknown;
+    timestamps?: unknown;
+    forceSummary?: unknown;
+    timeout?: unknown;
+    retries?: unknown;
+    maxOutputTokens?: unknown;
+    transcriber?: unknown;
+};
+export declare function resolveSummaryLength(raw: unknown, fallback?: string): {
+    lengthArg: LengthArg;
+    summaryLength: SummaryLengthTarget;
+};
+export declare function resolveOutputLanguageSetting({ raw, fallback, }: {
+    raw: unknown;
+    fallback: OutputLanguage;
+}): OutputLanguage;
+export declare function resolveCliRunSettings({ length, firecrawl, markdownMode, markdown, format, preprocess, youtube, timeout, retries, maxOutputTokens, }: {
+    length: string;
+    firecrawl: string;
+    markdownMode?: string | undefined;
+    markdown?: string | undefined;
+    format: 'text' | 'markdown';
+    preprocess: string;
+    youtube: string;
+    timeout: string;
+    retries: string;
+    maxOutputTokens?: string | undefined;
+}): ResolvedRunSettings;
+export declare function resolveRunOverrides({ firecrawl, markdownMode, preprocess, youtube, videoMode, timestamps, forceSummary, timeout, retries, maxOutputTokens, transcriber, }: RunOverridesInput, options?: {
+    strict?: boolean;
+}): RunOverrides;

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

@@ -0,0 +1,9 @@
+type SlidesCliContext = {
+    normalizedArgv: string[];
+    envForRun: Record<string, string | undefined>;
+    fetchImpl: typeof fetch;
+    stdout: NodeJS.WritableStream;
+    stderr: NodeJS.WritableStream;
+};
+export declare function handleSlidesCliRequest({ normalizedArgv, envForRun, stdout, stderr, }: SlidesCliContext): Promise<boolean>;
+export {};

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

@@ -0,0 +1,30 @@
+import type { SlideImage } from '../slides/types.js';
+export type SlidesRenderMode = 'none' | 'auto' | 'kitty' | 'iterm';
+export type InlineProtocol = 'none' | 'kitty' | 'iterm';
+type RenderSlide = Pick<SlideImage, 'imagePath' | 'index' | 'timestamp'>;
+export declare function renderSlidesInline({ slides, mode, env, stdout, labelForSlide, }: {
+    slides: RenderSlide[];
+    mode: SlidesRenderMode;
+    env: Record<string, string | undefined>;
+    stdout: NodeJS.WritableStream;
+    labelForSlide?: ((slide: RenderSlide) => string) | null;
+}): Promise<{
+    rendered: number;
+    protocol: InlineProtocol;
+}>;
+export declare function createSlidesInlineRenderer({ mode, env, stdout, }: {
+    mode: SlidesRenderMode;
+    env: Record<string, string | undefined>;
+    stdout: NodeJS.WritableStream;
+}): {
+    protocol: InlineProtocol;
+    renderSlide: (slide: RenderSlide, label?: string | null) => Promise<boolean>;
+    renderSlides: (args: {
+        slides: RenderSlide[];
+        labelForSlide?: ((slide: RenderSlide) => string) | null;
+    }) => Promise<{
+        rendered: number;
+        protocol: InlineProtocol;
+    }>;
+};
+export {};

package/dist/types/run/stream-output.d.ts

@@ -0,0 +1,12 @@
+export type StreamOutputMode = 'line' | 'delta';
+export declare function createStreamOutputGate({ stdout, clearProgressForStdout, restoreProgressAfterStdout, outputMode, richTty, }: {
+    stdout: NodeJS.WritableStream;
+    clearProgressForStdout: () => void;
+    restoreProgressAfterStdout?: (() => void) | null;
+    outputMode: StreamOutputMode;
+    richTty: boolean;
+}): {
+    handleChunk: (streamed: string, prevStreamed: string) => void;
+    finalize: (finalText: string) => void;
+    getFlushedLen: () => number;
+};

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

@@ -1,6 +1,12 @@
-export declare function mergeStreamingChunk(previous: string, chunk: string): {
-    next: string;
-    appended: string;
-};
+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';
+    prompt: {
+        attachments?: Array<{
+            kind: 'text' | 'image' | 'document';
+        }>;
+    };
+    transport: 'cli' | 'native' | 'openrouter';
+}): boolean;

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

@@ -1,6 +1,7 @@
 import type { CliProvider } from '../config.js';
 import { runCliModel } from '../llm/cli.js';
-import type { PromptPayload } from '../llm/prompt.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 = {
@@ -12,6 +13,7 @@ export type SummaryEngineDeps = {
     timeoutMs: number;
     retries: number;
     streamingEnabled: boolean;
+    streamingOutputMode?: StreamOutputMode;
     plain: boolean;
     verbose: boolean;
     verboseColor: boolean;
@@ -29,6 +31,7 @@ export type SummaryEngineDeps = {
         purpose: 'summary' | 'markdown';
     }>;
     clearProgressForStdout: () => void;
+    restoreProgressAfterStdout?: (() => void) | null;
     apiKeys: {
         xaiApiKey: string | null;
         openaiApiKey: string | null;
@@ -52,13 +55,21 @@ export type SummaryEngineDeps = {
         xai: string | null;
     };
 };
+export type SummaryStreamHandler = {
+    onChunk: (args: {
+        streamed: string;
+        prevStreamed: string;
+        appended: string;
+    }) => void | Promise<void>;
+    onDone?: ((finalText: string) => void | Promise<void>) | null;
+};
 export declare function createSummaryEngine(deps: SummaryEngineDeps): {
     applyZaiOverrides: (attempt: ModelAttempt) => ModelAttempt;
     envHasKeyFor: (requiredEnv: ModelAttempt["requiredEnv"]) => boolean;
     formatMissingModelError: (attempt: ModelAttempt) => string;
-    runSummaryAttempt: ({ attempt, prompt, allowStreaming, onModelChosen, cli, }: {
+    runSummaryAttempt: ({ attempt, prompt, allowStreaming, onModelChosen, cli, streamHandler, }: {
         attempt: ModelAttempt;
-        prompt: PromptPayload;
+        prompt: Prompt;
         allowStreaming: boolean;
         onModelChosen?: ((modelId: string) => void) | null;
         cli?: {
@@ -67,6 +78,7 @@ export declare function createSummaryEngine(deps: SummaryEngineDeps): {
             cwd?: string;
             extraArgsByProvider?: Partial<Record<CliProvider, string[]>>;
         } | null;
+        streamHandler?: SummaryStreamHandler | null;
     }) => Promise<{
         summary: string;
         summaryAlreadyPrinted: boolean;

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

@@ -1,6 +1,6 @@
 import { generateTextWithModelId } from '../llm/generate-text.js';
 import type { parseGatewayStyleModelId } from '../llm/model-id.js';
-import type { PromptPayload } from '../llm/prompt.js';
+import type { Prompt } from '../llm/prompt.js';
 export declare function resolveModelIdForLlmCall({ parsedModel, apiKeys, fetchImpl, timeoutMs, }: {
     parsedModel: ReturnType<typeof parseGatewayStyleModelId>;
     apiKeys: {
@@ -15,7 +15,7 @@ export declare function resolveModelIdForLlmCall({ parsedModel, apiKeys, fetchIm
 }>;
 export declare function summarizeWithModelId({ modelId, prompt, maxOutputTokens, timeoutMs, fetchImpl, apiKeys, forceOpenRouter, openaiBaseUrlOverride, anthropicBaseUrlOverride, googleBaseUrlOverride, xaiBaseUrlOverride, forceChatCompletions, retries, onRetry, }: {
     modelId: string;
-    prompt: PromptPayload;
+    prompt: Prompt;
     maxOutputTokens?: number;
     timeoutMs: number;
     fetchImpl: typeof fetch;

package/dist/types/run/transcriber-cli.d.ts

@@ -0,0 +1,8 @@
+type TranscriberCliContext = {
+    normalizedArgv: string[];
+    envForRun: Record<string, string | undefined>;
+    stdout: NodeJS.WritableStream;
+    stderr: NodeJS.WritableStream;
+};
+export declare function handleTranscriberCliRequest({ normalizedArgv, envForRun, stdout, }: TranscriberCliContext): Promise<boolean>;
+export {};

package/dist/types/shared/sse-events.d.ts

@@ -0,0 +1,64 @@
+import type { AssistantMessage } from '@mariozechner/pi-ai';
+export type SseMetaData = {
+    model: string | null;
+    modelLabel: string | null;
+    inputSummary: string | null;
+    summaryFromCache?: boolean | null;
+};
+export type SseSlidesData = {
+    sourceUrl: string;
+    sourceId: string;
+    sourceKind: string;
+    ocrAvailable: boolean;
+    slides: Array<{
+        index: number;
+        timestamp: number;
+        imageUrl: string;
+        ocrText?: string | null;
+        ocrConfidence?: number | null;
+    }>;
+};
+export type SseMetricsData = {
+    elapsedMs: number;
+    summary: string;
+    details: string | null;
+    summaryDetailed: string;
+    detailsDetailed: string | null;
+};
+export type SseEvent = {
+    event: 'meta';
+    data: SseMetaData;
+} | {
+    event: 'slides';
+    data: SseSlidesData;
+} | {
+    event: 'status';
+    data: {
+        text: string;
+    };
+} | {
+    event: 'chunk';
+    data: {
+        text: string;
+    };
+} | {
+    event: 'assistant';
+    data: AssistantMessage;
+} | {
+    event: 'metrics';
+    data: SseMetricsData;
+} | {
+    event: 'done';
+    data: Record<string, never>;
+} | {
+    event: 'error';
+    data: {
+        message: string;
+    };
+};
+export type RawSseMessage = {
+    event: string;
+    data: string;
+};
+export declare function encodeSseEvent(event: SseEvent): string;
+export declare function parseSseEvent(message: RawSseMessage): SseEvent | null;

package/dist/types/shared/streaming-merge.d.ts

@@ -0,0 +1,4 @@
+export declare function mergeStreamingChunk(previous: string, chunk: string): {
+    next: string;
+    appended: string;
+};

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

@@ -0,0 +1,42 @@
+import type { ExtractedLinkContent, MediaCache } from '../content/index.js';
+import type { SlideSettings } from './settings.js';
+import type { SlideExtractionResult, SlideImage, SlideSource, SlideSourceKind } from './types.js';
+type ExtractSlidesArgs = {
+    source: SlideSource;
+    settings: SlideSettings;
+    noCache?: boolean;
+    mediaCache?: MediaCache | null;
+    env: Record<string, string | undefined>;
+    timeoutMs: number;
+    ytDlpPath: string | null;
+    ffmpegPath: string | null;
+    tesseractPath: string | null;
+    hooks?: {
+        onSlideChunk?: (chunk: {
+            slide: SlideImage;
+            meta: {
+                slidesDir: string;
+                sourceUrl: string;
+                sourceId: string;
+                sourceKind: SlideSourceKind;
+                ocrAvailable: boolean;
+            };
+        }) => void;
+        onSlidesTimeline?: ((slides: SlideExtractionResult) => void) | null;
+        onSlidesProgress?: ((text: string) => void) | null;
+        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, 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/index.d.ts

@@ -0,0 +1,5 @@
+export { extractSlidesForSource, parseShowinfoTimestamp, resolveExtractedTimestamp, resolveSlideSource, resolveSlideSourceFromUrl, } from './extract.js';
+export type { SlideSettings, SlideSettingsInput } from './settings.js';
+export { resolveSlideSettings } from './settings.js';
+export { buildSlidesDirId, readSlidesCacheIfValid, resolveSlideImagePath, resolveSlidesDir, serializeSlideImagePath, validateSlidesCache, } from './store.js';
+export type { SlideAutoTune, SlideExtractionResult, SlideImage, SlideSource, SlideSourceKind, } from './types.js';

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

@@ -0,0 +1,20 @@
+export type SlideSettings = {
+    enabled: boolean;
+    ocr: boolean;
+    outputDir: string;
+    sceneThreshold: number;
+    autoTuneThreshold: boolean;
+    maxSlides: number;
+    minDurationSeconds: number;
+};
+export type SlideSettingsInput = {
+    slides?: unknown;
+    slidesOcr?: unknown;
+    slidesDir?: unknown;
+    slidesSceneThreshold?: unknown;
+    slidesSceneThresholdExplicit?: boolean;
+    slidesMax?: unknown;
+    slidesMinDuration?: unknown;
+    cwd: string;
+};
+export declare function resolveSlideSettings(input: SlideSettingsInput): SlideSettings | null;

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

@@ -0,0 +1,15 @@
+import type { SlideSettings } from './settings.js';
+import type { SlideExtractionResult, SlideSource } from './types.js';
+export declare function resolveSlidesDir(outputDir: string, sourceId: string): string;
+export declare function buildSlidesDirId(slidesDir: string): string;
+export declare function resolveSlideImagePath(slidesDir: string, imagePath: string): string | null;
+export declare function serializeSlideImagePath(slidesDir: string, imagePath: string): string;
+export declare function validateSlidesCache({ cached, source, settings, }: {
+    cached: SlideExtractionResult;
+    source: SlideSource;
+    settings: SlideSettings;
+}): Promise<SlideExtractionResult | null>;
+export declare function readSlidesCacheIfValid({ source, settings, }: {
+    source: SlideSource;
+    settings: SlideSettings;
+}): Promise<SlideExtractionResult | null>;

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

@@ -0,0 +1,40 @@
+export type SlideSourceKind = 'youtube' | 'direct';
+export type SlideSource = {
+    url: string;
+    kind: SlideSourceKind;
+    sourceId: string;
+};
+export type SlideImage = {
+    index: number;
+    timestamp: number;
+    imagePath: string;
+    /**
+     * Bump when the underlying image file changes (e.g. thumbnail improvement),
+     * so clients can cache-bust URLs.
+     */
+    imageVersion?: number;
+    ocrText?: string | null;
+    ocrConfidence?: number | null;
+};
+export type SlideAutoTune = {
+    enabled: boolean;
+    chosenThreshold: number;
+    confidence: number;
+    strategy: 'hash' | 'none';
+};
+export type SlideExtractionResult = {
+    sourceUrl: string;
+    sourceKind: SlideSourceKind;
+    sourceId: string;
+    slidesDir: string;
+    slidesDirId?: string | null;
+    sceneThreshold: number;
+    autoTuneThreshold: boolean;
+    autoTune: SlideAutoTune;
+    maxSlides: number;
+    minSlideDuration: number;
+    ocrRequested: boolean;
+    ocrAvailable: boolean;
+    slides: SlideImage[];
+    warnings: string[];
+};

package/dist/types/tty/osc-progress.d.ts

@@ -1,5 +1,5 @@
-import { createOscProgressController as createOscProgressControllerImpl } from 'osc-progress';
+import type { OscProgressController } from 'osc-progress';
 export type { OscProgressController, OscProgressOptions, OscProgressSupportOptions, OscProgressTerminator, } from 'osc-progress';
-export declare const createOscProgressController: typeof createOscProgressControllerImpl;
+export declare function createOscProgressController(options: import('osc-progress').OscProgressOptions): OscProgressController;
 export declare function startOscProgress(options: import('osc-progress').OscProgressOptions): () => void;
 export declare function supportsOscProgress(env: Record<string, string | undefined>, isTty: boolean, options?: import('osc-progress').OscProgressSupportOptions): boolean;

package/dist/types/tty/progress/fetch-html.d.ts

@@ -1,10 +1,12 @@
 import type { LinkPreviewProgressEvent } from '@steipete/summarize-core/content';
 import type { OscProgressController } from '../osc-progress.js';
-export declare function createFetchHtmlProgressRenderer({ spinner, oscProgress, }: {
+import type { ThemeRenderer } from '../theme.js';
+export declare function createFetchHtmlProgressRenderer({ spinner, oscProgress, theme, }: {
     spinner: {
         setText: (text: string) => void;
     };
     oscProgress?: OscProgressController | null;
+    theme?: ThemeRenderer | null;
 }): {
     stop: () => void;
     onProgress: (event: LinkPreviewProgressEvent) => void;