extension-develop 4.1.20 → 4.1.22

package/dist/950~0.mjs

@@ -1,10 +1,11 @@
 import { createRequire as __extjsCreateRequire } from "node:module"; const require = __extjsCreateRequire(import.meta.url);
 import pintor from "pintor";
 import { spawnSync } from "node:child_process";
-import { fmt, isDebug, artifactNoun, prefix as messaging_prefix } from "./852~0.mjs";
+import { fmt, isDebug, artifactNoun, prefix as messaging_prefix, hasChannelPrefix } from "./852~0.mjs";
 import { findNearestDenoConfigSync, validateDenoConfig, PROJECT_MANIFEST_FILENAMES, parseJsonSafe, readProjectDependencies } from "./731~0.mjs";
 import * as __rspack_external_node_path_806ed179 from "node:path";
 import * as __rspack_external_node_fs_1b05aee1 from "node:fs";
+import * as __rspack_external_node_os_4f3c9d58 from "node:os";
 function getLoggingPrefix(type) {
     return messaging_prefix(type);
 }
@@ -102,10 +103,17 @@ function addonLintSummary(errorCount, warningCount, distDisplay) {
     if (warningCount > 0) parts.push(pluralize(warningCount, 'warning'));
     return `${getLoggingPrefix('warn')} Store check for addons.mozilla.org: addons-linter found ${parts.join(' and ')} in ${pintor.underline(distDisplay)}`;
 }
