@steipete/summarize-core 0.7.0

package/dist/types/content/link-preview/content/firecrawl.d.ts

@@ -0,0 +1,14 @@
+import type { FirecrawlScrapeResult, LinkPreviewDeps } from '../deps.js';
+import type { FirecrawlDiagnostics } from '../types.js';
+import type { ExtractedLinkContent, FetchLinkContentOptions } from './types.js';
+export declare function shouldFallbackToFirecrawl(html: string): boolean;
+export declare function buildResultFromFirecrawl({ url, payload, cacheMode, maxCharacters, youtubeTranscriptMode, firecrawlDiagnostics, markdownRequested, deps, }: {
+    url: string;
+    payload: FirecrawlScrapeResult;
+    cacheMode: FetchLinkContentOptions['cacheMode'];
+    maxCharacters: number | null;
+    youtubeTranscriptMode: FetchLinkContentOptions['youtubeTranscript'];
+    firecrawlDiagnostics: FirecrawlDiagnostics;
+    markdownRequested: boolean;
+    deps: LinkPreviewDeps;
+}): Promise<ExtractedLinkContent | null>;

package/dist/types/content/link-preview/content/html.d.ts

@@ -0,0 +1,17 @@
+import type { LinkPreviewDeps } from '../deps.js';
+import type { FirecrawlDiagnostics } from '../types.js';
+import { extractReadabilityFromHtml } from './readability.js';
+import type { ExtractedLinkContent, FetchLinkContentOptions, MarkdownMode } from './types.js';
+export declare function buildResultFromHtmlDocument({ url, html, cacheMode, maxCharacters, youtubeTranscriptMode, firecrawlDiagnostics, markdownRequested, markdownMode, timeoutMs, deps, readabilityCandidate, }: {
+    url: string;
+    html: string;
+    cacheMode: FetchLinkContentOptions['cacheMode'];
+    maxCharacters: number | null;
+    youtubeTranscriptMode: FetchLinkContentOptions['youtubeTranscript'];
+    firecrawlDiagnostics: FirecrawlDiagnostics;
+    markdownRequested: boolean;
+    markdownMode: MarkdownMode;
+    timeoutMs: number;
+    deps: LinkPreviewDeps;
+    readabilityCandidate: Awaited<ReturnType<typeof extractReadabilityFromHtml>> | null;
+}): Promise<ExtractedLinkContent>;

package/dist/types/content/link-preview/content/index.d.ts

@@ -0,0 +1,4 @@
+import type { LinkPreviewDeps } from '../deps.js';
+import type { ExtractedLinkContent, FetchLinkContentOptions } from './types.js';
+export declare function fetchLinkContent(url: string, options: FetchLinkContentOptions | undefined, deps: LinkPreviewDeps): Promise<ExtractedLinkContent>;
+export type { ExtractedLinkContent, FetchLinkContentOptions } from './types.js';

package/dist/types/content/link-preview/content/jsonld.d.ts

@@ -0,0 +1,6 @@
+export type JsonLdContent = {
+    title: string | null;
+    description: string | null;
+    type: string | null;
+};
+export declare function extractJsonLdContent(html: string): JsonLdContent | null;

package/dist/types/content/link-preview/content/parsers.d.ts

@@ -0,0 +1,7 @@
+export interface ParsedMetadata {
+    title: string | null;
+    description: string | null;
+    siteName: string | null;
+}
+export declare function extractMetadataFromHtml(html: string, url: string): ParsedMetadata;
+export declare function extractMetadataFromFirecrawl(metadata: Record<string, unknown> | null | undefined): ParsedMetadata;

package/dist/types/content/link-preview/content/podcast-utils.d.ts

@@ -0,0 +1,7 @@
+export declare function extractSpotifyEpisodeId(url: string): string | null;
+export declare function extractApplePodcastIds(url: string): {
+    showId: string;
+    episodeId: string | null;
+} | null;
+export declare function isPodcastLikeJsonLdType(type: string | null | undefined): boolean;
+export declare function isPodcastHost(url: string): boolean;

