extension 3.12.0 → 3.12.2

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

@@ -0,0 +1,21 @@
+export type ContentScriptProbe = {
+    scriptPath: string;
+    probeId: string;
+};
+export type HmrIterationExpectation = {
+    scriptPath: string;
+    expectedToken: string;
+};
+export type HmrIterationResult = {
+    scriptPath: string;
+    expectedToken: string;
+    snapshotIndex: number;
+    passed: boolean;
+    reason: string;
+};
+export declare function listManifestContentScriptFiles(manifest: unknown): string[];
+export declare function contentScriptProbeId(scriptPath: string): string;
+export declare function buildContentScriptProbePlan(manifest: unknown): ContentScriptProbe[];
+export declare function buildIterationExpectations(probePlan: ContentScriptProbe[], tokenVersion: string): HmrIterationExpectation[];
+export declare function extractUpdatedHtmlFromNdjson(output: string): string[];
+export declare function evaluateDeterministicHmrIterations(expectations: HmrIterationExpectation[], updatedHtmlSnapshots: string[]): HmrIterationResult[];

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

@@ -0,0 +1,2 @@
+import { CDPClient } from './cdp-client';
+export declare function extractPageHtml(cdpClient: CDPClient, sessionId: string, logSamples?: boolean, includeShadow?: 'off' | 'open-only' | 'all'): Promise<string>;

package/dist/extension/browsers/run-chromium/chromium-source-inspection/index.d.ts

@@ -0,0 +1,79 @@
+import { WebSocketServer } from 'ws';
+import type { PluginInterface } from '../../browsers-types';
+/**
+ * ChromiumSourceInspectionPlugin
+ *
+ * Intended responsibilities:
+ * - Dev-only page/extension inspection; attach to target and extract HTML
+ * - Optional watch mode to re-print HTML on file changes
+ */
+export declare class ChromiumSourceInspectionPlugin {
+    private devOptions;
+    private cdpClient;
+    private currentTargetId;
+    private currentSessionId;
+    private isInitialized;
+    private isWatching;
+    private hasInspectedSourceOnce;
+    private pendingWatchSourceUpdate;
+    private pendingWatchSourceRootMeta?;
+    private debounceTimer;
+    private watchSourceFlushTimer;
+    private isFlushingWatchSourceUpdate;
+    private lastFlushTimestamp;
+    private runtimeMode?;
+    private lastOutputHash?;
+    private lastByteLength?;
+    private lastSummary?;
+    private lastDomSnapshot?;
+    private consoleCounts;
+    private consoleTop;
+    constructor(devOptions: Pick<PluginInterface, 'port' | 'source' | 'watchSource'> & {
+        startingUrl?: string;
+        instanceId?: string;
+    }, _ctx?: unknown);
+    private isAuthorMode;
+    private getOutputConfig;
+    private getPageMetadata;
+    private getFrameContext;
+    private getDomSnapshot;
+    private getExtensionRootMeta;
+    /**
+     * Require structural evidence (counted roots or shadow style nodes) after the
+     * injection wait, with a short settle loop for async shadow hydration. Falls back to
+     * the same shadow-innerHTML probe as {@link waitForContentScriptInjection}.
+     */
+    private shouldEmitContentScriptInjected;
+    private getPageMetaSnapshot;
+    private getSelectorProbes;
+    private getExtensionRootTree;
+    private setupConsoleCapture;
+    private recordConsoleEvent;
+    private buildPrettyTitle;
+    private emitSourceOutput;
+    private emitExtraOutputs;
+    private emitEventPayload;
+    private getShadowStyleSnapshot;
+    private getCdpPort;
+    initialize(port?: number): Promise<void>;
+    inspectSource(url: string, options?: {
+        forceNavigate?: boolean;
+    }): Promise<string>;
+    startWatching(websocketServer: WebSocketServer): Promise<void>;
+    private setupWebSocketHandler;
+    private setupConnectionHandler;
+    stopWatching(): void;
+    private registerContentReloadSnapshotHook;
+    private scheduleWatchSourceUpdate;
+    private emitImmediateUpdatedSnapshotFromCurrentSession;
+    private handleFileChange;
+    private waitForContentScriptReinjection;
+    private emitUpdatedSnapshotFromCurrentSession;
+    private waitForMeaningfulContentScriptContent;
+    private waitForContentScriptStyles;
+    private reconnectToTarget;
+    printHTML(html: string): Promise<void>;
+    printUpdatedHTML(html: string): Promise<void>;
+    cleanup(): Promise<void>;
+    apply(compiler: any): void;
+}

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

@@ -0,0 +1 @@
+export declare function waitForChromeRemoteDebugging(port: number, instanceId?: string): Promise<void>;

