extension-develop 4.0.11 → 4.0.12

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

@@ -0,0 +1,29 @@
+import { type Compiler } from '@rspack/core';
+import type { PluginInterface, DevOptions } from '../types';
+export { type ReloadType, type ReloadInstruction, type SourceFeatureIndex, formatReloadContextLabel, pageContextFromSources, buildSourceFeatureIndex, classifyReloadFromSources, readContentScriptCount } from './classify-reload';
+export { type ChangedSourcesSnapshot, type ChangedSourcesTracker, createChangedSourcesTracker, dispatchReload, type ReloadBroker, type ReloadExecutor } from './reload-dispatch';
+/**
+ * ReloadPlugin owns the dev-only reload/HMR strategy end to end:
+ *
+ * - build-time injection of the reload runtime (SetupReloadStrategy and the
+ *   vendored webpack-target-webextension fork), the SW scripts-replay shim,
+ *   and the control-bridge producer/relay instrumentation
+ * - the reload classifier and dispatch seam consumed by plugin-browsers'
+ *   BrowsersPlugin and the dev server's `--no-browser` broadcast path
+ *   (re-exported above from classify-reload.ts / reload-dispatch.ts)
+ *
+ * Registration order matters: this plugin must be applied AFTER
+ * plugin-web-extension — SetupReloadStrategy decorates the background and
+ * content-script entries that feature-scripts' AddScripts declares.
+ *
+ * The whole pipeline is dev-only; `EXTENSION_NO_RELOAD=true` opts out. The
+ * every-mode content-script wrapper (mount lifecycle) is NOT part of this
+ * plugin — it lives in feature-scripts/steps/add-content-script-wrapper.
+ */
+export declare class ReloadPlugin {
+    static readonly name = "plugin-reload";
+    readonly manifestPath: string;
+    readonly browser?: DevOptions['browser'];
+    constructor(options: PluginInterface);
+    apply(compiler: Compiler): void;
+}

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

@@ -0,0 +1 @@
+export declare function backgroundIsRequiredMessageOnly(backgroundChunkName: string): string;

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

@@ -0,0 +1,46 @@
+import type { Compiler } from '@rspack/core';
+import type { ReloadInstruction } from './classify-reload';
+export interface ReloadBroker {
+    broadcastReload(instruction: {
+        type: ReloadInstruction['type'];
+        changedContentScriptEntries?: string[];
+        label?: string;
+        changedFiles?: string[];
+    }): number;
+}
+export interface ReloadExecutor {
+    broker?: ReloadBroker;
+}
+/**
+ * The one stdout announcement per dispatched reload. Prints the SAME label the
+ * producer echoes into the page's devtools console and the devtools-extension
+ * pill renders — one server-built string, three surfaces, zero drift.
+ */
+export declare function formatReloadingLine(label: string): string;
+/**
+ * The single place that decides HOW a classified reload is executed: the SW
+ * producer re-injects via the control bridge, the SAME mechanism for launched
+ * (Chromium + Firefox) and `--no-browser`. A launched browser's CDP/RDP
+ * controller is kept for logging / source inspection, not reload.
+ *
+ * Both modes already share the reload DECISION (classifyReloadFromSources); this
+ * is the shared dispatch seam. Honors EXTENSION_NO_RELOAD (emit the new dist,
+ * but don't reload).
+ */
+export declare function dispatchReload(instruction: ReloadInstruction | undefined, executor: ReloadExecutor): Promise<void>;
+export interface ChangedSourcesSnapshot {
+    /** A manifest.json / _locales change — forces a full reload regardless of which other files changed. */
+    forcedFull: boolean;
+    /** Project-relative, forward-slashed paths of every file changed since the last compile. */
+    changedSources: string[];
+}
+export interface ChangedSourcesTracker {
+    snapshot(): ChangedSourcesSnapshot;
+}
+/**
+ * Taps `watchRun` and records the files changed for the next compile, shared by
+ * the launched (BrowsersPlugin) and `--no-browser` (dev server) reload paths so
+ * the collection logic isn't duplicated. Read it in the `done` hook via
+ * `snapshot()` and feed it to classifyReloadFromSources.
+ */
+export declare function createChangedSourcesTracker(compiler: Compiler): ChangedSourcesTracker;

