@legendapp/spark 0.0.1-next.2

package/vendor/node_modules/@legendapp/spark-desktop-host/windows/notifications.inc

@@ -0,0 +1,60 @@
+// Inbox Win32 toast activation avoids a separate Windows App SDK singleton package.
+#include <notificationactivationcallback.h>
+#include <atomic>
+#include <mutex>
+#include <deque>
+namespace SparkWin {
+static std::mutex notificationMutex;
+static std::deque<std::string> notificationResponses;
+static std::deque<std::string> notificationEvents;
+static std::atomic<HWND> notificationWindow{nullptr};
+static void SetNotificationWindow(HWND hwnd) { notificationWindow = hwnd; if (hwnd) PostMessageW(hwnd, WM_APP + 19, 0, 0); }
+static std::wstring ToastClassId() {
+  auto key = ProjectKey(); return L"{" + key.substr(0, 8) + L"-" + key.substr(8, 4) + L"-" + key.substr(12, 4) + L"-" + key.substr(16, 4) + L"-" + key.substr(20, 12) + L"}";
+}
+static void QueueNotificationResponse(std::string const &encoded) {
+  auto args = Json::JsonObject::Parse(to_hstring(encoded));
+  if (args.GetNamedString(L"project") != SparkWindowsEnv(L"SPARK_PROJECT_ID")) return;
+  auto data = args.GetNamedObject(L"data", Json::JsonObject());
+  for (auto const &entry : data) if (entry.Value().ValueType() != Json::JsonValueType::String) return;
+  GUID identity{}; winrt::check_hresult(CoCreateGuid(&identity));
+  Json::JsonObject response;
+  response.SetNamedValue(L"type", Json::JsonValue::CreateStringValue(L"notificationResponse"));
+  response.SetNamedValue(L"id", Json::JsonValue::CreateStringValue(winrt::to_hstring(winrt::guid(identity))));
+  response.SetNamedValue(L"notificationId", Json::JsonValue::CreateStringValue(args.GetNamedString(L"notificationId")));
+  response.SetNamedValue(L"action", Json::JsonValue::CreateStringValue(args.GetNamedString(L"action", L"open") == L"dismiss" ? L"dismiss" : L"open"));
+  response.SetNamedValue(L"data", data); auto json = to_string(response.Stringify());
+  { std::lock_guard lock(notificationMutex); notificationResponses.push_back(json); notificationEvents.push_back(json); if (notificationResponses.size() > 100) notificationResponses.pop_front(); if (notificationEvents.size() > 100) notificationEvents.pop_front(); }
+  if (auto hwnd = notificationWindow.load()) PostMessageW(hwnd, WM_APP + 19, 0, 0);
+}
+static std::string NotificationResponses() {
+  std::lock_guard lock(notificationMutex); Json::JsonArray responses;
+  for (auto const &value : notificationResponses) responses.Append(Json::JsonObject::Parse(to_hstring(value))); return to_string(responses.Stringify());
+}
+static void EmitNotificationEvents() {
+  if (!context) return;
+  std::deque<std::string> events; { std::lock_guard lock(notificationMutex); events.swap(notificationEvents); }
+  for (auto const &encoded : events) {
+    auto event = Json::JsonObject::Parse(to_hstring(encoded));
+    if (event.GetNamedString(L"action") == L"open") { auto hwnd = notificationWindow.load(); if (hwnd) { ShowWindow(hwnd, IsIconic(hwnd) ? SW_RESTORE : SW_SHOW); SetForegroundWindow(hwnd); } }
+    auto value = Value(event); context.EmitJSEvent(L"RCTDeviceEventEmitter", L"desktop", std::move(value));
+  }
+}
+struct ToastCallback : winrt::implements<ToastCallback, INotificationActivationCallback> {
+  HRESULT __stdcall Activate(LPCWSTR appId, LPCWSTR arguments, const NOTIFICATION_USER_INPUT_DATA *, ULONG) noexcept override {
+    try { if (appId && arguments && std::wstring(appId) == L"Spark." + ProjectKey()) QueueNotificationResponse(to_string(arguments)); return S_OK; } catch (...) { return winrt::to_hresult(); }
+  }
+};
+struct ToastFactory : winrt::implements<ToastFactory, IClassFactory> {
+  HRESULT __stdcall CreateInstance(IUnknown *outer, REFIID iid, void **object) noexcept override {
+    if (!object) return E_POINTER; *object = nullptr; if (outer) return CLASS_E_NOAGGREGATION;
+    try { auto callback = winrt::make_self<ToastCallback>(); return callback->QueryInterface(iid, object); } catch (...) { return winrt::to_hresult(); }
+  }
+  HRESULT __stdcall LockServer(BOOL) noexcept override { return S_OK; }
+};
+static DWORD toastRegistration = 0;
+static void InitializeToastActivation() {
+  auto factory = winrt::make_self<ToastFactory>();
+  winrt::check_hresult(CoRegisterClassObject(winrt::guid(ToastClassId()), factory.get(), CLSCTX_LOCAL_SERVER, REGCLS_MULTIPLEUSE, &toastRegistration));
+}
+}

package/vendor/node_modules/@legendapp/spark-desktop-host/windows/runtime.inc