package/dist/types/content/link-preview/content/readability.d.ts

@@ -0,0 +1,8 @@
+export type ReadabilityResult = {
+    text: string;
+    html: string | null;
+    title: string | null;
+    excerpt: string | null;
+};
+export declare function extractReadabilityFromHtml(html: string, url?: string): Promise<ReadabilityResult | null>;
+export declare function toReadabilityHtml(result: ReadabilityResult | null): string | null;

package/dist/types/content/link-preview/content/twitter-utils.d.ts

@@ -0,0 +1,4 @@
+export declare function isTwitterStatusUrl(url: string): boolean;
+export declare function toNitterUrls(url: string): string[];
+export declare function isBlockedTwitterContent(content: string): boolean;
+export declare function isAnubisHtml(html: string): boolean;

package/dist/types/content/link-preview/content/types.d.ts

@@ -0,0 +1,61 @@
+import type { CacheMode, ContentFetchDiagnostics, TranscriptDiagnostics, TranscriptSource } from '../types.js';
+export declare const DEFAULT_TIMEOUT_MS = 120000;
+export declare const DEFAULT_MAX_CONTENT_CHARACTERS = 8000;
+export declare const DEFAULT_CACHE_MODE: CacheMode;
+export type YoutubeTranscriptMode = 'auto' | 'web' | 'apify' | 'yt-dlp';
+export type FirecrawlMode = 'off' | 'auto' | 'always';
+export type ContentFormat = 'text' | 'markdown';
+export type MarkdownMode = 'off' | 'auto' | 'llm' | 'readability';
+export interface FetchLinkContentOptions {
+    timeoutMs?: number;
+    maxCharacters?: number;
+    cacheMode?: CacheMode;
+    youtubeTranscript?: YoutubeTranscriptMode;
+    firecrawl?: FirecrawlMode;
+    format?: ContentFormat;
+    markdownMode?: MarkdownMode;
+}
+export interface TranscriptResolution {
+    diagnostics?: TranscriptDiagnostics;
+    source: TranscriptSource | null;
+    text: string | null;
+    metadata?: Record<string, unknown> | null;
+}
+export interface ExtractedLinkContent {
+    url: string;
+    title: string | null;
+    description: string | null;
+    siteName: string | null;
+    content: string;
+    truncated: boolean;
+    totalCharacters: number;
+    wordCount: number;
+    transcriptCharacters: number | null;
+    transcriptLines: number | null;
+    transcriptWordCount: number | null;
+    transcriptSource: TranscriptSource | null;
+    transcriptionProvider: string | null;
+    transcriptMetadata: Record<string, unknown> | null;
+    mediaDurationSeconds: number | null;
+    video: {
+        kind: 'youtube' | 'direct';
+        url: string;
+    } | null;
+    isVideoOnly: boolean;
+    diagnostics: ContentFetchDiagnostics;
+}
+export interface FinalizationArguments {
+    url: string;
+    baseContent: string;
+    maxCharacters: number | null;
+    title: string | null;
+    description: string | null;
+    siteName: string | null;
+    transcriptResolution: TranscriptResolution;
+    video: {
+        kind: 'youtube' | 'direct';
+        url: string;
+    } | null;
+    isVideoOnly: boolean;
+    diagnostics: ContentFetchDiagnostics;
+}

package/dist/types/content/link-preview/content/utils.d.ts

