extension 3.12.0 → 3.12.1

package/dist/browser/index.d.ts

@@ -0,0 +1,74 @@
+import type { BrowserType } from './browsers-types';
+export type { BrowserType, CompilationLike, Controller } from './browsers-types';
+/**
+ * Options for launching a browser with an extension loaded.
+ */
+export interface BrowserLaunchOptions {
+    browser: BrowserType;
+    outputPath: string;
+    contextDir: string;
+    extensionsToLoad: string[];
+    mode?: 'development' | 'production';
+    enableDevtools?: boolean;
+    noOpen?: boolean;
+    profile?: string | false;
+    persistProfile?: boolean;
+    preferences?: Record<string, unknown>;
+    browserFlags?: string[];
+    excludeBrowserFlags?: string[];
+    startingUrl?: string;
+    chromiumBinary?: string;
+    geckoBinary?: string;
+    instanceId?: string;
+    port?: number | string;
+    dryRun?: boolean;
+    source?: string;
+    watchSource?: boolean;
+    sourceFormat?: 'pretty' | 'json' | 'ndjson';
+    sourceSummary?: boolean;
+    sourceMeta?: boolean;
+    sourceProbe?: string[];
+    sourceTree?: 'off' | 'root-only';
+    sourceConsole?: boolean;
+    sourceDom?: boolean;
+    sourceMaxBytes?: number;
+    sourceRedact?: 'off' | 'safe' | 'strict';
+    sourceIncludeShadow?: 'off' | 'open-only' | 'all';
+    sourceDiff?: boolean;
+    logLevel?: string;
+    logContexts?: string[];
+    logFormat?: 'pretty' | 'json' | 'ndjson';
+    logTimestamps?: boolean;
+    logColor?: boolean;
+    logUrl?: string;
+    logTab?: number | string;
+}
+/**
+ * Handle returned by `launchBrowser` — provides reload and logging control.
+ */
+export interface BrowserController {
+    reload(instruction?: {
+        type: 'full' | 'service-worker' | 'content-scripts';
+        changedContentScriptEntries?: string[];
+        changedAssets?: string[];
+    }): Promise<void>;
+    enableUnifiedLogging(opts: {
+        level?: string;
+        contexts?: string[];
+        format?: 'pretty' | 'json' | 'ndjson';
+        timestamps?: boolean;
+        color?: boolean;
+        urlFilter?: string;
+        tabFilter?: number | string;
+    }): Promise<void>;
+    close(): Promise<void>;
+}
+/**
+ * Launch a browser with the given extension(s) loaded.
+ *
+ * Returns a `BrowserController` that provides reload and unified-logging control.
+ * This is the primary entry point for the CLI orchestration layer — it replaces
+ * the old BrowsersPlugin that lived inside the bundler.
+ */
+export declare function launchBrowser(opts: BrowserLaunchOptions): Promise<BrowserController>;
+export { runOnlyPreviewBrowser } from './run-only';

package/dist/browser/run-chromium/chromium-context/index.d.ts

@@ -0,0 +1,20 @@
+import type { CDPExtensionController } from '../chromium-source-inspection/cdp-extension-controller';
+export type ChromiumContext = {
+    getController(): CDPExtensionController | undefined;
+    onControllerReady(cb: (c: CDPExtensionController, port: number) => void): void;
+    setController(c: CDPExtensionController, port: number): void;
+    getPorts(): {
+        cdpPort?: number;
+    };
+    getExtensionRoot(): string | undefined;
+    setExtensionRoot(root?: string): void;
+    setServiceWorkerPaths(rel?: string, abs?: string): void;
+    getServiceWorkerPaths(): {
+        relativePath?: string;
+        absolutePath?: string;
+    };
+    setPendingReloadReason(reason?: 'manifest' | 'locales' | 'sw'): void;
+    getPendingReloadReason(): 'manifest' | 'locales' | 'sw' | undefined;
+    clearPendingReloadReason(): void;
+};
+export declare function createChromiumContext(): ChromiumContext;

package/dist/browser/run-chromium/chromium-launch/browser-config.d.ts

