extension 3.12.0 → 3.12.2

package/dist/extension/browsers/browsers-types.d.ts

@@ -0,0 +1,270 @@
+export type BrowserType = 'chrome' | 'edge' | 'firefox' | 'chromium' | 'chromium-based' | 'gecko-based' | 'firefox-based';
+/**
+ * Lightweight stand-in for rspack's Compilation used by browser-launching code.
+ * Only the properties actually read by launch/reload/inspection flows are declared.
+ */
+export interface CompilationLike {
+    options: {
+        mode?: string;
+        output?: {
+            path?: string;
+        };
+        context?: string;
+    };
+    outputOptions?: {
+        path?: string;
+    };
+    getAsset?: (name: string) => {
+        source: {
+            source: () => string;
+        };
+    } | undefined;
+}
+/**
+ * Minimal logger interface mirroring the shape returned by
+ * rspack's `compiler.getInfrastructureLogger()`.
+ */
+export interface BrowserLogger {
+    info: (...args: unknown[]) => void;
+    warn: (...args: unknown[]) => void;
+    error: (...args: unknown[]) => void;
+    debug: (...args: unknown[]) => void;
+}
+/**
+ * Stand-in for rspack's BrowserConfig — the subset used by browser-config helpers.
+ */
+export interface BrowserConfig {
+    extensionPath: string;
+    profilePath: string | false;
+    preferences: Record<string, unknown>;
+    browserFlags: string[];
+    startingUrl: string | undefined;
+}
+/**
+ * List of default browser flags used by extension.js.
+ * These can be excluded using the `excludeBrowserFlags` option.
+ *
+ * Each flag disables or modifies a specific browser feature for a more controlled development environment.
+ */
+export type DefaultBrowserFlags = '--no-first-run' | '--disable-client-side-phishing-detection' | '--disable-component-extensions-with-background-pages' | '--disable-default-apps' | '--disable-features=InterestFeedContentSuggestions' | '--disable-features=Translate' | '--hide-scrollbars' | '--mute-audio' | '--no-default-browser-check' | '--ash-no-nudges' | '--disable-search-engine-choice-screen' | '--disable-features=MediaRoute' | '--use-mock-keychain' | '--disable-background-networking' | '--disable-breakpad' | '--disable-component-update' | '--disable-domain-reliability' | '--disable-features=AutofillServerCommunicatio' | '--disable-features=CertificateTransparencyComponentUpdate' | '--disable-sync' | '--disable-features=OptimizationHints' | '--disable-features=DialMediaRouteProvider' | '--no-pings' | '--enable-features=SidePanelUpdates';
+/**
+ * Options for the browser plugin.
+ */
+export interface PluginOptions {
+    /**
+     * Do not open the browser automatically after launch.
+     * @default false
+     */
+    noOpen?: boolean;
+    /**
+     * Additional browser flags to pass to the browser process.
+     * Example: ['--disable-extensions', '--disable-gpu']
+     */
+    browserFlags?: string[];
+    /**
+     * Array of browser flags to exclude from the default set.
+     * Example: ['--hide-scrollbars', '--mute-audio']
+     */
+    excludeBrowserFlags?: Array<DefaultBrowserFlags | string>;
+    /**
+     * Path to the browser profile directory, or false for a temporary profile.
+     * Example: 'dist/extension' or false
+     */
+    profile?: string | false;
+    /**
+     * Use a persistent managed profile for development.
+     * Defaults to false (ephemeral temp profiles are used).
+     */
+    persistProfile?: boolean;
+    /**
+     * Browser preferences object.
+     * Example: { extensions: ['dist/extension', 'dist/extension2'] }
+     */
+    preferences?: Record<string, unknown>;
+    /**
+     * Firefox only: persist changes made to the profile directory.
+     */
+    keepProfileChanges?: boolean;
+    /**
+     * Firefox only: copy an existing profile before launching.
+     */
+    copyFromProfile?: string;
+    /**
+     * URL to open when the browser starts.
+     * Example: 'http://localhost:3000'
+     */
+    startingUrl?: string;
+    /**
+     * Enable the browser console.
+     * @default false
+     */
+    browserConsole?: boolean;
+    /**
+     * Open DevTools automatically.
+     * @default false
+     */
+    devtools?: boolean;
+    /**
+     * Path to the Chromium binary.
+     * Example: '/path/to/chromium'
+     */
+    chromiumBinary?: string;
+    /**
+     * Path to the Gecko (Firefox) binary.
+     * Example: '/path/to/gecko'
+     */
+    geckoBinary?: string;
+}
+/**
+ * Main interface for the browser plugin.
+ */
+export interface PluginInterface extends PluginOptions {
+    /**
+     * Browser type to launch.
+     * @default 'chrome'
+     * @see DevOptions['browser']
+     * Example: 'chrome' | 'edge' | 'firefox'
+     */
+    browser: BrowserType;
+    /**
+     * Path(s) to the extension(s) to load.
+     * Example: 'dist/extension' or ['dist/extension', 'dist/extension2']
+     */
+    extension: string | string[];
+    /**
+     * Port to use for the extension or debugging.
+     * Example: 12345 or '12345'
+     */
+    port?: string | number;
+    /**
+     * Internal auto-generated instance ID (not user-configurable).
+     * Example: '1234567890'
+     */
+    instanceId?: string;
+    /**
+     * Path to source files for inspection.
+     * Example: 'dist/extension'
+     */
+    source?: string;
+    /**
+     * Whether to watch the source directory for changes.
+     * @default false
+     */
+    watchSource?: boolean;
+    /**
+     * Output format for source inspection HTML.
+     */
+    sourceFormat?: 'pretty' | 'json' | 'ndjson';
+    /**
+     * Output a compact summary instead of full HTML.
+     * @default false
+     */
+    sourceSummary?: boolean;
+    /**
+     * Output page metadata (readyState, viewport, frames).
+     */
+    sourceMeta?: boolean;
+    /**
+     * CSS selectors to probe for debugging.
+     */
+    sourceProbe?: string[];
+    /**
+     * Output a compact extension root tree.
+     */
+    sourceTree?: 'off' | 'root-only';
+    /**
+     * Output console summary (best-effort).
+     */
+    sourceConsole?: boolean;
+    /**
+     * Output DOM snapshots and diffs.
+     */
+    sourceDom?: boolean;
+    /**
+     * Maximum HTML bytes to print (0 disables truncation).
+     */
+    sourceMaxBytes?: number;
+    /**
+     * Redaction mode for HTML output.
+     */
+    sourceRedact?: 'off' | 'safe' | 'strict';
+    /**
+     * Control Shadow DOM inclusion when extracting HTML.
+     */
+    sourceIncludeShadow?: 'off' | 'open-only' | 'all';
+    /**
+     * Include diff metadata on watch updates.
+     */
+    sourceDiff?: boolean;
+    /**
+     * Log level for unified logger (Chromium CDP logging).
+     * One of: 'off', 'error', 'warn', 'info', 'debug', 'trace', 'all'
+     */
+    logLevel?: 'off' | 'error' | 'warn' | 'info' | 'debug' | 'trace' | 'all';
+    /**
+     * Log contexts to enable.
+     * Example: ['background', 'content', 'page']
+     */
+    logContexts?: Array<'background' | 'content' | 'page' | 'sidebar' | 'popup' | 'options' | 'devtools'>;
+    /**
+     * Log output format.
+     * One of: 'pretty', 'json'
+     */
+    logFormat?: 'pretty' | 'json' | 'ndjson';
+    /**
+     * Include timestamps in logs.
+     * @default true
+     */
+    logTimestamps?: boolean;
+    /**
+     * Enable colored log output.
+     * @default false
+     */
+    logColor?: boolean;
+    /**
+     * URL to send logs to.
+     * Example: 'http://localhost:3000'
+     */
+    logUrl?: string;
+    /**
+     * Tab ID or index for logging context.
+     */
+    logTab?: number | string;
+    /**
+     * Perform a dry run without launching the browser.
+     * @default false
+     */
+    dryRun?: boolean;
+}
+/**
+ * Runtime state shared with post-launch setup helpers (CDP/RDP).
+ * Extends the main PluginInterface with transient fields used during runtime.
+ */
+export interface PluginRuntime extends PluginInterface {
+}
+export type LogLevel = 'off' | 'error' | 'warn' | 'info' | 'debug' | 'trace' | 'all';
+export type LogContext = 'background' | 'content' | 'page' | 'sidebar' | 'popup' | 'options' | 'devtools';
+export type LogFormat = 'pretty' | 'json' | 'ndjson';
+/**
+ * Unified controller interface used by post-launch logging flows.
+ * Implemented by both CDP and RDP controllers.
+ */
+export interface Controller {
+    enableUnifiedLogging: (opts: {
+        level?: string;
+        contexts?: string[] | undefined;
+        urlFilter?: string | undefined;
+        tabFilter?: number | string | undefined;
+        format?: 'pretty' | 'json' | 'ndjson';
+        timestamps?: boolean;
+        color?: boolean;
+    }) => Promise<void>;
+    /**
+     * Optional event subscription hook for protocol events (CDP/RDP).
+     * Present in Chromium CDP flows; Firefox may omit it.
+     */
+    onProtocolEvent?: (cb: (evt: {
+        method?: string;
+        params?: unknown;
+    }) => void) => void;
+}

package/dist/extension/browsers/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/extension/browsers/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/extension/browsers/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/extension/browsers/run-chromium/chromium-launch/dry-run.d.ts

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

package/dist/extension/browsers/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/extension/browsers/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/extension/browsers/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/extension/browsers/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/extension/browsers/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/extension/browsers/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/extension/browsers/run-chromium/chromium-source-inspection/cdp-client.d.ts

@@ -0,0 +1,60 @@
+import { type ExtensionRootMetaPayload } from './page';
+export declare class CDPClient {
+    private port;
+    private host;
+    private ws;
+    private targetWebSocketUrl;
+    private eventCallbacks;
+    private messageId;
+    private pendingRequests;
+    private heartbeatTimer;
+    constructor(port?: number, host?: string);
+    private isDev;
+    connect(): Promise<void>;
+    disconnect(): void;
+    private startHeartbeat;
+    private stopHeartbeat;
+    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/extension/browsers/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/extension/browsers/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/extension/browsers/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;