SYMBOL INDEX (477 symbols across 81 files)

FILE: examples/ai-tools/anthropic-summary.ts
  function main (line 16) | async function main() {

FILE: examples/ai-tools/langchain-loader.ts
  class ReaderEngineLoader (line 17) | class ReaderEngineLoader extends BaseDocumentLoader {
    method constructor (line 24) | constructor(options: {
    method load (line 39) | async load(): Promise<Document[]> {
  function main (line 94) | async function main() {

FILE: examples/ai-tools/llamaindex-loader.ts
  function loadDocuments (line 16) | async function loadDocuments(reader: ReaderClient, urls: string[]): Prom...
  function crawlAndLoadDocuments (line 40) | async function crawlAndLoadDocuments(
  function main (line 71) | async function main() {

FILE: examples/ai-tools/openai-summary.ts
  function main (line 16) | async function main() {

FILE: examples/ai-tools/pinecone-ingest.ts
  constant INDEX_NAME (line 19) | const INDEX_NAME = "reader-docs";
  function main (line 21) | async function main() {

FILE: examples/ai-tools/qdrant-ingest.ts
  constant COLLECTION_NAME (line 19) | const COLLECTION_NAME = "reader-docs";
  constant VECTOR_SIZE (line 20) | const VECTOR_SIZE = 1536;
  function main (line 22) | async function main() {

FILE: examples/ai-tools/vercel-ai-stream.ts
  function main (line 17) | async function main() {

FILE: examples/basic/all-formats.ts
  function main (line 10) | async function main() {

FILE: examples/basic/basic-scrape.ts
  function main (line 10) | async function main() {

FILE: examples/basic/batch-scrape.ts
  function main (line 10) | async function main() {

FILE: examples/basic/browser-pool-config.ts
  function main (line 11) | async function main() {

FILE: examples/basic/browser-session-actions.ts
  function main (line 17) | async function main() {

FILE: examples/basic/browser-session-puppeteer.ts
  function main (line 15) | async function main() {

FILE: examples/basic/browser-session-selenium.ts
  function sendCDP (line 21) | function sendCDP(
  function main (line 45) | async function main() {

FILE: examples/basic/browser-session.ts
  function main (line 22) | async function main() {

FILE: examples/basic/cloudflare-bypass.ts
  function main (line 14) | async function main() {

FILE: examples/basic/crawl-website.ts
  function main (line 10) | async function main() {

FILE: examples/basic/large-batch-scrape.ts
  function generateSampleUrls (line 34) | function generateSampleUrls(count: number): string[] {
  function main (line 44) | async function main() {

FILE: examples/basic/proxy-pool.ts
  function main (line 15) | async function main() {

FILE: examples/basic/with-proxy.ts
  function main (line 10) | async function main() {

FILE: examples/production/browser-pool-scaling/src/index.ts
  function createConnectionToCore (line 23) | function createConnectionToCore(): ConnectionToHeroCore {
  constant PORT (line 64) | const PORT = process.env.PORT || 3003;
  function formatDuration (line 319) | function formatDuration(ms: number): string {
  function getUtilizationStatus (line 331) | function getUtilizationStatus(stats: { total: number; busy: number; queu...
  function startServer (line 365) | async function startServer() {

FILE: examples/production/express-server/src/index.ts
  constant PORT (line 21) | const PORT = process.env.PORT || 3001;
  function startServer (line 243) | async function startServer() {

FILE: examples/production/job-queue-bullmq/src/index.ts
  constant PORT (line 21) | const PORT = process.env.PORT || 3002;
  function startServer (line 265) | async function startServer() {

FILE: examples/production/job-queue-bullmq/src/queue.ts
  type ScrapeJobData (line 37) | interface ScrapeJobData {
  type ScrapeJobResult (line 51) | interface ScrapeJobResult {
  function addScrapeJob (line 75) | async function addScrapeJob(
  function getJob (line 89) | async function getJob(jobId: string) {
  function getQueueStats (line 96) | async function getQueueStats() {

FILE: examples/production/job-queue-bullmq/src/worker.ts
  function processJob (line 20) | async function processJob(job: Job<ScrapeJobData>): Promise<ScrapeJobRes...
  function startWorker (line 118) | async function startWorker() {

FILE: src/browser-session.ts
  constant DEFAULT_SESSION_TIMEOUT_MS (line 42) | const DEFAULT_SESSION_TIMEOUT_MS = 300_000;
  constant CHROME_LAUNCH_TIMEOUT_MS (line 43) | const CHROME_LAUNCH_TIMEOUT_MS = 15_000;
  function findChromePath (line 49) | function findChromePath(): string {
  function startAuthProxy (line 93) | function startAuthProxy(
  function parseProxy (line 179) | function parseProxy(proxyUrl: string): {
  function createBrowserSession (line 205) | async function createBrowserSession(

FILE: src/browser-types.ts
  type BrowserOptions (line 11) | interface BrowserOptions {
  type BrowserSession (line 50) | interface BrowserSession {
  type BrowserSessionInternalOptions (line 68) | interface BrowserSessionInternalOptions extends BrowserOptions {

FILE: src/browser/hero-config.ts
  type HeroConfigOptions (line 7) | interface HeroConfigOptions {
  function createHeroConfig (line 39) | function createHeroConfig(options: HeroConfigOptions = {}): any {
  function getDefaultHeroConfig (line 122) | function getDefaultHeroConfig(): any {

FILE: src/browser/pool.ts
  constant DEFAULT_POOL_CONFIG (line 17) | const DEFAULT_POOL_CONFIG: PoolConfig = {
  function generateId (line 31) | function generateId(): string {
  class BrowserPool (line 56) | class BrowserPool implements IBrowserPool {
    method constructor (line 72) | constructor(
    method initialize (line 90) | async initialize(): Promise<void> {
    method shutdown (line 116) | async shutdown(): Promise<void> {
    method acquire (line 158) | async acquire(): Promise<Hero> {
    method release (line 188) | release(hero: Hero): void {
    method withBrowser (line 218) | async withBrowser<T>(callback: (hero: Hero) => Promise<T>): Promise<T> {
    method getStats (line 238) | getStats(): PoolStats {
    method healthCheck (line 258) | async healthCheck(): Promise<HealthStatus> {
    method createInstance (line 291) | private async createInstance(): Promise<BrowserInstance> {
    method shouldRecycle (line 313) | private shouldRecycle(instance: BrowserInstance): boolean {
    method recycleInstance (line 324) | private async recycleInstance(instance: BrowserInstance): Promise<void> {
    method queueRequest (line 361) | private queueRequest(): Promise<Hero> {
    method processQueue (line 391) | private processQueue(): void {
    method startRecycling (line 410) | private startRecycling(): void {
    method startHealthChecks (line 425) | private startHealthChecks(): void {

FILE: src/browser/proxy-bound-browser.ts
  type TabLike (line 40) | interface TabLike {
  type HeroLike (line 54) | interface HeroLike {
  type HeroFactory (line 65) | interface HeroFactory {
  function createDefaultHeroFactory (line 83) | function createDefaultHeroFactory(): HeroFactory {
  type BrowserState (line 110) | type BrowserState = "launching" | "active" | "retired" | "closed";
  type ProxyBoundBrowserStats (line 116) | interface ProxyBoundBrowserStats {
  type ProxyBoundBrowserOptions (line 128) | interface ProxyBoundBrowserOptions {
  class ProxyBoundBrowser (line 192) | class ProxyBoundBrowser {
    method constructor (line 223) | constructor(options: ProxyBoundBrowserOptions) {
    method getState (line 275) | getState(): BrowserState {
    method isAvailable (line 283) | isAvailable(): boolean {
    method getActiveTabs (line 291) | getActiveTabs(): number {
    method getStats (line 298) | getStats(): ProxyBoundBrowserStats {
    method withPage (line 319) | async withPage<T>(fn: (tab: TabLike) => Promise<T>): Promise<T> {
    method retire (line 404) | async retire(): Promise<void> {
    method relaunch (line 447) | async relaunch(): Promise<void> {
    method launch (line 475) | private async launch(): Promise<void> {
    method drainLimit (line 499) | private async drainLimit(): Promise<void> {
  function redactProxyUrl (line 510) | function redactProxyUrl(proxyUrl: string | null): string {
  function makeDeferred (line 526) | function makeDeferred<T>(): { promise: Promise<T>; resolve: (v: T) => vo...

FILE: src/browser/tiered-pool.ts
  type PoolTier (line 44) | type PoolTier = "datacenter" | "residential" | "direct";
  type TierConfig (line 52) | interface TierConfig {
  type TieredBrowserPoolOptions (line 62) | interface TieredBrowserPoolOptions {
  type BrowserLease (line 125) | interface BrowserLease {
  type TierStats (line 135) | interface TierStats {
  type PoolStatsSnapshot (line 143) | interface PoolStatsSnapshot {
  class TieredBrowserPool (line 150) | class TieredBrowserPool {
    method constructor (line 173) | constructor(options: TieredBrowserPoolOptions) {
    method acquire (line 234) | acquire(tier: PoolTier): BrowserLease {
    method hasTier (line 274) | hasTier(tier: PoolTier): boolean {
    method getBrowserByProxy (line 285) | getBrowserByProxy(proxyUrl: string | null): ProxyBoundBrowser | null {
    method getStats (line 296) | getStats(): PoolStatsSnapshot {
    method close (line 311) | async close(): Promise<void> {
    method createBrowser (line 326) | private createBrowser(proxyUrl: string | null, timezoneId?: string): P...
    method attachHealthListeners (line 352) | private attachHealthListeners(tracker: ProxyHealthTracker): void {
  function buildTierConfigsFromPools (line 390) | function buildTierConfigsFromPools(
  function proxyUrlKey (line 439) | function proxyUrlKey(proxyUrl: string | null | undefined): string {

FILE: src/browser/types.ts
  type BrowserInstance (line 6) | interface BrowserInstance {
  type QueueItem (line 29) | interface QueueItem {
  type PoolConfig (line 43) | interface PoolConfig {
  type PoolStats (line 72) | interface PoolStats {
  type HealthStatus (line 101) | interface HealthStatus {
  type IBrowserPool (line 115) | interface IBrowserPool {

FILE: src/client.ts
  type ProxyRotation (line 48) | type ProxyRotation = "round-robin" | "random";
  type ReaderClientOptions (line 53) | interface ReaderClientOptions {
  class ReaderClient (line 97) | class ReaderClient {
    method constructor (line 110) | constructor(options: ReaderClientOptions = {}) {
    method getNextProxy (line 128) | private getNextProxy(): ProxyConfig | undefined {
    method getProxyForTier (line 149) | getProxyForTier(tier: "datacenter" | "residential"): ProxyConfig | und...
    method resolveProxy (line 173) | private resolveProxy(proxyTier?: import("./types").ProxyTier): ProxyCo...
    method hasProxyTier (line 196) | hasProxyTier(tier: "datacenter" | "residential"): boolean {
    method start (line 207) | async start(): Promise<void> {
    method initializeCore (line 241) | private async initializeCore(): Promise<void> {
    method createConnection (line 334) | private createConnection(): ConnectionToHeroCore {
    method ensureInitialized (line 347) | private async ensureInitialized(): Promise<void> {
    method scrape (line 369) | async scrape(options: Omit<ScrapeOptions, "connectionToCore" | "pool">...
    method crawl (line 407) | async crawl(options: Omit<CrawlOptions, "connectionToCore" | "pool">):...
    method browser (line 451) | async browser(options: Omit<BrowserOptions, "connectionToCore"> = {}):...
    method isReady (line 483) | isReady(): boolean {
    method close (line 492) | async close(): Promise<void> {
    method registerCleanup (line 564) | private registerCleanup(): void {
    method removeCleanupHandlers (line 584) | private removeCleanupHandlers(): void {

FILE: src/cloudflare/detector.ts
  constant CLOUDFLARE_CHALLENGE_SELECTORS (line 10) | const CLOUDFLARE_CHALLENGE_SELECTORS = [
  constant CLOUDFLARE_TEXT_PATTERNS (line 26) | const CLOUDFLARE_TEXT_PATTERNS = [
  constant CLOUDFLARE_INFRA_PATTERNS (line 38) | const CLOUDFLARE_INFRA_PATTERNS = ["/cdn-cgi/", "cloudflare", "__cf_bm",...
  constant CLOUDFLARE_BLOCKED_PATTERNS (line 45) | const CLOUDFLARE_BLOCKED_PATTERNS = ["sorry, you have been blocked", "ra...
  function detectChallenge (line 60) | async function detectChallenge(hero: Hero): Promise<ChallengeDetection> {
  function isChallengePage (line 174) | async function isChallengePage(hero: Hero): Promise<boolean> {

FILE: src/cloudflare/handler.ts
  function waitForChallengeResolution (line 28) | async function waitForChallengeResolution(
  function waitForSelector (line 118) | async function waitForSelector(
  function handleChallenge (line 164) | async function handleChallenge(

FILE: src/cloudflare/types.ts
  type ChallengeDetection (line 4) | interface ChallengeDetection {
  type ChallengeResolutionResult (line 21) | interface ChallengeResolutionResult {
  type ChallengeWaitOptions (line 35) | interface ChallengeWaitOptions {

FILE: src/config/domain-profiles.ts
  type DomainProfile (line 17) | interface DomainProfile {
  function getDomainProfile (line 39) | function getDomainProfile(
  function applyDomainProfile (line 73) | function applyDomainProfile<T extends Partial<ScrapeOptions>>(

FILE: src/crawl-types.ts
  type CrawlOptions (line 7) | interface CrawlOptions {
  type CrawlUrl (line 109) | interface CrawlUrl {
  type CrawlResult (line 123) | interface CrawlResult {
  type CrawlMetadata (line 137) | interface CrawlMetadata {

FILE: src/crawler.ts
  class Crawler (line 24) | class Crawler {
    method constructor (line 32) | constructor(options: CrawlOptions) {
    method crawl (line 49) | async crawl(): Promise<CrawlResult> {
    method fetchPage (line 125) | private async fetchPage(url: string): Promise<{ crawlUrl: CrawlUrl; ht...
    method extractLinks (line 169) | private extractLinks(
    method scrapeDiscoveredUrls (line 241) | private async scrapeDiscoveredUrls(): Promise<ScrapeResult> {
  function crawl (line 267) | async function crawl(options: CrawlOptions): Promise<CrawlResult> {

FILE: src/daemon/client.ts
  type DaemonClientOptions (line 26) | interface DaemonClientOptions {
  class DaemonClient (line 38) | class DaemonClient {
    method constructor (line 41) | constructor(options: DaemonClientOptions = {}) {
    method scrape (line 52) | async scrape(options: Omit<ScrapeOptions, "connectionToCore">): Promis...
    method crawl (line 62) | async crawl(options: Omit<CrawlOptions, "connectionToCore">): Promise<...
    method status (line 72) | async status(): Promise<DaemonStatus> {
    method shutdown (line 81) | async shutdown(): Promise<void> {
    method browserCreate (line 90) | async browserCreate(
    method browserStop (line 102) | async browserStop(sessionId: string): Promise<void> {
    method browserList (line 112) | async browserList(): Promise<BrowserSessionInfo[]> {
    method isRunning (line 121) | async isRunning(): Promise<boolean> {
    method request (line 133) | private request<T>(body: object): Promise<T> {
  function isDaemonRunning (line 199) | async function isDaemonRunning(port: number = DEFAULT_DAEMON_PORT): Prom...

FILE: src/daemon/server.ts
  constant DEFAULT_DAEMON_PORT (line 38) | const DEFAULT_DAEMON_PORT = 6003;
  constant PID_FILE_NAME (line 39) | const PID_FILE_NAME = ".reader-daemon.pid";
  constant SHUTDOWN_TIMEOUT_MS (line 40) | const SHUTDOWN_TIMEOUT_MS = 30_000;
  type DaemonServerOptions (line 45) | interface DaemonServerOptions {
  type ScrapeRequest (line 61) | interface ScrapeRequest {
  type CrawlRequest (line 66) | interface CrawlRequest {
  type StatusRequest (line 71) | interface StatusRequest {
  type ShutdownRequest (line 75) | interface ShutdownRequest {
  type BrowserCreateRequest (line 79) | interface BrowserCreateRequest {
  type BrowserStopRequest (line 84) | interface BrowserStopRequest {
  type BrowserListRequest (line 89) | interface BrowserListRequest {
  type DaemonRequest (line 93) | type DaemonRequest =
  type SuccessResponse (line 105) | interface SuccessResponse<T> {
  type ErrorResponse (line 110) | interface ErrorResponse {
  type DaemonResponse (line 115) | type DaemonResponse<T> = SuccessResponse<T> | ErrorResponse;
  type DaemonStatus (line 120) | interface DaemonStatus {
  type BrowserSessionInfo (line 133) | interface BrowserSessionInfo {
  class DaemonServer (line 142) | class DaemonServer {
    method constructor (line 151) | constructor(options: DaemonServerOptions = {}) {
    method start (line 164) | async start(): Promise<void> {
    method stop (line 244) | async stop(): Promise<void> {
    method getPort (line 268) | getPort(): number {
    method checkAuth (line 276) | private checkAuth(req: http.IncomingMessage, res: http.ServerResponse)...
    method handleRequest (line 290) | private async handleRequest(req: http.IncomingMessage, res: http.Serve...
    method handleScrape (line 390) | private async handleScrape(
    method handleCrawl (line 406) | private async handleCrawl(
    method handleStatus (line 422) | private handleStatus(res: http.ServerResponse): void {
    method handleShutdown (line 438) | private async handleShutdown(res: http.ServerResponse): Promise<void> {
    method gracefulStop (line 450) | async gracefulStop(): Promise<void> {
    method handleBrowserCreate (line 491) | private async handleBrowserCreate(
    method handleBrowserStop (line 515) | private async handleBrowserStop(res: http.ServerResponse, sessionId: s...
    method handleBrowserList (line 530) | private handleBrowserList(res: http.ServerResponse): void {
    method sendResponse (line 542) | private sendResponse<T>(
    method writePidFile (line 554) | private async writePidFile(): Promise<void> {
    method removePidFile (line 572) | private async removePidFile(): Promise<void> {
  function getPidFilePath (line 589) | async function getPidFilePath(): Promise<string> {
  function getDaemonInfo (line 598) | async function getDaemonInfo(): Promise<{

FILE: src/engines/errors.ts
  class EngineError (line 13) | class EngineError extends Error {
    method constructor (line 17) | constructor(
  class InsufficientContentError (line 37) | class InsufficientContentError extends EngineError {
    method constructor (line 41) | constructor(engine: EngineName, contentLength: number, threshold: numb...
  class HttpError (line 54) | class HttpError extends EngineError {
    method constructor (line 57) | constructor(engine: EngineName, statusCode: number, statusText?: strin...
  class EngineTimeoutError (line 68) | class EngineTimeoutError extends EngineError {
    method constructor (line 71) | constructor(engine: EngineName, timeoutMs: number) {
  class EngineUnavailableError (line 81) | class EngineUnavailableError extends EngineError {
    method constructor (line 82) | constructor(engine: EngineName, reason?: string) {
  class ScrapeFailedError (line 94) | class ScrapeFailedError extends Error {
    method constructor (line 98) | constructor(error: Error, options?: { proxyBlock?: boolean }) {

FILE: src/engines/hero/index.ts
  constant MIN_CONTENT_LENGTH (line 32) | const MIN_CONTENT_LENGTH = 100;
  class HeroEngine (line 37) | class HeroEngine implements Engine {
    method scrape (line 40) | async scrape(meta: EngineMeta): Promise<EngineResult> {
    method extractText (line 176) | private extractText(html: string): string {
    method isAvailable (line 185) | isAvailable(): boolean {
  function resolveTierFromOptions (line 198) | function resolveTierFromOptions(proxyTier: string | undefined): PoolTier {

FILE: src/engines/orchestrator.ts
  type OrchestratorOptions (line 17) | interface OrchestratorOptions {
  type OrchestratorResult (line 27) | interface OrchestratorResult extends EngineResult {
  class EngineOrchestrator (line 42) | class EngineOrchestrator {
    method constructor (line 45) | constructor(options: OrchestratorOptions = {}) {
    method assessQuality (line 53) | private assessQuality(result: EngineResult): {
    method scrape (line 81) | async scrape(meta: EngineMeta): Promise<OrchestratorResult> {
  function createOrchestrator (line 131) | function createOrchestrator(options: OrchestratorOptions = {}): EngineOr...

FILE: src/engines/types.ts
  type EngineName (line 14) | type EngineName = "hero";
  type EngineResult (line 19) | interface EngineResult {
  type EngineMeta (line 40) | interface EngineMeta {
  type EngineConfig (line 54) | interface EngineConfig {
  type EngineFeatures (line 68) | interface EngineFeatures {
  type Engine (line 84) | interface Engine {
  constant ENGINE_CONFIG (line 102) | const ENGINE_CONFIG: EngineConfig = {

FILE: src/errors.ts
  type ReaderErrorCode (line 11) | enum ReaderErrorCode {
  class ReaderError (line 59) | class ReaderError extends Error {
    method constructor (line 66) | constructor(
    method toJSON (line 92) | toJSON(): Record<string, unknown> {
  class NetworkError (line 109) | class NetworkError extends ReaderError {
    method constructor (line 110) | constructor(message: string, options?: { url?: string; cause?: Error }) {
  class TimeoutError (line 122) | class TimeoutError extends ReaderError {
    method constructor (line 125) | constructor(message: string, timeoutMs: number, options?: { url?: stri...
    method toJSON (line 134) | toJSON(): Record<string, unknown> {
  class CloudflareError (line 145) | class CloudflareError extends ReaderError {
    method constructor (line 148) | constructor(challengeType: string, options?: { url?: string; cause?: E...
    method toJSON (line 161) | toJSON(): Record<string, unknown> {
  class AccessDeniedError (line 172) | class AccessDeniedError extends ReaderError {
    method constructor (line 175) | constructor(message: string, options?: { url?: string; statusCode?: nu...
    method toJSON (line 184) | toJSON(): Record<string, unknown> {
  class ContentExtractionError (line 195) | class ContentExtractionError extends ReaderError {
    method constructor (line 196) | constructor(message: string, options?: { url?: string; cause?: Error }) {
  class ValidationError (line 208) | class ValidationError extends ReaderError {
    method constructor (line 211) | constructor(message: string, options?: { field?: string; url?: string ...
    method toJSON (line 220) | toJSON(): Record<string, unknown> {
  class InvalidUrlError (line 231) | class InvalidUrlError extends ReaderError {
    method constructor (line 232) | constructor(url: string, reason?: string) {
  class RobotsBlockedError (line 248) | class RobotsBlockedError extends ReaderError {
    method constructor (line 249) | constructor(url: string) {
  class BrowserPoolError (line 265) | class BrowserPoolError extends ReaderError {
    method constructor (line 266) | constructor(message: string, options?: { cause?: Error }) {
  class ClientClosedError (line 278) | class ClientClosedError extends ReaderError {
    method constructor (line 279) | constructor() {
  class NotInitializedError (line 294) | class NotInitializedError extends ReaderError {
    method constructor (line 295) | constructor(component: string) {
  class DNSError (line 314) | class DNSError extends ReaderError {
    method constructor (line 317) | constructor(hostname: string, options?: { url?: string; cause?: Error ...
    method toJSON (line 326) | toJSON(): Record<string, unknown> {
  class TLSError (line 334) | class TLSError extends ReaderError {
    method constructor (line 335) | constructor(detail: string, options?: { url?: string; cause?: Error }) {
  class BotDetectedError (line 351) | class BotDetectedError extends ReaderError {
    method constructor (line 354) | constructor(signal: string, options?: { url?: string; cause?: Error }) {
    method toJSON (line 363) | toJSON(): Record<string, unknown> {
  class ProxyConnectionError (line 375) | class ProxyConnectionError extends ReaderError {
    method constructor (line 378) | constructor(proxyTier: string, options?: { url?: string; cause?: Error...
    method toJSON (line 387) | toJSON(): Record<string, unknown> {
  class ProxyExhaustedError (line 395) | class ProxyExhaustedError extends ReaderError {
    method constructor (line 396) | constructor(options?: { url?: string; cause?: Error }) {
  class ContentTooLargeError (line 416) | class ContentTooLargeError extends ReaderError {
    method constructor (line 420) | constructor(sizeBytes: number, limitBytes: number, options?: { url?: s...
    method toJSON (line 431) | toJSON(): Record<string, unknown> {
  class MarkdownConversionError (line 439) | class MarkdownConversionError extends ReaderError {
    method constructor (line 440) | constructor(detail: string, options?: { url?: string; cause?: Error }) {
  class EmptyContentError (line 452) | class EmptyContentError extends ReaderError {
    method constructor (line 455) | constructor(contentLength: number, options?: { url?: string }) {
    method toJSON (line 465) | toJSON(): Record<string, unknown> {
  function wrapError (line 484) | function wrapError(error: unknown, url?: string): ReaderError {

FILE: src/formatters/html.ts
  function formatToHTML (line 15) | function formatToHTML(html: string): string {

FILE: src/formatters/markdown.ts
  function htmlToMarkdown (line 20) | function htmlToMarkdown(html: string): string {
  function fallbackTextExtract (line 53) | function fallbackTextExtract(html: string): string {

FILE: src/formatters/postprocess.ts
  function postprocessMarkdown (line 11) | function postprocessMarkdown(md: string): string {
  function deduplicateImageLinks (line 37) | function deduplicateImageLinks(md: string): string {

FILE: src/proxy/config.ts
  function createProxyUrl (line 23) | function createProxyUrl(config: ProxyConfig): string {
  function parseProxyUrl (line 54) | function parseProxyUrl(url: string): ProxyConfig {

FILE: src/proxy/env.ts
  function parseList (line 30) | function parseList(raw: string | undefined, tierLabel: string): ProxyCon...
  type ParsedProxyPools (line 55) | interface ParsedProxyPools {
  function parseProxyPoolsFromEnv (line 66) | function parseProxyPoolsFromEnv(env: NodeJS.ProcessEnv = process.env): P...

FILE: src/proxy/health-tracker.ts
  constant DEFAULT_FAILURE_THRESHOLD (line 39) | const DEFAULT_FAILURE_THRESHOLD = 10;
  constant DEFAULT_COOLDOWN_MS (line 40) | const DEFAULT_COOLDOWN_MS = 5 * 60 * 1000;
  type ProxyHealthEvents (line 45) | interface ProxyHealthEvents {
  type ProxyHealthTrackerOptions (line 57) | interface ProxyHealthTrackerOptions {
  type ProxyState (line 72) | interface ProxyState {
  type ProxyHealthSnapshot (line 89) | interface ProxyHealthSnapshot {
  class ProxyHealthTracker (line 124) | class ProxyHealthTracker extends EventEmitter {
    method constructor (line 130) | constructor(options: ProxyHealthTrackerOptions = {}) {
    method on (line 150) | override on<E extends keyof ProxyHealthEvents>(event: E, listener: Pro...
    method once (line 153) | override once<E extends keyof ProxyHealthEvents>(event: E, listener: P...
    method emit (line 156) | override emit<E extends keyof ProxyHealthEvents>(
    method isHealthy (line 168) | isHealthy(proxyUrl: string): boolean {
    method recordSuccess (line 188) | recordSuccess(proxyUrl: string): void {
    method recordFailure (line 208) | recordFailure(proxyUrl: string): void {
    method snapshot (line 236) | snapshot(proxyUrl: string): ProxyHealthSnapshot | null {
    method allSnapshots (line 254) | allSnapshots(): ProxyHealthSnapshot[] {
    method reset (line 264) | reset(proxyUrl: string): void {
    method ensureState (line 268) | private ensureState(proxyUrl: string): ProxyState {

FILE: src/proxy/proxy-gate.ts
  type PerProxyGateOptions (line 30) | interface PerProxyGateOptions {
  type PerProxyRelease (line 45) | type PerProxyRelease = () => void;
  type PerProxyStats (line 50) | interface PerProxyStats {
  class PerProxyGate (line 74) | class PerProxyGate {
    method constructor (line 79) | constructor(options: PerProxyGateOptions = {}) {
    method setOverride (line 97) | setOverride(proxyUrl: string, max: number): void {
    method acquire (line 115) | async acquire(proxyUrl: string | null | undefined): Promise<PerProxyRe...
    method withSlot (line 152) | async withSlot<T>(proxyUrl: string | null | undefined, fn: () => Promi...
    method stats (line 165) | stats(proxyUrl: string): PerProxyStats | null {
    method allStats (line 179) | allStats(): PerProxyStats[] {
    method gateFor (line 191) | private gateFor(proxyUrl: string): { limit: ReturnType<typeof pLimit>;...
  function makeRelease (line 204) | function makeRelease(resolve: () => void): PerProxyRelease {
  function noopRelease (line 216) | function noopRelease(): PerProxyRelease {

FILE: src/proxy/verify.ts
  constant IP_CHECK_URL (line 25) | const IP_CHECK_URL = "https://api.ipify.org?format=json";
  constant IP_CHECK_TIMEOUT_MS (line 26) | const IP_CHECK_TIMEOUT_MS = 10_000;
  type ProxyTierName (line 28) | type ProxyTierName = "datacenter" | "residential";
  type VerifiedProxy (line 30) | interface VerifiedProxy {
  type ProxyVerificationFailure (line 36) | interface ProxyVerificationFailure {
  type ProxyVerificationResult (line 42) | interface ProxyVerificationResult {
  type EgressIpFetcher (line 52) | type EgressIpFetcher = (proxyUrl: string) => Promise<string>;
  type VerifyProxiesOptions (line 54) | interface VerifyProxiesOptions {
  function verifyProxies (line 67) | async function verifyProxies(
  function verifyProxiesOrThrow (line 105) | async function verifyProxiesOrThrow(
  function defaultFetcher (line 132) | async function defaultFetcher(proxyUrl: string): Promise<string> {

FILE: src/scraper.ts
  constant DEFAULT_HARD_DEADLINE_MS (line 34) | const DEFAULT_HARD_DEADLINE_MS = 30_000;
  constant DEFAULT_DATACENTER_TIMEOUT_MS (line 37) | const DEFAULT_DATACENTER_TIMEOUT_MS = 10_000;
  class Scraper (line 49) | class Scraper {
    method constructor (line 54) | constructor(options: ScrapeOptions) {
    method getRobotsRules (line 64) | private async getRobotsRules(url: string): Promise<RobotsRules | null> {
    method scrape (line 76) | async scrape(): Promise<ScrapeResult> {
    method scrapeWithConcurrency (line 85) | private async scrapeWithConcurrency(): Promise<
    method scrapeSingleUrlWithRetry (line 115) | private async scrapeSingleUrlWithRetry(
    method scrapeSingleUrl (line 200) | private async scrapeSingleUrl(
    method buildScrapeResult (line 485) | private buildScrapeResult(
  function detectJsonPayload (line 519) | function detectJsonPayload(body: string, statusCode: number): string | n...
  function scrape (line 544) | async function scrape(options: ScrapeOptions): Promise<ScrapeResult> {

FILE: src/types.ts
  type ProxyConfig (line 6) | interface ProxyConfig {
  type ProxyTier (line 32) | type ProxyTier = "datacenter" | "residential" | "auto";
  type ProxyPoolConfig (line 37) | interface ProxyPoolConfig {
  type ProxyMetadata (line 47) | interface ProxyMetadata {
  type BrowserPoolConfig (line 61) | interface BrowserPoolConfig {
  type ScrapeOptions (line 75) | interface ScrapeOptions {
  type WebsiteMetadata (line 269) | interface WebsiteMetadata {
  type Page (line 314) | interface Page {
  type WebsiteScrapeResult (line 337) | interface WebsiteScrapeResult {
  type BatchMetadata (line 378) | interface BatchMetadata {
  type ScrapeResult (line 401) | interface ScrapeResult {
  type CrawlerState (line 412) | interface CrawlerState {
  type ScraperConfig (line 426) | interface ScraperConfig {
  constant DEFAULT_OPTIONS (line 440) | const DEFAULT_OPTIONS: Omit<
  function isValidFormat (line 499) | function isValidFormat(format: string): format is "markdown" | "html" {
  function shouldCrawlUrl (line 506) | function shouldCrawlUrl(url: URL, baseDomain: string): boolean {

FILE: src/utils/block-detector.ts
  type BlockDetectionConfig (line 18) | interface BlockDetectionConfig {
  function toRegExp (line 30) | function toRegExp(p: RegExp | string): RegExp {
  function detectBotPage (line 39) | function detectBotPage(html: string, config?: BlockDetectionConfig): boo...
  function detectBotTitle (line 60) | function detectBotTitle(title: string, config?: BlockDetectionConfig): b...
  function isBlockedResponse (line 73) | function isBlockedResponse(
  function stripTags (line 97) | function stripTags(html: string): string {

FILE: src/utils/content-cleaner.ts
  type CleaningOptions (line 25) | interface CleaningOptions {
  constant ALWAYS_REMOVE_SELECTORS (line 43) | const ALWAYS_REMOVE_SELECTORS = ["script", "style", "noscript", "meta", ...
  constant NAVIGATION_SELECTORS (line 50) | const NAVIGATION_SELECTORS = [
  constant FORCE_INCLUDE_SELECTORS (line 125) | const FORCE_INCLUDE_SELECTORS = [
  function removeElements (line 144) | function removeElements(document: Document, selectors: string[]): void {
  function removeWithProtection (line 158) | function removeWithProtection(
  function cleanHtml (line 201) | function cleanHtml(html: string, baseUrl: string, options: CleaningOptio...
  function removeBase64ImagesFromDocument (line 272) | function removeBase64ImagesFromDocument(document: Document): void {
  function resolveSrcsets (line 302) | function resolveSrcsets(document: Document): void {
  function convertRelativeUrls (line 334) | function convertRelativeUrls(document: Document, baseUrl: string): void {
  function cleanContent (line 369) | function cleanContent(html: string, baseUrl: string, options: CleaningOp...

FILE: src/utils/logger.ts
  type Logger (line 6) | type Logger = ReturnType<typeof createLogger>;
  function hasPinoPretty (line 11) | function hasPinoPretty(): boolean {
  function createLogger (line 27) | function createLogger(

FILE: src/utils/metadata-extractor.ts
  function extractMetadata (line 9) | function extractMetadata(html: string, baseUrl: string): WebsiteMetadata {
  function extractWebsiteMetadata (line 16) | function extractWebsiteMetadata(html: string, baseUrl: string): WebsiteM...
  function extractTitle (line 65) | function extractTitle(document: Document): string | null {
  function extractMetaContent (line 80) | function extractMetaContent(document: Document, name: string): string | ...
  function extractLanguage (line 101) | function extractLanguage(document: Document): string | null {
  function extractCharset (line 109) | function extractCharset(document: Document): string | null {
  function extractFavicon (line 133) | function extractFavicon(document: Document, baseUrl: string): string | n...
  function extractCanonical (line 163) | function extractCanonical(document: Document, baseUrl: string): string |...
  function extractKeywords (line 178) | function extractKeywords(document: Document): string[] | null {
  function extractOpenGraph (line 193) | function extractOpenGraph(document: Document): WebsiteMetadata["openGrap...
  function extractTwitterCard (line 223) | function extractTwitterCard(document: Document): WebsiteMetadata["twitte...
  function extractStructuredData (line 251) | function extractStructuredData(html: string): unknown[] {
  function extractMicrodata (line 270) | function extractMicrodata(_html: string): unknown[] {
  function getMetadataSummary (line 280) | function getMetadataSummary(metadata: WebsiteMetadata): string {

FILE: src/utils/rate-limiter.ts
  function rateLimit (line 6) | async function rateLimit(ms: number): Promise<void> {
  class RateLimiter (line 13) | class RateLimiter {
    method constructor (line 16) | constructor(requestsPerSecond: number) {
    method execute (line 29) | async execute<T>(fn: () => Promise<T>): Promise<T> {
    method waitForNextSlot (line 39) | private async waitForNextSlot(): Promise<void> {
    method executeAll (line 55) | async executeAll<T>(functions: Array<() => Promise<T>>): Promise<T[]> {

FILE: src/utils/robots-parser.ts
  type RobotsRules (line 5) | interface RobotsRules {
  function parseRobotsTxt (line 14) | function parseRobotsTxt(content: string, userAgent: string = "*"): Robot...
  function isPathAllowed (line 63) | function isPathAllowed(path: string, rules: RobotsRules): boolean {
  function pathMatches (line 89) | function pathMatches(path: string, pattern: string): boolean {
  function fetchRobotsTxt (line 119) | async function fetchRobotsTxt(baseUrl: string): Promise<RobotsRules | nu...
  function isUrlAllowed (line 144) | function isUrlAllowed(url: string, rules: RobotsRules | null): boolean {

FILE: src/utils/url-helpers.ts
  function resolveUrl (line 11) | function resolveUrl(relative: string, base: string): string {
  function isValidUrl (line 22) | function isValidUrl(string: string): boolean {
  function normalizeUrl (line 34) | function normalizeUrl(url: string, baseUrl?: string): string {
  function extractBaseDomain (line 58) | function extractBaseDomain(url: string): string {
  function isSameDomain (line 74) | function isSameDomain(url: string, baseUrl: string): boolean {
  function getUrlKey (line 96) | function getUrlKey(url: string): string {
  function validateUrls (line 143) | function validateUrls(urls: string[]): {
  function matchesPatterns (line 206) | function matchesPatterns(url: string, patterns: string[]): boolean {
  function shouldIncludeUrl (line 227) | function shouldIncludeUrl(
  function isContentUrl (line 253) | function isContentUrl(url: string): boolean {
  function shouldCrawlUrl (line 293) | function shouldCrawlUrl(

FILE: src/utils/url-rewriter.ts
  type UrlRewriteRule (line 16) | interface UrlRewriteRule {
  type RewriteResult (line 28) | interface RewriteResult {
  function rewriteUrl (line 42) | function rewriteUrl(inputUrl: string, rules?: UrlRewriteRule[]): Rewrite...

FILE: tests/engines/orchestrator.test.ts
  function createMeta (line 7) | function createMeta(url = "https://example.com") {

FILE: tests/integration/daemon.test.ts
  function request (line 16) | function request(

FILE: tests/unit/block-detector-cloudflare.test.ts
  constant FIXTURES_DIR (line 6) | const FIXTURES_DIR = join(__dirname, "..", "fixtures");
  function loadFixture (line 8) | function loadFixture(name: string): string {
  constant CF_CONFIG (line 12) | const CF_CONFIG: BlockDetectionConfig = {

FILE: tests/unit/block-detector-fixtures.test.ts
  constant FIXTURES_DIR (line 6) | const FIXTURES_DIR = join(__dirname, "..", "fixtures");
  function loadFixture (line 8) | function loadFixture(name: string): string {
  constant AMAZON_CONFIG (line 12) | const AMAZON_CONFIG: BlockDetectionConfig = {

FILE: tests/unit/block-detector.test.ts
  constant TEST_CONFIG (line 5) | const TEST_CONFIG: BlockDetectionConfig = {

FILE: tests/unit/crawler.test.ts
  function mockPool (line 28) | function mockPool(): IBrowserPool {
  function createTestCrawler (line 41) | function createTestCrawler(options: {
  function makeHtml (line 70) | function makeHtml(links: string[], title = "Test Page"): string {
  function pageResult (line 76) | function pageResult(url: string, html: string, title = "Test Page") {

FILE: tests/unit/daemon-dispatch.test.ts
  function mockReq (line 17) | function mockReq(
  type CapturedResponse (line 44) | interface CapturedResponse {
  function mockRes (line 51) | function mockRes(): { res: http.ServerResponse; captured: () => Captured...

FILE: tests/unit/domain-profiles.test.ts
  constant TEST_PROFILES (line 5) | const TEST_PROFILES = {

FILE: tests/unit/health-tracker.test.ts
  function fakeClock (line 7) | function fakeClock(start = 1_000_000_000_000) {

FILE: tests/unit/html-size-guard.test.ts
  constant DEFAULT_MAX (line 10) | const DEFAULT_MAX = 307200;
  function applyGuard (line 12) | function applyGuard(html: string, maxBytes: number = DEFAULT_MAX): { tru...

FILE: tests/unit/proxy-bound-browser.test.ts
  type FakeTab (line 19) | interface FakeTab extends TabLike {
  function makeFakeTab (line 23) | function makeFakeTab(): FakeTab {
  type FakeHero (line 41) | interface FakeHero extends HeroLike {
  function makeFakeFactory (line 47) | function makeFakeFactory(opts: {
  function tick (line 94) | async function tick(n = 1) {

FILE: tests/unit/proxy-gate.test.ts
  function defer (line 8) | function defer<T = void>() {
  function tick (line 18) | async function tick(n = 1) {

FILE: tests/unit/proxy-verify.test.ts
  function makeFakeFetcher (line 10) | function makeFakeFetcher(

FILE: tests/unit/scraper-pipeline.test.ts
  function makeScraper (line 15) | function makeScraper(options?: Record<string, unknown>): Scraper {
  function mockPipeline (line 28) | function mockPipeline(scraper: Scraper, html: string, url = "https://exa...

FILE: tests/unit/scraper-retry.test.ts
  function makeResult (line 21) | function makeResult(overrides?: Partial<WebsiteScrapeResult>): WebsiteSc...
  function makeScraper (line 38) | function makeScraper(overrides?: Record<string, unknown>): Scraper {
  function spySingleUrl (line 42) | function spySingleUrl(scraper: Scraper) {

FILE: tests/unit/tiered-pool.test.ts
  type FakeHero (line 12) | interface FakeHero extends HeroLike {
  function makeFakeTab (line 17) | function makeFakeTab(): TabLike {
  function makeFakeFactory (line 29) | function makeFakeFactory(opts: { failFor?: Set<string> } = {}): {
  function tick (line 56) | async function tick(n = 1) {

FILE: tests/unit/url-rewriter.test.ts
  function extractGoogleDocId (line 5) | function extractGoogleDocId(pathname: string): string | null {
  constant GOOGLE_RULES (line 10) | const GOOGLE_RULES: UrlRewriteRule[] = [