@@ -0,0 +1,4 @@
+import { type CompilationLike } from '../../browsers-types';
+import { type PluginInterface, type DefaultBrowserFlags } from '../../browsers-types';
+export declare const DEFAULT_BROWSER_FLAGS: DefaultBrowserFlags[];
+export declare function browserConfig(compilation: CompilationLike, configOptions: PluginInterface): string[];

package/dist/browser/run-chromium/chromium-launch/dry-run.d.ts

@@ -0,0 +1 @@
+export declare function logChromiumDryRun(browserBinaryLocation: string, chromiumConfig: string[]): void;

package/dist/browser/run-chromium/chromium-launch/extension-output-path.d.ts

@@ -0,0 +1,8 @@
+import type { CompilationLike } from '../../browsers-types';
+/**
+ * Derive the user extension output path from `--load-extension=...` flags.
+ *
+ * Kept in a standalone module so run-only preview can reuse it without
+ * importing CDP/WS-related code paths.
+ */
+export declare function getExtensionOutputPath(compilation: CompilationLike | undefined, loadExtensionFlag: string | undefined): string;

package/dist/browser/run-chromium/chromium-launch/index.d.ts

@@ -0,0 +1,31 @@
+import type { CompilationLike } from '../../browsers-types';
+import type { ChromiumContext } from '../chromium-context';
+import type { ChromiumLaunchOptions } from '../chromium-types';
+/**
+ * ChromiumLaunchPlugin
+ *
+ * Intended responsibilities (will be wired incrementally without changing inner logic):
+ * - Resolve binary; compose flags (profiles, excludes, overrides)
+ * - Allocate CDP port; spawn process; setup signals; dry-run
+ * - Connect CDP; ensure extension loaded; print dev banner
+ * - Publish controller + port via ChromiumContext
+ */
+export declare class ChromiumLaunchPlugin {
+    private readonly options;
+    private readonly ctx;
+    private didLaunch;
+    private didReportReady;
+    private logger;
+    constructor(options: ChromiumLaunchOptions, ctx: ChromiumContext);
+    /**
+     * Run the Chromium launch flow without requiring a bundler compiler instance.
+     * Intended for run-only preview paths.
+     */
+    runOnce(compilation: CompilationLike, opts?: {
+        enableCdpPostLaunch?: boolean;
+    }): Promise<void>;
+    apply(compiler: any): void;
+    private launchChromium;
+    private launchWithDirectSpawn;
+    private printEnhancedPuppeteerInstallHint;
+}

package/dist/browser/run-chromium/chromium-launch/master-preferences.d.ts

