extension 4.0.18 → 4.0.19

package/dist/browsers.cjs

@@ -148,7 +148,9 @@ var __webpack_modules__ = {
             };
             const updateSuffix = readUpdateSuffixOnce();
             console.log(_messages__rspack_import_5.io());
-            console.log(_messages__rspack_import_5.e_(manifest, opts.browser, message, opts.browserVersionLine, updateSuffix || void 0));
+            console.log(_messages__rspack_import_5.e_(manifest, opts.browser, message, opts.browserVersionLine, updateSuffix || void 0, {
+                profilePath: opts.profilePath
+            }));
             console.log(_messages__rspack_import_5.io());
             markCardPrinted(k, opts.browser, opts.outPath);
             return true;
@@ -187,7 +189,8 @@ var __webpack_modules__ = {
                     console.log(_messages__rspack_import_5.io());
                     console.log(_messages__rspack_import_5.e_(manifest, opts.browser, message, browserLabel, updateSuffix || void 0, {
                         includeExtensionId: opts.includeExtensionId,
-                        runLabel
+                        runLabel,
+                        profilePath: opts.profilePath
                     }));
                     console.log(_messages__rspack_import_5.io());
                 } else {
@@ -204,7 +207,8 @@ var __webpack_modules__ = {
                     console.log(_messages__rspack_import_5.io());
                     console.log(_messages__rspack_import_5.e_(manifest, opts.browser, message, browserLabel, updateSuffix || void 0, {
                         includeExtensionId: opts.includeExtensionId,
-                        runLabel
+                        runLabel,
+                        profilePath: opts.profilePath
                     }));
                     console.log(_messages__rspack_import_5.io());
                 }
@@ -219,6 +223,10 @@ var __webpack_modules__ = {
                         {
                             label: 'Output',
                             value: opts.outPath
+                        },
+                        {
+                            label: 'Profile',
+                            value: opts.profilePath || ''
                         }
                     ]
                 }));
