extension-develop 4.0.11 → 4.0.12

package/dist/lib/config-loader.d.ts

@@ -0,0 +1,38 @@
+import type { Configuration } from '@rspack/core';
+import type { BrowserConfig, DevOptions } from '../types';
+export declare function loadCustomConfig(projectPath: string): Promise<(config: Configuration) => Configuration>;
+export declare function loadCommandConfig(projectPath: string, command: 'dev' | 'build' | 'start' | 'preview'): Promise<{
+    perfBudgets: any;
+    transpilePackages: any;
+    extensions: any;
+} | {
+    perfBudgets?: undefined;
+    transpilePackages: any;
+    extensions: any;
+} | {
+    perfBudgets: any;
+    transpilePackages?: undefined;
+    extensions: any;
+} | {
+    perfBudgets?: undefined;
+    transpilePackages?: undefined;
+    extensions: any;
+} | {
+    perfBudgets: any;
+    transpilePackages: any;
+    extensions?: undefined;
+} | {
+    perfBudgets?: undefined;
+    transpilePackages: any;
+    extensions?: undefined;
+} | {
+    perfBudgets: any;
+    transpilePackages?: undefined;
+    extensions?: undefined;
+} | {
+    perfBudgets?: undefined;
+    transpilePackages?: undefined;
+    extensions?: undefined;
+}>;
+export declare function loadBrowserConfig(projectPath: string, browser?: DevOptions['browser']): Promise<BrowserConfig>;
+export declare function isUsingExperimentalConfig(projectPath: string): Promise<boolean>;

package/dist/lib/constants.d.ts

@@ -0,0 +1,11 @@
+export declare const CERTIFICATE_DESTINATION_PATH: string;
+export declare const CHROMIUM_BASED_BROWSERS: string[];
+export declare const GECKO_BASED_BROWSERS: string[];
+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_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;
+export declare function isGeckoBasedBrowser(browser: string): boolean;

package/dist/lib/dark-mode.d.ts

@@ -0,0 +1,9 @@
+import { type BrowserConfig, type BrowserType } from '../types';
+export declare function getDarkModeDefaults(browser: BrowserType): Pick<BrowserConfig, 'browserFlags' | 'preferences'>;
+/**
+ * Merge dark-mode defaults into an existing BrowserConfig without overriding
+ * explicit user choices. Flags are de-duplicated preserving user order.
+ */
+export declare function withDarkMode<T extends BrowserConfig & {
+    browser: BrowserType;
+}>(config: T): T;

package/dist/lib/dev-server-client-import.d.ts

@@ -0,0 +1,4 @@
+import { type Compiler } from '@rspack/core';
+export declare const HMR_CLIENT_SPECIFIER = "@rspack/dev-server/client/index.js";
+export declare const HMR_HOT_SPECIFIER = "@rspack/core/hot/dev-server";
+export declare function getDevServerHmrImports(compiler: Compiler): string[];

package/dist/lib/develop-context.d.ts

@@ -0,0 +1,3 @@
+export declare function findExtensionDevelopRoot(): string | null;
+export declare function resolveDevelopInstallRoot(): string | undefined;
+export declare function resolveDevelopDistFile(stem: string): string;

package/dist/lib/ensure-develop-artifacts.d.ts

@@ -0,0 +1,10 @@
+import { type AbsolutePath } from './paths';
+/**
+ * Install the user's project dependencies if node_modules is missing or stale.
+ * This runs `npm install` (or pnpm/yarn/bun) in the project directory so that
+ * user-declared dependencies (sass, vue, react, etc.) are available to the
+ * bundler. Without this, `pnpm dlx extension build` in a clean directory would
+ * fail to resolve project dependencies.
+ */
+export declare function ensureUserProjectDependencies(packageJsonDir: AbsolutePath): Promise<void>;
+export declare function ensureDevelopArtifacts(): Promise<void>;

package/dist/lib/extensions-to-load.d.ts

@@ -0,0 +1 @@
+export declare function computeExtensionsToLoad(baseDir: string, mode: 'development' | 'production' | 'none' | string | undefined, browser: string, userExtensionOutputPath: string, extraExtensionDirs?: string[], userManifestPath?: string): string[];

package/dist/lib/generate-extension-types.d.ts

@@ -0,0 +1 @@
+export declare function generateExtensionTypes(manifestDir: string, packageJsonDir: string): Promise<void>;