@@ -0,0 +1,163 @@
+declare const chromeMasterPreferences: {
+    alternate_error_pages: {
+        enabled: boolean;
+    };
+    autofill: {
+        enabled: boolean;
+    };
+    browser: {
+        check_default_browser: boolean;
+        default_browser_setting_enabled: boolean;
+    };
+    default_apps: string;
+    distribution: {
+        alternate_shortcut_text: boolean;
+        auto_launch_chrome: boolean;
+        import_bookmarks: boolean;
+        import_history: boolean;
+        import_home_page: boolean;
+        import_search_engine: boolean;
+        suppress_first_run_bubble: boolean;
+        do_not_register_for_update_launch: boolean;
+        make_chrome_default: boolean;
+        make_chrome_default_for_user: boolean;
+        require_eula: boolean;
+        suppress_first_run_default_browser_prompt: boolean;
+    };
+    dns_prefetching: {
+        enabled: boolean;
+    };
+    download: {
+        default_directory: string;
+        directory_upgrade: boolean;
+        open_pdf_in_adobe_reader: boolean;
+        prompt_for_download: boolean;
+    };
+    enable_do_not_track: boolean;
+    extensions: {
+        theme: {
+            use_system: boolean;
+        };
+        toolbarsize: number;
+        developer_mode: boolean;
+        ui: {
+            developer_mode: boolean;
+        };
+    };
+    plugins: {
+        plugins_list: {
+            enabled: boolean;
+            name: string;
+        }[];
+        show_details: boolean;
+    };
+    profile: {
+        password_manager_enabled: boolean;
+    };
+    safebrowsing: {
+        enabled: boolean;
+        safebrowsingextended_reporting_enabled: boolean;
+    };
+    savefile: {
+        default_directory: string;
+        type: number;
+    };
+    search: {
+        suggest_enabled: boolean;
+    };
+    session: {
+        restore_on_startup: number;
+    };
+    sync: {
+        suppress_start: boolean;
+    };
+    sync_promo: {
+        show_on_first_run_allowed: boolean;
+        show_ntp_bubble: boolean;
+    };
+    translate: {
+        enabled: boolean;
+    };
+};
+declare const edgeMasterPreferences: {
+    alternate_error_pages: {
+        enabled: boolean;
+    };
+    autofill: {
+        enabled: boolean;
+    };
+    browser: {
+        check_default_browser: boolean;
+        default_browser_setting_enabled: boolean;
+    };
+    default_apps: string;
+    distribution: {
+        alternate_shortcut_text: boolean;
+        auto_launch_chrome: boolean;
+        import_bookmarks: boolean;
+        import_history: boolean;
+        import_home_page: boolean;
+        import_search_engine: boolean;
+        suppress_first_run_bubble: boolean;
+        do_not_register_for_update_launch: boolean;
+        make_chrome_default: boolean;
+        make_chrome_default_for_user: boolean;
+        require_eula: boolean;
+        suppress_first_run_default_browser_prompt: boolean;
+    };
+    dns_prefetching: {
+        enabled: boolean;
+    };
+    download: {
+        default_directory: string;
+        directory_upgrade: boolean;
+        open_pdf_in_adobe_reader: boolean;
+        prompt_for_download: boolean;
+    };
+    enable_do_not_track: boolean;
+    extensions: {
+        theme: {
+            use_system: boolean;
+        };
+        toolbarsize: number;
+        developer_mode: boolean;
+        ui: {
+            developer_mode: boolean;
+        };
+    };
+    plugins: {
+        plugins_list: {
+            enabled: boolean;
+            name: string;
+        }[];
+        show_details: boolean;
+    };
+    profile: {
+        password_manager_enabled: boolean;
+    };
+    safebrowsing: {
+        enabled: boolean;
+        safebrowsingextended_reporting_enabled: boolean;
+    };
+    savefile: {
+        default_directory: string;
+        type: number;
+    };
+    search: {
+        suggest_enabled: boolean;
+    };
+    session: {
+        restore_on_startup: number;
+    };
+    sync: {
+        suppress_start: boolean;
+    };
+    sync_promo: {
+        show_on_first_run_allowed: boolean;
+        show_ntp_bubble: boolean;
+    };
+    translate: {
+        enabled: boolean;
+    };
+};
+export { chromeMasterPreferences, edgeMasterPreferences };

package/dist/browser/run-chromium/chromium-launch/process-handlers.d.ts

@@ -0,0 +1,3 @@
+import { ChildProcess } from 'child_process';
+import type { BrowserType } from '../../browsers-types';
+export declare function setupProcessSignalHandlers(browser: BrowserType, child: ChildProcess, cleanupInstance: () => void): void;

package/dist/browser/run-chromium/chromium-launch/setup-cdp-after-launch.d.ts

@@ -0,0 +1,3 @@
+import type { CompilationLike } from '../../browsers-types';
+import { type ChromiumPluginRuntime } from '../chromium-types';
+export declare function setupCdpAfterLaunch(compilation: CompilationLike | undefined, plugin: ChromiumPluginRuntime, chromiumArgs: string[]): Promise<void>;

package/dist/browser/run-chromium/chromium-launch/wsl-support.d.ts

@@ -0,0 +1,15 @@
+import { ChildProcess } from 'child_process';
+type ChromiumLogger = {
+    warn?: (...args: unknown[]) => void;
+};
+export declare function isWslEnv(): boolean;
+export declare function normalizeBinaryPathForWsl(input: string): string;
+export declare function resolveWslWindowsBinary(browser: string): string | null;
+export declare function spawnChromiumProcess(opts: {
+    binary: string;
+    launchArgs: string[];
+    stdio: 'ignore';
+    browser: string;
+    logger?: ChromiumLogger;
+}): Promise<ChildProcess>;
+export {};

