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

package/vendor/node_modules/@legendapp/spark-commands/src/router.ts

@@ -0,0 +1,138 @@
+import { addKeyboardListener, createKeyboardConsumption, type KeyboardConsumption, type KeyboardConsumptionRule, type KeyboardEvent } from "@legendapp/spark-desktop-shortcuts/src/keyboard-manager";
+import { SparkError, asyncRegistration, type AsyncRegistration } from "@legendapp/spark-desktop-app/src/contracts";
+import { getDefaultHotkeyBindings, matchesParsedHotkey, parseBinding, normalizeHotkeyBindings, validateDefinitions, type HotkeyBindingState, type HotkeyDefinition } from "./bindings";
+export type HotkeyScope = { kind: "application" } | { kind: "window"; windowId: string };
+export type HotkeyHandlerContext = { binding: string; event: KeyboardEvent; pressedKeys: ReadonlySet<number>; repeated: boolean };
+export type RoutedHotkeyHandlers<Id extends string = string> = Partial<Record<Id, (context: HotkeyHandlerContext) => boolean | void>>;
+export interface HotkeyRegistrationOptions<Id extends string = string> {
+  bindings?: Partial<HotkeyBindingState<Id>>;
+  definitions: readonly HotkeyDefinition<Id>[];
+  enabled?: boolean;
+  handlers: RoutedHotkeyHandlers<Id>;
+  priority?: number;
+  scope?: HotkeyScope;
+}
+export interface HotkeyRegistration extends AsyncRegistration { setEnabled(enabled: boolean): Promise<void> }
+export interface HotkeyRouter {
+  register<Id extends string>(options: HotkeyRegistrationOptions<Id>): Promise<HotkeyRegistration>;
+  suspend(scope?: HotkeyScope): Promise<AsyncRegistration>;
+  setActiveWindowId(windowId: string | null): void;
+  getPressedKeys(): ReadonlySet<number>;
+}
+export let capturing = false;
+export function setCapturing(value: boolean) { capturing = value; }
+function validateScope(scope: HotkeyScope) {
+  if (!scope || (scope.kind !== "application" && scope.kind !== "window") || (scope.kind === "window" && (typeof scope.windowId !== "string" || !scope.windowId))) throw new SparkError("E_INVALID_ARGUMENT", "Expected application or window scope");
+}
+export function createHotkeyRouter(): HotkeyRouter {
+  type Registration = Required<Pick<HotkeyRegistrationOptions, "definitions" | "handlers" | "scope" | "priority">> & { enabled: boolean; appliedEnabled: boolean; revision: number; bindings: Partial<HotkeyBindingState>; order: number };
+  const registrations = new Set<Registration>(), suspensions = new Set<HotkeyScope>(), pressed = new Set<number>();
+  type Candidate = { registration: Registration; definition: HotkeyDefinition; handler: NonNullable<RoutedHotkeyHandlers[string]>; binding: string; parsed: ReturnType<typeof parseBinding> };
+  let candidates = new Map<string, Candidate[]>();
+  const modifierBits = [16, 17, 18, 19, 20, 23].map(bit => 1 << bit);
+  const rebuild = () => {
+    const next = new Map<string, Candidate[]>();
+    for (const registration of [...registrations].sort((a, b) => b.priority - a.priority || b.order - a.order)) {
+      for (const definition of registration.definitions) {
+        const handler = Object.hasOwn(registration.handlers, definition.id) ? registration.handlers[definition.id] : undefined;
+        if (!handler) continue;
+        for (const binding of Object.hasOwn(registration.bindings, definition.id) ? registration.bindings[definition.id]! : definition.defaultBindings) {
+          const parsed = parseBinding(binding), key = parsed.key.toLowerCase();
+          const list = next.get(key) ?? [];
+          list.push({ registration, definition, handler, binding, parsed }); next.set(key, list);
+        }
+      }
+    }
+    candidates = next;
+  };
+  let activeWindowId: string | null = null, order = 0, transitions = Promise.resolve();
+  let consumption: KeyboardConsumption | undefined;
+  let subscriptions: AsyncRegistration[] | undefined, cleanup: AsyncRegistration[] | undefined;
+  const matchesScope = (scope: HotkeyScope, id: string | null) => scope.kind === "application" || scope.windowId === id;
+  const updateModifiers = (event: KeyboardEvent) => {
+    for (const modifier of modifierBits) { if (event.modifiers & modifier) pressed.add(modifier); else pressed.delete(modifier); }
+  };
+  const dispatch = (event: KeyboardEvent) => {
+    const windowId = event.windowId;
+    if (windowId !== activeWindowId) { pressed.clear(); activeWindowId = windowId; }
+    const repeated = event.repeated; pressed.add(event.keyCode);
+    updateModifiers(event);
+    if (capturing || event.captured || !event.consumed) return false;
+    for (const scope of suspensions) if (matchesScope(scope, windowId)) return false;
+    for (const { registration, definition, handler, binding, parsed } of candidates.get(event.key.toLowerCase()) ?? []) {
+      if (!registrations.has(registration) || !registration.enabled || !matchesScope(registration.scope, windowId)) continue;
+      if (repeated && !definition.repeat) continue;
+      if (matchesParsedHotkey(event, parsed, definition.allowExtraModifiers) && handler({ binding, event, pressedKeys: new Set(pressed), repeated }) !== false) return true;
+    }
+    return false;
+  };
+  const nativeRules = (): KeyboardConsumptionRule[] => {
+    if ([...suspensions].some(scope => scope.kind === "application")) return [];
+    const excludedWindowIds = [...suspensions].flatMap(scope => scope.kind === "window" ? [scope.windowId] : []);
+    const rules: KeyboardConsumptionRule[] = [];
+    for (const values of candidates.values()) for (const { registration, definition, parsed } of values) {
+      if (!registration.enabled) continue;
+      rules.push({ ...parsed, allowExtraModifiers: definition.allowExtraModifiers ?? false, repeat: definition.repeat ?? false,
+        ...(registration.scope.kind === "window" ? { windowIds: [registration.scope.windowId] } : {}), excludedWindowIds });
+    }
+    return rules;
+  };
+  const synchronize = () => {
+    const operation = transitions.then(async () => {
+      if (cleanup) { await Promise.all(cleanup.map(item => item.remove())); cleanup = undefined; }
+      if (registrations.size) {
+        if (!subscriptions) {
+          const down = await addKeyboardListener("down", dispatch);
+          try { subscriptions = [down, await addKeyboardListener("up", event => { pressed.delete(event.keyCode); updateModifiers(event); })]; }
+          catch (error) { cleanup = [down]; try { await down.remove(); cleanup = undefined; } catch {} throw error; }
+        }
+        const enabledSnapshot = [...registrations].map(registration => [registration, registration.enabled] as const);
+        if (consumption) await consumption.update(nativeRules());
+        else consumption = await createKeyboardConsumption(nativeRules());
+        for (const [registration, enabled] of enabledSnapshot) registration.appliedEnabled = enabled;
+      } else if (subscriptions) {
+        cleanup = [...(consumption ? [consumption] : []), ...subscriptions]; consumption = undefined; subscriptions = undefined; pressed.clear();
+        await Promise.all(cleanup.map(item => item.remove())); cleanup = undefined;
+      }
+    });
+    transitions = operation.catch(() => {}); return operation;
+  };
+  return {
+    async register(options) {
+      if (!options || typeof options !== "object" || Array.isArray(options)) throw new SparkError("E_INVALID_ARGUMENT", "Expected command registration options");
+      for (const key of Object.keys(options)) if (!["definitions", "bindings", "enabled", "handlers", "scope", "priority"].includes(key)) throw new SparkError("E_UNSUPPORTED_OPTION", `Unknown command option: ${key}`);
+      const { definitions, bindings = {}, enabled = true, handlers, scope = { kind: "application" }, priority = scope.kind === "window" ? 100 : 0 } = options;
+      validateDefinitions(definitions); validateScope(scope);
+      if (!Number.isFinite(priority) || typeof enabled !== "boolean" || !handlers || typeof handlers !== "object" || !bindings || typeof bindings !== "object" || Array.isArray(bindings)) throw new SparkError("E_INVALID_ARGUMENT", "Invalid command registration options");
+      const ids = new Set(definitions.map(definition => definition.id));
+      for (const [id, handler] of Object.entries(handlers)) if (!ids.has(id as never) || typeof handler !== "function") throw new SparkError("E_INVALID_ARGUMENT", `Invalid handler for command ${id}`);
+      for (const id of Object.keys(bindings)) if (!ids.has(id as never)) throw new SparkError("E_INVALID_ARGUMENT", `Unknown command binding: ${id}`);
+      const registration: Registration = { definitions: definitions.map(definition => ({ ...definition, defaultBindings: getDefaultHotkeyBindings(definition) })), bindings: Object.fromEntries(Object.entries(bindings).map(([id, values]) => [id, normalizeHotkeyBindings(values as readonly string[])])), enabled, appliedEnabled: enabled, revision: 0, handlers: { ...handlers }, scope: { ...scope }, priority, order: order++ };
+      registrations.add(registration);
+      rebuild();
+      try { await synchronize(); } catch (error) {
+        registrations.delete(registration); rebuild();
+        try { await synchronize(); } catch (cleanupError) { throw new AggregateError([error, cleanupError], "Command setup and cleanup failed"); }
+        throw error;
+      }
+      const removal = asyncRegistration(() => { registrations.delete(registration); rebuild(); }, synchronize);
+      return { remove: removal.remove, async setEnabled(value) {
+        if (typeof value !== "boolean") throw new SparkError("E_INVALID_ARGUMENT", "Expected enabled boolean");
+        if (!registrations.has(registration)) throw new SparkError("E_CLOSED", "Command registration has been removed");
+        const revision = ++registration.revision; registration.enabled = value;
+        try { await synchronize(); } catch (error) { if (registration.revision === revision && registrations.has(registration)) registration.enabled = registration.appliedEnabled; throw error; }
+      } };
+    },
+    async suspend(scope = { kind: "application" }) {
+      validateScope(scope); const snapshot = { ...scope }; suspensions.add(snapshot);
+      try { await synchronize(); } catch (error) {
+        suspensions.delete(snapshot);
+        try { await synchronize(); } catch (cleanupError) { throw new AggregateError([error, cleanupError], "Command suspension and rollback failed"); }
+        throw error;
+      }
+      return asyncRegistration(() => { suspensions.delete(snapshot); }, synchronize);
+    },
+    setActiveWindowId(id) { if (id !== null && (typeof id !== "string" || !id)) throw new SparkError("E_INVALID_ARGUMENT", "Expected a window ID or null"); if (activeWindowId !== id) pressed.clear(); activeWindowId = id; },
+    getPressedKeys: () => new Set(pressed),
+  };
+}