package/dist/plugin-reload/reload-lib/scripts-replay-shim.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Dev-only banner prepended to the background service worker / script. Wraps
+ * `chrome.scripting.executeScript` so the SDK can replay the same programmatic
+ * injections after a user edits a file in `/scripts/*`.
+ *
+ * Without this, editing `/scripts/script-one.js` rebuilds the bundle on disk
+ * but the previously-injected DOM stays stale until the user manually
+ * re-triggers whatever called `executeScript`. With this shim plus the
+ * controller-side trigger, `/scripts/*` edits behave like declarative
+ * `content_scripts` edits: the SDK re-executes the same injection on the
+ * same tab, and the wrapper around each `/scripts/<name>.js` (which runs
+ * via `__EXTENSIONJS_mount`) handles old-mount teardown.
+ *
+ * Storage: in-memory `Map` keyed by tabId. Lives on the SW's globalThis, so
+ * it survives across multiple `executeScript` calls in the same SW lifetime
+ * and dies when Chrome cycles the SW. That's fine for dev — the next click
+ * after a SW restart re-records the call.
+ */
+export declare const SCRIPTS_REPLAY_SHIM_SOURCE = ";(function () {\n  try {\n    if (typeof globalThis !== \"object\" || !globalThis) return;\n    var chromeRef =\n      (globalThis.chrome && globalThis.chrome.scripting && typeof globalThis.chrome.scripting.executeScript === \"function\")\n        ? globalThis.chrome\n        : (globalThis.browser && globalThis.browser.scripting && typeof globalThis.browser.scripting.executeScript === \"function\")\n          ? globalThis.browser\n          : null;\n    if (!chromeRef) return;\n    if (globalThis.__extjsScriptsReplayInstalled) return;\n    globalThis.__extjsScriptsReplayInstalled = true;\n\n    var registry = new Map();\n    var originalExecuteScript = chromeRef.scripting.executeScript.bind(chromeRef.scripting);\n\n    var serialize = function (entry) {\n      try {\n        return JSON.stringify({\n          files: entry && Array.isArray(entry.files) ? entry.files : [],\n          world: entry && entry.world ? String(entry.world) : \"\"\n        });\n      } catch (error) {\n        return \"\";\n      }\n    };\n\n    var track = function (injection) {\n      try {\n        var tabId = injection && injection.target && injection.target.tabId;\n        var files =\n          injection && Array.isArray(injection.files) ? injection.files.slice() : null;\n        if (typeof tabId !== \"number\") return;\n        if (!files || !files.length) return;\n        var world = injection.world ? String(injection.world) : undefined;\n        var entry = { files: files, world: world, sig: serialize({ files: files, world: world }) };\n        var existing = registry.get(tabId) || [];\n        // Dedupe by signature \u2014 repeated identical injections (e.g. user\n        // clicks the action twice) shouldn't stack in the replay list.\n        if (existing.some(function (e) { return e.sig === entry.sig; })) return;\n        existing.push(entry);\n        // Cap to the most recent 50 distinct injections per tab so a misbehaving\n        // user loop can't grow the registry unbounded.\n        registry.set(tabId, existing.slice(-50));\n      } catch (error) {\n        // Tracking is best-effort; never break the user's executeScript call.\n      }\n    };\n\n    chromeRef.scripting.executeScript = function (injection, callback) {\n      track(injection);\n      return originalExecuteScript(injection, callback);\n    };\n\n    var normalizeFile = function (value) {\n      return String(value || \"\").replace(/^[/\\\\]+/, \"\");\n    };\n\n    var fileMatches = function (entryFile, changedNormalized) {\n      var fn = normalizeFile(entryFile);\n      for (var i = 0; i < changedNormalized.length; i++) {\n        var c = changedNormalized[i];\n        if (!c) continue;\n        if (fn === c) return true;\n        if (fn.length > c.length && fn.slice(fn.length - c.length - 1) === \"/\" + c) return true;\n        if (c.length > fn.length && c.slice(c.length - fn.length - 1) === \"/\" + fn) return true;\n      }\n      return false;\n    };\n\n    globalThis.__extjsScriptsReplay = function (changedFiles) {\n      var changedNormalized = (Array.isArray(changedFiles) ? changedFiles : []).map(normalizeFile);\n      var promises = [];\n      registry.forEach(function (entries, tabId) {\n        entries.forEach(function (entry) {\n          var matches = false;\n          for (var i = 0; i < entry.files.length; i++) {\n            if (fileMatches(entry.files[i], changedNormalized)) {\n              matches = true;\n              break;\n            }\n          }\n          if (!matches) return;\n          try {\n            promises.push(\n              originalExecuteScript({\n                target: { tabId: tabId },\n                files: entry.files,\n                world: entry.world\n              }).then(\n                function () { return { ok: true, tabId: tabId, files: entry.files }; },\n                function (error) {\n                  return {\n                    ok: false,\n                    tabId: tabId,\n                    files: entry.files,\n                    error: String((error && error.message) || error)\n                  };\n                }\n              )\n            );\n          } catch (error) {\n            // Tab may have closed; skip silently.\n          }\n        });\n      });\n      return Promise.all(promises);\n    };\n  } catch (error) {\n    // Best-effort shim; do not break the SW bootstrap on any failure.\n  }\n})();\n";

