extension-develop 3.9.0-next.3 → 3.9.0-next.5

package/dist/323.cjs

@@ -268,20 +268,7 @@ exports.modules = {
         class CDPExtensionController {
             async connect() {
                 if (this.cdp) return;
-                this.cdp = await connectToChromeCdp(this.cdpPort);
-                try {
-                    await this.cdp.sendCommand('Target.setDiscoverTargets', {
-                        discover: true
-                    });
-                    await this.cdp.sendCommand('Target.setAutoAttach', {
-                        autoAttach: true,
-                        waitForDebuggerOnStart: false,
-                        flatten: true
-                    });
-                } catch (error) {
-                    if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.warn(messages.wXK(String(error?.message || error)));
-                }
-                registerAutoEnableLogging(this.cdp, ()=>this.extensionId);
+                await this.connectFreshClient();
             }
             async ensureLoaded() {
                 if (!this.cdp) throw new Error('CDP not connected');
@@ -414,13 +401,45 @@ exports.modules = {
                 return 'unknown';
             }
             async hardReload() {
-                if (!this.cdp || !this.extensionId) return false;
+                if (!this.extensionId) return false;
                 try {
-                    return await this.cdp.forceReloadExtension(this.extensionId);
+                    if (!this.cdp) await this.connectFreshClient();
+                    if (this.cdp && await this.cdp.forceReloadExtension(this.extensionId)) return true;
+                } catch  {}
+                try {
+                    await this.reconnectForReload();
+                    return Boolean(this.cdp && this.extensionId && await this.cdp.forceReloadExtension(this.extensionId));
                 } catch  {
                     return false;
                 }
             }
+            async connectFreshClient() {
+                this.cdp = await connectToChromeCdp(this.cdpPort);
+                try {
+                    await this.cdp.sendCommand('Target.setDiscoverTargets', {
+                        discover: true
+                    });
+                    await this.cdp.sendCommand('Target.setAutoAttach', {
+                        autoAttach: true,
+                        waitForDebuggerOnStart: false,
+                        flatten: true
+                    });
+                } catch (error) {
+                    if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.warn(messages.wXK(String(error?.message || error)));
+                }
+                registerAutoEnableLogging(this.cdp, ()=>this.extensionId);
+            }
+            async reconnectForReload() {
+                try {
+                    this.cdp?.disconnect?.();
+                } catch  {}
+                this.cdp = null;
+                await this.connectFreshClient();
+                try {
+                    const derivedExtensionId = await this.deriveExtensionIdFromTargets(10, 150);
+                    if (derivedExtensionId) this.extensionId = derivedExtensionId;
+                } catch  {}
+            }
             onProtocolEvent(cb) {
                 if (!this.cdp) throw new Error('CDP not connected');
                 this.cdp.onProtocolEvent((raw)=>{

package/dist/324.cjs

@@ -7,7 +7,10 @@ exports.modules = {
         __webpack_require__.d(__webpack_exports__, {
             devServer: ()=>dev_server_devServer
         });
+        var external_fs_ = __webpack_require__("fs");
+        var external_fs_default = /*#__PURE__*/ __webpack_require__.n(external_fs_);
         var external_path_ = __webpack_require__("path");
+        var external_stream_ = __webpack_require__("stream");
         var core_ = __webpack_require__("@rspack/core");
         var dev_server_ = __webpack_require__("@rspack/dev-server");
         var external_webpack_merge_ = __webpack_require__("webpack-merge");
@@ -88,7 +91,6 @@ exports.modules = {
                 this.basePort = basePort;
             }
         }
-        var external_fs_ = __webpack_require__("fs");
         function hasDependency(projectPath, dependency) {
             const findNearestPackageJsonDirectory = (startPath)=>{
                 let currentDirectory = startPath;
@@ -213,6 +215,139 @@ exports.modules = {
         function shouldWriteAssetToDisk(filePath) {
             return !/(?:^|[/\\])manifest\.json$/i.test(filePath);
         }
+        function isSamePath(left, right) {
+            return external_path_.resolve(left) === external_path_.resolve(right);
+        }
+        function isManifestTempPath(filePath) {
+            const base = external_path_.basename(filePath);
+            return base.startsWith('.manifest.') && base.endsWith('.tmp');
+        }
+        function createDiscardWriteStream() {
+            const stream = new external_stream_.Writable({
+                write (_chunk, _encoding, callback) {
+                    callback();
+                }
+            });
+            stream.on('finish', ()=>{
+                stream.emit('close');
+            });
+            process.nextTick(()=>{
+                stream.emit('open', 0);
+            });
+            return stream;
+        }
+        const guardedManifestDiskWritePaths = new Set();
+        let isManifestDiskWriteGuardInstalled = false;
+        function hasGuardedManifestDiskPath(filePath) {
+            if ('string' != typeof filePath) return false;
+            const resolvedPath = external_path_.resolve(filePath);
+            for (const guardedPath of guardedManifestDiskWritePaths)if (isSamePath(guardedPath, resolvedPath)) return true;
+            return false;
+        }
+        function suppressManifestOutputWrites(compiler, manifestOutputPath) {
+            const outputFileSystem = compiler?.outputFileSystem;
+            if (!outputFileSystem || outputFileSystem.__extensionjsManifestWriteGuard) return;
+            const isManifestPath = (filePath)=>'string' == typeof filePath && isSamePath(filePath, manifestOutputPath);
+            if ('function' == typeof outputFileSystem.writeFile) {
+                const originalWriteFile = outputFileSystem.writeFile.bind(outputFileSystem);
+                outputFileSystem.writeFile = (filePath, ...args)=>{
+                    if (isManifestPath(filePath)) {
+                        const callback = args[args.length - 1];
+                        if ('function' == typeof callback) callback(null);
+                        return;
+                    }
+                    return originalWriteFile(filePath, ...args);
+                };
+            }
+            if ('function' == typeof outputFileSystem.writeFileSync) {
+                const originalWriteFileSync = outputFileSystem.writeFileSync.bind(outputFileSystem);
+                outputFileSystem.writeFileSync = (filePath, ...args)=>{
+                    if (isManifestPath(filePath)) return;
+                    return originalWriteFileSync(filePath, ...args);
+                };
+            }
+            if ('function' == typeof outputFileSystem.createWriteStream) {
+                const originalCreateWriteStream = outputFileSystem.createWriteStream.bind(outputFileSystem);
+                outputFileSystem.createWriteStream = (filePath, ...args)=>{
+                    if (isManifestPath(filePath)) {
+                        const stream = createDiscardWriteStream();
+                        stream.path = filePath;
+                        return stream;
+                    }
+                    return originalCreateWriteStream(filePath, ...args);
+                };
+            }
+            if ('function' == typeof outputFileSystem?.promises?.writeFile) {
+                const originalPromiseWriteFile = outputFileSystem.promises.writeFile.bind(outputFileSystem.promises);
+                outputFileSystem.promises.writeFile = async (filePath, ...args)=>{
+                    if (isManifestPath(filePath)) return;
+                    return originalPromiseWriteFile(filePath, ...args);
+                };
+            }
+            outputFileSystem.__extensionjsManifestWriteGuard = true;
+        }
+        function installManifestDiskWriteGuard(manifestOutputPath) {
+            const guardKey = external_path_.resolve(manifestOutputPath);
+            guardedManifestDiskWritePaths.add(guardKey);
+            if (isManifestDiskWriteGuardInstalled) return;
+            const guardedFs = external_fs_default();
+            const isManifestPath = (filePath)=>hasGuardedManifestDiskPath(filePath);
+            const allowManifestRename = (fromPath, toPath)=>'string' == typeof fromPath && 'string' == typeof toPath && isManifestPath(toPath) && isManifestTempPath(fromPath);
+            const originalWriteFile = guardedFs.writeFile.bind(guardedFs);
+            guardedFs.writeFile = (filePath, ...args)=>{
+                if (isManifestPath(filePath)) {
+                    const callback = args[args.length - 1];
+                    if ('function' == typeof callback) callback(null);
+                    return;
+                }
+                return originalWriteFile(filePath, ...args);
+            };
+            const originalWriteFileSync = guardedFs.writeFileSync.bind(guardedFs);
+            guardedFs.writeFileSync = (filePath, ...args)=>{
+                if (isManifestPath(filePath)) return;
+                return originalWriteFileSync(filePath, ...args);
+            };
+            const originalCreateWriteStream = guardedFs.createWriteStream.bind(guardedFs);
+            guardedFs.createWriteStream = (filePath, ...args)=>{
+                if (isManifestPath(filePath)) {
+                    const stream = createDiscardWriteStream();
+                    stream.path = String(filePath);
+                    return stream;
+                }
+                return originalCreateWriteStream(filePath, ...args);
+            };
+            const originalOpen = guardedFs.open.bind(guardedFs);
+            guardedFs.open = (pathLike, flags, ...args)=>{
+                const nextPath = isManifestPath(pathLike) ? '/dev/null' : pathLike;
+                return originalOpen(nextPath, flags, ...args);
+            };
+            const originalOpenSync = guardedFs.openSync.bind(guardedFs);
+            guardedFs.openSync = (pathLike, flags, ...args)=>{
+                const nextPath = isManifestPath(pathLike) ? '/dev/null' : pathLike;
+                return originalOpenSync(nextPath, flags, ...args);
+            };
+            const originalRename = guardedFs.rename.bind(guardedFs);
+            guardedFs.rename = (oldPath, newPath, callback)=>{
+                if (isManifestPath(newPath) && !allowManifestRename(oldPath, newPath)) {
+                    if ('function' == typeof callback) callback(null);
+                    return;
+                }
+                return originalRename(oldPath, newPath, callback);
+            };
+            const originalRenameSync = guardedFs.renameSync.bind(guardedFs);
+            guardedFs.renameSync = (oldPath, newPath)=>{
+                if (isManifestPath(newPath) && !allowManifestRename(oldPath, newPath)) return;
+                return originalRenameSync(oldPath, newPath);
+            };
+            if (guardedFs.promises?.writeFile) {
+                const originalPromiseWriteFile = guardedFs.promises.writeFile.bind(guardedFs.promises);
+                guardedFs.promises.writeFile = async (filePath, ...args)=>{
+                    if (isManifestPath(filePath)) return;
+                    return originalPromiseWriteFile(filePath, ...args);
+                };
+            }
+            isManifestDiskWriteGuardInstalled = true;
+        }
         async function dev_server_devServer(projectStructure, devOptions) {
             process.env.EXTENSION_BROWSER_LAUNCH_ENABLED = devOptions.noBrowser ? '0' : '1';
             const { manifestPath, packageJsonPath } = projectStructure;
@@ -272,6 +407,9 @@ exports.modules = {
                 }
             };
             const compiler = (0, core_.rspack)(compilerConfig);
+            const manifestOutputPath = external_path_.join(packageJsonDir, 'dist', devOptions.browser, 'manifest.json');
+            installManifestDiskWriteGuard(manifestOutputPath);
+            suppressManifestOutputWrites(compiler, manifestOutputPath);
             const metadata = (0, plugin_playwright.Ih)({
                 packageJsonDir,
                 browser: String(devOptions.browser || 'chromium'),
@@ -280,7 +418,13 @@ exports.modules = {
                 manifestPath,
                 port
             });
-            (0, compiler_hooks.N)(compiler);
+            (0, compiler_hooks.NP)(compiler);
+            if (devOptions.noBrowser) (0, compiler_hooks.y1)({
+                compiler,
+                browser: String(devOptions.browser || 'chromium'),
+                manifestPath,
+                readyPath: metadata.readyPath
+            });
             if (void 0 !== devOptions.port && devOptions.port !== port) console.log(messages.aO(devOptions.port, port));
             const serverConfig = {
                 host: devServerHost,
@@ -332,16 +476,6 @@ exports.modules = {
                 }, START_TIMEOUT_MS);
                 await devServer.start();
                 if (startTimeout) clearTimeout(startTimeout);
-                if (devOptions.noBrowser) {
-                    console.log(messages.Gc('development', devOptions.browser));
-                    console.log(messages.tl());
-                    console.log(messages.bL({
-                        browser: String(devOptions.browser || 'chromium'),
-                        manifestPath,
-                        readyPath: metadata.readyPath
-                    }));
-                }
-                console.log(messages.tl());
             } catch (error) {
                 if (startTimeout) clearTimeout(startTimeout);
                 metadata.writeError('dev_server_start_failed', error instanceof Error ? error.message : String(error));

package/dist/552.cjs

@@ -11,7 +11,7 @@ exports.modules = {
         function scrubBrand(txt, brand = 'Extension.js') {
             if (!txt) return txt;
             const safeBrand = brand.replace(/\$/g, '$$$$');
-            return txt.replace(RegExp("(?<!@)\\bRspack\\b", "gi"), safeBrand).replace(RegExp("(?<!@)\\bWebpack\\b", "gi"), safeBrand).replace(RegExp("(?<!@)\\bwebpack-dev-server\\b", "gi"), `${safeBrand} dev server`).replace(RegExp("(?<!@)\\bRspackDevServer\\b", "gi"), `${safeBrand} dev server`).replace(/ModuleBuildError:\s*/g, '').replace(/ModuleParseError:\s*/g, '').replace(/Error:\s*Module\s+build\s+failed.*?\n/gi, '').replace(/\n{3,}/g, '\n\n');
+            return txt.replace(RegExp("(?<!@)\\bRspack\\b", "gi"), safeBrand).replace(RegExp("(?<!@)\\bWebpack\\b", "gi"), safeBrand).replace(RegExp("(?<!@)\\bwebpack-dev-server\\b", "gi"), `${safeBrand} dev server`).replace(RegExp("(?<!@)\\bRspackDevServer\\b", "gi"), `${safeBrand} dev server`).replace(/ModuleBuildError:\s*/g, '').replace(/ModuleParseError:\s*/g, '').replace(/Error:\s*Module\s+build\s+failed.*?\n/gi, '').replace(/\n{3,}/g, '\n\n').replace(/\n{2}(?=WARNING in )/g, '\n');
         }
         function makeSanitizedConsole(brand = 'Extension.js') {
             const sanitize = (a)=>'string' == typeof a ? scrubBrand(a, brand) : a;

package/dist/module.cjs

@@ -129186,7 +129186,6 @@ var __webpack_modules__ = {
         async function maybePrintDevBanner(args) {
             const mode = args.compilation?.options?.mode || 'development';
             if ('development' !== mode) return;
-            if (args.enableCdp) return;
             const loadExtensionFlag = args.chromiumConfig.find((flag)=>flag.startsWith('--load-extension='));
             const extensionOutputPath = (0, extension_output_path.W)(args.compilation, loadExtensionFlag);
             if (!extensionOutputPath) return;
@@ -129194,6 +129193,7 @@ var __webpack_modules__ = {
                 timeoutMs: 10000
             });
             if (!ready) return;
+            if (args.enableCdp) return;
             await (0, banner.a)({
                 browser: args.browser,
                 outPath: extensionOutputPath,
@@ -129226,7 +129226,7 @@ var __webpack_modules__ = {
                         if (this.didLaunch) return;
                         await this.launchChromium(stats.compilation);
                         this.didLaunch = true;
-                        if (!this.didReportReady) this.logger.info(dev_server_messages.Gc(stats.compilation.options.mode, this.options.browser));
+                        if (!this.didReportReady) console.log(dev_server_messages.Gc(stats.compilation.options.mode, this.options.browser));
                     } catch (error) {
                         try {
                             this.logger.error(messages._D4(this.options.browser, error));
@@ -129280,9 +129280,10 @@ var __webpack_modules__ = {
                         return 'npx extension install chrome';
                     }
                 };
+                const isAuthorMode = 'true' === process.env.EXTENSION_AUTHOR_MODE;
                 switch(browser){
                     case 'chrome':
-                        console.log(messages.GqE(browser));
+                        if (isAuthorMode) console.log(messages.GqE(browser));
                         if (!skipDetection) try {
                             try {
                                 const located = (0, external_chrome_location2_.locateChromeOrExplain)({
@@ -129319,7 +129320,7 @@ var __webpack_modules__ = {
                         }
                         break;
                     case 'chromium':
-                        console.log(messages.GqE(browser));
+                        if (isAuthorMode) console.log(messages.GqE(browser));
                         browserBinaryLocation = this.options?.chromiumBinary || null;
                         if (this.options?.chromiumBinary) {
                             const normalized = normalizePath(String(this.options.chromiumBinary));
@@ -129339,7 +129340,7 @@ var __webpack_modules__ = {
                         if (!browserBinaryLocation) browserBinaryLocation = resolveWslWindowsBinary(browser);
                         break;
                     case 'edge':
-                        console.log(messages.GqE(browser));
+                        if (isAuthorMode) console.log(messages.GqE(browser));
                         try {
                             const override = String(process.env.EDGE_BINARY || '').trim();
                             if (override) {
@@ -129515,7 +129516,7 @@ var __webpack_modules__ = {
                 if (this.options.dryRun) return void logChromiumDryRun(browserBinaryLocation, chromiumConfig);
                 await this.launchWithDirectSpawn(browserBinaryLocation, chromiumConfig);
                 if ('development' === compilation.options.mode && !this.didReportReady) {
-                    this.logger.info(dev_server_messages.Gc(compilation.options.mode, this.options.browser));
+                    console.log(dev_server_messages.Gc(compilation.options.mode, this.options.browser));
                     this.didReportReady = true;
                 }
                 try {
@@ -129656,6 +129657,42 @@ var __webpack_modules__ = {
                 return;
             }
         }
+        function normalizeManifestFile(filePath) {
+            if ('string' != typeof filePath) return;
+            const normalized = filePath.trim().replace(/^\/+/, '');
+            if (!normalized) return;
+            if (/^(https?:)?\/\//i.test(filePath)) return;
+            if (/[*?[\]{}]/.test(normalized)) return;
+            return normalized;
+        }
+        function getManifestRequiredFiles(content) {
+            try {
+                const manifest = JSON.parse(content);
+                const requiredFiles = new Set();
+                const addFile = (filePath)=>{
+                    const normalized = normalizeManifestFile(filePath);
+                    if (normalized) requiredFiles.add(normalized);
+                };
+                addFile(manifest.background?.service_worker);
+                addFile(manifest.background?.page);
+                if (Array.isArray(manifest.background?.scripts)) for (const script of manifest.background?.scripts || [])addFile(script);
+                addFile(manifest.side_panel?.default_path);
+                if (Array.isArray(manifest.content_scripts)) for (const contentScript of manifest.content_scripts){
+                    if (Array.isArray(contentScript?.js)) for (const jsFile of contentScript.js)addFile(jsFile);
+                    if (Array.isArray(contentScript?.css)) for (const cssFile of contentScript.css)addFile(cssFile);
+                }
+                return [
+                    ...requiredFiles
+                ];
+            } catch  {
+                return [];
+            }
+        }
+        function hasRequiredManifestFiles(outPath, content) {
+            const requiredFiles = getManifestRequiredFiles(content);
+            for (const relativeFile of requiredFiles)if (!fs__rspack_import_0.existsSync(path__rspack_import_1.join(outPath, relativeFile))) return false;
+            return true;
+        }
         async function waitForStableManifest(outPath, options) {
             const timeoutMs = options?.timeoutMs ?? 8000;
             const pollIntervalMs = options?.pollIntervalMs ?? 150;
@@ -129666,7 +129703,7 @@ var __webpack_modules__ = {
             let stableReads = 0;
             while(Date.now() - start < timeoutMs){
                 const currentContent = readValidManifest(manifestPath);
-                if (currentContent) {
+                if (currentContent && hasRequiredManifestFiles(outPath, currentContent)) {
                     if (currentContent === lastValidContent) stableReads += 1;
                     else {
                         lastValidContent = currentContent;
@@ -135379,7 +135416,7 @@ var __webpack_modules__ = {
     },
     "./package.json" (module) {
         "use strict";
-        module.exports = JSON.parse('{"rE":"3.9.0-next.3","El":{"@rspack/core":"^1.7.5","@rspack/dev-server":"^1.1.5","@swc/core":"^1.15.8","@swc/helpers":"^0.5.18","adm-zip":"^0.5.16","browser-extension-manifest-fields":"^2.2.1","case-sensitive-paths-webpack-plugin":"^2.4.0","chrome-location2":"4.0.0","chromium-location":"2.0.0","content-security-policy-parser":"^0.6.0","cross-spawn":"^7.0.6","dotenv":"^17.2.3","edge-location":"2.2.0","extension-from-store":"^0.1.1","firefox-location2":"3.0.0","go-git-it":"^5.1.1","ignore":"^7.0.5","loader-utils":"^3.3.1","magic-string":"^0.30.21","parse5":"^8.0.0","parse5-utilities":"^1.0.0","pintor":"0.3.0","schema-utils":"^4.3.3","tiny-glob":"^0.2.9","unique-names-generator":"^4.7.1","webextension-polyfill":"^0.12.0","webpack-merge":"^6.0.1","webpack-target-webextension":"^2.1.3","ws":"^8.19.0"}}');
+        module.exports = JSON.parse('{"rE":"3.9.0-next.5","El":{"@rspack/core":"^1.7.5","@rspack/dev-server":"^1.1.5","@swc/core":"^1.15.8","@swc/helpers":"^0.5.18","adm-zip":"^0.5.16","browser-extension-manifest-fields":"^2.2.1","case-sensitive-paths-webpack-plugin":"^2.4.0","chrome-location2":"4.0.0","chromium-location":"2.0.0","content-security-policy-parser":"^0.6.0","cross-spawn":"^7.0.6","dotenv":"^17.2.3","edge-location":"2.2.0","extension-from-store":"^0.1.1","firefox-location2":"3.0.0","go-git-it":"^5.1.1","ignore":"^7.0.5","loader-utils":"^3.3.1","magic-string":"^0.30.21","parse5":"^8.0.0","parse5-utilities":"^1.0.0","pintor":"0.3.0","schema-utils":"^4.3.3","tiny-glob":"^0.2.9","unique-names-generator":"^4.7.1","webextension-polyfill":"^0.12.0","webpack-merge":"^6.0.1","webpack-target-webextension":"^2.1.3","ws":"^8.19.0"}}');
     }
 };
 var __webpack_module_cache__ = {};
@@ -136259,7 +136296,7 @@ var __webpack_exports__ = {};
                 __webpack_require__.e("552").then(__webpack_require__.bind(__webpack_require__, "./webpack/webpack-lib/stats-handler.ts")),
                 Promise.all([
                     __webpack_require__.e("215"),
-                    __webpack_require__.e("946")
+                    __webpack_require__.e("270")
                 ]).then(__webpack_require__.bind(__webpack_require__, "./webpack/webpack-config.ts"))
             ]);
             const debug = isAuthor;
@@ -136403,7 +136440,7 @@ var __webpack_exports__ = {};
             if ('true' === process.env.EXTENSION_DEV_DRY_RUN) return;
             const { devServer } = await Promise.all([
                 __webpack_require__.e("215"),
-                __webpack_require__.e("946"),
+                __webpack_require__.e("270"),
                 __webpack_require__.e("324")
             ]).then(__webpack_require__.bind(__webpack_require__, "./webpack/dev-server/index.ts"));
             await devServer(projectStructure, {

package/dist/warn-no-default-export.cjs

@@ -1,4 +1,7 @@
 "use strict";
+const __rslib_import_meta_url__ = /*#__PURE__*/ function() {
+    return "u" < typeof document ? new (require('url'.replace('', ''))).URL('file:' + __filename).href : document.currentScript && document.currentScript.src || new URL('main.js', document.baseURI).href;
+}();
 var __webpack_require__ = {};
 (()=>{
     __webpack_require__.n = (module)=>{
@@ -64,6 +67,38 @@ function findNearestPackageJsonSync(manifestPath) {
         return null;
     }
 }
+require("os");
+require("pintor");
+const external_module_namespaceObject = require("module");
+(0, external_module_namespaceObject.createRequire)(__rslib_import_meta_url__);
+require("crypto");
+require("child_process");
+(0, external_module_namespaceObject.createRequire)(__rslib_import_meta_url__);
+function parseJsonSafe(text) {
+    const s = text && 0xfeff === text.charCodeAt(0) ? text.slice(1) : text;
+    return JSON.parse(s || '{}');
+}
+function hasDependency(projectPath, dependency) {
+    const findNearestPackageJsonDirectory = (startPath)=>{
+        let currentDirectory = startPath;
+        const maxDepth = 4;
+        for(let i = 0; i < maxDepth; i++){
+            const candidate = external_path_namespaceObject.join(currentDirectory, 'package.json');
+            if (external_fs_namespaceObject.existsSync(candidate)) return currentDirectory;
+            const parentDirectory = external_path_namespaceObject.dirname(currentDirectory);
+            if (parentDirectory === currentDirectory) break;
+            currentDirectory = parentDirectory;
+        }
+    };
+    const packageJsonDirectory = findNearestPackageJsonDirectory(projectPath);
+    if (!packageJsonDirectory) return false;
+    const packageJsonPath = external_path_namespaceObject.join(packageJsonDirectory, 'package.json');
+    if (!external_fs_namespaceObject.existsSync(packageJsonPath)) return false;
+    const packageJson = parseJsonSafe(external_fs_namespaceObject.readFileSync(packageJsonPath, 'utf8'));
+    const dependencies = packageJson.dependencies || {};
+    const devDependencies = packageJson.devDependencies || {};
+    return !!dependencies[dependency] || !!devDependencies[dependency];
+}
 const core_namespaceObject = require("@swc/core");
 const external_schema_utils_namespaceObject = require("schema-utils");
 const schema = {
@@ -80,6 +115,34 @@ const schema = {
         }
     }
 };
+const EXAMPLES_BASE = 'https://github.com/extension-js/examples/blob/main';
+function getContentScriptSampleInfo(packageJsonDir, resourcePath) {
+    if (hasDependency(packageJsonDir, 'react')) return {
+        phrase: 'See React sample',
+        url: `${EXAMPLES_BASE}/react/src/content/scripts.tsx`
+    };
+    if (hasDependency(packageJsonDir, 'preact')) return {
+        phrase: 'See Preact sample',
+        url: `${EXAMPLES_BASE}/preact/src/content/scripts.tsx`
+    };
+    if (hasDependency(packageJsonDir, 'vue')) return {
+        phrase: 'See Vue sample',
+        url: `${EXAMPLES_BASE}/vue/src/content/scripts.ts`
+    };
+    if (hasDependency(packageJsonDir, 'svelte')) return {
+        phrase: 'See Svelte sample',
+        url: `${EXAMPLES_BASE}/svelte/src/content/scripts.ts`
+    };
+    const ext = external_path_default().extname(resourcePath).toLowerCase();
+    if ('.ts' === ext || '.tsx' === ext || '.mts' === ext || '.mtsx' === ext) return {
+        phrase: 'See TypeScript sample',
+        url: `${EXAMPLES_BASE}/typescript/src/content/scripts.ts`
+    };
+    return {
+        phrase: 'See vanilla JS sample',
+        url: `${EXAMPLES_BASE}/content/src/content/scripts.js`
+    };
+}
 function getSourceSignature(source) {
     const head = source.slice(0, 64);
     const tail = source.slice(-64);
@@ -253,47 +316,28 @@ function warn_no_default_export(source) {
                     }
                     const relativeFile = external_path_default().relative(packageJsonDir, resourceAbsPath);
                     const found = 'class' === analysis.kind ? 'class' : 'non-callable value';
+                    const sample = getContentScriptSampleInfo(packageJsonDir, this.resourcePath);
                     const message = [
                         "Content script default export must be a function.",
-                        `File: ${relativeFile}`,
-                        "",
-                        `Found: ${found}`,
-                        "",
-                        "Fix:",
-                        "  - Export a default function that sets up your script and returns optional cleanup.",
-                        "  - If you want to use a class, instantiate it inside the default function and call its methods.",
-                        "",
-                        "Example:",
-                        "  class App { start(){} stop(){} }",
-                        "  export default function main(){",
-                        "    const app = new App(); app.start();",
-                        "    return () => app.stop();",
-                        "  }"
+                        `  │ File: ${relativeFile}`,
+                        "  │",
+                        `  │ Found: ${found}. Export a default function that sets up your script and returns optional cleanup.`,
+                        "  │ Without it: duplicate UI mounts, memory leaks, and inconsistent state during HMR.",
+                        `  │ ${sample.phrase} ${sample.url}`
                     ].join('\n');
                     compilation?.warnings.push(message);
                     compilation?.__extjsWarnedDefaultExportKinds?.add(dedupeKindKey);
                 }
             } else {
                 const relativeFile = external_path_default().relative(packageJsonDir, resourceAbsPath);
+                const sample = getContentScriptSampleInfo(packageJsonDir, this.resourcePath);
                 const message = [
                     "Content script requires a default export.",
-                    `File: ${relativeFile}`,
-                    "",
-                    "Why:",
-                    "  - During development, Extension.js uses your default export to start and stop your content script safely.",
-                    "  - Without it, automatic reloads and cleanup might not work reliably.",
-                    "",
-                    "Required:",
-                    "  - Export a default function (it can optionally return a cleanup callback).",
-                    "",
-                    "Example:",
-                    "  export default function main() {",
-                    "    // setup...",
-                    "    return () => { /* cleanup */ }",
-                    "  }",
+                    ` File: ${relativeFile}`,
                     "",
-                    "Side effects if omitted:",
-                    "  - Duplicate UI mounts, memory leaks, and inconsistent state during development."
+                    " Export a default function so Extension.js can mount and cleanup safely.",
+                    " Without it: duplicate UI mounts and inconsistent state during HMR.",
+                    ` ${sample.phrase}: ${sample.url}`
                 ].join('\n');
                 compilation?.warnings.push(message);
                 compilation?.__extjsWarnedDefaultExport?.add(dedupeKey);

package/package.json

@@ -25,7 +25,7 @@
     "webpack/webpack-lib/optional-dependencies.json"
   ],
   "name": "extension-develop",
-  "version": "3.9.0-next.3",
+  "version": "3.9.0-next.5",
   "description": "Develop, build, preview, and package Extension.js projects.",
   "author": {
     "name": "Cezar Augusto",