package/vendor/node_modules/@legendapp/spark-commands/src/storage.ts

@@ -0,0 +1,20 @@
+import { SparkError } from "@legendapp/spark-desktop-app/src/contracts";
+import type { ObservableFile } from "@legendapp/spark-settings/src/storage";
+import type { SettingsStorage } from "@legendapp/spark-settings/src/store";
+import { normalizeHotkeyFile, serializeHotkeyFile, type HotkeyBindingLimitOptions, type HotkeyDefinition, type HotkeyFile } from "./bindings";
+export interface HotkeyStoreOptions<Id extends string> extends HotkeyBindingLimitOptions {
+  definitions: readonly HotkeyDefinition<Id>[];
+  path: string;
+  storage?: SettingsStorage;
+  debounceMs?: number;
+}
+export async function createHotkeyStore<Id extends string>(options: HotkeyStoreOptions<Id>): Promise<ObservableFile<HotkeyFile<Id>>> {
+  if (!options || typeof options !== "object" || Array.isArray(options)) throw new SparkError("E_INVALID_ARGUMENT", "Expected hotkey store options");
+  for (const key of Object.keys(options)) if (!["definitions", "path", "maxBindingsPerCommand", "storage", "debounceMs"].includes(key)) throw new SparkError("E_UNSUPPORTED_OPTION", `Unknown hotkey store option: ${key}`);
+  const { definitions, path, maxBindingsPerCommand, storage, debounceMs } = options;
+  const limit = { maxBindingsPerCommand };
+  const initialValue = normalizeHotkeyFile(undefined, definitions, limit);
+  const snapshot = definitions.map(definition => ({ ...definition, defaultBindings: [...definition.defaultBindings] }));
+  const { createObservableFile } = await import("@legendapp/spark-settings/src/storage");
+  return createObservableFile({ path, initialValue, storage, debounceMs, decode: value => normalizeHotkeyFile(value, snapshot, limit), encode: value => serializeHotkeyFile(value, snapshot, limit) });
+}

