extension-develop 4.1.19 → 4.1.21

package/dist/plugin-web-extension/feature-manifest/manifest-lib/sanitize-fatal-shapes.d.ts

@@ -3,42 +3,6 @@ export interface FatalShapeFix {
     field: string;
     detail: string;
 }
-/**
- * Repair author-manifest shapes that make Chrome refuse to load the whole
- * extension. Loading via --load-extension surfaces the refusal as a native
- * modal dialog (no CDP, no console), so a dev session just wedges, the
- * browser never binds its debug endpoint. Both shapes below were found in
- * the wild and are unambiguous to fix:
- *
- * - `"name"` missing, empty, or not a string, Chrome refuses with
- *   "Required value 'name' is missing or invalid" (verified live on Chrome
- *   150 via CDP loadUnpacked for all three shapes). Coerce scalars,
- *   fall back to "Unnamed Extension".
- * - `"version"` missing entirely, Chrome refuses with "Required value
- *   'version' is missing or invalid" (wild: Ananyakk71/javscript). Inject
- *   "0.0.0" so the session can attach.
- * - `"version": 1.0`, JSON authors write a number; Chrome requires a string
- *   of 1-4 dot-separated integers. String() preserves the intent.
- * - `"version": "x.y.z"` (any string that is not 1-4 dot-separated integers
- *   0-65535), a placeholder the author never filled in; Chrome refuses the
- *   whole extension over it. Salvage the numeric parts when there are any,
- *   fall back to "0.0.0" otherwise.
- * - `"default_icon": ""` (in action/browser_action/page_action), an empty
- *   icon path rejects the extension. Empty means "no icon": drop the key.
- * - An icon path (`icons`, `*_action.default_icon`) whose file exists but is
- *   0 bytes (wild: Speak2Type ships an empty icon-128.png), Chrome cannot
- *   decode it and refuses the whole extension with "Could not load icon".
- *   Requires `manifestDir` to resolve the paths; drop the entry.
- * - `'unsafe-inline'` in `content_security_policy.extension_pages`
- *   script-src, Chrome refuses the whole extension with "Insecure CSP
- *   value" (wild: zenwerk/tonikakuyare). MV3 never honors it, so stripping
- *   it changes nothing but the refusal.
- * - A named (non-`_execute_*`) command whose `description` is missing,
- *   empty, or not a string, Chrome refuses the whole extension with
- *   "Invalid value for 'commands[N].description'" (seen live loading a
- *   built extension). Fall back to the command name so the shortcut stays
- *   registered and the session can attach.
- */
 export declare function sanitizeFatalManifestShapes(manifest: Manifest, manifestDir?: string): {
     manifest: Manifest;
     fixes: FatalShapeFix[];

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

@@ -13,6 +13,26 @@ export declare function manifestLegacyWarningsSummary(count: number): string;
 export declare function pageActionNotSupportedByBrowser(browser: string): string;
 export declare function pageActionDroppedForBrowserAction(browser: string): string;
 export declare function vendorPrefixedKeyDropped(key: string, familyKey: string, vendor: 'chrome' | 'edge', browser: string): string;
+export declare function manifestVersionLostForBrowser(browser: string, prefixedKeys: string[], resolved: unknown): string;
+export declare function edgeStoreKeyDropped(browser: string): string;
 export declare function mv2SandboxPolicyDropped(browser: string): string;
 export declare function geckoSidePanelUnsupported(file: string): string;
+export declare function safariSidePanelUnsupported(file: string): string;
+export declare function safariOffscreenUnsupported(file: string): string;
+export declare function safariTabGroupsUnsupported(file: string): string;
+export declare function safariManagementUnsupported(file: string): string;
+export declare function safariUserScriptsUnsupported(file: string): string;
+export declare function safariIdentityUnsupported(file: string): string;
+export declare function safariNotificationsUnsupported(file: string): string;
+export declare function safariOmniboxUnsupported(file: string): string;
+export declare function safariBookmarksUnsupported(file: string): string;
+export declare function safariHistoryUnsupported(file: string): string;
+export declare function safariDownloadsUnsupported(file: string): string;
+export declare function safariIdleUnsupported(file: string): string;
+export declare const safariMissingMemberDetails: Record<string, string>;
+export declare function safariMemberUnsupported(file: string, api: string, member: string, kind: 'call' | 'read'): string;
 export declare function geckoActionUnsupportedOnMv2(file: string): string;
+export declare function webkitUnsupportedKeysDropped(browser: string, dropped: Array<{
+    path: string;
+    reason: string;
+}>): string;

package/dist/plugin-web-extension/feature-manifest/steps/apply-dev-defaults-lib/dev-injected-hosts.d.ts

@@ -16,10 +16,5 @@ interface ScannableModule {
 }
 export declare function isContentScriptModule(module: ScannableModule): boolean;
 export declare function findAbsoluteRequestUrls(source: string): string[];
-/**
- * Finds absolute request URLs whose host is granted only because dev unioned
- * the content-script matches into the manifest. Content-script modules are
- * skipped: their requests answer to page CORS rather than host permissions.
- */
 export declare function findInjectedOnlyHostUses(modules: Iterable<ScannableModule>, injected: readonly string[], declared: readonly string[], optional: readonly string[]): InjectedOnlyHostUse[];
 export {};

package/dist/plugin-web-extension/feature-manifest/steps/apply-dev-defaults-lib/emitted-evidence.d.ts

@@ -0,0 +1,22 @@
+export interface EmittedModule {
+    resource?: string;
+    modules?: Iterable<EmittedModule>;
+}
+export interface EmittedChunk {
+    files?: Iterable<string>;
+}
+export interface EmittedCompilation {
+    getAssets?: () => readonly {
+        name: string;
+        source: {
+            source(): string | Buffer;
+        };
+    }[];
+    chunkGraph?: {
+        getModuleChunksIterable(module: EmittedModule): Iterable<EmittedChunk>;
+    };
+}
+export declare function shippableText(text: string): string;
+export declare function readEmittedScripts(compilation: EmittedCompilation): Map<string, string>;
+export declare function readProjectSource(resource: string): string | undefined;
+export declare function emittedFilesOf(compilation: EmittedCompilation, module: EmittedModule): string[] | undefined;

package/dist/plugin-web-extension/feature-manifest/steps/apply-dev-defaults-lib/patch-background.d.ts

@@ -1,5 +1,14 @@
 import type { DevOptions, Manifest } from '../../../../types.js';
 export default function patchBackground(manifest: Manifest, browser: DevOptions['browser']): {
+    background: ({
+        scripts?: string[] | undefined;
+        page?: string | undefined;
+        persistent?: boolean | undefined;
+    } & {
+        service_worker: string;
+        type?: "module";
+    }) | undefined;
+} | {
     background: {
         scripts?: string[] | undefined;
         page?: string | undefined;

package/dist/plugin-web-extension/feature-manifest/steps/apply-dev-defaults-lib/patch-web-resources.d.ts

@@ -1,19 +1,10 @@
 import type { Manifest } from '../../../../types.js';
+export declare const DEV_RUNTIME_RESOURCES: string[];
 declare function patchWebResourcesV2(manifest: Manifest): string[];
-declare function patchWebResourcesV3(manifest: Manifest): ({
-    resources: string[];
-    matches: string[];
-} | (string & {
-    resources: string[];
-    use_dynamic_url?: boolean | undefined;
-} & {
-    extension_ids: string[];
-    matches?: string[] | undefined;
-}) | (string & {
-    resources: string[];
-    use_dynamic_url?: boolean | undefined;
-} & {
-    matches: string[];
-    extension_ids?: string[] | undefined;
-}))[];
+declare function patchWebResourcesV3(manifest: Manifest): unknown[];
+export declare function patchWebResources(manifest: Manifest): {
+    web_accessible_resources?: undefined;
+} | {
+    web_accessible_resources: Manifest['web_accessible_resources'];
+};
 export { patchWebResourcesV2, patchWebResourcesV3 };

package/dist/plugin-web-extension/feature-manifest/steps/apply-dev-defaults.d.ts

@@ -1,6 +1,10 @@
-import { Compilation, type Compiler } from '@rspack/core';
+import { type Compiler } from '@rspack/core';
 import type { PluginInterface } from '../../../types.js';
-export declare function findInjectedOnlyPermissionUses(compilation: Pick<Compilation, 'modules'>, declared: Set<string>, injected: readonly string[]): Map<string, string>;
+import { type EmittedCompilation, type EmittedModule } from './apply-dev-defaults-lib/emitted-evidence.js';
+export interface PermissionScanCompilation extends EmittedCompilation {
+    modules: Iterable<EmittedModule>;
+}
+export declare function findInjectedOnlyPermissionUses(compilation: PermissionScanCompilation, declared: Set<string>, injected: readonly string[]): Map<string, string>;
 export declare class ApplyDevDefaults {
     private readonly manifestPath?;
     private readonly browser;

package/dist/plugin-web-extension/feature-manifest/steps/patch-war.d.ts

@@ -1,10 +1,5 @@
 import { type Compiler } from '@rspack/core';
 import type { DevOptions, PluginInterface } from '../../../types.js';
-/**
- * Patches manifest.json with web_accessible_resources from content script
- * imports. Depends on CollectContentEntryImports (feature-web-resources)
- * populating getSharedFor(compilation).entryImports before this runs.
- */
 export declare class PatchWAR {
     readonly manifestPath: string;
     readonly browser?: DevOptions['browser'];

package/dist/plugin-web-extension/feature-manifest/steps/patch-webkit-background.d.ts

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

package/dist/plugin-web-extension/feature-manifest/steps/update-manifest.d.ts

@@ -4,6 +4,7 @@ export declare class UpdateManifest {
     readonly manifestPath: string;
     readonly browser: DevOptions['browser'];
     private reportedFatalFixes;
+    private reportedUnsupportedApis;
     constructor(options: PluginInterface);
     private applyDevOverrides;
     apply(compiler: Compiler): void;

package/dist/plugin-web-extension/feature-manifest/steps/warn-gecko-unsupported-apis.d.ts

@@ -1,40 +1,133 @@
 import { type Compilation, type Compiler } from '@rspack/core';
 import type { DevOptions, Manifest } from '../../../types.js';
-export type GeckoUnsupportedApi = 'sidePanel' | 'action';
+import * as messages from '../messages.js';
+import { type EmittedCompilation } from './apply-dev-defaults-lib/emitted-evidence.js';
+declare const webkitUnsupportedApis: {
+    readonly sidePanel: typeof messages.safariSidePanelUnsupported;
+    readonly offscreen: typeof messages.safariOffscreenUnsupported;
+    readonly tabGroups: typeof messages.safariTabGroupsUnsupported;
+    readonly management: typeof messages.safariManagementUnsupported;
+    readonly userScripts: typeof messages.safariUserScriptsUnsupported;
+    readonly identity: typeof messages.safariIdentityUnsupported;
+    readonly notifications: typeof messages.safariNotificationsUnsupported;
+    readonly omnibox: typeof messages.safariOmniboxUnsupported;
+    readonly bookmarks: typeof messages.safariBookmarksUnsupported;
+    readonly history: typeof messages.safariHistoryUnsupported;
+    readonly downloads: typeof messages.safariDownloadsUnsupported;
+    readonly idle: typeof messages.safariIdleUnsupported;
+};
+type WebkitUnsupportedApi = keyof typeof webkitUnsupportedApis;
+export type GeckoUnsupportedApi = WebkitUnsupportedApi | 'action';
+export interface WebkitUnsupportedMember {
+    api: string;
+    member: string;
+    kind: 'call' | 'read';
+}
+export declare const webkitUnsupportedMembers: readonly [{
+    readonly api: 'action';
+    readonly member: 'getUserSettings';
+    readonly kind: 'call';
+}, {
+    readonly api: 'action';
+    readonly member: 'getBadgeTextColor';
+    readonly kind: 'call';
+}, {
+    readonly api: 'action';
+    readonly member: 'setBadgeTextColor';
+    readonly kind: 'call';
+}, {
+    readonly api: 'action';
+    readonly member: 'onUserSettingsChanged';
+    readonly kind: 'read';
+}, {
+    readonly api: 'storage';
+    readonly member: 'managed';
+    readonly kind: 'read';
+}, {
+    readonly api: 'runtime';
+    readonly member: 'getContexts';
+    readonly kind: 'call';
+}, {
+    readonly api: 'runtime';
+    readonly member: 'onSuspend';
+    readonly kind: 'read';
+}, {
+    readonly api: 'runtime';
+    readonly member: 'onSuspendCanceled';
+    readonly kind: 'read';
+}, {
+    readonly api: 'runtime';
+    readonly member: 'onUpdateAvailable';
+    readonly kind: 'read';
+}, {
+    readonly api: 'declarativeNetRequest';
+    readonly member: 'getAvailableStaticRuleCount';
+    readonly kind: 'call';
+}, {
+    readonly api: 'declarativeNetRequest';
+    readonly member: 'getDisabledRuleIds';
+    readonly kind: 'call';
+}, {
+    readonly api: 'declarativeNetRequest';
+    readonly member: 'updateStaticRules';
+    readonly kind: 'call';
+}, {
+    readonly api: 'declarativeNetRequest';
+    readonly member: 'testMatchOutcome';
+    readonly kind: 'call';
+}, {
+    readonly api: 'declarativeNetRequest';
+    readonly member: 'onRuleMatchedDebug';
+    readonly kind: 'read';
+}, {
+    readonly api: 'tabs';
+    readonly member: 'group';
+    readonly kind: 'call';
+}, {
+    readonly api: 'tabs';
+    readonly member: 'ungroup';
+    readonly kind: 'call';
+}, {
+    readonly api: 'webNavigation';
+    readonly member: 'onCreatedNavigationTarget';
+    readonly kind: 'read';
+}, {
+    readonly api: 'webNavigation';
+    readonly member: 'onHistoryStateUpdated';
+    readonly kind: 'read';
+}, {
+    readonly api: 'webNavigation';
+    readonly member: 'onReferenceFragmentUpdated';
+    readonly kind: 'read';
+}, {
+    readonly api: 'webNavigation';
+    readonly member: 'onTabReplaced';
+    readonly kind: 'read';
+}, {
+    readonly api: 'windows';
+    readonly member: 'onBoundsChanged';
+    readonly kind: 'read';
+}];
+export type WebkitMemberApi = (typeof webkitUnsupportedMembers)[number]['api'];
+export type UnsupportedApiName = GeckoUnsupportedApi | WebkitMemberApi;
+export type UnsupportedApiEngine = 'gecko' | 'webkit';
 export interface GeckoUnsupportedApiUse {
-    api: GeckoUnsupportedApi;
+    api: UnsupportedApiName;
+    member?: string;
     file: string;
     emitted: boolean;
 }
-export declare function geckoUnsupportedApis(manifestVersion: unknown): GeckoUnsupportedApi[];
-export declare function usesGeckoUnsupportedApi(source: string, api: GeckoUnsupportedApi): boolean;
+export declare function geckoUnsupportedApis(manifestVersion: unknown, engine?: UnsupportedApiEngine): GeckoUnsupportedApi[];
+export declare function usesGeckoUnsupportedApi(source: string, api: GeckoUnsupportedApi, engine?: UnsupportedApiEngine): boolean;
+export declare function usesWebkitUnsupportedMember(source: string, entry: WebkitUnsupportedMember): boolean;
 interface ScannableModule {
     resource?: string;
     modules?: Iterable<ScannableModule>;
     rootModule?: ScannableModule;
 }
-interface ScannableChunk {
-    files?: Iterable<string>;
-}
-export interface ScannableCompilation {
+export interface ScannableCompilation extends EmittedCompilation {
     modules: Iterable<ScannableModule>;
-    getAssets?: () => readonly {
-        name: string;
-        source: {
-            source(): string | Buffer;
-        };
-    }[];
-    chunkGraph?: {
-        getModuleChunksIterable(module: ScannableModule): Iterable<ScannableChunk>;
-    };
 }
-/**
- * Finds project source that reads a Chromium-only API and still ships in the
- * built Gecko bundle. The source scan names the file, the emitted-asset check
- * clears a call the bundler compiled out behind a build-time browser branch,
- * and an emitted script nobody explains is reported under its own name so
- * nothing addons-linter would flag goes unmentioned.
- */
-export declare function findGeckoUnsupportedApiUses(compilation: ScannableCompilation, manifestVersion: unknown): GeckoUnsupportedApiUse[];
-export declare function reportGeckoUnsupportedApis(compilation: Compilation, compiler: Compiler, browser: DevOptions['browser'], manifest: Manifest, projectPath: string): void;
+export declare function findGeckoUnsupportedApiUses(compilation: ScannableCompilation, manifestVersion: unknown, engine?: UnsupportedApiEngine, requireEmittedEvidence?: boolean): GeckoUnsupportedApiUse[];
+export declare function reportGeckoUnsupportedApis(compilation: Compilation, compiler: Compiler, browser: DevOptions['browser'], manifest: Manifest, projectPath: string, reported?: Set<string>): void;
 export {};

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

@@ -1,15 +1,5 @@
 import type { Compiler } from '@rspack/core';
 import type { DevOptions, FilepathList, PluginInterface } from '../../types.js';
-/**
- * Feature-scripts is the official scripts pipeline:
- * - content scripts use the inline lifecycle runtime only
- * - targeted reinjection stays browser-owned
- * - background/manifest changes stay on the full-reload path
- *
- * The dev-only reload/HMR strategy is NOT part of this feature. It lives
- * in plugin-reload, which registers after this plugin and decorates the
- * entries AddScripts declares here.
- */
 export declare class ScriptsPlugin {
     readonly manifestPath: string;
     readonly includeList?: FilepathList;

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

@@ -20,6 +20,11 @@ declare const SPLIT_ENTRY_SURFACES: {
     };
 };
 export declare function entrySplitAcrossInitialFiles(entryName: string, surface: keyof typeof SPLIT_ENTRY_SURFACES, ownFile: string, extraFiles: string[]): string;
+declare const PAGE_CONTEXT_SURFACES: {
+    readonly content_script: 'a content script';
+    readonly script: 'an injected script';
+};
+export declare function workerStartedFromPageContext(assetName: string, surface: keyof typeof PAGE_CONTEXT_SURFACES): string;
 export declare function fetchedFileDependencyMissing(assetName: string, literal: string, expectedPath: string): string;
 export declare function getURLDependencyMissing(assetName: string, literal: string, expectedPath: string): string;
 export declare function runtimeSetSurfaceDependencyMissing(assetName: string, literal: string, expectedPath: string): string;

package/dist/plugin-web-extension/feature-scripts/steps/native-geturl-import-loader.d.ts

@@ -1,7 +1,4 @@
 export declare function annotateGetURLDynamicImports(source: string): string;
-/** Loader entry: source-to-source, before the swc transform. The map that
- * arrived travels on: the annotation adds a comment inside a line, never a
- * line, so the line map of the loader before this one still holds. */
 export default function nativeGetURLImportLoader(this: {
     callback?: (error: Error | null, content: string, map?: unknown) => void;
     resourcePath?: string;

package/dist/plugin-web-extension/feature-scripts/steps/warn-page-context-worker.d.ts

@@ -0,0 +1,5 @@
+import { type Compiler } from '@rspack/core';
+export declare function startsWorkerFromExtensionUrl(source: string): boolean;
+export declare class WarnPageContextWorker {
+    apply(compiler: Compiler): void;
+}

package/dist/plugin-web-extension/feature-web-resources/collect-entry-imports.d.ts

@@ -6,4 +6,5 @@ export declare const EMITTED_ASSET_REF_PATTERN: RegExp;
 export declare function listEmittedAssetNames(compilation: Compilation): string[];
 export declare function collectReferencedRuntimePayloads(source: string, emittedAssetNames: string[]): string[];
 export declare function collectContentScriptAsyncChunkFiles(compilation: Compilation): Record<string, string[]>;
+export declare function collectPageContextEntryFiles(compilation: Compilation): Record<string, string[]>;
 export declare function collectContentScriptEntryImports(compilation: Compilation, includeList?: FilepathList): Record<string, string[]>;

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

@@ -1,15 +1,5 @@
 import type { Compiler } from '@rspack/core';
 import type { FilepathList, PluginInterface } from '../../types.js';
-/**
- * ResourcesPlugin collects content script imports for manifest WAR patching.
- * Actual manifest patching is done by ManifestPlugin (PatchWAR step) so all
- * manifest writes stay consolidated in feature-manifest.
- *
- * Feature supported:
- *
- * - Collects assets imported from content_scripts files.
- * - WAR patching uses this data (via getSharedFor) in manifest:patch-war.
- */
 export declare class WebResourcesPlugin {
     readonly manifestPath: string;
     readonly includeList?: FilepathList;

package/dist/plugin-web-extension/feature-web-resources/web-resources-lib/clean-matches.d.ts

@@ -1,7 +1 @@
-/**
- * From the docs at https://developer.chrome.com/docs/extensions/reference/manifest/web-accessible-resources#manifest_declaration
- * > Google Chrome emits an "Invalid match pattern" error if the pattern has a path other than '/*'.
- *
- * We need to ensure that paths are cleaned up from the matches to avoid this error.
- */
 export declare function cleanMatches(matches: string[]): string[];

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

@@ -6,5 +6,6 @@ export declare function warFieldError(filePath: string, opts?: {
 }): string;
 export declare function warStringEntryInMv3(entry: string): string;
 export declare function warInvalidMatchPattern(pattern: string): string;
+export declare function warUnreachableResource(resource: string, entryName: string): string;
 export declare function entryImportsSummary(entryCount: number, totalResources: number): string;
 export declare function warPatchedSummary(v3Groups: number, v3ResourcesTotal: number, v2Resources: number): string;

package/dist/plugin-web-extension/feature-web-resources/web-resources-lib/unreachable-resources.d.ts

@@ -0,0 +1,9 @@
+export declare function normalizeResourcePath(value: string): string;
+export declare function isResourceCovered(declared: readonly string[], candidate: string): boolean;
+export declare const GET_URL_LITERAL_PATTERN: RegExp;
+export declare function collectGetUrlLiterals(source: string): string[];
+export declare function findUnreachableRuntimeResources(options: {
+    source: string;
+    emittedAssetNames: readonly string[];
+    declaredResources: readonly string[];
+}): string[];

package/dist/plugin-web-extension/shared/discover-devtools-panels.d.ts

@@ -1,8 +1,2 @@
 import type { DevOptions, FilepathList } from '../../types.js';
-/**
- * Statically discovers HTML pages referenced only through
- * chrome.devtools.panels.create in the devtools page's scripts, and returns
- * them as extra HTML entries keyed by their extension-root-relative path so
- * the emitted dist serves the exact URL Chrome will request.
- */
 export declare function discoverDevtoolsPanelPages(manifestPath: string, browser?: DevOptions['browser']): FilepathList;

package/dist/plugin-web-extension/shared/paths.d.ts

@@ -3,6 +3,5 @@ export declare function isFromFilepathList(filePath: string, filepathList?: File
 export declare function getFilename(feature: string, filePath: string): string;
 export declare function unixify(filePath: string): string;
 export declare function resolveRootAbsoluteRef(ref: string, projectRoot: string, publicRoot?: string): string | undefined;
-/** Root-absolute refs in HTML (`src`/`href`) and CSS (`url(...)`). */
 export declare function collectRootAbsoluteRefs(source: string): Set<string>;
 export declare function isManifestAddress(value: unknown): boolean;

package/dist/rspack-config.d.ts

@@ -1,4 +1,4 @@
-import type { Configuration } from '@rspack/core';
+import { type Configuration } from '@rspack/core';
 import type { ProjectStructure } from './lib/project.js';
 import type { WebpackConfigOptions } from './types.js';
 export default function webpackConfig(projectStructure: ProjectStructure, devOptions: WebpackConfigOptions): Configuration;