@ddwang/magnitude-core 0.3.1-ddwang.2 → 0.3.1-ddwang.21

package/dist/web/recovery.test.js

@@ -1,182 +0,0 @@
-import { expect, test } from 'bun:test';
-import { BrowserBlockedError, BrowserRecovery, detectBlock, diagnosticUrl, retryAt } from './recovery';
-const click = { variant: 'mouse:click', x: 10, y: 10 };
-test('retry headers support seconds and HTTP dates, without persisting query credentials', () => {
-    expect(retryAt('30', 1000)).toBe(31_000);
-    expect(retryAt('Tue, 15 Sep 2026 00:00:00 GMT', 0)).toBe(Date.parse('2026-09-15T00:00:00Z'));
-    expect(retryAt('invalid', 0)).toBeUndefined();
-    expect(retryAt('-1', 0)).toBeUndefined();
-    expect(diagnosticUrl('https://user:password@example.com/search?q=secret&token=secret#private')).toBe('https://example.com/search');
-});
-test('classifies explicit barriers, not a bare 403 or ordinary Subscribe button', () => {
-    expect(detectBlock([], { status: 429, timestamp: 0, url: 'https://example.com', retryAt: 5000 })).toMatchObject({ reason: 'rate_limit', retryAt: 5000 });
-    expect(detectBlock(['Too many requests'])).toMatchObject({ reason: 'rate_limit' });
-    expect(detectBlock(['Subscribe to BBC to continue'])).toMatchObject({ reason: 'subscription' });
-    expect(detectBlock(['Sign in to continue'])).toMatchObject({ reason: 'authentication' });
-    expect(detectBlock(['Subscribe'], { status: 403, timestamp: 0, url: 'https://example.com' })).toBeUndefined();
-    expect(detectBlock(['Normal page'], { status: 429, timestamp: 0, url: 'https://example.com/analytics', navigation: false })).toBeUndefined();
-});
-test('respects server cooldown, then blocks rather than shortening an unaffordable wait', () => {
-    const recovery = new BrowserRecovery({ maxRateLimitWaitMs: 100, noProgress: true });
-    recovery.observe('limited', click, { reason: 'rate_limit', evidence: '429', retryAt: 60 }, 0);
-    expect(recovery.waitDuration(10, 0)).toBe(60);
-    recovery.observe('limited', click, { reason: 'rate_limit', evidence: '429', retryAt: 120 }, 60);
-    expect(() => recovery.waitDuration(0, 60)).toThrow(BrowserBlockedError);
-});
-test('unavailable retry headers get one stable cooldown, not a fresh delay on every observation', () => {
-    const recovery = new BrowserRecovery({ noProgress: true });
-    recovery.observe('limited', undefined, { reason: 'rate_limit', evidence: 'Too many requests' }, 0);
-    recovery.observe('limited', { variant: 'wait' }, { reason: 'rate_limit', evidence: 'Too many requests' }, 60_000);
-    expect(recovery.block?.retryAt).toBe(60_000);
-    expect(recovery.waitDuration(0, 60_000)).toBe(0);
-});
-test('repeated outcomes warn before stopping, even if click coordinates vary', () => {
-    const recovery = new BrowserRecovery({ noProgress: true });
-    for (let i = 0; i < 3; i++)
-        recovery.observe('same-query-and-page', { ...click, x: i }, undefined);
-    expect(recovery.warning).toContain('different approach');
-    expect(() => recovery.check()).not.toThrow();
-    for (let i = 0; i < 3; i++)
-        recovery.observe('same-query-and-page', click, undefined);
-    expect(() => recovery.check()).toThrow(BrowserBlockedError);
-});
-test('no-progress termination is opt-in for library consumers', () => {
-    const recovery = new BrowserRecovery();
-    for (let i = 0; i < 100; i++)
-        recovery.observe('unchanged', click, undefined);
-    expect(recovery.warning).toBeUndefined();
-    expect(() => recovery.check()).not.toThrow();
-});
-test('new page states and deliberate waits do not count as repeated outcomes', () => {
-    const recovery = new BrowserRecovery({ noProgress: true });
-    for (let i = 0; i < 20; i++)
-        recovery.observe(`page-${i}`, click, undefined);
-    for (let i = 0; i < 20; i++)
-        recovery.observe('same', { variant: 'wait' }, undefined);
-    expect(recovery.warning).toBeUndefined();
-    expect(() => recovery.check()).not.toThrow();
-});
-test('subscription barrier allows a few recovery actions, then produces a distinct block', () => {
-    const recovery = new BrowserRecovery({ noProgress: true });
-    const block = { reason: 'subscription', evidence: 'Subscribe to continue' };
-    recovery.observe('paywall', undefined, block);
-    for (let i = 0; i < 3; i++) {
-        recovery.check();
-        recovery.observe('paywall', click, block);
-    }
-    expect(() => recovery.check()).toThrow(BrowserBlockedError);
-    recovery.observe('accessible', undefined, undefined);
-    expect(() => recovery.check()).not.toThrow();
-});
-test('a new task resets previous repetition and wait budgets', () => {
-    const recovery = new BrowserRecovery({ maxRateLimitWaitMs: 100, noProgress: true });
-    for (let i = 0; i < 6; i++)
-        recovery.observe('same', click, undefined);
-    recovery.reset();
-    expect(() => recovery.check()).not.toThrow();
-    recovery.observe('limited', undefined, { reason: 'rate_limit', evidence: '429', retryAt: 100 }, 0);
-    expect(recovery.waitDuration(0, 0)).toBe(100);
-    recovery.reset();
-    recovery.observe('limited', undefined, { reason: 'rate_limit', evidence: '429', retryAt: 200 }, 100);
-    expect(recovery.waitDuration(0, 100)).toBe(100);
-});
-test('new content after a wait clears the old loop warning', () => {
-    const recovery = new BrowserRecovery({ noProgress: true });
-    for (let i = 0; i < 6; i++)
-        recovery.observe('old', click, undefined);
-    recovery.observe('newly-loaded-results', { variant: 'wait' }, undefined);
-    expect(recovery.warning).toBeUndefined();
-    expect(() => recovery.check()).not.toThrow();
-});
-test('changing sign-in steps are not mistaken for an unchanged barrier', () => {
-    const recovery = new BrowserRecovery({ noProgress: true });
-    for (let i = 0; i < 6; i++) {
-        recovery.observe(`step-${i}`, click, { reason: 'authentication', evidence: 'Sign in to continue' });
-        expect(() => recovery.check()).not.toThrow();
-    }
-});
-test('productive graph walks can revisit hubs and shared return paths without warnings', () => {
-    for (const depth of [1, 2, 4])
-        for (const breadth of [7, 13, 40]) {
-            const recovery = new BrowserRecovery({ noProgress: true });
-            recovery.observe('hub', undefined, undefined);
-            for (let leaf = 0; leaf < breadth; leaf++) {
-                const path = [`record-${leaf}`, ...Array.from({ length: depth }, (_, i) => `return-${i}`), 'hub'];
-                for (const state of path) {
-                    expect(() => recovery.check()).not.toThrow();
-                    recovery.observe(state, click, undefined);
-                    expect(recovery.warning).toBeUndefined();
-                }
-            }
-            expect(() => recovery.check()).not.toThrow();
-        }
-});
-test('cycles through known states still warn and stop within the unchanged history window', () => {
-    for (const length of [2, 3, 5]) {
-        const recovery = new BrowserRecovery({ noProgress: true });
-        recovery.observe('state-0', undefined, undefined);
-        let warned = false;
-        for (let step = 1; step <= length * recovery.repeatedActionLimit; step++) {
-            recovery.observe(`state-${step % length}`, { ...click, x: step }, undefined);
-            warned ||= Boolean(recovery.warning);
-        }
-        expect(warned).toBe(true);
-        expect(() => recovery.check()).toThrow(BrowserBlockedError);
-    }
-});
-test('different incoming transitions to a known hub are not one repeated outcome', () => {
-    const recovery = new BrowserRecovery({ noProgress: true });
-    for (let i = 0; i < 9; i++)
-        recovery.observe(`known-${i}`, undefined, undefined);
-    recovery.observe('hub', undefined, undefined);
-    for (let i = 0; i < 9; i++) {
-        recovery.observe(`known-${i}`, click, undefined);
-        recovery.observe('hub', click, undefined);
-        expect(recovery.warning).toBeUndefined();
-        expect(() => recovery.check()).not.toThrow();
-    }
-});
-test('new evidence clears old repetition history even when returning to a familiar page', () => {
-    const recovery = new BrowserRecovery({ noProgress: true });
-    recovery.observe('hub', undefined, undefined);
-    for (let i = 0; i < 5; i++)
-        recovery.observe('hub', click, undefined);
-    recovery.observe('new-evidence', click, undefined);
-    recovery.observe('hub', click, undefined);
-    expect(recovery.warning).toBeUndefined();
-    for (let i = 0; i < 5; i++) {
-        expect(() => recovery.check()).not.toThrow();
-        recovery.observe('hub', click, undefined);
-    }
-    expect(() => recovery.check()).not.toThrow();
-    recovery.observe('hub', click, undefined);
-    expect(() => recovery.check()).toThrow(BrowserBlockedError);
-});
-test('passive observations neither add failures nor erase an unchanged-page stop', () => {
-    for (const action of [undefined, { variant: 'wait' }, { variant: 'mouse:hover' }]) {
-        const recovery = new BrowserRecovery({ noProgress: true });
-        for (let i = 0; i < 6; i++)
-            recovery.observe('same', click, undefined);
-        for (let i = 0; i < 40; i++)
-            recovery.observe('same', action, undefined);
-        expect(() => recovery.check()).toThrow(BrowserBlockedError);
-        recovery.observe('fresh-evidence', action, undefined);
-        recovery.observe('same', click, undefined);
-        expect(recovery.warning).toBeUndefined();
-        expect(() => recovery.check()).not.toThrow();
-    }
-});
-test('a task reset clears both known states and transition counts', () => {
-    const recovery = new BrowserRecovery({ noProgress: true });
-    for (let i = 0; i < 6; i++) {
-        recovery.observe('a', click, undefined);
-        recovery.observe('b', click, undefined);
-    }
-    expect(() => recovery.check()).toThrow(BrowserBlockedError);
-    recovery.reset();
-    recovery.observe('a', undefined, undefined);
-    recovery.observe('b', click, undefined);
-    recovery.observe('a', click, undefined);
-    expect(recovery.warning).toBeUndefined();
-    expect(() => recovery.check()).not.toThrow();
-});

