@legendapp/spark 0.0.1-next.2

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

@@ -0,0 +1,46 @@
+{
+  "name": "@legendapp/spark-processes",
+  "version": "0.0.1-next.2",
+  "license": "MIT",
+  "main": "src/index.ts",
+  "react-native": "src/index.ts",
+  "files": [
+    "src",
+    "macos",
+    "*.podspec",
+    "windows",
+    "react-native.config.js"
+  ],
+  "peerDependencies": {
+    "react": "19.1.4",
+    "react-native": "0.81.6"
+  },
+  "codegenConfig": {
+    "name": "RNDesktopProcessesSpec",
+    "type": "modules",
+    "jsSrcsDir": "src",
+    "ios": {
+      "modulesProvider": {
+        "NativeDesktopProcesses": "RNDesktopProcesses"
+      }
+    }
+  },
+  "spark": {
+    "sdk": true,
+    "nativeModules": [
+      "NativeDesktopProcesses"
+    ],
+    "pod": "RNDesktopProcesses",
+    "platforms": [
+      "macos",
+      "windows"
+    ],
+    "requires": [
+      "@legendapp/spark-desktop-app"
+    ]
+  },
+  "dependencies": {
+    "@legendapp/spark-desktop-app": "0.0.1-next.2"
+  },
+  "private": true
+}

package/vendor/node_modules/@legendapp/spark-processes/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-processes/src/NativeDesktopProcesses.ts

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

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

@@ -0,0 +1,39 @@
+import { Platform } from "react-native";
+import Native from "./NativeDesktopProcesses";
+import { onDesktopEvent } from "@legendapp/spark-desktop-app";
+export type ProcessOptions = { executable: string; args?: string[]; cwd?: string; env?: Record<string, string>; timeoutMs?: number; input?: string };
+export type ProcessOutput = { stream: "stdout" | "stderr"; base64: string };
+export type ProcessResult = { exitCode: number; signal: boolean; stdout: string; stderr: string; stdoutBase64: string; stderrBase64: string; timedOut: boolean; outputTruncated: boolean };
+let sequence = 0;
+function absolute(value: string) { return Platform.OS === "windows" ? /^(?:[a-z]:[\\/]|\\\\[^\\/]+[\\/][^\\/]+)/i.test(value) : value.startsWith("/"); }
+export async function spawn(options: ProcessOptions, onOutput?: (chunk: ProcessOutput) => void) {
+  if (typeof options.executable !== "string" || (options.executable.startsWith("helper:") && !/^helper:[A-Za-z0-9_-]+$/.test(options.executable))) throw new Error("Invalid helper name or executable");
+  if (options.input !== undefined && typeof options.input !== "string") throw new Error("input must be a string");
+  if (!absolute(options.executable) && !options.executable.startsWith("helper:")) throw new Error("executable must be an absolute path or helper:name");
+  if (options.executable.includes("\0") || options.args?.some(arg => typeof arg !== "string" || arg.includes("\0"))) throw new Error("Invalid process arguments");
+  if (options.cwd !== undefined && (!absolute(options.cwd) || options.cwd.includes("\0"))) throw new Error("cwd must be absolute");
+  if (options.env && Object.entries(options.env).some(([key, value]) => !key || /[=\0]/.test(key) || typeof value !== "string" || value.includes("\0"))) throw new Error("Invalid process environment");
+  if (options.timeoutMs !== undefined && (!Number.isFinite(options.timeoutMs) || options.timeoutMs < 1)) throw new Error("timeoutMs must be positive");
+  const id = `process-${Date.now()}-${++sequence}`;
+  let finish!: (value: ProcessResult) => void;
+  let ended = false;
+  const exited = new Promise<ProcessResult>(resolve => { finish = resolve; });
+  const subscription = onDesktopEvent(event => {
+    if (event.processId !== id) return;
+    if (event.type === "processOutput") onOutput?.({ stream: event.stream as "stdout" | "stderr", base64: event.base64 as string });
+    if (event.type === "processExit") { ended = true; subscription.remove(); finish(event.result as ProcessResult); }
+  });
+  const call = async (method: string, args: object = {}) => { await Native.call(method, JSON.stringify({ id, ...args })); };
+  try { await call("spawn", { ...options, streamOutput: !!onOutput }); } catch (error) { subscription.remove(); throw error; }
+  return {
+    id, exited,
+    async write(text: string) { if (typeof text !== "string") throw new Error("Process input must be a string"); if (ended) throw new Error("Process has exited"); await call("write", { text }); },
+    async closeInput() { if (!ended) await call("closeInput"); },
+    async terminate() { if (!ended) await call("terminate"); },
+  };
+}
+export async function runCommand(options: ProcessOptions) {
+  const child = await spawn(options);
+  await child.closeInput();
+  return child.exited;
+}

