akanjs 3.0.0-beta.26 → 3.0.0-beta.28

package/vendor/@akanjs/native/native/android/src/com/akanjs/runtime/AkanNativeActivity.kt

@@ -115,6 +115,8 @@ class AkanNativeActivity : Activity(), AkanNativePluginContext.Host {
             setSupportMultipleWindows(false)
             javaScriptCanOpenWindowsAutomatically = false
             setSupportZoom(false)
+            // android.autoplay: media plays without a tap first, as it does on iOS and the desktop.
+            mediaPlaybackRequiresUserGesture = !shell.optBoolean("autoplay")
         }
         // The page follows prefers-color-scheme itself: no darkening by WebView.
         if (Build.VERSION.SDK_INT >= 33) Api33.noAlgorithmicDarkening(webView.settings)
@@ -396,13 +398,15 @@ class AkanNativeActivity : Activity(), AkanNativePluginContext.Host {
 
     private inner class ChromeClient : WebChromeClient() {
         override fun onConsoleMessage(message: ConsoleMessage): Boolean { // WV-3
+            // A dev page forwards its console through the bridge once its runtime is up; this copy covers the rest.
+            if (bridge.consoleForwarded) return true
             val priority = when (message.messageLevel()) {
                 ConsoleMessage.MessageLevel.ERROR -> Log.ERROR
                 ConsoleMessage.MessageLevel.WARNING -> Log.WARN
                 ConsoleMessage.MessageLevel.DEBUG -> Log.DEBUG
                 else -> Log.INFO
             }
-            Log.println(priority, "AkanNativeConsole", message.message())
+            Log.println(priority, "AkanNativeConsole", message.message().trimEnd('\n'))
             return true
         }
 

package/vendor/@akanjs/native/native/android/src/com/akanjs/runtime/AkanNativeBridge.kt

@@ -53,6 +53,8 @@ class AkanNativeBridge(private val webView: WebView) {
 
     /** Dev builds: the self-test's \$host methods. */
     var dev = false
+    /** The page's runtime forwards its console here (a dev build's `$console` attach), so the WebView's copy is spare. */
+    @Volatile var consoleForwarded = false
 
     /** Dev builds: \$host.hang calls still open, and how many were cancelled. */
     private val hanging = ArrayList<AkanNativeCall>()
@@ -207,6 +209,7 @@ class AkanNativeBridge(private val webView: WebView) {
         if (pluginId == "\$bridge") return bridgeOp(call, doc)
         doc.running[id] = java.lang.ref.WeakReference(call)
         call.document = doc
+        if (pluginId == "\$console") return console(call)
         if (pluginId == "\$host") return host(call)
         val plugin = plugins[pluginId] ?: return call.reject(AkanNativeErrorCode.NOT_FOUND, "plugin $pluginId is not registered")
         // L2: an undeclared method or event never reaches the plugin, whatever its code handles.
@@ -333,6 +336,22 @@ class AkanNativeBridge(private val webView: WebView) {
         JSONObject().put("v", 1).put("id", id).put("ok", false).put("error", JSONObject().put("code", code).put("message", message))
 
     /** Shell built-ins the page runtime calls. Dev builds only: the self-test's bridge checks. */
+    /** dev builds: the page console at its own priority (WV-3), through the bridge as on iOS and the desktop. */
+    private fun console(call: AkanNativeCall) {
+        if (!dev) return call.reject(AkanNativeErrorCode.NOT_FOUND, "plugin \$console is not registered")
+        consoleForwarded = true
+        if (call.method != "attach") {
+            val priority = when (call.method) {
+                "error" -> Log.ERROR
+                "warn" -> Log.WARN
+                "trace", "verbose", "debug" -> Log.DEBUG
+                else -> Log.INFO
+            }
+            Log.println(priority, "AkanNativeConsole", (call.string("message") ?: "").trimEnd('\n'))
+        }
+        call.resolve()
+    }
+
     private fun host(call: AkanNativeCall) {
         // AkanNativeFeatures.DEV is a constant: release builds (false) lose these methods and what only they
         // reach (AkanNativeVectors) in R8 (architecture review stage 6).

package/vendor/@akanjs/native/native/desktop/Cargo.toml

@@ -27,7 +27,7 @@ block2 = "0.6"
 
 [target.'cfg(target_os = "windows")'.dependencies]
 # windows-rs (Microsoft's Win32 bindings), already in the wry/tao tree; we only enable features.
-windows = { version = "0.62", features = ["Win32_Foundation", "Win32_UI_Shell", "Win32_UI_WindowsAndMessaging", "Win32_Globalization", "Win32_System_Com", "Win32_System_DataExchange", "Win32_System_Memory", "Win32_System_Ole", "Win32_System_Power", "Win32_System_Registry", "Win32_System_Threading", "Data_Xml_Dom", "Foundation", "UI_Notifications", "Win32_Security_Credentials", "Win32_System_Time", "Win32_UI_Controls", "Win32_UI_Shell_Common", "Win32_Graphics_Gdi", "Win32_System_ApplicationInstallationAndServicing", "Win32_System_LibraryLoader", "Win32_UI_Input_KeyboardAndMouse", "Win32_UI_HiDpi"] }
+windows = { version = "0.62", features = ["Win32_Foundation", "Win32_UI_Shell", "Win32_UI_WindowsAndMessaging", "Win32_Globalization", "Win32_System_Com", "Win32_System_DataExchange", "Win32_System_Memory", "Win32_System_Ole", "Win32_System_Power", "Win32_System_Registry", "Win32_System_Threading", "Data_Xml_Dom", "Foundation", "UI_Notifications", "Win32_Security_Credentials", "Win32_System_Time", "Win32_UI_Controls", "Win32_UI_Shell_Common", "Win32_Graphics_Gdi", "Win32_System_ApplicationInstallationAndServicing", "Win32_System_LibraryLoader", "Win32_UI_Input_KeyboardAndMouse", "Win32_UI_HiDpi", "Win32_Media_Audio", "Win32_Media_Audio_Endpoints", "Win32_System_Com_StructuredStorage", "Win32_System_Variant"] }
 # WebView2's COM API, the version wry uses: ScriptDialogOpening (D7 under tests, win/dialogs.rs).
 webview2-com = "0.39"
 

package/vendor/@akanjs/native/native/desktop/src/lib.rs

@@ -48,6 +48,8 @@ mod dock;
 #[cfg(target_os = "macos")]
 mod screen;
 #[cfg(target_os = "macos")]
+mod volume;
+#[cfg(target_os = "macos")]
 mod autostart;
 #[cfg(target_os = "macos")]
 mod keychain;
@@ -379,6 +381,8 @@ enum UserEvent {
   ThemeChanged,
   /// A window's web content process ended (crashed, killed, out of memory): its document is gone (N2).
   WebviewGone { window: u32, reason: &'static str },
+  /// desktop.recovery "reload": the wait after a window's page ended in a row is over; load it again.
+  ReloadGone(u32),
 }
 
 // ───────────────────────── C ABI ─────────────────────────
@@ -759,6 +763,15 @@ struct Config {
   app_id: String,
   /// security.shell.externalSchemes (L0): schemes links may also hand to the OS (navigation.rs).
   external_schemes: Vec<String>,
+  /// desktop.recovery "reload": a page that ends is always loaded again, and a browser process that ends
+  /// is the host's to relaunch (host.ts), instead of an error page and a quit.
+  recovery_reload: bool,
+  /// The main window from its first frame (desktop.window, or the launch phase): borderless fullscreen on
+  /// the display it is placed on, and no taskbar button (Windows, Linux).
+  fullscreen: bool,
+  skip_taskbar: bool,
+  /// desktop.screenCapture "auto" (Windows): the page captures the first screen without the picker.
+  screen_capture_auto: bool,
 }
 
 #[derive(Clone, Copy, PartialEq)]
@@ -821,6 +834,18 @@ fn parse_config(s: &str) -> Result<Config, String> {
       Some(json::V::Arr(a)) => a.iter().filter_map(|v| v.as_str().map(str::to_string)).collect(),
       _ => Vec::new(),
     },
+    recovery_reload: match get_s("recovery").as_deref() {
+      None | Some("errorPage") => false,
+      Some("reload") => true,
+      Some(other) => return Err(format!("recovery must be \"errorPage\" or \"reload\", not {other:?}")),
+    },
+    fullscreen: get_b("fullscreen", false),
+    skip_taskbar: get_b("skipTaskbar", false),
+    screen_capture_auto: match get_s("screenCapture").as_deref() {
+      None | Some("picker") => false,
+      Some("auto") => true,
+      Some(other) => return Err(format!("screenCapture must be \"picker\" or \"auto\", not {other:?}")),
+    },
   })
 }
 
@@ -1084,6 +1109,9 @@ struct Shell {
   icon: Option<tao::window::Icon>,
   #[cfg_attr(not(target_os = "linux"), allow(dead_code))]
   app_id: String,
+  recovery_reload: bool,
+  #[cfg_attr(not(target_os = "windows"), allow(dead_code))]
+  screen_capture_auto: bool,
 }
 
 /// The CLI's icon.rgba (icons.ts windowIcon) as a tao icon.
@@ -1101,15 +1129,25 @@ struct WindowOptions {
   size: Option<(f64, f64)>,
   position: Option<(f64, f64)>,
   maximized: bool,
+  fullscreen: bool,
+  /// macOS has no taskbar: its Dock shows apps, not windows.
+  #[cfg_attr(target_os = "macos", allow(dead_code))]
+  skip_taskbar: bool,
 }
 
 /// One window. The webview is declared first so that it is dropped before its window.
 struct Win {
   webview: WebView,
   window: tao::window::Window,
-  /// When its web content process last ended: a second end within a minute shows an error page
-  /// instead of reloading again (a page that crashes on load would loop).
-  gone_at: Option<std::time::Instant>,
+  /// When its page was last loaded again after its web content process ended: an end within a minute
+  /// of that shows an error page (a page that crashes on load would loop), or with desktop.recovery
+  /// "reload" waits longer before the next load (recovery_wait).
+  reloaded_at: Option<std::time::Instant>,
+  /// Ends in a row, each within a minute of the load before (desktop.recovery "reload").
+  gone_streak: u32,
+  /// A reload is waiting out recovery_wait: ends reported meanwhile (an unresponsive page repeats its report) are
+  /// the same end, and must neither raise the streak nor start a second wait.
+  reload_pending: bool,
 }
 
 struct Windows {
@@ -1133,14 +1171,27 @@ fn is_dark() -> bool {
 }
 
 fn monitors(target: &EventLoopWindowTarget<UserEvent>) -> Vec<placement::Rect> {
-  target
-    .available_monitors()
-    .map(|m| {
-      let scale = m.scale_factor();
-      let (p, s) = (m.position().to_logical::<f64>(scale), m.size().to_logical::<f64>(scale));
-      placement::Rect { x: p.x, y: p.y, width: s.width, height: s.height }
-    })
-    .collect()
+  target.available_monitors().map(|m| logical_rect(&m)).collect()
+}
+
+fn logical_rect(m: &tao::monitor::MonitorHandle) -> placement::Rect {
+  let scale = m.scale_factor();
+  let (p, s) = (m.position().to_logical::<f64>(scale), m.size().to_logical::<f64>(scale));
+  placement::Rect { x: p.x, y: p.y, width: s.width, height: s.height }
+}
+
+/// The display holding a logical point.
+fn monitor_at(target: &EventLoopWindowTarget<UserEvent>, x: f64, y: f64) -> Option<tao::monitor::MonitorHandle> {
+  target.available_monitors().find(|m| {
+    let r = logical_rect(m);
+    x >= r.x && x < r.x + r.width && y >= r.y && y < r.y + r.height
+  })
+}
+
+/// desktop.recovery "reload": how long to wait before loading a page again after `streak` ends in a
+/// row. The first end reloads at once; then 1 s, doubling to a minute.
+fn recovery_wait(streak: u32) -> Option<std::time::Duration> {
+  (streak > 0).then(|| std::time::Duration::from_secs((1u64 << (streak - 1).min(6)).min(60)))
 }
 
 /// Drops the webview's pending bridge calls (main thread): its document is gone.
@@ -1273,16 +1324,33 @@ fn open_window(target: &EventLoopWindowTarget<UserEvent>, shell: &Shell, context
   // (tao/src/platform_impl/macos/window.rs:202-208), so the title bar would end up above it;
   // window.getState reports the outer position, and set_outer_position takes one.
   let mut outer_position = None;
+  let mut placed = None;
   if let Some((x, y)) = opts.position {
     let wanted = placement::Rect { x, y, width, height };
     match placement::place(wanted, &monitors(target), MIN_INNER) {
       Some(r) => {
         builder = builder.with_inner_size(LogicalSize::new(r.width, r.height));
         outer_position = Some(tao::dpi::LogicalPosition::new(r.x, r.y));
+        placed = Some(r);
       }
       None => log!("window {id}: position ({x}, {y}) is on no display; using the default"),
     }
   }
+  if opts.fullscreen {
+    // Set before the first frame, on the display the window was placed on (else the primary one).
+    let monitor = placed.and_then(|r| monitor_at(target, r.x + r.width / 2.0, r.y + r.height / 2.0));
+    builder = builder.with_fullscreen(Some(tao::window::Fullscreen::Borderless(monitor)));
+  }
+  #[cfg(target_os = "windows")]
+  if opts.skip_taskbar {
+    use tao::platform::windows::WindowBuilderExtWindows;
+    builder = builder.with_skip_taskbar(true);
+  }
+  #[cfg(target_os = "linux")]
+  if opts.skip_taskbar {
+    use tao::platform::unix::WindowBuilderExtUnix;
+    builder = builder.with_skip_taskbar(true);
+  }
   let window = builder.build(target).map_err(|e| format!("window: {e}"))?;
   // Windows and Linux: the system theme is known once a window exists (tao reads it then).
   #[cfg(not(target_os = "macos"))]
@@ -1327,11 +1395,18 @@ fn open_window(target: &EventLoopWindowTarget<UserEvent>, shell: &Shell, context
     // Dev builds: AKAN_NATIVE_WEBVIEW2_DEBUG_PORT opens the Chrome DevTools Protocol on that port, for
     // test automation. WEBVIEW2_ADDITIONAL_BROWSER_ARGUMENTS does not apply: wry passes arguments of
     // its own, repeated here because these replace them (wry webview2/mod.rs, with autoplay on).
-    match std::env::var("AKAN_NATIVE_WEBVIEW2_DEBUG_PORT").ok().filter(|_| shell.devtools).and_then(|p| p.parse::<u16>().ok()) {
-      Some(port) => builder.with_additional_browser_args(format!(
-        "--disable-features=msWebOOUI,msPdfOOUI,msSmartScreenProtection --autoplay-policy=no-user-gesture-required --remote-debugging-port={port}"
-      )),
-      None => builder,
+    let port = std::env::var("AKAN_NATIVE_WEBVIEW2_DEBUG_PORT").ok().filter(|_| shell.devtools).and_then(|p| p.parse::<u16>().ok());
+    // desktop.screenCapture "auto": getDisplayMedia answers with the first screen, no picker, no user gesture. Not
+    // --auto-select-desktop-capture-source: it matches the picker's title, which follows the UI language (verified).
+    let capture = shell.screen_capture_auto.then(|| "--use-fake-ui-for-media-stream".to_string());
+    let extra: Vec<String> = port.map(|p| format!("--remote-debugging-port={p}")).into_iter().chain(capture).collect();
+    if extra.is_empty() {
+      builder
+    } else {
+      builder.with_additional_browser_args(format!(
+        "--disable-features=msWebOOUI,msPdfOOUI,msSmartScreenProtection --autoplay-policy=no-user-gesture-required {}",
+        extra.join(" ")
+      ))
     }
   };
   // SH-4: pages never leave the app origin (navigation.rs). Linux decides in its own signal handlers.
@@ -1435,7 +1510,7 @@ fn open_window(target: &EventLoopWindowTarget<UserEvent>, shell: &Shell, context
     std::thread::sleep(Duration::from_millis(3000));
     send(UserEvent::Show(id));
   });
-  Ok(Win { webview, window, gone_at: None })
+  Ok(Win { webview, window, reloaded_at: None, gone_streak: 0, reload_pending: false })
 }
 
 /// A `window` argument: a positive whole number.
@@ -1524,7 +1599,7 @@ impl Windows {
     };
     let id = self.next;
     self.next += 1;
-    let win = open_window(target, &self.shell, &mut self.web_context, id, WindowOptions { path: app_path(cmd)?, title, size, position, maximized: false })?;
+    let win = open_window(target, &self.shell, &mut self.web_context, id, WindowOptions { path: app_path(cmd)?, title, size, position, maximized: false, fullscreen: false, skip_taskbar: false })?;
     let state = self.state(id, &win);
     self.insert(id, win);
     push_event(&format!(r#"{{"type":"window","event":"created","window":{id}}}"#));
@@ -1573,14 +1648,15 @@ impl Windows {
       "debug.stats" if self.shell.devtools => return Ok(stats_json()),
       _ => {}
     }
-    // App-wide ops, not a window's: menu, tray, global shortcut, dock and screen plugins
-    // (menu.rs, tray.rs, hotkey.rs, dock.rs, screen.rs).
+    // App-wide ops, not a window's: menu, tray, global shortcut, dock, screen and volume plugins
+    // (menu.rs, tray.rs, hotkey.rs, dock.rs, screen.rs, volume.rs).
     #[cfg(target_os = "macos")]
     if let Some(result) = menu::shell_op(op, &cmd)
       .or_else(|| tray::shell_op(op, &cmd, &self.shell.app_dir))
       .or_else(|| hotkey::shell_op(op, &cmd))
       .or_else(|| dock::shell_op(op, &cmd, target))
       .or_else(|| screen::shell_op(op, target))
+      .or_else(|| volume::shell_op(op, &cmd))
     {
       return result;
     }
@@ -1775,6 +1851,8 @@ pub unsafe extern "C" fn akan_native_run(config_json: *const c_char) -> i32 {
       activate: cfg.activation != "prohibited",
       icon: cfg.icon.as_deref().and_then(read_icon),
       app_id: cfg.app_id.clone(),
+      recovery_reload: cfg.recovery_reload,
+      screen_capture_auto: cfg.screen_capture_auto,
     },
     web_context: wry::WebContext::new(cfg.data_dir.clone()),
     map: HashMap::new(),
@@ -1783,7 +1861,15 @@ pub unsafe extern "C" fn akan_native_run(config_json: *const c_char) -> i32 {
     focus: Vec::new(),
     next: 2,
   };
-  let main = WindowOptions { path: cfg.start_path.clone(), title: None, size: None, position: cfg.position, maximized: cfg.maximized };
+  let main = WindowOptions {
+    path: cfg.start_path.clone(),
+    title: None,
+    size: None,
+    position: cfg.position,
+    maximized: cfg.maximized,
+    fullscreen: cfg.fullscreen,
+    skip_taskbar: cfg.skip_taskbar,
+  };
   match open_window(&event_loop, &windows.shell, &mut windows.web_context, 1, main) {
     Ok(win) => windows.insert(1, win),
     Err(e) => {
@@ -1884,22 +1970,49 @@ pub unsafe extern "C" fn akan_native_run(config_json: *const c_char) -> i32 {
         // The page and every call it had made are gone: the host ends its document (dispatcher.reset).
         drop_pending(window);
         push_event(&format!(r#"{{"type":"webview","event":"processTerminated","window":{window},"reason":"{reason}"}}"#));
-        if reason == "browserExited" {
+        if reason == "browserExited" && windows.shell.recovery_reload {
+          // The host relaunches the app on the event above (host.ts); should it not, this quits.
+          log!("the webview's browser process ended; the app relaunches");
+          std::thread::spawn(|| {
+            std::thread::sleep(std::time::Duration::from_secs(10));
+            send(UserEvent::Quit(1));
+          });
+        } else if reason == "browserExited" {
           log!("the webview's browser process ended; quitting");
           send(UserEvent::Quit(1));
         } else if let Some(win) = windows.map.get_mut(&window) {
+          if win.reload_pending {
+            log!("window {window}: the page stopped ({reason}) while its reload waits");
+            return;
+          }
           let now = std::time::Instant::now();
-          let again = win.gone_at.is_some_and(|t| now.duration_since(t) < std::time::Duration::from_secs(60));
-          win.gone_at = Some(now);
-          if again {
+          let again = win.reloaded_at.is_some_and(|t| now.duration_since(t) < std::time::Duration::from_secs(60));
+          win.gone_streak = if again { win.gone_streak + 1 } else { 0 };
+          let wait = recovery_wait(win.gone_streak).filter(|_| windows.shell.recovery_reload);
+          if again && !windows.shell.recovery_reload {
             log!("window {window}: the page stopped again ({reason}) within a minute; showing an error page");
             let _ = win.webview.load_html(&gone_page());
+          } else if let Some(wait) = wait {
+            log!("window {window}: the page stopped again ({reason}); loading it again in {} s", wait.as_secs());
+            win.reload_pending = true;
+            std::thread::spawn(move || {
+              std::thread::sleep(wait);
+              send(UserEvent::ReloadGone(window));
+            });
           } else {
             log!("window {window}: the page stopped ({reason}); loading it again");
+            win.reloaded_at = Some(now);
             let _ = win.webview.reload();
           }
         }
       }
+      Event::UserEvent(UserEvent::ReloadGone(window)) => {
+        if let Some(win) = windows.map.get_mut(&window) {
+          win.reload_pending = false;
+          win.reloaded_at = Some(std::time::Instant::now());
+          let _ = win.webview.reload();
+        }
+      }
       Event::UserEvent(UserEvent::Emit { webview_id, js }) => {
         if let Some(win) = windows.map.get(&webview_id) {
           let _ = win.webview.evaluate_script(&js);
@@ -2183,3 +2296,26 @@ mod drag_drop_tests {
     assert!(enter.ends_with(r#""x":100,"y":200.67}"#), "{enter}");
   }
 }
+
+#[cfg(test)]
+mod recovery_tests {
+  use super::recovery_wait;
+  use std::time::Duration;
+
+  #[test]
+  fn waits_longer_after_each_end_in_a_row_up_to_a_minute() {
+    let secs: Vec<u64> = (0..10).map(|streak| recovery_wait(streak).map_or(0, |d| d.as_secs())).collect();
+    assert_eq!(secs, [0, 1, 2, 4, 8, 16, 32, 60, 60, 60]);
+    assert_eq!(recovery_wait(u32::MAX), Some(Duration::from_secs(60)));
+  }
+
+  #[test]
+  fn reads_the_recovery_policy_and_refuses_an_unknown_one() {
+    let base = r#""appDir":"/a","initJs":"x""#;
+    assert!(!super::parse_config(&format!("{{{base}}}")).unwrap().recovery_reload);
+    assert!(super::parse_config(&format!(r#"{{{base},"recovery":"reload","fullscreen":true}}"#)).unwrap().recovery_reload);
+    assert!(super::parse_config(&format!(r#"{{{base},"recovery":"always"}}"#)).is_err());
+    assert!(super::parse_config(&format!(r#"{{{base},"screenCapture":"auto"}}"#)).unwrap().screen_capture_auto);
+    assert!(super::parse_config(&format!(r#"{{{base},"screenCapture":"any"}}"#)).is_err());
+  }
+}

package/vendor/@akanjs/native/native/desktop/src/volume.rs

@@ -0,0 +1,184 @@
+//! The system output volume on macOS (volume plugin): the default output device's volume and mute,
+//! through CoreAudio's AudioObject API. The few C calls are declared here; the framework ships with macOS.
+//!   volume.get   → {"level":0…1|null,"muted":bool,"settable":bool}
+//!   volume.set   {level} → the same, after the change
+//!   volume.mute  {muted} → the same
+//!   volume.watch → null. From then on the shell sends {"type":"volume","event":"changed"} when the
+//!                  default output device changes, or its volume or mute does; the plugin host reads
+//!                  volume.get again.
+//!
+//! - The level is the device's virtual main volume ('vmvc'), which CoreAudio spreads over the channels
+//!   as the volume keys do. A device without one (HDMI or DisplayPort audio, many USB interfaces)
+//!   answers level null and settable false, and volume.set refuses: the volume keys do nothing there.
+//! - Listeners run on a CoreAudio thread; push_event is thread-safe. A device that stops being the
+//!   default keeps its listeners, and the host drops the events that change nothing.
+
+use std::{collections::HashSet, ffi::c_void, ptr, sync::Mutex};
+
+use crate::{json, push_event};
+
+#[repr(C)]
+struct Address {
+  selector: u32,
+  scope: u32,
+  element: u32,
+}
+
+type Listener = extern "C" fn(u32, u32, *const Address, *mut c_void) -> i32;
+
+#[link(name = "CoreAudio", kind = "framework")]
+extern "C" {
+  fn AudioObjectGetPropertyData(id: u32, address: *const Address, qualifier_size: u32, qualifier: *const c_void, size: *mut u32, data: *mut c_void) -> i32;
+  fn AudioObjectSetPropertyData(id: u32, address: *const Address, qualifier_size: u32, qualifier: *const c_void, size: u32, data: *const c_void) -> i32;
+  fn AudioObjectHasProperty(id: u32, address: *const Address) -> u8;
+  fn AudioObjectIsPropertySettable(id: u32, address: *const Address, settable: *mut u8) -> i32;
+  fn AudioObjectAddPropertyListener(id: u32, address: *const Address, listener: Listener, client: *mut c_void) -> i32;
+}
+
+const fn code(s: &[u8; 4]) -> u32 {
+  u32::from_be_bytes(*s)
+}
+
+/// kAudioObjectSystemObject
+const SYSTEM: u32 = 1;
+/// kAudioHardwarePropertyDefaultOutputDevice
+const DEFAULT_OUTPUT: Address = Address { selector: code(b"dOut"), scope: code(b"glob"), element: 0 };
+/// kAudioHardwareServiceDeviceProperty_VirtualMainVolume on the output scope's main element
+const VOLUME: Address = Address { selector: code(b"vmvc"), scope: code(b"outp"), element: 0 };
+/// kAudioDevicePropertyMute
+const MUTE: Address = Address { selector: code(b"mute"), scope: code(b"outp"), element: 0 };
+
+static WATCHED: Mutex<Option<HashSet<u32>>> = Mutex::new(None);
+
+fn default_output() -> Result<u32, String> {
+  let mut id = 0u32;
+  let mut size = size_of::<u32>() as u32;
+  let status = unsafe { AudioObjectGetPropertyData(SYSTEM, &DEFAULT_OUTPUT, 0, ptr::null(), &mut size, &mut id as *mut u32 as *mut c_void) };
+  if status != 0 || id == 0 {
+    return Err("NOT_FOUND: there is no audio output".into());
+  }
+  Ok(id)
+}
+
+fn read<T: Default>(device: u32, address: &Address) -> Option<T> {
+  if unsafe { AudioObjectHasProperty(device, address) } == 0 {
+    return None;
+  }
+  let mut value = T::default();
+  let mut size = size_of::<T>() as u32;
+  let status = unsafe { AudioObjectGetPropertyData(device, address, 0, ptr::null(), &mut size, &mut value as *mut T as *mut c_void) };
+  (status == 0).then_some(value)
+}
+
+fn write<T>(device: u32, address: &Address, value: T, what: &str) -> Result<(), String> {
+  let status = unsafe { AudioObjectSetPropertyData(device, address, 0, ptr::null(), size_of::<T>() as u32, &value as *const T as *const c_void) };
+  if status != 0 {
+    return Err(format!("INTERNAL: cannot set the {what} (OSStatus {status})"));
+  }
+  Ok(())
+}
+
+fn settable(device: u32, address: &Address) -> bool {
+  let mut flag = 0u8;
+  unsafe { AudioObjectHasProperty(device, address) != 0 && AudioObjectIsPropertySettable(device, address, &mut flag) == 0 && flag != 0 }
+}
+
+/// A level with the float noise of f32 taken off (0.5 reads back as 0.49999997).
+pub fn level_json(level: Option<f32>) -> String {
+  level.map_or("null".into(), |v| format!("{}", (f64::from(v) * 1000.0).round() / 1000.0))
+}
+
+pub fn state_json(level: Option<f32>, muted: bool, settable: bool) -> String {
+  format!(r#"{{"level":{},"muted":{},"settable":{}}}"#, level_json(level), muted, settable && level.is_some())
+}
+
+fn state(device: u32) -> String {
+  let level = read::<f32>(device, &VOLUME);
+  let muted = read::<u32>(device, &MUTE).is_some_and(|m| m != 0);
+  state_json(level, muted, settable(device, &VOLUME))
+}
+
+fn set(cmd: &json::V) -> Result<String, String> {
+  let level = cmd.get("level").and_then(|v| v.as_f64()).filter(|v| (0.0..=1.0).contains(v)).ok_or("level must be a number from 0 to 1")?;
+  let device = default_output()?;
+  if !settable(device, &VOLUME) {
+    return Err("UNSUPPORTED: this audio output takes no volume from the computer".into());
+  }
+  write(device, &VOLUME, level as f32, "volume")?;
+  Ok(state(device))
+}
+
+fn mute(cmd: &json::V) -> Result<String, String> {
+  let muted = cmd.get("muted").and_then(|v| v.as_bool()).ok_or("muted must be a boolean")?;
+  let device = default_output()?;
+  if !settable(device, &MUTE) {
+    return Err("UNSUPPORTED: this audio output cannot be muted from the computer".into());
+  }
+  write(device, &MUTE, u32::from(muted), "mute")?;
+  Ok(state(device))
+}
+
+extern "C" fn changed(_id: u32, _count: u32, _addresses: *const Address, _client: *mut c_void) -> i32 {
+  if let Ok(device) = default_output() {
+    listen(device);
+  }
+  push_event(r#"{"type":"volume","event":"changed"}"#);
+  0
+}
+
+/// Listens to a device's volume and mute once; the lock is not held while CoreAudio is called.
+fn listen(device: u32) {
+  let fresh = WATCHED.lock().unwrap_or_else(|e| e.into_inner()).get_or_insert_with(HashSet::new).insert(device);
+  if fresh {
+    for address in [&VOLUME, &MUTE] {
+      unsafe { AudioObjectAddPropertyListener(device, address, changed, ptr::null_mut()) };
+    }
+  }
+}
+
+fn watch() -> Result<String, String> {
+  let first = {
+    let mut watched = WATCHED.lock().unwrap_or_else(|e| e.into_inner());
+    let first = watched.is_none();
+    watched.get_or_insert_with(HashSet::new);
+    first
+  };
+  if first {
+    unsafe { AudioObjectAddPropertyListener(SYSTEM, &DEFAULT_OUTPUT, changed, ptr::null_mut()) };
+  }
+  if let Ok(device) = default_output() {
+    listen(device);
+  }
+  Ok("null".into())
+}
+
+/// volume.* shell ops; None for other ops.
+pub fn shell_op(op: &str, cmd: &json::V) -> Option<Result<String, String>> {
+  let result = match op {
+    "volume.get" => default_output().map(state),
+    "volume.set" => set(cmd),
+    "volume.mute" => mute(cmd),
+    "volume.watch" => watch(),
+    _ if op.starts_with("volume.") => Err(format!("unknown op {op}")),
+    _ => return None,
+  };
+  Some(result)
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+
+  #[test]
+  fn state_shape() {
+    assert_eq!(state_json(Some(0.49999997), false, true), r#"{"level":0.5,"muted":false,"settable":true}"#);
+    assert_eq!(state_json(None, true, true), r#"{"level":null,"muted":true,"settable":false}"#);
+    assert!(json::parse(&state_json(Some(1.0), false, false)).is_ok());
+  }
+
+  #[test]
+  fn four_char_codes() {
+    assert_eq!(code(b"dOut"), 0x644f_7574);
+    assert_eq!(code(b"vmvc"), 0x766d_7663);
+  }
+}

package/vendor/@akanjs/native/native/desktop/src/win/mod.rs

@@ -22,6 +22,7 @@ pub mod open;
 pub mod power;
 pub mod registry;
 mod screen;
+mod volume;
 mod tray;
 
 use std::ffi::c_void;
@@ -43,12 +44,13 @@ pub fn shell_op(op: &str, cmd: &json::V, target: &EventLoopWindowTarget<UserEven
     .or_else(|| device::shell_op(op))
     // keychain.*: secure-storage (the Credential Manager)
     .or_else(|| keychain::shell_op(op, cmd))
-    // menu.*, tray.*, hotkey.*: global-shortcut; dock.*: dock and badge; screen.*
+    // menu.*, tray.*, hotkey.*: global-shortcut; dock.*: dock and badge; screen.*; volume.*
     .or_else(|| menu::shell_op(op, cmd, &shell.title))
     .or_else(|| tray::shell_op(op, cmd, &shell.app_dir, &shell.title))
     .or_else(|| hotkey::shell_op(op, cmd))
     .or_else(|| dock::shell_op(op, cmd))
     .or_else(|| screen::shell_op(op, target))
+    .or_else(|| volume::shell_op(op, cmd))
 }
 
 /// Ops on one window. None: not handled here.