@@ -0,0 +1,63 @@
+// Spark development runtime, compiled into the Expo Desktop Win32 host.
+#include <string>
+#include <shellapi.h>
+#include <winrt/Windows.Foundation.h>
+#include <cstdlib>
+#include <cstdint>
+#include <cwchar>
+#include <fstream>
+#include <filesystem>
+#include <winrt/Windows.Data.Json.h>
+
+static std::wstring SparkWindowsEnv(const wchar_t *name) {
+  const DWORD size = GetEnvironmentVariableW(name, nullptr, 0);
+  if (!size) return {};
+  std::wstring value(size, L'\0');
+  const DWORD written = GetEnvironmentVariableW(name, value.data(), size);
+  if (!written || written >= size) return {};
+  value.resize(written);
+  return value;
+}
+static void SparkInitializeEnvironment() {
+  const auto defaults = winrt::Windows::Data::Json::JsonObject::Parse(LR"spark(__SPARK_PROJECT_CONFIG__)spark");
+  for (auto const &item : defaults) if (SparkWindowsEnv(item.Key().c_str()).empty()) SetEnvironmentVariableW(item.Key().c_str(), item.Value().GetString().c_str());
+  // Shell task activations carry their project context even in the shared prebuilt executable.
+  int count = 0; auto argv = CommandLineToArgvW(GetCommandLineW(), &count);
+  if (argv) {
+    try {
+      for (int i = 1; i < count; ++i) {
+        std::wstring argument(argv[i]); const std::wstring prefix = L"--spark-context=";
+        if (argument.rfind(prefix, 0) != 0) continue;
+        auto context = winrt::Windows::Data::Json::JsonObject::Parse(winrt::Windows::Foundation::Uri::UnescapeComponent(argument.substr(prefix.size())));
+        for (auto key : {L"SPARK_PROJECT_ID", L"SPARK_PROJECT_NAME", L"SPARK_PROJECT_VERSION", L"SPARK_WINDOW_CONFIG", L"SPARK_SESSION_FILE"})
+          if (context.HasKey(key)) SetEnvironmentVariableW(key, context.GetNamedString(key).c_str());
+      }
+    } catch (...) { LocalFree(argv); throw; }
+    LocalFree(argv);
+  }
+}
+static uint16_t SparkMetroPort() {
+  auto value = SparkWindowsEnv(L"SPARK_METRO_PORT");
+  if (value.empty()) {
+    std::ifstream file(std::filesystem::path(SparkWindowsEnv(L"SPARK_SESSION_FILE")), std::ios::binary);
+    if (file) try {
+      auto state = winrt::Windows::Data::Json::JsonObject::Parse(winrt::to_hstring(std::string(std::istreambuf_iterator<char>(file), std::istreambuf_iterator<char>())));
+      value = std::to_wstring(static_cast<int>(state.GetNamedNumber(L"port", 8081)));
+    } catch (...) {}
+  }
+  wchar_t *end = nullptr;
+  const auto port = wcstoul(value.c_str(), &end, 10);
+  return !value.empty() && end && *end == 0 && port > 0 && port <= 65535
+    ? static_cast<uint16_t>(port) : 8081;
+}
+REACT_MODULE(NativeSparkRuntime)
+struct NativeSparkRuntime {
+  REACT_SYNC_METHOD(describe)
+  std::string describe() noexcept {
+    return R"spark(__SPARK_METADATA__)spark";
+  }
+  REACT_SYNC_METHOD(server)
+  std::string server() noexcept { return "http://127.0.0.1:" + std::to_string(SparkMetroPort()); }
+  REACT_SYNC_METHOD(session)
+  std::string session() noexcept { return winrt::to_string(SparkWindowsEnv(L"SPARK_SESSION_TOKEN")); }
+};

package/vendor/node_modules/@legendapp/spark-desktop-host/windows/runtimes.inc