@@ -613,6 +621,92 @@ var __webpack_modules__ = {
         function firefoxDryRunConfig(cfg) {
             return `${getLoggingPrefix('info')} Config: ${pintor__rspack_import_8_default().gray(cfg)}.`;
         }
+        function safariBuildCalled() {
+            return `${getLoggingPrefix('debug')} browser  build browser=safari`;
+        }
+        function prettyPlatform(platform) {
+            if ('win32' === platform) return 'Windows';
+            if ('linux' === platform) return 'Linux';
+            return platform;
+        }
+        function safariRequiresMacOS(platform) {
+            return `${getLoggingPrefix('warn')} Safari extensions can only be built on macOS.\nDetected ${pintor__rspack_import_8_default().gray(prettyPlatform(platform))}.\nTarget another browser via ${pintor__rspack_import_8_default().blue('--browser')} ${pintor__rspack_import_8_default().gray('<chrome|edge|firefox>')}, or run this command on a Mac with Xcode.`;
+        }
+        function safariPackagingSkippedNonMac(platform) {
+            return `${getLoggingPrefix('warn')} Safari packaging needs macOS with Xcode, detected ${pintor__rspack_import_8_default().gray(prettyPlatform(platform))}, so the Xcode packaging step is skipped.\nThe web-extension build in ${pintor__rspack_import_8_default().yellow('dist/safari')} is still complete and can be packaged later on a Mac with ${pintor__rspack_import_8_default().blue('extension build --browser=safari')}.`;
+        }
+        function safariXcodeRequired(developerDir) {
+            const current = developerDir ? `${pintor__rspack_import_8_default().gray('Active toolchain:')} ${pintor__rspack_import_8_default().underline(developerDir)}` : `${pintor__rspack_import_8_default().gray('No active developer directory was found.')}`;
+            return `${getLoggingPrefix('error')} Safari packaging needs the full Xcode app (not just the Command Line Tools).\n${pintor__rspack_import_8_default().red('NOT FOUND')} ${pintor__rspack_import_8_default().underline('safari-web-extension-converter')}\n${current}\n\nTo enable Safari builds:\n- Install ${pintor__rspack_import_8_default().yellow('Xcode')} from the Mac App Store, then\n- Point the toolchain at it: ${pintor__rspack_import_8_default().blue('sudo xcode-select --switch')} ${pintor__rspack_import_8_default().gray('/Applications/Xcode.app')}\n- Finish setup once: ${pintor__rspack_import_8_default().blue('xcodebuild -runFirstLaunch')}\n\nPrefer to keep building now?\nTarget another browser via ${pintor__rspack_import_8_default().blue('--browser')} ${pintor__rspack_import_8_default().gray('<chrome|edge|firefox>')}.`;
+        }
+        function safariToolchainMissing(tool) {
+            return `${getLoggingPrefix('error')} Safari packaging tool not found: ${pintor__rspack_import_8_default().underline(tool)}\nYour Xcode install looks incomplete.\nTry ${pintor__rspack_import_8_default().blue('xcodebuild -runFirstLaunch')}, or reinstall Xcode from the Mac App Store.`;
+        }
+        function safariConverting(extensionDir) {
+            return `${getLoggingPrefix('info')} Convert the web extension into a Safari app project from ${pintor__rspack_import_8_default().underline(extensionDir)}.`;
+        }
+        function safariConverted(projectDir) {
+            return `${getLoggingPrefix('success')} Generated the Safari Xcode project at ${pintor__rspack_import_8_default().underline(projectDir)}.`;
+        }
+        function safariBuilding(scheme) {
+            return `${getLoggingPrefix('info')} Build the Safari app with xcodebuild (scheme: ${pintor__rspack_import_8_default().gray(scheme)}).`;
+        }
+        function safariBuilt(appPath) {
+            return `${getLoggingPrefix('success')} Built the Safari app at ${pintor__rspack_import_8_default().underline(appPath)}.`;
+        }
+        function safariOpening(target) {
+            return `${getLoggingPrefix('info')} Open ${pintor__rspack_import_8_default().underline(target)}.`;
+        }
+        function safariToolFailed(tool, exitCode, outputTail) {
+            const code = null === exitCode ? 'no exit code' : `exit ${exitCode}`;
+            const tail = outputTail.trim().length ? `\n${pintor__rspack_import_8_default().gray('── last output ──')}\n${outputTail}` : `\n${pintor__rspack_import_8_default().gray('(no output captured)')}`;
+            return `${getLoggingPrefix('error')} Safari packaging tool ${pintor__rspack_import_8_default().underline(tool)} failed (${pintor__rspack_import_8_default().red(code)}).${tail}`;
+        }
+        function safariConverterWarnings(warnings) {
+            return `${getLoggingPrefix('warn')} safari-web-extension-converter reported ${pintor__rspack_import_8_default().yellow(String(warnings.length))} warning(s), some manifest keys/APIs may not be supported by Safari:\n` + warnings.map((line)=>`  ${pintor__rspack_import_8_default().gray('•')} ${line}`).join('\n');
+        }
+        function safariDefaultBundleIdNote(bundleId) {
+            return `${getLoggingPrefix('info')} Use the generated bundle id ${pintor__rspack_import_8_default().gray(bundleId)}.\nFor an app you plan to distribute, set your own with ${pintor__rspack_import_8_default().blue('--bundle-id')} now.\nChanging it later makes Safari treat the extension as a new identity.`;
+        }
+        function safariOpenHint(appPath, appName) {
+            return `${getLoggingPrefix('info')} Launch it once to register with Safari: ${pintor__rspack_import_8_default().blue('open')} ${pintor__rspack_import_8_default().underline(`"${appPath}"`)}\nThen enable ${pintor__rspack_import_8_default().brightBlue(appName)} via Safari ▸ Develop ▸ ${pintor__rspack_import_8_default().yellow('Allow Unsigned Extensions')} and Safari ▸ Settings ▸ Extensions.`;
+        }
+        function safariDryRunNotBuilding() {
+            return `${getLoggingPrefix('info')} Dry run: skip the Safari app build.`;
+        }
+        function safariDryRunConverter(cmd) {
+            return `${getLoggingPrefix('info')} Converter: ${pintor__rspack_import_8_default().gray(cmd)}.`;
+        }
+        function safariDryRunXcodebuild(cmd) {
+            return `${getLoggingPrefix('info')} xcodebuild: ${pintor__rspack_import_8_default().gray(cmd)}.`;
+        }
+        function safariNextSteps(appName) {
+            return `${getLoggingPrefix('info')} One-time setup to load ${pintor__rspack_import_8_default().brightBlue(appName)} in Safari:\n  ${pintor__rspack_import_8_default().gray('1.')} Safari ▸ Settings ▸ Advanced ▸ check ${pintor__rspack_import_8_default().yellow('“Show features for web developers”')}\n  ${pintor__rspack_import_8_default().gray('2.')} Safari ▸ Develop ▸ ${pintor__rspack_import_8_default().yellow('Allow Unsigned Extensions')} ${pintor__rspack_import_8_default().gray('(resets each launch)')}\n  ${pintor__rspack_import_8_default().gray('3.')} Safari ▸ Settings ▸ Extensions ▸ turn on ${pintor__rspack_import_8_default().yellow(appName)}\n  ${pintor__rspack_import_8_default().gray('→')} The app window that just opened can also take you there.`;
+        }
+        function safariRegistered(appName) {
+            return `${getLoggingPrefix('success')} Safari recognizes ${pintor__rspack_import_8_default().brightBlue(appName)}, finish enabling it with the steps above.`;
+        }
+        function safariNotYetRegistered(appName) {
+            return `${getLoggingPrefix('warn')} Safari hasn't picked up ${pintor__rspack_import_8_default().brightBlue(appName)} yet.\nOpen the app once, then check Safari ▸ Settings ▸ Extensions.`;
+        }
+        function safariRebuilt(appName) {
+            return `${getLoggingPrefix('success')} Rebuilt ${pintor__rspack_import_8_default().brightBlue(appName)}, reload the page (or toggle the extension) in Safari to see changes.`;
+        }
+        function safariProjectStale() {
+            return `${getLoggingPrefix('info')} Regenerate the Xcode project, manifest.json or identity options changed since it was generated.`;
+        }
+        function safariForcedRegeneration() {
+            return `${getLoggingPrefix('info')} Regenerate the Xcode project, --force-regenerate is set.`;
+        }
+        function safariRegenerationDiscards(preservedKeys) {
+            return `${getLoggingPrefix('warn')} Regenerating replaces the Xcode project: customizations made in Xcode (entitlements, capabilities, added files/targets) are ${pintor__rspack_import_8_default().red('discarded')}.\nPreserved automatically: ${pintor__rspack_import_8_default().yellow(preservedKeys.join(', '))}.\nIf you customized the project, back it up before continuing.`;
+        }
+        function safariSettingsPreserved(keys) {
+            return `${getLoggingPrefix('info')} Preserved Xcode build settings across regeneration: ${pintor__rspack_import_8_default().yellow(keys.join(', '))}.\nIf any other project-level tweaks were lost, reconfigure them in Xcode.`;
+        }
+        function safariSkippingConversion() {
+            return `${getLoggingPrefix('info')} Skip the conversion, the Xcode project is up to date with manifest.json.`;
+        }
         function cdpClientFoundTargets(count) {
             return `${getLoggingPrefix('debug')} cdp      targets=${count}`;
         }
@@ -709,6 +803,10 @@ var __webpack_modules__ = {
                         label: 'Extension ID',
                         value: includeExtensionId ? cleanId : ''
                     },
+                    {
+                        label: 'Profile',
+                        value: String(opts?.profilePath || '').trim()
+                    },
                     {
                         label: 'Run ID',
                         value: opts?.runLabel || ''
@@ -761,12 +859,16 @@ var __webpack_modules__ = {
             return `${getLoggingPrefix('error')} Received an unreadable Firefox remote debugging message.\nThe debugging connection is out of sync with the browser, usually after a crash or an abrupt reload.\nRestart the dev session.\nIf it repeats, report it with your Firefox version.`;
         }
         __webpack_require__.d(__webpack_exports__, {
+            $q: ()=>safariDefaultBundleIdNote,
             $w: ()=>bestEffortBannerPrintFailed,
+            A: ()=>safariToolFailed,
             A9: ()=>firefoxLaunchCalled,
             AG: ()=>enhancedProcessManagementForceKill,
+            Aj: ()=>safariDryRunXcodebuild,
             CN: ()=>unsupportedManifestVersionOnChromium,
             CY: ()=>devChromiumDebugPort,
             Cn: ()=>chromeProcessError,
+            Cs: ()=>safariToolchainMissing,
             Dh: ()=>invalidGeckoBinaryPath,
             E8: ()=>chromiumDryRunFlags,
             EE: ()=>geckoAddonLoadRefused,
@@ -775,11 +877,14 @@ var __webpack_modules__ = {
             F4: ()=>enhancedProcessManagementUncaughtException,
             FF: ()=>cdpClientFoundTargets,
             Fm: ()=>connectionClosedError,
+            G3: ()=>safariRequiresMacOS,
             GB: ()=>waitingForBrowserDebugger,
             Gq: ()=>locatingBrowser,
+            H1: ()=>safariRegenerationDiscards,
             HH: ()=>messageWithoutSenderError,
             Ih: ()=>browserNotInstalledError,
             JB: ()=>devChannelSnapshotInUse,
+            KP: ()=>safariBuildCalled,
             L: ()=>chromiumManifestLoadBlockers,
             LD: ()=>firefoxDryRunBinary,
             M3: ()=>cdpClientConnected,
@@ -791,45 +896,64 @@ var __webpack_modules__ = {
             NO: ()=>mv3BackgroundScriptsNotSupportedByChromium,
             Nk: ()=>chromiumDryRunNotLaunching,
             Q0: ()=>chromiumDryRunBinary,
+            Rl: ()=>safariBuilt,
             Sp: ()=>invalidChromiumBinaryPath,
             TF: ()=>enhancedProcessManagementCleanupError,
             Te: ()=>cdpClientTargetWebSocketUrlStored,
             Th: ()=>browserInstanceExited,
+            Tq: ()=>safariForcedRegeneration,
+            UW: ()=>safariPackagingSkippedNonMac,
             Ug: ()=>usingManagedChromiumFamilyFallback,
             Vk: ()=>enhancedProcessManagementCleanup,
             WV: ()=>addonInstallError,
             XH: ()=>enhancedProcessManagementTerminating,
+            Xi: ()=>safariXcodeRequired,
             Z5: ()=>cdpClientExtensionInfoFailed,
             _D: ()=>browserLaunchError,
             aI: ()=>devChromeProfilePath,
+            aO: ()=>safariOpenHint,
             bv: ()=>cdpUnifiedExtensionLog,
             cD: ()=>targetActorHasActiveRequestError,
+            cF: ()=>safariRebuilt,
             dN: ()=>firefoxNoBinaryArgsFound,
             dk: ()=>generalBrowserError,
             dw: ()=>devFirefoxProfilePath,
             e_: ()=>runningInDevelopment,
+            fL: ()=>safariDryRunConverter,
+            fO: ()=>safariNextSteps,
             fR: ()=>cdpClientConnectionError,
+            fd: ()=>safariRegistered,
+            fw: ()=>safariOpening,
             hE: ()=>cdpClientConnectionClosed,
             iL: ()=>resolvedBrowserBinary,
             io: ()=>emptyLine,
             iv: ()=>firefoxBinaryArgsExtracted,
             jP: ()=>rdpInvalidRequestPayload,
+            jR: ()=>safariBuilding,
+            jc: ()=>safariProjectStale,
             jk: ()=>requireGeckoBinaryForGeckoBased,
             k6: ()=>firefoxDryRunConfig,
             kK: ()=>preferringSystemBrowserOverSnapshot,
             l9: ()=>parsingPacketError,
+            l_: ()=>safariConverted,
             ne: ()=>requireChromiumBinaryForChromiumBased,
             nn: ()=>chromeProcessExited,
+            oB: ()=>safariSettingsPreserved,
+            oM: ()=>safariSkippingConversion,
             p8: ()=>cdpClientAttachedToTarget,
             pd: ()=>devFirefoxDebugPort,
             qN: ()=>messagingClientClosedError,
             qR: ()=>chromiumInvalidMatchPatterns,
+            qY: ()=>safariNotYetRegistered,
             qn: ()=>firefoxDryRunNotLaunching,
             sP: ()=>mv2NotSupportedByChromium,
             sY: ()=>creatingUserProfile,
+            uK: ()=>safariConverting,
             wk: ()=>chromeFailedToSpawn,
             xy: ()=>chromeInitializingEnhancedReload,
-            y7: ()=>skippingBrowserLaunchDueToCompileErrors
+            y1: ()=>safariConverterWarnings,
+            y7: ()=>skippingBrowserLaunchDueToCompileErrors,
+            yc: ()=>safariDryRunNotBuilding
         });
     },
     "./browsers/browsers-lib/output-binaries-resolver.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
@@ -1584,12 +1708,15 @@ var __webpack_modules__ = {
         __webpack_require__.r(__webpack_exports__);
         var _browsers_lib_browser_family__rspack_import_0 = __webpack_require__("./browsers/browsers-lib/browser-family.ts");
         var _browsers_lib_output_binaries_resolver__rspack_import_1 = __webpack_require__("./browsers/browsers-lib/output-binaries-resolver.ts");
-        var _browsers_lib_runtime_options__rspack_import_7 = __webpack_require__("./browsers/browsers-lib/runtime-options.ts");
-        var _run_chromium_chromium_context__rspack_import_5 = __webpack_require__("./browsers/run-chromium/chromium-context/index.ts");
+        var _browsers_lib_runtime_options__rspack_import_10 = __webpack_require__("./browsers/browsers-lib/runtime-options.ts");
+        var _run_chromium_chromium_context__rspack_import_8 = __webpack_require__("./browsers/run-chromium/chromium-context/index.ts");
         var _run_chromium_chromium_launch__rspack_import_2 = __webpack_require__("./browsers/run-chromium/chromium-launch/index.ts");
-        var _run_firefox_firefox_context__rspack_import_6 = __webpack_require__("./browsers/run-firefox/firefox-context/index.ts");
+        var _run_firefox_firefox_context__rspack_import_9 = __webpack_require__("./browsers/run-firefox/firefox-context/index.ts");
         var _run_firefox_firefox_launch__rspack_import_3 = __webpack_require__("./browsers/run-firefox/firefox-launch/index.ts");
         var _run_only__rspack_import_4 = __webpack_require__("./browsers/run-only.ts");
+        var _run_safari_safari_launch__rspack_import_5 = __webpack_require__("./browsers/run-safari/safari-launch/index.ts");
+        var _run_safari_safari_launch_safari_config__rspack_import_6 = __webpack_require__("./browsers/run-safari/safari-launch/safari-config.ts");
+        var _run_safari_safari_packager__rspack_import_7 = __webpack_require__("./browsers/run-safari/safari-packager.ts");
         function createCompilationLike(opts) {
             return {
                 options: {
@@ -1638,7 +1765,7 @@ var __webpack_modules__ = {
                 logTab: opts.logTab,
                 logSink: opts.logSink
             };
-            const ctx = (0, _run_chromium_chromium_context__rspack_import_5.g)();
+            const ctx = (0, _run_chromium_chromium_context__rspack_import_8.g)();
             const launcher = new _run_chromium_chromium_launch__rspack_import_2.f(chromiumOpts, ctx);
             const enableCdp = 'development' === mode;
             await launcher.runOnce(compilationLike, {
@@ -1712,9 +1839,9 @@ var __webpack_modules__ = {
                 port: opts.port,
                 dryRun: opts.dryRun
             };
-            const ctx = (0, _run_firefox_firefox_context__rspack_import_6.D)();
+            const ctx = (0, _run_firefox_firefox_context__rspack_import_9.D)();
             const launcher = new _run_firefox_firefox_launch__rspack_import_3.c(firefoxOpts, ctx);
-            const launchRequest = (0, _browsers_lib_runtime_options__rspack_import_7.zU)(pluginOptions, mode, {
+            const launchRequest = (0, _browsers_lib_runtime_options__rspack_import_10.zU)(pluginOptions, mode, {
                 persistProfile: opts.persistProfile,
                 geckoBinary: opts.geckoBinary
             });
@@ -1745,8 +1872,17 @@ var __webpack_modules__ = {
             };
         }
         __webpack_require__.d(__webpack_exports__, {
+            builtAppPath: ()=>_run_safari_safari_launch_safari_config__rspack_import_6.fd,
+            createSafariPackager: ()=>_run_safari_safari_packager__rspack_import_7.P,
+            isValidBundleId: ()=>_run_safari_safari_launch_safari_config__rspack_import_6.OA,
             launchBrowser: ()=>launchBrowser,
-            runOnlyPreviewBrowser: ()=>_run_only__rspack_import_4.E
+            macOsSchemeName: ()=>_run_safari_safari_launch_safari_config__rspack_import_6.aD,
+            packageSafariExtension: ()=>_run_safari_safari_launch__rspack_import_5.Ah,
+            resolveSafariBuildConfig: ()=>_run_safari_safari_launch_safari_config__rspack_import_6.F7,
+            runOnlyPreviewBrowser: ()=>_run_only__rspack_import_4.E,
+            safariBuildPreflight: ()=>_run_safari_safari_launch__rspack_import_5.QW,
+            safariPreflightError: ()=>_run_safari_safari_launch__rspack_import_5.iF,
+            xcodeProjectPath: ()=>_run_safari_safari_launch_safari_config__rspack_import_6.Gi
         });
     },
     "./browsers/run-chromium/cdp/discovery.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
@@ -2507,10 +2643,13 @@ var __webpack_modules__ = {
             const loadExtensionFlag = args.chromiumConfig.find((flag)=>flag.startsWith('--load-extension='));
             const extensionOutputPath = (0, extension_output_path.W)(args.compilation, loadExtensionFlag);
             if (!extensionOutputPath) return;
+            const userDataDirFlag = args.chromiumConfig.find((flag)=>flag.startsWith('--user-data-dir='));
+            const profilePath = userDataDirFlag ? userDataDirFlag.replace('--user-data-dir=', '').replace(/^"|"$/g, '') : void 0;
             if ('production' === mode) return void await (0, banner.MK)({
                 browser: args.browser,
                 outPath: extensionOutputPath,
-                browserVersionLine: args.browserVersionLine
+                browserVersionLine: args.browserVersionLine,
+                profilePath
             });
             if ('development' !== mode) return;
             const ready = await (0, manifest_readiness.fR)(extensionOutputPath, {
@@ -2523,7 +2662,8 @@ var __webpack_modules__ = {
                 outPath: extensionOutputPath,
                 hostPort: args.hostPort,
                 getInfo: async ()=>null,
-                browserVersionLine: args.browserVersionLine
+                browserVersionLine: args.browserVersionLine,
+                profilePath
             });
         }
         class ChromiumLaunchPlugin {
@@ -5017,6 +5157,495 @@ var __webpack_modules__ = {
             E: ()=>runOnlyPreviewBrowser
         });
     },
+    "./browsers/run-safari/safari-launch/index.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            Ah: ()=>packageSafariExtension,
+            QW: ()=>safariBuildPreflight,
+            iF: ()=>safariPreflightError
+        });
+        var external_node_child_process_ = __webpack_require__("node:child_process");
+        var external_node_fs_ = __webpack_require__("node:fs");
+        var messaging = __webpack_require__("./helpers/messaging.ts");
+        var messages = __webpack_require__("./browsers/browsers-lib/messages.ts");
+        function logSafariDryRun(converterCmd, xcodebuildCmd) {
+            if ((0, messaging._o)()) console.log(messages.KP());
+            console.log(messages.yc());
+            console.log(messages.fL(converterCmd));
+            console.log(messages.Aj(xcodebuildCmd));
+        }
+        var safari_config = __webpack_require__("./browsers/run-safari/safari-launch/safari-config.ts");
+        function isMacOS() {
+            return 'darwin' === process.platform;
+        }
+        function activeDeveloperDir() {
+            try {
+                const result = (0, external_node_child_process_.spawnSync)('xcode-select', [
+                    '-p'
+                ], {
+                    encoding: 'utf8',
+                    timeout: 15000
+                });
+                if (0 !== result.status) return null;
+                const resolved = String(result.stdout || '').trim();
+                return resolved.length > 0 ? resolved : null;
+            } catch  {
+                return null;
+            }
+        }
+        function findWithXcrun(tool) {
+            try {
+                const result = (0, external_node_child_process_.spawnSync)('xcrun', [
+                    '--find',
+                    tool
+                ], {
+                    encoding: 'utf8',
+                    timeout: 15000
+                });
+                if (0 !== result.status) return null;
+                const resolved = String(result.stdout || '').trim();
+                return resolved.length > 0 ? resolved : null;
+            } catch  {
+                return null;
+            }
+        }
+        function detectSafariToolchain() {
+            const platformOk = isMacOS();
+            if (!platformOk) return {
+                platformOk: false,
+                developerDir: null,
+                needsFullXcode: false,
+                converter: null,
+                xcodebuild: null,
+                ok: false
+            };
+            const developerDir = activeDeveloperDir();
+            const needsFullXcode = !developerDir || /CommandLineTools/i.test(developerDir);
+            const converter = findWithXcrun('safari-web-extension-converter');
+            const xcodebuild = findWithXcrun('xcodebuild');
+            return {
+                platformOk,
+                developerDir,
+                needsFullXcode,
+                converter,
+                xcodebuild,
+                ok: Boolean(converter && xcodebuild)
+            };
+        }
+        function fallbackLogger() {
+            return {
+                info: (...a)=>console.log(...a),
+                warn: (...a)=>console.warn(...a),
+                error: (...a)=>console.error(...a),
+                debug: (...a)=>console?.debug?.(...a)
+            };
+        }
+        function isTestEnv() {
+            return Boolean(process.env.VITEST || process.env.VITEST_WORKER_ID);
+        }
+        function delay(ms) {
+            return new Promise((resolve)=>setTimeout(resolve, ms));
+        }
+        const TOOL_TAIL_LINES = 50;
+        const TOOL_TAIL_BYTES = 8192;
+        function toolOutputTail(output) {
+            const lines = output.slice(4 * -TOOL_TAIL_BYTES).split(/\r?\n/).filter((line)=>line.trim().length > 0);
+            const tail = lines.slice(-TOOL_TAIL_LINES).join('\n');
+            return tail.length > TOOL_TAIL_BYTES ? tail.slice(-TOOL_TAIL_BYTES) : tail;
+        }
+        function runTool(bin, args, opts) {
+            const streamOutput = (0, messaging._o)() && !opts?.quiet;
+            return new Promise((resolve)=>{
+                let output = '';
+                const child = (0, external_node_child_process_.spawn)(bin, args, {
+                    stdio: [
+                        'ignore',
+                        'pipe',
+                        'pipe'
+                    ]
+                });
+                const onChunk = (chunk)=>{
+                    const text = String(chunk);
+                    output += text;
+                    if (output.length > 8 * TOOL_TAIL_BYTES) output = output.slice(4 * -TOOL_TAIL_BYTES);
+                    if (streamOutput) process.stdout.write(text);
+                };
+                child.stdout?.on('data', onChunk);
+                child.stderr?.on('data', onChunk);
+                child.on('error', (error)=>resolve({
+                        ok: false,
+                        code: null,
+                        output: `${output}${String(error)}`
+                    }));
+                child.on('close', (code)=>resolve({
+                        ok: 0 === code,
+                        code,
+                        output
+                    }));
+            });
+        }
+        function converterWarnings(output) {
+            return output.split(/\r?\n/).filter((line)=>/warning/i.test(line)).map((line)=>line.trim()).filter((line)=>line.length > 0);
+        }
+        async function confirmRegisteredWithSafari(bundleIdentifier) {
+            const needle = `${bundleIdentifier}.Extension`;
+            for(let attempt = 0; attempt < 6; attempt += 1){
+                const { ok, output } = await runTool('pluginkit', [
+                    '-m'
+                ], {
+                    quiet: true
+                });
+                if (ok && output.includes(needle)) return true;
+                await delay(800);
+            }
+            return false;
+        }
+        function describePackage(config) {
+            return {
+                appName: config.appName,
+                bundleId: config.bundleIdentifier,
+                bundleIdDerived: config.bundleIdDerived,
+                appPath: (0, safari_config.fd)(config),
+                xcodeProjectPath: (0, safari_config.Gi)(config),
+                macOsOnly: config.macOsOnly
+            };
+        }
+        function safariPreflightError() {
+            const tc = detectSafariToolchain();
+            if (!tc.platformOk) return messages.G3(process.platform);
+            if (!tc.ok) {
+                if (tc.needsFullXcode) return messages.Xi(tc.developerDir);
+                return messages.Cs(tc.converter ? 'xcodebuild' : 'safari-web-extension-converter');
+            }
+            return null;
+        }
+        function safariBuildPreflight() {
+            const tc = detectSafariToolchain();
+            if (!tc.platformOk) return {
+                severity: 'skip',
+                message: messages.UW(process.platform)
+            };
+            if (!tc.ok) return {
+                severity: 'fatal',
+                message: tc.needsFullXcode ? messages.Xi(tc.developerDir) : messages.Cs(tc.converter ? 'xcodebuild' : 'safari-web-extension-converter')
+            };
+            return {
+                severity: 'ok'
+            };
+        }
+        async function runSafariPipeline(compilation, host, logger, mode) {
+            const config = (0, safari_config.F7)(compilation, host);
+            const converterArgs = (0, safari_config.w7)(config);
+            const xcodebuildArgs = (0, safari_config.vx)(config);
+            if (host.dryRun || isTestEnv()) {
+                logSafariDryRun(`xcrun ${converterArgs.join(' ')}`, `xcodebuild ${xcodebuildArgs.join(' ')}`);
+                return describePackage(config);
+            }
+            const toolchain = detectSafariToolchain();
+            if (!toolchain.platformOk) {
+                logger.warn?.(messages.G3(process.platform));
+                return describePackage(config);
+            }
+            if (!toolchain.ok) {
+                if (toolchain.needsFullXcode) logger.error?.(messages.Xi(toolchain.developerDir));
+                else {
+                    const missing = toolchain.converter ? 'xcodebuild' : 'safari-web-extension-converter';
+                    logger.error?.(messages.Cs(missing));
+                }
+                return describePackage(config);
+            }
+            const projectExists = external_node_fs_.existsSync((0, safari_config.Gi)(config));
+            const needsConversion = !projectExists || host.forceRegenerate || (0, safari_config.vk)(config);
+            if (needsConversion) {
+                if (projectExists) {
+                    logger.info?.(host.forceRegenerate ? messages.Tq() : messages.jc());
+                    logger.warn?.(messages.H1([
+                        ...safari_config.X9
+                    ]));
+                }
+                const { saved, restore } = (0, safari_config._D)(config);
+                logger.info?.(messages.uK(config.extensionDir));
+                const converted = await runTool('xcrun', converterArgs);
+                if (!converted.ok) {
+                    const tail = toolOutputTail(converted.output);
+                    logger.error?.(messages.A('safari-web-extension-converter', converted.code, tail));
+                    throw new Error(`safari-web-extension-converter failed (exit ${converted.code})\n${tail}`);
+                }
+                const warnings = converterWarnings(converted.output);
+                if (warnings.length > 0) logger.warn?.(messages.y1(warnings));
+                const projFile = (0, safari_config.vh)(config);
+                if (external_node_fs_.existsSync(projFile)) external_node_fs_.writeFileSync(projFile, (0, safari_config.IA)(external_node_fs_.readFileSync(projFile, 'utf8'), config.bundleIdentifier), 'utf8');
+                restore();
+                const preservedKeys = Object.keys(saved);
+                if (preservedKeys.length > 0) logger.info?.(messages.oB(preservedKeys));
+                (0, safari_config.x7)(config);
+                logger.info?.(messages.l_(config.projectLocation));
+            } else logger.info?.(messages.oM());
+            if ('full' === mode) logger.info?.(messages.jR((0, safari_config.aD)(config)));
+            const built = await runTool('xcodebuild', xcodebuildArgs);
+            if (!built.ok) {
+                const tail = toolOutputTail(built.output);
+                logger.error?.(messages.A('xcodebuild', built.code, tail));
+                throw new Error(`xcodebuild failed (exit ${built.code})\n${tail}`);
+            }
+            const appPath = (0, safari_config.fd)(config);
+            if ('resync' === mode) {
+                logger.info?.(messages.cF(config.appName));
+                return describePackage(config);
+            }
+            logger.info?.(messages.Rl(appPath));
+            if (config.bundleIdDerived) logger.info?.(messages.$q(config.bundleIdentifier));
+            if (!config.open) {
+                logger.info?.(messages.aO(appPath, config.appName));
+                return describePackage(config);
+            }
+            const target = external_node_fs_.existsSync(appPath) ? appPath : (0, safari_config.Gi)(config);
+            logger.info?.(messages.fw(target));
+            await runTool('open', [
+                target
+            ]);
+            if (config.safariBinary) await runTool('open', [
+                '-a',
+                config.safariBinary
+            ]);
+            logger.info?.(messages.fO(config.appName));
+            if (await confirmRegisteredWithSafari(config.bundleIdentifier)) logger.info?.(messages.fd(config.appName));
+            else logger.warn?.(messages.qY(config.appName));
+            return describePackage(config);
+        }
+        async function packageSafariExtension(host, outputPath, logger, mode = 'full') {
+            const compilation = {
+                options: {
+                    output: {
+                        path: outputPath
+                    }
+                },
+                outputOptions: {
+                    path: outputPath
+                }
+            };
+            return await runSafariPipeline(compilation, host, logger || fallbackLogger(), mode);
+        }
+    },
+    "./browsers/run-safari/safari-launch/safari-config.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        var node_fs__rspack_import_0 = __webpack_require__("node:fs");
+        var node_path__rspack_import_1 = __webpack_require__("node:path");
+        function sanitizeAppName(value) {
+            const cleaned = String(value || '').replace(/[\\/:*?"<>|]+/g, ' ').replace(/\s+/g, ' ').trim();
+            return cleaned.length > 0 ? cleaned : 'Extension';
+        }
+        function bundleSegment(appName) {
+            return String(appName || '').replace(/[^A-Za-z0-9]+/g, '-').replace(/^-+|-+$/g, '') || 'extension';
+        }
+        function deriveBundleId(appName) {
+            return `dev.extensionjs.${bundleSegment(appName)}`;
+        }
+        function isValidBundleId(value) {
+            return /^[A-Za-z][A-Za-z0-9-]*(\.[A-Za-z][A-Za-z0-9-]*)+$/.test(value);
+        }
+        function readManifest(extensionDir) {
+            try {
+                const manifestPath = node_path__rspack_import_1.join(extensionDir, 'manifest.json');
+                if (node_fs__rspack_import_0.existsSync(manifestPath)) return JSON.parse(node_fs__rspack_import_0.readFileSync(manifestPath, 'utf8')) || {};
+            } catch  {}
+            return {};
+        }
+        function resolveSafariBuildConfig(compilation, host) {
+            const extensionDir = String(compilation?.options?.output?.path || '');
+            const manifest = readManifest(extensionDir);
+            const appName = sanitizeAppName(String(host.appName || manifest?.name || 'Extension'));
+            const userBundleId = String(host.bundleId || '').trim();
+            const bundleIdDerived = !userBundleId;
+            const bundleIdentifier = bundleIdDerived ? deriveBundleId(appName) : userBundleId;
+            const projectLocation = `${extensionDir.replace(/[\\/]+$/, '')}-xcode`;
+            return {
+                extensionDir,
+                projectLocation,
+                appName,
+                bundleIdentifier,
+                bundleIdDerived,
+                macOsOnly: false !== host.macOsOnly,
+                language: 'swift',
+                open: !host.noOpen,
+                safariBinary: host.safariBinary
+            };
+        }
+        function composeConverterArgs(config) {
+            const args = [
+                'safari-web-extension-converter',
+                config.extensionDir,
+                '--project-location',
+                config.projectLocation,
+                '--app-name',
+                config.appName,
+                '--bundle-identifier',
+                config.bundleIdentifier,
+                '--no-prompt',
+                '--no-open',
+                '--force',
+                'objc' === config.language ? '--objc' : '--swift'
+            ];
+            if (config.macOsOnly) args.push('--macos-only');
+            return args;
+        }
+        function macOsSchemeName(config) {
+            return config.macOsOnly ? config.appName : `${config.appName} (macOS)`;
+        }
+        function xcodeProjectPath(config) {
+            return node_path__rspack_import_1.join(config.projectLocation, config.appName, `${config.appName}.xcodeproj`);
+        }
+        function derivedDataPath(config) {
+            return node_path__rspack_import_1.join(config.projectLocation, '.derived');
+        }
+        function builtAppPath(config) {
+            return node_path__rspack_import_1.join(derivedDataPath(config), 'Build', 'Products', 'Release', `${config.appName}.app`);
+        }
+        function composeXcodebuildArgs(config) {
+            return [
+                '-project',
+                xcodeProjectPath(config),
+                '-scheme',
+                macOsSchemeName(config),
+                '-configuration',
+                'Release',
+                '-derivedDataPath',
+                derivedDataPath(config),
+                'CODE_SIGN_IDENTITY=-',
+                'CODE_SIGNING_REQUIRED=NO',
+                'CODE_SIGNING_ALLOWED=YES',
+                'build'
+            ];
+        }
+        function manifestFingerprintPath(config) {
+            return node_path__rspack_import_1.join(config.projectLocation, '.manifest-fingerprint');
+        }
+        function stableStringify(obj) {
+            if (null == obj) return JSON.stringify(obj);
+            if ('object' != typeof obj) return JSON.stringify(obj);
+            if (Array.isArray(obj)) return `[${obj.map(stableStringify).join(',')}]`;
+            const keys = Object.keys(obj).sort();
+            return `{${keys.map((k)=>`${JSON.stringify(k)}:${stableStringify(obj[k])}`).join(',')}}`;
+        }
+        function readManifestRaw(extensionDir) {
+            try {
+                return node_fs__rspack_import_0.readFileSync(node_path__rspack_import_1.join(extensionDir, 'manifest.json'), 'utf8');
+            } catch  {
+                return '';
+            }
+        }
+        function normalizeManifest(raw) {
+            try {
+                return stableStringify(JSON.parse(raw));
+            } catch  {
+                return raw;
+            }
+        }
+        function composeProjectFingerprint(config) {
+            return JSON.stringify({
+                v: 2,
+                identity: {
+                    appName: config.appName,
+                    bundleId: config.bundleIdentifier,
+                    macOsOnly: config.macOsOnly
+                },
+                manifest: normalizeManifest(readManifestRaw(config.extensionDir))
+            });
+        }
+        function saveManifestFingerprint(config) {
+            node_fs__rspack_import_0.mkdirSync(node_path__rspack_import_1.dirname(manifestFingerprintPath(config)), {
+                recursive: true
+            });
+            node_fs__rspack_import_0.writeFileSync(manifestFingerprintPath(config), composeProjectFingerprint(config), 'utf8');
+        }
+        function isProjectStale(config) {
+            const fpPath = manifestFingerprintPath(config);
+            if (!node_fs__rspack_import_0.existsSync(fpPath)) return true;
+            const stored = node_fs__rspack_import_0.readFileSync(fpPath, 'utf8');
+            return stored !== composeProjectFingerprint(config);
+        }
+        function alignBundleIdentifiers(pbxprojContent, bundleId) {
+            return pbxprojContent.replace(/PRODUCT_BUNDLE_IDENTIFIER = ("?)([^;"]+)\1;/g, (_match, _quote, value)=>/\.Extension$/.test(String(value)) ? `PRODUCT_BUNDLE_IDENTIFIER = "${bundleId}.Extension";` : `PRODUCT_BUNDLE_IDENTIFIER = "${bundleId}";`);
+        }
+        const PRESERVED_SETTINGS = [
+            'DEVELOPMENT_TEAM',
+            'CODE_SIGN_STYLE',
+            'PROVISIONING_PROFILE_SPECIFIER'
+        ];
+        function pbxprojPath(config) {
+            return node_path__rspack_import_1.join(xcodeProjectPath(config), 'project.pbxproj');
+        }
+        function extractXcodeUserSettings(pbxprojContent) {
+            const found = {};
+            for (const key of PRESERVED_SETTINGS){
+                const m = new RegExp(`\\b${key}\\s*=\\s*([^;]+);`).exec(pbxprojContent);
+                if (m) {
+                    const val = m[1].trim();
+                    if (val && '""' !== val && "''" !== val) found[key] = val;
+                }
+            }
+            return found;
+        }
+        function applyXcodeUserSettings(pbxprojContent, settings) {
+            let result = pbxprojContent;
+            for (const [key, value] of Object.entries(settings)){
+                const existing = new RegExp(`\\b${key}\\s*=\\s*[^;]+;`, 'g');
+                result = existing.test(result) ? result.replace(existing, `${key} = ${value};`) : result.replace(/buildSettings\s*=\s*\{/g, `buildSettings = {\n\t\t\t\t${key} = ${value};`);
+            }
+            return result;
+        }
+        function backupAndRestoreXcodeSettings(config) {
+            const projFile = pbxprojPath(config);
+            let saved = {};
+            if (node_fs__rspack_import_0.existsSync(projFile)) saved = extractXcodeUserSettings(node_fs__rspack_import_0.readFileSync(projFile, 'utf8'));
+            return {
+                saved,
+                restore () {
+                    if (0 === Object.keys(saved).length) return;
+                    if (!node_fs__rspack_import_0.existsSync(projFile)) return;
+                    const content = node_fs__rspack_import_0.readFileSync(projFile, 'utf8');
+                    node_fs__rspack_import_0.writeFileSync(projFile, applyXcodeUserSettings(content, saved), 'utf8');
+                }
+            };
+        }
+        __webpack_require__.d(__webpack_exports__, {
+            F7: ()=>resolveSafariBuildConfig,
+            Gi: ()=>xcodeProjectPath,
+            IA: ()=>alignBundleIdentifiers,
+            OA: ()=>isValidBundleId,
+            _D: ()=>backupAndRestoreXcodeSettings,
+            aD: ()=>macOsSchemeName,
+            fd: ()=>builtAppPath,
+            vh: ()=>pbxprojPath,
+            vk: ()=>isProjectStale,
+            vx: ()=>composeXcodebuildArgs,
+            w7: ()=>composeConverterArgs,
+            x7: ()=>saveManifestFingerprint
+        }, {
+            X9: PRESERVED_SETTINGS
+        });
+    },
+    "./browsers/run-safari/safari-packager.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        var _safari_launch__rspack_import_0 = __webpack_require__("./browsers/run-safari/safari-launch/index.ts");
+        function withoutUndefined(input) {
+            if (!input) return {};
+            return Object.fromEntries(Object.entries(input).filter(([, value])=>void 0 !== value));
+        }
+        function createSafariPackager(options = {}) {
+            const { browser = 'safari', noOpen = true, dryRun = false, logger, ...identity } = options;
+            return async (distPath, mode = 'full', overrides)=>await (0, _safari_launch__rspack_import_0.Ah)({
+                    extension: [
+                        distPath
+                    ],
+                    browser,
+                    noOpen,
+                    dryRun,
+                    ...withoutUndefined(identity),
+                    ...withoutUndefined(overrides)
+                }, distPath, logger, mode);
+        }
+        __webpack_require__.d(__webpack_exports__, {
+            P: ()=>createSafariPackager
+        });
+    },
     "./helpers/messaging.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
         var pintor__rspack_import_0 = __webpack_require__("pintor");
         var pintor__rspack_import_0_default = /*#__PURE__*/ __webpack_require__.n(pintor__rspack_import_0);
@@ -5201,11 +5830,29 @@ __webpack_require__.m = __webpack_modules__;
     };
 })();
 var __webpack_exports__ = __webpack_require__("./browsers/index.ts");
+exports.builtAppPath = __webpack_exports__.builtAppPath;
+exports.createSafariPackager = __webpack_exports__.createSafariPackager;
+exports.isValidBundleId = __webpack_exports__.isValidBundleId;
 exports.launchBrowser = __webpack_exports__.launchBrowser;
+exports.macOsSchemeName = __webpack_exports__.macOsSchemeName;
+exports.packageSafariExtension = __webpack_exports__.packageSafariExtension;
+exports.resolveSafariBuildConfig = __webpack_exports__.resolveSafariBuildConfig;
 exports.runOnlyPreviewBrowser = __webpack_exports__.runOnlyPreviewBrowser;
+exports.safariBuildPreflight = __webpack_exports__.safariBuildPreflight;
+exports.safariPreflightError = __webpack_exports__.safariPreflightError;
+exports.xcodeProjectPath = __webpack_exports__.xcodeProjectPath;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "builtAppPath",
+    "createSafariPackager",
+    "isValidBundleId",
     "launchBrowser",
-    "runOnlyPreviewBrowser"
+    "macOsSchemeName",
+    "packageSafariExtension",
+    "resolveSafariBuildConfig",
+    "runOnlyPreviewBrowser",
+    "safariBuildPreflight",
+    "safariPreflightError",
+    "xcodeProjectPath"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true