@@ -0,0 +1,17 @@
+import type { CacheMode, TranscriptDiagnostics } from '../types.js';
+import { type ExtractedLinkContent, type FetchLinkContentOptions, type FinalizationArguments, type FirecrawlMode, type TranscriptResolution } from './types.js';
+export declare function resolveCacheMode(options?: FetchLinkContentOptions): "default" | "bypass";
+export declare function resolveMaxCharacters(options?: FetchLinkContentOptions): number | null;
+export declare function resolveTimeoutMs(options?: FetchLinkContentOptions): number;
+export declare function resolveFirecrawlMode(options?: FetchLinkContentOptions): FirecrawlMode;
+export declare function appendNote(existing: string | null | undefined, next: string): string;
+export declare function safeHostname(rawUrl: string): string | null;
+export declare function pickFirstText(candidates: Array<string | null | undefined>): string | null;
+export declare function selectBaseContent(sourceContent: string, transcriptText: string | null): string;
+export declare function summarizeTranscript(transcriptText: string | null): {
+    transcriptCharacters: number | null;
+    transcriptLines: number | null;
+    transcriptWordCount: number | null;
+};
+export declare function ensureTranscriptDiagnostics(resolution: TranscriptResolution, cacheMode: CacheMode): TranscriptDiagnostics;
+export declare function finalizeExtractedLinkContent({ url, baseContent, maxCharacters, title, description, siteName, transcriptResolution, video, isVideoOnly, diagnostics, }: FinalizationArguments): ExtractedLinkContent;

package/dist/types/content/link-preview/content/video.d.ts

@@ -0,0 +1,5 @@
+export type DetectedVideo = {
+    kind: 'youtube' | 'direct';
+    url: string;
+};
+export declare function detectPrimaryVideoFromHtml(html: string, url: string): DetectedVideo | null;

package/dist/types/content/link-preview/content/youtube.d.ts

@@ -0,0 +1 @@
+export declare function extractYouTubeShortDescription(html: string): string | null;

package/dist/types/content/link-preview/deps.d.ts

