extension-develop 4.0.11 → 4.0.12

package/dist/plugin-compatibility/index.d.ts

@@ -0,0 +1,12 @@
+import { type Compiler } from '@rspack/core';
+import type { PluginInterface, DevOptions } from '../types';
+export declare class CompatibilityPlugin {
+    static readonly name: string;
+    readonly manifestPath: string;
+    readonly browser: DevOptions['browser'];
+    readonly polyfill: DevOptions['polyfill'];
+    constructor(options: PluginInterface & {
+        polyfill: DevOptions['polyfill'];
+    });
+    apply(compiler: Compiler): void;
+}

package/dist/plugin-compilation/boring.d.ts

@@ -0,0 +1,11 @@
+import { Compiler } from '@rspack/core';
+import { type PluginInterface } from '../types';
+export declare class BoringPlugin {
+    static readonly name: string;
+    readonly manifestPath: string;
+    readonly browser: PluginInterface['browser'];
+    private sawUserInvalidation;
+    private printedPostBannerStartupSuccess;
+    constructor(options: PluginInterface);
+    apply(compiler: Compiler): void;
+}

package/dist/plugin-compilation/clean-dist.d.ts

@@ -0,0 +1,8 @@
+import { type Compiler } from '@rspack/core';
+export declare class CleanDistFolderPlugin {
+    private options;
+    constructor(options: {
+        browser: string;
+    });
+    apply(compiler: Compiler): void;
+}

package/dist/plugin-compilation/compilation-lib/messages.d.ts

@@ -0,0 +1,11 @@
+import type { Stats } from '@rspack/core';
+export declare function boring(manifestName: string, durationMs: number, stats: Stats): string;
+export declare function portInUse(requestedPort: number, newPort: number): string;
+export declare function extensionJsRunnerError(error: unknown): string;
+export declare function cleanDistStarting(distPath: string): string;
+export declare function cleanDistRemovedSummary(removedCount: number, distPath: string): string;
+export declare function cleanDistSkippedNotFound(distPath: string): string;
+export declare function zipPackagingSkipped(reason: string): string;
+export declare function envSelectedFile(envPath: string): string;
+export declare function envInjectedPublicVars(count: number): string;
+export declare function envNoMatchingFile(browser: string, mode: string, presentFiles: string[], expectedCandidates: string[]): string;

package/dist/plugin-compilation/compilation-lib/shared-state.d.ts

@@ -0,0 +1,7 @@
+export declare const sharedState: {
+    bannerPrinted: boolean;
+    pendingCompilationLine: string;
+};
+export declare function markBannerPrinted(): void;
+export declare function isBannerPrinted(): boolean;
+export declare function setPendingCompilationLine(line: string): void;

package/dist/plugin-compilation/env.d.ts

@@ -0,0 +1,17 @@
+import { Compiler } from '@rspack/core';
+import type { PluginInterface, DevOptions } from '../types';
+/**
+ * Env files resolve family-wide, mirroring the manifest-prefix contract
+ * (lib/manifest-utils.ts): `chrome:`/`chromium:`/`edge:` manifest keys all
+ * apply to any chromium-family target, so `.env.chrome` must equally apply
+ * when building the default `chromium` target. The exact browser name always
+ * wins over family siblings; Safari/webkit inherit the chromium family for
+ * the same reason they inherit its manifest keys.
+ */
+export declare function getEnvFileCandidates(browser: DevOptions['browser'], mode: string): string[];
+export declare class EnvPlugin {
+    readonly browser: DevOptions['browser'];
+    readonly manifestPath?: string;
+    constructor(options: Partial<PluginInterface>);
+    apply(compiler: Compiler): void;
+}

package/dist/plugin-compilation/index.d.ts

@@ -0,0 +1,22 @@
+import { Compiler } from '@rspack/core';
+import { type PluginInterface } from '../types';
+export declare class CompilationPlugin {
+    static readonly name: string;
+    readonly manifestPath: string;
+    readonly browser: PluginInterface['browser'];
+    readonly clean: boolean;
+    readonly zip?: boolean;
+    readonly zipSource?: boolean;
+    readonly zipFilename?: string;
+    readonly port?: number;
+    constructor(options: PluginInterface & {
+        clean: boolean;
+    } & {
+        zip?: boolean;
+        zipSource?: boolean;
+        zipFilename?: string;
+        port?: number;
+    });
+    private applyIgnoreWarnings;
+    apply(compiler: Compiler): void;
+}

