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

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

@@ -1,11 +1,12 @@
 #import "SparkDesktop.h"
+#import "SparkDesktopError.h"
+#import "SparkQuitCoordinator.h"
 #import <CommonCrypto/CommonDigest.h>
 #import <sys/file.h>
 #import <fcntl.h>
 #import <unistd.h>
 NSString * const SparkDesktopEvent = @"SparkDesktopEvent";
-static BOOL quitGuard = NO;
-static BOOL quitting = NO;
+static NSMutableDictionary<NSString *, NSDictionary *> *jsQuitReplies;
 static NSUInteger quitGeneration = 0;
 static NSMutableArray *pendingURLs;
 static NSString *initialURL;
@@ -21,13 +22,7 @@ NSDictionary *SparkArgs(NSString *json) {
 }
 void SparkInvalid(RCTPromiseRejectBlock reject, NSString *message) { reject(@"E_INVALID_ARGUMENT", message, nil); }
 void SparkReject(RCTPromiseRejectBlock reject, NSError *error) {
-  NSString *code = @"E_IO";
-  if ([error.domain isEqualToString:NSCocoaErrorDomain]) {
-    if (error.code == NSFileReadNoSuchFileError || error.code == NSFileNoSuchFileError) code = @"E_NOT_FOUND";
-    if (error.code == NSFileReadNoPermissionError || error.code == NSFileWriteNoPermissionError) code = @"E_PERMISSION";
-    if (error.code == NSFileWriteFileExistsError) code = @"E_EXISTS";
-  }
-  reject(code, error.localizedDescription ?: @"Native operation failed", error);
+  reject(SparkDesktopErrorCode(error), error.localizedDescription ?: @"Native operation failed", error);
 }
 NSDictionary *SparkContext(void) {
   static NSDictionary *context;
@@ -36,7 +31,8 @@ NSDictionary *SparkContext(void) {
     NSBundle *bundle = NSBundle.mainBundle;
     NSString *runtimePath = [bundle pathForResource:@"spark-runtime" ofType:@"json"];
     NSData *data = runtimePath ? [NSData dataWithContentsOfFile:runtimePath] : nil;
-    NSDictionary *runtime = data ? [NSJSONSerialization JSONObjectWithData:data options:0 error:nil] : @{};
+    id rawRuntime = data ? [NSJSONSerialization JSONObjectWithData:data options:0 error:nil] : nil;
+    NSDictionary *runtime = [rawRuntime isKindOfClass:NSDictionary.class] ? rawRuntime : @{};
     NSString *project = [bundle objectForInfoDictionaryKey:@"SparkProjectIdentifier"] ?: bundle.bundleIdentifier;
     NSString *version = [bundle objectForInfoDictionaryKey:@"CFBundleShortVersionString"] ?: @"0.0.0";
     NSString *name = [bundle objectForInfoDictionaryKey:@"CFBundleDisplayName"] ?: [bundle objectForInfoDictionaryKey:@"CFBundleName"];
@@ -87,31 +83,33 @@ void SparkOpenURLs(NSArray<NSURL *> *urls) {
   }
 }
 NSArray *SparkPendingURLs(void) { return [pendingURLs copy] ?: @[]; }
-void SparkSetQuitGuard(BOOL value) {
-  if (value != quitGuard) {
-    if (value) [NSProcessInfo.processInfo disableSuddenTermination];
-    else [NSProcessInfo.processInfo enableSuddenTermination];
-  }
-  quitGuard = value;
-  if (!value && quitting) { quitting = NO; [NSApp replyToApplicationShouldTerminate:NO]; }
-}
-void SparkReplyQuit(BOOL allow, NSUInteger generation) {
-  if (!quitting || generation != quitGeneration) return;
-  quitting = NO;
-  [NSApp replyToApplicationShouldTerminate:allow];
+static SparkQuitCoordinator *SparkQuitCoordinatorInstance(void) {
+  static SparkQuitCoordinator *coordinator;
+  static dispatch_once_t once;
+  dispatch_once(&once, ^{ coordinator = [[SparkQuitCoordinator alloc] initWithReply:^(BOOL allow) {
+    [NSApp replyToApplicationShouldTerminate:allow];
+  } timeout:30]; });
+  return coordinator;
 }
-NSApplicationTerminateReply SparkShouldQuit(void) {
-  if (!quitGuard) return NSTerminateNow;
-  if (quitting) return NSTerminateLater;
-  quitting = YES;
-  NSUInteger generation = ++quitGeneration;
-  // Emit after returning Later so synchronous JS replies cannot race AppKit.
-  dispatch_async(dispatch_get_main_queue(), ^{ SparkEmit(@{ @"type": @"beforeQuit", @"requestId": @(generation) }); });
-  dispatch_after(dispatch_time(DISPATCH_TIME_NOW, 30 * NSEC_PER_SEC), dispatch_get_main_queue(), ^{
-    if (quitting && generation == quitGeneration) SparkReplyQuit(NO, generation);
+void SparkRegisterQuitHandler(NSString *identifier, SparkQuitHandler handler) { [SparkQuitCoordinatorInstance() registerHandler:identifier handler:handler]; }
+void SparkRemoveQuitHandler(NSString *identifier) { [SparkQuitCoordinatorInstance() removeHandler:identifier]; }
+void SparkSetQuitGuard(NSString *identifier, BOOL value) {
+  if (!jsQuitReplies) jsQuitReplies = [NSMutableDictionary new];
+  NSString *key = [@"spark.javascript." stringByAppendingString:identifier];
+  if (value) SparkRegisterQuitHandler(key, ^(SparkQuitReply reply) {
+    NSUInteger generation = ++quitGeneration;
+    jsQuitReplies[identifier] = @{ @"generation": @(generation), @"reply": [reply copy] };
+    SparkEmit(@{ @"type": @"beforeQuit", @"guardId": identifier, @"requestId": @(generation) });
   });
-  return NSTerminateLater;
+  else { [jsQuitReplies removeObjectForKey:identifier]; SparkRemoveQuitHandler(key); }
+}
+void SparkReplyQuit(NSString *identifier, BOOL allow, NSUInteger generation) {
+  NSDictionary *pending = jsQuitReplies[identifier];
+  if (!pending || [pending[@"generation"] unsignedIntegerValue] != generation) return;
+  SparkQuitReply reply = pending[@"reply"]; [jsQuitReplies removeObjectForKey:identifier]; reply(allow);
 }
+void SparkObserveQuitDecision(SparkQuitReply observer) { [SparkQuitCoordinatorInstance() observeDecision:observer]; }
+NSApplicationTerminateReply SparkShouldQuit(void) { return [SparkQuitCoordinatorInstance() requestQuit]; }
 
 BOOL SparkAcquireInstance(void) {
   static int lockFD = -1;
@@ -127,7 +125,9 @@ BOOL SparkAcquireInstance(void) {
   }
   observer = [NSDistributedNotificationCenter.defaultCenter addObserverForName:name object:nil queue:NSOperationQueue.mainQueue usingBlock:^(NSNotification *note) {
     [NSApp activateIgnoringOtherApps:YES];
-    for (NSWindow *window in NSApp.windows) if ([window.identifier isEqual:@"spark.main"]) [window makeKeyAndOrderFront:nil];
+    BOOL visible = NO;
+    for (NSWindow *window in NSApp.orderedWindows) if (window.isVisible && ![window isKindOfClass:NSPanel.class]) { visible = YES; break; }
+    [NSApp.delegate applicationShouldHandleReopen:NSApp hasVisibleWindows:visible];
     SparkEmit(@{ @"type": @"secondInstance", @"arguments": note.userInfo[@"arguments"] ?: @[] });
   }];
   return YES;

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

@@ -0,0 +1,20 @@
+#import <Foundation/Foundation.h>
+#import <errno.h>
+
+static inline NSString *SparkDesktopErrorCode(NSError *error) {
+  NSString *code = @"E_IO";
+  if ([error.domain isEqualToString:NSCocoaErrorDomain]) {
+    if (error.code == NSFileReadNoSuchFileError || error.code == NSFileNoSuchFileError) return @"E_NOT_FOUND";
+    if (error.code == NSFileReadNoPermissionError || error.code == NSFileWriteNoPermissionError) return @"E_PERMISSION";
+    if (error.code == NSFileWriteFileExistsError) return @"E_EXISTS";
+    if (error.code == NSFileWriteInvalidFileNameError) return @"E_INVALID_ARGUMENT";
+  }
+  if ([error.domain isEqualToString:NSPOSIXErrorDomain]) {
+    if (error.code == ENOENT || error.code == ENOTDIR) return @"E_NOT_FOUND";
+    if (error.code == EACCES || error.code == EPERM) return @"E_PERMISSION";
+    if (error.code == EEXIST) return @"E_EXISTS";
+    if (error.code == EINVAL) return @"E_INVALID_ARGUMENT";
+    if (error.code == ENOTEMPTY) return @"E_NOT_EMPTY";
+  }
+  return code;
+}

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

@@ -0,0 +1,26 @@
+#import <AppKit/AppKit.h>
+
+// Startup extensions own package-specific native chrome, never application dispatch.
+// Only explicitly configured classes are instantiated, on the main thread.
+@protocol SparkStartupPlugin <NSObject>
+@optional
+- (void)prepareApplication;
+- (void)prepareMainWindow:(NSWindow *)window;
+// At most one configured plugin may own root attachment. Call installRoot when
+// attaching to the normal content view; otherwise retain the root in your view.
+- (void)attachRootView:(NSView *)root toWindow:(NSWindow *)window installRoot:(void (^)(void))installRoot;
+@end
+
+FOUNDATION_EXPORT NSDictionary *SparkLifecycleConfiguration(void);
+FOUNDATION_EXPORT void SparkPrepareApplication(void);
+FOUNDATION_EXPORT void SparkPrepareMainWindow(NSWindow *window);
+FOUNDATION_EXPORT void SparkAttachMainRootView(NSView *root, NSWindow *window, void (^installRoot)(void));
+FOUNDATION_EXPORT void SparkRecordMainWindowShown(void);
+FOUNDATION_EXPORT NSDictionary *SparkStartupTiming(void);
+
+typedef void (^SparkQuitReply)(BOOL allow);
+typedef void (^SparkQuitHandler)(SparkQuitReply reply);
+// Registration, removal and replies are main-thread confined. No handlers means
+// immediate quit. All registered handlers must approve; removal/timeout cancels.
+FOUNDATION_EXPORT void SparkRegisterQuitHandler(NSString *identifier, SparkQuitHandler handler);
+FOUNDATION_EXPORT void SparkRemoveQuitHandler(NSString *identifier);

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

@@ -0,0 +1,49 @@
+#import "SparkLifecycle.h"
+#import <QuartzCore/QuartzCore.h>
+
+static NSArray<id<SparkStartupPlugin>> *plugins;
+static double mainWindowShown = 0;
+static double mainRootAttached = 0;
+NSDictionary *SparkLifecycleConfiguration(void) {
+  return [NSBundle.mainBundle objectForInfoDictionaryKey:@"SparkLifecycleConfiguration"] ?: @{};
+}
+void SparkPrepareApplication(void) {
+  NSCAssert(NSThread.isMainThread, @"Startup is main-thread confined");
+  NSString *appearance = SparkLifecycleConfiguration()[@"appearance"];
+  if (appearance) NSApp.appearance = [appearance isEqual:@"dark"] ? [NSAppearance appearanceNamed:NSAppearanceNameDarkAqua] : [appearance isEqual:@"light"] ? [NSAppearance appearanceNamed:NSAppearanceNameAqua] : nil;
+  NSMutableArray *instances = [NSMutableArray new];
+  NSUInteger rootOwners = 0;
+  for (NSString *name in SparkLifecycleConfiguration()[@"plugins"] ?: @[]) {
+    Class type = NSClassFromString(name);
+    if (!type || ![type conformsToProtocol:@protocol(SparkStartupPlugin)])
+      [NSException raise:NSInvalidArgumentException format:@"Startup plugin %@ is not linked or does not implement SparkStartupPlugin", name];
+    id<SparkStartupPlugin> plugin = [type new];
+    if ([plugin respondsToSelector:@selector(attachRootView:toWindow:installRoot:)]) rootOwners++;
+    [instances addObject:plugin];
+  }
+  if (rootOwners > 1) [NSException raise:NSInvalidArgumentException format:@"Only one startup plugin may own main root attachment"];
+  plugins = instances;
+  for (id<SparkStartupPlugin> plugin in plugins)
+    if ([plugin respondsToSelector:@selector(prepareApplication)]) [plugin prepareApplication];
+}
+void SparkPrepareMainWindow(NSWindow *window) {
+  for (id<SparkStartupPlugin> plugin in plugins)
+    if ([plugin respondsToSelector:@selector(prepareMainWindow:)]) [plugin prepareMainWindow:window];
+}
+void SparkAttachMainRootView(NSView *root, NSWindow *window, void (^installRoot)(void)) {
+  BOOL attached = NO;
+  for (id<SparkStartupPlugin> plugin in plugins) {
+    if ([plugin respondsToSelector:@selector(attachRootView:toWindow:installRoot:)]) {
+      [plugin attachRootView:root toWindow:window installRoot:installRoot]; attached = YES;
+    }
+  }
+  if (!attached) installRoot();
+  mainRootAttached = CACurrentMediaTime() * 1000;
+}
+void SparkRecordMainWindowShown(void) { if (!mainWindowShown) mainWindowShown = CACurrentMediaTime() * 1000; }
+NSDictionary *SparkStartupTiming(void) {
+  NSMutableDictionary *result = [NSMutableDictionary new];
+  if (mainWindowShown) result[@"mainWindowFirstVisibleTime"] = @(mainWindowShown);
+  if (mainRootAttached) result[@"mainWindowReactRootAttachedTime"] = @(mainRootAttached);
+  return result;
+}

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

@@ -0,0 +1,9 @@
+#import "SparkLifecycle.h"
+@interface SparkQuitCoordinator : NSObject
+- (instancetype)initWithReply:(SparkQuitReply)reply timeout:(NSTimeInterval)timeout;
+- (void)registerHandler:(NSString *)identifier handler:(SparkQuitHandler)handler;
+- (void)removeHandler:(NSString *)identifier;
+// Observe the current pending attempt, or the next request when none is pending.
+- (void)observeDecision:(SparkQuitReply)observer;
+- (NSApplicationTerminateReply)requestQuit;
+@end

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

@@ -0,0 +1,70 @@
+#import "SparkQuitCoordinator.h"
+@implementation SparkQuitCoordinator {
+  NSMutableDictionary<NSString *, SparkQuitHandler> *_handlers;
+  NSMutableSet<NSString *> *_pending;
+  NSMutableArray<SparkQuitReply> *_observers;
+  SparkQuitReply _reply;
+  NSTimeInterval _timeout;
+  NSUInteger _generation;
+}
+- (instancetype)initWithReply:(SparkQuitReply)reply timeout:(NSTimeInterval)timeout {
+  if ((self = [super init])) { _handlers = [NSMutableDictionary new]; _observers = [NSMutableArray new]; _reply = [reply copy]; _timeout = timeout; }
+  return self;
+}
+- (void)observeDecision:(SparkQuitReply)observer {
+  NSAssert(NSThread.isMainThread, @"Quit observers are main-thread confined");
+  [_observers addObject:[observer copy]];
+}
+- (void)notifyObservers:(BOOL)allow {
+  NSArray<SparkQuitReply> *observers = [_observers copy]; [_observers removeAllObjects];
+  for (SparkQuitReply observer in observers) observer(allow);
+}
+- (void)finish:(BOOL)allow generation:(NSUInteger)generation {
+  if (!_pending || _generation != generation) return;
+  _pending = nil; [self notifyObservers:allow]; _reply(allow);
+}
+- (void)registerHandler:(NSString *)identifier handler:(SparkQuitHandler)handler {
+  NSAssert(NSThread.isMainThread, @"Quit handlers are main-thread confined");
+  if (_handlers[identifier]) [self removeHandler:identifier];
+  _handlers[identifier] = [handler copy];
+  [NSProcessInfo.processInfo disableSuddenTermination];
+  // A newly installed guard has not approved the current attempt.
+  [self finish:NO generation:_generation];
+}
+- (void)removeHandler:(NSString *)identifier {
+  NSAssert(NSThread.isMainThread, @"Quit handlers are main-thread confined");
+  if (!_handlers[identifier]) return;
+  [_handlers removeObjectForKey:identifier];
+  [NSProcessInfo.processInfo enableSuddenTermination];
+  [self finish:NO generation:_generation];
+}
+- (NSApplicationTerminateReply)requestQuit {
+  NSAssert(NSThread.isMainThread, @"Quit requests are main-thread confined");
+  if (_pending) return NSTerminateLater;
+  if (!_handlers.count) { [self notifyObservers:YES]; return NSTerminateNow; }
+  NSDictionary<NSString *, SparkQuitHandler> *handlers = [_handlers copy];
+  _pending = [NSMutableSet setWithArray:handlers.allKeys];
+  NSUInteger generation = ++_generation;
+  // Return Later before invoking even synchronous native handlers.
+  dispatch_async(dispatch_get_main_queue(), ^{
+    if (!self->_pending || self->_generation != generation) return;
+    for (NSString *identifier in handlers) {
+      if (!self->_pending || self->_generation != generation) break;
+      handlers[identifier](^(BOOL allow) {
+        NSAssert(NSThread.isMainThread, @"Quit replies are main-thread confined");
+        if (self->_generation != generation || ![self->_pending containsObject:identifier]) return;
+        if (!allow) { [self finish:NO generation:generation]; return; }
+        [self->_pending removeObject:identifier];
+        if (!self->_pending.count) [self finish:YES generation:generation];
+      });
+    }
+  });
+  dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(_timeout * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
+    [self finish:NO generation:generation];
+  });
+  return NSTerminateLater;
+}
+- (void)dealloc {
+  for (__unused NSString *identifier in _handlers) [NSProcessInfo.processInfo enableSuddenTermination];
+}
+@end

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

@@ -59,14 +59,17 @@ void SparkApplyWindowOptions(NSWindow *window, NSDictionary *patch) {
     view.wantsLayer = YES;
     view.layer.backgroundColor = material ? NSColor.clearColor.CGColor : background.CGColor;
   }
-  window.contentMinSize = NSMakeSize(options[@"minWidth"] ? [options[@"minWidth"] doubleValue] : 100, options[@"minHeight"] ? [options[@"minHeight"] doubleValue] : 100);
-  window.contentMaxSize = NSMakeSize(options[@"maxWidth"] ? [options[@"maxWidth"] doubleValue] : 20000, options[@"maxHeight"] ? [options[@"maxHeight"] doubleValue] : 20000);
-  NSSize size = [window contentRectForFrameRect:window.frame].size;
+  window.minSize = NSMakeSize(options[@"minWidth"] ? [options[@"minWidth"] doubleValue] : 100, options[@"minHeight"] ? [options[@"minHeight"] doubleValue] : 100);
+  window.maxSize = NSMakeSize(options[@"maxWidth"] ? [options[@"maxWidth"] doubleValue] : 20000, options[@"maxHeight"] ? [options[@"maxHeight"] doubleValue] : 20000);
+  NSSize size = window.frame.size;
   if (patch[@"width"]) size.width = [patch[@"width"] doubleValue];
   if (patch[@"height"]) size.height = [patch[@"height"] doubleValue];
-  size.width = MIN(MAX(size.width, window.contentMinSize.width), window.contentMaxSize.width);
-  size.height = MIN(MAX(size.height, window.contentMinSize.height), window.contentMaxSize.height);
-  [window setContentSize:size];
+  size.width = MIN(MAX(size.width, window.minSize.width), window.maxSize.width);
+  size.height = MIN(MAX(size.height, window.minSize.height), window.maxSize.height);
+  NSRect frame = window.frame;
+  frame.origin.y += frame.size.height - size.height;
+  frame.size = size;
+  [window setFrame:frame display:NO];
   if (options[@"title"]) window.title = options[@"title"];
 }
 void SparkRestoreWindow(NSWindow *window, NSString *key, NSDictionary *options) {

package/vendor/node_modules/@legendapp/spark-desktop-app/macos/recent-documents/RNRecentDocumentController.mm

@@ -0,0 +1,55 @@
+#import "../SparkDesktop.h"
+
+#import <TargetConditionals.h>
+
+#if TARGET_OS_OSX
+#import <AppKit/AppKit.h>
+
+@interface RNRecentDocumentController : NSDocumentController
+@end
+
+@implementation RNRecentDocumentController
+
+- (void)openDocumentWithContentsOfURL:(NSURL *)url
+                              display:(BOOL)displayDocument
+                    completionHandler:(void (^)(NSDocument *_Nullable document,
+                                                 BOOL documentWasAlreadyOpen,
+                                                 NSError *_Nullable error))completionHandler
+{
+  [self emitOpenDocumentURL:url];
+
+  if (completionHandler) {
+    completionHandler(nil, NO, nil);
+  }
+}
+
+- (void)reopenDocumentForURL:(NSURL *)urlOrNil
+           withContentsOfURL:(NSURL *)contentsURL
+                     display:(BOOL)displayDocument
+           completionHandler:(void (^)(NSDocument *_Nullable document,
+                                        BOOL documentWasAlreadyOpen,
+                                        NSError *_Nullable error))completionHandler
+{
+  [self emitOpenDocumentURL:contentsURL ?: urlOrNil];
+
+  if (completionHandler) {
+    completionHandler(nil, NO, nil);
+  }
+}
+
+- (void)emitOpenDocumentURL:(NSURL *)url
+{
+  if (!url.isFileURL || url.path.length == 0) {
+    return;
+  }
+
+  SparkOpenURLs(@[url]);
+}
+
+@end
+@interface RNRecentDocumentsStartup : NSObject <SparkStartupPlugin>
+@end
+@implementation RNRecentDocumentsStartup
+- (void)prepareApplication { (void)[[RNRecentDocumentController alloc] init]; }
+@end
+#endif

package/vendor/node_modules/@legendapp/spark-desktop-app/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@legendapp/spark-desktop-app",
-  "version": "0.0.1-next.2",
+  "version": "0.0.1-next.4",
   "license": "MIT",
   "main": "src/index",
   "react-native": "src/index",
@@ -8,7 +8,8 @@
     "src",
     "macos",
     "*.podspec",
-    "react-native.config.js"
+    "react-native.config.js",
+    "cpp"
   ],
   "peerDependencies": {
     "react": "19.1.4",
@@ -21,7 +22,8 @@
     "ios": {
       "modulesProvider": {
         "NativeDesktopApp": "RNDesktopApp"
-      }
+      },
+      "componentProvider": {}
     }
   },
   "spark": {

package/vendor/node_modules/@legendapp/spark-desktop-app/src/NativeDesktopApp.ts

@@ -5,4 +5,4 @@ export interface Spec extends TurboModule {
   addListener(eventName: string): void;
   removeListeners(count: number): void;
 }
-export default TurboModuleRegistry.getEnforcing<Spec>("NativeDesktopApp");
+export default TurboModuleRegistry.get<Spec>("NativeDesktopApp");

package/vendor/node_modules/@legendapp/spark-desktop-app/src/api.ts

@@ -1,42 +1,88 @@
-import { NativeEventEmitter } from "react-native";
-import Native from "./NativeDesktopApp";
-export type AppContext = {
-  projectId: string; name: string; version: string;
-  runtime: { mode?: string; modules?: Record<string, string> };
-  launchArguments: string[];
+import { Platform, TurboModuleRegistry } from "react-native";
+import { onDesktopEvent, type DesktopEvent } from "./events";
+import { callAppNative } from "./transport";
+import { SparkError, asyncRegistration, nativeError, type Availability, type AsyncRegistration, type Subscription } from "./contracts";
+export type { AsyncRegistration, Subscription } from "./contracts";
+export interface AppRuntime { mode: "go" | "dev" | "preview" | "release"; modules: Readonly<Record<string, string>> }
+export interface AppContext { projectId: string; name: string; version: string; runtime: AppRuntime; launchArguments: readonly string[] }
+export type QuitResult = { quitRequested: true } | { quitRequested: false; reason: "vetoed" };
+export type AppEventMap = {
+  windowOpened: { type: "windowOpened"; windowId: string };
+  windowClosed: { type: "windowClosed"; windowId: string };
+  activate: { type: "activate" };
+  deactivate: { type: "deactivate" };
+  reopen: { type: "reopen"; hasVisibleWindows: boolean; mainWindowWasVisible: boolean };
+  secondInstance: { type: "secondInstance"; arguments: readonly string[] };
+  willQuit: { type: "willQuit" };
 };
-export type DesktopEvent = { type: string; id?: string; url?: string; windowId?: string; [key: string]: unknown };
-const events = new NativeEventEmitter(Native);
-export async function callApp<T = void>(method: string, args: object = {}): Promise<T> {
-  return JSON.parse(await Native.call(method, JSON.stringify(args))) as T;
-}
-export const getAppContext = () => callApp<AppContext>("context");
-export const quit = () => callApp("quit");
-export const hide = () => callApp("hide");
-export const activate = () => callApp("activate");
-export function onDesktopEvent(listener: (event: DesktopEvent) => void) {
-  return events.addListener("desktop", listener);
-}
-export function onAppEvent(listener: (event: DesktopEvent) => void) {
-  return onDesktopEvent(event => { if (["activate", "deactivate", "reopen", "beforeQuit", "secondInstance"].includes(event.type)) listener(event); });
-}
-/** Await registration before enabling edits. A rejection or timeout cancels quit. */
-export async function beforeQuit(handler: () => boolean | Promise<boolean>) {
-  if (quitHandlerRegistered) throw new Error("A beforeQuit handler is already registered");
-  quitHandlerRegistered = true;
-  let removed = false;
+export type AppEvent = AppEventMap[keyof AppEventMap];
+export interface BeforeQuitOptions { onError?: (error: Error) => void }
+export function getAppAvailability(): Availability {
+  if (Platform.OS !== "macos" && Platform.OS !== "windows") return { available: false, reason: "unsupported-platform" };
+  return TurboModuleRegistry.get("NativeDesktopApp") ? { available: true } : { available: false, reason: "missing-module" };
+}
+function record(value: unknown): value is Record<string, unknown> { return !!value && typeof value === "object" && !Array.isArray(value); }
+function strings(value: unknown): value is string[] { return Array.isArray(value) && value.every(item => typeof item === "string"); }
+function context(value: unknown): value is AppContext {
+  if (!record(value) || ![value.projectId, value.name, value.version].every(item => typeof item === "string" && item.length > 0) || !strings(value.launchArguments) || !record(value.runtime)) return false;
+  return ["go", "dev", "preview", "release"].includes(value.runtime.mode as string) && record(value.runtime.modules) && Object.values(value.runtime.modules).every(item => typeof item === "string");
+}
+export async function getAppContext(): Promise<AppContext> {
+  const value = await callAppNative("context", context);
+  return { projectId: value.projectId, name: value.name, version: value.version, launchArguments: [...value.launchArguments], runtime: { mode: value.runtime.mode, modules: { ...value.runtime.modules } } };
+}
+const command = (method: string, args: object = {}) => callAppNative(method, (value): value is null => value === null, args).then(() => {});
+const orphanGuards = new Set<AsyncRegistration>();
+async function cleanOrphanGuards(): Promise<void> {
+  await Promise.all([...orphanGuards].map(async guard => { await guard.remove(); orphanGuards.delete(guard); }));
+}
+let quitting: Promise<QuitResult> | undefined;
+/** Joins an existing quit decision. Success permits shutdown; it is not an after-exit hook. */
+export function quit(): Promise<QuitResult> {
+  return quitting ??= cleanOrphanGuards().then(() => callAppNative("quit", (value): value is QuitResult => record(value) && (value.quitRequested === true || (value.quitRequested === false && value.reason === "vetoed")))).finally(() => { quitting = undefined; });
+}
+export const hide = (): Promise<void> => command("hide");
+export const activate = (): Promise<void> => command("activate");
+function appEvent(value: DesktopEvent): AppEvent | undefined {
+  switch (value.type) {
+    case "opened": case "closed": if (typeof value.windowId === "string" && value.windowId) return { type: value.type === "opened" ? "windowOpened" : "windowClosed", windowId: value.windowId }; break;
+    case "activate": case "deactivate": case "willQuit": return { type: value.type };
+    case "reopen": if (typeof value.hasVisibleWindows === "boolean" && typeof value.mainWindowWasVisible === "boolean") return { type: "reopen", hasVisibleWindows: value.hasVisibleWindows, mainWindowWasVisible: value.mainWindowWasVisible }; break;
+    case "secondInstance": if (strings(value.arguments)) return { type: "secondInstance", arguments: [...value.arguments] }; break;
+  }
+}
+/** Live events only. Initial identity is getAppContext; file/URL replay belongs to documents. */
+export function addAppListener<K extends keyof AppEventMap>(type: K, listener: (event: AppEventMap[K]) => void): Subscription {
+  if (!["activate", "deactivate", "reopen", "secondInstance", "willQuit", "windowOpened", "windowClosed"].includes(type) || typeof listener !== "function") throw new SparkError("E_INVALID_ARGUMENT", "Expected an application event and listener");
+  const availability = getAppAvailability();
+  if (!availability.available) throw new SparkError(availability.reason === "missing-module" ? "E_MODULE_UNAVAILABLE" : "E_UNSUPPORTED_PLATFORM", "Application events are unavailable");
+  return onDesktopEvent(value => { const event = appEvent(value); if (event?.type === type) listener(event as AppEventMap[K]); }, { types: [type === "windowOpened" ? "opened" : type === "windowClosed" ? "closed" : type] });
+}
+let nextGuard = 0;
+/** All registered guards must approve. Rejection, removal or the native 30s deadline vetoes. */
+export async function beforeQuit(handler: () => boolean | Promise<boolean>, options: BeforeQuitOptions = {}): Promise<AsyncRegistration> {
+  if (typeof handler !== "function" || !options || typeof options !== "object" || Array.isArray(options)) throw new SparkError("E_INVALID_ARGUMENT", "Expected a quit handler and options");
+  for (const key of Object.keys(options)) if (key !== "onError") throw new SparkError("E_UNSUPPORTED_OPTION", `Unknown quit-guard option: ${key}`);
+  if (options.onError !== undefined && typeof options.onError !== "function") throw new SparkError("E_INVALID_ARGUMENT", "Expected an error callback");
+  const availability = getAppAvailability();
+  if (!availability.available) throw new SparkError(availability.reason === "missing-module" ? "E_MODULE_UNAVAILABLE" : "E_UNSUPPORTED_PLATFORM", "Quit guards are unavailable");
+  await cleanOrphanGuards();
+  const id = `quit-${Date.now()}-${++nextGuard}-${Math.random().toString(36).slice(2)}`;
+  let removed = false, latestRequest = 0;
+  const onError = options.onError ?? console.error;
+  const reportError = (cause: unknown) => { if (!removed) { try { onError(nativeError(cause)); } catch (error) { console.error(error); } } };
   const subscription = onDesktopEvent(event => {
-    if (event.type === "beforeQuit") void Promise.resolve().then(handler).then(
-      allow => callApp("replyQuit", { allow: !removed && allow === true, requestId: event.requestId }),
-      () => callApp("replyQuit", { allow: false, requestId: event.requestId }),
-    ).catch(console.error);
-  });
-  try { await callApp("quitGuard", { enabled: true }); }
-  catch (error) { subscription.remove(); quitHandlerRegistered = false; throw error; }
-  return { async remove() {
-    if (removed) return;
-    removed = true; subscription.remove(); quitHandlerRegistered = false;
-    await callApp("quitGuard", { enabled: false });
-  } };
-}
-let quitHandlerRegistered = false;
+    if (removed || event.type !== "beforeQuit" || event.guardId !== id || !Number.isSafeInteger(event.requestId) || (event.requestId as number) <= latestRequest) return;
+    const requestId = latestRequest = event.requestId as number;
+    void Promise.resolve().then(() => removed ? false : handler()).catch(error => { reportError(error); return false; }).then(
+      allow => command("replyQuit", { id, allow: !removed && latestRequest === requestId && allow === true, requestId }),
+    ).catch(error => { reportError(error); });
+  }, { types: ["beforeQuit"], target: { field: "guardId", value: id } });
+  const registration = asyncRegistration(() => { removed = true; subscription.remove(); }, () => command("quitGuard", { id, enabled: false }));
+  try { await command("quitGuard", { id, enabled: true }); }
+  catch (cause) {
+    try { await registration.remove(); } catch (cleanup) { orphanGuards.add(registration); throw new SparkError("E_NATIVE", "Quit guard registration and cleanup failed", { cause: new AggregateError([cause, cleanup]) }); }
+    throw cause;
+  }
+  return registration;
+}

package/vendor/node_modules/@legendapp/spark-desktop-app/src/contracts/accelerator.ts

@@ -0,0 +1,40 @@
+import { SparkError } from "./index";
+export type Accelerator = { key: string; modifiers: number };
+// AppKit uses these bit positions in NSEventModifierFlags.
+const modifiers: Record<string, number> = {
+  cmd: 1 << 20, command: 1 << 20, meta: 1 << 20, commandorcontrol: 1 << 20, cmdorctrl: 1 << 20,
+  ctrl: 1 << 18, control: 1 << 18, alt: 1 << 19, option: 1 << 19, shift: 1 << 17, fn: 1 << 23, capslock: 1 << 16,
+};
+const named: Record<string, string> = { enter: "\r", return: "\r", escape: "\u001b", esc: "\u001b", tab: "\t", space: " ", backspace: "\u007f", delete: "\uf728", up: "\uf700", down: "\uf701", left: "\uf702", right: "\uf703", plus: "+" };
+const extended: Record<string, string> = { home: "\uf729", end: "\uf72b", pageup: "\uf72c", pagedown: "\uf72d", mediaplaypause: "MediaPlayPause", medianext: "MediaNext", mediaprevious: "MediaPrevious" };
+export interface AcceleratorParseOptions { allowUnmodifiedCharacter?: boolean; allowExtendedKeys?: boolean }
+export function parseAccelerator(value: string, platform: "macos" | "windows" = "macos", options: AcceleratorParseOptions = {}): Accelerator {
+  if (typeof value !== "string" || !["macos", "windows"].includes(platform)) throw new SparkError("E_INVALID_ARGUMENT", "Expected accelerator and desktop platform");
+  if (!options || typeof options !== "object" || Array.isArray(options)) throw new SparkError("E_INVALID_ARGUMENT", "Expected accelerator parsing options");
+  for (const key of Object.keys(options)) if (!["allowUnmodifiedCharacter", "allowExtendedKeys"].includes(key)) throw new SparkError("E_UNSUPPORTED_OPTION", `Unknown accelerator option: ${key}`);
+  if ([options.allowUnmodifiedCharacter, options.allowExtendedKeys].some(value => value !== undefined && typeof value !== "boolean")) throw new SparkError("E_INVALID_ARGUMENT", "Accelerator parsing flags must be boolean");
+  const parts = value.toLowerCase().split("+").map(part => part.trim());
+  let flags = 0;
+  for (const part of parts.slice(0, -1)) {
+    const flag = platform === "windows" && (part === "cmdorctrl" || part === "commandorcontrol") ? 1 << 18 : modifiers[part];
+    if (!flag || (flags & flag)) throw new SparkError("E_INVALID_ARGUMENT", `Invalid or duplicate modifier: ${part}`);
+    if ((part === "fn" || part === "capslock") && !options.allowExtendedKeys) throw new SparkError("E_UNSUPPORTED_OPTION", `Modifier unavailable on this shortcut surface: ${part}`);
+    flags |= flag;
+  }
+  const last = parts.at(-1)!;
+  if (extended[last] && !options.allowExtendedKeys) throw new SparkError("E_UNSUPPORTED_OPTION", `Key unavailable on this shortcut surface: ${last}`);
+  let key = named[last] ?? extended[last] ?? last;
+  if (/^f([1-9]|1[0-9]|20)$/.test(last)) key = String.fromCharCode(0xf704 + Number(last.slice(1)) - 1);
+  if ((!extended[last] && key.length !== 1) || /[\ud800-\udfff]/.test(key)) throw new SparkError("E_INVALID_ARGUMENT", `Unknown shortcut key: ${last}`);
+  if (!options.allowUnmodifiedCharacter && !flags && !named[last] && !extended[last] && !/^f([1-9]|1[0-9]|20)$/.test(last)) throw new SparkError("E_INVALID_ARGUMENT", "Character shortcuts need a modifier");
+  return { key, modifiers: flags };
+}
+
+/** Canonical spelling for a parsed binding; this does not encode physical key codes. */
+export function formatAccelerator(value: Accelerator): string {
+  const labels = [[1 << 20, "Cmd"], [1 << 18, "Ctrl"], [1 << 19, "Alt"], [1 << 17, "Shift"], [1 << 23, "Fn"], [1 << 16, "CapsLock"]] as const;
+  const keys: Record<string, string> = { "\r": "Enter", "\u001b": "Escape", "\t": "Tab", " ": "Space", "\u007f": "Backspace", "\uf728": "Delete", "\uf700": "Up", "\uf701": "Down", "\uf702": "Left", "\uf703": "Right", "+": "Plus", "\uf729": "Home", "\uf72b": "End", "\uf72c": "PageUp", "\uf72d": "PageDown" };
+  const code = value.key.charCodeAt(0);
+  const key = keys[value.key] ?? (value.key.length === 1 && code >= 0xf704 && code <= 0xf717 ? `F${code - 0xf704 + 1}` : value.key.length === 1 ? value.key.toUpperCase() : value.key);
+  return [...labels.filter(([flag]) => value.modifiers & flag).map(([, label]) => label), key].join("+");
+}