@@ -0,0 +1,167 @@
+import type { CacheMode, TranscriptSource } from './types.js';
+export declare const ProgressKind: {
+    readonly FetchHtmlStart: "fetch-html-start";
+    readonly FetchHtmlProgress: "fetch-html-progress";
+    readonly FetchHtmlDone: "fetch-html-done";
+    readonly TranscriptMediaDownloadStart: "transcript-media-download-start";
+    readonly TranscriptMediaDownloadProgress: "transcript-media-download-progress";
+    readonly TranscriptMediaDownloadDone: "transcript-media-download-done";
+    readonly TranscriptWhisperStart: "transcript-whisper-start";
+    readonly TranscriptWhisperProgress: "transcript-whisper-progress";
+    readonly TranscriptStart: "transcript-start";
+    readonly TranscriptDone: "transcript-done";
+    readonly FirecrawlStart: "firecrawl-start";
+    readonly FirecrawlDone: "firecrawl-done";
+    readonly NitterStart: "nitter-start";
+    readonly NitterDone: "nitter-done";
+    readonly BirdStart: "bird-start";
+    readonly BirdDone: "bird-done";
+};
+export type LinkPreviewProgressEvent = {
+    kind: 'fetch-html-start';
+    url: string;
+} | {
+    kind: 'fetch-html-progress';
+    url: string;
+    downloadedBytes: number;
+    totalBytes: number | null;
+} | {
+    kind: 'fetch-html-done';
+    url: string;
+    downloadedBytes: number;
+    totalBytes: number | null;
+} | {
+    kind: 'transcript-media-download-start';
+    url: string;
+    service: 'youtube' | 'podcast' | 'generic';
+    mediaUrl: string | null;
+    totalBytes: number | null;
+} | {
+    kind: 'transcript-media-download-progress';
+    url: string;
+    service: 'youtube' | 'podcast' | 'generic';
+    downloadedBytes: number;
+    totalBytes: number | null;
+} | {
+    kind: 'transcript-media-download-done';
+    url: string;
+    service: 'youtube' | 'podcast' | 'generic';
+    downloadedBytes: number;
+    totalBytes: number | null;
+} | {
+    kind: 'transcript-whisper-start';
+    url: string;
+    service: 'youtube' | 'podcast' | 'generic';
+    providerHint: 'cpp' | 'openai' | 'fal' | 'openai->fal' | 'unknown';
+    modelId: string | null;
+    totalDurationSeconds: number | null;
+    parts: number | null;
+} | {
+    kind: 'transcript-whisper-progress';
+    url: string;
+    service: 'youtube' | 'podcast' | 'generic';
+    processedDurationSeconds: number | null;
+    totalDurationSeconds: number | null;
+    partIndex: number | null;
+    parts: number | null;
+} | {
+    kind: 'transcript-start';
+    url: string;
+    service: 'youtube' | 'podcast' | 'generic';
+    hint: string | null;
+} | {
+    kind: 'transcript-done';
+    url: string;
+    ok: boolean;
+    service: 'youtube' | 'podcast' | 'generic';
+    source: TranscriptSource | null;
+    hint: string | null;
+} | {
+    kind: 'firecrawl-start';
+    url: string;
+    reason: string;
+} | {
+    kind: 'firecrawl-done';
+    url: string;
+    ok: boolean;
+    markdownBytes: number | null;
+    htmlBytes: number | null;
+} | {
+    kind: 'nitter-start';
+    url: string;
+} | {
+    kind: 'nitter-done';
+    url: string;
+    ok: boolean;
+    textBytes: number | null;
+} | {
+    kind: 'bird-start';
+    url: string;
+} | {
+    kind: 'bird-done';
+    url: string;
+    ok: boolean;
+    textBytes: number | null;
+};
+export interface FirecrawlScrapeResult {
+    markdown: string;
+    html?: string | null;
+    metadata?: Record<string, unknown> | null;
+}
+export type ScrapeWithFirecrawl = (url: string, options?: {
+    cacheMode?: CacheMode;
+    timeoutMs?: number;
+}) => Promise<FirecrawlScrapeResult | null>;
+export type ConvertHtmlToMarkdown = (args: {
+    url: string;
+    html: string;
+    title: string | null;
+    siteName: string | null;
+    timeoutMs: number;
+}) => Promise<string>;
+export type BirdTweetPayload = {
+    id?: string;
+    text: string;
+    author?: {
+        username?: string;
+        name?: string;
+    };
+    createdAt?: string;
+};
+export type ReadTweetWithBird = (args: {
+    url: string;
+    timeoutMs: number;
+}) => Promise<BirdTweetPayload | null>;
+export interface TranscriptCacheGetResult {
+    content: string | null;
+    source: TranscriptSource | null;
+    expired: boolean;
+    metadata?: Record<string, unknown> | null;
+}
+export interface TranscriptCacheSetArgs {
+    url: string;
+    service: string;
+    resourceKey: string | null;
+    content: string | null;
+    source: TranscriptSource | null;
+    ttlMs: number;
+    metadata?: Record<string, unknown> | null;
+}
+export interface TranscriptCache {
+    get(args: {
+        url: string;
+    }): Promise<TranscriptCacheGetResult | null>;
+    set(args: TranscriptCacheSetArgs): Promise<void>;
+}
+export interface LinkPreviewDeps {
+    fetch: typeof fetch;
+    scrapeWithFirecrawl: ScrapeWithFirecrawl | null;
+    apifyApiToken: string | null;
+    ytDlpPath: string | null;
+    falApiKey: string | null;
+    openaiApiKey: string | null;
+    convertHtmlToMarkdown: ConvertHtmlToMarkdown | null;
+    transcriptCache: TranscriptCache | null;
+    readTweetWithBird?: ReadTweetWithBird | null;
+    onProgress?: ((event: LinkPreviewProgressEvent) => void) | null;
+}

package/dist/types/content/link-preview/fetch-with-timeout.d.ts

@@ -0,0 +1,4 @@
+type FetchLike = typeof fetch;
+type FetchArguments = Parameters<typeof fetch>;
+export declare function fetchWithTimeout(fetchImpl: FetchLike, input: FetchArguments[0], init?: FetchArguments[1], timeoutMs?: number): Promise<Response>;
+export {};