package/dist/lib/has-dependency.d.ts

@@ -0,0 +1,6 @@
+/**
+ * True when `packageName` is declared by the project's manifest: package.json
+ * dependency fields (dependencies, devDependencies, optionalDependencies,
+ * peerDependencies) or a deno.json(c) `npm:` import.
+ */
+export declare function hasDependency(projectPath: string, packageName: string): boolean;

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

@@ -0,0 +1,2 @@
+import type { Manifest, DevOptions } from '../types';
+export declare function filterKeysForThisBrowser(manifest: Manifest, browser: DevOptions['browser']): any;

package/dist/lib/messages.d.ts

@@ -0,0 +1,55 @@
+import type { DevOptions, Manifest } from '../types';
+export declare const fmt: {
+    heading: (title: string) => string;
+    label: (key: string) => string;
+    val: (value: string) => string;
+    code: (value: string) => string;
+    bullet: (value: string) => string;
+    block(title: string, rows: Array<[string, string]>): string;
+    truncate(input: unknown, max?: number): string;
+};
+export declare function resolvedWorkspaceManifest(projectPath: string, manifestPath: string): string;
+export declare function remoteFetchTimedOut(target: string, ms: number): string;
+export declare function manifestInvalidJson(manifestPath: string, error: unknown): string;
+export declare function notAnExtensionManifestError(manifestPath: string): string;
+export declare function manifestNotFoundError(manifestPath: string, candidates?: string[]): string;
+export declare function building(browser: DevOptions['browser']): string;
+export declare function previewing(browser: DevOptions['browser']): string;
+export declare function previewSkippedNoBrowser(browser: DevOptions['browser']): string;
+export declare function authorInstallNotice(target: string): string;
+export declare function projectInstallFallbackToNpm(pmName: string): string;
+export declare function projectInstallScriptsDisabled(pmName: string): string;
+export declare function buildWebpack(projectDir: string, stats: any, browser: DevOptions['browser']): string;
+export declare function buildSuccess(): string;
+export declare function buildSuccessWithWarnings(warningCount: number): string;
+export declare function buildWarningsDetails(warnings: any[]): string;
+export declare function fetchingProjectPath(owner: string, project: string): string;
+export declare function downloadingProjectPath(projectName: string): string;
+export declare function creatingProjectPath(projectPath: string): string;
+export declare function downloadedProjectFolderNotFound(cwd: string, candidates: string[]): string;
+export declare function packagingSourceFiles(zipPath: string): string;
+export declare function packagingDistributionFiles(zipPath: string): string;
+export declare function treeWithSourceAndDistFiles(browser: DevOptions['browser'], name: string, sourceZip: string, destZip: string): string;
+export declare function treeWithDistFilesbrowser(name: string, ext: string, browser: DevOptions['browser'], zipPath: string): string;
+export declare function treeWithSourceFiles(name: string, ext: string, browser: DevOptions['browser'], zipPath: string): string;
+export declare function writingTypeDefinitions(manifest: Manifest): string;
+export declare function writingTypeDefinitionsError(error: any): string;
+export declare function downloadingText(url: string): string;
+export declare function unpackagingExtension(zipFilePath: string): string;
+export declare function unpackagedSuccessfully(): string;
+export declare function failedToDownloadOrExtractZIPFileError(error: any): string;
+export declare function invalidRemoteZip(url: string, contentType: string): string;
+export declare function notAZipArchive(source: string, contentType?: string): string;
+export declare function localZipNotFound(zipFilePath: string): string;
+export declare function isUsingExperimentalConfig(integration: any): string;
+export declare function debugDirs(manifestDir: string, packageJsonDir: string): string;
+export declare function debugBrowser(browser: DevOptions['browser'], chromiumBinary?: string, geckoBinary?: string): string;
+export declare function debugOutputPath(pathValue: string): string;
+export declare function debugPreviewOutput(outputPath: string, distPath: string): string;
+export declare function debugContextPath(packageJsonDir: string): string;
+export declare function debugExtensionsToLoad(extensions: string[]): string;
+export declare function noCompanionExtensionsResolved(): string;
+export declare function configLoadingError(configPath: string, error: unknown): string;
+export declare function buildCommandFailed(error: unknown): string;
+export declare function devCommandFailed(error: unknown): string;
+export declare function managedDependencyConflict(duplicates: string[], userPackageJsonPath: string): string;

