extension 3.12.0 → 3.12.1

package/dist/browser/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/browser/run-firefox/firefox-launch/dry-run.d.ts

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

package/dist/browser/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/browser/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/browser/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/browser/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/browser/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 {};

package/dist/browser/run-firefox/firefox-source-inspection/rdp-extension-controller/index.d.ts

@@ -0,0 +1,38 @@
+import type { CompilationLike } from '../../../browsers-types';
+import { RemoteFirefox } from '../remote-firefox';
+import type { BrowserType } from '../../../browsers-types';
+import type { ContentScriptTargetRule } from '../../../browsers-lib/content-script-targets';
+type PluginLike = {
+    extension: string | string[];
+    browser: BrowserType;
+    browserFlags?: string[];
+    profile?: string | false;
+    preferences?: Record<string, unknown>;
+    startingUrl?: string;
+    geckoBinary?: string;
+    instanceId?: string;
+    source?: string | boolean;
+    watchSource?: boolean;
+    port?: number | string;
+    browserVersionLine?: string;
+};
+export declare class FirefoxRDPController {
+    private readonly remote;
+    private readonly debugPort;
+    constructor(plugin: PluginLike, debugPort: number);
+    getRemoteFirefox(): RemoteFirefox;
+    connect(): Promise<void>;
+    ensureLoaded(compilation: CompilationLike): Promise<void>;
+    hardReload(compilation: CompilationLike, changedAssets: string[]): Promise<void>;
+    reloadMatchingTabsForContentScripts(rules: ContentScriptTargetRule[]): Promise<number>;
+    enableUnifiedLogging(opts: {
+        level?: string;
+        contexts?: string[] | undefined;
+        urlFilter?: string | undefined;
+        tabFilter?: number | string | undefined;
+        format?: 'pretty' | 'json' | 'ndjson';
+        timestamps?: boolean;
+        color?: boolean;
+    }): Promise<void>;
+}
+export { FirefoxRDPController as RDPExtensionController };

package/dist/browser/run-firefox/firefox-source-inspection/remote-firefox/addons-install.d.ts

@@ -0,0 +1,10 @@
+import type { CompilationLike } from '../../../browsers-types';
+import { MessagingClient } from './messaging-client';
+export declare function getAddonsActorWithRetry(client: MessagingClient, cached: string | undefined, tries?: number, delayMs?: number): Promise<string | undefined>;
+export declare function computeCandidateAddonPaths(compilation: CompilationLike, extensionsToLoad: string[], projectContext?: string): string[];
+export declare function waitForManagerWelcome(client: MessagingClient): Promise<void>;
+export declare function installTemporaryAddon(client: MessagingClient, addonsActor: string, addonPath: string, openDevTools: boolean): Promise<{
+    addon?: {
+        id?: string;
+    };
+} | undefined>;

package/dist/browser/run-firefox/firefox-source-inspection/remote-firefox/addons.d.ts

@@ -0,0 +1 @@
+export declare function resolveAddonDirectory(baseDir: string, inputPath: string): string;

package/dist/browser/run-firefox/firefox-source-inspection/remote-firefox/evaluate.d.ts

@@ -0,0 +1,18 @@
+interface RdpClientLike {
+    request: (payload: unknown) => Promise<unknown>;
+    getTargetFromDescriptor?: (descriptorId: string) => Promise<unknown>;
+    on?: (event: string, listener: (message: unknown) => void) => unknown;
+    off?: (event: string, listener: (message: unknown) => void) => unknown;
+    removeListener?: (event: string, listener: (message: unknown) => void) => unknown;
+}
+export declare function evaluate(client: RdpClientLike, tabId: string, expression: string): Promise<any>;
+export declare function evaluateRaw(client: RdpClientLike, tabId: string, expression: string): Promise<unknown>;
+export declare function coerceResponseToString(client: RdpClientLike, tabId: string, response: unknown, opts?: {
+    fallbackToFullDocument?: boolean;
+}): Promise<string>;
+export declare function resolveActorForEvaluation(client: RdpClientLike, descriptorActor: string, consoleActorHint?: string): Promise<string>;
+export declare function serializeDocument(client: RdpClientLike, actorToUse: string): Promise<string>;
+export declare function extractShadowContent(client: RdpClientLike, actorToUse: string): Promise<string>;
+export declare function mergeShadowIntoMain(mainHTML: string, shadowContent: string): string;
+export declare function getPageHTML(client: RdpClientLike, descriptorActor: string, consoleActorHint?: string): Promise<string>;
+export {};

