pake-cli 3.16.3 → 3.17.0

package/README.md

@@ -192,7 +192,7 @@ pake https://weekly.tw93.fun --name Weekly --icon https://cdn.tw93.fun/pake/week
 
 First-time packaging requires environment setup and may be slower, subsequent builds are fast. For complete parameter documentation, see [CLI Usage Guide](docs/cli-usage.md). Don't want to use CLI? Try [GitHub Actions Online Building](docs/github-actions-usage.md).
 
-Using Pake from a script or AI agent? Pass `--json` for machine-readable results, describe apps declaratively with `--config app.json` ([schema](schema/pake.schema.json)), and package local build output directly with `pake ./dist --name MyTool`. See [llms.txt](llms.txt) for the full agent contract. Claude Code users can install the official skill with `/plugin marketplace add tw93/Pake` and `/plugin install pake@pake`.
+Using Pake from a script or AI agent? Pass `--json` for machine-readable results, describe apps declaratively with `--config app.json` ([schema](schema/pake.schema.json)), and package local build output directly with `pake ./dist --name MyTool`. See [llms.txt](llms.txt) for the full agent contract. To install the official skill, run `/plugin marketplace add tw93/Pake` and `/plugin install pake@pake` in Claude Code, or `codex plugin marketplace add tw93/Pake` and `codex plugin add pake@pake` in Codex.
 
 Copy this to your AI agent to get started:
 

package/dist/cli.js

@@ -19,7 +19,7 @@ import * as psl from 'psl';
 import { InvalidArgumentError, program as program$1, Option } from 'commander';
 
 var name = "pake-cli";
-var version = "3.16.3";
+var version = "3.17.0";
 var description = "🤱🏻 Turn any webpage into a desktop app with one command. 🤱🏻 一键打包网页生成轻量桌面应用。";
 var engines = {
 	node: ">=20.9.0"
@@ -787,6 +787,49 @@ function checkRustInstalled() {
         return false;
     }
 }