package/dist/lib/optional-dependency-types.d.ts

@@ -0,0 +1,14 @@
+export type OptionalDependencyVerificationRule = {
+    type: 'install-root';
+    packageId: string;
+} | {
+    type: 'module-context-resolve' | 'module-context-load';
+    fromPackage: string;
+    packageId: string;
+};
+export type OptionalDependencyContract = {
+    id: string;
+    integration: string;
+    installPackages: string[];
+    verificationRules: OptionalDependencyVerificationRule[];
+};

package/dist/lib/optional-deps-contracts.d.ts

@@ -0,0 +1,13 @@
+import type { OptionalDependencyContract, OptionalDependencyVerificationRule } from './optional-dependency-types';
+declare const OPTIONAL_DEPENDENCY_CONTRACTS: {
+    typescript: OptionalDependencyContract;
+    'react-refresh': OptionalDependencyContract;
+    'preact-refresh': OptionalDependencyContract;
+    vue: OptionalDependencyContract;
+    svelte: OptionalDependencyContract;
+    less: OptionalDependencyContract;
+    postcss: OptionalDependencyContract;
+    sass: OptionalDependencyContract;
+};
+export declare function getOptionalDependencyContract(contractId: string): OptionalDependencyContract;
+export { OPTIONAL_DEPENDENCY_CONTRACTS, type OptionalDependencyContract, type OptionalDependencyVerificationRule };

package/dist/lib/optional-deps-resolver.d.ts

@@ -0,0 +1,41 @@
+import type { OptionalDependencyContract } from './optional-dependency-types';
+type EnsureResolveInput = {
+    integration: string;
+    projectPath: string;
+    dependencyId: string;
+    installDependencies?: string[];
+    verifyPackageIds?: string[];
+    contract?: OptionalDependencyContract;
+};
+type EnsureLoadInput<T = any> = EnsureResolveInput & {
+    moduleAdapter?: (loaded: any) => T;
+};
+export declare function getContractVerificationFailuresFromKnownLocations(contract: OptionalDependencyContract, projectPath: string): string[];
+export declare function getContractVerificationFailuresAtInstallRoot(contract: OptionalDependencyContract, installRoot: string): string[];
+export declare function ensureOptionalPackageResolved(input: EnsureResolveInput): Promise<string>;
+export declare function resolveOptionalPackageWithoutInstall(input: EnsureResolveInput): string;
+export declare function ensureOptionalModuleLoaded<T = any>(input: EnsureLoadInput<T>): Promise<T>;
+export declare function loadOptionalModuleWithoutInstall<T = any>(input: EnsureLoadInput<T>): T;
+export declare function ensureOptionalContractPackageResolved(input: {
+    contractId: string;
+    projectPath: string;
+    dependencyId: string;
+}): Promise<string>;
+export declare function ensureOptionalContractModuleLoaded<T = any>(input: {
+    contractId: string;
+    projectPath: string;
+    dependencyId: string;
+    moduleAdapter?: (loaded: any) => T;
+}): Promise<T>;
+export declare function resolveOptionalContractPackageWithoutInstall(input: {
+    contractId: string;
+    projectPath: string;
+    dependencyId: string;
+}): string;
+export declare function loadOptionalContractModuleWithoutInstall<T = any>(input: {
+    contractId: string;
+    projectPath: string;
+    dependencyId: string;
+    moduleAdapter?: (loaded: any) => T;
+}): T;
+export {};

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

@@ -0,0 +1,3 @@
+export declare function findNearestPackageJson(manifestPath: string): Promise<string | null>;
+export declare function findNearestPackageJsonSync(manifestPath: string): string | null;
+export declare function validatePackageJson(packageJsonPath: string): boolean;

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