package/dist/plugin-compilation/zip.d.ts

@@ -0,0 +1,18 @@
+import type { Compiler } from '@rspack/core';
+import type { DevOptions } from '../types';
+export interface ZipPluginOptions {
+    manifestPath?: string;
+    browser: DevOptions['browser'];
+    zipData?: {
+        zip?: boolean;
+        zipSource?: boolean;
+        zipFilename?: string;
+    };
+}
+export declare class ZipPlugin {
+    private readonly options;
+    private readonly browser;
+    private readonly zipData;
+    constructor(options: ZipPluginOptions);
+    apply(compiler: Compiler): void;
+}

package/dist/plugin-css/common-style-loaders.d.ts

@@ -0,0 +1,8 @@
+import { type RuleSetRule } from '@rspack/core';
+import { type DevOptions } from '../types';
+export interface StyleLoaderOptions {
+    mode: DevOptions['mode'];
+    loader?: string;
+    loaderOptions?: Record<string, any>;
+}
+export declare function commonStyleLoaders(projectPath: string, opts: StyleLoaderOptions): Promise<RuleSetRule['use']>;

package/dist/plugin-css/css-in-content-script-loader.d.ts

@@ -0,0 +1,4 @@
+import type { RuleSetRule } from '@rspack/core';
+import { type PreprocessorUsage } from './css-lib/build-css-rules';
+import type { DevOptions } from '../types';
+export declare function cssInContentScriptLoader(projectPath: string, manifestPath: string, mode: DevOptions['mode'], usage?: PreprocessorUsage): Promise<RuleSetRule[]>;

package/dist/plugin-css/css-in-html-loader.d.ts

@@ -0,0 +1,4 @@
+import type { RuleSetRule } from '@rspack/core';
+import { type PreprocessorUsage } from './css-lib/build-css-rules';
+import type { DevOptions } from '../types';
+export declare function cssInHtmlLoader(projectPath: string, mode: DevOptions['mode'], manifestPath: string, usage?: PreprocessorUsage): Promise<RuleSetRule[]>;

package/dist/plugin-css/css-lib/build-css-rules.d.ts

@@ -0,0 +1,12 @@
+import type { RuleSetRule } from '@rspack/core';
+import type { DevOptions } from '../../types';
+export interface PreprocessorUsage {
+    useSass?: boolean;
+    useLess?: boolean;
+}
+interface BuildCssRulesOptions {
+    nonModuleType: 'asset/inline' | 'css';
+    issuer: (issuer: string) => boolean;
+}
+export declare function buildCssRules(projectPath: string, mode: DevOptions['mode'], usage: PreprocessorUsage, opts: BuildCssRulesOptions): Promise<RuleSetRule[]>;
+export {};

package/dist/plugin-css/css-lib/inject-css-link.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Injects a `<link rel="stylesheet">` tag into the given `<head>` node
+ * for the bundled CSS of an entry feature.
+ *
+ * @param headNode   – The parse5 `<head>` node to append to.
+ * @param feature    – Entry name (e.g. `chrome_url_overrides/newtab`).
+ * @param firstLinkAttrs – Attributes captured from the first user-authored
+ *   `<link>` so that non-default attributes (media, integrity, …) are
+ *   propagated to the injected tag.
+ * @param hrefOverride – When the emitted CSS filename differs from the
+ *   canonical `/<feature>.css`, pass the actual public href here.
+ */
+export declare function injectCssLink(headNode: any, feature: string, firstLinkAttrs?: Array<{
+    name: string;
+    value: string;
+}>, hrefOverride?: string): void;

package/dist/plugin-css/css-lib/is-content-script.d.ts

@@ -0,0 +1 @@
+export declare function isContentScriptEntry(absolutePath: string, manifestPath: string, projectPath: string): boolean;

package/dist/plugin-css/css-lib/messages.d.ts