-function addonLintFinding(level, code, message, location) {
+function addonLintFinding(level, code, message, location, attribution) {
     const glyph = getLoggingPrefix('error' === level ? 'warn' : 'info');
     const where = location ? ` ${pintor.gray(`(${location})`)}` : '';
-    return `${glyph} AMO ${level} ${pintor.yellow(code)}: ${message}${where}`;
+    const from = attribution ? ` ${pintor.gray(attribution)}` : '';
+    return `${glyph} AMO ${level} ${pintor.yellow(code)}: ${message}${where}${from}`;
+}
+function addonLintDependencyAttribution(packages, onlyDependencies) {
+    if (0 === packages.length) return '';
+    const named = packages.slice(0, 3).join(', ');
+    const rest = packages.length > 3 ? `, +${packages.length - 3} more` : '';
+    return onlyDependencies ? `- this file is bundled dependency code (${named}${rest}), not yours` : `- this file also bundles ${named}${rest}, so the finding may be theirs`;
 }
 function addonLintMore(hiddenCount, distDisplay) {
     return `${getLoggingPrefix('info')} ${pluralize(hiddenCount, 'more finding')} not shown. Run ${pintor.blue(`npx addons-linter ${distDisplay}`)} for the full report.`;
@@ -129,16 +137,22 @@ function buildFailed(errorCount) {
 function stripModuleWarningWrapper(message) {
     return message.replace(/^Module (?:Warning|Error) \(from [^)]*\):\s*/, '');
 }
+function stripBundlerDecoration(message) {
+    return message.replace(/\r/g, '').split('\n').map((line, index)=>0 === index ? line.replace(/^\s*⚠ ?/, '') : line.replace(/^\s*│ ?/, '')).join('\n').trim();
+}
+function cleanWarningText(message) {
+    return stripModuleWarningWrapper(stripBundlerDecoration(message));
+}
 function getWarningMessage(warning) {
     if (!warning) return '';
-    if ('string' == typeof warning) return stripModuleWarningWrapper(warning.trim());
+    if ('string' == typeof warning) return cleanWarningText(warning);
     const candidates = [
         warning.message,
         warning.details,
         warning.reason,
         warning.description
     ];
-    for (const candidate of candidates)if ('string' == typeof candidate && candidate.trim()) return stripModuleWarningWrapper(candidate.trim());
+    for (const candidate of candidates)if ('string' == typeof candidate && candidate.trim()) return cleanWarningText(candidate);
     return '';
 }
 function getWarningSource(warning) {
@@ -192,23 +206,17 @@ function buildWarningsDetails(warnings) {
         if (!message) return void blocks.push(`${getLoggingPrefix('warn')} Warning ${index + 1}: details were suppressed by tool output.\n${formatWarningLabelLine('Source', pintor.gray(source))}\n${formatWarningLabelLine('Hint', 'Re-run with EXTENSION_VERBOSE=1 to inspect full warning messages.')}`);
         const performanceWarning = parsePerformanceWarning(warning, source, artifact);
         if (performanceWarning) return void blocks.push(performanceWarning);
+        if (hasChannelPrefix(message)) return void blocks.push(message);
+        const explained = message.includes('\n');
         const oneLine = message.replace(/\s+/g, ' ').trim();
         const artifactSuffix = artifact ? ` ${pintor.gray(`(${artifact})`)}` : '';
-        blocks.push(`${getLoggingPrefix('warn')} ${category}: ${oneLine}${artifactSuffix}\n${formatWarningLabelLine('Source', pintor.gray(source))}\n${formatWarningLabelLine('Hint', hint)}`);
+        blocks.push(`${getLoggingPrefix('warn')} ${category}: ${oneLine}${artifactSuffix}\n` + formatWarningLabelLine('Source', pintor.gray(source)) + (explained ? '' : `\n${formatWarningLabelLine('Hint', hint)}`));
     });
     return blocks.join('\n\n');
 }
-function fetchingProjectPath(owner, project) {
-    return fmt.block('Fetching project', [
-        [
-            'URL',
-            fmt.val(`https://github.com/${owner}/${project}`)
-        ]
-    ]);
-}
-function downloadingProjectPath(projectName) {
+function downloadingProjectPath(projectName, url) {
     const formatted = isPathLike(projectName) ? pintor.underline(projectName) : projectName;
-    return `${getLoggingPrefix('info')} Downloading ${formatted}…`;
+    return `${getLoggingPrefix('info')} Downloading ${formatted}…\n${pintor.gray('URL')} ${fmt.val(url)}`;
 }
 function creatingProjectPath() {
     return `${getLoggingPrefix('info')} Creating a new browser extension…`;
@@ -241,12 +249,7 @@ function writingTypeDefinitionsError(error) {
     return `${getLoggingPrefix('error')} Couldn't write the extension type definitions.\n${pintor.gray('REASON')} ${pintor.red(String(error))}\nCheck the file permissions, then try again.`;
 }
 function downloadingText(url) {
-    return fmt.block('Downloading extension', [
-        [
-            'URL',
-            fmt.val(url)
-        ]
-    ]);
+    return `${getLoggingPrefix('info')} Downloading the browser extension…\n${pintor.gray('URL')} ${fmt.val(url)}`;
 }
 function unpackagingExtension(zipFilePath) {
     return `${getLoggingPrefix('info')} Unpackaging the browser extension…\n${pintor.gray('PATH')} ${pintor.underline(zipFilePath)}`;
@@ -591,12 +594,9 @@ async function getProjectPath(pathOrRemoteUrl) {
                 const urlSource = await importUrlSourceFromZip(pathOrRemoteUrl);
                 return urlSource;
             }
-            const urlData = url.pathname.split('/');
-            const owner = urlData.slice(1, 3)[0];
-            const project = urlData.slice(1, 3)[1];
-            console.log(fetchingProjectPath(owner, project));
+            const [owner, project] = url.pathname.split('/').slice(1, 3);
             const projectName = __rspack_external_node_path_806ed179.basename(url.pathname);
-            const urlSource = await importUrlSourceFromGithub(pathOrRemoteUrl, downloadingProjectPath(projectName));
+            const urlSource = await importUrlSourceFromGithub(pathOrRemoteUrl, downloadingProjectPath(projectName, `https://github.com/${owner}/${project}`));
             console.log(creatingProjectPath());
             return urlSource;
         }
@@ -746,6 +746,23 @@ function asAbsolute(p) {
 function toPosixPath(p) {
     return p.split(__rspack_external_node_path_806ed179.sep).join('/');
 }
+function collapseHomeDir(value) {
+    const raw = String(value || '');
+    const home = __rspack_external_node_os_4f3c9d58.homedir();
+    if (!home || !raw.startsWith(home)) return raw;
+    const rest = raw.slice(home.length);
+    if ('' === rest) return '~';
+    if (rest.startsWith(__rspack_external_node_path_806ed179.sep) || rest.startsWith('/')) return `~${rest}`;
+    return raw;
+}
+function relativeToDir(target, base) {
+    const relative = __rspack_external_node_path_806ed179.relative(base, target);
+    if (relative && !relative.startsWith('..') && !__rspack_external_node_path_806ed179.isAbsolute(relative)) return relative;
+    return null;
+}
+function displayPath(target, base = process.cwd()) {
+    return relativeToDir(target, base) || collapseHomeDir(target);
+}
 function getDirs(struct) {
     const manifestDir = asAbsolute(__rspack_external_node_path_806ed179.dirname(struct.manifestPath));
     const projectManifestPath = struct.packageJsonPath || struct.denoJsonPath;
@@ -979,4 +996,4 @@ function actionsPath(projectPath, browser) {
 function buildSummaryPath(projectPath, browser) {
     return __rspack_external_node_path_806ed179.join(browserArtifactsDir(projectPath, browser), 'build-summary.json');
 }
-export { actionsPath, addonLintFailed, addonLintFinding, addonLintMore, addonLintNotInstalled, addonLintSummary, anotherDevSessionActive, asAbsolute, authorInstallNotice, browserArtifactsDir, browserDistDir, browserLaunchFailed, browserProfileRootDir, buildAssetsTree, buildCommandFailed, buildComplete, buildFailed, buildShareHint, buildSummaryPath, buildWarningsDetails, computePreviewOutputPath, configBrowserOrThrow, configLoadingError, controlPortFilePath, controlTokenPath, debugBrowser, debugContextPath, debugDirs, debugExtensionsToLoad, debugOutputPath, debugPreviewOutput, debugSplitChunksNarrowed, devCommandFailed, devtoolsEngineFor, downloadingText, ensureSessionArtifactsIgnoreFile, ensureSessionStateInProjectGitignore, eventsPath, extensionLoadRecovered, extensionLoadStillRefused, failedToDownloadOrExtractZIPFileError, getDirs, getDistPath, getProjectStructure, invalidRemoteZip, isUsingExperimentalConfig, legacyControlPortFilePath, legacyControlTokenPath, localZipNotFound, logsPath, managedDependencyConflict, manifestInvalidJson, needsInstall, noCompanionExtensionsResolved, normalizeBrowser, notAZipArchive, packagingDistributionFiles, packagingSourceFiles, previewing, previewingCustomOutput, previewingSourceFallback, projectInstallFallbackToNpm, projectInstallInWorkspaceRoot, projectInstallScriptsDisabled, readyContractPath, resolveProjectStructureSync, sessionArtifactsRootDir, sessionStateDir, starting, toPosixPath, treeWithDistFilesBrowser, treeWithSourceAndDistFiles, treeWithSourceFiles, unpackagedSuccessfully, unpackagingExtension, writingTypeDefinitions, writingTypeDefinitionsError, zipArtifactReady };
+export { actionsPath, addonLintDependencyAttribution, addonLintFailed, addonLintFinding, addonLintMore, addonLintNotInstalled, addonLintSummary, anotherDevSessionActive, asAbsolute, authorInstallNotice, browserArtifactsDir, browserDistDir, browserLaunchFailed, browserProfileRootDir, buildAssetsTree, buildCommandFailed, buildComplete, buildFailed, buildShareHint, buildSummaryPath, buildWarningsDetails, collapseHomeDir, computePreviewOutputPath, configBrowserOrThrow, configLoadingError, controlPortFilePath, controlTokenPath, debugBrowser, debugContextPath, debugDirs, debugExtensionsToLoad, debugOutputPath, debugPreviewOutput, debugSplitChunksNarrowed, devCommandFailed, devtoolsEngineFor, displayPath, downloadingText, ensureSessionArtifactsIgnoreFile, ensureSessionStateInProjectGitignore, eventsPath, extensionLoadRecovered, extensionLoadStillRefused, failedToDownloadOrExtractZIPFileError, getDirs, getDistPath, getProjectStructure, invalidRemoteZip, isUsingExperimentalConfig, legacyControlPortFilePath, legacyControlTokenPath, localZipNotFound, logsPath, managedDependencyConflict, manifestInvalidJson, needsInstall, noCompanionExtensionsResolved, normalizeBrowser, notAZipArchive, packagingDistributionFiles, packagingSourceFiles, previewing, previewingCustomOutput, previewingSourceFallback, projectInstallFallbackToNpm, projectInstallInWorkspaceRoot, projectInstallScriptsDisabled, readyContractPath, relativeToDir, resolveProjectStructureSync, sessionArtifactsRootDir, sessionStateDir, starting, toPosixPath, treeWithDistFilesBrowser, treeWithSourceAndDistFiles, treeWithSourceFiles, unpackagedSuccessfully, unpackagingExtension, writingTypeDefinitions, writingTypeDefinitionsError, zipArtifactReady };

package/dist/command-preview.d.ts

@@ -1,4 +1,8 @@
 import type { PreviewOptions } from './types.js';
+/**
+ * Resolved browser launch options returned by extensionPreview.
+ * The caller is responsible for actually launching the browser.
+ */
 export interface ResolvedPreviewOptions {
     browser: string;
     outPath: string;
@@ -25,5 +29,9 @@ export interface ResolvedPreviewOptions {
     logUrl?: string;
     logTab?: number | string;
 }
+/**
+ * Browser launcher callback. When provided, extensionPreview calls it
+ * instead of requiring plugin-browsers internally.
+ */
 export type PreviewLauncherFn = (opts: ResolvedPreviewOptions) => Promise<void>;
 export declare function extensionPreview(pathOrRemoteUrl: string | undefined, previewOptions: PreviewOptions, browserLauncher?: PreviewLauncherFn): Promise<void>;

package/dist/dev-server/control-bridge/consumer-client.d.ts

@@ -4,17 +4,26 @@ export interface ReadyContractInfo {
     controlPort: number;
     instanceId: string;
     runId: string;
+    /** Ready-contract version, `ReadyMetadata['schemaVersion']` on current engines. */
     schemaVersion?: number;
+    /** Result-envelope capability advertisement, `1` on current engines. */
     schema?: number;
     logsPath?: string;
     status?: string;
+    /** Dev-server pid; absent in pre-4.1 contracts. */
     pid?: number;
+    /** Browser CDP port, stamped post-launch, may lag `status: 'ready'`. */
     cdpPort?: number;
+    /** Stamped when the launched browser exits while the server keeps running. */
     browserExitedAt?: string;
     browserExitCode?: number;
+    /** When the compile finished (ISO), the meaning of `status: 'ready'`. */
     compiledAt?: string;
+    /** When the extension's service worker attached to the control channel (ISO). */
     executorAttachedAt?: string;
+    /** `'attached'` once the SW has connected; absent while still launching. */
     runtime?: string;
+    /** Last contract write time (ISO). */
     ts?: string;
     binary?: string;
     binaryProvenance?: string;
@@ -46,6 +55,7 @@ export declare class BridgeConsumer {
     private timer;
     private lastCloseInfo;
     constructor(options: ConsumerOptions);
+    /** Why the last socket closed; null until a close has happened. */
     get lastClose(): ConsumerCloseInfo | null;
     start(): void;
     close(): void;

package/dist/dev-server/control-bridge/contracts.d.ts

@@ -40,7 +40,21 @@ export interface BridgeTarget {
     tabId?: number;
 }
 export type CommandOp = 'eval' | 'storage.get' | 'storage.set' | 'reload' | 'open' | 'tabs.query' | 'inspect';
+/**
+ * Granularity of a dev-loop reload. Mirrors `ReloadType` in
+ * plugin-reload/classify-reload.ts: the launched-browser path feeds this
+ * decision to the CDP controller; the `--no-browser` path feeds the same
+ * decision to the broker, which broadcasts a {@link ReloadFrame} to the SW
+ * producer.
+ */
 export type ReloadType = 'full' | 'service-worker' | 'content-scripts';
+/**
+ * Everything a {@link ReloadFrame} can carry in `reloadType`: the extension
+ * reload granularities plus `'page'`, a notify-only signal for page-only
+ * edits (popup/options/sidebar/devtools/newtab). For `'page'` the producer
+ * performs NO reload (livereload owns the refresh); it only forwards the
+ * announcement so the devtools pill mirrors the dev loop.
+ */
 export type DevReloadKind = ReloadType | 'page';
 export type GapReason = 'ring_overflow' | 'rate_limit' | 'disk_slow' | 'slow_consumer';
 export interface HelloFrame {
@@ -101,12 +115,27 @@ export interface ResultFrame {
         code?: BridgeRefusalCode;
     };
 }
+/**
+ * Dev-loop reload broadcast, server → producer. Sent by the broker on a compile
+ * that completed without a CDP controller (`--no-browser`, headless/CI, remote)
+ * so the service-worker producer can self-reload. Unlike a `reload` CommandFrame
+ * (a controller-issued, `--allow-control`-gated act verb that expects a result),
+ * this is a fire-and-forget dev-server signal, no cmdId, no result.
+ */
 export interface ReloadFrame {
     type: 'reload';
     reloadType: DevReloadKind;
     changedContentScriptEntries?: string[];
+    /**
+     * Server-built human context label, e.g. "content_script (content/scripts.tsx)".
+     * Shown VERBATIM by every announcement surface (CLI stdout, the page's
+     * devtools console line, the devtools-extension pill) so the three can
+     * never disagree about what is reloading.
+     */
     label?: string;
+    /** Project-relative source files that triggered this reload. */
     changedFiles?: string[];
+    /** Emitted scripts/ bundles the SW should replay its executeScript calls for. */
     changedScriptFiles?: string[];
 }
 export interface ReloadAckFrame {
@@ -114,6 +143,15 @@ export interface ReloadAckFrame {
     reloadType: DevReloadKind;
     label?: string;
 }
+/**
+ * Server → producer keepalive. An MV3 service worker idles out after ~30s
+ * without events, and a stopped SW holds no control socket, reload
+ * broadcasts would reach zero producers and silently apply to nothing
+ * (quiet extensions lost SW/manifest reloads once >30s passed between
+ * edits). Receiving any WebSocket message resets the SW idle timer
+ * (Chrome 116+), so a periodic ping keeps the dev extension's SW
+ * responsive for the whole dev session. Producers ignore the frame.
+ */
 export interface PingFrame {
     type: 'ping';
 }
@@ -121,7 +159,11 @@ export type ClientFrame = HelloFrame | LogFrame | CommandFrame | ReloadAckFrame;
 export type ServerFrame = ReadyFrame | LogFrame | GapFrame | ResultFrame | ReloadFrame | PingFrame;
 export type AnyFrame = ClientFrame | ServerFrame;
 export declare const CONTROL_WS_PATH = "/extjs-control";
+/** The hello named an instanceId from a previous dev session. */
 export declare const CLOSE_BAD_INSTANCE = 4001;
+/** The hello was malformed: wrong envelope version, or an unknown role. */
 export declare const CLOSE_BAD_HELLO = 4002;
+/** A controller dialed a session started without `--allow-control`. */
 export declare const CLOSE_CONTROL_UNAVAILABLE = 4003;
+/** The socket fell far enough behind that it was dropped to protect the broker. */
 export declare const CLOSE_SLOW_CONSUMER = 4008;

package/dist/dev-server/control-bridge/logs-query.d.ts

@@ -1,13 +1,22 @@
+/** Increasing verbosity; a level selects itself plus everything more severe. */
 export declare const LOG_LEVEL_ORDER: readonly ['error', 'warn', 'info', 'debug', 'trace'];
 export type LogLevelFilter = (typeof LOG_LEVEL_ORDER)[number] | 'all' | 'off' | (string & {});
 export interface LogQuery {
+    /** One context, a comma-separated list, an array, or 'all'. */
     context?: string | string[];
+    /** Minimum severity. 'all' and 'off' select every level. */
     level?: LogLevelFilter;
+    /** Only structured dx.signal diagnostics. */
     signalsOnly?: boolean;
+    /** Only events after this point: a sequence number, or an ISO timestamp
+     * compared against the event's own clock. */
     since?: number | string;
+    /** Glob (`*` = any run of chars) or plain substring over url then hostname. */
     url?: string;
+    /** Only events carrying this tab id. */
     tab?: number | string;
 }
+/** A bridge log line as read off disk: dynamic, so the probed fields only. */
 export interface LogEventLike {
     type?: unknown;
     eventType?: unknown;
@@ -21,6 +30,7 @@ export interface LogEventLike {
     tabId?: unknown;
 }
 export declare function logLevelRank(level: string): number;
+/** How a `since` value is read: a sequence number, or a point in time. */
 export type LogSince = {
     seq: number;
 } | {
@@ -28,5 +38,11 @@ export type LogSince = {
 };
 export declare function parseLogSince(value: unknown): LogSince | null | undefined;
 export declare function isAfterSince(event: LogEventLike, since: LogSince): boolean;
+/** True when the event passes every clause of the query. */
 export declare function matchesLogQuery(event: LogEventLike, query: LogQuery): boolean;
+/**
+ * One-shot read of a session's logs.ndjson. Returns an empty array when the
+ * session has never written one: an absent file is "nothing logged yet", and
+ * making that a throw would force every caller to guard it.
+ */
 export declare function readLogEvents(projectPath: string, browser?: string, query?: LogQuery): LogEventLike[];

package/dist/dev-server~0.mjs

@@ -262,6 +262,7 @@ const UNDELIVERED_RELOAD_WARN = {
     'never-connected': "SW not attached, your edit compiled but no page received it. The extension's service worker has not connected to the dev server this session (a heavy ad/bot-laden page, an auth wall, or a profile-cached worker can prevent it). Reloads resume automatically once it connects.",
     'recently-disconnected': "SW not attached, your edit compiled but no page received it. The extension's service worker disconnected (MV3 workers idle out, or the browser may have exited). Reloads resume automatically once it reconnects."
 };
+const UNDELIVERED_RELOAD_WARN_WEBKIT_NEVER_CONNECTED = "Extension not connected, your edit compiled but no page received it. The extension has not connected to the dev server this session. Open Safari > Settings > Extensions and turn it on. Safari restarts the extension itself once it is enabled, and reloads resume automatically.";
 class BridgeBroker {
     instanceId;
     runId;
@@ -382,6 +383,7 @@ class BridgeBroker {
         if (options?.producerRestartExpected && 'recently-disconnected' === kind) return null;
         if (this.lastUndeliveredWarnKind === kind) return null;
         this.lastUndeliveredWarnKind = kind;
+        if ('never-connected' === kind && 'webkit' === this.engine) return UNDELIVERED_RELOAD_WARN_WEBKIT_NEVER_CONNECTED;
         return UNDELIVERED_RELOAD_WARN[kind];
     }
     pingProducers() {

package/dist/lib/addon-lint.d.ts

@@ -1,3 +1,4 @@
+import type { ChunkProvenance } from './chunk-dependency-provenance.js';
 export declare const ADDON_LINT_DEFAULT = true;
 export declare const ADDON_LINT_TIMEOUT_MS = 10000;
 export declare const ADDON_LINT_MAX_PRINTED = 20;
@@ -54,6 +55,7 @@ export interface RunAddonLintInput {
     enabled?: boolean;
     loadLinter?: LoadAddonLinter;
     timeoutMs?: number;
+    chunkProvenance?: () => Map<string, ChunkProvenance>;
 }
 export declare function shouldRunAddonLint(input: {
     browser: string;
@@ -63,7 +65,8 @@ export declare function shouldRunAddonLint(input: {
     status: 'skipped';
 }> | null;
 export declare function collectAddonLintLines(output: AddonLintOutput | null | undefined): AddonLintLine[];
-export declare function formatAddonLintFindings(output: AddonLintOutput | null | undefined, distDisplay: string, maxPrinted?: number): {
+export declare function attributionFor(location: string, chunkProvenance?: Map<string, ChunkProvenance>): string;
+export declare function formatAddonLintFindings(output: AddonLintOutput | null | undefined, distDisplay: string, maxPrinted?: number, chunkProvenance?: Map<string, ChunkProvenance>): {
     findings: number;
     lines: string[];
 };

package/dist/lib/build-summary.d.ts

@@ -1,3 +1,9 @@
+/**
+ * What the injected Safari packager reports back about the app it produced.
+ * `bundleIdDerived` is the load-bearing one: a generated `dev.extensionjs.*`
+ * identifier comes from the app name, so every project built from the same
+ * source shares it and the first registration takes it.
+ */
 export interface SafariPackageSummary {
     appName?: string;
     bundleId?: string;
@@ -8,13 +14,18 @@ export interface SafariPackageSummary {
 }
 export type BuildSummary = {
     browser: string;
+    /** Absolute dist directory the build emitted into. Hosts that shell out
+     * would otherwise have to re-derive `<project>/dist/<browser>` themselves. */
     output_path?: string;
     total_assets: number;
     total_bytes: number;
     largest_asset_bytes: number;
     warnings_count: number;
     errors_count: number;
+    /** Plain-text warning messages (ANSI-stripped, capped) so programmatic
+     * consumers get a structured channel instead of scraping stdout. */
     warnings?: string[];
+    /** Present only for safari/webkit-based builds that ran the packager. */
     safari?: SafariPackageSummary;
 };
 export declare function getBuildSummary(browser: string, info: {

package/dist/lib/chunk-dependency-provenance.d.ts

@@ -0,0 +1,14 @@
+export interface ChunkProvenance {
+    packages: string[];
+    onlyDependencies: boolean;
+}
+interface ChunkGraphLike {
+    getChunkModulesIterable: (chunk: never) => Iterable<unknown>;
+}
+export interface CompilationLike {
+    chunks?: Iterable<unknown>;
+    chunkGraph?: ChunkGraphLike;
+}
+export declare function packageNameFromPath(candidate: string): string | null;
+export declare function collectChunkDependencyProvenance(compilation: CompilationLike | null | undefined): Map<string, ChunkProvenance>;
+export {};

package/dist/lib/constants.d.ts

@@ -6,7 +6,7 @@ export declare const CHROMIUM_FAMILY_ALIASES: string[];
 export declare const GECKO_FAMILY_ALIASES: string[];
 export declare const SUPPORTED_BROWSERS: string[];
 export declare const SUPPORTED_PACKAGE_MANAGERS: readonly ['npm', 'pnpm', 'yarn', 'bun', 'deno'];
-export declare const SUPPORTED_RUNTIMES: readonly ['node', 'deno'];
+export declare const SUPPORTED_RUNTIMES: readonly ['node', 'deno', 'bun'];
 export declare const SUPPORTED_UI_FRAMEWORKS: readonly ['react', 'preact', 'vue', 'svelte'];
 export declare const SUPPORTED_CSS_TECH: readonly ['css', 'css-modules', 'sass', 'less', 'postcss', 'tailwind'];
 export declare function isChromiumBasedBrowser(browser: string): boolean;

package/dist/lib/manifest-utils.d.ts

@@ -8,5 +8,7 @@ export interface DroppedVendorKey {
     appliedBefore: boolean;
 }
 export declare function findDroppedVendorKeys(manifest: Manifest, browser: DevOptions['browser']): DroppedVendorKey[];
+export declare function isValidManifestVersion(value: unknown): value is 2 | 3;
+export declare function findPrefixedManifestVersionKeys(manifest: Manifest): string[];
 export declare function isStaticTheme(manifest: Manifest | undefined | null): boolean;
 export declare function isStaticThemeSource(manifestPath: string | undefined, browser: DevOptions['browser'] | string | undefined): boolean;

package/dist/lib/messages.d.ts

@@ -21,7 +21,8 @@ export declare function anotherDevSessionActive(browser: string, pid: number, ru
 export declare function buildAssetsTree(stats: Stats | undefined): string;
 export declare function buildComplete(browser: DevOptions['browser'], distDisplayPath: string, totalBytes?: number, mode?: 'development' | 'production' | 'none'): string;
 export declare function addonLintSummary(errorCount: number, warningCount: number, distDisplay: string): string;
-export declare function addonLintFinding(level: 'error' | 'warning', code: string, message: string, location: string): string;
+export declare function addonLintFinding(level: 'error' | 'warning', code: string, message: string, location: string, attribution?: string): string;
+export declare function addonLintDependencyAttribution(packages: string[], onlyDependencies: boolean): string;
 export declare function addonLintMore(hiddenCount: number, distDisplay: string): string;
 export declare function addonLintNotInstalled(installHint: string): string;
 export declare function addonLintFailed(reason: string): string;
@@ -41,8 +42,7 @@ type LooseBuildWarning = string | null | undefined | {
     chunkName?: unknown;
 };
 export declare function buildWarningsDetails(warnings: LooseBuildWarning[]): string;
-export declare function fetchingProjectPath(owner: string, project: string): string;
-export declare function downloadingProjectPath(projectName: string): string;
+export declare function downloadingProjectPath(projectName: string, url: string): string;
 export declare function creatingProjectPath(): string;
 export declare function downloadedProjectFolderNotFound(cwd: string, candidates: string[]): string;
 export declare function packagingSourceFiles(zipPath: string): string;

package/dist/lib/messaging.d.ts

@@ -1,6 +1,7 @@
 export type Channel = 'info' | 'success' | 'warn' | 'error' | 'debug';
 export declare function isDebug(): boolean;
 export declare function prefix(type: Channel): string;
+export declare function hasChannelPrefix(text: string): boolean;
 export declare function isMachineOutput(): boolean;
 export declare function humanLine(...parts: unknown[]): void;
 export declare function humanWarn(...parts: unknown[]): void;

package/dist/lib/package-manager.d.ts

@@ -1,3 +1,4 @@
+import { type ChildProcess } from 'node:child_process';
 import { buildExecEnv } from 'prefers-yarn';
 export { buildExecEnv };
 import type { SUPPORTED_PACKAGE_MANAGERS } from './constants.js';
@@ -43,4 +44,5 @@ export declare function buildSpawnInvocation(command: string, args: string[]): {
     command: string;
     args: string[];
 };
+export declare function spawnInstallCommand(command: string, args: string[], options?: ExecOptions): ChildProcess;
 export declare function execInstallCommand(command: string, args: string[], options?: ExecOptions): Promise<void>;

package/dist/lib/paths.d.ts

@@ -6,6 +6,9 @@ export type BrowserInput = 'chrome' | 'edge' | 'chromium' | 'firefox' | 'brave'
 export type NormalizedBrowser = 'chrome' | 'edge' | 'chromium' | 'firefox' | 'brave' | 'opera' | 'vivaldi' | 'yandex' | 'waterfox' | 'librewolf' | 'chromium-based' | 'gecko-based' | 'safari' | 'webkit-based';
 export declare function asAbsolute(p: string): AbsolutePath;
 export declare function toPosixPath(p: string): string;
+export declare function collapseHomeDir(value: string): string;
+export declare function relativeToDir(target: string, base: string): string | null;
+export declare function displayPath(target: string, base?: string): string;
 export declare function getDirs(struct: ProjectStructure): {
     manifestDir: AbsolutePath;
     packageJsonDir: AbsolutePath;

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

@@ -49,6 +49,7 @@ export interface BrowserLaunchOptions {
     logTab?: number | string;
     logSink?: BrowserLogSink;
 }
+/** Browser-generated log entry normalized by the launcher's CDP controller. */
 export interface BrowserLogSinkEvent {
     level: 'log' | 'info' | 'warn' | 'error' | 'debug';
     text: string;
@@ -73,7 +74,9 @@ export interface BrowserController {
         urlFilter?: string;
         tabFilter?: number | string;
     }): Promise<void>;
+    /** The browser's refusal reason for this session, or null when it loaded. */
     getExtensionLoadRefusal?(): string | null;
+    /** Re-offer the current dist. Only ever called while the session is refused. */
     retryExtensionLoad?(): Promise<ExtensionLoadRetryResult>;
 }
 export type BrowserLauncherFn = (opts: BrowserLaunchOptions) => Promise<BrowserController>;
@@ -83,13 +86,33 @@ export interface RunnerPlugin {
     apply(compiler: Compiler): void;
 }
 export interface BrowsersPluginOptions {
+    /** Injected browser launcher, provided by the CLI from programs/extension/browsers/ */
     launcher: BrowserLauncherFn;
+    /** Browser-related options forwarded to the launcher (outputPath/contextDir/extensionsToLoad are filled at compile time) */
     browserOptions: Omit<BrowserLaunchOptions, 'outputPath' | 'contextDir' | 'extensionsToLoad'>;
 }
+/**
+ * BrowsersPlugin
+ *
+ * An rspack plugin that manages the browser lifecycle for extension development.
+ * On first successful compilation it launches a browser via the injected launcher
+ * function; on subsequent compilations it classifies changed files and triggers
+ * the appropriate reload strategy (full / service-worker / content-scripts).
+ *
+ * A `BuildEmitter` is exposed as `plugin.emitter` so that external consumers
+ * (CLI telemetry, wait-mode, etc.) can subscribe to build events without
+ * coupling to rspack.
+ */
 export declare class BrowsersPlugin implements RunnerPlugin {
     private readonly options;
     static readonly name = "plugin-browsers";
+    /** EventEmitter for build lifecycle events (compiled, error, close). */
     readonly emitter: BuildEmitter;
+    /**
+     * Extension directories to load alongside the user extension.
+     * Set externally by webpack-config after computing companion extensions,
+     * before the first compilation.
+     */
     extensionsToLoad: string[];
     private isFirstCompile;
     private controller;
@@ -97,6 +120,11 @@ export declare class BrowsersPlugin implements RunnerPlugin {
     private logSink;
     private lastReportedRefusal;
     constructor(options: BrowsersPluginOptions);
+    /**
+     * The dev server injects the control-bridge broker so a launched
+     * Chromium reloads through the SW producer (the same path as `--no-browser`),
+     * not the CDP controller. Called once, before the first compile.
+     */
     setReloadBroker(broker: ReloadBroker): void;
     setLogSink(sink: BrowserLogSink): void;
     private retryRefusedExtensionLoad;

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

@@ -1,6 +1,8 @@
 import { type Compiler } from '@rspack/core';
 import type { DevOptions, PluginInterface } from '../types.js';
 export declare const IMPORT_META_URL_RUNTIME = "(function(){var h=typeof document!==\"undefined\"&&document.baseURI||self.location.href;try{var g=globalThis,r=(g.browser||g.chrome).runtime.getURL(\"/\");return h.indexOf(r)===0?h:r}catch(_){return h}})()";
+export declare function importMetaUrlForEmitPath(emitPath: string): string;
+export declare function toJsStringLiteral(value: string): string;
 export declare function getEnvFileCandidates(browser: DevOptions['browser'], mode: string): string[];
 export declare class EnvPlugin {
     readonly browser: DevOptions['browser'];

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

@@ -1,6 +1,7 @@
 export declare function installingRootDependencies(integration: string): string;
 export declare function integrationInstalledSuccessfully(integration: string): string;
 export declare function isUsingIntegration(name: string): string;
+export declare function solidIsNotSupported(): string;
 export declare function youAreAllSet(name: string): string;
 export declare function creatingTSConfig(): string;
 export declare function failedToInstallIntegration(integration: string, error: unknown): string;

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

@@ -1,3 +1,6 @@
 import type { JsFramework } from '../../types.js';
 export declare function isUsingSolid(projectPath: string): boolean;
+type ResolveFromProject = (id: string) => string | undefined;
+export declare function resolveSolidHyperscript(resolveFromProject: ResolveFromProject): string | undefined;
 export declare function maybeUseSolid(projectPath: string): Promise<JsFramework | undefined>;
+export {};

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

@@ -3,6 +3,22 @@ export declare function isUsingTypeScript(projectPath: string): boolean;
 export declare function ensureTypeScriptConfig(projectPath: string): void;
 export declare function defaultTypeScriptConfig(projectPath: string, _opts?: unknown): {
     compilerOptions: {
+        jsxImportSource: import("../js-frameworks-lib/jsx-transform.js").JsxImportSource;
+        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;
+    } | {
+        jsxImportSource?: undefined;
         allowJs: boolean;
         allowSyntheticDefaultImports: boolean;
         esModuleInterop: boolean;

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

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

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

@@ -11,4 +11,4 @@ export declare class PerfBudgetsPlugin {
     apply(compiler: Compiler): void;
 }
 export type { AssetCategory } from './categorize.js';
-export { BUDGET_BYTES, categorizeAsset } from './categorize.js';
+export { ASSET_CATEGORIES, BUDGET_BYTES, categorizeAsset } from './categorize.js';

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

@@ -30,6 +30,7 @@ export type ReadyMetadata = {
     rdpPort?: number;
     profilePath?: string;
     browserPid?: number;
+    launcherPid?: number;
     toolchainVersion: string;
     extensionName?: string;
     extensionVersion?: string;

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

@@ -6,13 +6,17 @@ export interface ReloadInstruction {
     changedScriptFiles?: string[];
     label?: string;
 }
+/** "context (fileA, fileB +2 more)", the one label every reload surface shows. */
 export declare function formatReloadContextLabel(context: string, files: string[]): string;
 export declare function pageContextFromSources(changedSources: string[]): string;
 export interface SourceFeatureIndex {
     swSources: Set<string>;
+    /** Source → canonical content_scripts entry names whose chunks contain it. */
     contentEntriesBySource: Map<string, Set<string>>;
     pageSources: Set<string>;
+    /** Source → emitted scripts/ bundle names whose chunks contain it. */
     scriptFilesBySource?: Map<string, Set<string>>;
+    /** Project-relative public/ roots the copier ships at the dist root. */
     publicRoots?: string[];
 }
 export declare function publicOutputPath(rel: string, publicRoots: string[] | undefined): string | undefined;