extension-develop 3.17.0 → 3.18.0

package/dist/0~zip.mjs

@@ -1,7 +1,27 @@
 import { createRequire as __extjsCreateRequire } from "node:module"; const require = __extjsCreateRequire(import.meta.url);
 import adm_zip from "adm-zip";
-import { unpackagingExtension, failedToDownloadOrExtractZIPFileError, invalidRemoteZip, unpackagedSuccessfully, downloadingText } from "./946.mjs";
+import { unpackagingExtension, failedToDownloadOrExtractZIPFileError, invalidRemoteZip, notAZipArchive, unpackagedSuccessfully, localZipNotFound, downloadingText } from "./946.mjs";
 import * as __rspack_external_path from "path";
+import * as __rspack_external_fs from "fs";
+function isZipBuffer(buffer) {
+    if (buffer.length < 4) return false;
+    if (0x50 !== buffer[0] || 0x4b !== buffer[1]) return false;
+    const third = buffer[2];
+    const fourth = buffer[3];
+    return 0x03 === third && 0x04 === fourth || 0x05 === third && 0x06 === fourth || 0x07 === third && 0x08 === fourth;
+}
+function extractBuffer(zipBuffer, destinationPath) {
+    console.log(unpackagingExtension(destinationPath));
+    const zip = new adm_zip(zipBuffer);
+    zip.extractAllTo(destinationPath, true);
+    console.log(unpackagedSuccessfully());
+}
+function asZipError(error) {
+    console.error(failedToDownloadOrExtractZIPFileError(error));
+    const err = new Error(`${failedToDownloadOrExtractZIPFileError(error)}`);
+    err.code = 'EZIP';
+    return err;
+}
 async function downloadAndExtractZip(url, targetPath) {
     const urlNoSearchParams = url.split('?')[0];
     try {
@@ -17,18 +37,27 @@ async function downloadAndExtractZip(url, targetPath) {
         const extname = __rspack_external_path.extname(urlNoSearchParams);
         const basename = __rspack_external_path.basename(urlNoSearchParams, extname);
         const destinationPath = __rspack_external_path.join(targetPath, basename);
-        console.log(unpackagingExtension(destinationPath));
         const arrayBuffer = await res.arrayBuffer();
         const zipBuffer = Buffer.from(arrayBuffer);
-        const zip = new adm_zip(zipBuffer);
-        zip.extractAllTo(destinationPath, true);
-        console.log(unpackagedSuccessfully());
+        if (!isZipBuffer(zipBuffer)) throw new Error(`${notAZipArchive(urlNoSearchParams, contentType)}`);
+        extractBuffer(zipBuffer, destinationPath);
+        return destinationPath;
+    } catch (error) {
+        throw asZipError(error);
+    }
+}
+async function extractLocalZip(zipFilePath, targetPath) {
+    try {
+        if (!__rspack_external_fs.existsSync(zipFilePath) || !__rspack_external_fs.statSync(zipFilePath).isFile()) throw new Error(`${localZipNotFound(zipFilePath)}`);
+        const extname = __rspack_external_path.extname(zipFilePath);
+        const basename = __rspack_external_path.basename(zipFilePath, extname);
+        const destinationPath = __rspack_external_path.join(targetPath, basename);
+        const zipBuffer = __rspack_external_fs.readFileSync(zipFilePath);
+        if (!isZipBuffer(zipBuffer)) throw new Error(`${notAZipArchive(zipFilePath)}`);
+        extractBuffer(zipBuffer, destinationPath);
         return destinationPath;
     } catch (error) {
-        console.error(failedToDownloadOrExtractZIPFileError(error));
-        const err = new Error(`${failedToDownloadOrExtractZIPFileError(error)}`);
-        err.code = 'EZIP';
-        throw err;
+        throw asZipError(error);
     }
 }
-export { downloadAndExtractZip };
+export { downloadAndExtractZip, extractLocalZip };

package/dist/45.mjs

@@ -0,0 +1,39 @@
+import { createRequire as __extjsCreateRequire } from "node:module"; const require = __extjsCreateRequire(import.meta.url);
+import * as __rspack_external_fs from "fs";
+import * as __rspack_external_path from "path";
+import * as __rspack_external_crypto from "crypto";
+const CONTROL_WS_PATH = '/extjs-control';
+function controlTokenPath(projectPath) {
+    return __rspack_external_path.resolve(projectPath, '.extension-js', 'control.token');
+}
+function writeControlToken(projectPath) {
+    const token = __rspack_external_crypto.randomBytes(32).toString('hex');
+    const file = controlTokenPath(projectPath);
+    __rspack_external_fs.mkdirSync(__rspack_external_path.dirname(file), {
+        recursive: true
+    });
+    __rspack_external_fs.writeFileSync(file, token, {
+        encoding: 'utf-8',
+        mode: 384
+    });
+    try {
+        __rspack_external_fs.chmodSync(file, 384);
+    } catch  {}
+    return token;
+}
+function readControlToken(projectPath) {
+    try {
+        const token = __rspack_external_fs.readFileSync(controlTokenPath(projectPath), 'utf-8').trim();
+        return token.length ? token : null;
+    } catch  {
+        return null;
+    }
+}
+function clearControlToken(projectPath) {
+    try {
+        __rspack_external_fs.rmSync(controlTokenPath(projectPath), {
+            force: true
+        });
+    } catch  {}
+}
+export { CONTROL_WS_PATH, clearControlToken, controlTokenPath, readControlToken, writeControlToken };

package/dist/946.mjs

@@ -12,7 +12,7 @@ import * as __rspack_external_path from "path";
 import * as __rspack_external_fs from "fs";
 import * as __rspack_external_os from "os";
 import * as __rspack_external_vm from "vm";
-var package_namespaceObject = JSON.parse('{"rE":"3.17.0","El":{"@prefresh/core":"1.5.9","@prefresh/utils":"1.2.1","@rspack/core":"^2.0.1","@rspack/dev-server":"^2.0.1","@rspack/plugin-preact-refresh":"1.1.5","@rspack/plugin-react-refresh":"1.6.2","@swc/core":"^1.15.8","@swc/helpers":"^0.5.18","@vue/compiler-sfc":"3.5.26","adm-zip":"^0.5.16","browser-extension-manifest-fields":"^2.2.3","case-sensitive-paths-webpack-plugin":"^2.4.0","content-security-policy-parser":"^0.6.0","cross-spawn":"^7.0.6","dotenv":"^17.2.3","extension-from-store":"^0.1.1","go-git-it":"^5.1.5","ignore":"^7.0.5","less":"4.5.1","less-loader":"12.3.2","loader-utils":"^3.3.1","magic-string":"^0.30.21","parse5-utilities":"^1.0.0","pintor":"0.3.0","postcss":"8.5.10","postcss-loader":"8.2.1","postcss-preset-env":"11.1.1","postcss-scss":"4.0.9","preact":"10.27.3","react-refresh":"0.18.0","sass-loader":"16.0.7","schema-utils":"^4.3.3","svelte-loader":"3.2.4","tiny-glob":"^0.2.9","typescript":"5.9.3","unique-names-generator":"^4.7.1","vue":"3.5.26","vue-loader":"17.4.2","webextension-polyfill":"^0.12.0","webpack-merge":"^6.0.1","webpack-target-webextension":"^2.1.3"}}');
+var package_namespaceObject = JSON.parse('{"rE":"3.18.0","El":{"@prefresh/core":"1.5.9","@prefresh/utils":"1.2.1","@rspack/core":"^2.0.1","@rspack/dev-server":"2.0.1","@rspack/plugin-preact-refresh":"1.1.5","@rspack/plugin-react-refresh":"1.6.2","@swc/core":"^1.15.8","@swc/helpers":"^0.5.18","@vue/compiler-sfc":"3.5.26","adm-zip":"^0.5.16","browser-extension-manifest-fields":"^2.2.3","case-sensitive-paths-webpack-plugin":"^2.4.0","content-security-policy-parser":"^0.6.0","cross-spawn":"^7.0.6","dotenv":"^17.2.3","extension-from-store":"^0.1.1","go-git-it":"^5.1.5","ignore":"^7.0.5","less":"4.5.1","less-loader":"12.3.2","loader-utils":"^3.3.1","magic-string":"^0.30.21","parse5-utilities":"^1.0.0","pintor":"0.3.0","postcss":"8.5.10","postcss-loader":"8.2.1","postcss-preset-env":"11.1.1","postcss-scss":"4.0.9","preact":"10.27.3","react-refresh":"0.18.0","sass-loader":"16.0.7","schema-utils":"^4.3.3","svelte-loader":"3.2.4","tiny-glob":"^0.2.9","typescript":"5.9.3","unique-names-generator":"^4.7.1","vue":"3.5.26","vue-loader":"17.4.2","webextension-polyfill":"^0.12.0","webpack-merge":"^6.0.1","webpack-target-webextension":"^2.1.3","ws":"^8.20.1"}}');
 const fmt = {
     heading: (title)=>pintor.underline(pintor.blue(title)),
     label: (key)=>pintor.gray(key.toUpperCase()),
@@ -55,6 +55,13 @@ function resolvedWorkspaceManifest(projectPath, manifestPath) {
     const display = __rspack_external_path.relative(projectPath, packageDir) || packageDir;
     return `${getLoggingPrefix('info')} ${pintor.gray('Workspace root detected — resolved extension package:')} ${pintor.brightBlue(display)}`;
 }
+function remoteFetchTimedOut(target, ms) {
+    return `${getLoggingPrefix('error')} Timed out after ${pintor.yellow(`${Math.round(ms / 1000)}s`)} fetching ${pintor.underline(target)}.\n${pintor.red('Check your network, or set EXTENSION_FETCH_TIMEOUT_MS to allow more time.')}`;
+}
+function manifestInvalidJson(manifestPath, error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    return `${getLoggingPrefix('error')} Could not parse manifest.json — it is not valid JSON.\n${pintor.red('Fix the syntax error and try again.')}\n${pintor.gray('PATH')} ${pintor.underline(manifestPath)}\n${pintor.red(detail)}`;
+}
 function manifestNotFoundError(manifestPath, candidates = []) {
     const base = `${getLoggingPrefix('error')} Manifest file not found.\n${pintor.red('Ensure the path to your extension exists and try again.')}\n${pintor.red('NOT FOUND')}\n${pintor.gray('PATH')} ${pintor.underline(manifestPath)}`;
     if (!candidates.length) return base;
@@ -237,6 +244,12 @@ function failedToDownloadOrExtractZIPFileError(error) {
 function invalidRemoteZip(url, contentType) {
     return `${getLoggingPrefix('error')} Remote URL does not appear to be a ZIP archive.\n${pintor.gray('URL')} ${pintor.underline(url)}\n${pintor.gray('Content-Type')} ${pintor.underline(contentType || 'unknown')}`;
 }
+function notAZipArchive(source, contentType) {
+    return `${getLoggingPrefix('error')} The downloaded content is not a ZIP archive.\n${pintor.gray('SOURCE')} ${pintor.underline(source)}\n` + (contentType ? `${pintor.gray('Content-Type')} ${pintor.underline(contentType)}\n` : '') + "This usually means the URL requires authentication (for example a Slack, Google Drive, or Dropbox file page) and returned an HTML login page instead of the file. Download the ZIP through the browser and pass the local path instead, or use a direct-download URL.";
+}
+function localZipNotFound(zipFilePath) {
+    return `${getLoggingPrefix('error')} ZIP file not found.\n${pintor.gray('PATH')} ${pintor.underline(zipFilePath)}`;
+}
 function capitalizedBrowserName(browser) {
     const b = String(browser || '');
     const cap = b.charAt(0).toUpperCase() + b.slice(1);
@@ -405,6 +418,22 @@ const isUrl = (url)=>{
         return false;
     }
 };
+const REMOTE_FETCH_TIMEOUT_MS = (()=>{
+    const raw = parseInt(String(process.env.EXTENSION_FETCH_TIMEOUT_MS || ''), 10);
+    return Number.isFinite(raw) && raw > 0 ? raw : 60000;
+})();
+function withTimeout(task, ms, label) {
+    let timer;
+    const timeout = new Promise((_, reject)=>{
+        timer = setTimeout(()=>reject(new Error(remoteFetchTimedOut(label, ms))), ms);
+    });
+    return Promise.race([
+        task,
+        timeout
+    ]).finally(()=>{
+        if (timer) clearTimeout(timer);
+    });
+}
 async function importUrlSourceFromGithub(pathOrRemoteUrl, text) {
     const cwd = process.cwd();
     const url = new URL(pathOrRemoteUrl);
@@ -445,7 +474,7 @@ async function importUrlSourceFromGithub(pathOrRemoteUrl, text) {
     } catch  {}
     async function tryGitClone() {
         const { default: goGitIt } = await import("go-git-it");
-        await goGitIt(pathOrRemoteUrl, cwd, text);
+        await withTimeout(goGitIt(pathOrRemoteUrl, cwd, text), REMOTE_FETCH_TIMEOUT_MS, pathOrRemoteUrl);
     }
     async function tryZipFallback() {
         const branch = -1 !== treeIndex && segments.length > treeIndex + 1 ? segments[treeIndex + 1] : 'main';
@@ -492,9 +521,14 @@ async function importUrlSourceFromGithub(pathOrRemoteUrl, text) {
 async function importUrlSourceFromZip(pathOrRemoteUrl) {
     const cwd = process.cwd();
     const { downloadAndExtractZip } = await import("./0~zip.mjs");
-    const extractedPath = await downloadAndExtractZip(pathOrRemoteUrl, cwd);
+    const extractedPath = await withTimeout(downloadAndExtractZip(pathOrRemoteUrl, cwd), REMOTE_FETCH_TIMEOUT_MS, pathOrRemoteUrl);
     return extractedPath;
 }
+async function importLocalSourceFromZip(zipFilePath) {
+    const cwd = process.cwd();
+    const { extractLocalZip } = await import("./0~zip.mjs");
+    return await extractLocalZip(zipFilePath, cwd);
+}
 async function getProjectPath(pathOrRemoteUrl) {
     if (!pathOrRemoteUrl) return process.cwd();
     if (isUrl(pathOrRemoteUrl)) {
@@ -516,7 +550,9 @@ async function getProjectPath(pathOrRemoteUrl) {
             return urlSource;
         }
     }
-    return __rspack_external_path.resolve(process.cwd(), pathOrRemoteUrl);
+    const resolvedPath = __rspack_external_path.resolve(process.cwd(), pathOrRemoteUrl);
+    if ('.zip' === __rspack_external_path.extname(resolvedPath).toLowerCase() && __rspack_external_fs.existsSync(resolvedPath) && __rspack_external_fs.statSync(resolvedPath).isFile()) return await importLocalSourceFromZip(resolvedPath);
+    return resolvedPath;
 }
 function collectManifestCandidates(rootDir, maxDepth) {
     const SKIP_DIRS = new Set([
@@ -572,20 +608,27 @@ async function getProjectStructure(pathOrRemoteUrl) {
             console.log(resolvedWorkspaceManifest(projectPath, manifestPath));
         } else throw new Error(manifestNotFoundError(manifestPath, relativeCandidates));
     } else {
-        const findManifest = (dir)=>{
-            const files = __rspack_external_fs.readdirSync(dir, {
-                withFileTypes: true
-            });
+        const MAX_DEPTH = 5;
+        const findManifest = (dir, depth)=>{
+            if (depth > MAX_DEPTH) return null;
+            let files;
+            try {
+                files = __rspack_external_fs.readdirSync(dir, {
+                    withFileTypes: true
+                });
+            } catch  {
+                return null;
+            }
             for (const file of files){
                 if (file.isFile() && 'manifest.json' === file.name) return __rspack_external_path.join(dir, file.name);
                 if (file.isDirectory() && !file.name.startsWith('.') && 'node_modules' !== file.name && 'dist' !== file.name && 'public' !== file.name) {
-                    const found = findManifest(__rspack_external_path.join(dir, file.name));
+                    const found = findManifest(__rspack_external_path.join(dir, file.name), depth + 1);
                     if (found) return found;
                 }
             }
             return null;
         };
-        const foundManifest = findManifest(projectPath);
+        const foundManifest = findManifest(projectPath, 0);
         if (foundManifest) manifestPath = foundManifest;
         else throw new Error(manifestNotFoundError(manifestPath));
     }
@@ -683,8 +726,21 @@ function preloadEnvFiles(projectDir) {
     if (workspaceRoot && workspaceRoot !== projectDir) return preloadEnvFilesFromDir(workspaceRoot);
     return local;
 }
+const loadedConfigCache = new Map();
 async function loadConfigFile(configPath) {
     const absolutePath = __rspack_external_path.resolve(configPath);
+    const cached = loadedConfigCache.get(absolutePath);
+    if (cached) return cached;
+    const loading = loadConfigFileUncached(absolutePath);
+    loadedConfigCache.set(absolutePath, loading);
+    try {
+        return await loading;
+    } catch (error) {
+        loadedConfigCache.delete(absolutePath);
+        throw error;
+    }
+}
+async function loadConfigFileUncached(absolutePath) {
     const projectDir = __rspack_external_path.dirname(absolutePath);
     preloadEnvFiles(projectDir);
     try {
@@ -694,11 +750,12 @@ async function loadConfigFile(configPath) {
             return required?.default || required;
         }
         let esmImportPath = absolutePath;
+        let shimTmpDir;
         try {
             const originalContent = __rspack_external_fs.readFileSync(absolutePath, 'utf-8');
             if (originalContent.includes('import.meta.env')) {
-                const tmpDir = __rspack_external_fs.mkdtempSync(__rspack_external_path.join(__rspack_external_os.tmpdir(), 'extension-config-esm-'));
-                const tmpPath = __rspack_external_path.join(tmpDir, __rspack_external_path.basename(absolutePath));
+                shimTmpDir = __rspack_external_fs.mkdtempSync(__rspack_external_path.join(__rspack_external_os.tmpdir(), 'extension-config-esm-'));
+                const tmpPath = __rspack_external_path.join(shimTmpDir, __rspack_external_path.basename(absolutePath));
                 const envObjectLiteral = JSON.stringify(Object.fromEntries(Object.entries(process.env).map(([k, v])=>[
                         k,
                         v
@@ -709,8 +766,17 @@ async function loadConfigFile(configPath) {
                 esmImportPath = tmpPath;
             }
         } catch  {}
-        const module = await import(pathToFileURL(esmImportPath).href);
-        return module.default || module;
+        try {
+            const module = await import(pathToFileURL(esmImportPath).href);
+            return module.default || module;
+        } finally{
+            if (shimTmpDir) try {
+                __rspack_external_fs.rmSync(shimTmpDir, {
+                    recursive: true,
+                    force: true
+                });
+            } catch  {}
+        }
     } catch (err) {
         const error = err;
         try {
@@ -726,9 +792,18 @@ async function loadConfigFile(configPath) {
                         required = loadCommonJsConfigWithStableDirname(absolutePath);
                     } catch  {
                         const tmpDir = __rspack_external_fs.mkdtempSync(__rspack_external_path.join(__rspack_external_os.tmpdir(), 'extension-config-'));
-                        const tmpCjsPath = __rspack_external_path.join(tmpDir, __rspack_external_path.basename(absolutePath, __rspack_external_path.extname(absolutePath)) + '.cjs');
-                        __rspack_external_fs.copyFileSync(absolutePath, tmpCjsPath);
-                        required = requireFn(tmpCjsPath);
+                        try {
+                            const tmpCjsPath = __rspack_external_path.join(tmpDir, __rspack_external_path.basename(absolutePath, __rspack_external_path.extname(absolutePath)) + '.cjs');
+                            __rspack_external_fs.copyFileSync(absolutePath, tmpCjsPath);
+                            required = requireFn(tmpCjsPath);
+                        } finally{
+                            try {
+                                __rspack_external_fs.rmSync(tmpDir, {
+                                    recursive: true,
+                                    force: true
+                                });
+                            } catch  {}
+                        }
                     }
                     else throw requireErr;
                 }
@@ -739,7 +814,7 @@ async function loadConfigFile(configPath) {
             const content = __rspack_external_fs.readFileSync(absolutePath, 'utf-8');
             return JSON.parse(content);
         } catch (jsonErr) {
-            throw new Error(`Failed to load config file: ${configPath}\nError: ${error.message || error}`);
+            throw new Error(`Failed to load config file: ${absolutePath}\nError: ${error.message || error}`);
         }
     }
 }
@@ -776,10 +851,14 @@ async function loadCommandConfig(projectPath, command) {
             const baseTranspilePackages = userConfig && Array.isArray(userConfig.transpilePackages) ? {
                 transpilePackages: userConfig.transpilePackages
             } : {};
+            const basePerfBudgets = userConfig && userConfig.perfBudgets && 'object' == typeof userConfig.perfBudgets ? {
+                perfBudgets: userConfig.perfBudgets
+            } : {};
             const perCommand = userConfig && userConfig.commands && userConfig.commands[command] ? userConfig.commands[command] : {};
             return {
                 ...baseExtensions,
                 ...baseTranspilePackages,
+                ...basePerfBudgets,
                 ...perCommand
             };
         } catch (err) {
@@ -830,6 +909,11 @@ async function config_loader_isUsingExperimentalConfig(projectPath) {
     }
     return false;
 }
+function isReferencedAsModuleSpecifier(configSource, dep) {
+    const escaped = dep.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const specifierRe = new RegExp(`['"\`]${escaped}(?:/[^'"\`]*)?['"\`]`);
+    return specifierRe.test(configSource);
+}
 function assertNoManagedDependencyConflicts(userPackageJsonPath, projectPath) {
     try {
         const raw = __rspack_external_fs.readFileSync(userPackageJsonPath, 'utf-8');
@@ -851,7 +935,7 @@ function assertNoManagedDependencyConflicts(userPackageJsonPath, projectPath) {
         if (!hasConfig) return;
         const configPath = __rspack_external_fs.existsSync(userConfigJs) ? userConfigJs : userConfigMjs;
         const configSource = __rspack_external_fs.readFileSync(configPath, 'utf-8');
-        const duplicates = userDeps.filter((d)=>managedDeps.has(d)).filter((d)=>configSource.includes(d)).sort();
+        const duplicates = userDeps.filter((d)=>managedDeps.has(d)).filter((d)=>isReferencedAsModuleSpecifier(configSource, d)).sort();
         if (duplicates.length > 0) {
             console.error(managedDependencyConflict(duplicates, userPackageJsonPath));
             process.exit(1);
@@ -898,7 +982,7 @@ function needsInstall(packageJsonDir) {
         return true;
     }
 }
-function normalizeBrowser(browser, chromiumBinary, geckoBinary) {
+function normalizeBrowser(browser, chromiumBinary, geckoBinary, safariBinary) {
     const requested = String(browser || '');
     if (chromiumBinary) {
         if (!requested || 'chromium-based' === requested) return 'chromium-based';
@@ -910,6 +994,10 @@ function normalizeBrowser(browser, chromiumBinary, geckoBinary) {
         if (!requested || 'gecko-based' === requested || 'firefox-based' === requested) return 'gecko-based';
         if ('firefox' === requested) return 'firefox';
     }
+    if (safariBinary) {
+        if (!requested || 'webkit-based' === requested) return 'webkit-based';
+        if ('safari' === requested) return 'safari';
+    }
     switch(requested){
         case 'chrome':
             return 'chrome';
@@ -924,8 +1012,12 @@ function normalizeBrowser(browser, chromiumBinary, geckoBinary) {
         case 'gecko-based':
         case 'firefox-based':
             return 'gecko-based';
+        case 'safari':
+            return 'safari';
+        case 'webkit-based':
+            return 'webkit-based';
         default:
-            return browser || 'chrome';
+            return 'chrome';
     }
 }
 function getDistPath(packageJsonDir, browser) {
@@ -1222,21 +1314,27 @@ function createPlaywrightMetadataWriter(options) {
     const metadataDir = getPlaywrightMetadataDir(options.packageJsonDir, options.browser);
     const readyPath = asAbsolute(__rspack_external_path.join(metadataDir, 'ready.json'));
     const eventsPath = asAbsolute(__rspack_external_path.join(metadataDir, 'events.ndjson'));
+    const toPort = (value)=>{
+        if ('number' == typeof value && Number.isFinite(value)) return value;
+        if ('string' == typeof value) {
+            const parsed = parseInt(value, 10);
+            return Number.isFinite(parsed) ? parsed : null;
+        }
+        return null;
+    };
     const base = {
+        schemaVersion: 2,
         command: options.command,
         browser: options.browser,
         runId: createRunId(),
         startedAt: nowISO(),
         distPath: options.distPath,
         manifestPath: options.manifestPath,
-        port: (()=>{
-            if ('number' == typeof options.port && Number.isFinite(options.port)) return options.port;
-            if ('string' == typeof options.port) {
-                const parsed = parseInt(options.port, 10);
-                return Number.isFinite(parsed) ? parsed : null;
-            }
-            return null;
-        })()
+        port: toPort(options.port),
+        instanceId: options.instanceId,
+        controlPort: toPort(options.controlPort),
+        controlPath: options.controlPath,
+        logsPath: options.logsPath
     };
     function writeReady(status, extra) {
         plugin_playwright_ensureDirSync(metadataDir);
@@ -1250,6 +1348,12 @@ function createPlaywrightMetadataWriter(options) {
         };
         if (extra?.code) payload.code = extra.code;
         if (extra?.message) payload.message = extra.message;
+        try {
+            if (__rspack_external_fs.existsSync(readyPath)) {
+                const prev = JSON.parse(__rspack_external_fs.readFileSync(readyPath, 'utf-8'));
+                if ('number' == typeof prev.cdpPort) payload.cdpPort = prev.cdpPort;
+            }
+        } catch  {}
         writeJsonAtomic(readyPath, payload);
     }
     function appendEvent(event) {
@@ -1295,7 +1399,11 @@ class PlaywrightPlugin {
             command: this.command,
             distPath: options.outputPath,
             manifestPath: options.manifestPath,
-            port: options.port
+            port: options.port,
+            instanceId: options.instanceId,
+            controlPort: options.controlPort,
+            controlPath: options.controlPath,
+            logsPath: options.logsPath
         });
     }
     apply(compiler) {
@@ -1311,13 +1419,11 @@ class PlaywrightPlugin {
         compiler.hooks.done.tap(PlaywrightPlugin.name, (stats)=>{
             const durationMs = Number((stats?.compilation?.endTime || 0) - (stats?.compilation?.startTime || 0));
             const hasErrors = Boolean(stats?.hasErrors?.());
-            const errorsCount = Number(Array.isArray(stats?.toJson?.({
-                all: false,
-                errors: true
-            })?.errors) ? stats.toJson({
+            const errorsJson = stats?.toJson?.({
                 all: false,
                 errors: true
-            }).errors.length : 0);
+            });
+            const errorsCount = Array.isArray(errorsJson?.errors) ? errorsJson.errors.length : 0;
             if (hasErrors) {
                 this.writer.appendEvent({
                     type: 'compile_error',
@@ -1724,4 +1830,4 @@ async function extensionPreview(pathOrRemoteUrl, previewOptions, browserLauncher
     await browserLauncher(resolvedOpts);
     metadata.writeReady();
 }
-export { PlaywrightPlugin, asAbsolute, assertNoManagedDependencyConflicts, authorInstallNotice, autoExitForceKill, autoExitModeEnabled, autoExitTriggered, browserRunnerDisabled, buildCommandFailed, buildSuccess, buildSuccessWithWarnings, buildWarningsDetails, buildWebpack, bundlerFatalError, bundlerRecompiling, computeExtensionsToLoad, createPlaywrightMetadataWriter, debugBrowser, debugContextPath, debugDirs, debugExtensionsToLoad, debugOutputPath, devServerStartTimeout, downloadingText, extensionJsRunnerError, extensionPreview, failedToDownloadOrExtractZIPFileError, getDirs, getDistPath, getProjectStructure, getSpecialFoldersDataForCompiler, getSpecialFoldersDataForProjectRoot, invalidRemoteZip, loadBrowserConfig, loadCommandConfig, loadCustomConfig, messages_ready, needsInstall, noCompanionExtensionsResolved, noEntrypointsDetected, normalizeBrowser, package_namespaceObject, packagingDistributionFiles, packagingSourceFiles, portInUse, resolveCompanionExtensionsConfig, sanitize, spacerLine, treeWithDistFilesbrowser, treeWithSourceAndDistFiles, treeWithSourceFiles, unpackagedSuccessfully, unpackagingExtension, writingTypeDefinitions, writingTypeDefinitionsError };
+export { PlaywrightPlugin, asAbsolute, assertNoManagedDependencyConflicts, authorInstallNotice, autoExitForceKill, autoExitModeEnabled, autoExitTriggered, browserRunnerDisabled, buildCommandFailed, buildSuccess, buildSuccessWithWarnings, buildWarningsDetails, buildWebpack, bundlerFatalError, bundlerRecompiling, computeExtensionsToLoad, createPlaywrightMetadataWriter, debugBrowser, debugContextPath, debugDirs, debugExtensionsToLoad, debugOutputPath, devServerStartTimeout, downloadingText, extensionJsRunnerError, extensionPreview, failedToDownloadOrExtractZIPFileError, getDirs, getDistPath, getProjectStructure, getSpecialFoldersDataForCompiler, getSpecialFoldersDataForProjectRoot, invalidRemoteZip, loadBrowserConfig, loadCommandConfig, loadCustomConfig, localZipNotFound, manifestInvalidJson, messages_ready, needsInstall, noCompanionExtensionsResolved, noEntrypointsDetected, normalizeBrowser, notAZipArchive, package_namespaceObject, packagingDistributionFiles, packagingSourceFiles, portInUse, resolveCompanionExtensionDirs, resolveCompanionExtensionsConfig, sanitize, spacerLine, treeWithDistFilesbrowser, treeWithSourceAndDistFiles, treeWithSourceFiles, unpackagedSuccessfully, unpackagingExtension, writingTypeDefinitions, writingTypeDefinitionsError };