@@ -0,0 +1,162 @@
+// Margelo Runtimes backend. Every worker is a real RNW host with its own Hermes heap.
+#include <JSI/JsiApiContext.h>
+#include <functional>
+#include <memory>
+#include <vector>
+#include <optional>
+#include <winrt/Microsoft.ReactNative.Composition.h>
+namespace SparkWin {
+namespace Composition = winrt::Microsoft::ReactNative::Composition;
+static React::ReactPropertyId<bool> secondaryProperty{L"Spark", L"SecondaryRuntime"};
+struct Worker {
+  std::string name, kind;
+  React::ReactNativeHost host{nullptr}; React::ReactContext context;
+  bool ready = false, stopped = false;
+  std::vector<std::function<void(std::string const &)>> pending;
+  std::vector<std::function<void()>> detach;
+};
+static std::map<std::string, std::shared_ptr<Worker>> workers;
+struct RuntimeCall { std::string runtime; React::ReactPromise<std::string> promise; };
+static std::map<std::string, RuntimeCall> runtimeCalls;
+static uint64_t runtimeCallSequence = 0;
+static std::shared_ptr<bool> runtimeOwner;
+static bool IsSecondary(React::ReactContext const &value) { return value.Properties().Get(secondaryProperty).value_or(false); }
+static void StopWorker(std::string const &name, std::string const &reason) {
+  auto found = workers.find(name); if (found == workers.end()) return; auto worker = found->second; workers.erase(found); worker->stopped = true;
+  auto pending = std::move(worker->pending); for (auto &callback : pending) callback(reason);
+  for (auto &detach : worker->detach) detach(); worker->detach.clear();
+  for (auto it = runtimeCalls.begin(); it != runtimeCalls.end();) { if (it->second.runtime == name) { it->second.promise.Reject(React::ReactError{"E_RUNTIME_DESTROYED", reason}); it = runtimeCalls.erase(it); } else ++it; }
+  auto unload = worker->host.UnloadInstance(); unload.Completed([worker](auto const &, auto const &) {});
+}
+static void StopWorkers() { while (!workers.empty()) StopWorker(workers.begin()->first, "Runtime was destroyed"); }
+static winrt::fire_and_forget LoadWorker(std::shared_ptr<Worker> worker) {
+  try { co_await worker->host.LoadInstance(); }
+  catch (...) { auto error = winrt::to_string(winrt::to_message()); React::ReactDispatcher(host.InstanceSettings().UIDispatcher()).Post([worker, error]() { if (!worker->stopped) StopWorker(worker->name, error); }); }
+}
+static winrt::fire_and_forget WorkerDeadline(std::weak_ptr<Worker> weak, React::ReactDispatcher dispatcher) {
+  co_await winrt::resume_after(std::chrono::seconds(120));
+  dispatcher.Post([weak]() { if (auto worker = weak.lock(); worker && !worker->stopped && !worker->ready) StopWorker(worker->name, "Worker bundle did not become ready within 120 seconds"); });
+}
+static std::shared_ptr<Worker> GetWorker(std::string const &name, std::string kind = "threaded-runtime") {
+  if (name.empty() || name == "main" || name.size() > 100) throw winrt::hresult_invalid_argument(L"Expected a secondary runtime name of 1–100 characters");
+  if (auto found = workers.find(name); found != workers.end()) { if (kind != found->second->kind && kind != "threaded-runtime") throw winrt::hresult_invalid_argument(L"Runtime kind cannot change while running"); return found->second; }
+  auto worker = std::make_shared<Worker>(); worker->name = name; worker->kind = kind; worker->host = React::ReactNativeHost();
+  auto settings = worker->host.InstanceSettings(), main = host.InstanceSettings();
+  settings.UIDispatcher(main.UIDispatcher()); settings.JSIEngineOverride(React::JSIEngine::Hermes);
+  settings.SourceBundleHost(main.SourceBundleHost()); settings.SourceBundlePort(main.SourceBundlePort());
+  settings.UseDeveloperSupport(main.UseDeveloperSupport()); settings.UseFastRefresh(true); settings.UseDirectDebugger(false);
+  settings.DebugBundlePath(L".threaded-runtime/entry"); settings.JavaScriptBundleFile(L"index.windows");
+  React::ReactPropertyBag(settings.Properties()).Set(secondaryProperty, true);
+  for (auto const &provider : main.PackageProviders()) settings.PackageProviders().Append(provider);
+  auto weak = std::weak_ptr(worker); auto dispatcher = React::ReactDispatcher(main.UIDispatcher());
+  settings.InstanceCreated([weak](auto const &, React::InstanceCreatedEventArgs const &args) {
+    if (auto worker = weak.lock()) {
+      React::ReactContext context(args.Context()); auto handle = context.Handle().JSRuntime();
+      if (!handle) throw winrt::hresult_error(E_FAIL, L"Worker has no Hermes JSI runtime");
+      auto &runtime = React::GetOrCreateContextRuntime(context, handle); facebook::jsi::Object env(runtime);
+      env.setProperty(runtime, "runtimeName", facebook::jsi::String::createFromUtf8(runtime, worker->name)); env.setProperty(runtime, "kind", facebook::jsi::String::createFromUtf8(runtime, worker->kind)); runtime.global().setProperty(runtime, "__THREADED_RUNTIME_ENV__", std::move(env));
+    }
+  });
+  settings.InstanceLoaded([weak, dispatcher](auto const &, React::InstanceLoadedEventArgs const &args) {
+    auto context = React::ReactContext(args.Context()); auto failed = args.Failed();
+    dispatcher.Post([weak, context, failed]() {
+      auto worker = weak.lock(); if (!worker || worker->stopped) return;
+      if (failed) { StopWorker(worker->name, "Worker bundle failed to load; inspect Metro and native logs"); return; }
+      worker->context = context; worker->ready = true; auto pending = std::move(worker->pending); for (auto &callback : pending) callback("");
+    });
+  });
+  workers.emplace(name, worker); LoadWorker(worker); WorkerDeadline(weak, dispatcher); return worker;
+}
+static void WhenReady(std::shared_ptr<Worker> const &worker, std::function<void(std::string const &)> callback) {
+  if (worker->ready) callback(""); else { if (worker->pending.size() >= 1000) throw winrt::hresult_error(E_FAIL, L"Too many pending runtime operations"); worker->pending.push_back(std::move(callback)); }
+}
+static winrt::fire_and_forget CallDeadline(std::string id, React::ReactDispatcher dispatcher) {
+  co_await winrt::resume_after(std::chrono::seconds(120)); dispatcher.Post([id]() { auto found = runtimeCalls.find(id); if (found != runtimeCalls.end()) { found->second.promise.Reject(React::ReactError{"E_RUNTIME_TIMEOUT", "Runtime call exceeded 120 seconds"}); runtimeCalls.erase(found); } });
+}
+struct RuntimeProps : winrt::implements<RuntimeProps, React::IComponentProps> {
+  std::string name = "background-list", app = "ThreadedRuntimeHost", component, key, props = "{}"; React::ViewProps view{nullptr};
+  void SetProp(uint32_t, winrt::hstring const &key, React::IJSValueReader const &reader) noexcept { if (key == L"runtimeName") React::ReadValue(reader, name); else if (key == L"appName") React::ReadValue(reader, app); else if (key == L"initialPropsJson") React::ReadValue(reader, props); else if (key == L"componentName") React::ReadValue(reader, component); else if (key == L"surfaceKey") React::ReadValue(reader, this->key); }
+};
+struct RuntimeSurface : winrt::implements<RuntimeSurface, winrt::Windows::Foundation::IInspectable> {
+  winrt::weak_ref<Composition::ContentIslandComponentView> view; React::ReactNativeIsland island{nullptr};
+  React::EventEmitter emitter{nullptr}; std::string failure;
+  void Fail(std::string const &message) { failure = message; if (emitter) emitter.DispatchEvent(L"runtimeError", [message](React::IJSValueWriter const &writer) { writer.WriteObjectBegin(); writer.WritePropertyName(L"message"); writer.WriteString(winrt::to_hstring(message)); writer.WriteObjectEnd(); }); }
+  std::string name, app, component, key, props; uint64_t generation = 0; bool mounted = false;
+  void Close() noexcept { ++generation; auto previous = island; island = nullptr; if (previous) { try { previous.ReactViewHost(nullptr); previous.Island().Close(); } catch (...) { /* The containing island may already be closing. */ } } }
+  Json::JsonObject InitialProps() {
+    Json::JsonObject::Parse(winrt::to_hstring(props)); // Validate before entering an RNW writer callback.
+    Json::JsonObject value;
+    value.SetNamedValue(L"componentName", Json::JsonValue::CreateStringValue(winrt::to_hstring(component)));
+    value.SetNamedValue(L"initialPropsJson", Json::JsonValue::CreateStringValue(winrt::to_hstring(props)));
+    value.SetNamedValue(L"runtimeName", Json::JsonValue::CreateStringValue(winrt::to_hstring(name)));
+    return value;
+  }
+  void Render() { try {
+    if (!mounted || name.empty() || app.empty()) return; Close();
+    auto worker = GetWorker(name); auto weak = get_weak(); const auto expected = generation;
+    WhenReady(worker, [weak, expected, worker](std::string const &error) {
+      auto self = weak.get(); if (!self || !self->mounted || self->generation != expected) return;
+      if (!error.empty()) { self->Fail(error); return; }
+      try {
+      auto view = self->view.get(); if (!view) return;
+      self->island = React::ReactNativeIsland(compositor); React::ReactViewOptions options; options.ComponentName(winrt::to_hstring(self->app));
+      auto props = self->InitialProps(); options.InitialProps([props](React::IJSValueWriter const &writer) { WriteJson(writer, props); });
+      self->island.ReactViewHost(React::ReactCoreInjection::MakeViewHost(worker->host, options)); view.Connect(self->island.Island());
+      worker->detach.push_back([weak, expected]() { if (auto self = weak.get(); self && self->generation == expected) self->Close(); });
+      } catch (...) { self->Fail(winrt::to_string(winrt::to_message())); }
+    });
+  } catch (...) { Fail(winrt::to_string(winrt::to_message())); } }
+};
+static void RegisterRuntimeSurface(React::IReactPackageBuilder const &package) {
+  package.as<React::IReactPackageBuilderFabric>().AddViewComponent(L"ThreadedRuntimeSurface", [](React::IReactViewComponentBuilder const &builder) {
+    builder.SetCreateProps([](React::ViewProps const &view, React::IComponentProps const &previous) { auto props = winrt::make_self<RuntimeProps>(); if (previous) { auto old = winrt::get_self<RuntimeProps>(previous); props->name = old->name; props->app = old->app; props->component = old->component; props->key = old->key; props->props = old->props; } props->view = view; return props.as<React::IComponentProps>(); });
+    builder.as<Composition::IReactCompositionViewComponentBuilder>().SetContentIslandComponentViewInitializer([](Composition::ContentIslandComponentView const &view) {
+      auto state = winrt::make_self<RuntimeSurface>(); state->view = view; view.UserData(state.as<winrt::Windows::Foundation::IInspectable>()); auto weak = state->get_weak();
+      view.Mounted([weak](auto const &, auto const &) { if (auto self = weak.get()) { self->mounted = true; self->Render(); } });
+      view.Unmounted([weak](auto const &, auto const &) { if (auto self = weak.get()) { self->mounted = false; self->Close(); } });
+      view.Destroying([weak](auto const &, auto const &) { if (auto self = weak.get()) { self->mounted = false; self->Close(); } });
+    });
+    builder.SetUpdateEventEmitterHandler([](React::ComponentView const &view, React::EventEmitter const &emitter) { auto state = winrt::get_self<RuntimeSurface>(view.UserData()); state->emitter = emitter; if (!state->failure.empty()) state->Fail(state->failure); });
+    builder.SetUpdatePropsHandler([](React::ComponentView const &view, React::IComponentProps const &props, React::IComponentProps const &) {
+      auto self = winrt::get_self<RuntimeSurface>(view.UserData()); auto value = winrt::get_self<RuntimeProps>(props);
+      bool recreate = self->name != value->name || self->app != value->app || self->key != value->key; self->name = value->name; self->app = value->app; self->component = value->component; self->key = value->key; self->props = value->props;
+      if (recreate || !self->island) self->Render(); else { try { auto props = self->InitialProps(); self->island.SetProperties([props](React::IJSValueWriter const &writer) { WriteJson(writer, props); }); } catch (...) { self->Fail(winrt::to_string(winrt::to_message())); } }
+    });
+  });
+}
+}
+REACT_MODULE(SparkThreadedRuntime, L"ThreadedRuntime")
+struct SparkThreadedRuntime {
+  using Promise = winrt::Microsoft::ReactNative::ReactPromise<void>;
+  winrt::Microsoft::ReactNative::ReactContext context; std::shared_ptr<bool> owner;
+  REACT_INIT(Initialize) void Initialize(winrt::Microsoft::ReactNative::ReactContext const &value) noexcept { context = value; if (!SparkWin::IsSecondary(context)) { owner = std::make_shared<bool>(true); context.UIDispatcher().Post([token = owner]() { SparkWin::StopWorkers(); SparkWin::runtimeOwner = token; }); } }
+  ~SparkThreadedRuntime() { if (owner) context.UIDispatcher().Post([token = owner]() { if (SparkWin::runtimeOwner == token) { SparkWin::StopWorkers(); SparkWin::runtimeOwner.reset(); } }); }
+  template<typename F> void UI(F action, Promise promise) { context.UIDispatcher().Post([action, promise]() { try { action(); promise.Resolve(); } catch (winrt::hresult_error const &error) { promise.Reject(winrt::Microsoft::ReactNative::ReactError{"E_RUNTIME", winrt::to_string(error.message())}); } catch (std::exception const &error) { promise.Reject(error.what()); } }); }
+  REACT_METHOD(prewarmRuntime) void prewarmRuntime(std::string name, Promise promise) noexcept { prewarmRuntimeWithOptions(name, "threaded-runtime", false, promise); }
+  REACT_METHOD(prewarmRuntimeWithOptions) void prewarmRuntimeWithOptions(std::string name, std::string kind, bool useMainNativeModules, Promise promise) noexcept {
+    if (useMainNativeModules) { promise.Reject(winrt::Microsoft::ReactNative::ReactError{"E_RUNTIME_OPTIONS", "Windows workers own independent native module instances; useMainNativeModules is not supported"}); return; }
+    context.UIDispatcher().Post([name, kind, promise]() { try { auto worker = SparkWin::GetWorker(name, kind); SparkWin::WhenReady(worker, [promise](std::string const &error) { if (error.empty()) promise.Resolve(); else promise.Reject(error.c_str()); }); } catch (winrt::hresult_error const &error) { promise.Reject(winrt::to_string(error.message()).c_str()); } });
+  }
+  REACT_METHOD(notifyRuntimeReady) void notifyRuntimeReady(std::string, Promise promise) noexcept { promise.Resolve(); /* InstanceLoaded gates calls after the complete worker bundle. */ }
+  REACT_METHOD(dispatchHeadlessTask) void dispatchHeadlessTask(std::string name, std::string task, std::string payload, Promise promise) noexcept {
+    context.UIDispatcher().Post([name, task, payload, promise]() { try { auto worker = SparkWin::GetWorker(name); SparkWin::WhenReady(worker, [worker, task, payload, promise](std::string const &error) { if (!error.empty()) { promise.Reject(error.c_str()); return; } worker->context.CallJSFunction(L"ThreadedRuntimeHeadlessTaskRunner", L"run", task, payload, worker->name); promise.Resolve(); }); } catch (winrt::hresult_error const &error) { promise.Reject(winrt::to_string(error.message()).c_str()); } });
+  }
+  REACT_METHOD(callRuntimeFunction) void callRuntimeFunction(std::string name, std::string function, std::string args, winrt::Microsoft::ReactNative::ReactPromise<std::string> promise) noexcept {
+    auto dispatcher = context.UIDispatcher(); dispatcher.Post([name, function, args, promise, dispatcher]() {
+      using namespace SparkWin;
+      try {
+        if (runtimeCalls.size() >= 1000) throw winrt::hresult_error(E_FAIL, L"Too many runtime calls");
+        auto worker = GetWorker(name); auto id = std::to_string(++runtimeCallSequence);
+        if (!worker->ready && worker->pending.size() >= 1000) throw winrt::hresult_error(E_FAIL, L"Too many pending runtime operations");
+        runtimeCalls.emplace(id, RuntimeCall{name, promise}); CallDeadline(id, dispatcher);
+        WhenReady(worker, [worker, id, function, args](std::string const &error) { auto found = runtimeCalls.find(id); if (found == runtimeCalls.end()) return; if (!error.empty()) { found->second.promise.Reject(error.c_str()); runtimeCalls.erase(found); return; } worker->context.CallJSFunction(L"ThreadedRuntimeFunctionRunner", L"run", function, args, id, worker->name); });
+      } catch (winrt::hresult_error const &error) { promise.Reject(winrt::to_string(error.message()).c_str()); }
+    });
+  }
+  REACT_METHOD(completeRuntimeFunctionCall) void completeRuntimeFunctionCall(std::string id, std::optional<std::string> result, std::optional<std::string> error, Promise promise) noexcept {
+    UI([id, result, error]() { auto found = SparkWin::runtimeCalls.find(id); if (found == SparkWin::runtimeCalls.end()) return; if (error) found->second.promise.Reject(error->c_str()); else found->second.promise.Resolve(result.value_or("null")); SparkWin::runtimeCalls.erase(found); }, promise);
+  }
+  REACT_METHOD(destroyRuntime) void destroyRuntime(std::string name, Promise promise) noexcept { UI([name]() { SparkWin::StopWorker(name, "Runtime was destroyed"); }, promise); }
+  REACT_METHOD(destroyAllRuntimes) void destroyAllRuntimes(Promise promise) noexcept { UI([]() { SparkWin::StopWorkers(); }, promise); }
+  REACT_METHOD(getRuntimeNames) void getRuntimeNames(winrt::Microsoft::ReactNative::ReactPromise<std::vector<std::string>> promise) noexcept { context.UIDispatcher().Post([promise]() { std::vector<std::string> names; for (auto const &[name, worker] : SparkWin::workers) names.push_back(name); promise.Resolve(names); }); }
+};