package/dist/types/content/link-preview/types.d.ts

@@ -0,0 +1,37 @@
+export type TranscriptSource = 'youtubei' | 'captionTracks' | 'yt-dlp' | 'podcastTranscript' | 'whisper' | 'apify' | 'html' | 'unavailable' | 'unknown';
+export declare const CACHE_MODES: readonly ["default", "bypass"];
+export type CacheMode = (typeof CACHE_MODES)[number];
+export type CacheStatus = 'hit' | 'miss' | 'expired' | 'bypassed' | 'fallback' | 'unknown';
+export interface TranscriptDiagnostics {
+    cacheMode: CacheMode;
+    cacheStatus: CacheStatus;
+    textProvided: boolean;
+    provider: TranscriptSource | null;
+    attemptedProviders: TranscriptSource[];
+    notes?: string | null;
+}
+export interface FirecrawlDiagnostics {
+    attempted: boolean;
+    used: boolean;
+    cacheMode: CacheMode;
+    cacheStatus: CacheStatus;
+    notes?: string | null;
+}
+export interface MarkdownDiagnostics {
+    requested: boolean;
+    used: boolean;
+    provider: 'firecrawl' | 'llm' | null;
+    notes?: string | null;
+}
+export interface ContentFetchDiagnostics {
+    strategy: 'bird' | 'firecrawl' | 'html' | 'nitter';
+    firecrawl: FirecrawlDiagnostics;
+    markdown: MarkdownDiagnostics;
+    transcript: TranscriptDiagnostics;
+}
+export interface TranscriptResolution {
+    text: string | null;
+    source: TranscriptSource | null;
+    metadata?: Record<string, unknown> | null;
+    diagnostics?: TranscriptDiagnostics;
+}

package/dist/types/content/transcript/cache.d.ts

@@ -0,0 +1,29 @@
+import type { TranscriptCache } from '../link-preview/deps.js';
+import type { CacheMode, TranscriptDiagnostics, TranscriptResolution, TranscriptSource } from '../link-preview/types.js';
+export declare const DEFAULT_TTL_MS: number;
+export declare const NEGATIVE_TTL_MS: number;
+type CacheDiagnostics = Pick<TranscriptDiagnostics, 'cacheStatus' | 'notes' | 'provider' | 'textProvided' | 'cacheMode' | 'attemptedProviders'>;
+export interface CacheReadArguments {
+    url: string;
+    cacheMode: CacheMode;
+    transcriptCache: TranscriptCache | null;
+}
+export interface TranscriptCacheLookup {
+    cached: Awaited<ReturnType<TranscriptCache['get']>> | null;
+    resolution: TranscriptResolution | null;
+    diagnostics: CacheDiagnostics;
+}
+export declare const readTranscriptCache: ({ url, cacheMode, transcriptCache, }: CacheReadArguments) => Promise<TranscriptCacheLookup>;
+export declare const mapCachedSource: (source: string | null) => TranscriptSource | null;
+export declare const writeTranscriptCache: ({ url, service, resourceKey, result, transcriptCache, }: {
+    url: string;
+    service: string;
+    resourceKey: string | null;
+    result: {
+        text: string | null;
+        source: TranscriptSource | null;
+        metadata?: Record<string, unknown> | undefined;
+    };
+    transcriptCache: TranscriptCache | null;
+}) => Promise<void>;
+export {};

package/dist/types/content/transcript/index.d.ts

@@ -0,0 +1,9 @@
+import type { LinkPreviewDeps } from '../link-preview/deps.js';
+import type { CacheMode, TranscriptResolution } from '../link-preview/types.js';
+import type { ProviderFetchOptions } from './types.js';
+interface ResolveTranscriptOptions {
+    youtubeTranscriptMode?: ProviderFetchOptions['youtubeTranscriptMode'];
+    cacheMode?: CacheMode;
+}
+export declare const resolveTranscriptForLink: (url: string, html: string | null, deps: LinkPreviewDeps, { youtubeTranscriptMode, cacheMode: providedCacheMode }?: ResolveTranscriptOptions) => Promise<TranscriptResolution>;
+export {};

