@legendapp/spark 0.0.1-next.2 → 0.0.1-next.3

package/vendor/node_modules/@legendapp/spark-notifications/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@legendapp/spark-notifications",
-  "version": "0.0.1-next.2",
+  "version": "0.0.1-next.3",
   "license": "MIT",
   "main": "src/index.ts",
   "react-native": "src/index.ts",
@@ -40,7 +40,7 @@
     ]
   },
   "dependencies": {
-    "@legendapp/spark-desktop-app": "0.0.1-next.2"
+    "@legendapp/spark-desktop-app": "0.0.1-next.3"
   },
   "private": true
 }

package/vendor/node_modules/@legendapp/spark-notifications/src/NativeDesktopNotifications.ts

@@ -1,4 +1,4 @@
 import type { TurboModule } from "react-native";
 import { TurboModuleRegistry } from "react-native";
 export interface Spec extends TurboModule { call(method: string, args: string): Promise<string>; }
-export default TurboModuleRegistry.getEnforcing<Spec>("NativeDesktopNotifications");
+export default TurboModuleRegistry.get<Spec>("NativeDesktopNotifications");

package/vendor/node_modules/@legendapp/spark-notifications/src/index.ts

@@ -1,53 +1,141 @@
 import Native from "./NativeDesktopNotifications";
-import { Platform } from "react-native";
-import { onDesktopEvent, callApp } from "@legendapp/spark-desktop-app";
+import { Platform, TurboModuleRegistry } from "react-native";
+import type { Spec as AppSpec } from "@legendapp/spark-desktop-app/src/NativeDesktopApp";
+import { onDesktopEvent } from "@legendapp/spark-desktop-app/src/events";
+import { SparkError, invokeNative, parseNativeResult, type Availability, type Subscription } from "@legendapp/spark-desktop-app/src/contracts";
+export type { Subscription } from "@legendapp/spark-desktop-app/src/contracts";
 