package/vendor/node_modules/@legendapp/spark-processes/windows/ExperimentalFeatures.props

@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+
+  <PropertyGroup Label="Microsoft.ReactNative Experimental Features">
+    <!--
+      Required for building a New Architecture project.
+
+      Library projects can change this value to test against Old and New
+      Architectures when building the library project's local sln file.
+
+      Otherwise this value will be decided by the consuming RNW app.
+
+      See https://microsoft.github.io/react-native-windows/docs/new-architecture
+    -->
+    <RnwNewArch>true</RnwNewArch>
+
+    <!--
+      Changes compilation to assume use of Microsoft.ReactNative NuGet packages
+      instead of building the framework from source. Defaults to true.
+
+      This is set during library project creation and is used when building
+      the library project's local sln file.
+
+      Otherwise this value will be decided by the consuming RNW app.
+
+      See https://microsoft.github.io/react-native-windows/docs/nuget
+    -->
+    <UseExperimentalNuget>true</UseExperimentalNuget>
+
+    <ReactExperimentalFeaturesSet>true</ReactExperimentalFeaturesSet>
+  </PropertyGroup>
+
+</Project>

package/vendor/node_modules/@legendapp/spark-processes/windows/LICENSE

@@ -0,0 +1,25 @@
+The MIT License (MIT)
+
+Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+
+Portions derived from React Native:
+
+Copyright (c) 2015-present, Facebook, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/vendor/node_modules/@legendapp/spark-processes/windows/SparkProcesses/ReactPackageProvider.cpp

@@ -0,0 +1,20 @@
+#include "pch.h"
+
+#include "ReactPackageProvider.h"
+#if __has_include("ReactPackageProvider.g.cpp")
+#include "ReactPackageProvider.g.cpp"
+#endif
+
+#include "SparkProcesses.h"
+
+using namespace winrt::Microsoft::ReactNative;
+
+namespace winrt::SparkProcesses::implementation
+{
+
+void ReactPackageProvider::CreatePackage(IReactPackageBuilder const &packageBuilder) noexcept
+{
+  AddAttributedModules(packageBuilder, true);
+}
+
+} // namespace winrt::SparkProcesses::implementation

package/vendor/node_modules/@legendapp/spark-processes/windows/SparkProcesses/ReactPackageProvider.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#include "ReactPackageProvider.g.h"
+
+using namespace winrt::Microsoft::ReactNative;
+
+namespace winrt::SparkProcesses::implementation
+{
+
+struct ReactPackageProvider : ReactPackageProviderT<ReactPackageProvider>
+{
+  ReactPackageProvider() = default;
+
+  void CreatePackage(IReactPackageBuilder const &packageBuilder) noexcept;
+};
+
+} // namespace winrt::SparkProcesses::implementation
+
+namespace winrt::SparkProcesses::factory_implementation
+{
+
+struct ReactPackageProvider : ReactPackageProviderT<ReactPackageProvider, implementation::ReactPackageProvider> {};
+
+} // namespace winrt::SparkProcesses::factory_implementation

package/vendor/node_modules/@legendapp/spark-processes/windows/SparkProcesses/ReactPackageProvider.idl

@@ -0,0 +1,9 @@
+namespace SparkProcesses
+{
+  [webhosthidden]
+  [default_interface]
+  runtimeclass ReactPackageProvider : Microsoft.ReactNative.IReactPackageProvider
+  {
+    ReactPackageProvider();
+  };
+}

package/vendor/node_modules/@legendapp/spark-processes/windows/SparkProcesses/SparkProcesses.cpp