@@ -0,0 +1,9 @@
+export declare function cssIntegrationsEnabled(integrations: string[]): string;
+export declare function cssConfigsDetected(postcssConfig?: string, tailwindConfig?: string, browserslistSource?: string): string;
+export declare function isUsingIntegration(name: string): string;
+export declare function youAreAllSet(name: string): string;
+export declare function missingSassDependency(): string;
+export declare function postCssPluginNotResolved(pluginName: string, projectPath: string): string;
+export declare function cssParseErrorShippedVerbatim(resourcePath: string, error: unknown): string;
+export declare function preprocessorShippedUncompiled(resourcePath: string, tool: 'sass' | 'less'): string;
+export declare function deadCssUrlRef(issuerPath: string, request: string): string;

package/dist/plugin-css/css-lib/resolve-css-asset.d.ts

@@ -0,0 +1,21 @@
+import { type Compilation } from '@rspack/core';
+export interface CssAssetResult {
+    /** Whether a CSS asset was found for this feature. */
+    found: boolean;
+    /**
+     * When the asset lives under a name that differs from the canonical
+     * `<feature>.css` (e.g. a chunk split by rspack's native CSS), this
+     * holds the public href to use in the injected `<link>` tag.
+     * Undefined when the canonical name matched directly.
+     */
+    href: string | undefined;
+}
+/**
+ * Resolves the CSS asset emitted for a given entry feature.
+ *
+ * First tries the canonical name (`<feature>.css`).  If that misses —
+ * which can happen when rspack's native CSS (`experiments.css`) splits
+ * the stylesheet into a chunk whose name differs from the entry — it
+ * falls back to inspecting the entrypoint's actual chunk files.
+ */
+export declare function resolveCssAsset(compilation: Compilation, feature: string): CssAssetResult;

package/dist/plugin-css/css-parse-guard-loader.d.ts

@@ -0,0 +1,8 @@
+interface CssParseGuardLoaderContext {
+    resourcePath: string;
+    async(): (err: Error | null, content?: string) => void;
+    emitWarning(warning: Error): void;
+}
+export default function cssParseGuardLoader(this: unknown, source: string): string;
+export declare function pitch(this: CssParseGuardLoaderContext): void;
+export {};

package/dist/plugin-css/css-tools/less.d.ts

@@ -0,0 +1,7 @@
+export declare function isUsingLess(projectPath: string): boolean;
+/**
+ * Resolve (and install if missing) the less-loader contract. The actual loader
+ * rules are emitted by the content-script/HTML CSS loaders — this only ensures
+ * the optional dependency is present before that chain runs.
+ */
+export declare function maybeUseLess(projectPath: string): Promise<void>;

package/dist/plugin-css/css-tools/postcss.d.ts

@@ -0,0 +1,4 @@
+import type { StyleLoaderOptions } from '../common-style-loaders';
+export declare function findPostCssConfig(projectPath: string): string | undefined;
+export declare function isUsingPostCss(projectPath: string): boolean;
+export declare function maybeUsePostCss(projectPath: string, opts: StyleLoaderOptions): Promise<Record<string, any>>;

package/dist/plugin-css/css-tools/sass.d.ts

@@ -0,0 +1,10 @@
+export declare function isUsingSass(projectPath: string): boolean;
+/**
+ * Resolve the Sass implementation from the user's project first, then fall back
+ * to the Extension.js cache/runtime. This mirrors the PostCSS/Tailwind
+ * resolution strategy so we don't depend on Node resolving `sass` from the
+ * loader path inside the npx cache.
+ */
+export declare function resolveSassImplementation(projectPath: string): any | undefined;
+export declare function createSassLoaderOptions(projectPath: string, mode: 'development' | 'production'): Record<string, any>;
+export declare function maybeUseSass(projectPath: string): Promise<void>;

package/dist/plugin-css/css-tools/tailwind.d.ts

@@ -0,0 +1,2 @@
+export declare function isUsingTailwind(projectPath: string): boolean;
+export declare function getTailwindConfigFile(projectPath: string): string | undefined;

package/dist/plugin-css/index.d.ts