package/dist/browser/run-chromium/chromium-source-inspection/cdp-client.d.ts

@@ -0,0 +1,57 @@
+import { type ExtensionRootMetaPayload } from './page';
+export declare class CDPClient {
+    private port;
+    private host;
+    private ws;
+    private targetWebSocketUrl;
+    private eventCallbacks;
+    private messageId;
+    private pendingRequests;
+    constructor(port?: number, host?: string);
+    private isDev;
+    connect(): Promise<void>;
+    disconnect(): void;
+    isConnected(): boolean;
+    onProtocolEvent(handler: (message: Record<string, unknown>) => void): () => void;
+    private handleMessage;
+    sendCommand(method: string, params?: Record<string, unknown>, sessionId?: string, timeoutMs?: number): Promise<unknown>;
+    getTargets(): Promise<Record<string, unknown>[]>;
+    getBrowserVersion(): Promise<{
+        product?: string;
+        userAgent?: string;
+        jsVersion?: string;
+    }>;
+    attachToTarget(targetId: string): Promise<string>;
+    enableAutoAttach(): Promise<void>;
+    enableRuntimeAndLog(sessionId?: string): Promise<void>;
+    navigate(sessionId: string, url: string): Promise<void>;
+    createTarget(url: string): Promise<string>;
+    activateTarget(targetId: string): Promise<void>;
+    waitForLoadEvent(sessionId: string): Promise<void>;
+    waitForContentScriptInjection(sessionId: string): Promise<boolean>;
+    /** Extension root / reinject markers — uses page + isolated content-script context (matches injection wait). */
+    getExtensionRootMeta(sessionId: string): Promise<ExtensionRootMetaPayload | undefined>;
+    /** Shadow <style> nodes under non-devtools content roots — same dual-context evaluation as root meta. */
+    getShadowStyleSnapshot(sessionId: string): Promise<Record<string, unknown> | undefined>;
+    /** Best-effort poll when injection wait fails (async shadow fill, context quirks). */
+    pollForVisibleShadowHostContent(sessionId: string, deadlineMs?: number): Promise<void>;
+    hasVisibleShadowHostContent(sessionId: string): Promise<boolean>;
+    evaluate(sessionId: string, expression: string, options?: {
+        awaitPromise?: boolean;
+    }): Promise<unknown>;
+    evaluateInContext(sessionId: string, expression: string, contextId: number, options?: {
+        awaitPromise?: boolean;
+    }): Promise<unknown>;
+    getPageHTML(sessionId: string, includeShadow?: 'off' | 'open-only' | 'all'): Promise<string>;
+    closeTarget(targetId: string): Promise<void>;
+    forceReloadExtension(extensionId: string): Promise<boolean>;
+    getExtensionInfo(extensionId: string): Promise<{
+        extensionInfo?: {
+            name?: string;
+            version?: string;
+        };
+    }>;
+    private reloadExtensionViaTargetEval;
+    loadUnpackedExtension(path: string): Promise<string>;
+    unloadExtension(extensionId: string): Promise<boolean>;
+}

package/dist/browser/run-chromium/chromium-source-inspection/cdp-extension-controller/connect.d.ts

@@ -0,0 +1,2 @@
+import { CDPClient } from '../cdp-client';
+export declare function connectToChromeCdp(cdpPort: number): Promise<CDPClient>;

package/dist/browser/run-chromium/chromium-source-inspection/cdp-extension-controller/derive-id.d.ts

@@ -0,0 +1,2 @@
+import { CDPClient } from '../cdp-client';
+export declare function deriveExtensionIdFromTargetsHelper(cdp: CDPClient, outPath: string, maxRetries?: number, backoffMs?: number, profilePath?: string, extensionPaths?: string[]): Promise<string | null>;

package/dist/browser/run-chromium/chromium-source-inspection/cdp-extension-controller/ensure.d.ts