package/dist/browser/run-firefox/firefox-source-inspection/remote-firefox/firefox-utils.d.ts

@@ -0,0 +1,17 @@
+export declare function printRunningInDevelopmentSummary(candidateAddonPaths: string[], browser: 'firefox', extensionId?: string, browserVersionLine?: string): Promise<boolean>;
+export declare function printSourceInspection(html: string): void;
+export declare function printLogEventPretty(event: {
+    id: string;
+    timestamp: number;
+    level: string;
+    context: string;
+    messageParts: string[];
+    url: string;
+    tabId: number | undefined;
+}, color: boolean, colorFns: {
+    red: (s: string) => string;
+    yellow: (s: string) => string;
+    gray: (s: string) => string;
+    blue: (s: string) => string;
+}, showTs: boolean): void;
+export declare function printLogEventJson(event: unknown): void;

package/dist/browser/run-firefox/firefox-source-inspection/remote-firefox/index.d.ts

@@ -0,0 +1,38 @@
+import type { CompilationLike } from '../../../browsers-types';
+import { type PluginInterface } from '../../../browsers-types';
+import { type ContentScriptTargetRule } from '../../../browsers-lib/content-script-targets';
+export declare class RemoteFirefox {
+    private readonly options;
+    private needsReinstall;
+    private client;
+    private loggingAttached;
+    private cachedAddonsActor;
+    private cachedSupportsReload;
+    private lastInstalledAddonPath;
+    private derivedExtensionId;
+    private selectPrimaryAddonPath;
+    constructor(configOptions: PluginInterface & {
+        browserVersionLine?: string;
+    });
+    private resolveRdpPort;
+    private connectClient;
+    installAddons(compilation: CompilationLike): Promise<void>;
+    markNeedsReinstall(): void;
+    private ensureCapabilities;
+    private reloadAddonOrReinstall;
+    hardReloadIfNeeded(compilation: CompilationLike, changedAssets: string[]): Promise<void>;
+    reloadMatchingTabsForContentScripts(rules: ContentScriptTargetRule[]): Promise<number>;
+    inspectSource(compilation: CompilationLike, opts: {
+        startingUrl?: string;
+        source?: string | boolean;
+    }): Promise<void>;
+    enableUnifiedLogging(opts: {
+        level?: string;
+        contexts?: string[] | undefined;
+        urlFilter?: string | undefined;
+        tabFilter?: number | string | undefined;
+        format?: 'pretty' | 'json' | 'ndjson';
+        timestamps?: boolean;
+        color?: boolean;
+    }): Promise<void>;
+}

package/dist/browser/run-firefox/firefox-source-inspection/remote-firefox/logging.d.ts

@@ -0,0 +1,11 @@
+import { MessagingClient } from './messaging-client';
+export declare function attachConsoleListeners(client: MessagingClient): Promise<void>;
+export declare function subscribeUnifiedLogging(client: MessagingClient, opts: {
+    level?: string;
+    contexts?: string[] | undefined;
+    urlFilter?: string | undefined;
+    tabFilter?: string;
+    format?: 'pretty' | 'json' | 'ndjson';
+    timestamps?: boolean;
+    color?: boolean;
+}): void;

package/dist/browser/run-firefox/firefox-source-inspection/remote-firefox/message-utils.d.ts

@@ -0,0 +1,2 @@
+export declare function requestErrorToMessage(error: unknown): string;
+export declare function isErrorWithCode(codeWanted: string | string[], error: unknown): boolean;

package/dist/browser/run-firefox/firefox-source-inspection/remote-firefox/messaging-client.d.ts