package/dist/plugin-reload/steps/inject-bridge-producer.d.ts

@@ -0,0 +1,14 @@
+import { type Compiler } from '@rspack/core';
+/**
+ * Prepends the agent-bridge producer to the compiled background SW so the
+ * user extension forwards its console output to the dev-server control WS
+ * (agent bridge). The control port + instanceId are read from process.env
+ * (set by dev-server/index.ts); when the bridge is unavailable the builder
+ * returns '' and nothing is injected.
+ *
+ * Mirrors InjectScriptsReplayShim: a late processAssets post-process that only
+ * touches the background entry, independent of banner-emission ordering.
+ */
+export declare class InjectBridgeProducer {
+    apply(compiler: Compiler): void;
+}

package/dist/plugin-reload/steps/inject-bridge-relay.d.ts

@@ -0,0 +1,4 @@
+import { type Compiler } from '@rspack/core';
+export declare class InjectBridgeRelay {
+    apply(compiler: Compiler): void;
+}

package/dist/plugin-reload/steps/inject-scripts-replay-shim.d.ts

@@ -0,0 +1,10 @@
+import { type Compiler } from '@rspack/core';
+/**
+ * Prepends the dev-only `globalThis.__extjsScriptsReplay` shim to the
+ * compiled background SW / script. Done as a `processAssets` post-process
+ * rather than via BannerPlugin so we only touch the background entry asset
+ * regardless of the bundler's banner-emission ordering.
+ */
+export declare class InjectScriptsReplayShim {
+    apply(compiler: Compiler): void;
+}

package/dist/plugin-reload/steps/prune-stale-hot-updates.d.ts

@@ -0,0 +1,20 @@
+import { type Compiler } from '@rspack/core';
+/**
+ * Prune superseded hot-update generations from `dist/<browser>/hot/`.
+ *
+ * The HMR runtime resolves hot chunks against the extension origin
+ * (publicPath = chrome-extension://<id>/), so the files under hot/ are
+ * fetched FROM DISK and must ship in the loadable dist — but only the
+ * current generation is ever requested (currentHash -> nextHash). Without
+ * pruning, every edit leaves its .js/.json/.map generation behind forever:
+ * an afternoon of editing puts hundreds of stale files in the "what ships"
+ * tree, all churning fs watchers on each edit.
+ *
+ * The previous generation is kept one round as a grace window for an
+ * in-flight fetch racing the compile that superseded it.
+ */
+export declare class PruneStaleHotUpdates {
+    static readonly name = "plugin-reload:prune-stale-hot-updates";
+    private previousGeneration;
+    apply(compiler: Compiler): void;
+}

package/dist/plugin-reload/steps/remove-content-script-dev-server-runtime.d.ts

@@ -0,0 +1,2 @@
+export declare function contentScriptRetainsDevServerRuntime(source: string): boolean;
+export declare function stripDevServerStartupFromContentScript(source: string): string;

package/dist/plugin-reload/steps/setup-reload-strategy/index.d.ts

@@ -0,0 +1,9 @@
+import { type Compiler } from '@rspack/core';
+import type { PluginInterface } from '../../../types';
+export declare class SetupReloadStrategy {
+    private readonly manifestPath;
+    private readonly browser;
+    constructor(options: PluginInterface);
+    private getEntryName;
+    apply(compiler: Compiler): void;
+}

package/dist/plugin-reload/steps/setup-reload-strategy/setup-background-entry.d.ts