@@ -0,0 +1,6 @@
+import { CDPClient } from '../cdp-client';
+export declare function loadUnpackedIfNeeded(cdp: CDPClient, outPath: string): Promise<string | null>;
+export declare function readManifestInfo(outPath: string): {
+    name?: string;
+    version?: string;
+} | null;

package/dist/browser/run-chromium/chromium-source-inspection/cdp-extension-controller/index.d.ts

@@ -0,0 +1,58 @@
+import { type ContentScriptTargetRule } from '../../../browsers-lib/content-script-targets';
+interface ExtensionInfoResult {
+    extensionId: string;
+    name?: string;
+    version?: string;
+}
+export type ChromiumDeveloperModeStatus = 'enabled' | 'disabled' | 'unknown';
+export declare class CDPExtensionController {
+    private readonly outPath;
+    private readonly browser;
+    private readonly cdpPort;
+    private readonly profilePath?;
+    private readonly extensionPaths?;
+    private cdp;
+    private extensionId;
+    private lastRuntimeReinjectionReport;
+    constructor(args: {
+        outPath: string;
+        browser: 'chrome' | 'edge' | 'chromium-based';
+        cdpPort: number;
+        profilePath?: string;
+        extensionPaths?: string[];
+    });
+    connect(): Promise<void>;
+    ensureLoaded(): Promise<ExtensionInfoResult>;
+    private deriveExtensionIdFromTargets;
+    private normalizePath;
+    private extensionIdBelongsToOutPath;
+    getDeveloperModeStatus(): ChromiumDeveloperModeStatus;
+    getLastRuntimeReinjectionReport(): Record<string, unknown> | null;
+    reloadMatchingTabsForContentScripts(rules: ContentScriptTargetRule[], options?: {
+        preferPageReload?: boolean;
+        allowCoarseCleanup?: boolean;
+        sourceOverridesByBundleId?: Record<string, string>;
+    }): Promise<number>;
+    reinjectMatchingTabsViaExtensionRuntime(rules: ContentScriptTargetRule[]): Promise<number>;
+    private reloadPageTarget;
+    hardReload(): Promise<boolean>;
+    private attachToExtensionRuntimeTarget;
+    private connectFreshClient;
+    private reconnectForReload;
+    onProtocolEvent(cb: (evt: {
+        method: string;
+        params?: unknown;
+    } & Record<string, unknown>) => void): void;
+    clearProtocolEventHandler(): void;
+    enableUnifiedLogging(): Promise<void>;
+    enableRuntimeForSession(sessionId: string): Promise<void>;
+    private enableLogging;
+    getInfoBestEffort(): Promise<ExtensionInfoResult | null>;
+    private reinjectContentScriptRule;
+    private buildReinjectExpression;
+    private patchReinjectSourceForInvalidatedRuntime;
+    private resolveExecutionContextId;
+    private getTopFrameId;
+    private collectExecutionContexts;
+}
+export {};

package/dist/browser/run-chromium/chromium-source-inspection/cdp-extension-controller/logging.d.ts

@@ -0,0 +1,7 @@
+import type { Controller } from '../../chromium-types';
+import { CDPClient } from '../cdp-client';
+export declare function enableUnifiedLoggingForAllTargets(controller: Controller): Promise<void>;
+export declare function enableRuntimeForAttachedTarget(controller: {
+    enableRuntimeForSession: (sessionId: string) => Promise<void>;
+}, sessionId: string): Promise<void>;
+export declare function registerAutoEnableLogging(cdp: CDPClient, getExtensionId: () => string | null): void;

package/dist/browser/run-chromium/chromium-source-inspection/discovery.d.ts

@@ -0,0 +1,2 @@
+export declare function discoverWebSocketDebuggerUrl(host: string, port: number, isDev: boolean): Promise<string>;
+export declare function checkChromeRemoteDebugging(port?: number): Promise<boolean>;

package/dist/browser/run-chromium/chromium-source-inspection/extensions.d.ts

@@ -0,0 +1,9 @@
+import { CDPClient } from './cdp-client';
+export declare function getExtensionInfo(cdp: CDPClient, extensionId: string): Promise<{
+    extensionInfo?: {
+        name?: string;
+        version?: string;
+    };
+}>;
+export declare function loadUnpackedExtension(cdp: CDPClient, absPath: string): Promise<string>;
+export declare function unloadExtension(cdp: CDPClient, extensionId: string): Promise<boolean>;