-export type NotificationPermission = "notDetermined" | "denied" | "authorized" | "provisional" | "unknown";
-export type DesktopNotification = {
-  id: string;
+export interface NotificationPermission {
+  status: "undetermined" | "denied" | "granted" | "unknown";
+  granted: boolean;
+  /** null when the host cannot determine this; Windows has no in-app prompt. */
+  canAskAgain: boolean | null;
+  macos?: { authorization: "notDetermined" | "denied" | "authorized" | "provisional" | "unknown" };
+}
+export interface NotificationAction { id: string; label: string }
+/** Portable tone names; each target maps them to its own system sounds (documented in the native bridges). */
+export type NotificationTone = "message" | "mail" | "reminder" | "call" | "error";
+export interface NotificationContent {
   title: string;
   body?: string;
   subtitle?: string;
-  sound?: boolean;
-  /** Deliver after this many seconds, or immediately when omitted. */
-  delay?: number;
+  /** false/omitted is silent; true or "default" plays the platform default; a tone selects a system sound. */
+  sound?: boolean | "default" | NotificationTone;
+  /** Custom buttons: 1–4 entries (the portable intersection of macOS categories and Windows toasts). macOS banners show the first two; the rest appear in Notification Center. Tapping the body reports "open", dismissing reports "dismiss". */
+  actions?: readonly NotificationAction[];
   data?: Record<string, string>;
-};
-export type NotificationResponse = { type: "notificationResponse"; id: string; notificationId: string; action: "open" | "dismiss"; data: Record<string, string> };
-async function call<T = void>(method: string, args: object = {}): Promise<T> {
-  return JSON.parse(await Native.call(method, JSON.stringify(args))) as T;
-}
-function validId(id: string) {
-  if (!/^[a-zA-Z0-9_.-]{1,100}$/.test(id)) throw new Error("Notification id must contain 1–100 letters, numbers, dots, underscores or hyphens");
-  return id;
-}
-export const getNotificationPermission = () => call<NotificationPermission>("permission");
-/** Call from an explicit user action. Go shares its host's OS permission. */
-export const requestNotificationPermission = () => call<NotificationPermission>("requestPermission");
-export function showNotification(notification: DesktopNotification) {
-  validId(notification.id);
-  if (!notification.title?.trim()) throw new Error("Notification title is required");
-  if (notification.delay !== undefined && (!Number.isFinite(notification.delay) || notification.delay < 1)) throw new Error("Notification delay must be at least one second");
-  if (notification.data && Object.values(notification.data).some(value => typeof value !== "string")) throw new Error("Notification data values must be strings");
-  return call("show", notification);
-}
-/** Removes pending and delivered notifications with this project-scoped id. */
-export const cancelNotification = (id: string) => call("cancel", { id: validId(id) });
-export const clearNotifications = () => call("clear");
-export const getPendingNotifications = () => call<string[]>("pending");
-export const getDeliveredNotifications = () => call<string[]>("delivered");
-/** Subscribe before draining cold-launch responses; each subscription deduplicates overlap. */
-export async function onNotificationResponse(listener: (response: NotificationResponse) => void) {
+}
+export interface ShowNotificationOptions { id: string; content: NotificationContent }
+export type NotificationTrigger = { type: "delay"; delaySeconds: number };
+export interface ScheduleNotificationOptions extends ShowNotificationOptions { trigger: NotificationTrigger }
+/** action is "open", "dismiss", or the id of a tapped notification action. */
+export interface NotificationResponse { type: "notificationResponse"; id: string; notificationId: string; action: "open" | "dismiss" | (string & {}); data: Record<string, string> }
+export function getNotificationAvailability(): Availability {
+  if (Platform.OS !== "macos" && Platform.OS !== "windows") return { available: false, reason: "unsupported-platform" };
+  return Native ? { available: true } : { available: false, reason: "missing-module" };
+}
+function native() {
+  const availability = getNotificationAvailability();
+  if (!availability.available) throw new SparkError(availability.reason === "unsupported-platform" ? "E_UNSUPPORTED_PLATFORM" : "E_MODULE_UNAVAILABLE", "Desktop notifications are unavailable");
+  return Native!;
+}
+async function call<T>(method: string, args: object, validate: (value: unknown) => value is T): Promise<T> {
+  return parseNativeResult(await invokeNative(() => native().call(method, JSON.stringify(args))), validate);
+}
+async function command(method: string, args: object = {}): Promise<void> { await call(method, args, (value): value is null => value === null); }
+function validId(id: unknown): id is string { return typeof id === "string" && /^[a-zA-Z0-9_.-]{1,100}$/.test(id); }
+function id(value: string): string {
+  if (!validId(value)) throw new SparkError("E_INVALID_ARGUMENT", "Notification id must contain 1–100 letters, numbers, dots, underscores or hyphens");
+  return value;
+}
+function options(value: unknown, keys: string[]) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new SparkError("E_INVALID_ARGUMENT", "Expected notification options");
+  for (const key of Object.keys(value)) if (!keys.includes(key)) throw new SparkError("E_UNSUPPORTED_OPTION", `Unsupported notification option: ${key}`);
+}
+function stringRecord(value: unknown): value is Record<string, string> {
+  return !!value && typeof value === "object" && !Array.isArray(value) && Object.values(value).every(item => typeof item === "string");
+}
+const tones = ["message", "mail", "reminder", "call", "error"] as const;
+function sound(value: unknown): "none" | "default" | NotificationTone {
+  if (value === undefined || value === false) return "none";
+  if (value === true || value === "default") return "default";
+  if (typeof value === "string" && (tones as readonly string[]).includes(value)) return value as NotificationTone;
+  throw new SparkError("E_INVALID_ARGUMENT", "Notification sound must be false, true, \"default\", or a tone name");
+}
+function actions(value: unknown): NotificationAction[] | undefined {
+  if (value === undefined) return undefined;
+  if (!Array.isArray(value) || !value.length || value.length > 4) throw new SparkError("E_INVALID_ARGUMENT", "Notification actions must contain 1–4 entries");
+  return value.map(action => {
+    if (!action || typeof action !== "object" || Array.isArray(action) || Object.keys(action).some(key => key !== "id" && key !== "label") || !validId((action as NotificationAction).id) || ["open", "dismiss"].includes((action as NotificationAction).id) || typeof (action as NotificationAction).label !== "string" || !(action as NotificationAction).label.trim() || (action as NotificationAction).label.includes("\0")) throw new SparkError("E_INVALID_ARGUMENT", "Notification actions need an id outside open/dismiss and a label");
+    return { id: action.id, label: action.label };
+  });
+}
+function notification(value: ShowNotificationOptions, scheduled: boolean) {
+  options(value, scheduled ? ["id", "content", "trigger"] : ["id", "content"]);
+  id(value.id); options(value.content, ["title", "body", "subtitle", "sound", "actions", "data"]);
+  const content = value.content;
+  if (typeof content.title !== "string" || !content.title.trim()) throw new SparkError("E_INVALID_ARGUMENT", "Notification title is required");
+  if ([content.body, content.subtitle].some(text => text !== undefined && typeof text !== "string") || (content.data !== undefined && !stringRecord(content.data))) throw new SparkError("E_INVALID_ARGUMENT", "Invalid notification content");
+  const result = { id: value.id, title: content.title, body: content.body, subtitle: content.subtitle, data: content.data, sound: sound(content.sound) };
+  const actionList = actions(content.actions);
+  return actionList === undefined ? result : { ...result, actions: actionList };
+}
+async function permission(method: string): Promise<NotificationPermission> {
+  const value = await call(method, {}, (value): value is NonNullable<NotificationPermission["macos"]>["authorization"] => typeof value === "string" && ["notDetermined", "denied", "authorized", "provisional", "unknown"].includes(value));
+  const granted = value === "authorized" || value === "provisional";
+  return { status: granted ? "granted" : value === "notDetermined" ? "undetermined" : value as "denied" | "unknown", granted,
+    canAskAgain: Platform.OS === "windows" ? false : value === "unknown" ? null : value !== "denied",
+    ...(Platform.OS === "macos" ? { macos: { authorization: value } } : {}) };
+}
+export async function getNotificationPermission(): Promise<NotificationPermission> { return permission("permission"); }
+/** Call from an explicit user action. Windows reads OS settings without a prompt. */
+export async function requestNotificationPermission(): Promise<NotificationPermission> { return permission("requestPermission"); }
+/** Submission accepted by the OS; it does not guarantee presentation. */
+export async function showNotification(value: ShowNotificationOptions): Promise<void> { await command("show", notification(value, false)); }
+export async function scheduleNotification(value: ScheduleNotificationOptions): Promise<void> {
+  const content = notification(value, true);
+  options(value.trigger, ["type", "delaySeconds"]);
+  if (value.trigger.type !== "delay" || !Number.isFinite(value.trigger.delaySeconds) || value.trigger.delaySeconds < 1 || value.trigger.delaySeconds > 315360000) throw new SparkError("E_INVALID_ARGUMENT", "Notification delay must be 1 second to ten years");
+  await command("show", { ...content, delay: value.trigger.delaySeconds });
+}
+/** Cancels pending delivery only. Missing IDs succeed. */
+export async function cancelNotification(value: string): Promise<void> { await command("cancel", { id: id(value) }); }
+export async function cancelAllNotifications(): Promise<void> { await command("cancelAll"); }
+/** Removes delivered notifications only. Missing IDs succeed. */
+export async function dismissNotification(value: string): Promise<void> { await command("dismiss", { id: id(value) }); }
+export async function dismissAllNotifications(): Promise<void> { await command("dismissAll"); }
+const ids = (value: unknown): value is string[] => Array.isArray(value) && value.every(validId);
+export async function getPendingNotifications(): Promise<string[]> { return call("pending", {}, ids); }
+export async function getDeliveredNotifications(): Promise<string[]> { return call("delivered", {}, ids); }
+function response(value: unknown): value is NotificationResponse {
+  if (!value || typeof value !== "object") return false;
+  const event = value as NotificationResponse;
+  return event.type === "notificationResponse" && typeof event.id === "string" && event.id.length > 0 && validId(event.notificationId) && validId(event.action) && stringRecord(event.data);
+}
+/** Subscribe before reading retained cold-launch responses; deduplicate queued/live overlap.
+ * Each new subscription replays retained responses (up to 100). Cleanup is synchronous.
+ */
+export async function onNotificationResponse(listener: (event: NotificationResponse) => void): Promise<Subscription> {
+  if (typeof listener !== "function") throw new SparkError("E_INVALID_ARGUMENT", "Expected notification response listener");
+  native();
   let removed = false;
   const seen = new Set<string>();
-  function receive(response: NotificationResponse) {
-    if (removed || seen.has(response.id)) return;
-    seen.add(response.id);
+  function receive(event: NotificationResponse) {
+    if (removed || seen.has(event.id)) return;
+    seen.add(event.id);
     if (seen.size > 256) seen.delete(seen.values().next().value!);
-    listener(response);
+    listener(event);
   }
-  const sub = onDesktopEvent(event => { if (event.type === "notificationResponse") receive(event as NotificationResponse); });
-  try { for (const response of (Platform.OS === "windows" ? await callApp<NotificationResponse[]>("notificationResponses") : await call<NotificationResponse[]>("responses"))) receive(response); }
-  catch (error) { sub.remove(); throw error; }
-  return { remove() { removed = true; sub.remove(); } };
+  const sub = onDesktopEvent(event => { if (response(event)) receive(event); }, { types: ["notificationResponse"] });
+  try {
+    const responses = Platform.OS === "windows"
+      ? parseNativeResult(await invokeNative(() => {
+          const app = TurboModuleRegistry.get<AppSpec>("NativeDesktopApp");
+          if (!app) throw new SparkError("E_MODULE_UNAVAILABLE", "Notification activation host is unavailable");
+          return app.call("notificationResponses", "{}");
+        }), (value): value is NotificationResponse[] => Array.isArray(value) && value.every(response))
+      : await call("responses", {}, (value): value is NotificationResponse[] => Array.isArray(value) && value.every(response));
+    responses.forEach(receive);
+  } catch (error) { removed = true; sub.remove(); throw error; }
+  return { remove() { if (!removed) { removed = true; sub.remove(); } } };
 }

package/vendor/node_modules/@legendapp/spark-notifications/windows/SparkNotifications/SparkNotifications.h

@@ -7,6 +7,7 @@
 #include <filesystem>
 #include <map>
 #include <memory>
+#include <cstdint>
 #include <cmath>
 #include <winrt/Windows.Data.Json.h>
 #include <winrt/Windows.Data.Xml.Dom.h>
@@ -38,8 +39,9 @@ struct NotificationsState : std::enable_shared_from_this<NotificationsState> {
   React::ReactContext context;
   std::wstring project, appId;
   Toast::ToastNotifier notifier{nullptr};
-  struct Live { Toast::ToastNotification toast{nullptr}; event_token dismissed; };
+  struct Live { Toast::ToastNotification toast{nullptr}; event_token dismissed; uint64_t generation; };
   std::map<std::wstring, Live> live;
+  uint64_t nextGeneration = 0;
   static constexpr wchar_t const *group = L"Spark";
   void Ensure() {
     if (notifier) return;
@@ -75,6 +77,12 @@ struct NotificationsState : std::enable_shared_from_this<NotificationsState> {
     notifier = candidate;
   }
   void Forget(std::wstring const &tag) { auto entry = live.find(tag); if (entry != live.end()) { entry->second.toast.Dismissed(entry->second.dismissed); live.erase(entry); } }
+  void Retire(std::wstring const &tag, uint64_t generation, bool userDismissed, std::wstring const &encoded) {
+    auto entry = live.find(tag);
+    if (entry == live.end() || entry->second.generation != generation) return;
+    Forget(tag);
+    if (userDismissed) Dismiss(hstring(encoded));
+  }
   void Close() noexcept { for (auto &[tag, item] : live) try { item.toast.Dismissed(item.dismissed); } catch (...) {} live.clear(); }
   void RemovePending(std::wstring const &tag) { for (auto const &item : notifier.GetScheduledToastNotifications()) if (item.Group() == group && (tag.empty() || item.Tag() == tag)) notifier.RemoveFromSchedule(item); }
   static hstring Id(Xml::XmlDocument const &xml) { return Json::JsonObject::Parse(xml.DocumentElement().GetAttribute(L"launch")).GetNamedString(L"notificationId"); }
@@ -92,15 +100,43 @@ struct NotificationsState : std::enable_shared_from_this<NotificationsState> {
     Xml::XmlDocument xml; xml.LoadXml(L"<toast><visual><binding template='ToastGeneric'/></visual></toast>"); xml.DocumentElement().SetAttribute(L"launch", response.Stringify());
     auto binding = xml.SelectSingleNode(L"/toast/visual/binding");
     for (auto field : {L"title", L"subtitle", L"body"}) { auto text = args.GetNamedString(field, L""); if (!text.empty()) { auto node = xml.CreateElement(L"text"); node.AppendChild(xml.CreateTextNode(text)); binding.AppendChild(node); } }
-    if (!args.GetNamedBoolean(L"sound", true)) { auto audio = xml.CreateElement(L"audio"); audio.SetAttribute(L"silent", L"true"); xml.DocumentElement().AppendChild(audio); }
+    // JS normalizes sound to "none", "default", or a tone name mapped onto the
+    // system Notification.* catalog; tones without a Windows counterpart use Default.
+    auto sound = args.GetNamedString(L"sound", L"none");
+    if (sound == L"none") { auto audio = xml.CreateElement(L"audio"); audio.SetAttribute(L"silent", L"true"); xml.DocumentElement().AppendChild(audio); }
+    else {
+      auto audio = xml.CreateElement(L"audio");
+      auto tone = std::wstring(L"ms-winsoundevent:Notification.");
+      if (sound == L"mail") tone += L"Mail"; else if (sound == L"message") tone += L"IM"; else if (sound == L"reminder") tone += L"Reminder";
+      else if (sound == L"call") { tone += L"Looping.Call"; audio.SetAttribute(L"duration", L"long"); }
+      else tone += L"Default";
+      audio.SetAttribute(L"src", tone.c_str()); xml.DocumentElement().AppendChild(audio);
+    }
+    // Action buttons activate through the same CustomActivator as the toast body,
+    // carrying their own action id in the activation arguments.
+    for (auto const &entry : args.GetNamedArray(L"actions", Json::JsonArray())) {
+      auto action = entry.GetObject();
+      auto button = xml.CreateElement(L"action");
+      // JsonObject is a reference type; parse a copy so each action carries its
+      // own action id without mutating the body/dismiss payload.
+      auto arguments = Json::JsonObject::Parse(response.Stringify());
+      arguments.SetNamedValue(L"action", Json::JsonValue::CreateStringValue(action.GetNamedString(L"id")));
+      button.SetAttribute(L"content", action.GetNamedString(L"label").c_str());
+      button.SetAttribute(L"arguments", arguments.Stringify().c_str());
+      xml.DocumentElement().AppendChild(button);
+    }
     auto tag = Hash(id); RemovePending(tag); Forget(tag);
     if (delay > 0) {
       Toast::ScheduledToastNotification toast(xml, clock::now() + std::chrono::milliseconds(static_cast<int64_t>(delay * 1000))); toast.Tag(tag); toast.Group(group); notifier.AddToSchedule(toast);
     } else {
       Toast::ToastNotification toast(xml); toast.Tag(tag); toast.Group(group);
       response.SetNamedValue(L"action", Json::JsonValue::CreateStringValue(L"dismiss")); auto encoded = response.Stringify(); auto weak = weak_from_this(); auto dispatcher = context.UIDispatcher();
-      auto token = toast.Dismissed([weak, dispatcher, encoded](auto const &, Toast::ToastDismissedEventArgs const &event) { if (event.Reason() == Toast::ToastDismissalReason::UserCanceled) dispatcher.Post([weak, encoded]() { if (auto state = weak.lock()) state->Dismiss(encoded); }); });
-      try { notifier.Show(toast); live.emplace(tag, Live{toast, token}); } catch (...) { toast.Dismissed(token); throw; }
+      const auto generation = ++nextGeneration;
+      auto token = toast.Dismissed([weak, dispatcher, tag, generation, encoded](auto const &, Toast::ToastDismissedEventArgs const &event) {
+        const bool userDismissed = event.Reason() == Toast::ToastDismissalReason::UserCanceled;
+        dispatcher.Post([weak, tag, generation, userDismissed, encoded]() { if (auto state = weak.lock()) state->Retire(tag, generation, userDismissed, encoded); });
+      });
+      try { notifier.Show(toast); live.emplace(tag, Live{toast, token, generation}); } catch (...) { toast.Dismissed(token); throw; }
     }
   }
 };
@@ -115,8 +151,10 @@ struct SparkNotifications {
         value->Ensure(); auto args = Json::JsonObject::Parse(to_hstring(encoded));
         if (method == "permission" || method == "requestPermission") { promise.Resolve(value->notifier.Setting() == Toast::NotificationSetting::Enabled ? "\"authorized\"" : "\"denied\""); return; }
         if (method == "show") value->Show(args);
-        else if (method == "cancel") { auto tag = Hash(args.GetNamedString(L"id")); value->RemovePending(tag); value->Forget(tag); Toast::ToastNotificationManager::History().Remove(tag, value->group, value->appId); }
-        else if (method == "clear") { value->RemovePending(L""); value->Close(); Toast::ToastNotificationManager::History().RemoveGroup(value->group, value->appId); }
+        else if (method == "cancel") value->RemovePending(Hash(args.GetNamedString(L"id")));
+        else if (method == "dismiss") { auto tag = Hash(args.GetNamedString(L"id")); value->Forget(tag); Toast::ToastNotificationManager::History().Remove(tag, value->group, value->appId); }
+        else if (method == "cancelAll") value->RemovePending(L"");
+        else if (method == "dismissAll") { value->Close(); Toast::ToastNotificationManager::History().RemoveGroup(value->group, value->appId); }
         else if (method == "pending" || method == "delivered") {
           Json::JsonArray result;
           if (method == "pending") { for (auto const &item : value->notifier.GetScheduledToastNotifications()) if (item.Group() == value->group) result.Append(Json::JsonValue::CreateStringValue(value->Id(item.Content()))); }
@@ -124,8 +162,8 @@ struct SparkNotifications {
           promise.Resolve(to_string(result.Stringify())); return;
         } else throw hresult_invalid_argument(L"Unsupported notification operation");
         promise.Resolve("null");
-      } catch (hresult_error const &error) { promise.Reject(React::ReactError{error.code() == E_ACCESSDENIED ? "E_NOTIFICATION_PERMISSION" : "E_NOTIFICATION", to_string(error.message())}); }
-      catch (std::exception const &error) { promise.Reject(React::ReactError{"E_NOTIFICATION", error.what()}); }
+      } catch (hresult_error const &error) { promise.Reject(React::ReactError{error.code() == E_ACCESSDENIED ? "E_PERMISSION_DENIED" : "E_NATIVE", to_string(error.message())}); }
+      catch (std::exception const &error) { promise.Reject(React::ReactError{"E_NATIVE", error.what()}); }
     });
   }
 };