package/dist/extension/browsers/run-chromium/chromium-source-inspection/sessions.d.ts

@@ -0,0 +1,2 @@
+import { CDPClient } from './cdp-client';
+export declare function enableRuntimeAndLog(cdp: CDPClient, sessionId?: string): Promise<void>;

package/dist/extension/browsers/run-chromium/chromium-source-inspection/targets.d.ts

@@ -0,0 +1,7 @@
+import { CDPClient } from './cdp-client';
+export declare function ensureTargetAndSession(cdpClient: CDPClient, url: string, options?: {
+    forceNavigate?: boolean;
+}): Promise<{
+    targetId: string;
+    sessionId: string;
+}>;

package/dist/extension/browsers/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/extension/browsers/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/extension/browsers/run-chromium/chromium-unified-logger/index.d.ts

@@ -0,0 +1,22 @@
+import type { ChromiumContext } from '../chromium-context';
+/**
+ * ChromiumUnifiedLoggerPlugin
+ *
+ * Intended responsibilities:
+ * - Wait for controller readiness; enable unified CDP logging
+ * - Respect level/contexts/filters/format/timestamps/color
+ */
+export declare class ChromiumUnifiedLoggerPlugin {
+    private readonly options;
+    private readonly ctx;
+    constructor(options: {
+        logLevel?: string;
+        logContexts?: string[];
+        logUrl?: string;
+        logTab?: number | string;
+        logFormat?: 'pretty' | 'json' | 'ndjson';
+        logTimestamps?: boolean;
+        logColor?: boolean;
+    }, ctx: ChromiumContext);
+    apply(_compiler: any): void;
+}

package/dist/extension/browsers/run-chromium/chromium-unified-logger/unified-logging.d.ts

@@ -0,0 +1,2 @@
+import type { Controller, ChromiumLogger } from '../chromium-types';
+export declare function setupUnifiedLogging(controller: Controller, opts: ChromiumLogger): Promise<void>;

package/dist/extension/browsers/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/extension/browsers/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/extension/browsers/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;
+    }>;
+}

package/dist/extension/browsers/run-firefox/firefox-launch/browser-config.d.ts

@@ -0,0 +1,19 @@
+import type { CompilationLike } from '../../browsers-types';
+import type { BrowserType, BrowserConfig } from '../../browsers-types';
+type BrowserConfigOptions = {
+    browser: BrowserType;
+    mode: 'development' | 'production' | 'none';
+    browserFlags?: string[];
+    excludeBrowserFlags?: string[];
+    profile?: string | false;
+    preferences?: Record<string, unknown>;
+    startingUrl?: string;
+    port?: number | string;
+    noOpen?: boolean;
+} & BrowserConfig & {
+    keepProfileChanges?: boolean;
+    copyFromProfile?: string;
+    instanceId?: string;
+};
+export declare function browserConfig(compilation: CompilationLike, configOptions: BrowserConfigOptions): Promise<string>;
+export {};

package/dist/extension/browsers/run-firefox/firefox-launch/dry-run.d.ts

@@ -0,0 +1 @@
+export declare function logFirefoxDryRun(browserBinaryLocation: string, firefoxConfig: string): void;

package/dist/extension/browsers/run-firefox/firefox-launch/index.d.ts

@@ -0,0 +1,37 @@
+import type { CompilationLike } from '../../browsers-types';
+import type { FirefoxContext } from '../firefox-context';
+import type { BrowserType, BrowserConfig } from '../../browsers-types';
+import type { FirefoxPluginRuntime } from '../firefox-types';
+type LaunchOptions = {
+    browser: BrowserType;
+    mode: 'development' | 'production' | 'none';
+    browserFlags?: string[];
+    excludeBrowserFlags?: string[];
+    profile?: string | false;
+    preferences?: Record<string, unknown>;
+    startingUrl?: string;
+    port?: number | string;
+    noOpen?: boolean;
+} & BrowserConfig;
+export declare class FirefoxLaunchPlugin {
+    private readonly host;
+    private readonly ctx;
+    private child;
+    private watchTimeout?;
+    constructor(host: FirefoxPluginRuntime, ctx: FirefoxContext);
+    /**
+     * Run the Firefox launch flow without requiring a bundler compiler instance.
+     * Intended for run-only preview paths.
+     */
+    runOnce(compilation: CompilationLike, options: LaunchOptions): Promise<void>;
+    apply(compiler: any): void;
+    private launch;
+    private resolveSpawnStdio;
+    private spawnFirefoxChild;
+    private pipeChildOutput;
+    private wireChildLifecycle;
+    private cleanupInstance;
+    private scheduleWatchTimeout;
+    private printInstallHint;
+}
+export {};