package/dist/web/stability.d.ts

@@ -1,57 +0,0 @@
-import { Page } from 'playwright';
-export interface ImageDiff {
-    /** Difference score between 0-1, where 0 means identical */
-    difference: number;
-    /** Optional error message if comparison failed */
-    error?: string;
-}
-export interface PageStabilityOptions {
-    /** Threshold below which screenshots are considered similar (0-1) */
-    differenceThreshold?: number;
-    /** Number of consecutive stable checks required to confirm stability */
-    requiredStableChecks?: number;
-    /** Interval between stability checks in ms */
-    checkInterval?: number;
-    /** Whether to log detailed stability information */
-    /** Minimum time to wait before getting page state */
-    minimumWaitPageLoadTime?: number;
-    /** Time to wait for network requests to finish before getting page state */
-    waitForNetworkIdleTime?: number;
-    /** Maximum time to wait for page load before proceeding anyway */
-    maximumWaitPageLoadTime?: number;
-    /** Whether to disable visual stability checking */
-    disableVisualStability?: boolean;
-}
-/**
- * Utility class to check for visual stability of a page
- */
-export declare class PageStabilityAnalyzer {
-    private page;
-    private options;
-    private lastStart;
-    private logger;
-    constructor(options?: PageStabilityOptions);
-    setActivePage(page: Page): void;
-    private log;
-    /**
-     * Compare two screenshots and return their difference score
-     * @returns Difference as float between 0-1, where 0 means identical
-     */
-    private compareScreenshots;
-    /**
-     * Wait for the network to become stable
-     * This monitors network requests and waits until there's a period of inactivity
-     * @param timeout Maximum time to wait for network stability
-     */
-    waitForNetworkStability(timeout?: number): Promise<void>;
-    /**
-     * Wait for the page to become visually stable
-     * @param timeout Maximum time to wait for stability in ms
-     */
-    waitForVisualStability(timeout?: number): Promise<void>;
-    /**
-     * Wait for both network and visual stability
-     * @param timeout Maximum time to wait for page load
-     */
-    waitForStability(timeout?: number): Promise<void>;
-}