@@ -0,0 +1,13 @@
+import { Compiler } from '@rspack/core';
+import { type DevOptions } from '../../../types';
+export declare class SetupBackgroundEntry {
+    private manifestPath;
+    private browser;
+    constructor(options: {
+        manifestPath: string;
+        browser?: DevOptions['browser'];
+    });
+    private getMissingBackgroundError;
+    private addDefaultEntry;
+    apply(compiler: Compiler): void;
+}

package/dist/plugin-reload/steps/setup-reload-strategy/webpack-target-webextension-fork/index.d.ts

@@ -0,0 +1,2 @@
+import WebExtensionPlugin from './lib/webpack5/index';
+export default WebExtensionPlugin;

package/dist/plugin-reload/steps/setup-reload-strategy/webpack-target-webextension-fork/lib/webpack5/ChunkLoader.d.ts

@@ -0,0 +1,9 @@
+export default class WebExtensionChuckLoaderRuntimePlugin {
+    private readonly pluginOptions;
+    private readonly options;
+    private readonly contentScriptsMeta;
+    private rspackAutoPublicPath;
+    constructor(options: any);
+    apply(compiler: any): void;
+    tap(compiler: any, compilation: any): void;
+}

package/dist/plugin-reload/steps/setup-reload-strategy/webpack-target-webextension-fork/lib/webpack5/HMRDevServer.d.ts

@@ -0,0 +1,3 @@
+export default class DevServerConfigPlugin {
+    apply(compiler: any): void;
+}

package/dist/plugin-reload/steps/setup-reload-strategy/webpack-target-webextension-fork/lib/webpack5/InitialChunkFile.d.ts

@@ -0,0 +1,5 @@
+export default class WebExtensionContentScriptEntryPlugin {
+    private readonly options;
+    constructor(options: any);
+    apply(compiler: any): void;
+}

package/dist/plugin-reload/steps/setup-reload-strategy/webpack-target-webextension-fork/lib/webpack5/NoDangerNamePlugin.d.ts

@@ -0,0 +1,3 @@
+export default class NoDangerNamePlugin {
+    apply(compiler: any): void;
+}

package/dist/plugin-reload/steps/setup-reload-strategy/webpack-target-webextension-fork/lib/webpack5/RuntimeModules/AutoPublicPath.d.ts

@@ -0,0 +1,2 @@
+import type * as webpack from 'webpack';
+export default function AutoPublicPathRuntimeModule(webpack: typeof import('webpack')): webpack.RuntimeModule;

package/dist/plugin-reload/steps/setup-reload-strategy/webpack-target-webextension-fork/lib/webpack5/RuntimeModules/BaseUri.d.ts

@@ -0,0 +1,2 @@
+import type * as webpack from 'webpack';
+export default function BaseUriRuntimeModule(webpack: typeof import('webpack')): webpack.RuntimeModule;

package/dist/plugin-reload/steps/setup-reload-strategy/webpack-target-webextension-fork/lib/webpack5/RuntimeModules/BrowserRuntime.d.ts

@@ -0,0 +1,8 @@
+import type * as webpack from 'webpack';
+export declare const RuntimeGlobal = "__webpack_require__.webExtRt";
+export declare const RuntimeGlobalIsBrowser = "__webpack_require__.webExtRtModern";
+/**
+ * @param webpack webpack instance
+ * @param acceptWeak if accept weak runtime check
+ */
+export default function BrowserRuntimeModule(webpack: typeof import('webpack'), acceptWeak: boolean): webpack.RuntimeModule;

package/dist/plugin-reload/steps/setup-reload-strategy/webpack-target-webextension-fork/lib/webpack5/RuntimeModules/ChunkLoaderFallback.d.ts

@@ -0,0 +1 @@
+export default function ChunkLoaderFallbackRuntimeModule(webpack: typeof import('webpack')): import('webpack').RuntimeModule;

package/dist/plugin-reload/steps/setup-reload-strategy/webpack-target-webextension-fork/lib/webpack5/RuntimeModules/EagerlyLoadChunks.d.ts

@@ -0,0 +1 @@
+export default function createEagerlyLoadChunksRuntimeModule(webpack: typeof import('webpack')): any;

package/dist/plugin-reload/steps/setup-reload-strategy/webpack-target-webextension-fork/lib/webpack5/RuntimeModules/LoadScript.d.ts