@@ -0,0 +1,61 @@
+import { buildExecEnv } from 'prefers-yarn';
+export { buildExecEnv };
+import { SUPPORTED_PACKAGE_MANAGERS } from './constants';
+export type PackageManagerName = (typeof SUPPORTED_PACKAGE_MANAGERS)[number];
+export type PackageManagerResolution = {
+    name: PackageManagerName;
+    execPath?: string;
+    runnerCommand?: string;
+    runnerArgs?: string[];
+};
+type ExecOptions = {
+    cwd?: string;
+    stdio?: 'inherit' | 'ignore' | 'pipe';
+    env?: Record<string, string>;
+};
+export declare function resolvePackageManager(opts?: {
+    cwd?: string;
+}): PackageManagerResolution;
+/**
+ * Extra args that confine a *project* dependency install to the project
+ * directory. pnpm walks up from cwd and, on finding any ancestor
+ * `pnpm-workspace.yaml`, installs that ENTIRE workspace instead of the
+ * project — for a project that merely sits under an unrelated monorepo
+ * (G28), that installs a foreign codebase's dependency tree. Skip the
+ * confinement only when the workspace is genuinely the project's own:
+ * the project dir is itself a workspace root, or its package.json uses
+ * `workspace:` specifiers (a standalone install could never satisfy those).
+ */
+export declare function projectInstallArgs(pm: PackageManagerResolution, projectDir: string): string[];
+/**
+ * Args/env that stop an auto-install from running lifecycle scripts
+ * (preinstall/postinstall/prepare) — the project being built was never
+ * vetted by the user typing an install command, so a wild package.json
+ * must not get code execution as a side effect of `extension dev/build`.
+ * Matches the pnpm 10 / Bun default. Opt back in with
+ * EXTENSION_ALLOW_INSTALL_SCRIPTS=true.
+ *
+ * yarn needs env instead of a flag: yarn 1 accepts --ignore-scripts but
+ * Berry rejects unknown flags outright, and the resolved binary's major
+ * is unknowable here. Berry maps YARN_ENABLE_SCRIPTS -> enableScripts;
+ * yarn 1 reads npm_config_* and ignores YARN_ENABLE_SCRIPTS. deno install
+ * already refuses npm lifecycle scripts unless --allow-scripts is passed.
+ */
+export declare function installScriptSuppression(pm: PackageManagerResolution): {
+    args: string[];
+    env: Record<string, string>;
+};
+/**
+ * A hydrated npm resolution for fallback installs: PATH npm first, then the
+ * npm CLI bundled with the running Node.
+ */
+export declare function resolveNpmPackageManager(): PackageManagerResolution;
+export declare function buildInstallCommand(pm: PackageManagerResolution, args: string[]): {
+    command: string;
+    args: string[];
+};
+export declare function buildSpawnInvocation(command: string, args: string[]): {
+    command: string;
+    args: string[];
+};
+export declare function execInstallCommand(command: string, args: string[], options?: ExecOptions): Promise<void>;

package/dist/lib/parse-json-safe.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Strips the UTF-8 BOM (0xFEFF) that some editors prepend to JSON files.
+ * Chrome tolerates the BOM in every extension JSON it reads (manifest.json,
+ * declarativeNetRequest rulesets, _locales) — verified against live Chrome —
+ * so every parse of user-authored JSON must strip it too.
+ */
+export declare function stripBom(text: string | Buffer): string;
+/**
+ * JSON.parse with BOM stripping. Empty input parses as `{}`; invalid JSON
+ * still throws. Use `JSON.parse(stripBom(...))` instead where empty input
+ * must stay an error.
+ */
+export declare function parseJsonSafe(text: string | Buffer): any;

package/dist/lib/paths.d.ts

@@ -0,0 +1,19 @@
+import type { ProjectStructure } from './project';
+export type AbsolutePath = string & {
+    readonly __brand: 'AbsolutePath';
+};
+export type BrowserInput = 'chrome' | 'edge' | 'chromium' | 'firefox' | 'brave' | 'opera' | 'vivaldi' | 'yandex' | 'waterfox' | 'librewolf' | 'chromium-based' | 'gecko-based' | 'firefox-based' | 'safari' | 'webkit-based' | undefined;
+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 getDirs(struct: ProjectStructure): {
+    manifestDir: AbsolutePath;
+    packageJsonDir: AbsolutePath;
+};
+export declare function getNodeModulesDir(packageJsonDir: AbsolutePath): AbsolutePath;
+export declare function needsInstall(packageJsonDir: AbsolutePath): boolean;
+export declare function normalizeBrowser(browser: BrowserInput, chromiumBinary?: string, geckoBinary?: string, safariBinary?: string): NormalizedBrowser;
+export declare function getDistPath(packageJsonDir: AbsolutePath, browser: string): AbsolutePath;
+export declare function computePreviewOutputPath(struct: ProjectStructure, browser: string, explicitOutputPath?: string): AbsolutePath;
+export declare function ensureDirSync(dir: AbsolutePath): void;
+export declare function devtoolsEngineFor(browser: any): 'chrome' | 'edge' | 'chromium' | 'firefox';

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

