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

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

@@ -1,7 +1,20 @@
-import { open } from "@op-engineering/op-sqlite";
-import { getDirectory } from "@legendapp/spark-file-system";
-export type { DB, QueryResult } from "@op-engineering/op-sqlite";
-export async function openDatabase(name: string) {
-  if (!/^[a-zA-Z0-9_-]+\.sqlite$/.test(name)) throw new Error("Database name must be a simple .sqlite filename");
-  return open({ name, location: await getDirectory("data") });
+import { SparkError } from "@legendapp/spark-desktop-app/src/contracts";
+import { createDatabase } from "./database";
+import type { Database, DatabaseOptions } from "./types";
+export type { Database, DatabaseOptions, IntegerMode, SqlExecutor, SqlRow, SqlValue, RunResult } from "./types";
+
+/**
+ * Open a project-scoped database. Backends deliver INTEGER values as JS numbers, so
+ * `integers: "text"` reads values outside 2^53−1 as text instead of rejecting them;
+ * exact digits beyond the double's precision still require `CAST(col AS TEXT)`.
+ */
+export async function openDatabase(name: string, options: DatabaseOptions = {}): Promise<Database> {
+  if (!/^[a-zA-Z0-9_-]+\.sqlite$/.test(name)) throw new SparkError("E_INVALID_ARGUMENT", "Database name must be a simple .sqlite filename");
+  if (!options || typeof options !== "object" || Array.isArray(options)) throw new SparkError("E_INVALID_ARGUMENT", "Expected database options");
+  for (const key of Object.keys(options)) if (key !== "readOnly" && key !== "integers") throw new SparkError("E_UNSUPPORTED_OPTION", `Unsupported database option: ${key}`);
+  if (options.readOnly !== undefined && typeof options.readOnly !== "boolean") throw new SparkError("E_INVALID_ARGUMENT", "readOnly must be a boolean");
+  if (options.integers !== undefined && options.integers !== "number" && options.integers !== "text") throw new SparkError("E_INVALID_ARGUMENT", "integers must be number or text");
+  const [{ open }, { getDirectory }] = await Promise.all([import("@op-engineering/op-sqlite"), import("@legendapp/spark-file-system")]);
+  const native = open({ name, location: await getDirectory("data"), readOnly: options.readOnly });
+  return createDatabase({ execute: (sql, params) => native.execute(sql, params as import("@op-engineering/op-sqlite").Scalar[]), close: () => native.close() }, options.integers ?? "number");
 }

package/vendor/node_modules/@legendapp/spark-sqlite/src/types.ts

@@ -0,0 +1,22 @@
+export type SqlValue = null | string | number | Uint8Array;
+export type SqlRow = Record<string, SqlValue>;
+export type IntegerMode = "number" | "text";
+export type RunResult = {
+  changes: number;
+  /** Connection's last insert row ID; null when the backend omits it. Text in `integers: "text"` mode. */
+  lastInsertRowId: number | string | null;
+};
+export interface SqlExecutor {
+  run(sql: string, params?: readonly SqlValue[]): Promise<RunResult>;
+  getAll(sql: string, params?: readonly SqlValue[]): Promise<SqlRow[]>;
+  getFirst(sql: string, params?: readonly SqlValue[]): Promise<SqlRow | null>;
+}
+export interface Database extends SqlExecutor {
+  /** Row mode chosen at open. Text rows carry integers beyond 2^53−1 as strings. */
+  readonly integers: IntegerMode;
+  /** Use tx inside the callback. Direct database operations reject while a transaction is active. */
+  transaction<T>(operation: (tx: SqlExecutor) => Promise<T>): Promise<T>;
+  /** Waits for already queued work. Repeated calls share completion. */
+  close(): Promise<void>;
+}
+export type DatabaseOptions = { readOnly?: boolean; integers?: IntegerMode };

package/vendor/node_modules/@legendapp/spark-system/macos/RNDesktopSystem.mm

@@ -23,6 +23,7 @@ static NSDictionary *Power(void) {
 static void PowerChanged(void *context) { SparkEmit(@{ @"type": @"powerChanged" }); }
 @interface RNDesktopSystem ()
 @property NSMutableArray *observers;
+@property NSMutableSet *subscriptions;
 @property NSMutableSet *assertions;
 @property NSMutableSet *attention;
 @property CFRunLoopSourceRef powerSource;
@@ -32,7 +33,7 @@ static void PowerChanged(void *context) { SparkEmit(@{ @"type": @"powerChanged"
 @implementation RNDesktopSystem
 RCT_EXPORT_MODULE(NativeDesktopSystem)
 + (BOOL)requiresMainQueueSetup { return YES; }
-- (instancetype)init { if (self = [super init]) { _observers = [NSMutableArray new]; _assertions = [NSMutableSet new]; _attention = [NSMutableSet new]; } return self; }
+- (instancetype)init { if (self = [super init]) { _observers = [NSMutableArray new]; _subscriptions = [NSMutableSet new]; _assertions = [NSMutableSet new]; _attention = [NSMutableSet new]; } return self; }
 - (void)observe {
   if (self.observing) return; self.observing = YES;
   NSArray *definitions = @[
@@ -51,18 +52,45 @@ RCT_EXPORT_MODULE(NativeDesktopSystem)
   self.powerSource = IOPSNotificationCreateRunLoopSource(PowerChanged, NULL);
   if (self.powerSource) CFRunLoopAddSource(CFRunLoopGetMain(), self.powerSource, kCFRunLoopCommonModes);
 }
-- (void)dockAction:(NSMenuItem *)sender { SparkEmit(@{ @"type": @"dockAction", @"id": sender.representedObject, @"owner": self.dockOwner ?: @"" }); }
+- (void)stopObserving {
+  for (NSArray *entry in self.observers) [entry[0] removeObserver:entry[1]];
+  [self.observers removeAllObjects]; self.observing = NO;
+  if (self.powerSource) { CFRunLoopRemoveSource(CFRunLoopGetMain(), self.powerSource, kCFRunLoopCommonModes); CFRelease(self.powerSource); self.powerSource = NULL; }
+}
+- (NSMenu *)menu:(NSArray *)items {
+  NSMenu *menu = [NSMenu new]; menu.autoenablesItems = NO;
+  for (NSDictionary *item in items) {
+    if ([item[@"separator"] boolValue]) { [menu addItem:NSMenuItem.separatorItem]; continue; }
+    NSMenuItem *entry = [[NSMenuItem alloc] initWithTitle:item[@"title"] action:@selector(dockAction:) keyEquivalent:@""];
+    entry.target = self; entry.representedObject = @{ @"id": item[@"id"], @"owner": self.dockOwner };
+    entry.enabled = !item[@"enabled"] || [item[@"enabled"] boolValue];
+    entry.state = [item[@"checked"] boolValue] ? NSControlStateValueOn : NSControlStateValueOff;
+    if (item[@"items"]) entry.submenu = [self menu:item[@"items"]];
+    [menu addItem:entry];
+  }
+  return menu;
+}
+- (void)dockAction:(NSMenuItem *)sender { SparkEmit(@{ @"type": @"dockAction", @"id": sender.representedObject[@"id"], @"owner": sender.representedObject[@"owner"] }); }
 - (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:@"info"]) {
       NSMutableDictionary *value = [Power() mutableCopy];
-      [value addEntriesFromDictionary:@{ @"osVersion": NSProcessInfo.processInfo.operatingSystemVersionString, @"architecture": @"arm64", @"locale": NSLocale.currentLocale.localeIdentifier,
+      [value addEntriesFromDictionary:@{ @"osVersion": NSProcessInfo.processInfo.operatingSystemVersionString, @"architecture":
+#if defined(__arm64__)
+        @"arm64",
+#elif defined(__x86_64__)
+        @"x64",
+#else
+        @"unknown",
+#endif
+        @"locale": NSLocale.currentLocale.localeIdentifier,
         @"dark": @([[NSApp.effectiveAppearance bestMatchFromAppearancesWithNames:@[NSAppearanceNameAqua, NSAppearanceNameDarkAqua]] isEqual:NSAppearanceNameDarkAqua]),
         @"idleSeconds": @(CGEventSourceSecondsSinceLastEventType(kCGEventSourceStateCombinedSessionState, kCGAnyInputEventType)) }];
       resolve(SparkJSON(value)); return;
     }
-    if ([method isEqual:@"observe"]) [self observe];
+    if ([method isEqual:@"observe"]) { [self.subscriptions addObject:args[@"id"]]; [self observe]; }
+    else if ([method isEqual:@"unobserve"]) { [self.subscriptions removeObject:args[@"id"]]; if (!self.subscriptions.count) [self stopObserving]; }
     else if ([method isEqual:@"loginStatus"] || [method isEqual:@"login"]) {
       BOOL available = [SparkContext()[@"runtime"][@"mode"] isEqual:@"release"];
       if ([method isEqual:@"loginStatus"]) {
@@ -80,11 +108,9 @@ RCT_EXPORT_MODULE(NativeDesktopSystem)
     else if ([method isEqual:@"cancelAttention"]) { if ([self.attention containsObject:args[@"id"]]) [NSApp cancelUserAttentionRequest:[args[@"id"] integerValue]]; [self.attention removeObject:args[@"id"]]; }
     else if ([method isEqual:@"clearDockMenu"]) { if ([self.dockOwner isEqual:args[@"owner"]]) { SparkDockMenu = nil; self.dockOwner = nil; } }
     else if ([method isEqual:@"dockMenu"]) {
-      if (self.dockOwner) { reject(@"E_DOCK_MENU_EXISTS", @"Remove the existing Dock menu before replacing it", nil); return; }
+      if (self.dockOwner) { reject(@"E_ALREADY_EXISTS", @"Remove the existing Dock menu before replacing it", nil); return; }
       self.dockOwner = args[@"owner"];
-      NSMenu *menu = [NSMenu new]; menu.autoenablesItems = NO;
-      for (NSDictionary *item in args[@"items"]) { NSMenuItem *entry = [[NSMenuItem alloc] initWithTitle:item[@"title"] action:@selector(dockAction:) keyEquivalent:@""]; entry.target = self; entry.representedObject = item[@"id"]; entry.enabled = !item[@"enabled"] || [item[@"enabled"] boolValue]; entry.state = [item[@"checked"] boolValue] ? NSControlStateValueOn : NSControlStateValueOff; [menu addItem:entry]; }
-      SparkDockMenu = menu;
+      SparkDockMenu = [self menu:args[@"items"]];
     }
     else if ([method isEqual:@"preventSleep"]) {
       IOPMAssertionID assertion; CFStringRef kind = [args[@"kind"] isEqual:@"system"] ? kIOPMAssertionTypePreventUserIdleSystemSleep : kIOPMAssertionTypePreventUserIdleDisplaySleep;
@@ -92,14 +118,13 @@ RCT_EXPORT_MODULE(NativeDesktopSystem)
       if (status != kIOReturnSuccess) { reject(@"E_POWER", @"Could not create sleep assertion", nil); return; }
       [self.assertions addObject:@(assertion)]; resolve(SparkJSON(@(assertion))); return;
     }
-    else if ([method isEqual:@"allowSleep"]) { if ([self.assertions containsObject:args[@"id"]]) IOPMAssertionRelease([args[@"id"] unsignedIntValue]); [self.assertions removeObject:args[@"id"]]; }
+    else if ([method isEqual:@"allowSleep"]) { if ([self.assertions containsObject:args[@"id"]] && IOPMAssertionRelease([args[@"id"] unsignedIntValue]) != kIOReturnSuccess) { reject(@"E_NATIVE", @"Could not release sleep assertion", nil); return; } [self.assertions removeObject:args[@"id"]]; }
     else { SparkInvalid(reject, @"Unknown system operation"); return; }
     resolve(@"null");
   });
 }
 - (void)invalidate { dispatch_async(dispatch_get_main_queue(), ^{
-  for (NSArray *entry in self.observers) [entry[0] removeObserver:entry[1]]; [self.observers removeAllObjects];
-  if (self.powerSource) { CFRunLoopRemoveSource(CFRunLoopGetMain(), self.powerSource, kCFRunLoopCommonModes); CFRelease(self.powerSource); self.powerSource = NULL; }
+  [self stopObserving]; [self.subscriptions removeAllObjects];
   for (NSNumber *value in self.assertions) IOPMAssertionRelease(value.unsignedIntValue); [self.assertions removeAllObjects];
   for (NSNumber *value in self.attention) [NSApp cancelUserAttentionRequest:value.integerValue]; [self.attention removeAllObjects];
   SparkDockMenu = nil; NSApp.dockTile.badgeLabel = nil;

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

@@ -1,6 +1,6 @@
 {
   "name": "@legendapp/spark-system",
-  "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-system/src/NativeDesktopSystem.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>("NativeDesktopSystem");
+export default TurboModuleRegistry.get<Spec>("NativeDesktopSystem");

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

@@ -1,35 +1,92 @@
+import { Platform } from "react-native";
 import Native from "./NativeDesktopSystem";
-import { onDesktopEvent } from "@legendapp/spark-desktop-app";
-export type SystemInfo = { osVersion: string; architecture: string; locale: string; dark: boolean; idleSeconds: number; onBattery: boolean; batteryLevel: number | null };
+import { onDesktopEvent } from "@legendapp/spark-desktop-app/src/events";
+import { SparkError, asyncRegistration, invokeNative, parseNativeResult, type Availability, type AsyncRegistration } from "@legendapp/spark-desktop-app/src/contracts";
+import { menuItems, selectableMenuIds, type MenuItem } from "@legendapp/spark-desktop-app/src/contracts/menu";
+export type { AsyncRegistration } from "@legendapp/spark-desktop-app/src/contracts";
+type SupportedDockLeaf = Exclude<MenuItem, { type: "submenu" | "role" | "slider" }> extends infer Item
+  ? Item extends unknown ? Omit<Item, "target" | "placement" | "icon" | "shortcut" | "hidden"> : never
+  : never;
+export type DockMenuItem = SupportedDockLeaf | (Omit<Extract<MenuItem, { type: "submenu" }>, "items" | "target" | "placement" | "icon" | "shortcut" | "hidden"> & { items: readonly DockMenuItem[] });
+type SupportedTaskbarLeaf = Extract<MenuItem, { type: "action" | "checkbox" }> extends infer Item
+  ? Item extends unknown ? Omit<Item, "target" | "placement" | "icon" | "shortcut" | "hidden" | "disabled"> & { disabled?: false } : never
+  : never;
+export type TaskbarMenuItem = SupportedTaskbarLeaf;
+type LauncherMenuOptions = { items: readonly MenuItem[]; onAction: (event: { type: "action"; itemId: string }) => void };
+export interface DockMenuOptions { items: readonly DockMenuItem[]; onAction: (event: { type: "action"; itemId: string }) => void }
+export interface TaskbarMenuOptions { items: readonly TaskbarMenuItem[]; onAction: (event: { type: "action"; itemId: string }) => void }
+export interface SystemInfo { osVersion: string; architecture: string; locale: string; dark: boolean; idleSeconds: number; onBattery: boolean; batteryLevel: number | null }
 export type SystemEvent = { type: "sleep" | "wake" | "lock" | "unlock" | "powerChanged" | "appearanceChanged" | "displaysChanged" };
-export type DockMenuItem = { id: string; title: string; enabled?: boolean; checked?: boolean };
-async function call<T = void>(method: string, args: object = {}): Promise<T> { return JSON.parse(await Native.call(method, JSON.stringify(args))); }
-export const getSystemInfo = () => call<SystemInfo>("info");
-export const getLoginItemStatus = () => call<"enabled" | "disabled" | "requiresApproval" | "notFound" | "unavailable">("loginStatus");
-export const setLaunchAtLogin = (enabled: boolean) => call("login", { enabled });
-export const setDockBadge = (label: string) => call("badge", { label });
-export async function requestAttention(critical = false) {
-  const id = await call<number>("attention", { critical });
-  return { remove: () => call("cancelAttention", { id }) };
-}
-export async function preventSleep(reason: string, kind: "display" | "system" = "display") {
-  if (!reason.trim()) throw new Error("A reason is required");
-  const id = await call<number>("preventSleep", { reason, kind }); let removed = false;
-  return { async remove() { if (!removed) { await call("allowSleep", { id }); removed = true; } } };
-}
-let dockSequence = 0;
-export async function setDockMenu(items: DockMenuItem[], handler: (id: string) => void) {
-  const owner = `dock-${Date.now()}-${++dockSequence}`;
-  const ids = new Set<string>();
-  for (const item of items) { if (!item.id || !item.title || ids.has(item.id)) throw new Error("Dock items need unique ids and titles"); ids.add(item.id); }
-  const subscription = onDesktopEvent(event => { if (event.type === "dockAction" && event.owner === owner && typeof event.id === "string") handler(event.id); });
-  try { await call("dockMenu", { items, owner }); } catch (error) { subscription.remove(); throw error; }
-  let removed = false;
-  return { async remove() { if (!removed) { await call("clearDockMenu", { owner }); subscription.remove(); removed = true; } } };
-}
-export async function onSystemEvent(handler: (event: SystemEvent) => void) {
-  const types = ["sleep", "wake", "lock", "unlock", "powerChanged", "appearanceChanged", "displaysChanged"];
-  const subscription = onDesktopEvent(event => { if (types.includes(event.type)) handler(event as SystemEvent); });
-  try { await call("observe"); } catch (error) { subscription.remove(); throw error; }
-  return subscription;
+export type LoginItemStatus = "enabled" | "disabled" | "requiresApproval" | "notFound" | "unavailable";
+export interface AttentionOptions { kind?: "informational" | "critical" }
+export interface PreventSleepOptions { reason: string; kind?: "display" | "system" }
+let sequence = 0;
+const token = () => `system-${Date.now()}-${++sequence}`;
+export function getSystemAvailability(): Availability {
+  if (Platform.OS !== "macos" && Platform.OS !== "windows") return { available: false, reason: "unsupported-platform" };
+  return Native ? { available: true } : { available: false, reason: "missing-module" };
+}
+async function call<T>(method: string, args: object, validate: (value: unknown) => value is T): Promise<T> {
+  const available = getSystemAvailability();
+  if (!available.available) throw new SparkError(available.reason === "unsupported-platform" ? "E_UNSUPPORTED_PLATFORM" : "E_MODULE_UNAVAILABLE", "System APIs are unavailable");
+  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 options(value: object, keys: readonly string[]) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new SparkError("E_INVALID_ARGUMENT", "Expected options");
+  for (const key of Object.keys(value)) if (!keys.includes(key)) throw new SparkError("E_UNSUPPORTED_OPTION", `Unsupported system option: ${key}`);
+}
+function isInfo(value: unknown): value is SystemInfo {
+  if (!value || typeof value !== "object") return false;
+  const info = value as SystemInfo;
+  return [info.osVersion, info.architecture, info.locale].every(value => typeof value === "string" && value.length > 0) && typeof info.dark === "boolean" && typeof info.onBattery === "boolean" && Number.isFinite(info.idleSeconds) && info.idleSeconds >= 0 && (info.batteryLevel === null || (typeof info.batteryLevel === "number" && Number.isFinite(info.batteryLevel) && info.batteryLevel >= 0 && info.batteryLevel <= 1));
+}
+export function getSystemInfo(): Promise<SystemInfo> { return call("info", {}, isInfo); }
+export function getLoginItemStatus(): Promise<LoginItemStatus> { return call("loginStatus", {}, (value): value is LoginItemStatus => typeof value === "string" && ["enabled", "disabled", "requiresApproval", "notFound", "unavailable"].includes(value)); }
+export async function setLaunchAtLogin(enabled: boolean): Promise<void> {
+  if (typeof enabled !== "boolean") throw new SparkError("E_INVALID_ARGUMENT", "Expected enabled boolean");
+  await command("login", { enabled });
+}
+/** Dock badge on macOS, taskbar overlay on Windows; empty string clears it. */
+export async function setAppBadge(label: string): Promise<void> {
+  if (typeof label !== "string" || label.includes("\0")) throw new SparkError("E_INVALID_ARGUMENT", "Expected badge text without NUL");
+  await command("badge", { label });
+}
+export async function requestAttention(value: AttentionOptions = {}): Promise<AsyncRegistration> {
+  options(value, ["kind"]);
+  if (value.kind !== undefined && value.kind !== "informational" && value.kind !== "critical") throw new SparkError("E_INVALID_ARGUMENT", "Unknown attention kind");
+  // AppKit can return a negative request token when no attention is necessary.
+  const id = await call("attention", { critical: value.kind === "critical" }, (value): value is number => typeof value === "number" && Number.isSafeInteger(value));
+  return asyncRegistration(() => {}, () => command("cancelAttention", { id }));
+}
+export async function preventSleep(value: PreventSleepOptions): Promise<AsyncRegistration> {
+  options(value, ["reason", "kind"]);
+  if (typeof value.reason !== "string" || !value.reason.trim() || value.reason.includes("\0")) throw new SparkError("E_INVALID_ARGUMENT", "A reason is required");
+  if (value.kind !== undefined && value.kind !== "display" && value.kind !== "system") throw new SparkError("E_INVALID_ARGUMENT", "Unknown sleep prevention kind");
+  const id = await call("preventSleep", { reason: value.reason, kind: value.kind ?? "display" }, (value): value is number => typeof value === "number" && Number.isSafeInteger(value) && value >= 0);
+  return asyncRegistration(() => {}, () => command("allowSleep", { id }));
+}
+async function createLauncherMenu(value: LauncherMenuOptions, platform: "macos" | "windows"): Promise<AsyncRegistration> {
+  if (Platform.OS !== platform) throw new SparkError("E_UNSUPPORTED_PLATFORM", `${platform === "macos" ? "Dock" : "Taskbar"} menus require ${platform}`);
+  options(value, ["items", "onAction"]);
+  if (typeof value.onAction !== "function") throw new SparkError("E_INVALID_ARGUMENT", "Expected onAction callback");
+  // Jump Lists cannot render native submenus, shortcuts, icons or disabled tasks.
+  const items = menuItems(value.items, { types: platform === "macos" ? ["action", "checkbox", "separator", "submenu"] : ["action", "checkbox"] }, platform);
+  const ids = selectableMenuIds(items), owner = token(), onAction = value.onAction;
+  let stopped = false, ready = false;
+  const subscription = onDesktopEvent(event => {
+    if (ready && !stopped && event.type === "dockAction" && event.owner === owner && typeof event.id === "string" && ids.has(event.id)) onAction({ type: "action", itemId: event.id });
+  }, { types: ["dockAction"], target: { field: "owner", value: owner } });
+  try { await command("dockMenu", { items, owner }); ready = true; } catch (error) { subscription.remove(); throw error; }
+  return asyncRegistration(() => { stopped = true; subscription.remove(); }, () => command("clearDockMenu", { owner }));
+}
+export function createDockMenu(options: DockMenuOptions): Promise<AsyncRegistration> { return createLauncherMenu(options, "macos"); }
+export function createTaskbarMenu(options: TaskbarMenuOptions): Promise<AsyncRegistration> { return createLauncherMenu(options, "windows"); }
+export async function onSystemEvent(handler: (event: SystemEvent) => void): Promise<AsyncRegistration> {
+  if (typeof handler !== "function") throw new SparkError("E_INVALID_ARGUMENT", "Expected system event handler");
+  const types: readonly SystemEvent["type"][] = ["sleep", "wake", "lock", "unlock", "powerChanged", "appearanceChanged", "displaysChanged"];
+  const id = token(); let stopped = false;
+  const subscription = onDesktopEvent(event => { if (!stopped && types.includes(event.type as SystemEvent["type"])) handler({ type: event.type as SystemEvent["type"] }); }, { types });
+  try { await command("observe", { id }); } catch (error) { subscription.remove(); throw error; }
+  return asyncRegistration(() => { stopped = true; subscription.remove(); }, () => command("unobserve", { id }));
 }

package/vendor/node_modules/@legendapp/spark-system/windows/SparkSystem/SparkSystem.h

@@ -2,6 +2,7 @@
 #include "NativeModules.h"
 #include <algorithm>
 #include <map>
+#include <set>
 #include <memory>
 #include <filesystem>
 #include <powrprof.h>
@@ -38,6 +39,7 @@ inline std::wstring AppId() {
 struct SystemState {
   React::ReactContext context;
   HWND hwnd = nullptr; bool observing = false;
+  std::set<std::string> subscriptions;
   uint64_t sequence = 0;
   std::map<uint64_t, std::pair<handle, POWER_REQUEST_TYPE>> requests;
   std::map<uint64_t, bool> attention;
@@ -110,7 +112,7 @@ struct SystemState {
     Json::JsonObject result; auto version = std::stoull(std::wstring(Windows::System::Profile::AnalyticsInfo::VersionInfo().DeviceFamilyVersion()));
     auto number = [&](wchar_t const *key, double value) { result.SetNamedValue(key, Json::JsonValue::CreateNumberValue(value)); };
     result.SetNamedValue(L"osVersion", Json::JsonValue::CreateStringValue(std::to_wstring(version >> 48) + L"." + std::to_wstring((version >> 32) & 0xffff) + L"." + std::to_wstring((version >> 16) & 0xffff)));
-    SYSTEM_INFO info{}; GetNativeSystemInfo(&info); result.SetNamedValue(L"architecture", Json::JsonValue::CreateStringValue(info.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_ARM64 ? L"arm64" : info.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64 ? L"x64" : L"x86"));
+    SYSTEM_INFO info{}; ::GetSystemInfo(&info); result.SetNamedValue(L"architecture", Json::JsonValue::CreateStringValue(info.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_ARM64 ? L"arm64" : info.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64 ? L"x64" : L"x86"));
     wchar_t locale[LOCALE_NAME_MAX_LENGTH]{}; GetUserDefaultLocaleName(locale, LOCALE_NAME_MAX_LENGTH); result.SetNamedValue(L"locale", Json::JsonValue::CreateStringValue(locale));
     Windows::UI::ViewManagement::UISettings settings; auto color = settings.GetColorValue(Windows::UI::ViewManagement::UIColorType::Background); result.SetNamedValue(L"dark", Json::JsonValue::CreateBooleanValue(color.R + color.G + color.B < 384));
     LASTINPUTINFO input{sizeof(LASTINPUTINFO)}; if (!GetLastInputInfo(&input)) throw_last_error(); number(L"idleSeconds", static_cast<DWORD>(GetTickCount() - input.dwTime) / 1000.0);
@@ -130,7 +132,8 @@ struct SparkSystem {
       try {
         auto args = Json::JsonObject::Parse(to_hstring(encoded));
         if (method == "info") { promise.Resolve(to_string(SystemState::Info().Stringify())); return; }
-        if (method == "observe") { current->EnsureWindow(); current->observing = true; }
+        if (method == "observe") { current->EnsureWindow(); current->subscriptions.insert(to_string(args.GetNamedString(L"id"))); current->observing = true; }
+        else if (method == "unobserve") { current->subscriptions.erase(to_string(args.GetNamedString(L"id"))); current->observing = !current->subscriptions.empty(); if (!current->observing && current->hwnd) { WTSUnRegisterSessionNotification(current->hwnd); DestroyWindow(current->hwnd); current->hwnd = nullptr; } }
         else if (method == "loginStatus") { promise.Resolve("\"unavailable\""); return; }
         else if (method == "login") { promise.Reject(React::ReactError{"E_UNAVAILABLE", "Login startup requires a standalone distribution app"}); return; }
         else if (method == "badge") { auto label = args.GetNamedString(L"label"); HICON icon = label.empty() ? nullptr : SystemState::Badge(std::wstring(label)); auto result = SystemState::Taskbar()->SetOverlayIcon(MainWindow(), icon, label.c_str()); if (icon) DestroyIcon(icon); check_hresult(result); current->badge = !label.empty(); }
@@ -141,8 +144,9 @@ struct SparkSystem {
           handle request{PowerCreateRequest(&description)}; if (!request || request.get() == INVALID_HANDLE_VALUE) { request.detach(); throw_last_error(); } auto kind = args.GetNamedString(L"kind") == L"system" ? PowerRequestSystemRequired : PowerRequestDisplayRequired;
           if (!PowerSetRequest(request.get(), kind)) throw_last_error(); if (kind == PowerRequestDisplayRequired && !PowerSetRequest(request.get(), PowerRequestSystemRequired)) throw_last_error();
           auto id = ++current->sequence; current->requests.emplace(id, std::make_pair(std::move(request), kind)); promise.Resolve(std::to_string(id)); return;
-        } else if (method == "allowSleep") { auto found = current->requests.find(static_cast<uint64_t>(args.GetNamedNumber(L"id"))); if (found != current->requests.end()) { if (!PowerClearRequest(found->second.first.get(), found->second.second)) throw_last_error(); if (found->second.second == PowerRequestDisplayRequired) PowerClearRequest(found->second.first.get(), PowerRequestSystemRequired); current->requests.erase(found); } }
-        else if (method == "dockMenu") { if (!current->dockOwner.empty()) { promise.Reject(React::ReactError{"E_DOCK_MENU_EXISTS", "Remove the existing taskbar menu before replacing it"}); return; } current->DockMenu(args); }
+        } // Closing the dedicated handle releases every request held by this registration.
+        else if (method == "allowSleep") { current->requests.erase(static_cast<uint64_t>(args.GetNamedNumber(L"id"))); }
+        else if (method == "dockMenu") { if (!current->dockOwner.empty()) { promise.Reject(React::ReactError{"E_ALREADY_EXISTS", "Remove the existing taskbar menu before replacing it"}); return; } current->DockMenu(args); }
         else if (method == "clearDockMenu") { if (current->dockOwner == std::wstring(args.GetNamedString(L"owner"))) current->ClearDock(); }
         else throw hresult_invalid_argument(L"Unknown system operation");
         promise.Resolve("null");

package/vendor/node_modules/@legendapp/spark-tray/macos/RNDesktopTray.mm

@@ -3,14 +3,15 @@
 
 @interface SparkTrayItem : NSObject
 @property NSString *identifier;
+@property NSString *instanceId;
 @property NSStatusItem *item;
 @property NSDictionary *options;
 - (void)clicked:(id)sender;
 - (void)selected:(NSMenuItem *)sender;
 @end
 @implementation SparkTrayItem
-- (void)clicked:(id)sender { SparkEmit(@{ @"type": @"trayClick", @"trayId": self.identifier }); }
-- (void)selected:(NSMenuItem *)sender { SparkEmit(@{ @"type": @"trayAction", @"trayId": self.identifier, @"itemId": sender.representedObject }); }
+- (void)clicked:(id)sender { SparkEmit(@{ @"type": @"trayClick", @"trayId": self.identifier, @"instanceId": self.instanceId }); }
+- (void)selected:(NSMenuItem *)sender { SparkEmit(@{ @"type": @"trayAction", @"trayId": self.identifier, @"instanceId": self.instanceId, @"itemId": sender.representedObject }); }
 @end
 static NSMenu *Menu(NSArray *items, SparkTrayItem *owner) {
   NSMenu *menu = [NSMenu new]; menu.autoenablesItems = NO;
@@ -36,25 +37,36 @@ RCT_EXPORT_MODULE(NativeDesktopTray)
     NSDictionary *args = SparkArgs(json); NSString *key = args[@"id"];
     if (![key isKindOfClass:NSString.class] || !key.length) { SparkInvalid(reject, @"Tray needs an id"); return; }
     SparkTrayItem *owner = self.items[key];
+    if (owner && ![owner.instanceId isEqual:args[@"instanceId"]]) { if ([method isEqual:@"remove"]) resolve(@"null"); else reject([method isEqual:@"create"] ? @"E_ALREADY_EXISTS" : @"E_NOT_FOUND", @"Tray belongs to a different instance", nil); return; }
     if ([method isEqual:@"remove"]) { if (owner) [NSStatusBar.systemStatusBar removeStatusItem:owner.item]; [self.items removeObjectForKey:key]; resolve(@"null"); return; }
     if (![method isEqual:@"create"] && ![method isEqual:@"update"]) { SparkInvalid(reject, @"Unknown tray operation"); return; }
-    if ([method isEqual:@"create"] && owner) { reject(@"E_TRAY_EXISTS", @"Tray id already exists", nil); return; }
+    if ([method isEqual:@"create"] && owner) { reject(@"E_ALREADY_EXISTS", @"Tray id already exists", nil); return; }
     if ([method isEqual:@"update"] && !owner) { reject(@"E_NOT_FOUND", @"Tray was removed", nil); return; }
     NSMutableDictionary *options = [owner.options mutableCopy] ?: [NSMutableDictionary new]; [options addEntriesFromDictionary:args];
-    NSImage *image = nil;
-    if ([options[@"symbol"] length]) {
+    BOOL imageChanged = !owner || args[@"symbol"] != nil || args[@"imagePath"] != nil;
+    BOOL menuChanged = !owner || args[@"menu"] != nil;
+    NSImage *image = imageChanged ? nil : owner.item.button.image;
+    if (imageChanged && [options[@"symbol"] length]) {
       image = [NSImage imageWithSystemSymbolName:options[@"symbol"] accessibilityDescription:options[@"tooltip"] ?: options[@"title"]];
       if (!image) { SparkInvalid(reject, @"Unknown SF Symbol name"); return; }
       [image setTemplate:YES];
     }
+    if (imageChanged && [options[@"imagePath"] length]) {
+      image = [[NSImage alloc] initWithContentsOfFile:options[@"imagePath"]];
+      if (!image) { reject(@"E_INVALID_DATA", @"Tray image could not be decoded", nil); return; }
+      NSSize size = image.size; CGFloat height = MAX(1, NSStatusBar.systemStatusBar.thickness - 4);
+      image.size = NSMakeSize(size.height > 0 ? height * size.width / size.height : height, height);
+    }
     if (![options[@"title"] length] && !image) { SparkInvalid(reject, @"Tray needs a title or symbol"); return; }
-    if (!owner) { owner = [SparkTrayItem new]; owner.identifier = key; owner.item = [NSStatusBar.systemStatusBar statusItemWithLength:NSVariableStatusItemLength]; self.items[key] = owner; }
+    if (!owner) { owner = [SparkTrayItem new]; owner.identifier = key; owner.instanceId = args[@"instanceId"]; owner.item = [NSStatusBar.systemStatusBar statusItemWithLength:NSVariableStatusItemLength]; self.items[key] = owner; }
+    NSMenu *menu = menuChanged && [options[@"menu"] count] ? Menu(options[@"menu"], owner) : nil;
     owner.options = options;
-    owner.item.button.title = options[@"title"] ?: @""; owner.item.button.image = image;
+    owner.item.button.title = options[@"title"] ?: @"";
+    if (imageChanged) owner.item.button.image = image;
     owner.item.button.imagePosition = NSImageLeft; owner.item.button.toolTip = options[@"tooltip"];
     owner.item.button.target = owner; owner.item.button.action = @selector(clicked:);
     owner.item.button.accessibilityIdentifier = [@"spark.tray." stringByAppendingString:key];
-    owner.item.menu = [options[@"menu"] count] ? Menu(options[@"menu"], owner) : nil;
+    if (menuChanged) owner.item.menu = menu;
     resolve(@"null");
   });
 }

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

@@ -1,6 +1,6 @@
 {
   "name": "@legendapp/spark-tray",
-  "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-tray/src/NativeDesktopTray.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>("NativeDesktopTray");
+export default TurboModuleRegistry.get<Spec>("NativeDesktopTray");

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

@@ -1,46 +1,103 @@
+import { nativePath } from "@legendapp/spark-desktop-app/src/contracts/path";
+import { Platform } from "react-native";
 import Native from "./NativeDesktopTray";
-import { onDesktopEvent } from "@legendapp/spark-desktop-app";
-
-export type TrayMenuItem = { id: string; title: string; enabled?: boolean; checked?: boolean; items?: TrayMenuItem[] } | { separator: true };
-export type TrayOptions = { id: string; title?: string; /** SF Symbol name. */ symbol?: string; tooltip?: string; menu?: TrayMenuItem[] };
-export type TrayAction = { trayId: string; itemId?: string; type: "trayClick" | "trayAction" };
-async function call<T = void>(method: string, args: object): Promise<T> { return JSON.parse(await Native.call(method, JSON.stringify(args))) as T; }
-function validate(options: Partial<TrayOptions>) {
-  if (options.id !== undefined && !/^[a-zA-Z0-9_-]{1,100}$/.test(options.id)) throw new Error("Invalid tray id");
-  if (options.title !== undefined && typeof options.title !== "string") throw new Error("Tray title must be a string");
-  const ids = new Set<string>();
-  function menu(items: TrayMenuItem[], depth: number) {
-    if (depth > 5) throw new Error("Tray menus support at most five levels");
-    for (const item of items) {
-      if ("separator" in item) continue;
-      if (!item.id || ids.has(item.id) || !item.title) throw new Error("Tray menu items need unique ids and titles");
-      ids.add(item.id);
-      if (item.items) menu(item.items, depth + 1);
+import { onDesktopEvent } from "@legendapp/spark-desktop-app/src/events";
+import { SparkError, asyncRegistration, invokeNative, parseNativeResult, type Availability, type AsyncRegistration } from "@legendapp/spark-desktop-app/src/contracts";
+import { menuItems, selectableMenuIds, type MenuItem as SharedMenuItem, type MenuWireItem } from "@legendapp/spark-desktop-app/src/contracts/menu";
+type TrayEntry = { id: string; label: string; disabled?: boolean; hidden?: boolean };
+type TrayLeaf = { type: "separator" } | (TrayEntry & { type: "action" }) | (TrayEntry & { type: "checkbox"; checked: boolean });
+export type MenuItem = TrayLeaf | (TrayEntry & { type: "submenu"; items: readonly MenuItem[] });
+export type MenuAction = Extract<import("@legendapp/spark-desktop-app/src/contracts/menu").MenuAction, { type: "action" }>;
+export type { MenuIcon } from "@legendapp/spark-desktop-app/src/contracts/menu";
+export type { AsyncRegistration } from "@legendapp/spark-desktop-app/src/contracts";
+export type TrayAction = { type: "click" } | { type: "action"; itemId: string };
+export interface TrayUpdate {
+  /** Visible text on macOS; accessible tooltip fallback on Windows. */
+  title?: string;
+  /** Local image file; PNG is supported on both desktop hosts. Null clears it. */
+  image?: { path: string } | null;
+  tooltip?: string;
+  /** Replaces the entire menu; [] removes it. */
+  menu?: readonly MenuItem[];
+  /** Replaces macOS presentation options; null clears the symbol. */
+  macos?: { symbol?: string | null };
+}
+export interface TrayOptions extends TrayUpdate { id: string; onAction?: (action: TrayAction) => void }
+export interface Tray extends AsyncRegistration { readonly id: string; update(changes: TrayUpdate): Promise<void> }
+interface Wire { id: string; instanceId: string; imagePath: string; title: string; tooltip?: string; symbol: string; menu: MenuWireItem[] }
+export function getTrayAvailability(): Availability {
+  if (Platform.OS !== "macos" && Platform.OS !== "windows") return { available: false, reason: "unsupported-platform" };
+  return Native ? { available: true } : { available: false, reason: "missing-module" };
+}
+async function call(method: string, args: object): Promise<void> {
+  const available = getTrayAvailability();
+  if (!available.available) throw new SparkError(available.reason === "unsupported-platform" ? "E_UNSUPPORTED_PLATFORM" : "E_MODULE_UNAVAILABLE", "Tray is unavailable");
+  parseNativeResult(await invokeNative(() => Native!.call(method, JSON.stringify(args))), (value): value is null => value === null);
+}
+function validate(options: TrayUpdate, creating = false): Partial<Wire> {
+  if (!options || typeof options !== "object" || Array.isArray(options)) throw new SparkError("E_INVALID_ARGUMENT", "Expected tray options");
+  for (const key of Object.keys(options)) if (!["title", "tooltip", "image", "menu", "macos", ...(creating ? ["id", "onAction"] : [])].includes(key)) throw new SparkError("E_UNSUPPORTED_OPTION", `Unsupported tray option: ${key}`);
+  const result: Partial<Wire> = {};
+  for (const key of ["title", "tooltip"] as const) if (options[key] !== undefined) {
+    if (typeof options[key] !== "string" || options[key].includes("\0")) throw new SparkError("E_INVALID_ARGUMENT", `Tray ${key} must be a string without NUL`);
+    result[key] = options[key];
+  }
+  if (options.image !== undefined) {
+    if (options.image === null) result.imagePath = "";
+    else {
+      if (!options.image || typeof options.image !== "object" || Array.isArray(options.image) || Object.keys(options.image).some(key => key !== "path")) throw new SparkError("E_INVALID_ARGUMENT", "Expected an image path or null");
+      result.imagePath = nativePath(options.image.path, Platform.OS);
     }
   }
-  if (options.menu) menu(options.menu, 1);
+  if (options.macos !== undefined && Platform.OS === "macos") {
+    if (!options.macos || typeof options.macos !== "object" || Array.isArray(options.macos) || Object.keys(options.macos).some(key => key !== "symbol")) throw new SparkError("E_INVALID_ARGUMENT", "Expected macos tray options");
+    const symbol = options.macos.symbol;
+    if (symbol != null && (typeof symbol !== "string" || !symbol.trim() || symbol.includes("\0"))) throw new SparkError("E_INVALID_ARGUMENT", "Expected an SF Symbol name or null");
+    result.symbol = symbol ?? "";
+  }
+  if (options.menu !== undefined) result.menu = menuItems(options.menu, { types: ["action", "checkbox", "separator", "submenu"] }, Platform.OS === "windows" ? "windows" : "macos");
+  return result;
+}
+function presentation(options: Wire) {
+  if (options.imagePath && options.symbol) throw new SparkError("E_INVALID_ARGUMENT", "Choose a tray image or macOS symbol");
+  if (!options.title.trim() && !options.symbol && !options.imagePath) throw new SparkError("E_INVALID_ARGUMENT", "Tray needs a title, image or macOS symbol");
 }
-export async function createTray(options: TrayOptions, onAction: (action: TrayAction) => void = () => {}) {
-  validate(options);
-  if (!options.id || (!options.title && !options.symbol)) throw new Error("Tray needs an id and a title or symbol");
-  let removed = false;
+let sequence = 0;
+export async function createTray(options: TrayOptions): Promise<Tray> {
+  const changes = validate(options, true);
+  if (typeof options.id !== "string" || !/^[a-zA-Z0-9_-]{1,100}$/.test(options.id)) throw new SparkError("E_INVALID_ARGUMENT", "Invalid tray id");
+  if (options.onAction !== undefined && typeof options.onAction !== "function") throw new SparkError("E_INVALID_ARGUMENT", "Expected onAction callback");
+  const id = options.id, onAction = options.onAction;
+  const instanceId = `tray-${Date.now()}-${++sequence}-${Math.random().toString(36).slice(2)}`;
+  let current: Wire = { id, instanceId, imagePath: "", title: "", symbol: "", menu: [], ...changes };
+  presentation(current);
+  const available = getTrayAvailability();
+  if (!available.available) throw new SparkError(available.reason === "unsupported-platform" ? "E_UNSUPPORTED_PLATFORM" : "E_MODULE_UNAVAILABLE", "Tray is unavailable");
+  let stopped = false, ready = false;
+  let selected = selectableMenuIds(current.menu);
   let queue: Promise<unknown> = Promise.resolve();
   const sub = onDesktopEvent(event => {
-    if (!removed && event.trayId === options.id && (event.type === "trayClick" || event.type === "trayAction")) onAction(event as TrayAction);
-  });
-  try { await call("create", options); } catch (error) { sub.remove(); throw error; }
+    if (!ready || stopped || event.trayId !== id || event.instanceId !== instanceId) return;
+    if (event.type === "trayClick") onAction?.({ type: "click" });
+    else if (event.type === "trayAction" && typeof event.itemId === "string" && selected.has(event.itemId)) onAction?.({ type: "action", itemId: event.itemId });
+  }, { types: ["trayClick", "trayAction"], target: { field: "trayId", value: id } });
+  try { await call("create", current); ready = true; } catch (error) { sub.remove(); throw error; }
+  const registration = asyncRegistration(() => { stopped = true; sub.remove(); }, async () => { await queue; await call("remove", { id, instanceId }); });
   return {
-    async update(changes: Omit<Partial<TrayOptions>, "id">) {
-      if (removed) throw new Error("Tray was removed");
-      validate(changes);
-      const next = queue.then(() => call("update", { ...changes, id: options.id }));
+    id,
+    async update(changes) {
+      if (stopped) throw new SparkError("E_CLOSED", "Tray was removed");
+      const snapshot = validate(changes);
+      const next = queue.then(async () => {
+        const options = { ...current, ...snapshot };
+        presentation(options);
+        await call("update", { id, instanceId, ...snapshot });
+        current = options;
+        if (snapshot.menu !== undefined) selected = selectableMenuIds(options.menu);
+      });
       queue = next.catch(() => {});
       await next;
     },
-    async remove() {
-      if (removed) return;
-      removed = true; sub.remove();
-      await queue; await call("remove", { id: options.id });
-    },
+    remove: registration.remove,
   };
 }