@@ -0,0 +1,4 @@
+export default function LoadScriptRuntimeModule(webpack: typeof import('webpack'), supportDynamicImport: boolean | undefined, classicLoaderEnabled: boolean | undefined, contentScriptsMeta?: Record<string, {
+    world?: 'main' | 'extension';
+    bridgeBundleId?: string;
+}>): import('webpack').RuntimeModule;

package/dist/plugin-reload/steps/setup-reload-strategy/webpack-target-webextension-fork/lib/webpack5/RuntimeModules/PublicPath.d.ts

@@ -0,0 +1,2 @@
+import type * as webpack from 'webpack';
+export default function PublicPathRuntimeModule(webpack: typeof import('webpack')): webpack.RuntimeModule;

package/dist/plugin-reload/steps/setup-reload-strategy/webpack-target-webextension-fork/lib/webpack5/ServiceWorkerPlugin.d.ts

@@ -0,0 +1,6 @@
+export default class WebExtensionServiceWorkerEntryPlugin {
+    private readonly options;
+    private readonly backgroundOutputEmitted;
+    constructor(options: any, backgroundOutputEmitted: boolean);
+    apply(compiler: any): void;
+}

package/dist/plugin-reload/steps/setup-reload-strategy/webpack-target-webextension-fork/lib/webpack5/helper.d.ts

@@ -0,0 +1,12 @@
+export type TemplateLike = {
+    asString: (chunks: any) => string;
+    indent: (lines: any) => string;
+};
+/**
+ * @param compilation webpack/rspack compilation
+ * @param Template webpack Template
+ */
+export declare function TemplateFn(compilation: any, Template: TemplateLike): {
+    f: (args: string, body: string | string[]) => any;
+    retF: (returnValue: string, args?: string) => any;
+};

package/dist/plugin-reload/steps/setup-reload-strategy/webpack-target-webextension-fork/lib/webpack5/index.d.ts

@@ -0,0 +1,5 @@
+export default class WebExtensionPlugin {
+    private readonly options;
+    constructor(options?: any);
+    apply(compiler: any): void;
+}

package/dist/plugin-reload/steps/strip-content-script-dev-server-runtime.d.ts

@@ -0,0 +1,4 @@
+import { type Compiler } from '@rspack/core';
+export declare class StripContentScriptDevServerRuntime {
+    apply(compiler: Compiler): void;
+}

package/dist/plugin-special-folders/check-manifest-in-public.d.ts

@@ -0,0 +1,2 @@
+import { Compilation } from '@rspack/core';
+export declare function checkManifestInPublic(compilation: Compilation, publicDir: string): void;

package/dist/plugin-special-folders/emit-root-absolute-refs.d.ts

@@ -0,0 +1,2 @@
+import { type Compilation } from '@rspack/core';
+export declare function emitRootAbsoluteRefs(compilation: Compilation, context: string, publicDir: string): void;

package/dist/plugin-special-folders/folder-extensions/resolve-config.d.ts

@@ -0,0 +1,6 @@
+import type { CompanionExtensionsConfig } from './types';
+export declare function resolveCompanionExtensionsConfig(opts: {
+    projectRoot: string;
+    browser: string;
+    config?: CompanionExtensionsConfig;
+}): Promise<CompanionExtensionsConfig | undefined>;

package/dist/plugin-special-folders/folder-extensions/resolve-dirs.d.ts

@@ -0,0 +1,5 @@
+import type { CompanionExtensionsConfig } from './types';
+export declare function resolveCompanionExtensionDirs(opts: {
+    projectRoot: string;
+    config?: CompanionExtensionsConfig;
+}): string[];

package/dist/plugin-special-folders/folder-extensions/types.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Companion extensions are "load-only" unpacked extension directories that
+ * should be loaded alongside the user extension in dev/preview/start.
+ *
+ * Each directory MUST be an unpacked extension root containing a manifest.json.
+ */
+export type CompanionExtensionsConfig = string[] | {
+    /**
+     * Folder to scan for subfolders that contain a manifest.json.
+     * Example: "./extensions" -> loads "./extensions/*" (one level deep)
+     */
+    dir?: string;
+    /**
+     * Explicit extension directories to load (absolute or relative to projectRoot).
+     */
+    paths?: string[];
+};

package/dist/plugin-special-folders/folder-extensions/utils.d.ts