package/vendor/node_modules/@legendapp/spark-context-menu/macos/RNContextMenu.mm

@@ -47,6 +47,13 @@ RCT_EXPORT_MODULE(NativeContextMenu)
   RCTExecuteOnMainQueue(^{
     NSArray *items = [self parseJSON:itemsJson fallback:@[]];
     NSDictionary *location = [self parseJSON:locationJson fallback:@{}];
+    NSString *windowId = [location[@"windowId"] isKindOfClass:NSString.class] ? location[@"windowId"] : @"";
+    NSWindow *window = nil;
+    NSString *identifier = [@"spark." stringByAppendingString:windowId];
+    for (NSWindow *candidate in NSApp.windows) if ([candidate.identifier isEqual:identifier]) { window = candidate; break; }
+    if (!window) for (NSWindow *candidate in NSApp.windows) if ([candidate.identifier isEqual:windowId]) { window = candidate; break; }
+    NSView *targetView = window.contentView;
+    if (!targetView) { reject(@"E_NOT_FOUND", @"Context menu owner window does not exist", nil); return; }
     if (![items isKindOfClass:[NSArray class]] || items.count == 0) {
       resolve(@"");
       return;
@@ -87,14 +94,6 @@ RCT_EXPORT_MODULE(NativeContextMenu)
       return;
     }
 
-    NSWindow *window = NSApp.keyWindow ?: NSApp.mainWindow;
-    NSView *targetView = window.contentView;
-    if (!targetView) {
-      self.pendingResolve(@"");
-      self.pendingResolve = nil;
-      return;
-    }
-
     double x = [location[@"x"] isKindOfClass:[NSNumber class]] ? [location[@"x"] doubleValue] : 0;
     double y = [location[@"y"] isKindOfClass:[NSNumber class]] ? [location[@"y"] doubleValue] : 0;
     NSPoint point = NSMakePoint(x, y);

package/vendor/node_modules/@legendapp/spark-context-menu/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@legendapp/spark-context-menu",
-  "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": {
         "NativeContextMenu": "RNContextMenu"
-      }
+      },
+      "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-context-menu/src/NativeContextMenu.ts

@@ -5,4 +5,4 @@ export interface Spec extends TurboModule {
   showMenu(itemsJson: string, locationJson: string): Promise<string>;
 }
 
-export default TurboModuleRegistry.getEnforcing<Spec>("NativeContextMenu");
+export default TurboModuleRegistry.get<Spec>("NativeContextMenu");

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

@@ -1,29 +1,29 @@
 import { Platform } from "react-native";
 import NativeContextMenu from "./NativeContextMenu";
-
-export type ContextMenuItem = {
-  id: string;
-  title: string;
-  enabled?: boolean;
-  checked?: boolean;
-  separator?: boolean;
-};
-
-export type ContextMenuLocation = {
-  x: number;
-  y: number;
-};
-
-export async function showContextMenu(items: ContextMenuItem[], location: ContextMenuLocation) {
-  if (Platform.OS !== "macos" && Platform.OS !== "windows") {
-    return null;
-  }
-
-  if (!Number.isFinite(location.x) || !Number.isFinite(location.y)) throw new Error("Menu location must be finite");
-  const ids = items.filter(item => !item.separator).map(item => item.id);
-  if (new Set(ids).size !== ids.length) throw new Error("Context menu ids must be unique");
-  const result = await NativeContextMenu.showMenu(JSON.stringify(items), JSON.stringify(location));
-  return result.length > 0 ? result : null;
+import { SparkError, invokeNative, type Availability } from "@legendapp/spark-desktop-app/src/contracts";
+import { menuItems, selectableMenuIds, type MenuItem as SharedMenuItem, type MenuAction as SharedMenuAction } from "@legendapp/spark-desktop-app/src/contracts/menu";
+type ContextMenuEntry = { id: string; label: string; disabled?: boolean; hidden?: boolean };
+export type MenuItem = { type: "separator" } | (ContextMenuEntry & { type: "action" }) | (ContextMenuEntry & { type: "checkbox"; checked: boolean });
+export type MenuAction = Extract<SharedMenuAction, { type: "action" }>;
+export type { MenuIcon } from "@legendapp/spark-desktop-app/src/contracts/menu";
+export interface ContextMenuOptions { items: readonly MenuItem[]; windowId: string; position: { x: number; y: number } }
+export type ContextMenuResult = { canceled: true } | { canceled: false; itemId: string };
+export function getContextMenuAvailability(): Availability {
+  if (Platform.OS !== "macos" && Platform.OS !== "windows") return { available: false, reason: "unsupported-platform" };
+  return NativeContextMenu ? { available: true } : { available: false, reason: "missing-module" };
+}
+/** Owner-content logical coordinates. Empty menus cancel; missing owners reject. */
+export async function showContextMenu(options: ContextMenuOptions): Promise<ContextMenuResult> {
+  if (!options || typeof options !== "object" || Array.isArray(options)) throw new SparkError("E_INVALID_ARGUMENT", "Expected context menu options");
+  for (const key of Object.keys(options)) if (!["items", "windowId", "position"].includes(key)) throw new SparkError("E_UNSUPPORTED_OPTION", `Unsupported context menu option: ${key}`);
+  if (typeof options.windowId !== "string" || !/^[a-zA-Z0-9_-]{1,100}$/.test(options.windowId)) throw new SparkError("E_INVALID_ARGUMENT", "Expected an owner windowId");
+  if (!options.position || typeof options.position !== "object" || Object.keys(options.position).some(key => key !== "x" && key !== "y") || !Number.isFinite(options.position.x) || !Number.isFinite(options.position.y) || Math.abs(options.position.x) > 1000000 || Math.abs(options.position.y) > 1000000) throw new SparkError("E_INVALID_ARGUMENT", "Menu position must be finite logical coordinates within one million units");
+  const availability = getContextMenuAvailability();
+  if (!availability.available) throw new SparkError(availability.reason === "unsupported-platform" ? "E_UNSUPPORTED_PLATFORM" : "E_MODULE_UNAVAILABLE", "Context menus are unavailable");
+  const items = menuItems(options.items, { types: ["action", "checkbox", "separator"] }, Platform.OS === "windows" ? "windows" : "macos");
+  const ids = selectableMenuIds(items);
+  const result = await invokeNative(() => NativeContextMenu!.showMenu(JSON.stringify(items), JSON.stringify({ ...options.position, windowId: options.windowId })));
+  if (result === "") return { canceled: true };
+  if (typeof result !== "string" || !ids.has(result)) throw new SparkError("E_INVALID_DATA", "Context menu returned an unknown or disabled item");
+  return { canceled: false, itemId: result };
 }
-
-export { default as NativeContextMenu } from "./NativeContextMenu";

package/vendor/node_modules/@legendapp/spark-context-menu/windows/SparkContextMenu/SparkContextMenu.h

@@ -76,8 +76,9 @@ struct SparkContextMenu {
         if (current->stopped) { current->busy = false; promise.Resolve(""); return; }
         auto items = Json::JsonArray::Parse(to_hstring(encoded));
         auto position = Json::JsonObject::Parse(to_hstring(location));
-        auto owner = Parent(L"", false);
-        if (!owner || items.Size() == 0) { current->busy = false; promise.Resolve(""); return; }
+        auto owner = Parent(std::wstring(position.GetNamedString(L"windowId")), true);
+        if (!owner) { current->busy = false; promise.Reject(React::ReactError{"E_NOT_FOUND", "Context menu owner window does not exist"}); return; }
+        if (items.Size() == 0) { current->busy = false; promise.Resolve(""); return; }
         if (!IsWindowEnabled(owner)) { current->busy = false; promise.Reject(React::ReactError{"E_BUSY", "Menu parent has a modal operation"}); return; }
         const double x = position.GetNamedNumber(L"x"), y = position.GetNamedNumber(L"y");
         const double scale = static_cast<double>(GetDpiForWindow(owner)) / 96.0;

package/vendor/node_modules/@legendapp/spark-desktop-app/RNDesktopApp.podspec

@@ -9,7 +9,8 @@ Pod::Spec.new do |s|
   s.homepage = "https://legendapp.com"
   s.source = { :path => "." }
   s.platforms = { :osx => "14.0" }
-  s.source_files = "macos/**/*.{h,m,mm}"
+  s.source_files = "macos/**/*.{h,m,mm}", "cpp/**/*.hpp"
+  s.pod_target_xcconfig = { "CLANG_CXX_LANGUAGE_STANDARD" => "c++20" }
   s.dependency "React-Core"
   s.dependency "ReactCodegen"
 end

package/vendor/node_modules/@legendapp/spark-desktop-app/cpp/SparkBinaryJSI.hpp

@@ -0,0 +1,89 @@
+#pragma once
+#ifdef __cplusplus
+#include <jsi/jsi.h>
+#include <ReactCommon/CallInvoker.h>
+#include <react/bridging/CallbackWrapper.h>
+#include <atomic>
+#include <functional>
+#include <cstring>
+#include <cmath>
+#include <optional>
+#include <map>
+#include <vector>
+
+namespace spark::binary {
+namespace jsi = facebook::jsi;
+using Builder = std::function<jsi::Value(jsi::Runtime &)>;
+using Completion = std::function<void(Builder, std::string, std::string)>;
+using Start = std::function<void(std::string, std::string, std::optional<std::vector<uint8_t>>, Completion)>;
+
+class Bytes final : public jsi::MutableBuffer {
+public:
+  explicit Bytes(std::vector<uint8_t> value) : value_(std::move(value)) { if (value_.empty()) value_.reserve(1); }
+  size_t size() const override { return value_.size(); }
+  uint8_t *data() override { return value_.data(); }
+private:
+  std::vector<uint8_t> value_;
+};
+inline jsi::Value Buffer(jsi::Runtime &rt, std::shared_ptr<jsi::MutableBuffer> const &bytes) { return jsi::ArrayBuffer(rt, bytes); }
+inline Builder JSON(std::string value) {
+  return [value = std::move(value)](jsi::Runtime &rt) { auto json = rt.global().getPropertyAsObject(rt, "JSON"); return json.getPropertyAsFunction(rt, "parse").callWithThis(rt, json, jsi::String::createFromUtf8(rt, value)); };
+}
+struct Response {
+  std::string json = "null";
+  std::shared_ptr<jsi::MutableBuffer> bytes;
+  std::map<std::string, std::shared_ptr<jsi::MutableBuffer>> fields;
+  Builder Build() const {
+    return [value = *this](jsi::Runtime &rt) {
+      if (value.bytes) return Buffer(rt, value.bytes);
+      auto result = JSON(value.json)(rt);
+      if (!value.fields.empty()) { auto object = result.asObject(rt); for (auto const &[key, bytes] : value.fields) object.setProperty(rt, key.c_str(), Buffer(rt, bytes)); return jsi::Value(std::move(object)); }
+      return result;
+    };
+  }
+};
+// Uses React's runtime-owned callbacks; pending native work never retains a JS
+// function after runtime teardown. Only the invoker accesses the owning runtime.
+inline jsi::Value Promise(jsi::Runtime &rt, std::shared_ptr<facebook::react::CallInvoker> invoker, std::function<void(Completion)> start) {
+  auto executor = jsi::Function::createFromHostFunction(rt, jsi::PropNameID::forAscii(rt, "executor"), 2,
+    [invoker, start = std::move(start)](jsi::Runtime &rt, const jsi::Value &, const jsi::Value *args, size_t) {
+      auto resolve = facebook::react::CallbackWrapper::createWeak(args[0].asObject(rt).asFunction(rt), rt, invoker);
+      auto reject = facebook::react::CallbackWrapper::createWeak(args[1].asObject(rt).asFunction(rt), rt, invoker);
+      auto settled = std::make_shared<std::atomic<bool>>(false);
+      Completion finish = [resolve, reject, invoker, settled](Builder build, std::string code, std::string message) {
+        if (settled->exchange(true)) return;
+        invoker->invokeAsync([resolve, reject, build = std::move(build), code = std::move(code), message = std::move(message)](jsi::Runtime &rt) {
+          auto good = resolve.lock(), bad = reject.lock(); if (!good || !bad) return;
+          if (code.empty()) good->callback().call(rt, build(rt));
+          else { auto error = rt.global().getPropertyAsFunction(rt, "Error").callAsConstructor(rt, jsi::String::createFromUtf8(rt, message)).asObject(rt); error.setProperty(rt, "code", jsi::String::createFromUtf8(rt, code)); bad->callback().call(rt, error); }
+          good->destroy(); bad->destroy();
+        });
+      };
+      try { start(finish); } catch (std::exception const &error) { finish({}, "E_NATIVE", error.what()); }
+      return jsi::Value::undefined();
+    });
+  return rt.global().getPropertyAsFunction(rt, "Promise").callAsConstructor(rt, executor);
+}
+inline jsi::Function Function(jsi::Runtime &rt, std::shared_ptr<facebook::react::CallInvoker> invoker, Start start) {
+  return jsi::Function::createFromHostFunction(rt, jsi::PropNameID::forAscii(rt, "binaryCall"), 5,
+    [invoker, start = std::move(start)](jsi::Runtime &rt, const jsi::Value &, const jsi::Value *args, size_t count) -> jsi::Value {
+      if (count < 2) throw jsi::JSError(rt, "Expected a binary operation and arguments");
+      auto method = args[0].asString(rt).utf8(rt), json = args[1].asString(rt).utf8(rt);
+      std::optional<std::vector<uint8_t>> bytes;
+      if (count > 2 && !args[2].isUndefined()) {
+        if (count < 5) throw jsi::JSError(rt, "Expected a binary buffer offset and length");
+        auto buffer = args[2].asObject(rt).getArrayBuffer(rt); auto offset = args[3].asNumber(), length = args[4].asNumber();
+        if (!std::isfinite(offset) || !std::isfinite(length) || offset < 0 || length < 0 || std::floor(offset) != offset || std::floor(length) != length || offset + length > buffer.size(rt)) throw jsi::JSError(rt, "Invalid binary buffer range");
+        // Snapshot once, before returning to JS. Never touch borrowed JS bytes on
+        // an I/O worker; views retain their exact offset and length.
+        bytes.emplace(static_cast<size_t>(length)); if (length) memcpy(bytes->data(), buffer.data(rt) + static_cast<size_t>(offset), static_cast<size_t>(length));
+      }
+      return Promise(rt, invoker, [start, method = std::move(method), json = std::move(json), bytes = std::move(bytes)](Completion finish) mutable { start(std::move(method), std::move(json), std::move(bytes), std::move(finish)); });
+    });
+}
+inline void Emit(std::shared_ptr<facebook::react::CallInvoker> invoker, Builder build, std::function<void()> delivered = {}) {
+  invoker->invokeAsync([build = std::move(build), delivered = std::move(delivered)](jsi::Runtime &rt) { struct Ack { std::function<void()> done; ~Ack() { if (done) done(); } } ack{delivered}; if (rt.global().getProperty(rt, "__rctDeviceEventEmitter").isUndefined()) return; auto emitter = rt.global().getPropertyAsObject(rt, "__rctDeviceEventEmitter"); emitter.getPropertyAsFunction(rt, "emit").callWithThis(rt, emitter, "desktop", build(rt)); });
+}
+}
+
+#endif

package/vendor/node_modules/@legendapp/spark-desktop-app/cpp/SparkBinaryWindows.hpp

@@ -0,0 +1,22 @@
+#pragma once
+#ifdef _WIN32
+#include "SparkBinaryJSI.hpp"
+#include <JSI/JsiApiContext.h>
+namespace spark::binary {
+struct NativePromise {
+  std::function<void(Response)> resolve;
+  std::function<void(winrt::Microsoft::ReactNative::ReactError)> reject;
+  void Resolve(std::string json) const { resolve(Response{std::move(json), {}, {}}); }
+  void Resolve(Response value) const { resolve(std::move(value)); }
+  void Reject(winrt::Microsoft::ReactNative::ReactError value) const { reject(std::move(value)); }
+  NativePromise(Completion finish) : resolve([finish](Response value) { finish(value.Build(), {}, {}); }), reject([finish](auto error) { finish({}, error.Code, error.Message); }) {}
+  NativePromise(winrt::Microsoft::ReactNative::ReactPromise<std::string> promise) : resolve([promise](Response value) { promise.Resolve(value.json); }), reject([promise](auto error) { promise.Reject(error); }) {}
+};
+inline void Install(winrt::Microsoft::ReactNative::ReactContext context, const char *name, Start start) {
+  auto handle = context.Handle().JSRuntime(); if (!handle) throw std::runtime_error("The Windows runtime does not expose JSI");
+  auto &runtime = winrt::Microsoft::ReactNative::GetOrCreateContextRuntime(context, handle);
+  runtime.global().setProperty(runtime, name, Function(runtime, context.CallInvoker(), std::move(start)));
+}
+}
+
+#endif

package/vendor/node_modules/@legendapp/spark-desktop-app/macos/RNDesktopApp.mm

@@ -1,8 +1,7 @@
 #import "RNDesktopApp.h"
 #import "SparkDesktop.h"
-extern void SparkSetQuitGuard(BOOL value);
-extern void SparkReplyQuit(BOOL allow, NSUInteger generation);
-@implementation RNDesktopApp
+@implementation RNDesktopApp { NSMutableSet<NSString *> *_guardIds; }
+- (instancetype)init { if ((self = [super init])) _guardIds = [NSMutableSet new]; return self; }
 RCT_EXPORT_MODULE(NativeDesktopApp)
 + (BOOL)requiresMainQueueSetup { return YES; }
 - (dispatch_queue_t)methodQueue { return dispatch_get_main_queue(); }
@@ -10,19 +9,26 @@ RCT_EXPORT_MODULE(NativeDesktopApp)
 - (void)startObserving { [NSNotificationCenter.defaultCenter addObserver:self selector:@selector(event:) name:SparkDesktopEvent object:nil]; }
 - (void)stopObserving { [NSNotificationCenter.defaultCenter removeObserver:self]; }
 - (void)event:(NSNotification *)note { [self sendEventWithName:@"desktop" body:note.userInfo]; }
-- (void)invalidate { [self stopObserving]; dispatch_async(dispatch_get_main_queue(), ^{ SparkSetQuitGuard(NO); }); [super invalidate]; }
+- (void)invalidate { [self stopObserving]; dispatch_async(dispatch_get_main_queue(), ^{ for (NSString *identifier in self->_guardIds) SparkSetQuitGuard(identifier, NO); [self->_guardIds removeAllObjects]; }); [super invalidate]; }
 - (void)call:(NSString *)method args:(NSString *)json resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {
   dispatch_async(dispatch_get_main_queue(), ^{
     NSDictionary *args = SparkArgs(json);
     if ([method isEqual:@"context"]) resolve(SparkJSON(SparkContext()));
     else if ([method isEqual:@"initialURL"]) resolve(SparkJSON(SparkInitialURL()));
     else if ([method isEqual:@"pendingURLs"]) resolve(SparkJSON(SparkPendingURLs()));
-    else if ([method isEqual:@"quit"]) { resolve(@"null");
+    else if ([method isEqual:@"quit"]) {
+      SparkObserveQuitDecision(^(BOOL allow) { resolve(SparkJSON(allow ? @{ @"quitRequested": @YES } : @{ @"quitRequested": @NO, @"reason": @"vetoed" })); });
       // AppKit can enter a modal run loop while awaiting the JS decision. Do
       // not hold the main GCD queue that must deliver that decision.
       [NSRunLoop.mainRunLoop performBlock:^{ [NSApp terminate:nil]; }]; }
-    else if ([method isEqual:@"quitGuard"]) { SparkSetQuitGuard([args[@"enabled"] boolValue]); resolve(@"null"); }
-    else if ([method isEqual:@"replyQuit"]) { SparkReplyQuit([args[@"allow"] boolValue], [args[@"requestId"] unsignedIntegerValue]); resolve(@"null"); }
+    else if ([method isEqual:@"quitGuard"]) {
+      NSString *identifier = args[@"id"];
+      if (![identifier isKindOfClass:NSString.class] || !identifier.length) { SparkInvalid(reject, @"Expected quit guard ID"); return; }
+      BOOL enabled = [args[@"enabled"] boolValue];
+      if (enabled) [self->_guardIds addObject:identifier]; else [self->_guardIds removeObject:identifier];
+      SparkSetQuitGuard(identifier, enabled); resolve(@"null");
+    }
+    else if ([method isEqual:@"replyQuit"]) { SparkReplyQuit(args[@"id"], [args[@"allow"] boolValue], [args[@"requestId"] unsignedIntegerValue]); resolve(@"null"); }
     else if ([method isEqual:@"hide"]) { [NSApp hide:nil]; resolve(@"null"); }
     else if ([method isEqual:@"activate"]) { [NSApp activateIgnoringOtherApps:YES]; resolve(@"null"); }
     else SparkInvalid(reject, @"Unknown app operation");

package/vendor/node_modules/@legendapp/spark-desktop-app/macos/SparkBinaryJSI.h

@@ -0,0 +1,48 @@
+#pragma once
+#import <Foundation/Foundation.h>
+#import <React/RCTBridgeModule.h>
+#include <RNDesktopApp/SparkBinaryJSI.hpp>
+
+@protocol SparkBinaryModule <NSObject>
+- (void)binaryCall:(NSString *)method args:(NSString *)json bytes:(NSData *)bytes resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject;
+@end
+#ifdef __cplusplus
+namespace spark::binary {
+class Data final : public facebook::jsi::MutableBuffer {
+public:
+  explicit Data(NSData *value) : value_([value isKindOfClass:NSMutableData.class] ? (NSMutableData *)value : [value mutableCopy]) {}
+  size_t size() const override { return value_.length; }
+  uint8_t *data() override { return static_cast<uint8_t *>(value_.mutableBytes); }
+private:
+  NSMutableData *__strong value_;
+};
+inline jsi::Value Value(jsi::Runtime &rt, id value) {
+  if (!value || value == NSNull.null) return jsi::Value::null();
+  if ([value isKindOfClass:NSData.class]) return Buffer(rt, std::make_shared<Data>(value));
+  if ([value isKindOfClass:NSString.class]) return jsi::String::createFromUtf8(rt, [value UTF8String]);
+  if ([value isKindOfClass:NSNumber.class]) { if (CFGetTypeID((__bridge CFTypeRef)value) == CFBooleanGetTypeID()) return jsi::Value([value boolValue]); return jsi::Value([value doubleValue]); }
+  if ([value isKindOfClass:NSArray.class]) { jsi::Array result(rt, [value count]); size_t index = 0; for (id item in value) result.setValueAtIndex(rt, index++, Value(rt, item)); return result; }
+  jsi::Object result(rt); for (NSString *key in value) result.setProperty(rt, key.UTF8String, Value(rt, value[key])); return result;
+}
+inline Start ObjectiveC(id<SparkBinaryModule> module) {
+  return [module](std::string method, std::string json, std::optional<std::vector<uint8_t>> bytes, Completion finish) {
+    NSData *input = nil;
+    if (bytes && bytes->empty()) input = [NSData data];
+    else if (bytes) { auto owned = new std::vector<uint8_t>(std::move(*bytes)); input = [[NSData alloc] initWithBytesNoCopy:owned->data() length:owned->size() deallocator:^(void *, NSUInteger) { delete owned; }]; }
+    [module binaryCall:[NSString stringWithUTF8String:method.c_str()] args:[NSString stringWithUTF8String:json.c_str()] bytes:input
+      resolve:^(id value) { finish([value](jsi::Runtime &rt) { return Value(rt, value); }, {}, {}); }
+      reject:^(NSString *code, NSString *message, NSError *) { finish({}, code.UTF8String ?: "E_NATIVE", message.UTF8String ?: "Native operation failed"); }];
+  };
+}
+template <class Spec> class Module final : public Spec {
+public:
+  Module(const facebook::react::ObjCTurboModule::InitParams &params) : Spec(params) { this->methodMap_["binaryCall"] = {5, nullptr}; }
+protected:
+  jsi::Value create(jsi::Runtime &rt, const jsi::PropNameID &name) override {
+    if (name.utf8(rt) == "binaryCall") return Function(rt, this->jsInvoker_, ObjectiveC((id<SparkBinaryModule>)this->instance_));
+    return Spec::create(rt, name);
+  }
+};
+}
+
+#endif

package/vendor/node_modules/@legendapp/spark-desktop-app/macos/SparkDesktop.h

@@ -1,4 +1,5 @@
 #import <AppKit/AppKit.h>
+#import "SparkLifecycle.h"
 #import <React/RCTBridgeModule.h>
 
 FOUNDATION_EXPORT NSString * const SparkDesktopEvent;
@@ -12,6 +13,9 @@ FOUNDATION_EXPORT NSArray *SparkPendingURLs(void);
 FOUNDATION_EXPORT NSString *SparkInitialURL(void);
 FOUNDATION_EXPORT void SparkMarkLaunchComplete(void);
 FOUNDATION_EXPORT NSApplicationTerminateReply SparkShouldQuit(void);
+FOUNDATION_EXPORT void SparkObserveQuitDecision(SparkQuitReply observer);
+FOUNDATION_EXPORT void SparkSetQuitGuard(NSString *identifier, BOOL value);
+FOUNDATION_EXPORT void SparkReplyQuit(NSString *identifier, BOOL allow, NSUInteger generation);
 FOUNDATION_EXPORT NSString *SparkJSON(id value);
 FOUNDATION_EXPORT NSDictionary *SparkArgs(NSString *json);
 FOUNDATION_EXPORT void SparkReject(RCTPromiseRejectBlock reject, NSError *error);