@@ -0,0 +1,37 @@
+import EventEmitter from 'events';
+export declare class MessagingClient extends EventEmitter {
+    private transport;
+    private forwardingSetup;
+    connect(port: number): Promise<void>;
+    disconnect(): void;
+    request(requestProps: unknown): Promise<unknown>;
+    onError(error: Error): void;
+    getTargets(): Promise<{
+        actor?: string;
+        url?: string;
+        consoleActor?: string;
+        webConsoleActor?: string;
+    }[]>;
+    navigate(tabId: string, url: string): Promise<void>;
+    attach(tabId: string): Promise<unknown>;
+    getTargetFromDescriptor(descriptorId: string): Promise<{
+        targetActor: string | undefined;
+        consoleActor: string | undefined;
+    } | {
+        targetActor?: undefined;
+        consoleActor?: undefined;
+    }>;
+    addTab(url: string): Promise<unknown>;
+    navigateViaScript(consoleActor: string, url: string): Promise<void>;
+    waitForPageReady(consoleActor: string, url: string, timeoutMs?: number): Promise<void>;
+    waitForLoadEvent(tabId: string): Promise<void>;
+    evaluate(tabId: string, expression: string): Promise<any>;
+    evaluateRaw(tabId: string, expression: string): Promise<unknown>;
+    private coerceResponseToString;
+    private resolveActorForEvaluation;
+    private serializeDocument;
+    private extractShadowContent;
+    private mergeShadowIntoMain;
+    getPageHTML(descriptorActor: string, consoleActorHint?: string): Promise<string>;
+    closeTab(tabId: string): Promise<void>;
+}

package/dist/browser/run-firefox/firefox-source-inspection/remote-firefox/moz-id.d.ts

@@ -0,0 +1,2 @@
+import { MessagingClient } from './messaging-client';
+export declare function deriveMozExtensionId(client: MessagingClient): Promise<string | undefined>;

package/dist/browser/run-firefox/firefox-source-inspection/remote-firefox/rdp-api.d.ts

@@ -0,0 +1,29 @@
+import { RdpTransport } from './transport';
+export declare function listTabs(transport: RdpTransport): Promise<{
+    actor?: string;
+    url?: string;
+    consoleActor?: string;
+    webConsoleActor?: string;
+}[]>;
+export declare function addTab(transport: RdpTransport, url: string): Promise<unknown>;
+export declare function navigate(transport: RdpTransport, tabId: string, url: string): Promise<void>;
+export declare function attach(transport: RdpTransport, tabId: string): Promise<unknown>;
+export declare function getTargetFromDescriptor(transport: RdpTransport, descriptorId: string): Promise<{
+    frame?: {
+        actor?: string;
+        consoleActor?: string;
+    };
+    actor?: string;
+    target?: {
+        actor?: string;
+        consoleActor?: string;
+    };
+    tab?: {
+        actor?: string;
+    } | string;
+    webConsoleActor?: string;
+    consoleActor?: string;
+}>;
+export declare function navigateViaScript(transport: RdpTransport, consoleActor: string, url: string): Promise<void>;
+export declare function waitForPageReady(transport: RdpTransport, consoleActor: string, url: string, timeoutMs?: number): Promise<void>;
+export declare function waitForLoadEvent(transport: RdpTransport, tabId: string): Promise<void>;

package/dist/browser/run-firefox/firefox-source-inspection/remote-firefox/rdp-wire.d.ts

@@ -0,0 +1,8 @@
+export interface RdpFrameParseResult<T = unknown> {
+    remainingData: Buffer;
+    parsedMessage?: T;
+    error?: Error;
+    fatal?: boolean;
+}
+export declare function parseRdpFrame<T = unknown>(data: Buffer): RdpFrameParseResult<T>;
+export declare function buildRdpFrame(obj: unknown): string;

package/dist/browser/run-firefox/firefox-source-inspection/remote-firefox/source-inspect.d.ts