@@ -0,0 +1,9 @@
+import type { CompanionExtensionsConfig } from './types';
+export declare function isDir(p: string): boolean;
+export declare function isFile(p: string): boolean;
+export declare function toAbs(projectRoot: string, p: string): string;
+export declare function isValidExtensionRoot(dir: string): boolean;
+export declare function normalizeCompanionConfig(config?: CompanionExtensionsConfig): {
+    dir?: string;
+    paths: string[];
+};

package/dist/plugin-special-folders/get-data.d.ts

@@ -0,0 +1,12 @@
+import { type Compiler } from '@rspack/core';
+import { getSpecialFoldersData } from 'browser-extension-manifest-fields';
+import { type FilepathList } from '../types';
+import { type CompanionExtensionsConfig } from './folder-extensions/types';
+export declare function getSpecialFoldersDataForCompiler(compiler: Compiler): SpecialFoldersData;
+export declare function getSpecialFoldersDataForProjectRoot(projectRoot: string): SpecialFoldersData;
+type SpecialFoldersData = Omit<ReturnType<typeof getSpecialFoldersData>, 'pages' | 'scripts'> & {
+    pages?: FilepathList;
+    scripts?: FilepathList;
+    extensions?: CompanionExtensionsConfig;
+};
+export {};

package/dist/plugin-special-folders/index.d.ts

@@ -0,0 +1,20 @@
+import { type Compiler } from '@rspack/core';
+interface SpecialFoldersPluginOptions {
+    manifestPath: string;
+}
+/**
+ * SpecialFoldersPlugin is responsible for handling the
+ * special folders in the extension:
+ *
+ * - /pages - HTML pages not included in the manifest
+ * - /scripts - Script files not included in the manifest
+ * - /public - Static files not included in the manifest
+ * - /extensions - Load-only companion extensions (unpacked)
+ */
+export declare class SpecialFoldersPlugin {
+    static readonly name: string;
+    private readonly options;
+    constructor(options: SpecialFoldersPluginOptions);
+    apply(compiler: Compiler): void;
+}
+export {};

package/dist/plugin-special-folders/messages.d.ts

@@ -0,0 +1,3 @@
+export declare function serverRestartRequiredFromSpecialFolderMessageOnly(addingOrRemoving: string, folder: string, typeOfAsset: string): string;
+export declare function specialFoldersSetupSummary(hasPublic: boolean, copyEnabled: boolean, ignoredCount: number): string;
+export declare function specialFolderChangeDetected(action: 'add' | 'remove', folder: 'pages' | 'scripts', relativePath: string): string;

package/dist/plugin-special-folders/warn-upon-folder-changes.d.ts

@@ -0,0 +1,13 @@
+import { type Compiler } from '@rspack/core';
+export declare class WarnUponFolderChanges {
+    private pendingChanges;
+    private knownFolderFiles;
+    private hasSnapshot;
+    private snapshotFolderFiles;
+    private getContextDependencyPaths;
+    private throwCompilationError;
+    private trackChange;
+    private collectChanges;
+    private applyPendingChanges;
+    apply(compiler: Compiler): void;
+}

package/dist/plugin-static-assets/index.d.ts

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

package/dist/plugin-static-assets/static-assets-lib/messages.d.ts

@@ -0,0 +1,8 @@
+export declare function assetsRulesEnabled(rules: string[]): string;
+export declare function assetsConfigsDetected(filenamePattern: string, svgRuleMode: 'default' | 'custom', svgInlineLimitKB?: number, imageInlineLimitKB?: number, fileInlineLimitKB?: number): string;
+export declare function assetsEmittedSummary(total: number, byCategory: {
+    svg: number;
+    images: number;
+    fonts: number;
+    files: number;
+}): string;

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

@@ -0,0 +1,15 @@
+import { type Compiler } from '@rspack/core';
+import type { PluginInterface, DevOptions } from '../types';
+export declare class WasmPlugin {
+    static readonly name: string;
+    readonly manifestPath: string;
+    readonly mode: DevOptions['mode'];
+    constructor(options: PluginInterface & {
+        mode: DevOptions['mode'];
+    });
+    private resolveAssetPath;
+    private buildAssetAliases;
+    private ensureWasmResolution;
+    private ensureWasmExperiments;
+    apply(compiler: Compiler): void;
+}

package/dist/plugin-web-extension/feature-html/html-lib/assets.d.ts