@@ -0,0 +1,2 @@
+#include "pch.h"
+#include "SparkProcesses.h"

package/vendor/node_modules/@legendapp/spark-processes/windows/SparkProcesses/SparkProcesses.def

@@ -0,0 +1,3 @@
+EXPORTS
+DllCanUnloadNow = WINRT_CanUnloadNow                    PRIVATE
+DllGetActivationFactory = WINRT_GetActivationFactory    PRIVATE

package/vendor/node_modules/@legendapp/spark-processes/windows/SparkProcesses/SparkProcesses.h

@@ -0,0 +1,171 @@
+#pragma once
+#include "NativeModules.h"
+#include <algorithm>
+#include <atomic>
+#include <condition_variable>
+#include <deque>
+#include <filesystem>
+#include <future>
+#include <fstream>
+#include <map>
+#include <memory>
+#include <mutex>
+#include <optional>
+#include <thread>
+#include <vector>
+#include <wincrypt.h>
+#include <winrt/Windows.Data.Json.h>
+#pragma comment(lib, "Crypt32.lib")
+namespace winrt::SparkProcesses {
+namespace React = Microsoft::ReactNative;
+namespace Json = Windows::Data::Json;
+inline std::wstring Quote(std::wstring const &argument) {
+  std::wstring result = L"\""; size_t slashes = 0;
+  for (auto c : argument) {
+    if (c == L'\\') { ++slashes; continue; }
+    result.append(c == L'"' ? slashes * 2 + 1 : slashes, L'\\'); slashes = 0; result += c;
+  }
+  result.append(slashes * 2, L'\\'); result += L'"'; return result;
+}
+inline std::string Base64(std::string const &bytes) {
+  if (bytes.empty()) return "";
+  DWORD length = 0; if (!CryptBinaryToStringA(reinterpret_cast<BYTE const *>(bytes.data()), static_cast<DWORD>(bytes.size()), CRYPT_STRING_BASE64 | CRYPT_STRING_NOCRLF, nullptr, &length)) throw_last_error();
+  std::string result(length, '\0'); if (!CryptBinaryToStringA(reinterpret_cast<BYTE const *>(bytes.data()), static_cast<DWORD>(bytes.size()), CRYPT_STRING_BASE64 | CRYPT_STRING_NOCRLF, result.data(), &length)) throw_last_error(); result.resize(length); return result;
+}
+inline std::string UTF8(std::string const &bytes) { return bytes.empty() || MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, bytes.data(), static_cast<int>(bytes.size()), nullptr, 0) ? bytes : ""; }
+struct Process : std::enable_shared_from_this<Process> {
+  struct Input { std::string text; bool close; std::optional<React::ReactPromise<std::string>> promise; };
+  handle process, job, input, output, error;
+  std::mutex mutex; std::condition_variable condition; std::deque<Input> queue;
+  std::atomic<bool> done{false}, terminated{false}, timedOut{false}, truncated{false};
+  bool inputClosed = false;
+  std::string id, stdoutBytes, stderrBytes;
+  React::ReactContext context;
+  void Stop() noexcept { terminated = true; if (job) TerminateJobObject(job.get(), 1); }
+  void Write(Input value) { std::lock_guard lock(mutex); if (done || inputClosed) { if (value.promise) { if (value.close) value.promise->Resolve("null"); else value.promise->Reject(React::ReactError{"E_PIPE", "Process input is closed"}); } return; } if (value.close) inputClosed = true; queue.push_back(std::move(value)); condition.notify_one(); }
+  void InputLoop() noexcept {
+    while (true) {
+      Input value;
+      { std::unique_lock lock(mutex); condition.wait(lock, [&]() { return done || !queue.empty(); }); if (queue.empty()) break; value = std::move(queue.front()); queue.pop_front(); }
+      if (done || !input) { if (value.promise) value.promise->Reject(React::ReactError{"E_PIPE", "Process input is closed"}); continue; }
+      bool success = true;
+      if (value.close) input.close();
+      else for (size_t offset = 0; offset < value.text.size();) { DWORD written = 0; if (!WriteFile(input.get(), value.text.data() + offset, static_cast<DWORD>(std::min<size_t>(16384, value.text.size() - offset)), &written, nullptr) || !written) { success = false; break; } offset += written; }
+      if (value.promise) { if (success) value.promise->Resolve("null"); else value.promise->Reject(React::ReactError{"E_PIPE", "Process input is closed"}); }
+    }
+    input.close();
+  }
+  void Read(HANDLE pipe, std::string &buffer, std::string stream, bool streaming, std::shared_ptr<std::atomic<bool>> active) {
+    char bytes[16384]; DWORD count;
+    while (ReadFile(pipe, bytes, sizeof(bytes), &count, nullptr) && count) {
+      const auto keep = std::min<size_t>(count, 8 * 1024 * 1024 - buffer.size()); buffer.append(bytes, keep); if (keep < count) truncated = true;
+      if (streaming && *active) {
+        auto flushed = std::make_shared<std::promise<void>>(); auto wait = flushed->get_future();
+        auto data = Base64(std::string(bytes, count)); auto key = id;
+        context.UIDispatcher().Post([context = context, active, key, stream, data, flushed]() {
+          if (*active) context.EmitJSEvent(L"RCTDeviceEventEmitter", L"desktop", React::JSValueObject{{"type", "processOutput"}, {"processId", key}, {"stream", stream}, {"base64", data}});
+          flushed->set_value();
+        });
+        // Backpressure bounds the JS queue. Runtime shutdown releases this wait.
+        while (*active && wait.wait_for(std::chrono::milliseconds(100)) != std::future_status::ready) {}
+      }
+    }
+  }
+  static void Pipe(handle &read, handle &write, bool parentReads) {
+    SECURITY_ATTRIBUTES security{sizeof(SECURITY_ATTRIBUTES), nullptr, TRUE};
+    if (!CreatePipe(read.put(), write.put(), &security, 0)) throw_last_error();
+    if (!SetHandleInformation(parentReads ? read.get() : write.get(), HANDLE_FLAG_INHERIT, 0)) throw_last_error();
+  }
+  void Start(Json::JsonObject const &args) {
+    auto executable = std::wstring(args.GetNamedString(L"executable"));
+    if (executable.rfind(L"helper:", 0) == 0) {
+      const auto name = executable.substr(7); if (name.empty() || name.find_first_not_of(L"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_-") != std::wstring::npos) throw hresult_invalid_argument(L"Invalid helper name");
+      wchar_t module[32768]{}; GetModuleFileNameW(nullptr, module, 32768);
+      const auto helpers = std::filesystem::path(module).parent_path() / L"Helpers";
+      const auto bundle = helpers / (name + L".helper");
+      executable = (helpers / (name + L".exe")).wstring();
+      if (std::filesystem::exists(bundle)) {
+        std::ifstream metadata(bundle / L".spark-entry", std::ios::binary);
+        std::string entry((std::istreambuf_iterator<char>(metadata)), std::istreambuf_iterator<char>());
+        if (entry.empty() || entry.front() == '/' || entry.find_first_of("\\:") != std::string::npos || entry.find('\0') != std::string::npos) throw hresult_invalid_argument(L"Invalid helper bundle entry");
+        const auto relative = std::filesystem::path(winrt::to_hstring(entry).c_str());
+        for (auto const &part : relative) if (part == L"..") throw hresult_invalid_argument(L"Invalid helper bundle entry");
+        executable = (bundle / relative).wstring();
+      }
+    }
+    if (!std::filesystem::path(executable).is_absolute()) throw hresult_invalid_argument(L"Executable must be absolute");
+    std::wstring command = Quote(executable); for (auto const &value : args.GetNamedArray(L"args", Json::JsonArray())) { command += L' '; command += Quote(std::wstring(value.GetString())); }
+    auto cwd = args.GetNamedString(L"cwd", L"");
+    struct Less { bool operator()(std::wstring const &a, std::wstring const &b) const { return _wcsicmp(a.c_str(), b.c_str()) < 0; } };
+    std::map<std::wstring, std::wstring, Less> environment;
+    auto inherited = GetEnvironmentStringsW(); if (!inherited) throw_last_error();
+    for (auto entry = inherited; *entry; entry += wcslen(entry) + 1) { std::wstring value(entry); auto split = value.find(L'=', value[0] == L'=' ? 1 : 0); if (split != std::wstring::npos) environment[value.substr(0, split)] = value.substr(split + 1); } FreeEnvironmentStringsW(inherited);
+    for (auto const &entry : args.GetNamedObject(L"env", Json::JsonObject())) environment[std::wstring(entry.Key())] = std::wstring(entry.Value().GetString());
+    std::vector<wchar_t> block; for (auto const &[key, value] : environment) { auto pair = key + L"=" + value; block.insert(block.end(), pair.begin(), pair.end()); block.push_back(0); } block.push_back(0);
+    handle childIn, childOut, childErr; Pipe(childIn, input, false); Pipe(output, childOut, true); Pipe(error, childErr, true);
+    STARTUPINFOEXW startup{}; startup.StartupInfo.cb = sizeof(startup); startup.StartupInfo.dwFlags = STARTF_USESTDHANDLES;
+    startup.StartupInfo.hStdInput = childIn.get(); startup.StartupInfo.hStdOutput = childOut.get(); startup.StartupInfo.hStdError = childErr.get();
+    SIZE_T size = 0; InitializeProcThreadAttributeList(nullptr, 1, 0, &size); std::vector<uint8_t> attributes(size); startup.lpAttributeList = reinterpret_cast<LPPROC_THREAD_ATTRIBUTE_LIST>(attributes.data());
+    if (!InitializeProcThreadAttributeList(startup.lpAttributeList, 1, 0, &size)) throw_last_error();
+    struct Cleanup { LPPROC_THREAD_ATTRIBUTE_LIST value; ~Cleanup() { DeleteProcThreadAttributeList(value); } } cleanup{startup.lpAttributeList};
+    HANDLE handles[]{childIn.get(), childOut.get(), childErr.get()};
+    if (!UpdateProcThreadAttribute(startup.lpAttributeList, 0, PROC_THREAD_ATTRIBUTE_HANDLE_LIST, handles, sizeof(handles), nullptr, nullptr)) throw_last_error();
+    job.attach(CreateJobObjectW(nullptr, nullptr)); if (!job) throw_last_error(); JOBOBJECT_EXTENDED_LIMIT_INFORMATION limits{}; limits.BasicLimitInformation.LimitFlags = JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE;
+    if (!SetInformationJobObject(job.get(), JobObjectExtendedLimitInformation, &limits, sizeof(limits))) throw_last_error();
+    PROCESS_INFORMATION info{};
+    if (!CreateProcessW(executable.c_str(), command.data(), nullptr, nullptr, TRUE, EXTENDED_STARTUPINFO_PRESENT | CREATE_UNICODE_ENVIRONMENT | CREATE_NO_WINDOW | CREATE_SUSPENDED, block.data(), cwd.empty() ? nullptr : cwd.c_str(), &startup.StartupInfo, &info)) throw_last_error();
+    process.attach(info.hProcess); handle thread{info.hThread};
+    if (!AssignProcessToJobObject(job.get(), process.get())) { auto error = GetLastError(); TerminateProcess(process.get(), 1); throw hresult_error(HRESULT_FROM_WIN32(error)); }
+    if (ResumeThread(thread.get()) == static_cast<DWORD>(-1)) { Stop(); throw_last_error(); }
+    if (args.HasKey(L"input")) Write({to_string(args.GetNamedString(L"input")), false, std::nullopt});
+  }
+};
+REACT_MODULE(SparkProcesses, L"NativeDesktopProcesses")
+struct SparkProcesses {
+  struct State { React::ReactContext context; std::map<std::string, std::shared_ptr<Process>> processes; std::shared_ptr<std::atomic<bool>> active = std::make_shared<std::atomic<bool>>(true); };
+  std::shared_ptr<State> state = std::make_shared<State>();
+  REACT_INIT(Initialize) void Initialize(React::ReactContext const &context) noexcept { state->context = context; }
+  ~SparkProcesses() { auto current = state; *current->active = false; if (current->context) current->context.UIDispatcher().Post([current]() { for (auto const &[id, process] : current->processes) process->Stop(); }); }
+  REACT_METHOD(call) void call(std::string method, std::string encoded, React::ReactPromise<std::string> promise) noexcept {
+    auto current = state;
+    current->context.UIDispatcher().Post([current, method, encoded, promise]() {
+      try {
+        if (!*current->active) { promise.Reject(React::ReactError{"E_CLOSED", "Process module is closed"}); return; }
+        auto args = Json::JsonObject::Parse(to_hstring(encoded)); auto id = to_string(args.GetNamedString(L"id"));
+        auto found = current->processes.find(id);
+        if (method == "spawn") {
+          if (found != current->processes.end()) { promise.Reject(React::ReactError{"E_EXISTS", "Process id already exists"}); return; }
+          auto child = std::make_shared<Process>(); child->context = current->context; child->id = id; child->Start(args);
+          const auto timeout = args.HasKey(L"timeoutMs") ? static_cast<DWORD>(std::clamp(args.GetNamedNumber(L"timeoutMs"), 1.0, static_cast<double>(INFINITE - 1))) : INFINITE;
+          const bool stream = args.GetNamedBoolean(L"streamOutput", false);
+          std::thread([current, child, timeout, stream]() {
+            std::thread input, output, error;
+            try {
+              input = std::thread([child]() { child->InputLoop(); });
+              output = std::thread([current, child, stream]() { try { child->Read(child->output.get(), child->stdoutBytes, "stdout", stream, current->active); } catch (...) { child->truncated = true; child->Stop(); } });
+              error = std::thread([current, child, stream]() { try { child->Read(child->error.get(), child->stderrBytes, "stderr", stream, current->active); } catch (...) { child->truncated = true; child->Stop(); } });
+            } catch (...) { child->truncated = true; child->Stop(); }
+            if (WaitForSingleObject(child->process.get(), timeout) == WAIT_TIMEOUT) { child->timedOut = true; child->Stop(); WaitForSingleObject(child->process.get(), INFINITE); }
+            DWORD exit = 1; GetExitCodeProcess(child->process.get(), &exit);
+            // Stop descendants that retained pipe handles when their parent exited.
+            TerminateJobObject(child->job.get(), 1); child->done = true; child->condition.notify_all();
+            if (input.joinable()) input.join(); if (output.joinable()) output.join(); if (error.joinable()) error.join();
+            current->context.UIDispatcher().Post([current, child, exit]() {
+              if (*current->active) current->context.EmitJSEvent(L"RCTDeviceEventEmitter", L"desktop", React::JSValueObject{{"type", "processExit"}, {"processId", child->id}, {"result", React::JSValueObject{
+                {"exitCode", static_cast<int64_t>(exit)}, {"signal", child->terminated.load()}, {"timedOut", child->timedOut.load()}, {"outputTruncated", child->truncated.load()},
+                {"stdout", UTF8(child->stdoutBytes)}, {"stderr", UTF8(child->stderrBytes)}, {"stdoutBase64", Base64(child->stdoutBytes)}, {"stderrBase64", Base64(child->stderrBytes)}}});
+              current->processes.erase(child->id);
+            });
+          }).detach();
+          current->processes.emplace(id, child);
+        } else if (found == current->processes.end() || found->second->done) { if (method == "terminate" || method == "closeInput") promise.Resolve("null"); else promise.Reject(React::ReactError{"E_CLOSED", "Process has exited"}); return; }
+        else if (method == "terminate") found->second->Stop();
+        else if (method == "write" || method == "closeInput") { found->second->Write({method == "write" ? to_string(args.GetNamedString(L"text")) : "", method == "closeInput", promise}); return; }
+        else throw hresult_invalid_argument(L"Unknown process operation");
+        promise.Resolve("null");
+      } catch (hresult_error const &error) { promise.Reject(React::ReactError{"E_PROCESS", to_string(error.message())}); }
+      catch (std::exception const &error) { promise.Reject(React::ReactError{"E_PROCESS", error.what()}); }
+    });
+  }
+};
+}