package/dist/types/content/transcript/normalize.d.ts

@@ -0,0 +1,3 @@
+export declare const normalizeTranscriptText: (input: string) => string;
+export declare const normalizeTranscriptLines: (lines: readonly string[]) => string | null;
+export declare const normalizeApifyTranscript: (raw: unknown) => string | null;

package/dist/types/content/transcript/providers/generic.d.ts

@@ -0,0 +1,3 @@
+import type { ProviderContext, ProviderFetchOptions, ProviderResult } from '../types.js';
+export declare const canHandle: () => boolean;
+export declare const fetchTranscript: (_context: ProviderContext, _options: ProviderFetchOptions) => Promise<ProviderResult>;

package/dist/types/content/transcript/providers/podcast/apple-flow.d.ts

@@ -0,0 +1,4 @@
+import type { ProviderResult } from '../../types.js';
+import type { PodcastFlowContext } from './flow-context.js';
+export declare function fetchAppleTranscriptFromItunesLookup(flow: PodcastFlowContext): Promise<ProviderResult | null>;
+export declare function fetchAppleTranscriptFromEmbeddedHtml(flow: PodcastFlowContext): Promise<ProviderResult | null>;

package/dist/types/content/transcript/providers/podcast/apple.d.ts

@@ -0,0 +1,6 @@
+export declare function extractAppleEpisodeTitleFromHtml(html: string): string | null;
+export declare function extractEmbeddedJsonUrl(html: string, field: string): string | null;
+export declare function extractApplePodcastIds(url: string): {
+    showId: string;
+    episodeId: string | null;
+} | null;

package/dist/types/content/transcript/providers/podcast/constants.d.ts

@@ -0,0 +1,7 @@
+export declare const FEED_HINT_URL_PATTERN: RegExp;
+export declare const PODCAST_PLATFORM_HOST_PATTERN: RegExp;
+export declare const TRANSCRIPTION_TIMEOUT_MS = 600000;
+export declare const MAX_REMOTE_MEDIA_BYTES: number;
+export declare const BLOCKED_HTML_HINT_PATTERN: RegExp;
+export declare const ITUNES_SEARCH_URL = "https://itunes.apple.com/search";
+export declare const ITUNES_LOOKUP_URL = "https://itunes.apple.com/lookup";

package/dist/types/content/transcript/providers/podcast/flow-context.d.ts

@@ -0,0 +1,11 @@
+import type { ProviderContext, ProviderFetchOptions, ProviderResult } from '../../types.js';
+import type { TranscribeRequest, TranscriptionResult } from './media.js';
+export type PodcastFlowContext = {
+    context: ProviderContext;
+    options: ProviderFetchOptions;
+    attemptedProviders: ProviderResult['attemptedProviders'];
+    notes: string[];
+    pushOnce: (provider: ProviderResult['attemptedProviders'][number]) => void;
+    ensureTranscriptionProvider: () => ProviderResult | null;
+    transcribe: (request: TranscribeRequest) => Promise<TranscriptionResult>;
+};

package/dist/types/content/transcript/providers/podcast/itunes.d.ts

@@ -0,0 +1,17 @@
+export declare function resolveApplePodcastEpisodeFromItunesLookup({ fetchImpl, showId, episodeId, }: {
+    fetchImpl: typeof fetch;
+    showId: string;
+    episodeId: string | null;
+}): Promise<{
+    episodeUrl: string;
+    feedUrl: string | null;
+    fileExtension: string | null;
+    durationSeconds: number | null;
+    episodeTitle: string | null;
+} | null>;
+export declare function resolvePodcastFeedUrlFromItunesSearch(fetchImpl: typeof fetch, showTitle: string): Promise<string | null>;
+export declare function resolvePodcastEpisodeFromItunesSearch(fetchImpl: typeof fetch, showTitle: string, episodeTitle: string): Promise<{
+    episodeUrl: string;
+    durationSeconds: number | null;
+    episodeTitle: string;
+} | null>;