@@ -0,0 +1,60 @@
+/**
+ * Files that mark a directory as a project root and declare its dependencies.
+ * package.json is the npm-family manifest; deno.json(c) is Deno's, where npm
+ * dependencies appear as `npm:` specifiers in the `imports` map.
+ */
+export declare const PROJECT_MANIFEST_FILENAMES: readonly ["package.json", "deno.jsonc", "deno.json"];
+export declare const DENO_CONFIG_FILENAMES: readonly ["deno.jsonc", "deno.json"];
+/**
+ * Removes JSONC extensions (// and block comments, trailing commas) so the
+ * result parses with JSON.parse. String contents — including commas and
+ * comment-looking sequences inside them — are preserved verbatim.
+ */
+export declare function stripJsoncExtensions(text: string): string;
+/**
+ * JSON.parse for JSONC input (comments + trailing commas tolerated).
+ * Empty input parses as `{}`; invalid syntax still throws.
+ */
+export declare function parseJsoncSafe(text: string | Buffer): any;
+/**
+ * Parses an `npm:` import specifier into its package name and version range.
+ * Handles `npm:pkg@ver`, `npm:@scope/pkg@ver`, the path form `npm:/pkg@ver/sub`,
+ * and versionless `npm:pkg` (version `*`).
+ */
+export declare function parseNpmSpecifier(specifier: unknown): {
+    name: string;
+    version: string;
+} | undefined;
+export declare function findDenoConfigPath(projectDir: string): string | undefined;
+/**
+ * Dependencies a deno.json(c) declares through `npm:` specifiers in its
+ * `imports` map. Both the npm package name and the import alias are
+ * registered: the alias is what project source imports, the package name is
+ * what lands in node_modules — dependency checks may ask for either.
+ */
+export declare function readDenoConfigDependencies(denoConfigPath: string): Record<string, string>;
+/**
+ * The project's declared dependencies, merged across every manifest present
+ * in `projectDir`: package.json dependency fields and deno.json(c) `npm:`
+ * imports. package.json wins when both declare the same package.
+ */
+export declare function readProjectDependencies(projectDir: string): Record<string, string>;
+export declare function hasProjectDependency(projectDir: string, packageName: string): boolean;
+/**
+ * Walks up from `startPath` to the nearest directory containing a project
+ * manifest (package.json or deno.json(c)).
+ */
+export declare function findNearestProjectManifestDirSync(startPath: string, maxDepth?: number): string | undefined;
+/**
+ * Find-up variant that returns the manifest file path itself, preferring
+ * package.json when a directory holds more than one manifest. Walks to the
+ * filesystem root, mirroring findNearestPackageJsonSync.
+ */
+export declare function findNearestProjectManifestSync(manifestPath: string): string | null;
+/**
+ * Walks up from the extension manifest to the nearest deno.json(c), mirroring
+ * findNearestPackageJson's contract (walks to the filesystem root).
+ */
+export declare function findNearestDenoConfigSync(manifestPath: string): string | null;
+/** True when the file exists and parses as JSONC. */
+export declare function validateDenoConfig(denoConfigPath: string): boolean;

package/dist/lib/project.d.ts

@@ -0,0 +1,7 @@
+export interface ProjectStructure {
+    manifestPath: string;
+    packageJsonPath?: string;
+    denoJsonPath?: string;
+}
+export declare function getProjectPath(pathOrRemoteUrl: string | undefined): Promise<string>;
+export declare function getProjectStructure(pathOrRemoteUrl: string | undefined): Promise<ProjectStructure>;

package/dist/lib/resource-path.d.ts

@@ -0,0 +1,4 @@
+export declare function canonicalizeDir(dir: string): string;
+export declare function canonicalizeResourcePath(resourcePath: string): string;
+export declare function toResourceKey(resourcePath: string): string;
+export declare function isResourceUnderDirs(resource: string, dirs: string[]): boolean;

package/dist/lib/rust-min-stack.d.ts

@@ -0,0 +1,2 @@
+export declare const RUST_MIN_STACK_BYTES: number;
+export declare function ensureRustMinStack(env?: NodeJS.ProcessEnv): void;

package/dist/lib/sanitize.d.ts