+function getVsWherePath() {
+    const programFilesX86 = process.env['ProgramFiles(x86)'] || 'C:\\Program Files (x86)';
+    return path.join(programFilesX86, 'Microsoft Visual Studio', 'Installer', 'vswhere.exe');
+}
+/**
+ * Detects Visual Studio Build Tools the way rustc itself does: via the VS
+ * installer's vswhere.exe, not PATH. cl.exe/link.exe are normally absent
+ * from PATH even on a fully working MSVC setup (rustc locates them through
+ * the same registry vswhere reads), so checking PATH directly would warn on
+ * most MSVC machines.
+ */
+function hasWindowsMsvcBuildTools() {
+    const vswhere = getVsWherePath();
+    if (!fsExtra.pathExistsSync(vswhere))
+        return false;
+    try {
+        const { stdout } = execaSync(vswhere, [
+            '-products',
+            '*',
+            '-requires',
+            'Microsoft.VisualStudio.Component.VC.Tools.x86.x64',
+            '-property',
+            'installationPath',
+        ]);
+        return stdout.trim().length > 0;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * MinGW/MSYS2's gcc drives the GNU Windows target directly off PATH (no
+ * registry lookup involved), so a PATH check is the correct signal here.
+ */
+function hasWindowsGnuToolchain() {
+    try {
+        execaSync('gcc', ['--version'], { stdio: 'ignore' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 
 async function combineFiles(files, output) {
     const contents = await Promise.all(files.map(async (file) => {
@@ -1361,6 +1404,27 @@ function getBuildEnvironment() {
         PATH: buildPath,
     };
 }
+/**
+ * Build scripts and proc-macros compile for the rustup *host* toolchain, not
+ * the `--target` triple, even when cross-compiling. Pake's own
+ * rust-toolchain.toml pins a bare channel (no host), which rustup resolves
+ * against the machine's configured default host — msvc on most Windows
+ * installs, regardless of whether MSVC is actually present. Without this,
+ * a gnu `--target` build still shells out to the (possibly missing) MSVC
+ * `link.exe` for every build script. RUSTUP_TOOLCHAIN is rustup's documented
+ * per-invocation override (read by the cargo/rustc proxies it installs) and
+ * only affects this build subprocess. Left alone if the user already set it.
+ */
+function getWindowsGnuBuildEnvironment() {
+    const excludeAllSymbols = '-C link-args=-Wl,--exclude-all-symbols';
+    const existingRustflags = process.env.RUSTFLAGS;
+    return {
+        RUSTFLAGS: existingRustflags
+            ? `${existingRustflags} ${excludeAllSymbols}`
+            : excludeAllSymbols,
+        RUSTUP_TOOLCHAIN: process.env.RUSTUP_TOOLCHAIN || 'stable-x86_64-pc-windows-gnu',
+    };
+}
 /**
  * Windows needs more time due to native compilation and antivirus scanning.
  */
@@ -1575,6 +1639,13 @@ class BaseBuilder {
             logger.warn('✼ See more in https://tauri.app/start/prerequisites/.');
         }
         ensureRustEnv();
+        if (IS_WIN &&
+            this.options.windowsToolchain !== 'gnu' &&
+            !hasWindowsMsvcBuildTools() &&
+            hasWindowsGnuToolchain()) {
+            logger.warn('✼ No Visual Studio Build Tools detected, but a MinGW/GNU toolchain (gcc) is available.');
+            logger.warn('✼ If the build fails to link, retry with --windows-toolchain gnu.');
+        }
         if (!checkRustInstalled()) {
             if (!isInteractive()) {
                 throw new PakeError('Rust required to package your webapp.', {
@@ -1675,8 +1746,10 @@ class BaseBuilder {
         // entries feed the --json warnings array and this is a status line.
         logger.info('✸ Building app...');
         const baseEnv = getBuildEnvironment();
+        const isWindowsGnuBuild = process.platform === 'win32' && this.options.windowsToolchain === 'gnu';
         let buildEnv = {
             ...(baseEnv ?? {}),
+            ...(isWindowsGnuBuild ? getWindowsGnuBuildEnvironment() : {}),
             ...(process.env.NO_STRIP ? { NO_STRIP: process.env.NO_STRIP } : {}),
         };
         const resolveExecEnv = () => Object.keys(buildEnv).length > 0 ? buildEnv : undefined;
@@ -2038,11 +2111,18 @@ class WinBuilder extends BaseBuilder {
         this.buildArch = validArchs.includes(options.targets || '')
             ? this.resolveTargetArch(options.targets)
             : this.resolveTargetArch('auto');
+        this.toolchain = options.windowsToolchain === 'gnu' ? 'gnu' : 'msvc';
         this.options.targets = this.buildFormat;
     }
     getReportArch() {
         return this.buildArch;
     }
+    getTauriTarget(arch, platform = 'win32') {
+        if (this.toolchain === 'gnu') {
+            return WinBuilder.GNU_ARCH_MAPPINGS[arch] || null;
+        }
+        return super.getTauriTarget(arch, platform);
+    }
     getFileName() {
         const { name } = this.options;
         const language = this.options.installerLanguage;
@@ -2082,6 +2162,12 @@ class WinBuilder extends BaseBuilder {
         return `pake-${generateIdentifierSafeName(appName)}.exe`;
     }
 }
+// MSYS2/MinGW only ships an x86_64 GCC toolchain, so gnu is x64-only;
+// arm64 falls through to getTauriTarget returning null, which the
+// existing call sites already turn into "Unsupported architecture".
+WinBuilder.GNU_ARCH_MAPPINGS = {
+    x64: 'x86_64-pc-windows-gnu',
+};
 
 class LinuxBuilder extends BaseBuilder {
     constructor(options) {
@@ -3537,6 +3623,7 @@ ${green('|_|   \\__,_|_|\\_\\___|  can turn any webpage into a desktop app with
         .default(DEFAULT_PAKE_OPTIONS.userAgent)
         .hideHelp())
         .addOption(new Option('--targets <string>', 'Build target format for your system').default(DEFAULT_PAKE_OPTIONS.targets))
+        .addOption(new Option('--windows-toolchain <toolchain>', 'Windows Rust toolchain: msvc (default, requires Visual Studio Build Tools) or gnu (MinGW/MSYS2, for machines without them)').choices(['msvc', 'gnu']))
         .addOption(new Option('--app-version <string>', 'App version, the same as package.json version')
         .default(DEFAULT_PAKE_OPTIONS.appVersion)
         .hideHelp())
@@ -3570,7 +3657,7 @@ ${green('|_|   \\__,_|_|\\_\\___|  can turn any webpage into a desktop app with
             return true;
         if (value === 'false')
             return false;
-        throw new Error('--hide-on-close must be true or false');
+        throw new InvalidArgumentError('--hide-on-close must be true or false');
     })
         .hideHelp())
         .addOption(new Option('--title <string>', 'Window title').hideHelp())
@@ -3612,7 +3699,7 @@ ${green('|_|   \\__,_|_|\\_\\___|  can turn any webpage into a desktop app with
         .argParser((value) => {
         const zoom = Number(value);
         if (!Number.isInteger(zoom) || zoom < 50 || zoom > 200) {
-            throw new Error('--zoom must be an integer between 50 and 200');
+            throw new InvalidArgumentError('--zoom must be an integer between 50 and 200');
         }
         return zoom;
     })
@@ -3668,12 +3755,20 @@ const REJECTED_KEYS = new Set(['config', 'json', 'version']);
 const EXTRA_STRING_KEYS = new Set(['name', 'title', 'identifier']);
 // Numeric fields share the CLI flag ranges (see cli-program.ts validators),
 // so a config file cannot smuggle a value the same flag would reject.
+// Like --zoom, zoom must be an integer: pake.json stores it as a Rust u32.
 const NUMBER_RANGES = {
     width: { min: 0 },
     height: { min: 0 },
     minWidth: { min: 0 },
     minHeight: { min: 0 },
-    zoom: { min: 50, max: 200 },
+    zoom: { min: 50, max: 200, integer: true },
+};
+// Fields whose CLI flag restricts the value set (see the .choices() calls in
+// cli-program.ts), so a config file cannot smuggle a value the same flag
+// would reject. Without this, an unknown value falls through to the builder's
+// own fallback and silently produces the default behavior.
+const ENUM_VALUES = {
+    windowsToolchain: ['msvc', 'gnu'],
 };
 function expectedTypeFor(key) {
     if (key === 'inject')
@@ -3752,15 +3847,25 @@ async function loadConfigFile(configPath, validKeys) {
                 hint: 'See schema/pake.schema.json for field types.',
             });
         }
+        const allowed = ENUM_VALUES[key];
+        if (allowed && !allowed.includes(value)) {
+            throw new PakeError(`Config field "${key}" must be one of: ${allowed.join(', ')}.`, {
+                code: 'INVALID_INPUT',
+                hint: 'See schema/pake.schema.json for allowed values.',
+            });
+        }
         if (typeof value === 'number') {
             const range = NUMBER_RANGES[key];
             const min = range?.min ?? 0;
             const max = range?.max;
+            const integer = range?.integer === true;
             if (!Number.isFinite(value) ||
+                (integer && !Number.isInteger(value)) ||
                 value < min ||
                 (max !== undefined && value > max)) {
                 const bounds = max !== undefined ? `${min}-${max}` : `>= ${min}`;
-                throw new PakeError(`Config field "${key}" must be a finite number (${bounds}).`, {
+                const kind = integer ? 'an integer' : 'a finite number';
+                throw new PakeError(`Config field "${key}" must be ${kind} (${bounds}).`, {
                     code: 'INVALID_INPUT',
                     hint: 'See schema/pake.schema.json for field ranges.',
                 });
@@ -3968,6 +4073,19 @@ program.parseAsync().catch((error) => {
         // Parse errors (unknown option, invalid argument, missing value) are
         // invalid input. Commander already printed the message to stderr; in
         // json mode also emit the machine-readable result on stdout.
+        //
+        // Excess operands are almost always an unquoted value: `--name Google
+        // Translate` leaves `Translate` as a second operand, and commander's
+        // "too many arguments" names neither --name nor quoting, so the shape
+        // reads as "names with spaces are unsupported" (#1378).
+        const excessArguments = error.code === 'commander.excessArguments';
+        // Name the operand rather than asserting why it is there. Unquoting is the
+        // usual cause, but two bare URLs produce the same error and the quoting
+        // advice would be wrong for them.
+        const extraOperand = excessArguments ? program.args.slice(1)[0] : undefined;
+        const hint = excessArguments
+            ? `Unexpected extra argument${extraOperand ? ` "${extraOperand}"` : ''}. A value containing spaces must be quoted, for example --name "Google Translate".`
+            : 'Run pake --help for the accepted options.';
         if (process.argv.includes('--json')) {
             printJsonResult({
                 ok: false,
@@ -3979,10 +4097,15 @@ program.parseAsync().catch((error) => {
                 error: {
                     code: 'INVALID_INPUT',
                     message: error.message.trim(),
-                    hint: 'Run pake --help for the accepted options.',
+                    hint,
                 },
             });
         }
+        else if (excessArguments) {
+            // Commander has already written its message and the full help, so this
+            // lands last, which is where the eye goes after a wall of help text.
+            console.error(chalk.red(`\u2715 ${hint}`));
+        }
         process.exitCode = ERROR_EXIT_CODES.INVALID_INPUT;
         return;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pake-cli",
-  "version": "3.16.3",
+  "version": "3.17.0",
   "description": "🤱🏻 Turn any webpage into a desktop app with one command. 🤱🏻 一键打包网页生成轻量桌面应用。",
   "engines": {
     "node": ">=20.9.0"

package/src-tauri/Cargo.lock

@@ -2564,7 +2564,7 @@ dependencies = [
 
 [[package]]
 name = "pake"
-version = "3.16.3"
+version = "3.17.0"
 dependencies = [
  "block2",
  "dispatch",

package/src-tauri/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "pake"
-version = "3.16.3"
+version = "3.17.0"
 description = "🤱🏻 Turn any webpage into a desktop app with Rust."
 authors = ["Tw93"]
 license = "GPL-3.0-or-later"

package/src-tauri/src/app/window.rs

@@ -405,6 +405,27 @@ fn build_window(
         ))
     })?;
 
+    let restored_url = if label == "pake"
+        && window_config.url_type == "web"
+        && !window_config.incognito
+    {
+        match app.path().app_data_dir() {
+            Ok(directory) => match crate::util::read_last_url(&directory.join("last-url.txt")) {
+                Ok(url) => url,
+                Err(error) => {
+                    eprintln!("[Pake] Could not read the last URL: {error}");
+                    None
+                }
+            },
+            Err(error) => {
+                eprintln!("[Pake] Could not locate the last URL: {error}");
+                None
+            }
+        }
+    } else {
+        None
+    };
+
     // On macOS both HTTP Basic auth and certificate bypass use the same
     // navigation-delegate proxy. Start on a neutral page so the proxy is in
     // place before the target can issue its first authentication challenge.
@@ -413,11 +434,15 @@ fn build_window(
         && window_config.url_type == "web"
         && (config.basic_auth || window_config.ignore_certificate_errors)
     {
-        Url::parse(&window_config.url).ok()
+        restored_url
+            .clone()
+            .or_else(|| Url::parse(&window_config.url).ok())
     } else {
         None
     };
 
+    let url = restored_url.map(WebviewUrl::External).unwrap_or(url);
+
     // The delegate must be installed before the first TLS challenge. Start on
     // a neutral page, then navigate from the with_webview callback below.
     #[cfg(target_os = "macos")]
@@ -821,6 +846,20 @@ fn build_window(
     Ok(window)
 }
 
+pub fn save_last_url(app: &AppHandle) {
+    let Some(window) = app.get_webview_window("pake") else {
+        return;
+    };
+    let result = (|| -> Result<(), Box<dyn std::error::Error>> {
+        let path = app.path().app_data_dir()?.join("last-url.txt");
+        crate::util::write_last_url(&path, &window.url()?)?;
+        Ok(())
+    })();
+    if let Err(error) = result {
+        eprintln!("[Pake] Could not save the last URL: {error}");
+    }
+}
+
 #[cfg(all(test, target_os = "windows"))]
 mod proxy_arg_tests {
     use super::*;

package/src-tauri/src/lib.rs

@@ -32,8 +32,8 @@ use app::{
     },
     setup::{set_global_shortcut, set_system_tray},
     window::{
-        open_additional_window_safe, reapply_window_icon, reveal_built_window, set_window,
-        MultiWindowState,
+        open_additional_window_safe, reapply_window_icon, reveal_built_window, save_last_url,
+        set_window, MultiWindowState,
     },
 };
 use util::get_pake_config;
@@ -107,16 +107,51 @@ fn contains_niri(value: &str) -> bool {
         .any(|part| part.eq_ignore_ascii_case("niri"))
 }
 
+/// The two WebKit workarounds have different origins and therefore different
+/// scopes, which one gate cannot express.
+///
+/// `WEBKIT_DISABLE_DMABUF_RENDERER` came from #1117 (96e57376) for Linux
+/// stability in general, three months before anything Wayland-specific, and
+/// upstream still reports the blank window it prevents on X11 with the NVIDIA
+/// proprietary driver (tauri-apps/tauri#9394). It stays on for every session.
 #[cfg(any(target_os = "linux", test))]
-fn should_enable_linux_webkit_safe_mode_from_values(
+fn should_disable_dmabuf_renderer(safe_mode: Option<&str>) -> bool {
+    match safe_mode.filter(|value| !value.trim().is_empty()) {
+        Some(value) => !is_disabled_env_value(value),
+        None => true,
+    }
+}
+
+/// `WEBKIT_DISABLE_COMPOSITING_MODE` came from cb911ec7, for a blank screen on
+/// Wayland without a GPU. X11 never had that failure, and disabling compositing
+/// there segfaults WebKitGTK 2.52 as soon as a video decodes (#1374, Intel i915
+/// under i3), so this one is Wayland-only. niri keeps its existing exception.
+/// `PAKE_LINUX_WEBKIT_SAFE_MODE` still forces or suppresses both anywhere.
+#[cfg(any(target_os = "linux", test))]
+fn should_disable_compositing_mode(
     safe_mode: Option<&str>,
     niri_socket: Option<&str>,
+    wayland_display: Option<&str>,
+    gdk_backend: Option<&str>,
     desktop_values: &[Option<&str>],
 ) -> bool {
     if let Some(value) = safe_mode.filter(|value| !value.trim().is_empty()) {
         return !is_disabled_env_value(value);
     }
 
+    // WAYLAND_DISPLAY says a compositor is reachable, not that GTK will use it.
+    // An explicit GDK_BACKEND=x11 renders through XWayland, which is the X11
+    // path this flag crashes, and it is also the workaround recommended in
+    // #1117, so the two would otherwise collide. should_force_wayland_gdk_backend
+    // already treats an explicit backend as authoritative; so does this.
+    if gdk_backend.is_some_and(|value| value.trim().eq_ignore_ascii_case("x11")) {
+        return false;
+    }
+
+    if !is_non_empty_env_value(wayland_display) {
+        return false;
+    }
+
     let is_niri_session = is_non_empty_env_value(niri_socket)
         || desktop_values
             .iter()
@@ -173,18 +208,20 @@ fn apply_linux_webkit_runtime_flags() {
         .map(|value| value.as_deref())
         .collect::<Vec<_>>();
 
-    if !should_enable_linux_webkit_safe_mode_from_values(
+    if should_disable_dmabuf_renderer(safe_mode.as_deref())
+        && std::env::var(WEBKIT_DISABLE_DMABUF_RENDERER).is_err()
+    {
+        std::env::set_var(WEBKIT_DISABLE_DMABUF_RENDERER, "1");
+    }
+
+    if should_disable_compositing_mode(
         safe_mode.as_deref(),
         std::env::var("NIRI_SOCKET").ok().as_deref(),
+        std::env::var("WAYLAND_DISPLAY").ok().as_deref(),
+        std::env::var(GDK_BACKEND).ok().as_deref(),
         &desktop_refs,
-    ) {
-        return;
-    }
-
-    if std::env::var(WEBKIT_DISABLE_DMABUF_RENDERER).is_err() {
-        std::env::set_var(WEBKIT_DISABLE_DMABUF_RENDERER, "1");
-    }
-    if std::env::var(WEBKIT_DISABLE_COMPOSITING_MODE).is_err() {
+    ) && std::env::var(WEBKIT_DISABLE_COMPOSITING_MODE).is_err()
+    {
         std::env::set_var(WEBKIT_DISABLE_COMPOSITING_MODE, "1");
     }
 }
@@ -201,6 +238,8 @@ pub fn run_app() {
 
     let show_system_tray = pake_config.show_system_tray();
     let hide_on_close = pake_config.windows[0].hide_on_close;
+    let remember_url =
+        pake_config.windows[0].url_type == "web" && !pake_config.windows[0].incognito;
     let activation_shortcut = pake_config.windows[0].activation_shortcut.clone();
     let init_fullscreen = pake_config.windows[0].fullscreen;
     let start_to_tray = pake_config.windows[0].start_to_tray && show_system_tray; // Only valid when tray is enabled
@@ -357,6 +396,9 @@ pub fn run_app() {
         })
         .on_window_event(move |_window, _event| {
             if let tauri::WindowEvent::CloseRequested { api, .. } = _event {
+                if remember_url && _window.label() == "pake" {
+                    save_last_url(_window.app_handle());
+                }
                 if hide_on_close && _window.label() == "pake" {
                     // User dismissed the window; do not let startup reveal reopen it.
                     cancel_startup_reveal(&close_revealed);
@@ -395,6 +437,9 @@ pub fn run_app() {
             std::process::exit(1);
         })
         .run(move |_app, _event| {
+            if remember_url && matches!(&_event, tauri::RunEvent::Exit) {
+                save_last_url(_app);
+            }
             // Handle macOS dock icon click to reopen hidden window
             #[cfg(target_os = "macos")]
             if let tauri::RunEvent::Reopen {
@@ -463,51 +508,123 @@ mod tests {
     }
 
     #[test]
-    fn linux_webkit_safe_mode_stays_on_by_default() {
-        assert!(should_enable_linux_webkit_safe_mode_from_values(
+    fn dmabuf_renderer_stays_disabled_on_every_session() {
+        // #1117 was never Wayland-scoped, and upstream still reports the blank
+        // window it prevents on X11 with the NVIDIA proprietary driver.
+        assert!(should_disable_dmabuf_renderer(None));
+        assert!(should_disable_dmabuf_renderer(Some("1")));
+    }
+
+    #[test]
+    fn dmabuf_renderer_can_be_re_enabled_explicitly() {
+        for value in ["0", "false", "off", "no", "native", "disabled"] {
+            assert!(
+                !should_disable_dmabuf_renderer(Some(value)),
+                "expected {value} to restore the dmabuf renderer"
+            );
+        }
+    }
+
+    #[test]
+    fn x11_keeps_dmabuf_disabled_but_keeps_compositing() {
+        // The exact shape of #1374: an X11 session gets the stability flag it
+        // has had since #1117, and does not get the compositing flag that
+        // segfaults playback there.
+        let desktop = [Some("i3"), None, None];
+        assert!(should_disable_dmabuf_renderer(None));
+        assert!(!should_disable_compositing_mode(
+            None, None, None, None, &desktop
+        ));
+    }
+
+    #[test]
+    fn explicit_x11_gdk_backend_keeps_compositing_on_wayland() {
+        // XWayland renders through the X11 path this flag crashes, and
+        // GDK_BACKEND=x11 is the workaround recommended in #1117.
+        assert!(!should_disable_compositing_mode(
+            None,
+            None,
+            Some("wayland-0"),
+            Some("x11"),
+            &[None, None, None]
+        ));
+        // An explicit wayland backend is still a Wayland session.
+        assert!(should_disable_compositing_mode(
+            None,
+            None,
+            Some("wayland-0"),
+            Some("wayland"),
+            &[None, None, None]
+        ));
+    }
+
+    #[test]
+    fn compositing_mode_stays_disabled_by_default_on_wayland() {
+        assert!(should_disable_compositing_mode(
+            None,
             None,
+            Some("wayland-0"),
             None,
             &[None, None, None]
         ));
     }
 
     #[test]
-    fn linux_webkit_safe_mode_is_disabled_for_niri_socket() {
-        assert!(!should_enable_linux_webkit_safe_mode_from_values(
+    fn compositing_mode_can_be_forced_on_x11() {
+        assert!(should_disable_compositing_mode(
+            Some("1"),
+            None,
+            None,
+            None,
+            &[Some("i3"), None, None]
+        ));
+    }
+
+    #[test]
+    fn compositing_mode_is_kept_for_niri_socket() {
+        assert!(!should_disable_compositing_mode(
             None,
             Some("/run/user/501/niri.sock"),
+            Some("wayland-0"),
+            None,
             &[None, None, None]
         ));
     }
 
     #[test]
-    fn linux_webkit_safe_mode_is_disabled_for_niri_desktop() {
-        assert!(!should_enable_linux_webkit_safe_mode_from_values(
+    fn compositing_mode_is_kept_for_niri_desktop() {
+        assert!(!should_disable_compositing_mode(
             None,
             None,
+            Some("wayland-0"),
+            None,
             &[Some("niri"), None, None]
         ));
     }
 
     #[test]
-    fn linux_webkit_safe_mode_can_be_forced_on_for_niri() {
-        assert!(should_enable_linux_webkit_safe_mode_from_values(
+    fn compositing_mode_can_be_forced_on_for_niri() {
+        assert!(should_disable_compositing_mode(
             Some("1"),
             Some("/run/user/501/niri.sock"),
+            Some("wayland-0"),
+            None,
             &[Some("niri"), None, None]
         ));
     }
 
     #[test]
-    fn linux_webkit_safe_mode_can_be_disabled_explicitly() {
+    fn compositing_mode_can_be_disabled_explicitly() {
         for value in ["0", "false", "off", "no", "native", "disabled"] {
             assert!(
-                !should_enable_linux_webkit_safe_mode_from_values(
+                !should_disable_compositing_mode(
                     Some(value),
                     None,
+                    Some("wayland-0"),
+                    None,
                     &[None, None, None]
                 ),
-                "expected {value} to disable safe mode"
+                "expected {value} to restore compositing"
             );
         }
     }

package/src-tauri/src/util.rs

@@ -48,6 +48,26 @@ pub fn get_data_dir(app: &AppHandle, package_name: String) -> std::io::Result<Pa
     Ok(data_dir)
 }
 
+pub fn read_last_url(path: &Path) -> std::io::Result<Option<tauri::Url>> {
+    match std::fs::read_to_string(path) {
+        Ok(value) => Ok(tauri::Url::parse(&value)
+            .ok()
+            .filter(|url| matches!(url.scheme(), "http" | "https"))),
+        Err(error) if error.kind() == std::io::ErrorKind::NotFound => Ok(None),
+        Err(error) => Err(error),
+    }
+}
+
+pub fn write_last_url(path: &Path, url: &tauri::Url) -> std::io::Result<()> {
+    if matches!(url.scheme(), "http" | "https") {
+        if let Some(parent) = path.parent() {
+            std::fs::create_dir_all(parent)?;
+        }
+        std::fs::write(path, url.as_str())?;
+    }
+    Ok(())
+}
+
 /// Both native and IPC downloads use the trusted, packaged configuration.
 pub fn get_download_dir(app: &AppHandle) -> Result<PathBuf, String> {
     let state = app
@@ -257,6 +277,25 @@ mod tests {
         dir
     }
 
+    #[test]
+    fn last_url_round_trip_preserves_full_address() {
+        let path = temp_path("state/last-url.txt");
+        assert_eq!(read_last_url(&path).unwrap(), None);
+        for address in [
+            "https://acme.example/projects/42?view=board#activity",
+            "https://login.example/callback?code=example#result",
+        ] {
+            let url = tauri::Url::parse(address).unwrap();
+            write_last_url(&path, &url).unwrap();
+            assert_eq!(read_last_url(&path).unwrap(), Some(url));
+        }
+        write_last_url(&path, &tauri::Url::parse("about:blank").unwrap()).unwrap();
+        assert!(read_last_url(&path).unwrap().is_some());
+        std::fs::write(&path, "invalid URL").unwrap();
+        assert_eq!(read_last_url(&path).unwrap(), None);
+        fs::remove_dir_all(path.parent().unwrap().parent().unwrap()).unwrap();
+    }
+
     #[test]
     fn expand_download_dir_preserves_absolute_paths_without_home() {
         let absolute = temp_path("My Downloads");

package/src-tauri/tauri.conf.json

@@ -1,7 +1,7 @@
 {
   "productName": "Weekly",
   "identifier": "com.pake.weekly",
-  "version": "3.16.3",
+  "version": "3.17.0",
   "app": {
     "withGlobalTauri": true,
     "trayIcon": {