package/vendor/node_modules/@legendapp/spark-desktop-links/RNDesktopLinks.podspec

@@ -0,0 +1,17 @@
+require "json"
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+Pod::Spec.new do |s|
+  s.name = "RNDesktopLinks"
+  s.version = package["version"]
+  s.summary = "Desktop desktop-links"
+  s.license = { :type => "MIT" }
+  s.author = "Legend"
+  s.homepage = "https://legendapp.com"
+  s.source = { :path => "." }
+  s.platforms = { :osx => "14.0" }
+  s.source_files = "macos/**/*.{h,m,mm}", "common/**/*.h"
+  s.frameworks = "Security"
+  s.dependency "React-Core"
+  s.dependency "ReactCodegen"
+  s.dependency "RNDesktopApp"
+end

package/vendor/node_modules/@legendapp/spark-desktop-links/common/AuthLoopback.h

@@ -0,0 +1,121 @@
+#pragma once
+// Minimal, bounded loopback HTTP receiver. No Node runtime and no general server API.
+#ifdef _WIN32
+#include <winsock2.h>
+#include <ws2tcpip.h>
+#pragma comment(lib, "Ws2_32.lib")
+#else
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <unistd.h>
+#endif
+#include <atomic>
+#include <chrono>
+#include <mutex>
+#include <string>
+#include <vector>
+#include <thread>
+#include <stdexcept>
+#include <algorithm>
+#include <cctype>
+namespace spark {
+#ifdef _WIN32
+using AuthSocket = SOCKET;
+static constexpr AuthSocket InvalidSocket = INVALID_SOCKET;
+inline void CloseSocket(AuthSocket fd) { closesocket(fd); }
+#else
+using AuthSocket = int;
+static constexpr AuthSocket InvalidSocket = -1;
+inline void CloseSocket(AuthSocket fd) { close(fd); }
+#endif
+class AuthLoopback {
+  AuthSocket listener = InvalidSocket;
+  std::atomic<bool> stopped{false};
+  std::thread worker;
+  std::mutex mutex;
+  std::vector<std::string> results;
+  std::string route, origin;
+  bool initialized = false;
+  void Receive() {
+    const auto expires = std::chrono::steady_clock::now() + std::chrono::minutes(10);
+    while (!stopped && std::chrono::steady_clock::now() < expires) {
+      fd_set sockets; FD_ZERO(&sockets); FD_SET(listener, &sockets); timeval wait{0, 100000};
+      if (select(static_cast<int>(listener + 1), &sockets, nullptr, nullptr, &wait) <= 0) continue;
+      AuthSocket client = accept(listener, nullptr, nullptr); if (client == InvalidSocket) continue;
+#ifdef _WIN32
+      DWORD timeout = 200; setsockopt(client, SOL_SOCKET, SO_RCVTIMEO, reinterpret_cast<char *>(&timeout), sizeof(timeout)); setsockopt(client, SOL_SOCKET, SO_SNDTIMEO, reinterpret_cast<char *>(&timeout), sizeof(timeout));
+#else
+      timeval timeout{0, 200000}; setsockopt(client, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout)); setsockopt(client, SOL_SOCKET, SO_SNDTIMEO, &timeout, sizeof(timeout));
+      int noPipe = 1; setsockopt(client, SOL_SOCKET, SO_NOSIGPIPE, &noPipe, sizeof(noPipe));
+#endif
+      std::string request; char buffer[1024];
+      auto deadline = std::chrono::steady_clock::now() + std::chrono::seconds(2);
+      while (!stopped && request.size() < 8192 && request.find("\r\n\r\n") == std::string::npos && std::chrono::steady_clock::now() < deadline) {
+        int count = recv(client, buffer, sizeof(buffer), 0); if (count <= 0) break; request.append(buffer, count);
+      }
+      bool valid = false;
+      std::string target;
+      auto first = request.find("\r\n");
+      if (!stopped && request.size() <= 8192 && request.find("\r\n\r\n") != std::string::npos && request.starts_with("GET ") && first != std::string::npos) {
+        auto end = request.find(' ', 4);
+        if (end != std::string::npos && end < first) {
+          target = request.substr(4, end - 4);
+          const auto query = target.find('?');
+          std::string headers = request.substr(first + 2);
+          std::transform(headers.begin(), headers.end(), headers.begin(), [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
+          const auto host = std::string("host: ") + origin.substr(7) + "\r\n";
+          valid = target.substr(0, query) == route && target.find('#') == std::string::npos &&
+            (headers.starts_with(host) || headers.find("\r\n" + host) != std::string::npos) &&
+            std::all_of(target.begin(), target.end(), [](unsigned char c) { return c > 32 && c < 127; }) &&
+            (request.substr(end, first - end) == " HTTP/1.1" || request.substr(end, first - end) == " HTTP/1.0");
+        }
+      }
+      if (valid) { std::lock_guard lock(mutex); if (results.size() < 16) results.push_back(origin + target); }
+      const std::string body = valid ? "Callback received. You may return to the application." : "Invalid callback request.";
+      const std::string response = std::string("HTTP/1.1 ") + (valid ? "200 OK" : "400 Bad Request") + "\r\nContent-Type: text/plain; charset=utf-8\r\nCache-Control: no-store\r\nConnection: close\r\nContent-Length: " + std::to_string(body.size()) + "\r\n\r\n" + body;
+      send(client, response.data(), static_cast<int>(response.size()), 0); CloseSocket(client);
+    }
+    CloseSocket(listener); listener = InvalidSocket;
+  }
+ public:
+  AuthLoopback(unsigned short port, std::string path) : route(std::move(path)) {
+    if (route.empty() || route[0] != '/' || route.find_first_not_of("/abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_") != std::string::npos) throw std::invalid_argument("Invalid callback path");
+#ifdef _WIN32
+    WSADATA data{}; if (WSAStartup(MAKEWORD(2, 2), &data)) throw std::runtime_error("Could not initialize loopback socket"); initialized = true;
+#endif
+    try {
+      listener = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); if (listener == InvalidSocket) throw std::runtime_error("Could not create loopback socket");
+#ifdef _WIN32
+      BOOL exclusive = TRUE; setsockopt(listener, SOL_SOCKET, SO_EXCLUSIVEADDRUSE, reinterpret_cast<char *>(&exclusive), sizeof(exclusive));
+#endif
+#ifndef _WIN32
+      if (listener >= FD_SETSIZE) throw std::runtime_error("Loopback descriptor exceeds select capacity");
+#endif
+      sockaddr_in address{}; address.sin_family = AF_INET; address.sin_addr.s_addr = htonl(INADDR_LOOPBACK); address.sin_port = htons(port);
+      if (bind(listener, reinterpret_cast<sockaddr *>(&address), sizeof(address)) != 0 || listen(listener, 8) != 0) throw std::runtime_error("Could not bind loopback callback port");
+#ifdef _WIN32
+      int size = sizeof(address);
+#else
+      socklen_t size = sizeof(address);
+#endif
+      if (getsockname(listener, reinterpret_cast<sockaddr *>(&address), &size) != 0) throw std::runtime_error("Could not read loopback port");
+      origin = "http://127.0.0.1:" + std::to_string(ntohs(address.sin_port));
+      worker = std::thread([this] { Receive(); });
+    } catch (...) { if (listener != InvalidSocket) CloseSocket(listener);
+#ifdef _WIN32
+      if (initialized) WSACleanup();
+#endif
+      throw;
+    }
+  }
+  ~AuthLoopback() { stopped = true; if (worker.joinable()) worker.join();
+#ifdef _WIN32
+    if (initialized) WSACleanup();
+#endif
+  }
+  std::string RedirectURI() const { return origin + route; }
+  std::vector<std::string> Drain() { std::lock_guard lock(mutex); auto values = std::move(results); results.clear(); return values; }
+  AuthLoopback(AuthLoopback const &) = delete;
+};
+}