@@ -0,0 +1,26 @@
+import { type Compiler } from '@rspack/core';
+import type { PluginInterface } from '../types';
+export { resolveCssAsset } from './css-lib/resolve-css-asset';
+export type { CssAssetResult } from './css-lib/resolve-css-asset';
+export { injectCssLink } from './css-lib/inject-css-link';
+export declare class CssPlugin {
+    static readonly name: string;
+    readonly manifestPath: string;
+    constructor(options: PluginInterface);
+    private configureOptions;
+    /**
+     * A stylesheet url() whose file exists nowhere in the project is a fatal
+     * "Module not found" to rspack's CSS parser, but Chrome applies the rest
+     * of the stylesheet and 404s the reference silently (wild:
+     * mozilla/contain-facebook ships url(/img/login_continue_*.png) with no
+     * such files anywhere — the extension is store-published and works).
+     * Cancel these requests before resolution and warn instead, mirroring the
+     * dead-HTML-ref policy; EXTENSION_STRICT_REFS=true keeps them fatal.
+     * Only unambiguous file refs are tolerated — '/x' (extension root),
+     * './x'/'../x' (issuer-relative), and bare paths with a non-CSS asset
+     * extension. Bare specifiers without one stay with the resolver so
+     * node_modules @imports keep failing loudly when genuinely broken.
+     */
+    private tolerateDeadUrlRefs;
+    apply(compiler: Compiler): Promise<void>;
+}

package/dist/plugin-css/preprocessor-passthrough-loader.d.ts

@@ -0,0 +1,6 @@
+interface PreprocessorPassthroughLoaderContext {
+    resourcePath: string;
+    emitWarning(warning: Error): void;
+}
+export default function preprocessorPassthroughLoader(this: PreprocessorPassthroughLoaderContext, source: string): string;
+export {};

package/dist/plugin-js-frameworks/frameworks-lib/integrations.d.ts

@@ -0,0 +1,4 @@
+import { hasDependency } from '../../lib/has-dependency';
+import { resolveDevelopInstallRoot } from '../../lib/develop-context';
+export { hasDependency, resolveDevelopInstallRoot };
+export declare function isUsingJSFramework(projectPath: string): boolean;

package/dist/plugin-js-frameworks/index.d.ts

@@ -0,0 +1,18 @@
+import { type Compiler } from '@rspack/core';
+import type { PluginInterface, DevOptions } from '../types';
+export declare class JsFrameworksPlugin {
+    static readonly name: string;
+    readonly manifestPath: string;
+    readonly browser: DevOptions['browser'];
+    readonly mode: DevOptions['mode'];
+    readonly transpilePackages: string[];
+    constructor(options: PluginInterface & {
+        mode: DevOptions['mode'];
+        transpilePackages?: string[];
+    });
+    private findVueLoaderRuleIndices;
+    private mergeVueRule;
+    private patchReactRefreshRules;
+    private configureOptions;
+    apply(compiler: Compiler): Promise<void>;
+}

package/dist/plugin-js-frameworks/js-frameworks-lib/load-loader-options.d.ts

@@ -0,0 +1,2 @@
+export declare function resolveLoaderConfigPath(projectPath: string, framework: 'vue' | 'svelte'): string | null;
+export declare function loadLoaderOptions(projectPath: string, framework: 'vue' | 'svelte'): Promise<any>;

package/dist/plugin-js-frameworks/js-frameworks-lib/messages.d.ts

@@ -0,0 +1,10 @@
+export declare function installingRootDependencies(integration: string): string;
+export declare function integrationInstalledSuccessfully(integration: string): string;
+export declare function isUsingIntegration(name: string): string;
+export declare function youAreAllSet(name: string): string;
+export declare function creatingTSConfig(): string;
+export declare function failedToInstallIntegration(integration: string, error: unknown): string;
+export declare function isUsingCustomLoader(loaderPath: string): string;
+export declare function jsFrameworksIntegrationsEnabled(integrations: string[]): string;
+export declare function jsFrameworksConfigsDetected(tsConfigPath?: string, tsRoot?: string, targets?: string[]): string;
+export declare function jsFrameworksHmrSummary(enabled: boolean, frameworks: string[]): string;

package/dist/plugin-js-frameworks/js-tools/preact.d.ts

@@ -0,0 +1,3 @@
+import { JsFramework } from '../../types';
+export declare function isUsingPreact(projectPath: string): boolean;
+export declare function maybeUsePreact(projectPath: string): Promise<JsFramework | undefined>;