package/dist/types/content/transcript/providers/podcast/json.d.ts

@@ -0,0 +1,8 @@
+export type JsonRecord = Record<string, unknown>;
+export declare function isJsonRecord(value: unknown): value is JsonRecord;
+export declare function getJsonPath(value: unknown, path: readonly string[]): unknown;
+export declare function getJsonString(value: unknown, path: readonly string[]): string | null;
+export declare function getJsonNumber(value: unknown, path: readonly string[]): number | null;
+export declare function getJsonArray(value: unknown, path: readonly string[]): unknown[];
+export declare function asRecordArray(value: unknown): JsonRecord[];
+export declare function getRecordString(record: JsonRecord, key: string): string | null;

package/dist/types/content/transcript/providers/podcast/media.d.ts

@@ -0,0 +1,42 @@
+import type { ProviderFetchOptions } from '../../types.js';
+export type TranscribeRequest = {
+    url: string;
+    filenameHint: string;
+    durationSecondsHint: number | null;
+};
+export type TranscriptionResult = {
+    text: string | null;
+    provider: string | null;
+    error: Error | null;
+};
+export declare function transcribeMediaUrl({ fetchImpl, url, filenameHint, durationSecondsHint, openaiApiKey, falApiKey, notes, progress, }: {
+    fetchImpl: typeof fetch;
+    url: string;
+    filenameHint: string;
+    durationSecondsHint: number | null;
+    openaiApiKey: string | null;
+    falApiKey: string | null;
+    notes: string[];
+    progress: {
+        url: string;
+        service: 'podcast';
+        onProgress: ProviderFetchOptions['onProgress'] | null;
+    } | null;
+}): Promise<TranscriptionResult>;
+export declare function probeRemoteMedia(fetchImpl: typeof fetch, url: string): Promise<{
+    contentLength: number | null;
+    mediaType: string | null;
+    filename: string | null;
+}>;
+export declare function downloadCappedBytes(fetchImpl: typeof fetch, url: string, maxBytes: number, options?: {
+    totalBytes: number | null;
+    onProgress?: ((downloadedBytes: number) => void) | null;
+}): Promise<Uint8Array>;
+export declare function downloadToFile(fetchImpl: typeof fetch, url: string, filePath: string, options?: {
+    totalBytes: number | null;
+    onProgress?: ((downloadedBytes: number) => void) | null;
+}): Promise<number>;
+export declare function normalizeHeaderType(value: string | null): string | null;
+export declare function parseContentLength(value: string | null): number | null;
+export declare function filenameFromUrl(url: string): string | null;
+export declare function formatBytes(bytes: number): string;

package/dist/types/content/transcript/providers/podcast/results.d.ts

@@ -0,0 +1,10 @@
+import type { ProviderResult } from '../../types.js';
+import type { TranscriptionResult } from './media.js';
+export declare function joinNotes(notes: string[]): string | null;
+export declare function buildWhisperResult({ attemptedProviders, notes, outcome, metadata, includeProviderOnFailure, }: {
+    attemptedProviders: ProviderResult['attemptedProviders'];
+    notes: string[];
+    outcome: TranscriptionResult;
+    metadata: Record<string, unknown>;
+    includeProviderOnFailure?: boolean;
+}): ProviderResult;

package/dist/types/content/transcript/providers/podcast/rss.d.ts