@@ -0,0 +1,9 @@
+import { MessagingClient } from './messaging-client';
+export declare function ensureTabForUrl(client: MessagingClient, urlToInspect?: string): Promise<{
+    actor: string;
+    consoleActor?: string;
+} | null>;
+export declare function navigateTo(client: MessagingClient, tabActor: string, consoleActorHint: string | undefined, url: string): Promise<void>;
+export declare function getPageHTML(client: MessagingClient, descriptorActor: string, consoleActorHint?: string): Promise<any>;
+export declare function resolveConsoleActorMethod(client: MessagingClient, tabActor: string, urlToInspect: string): Promise<string>;
+export declare function waitForContentScriptInjectionMethod(client: MessagingClient, consoleActor: string): Promise<boolean>;

package/dist/browser/run-firefox/firefox-source-inspection/remote-firefox/transport.d.ts

@@ -0,0 +1,20 @@
+import EventEmitter from 'events';
+export declare class RdpTransport extends EventEmitter {
+    private conn?;
+    private incoming;
+    private active;
+    private pending;
+    connect(port: number): Promise<void>;
+    disconnect(): void;
+    private rejectAll;
+    request(payload: any & {
+        to?: string;
+    }): Promise<unknown>;
+    private flush;
+    private expectReply;
+    private onData;
+    private readMessage;
+    private handleMessage;
+    private onEnd;
+    private onTimeout;
+}

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

@@ -0,0 +1,16 @@
+import type { PluginInterface } from '../browsers-types';
+import type { FirefoxRDPController } from './firefox-source-inspection/rdp-extension-controller';
+/**
+ * Narrowed plugin options used through the Firefox flow.
+ */
+export type FirefoxPluginLike = Pick<PluginInterface, 'extension' | 'browserFlags' | 'profile' | 'preferences' | 'startingUrl' | 'geckoBinary' | 'instanceId' | 'watchSource' | 'sourceFormat' | 'sourceSummary' | 'sourceMeta' | 'sourceProbe' | 'sourceTree' | 'sourceConsole' | 'sourceDom' | 'sourceMaxBytes' | 'sourceRedact' | 'sourceIncludeShadow' | 'sourceDiff' | 'port' | 'logLevel' | 'logContexts' | 'logFormat' | 'logTimestamps' | 'logColor' | 'logUrl' | 'logTab' | 'dryRun'> & {
+    browser: PluginInterface['browser'];
+    source?: string | boolean;
+};
+/**
+ * Runtime state in Firefox flow.
+ */
+export interface FirefoxPluginRuntime extends FirefoxPluginLike {
+    rdpController?: FirefoxRDPController;
+    browserVersionLine?: string;
+}

package/dist/browser/run-only.d.ts

@@ -0,0 +1,22 @@
+import type { BrowserType } from './browsers-types';
+type PreviewRunOptions = {
+    browser: BrowserType;
+    outPath: string;
+    contextDir: string;
+    extensionsToLoad: string[];
+    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;
+    readyPath?: string;
+};
+export declare function runOnlyPreviewBrowser(opts: PreviewRunOptions): Promise<void>;
+export {};

package/dist/cli/cli-lib/extension-develop-runtime.d.ts

@@ -0,0 +1,9 @@
+export declare function resolveExtensionDevelopRoot(startDir?: string): string;
+export declare function resolveExtensionDevelopVersion(startDir?: string, fallbackVersion?: string): string;
+export declare function loadExtensionDevelopModule<T = any>(startDir?: string): T;
+/**
+ * Load only the lightweight preview entry from extension-develop.
+ * This avoids pulling in rspack and the full build toolchain, making
+ * `extension preview` start significantly faster.
+ */
+export declare function loadExtensionDevelopPreviewModule<T = any>(startDir?: string): T;

package/dist/{utils.d.ts → cli/utils.d.ts}

@@ -1,4 +1,3 @@
-export declare function resolveModuleEntry(modulePath: string, pkgJson: any): string | undefined;
 export type Browser = 'chrome' | 'edge' | 'firefox' | 'chromium' | 'chromium-based' | 'gecko-based' | 'firefox-based';
 export declare function parseOptionalBoolean(value?: string): boolean;
 export declare const vendors: (browser?: Browser | "all") => string[];