package/vendor/node_modules/@legendapp/spark-processes/windows/SparkProcesses/SparkProcesses.vcxproj

@@ -0,0 +1,143 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- This project was created with react-native-windows 0.81.35 -->
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(SolutionDir)\ExperimentalFeatures.props" Condition="Exists('$(SolutionDir)\ExperimentalFeatures.props')" />
+  <PropertyGroup Label="Globals">
+    <CppWinRTOptimized>true</CppWinRTOptimized>
+    <MinimalCoreWin>true</MinimalCoreWin>
+    <ProjectGuid>{8201AD2E-139E-441B-968A-09B8E6943437}</ProjectGuid>
+    <ProjectName>SparkProcesses</ProjectName>
+    <Keyword>Win32Proj</Keyword>
+    <RootNamespace>SparkProcesses</RootNamespace>
+    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
+    <DefaultLanguage>en-US</DefaultLanguage>
+    <MinimumVisualStudioVersion>17.0</MinimumVisualStudioVersion>
+    <AppxPackage>false</AppxPackage>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Label="ReactNativeWindowsProps">
+    <ReactNativeWindowsDir Condition="'$(ReactNativeWindowsDir)' == ''">$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), 'node_modules\react-native-windows\package.json'))\node_modules\react-native-windows\</ReactNativeWindowsDir>
+    <RunAutolinkCheck>false</RunAutolinkCheck>
+  </PropertyGroup>
+  <Import Project="$(ReactNativeWindowsDir)\PropertySheets\External\Microsoft.ReactNative.WindowsSdk.Default.props" />
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|ARM64">
+      <Configuration>Debug</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|ARM64">
+      <Configuration>Release</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <CharacterSet>Unicode</CharacterSet>
+    <PlatformToolset>v145</PlatformToolset>
+    <GenerateManifest>false</GenerateManifest>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)'=='Debug'" Label="Configuration">
+    <UseDebugLibraries>true</UseDebugLibraries>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)'=='Release'" Label="Configuration">
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="ReactNativeWindowsPropertySheets">
+    <Import Project="$(ReactNativeWindowsDir)\PropertySheets\External\Microsoft.ReactNative.CppLib.props" Condition="Exists('$(ReactNativeWindowsDir)\PropertySheets\External\Microsoft.ReactNative.CppLib.props')" />
+  </ImportGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <PrecompiledHeader>Use</PrecompiledHeader>
+      <PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
+      <PrecompiledHeaderOutputFile>$(IntDir)pch.pch</PrecompiledHeaderOutputFile>
+      <WarningLevel>Level4</WarningLevel>
+      <SDLCheck>true</SDLCheck>
+      <AdditionalOptions>%(AdditionalOptions) /bigobj</AdditionalOptions>
+      <DisableSpecificWarnings>4453;28204</DisableSpecificWarnings>
+      <PreprocessorDefinitions>_WINRT_DLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalUsingDirectories>$(WindowsSDK_WindowsMetadata);$(AdditionalUsingDirectories)</AdditionalUsingDirectories>
+      <AdditionalIncludeDirectories>
+        $(MSBuildThisFileDirectory);
+        %(AdditionalIncludeDirectories)
+      </AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <AdditionalDependencies>shell32.lib;user32.lib;windowsapp.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <SubSystem>Console</SubSystem>
+      <GenerateWindowsMetadata>true</GenerateWindowsMetadata>
+      <ModuleDefinitionFile>SparkProcesses.def</ModuleDefinitionFile>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)'=='Debug'">
+    <ClCompile>
+      <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)'=='Release'">
+    <ClCompile>
+      <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <PropertyGroup Label="UserMacros" />
+  <ItemGroup>
+    <ClInclude Include="SparkProcesses.h" />
+    <ClInclude Include="ReactPackageProvider.h">
+      <DependentUpon>ReactPackageProvider.idl</DependentUpon>
+    </ClInclude>
+    <ClInclude Include="resource.h" />
+    <ClInclude Include="pch.h" />
+    <ClInclude Include="targetver.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="SparkProcesses.cpp" />
+    <ClCompile Include="pch.cpp">
+      <PrecompiledHeader>Create</PrecompiledHeader>
+    </ClCompile>
+    <ClCompile Include="ReactPackageProvider.cpp">
+      <DependentUpon>ReactPackageProvider.idl</DependentUpon>
+    </ClCompile>
+    <ClCompile Include="$(GeneratedFilesDir)module.g.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <Midl Include="ReactPackageProvider.idl" />
+  </ItemGroup>
+  <ItemGroup>
+    <ResourceCompile Include="SparkProcesses.rc" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ReactNativeWindowsTargets">
+    <Import Project="$(ReactNativeWindowsDir)\PropertySheets\External\Microsoft.ReactNative.CppLib.targets" Condition="Exists('$(ReactNativeWindowsDir)\PropertySheets\External\Microsoft.ReactNative.CppLib.targets')" />
+  </ImportGroup>
+  <ItemGroup>
+  </ItemGroup>
+  <Target Name="EnsureReactNativeWindowsTargets" BeforeTargets="PrepareForBuild">
+    <PropertyGroup>
+      <ErrorText>This project references targets in your node_modules\react-native-windows folder. The missing file is {0}.</ErrorText>
+    </PropertyGroup>
+    <Error Condition="!Exists('$(ReactNativeWindowsDir)\PropertySheets\External\Microsoft.ReactNative.CppLib.props')" Text="$([System.String]::Format('$(ErrorText)', '$(ReactNativeWindowsDir)\PropertySheets\External\Microsoft.ReactNative.CppLib.props'))" />
+    <Error Condition="!Exists('$(ReactNativeWindowsDir)\PropertySheets\External\Microsoft.ReactNative.CppLib.targets')" Text="$([System.String]::Format('$(ErrorText)', '$(ReactNativeWindowsDir)\PropertySheets\External\Microsoft.ReactNative.CppLib.targets'))" />
+  </Target>
+</Project>