package/dist/plugin-js-frameworks/js-tools/react.d.ts

@@ -0,0 +1,8 @@
+import { JsFramework } from '../../types';
+type MaybeUseReactOptions = {
+    refreshExclude?: unknown;
+    disableRefresh?: boolean;
+};
+export declare function isUsingReact(projectPath: string): boolean;
+export declare function maybeUseReact(projectPath: string, options?: MaybeUseReactOptions): Promise<JsFramework | undefined>;
+export {};

package/dist/plugin-js-frameworks/js-tools/svelte.d.ts

@@ -0,0 +1,4 @@
+import type { JsFramework } from '../../types';
+import type { DevOptions } from '../../types';
+export declare function isUsingSvelte(projectPath: string): boolean;
+export declare function maybeUseSvelte(projectPath: string, mode: DevOptions['mode']): Promise<JsFramework | undefined>;

package/dist/plugin-js-frameworks/js-tools/typescript.d.ts

@@ -0,0 +1,37 @@
+import { type DevOptions } from '../../types';
+export declare function isUsingTypeScript(projectPath: string): boolean;
+export declare function ensureTypeScriptConfig(projectPath: string): void;
+export declare function defaultTypeScriptConfig(projectPath: string, _opts?: any): {
+    compilerOptions: {
+        allowJs: boolean;
+        allowSyntheticDefaultImports: boolean;
+        esModuleInterop: boolean;
+        forceConsistentCasingInFileNames: boolean;
+        jsx: string;
+        lib: string[];
+        moduleResolution: string;
+        module: string;
+        resolveJsonModule: boolean;
+        strict: boolean;
+        target: string;
+        isolatedModules: boolean;
+        skipLibCheck: boolean;
+    };
+    exclude: string[];
+};
+export declare function getUserTypeScriptConfigFile(projectPath: string): string | undefined;
+export declare function getTypeScriptConfigOverrides(opts: {
+    mode: DevOptions['mode'];
+}): {
+    compilerOptions: {
+        sourceMap: boolean;
+        skipLibCheck: boolean;
+        inlineSourceMap: boolean;
+        declarationMap: boolean;
+        noEmit: boolean;
+        incremental: boolean;
+        tsBuildInfoFile: string;
+    };
+    exclude: string[];
+};
+export declare function maybeUseTypeScript(projectPath: string): Promise<boolean>;

package/dist/plugin-js-frameworks/js-tools/vue.d.ts

@@ -0,0 +1,3 @@
+import { JsFramework } from '../../types';
+export declare function isUsingVue(projectPath: string): boolean;
+export declare function maybeUseVue(projectPath: string, mode?: 'development' | 'production' | string): Promise<JsFramework | undefined>;

package/dist/plugin-perf-budgets/categorize.d.ts

@@ -0,0 +1,3 @@
+export type AssetCategory = 'content-script' | 'service-worker' | 'page' | 'ignored';
+export declare function categorizeAsset(rawName: string): AssetCategory;
+export declare const BUDGET_BYTES: Record<AssetCategory, number>;

package/dist/plugin-perf-budgets/index.d.ts

@@ -0,0 +1,34 @@
+import type { Compiler } from '@rspack/core';
+import { type AssetCategory } from './categorize';
+interface PerfBudgetsPluginOptions {
+    enabled?: boolean;
+    budgets?: Partial<Record<AssetCategory, number>>;
+}
+/**
+ * PerfBudgetsPlugin — extension-aware performance budgets.
+ *
+ * Replaces rspack's stock single-threshold `performance.hints` with a
+ * per-asset-category budget tuned to how browser extensions actually
+ * load code:
+ *
+ *   content_scripts/*    → 512 KiB  (injected on every navigation)
+ *   background / SW      → 512 KiB  (wakes from cold each session)
+ *   pages / sidebar / …  → 1 MiB    (opened on demand)
+ *   images, fonts, etc.  → silenced (not a code-splitting concern)
+ *
+ * Numbers are sized to clear realistic framework templates (React/Vue/
+ * Preact/Svelte + a design system) and still flag genuine outliers
+ * (multi-MiB AI sidebars, heavyweight WASM service workers). Override
+ * per-category via `perfBudgets` in `extension.config.{js,ts}`.
+ *
+ * Set `compiler.options.performance.hints = false` when this plugin is
+ * registered to avoid double-warnings.
+ */
+export declare class PerfBudgetsPlugin {
+    static readonly name = "plugin-perf-budgets";
+    private readonly options;
+    constructor(options?: PerfBudgetsPluginOptions);
+    apply(compiler: Compiler): void;
+}
+export { BUDGET_BYTES, categorizeAsset } from './categorize';
+export type { AssetCategory } from './categorize';

