@steipete/summarize 0.8.2 → 0.10.0

package/dist/types/llm/providers/shared.d.ts

@@ -0,0 +1,14 @@
+import type { Api, AssistantMessage, Context, KnownProvider, Model } from '@mariozechner/pi-ai';
+export declare function resolveBaseUrlOverride(raw: string | null | undefined): string | null;
+export declare function bytesToBase64(bytes: Uint8Array): string;
+export declare function extractText(message: AssistantMessage): string;
+export declare function wantsImages(context: Context): boolean;
+export declare function tryGetModel(provider: KnownProvider, modelId: string): Model<Api> | null;
+export declare function createSyntheticModel({ provider, modelId, api, baseUrl, allowImages, headers, }: {
+    provider: KnownProvider;
+    modelId: string;
+    api: Model<Api>['api'];
+    baseUrl: string;
+    allowImages: boolean;
+    headers?: Record<string, string>;
+}): Model<Api>;

package/dist/types/llm/providers/types.d.ts

@@ -0,0 +1,6 @@
+export type OpenAiClientConfig = {
+    apiKey: string;
+    baseURL?: string;
+    useChatCompletions: boolean;
+    isOpenRouter: boolean;
+};

package/dist/types/llm/types.d.ts

@@ -0,0 +1,5 @@
+export type LlmTokenUsage = {
+    promptTokens: number | null;
+    completionTokens: number | null;
+    totalTokens: number | null;
+};

package/dist/types/llm/usage.d.ts

@@ -0,0 +1,5 @@
+import type { LlmTokenUsage } from './types.js';
+export declare function normalizeTokenUsage(raw: unknown): LlmTokenUsage | null;
+export declare function normalizeAnthropicUsage(raw: unknown): LlmTokenUsage | null;
+export declare function normalizeOpenAiUsage(raw: unknown): LlmTokenUsage | null;
+export declare function normalizeGoogleUsage(raw: unknown): LlmTokenUsage | null;

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

@@ -0,0 +1,26 @@
+import { Logger } from 'tslog';
+import type { SummarizeConfig } from '../config.js';
+export type DaemonLogLevel = 'debug' | 'info' | 'warn' | 'error';
+export type DaemonLogFormat = 'json' | 'pretty';
+export type DaemonLoggingConfig = {
+    enabled: true;
+    level: DaemonLogLevel;
+    format: DaemonLogFormat;
+    file: string;
+    maxBytes: number;
+    maxFiles: number;
+};
+export type DaemonLogger = {
+    enabled: boolean;
+    config: DaemonLoggingConfig | null;
+    logger: Logger<Record<string, unknown>> | null;
+    getSubLogger: (name: string, logObj?: Record<string, unknown>) => Logger<Record<string, unknown>> | null;
+};
+export declare function resolveDaemonLoggingConfig({ env, config, }: {
+    env: Record<string, string | undefined>;
+    config: SummarizeConfig | null;
+}): DaemonLoggingConfig | null;
+export declare function createDaemonLogger({ env, config, }: {
+    env: Record<string, string | undefined>;
+    config: SummarizeConfig | null;
+}): DaemonLogger;

package/dist/types/logging/ring-file.d.ts

@@ -0,0 +1,10 @@
+export type RingFileOptions = {
+    filePath: string;
+    maxBytes: number;
+    maxFiles: number;
+};
+export type RingFileWriter = {
+    write: (line: string) => void;
+    flush: () => Promise<void>;
+};
+export declare function createRingFileWriter(options: RingFileOptions): RingFileWriter;

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

@@ -0,0 +1,22 @@
+import type { MediaCache } from './content/index.js';
+export type MediaCacheVerifyMode = 'none' | 'size' | 'hash';
+export type MediaCacheConfig = {
+    enabled?: boolean;
+    maxMb?: number;
+    ttlDays?: number;
+    path?: string;
+    verify?: MediaCacheVerifyMode;
+};
+export declare const DEFAULT_MEDIA_CACHE_MAX_MB = 2048;
+export declare const DEFAULT_MEDIA_CACHE_TTL_DAYS = 7;
+export declare const DEFAULT_MEDIA_CACHE_VERIFY: MediaCacheVerifyMode;
+export declare function resolveMediaCachePath({ env, cachePath, }: {
+    env: Record<string, string | undefined>;
+    cachePath: string | null;
+}): string | null;
+export declare function createMediaCache({ path, maxBytes, ttlMs, verify, }: {
+    path: string;
+    maxBytes: number;
+    ttlMs: number;
+    verify?: MediaCacheVerifyMode;
+}): Promise<MediaCache>;