package/dist/browser/run-chromium/chromium-source-inspection/page.d.ts

@@ -0,0 +1,45 @@
+import type { CDPClient } from './cdp-client';
+/** Serialized snapshot of extension content roots / reinject markers (same shape as ChromiumSourceInspectionPlugin root meta). */
+export type ExtensionRootMetaPayload = {
+    rootCount: number;
+    markerCount: number;
+    latestGeneration: number;
+    roots: Array<{
+        tag: string;
+        id?: string;
+        key?: string;
+        generation?: number;
+        status?: string;
+        build?: string;
+    }>;
+    markers: Array<{
+        tag: string;
+        id?: string;
+        key?: string;
+        generation?: number;
+        status?: string;
+        build?: string;
+    }>;
+    registries: Array<{
+        key: string;
+        generation?: number;
+        hasCleanup?: boolean;
+        build?: string;
+    }>;
+    page?: {
+        key?: string;
+        generation?: number;
+        status?: string;
+        build?: string;
+    };
+};
+export declare function evaluateWithContentContext<T = unknown>(cdp: CDPClient, sessionId: string, expression: string, shouldAccept: (value: unknown) => boolean): Promise<T | undefined>;
+export declare function evaluateExtensionRootMeta(cdp: CDPClient, sessionId: string): Promise<ExtensionRootMetaPayload | undefined>;
+export declare function evaluateShadowStyleSnapshot(cdp: CDPClient, sessionId: string): Promise<Record<string, unknown> | undefined>;
+/** Used after navigation when injection wait timed out — polls with isolated-world fallback. */
+export declare function pollForVisibleShadowHostContent(cdp: CDPClient, sessionId: string, deadlineMs?: number): Promise<void>;
+/** Single-shot check aligned with waitForContentScriptInjection shadow proof. */
+export declare function hasVisibleShadowHostContent(cdp: CDPClient, sessionId: string): Promise<boolean>;
+export declare function getPageHTML(cdp: CDPClient, sessionId: string, includeShadow?: 'off' | 'open-only' | 'all'): Promise<string>;
+export declare function waitForLoadEvent(cdp: CDPClient, sessionId: string): Promise<void>;
+export declare function waitForContentScriptInjection(cdp: CDPClient, sessionId: string): Promise<boolean>;

package/dist/browser/run-chromium/chromium-source-inspection/ws.d.ts

@@ -0,0 +1,2 @@
+import WebSocket from 'ws';
+export declare function establishBrowserConnection(url: string, isDev: boolean, onMessage: (data: string) => void, onRejectPending: (reason: string) => void): Promise<WebSocket>;

package/dist/browser/run-chromium/chromium-types.d.ts