package/dist/web/stability.js

@@ -1,323 +0,0 @@
-import sharp from 'sharp';
-import logger from '@/logger';
-import { checkOperation, operationSleep } from '@/common/operation';
-// Maximum wait time for page stability in ms
-const DEFAULT_PAGE_STABILITY_TIMEOUT = 5000;
-// Default minimum wait time for page load
-const DEFAULT_MINIMUM_WAIT_PAGE_LOAD_TIME = 500;
-// Default time to wait for network requests to finish
-const DEFAULT_WAIT_FOR_NETWORK_IDLE_TIME = 500;
-// Default maximum time to wait for page load
-const DEFAULT_MAXIMUM_WAIT_PAGE_LOAD_TIME = 5000;
-/**
- * Utility class to check for visual stability of a page
- */
-export class PageStabilityAnalyzer {
-    page;
-    options;
-    lastStart;
-    logger;
-    constructor(options = {}) {
-        //this.page = page;
-        this.options = {
-            differenceThreshold: options.differenceThreshold ?? 0.01,
-            requiredStableChecks: options.requiredStableChecks ?? 3,
-            checkInterval: options.checkInterval ?? 100, // 200ms
-            minimumWaitPageLoadTime: options.minimumWaitPageLoadTime ?? DEFAULT_MINIMUM_WAIT_PAGE_LOAD_TIME,
-            waitForNetworkIdleTime: options.waitForNetworkIdleTime ?? DEFAULT_WAIT_FOR_NETWORK_IDLE_TIME,
-            maximumWaitPageLoadTime: options.maximumWaitPageLoadTime ?? DEFAULT_MAXIMUM_WAIT_PAGE_LOAD_TIME,
-            disableVisualStability: options.disableVisualStability ?? false
-        };
-        this.lastStart = Date.now();
-        this.logger = logger.child({ name: 'magnus.stability' });
-    }
-    setActivePage(page) {
-        this.page = page;
-    }
-    log(message) {
-        this.logger.trace(`[${Date.now() - this.lastStart}ms] ${message}`);
-    }
-    /**
-     * Compare two screenshots and return their difference score
-     * @returns Difference as float between 0-1, where 0 means identical
-     */
-    async compareScreenshots(screenshot1, screenshot2) {
-        try {
-            // Convert screenshots to raw pixel data using Sharp
-            const img1 = await sharp(screenshot1).raw().toBuffer({ resolveWithObject: true });
-            const img2 = await sharp(screenshot2).raw().toBuffer({ resolveWithObject: true });
-            // Check for size mismatch
-            if (img1.info.width !== img2.info.width || img1.info.height !== img2.info.height) {
-                return {
-                    difference: 1.0,
-                    error: "Image sizes don't match"
-                };
-            }
-            // Calculate pixel differences
-            let diffSum = 0;
-            for (let i = 0; i < img1.data.length; i++) {
-                diffSum += Math.abs(img1.data[i] - img2.data[i]);
-            }
-            // Calculate mean difference and normalize
-            const mse = diffSum / img1.data.length;
-            // Normalize to 0-1 range (assuming 8-bit color depth)
-            const maxDiff = 255.0 * (img1.info.channels || 3); // Multiply by number of channels
-            const normalizedDiff = mse / maxDiff;
-            return { difference: normalizedDiff };
-        }
-        catch (e) {
-            return {
-                difference: 1.0,
-                error: `Comparison failed: ${e instanceof Error ? e.message : String(e)}`
-            };
-        }
-    }
-    /**
-     * Wait for the network to become stable
-     * This monitors network requests and waits until there's a period of inactivity
-     * @param timeout Maximum time to wait for network stability
-     */
-    async waitForNetworkStability(timeout) {
-        checkOperation();
-        const maxWaitTime = timeout ?? this.options.maximumWaitPageLoadTime;
-        const start = Date.now();
-        this.log("Checking network stability");
-        const pendingRequests = new Set();
-        let lastActivity = Date.now();
-        // Define relevant resource types and content types
-        const RELEVANT_RESOURCE_TYPES = new Set([
-            'document',
-            'stylesheet',
-            'image',
-            'font',
-            'script',
-            'fetch',
-            'xhr',
-            'iframe'
-        ]);
-        const RELEVANT_CONTENT_TYPES = [
-            'text/html',
-            'text/css',
-            'application/javascript',
-            'image/',
-            'font/',
-            'application/json'
-        ];
-        // Additional patterns to filter out
-        const IGNORED_URL_PATTERNS = [
-            // Analytics and tracking
-            'analytics',
-            'tracking',
-            'telemetry',
-            'beacon',
-            'metrics',
-            // Ad-related
-            'doubleclick',
-            'adsystem',
-            'adserver',
-            'advertising',
-            // Social media widgets
-            'facebook.com/plugins',
-            'platform.twitter',
-            'linkedin.com/embed',
-            // Live chat and support
-            'livechat',
-            'zendesk',
-            'intercom',
-            'crisp.chat',
-            'hotjar',
-            // Push notifications
-            'push-notifications',
-            'onesignal',
-            'pushwoosh',
-            // Background sync/heartbeat
-            'heartbeat',
-            'ping',
-            'alive',
-            // WebRTC and streaming
-            'webrtc',
-            'rtmp://',
-            'wss://',
-            // Common CDNs for dynamic content
-            'cloudfront.net',
-            'fastly.net'
-        ];
-        // Setup request handler
-        const onRequest = (request) => {
-            // Filter by resource type
-            if (!RELEVANT_RESOURCE_TYPES.has(request.resourceType())) {
-                return;
-            }
-            // Filter out streaming, websocket, and other real-time requests
-            if (['websocket', 'media', 'eventsource', 'manifest', 'other'].includes(request.resourceType())) {
-                return;
-            }
-            // Filter out by URL patterns
-            const url = request.url().toLowerCase();
-            if (IGNORED_URL_PATTERNS.some(pattern => url.includes(pattern))) {
-                return;
-            }
-            // Filter out data URLs and blob URLs
-            if (url.startsWith('data:') || url.startsWith('blob:')) {
-                return;
-            }
-            pendingRequests.add(request);
-            lastActivity = Date.now();
-            this.log(`Request started: ${request.url()}`);
-        };
-        // Setup response handler
-        const onResponse = (response) => {
-            const request = response.request();
-            if (!pendingRequests.has(request)) {
-                return;
-            }
-            // Filter by content type if available
-            const contentType = response.headers()['content-type'] || '';
-            // Skip if content type indicates streaming or real-time data
-            if (['streaming', 'video', 'audio', 'webm', 'mp4', 'event-stream', 'websocket', 'protobuf']
-                .some(t => contentType.includes(t))) {
-                pendingRequests.delete(request);
-                return;
-            }
-            // Only process relevant content types
-            if (!RELEVANT_CONTENT_TYPES.some(ct => contentType.includes(ct))) {
-                pendingRequests.delete(request);
-                return;
-            }
-            // Skip if response is too large (likely not essential for page load)
-            const contentLength = parseInt(response.headers()['content-length'] || '0', 10);
-            if (contentLength > 5 * 1024 * 1024) { // 5MB
-                pendingRequests.delete(request);
-                return;
-            }
-            pendingRequests.delete(request);
-            lastActivity = Date.now();
-            this.log(`Request resolved: ${request.url()}`);
-        };
-        // Add event listeners
-        this.page.on('request', onRequest);
-        this.page.on('response', onResponse);
-        try {
-            // Wait for idle time
-            const startTime = Date.now();
-            while (true) {
-                await operationSleep(100);
-                const now = Date.now();
-                if (pendingRequests.size === 0 &&
-                    (now - lastActivity) >= this.options.waitForNetworkIdleTime) {
-                    break;
-                }
-                if (now - startTime > maxWaitTime) {
-                    this.log(`Network timeout after ${maxWaitTime}ms with ${pendingRequests.size} pending requests`);
-                    break;
-                }
-            }
-        }
-        finally {
-            // Clean up event listeners
-            this.page.removeListener('request', onRequest);
-            this.page.removeListener('response', onResponse);
-        }
-        const totalTime = (Date.now() - start) / 1000;
-        this.log(`Network stabilized in ${totalTime.toFixed(2)}s`);
-    }
-    /**
-     * Wait for the page to become visually stable
-     * @param timeout Maximum time to wait for stability in ms
-     */
-    async waitForVisualStability(timeout = DEFAULT_PAGE_STABILITY_TIMEOUT) {
-        checkOperation();
-        const start = Date.now();
-        this.log("Checking visual stability");
-        try {
-            let lastScreenshot = await this.page.screenshot();
-            let stabilityCount = 0;
-            const deadline = start + timeout;
-            while (Date.now() < deadline) {
-                this.log(`Waiting for ${this.options.checkInterval}`);
-                await operationSleep(this.options.checkInterval);
-                this.log(`Done waiting`);
-                try {
-                    this.log("Taking screenshot...");
-                    const currentScreenshot = await this.page.screenshot();
-                    this.log("Comparing screenshots...");
-                    const diffResult = await this.compareScreenshots(lastScreenshot, currentScreenshot);
-                    if (diffResult.error) {
-                        this.log(`Comparison error: ${diffResult.error}`);
-                        stabilityCount = 0;
-                    }
-                    else {
-                        this.log(`Screenshot difference: ${diffResult.difference.toFixed(4)}`);
-                        if (diffResult.difference < this.options.differenceThreshold) {
-                            stabilityCount++;
-                            if (stabilityCount >= this.options.requiredStableChecks) {
-                                this.log(`Visual stability achieved (difference: ${diffResult.difference.toFixed(4)})`);
-                                return;
-                            }
-                        }
-                        else {
-                            stabilityCount = 0;
-                        }
-                    }
-                    lastScreenshot = currentScreenshot;
-                }
-                catch (e) {
-                    checkOperation();
-                    this.log(`Screenshot/comparison error: ${e instanceof Error ? e.message : String(e)}`);
-                    stabilityCount = 0;
-                }
-            }
-            // If we exit the loop without returning, we timed out
-            this.log("Visual stability check timed out");
-        }
-        catch (e) {
-            checkOperation();
-            this.log(`Visual stability check error: ${e instanceof Error ? e.message : String(e)}`);
-        }
-        finally {
-            const totalTime = (Date.now() - start) / 1000;
-            this.log(`Visual stability check took ${totalTime.toFixed(2)}s`);
-        }
-    }
-    /**
-     * Wait for both network and visual stability
-     * @param timeout Maximum time to wait for page load
-     */
-    async waitForStability(timeout) {
-        checkOperation();
-        const maxWaitTime = timeout ?? this.options.maximumWaitPageLoadTime;
-        const startTime = Date.now();
-        this.lastStart = startTime;
-        // Track our deadlines
-        const minWaitDeadline = startTime + this.options.minimumWaitPageLoadTime;
-        const maxWaitDeadline = startTime + maxWaitTime;
-        this.log(`Starting stability wait (min: ${this.options.minimumWaitPageLoadTime}ms, max: ${maxWaitTime}ms)`);
-        try {
-            // Wait for network stability, but don't exceed max wait time
-            const remainingForNetwork = Math.max(0, maxWaitDeadline - Date.now());
-            if (remainingForNetwork > 0) {
-                await this.waitForNetworkStability(remainingForNetwork);
-            }
-            // Wait for visual stability with whatever time remains, but don't exceed max wait time
-            if (!this.options.disableVisualStability) {
-                const remainingForVisual = Math.max(0, maxWaitDeadline - Date.now());
-                if (remainingForVisual > 0) {
-                    await this.waitForVisualStability(remainingForVisual);
-                }
-            }
-            // Ensure we've waited at least the minimum time
-            const now = Date.now();
-            if (now < minWaitDeadline) {
-                const remainingMinWait = minWaitDeadline - now;
-                this.log(`Waiting additional ${remainingMinWait}ms to meet minimum wait time`);
-                await operationSleep(remainingMinWait);
-            }
-            const totalTime = Date.now() - startTime;
-            this.log(`Page stability wait completed in ${totalTime}ms`);
-        }
-        catch (e) {
-            checkOperation();
-            this.log(`Error during stability wait: ${e instanceof Error ? e.message : String(e)}`);
-        }
-    }
-}