package/dist/types/model-auto.d.ts

@@ -9,6 +9,7 @@ export type AutoSelectionInput = {
     config: SummarizeConfig | null;
     catalog: LiteLlmCatalog | null;
     openrouterProvidersFromEnv: string[] | null;
+    openrouterModelIds?: string[] | null;
     cliAvailability?: Partial<Record<CliProvider, boolean>>;
 };
 export type AutoModelAttempt = {

package/dist/types/processes.d.ts

@@ -0,0 +1 @@
+export * from '@steipete/summarize-core/processes';

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

@@ -1,16 +1,12 @@
-import { type loadLocalAsset } from '../content/asset.js';
-import type { PromptPayload } from '../llm/prompt.js';
+import type { loadLocalAsset } from '../content/asset.js';
 export type AssetAttachment = Awaited<ReturnType<typeof loadLocalAsset>>['attachment'];
+export declare const MAX_DOCUMENT_BYTES_DEFAULT: number;
 export declare function isUnsupportedAttachmentError(error: unknown): boolean;
 export declare function isTextLikeMediaType(mediaType: string): boolean;
 export declare function assertAssetMediaTypeSupported({ attachment, sizeLabel, }: {
     attachment: AssetAttachment;
     sizeLabel: string | null;
 }): void;
-export declare function buildAssetPromptPayload({ promptText, attachment, }: {
-    promptText: string;
-    attachment: AssetAttachment;
-}): PromptPayload;
 export declare function getTextContentFromAttachment(attachment: AssetAttachment): {
     content: string;
     bytes: number;
@@ -22,6 +18,13 @@ export declare function ensureCliAttachmentPath({ sourceKind, sourceLabel, attac
     attachment: AssetAttachment;
 }): Promise<string>;
 export declare function shouldMarkitdownConvertMediaType(mediaType: string): boolean;
+export declare function supportsNativeFileAttachment({ provider, attachment, }: {
+    provider: 'xai' | 'openai' | 'google' | 'anthropic' | 'zai';
+    attachment: {
+        kind: 'image' | 'file';
+        mediaType: string;
+    };
+}): boolean;
 export declare function assertProviderSupportsAttachment({ provider, modelId, attachment, }: {
     provider: 'xai' | 'openai' | 'google' | 'anthropic' | 'zai';
     modelId: string;

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

@@ -6,6 +6,13 @@ type BirdTweetPayload = {
         name?: string;
     };
     createdAt?: string;
+    media?: BirdTweetMedia | null;
+};
+type BirdTweetMedia = {
+    kind: 'video' | 'audio';
+    urls: string[];
+    preferredUrl: string | null;
+    source: 'extended_entities' | 'card' | 'entities';
 };
 export declare function readTweetWithBird(args: {
     url: string;

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

@@ -1,10 +1,8 @@
 import type { ModelConfig } from '../config.js';
-import type { SummaryLength } from '../shared/contracts.js';
 export declare const BIRD_TIP = "Tip: Install bird\uD83D\uDC26 for better Twitter support: https://github.com/steipete/bird";
 export declare const UVX_TIP = "Tip: Install uv (uvx) for local Markdown conversion: brew install uv (or set UVX_PATH to your uvx binary).";
 export declare const SUPPORT_URL = "https://github.com/steipete/summarize";
 export declare const TWITTER_HOSTS: Set<string>;
-export declare const SUMMARY_LENGTH_MAX_CHARACTERS: Record<SummaryLength, number>;
 export declare const MAX_TEXT_BYTES_DEFAULT: number;
 export declare const BUILTIN_MODELS: Record<string, ModelConfig>;
 export declare const VERBOSE_PREFIX = "[summarize]";

package/dist/types/run/finish-line.d.ts

@@ -2,6 +2,10 @@ export type FinishLineText = {
     line: string;
     details: string | null;
 };
+export type FinishLineModel = {
+    lineParts: string[];
+    detailParts: string[];
+};
 export type ExtractDiagnosticsForFinishLine = {
     strategy: 'bird' | 'firecrawl' | 'html' | 'nitter';
     firecrawl: {
@@ -41,7 +45,7 @@ export type ExtractedForLengths = {
 };
 export declare function formatModelLabelForDisplay(model: string): string;
 export declare function buildLengthPartsForFinishLine(extracted: ExtractedForLengths, detailed: boolean): string[] | null;
-export declare function writeFinishLine({ stderr, elapsedMs, elapsedLabel, label, model, report, costUsd, detailed, extraParts, color, }: {
+export declare function writeFinishLine({ stderr, elapsedMs, elapsedLabel, label, model, report, costUsd, detailed, extraParts, color, env, }: {
     stderr: NodeJS.WritableStream;
     elapsedMs: number;
     elapsedLabel?: string | null;
@@ -67,6 +71,7 @@ export declare function writeFinishLine({ stderr, elapsedMs, elapsedLabel, label
     detailed: boolean;
     extraParts?: string[] | null;
     color: boolean;
+    env?: Record<string, string | undefined>;
 }): void;
 export declare function buildFinishLineText({ elapsedMs, elapsedLabel, label, model, report, costUsd, detailed, extraParts, }: {
     elapsedMs: number;
@@ -93,6 +98,59 @@ export declare function buildFinishLineText({ elapsedMs, elapsedLabel, label, mo
     detailed: boolean;
     extraParts?: string[] | null;
 }): FinishLineText;
+export declare function buildFinishLineVariants({ elapsedMs, elapsedLabel, label, model, report, costUsd, compactExtraParts, detailedExtraParts, }: {
+    elapsedMs: number;
+    elapsedLabel?: string | null;
+    label?: string | null;
+    model: string | null;
+    report: {
+        llm: Array<{
+            promptTokens: number | null;
+            completionTokens: number | null;
+            totalTokens: number | null;
+            calls: number;
+        }>;
+        services: {
+            firecrawl: {
+                requests: number;
+            };
+            apify: {
+                requests: number;
+            };
+        };
+    };
+    costUsd: number | null;
+    compactExtraParts?: string[] | null;
+    detailedExtraParts?: string[] | null;
+}): {
+    compact: FinishLineText;
+    detailed: FinishLineText;
+};
+export declare function formatFinishLineText(model: FinishLineModel, detailed: boolean): FinishLineText;
+export declare function buildFinishLineModel({ elapsedMs, elapsedLabel, label, model, report, costUsd, extraParts, }: {
+    elapsedMs: number;
+    elapsedLabel?: string | null;
+    label?: string | null;
+    model: string | null;
+    report: {
+        llm: Array<{
+            promptTokens: number | null;
+            completionTokens: number | null;
+            totalTokens: number | null;
+            calls: number;
+        }>;
+        services: {
+            firecrawl: {
+                requests: number;
+            };
+            apify: {
+                requests: number;
+            };
+        };
+    };
+    costUsd: number | null;
+    extraParts?: string[] | null;
+}): FinishLineModel;
 export declare function buildExtractFinishLabel(args: {
     extracted: {
         diagnostics: ExtractDiagnosticsForFinishLine;

package/dist/types/run/flows/asset/extract.d.ts

@@ -0,0 +1,18 @@
+import type { ExecFileFn } from '../../../markitdown.js';
+import { type AssetAttachment } from '../../attachments.js';
+import type { ExtractDiagnosticsForFinishLine } from '../../finish-line.js';
+export type AssetExtractContext = {
+    env: Record<string, string | undefined>;
+    envForRun: Record<string, string | undefined>;
+    execFileImpl: ExecFileFn;
+    timeoutMs: number;
+    preprocessMode: 'off' | 'auto' | 'always';
+};
+export type AssetExtractResult = {
+    content: string;
+    diagnostics: ExtractDiagnosticsForFinishLine;
+};
+export declare function extractAssetContent({ ctx, attachment, }: {
+    ctx: AssetExtractContext;
+    attachment: AssetAttachment;
+}): Promise<AssetExtractResult>;

package/dist/types/run/flows/asset/input.d.ts

@@ -1,14 +1,24 @@
-import { type InputTarget } from '../../../content/asset.js';
+import { type InputTarget, loadRemoteAsset } from '../../../content/asset.js';
+import { startSpinner } from '../../../tty/spinner.js';
 import type { SummarizeAssetArgs } from './summary.js';
 export type 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>;
-    setClearProgressBeforeStdout: (fn: (() => void) | null) => void;
+    summarizeMediaFile?: (args: SummarizeAssetArgs) => Promise<void>;
+    setClearProgressBeforeStdout: (fn: (() => undefined | (() => void)) | null) => void;
     clearProgressIfCurrent: (fn: () => void) => void;
 };
+type UrlAssetHandler = (args: {
+    loaded: Awaited<ReturnType<typeof loadRemoteAsset>>;
+    spinner: ReturnType<typeof startSpinner>;
+    clearProgressLine: () => void;
+}) => Promise<void>;
 export declare function handleFileInput(ctx: AssetInputContext, inputTarget: InputTarget): Promise<boolean>;
+export declare function withUrlAsset(ctx: AssetInputContext, url: string, isYoutubeUrl: boolean, handler: UrlAssetHandler): Promise<boolean>;
 export declare function handleUrlAsset(ctx: AssetInputContext, url: string, isYoutubeUrl: boolean): Promise<boolean>;
+export {};

package/dist/types/run/flows/asset/media-policy.d.ts

@@ -0,0 +1,2 @@
+export declare const MAX_LOCAL_MEDIA_BYTES: number;
+export declare const MAX_LOCAL_MEDIA_LABEL = "2 GB";

package/dist/types/run/flows/asset/media.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Media file transcription handler for local audio/video files.
+ * Phase 2: Transcript provider integration
+ * Phase 2.2: Local file path handling for transcript caching
+ */
+import type { AssetSummaryContext, SummarizeAssetArgs } from './summary.js';
+/**
+ * Handler for local audio/video files.
+ *
+ * Phase 2 Implementation:
+ * 1. Validates transcription provider availability
+ * 2. Creates LinkPreviewClient with necessary dependencies
+ * 3. Calls client.fetchLinkContent to trigger transcription
+ * 4. Converts transcript text to AssetAttachment
+ * 5. Calls summarizeAsset with the transcript
+ *
+ * Phase 2.2 Enhancement:
+ * - Captures file modification time for cache invalidation
+ * - Passes fileMtime to transcript cache for local file support
+ */
+export declare function summarizeMediaFile(ctx: AssetSummaryContext, args: SummarizeAssetArgs): Promise<void>;

package/dist/types/run/flows/asset/output.d.ts

@@ -0,0 +1,42 @@
+import type { RunMetricsReport } from '../../../costs.js';
+import type { AssetAttachment } from '../../attachments.js';
+import type { AssetExtractResult } from './extract.js';
+export declare function outputExtractedAsset({ io, flags, hooks, url, sourceLabel, attachment, extracted, apiStatus, }: {
+    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>;
+    };
+    url: string;
+    sourceLabel: string;
+    attachment: AssetAttachment;
+    extracted: AssetExtractResult;
+    apiStatus: {
+        xaiApiKey: string | null;
+        apiKey: string | null;
+        openrouterApiKey: string | null;
+        apifyToken: string | null;
+        firecrawlConfigured: boolean;
+        googleConfigured: boolean;
+        anthropicConfigured: boolean;
+    };
+}): Promise<void>;

package/dist/types/run/flows/asset/preprocess.d.ts

@@ -1,5 +1,5 @@
 import type { OutputLanguage } from '../../../language.js';
-import type { PromptPayload } from '../../../llm/prompt.js';
+import type { Attachment } from '../../../llm/attachments.js';
 import { convertToMarkdownWithMarkitdown } from '../../../markitdown.js';
 import type { FixedModelSpec } from '../../../model-spec.js';
 import type { SummaryLength } from '../../../shared/contracts.js';
@@ -25,14 +25,34 @@ export type AssetPreprocessContext = {
     languageInstruction?: string | null;
 };
 export type AssetPreprocessResult = {
-    promptPayload: PromptPayload;
     promptText: string;
+    attachments: Attachment[];
     assetFooterParts: string[];
     textContent: {
         content: string;
         bytes: number;
     } | null;
 };
+export type DocumentHandlingDecision = {
+    mode: 'inline';
+} | {
+    mode: 'attach';
+} | {
+    mode: 'preprocess';
+} | {
+    mode: 'error';
+    error: Error;
+};
+export declare function resolveDocumentHandling({ attachment, textContent, fileBytes, preprocessMode, fixedModelSpec, }: {
+    attachment: AssetAttachment;
+    textContent: {
+        content: string;
+        bytes: number;
+    } | null;
+    fileBytes: Uint8Array | null;
+    preprocessMode: 'off' | 'auto' | 'always';
+    fixedModelSpec: FixedModelSpec | null;
+}): DocumentHandlingDecision;
 export declare function prepareAssetPrompt({ ctx, attachment, }: {
     ctx: AssetPreprocessContext;
     attachment: AssetAttachment;

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

@@ -1,5 +1,6 @@
 import { type CacheState } from '../../../cache.js';
 import type { CliProvider, SummarizeConfig } from '../../../config.js';
+import type { MediaCache } from '../../../content/index.js';
 import type { LlmCall, RunMetricsReport } from '../../../costs.js';
 import type { OutputLanguage } from '../../../language.js';
 import type { ExecFileFn } from '../../../markitdown.js';
@@ -16,6 +17,7 @@ export type AssetSummaryContext = {
     timeoutMs: number;
     preprocessMode: 'off' | 'auto' | 'always';
     format: 'text' | 'markdown';
+    extractMode: boolean;
     lengthArg: {
         kind: 'preset';
         preset: SummaryLength;
@@ -23,6 +25,7 @@ export type AssetSummaryContext = {
         kind: 'chars';
         maxCharacters: number;
     };
+    forceSummary: boolean;
     outputLanguage: OutputLanguage;
     videoMode: 'auto' | 'transcript' | 'understand';
     fixedModelSpec: FixedModelSpec | null;
@@ -53,11 +56,14 @@ export type AssetSummaryContext = {
     trackedFetch: typeof fetch;
     writeViaFooter: (parts: string[]) => void;
     clearProgressForStdout: () => void;
+    restoreProgressAfterStdout?: (() => void) | null;
     getLiteLlmCatalog: () => Promise<Awaited<ReturnType<typeof import('../../../pricing/litellm.js').loadLiteLlmCatalog>>['catalog']>;
     buildReport: () => Promise<RunMetricsReport>;
     estimateCostUsd: () => Promise<number | null>;
     llmCalls: LlmCall[];
     cache: CacheState;
+    summaryCacheBypass: boolean;
+    mediaCache: MediaCache | null;
     apiStatus: {
         xaiApiKey: string | null;
         apiKey: string | null;

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

@@ -14,9 +14,10 @@ export declare function fetchLinkContentWithBirdTip({ client, url, options, env,
     env: Record<string, string | undefined>;
 }): Promise<ExtractedLinkContent>;
 export declare function deriveExtractionUi(extracted: ExtractedLinkContent): UrlExtractionUi;
-export declare function logExtractionDiagnostics({ extracted, stderr, verbose, verboseColor, }: {
+export declare function logExtractionDiagnostics({ extracted, stderr, verbose, verboseColor, env, }: {
     extracted: ExtractedLinkContent;
     stderr: NodeJS.WritableStream;
     verbose: boolean;
     verboseColor: boolean;
+    env?: Record<string, string | undefined>;
 }): void;

package/dist/types/run/flows/url/slides-output.d.ts

@@ -0,0 +1,66 @@
+import type { ExtractedLinkContent } from '../../../content/index.js';
+import type { SummaryLength } from '../../../shared/contracts.js';
+import type { SlideExtractionResult, SlideImage, SlideSourceKind } from '../../../slides/index.js';
+import { type StreamOutputMode } from '../../stream-output.js';
+import type { SummaryStreamHandler } from '../../summary-engine.js';
+export type SlidesTerminalOutput = {
+    onSlidesExtracted: (slides: SlideExtractionResult) => void;
+    onSlidesDone: (result: {
+        ok: boolean;
+        error?: string | null;
+    }) => void;
+    onSlideChunk: (chunk: {
+        slide: SlideImage;
+        meta: {
+            slidesDir: string;
+            sourceUrl: string;
+            sourceId: string;
+            sourceKind: SlideSourceKind;
+            ocrAvailable: boolean;
+        };
+    }) => void;
+    streamHandler: SummaryStreamHandler;
+    renderFromText: (summary: string) => Promise<void>;
+};
+export declare function createSlidesTerminalOutput({ io, flags, extracted, slides, enabled, outputMode, clearProgressForStdout, restoreProgressAfterStdout, onProgressText, }: {
+    io: {
+        env: Record<string, string | undefined>;
+        envForRun: Record<string, string | undefined>;
+        stdout: NodeJS.WritableStream;
+        stderr: NodeJS.WritableStream;
+    };
+    flags: {
+        plain: boolean;
+        lengthArg: {
+            kind: 'preset';
+            preset: SummaryLength;
+        } | {
+            kind: 'chars';
+            maxCharacters: number;
+        };
+        slidesDebug?: boolean;
+    };
+    extracted: ExtractedLinkContent;
+    slides: SlideExtractionResult | null | undefined;
+    enabled: boolean;
+    outputMode?: StreamOutputMode | null;
+    clearProgressForStdout: () => void;
+    restoreProgressAfterStdout?: (() => void) | null;
+    onProgressText?: ((text: string) => void) | null;
+}): SlidesTerminalOutput | null;
+export declare function createSlidesSummaryStreamHandler({ stdout, env, envForRun, plain, outputMode, clearProgressForStdout, restoreProgressAfterStdout, renderSlide, getSlideIndexOrder, getSlideMeta, debugWrite, }: {
+    stdout: NodeJS.WritableStream;
+    env: Record<string, string | undefined>;
+    envForRun: Record<string, string | undefined>;
+    plain: boolean;
+    outputMode: StreamOutputMode;
+    clearProgressForStdout: () => void;
+    restoreProgressAfterStdout?: (() => void) | null;
+    renderSlide: (index: number, title?: string | null) => Promise<void>;
+    getSlideIndexOrder: () => number[];
+    getSlideMeta?: ((index: number) => {
+        total: number;
+        timestamp: number | null;
+    }) | null;
+    debugWrite?: ((text: string) => void) | null;
+}): SummaryStreamHandler;

package/dist/types/run/flows/url/slides-text.d.ts

@@ -0,0 +1,87 @@
+import type { SummaryLength } from '../../../shared/contracts.js';
+export type TranscriptSegment = {
+    startSeconds: number;
+    text: string;
+};
+export type SlideTimelineEntry = {
+    index: number;
+    timestamp: number;
+};
+export declare const splitSlideTitleFromText: ({ text, }: {
+    text: string;
+    slideIndex: number;
+    total: number;
+}) => {
+    title: string | null;
+    body: string;
+};
+export declare const ensureSlideTitleLine: ({ text, slide, total, }: {
+    text: string;
+    slide: SlideTimelineEntry;
+    total: number;
+}) => string;
+export declare function findSlidesSectionStart(markdown: string): number | null;
+export declare function splitSummaryFromSlides(markdown: string): {
+    summary: string;
+    slidesSection: string | null;
+};
+export declare function parseSlideSummariesFromMarkdown(markdown: string): Map<number, string>;
+export declare function extractSlideMarkers(markdown: string): number[];
+export declare function normalizeSummarySlideHeadings(markdown: string): string;
+export declare function buildSlideTextFallback({ slides, transcriptTimedText, lengthArg, }: {
+    slides: SlideTimelineEntry[];
+    transcriptTimedText: string | null | undefined;
+    lengthArg: {
+        kind: 'preset';
+        preset: SummaryLength;
+    } | {
+        kind: 'chars';
+        maxCharacters: number;
+    };
+}): Map<number, string>;
+export declare function coerceSummaryWithSlides({ markdown, slides, transcriptTimedText, lengthArg, }: {
+    markdown: string;
+    slides: SlideTimelineEntry[];
+    transcriptTimedText?: string | null;
+    lengthArg: {
+        kind: 'preset';
+        preset: SummaryLength;
+    } | {
+        kind: 'chars';
+        maxCharacters: number;
+    };
+}): string;
+export declare function interleaveSlidesIntoTranscript({ transcriptTimedText, slides, }: {
+    transcriptTimedText: string;
+    slides: SlideTimelineEntry[];
+}): string;
+export declare function parseTranscriptTimedText(input: string | null | undefined): TranscriptSegment[];
+export declare function formatTimestamp(seconds: number): string;
+export declare function resolveSlideTextBudget({ lengthArg, slideCount, }: {
+    lengthArg: {
+        kind: 'preset';
+        preset: SummaryLength;
+    } | {
+        kind: 'chars';
+        maxCharacters: number;
+    };
+    slideCount: number;
+}): number;
+export declare function resolveSlideWindowSeconds({ lengthArg, }: {
+    lengthArg: {
+        kind: 'preset';
+        preset: SummaryLength;
+    } | {
+        kind: 'chars';
+        maxCharacters: number;
+    };
+}): number;
+export declare function getTranscriptTextForSlide({ slide, nextSlide, segments, budget, windowSeconds, }: {
+    slide: SlideTimelineEntry;
+    nextSlide: SlideTimelineEntry | null;
+    segments: TranscriptSegment[];
+    budget: number;
+    windowSeconds: number;
+}): string;
+export declare function formatOsc8Link(label: string, url: string | null, enabled: boolean): string;
+export declare function buildTimestampUrl(sourceUrl: string, seconds: number): string | null;