package/dist/plugin-perf-budgets/messages.d.ts

@@ -0,0 +1,8 @@
+import type { AssetCategory } from './categorize';
+export interface OversizedAsset {
+    name: string;
+    size: number;
+    budget: number;
+    category: AssetCategory;
+}
+export declare function perfBudgetWarning(assets: OversizedAsset[]): string;

package/dist/plugin-playwright/index.d.ts

@@ -0,0 +1,89 @@
+import { type Compiler } from '@rspack/core';
+import { type AbsolutePath } from '../lib/paths';
+export type PlaywrightAutomationCommand = 'dev' | 'start' | 'preview' | 'build';
+export type ReadyStatus = 'starting' | 'ready' | 'error';
+export type ReadyMetadata = {
+    schemaVersion: 2;
+    status: ReadyStatus;
+    command: PlaywrightAutomationCommand;
+    browser: string;
+    runId: string;
+    startedAt: string;
+    distPath: string;
+    manifestPath: string;
+    port: number | null;
+    host?: string;
+    pid: number;
+    ts: string;
+    compiledAt: string | null;
+    errors: string[];
+    code?: string;
+    message?: string;
+    instanceId?: string;
+    controlPort?: number | null;
+    controlPath?: string;
+    logsPath?: string;
+    cdpPort?: number;
+    toolchainVersion: string;
+    extensionName?: string;
+    extensionVersion?: string;
+    browserExitedAt?: string;
+    browserExitCode?: number | null;
+};
+export type PlaywrightAutomationEvent = {
+    type: 'compile_start' | 'compile_success' | 'compile_error' | 'shutdown';
+    ts: string;
+    command: PlaywrightAutomationCommand;
+    browser: string;
+    runId?: string;
+    durationMs?: number;
+    errorCount?: number;
+    errors?: string[];
+};
+type WriterOptions = {
+    packageJsonDir: string;
+    browser: string;
+    command: PlaywrightAutomationCommand;
+    distPath: string;
+    manifestPath: string;
+    port?: number | string | null;
+    host?: string;
+    instanceId?: string;
+    controlPort?: number | string | null;
+    controlPath?: string;
+    logsPath?: string;
+};
+type PluginOptions = {
+    packageJsonDir: string;
+    browser?: string;
+    mode?: 'development' | 'production' | 'none';
+    outputPath: string;
+    manifestPath: string;
+    port?: number | string | null;
+    host?: string;
+    command?: PlaywrightAutomationCommand;
+    instanceId?: string;
+    controlPort?: number | string | null;
+    controlPath?: string;
+    logsPath?: string;
+};
+export declare function formatStatsErrors(errors: unknown): string[];
+export declare function getPlaywrightMetadataDir(packageJsonDir: string, browser: string): AbsolutePath;
+export declare function createPlaywrightMetadataWriter(options: WriterOptions): {
+    metadataDir: AbsolutePath;
+    readyPath: AbsolutePath;
+    eventsPath: AbsolutePath;
+    writeStarting(): void;
+    writeReady(compiledAt?: string | null): void;
+    writeError(code: string, message: string, errors?: string[]): void;
+    appendEvent: (event: PlaywrightAutomationEvent) => void;
+};
+export declare class PlaywrightPlugin {
+    static readonly name = "plugin-playwright";
+    private readonly writer;
+    private readonly command;
+    private readonly browser;
+    constructor(options: PluginOptions);
+    apply(compiler: Compiler): void;
+}
+export {};

package/dist/plugin-reload/classify-reload.d.ts