@@ -0,0 +1,22 @@
+export declare function looksLikeRssOrAtomFeed(xml: string): boolean;
+export declare function extractEnclosureFromFeed(xml: string): {
+    enclosureUrl: string;
+    durationSeconds: number | null;
+} | null;
+export declare function extractEnclosureForEpisode(feedXml: string, episodeTitle: string): {
+    enclosureUrl: string;
+    durationSeconds: number | null;
+} | null;
+export declare function extractItemDurationSeconds(itemXml: string): number | null;
+export declare function decodeXmlEntities(value: string): string;
+export declare function normalizeLooseTitle(value: string): string;
+export declare function tryFetchTranscriptFromFeedXml({ fetchImpl, feedXml, episodeTitle, notes, }: {
+    fetchImpl: typeof fetch;
+    feedXml: string;
+    episodeTitle: string | null;
+    notes: string[];
+}): Promise<{
+    text: string;
+    transcriptUrl: string;
+    transcriptType: string | null;
+} | null>;

package/dist/types/content/transcript/providers/podcast/spotify-flow.d.ts

@@ -0,0 +1,3 @@
+import type { ProviderResult } from '../../types.js';
+import type { PodcastFlowContext } from './flow-context.js';
+export declare function fetchSpotifyTranscript(flow: PodcastFlowContext): Promise<ProviderResult | null>;

package/dist/types/content/transcript/providers/podcast/spotify.d.ts

@@ -0,0 +1,24 @@
+export declare function extractSpotifyEpisodeId(url: string): string | null;
+export declare function extractSpotifyEmbedData(html: string): {
+    showTitle: string;
+    episodeTitle: string;
+    durationSeconds: number | null;
+    drmFormat: string | null;
+    audioUrl: string | null;
+} | null;
+export declare function fetchSpotifyEmbedHtml({ embedUrl, episodeId, fetchImpl, scrapeWithFirecrawl, }: {
+    embedUrl: string;
+    episodeId: string;
+    fetchImpl: typeof fetch;
+    scrapeWithFirecrawl: ((url: string, options?: {
+        cacheMode?: 'default' | 'bypass';
+        timeoutMs?: number;
+    }) => Promise<{
+        html?: string | null;
+        markdown: string;
+    } | null>) | null;
+}): Promise<{
+    html: string;
+    via: 'fetch' | 'firecrawl';
+}>;
+export declare function looksLikeBlockedHtml(html: string): boolean;

package/dist/types/content/transcript/providers/podcast.d.ts

@@ -0,0 +1,20 @@
+import type { ProviderContext, ProviderFetchOptions, ProviderResult } from '../types.js';
+import { resolvePodcastFeedUrlFromItunesSearch } from './podcast/itunes.js';
+import { downloadCappedBytes, downloadToFile, filenameFromUrl, formatBytes, normalizeHeaderType, parseContentLength, probeRemoteMedia } from './podcast/media.js';
+import { extractEnclosureForEpisode, extractItemDurationSeconds } from './podcast/rss.js';
+import { looksLikeBlockedHtml } from './podcast/spotify.js';
+export declare const canHandle: ({ url, html }: ProviderContext) => boolean;
+export declare const fetchTranscript: (context: ProviderContext, options: ProviderFetchOptions) => Promise<ProviderResult>;
+export declare const __test__: {
+    probeRemoteMedia: typeof probeRemoteMedia;
+    downloadCappedBytes: typeof downloadCappedBytes;
+    downloadToFile: typeof downloadToFile;
+    normalizeHeaderType: typeof normalizeHeaderType;
+    parseContentLength: typeof parseContentLength;
+    filenameFromUrl: typeof filenameFromUrl;
+    looksLikeBlockedHtml: typeof looksLikeBlockedHtml;
+    extractItemDurationSeconds: typeof extractItemDurationSeconds;
+    extractEnclosureForEpisode: typeof extractEnclosureForEpisode;
+    resolvePodcastFeedUrlFromItunesSearch: typeof resolvePodcastFeedUrlFromItunesSearch;
+    formatBytes: typeof formatBytes;
+};