@@ -0,0 +1,65 @@
+import type { BrowserLogger, LogLevel, PluginInterface, Controller } from '../browsers-types';
+export type { Controller, LogFormat, LogLevel, PluginInterface } from '../browsers-types';
+export interface ConsoleAPICalledEvent {
+    method: 'Runtime.consoleAPICalled';
+    params?: {
+        type?: string;
+        args?: Array<{
+            value?: unknown;
+            description?: string;
+        }>;
+        stackTrace?: {
+            callFrames?: Array<{
+                url?: string;
+                lineNumber?: number;
+                columnNumber?: number;
+            }>;
+        };
+    };
+}
+export interface LogEntryAddedEvent {
+    method: 'Log.entryAdded';
+    params?: {
+        entry?: {
+            level?: string;
+            text?: string;
+            url?: string;
+            lineNumber?: number;
+            columnNumber?: number;
+        };
+    };
+}
+export type CdpEvent = ConsoleAPICalledEvent | LogEntryAddedEvent | {
+    method: string;
+    params?: unknown;
+};
+export type PendingReason = 'manifest' | 'locales' | 'sw';
+export type Logger = BrowserLogger;
+/**
+ * Options consumed by Chromium plugins (launch/logger/reload/inspection).
+ * Narrowed from PluginInterface and specialized for Chromium path.
+ */
+export interface ChromiumLaunchOptions extends Pick<PluginInterface, 'extension' | 'browser' | 'noOpen' | 'browserFlags' | 'excludeBrowserFlags' | 'profile' | 'preferences' | 'startingUrl' | 'chromiumBinary' | 'instanceId' | 'port' | 'source' | 'watchSource' | 'sourceFormat' | 'sourceSummary' | 'sourceMeta' | 'sourceProbe' | 'sourceTree' | 'sourceConsole' | 'sourceDom' | 'sourceMaxBytes' | 'sourceRedact' | 'sourceIncludeShadow' | 'sourceDiff' | 'dryRun' | 'logLevel' | 'logContexts' | 'logFormat' | 'logTimestamps' | 'logColor' | 'logUrl' | 'logTab'> {
+}
+/**
+ * Runtime state in Chromium flow.
+ * Kept Chromium-specific to avoid polluting shared browser types.
+ */
+export interface ChromiumPluginRuntime extends ChromiumLaunchOptions {
+    bannerPrintedOnce?: boolean;
+    cdpController?: Controller;
+    browserVersionLine?: string;
+}
+/**
+ * Configuration for the unified logger in Chromium flows.
+ * Mirrors CLI flags and shared logging options.
+ */
+export interface ChromiumLogger {
+    level?: LogLevel | 'off' | string;
+    contexts?: string[];
+    urlFilter?: string;
+    tabFilter?: number | string;
+    format?: 'pretty' | 'json' | 'ndjson' | string;
+    timestamps?: boolean;
+    color?: boolean;
+}

package/dist/browser/run-chromium/manifest-readiness.d.ts

@@ -0,0 +1,15 @@
+export declare function waitForStableManifest(outPath: string, options?: {
+    timeoutMs?: number;
+    pollIntervalMs?: number;
+    stableReadsRequired?: number;
+}): Promise<boolean>;
+export declare function waitForStableFiles(outPath: string, relativeFiles: string[], options?: {
+    timeoutMs?: number;
+    pollIntervalMs?: number;
+    stableReadsRequired?: number;
+}): Promise<boolean>;
+export declare function waitForStableExtensionOutput(outPath: string, options?: {
+    timeoutMs?: number;
+    pollIntervalMs?: number;
+    stableReadsRequired?: number;
+}): Promise<boolean>;

package/dist/browser/run-firefox/firefox-context/index.d.ts

@@ -0,0 +1,24 @@
+import type { BrowserLogger } from '../../browsers-types';
+import type { FirefoxRDPController } from '../firefox-source-inspection/rdp-extension-controller';
+export type PendingReason = 'manifest' | 'locales' | 'sw';
+export type FirefoxContext = {
+    getController(): FirefoxRDPController | undefined;
+    onControllerReady(cb: (c: FirefoxRDPController, port: number) => void): void;
+    setController(c: FirefoxRDPController, port: number): void;
+    getPorts(): {
+        rdpPort?: number;
+    };
+    setExtensionRoot(root?: string): void;
+    getExtensionRoot(): string | undefined;
+    setServiceWorkerPaths(rel?: string, abs?: string): void;
+    getServiceWorkerPaths(): {
+        relativePath?: string;
+        absolutePath?: string;
+    };
+    setPendingReloadReason(reason?: PendingReason): void;
+    getPendingReloadReason(): PendingReason | undefined;
+    clearPendingReloadReason(): void;
+    logger?: BrowserLogger;
+    didLaunch?: boolean;
+};
+export declare function createFirefoxContext(): FirefoxContext;

package/dist/browser/run-firefox/firefox-launch/binary-detector.d.ts

@@ -0,0 +1,10 @@
+export declare class FirefoxBinaryDetector {
+    static generateFirefoxArgs(binaryPath: string, profilePath: string, debugPort: number, additionalArgs?: string[]): {
+        binary: string;
+        args: string[];
+    };
+    static validateFirefoxBinary(binaryPath: string): Promise<{
+        version: string;
+        path: string;
+    }>;
+}