@@ -0,0 +1,86 @@
+export type ReloadType = 'full' | 'service-worker' | 'content-scripts';
+export interface ReloadInstruction {
+    /**
+     * 'page' is a notify-only instruction: the extension itself is NOT reloaded
+     * (rspack-dev-server's livereload refreshes the open surface), but the
+     * signal still travels the bridge so every "Reloading…" surface (stdout,
+     * devtools pill) reflects it.
+     */
+    type: ReloadType | 'page';
+    changedContentScriptEntries?: string[];
+    changedAssets?: string[];
+    /**
+     * Human context label shared VERBATIM by every surface that announces this
+     * reload — CLI stdout, the page's devtools console line, and the devtools
+     * extension pill — so they can never disagree about what is reloading.
+     * e.g. "content_script (content/scripts.tsx)".
+     */
+    label?: string;
+}
+/** "context (fileA, fileB +2 more)" — the one label every reload surface shows. */
+export declare function formatReloadContextLabel(context: string, files: string[]): string;
+/**
+ * Best-effort page-context name for a page-only edit, mirroring the path
+ * heuristics used for the service-worker branch. Only used for the label —
+ * never for the reload decision.
+ */
+export declare function pageContextFromSources(changedSources: string[]): string;
+/**
+ * Which dev-reload feature owns each project source file, derived from the
+ * compilation's chunk graph. Name-pattern heuristics are NOT trustworthy for
+ * this decision: a service worker named `background-ultimate.js` fails the
+ * `background.`/`service-worker` patterns and would be re-injected as a
+ * content script (the SW then never restarts — the wild-corpus anshul bug).
+ */
+export interface SourceFeatureIndex {
+    /** Sources bundled into a background/* chunk (SW or MV2 scripts). */
+    swSources: Set<string>;
+    /** Source → canonical content_scripts entry names whose chunks contain it. */
+    contentEntriesBySource: Map<string, Set<string>>;
+    /** Sources bundled only into page chunks (popup/options/devtools/…). */
+    pageSources: Set<string>;
+}
+/**
+ * Walk the finished compilation and record, for every bundled source file,
+ * which reload feature its chunks belong to. Nameless (async) chunks are
+ * skipped — sources reached only through dynamic imports fall back to the
+ * name heuristics in {@link classifyReloadFromSources}.
+ */
+export declare function buildSourceFeatureIndex(compilation: any, contextDir: string): SourceFeatureIndex;
+/**
+ * Pure reload classifier shared by the launched-browser path (BrowsersPlugin,
+ * below) and the controller-less path (the dev server's `--no-browser` reload
+ * broadcast). Centralizing the decision keeps both paths converged: the same
+ * change always resolves to the same {@link ReloadType}, whether it is handed
+ * to the CDP controller or broadcast over the control bridge.
+ *
+ * Decision order per changed file:
+ *   1. manifest/_locales (forcedFull) → full reload.
+ *   2. Chunk-graph membership ({@link buildSourceFeatureIndex}): background
+ *      chunk → service-worker; content chunk → content-scripts (re-injecting
+ *      ONLY the entries whose chunks contain a changed file); page chunk →
+ *      notify-only page.
+ *   3. Emitted static asset (exists at the same relative path in the output
+ *      dir: manifest icons, web-accessible resources, DNR rulesets) → full
+ *      reload — the browser only re-reads those from disk on an extension
+ *      reload, and re-injecting content scripts for an icon edit is a storm
+ *      of no-ops (the wild-corpus Sappgulf bug).
+ *   4. Name heuristics, as before, for anything the graph can't see.
+ *
+ * The thunks keep the (cheap) index build and manifest read lazy — they only
+ * run when a classification actually needs them.
+ *
+ * Returns a notify-only `type: 'page'` instruction for page-only edits
+ * (popup/options/devtools/newtab HTML/CSS/JS) — those are delivered by
+ * rspack-dev-server's livereload broadcast, so firing an extension reload
+ * would race it and flash the open surface. The 'page' instruction only
+ * carries the announcement label; dispatch never reloads the extension for it.
+ */
+export declare function classifyReloadFromSources(opts: {
+    changedSources: string[];
+    forcedFull?: boolean;
+    getContentScriptCount: () => number;
+    getSourceFeatureIndex?: () => SourceFeatureIndex | null;
+    outputPath?: string;
+}): ReloadInstruction | undefined;
+export declare function readContentScriptCount(compilation: any, outputPath: string): number;