@@ -0,0 +1 @@
+export declare function sanitize<T extends Record<string, any>>(obj: T): Partial<T>;

package/dist/lib/session-paths.d.ts

@@ -0,0 +1,39 @@
+/**
+ * THE owner of every on-disk session-state path. Dev sessions are
+ * per project+browser, so every artifact here must embed the browser key —
+ * a per-project single slot gets clobbered the moment a second browser
+ * session starts on the same project (the control.token defect: session B's
+ * start overwrote session A's eval token, and either shutdown deleted it
+ * for both). New artifacts MUST be registered in SESSION_ARTIFACTS; the
+ * layout spec fails any per-project shape that isn't an explicitly
+ * allowlisted legacy slot, and a repo-scan spec fails path joins that
+ * bypass this module.
+ *
+ * Two roots with different lifetimes:
+ * - `<project>/.extension-js/` survives dist wipes. Anything a browser
+ *   profile may have baked in (ports, tokens) lives here — a profile can
+ *   outlive dist/, and state that dies with dist strands the profile's
+ *   cached service worker (issue #484).
+ * - `<project>/dist/extension-js/<browser>/` dies with dist. Machine
+ *   contracts and logs that describe the CURRENT session only.
+ */
+export declare function sessionStateDir(projectPath: string): string;
+export declare function controlPortFilePath(projectPath: string, browser: string): string;
+/** Pre-#484 location: died with dist/ while profiles outlived it. Read-only
+ * fallback so a 4.0.6-era profile's cached SW can still resync. */
+export declare function legacyControlPortFilePath(projectPath: string, browser: string): string;
+export declare function controlTokenPath(projectPath: string, browser: string): string;
+/** Pre-fix single-slot token shared by every browser session of a project. */
+export declare function legacyControlTokenPath(projectPath: string): string;
+export declare function browserArtifactsDir(projectPath: string, browser: string): string;
+export declare function readyContractPath(projectPath: string, browser: string): string;
+export declare function eventsPath(projectPath: string, browser: string): string;
+export declare function logsPath(projectPath: string, browser: string): string;
+export declare function actionsPath(projectPath: string, browser: string): string;
+export type SessionArtifactKeying = 'per-browser' | 'legacy-shared' | 'legacy-per-browser-in-dist';
+export interface SessionArtifact {
+    name: string;
+    keying: SessionArtifactKeying;
+    build: (projectPath: string, browser: string) => string;
+}
+export declare const SESSION_ARTIFACTS: ReadonlyArray<SessionArtifact>;

package/dist/lib/stats-handler.d.ts

@@ -0,0 +1 @@
+export declare function handleStatsErrors(stats: any): void;

package/dist/lib/transpile-packages.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Resolves package roots for transpile allowlist entries.
+ * We keep both the symlinked package path and its real path so include/exclude
+ * checks work across npm/pnpm/yarn and different symlink modes.
+ */
+export declare function resolveTranspilePackageDirs(projectRoot: string, transpilePackages?: string[]): string[];
+export declare function isSubPath(resourcePath: string, directoryPath: string): boolean;

package/dist/lib/validate-user-dependencies.d.ts

@@ -0,0 +1 @@
+export declare function assertNoManagedDependencyConflicts(userManifestPath: string, projectPath: string): void;

package/dist/lib/zip.d.ts

@@ -0,0 +1,2 @@
+export declare function downloadAndExtractZip(url: string, targetPath: string): Promise<string>;
+export declare function extractLocalZip(zipFilePath: string, targetPath: string): Promise<string>;

package/dist/module.d.ts

@@ -0,0 +1,8 @@
+import './lib/rust-min-stack';
+import { extensionBuild } from './command-build';
+import { extensionDev } from './command-dev';
+import { extensionPreview } from './command-preview';
+import { type FileConfig, type BuildOptions, type DevOptions, type PreviewOptions, type Manifest } from './types';
+import { BuildEmitter, type CompiledEvent, type BuildErrorEvent, type BrowserLauncherFn, type BrowserLaunchOptions, type BrowserController } from './plugin-browsers';
+import { type ReloadType, type ReloadInstruction } from './plugin-reload';
+export { extensionBuild, BuildOptions, extensionDev, DevOptions, extensionPreview, PreviewOptions, FileConfig, Manifest, BuildEmitter, CompiledEvent, BuildErrorEvent, ReloadType, ReloadInstruction, BrowserLauncherFn, BrowserLaunchOptions, BrowserController };

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