package/vendor/node_modules/@legendapp/spark-desktop-links/macos/RNDesktopLinks.h

@@ -0,0 +1,4 @@
+#import <RNDesktopLinksSpec/RNDesktopLinksSpec.h>
+#import <Foundation/Foundation.h>
+@interface RNDesktopLinks : NSObject <NativeDesktopLinksSpec>
+@end

package/vendor/node_modules/@legendapp/spark-desktop-links/macos/RNDesktopLinks.mm

@@ -0,0 +1,79 @@
+#import "RNDesktopLinks.h"
+#import <RNDesktopApp/SparkDesktop.h>
+#import <Security/Security.h>
+#import <CommonCrypto/CommonDigest.h>
+#include "../common/AuthLoopback.h"
+#include <map>
+#include <memory>
+@implementation RNDesktopLinks {
+  std::map<std::string, std::unique_ptr<spark::AuthLoopback>> _authSessions;
+}
+RCT_EXPORT_MODULE(NativeDesktopLinks)
+- (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 hasPrefix:@"auth"] || [method hasPrefix:@"crypto"]) {
+      try {
+        NSString *identifier = args[@"id"] ?: @"";
+        std::string key(identifier.UTF8String);
+        if ([method isEqual:@"cryptoRandom"]) {
+          NSInteger count = [args[@"count"] integerValue]; if (count < 1 || count > 1024) throw std::invalid_argument("Random byte count must be 1–1024");
+          NSMutableData *bytes = [NSMutableData dataWithLength:count];
+          if (SecRandomCopyBytes(kSecRandomDefault, count, bytes.mutableBytes) != errSecSuccess) throw std::runtime_error("Secure random generation failed");
+          resolve(SparkJSON([bytes base64EncodedStringWithOptions:0]));
+        } else if ([method isEqual:@"cryptoDigest"]) {
+          NSData *data = [args[@"value"] dataUsingEncoding:NSUTF8StringEncoding];
+          if (!data || data.length > 1048576) throw std::invalid_argument("Digest input exceeds 1 MiB");
+          unsigned char digest[CC_SHA256_DIGEST_LENGTH]; CC_SHA256(data.bytes, (CC_LONG)data.length, digest);
+          NSMutableString *hex = [NSMutableString new]; for (unsigned char byte : digest) [hex appendFormat:@"%02x", byte]; resolve(SparkJSON(hex));
+        } else if ([method isEqual:@"authPrepare"]) {
+          if (key.empty() || _authSessions.count(key) || _authSessions.size() >= 4) throw std::invalid_argument("Invalid or busy auth session");
+          NSInteger port = [args[@"port"] integerValue]; if (port < 0 || port > 65535) throw std::invalid_argument("Invalid callback port");
+          auto receiver = std::make_unique<spark::AuthLoopback>((unsigned short)port, std::string([args[@"path"] UTF8String]));
+          NSString *uri = [NSString stringWithUTF8String:receiver->RedirectURI().c_str()]; _authSessions.emplace(key, std::move(receiver)); resolve(SparkJSON(uri));
+        } else if ([method isEqual:@"authClose"]) { _authSessions.erase(key); resolve(@"null"); }
+        else if ([method isEqual:@"authPoll"]) {
+          auto found = _authSessions.find(key); if (found == _authSessions.end()) throw std::invalid_argument("Auth session is closed");
+          NSMutableArray *urls = [NSMutableArray new]; for (auto const &value : found->second->Drain()) [urls addObject:[NSString stringWithUTF8String:value.c_str()]];
+          resolve(SparkJSON(urls));
+        } else throw std::invalid_argument("Unknown auth operation");
+      } catch (std::exception const &error) { reject(@"E_AUTH", [NSString stringWithUTF8String:error.what()], nil); }
+      return;
+    }
+    if ([method isEqual:@"recent"]) {
+      NSArray *result = [NSUserDefaults.standardUserDefaults arrayForKey:[SparkNamespace() stringByAppendingString:@".recentDocuments"]] ?: @[];
+      resolve(SparkJSON(result)); return;
+    }
+    if ([method isEqual:@"clearRecent"]) {
+      [NSUserDefaults.standardUserDefaults removeObjectForKey:[SparkNamespace() stringByAppendingString:@".recentDocuments"]];
+      if (![SparkContext()[@"runtime"][@"mode"] isEqual:@"go"]) [NSDocumentController.sharedDocumentController clearRecentDocuments:nil];
+      resolve(@"null"); return;
+    }
+    NSURL *url = [NSURL URLWithString:args[@"url"] ?: @""];
+    if (!url.scheme.length) { SparkInvalid(reject, @"URL must have a scheme"); return; }
+    if ([method isEqual:@"canOpen"]) resolve(SparkJSON(@([NSWorkspace.sharedWorkspace URLForApplicationToOpenURL:url] != nil)));
+    else if ([method isEqual:@"open"]) {
+      // Opening a URL can deliver an Apple event back to this app. Keep its
+      // main run loop free while LaunchServices resolves and opens the target.
+      [NSWorkspace.sharedWorkspace openURL:url configuration:NSWorkspaceOpenConfiguration.configuration
+        completionHandler:^(NSRunningApplication *application, NSError *error) {
+          if (error) reject(@"E_OPEN_URL", error.localizedDescription, error);
+          else resolve(@"null");
+        }];
+    } else if ([method isEqual:@"noteRecent"]) {
+      if (!url.isFileURL) { SparkInvalid(reject, @"Recent documents must be file URLs"); return; }
+      NSString *key = [SparkNamespace() stringByAppendingString:@".recentDocuments"];
+      NSMutableArray *recent = [[NSUserDefaults.standardUserDefaults arrayForKey:key] mutableCopy] ?: [NSMutableArray new];
+      [recent removeObject:url.absoluteString]; [recent insertObject:url.absoluteString atIndex:0];
+      if (recent.count > 20) [recent removeLastObject];
+      [NSUserDefaults.standardUserDefaults setObject:recent forKey:key];
+      if (![SparkContext()[@"runtime"][@"mode"] isEqual:@"go"]) [NSDocumentController.sharedDocumentController noteNewRecentDocumentURL:url];
+      resolve(@"null");
+    } else SparkInvalid(reject, @"Unknown links operation");
+  });
+}
+- (void)invalidate { dispatch_async(dispatch_get_main_queue(), ^{ self->_authSessions.clear(); }); }
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:(const facebook::react::ObjCTurboModule::InitParams &)params {
+  return std::make_shared<facebook::react::NativeDesktopLinksSpecJSI>(params);
+}
+@end

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