package/vendor/node_modules/@legendapp/spark-processes/macos/RNDesktopProcesses.mm

@@ -1,10 +1,49 @@
 #import "RNDesktopProcesses.h"
+#import <RNDesktopApp/SparkBinaryJSI.h>
 #import <RNDesktopApp/SparkDesktop.h>
 #import <signal.h>
 #import <AppKit/AppKit.h>
 #import <spawn.h>
 #import <sys/wait.h>
 #import <vector>
+static NSString *ResolveCommandPath(NSString *command)
+{
+  NSString *homeDirectory = NSHomeDirectory();
+  NSArray<NSString *> *fallbackPaths = @[
+    [homeDirectory stringByAppendingPathComponent:@".local/bin"],
+    [homeDirectory stringByAppendingPathComponent:@".bun/bin"],
+    [homeDirectory stringByAppendingPathComponent:@"bin"],
+    @"/opt/homebrew/bin",
+    @"/usr/local/bin",
+    @"/usr/bin",
+    @"/bin",
+    @"/usr/sbin",
+    @"/sbin",
+  ];
+  NSMutableArray<NSString *> *searchPaths = [NSMutableArray array];
+  NSString *pathValue = [[NSProcessInfo processInfo] environment][@"PATH"];
+  if (pathValue.length > 0) {
+    [searchPaths addObjectsFromArray:[pathValue componentsSeparatedByString:@":"]];
+  }
+  for (NSString *fallback in fallbackPaths) {
+    if (![searchPaths containsObject:fallback]) {
+      [searchPaths addObject:fallback];
+    }
+  }
+
+  NSFileManager *fileManager = [NSFileManager defaultManager];
+  for (NSString *directory in searchPaths) {
+    if (![directory hasPrefix:@"/"]) continue;
+    NSString *candidate = [directory stringByAppendingPathComponent:command];
+    BOOL directoryEntry = NO;
+    if ([fileManager fileExistsAtPath:candidate isDirectory:&directoryEntry] && !directoryEntry && [fileManager isExecutableFileAtPath:candidate]) {
+      return candidate;
+    }
+  }
+
+  return nil;
+}
+
 @interface SparkProcess : NSObject
 @property pid_t pid;
 @property BOOL running;