@@ -0,0 +1,108 @@
+import { EventEmitter } from 'node:events';
+import type { Compiler } from '@rspack/core';
+import { type ReloadBroker, type ReloadInstruction } from '../plugin-reload';
+export interface CompiledEvent {
+    outputPath: string;
+    contextDir: string;
+    isFirstCompile: boolean;
+    reloadInstruction?: ReloadInstruction;
+    extensionsToLoad?: string[];
+}
+export interface BuildErrorEvent {
+    errors: string[];
+}
+export interface BuildEventMap {
+    compiled: [CompiledEvent];
+    error: [BuildErrorEvent];
+    close: [];
+}
+export declare class BuildEmitter extends EventEmitter<BuildEventMap> {
+    constructor();
+}
+export interface BrowserLaunchOptions {
+    browser: string;
+    outputPath: string;
+    contextDir: string;
+    extensionsToLoad: string[];
+    mode?: 'development' | 'production';
+    enableDevtools?: boolean;
+    noOpen?: boolean;
+    profile?: string | false;
+    persistProfile?: boolean;
+    keepProfileChanges?: boolean;
+    copyFromProfile?: string;
+    preferences?: Record<string, unknown>;
+    browserFlags?: string[];
+    excludeBrowserFlags?: string[];
+    startingUrl?: string;
+    chromiumBinary?: string;
+    geckoBinary?: string;
+    instanceId?: string;
+    port?: number | string;
+    dryRun?: boolean;
+    logLevel?: string;
+    logContexts?: string[];
+    logFormat?: 'pretty' | 'json' | 'ndjson';
+    logTimestamps?: boolean;
+    logColor?: boolean;
+    logUrl?: string;
+    logTab?: number | string;
+}
+export interface BrowserController {
+    enableUnifiedLogging(opts: {
+        level?: string;
+        contexts?: string[];
+        format?: 'pretty' | 'json' | 'ndjson';
+        timestamps?: boolean;
+        color?: boolean;
+        urlFilter?: string;
+        tabFilter?: number | string;
+    }): Promise<void>;
+}
+export type BrowserLauncherFn = (opts: BrowserLaunchOptions) => Promise<BrowserController>;
+export interface RunnerPlugin {
+    readonly emitter: BuildEmitter;
+    extensionsToLoad: string[];
+    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;
+    private reloadBroker;
+    constructor(options: BrowsersPluginOptions);
+    /**
+     * Option B: 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;
+    apply(compiler: Compiler): void;
+}

package/dist/plugin-browsers/safari-dev-plugin.d.ts

@@ -0,0 +1,19 @@
+import type { Compiler } from '@rspack/core';
+import { BuildEmitter, type RunnerPlugin } from './index';
+export type SafariPackagerFn = (distPath: string, mode: 'full' | 'resync') => Promise<void>;
+export declare class SafariDevPlugin implements RunnerPlugin {
+    private readonly packager;
+    static readonly name = "safari-dev";
+    readonly emitter: BuildEmitter;
+    extensionsToLoad: string[];
+    private firstRun;
+    private active;
+    private pending;
+    private idleWaiters;
+    constructor(packager: SafariPackagerFn);
+    apply(compiler: Compiler): void;
+    idle(): Promise<void>;
+    private drain;
+    private runOne;
+    private settleIdle;
+}

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

@@ -0,0 +1,5 @@
+import type { DevOptions } from '../../types';
+export declare function webextensionPolyfillNotFound(): string;
+export declare function compatibilityPolyfillEnabled(browser: DevOptions['browser'], polyfillPath: string): string;
+export declare function compatibilityPolyfillSkipped(reason: string, browser: DevOptions['browser']): string;
+export declare function compatibilityPolyfillDisabled(browser: DevOptions['browser']): string;

package/dist/plugin-compatibility/feature-polyfill.d.ts

@@ -0,0 +1,11 @@
+import { Compiler } from '@rspack/core';
+import type { PluginInterface, DevOptions } from '../types';
+/**
+ * PolyfillPlugin is responsible for providing the `browser`
+ * global variable to the extension's codebase.
+ */
+export declare class PolyfillPlugin {
+    readonly browser: DevOptions['browser'];
+    constructor(options: PluginInterface);
+    apply(compiler: Compiler): void;
+}