@@ -0,0 +1,53 @@
+{
+  "name": "@legendapp/spark-desktop-links",
+  "version": "0.0.1-next.2",
+  "license": "MIT",
+  "main": "src/index",
+  "react-native": "src/index",
+  "files": [
+    "src",
+    "macos",
+    "*.podspec",
+    "react-native.config.js",
+    "windows",
+    "common"
+  ],
+  "peerDependencies": {
+    "react": "19.1.4",
+    "react-native": "0.81.6",
+    "expo-linking": "~8.0.12"
+  },
+  "codegenConfig": {
+    "name": "RNDesktopLinksSpec",
+    "type": "modules",
+    "jsSrcsDir": "src",
+    "ios": {
+      "modulesProvider": {
+        "NativeDesktopLinks": "RNDesktopLinks"
+      }
+    }
+  },
+  "spark": {
+    "sdk": true,
+    "nativeModules": [
+      "NativeDesktopLinks"
+    ],
+    "pod": "RNDesktopLinks",
+    "platforms": [
+      "macos",
+      "windows"
+    ],
+    "requires": [
+      "@legendapp/spark-desktop-app"
+    ]
+  },
+  "dependencies": {
+    "@legendapp/spark-desktop-app": "0.0.1-next.2"
+  },
+  "peerDependenciesMeta": {
+    "expo-linking": {
+      "optional": true
+    }
+  },
+  "private": true
+}