@@ -0,0 +1,2 @@
+import { type FilepathList } from '../../../types';
+export declare function handleStaticAsset(compilation: any, htmlEntry: string, htmlDir: string, absolutePath: string, assetType: 'staticSrc' | 'staticHref', cleanPath: string, search: string | undefined, hash: string | undefined, baseHref: string | undefined, includeList: FilepathList, extname: string, childNode: any): any;

package/dist/plugin-web-extension/feature-html/html-lib/inject.d.ts

@@ -0,0 +1,4 @@
+export declare function injectJsScript(bodyNode: any, feature: string, firstScriptAttrs?: Array<{
+    name: string;
+    value: string;
+}>): void;

package/dist/plugin-web-extension/feature-html/html-lib/messages.d.ts

@@ -0,0 +1,24 @@
+export declare function javaScriptError(errorSourcePath: string, missingFilePath: string, opts?: {
+    publicRootHint?: boolean;
+    deadRefHint?: boolean;
+}): string;
+export declare function cssError(errorSourcePath: string, missingFilePath: string, opts?: {
+    publicRootHint?: boolean;
+    deadRefHint?: boolean;
+}): string;
+export declare function staticAssetError(errorSourcePath: string, missingFilePath: string, opts?: {
+    publicRootHint?: boolean;
+    refLabel?: string;
+    deadRefHint?: boolean;
+}): string;
+export declare function fileNotFound(errorSourcePath: string | undefined, missingFilePath: string, opts?: {
+    publicRootHint?: boolean;
+    refLabel?: string;
+    deadRefHint?: boolean;
+}): string;
+export declare function htmlFileNotFoundMessageOnly(context?: 'script' | 'style' | 'static'): string;
+export declare function remoteResourceWarning(errorSourcePath: string, remoteUrl: string, kind: 'script' | 'style'): string;
+export declare function serverRestartRequiredFromHtml(relativeHtmlPath: string, absoluteHtmlPath: string): string;
+export declare function manifestHtmlEntrypointChange(manifestField?: string, pathAfter?: string, pathBefore?: string): string;
+export declare function manifestPageMissing(manifestField: string, missingFilePath: string): string;
+export declare function manifestFieldMessageOnly(manifestField: string): string;

package/dist/plugin-web-extension/feature-html/html-lib/parse-html.d.ts

@@ -0,0 +1,8 @@
+import * as parse5utilities from 'parse5-utilities';
+interface OnResourceFoundOptions {
+    filePath: string;
+    childNode: ReturnType<typeof parse5utilities.createNode>;
+    assetType: 'script' | 'css' | 'staticSrc' | 'staticHref';
+}
+export declare function parseHtml(node: ReturnType<typeof parse5utilities.createNode>, onResourceFound: (options: OnResourceFoundOptions) => void): void;
+export {};

package/dist/plugin-web-extension/feature-html/html-lib/patch-html.d.ts

@@ -0,0 +1,8 @@
+import { type Compilation } from '@rspack/core';
+import { type FilepathList } from '../../../types';
+export declare function patchHtml(compilation: Compilation, feature: string, htmlEntry: string, includeList: FilepathList): string;
+/**
+ * Patches a nested HTML: preserve original script/link tags,
+ * only rewrite static assets, and warn about missing public-root assets.
+ */
+export declare function patchHtmlNested(compilation: Compilation, htmlEntry: string): string;

package/dist/plugin-web-extension/feature-html/html-lib/utils.d.ts

