ruby_everywhere 0.4.0 → 0.5.0

data/support/{shell → desktop}/src-tauri/src/main.rs

@@ -25,6 +25,15 @@ use tauri::{Manager, RunEvent, WebviewUrl, WebviewWindowBuilder};
 
 mod updater;
 
+// The event bridge extension commands answer on. Frozen shell code.
+mod extension_host;
+
+// The app's own Rust, from native/desktop/ in the app repo. The CLI regenerates
+// src/extensions/mod.rs on every build from what `native.desktop` declares in
+// everywhere.yml; the copy checked in here registers nothing, so the bare
+// template still builds. See support/desktop/README.md for the freeze contract.
+mod extensions;
+
 struct Sidecar(Mutex<Option<Child>>);
 
 struct MenuEntry {
@@ -44,6 +53,28 @@ struct AppConfig {
     background_light: Option<(u8, u8, u8)>,
     menu: Vec<MenuEntry>,
     tray: Vec<TrayEntry>,
+    window: WindowConfig,
+}
+
+// Window chrome, from `window:` in everywhere.yml. Every field is optional and
+// the defaults live HERE rather than in the Ruby config, so there is exactly one
+// place each default is written down.
+struct WindowConfig {
+    title_bar: TitleBar,
+    // Tri-state: None leaves the shell's default (show the title) alone.
+    title: Option<bool>,
+    resizable: Option<bool>,
+    size: Option<(f64, f64)>,
+    min_size: Option<(f64, f64)>,
+}
+
+#[derive(Clone, Copy, PartialEq)]
+enum TitleBar {
+    Decorated,
+    // macOS: traffic lights float over the page, no title text. There is no
+    // Windows/Linux equivalent, so it degrades to Frameless there.
+    Overlay,
+    Frameless,
 }
 
 struct TrayEntry {
@@ -112,9 +143,32 @@ fn load_config() -> AppConfig {
                     .collect()
             })
             .unwrap_or_default(),
+        // Indexing a missing key yields Null rather than panicking, so an app
+        // with no `window:` at all lands on every default below.
+        window: WindowConfig {
+            title_bar: match value["window"]["title_bar"].as_str() {
+                Some("overlay") => TitleBar::Overlay,
+                Some("frameless") => TitleBar::Frameless,
+                _ => TitleBar::Decorated,
+            },
+            title: value["window"]["title"].as_bool(),
+            resizable: value["window"]["resizable"].as_bool(),
+            size: dimensions(&value["window"]["size"]),
+            min_size: dimensions(&value["window"]["min_size"]),
+        },
     }
 }
 