package/dist/web/tabs.d.ts

@@ -1,58 +0,0 @@
-import EventEmitter from "eventemitter3";
-import { BrowserContext, Page } from "playwright";
-export interface TabEvents {
-    'tabChanged': (page: Page) => void;
-}
-export interface TabState {
-    activeTab: number;
-    tabs: {
-        title: string;
-        url: string;
-    }[];
-}
-export interface TabManagerOptions {
-    switchOnActivity?: boolean;
-}
-export declare class TabManager {
-    private context;
-    private activePage;
-    private options;
-    private pollInterval?;
-    readonly events: EventEmitter<TabEvents>;
-    constructor(context: BrowserContext, options?: TabManagerOptions);
-    initialize(): Promise<void>;
-    private initializeExistingPages;
-    private onPageCreated;
-    private setupPageTracking;
-    private startActivityPolling;
-    setActivePage(page: Page): void;
-    switchTab(index: number): Promise<void>;
-    getActivePage(): Page;
-    getPages(): Page[];
-    retrieveState(): Promise<TabState>;
-    debugVisibilityStates(): Promise<({
-        hasFocus: boolean;
-        hidden: boolean;
-        visibilityState: DocumentVisibilityState;
-        index: number;
-        url: string;
-        error?: undefined;
-    } | {
-        index: number;
-        url: string;
-        error: boolean;
-    })[]>;
-    debugFocusStates(): Promise<({
-        hasFocus: boolean;
-        isVisible: boolean;
-        isHidden: boolean;
-        url: string;
-        index: number;
-        error?: undefined;
-    } | {
-        index: number;
-        url: string;
-        error: boolean;
-    })[]>;
-    destroy(): void;
-}