package/vendor/node_modules/@legendapp/spark-desktop-links/react-native.config.js

@@ -0,0 +1,6 @@
+// Expo Desktop currently invokes the Apple autolinker with --platform ios.
+// Its generated Podfile identifies macOS explicitly; ordinary iOS apps use Expo backends.
+module.exports = { dependency: { platforms: {
+  ios: process.env.SPARK_DESKTOP_AUTOLINK === "macos" ? {} : null,
+  android: null,
+} } };

package/vendor/node_modules/@legendapp/spark-desktop-links/src/NativeDesktopLinks.ts

@@ -0,0 +1,6 @@
+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>("NativeDesktopLinks");

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

@@ -0,0 +1,37 @@
+import Native from "./NativeDesktopLinks";
+import { callApp, onDesktopEvent, type DesktopEvent } from "@legendapp/spark-desktop-app";
+export type OpenEvent = { type: "openFile" | "openURL"; id: string; url: string };
+function url(value: string) { if (!/^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(value)) throw new Error("URL must include a scheme"); return value; }
+async function call<T = void>(method: string, args: object = {}): Promise<T> { return JSON.parse(await Native.call(method, JSON.stringify(args))) as T; }
+export async function openURL(value: string): Promise<true> {
+  await call("open", { url: url(value) }); return true;
+}
+export async function canOpenURL(value: string): Promise<boolean> { return call("canOpen", { url: url(value) }); }
+export const noteRecentDocument = (value: string) => call("noteRecent", { url: url(value) });
+export const clearRecentDocuments = () => call("clearRecent");
+export const getRecentDocuments = () => call<string[]>("recent");
+/** Subscribe before fetching queued launches; event ids deduplicate the overlap. */
+export async function onOpen(listener: (event: OpenEvent) => void) {
+  const seen = new Set<string>(); let removed = false;
+  function deliver(event: DesktopEvent) {
+    if (removed || (event.type !== "openFile" && event.type !== "openURL") || !event.id || seen.has(event.id)) return;
+    seen.add(event.id);
+    if (seen.size > 200) seen.delete(seen.values().next().value!);
+    listener(event as OpenEvent);
+  }
+  const subscription = onDesktopEvent(deliver);
+  try { for (const event of await callApp<DesktopEvent[]>("pendingURLs")) deliver(event); }
+  catch (error) { subscription.remove(); throw error; }
+  return { remove() { removed = true; subscription.remove(); } };
+}
+
+export type URLListener = (event: { url: string }) => void;
+/** URL that launched this native process, or null; stable across later opens and JS reloads. */
+export const getInitialURL = (): Promise<string | null> => callApp("initialURL");
+/** Live URL events only. Use onOpen for queued desktop URLs and file-open events. */
+export function addEventListener(type: "url", listener: URLListener): { remove(): void } {
+  if (type !== "url" || typeof listener !== "function") throw new TypeError("Expected a url event listener");
+  return onDesktopEvent(event => {
+    if (event.type === "openURL" && event.initial !== true && typeof event.url === "string") listener({ url: event.url });
+  });
+}

package/vendor/node_modules/@legendapp/spark-desktop-links/src/expo.ts

@@ -0,0 +1,5 @@
+export { openURL, canOpenURL, getInitialURL, addEventListener } from "expo-linking";
+export type { OpenEvent, URLListener } from "./index";
+/** Legacy desktop facilities have no shared equivalent. */
+const unavailable = async (..._args: unknown[]): Promise<never> => { throw Object.assign(new Error("Desktop document events/history are unavailable on this platform; use URL events instead"), { code: "E_UNAVAILABLE" }); };
+export const onOpen = unavailable, noteRecentDocument = unavailable, clearRecentDocuments = unavailable, getRecentDocuments = unavailable;

package/vendor/node_modules/@legendapp/spark-desktop-links/src/index.android.ts

@@ -0,0 +1 @@
+export * from "./expo";