+// A [width, height] pair. The Ruby side already rejects the near-misses with a
+// readable error; this is the belt-and-braces so a hand-edited everywhere.json
+// can't produce a zero-pixel window.
+fn dimensions(value: &serde_json::Value) -> Option<(f64, f64)> {
+    let pair = value.as_array()?;
+    let width = pair.first()?.as_f64()?;
+    let height = pair.get(1)?.as_f64()?;
+    (width > 0.0 && height > 0.0).then_some((width, height))
+}
+
 fn parse_hex(hex: &str) -> Option<(u8, u8, u8)> {
     let h = hex.trim_start_matches('#');
     match h.len() {
@@ -130,6 +184,92 @@ fn parse_hex(hex: &str) -> Option<(u8, u8, u8)> {
     }
 }
 
+// --- app assets (native/desktop/assets) -------------------------------------
+//
+// Images the APP ships for the SHELL to draw: the tray icon, splash artwork,
+// anything extension Rust loads. Not for pages — those keep using the asset
+// pipeline, which already fingerprints and serves them.
+
+// Same resolution order as load_config, for the same reason: under `every dev`
+// there is no .app to look inside, so the CLI stages the folder and points here.
+fn assets_dir() -> Option<PathBuf> {
+    if let Ok(dir) = std::env::var("NATIVE_ASSETS_DIR") {
+        let path = PathBuf::from(dir);
+        if path.is_dir() {
+            return Some(path);
+        }
+    }
+    let exe = std::env::current_exe().ok()?;
+    let path = exe.parent()?.join("../Resources/assets");
+    path.is_dir().then_some(path)
+}
+
+// Resolve a logical asset name to a file. The folder is flat and the suffixes
+// carry the variants (<name>[@2x|@3x][~dark].<ext>) — the CLI validated them,
+// so anything unparseable here simply doesn't match.
+//
+// Highest scale wins: nothing at this layer knows which display the image will
+// land on, and downscaling a @3x looks far better than upscaling a 1x.
+fn asset_path(name: &str, dark: bool) -> Option<PathBuf> {
+    let dir = assets_dir()?;
+    let mut best: Option<(u8, PathBuf)> = None;
+    for entry in std::fs::read_dir(dir).ok()?.flatten() {
+        let path = entry.path();
+        let Some(stem) = path.file_stem().and_then(|s| s.to_str()) else {
+            continue;
+        };
+        let (base, scale, is_dark) = parse_asset_stem(stem);
+        if base != name || is_dark != dark {
+            continue;
+        }
+        if best.as_ref().map_or(true, |(best_scale, _)| scale > *best_scale) {
+            best = Some((scale, path));
+        }
+    }
+    best.map(|(_, path)| path)
+}
+
+// The ~dark variant when the app shipped one, else the plain asset.
+fn asset(name: &str, dark: bool) -> Option<PathBuf> {
+    if dark {
+        if let Some(path) = asset_path(name, true) {
+            return Some(path);
+        }
+    }
+    asset_path(name, false)
+}
+
+// Trailing @2x/@3x and ~dark markers, in either order. Mirrors the Ruby
+// DesktopAssets#parse — one filename convention across all three platforms.
+fn parse_asset_stem(stem: &str) -> (String, u8, bool) {
+    let mut name = stem.to_string();
+    let mut scale = 1u8;
+    let mut dark = false;
+    loop {
+        if let Some(rest) = name.strip_suffix("~dark") {
+            dark = true;
+            name = rest.to_string();
+        } else if let Some(rest) = name.strip_suffix("@2x") {
+            scale = 2;
+            name = rest.to_string();
+        } else if let Some(rest) = name.strip_suffix("@3x") {
+            scale = 3;
+            name = rest.to_string();
+        } else {
+            break;
+        }
+    }
+    (name, scale, dark)
+}
+
+fn asset_mime(path: &Path) -> &'static str {
+    match path.extension().and_then(|e| e.to_str()).unwrap_or("").to_ascii_lowercase().as_str() {
+        "jpg" | "jpeg" => "image/jpeg",
+        "ico" => "image/x-icon",
+        _ => "image/png",
+    }
+}
+
 fn sidecar_log_path(app_data: &Path) -> PathBuf {
     let dir = app_data.join("log");
     let _ = std::fs::create_dir_all(&dir);
@@ -216,7 +356,7 @@ fn main() {
         .plugin(tauri_plugin_dialog::init())
         .plugin(tauri_plugin_clipboard_manager::init())
         .plugin(window_state)
-        .invoke_handler(tauri::generate_handler![notify_command])
+        .invoke_handler(extensions::handler())
         .setup(move |app| {
             // A persisted user channel choice (Everywhere.updates.setChannel)
             // overrides everywhere.yml's updates.channel. Fold it in before
@@ -247,6 +387,12 @@ fn main() {
             build_menu(app, &config)?;
             updater::init(app, &config.raw_json);
 
+            // The app's own Rust gets the handle before any window exists, so it
+            // can register plugins, open ports, or spawn workers that the first
+            // page load already depends on. It also installs the event-based
+            // command transport remote-mode pages use.
+            extensions::setup(app)?;
+
             // Dev mode (`every dev`): no sidecar, just point the webview at the
             // developer's normal dev server.
             if let Ok(dev_url) = std::env::var("NATIVE_DEV_URL") {
@@ -401,6 +547,17 @@ fn main() {
         .build(tauri::generate_context!())
         .expect("error while building tauri application")
         .run(|app, event| {
+            // Tauri applies its own compiled-in icons/icon.png to the Dock as
+            // part of finishing launch — AFTER setup() — so setting ours there
+            // gets stomped. Ready is the first point we're guaranteed to win.
+            #[cfg(target_os = "macos")]
+            if let RunEvent::Ready = event {
+                if let Ok(icon) = std::env::var("NATIVE_ICON_PATH") {
+                    if !icon.is_empty() {
+                        set_dock_icon(&icon);
+                    }
+                }
+            }
             if let RunEvent::Exit = event {
                 // A fully staged silent update (updates.auto: install) swaps
                 // in now — two renames, no perceptible quit latency.
@@ -581,8 +738,28 @@ fn build_tray(app: &tauri::App, config: &AppConfig) -> tauri::Result<()> {
         .menu(&menu)
         .show_menu_on_left_click(true)
         .tooltip(&config.name);
-    if let Some(icon) = app.default_window_icon() {
-        tray = tray.icon(icon.clone());
+
+    // A `tray` asset (native/desktop/assets/tray.png) beats the app icon here.
+    // An app icon is a 1024px full-colour square; macOS squeezes that into
+    // ~22pt of menu bar and it turns to mush.
+    //
+    // `tray-template` is the macOS convention instead: a black-and-alpha image
+    // the system recolours itself, so it stays legible in a light menu bar, a
+    // dark one, and under a highlight. Two names rather than a config key —
+    // whether an image is a template is a property of the image.
+    let (template, icon_path) = match asset("tray-template", false) {
+        Some(path) => (true, Some(path)),
+        None => (false, asset("tray", false)),
+    };
+    match icon_path.and_then(|path| tauri::image::Image::from_path(path).ok()) {
+        Some(icon) => {
+            tray = tray.icon(icon).icon_as_template(template);
+        }
+        None => {
+            if let Some(icon) = app.default_window_icon() {
+                tray = tray.icon(icon.clone());
+            }
+        }
     }
     tray.on_menu_event(|app, event| handle_menu_id(app, event.id().0.as_str()))
         .build(app)?;
@@ -644,6 +821,10 @@ const INIT_SCRIPT: &str = r#"
   // fall back to the app name, suffix "(dev)" in dev mode.
   const syncTitle = () => {
     try {
+      // `window.title: false` means the window has no title text, so don't put
+      // one back on the next page load — this runs on every visit and would
+      // otherwise quietly undo what build_window set.
+      if (cfg.window && cfg.window.title === false) return;
       const base = document.title || cfg.name || "";
       const title = cfg.dev ? base + " (dev)" : base;
       if (title && window.__TAURI__ && window.__TAURI__.window) {
@@ -658,6 +839,53 @@ const INIT_SCRIPT: &str = r#"
   });
   document.addEventListener('turbo:load', syncTitle);
 
+  // Overlay and frameless windows have no system title bar left to grab: the
+  // webview covers that strip, so every mousedown in it belongs to the page and
+  // the window stops being draggable. Rather than make every app hand-roll a
+  // drag region just to hide a title, the top strip drags the window by default.
+  //
+  // Interactive elements keep their clicks — a toolbar button up there still
+  // works — and `window.drag_height: 0` in everywhere.yml turns it off for an
+  // app that wants to own the whole area itself.
+  const dragTop = () => {
+    const win = cfg.window || {};
+    if (!win.title_bar || win.title_bar === 'decorated') return;
+    const height = win.drag_height === undefined ? 28 : win.drag_height;
+    if (!height) return;
+
+    const NO_DRAG = 'a,button,input,select,textarea,label,summary,[role="button"],' +
+                    '[contenteditable],[data-no-drag]';
+    // data-tauri-drag-region is deliberately NOT deferred to. Tauri's own
+    // handling of it round-trips through the IPC, which is blocked on http
+    // origins — the same wall invoke hits — so on a RubyEverywhere page that
+    // attribute does nothing on its own. We honour it here instead, and extend
+    // it past the strip: marking a region draggable should work wherever it is.
+    const draggable = (e) => {
+      if (e.button !== 0 || !e.target || !e.target.closest) return false;
+      if (e.target.closest(NO_DRAG)) return false;
+      return e.target.closest('[data-tauri-drag-region]') !== null || e.clientY <= height;
+    };
+
+    // Double-click-to-zoom is detected here rather than with a dblclick
+    // listener: startDragging() takes over the mouse on mousedown, so the
+    // dblclick event never arrives.
+    let lastDown = 0;
+    document.addEventListener('mousedown', (e) => {
+      if (!draggable(e)) return;
+      try {
+        const w = window.__TAURI__.window.getCurrentWindow();
+        e.preventDefault();
+        // Keep Tauri's own drag-region listener from starting a second drag on
+        // top of ours if a future version stops needing the IPC for it.
+        e.stopPropagation();
+        const now = Date.now();
+        if (now - lastDown < 400) { lastDown = 0; w.toggleMaximize(); }
+        else { lastDown = now; w.startDragging(); }
+      } catch (_) {}
+    });
+  };
+  dragTop();
+
   const hookMenu = () => {
     if (window.__TAURI__ && window.__TAURI__.event) {
       window.__TAURI__.event.listen('everywhere:menu', (e) => {
@@ -682,6 +910,32 @@ const INIT_SCRIPT: &str = r#"
 // tells it the request came from the native shell and which app version (from
 // everywhere.yml → the submitted build) made it. Version is absent only in bare
 // `cargo run` dev where no config was passed.
+// --- macOS Dock icon under `every dev` --------------------------------------
+//
+// The app NAME is not handled here: macOS reads it from CFBundleName, and the
+// menu bar plus the About/Hide/Quit items are built from the bundle before any
+// of our Rust runs. (Setting NSProcessInfo's processName doesn't move them —
+// tried it.) `every dev` solves that by running this binary from inside a
+// throwaway .app it assembles; see Commands::Dev#stage_dev_bundle.
+//
+// The icon does need doing here, because Tauri bakes icons/icon.png into the
+// binary and applies it at launch — which in dev is the gem's placeholder, and
+// it would win over a bundle icns anyway. This replaces it with the app's own,
+// already shaped by the CLI exactly like the packaged .icns, so the Dock looks
+// the same in dev as it does in a release build.
+#[cfg(target_os = "macos")]
+fn set_dock_icon(path: &str) {
+    use objc2::{AllocAnyThread, MainThreadMarker};
+    use objc2_app_kit::{NSApplication, NSImage};
+    use objc2_foundation::NSString;
+
+    let Some(mtm) = MainThreadMarker::new() else { return };
+    let image = NSImage::initWithContentsOfFile(NSImage::alloc(), &NSString::from_str(path));
+    if let Some(image) = image {
+        unsafe { NSApplication::sharedApplication(mtm).setApplicationIconImage(Some(&image)) };
+    }
+}
+
 fn ua_marker(config: &AppConfig) -> String {
     let os = std::env::consts::OS;
     match &config.version {
@@ -739,16 +993,51 @@ fn build_window(
     url: WebviewUrl,
 ) -> tauri::Result<tauri::WebviewWindow> {
     let dev_mode = std::env::var("NATIVE_DEV_URL").is_ok();
+    let window = &config.window;
+    let (width, height) = window.size.unwrap_or((1100.0, 750.0));
 
     let mut builder = WebviewWindowBuilder::new(app, "main", url)
-        .title(title)
-        .inner_size(1100.0, 750.0)
+        // `title: false` blanks the text everywhere it can still show up (the
+        // Window menu, Mission Control) — not just in the title bar. The " (dev)"
+        // suffix the callers add goes with it; the bridge already tells the page
+        // it's a dev build via config.dev.
+        .title(if window.title == Some(false) { "" } else { title })
+        .inner_size(width, height)
         // Injected into every page: app config global, remote console, native
         // confirm default, and the menu-navigation listener.
         .initialization_script(INIT_SCRIPT.replace("/*__CONFIG_JSON__*/ null", &config.raw_json));
     if let Some((r, g, b)) = config.background_light {
         builder = builder.background_color(tauri::window::Color(r, g, b, 255));
     }
+    if let Some((min_width, min_height)) = window.min_size {
+        builder = builder.min_inner_size(min_width, min_height);
+    }
+    if let Some(resizable) = window.resizable {
+        builder = builder.resizable(resizable);
+    }
+    // Title bar. Overlay is a real macOS window style — the system keeps drawing
+    // (and positioning) the traffic lights, we just hide the title and let the
+    // webview run full-height underneath. Windows and Linux have no equivalent,
+    // so overlay degrades to frameless there and the page supplies its own
+    // controls through Everywhere.window.
+    match window.title_bar {
+        TitleBar::Decorated => {}
+        TitleBar::Overlay => {
+            #[cfg(target_os = "macos")]
+            {
+                builder = builder
+                    .title_bar_style(tauri::TitleBarStyle::Overlay)
+                    .hidden_title(true);
+            }
+            #[cfg(not(target_os = "macos"))]
+            {
+                builder = builder.decorations(false);
+            }
+        }
+        TitleBar::Frameless => {
+            builder = builder.decorations(false);
+        }
+    }
 
     // Cookie / session persistence: give the webview a stable data store so
     // logins survive relaunches. macOS carries it (and the UA marker) on a
@@ -791,8 +1080,46 @@ fn build_window(
 // everywhere.yml) loads via data: URL — no server needed before Rails boots.
 fn custom_splash_url() -> Option<WebviewUrl> {
     let exe = std::env::current_exe().ok()?;
-    let html = std::fs::read(exe.parent()?.join("../Resources/splash.html")).ok()?;
-    format!("data:text/html;base64,{}", base64(&html)).parse().ok().map(WebviewUrl::External)
+    let html = std::fs::read_to_string(exe.parent()?.join("../Resources/splash.html")).ok()?;
+    let html = inline_splash_assets(html);
+    format!("data:text/html;base64,{}", base64(html.as_bytes())).parse().ok().map(WebviewUrl::External)
+}
+
+// A data: URL page has no base to resolve relative URLs against, so an <img
+// src="assets/logo.png"> in a splash would silently render nothing. Rewrite
+// those references into data: URIs first, so the markup works the way it reads.
+//
+// Substitution rather than parsing: the splash is one small file the app author
+// wrote, the asset names come from a directory we control, and a real HTML
+// parse would pull in a dependency to solve a problem nobody has.
+fn inline_splash_assets(html: String) -> String {
+    let Some(dir) = assets_dir() else {
+        return html;
+    };
+    let Ok(entries) = std::fs::read_dir(dir) else {
+        return html;
+    };
+
+    let mut out = html;
+    for entry in entries.flatten() {
+        let path = entry.path();
+        let Some(name) = path.file_name().and_then(|n| n.to_str()) else {
+            continue;
+        };
+        if !out.contains(name) {
+            continue;
+        }
+        let Ok(bytes) = std::fs::read(&path) else {
+            continue;
+        };
+        let uri = format!("data:{};base64,{}", asset_mime(&path), base64(&bytes));
+        // Longest prefix first: replacing the bare "assets/…" first would strip
+        // the path off "./assets/…" and leave a dangling "./" glued to the URI.
+        for prefix in ["./assets/", "/assets/", "assets/"] {
+            out = out.replace(&format!("{prefix}{name}"), &uri);
+        }
+    }
+    out
 }
 
 fn base64(data: &[u8]) -> String {
@@ -836,6 +1163,17 @@ fn authorize_remote_origin(app: &tauri::App, remote_url: &str) -> tauri::Result<
         "permissions": [
             "core:default",
             "core:window:allow-set-title",
+            // Window controls (Everywhere.window.*): a frameless or overlay
+            // title bar is drawn by the page, so the page must be able to drag
+            // and close the window it lives in. Kept in lockstep with
+            // capabilities/default.json — see the mirroring rule above.
+            "core:window:allow-minimize",
+            "core:window:allow-maximize",
+            "core:window:allow-unmaximize",
+            "core:window:allow-toggle-maximize",
+            "core:window:allow-close",
+            "core:window:allow-is-maximized",
+            "core:window:allow-start-dragging",
             "notification:default",
             "dialog:default",
             "clipboard-manager:allow-read-text",
@@ -898,7 +1236,14 @@ fn notify(app: &tauri::AppHandle, title: &str, body: &str) {
     }
 }
 
-#[tauri::command]
-fn notify_command(app: tauri::AppHandle, title: String, body: String) {
-    notify(&app, &title, &body);
+// The shell's own Tauri commands. In a module rather than at the crate root
+// because #[tauri::command] expands to helper macros that generate_handler!
+// resolves by path — and a command sitting in main.rs can only be named by an
+// absolute `crate::` path, which is exactly the one form that doesn't work from
+// another module. The extensions registry has to name this, so it lives here.
+pub(crate) mod commands {
+    #[tauri::command]
+    pub fn notify_command(app: tauri::AppHandle, title: String, body: String) {
+        super::notify(&app, &title, &body);
+    }
 }

data/support/{shell → desktop}/src-tauri/tauri.conf.json

@@ -1,8 +1,8 @@
 {
   "$schema": "https://schema.tauri.app/config/2",
-  "productName": "ExampleNative",
+  "productName": "RubyEverywhere Shell",
   "version": "0.2.0",
-  "identifier": "com.rubyeverywhere.example",
+  "identifier": "com.rubyeverywhere.shell",
   "build": {
     "frontendDist": "../splash"
   },

data/support/{macos → release/macos}/notarize.sh

@@ -7,7 +7,7 @@
 # easiest way is to source your release env first:
 #
 #     source ~/Projects/atlastools.dev/atlas-workspaces/.env.release
-#     cli/support/macos/notarize.sh "example/dist/Example Notes.app"
+#     cli/support/release/macos/notarize.sh "example/dist/Example Notes.app"
 #
 # Required env vars (these match Tauri's names, so your existing .env works):
 #   APPLE_SIGNING_IDENTITY   e.g. "Developer ID Application: Your Name (TEAMID)"
@@ -33,7 +33,7 @@ APP="${1:?usage: notarize.sh /path/to/App.app}"
 # containing spaces/parens (e.g. APPLE_SIGNING_IDENTITY=Developer ID
 # Application: Name (TEAM)) that plain `source .env.release` cannot.
 #
-#   ENV_FILE=.env.release cli/support/macos/notarize.sh "App.app"
+#   ENV_FILE=.env.release cli/support/release/macos/notarize.sh "App.app"
 if [ -n "${ENV_FILE:-}" ]; then
   [ -f "$ENV_FILE" ] || { echo "ENV_FILE not found: $ENV_FILE" >&2; exit 1; }
   while IFS= read -r line || [ -n "$line" ]; do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby_everywhere
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Andrea Fomera
@@ -94,7 +94,9 @@ files:
 - lib/everywhere/blake2b.rb
 - lib/everywhere/boot.rb
 - lib/everywhere/builders/android.rb
+- lib/everywhere/builders/desktop.rb
 - lib/everywhere/builders/ios.rb
+- lib/everywhere/child_processes.rb
 - lib/everywhere/cli.rb
 - lib/everywhere/commands/build.rb
 - lib/everywhere/commands/clean.rb
@@ -113,12 +115,20 @@ files:
 - lib/everywhere/commands/shell_dir.rb
 - lib/everywhere/commands/updates_keygen.rb
 - lib/everywhere/config.rb
+- lib/everywhere/console.rb
 - lib/everywhere/database.rb
+- lib/everywhere/desktop_assets.rb
+- lib/everywhere/dock.rb
+- lib/everywhere/dock/footer.rb
+- lib/everywhere/dock/screen.rb
+- lib/everywhere/dock/state.rb
 - lib/everywhere/emulator.rb
 - lib/everywhere/engine.rb
+- lib/everywhere/fatal.rb
 - lib/everywhere/framework.rb
 - lib/everywhere/icon.rb
 - lib/everywhere/ignore.rb
+- lib/everywhere/line_pump.rb
 - lib/everywhere/log_filter.rb
 - lib/everywhere/minisign.rb
 - lib/everywhere/mobile_config_endpoint.rb
@@ -132,16 +142,31 @@ files:
 - lib/everywhere/png.rb
 - lib/everywhere/raster.rb
 - lib/everywhere/receipt.rb
+- lib/everywhere/relay.rb
 - lib/everywhere/s3.rb
 - lib/everywhere/shellout.rb
 - lib/everywhere/simulator.rb
+- lib/everywhere/task_pool.rb
 - lib/everywhere/ui.rb
 - lib/everywhere/update_manifest.rb
 - lib/everywhere/version.rb
 - lib/ruby_everywhere.rb
-- support/github/build.yml
-- support/macos/entitlements.plist
-- support/macos/notarize.sh
+- support/desktop/README.md
+- support/desktop/splash/index.html
+- support/desktop/src-tauri/Cargo.lock
+- support/desktop/src-tauri/Cargo.toml
+- support/desktop/src-tauri/build.rs
+- support/desktop/src-tauri/capabilities/default.json
+- support/desktop/src-tauri/gen/schemas/acl-manifests.json
+- support/desktop/src-tauri/gen/schemas/capabilities.json
+- support/desktop/src-tauri/gen/schemas/desktop-schema.json
+- support/desktop/src-tauri/gen/schemas/macOS-schema.json
+- support/desktop/src-tauri/icons/icon.png
+- support/desktop/src-tauri/src/extension_host.rs
+- support/desktop/src-tauri/src/extensions/mod.rs
+- support/desktop/src-tauri/src/main.rs
+- support/desktop/src-tauri/src/updater.rs
+- support/desktop/src-tauri/tauri.conf.json
 - support/mobile/android/README.md
 - support/mobile/android/app/build.gradle.kts
 - support/mobile/android/app/everywhere.properties
@@ -228,19 +253,8 @@ files:
 - support/mobile/ios/NativeExtensions/Package.swift
 - support/mobile/ios/NativeExtensions/Sources/NativeExtensions/Exports.swift
 - support/mobile/ios/README.md
-- support/shell/splash/index.html
-- support/shell/src-tauri/Cargo.lock
-- support/shell/src-tauri/Cargo.toml
-- support/shell/src-tauri/build.rs
-- support/shell/src-tauri/capabilities/default.json
-- support/shell/src-tauri/gen/schemas/acl-manifests.json
-- support/shell/src-tauri/gen/schemas/capabilities.json
-- support/shell/src-tauri/gen/schemas/desktop-schema.json
-- support/shell/src-tauri/gen/schemas/macOS-schema.json
-- support/shell/src-tauri/icons/icon.png
-- support/shell/src-tauri/src/main.rs
-- support/shell/src-tauri/src/updater.rs
-- support/shell/src-tauri/tauri.conf.json
+- support/release/macos/entitlements.plist
+- support/release/macos/notarize.sh
 homepage: https://rubyeverywhere.com
 licenses:
 - MIT