package/vendor/node_modules/@legendapp/spark-processes/windows/SparkProcesses/SparkProcesses.vcxproj.filters

@@ -0,0 +1,44 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="Source Files">
+      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
+      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
+    </Filter>
+    <Filter Include="Header Files">
+      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
+      <Extensions>h;hh;hpp;hxx;hm;inl;inc;ipp;xsd</Extensions>
+    </Filter>
+    <Filter Include="Resource Files">
+      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
+      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="targetver.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="resource.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="SparkProcesses.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="pch.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="SparkProcesses.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="pch.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <ResourceCompile Include="SparkProcesses.rc">
+      <Filter>Resource Files</Filter>
+    </ResourceCompile>
+  </ItemGroup>
+</Project>

package/vendor/node_modules/@legendapp/spark-processes/windows/SparkProcesses/pch.cpp

@@ -0,0 +1 @@
+#include "pch.h"

package/vendor/node_modules/@legendapp/spark-processes/windows/SparkProcesses/pch.h

@@ -0,0 +1,30 @@
+// pch.h : include file for standard system include files,
+// or project specific include files that are used frequently, but
+// are changed infrequently
+//
+
+#pragma once
+
+#include "targetver.h"
+
+#define NOMINMAX 1
+#define WIN32_LEAN_AND_MEAN 1
+#define WINRT_LEAN_AND_MEAN 1
+
+// Windows Header Files
+#include <windows.h>
+#undef GetCurrentTime
+#include <unknwn.h>
+
+// WinRT Header Files
+#include <winrt/base.h>
+#include <CppWinRTIncludes.h>
+#include <winrt/Microsoft.ReactNative.h>
+
+// C RunTime Header Files
+#include <malloc.h>
+#include <memory.h>
+#include <stdlib.h>
+#include <tchar.h>
+
+// Reference additional headers your project requires here

package/vendor/node_modules/@legendapp/spark-processes/windows/SparkProcesses/resource.h

@@ -0,0 +1,5 @@
+//
+// Microsoft Visual C++ generated include file.
+// Used by SparkProcesses.rc
+
+#pragma once

package/vendor/node_modules/@legendapp/spark-processes/windows/SparkProcesses/targetver.h

@@ -0,0 +1,8 @@
+#pragma once
+
+// Including SDKDDKVer.h defines the highest available Windows platform.
+
+// If you wish to build your application for a previous Windows platform, include WinSDKVer.h and
+// set the _WIN32_WINNT macro to the platform you wish to support before including SDKDDKVer.h.
+
+#include <SDKDDKVer.h>