@@ -12,6 +51,7 @@
 @property BOOL timedOut;
 @property BOOL truncated;
 @property BOOL ended;
+@property BOOL inputClosed;
 @property dispatch_queue_t inputQueue;
 @end
 @implementation SparkProcess
@@ -19,6 +59,7 @@
 @interface RNDesktopProcesses ()
 @property NSMutableDictionary<NSString *, SparkProcess *> *processes;
 @property BOOL invalidated;
+@property (copy) void (^binaryEvent)(NSDictionary *event, dispatch_block_t delivered);
 @end
 @implementation RNDesktopProcesses
 RCT_EXPORT_MODULE(NativeDesktopProcesses)
@@ -33,23 +74,32 @@ RCT_EXPORT_MODULE(NativeDesktopProcesses)
 - (void)stopAll { for (SparkProcess *process in self.processes.allValues) if (process.running) kill(-process.pid, SIGKILL); }
 - (void)dealloc { [[NSNotificationCenter defaultCenter] removeObserver:self]; }
 
-- (void)terminate:(SparkProcess *)process {
+- (BOOL)terminate:(SparkProcess *)process {
   if (process.running) {
-    kill(-process.pid, SIGTERM);
+    if (kill(-process.pid, SIGTERM) != 0 && errno != ESRCH) return NO;
     dispatch_after(dispatch_time(DISPATCH_TIME_NOW, 2 * NSEC_PER_SEC), dispatch_get_main_queue(), ^{
       if (process.running) kill(-process.pid, SIGKILL);
     });
   }
+  return YES;
 }
 
-- (void)call:(NSString *)method args:(NSString *)json resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {
+- (void)call:(NSString *)method args:(NSString *)json resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject { [self perform:method args:SparkArgs(json) binary:NO resolve:resolve reject:reject]; }
+- (void)binaryCall:(NSString *)method args:(NSString *)json bytes:(NSData *)bytes resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject { NSMutableDictionary *args = [SparkArgs(json) mutableCopy]; if (bytes) args[@"bytes"] = bytes; [self perform:method args:args binary:YES resolve:resolve reject:reject]; }
+- (void)perform:(NSString *)method args:(NSDictionary *)args binary:(BOOL)binary resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {
   dispatch_async(dispatch_get_main_queue(), ^{
-    NSDictionary *args = SparkArgs(json); NSString *key = args[@"id"];
+    NSString *key = args[@"id"];
     if (self.invalidated) { reject(@"E_CLOSED", @"Process module is closed", nil); return; }
-    SparkProcess *process = self.processes[key];
+    if ([method isEqual:@"resolveCommand"]) {
+      NSString *command = args[@"command"];
+      if (![command isKindOfClass:NSString.class] || !command.length) { SparkInvalid(reject, @"Expected a command name"); return; }
+      resolve(binary ? (ResolveCommandPath(command) ?: (id)NSNull.null) : SparkJSON(ResolveCommandPath(command) ?: (id)NSNull.null)); return;
+    }
+    SparkProcess *process = key ? self.processes[key] : nil;
     if ([method isEqual:@"spawn"]) {
       if (process) { reject(@"E_EXISTS", @"Process id already exists", nil); return; }
       NSString *executable = args[@"executable"];
+      if ([args[@"command"] boolValue]) { executable = ResolveCommandPath(executable); if (!executable) { reject(@"E_NOT_FOUND", @"Command not found", nil); return; } }
       if ([executable hasPrefix:@"helper:"]) {
         NSString *name = [executable substringFromIndex:7];
         if (!name.length || [name rangeOfCharacterFromSet:[[NSCharacterSet characterSetWithCharactersInString:@"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_-"] invertedSet]].location != NSNotFound) { SparkInvalid(reject, @"Invalid helper name"); return; }
@@ -63,6 +113,10 @@ RCT_EXPORT_MODULE(NativeDesktopProcesses)
         }
       }
       if (![executable hasPrefix:@"/"]) { SparkInvalid(reject, @"Executable path must be absolute"); return; }
+      NSUInteger captureLimit = [args[@"captureLimitBytes"] unsignedIntegerValue];
+      if (captureLimit > 8 * 1024 * 1024) { SparkInvalid(reject, @"Invalid capture limit"); return; }
+      NSData *initialInput = args[@"bytes"];
+      if (args[@"bytes"] && ![initialInput isKindOfClass:NSData.class]) { SparkInvalid(reject, @"Invalid process input"); return; }
       process = [SparkProcess new];
       process.inputQueue = dispatch_queue_create("desktop.process.input", DISPATCH_QUEUE_SERIAL);
       NSMutableDictionary *environment = [NSProcessInfo.processInfo.environment mutableCopy]; [environment addEntriesFromDictionary:args[@"env"] ?: @{}];
@@ -71,7 +125,11 @@ RCT_EXPORT_MODULE(NativeDesktopProcesses)
       // Create the process group atomically, before executable code can fork.
       // NSTask + setpgid after launch has a race and cannot provide this contract.
       posix_spawnattr_t attributes; posix_spawnattr_init(&attributes);
-      posix_spawnattr_setflags(&attributes, POSIX_SPAWN_SETPGROUP | POSIX_SPAWN_CLOEXEC_DEFAULT);
+      // GCD/host threads can block or ignore signals. Child defaults must not
+      // inherit that state or cooperative SIGTERM degrades into forced SIGKILL.
+      sigset_t mask, defaults; sigemptyset(&mask); sigfillset(&defaults);
+      posix_spawnattr_setsigmask(&attributes, &mask); posix_spawnattr_setsigdefault(&attributes, &defaults);
+      posix_spawnattr_setflags(&attributes, POSIX_SPAWN_SETPGROUP | POSIX_SPAWN_CLOEXEC_DEFAULT | POSIX_SPAWN_SETSIGMASK | POSIX_SPAWN_SETSIGDEF);
       posix_spawnattr_setpgroup(&attributes, 0);
       posix_spawn_file_actions_t actions; posix_spawn_file_actions_init(&actions);
       posix_spawn_file_actions_adddup2(&actions, input.fileHandleForReading.fileDescriptor, STDIN_FILENO);
@@ -98,6 +156,9 @@ RCT_EXPORT_MODULE(NativeDesktopProcesses)
         NSFileHandle *handle = streams[index]; NSMutableData *buffer = index ? stderrData : stdoutData;
         NSString *stream = index ? @"stderr" : @"stdout";
         dispatch_group_async(group, dispatch_get_global_queue(QOS_CLASS_UTILITY, 0), ^{
+          // Keep up to 1 MiB in flight per stream; ordinary delivery never waits
+          // for a per-chunk JS acknowledgement. A stalled consumer backpressures the pipe.
+          dispatch_semaphore_t slots = dispatch_semaphore_create(64);
           @try {
             while (YES) {
               // readDataOfLength can wait for the requested length. A service's
@@ -105,9 +166,13 @@ RCT_EXPORT_MODULE(NativeDesktopProcesses)
               char bytes[16384]; ssize_t count;
               do { count = read(handle.fileDescriptor, bytes, sizeof(bytes)); } while (count < 0 && errno == EINTR);
               if (count <= 0) break;
-              NSData *data = [NSData dataWithBytes:bytes length:(NSUInteger)count];
-              @synchronized(process) { NSUInteger remaining = 8 * 1024 * 1024 - buffer.length; if (data.length > remaining) process.truncated = YES; [buffer appendData:[data subdataWithRange:NSMakeRange(0, MIN(remaining, data.length))]]; }
-              if ([args[@"streamOutput"] boolValue]) dispatch_sync(dispatch_get_main_queue(), ^{ if (!self.invalidated) SparkEmit(@{ @"type": @"processOutput", @"processId": key, @"stream": stream, @"base64": [data base64EncodedStringWithOptions:0] }); });
+              NSMutableData *data = [NSMutableData dataWithBytes:bytes length:(NSUInteger)count];
+              @synchronized(process) { NSUInteger remaining = captureLimit - buffer.length; if (data.length > remaining) process.truncated = YES; [buffer appendData:[data subdataWithRange:NSMakeRange(0, MIN(remaining, data.length))]]; }
+              if ([args[@"streamOutput"] boolValue]) {
+                while (!self.invalidated && dispatch_semaphore_wait(slots, dispatch_time(DISPATCH_TIME_NOW, 100 * NSEC_PER_MSEC))) {}
+                if (self.invalidated) break;
+                dispatch_sync(dispatch_get_main_queue(), ^{ if (!self.invalidated) self.binaryEvent(@{ @"type": @"processOutput", @"processId": key, @"stream": stream, @"bytes": data }, ^{ dispatch_semaphore_signal(slots); }); else dispatch_semaphore_signal(slots); });
+              }
             }
           } @catch (NSException *exception) { /* Closing the runtime interrupts pipe reads. */ }
           [handle closeFile];
@@ -123,31 +188,39 @@ RCT_EXPORT_MODULE(NativeDesktopProcesses)
           int terminationStatus = status;
           process.ended = YES;
           dispatch_async(process.inputQueue, ^{ @try { [process.input closeFile]; } @catch (NSException *exception) {} });
-          if (!self.invalidated) SparkEmit(@{ @"type": @"processExit", @"processId": key, @"result": @{
-            @"exitCode": @(WIFEXITED(terminationStatus) ? WEXITSTATUS(terminationStatus) : WTERMSIG(terminationStatus)), @"signal": @(WIFSIGNALED(terminationStatus)),
-            @"stdout": [[NSString alloc] initWithData:stdoutData encoding:NSUTF8StringEncoding] ?: @"", @"stderr": [[NSString alloc] initWithData:stderrData encoding:NSUTF8StringEncoding] ?: @"",
-            @"stdoutBase64": [stdoutData base64EncodedStringWithOptions:0], @"stderrBase64": [stderrData base64EncodedStringWithOptions:0],
-            @"timedOut": @(process.timedOut), @"outputTruncated": @(process.truncated) } });
+          if (!self.invalidated) self.binaryEvent(@{ @"type": @"processExit", @"processId": key, @"result": @{
+            @"exitCode": @(WIFEXITED(terminationStatus) ? WEXITSTATUS(terminationStatus) : WTERMSIG(terminationStatus)), @"terminated": @(WIFSIGNALED(terminationStatus)), @"terminationSignal": WIFSIGNALED(terminationStatus) ? @(WTERMSIG(terminationStatus)) : (id)NSNull.null,
+            @"stdout": stdoutData, @"stderr": stderrData,
+            @"timedOut": @(process.timedOut), @"outputTruncated": @(process.truncated) } }, nil);
           [self.processes removeObjectForKey:key];
         });
       });
-      if (args[@"input"]) { NSData *data = [args[@"input"] dataUsingEncoding:NSUTF8StringEncoding]; dispatch_async(process.inputQueue, ^{ @try { [process.input writeData:data]; } @catch (NSException *exception) {} }); }
+      if (initialInput) { NSData *data = initialInput; dispatch_async(process.inputQueue, ^{ @try { [process.input writeData:data]; } @catch (NSException *exception) {} }); }
       if (args[@"timeoutMs"]) dispatch_after(dispatch_time(DISPATCH_TIME_NOW, [args[@"timeoutMs"] doubleValue] * NSEC_PER_MSEC), dispatch_get_main_queue(), ^{
         if (process.running) { process.timedOut = YES; [self terminate:process]; }
       });
     } else {
-      if (!process || process.ended) { if ([method isEqual:@"terminate"] || [method isEqual:@"closeInput"]) { resolve(@"null"); return; } reject(@"E_CLOSED", @"Process has exited", nil); return; }
-      if ([method isEqual:@"terminate"]) [self terminate:process];
+      if (!process || process.ended) { if ([method isEqual:@"terminate"] || [method isEqual:@"closeInput"]) { resolve(binary ? NSNull.null : @"null"); return; } reject(@"E_CLOSED", @"Process has exited", nil); return; }
+      if ([method isEqual:@"terminate"]) {
+        if (![self terminate:process]) { SparkReject(reject, [NSError errorWithDomain:NSPOSIXErrorDomain code:errno userInfo:nil]); return; }
+      }
       else if ([method isEqual:@"write"] || [method isEqual:@"closeInput"]) {
+        NSData *data = [method isEqual:@"write"] ? args[@"bytes"] : nil;
+        if ([method isEqual:@"write"] && !data) { SparkInvalid(reject, @"Invalid process input"); return; }
         dispatch_async(process.inputQueue, ^{
-          @try { if ([method isEqual:@"write"]) [process.input writeData:[args[@"text"] dataUsingEncoding:NSUTF8StringEncoding]]; else [process.input closeFile]; resolve(@"null"); }
-          @catch (NSException *exception) { reject(@"E_PIPE", @"Process input is closed", nil); }
+          @try {
+            if ([method isEqual:@"write"]) {
+              if (process.inputClosed) { reject(@"E_CLOSED", @"Process input is closed", nil); return; }
+              [process.input writeData:data];
+            } else if (!process.inputClosed) { [process.input closeFile]; process.inputClosed = YES; }
+            resolve(binary ? NSNull.null : @"null");
+          } @catch (NSException *exception) { reject(@"E_CLOSED", @"Process input is closed", nil); }
         }); return;
       } else { SparkInvalid(reject, @"Unknown process operation"); return; }
     }
-    resolve(@"null");
+    resolve(binary ? NSNull.null : @"null");
   });
 }
 - (void)invalidate { dispatch_async(dispatch_get_main_queue(), ^{ self.invalidated = YES; [self stopAll]; }); }
-- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:(const facebook::react::ObjCTurboModule::InitParams &)params { return std::make_shared<facebook::react::NativeDesktopProcessesSpecJSI>(params); }
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:(const facebook::react::ObjCTurboModule::InitParams &)params { auto invoker = params.jsInvoker; self.binaryEvent = ^(NSDictionary *event, dispatch_block_t delivered) { spark::binary::Emit(invoker, [event](spark::binary::jsi::Runtime &rt) { return spark::binary::Value(rt, event); }, [delivered] { if (delivered) delivered(); }); }; return std::make_shared<spark::binary::Module<facebook::react::NativeDesktopProcessesSpecJSI>>(params); }
 @end

package/vendor/node_modules/@legendapp/spark-processes/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@legendapp/spark-processes",
-  "version": "0.0.1-next.2",
+  "version": "0.0.1-next.3",
   "license": "MIT",
   "main": "src/index.ts",
   "react-native": "src/index.ts",
@@ -22,7 +22,8 @@
     "ios": {
       "modulesProvider": {
         "NativeDesktopProcesses": "RNDesktopProcesses"
-      }
+      },
+      "componentProvider": {}
     }
   },
   "spark": {
@@ -40,7 +41,7 @@
     ]
   },
   "dependencies": {
-    "@legendapp/spark-desktop-app": "0.0.1-next.2"
+    "@legendapp/spark-desktop-app": "0.0.1-next.3"
   },
   "private": true
 }

package/vendor/node_modules/@legendapp/spark-processes/src/NativeDesktopProcesses.ts

@@ -1,3 +1,3 @@
 import { TurboModuleRegistry, type TurboModule } from "react-native";
 export interface Spec extends TurboModule { call(method: string, args: string): Promise<string>; }
-export default TurboModuleRegistry.getEnforcing<Spec>("NativeDesktopProcesses");
+export default TurboModuleRegistry.get<Spec>("NativeDesktopProcesses");