package/dist/extension/browsers/run-firefox/firefox-launch/master-preferences.d.ts

@@ -0,0 +1,137 @@
+declare const masterPreferences: {
+    'browser.aboutwelcome.enabled': boolean;
+    'browser.startup.homepage_override.mstone': string;
+    'browser.shell.didSkipDefaultBrowserCheckOnFirstRun': boolean;
+    'datareporting.policy.dataSubmissionPolicyBypassNotification': boolean;
+    'browser.startup.upgradeDialog.enabled': boolean;
+    'browser.messaging-system.whatsNewPanel.enabled': boolean;
+    'browser.newtabpage.activity-stream.asrouter.userprefs.cfr.addons': boolean;
+    'browser.newtabpage.activity-stream.asrouter.userprefs.cfr.features': boolean;
+    'browser.startup.homepage_override_url': string;
+    'app.update.enabled': boolean;
+    'browser.dom.window.dump.enabled': boolean;
+    'browser.formfill.enable': boolean;
+    'browser.link.open_newwindow': number;
+    'browser.sessionstore.enabled': boolean;
+    'browser.sessionstore.resume_from_crash': boolean;
+    'browser.sessionstore.max_resumed_crashes': number;
+    'browser.sessionstore.restore_on_demand': boolean;
+    'browser.sessionstore.resume_session_once': boolean;
+    'toolkit.startup.max_resumed_crashes': number;
+    'browser.shell.checkDefaultBrowser': boolean;
+    'browser.sync.enabled': boolean;
+    'browser.startup.page': number;
+    'browser.startup.homepage_welcome_url': string;
+    'browser.startup.homepage_welcome_url_additional': string;
+    'browser.urlbar.suggest.bookmark': boolean;
+    'browser.urlbar.suggest.clipboard': boolean;
+    'browser.urlbar.suggest.history': boolean;
+    'browser.urlbar.suggest.openpage': boolean;
+    'browser.urlbar.suggest.remotetab': boolean;
+    'browser.urlbar.suggest.searches': boolean;
+    'browser.urlbar.suggest.topsites': boolean;
+    'browser.urlbar.suggest.engines': boolean;
+    'browser.urlbar.suggest.calculator': boolean;
+    'browser.urlbar.suggest.recentsearches': boolean;
+    'browser.newtabpage.enabled': boolean;
+    'browser.newtabpage.activity-stream.showSearch': boolean;
+    'browser.newtabpage.activity-stream.showSponsored': boolean;
+    'browser.newtabpage.activity-stream.feeds.topsites': boolean;
+    'browser.newtabpage.activity-stream.feeds.section.topstories': boolean;
+    'browser.newtabpage.activity-stream.feeds.snippets': boolean;
+    'browser.newtabpage.activity-stream.improvesearch.handoffToAwesomebar': boolean;
+    'datareporting.policy.dataSubmissionEnabled': boolean;
+    'datareporting.policy.firstRunURL': string;
+    'devtools.browserconsole.contentMessages': boolean;
+    'devtools.chrome.enabled': boolean;
+    'devtools.debugger.prompt-connection': boolean;
+    'devtools.debugger.remote-enabled': boolean;
+    'devtools.errorconsole.enabled': boolean;
+    'extensions.installDistroAddons': boolean;
+    'extensions.autoDisableScopes': number;
+    'extensions.chrome.enabled': boolean;
+    'extensions.logging.enabled': boolean;
+    'extensions.checkCompatibility.nightly': boolean;
+    'extensions.update.enabled': boolean;
+    'extensions.update.notifyUser': boolean;
+    'extensions.enabledScopes': number;
+    'extensions.getAddons.cache.enabled': boolean;
+    'network.prefetch.next': boolean;
+    'network.speculative.preconnect.enabled': boolean;
+    'toolkit.telemetry.enabled': boolean;
+    'toolkit.telemetry.archive.enabled': boolean;
+    'toolkit.telemetry.newProfilePing.enabled': boolean;
+    'toolkit.recovery.enabled': boolean;
+    'urlclassifier.updateinterval': number;
+    'security.enterprise_roots.enabled': boolean;
+    'xpinstall.signatures.required': boolean;
+};
+export default masterPreferences;
+export declare function getPreferences(customPrefs: Record<string, any>): {
+    'browser.aboutwelcome.enabled': boolean;
+    'browser.startup.homepage_override.mstone': string;
+    'browser.shell.didSkipDefaultBrowserCheckOnFirstRun': boolean;
+    'datareporting.policy.dataSubmissionPolicyBypassNotification': boolean;
+    'browser.startup.upgradeDialog.enabled': boolean;
+    'browser.messaging-system.whatsNewPanel.enabled': boolean;
+    'browser.newtabpage.activity-stream.asrouter.userprefs.cfr.addons': boolean;
+    'browser.newtabpage.activity-stream.asrouter.userprefs.cfr.features': boolean;
+    'browser.startup.homepage_override_url': string;
+    'app.update.enabled': boolean;
+    'browser.dom.window.dump.enabled': boolean;
+    'browser.formfill.enable': boolean;
+    'browser.link.open_newwindow': number;
+    'browser.sessionstore.enabled': boolean;
+    'browser.sessionstore.resume_from_crash': boolean;
+    'browser.sessionstore.max_resumed_crashes': number;
+    'browser.sessionstore.restore_on_demand': boolean;
+    'browser.sessionstore.resume_session_once': boolean;
+    'toolkit.startup.max_resumed_crashes': number;
+    'browser.shell.checkDefaultBrowser': boolean;
+    'browser.sync.enabled': boolean;
+    'browser.startup.page': number;
+    'browser.startup.homepage_welcome_url': string;
+    'browser.startup.homepage_welcome_url_additional': string;
+    'browser.urlbar.suggest.bookmark': boolean;
+    'browser.urlbar.suggest.clipboard': boolean;
+    'browser.urlbar.suggest.history': boolean;
+    'browser.urlbar.suggest.openpage': boolean;
+    'browser.urlbar.suggest.remotetab': boolean;
+    'browser.urlbar.suggest.searches': boolean;
+    'browser.urlbar.suggest.topsites': boolean;
+    'browser.urlbar.suggest.engines': boolean;
+    'browser.urlbar.suggest.calculator': boolean;
+    'browser.urlbar.suggest.recentsearches': boolean;
+    'browser.newtabpage.enabled': boolean;
+    'browser.newtabpage.activity-stream.showSearch': boolean;
+    'browser.newtabpage.activity-stream.showSponsored': boolean;
+    'browser.newtabpage.activity-stream.feeds.topsites': boolean;
+    'browser.newtabpage.activity-stream.feeds.section.topstories': boolean;
+    'browser.newtabpage.activity-stream.feeds.snippets': boolean;
+    'browser.newtabpage.activity-stream.improvesearch.handoffToAwesomebar': boolean;
+    'datareporting.policy.dataSubmissionEnabled': boolean;
+    'datareporting.policy.firstRunURL': string;
+    'devtools.browserconsole.contentMessages': boolean;
+    'devtools.chrome.enabled': boolean;
+    'devtools.debugger.prompt-connection': boolean;
+    'devtools.debugger.remote-enabled': boolean;
+    'devtools.errorconsole.enabled': boolean;
+    'extensions.installDistroAddons': boolean;
+    'extensions.autoDisableScopes': number;
+    'extensions.chrome.enabled': boolean;
+    'extensions.logging.enabled': boolean;
+    'extensions.checkCompatibility.nightly': boolean;
+    'extensions.update.enabled': boolean;
+    'extensions.update.notifyUser': boolean;
+    'extensions.enabledScopes': number;
+    'extensions.getAddons.cache.enabled': boolean;
+    'network.prefetch.next': boolean;
+    'network.speculative.preconnect.enabled': boolean;
+    'toolkit.telemetry.enabled': boolean;
+    'toolkit.telemetry.archive.enabled': boolean;
+    'toolkit.telemetry.newProfilePing.enabled': boolean;
+    'toolkit.recovery.enabled': boolean;
+    'urlclassifier.updateinterval': number;
+    'security.enterprise_roots.enabled': boolean;
+    'xpinstall.signatures.required': boolean;
+};

package/dist/extension/browsers/run-firefox/firefox-launch/process-handlers.d.ts

@@ -0,0 +1,2 @@
+import { ChildProcess } from 'child_process';
+export declare function setupFirefoxProcessHandlers(browser: 'firefox' | 'chrome' | 'edge' | 'chromium-based', childRef: () => ChildProcess | null, cleanupInstance: () => Promise<void>): void;

package/dist/extension/browsers/run-firefox/firefox-launch/setup-rdp-after-launch.d.ts

@@ -0,0 +1,6 @@
+import type { CompilationLike } from '../../browsers-types';
+import { FirefoxRDPController } from '../firefox-source-inspection/rdp-extension-controller';
+import type { FirefoxPluginRuntime } from '../firefox-types';
+export declare function setupRdpAfterLaunch(plugin: FirefoxPluginRuntime & {
+    [k: string]: unknown;
+}, compilation: CompilationLike, debugPort: number): Promise<FirefoxRDPController>;

package/dist/extension/browsers/run-firefox/firefox-launch/wsl-support.d.ts

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