@@ -0,0 +1,46 @@
+import { type FilepathList } from '../../../types';
+export interface ParsedHtmlAsset {
+    css?: string[];
+    js?: string[];
+    moduleJs?: string[];
+    static?: string[];
+}
+export declare function getAssetsFromHtml(htmlFilePath: string | undefined, htmlContent?: string, publicPath?: string): ParsedHtmlAsset;
+export declare function getHtmlPageDeclaredAssetPath(filepathList: FilepathList, filePath: string, extension: string): string;
+export declare function getExtname(filePath: string): string;
+export declare function getFilePath(filePath: string, extension: string, isPublic: boolean): string;
+export declare function isFromIncludeList(filePath: string, includeList?: FilepathList): boolean;
+export declare function isUrl(src: string): boolean;
+export declare function cleanAssetUrl(url: string): {
+    cleanPath: string;
+    hash: string;
+    search: string;
+};
+export declare function isHttpLike(inputUrl: string): boolean;
+export declare function isSpecialScheme(u: string): boolean;
+export declare function cleanLeading(s: string): string;
+/**
+ * Join an emitted-asset name from a prefix and an HTML-relative walk, clamped
+ * the way Chrome resolves the matching URL: `..` segments cannot climb above
+ * the extension root, so leading `..` left after the join are dropped. Without
+ * the clamp, an asset referenced from a nested page (`../../../assets/x.png`
+ * from `adapters/chrome/popup/popup.html`) produces the asset NAME
+ * `../../assets/x.png` — the dev middleware then writes it OUTSIDE the output
+ * dir, on top of the source file, and the watcher loops on its own emit
+ * forever (the wild-corpus Sappgulf storm).
+ */
+export declare function joinEmittedAssetName(prefix: string, rel: string): string;
+export declare function computePosixRelative(fromPath: string, toPath: string): string;
+export declare function resolveAbsoluteFsPath(params: {
+    asset: string;
+    projectRoot: string;
+    publicRootForResource: string;
+    outputRoot: string;
+    /** Manifest dir: Chrome resolves root URLs (/pages/x.html) against it. */
+    manifestRoot?: string;
+}): {
+    absoluteFsPath: string;
+    isUnderPublicRoot: boolean;
+    isRootUrl: boolean;
+};
+export declare function getBaseHref(htmlDocument: any): string | undefined;

package/dist/plugin-web-extension/feature-html/index.d.ts

@@ -0,0 +1,36 @@
+import { type Compiler } from '@rspack/core';
+import type { FilepathList, PluginInterface } from '../../types';
+/**
+ * HtmlPlugin is responsible for handling the HTML file
+ * defined in the manifest.json. Static assets and CSS files
+ * within the HTML file are added to the compilation. JS files
+ * are added as webpack entrypoints. It also supports ecxtra
+ * html files defined via this.include option. These extra
+ * html files are added to the compilation and are also HMR
+ * enabled. They are useful for adding extra pages to the
+ * extension runtime that are not defined in manifest.
+ *
+ * The plugin also has a guard against recompiling entrypoints
+ * at runtime, throwing an error if any of those files change.
+ *
+ * Features supported:
+ * action.default_popup - HMR enabled
+ * background.page - HMR enabled
+ * chrome_settings_overrides.homepage - HMR enabled
+ * chrome_url_overrides.newtab - HMR enabled
+ * chrome_url_overrides.history - HMR enabled
+ * chrome_url_overrides.bookmarks - HMR enabled
+ * devtools_page - HMR enabled
+ * options_ui.page - HMR enabled
+ * page_action.default_popup - HMR enabled
+ * sandbox.page - HMR enabled
+ * side_panel.default_panel - HMR enabled
+ * sidebar_action.default_panel - HMR enabled
+ */
+export declare class HtmlPlugin {
+    readonly manifestPath: string;
+    readonly includeList?: FilepathList;
+    private readonly browser;
+    constructor(options: PluginInterface);
+    apply(compiler: Compiler): void;
+}

package/dist/plugin-web-extension/feature-html/steps/add-assets-to-compilation.d.ts

@@ -0,0 +1,9 @@
+import { type Compiler } from '@rspack/core';
+import { type FilepathList, type PluginInterface } from '../../../types';
+export declare class AddAssetsToCompilation {
+    readonly manifestPath: string;
+    readonly includeList?: FilepathList;
+    readonly browser?: string;
+    constructor(options: PluginInterface);
+    apply(compiler: Compiler): void;
+}

package/dist/plugin-web-extension/feature-html/steps/add-scripts-and-styles-to-compilation.d.ts

@@ -0,0 +1,9 @@
+import { type Compiler } from '@rspack/core';
+import { type FilepathList, type PluginInterface } from '../../../types';
+export declare class AddScriptsAndStylesToCompilation {
+    readonly manifestPath: string;
+    readonly includeList?: FilepathList;
+    readonly browser?: string;
+    constructor(options: PluginInterface);
+    apply(compiler: Compiler): void;
+}

package/dist/plugin-web-extension/feature-html/steps/add-to-file-dependencies.d.ts

@@ -0,0 +1,9 @@
+import { type Compiler } from '@rspack/core';
+import { type FilepathList, type PluginInterface } from '../../../types';
+export declare class AddToFileDependencies {
+    readonly manifestPath: string;
+    readonly includeList?: FilepathList;
+    readonly browser?: string;
+    constructor(options: PluginInterface);
+    apply(compiler: Compiler): void;
+}