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

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

@@ -1,61 +1,150 @@
 import { NativeEventEmitter, Platform } from "react-native";
+import { callBinary, nativeBytes } from "@legendapp/spark-desktop-app/src/contracts/native-buffer";
+import { SparkError, invokeNative, asyncRegistration, type AsyncRegistration, type Availability } from "@legendapp/spark-desktop-app/src/contracts";
+export type { AsyncRegistration } from "@legendapp/spark-desktop-app/src/contracts";
+import { nativePath } from "@legendapp/spark-desktop-app/src/contracts/path";
 import Native from "./NativeDesktopFileSystem";
-import { absolutePath } from "./path";
-export type FileStat = { type: "file" | "directory" | "symlink"; size: number; modifiedAt: number };
+import { createFileHandle, iterateFile, writeFileChunks, type FileMode, type ReadChunksOptions } from "./handles";
+export { FileCleanupError } from "./handles";
+export type { FileHandle, FileMode, ReadChunksOptions } from "./handles";
+export interface FileInfo { type: "file" | "directory" | "symlink"; size: number; modifiedAt: number }
+export interface DirectoryEntry { name: string; path: string }
+export interface CreateDirectoryOptions { recursive?: boolean }
+export interface RemoveOptions { recursive?: boolean }
+export interface CopyMoveOptions { overwrite?: boolean }
+export interface WatchOptions { recursive?: boolean }
+export interface OpenFileOptions { mode?: FileMode }
+export interface WriteChunksOptions { mode?: "write" | "createNew"; signal?: AbortSignal }
+export function getFileSystemAvailability(): Availability {
+  if (Platform.OS !== "macos" && Platform.OS !== "windows") return { available: false, reason: "unsupported-platform" };
+  return Native ? { available: true } : { available: false, reason: "missing-module" };
+}
+function native() {
+  const availability = getFileSystemAvailability();
+  if (!availability.available) throw new SparkError(availability.reason === "unsupported-platform" ? "E_UNSUPPORTED_PLATFORM" : "E_MODULE_UNAVAILABLE", "File IO requires a desktop host with NativeDesktopFileSystem installed");
+  return Native!;
+}
+const absolute = (path: string) => nativePath(path, Platform.OS);
+const isString = (value: unknown): value is string => typeof value === "string";
+function validResponse(method: string, value: unknown): boolean {
+  if (["directory", "openFile"].includes(method)) return isString(value) && value.length > 0;
+  if (["readText"].includes(method)) return isString(value);
+  if (method === "readBytes" || method === "readChunk") return value instanceof ArrayBuffer;
+  if (method === "list") return Array.isArray(value) && value.every(name => isString(name) && name.length > 0 && ![".", ".."].includes(name) && !name.includes("/") && !name.includes("\0") && (Platform.OS !== "windows" || !name.includes("\\")));
+  if (method === "stat") {
+    if (!value || typeof value !== "object") return false;
+    const info = value as FileInfo;
+    return ["file", "directory", "symlink"].includes(info.type) && Number.isSafeInteger(info.size) && info.size >= 0 && typeof info.modifiedAt === "number" && Number.isFinite(info.modifiedAt);
+  }
+  if (method === "writeChunk") return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+  if (method === "remove" || method === "writeTextIfUnchanged") return typeof value === "boolean";
+  return value === null;
+}
 async function call<T = void>(method: string, args: object): Promise<T> {
-  return JSON.parse(await Native.call(method, JSON.stringify(args))) as T;
-}
-function absolute(path: string) {
-  return absolutePath(path, Platform.OS);
-}
-export const getDirectory = (kind: "data" | "cache" | "temp") => call<string>("directory", { kind });
-export const readText = (path: string) => call<string>("readText", { path: absolute(path) });
-export const writeText = (path: string, text: string) => call("writeText", { path: absolute(path), text });
-/** Binary data uses base64 across the bridge; it does not require Node or Buffer. */
-export const readBase64 = (path: string) => call<string>("readBytes", { path: absolute(path) });
-export const writeBase64 = (path: string, base64: string) => call("writeBytes", { path: absolute(path), base64 });
-export const stat = (path: string) => call<FileStat>("stat", { path: absolute(path) });
-export async function exists(path: string) {
+  const { bytes, ...metadata } = args as { bytes?: Uint8Array };
+  const value = await invokeNative(() => callBinary(native(), "__sparkFileSystemBinary", method, metadata, bytes));
+  if (!validResponse(method, value)) throw new SparkError("E_INVALID_DATA", "Invalid native file response");
+  return value as T;
+}
+/** Rejects unknown or extra option keys so a misspelled option can never silently no-op. */
+function checkedOptions<T extends object>(options: T, allowed: readonly string[], label: string): T {
+  if (!options || typeof options !== "object" || Array.isArray(options)) throw new SparkError("E_INVALID_ARGUMENT", `Expected ${label} options`);
+  for (const key of Object.keys(options)) if (!allowed.includes(key)) throw new SparkError("E_UNSUPPORTED_OPTION", `Unknown ${label} option: ${key}`);
+  return options;
+}
+function recursiveOption(options: { recursive?: boolean }, fallback: boolean): boolean {
+  const value = checkedOptions(options, ["recursive"], "recursive");
+  if (value.recursive !== undefined && typeof value.recursive !== "boolean") throw new SparkError("E_INVALID_ARGUMENT", "recursive must be a boolean");
+  return value.recursive ?? fallback;
+}
+function overwriteOption(options: CopyMoveOptions): boolean {
+  const value = checkedOptions(options, ["overwrite"], "copy/move");
+  if (value.overwrite !== undefined && typeof value.overwrite !== "boolean") throw new SparkError("E_INVALID_ARGUMENT", "overwrite must be a boolean");
+  return value.overwrite ?? false;
+}
+export async function getDirectory(kind: "data" | "cache" | "temp"): Promise<string> {
+  if (!["data", "cache", "temp"].includes(kind)) throw new SparkError("E_INVALID_ARGUMENT", "Invalid directory kind");
+  const path = await call<string>("directory", { kind });
+  try { return absolute(path); } catch (cause) { throw new SparkError("E_INVALID_DATA", "Invalid native directory path", { cause }); }
+}
+/** UTF-8. Invalid text rejects instead of inserting replacement characters. */
+export async function readText(path: string): Promise<string> { return call("readText", { path: absolute(path) }); }
+export async function writeText(path: string, text: string): Promise<void> {
+  if (typeof text !== "string") throw new SparkError("E_INVALID_ARGUMENT", "Expected a text string");
+  await call("writeText", { path: absolute(path), text });
+}
+export async function readBytes(path: string): Promise<Uint8Array> { return nativeBytes(await call<ArrayBuffer>("readBytes", { path: absolute(path) })); }
+export async function writeBytes(path: string, bytes: Uint8Array): Promise<void> {
+  if (!(bytes instanceof Uint8Array)) throw new SparkError("E_INVALID_ARGUMENT", "Expected Uint8Array");
+  await call("writeBytes", { path: absolute(path), bytes });
+}
+/** Describes the link itself, without following it. modifiedAt is Unix milliseconds. */
+export async function stat(path: string): Promise<FileInfo> { return call("stat", { path: absolute(path) }); }
+export async function exists(path: string): Promise<boolean> {
   try { await stat(path); return true; } catch (error) {
-    if ((error as { code?: string }).code === "E_NOT_FOUND") return false;
+    if (error instanceof SparkError && error.code === "E_NOT_FOUND") return false;
     throw error;
   }
 }
-export const list = (path: string) => call<string[]>("list", { path: absolute(path) });
-export const mkdir = (path: string, options: { recursive?: boolean } = {}) => call("mkdir", { path: absolute(path), recursive: options.recursive ?? true });
-export const remove = (path: string, options: { recursive?: boolean } = {}) => call<boolean>("remove", { path: absolute(path), recursive: options.recursive ?? false });
-export const copy = (path: string, to: string) => call("copy", { path: absolute(path), to: absolute(to) });
-export const move = (path: string, to: string) => call("move", { path: absolute(path), to: absolute(to) });
+/** Entries are sorted by name. Metadata is obtained explicitly with stat(entry.path). */
+export async function list(path: string): Promise<DirectoryEntry[]> {
+  const directory = absolute(path);
+  const names = await call<string[]>("list", { path: directory });
+  const separator = Platform.OS === "windows" ? "\\" : "/";
+  return names.sort().map(name => ({ name, path: directory.replace(/[\\/]+$/, "") + separator + name }));
+}
+export async function mkdir(path: string, options: CreateDirectoryOptions = {}): Promise<void> { await call("mkdir", { path: absolute(path), recursive: recursiveOption(options, true) }); }
+/** Absence is success; deleting a nonempty directory requires recursive: true. */
+export async function remove(path: string, options: RemoveOptions = {}): Promise<void> { await call("remove", { path: absolute(path), recursive: recursiveOption(options, false) }); }
+/** Copies directories recursively and preserves symlinks. An existing destination rejects unless overwrite: true. Self-transfers and overlapping source/destination paths reject. Overwrite stages beside the destination and restores the previous destination if publication fails. If backup cleanup fails after commit, the native error reports the published destination and recoverable backup path. */
+export async function copy(source: string, destination: string, options: CopyMoveOptions = {}): Promise<void> {
+  await call("copy", { path: absolute(source), to: absolute(destination), overwrite: overwriteOption(options) });
+}
+/** An existing destination rejects unless overwrite: true. Self-transfers and overlapping source/destination paths reject. Cross-volume moves copy beside the destination before deleting the source. If source cleanup fails, the destination has been published, the source may be partially removed, and the previous destination is retained at a recovery path reported by the native error. Backup cleanup failures also report the committed destination and retained backup. */
+export async function move(source: string, destination: string, options: CopyMoveOptions = {}): Promise<void> {
+  await call("move", { path: absolute(source), to: absolute(destination), overwrite: overwriteOption(options) });
+}
 let nextWatch = 0;
-const emitter = new NativeEventEmitter(Native);
-export type WatchOptions = { recursive?: boolean };
-/** Invalidation, not an exact change log. Recursive watches require a directory.
- * Re-read the watched path after a callback; events may be coalesced. */
-export async function watch(path: string, listener: (path: string) => void, options: WatchOptions = {}) {
-  if (options.recursive !== undefined && typeof options.recursive !== "boolean") throw new TypeError("recursive must be a boolean");
+/** Invalidation, not an exact change log. Recursive watches require a directory. */
+export async function watch(path: string, listener: (path: string) => void, options: WatchOptions = {}): Promise<AsyncRegistration> {
+  const location = absolute(path), recursive = recursiveOption(options, false);
+  if (typeof listener !== "function") throw new SparkError("E_INVALID_ARGUMENT", "Expected a watch listener");
   const id = `watch-${Date.now()}-${++nextWatch}`;
   let removed = false;
+  const emitter = new NativeEventEmitter(native());
   const subscription = emitter.addListener("change", (event: { id: string; path: string }) => {
-    if (!removed && event.id === id) listener(event.path);
+    if (!removed && event?.id === id && typeof event.path === "string") listener(event.path);
   });
-  try { await call("watch", { path: absolute(path), id, recursive: options.recursive ?? false }); }
+  try { await call("watch", { path: location, id, recursive }); }
   catch (error) { subscription.remove(); throw error; }
-  return { async remove() {
-    if (removed) return;
-    removed = true; subscription.remove(); await call("unwatch", { id });
-  } };
+  return asyncRegistration(() => { removed = true; subscription.remove(); }, async () => { await call("unwatch", { id }); });
 }
-
-import { createFileHandle, iterateFile, writeFileChunks, type FileMode, type ReadChunksOptions } from "./handles";
-export type { FileHandle, FileMode, ReadChunksOptions } from "./handles";
-/** read/readWrite require an existing regular file. write truncates; createNew fails if it exists. */
-export const openFile = (path: string, options: { mode?: FileMode } = {}) => createFileHandle(call, absolute(path), options.mode);
-/** Pull-based binary stream; closes the handle on EOF, error, abort, or early loop exit. */
-export const readChunks = (path: string, options: ReadChunksOptions = {}) => iterateFile(() => openFile(path), options);
-/** Writes sequentially, splitting large chunks. Failure leaves a partial file; use a temporary file + move for publication. */
-export const writeChunks = (path: string, chunks: AsyncIterable<Uint8Array> | Iterable<Uint8Array>, options: { mode?: "write" | "createNew"; signal?: AbortSignal } = {}) => {
-  if (options.mode !== undefined && options.mode !== "write" && options.mode !== "createNew") throw new TypeError("Streaming writes require write or createNew mode");
+/** read/readWrite require an existing regular file. write truncates; createNew rejects if it exists. */
+export async function openFile(path: string, options: OpenFileOptions = {}) {
+  checkedOptions(options, ["mode"], "openFile");
+  return createFileHandle(call, absolute(path), options.mode);
+}
+/** Returns an iterator synchronously; option names validate now, while path/range validation occurs on first iteration. Closes on EOF, error, abort, or early loop exit. */
+export function readChunks(path: string, options: ReadChunksOptions = {}): AsyncGenerator<Uint8Array> {
+  checkedOptions(options, ["offset", "chunkSize", "signal"], "readChunks");
+  return iterateFile(() => openFile(path), options);
+}
+/** Promise-based validation and IO; failure leaves a partial file, so use a temporary file + move for publication. */
+export async function writeChunks(path: string, chunks: AsyncIterable<Uint8Array> | Iterable<Uint8Array>, options: WriteChunksOptions = {}): Promise<number> {
+  checkedOptions(options, ["mode", "signal"], "writeChunks");
+  if (options.mode !== undefined && options.mode !== "write" && options.mode !== "createNew") throw new SparkError("E_INVALID_ARGUMENT", "Streaming writes require write or createNew mode");
   return writeFileChunks(() => openFile(path, { mode: options.mode ?? "write" }), chunks, options.signal);
-};
+}
 /** Move to the OS Trash/Recycle Bin. Never falls back to permanent deletion. */
-export const trash = (path: string) => call<void>("trash", { path: absolute(path) });
+export async function trash(path: string): Promise<void> { await call("trash", { path: absolute(path) }); }
+
+/** Reveal an existing path in Finder or Explorer. */
+export async function revealInFileManager(path: string): Promise<void> { await call("reveal", { path: absolute(path) }); }
+/** Compare before replacing. Detects observed changes; not an OS-wide atomic compare-and-swap. */
+export async function writeTextIfUnchanged(path: string, expected: string, contents: string): Promise<{ written: boolean }> {
+  if (typeof expected !== "string" || typeof contents !== "string") throw new SparkError("E_INVALID_ARGUMENT", "Expected text strings");
+  return { written: await call<boolean>("writeTextIfUnchanged", { path: absolute(path), expected, text: contents }) };
+}
+
+export { scanFiles, getFileScanAvailability } from "./file-scanner";
+export type { FileScanOptions, FileScanSkipEntry, ScannedFile, FileScanProgress, FileScanBatch, FileScanResult } from "./file-scanner";

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

@@ -1,9 +1 @@
-/** Drive-qualified and UNC paths are absolute on Windows; C:foo and \foo are not. */
-export function absolutePath(path: string, platform: string) {
-  const windows = /^(?:[a-z]:[\\/]|\\\\[^\\/]+[\\/][^\\/]+)/i.test(path);
-  if (typeof path !== "string" || path.includes("\0") ||
-      !(path.startsWith("file://") || (platform === "windows" ? windows : path.startsWith("/")))) {
-    throw new Error("Expected an absolute path or file URL");
-  }
-  return path;
-}
+export { absolutePath } from "@legendapp/spark-desktop-app/src/contracts/path";

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

@@ -1,9 +1,9 @@
 #pragma once
 #include "NativeModules.h"
+#include <SparkBinaryWindows.hpp>
 #include <shlobj.h>
 #include <shlwapi.h>
 #include <winrt/Windows.Data.Json.h>
-#include <winrt/Windows.Security.Cryptography.h>
 #include <winrt/Windows.Storage.Streams.h>
 #include <filesystem>
 #include <algorithm>
@@ -26,7 +26,6 @@ namespace winrt::SparkFileSystem {
 namespace React = Microsoft::ReactNative;
 namespace Json = Windows::Data::Json;
 namespace fs = std::filesystem;
-using Crypto = Windows::Security::Cryptography::CryptographicBuffer;
 
 inline fs::path FilePath(hstring const &input) {
   std::wstring value(input);
@@ -58,7 +57,7 @@ inline std::string ErrorCode(DWORD error) {
     default: return "E_IO";
   }
 }
-inline void Reject(React::ReactPromise<std::string> const &promise) noexcept {
+template <class Promise> inline void Reject(Promise const &promise) noexcept {
   try { throw; }
   catch (fs::filesystem_error const &e) {
     auto code = e.code(); std::string kind = "E_IO";
@@ -100,6 +99,58 @@ inline void Write(fs::path const &path, std::vector<uint8_t> const &data) {
     if (!MoveFileExW(temporary.c_str(), path.c_str(), MOVEFILE_REPLACE_EXISTING | MOVEFILE_WRITE_THROUGH)) throw_last_error();
   } catch (...) { std::error_code ignored; fs::remove(temporary, ignored); throw; }
 }
+inline bool PathContains(fs::path const &parent, fs::path const &child) {
+  auto p = parent.begin(), c = child.begin();
+  for (; p != parent.end() && c != child.end() && CompareStringOrdinal(p->c_str(), -1, c->c_str(), -1, TRUE) == CSTR_EQUAL; ++p, ++c) {}
+  return p == parent.end();
+}
+inline void Transfer(fs::path const &from, fs::path const &to, bool move, bool overwrite) {
+  auto source = fs::weakly_canonical(from), destination = fs::weakly_canonical(to);
+  std::error_code identityError;
+  bool sameFile = fs::equivalent(from, to, identityError);
+  if (identityError && identityError != std::errc::no_such_file_or_directory) throw fs::filesystem_error("Could not compare transfer paths", from, to, identityError);
+  if (sameFile || PathContains(source, destination) || PathContains(destination, source))
+    throw hresult_invalid_argument(L"Source and destination identify or contain one another");
+  bool destinationExists = fs::symlink_status(to).type() != fs::file_type::not_found;
+  if (destinationExists && !overwrite) throw fs::filesystem_error("Destination already exists", to, std::make_error_code(std::errc::file_exists));
+  GUID guid{}; check_hresult(CoCreateGuid(&guid)); wchar_t identifier[40]{}; StringFromGUID2(guid, identifier, 40);
+  auto stage = to.parent_path() / (std::wstring(L".spark-stage-") + identifier);
+  auto backup = to.parent_path() / (std::wstring(L".spark-backup-") + identifier);
+  bool stagedByRename = false;
+  try {
+    wchar_t sourceVolume[32768]{}, destinationVolume[32768]{};
+    bool sameVolumeMove = move && GetVolumePathNameW(from.parent_path().c_str(), sourceVolume, ARRAYSIZE(sourceVolume)) &&
+      GetVolumePathNameW(to.parent_path().c_str(), destinationVolume, ARRAYSIZE(destinationVolume)) &&
+      _wcsicmp(sourceVolume, destinationVolume) == 0;
+    if (sameVolumeMove) { fs::rename(from, stage); stagedByRename = true; }
+    else fs::copy(from, stage, fs::copy_options::recursive | fs::copy_options::copy_symlinks);
+    if (destinationExists && !MoveFileExW(to.c_str(), backup.c_str(), MOVEFILE_WRITE_THROUGH)) {
+      auto failure = GetLastError();
+      bool restoredSource = !stagedByRename || MoveFileExW(stage.c_str(), from.c_str(), MOVEFILE_WRITE_THROUGH);
+      if (!restoredSource) throw hresult_error(HRESULT_FROM_WIN32(ERROR_WRITE_FAULT), L"Destination staging failed and source rollback failed; recoverable source: " + stage.wstring());
+      throw hresult_error(HRESULT_FROM_WIN32(failure));
+    }
+    if (!MoveFileExW(stage.c_str(), to.c_str(), MOVEFILE_WRITE_THROUGH)) {
+      auto failure = GetLastError();
+      bool restoredDestination = !destinationExists || MoveFileExW(backup.c_str(), to.c_str(), MOVEFILE_WRITE_THROUGH);
+      bool restoredSource = !stagedByRename || MoveFileExW(stage.c_str(), from.c_str(), MOVEFILE_WRITE_THROUGH);
+      if (!restoredDestination || !restoredSource)
+        throw hresult_error(HRESULT_FROM_WIN32(ERROR_WRITE_FAULT), L"Publication and rollback failed; recoverable paths: " + stage.wstring() + L"; " + backup.wstring());
+      throw hresult_error(HRESULT_FROM_WIN32(failure));
+    }
+    if (move && !stagedByRename) {
+      std::error_code sourceError; fs::remove_all(from, sourceError);
+      if (sourceError) throw fs::filesystem_error("Source cleanup failed after publishing " + PathString(to) + "; source may be partially removed; previous destination is retained at " + PathString(backup), from, sourceError);
+    }
+    if (destinationExists) {
+      std::error_code cleanupError; fs::remove_all(backup, cleanupError);
+      if (cleanupError) throw fs::filesystem_error("Transfer committed at " + PathString(to) + "; previous destination cleanup failed; recoverable backup: " + PathString(backup), backup, cleanupError);
+    }
+  } catch (...) {
+    if (!stagedByRename) { std::error_code ignored; fs::remove_all(stage, ignored); }
+    throw;
+  }
+}
 inline fs::path Directory(hstring const &kind) {
   wchar_t identity[201]{}; auto count = GetEnvironmentVariableW(L"SPARK_PROJECT_ID", identity, 201);
   if (!count || count >= 201) throw hresult_invalid_argument(L"Launch through Spark to establish project storage identity");
@@ -182,7 +233,7 @@ struct FileQueue {
   }) {}
   ~FileQueue() { { std::lock_guard lock(mutex); stopping = true; } ready.notify_one(); worker.join(); }
   void Post(std::function<void()> action) { { std::lock_guard lock(mutex); pending.push_back(std::move(action)); } ready.notify_one(); }
-  Json::IJsonValue Call(std::string const &method, Json::JsonObject const &args) {
+  Json::IJsonValue Call(std::string const &method, Json::JsonObject const &args, std::optional<std::vector<uint8_t>> const &input = {}, std::vector<uint8_t> *output = nullptr) {
     if (method == "directory") return Json::JsonValue::CreateStringValue(Directory(args.GetNamedString(L"kind")).wstring());
     if (method == "unwatch") { watches.erase(to_string(args.GetNamedString(L"id"))); return Json::JsonValue::Parse(L"null"); }
     if (method == "closeFile") { files.erase(to_string(args.GetNamedString(L"id"))); return Json::JsonValue::Parse(L"null"); }
@@ -200,13 +251,10 @@ struct FileQueue {
         if (!std::isfinite(length) || length < 1 || length > 1048576 || std::floor(length) != length || offset + length > 9007199254740991.0) throw hresult_invalid_argument(L"Invalid chunk length");
         std::vector<uint8_t> data(static_cast<size_t>(length)); DWORD count = 0;
         if (!ReadFile(file, data.data(), static_cast<DWORD>(data.size()), &count, nullptr)) throw_last_error();
-        data.resize(count); return Json::JsonValue::CreateStringValue(Crypto::EncodeToBase64String(Crypto::CreateFromByteArray(data)));
+        data.resize(count); if (!output) throw hresult_invalid_argument(L"Expected binary transport"); *output = std::move(data); return Json::JsonValue::CreateNullValue();
       }
-      auto base64 = args.GetNamedString(L"base64");
-      if (base64.size() > 1398104) throw hresult_invalid_argument(L"Chunk exceeds 1 MiB");
-      auto buffer = Crypto::DecodeFromBase64String(base64);
-      if (Crypto::EncodeToBase64String(buffer) != base64 || buffer.Length() > 1048576 || offset + buffer.Length() > 9007199254740991.0) throw hresult_invalid_argument(L"Invalid chunk");
-      com_array<uint8_t> data; Crypto::CopyToByteArray(buffer, data);
+      if (!input || input->size() > 1048576 || offset + input->size() > 9007199254740991.0) throw hresult_invalid_argument(L"Invalid chunk");
+      auto const &data = *input;
       size_t written = 0;
       while (written < data.size()) { DWORD count = 0; if (!WriteFile(file, data.data() + written, static_cast<DWORD>(data.size() - written), &count, nullptr)) throw_last_error(); if (!count) throw hresult_error(E_FAIL, L"File write made no progress"); written += count; }
       return Json::JsonValue::CreateNumberValue(static_cast<double>(written));
@@ -234,13 +282,15 @@ struct FileQueue {
       if (text.size() > INT_MAX) throw hresult_error(E_FAIL, L"Text exceeds the UTF-8 conversion limit");
       if (!text.empty() && !MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, text.data(), static_cast<int>(text.size()), nullptr, 0)) throw_last_error();
       return Json::JsonValue::CreateStringValue(to_hstring(text));
-    } else if (method == "readBytes") return Json::JsonValue::CreateStringValue(Crypto::EncodeToBase64String(Crypto::CreateFromByteArray(Read(path))));
+    } else if (method == "readBytes") { if (!output) throw hresult_invalid_argument(L"Expected binary transport"); *output = Read(path); return Json::JsonValue::CreateNullValue(); }
+    else if (method == "writeTextIfUnchanged") {
+      if (Call("readText", args).GetString() != args.GetNamedString(L"expected")) return Json::JsonValue::CreateBooleanValue(false);
+      auto text = to_string(args.GetNamedString(L"text")); Write(path, std::vector<uint8_t>(text.begin(), text.end()));
+      return Json::JsonValue::CreateBooleanValue(true);
+    }
     else if (method == "writeText") { auto text = to_string(args.GetNamedString(L"text")); Write(path, std::vector<uint8_t>(text.begin(), text.end())); }
     else if (method == "writeBytes") {
-      auto base64 = args.GetNamedString(L"base64"); Windows::Storage::Streams::IBuffer buffer{nullptr};
-      try { buffer = base64.empty() ? Crypto::CreateFromByteArray(array_view<uint8_t const>{}) : Crypto::DecodeFromBase64String(base64); } catch (hresult_error const &) { throw hresult_invalid_argument(L"Invalid base64 data"); }
-      if (Crypto::EncodeToBase64String(buffer) != base64) throw hresult_invalid_argument(L"Invalid base64 data");
-      com_array<uint8_t> data; Crypto::CopyToByteArray(buffer, data); Write(path, std::vector<uint8_t>(data.begin(), data.end()));
+      if (!input) throw hresult_invalid_argument(L"Expected binary file data"); Write(path, *input);
     } else if (method == "mkdir") {
       if (args.GetNamedBoolean(L"recursive", true)) fs::create_directories(path);
       else if (!fs::create_directory(path)) throw hresult_error(HRESULT_FROM_WIN32(ERROR_ALREADY_EXISTS));
@@ -249,15 +299,7 @@ struct FileQueue {
       return Json::JsonValue::CreateBooleanValue(fs::remove(path));
     } else if (method == "copy" || method == "move") {
       auto to = FilePath(args.GetNamedString(L"to"));
-      auto destination = fs::symlink_status(to);
-      if (destination.type() != fs::file_type::not_found) throw hresult_error(HRESULT_FROM_WIN32(ERROR_ALREADY_EXISTS));
-      if (method == "copy") fs::copy(path, to, fs::copy_options::recursive | fs::copy_options::copy_symlinks);
-      else if (!MoveFileExW(path.c_str(), to.c_str(), MOVEFILE_COPY_ALLOWED | MOVEFILE_WRITE_THROUGH)) {
-        if (GetLastError() != ERROR_NOT_SAME_DEVICE || !fs::is_directory(path)) throw_last_error();
-        try { fs::copy(path, to, fs::copy_options::recursive | fs::copy_options::copy_symlinks); }
-        catch (...) { std::error_code ignored; fs::remove_all(to, ignored); throw; }
-        fs::remove_all(path);
-      }
+      Transfer(path, to, method == "move", args.GetNamedBoolean(L"overwrite", false));
     } else if (method == "stat") {
       // OPEN_REPARSE_POINT describes a link itself, including dangling links.
       auto file = Open(path, FILE_READ_ATTRIBUTES, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OPEN_REPARSE_POINT);
@@ -281,9 +323,43 @@ struct FileQueue {
 };
 REACT_MODULE(SparkFileSystem, L"NativeDesktopFileSystem")
 struct SparkFileSystem {
-  std::unique_ptr<FileQueue> queue;
-  REACT_INIT(Initialize) void Initialize(React::ReactContext const &context) noexcept { queue = std::make_unique<FileQueue>(context); }
+  React::ReactContext context;
+  std::shared_ptr<FileQueue> queue;
+  REACT_INIT(Initialize) void Initialize(React::ReactContext const &value) noexcept { context = value; queue = std::make_shared<FileQueue>(context); }
+  REACT_SYNC_METHOD(installBinary) std::optional<std::string> installBinary() noexcept {
+    try {
+    spark::binary::Install(context, "__sparkFileSystemBinary", [queue = queue](std::string method, std::string encoded, std::optional<std::vector<uint8_t>> bytes, spark::binary::Completion finish) {
+      if (method == "reveal") {
+        queue->context.UIDispatcher().Post([encoded, promise = spark::binary::NativePromise(finish)] {
+          PIDLIST_ABSOLUTE item = nullptr;
+          try { auto path = FilePath(Json::JsonObject::Parse(to_hstring(encoded)).GetNamedString(L"path")); check_hresult(SHParseDisplayName(path.c_str(), nullptr, &item, 0, nullptr)); auto result = SHOpenFolderAndSelectItems(item, 0, nullptr, 0); CoTaskMemFree(item); item = nullptr; check_hresult(result); promise.Resolve("null"); }
+          catch (...) { if (item) CoTaskMemFree(item); Reject(promise); }
+        }); return;
+      }
+      queue->Post([queue, method = std::move(method), encoded = std::move(encoded), bytes = std::move(bytes), promise = spark::binary::NativePromise(finish)] {
+        try { std::vector<uint8_t> output; auto result = queue->Call(method, Json::JsonObject::Parse(to_hstring(encoded)), bytes, &output); spark::binary::Response response{to_string(result.Stringify()), {}, {}}; if (method == "readBytes" || method == "readChunk") response.bytes = std::make_shared<spark::binary::Bytes>(std::move(output)); promise.Resolve(std::move(response)); }
+        catch (...) { Reject(promise); }
+      });
+    });
+      return std::nullopt;
+    } catch (std::exception const &error) { return error.what(); }
+    catch (hresult_error const &error) { return to_string(error.message()); }
+    catch (...) { return "Could not install native binary transport"; }
+  }
+
   REACT_METHOD(call) void call(std::string method, std::string args, React::ReactPromise<std::string> promise) noexcept {
+    if (method == "reveal") {
+      context.UIDispatcher().Post([args, promise] {
+        PIDLIST_ABSOLUTE item = nullptr;
+        try {
+          auto path = FilePath(Json::JsonObject::Parse(to_hstring(args)).GetNamedString(L"path"));
+          check_hresult(SHParseDisplayName(path.c_str(), nullptr, &item, 0, nullptr));
+          auto result = SHOpenFolderAndSelectItems(item, 0, nullptr, 0);
+          CoTaskMemFree(item); item = nullptr; check_hresult(result); promise.Resolve("null");
+        } catch (...) { if (item) CoTaskMemFree(item); Reject(promise); }
+      });
+      return;
+    }
     queue->Post([state = queue.get(), method, args, promise] {
       try { promise.Resolve(to_string(state->Call(method, Json::JsonObject::Parse(to_hstring(args))).Stringify())); }
       catch (...) { Reject(promise); }

package/vendor/node_modules/@legendapp/spark-file-system/windows/SparkFileSystem/SparkFileSystem.vcxproj

@@ -80,6 +80,8 @@
       <PreprocessorDefinitions>_WINRT_DLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <AdditionalUsingDirectories>$(WindowsSDK_WindowsMetadata);$(AdditionalUsingDirectories)</AdditionalUsingDirectories>
       <AdditionalIncludeDirectories>
+        $(MSBuildThisFileDirectory)..\..\..\spark-desktop-app\cpp;
+        $(MSBuildThisFileDirectory)..\..\..\desktop-app\cpp;
         $(MSBuildThisFileDirectory);
         %(AdditionalIncludeDirectories)
       </AdditionalIncludeDirectories>

package/vendor/node_modules/@legendapp/spark-global-shortcuts/RNDesktopGlobalShortcuts.podspec

@@ -14,4 +14,5 @@ Pod::Spec.new do |s|
   s.dependency "React-Core"
   s.dependency "ReactCodegen"
   s.dependency "RNDesktopApp"
+  s.osx.frameworks = "Carbon"
 end

package/vendor/node_modules/@legendapp/spark-global-shortcuts/macos/RNDesktopGlobalShortcuts.mm

@@ -36,6 +36,7 @@ RCT_EXPORT_MODULE(NativeDesktopGlobalShortcuts)
   dispatch_async(dispatch_get_main_queue(), ^{
     NSDictionary *args = SparkArgs(json); NSString *key = args[@"id"];
     if ([method isEqual:@"register"]) {
+      if (![args[@"key"] isKindOfClass:NSString.class] || ![args[@"key"] length]) { SparkInvalid(reject, @"Expected a shortcut key"); return; }
       NSInteger code = KeyCode(args[@"key"]);
       if (code < 0) { reject(@"E_KEY", @"Key is unavailable in the current keyboard layout", nil); return; }
       NSUInteger flags = [args[@"modifiers"] unsignedIntegerValue]; UInt32 modifiers = 0;
@@ -43,15 +44,17 @@ RCT_EXPORT_MODULE(NativeDesktopGlobalShortcuts)
       if (flags & NSEventModifierFlagControl) modifiers |= controlKey;
       if (flags & NSEventModifierFlagShift) modifiers |= shiftKey;
       if (flags & NSEventModifierFlagOption) modifiers |= optionKey;
-      for (NSDictionary *existing in self.registrations.allValues) if ([existing[@"code"] integerValue] == code && [existing[@"modifiers"] unsignedIntValue] == modifiers) { reject(@"E_SHORTCUT_CONFLICT", @"Shortcut already registered", nil); return; }
-      if (self.registrations[key]) { reject(@"E_SHORTCUT_CONFLICT", @"Shortcut id already exists", nil); return; }
+      for (NSDictionary *existing in self.registrations.allValues) if ([existing[@"code"] integerValue] == code && [existing[@"modifiers"] unsignedIntValue] == modifiers) { reject(@"E_BUSY", @"Shortcut already registered", nil); return; }
+      if (self.registrations[key]) { reject(@"E_BUSY", @"Shortcut id already exists", nil); return; }
       if (!self.handler) { EventTypeSpec spec = { kEventClassKeyboard, kEventHotKeyPressed }; EventHandlerRef handler;
         if (InstallEventHandler(GetEventDispatcherTarget(), Hotkey, 1, &spec, (__bridge void *)self, &handler) != noErr) { reject(@"E_SHORTCUT", @"Could not install hotkey handler", nil); return; } self.handler = handler; }
       EventHotKeyID identity = { 'LGDS', ++self.sequence }; EventHotKeyRef reference;
-      if (RegisterEventHotKey((UInt32)code, modifiers, identity, GetEventDispatcherTarget(), 0, &reference) != noErr) { reject(@"E_SHORTCUT_CONFLICT", @"Shortcut is unavailable or reserved by another app", nil); return; }
+      if (RegisterEventHotKey((UInt32)code, modifiers, identity, GetEventDispatcherTarget(), 0, &reference) != noErr) { reject(@"E_BUSY", @"Shortcut is unavailable or reserved by another app", nil); return; }
       self.registrations[key] = @{ @"code": @(code), @"modifiers": @(modifiers), @"number": @(identity.id), @"reference": [NSValue valueWithPointer:reference] };
     } else if ([method isEqual:@"remove"]) {
-      NSDictionary *value = self.registrations[key]; if (value) UnregisterEventHotKey((EventHotKeyRef)[value[@"reference"] pointerValue]); [self.registrations removeObjectForKey:key];
+      NSDictionary *value = self.registrations[key];
+      if (value && UnregisterEventHotKey((EventHotKeyRef)[value[@"reference"] pointerValue]) != noErr) { reject(@"E_NATIVE", @"Could not unregister global shortcut", nil); return; }
+      [self.registrations removeObjectForKey:key];
     } else { SparkInvalid(reject, @"Unknown global shortcut operation"); return; }
     resolve(@"null");
   });

package/vendor/node_modules/@legendapp/spark-global-shortcuts/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@legendapp/spark-global-shortcuts",
-  "version": "0.0.1-next.2",
+  "version": "0.0.1-next.4",
   "license": "MIT",
   "main": "src/index.ts",
   "react-native": "src/index.ts",
@@ -22,7 +22,8 @@
     "ios": {
       "modulesProvider": {
         "NativeDesktopGlobalShortcuts": "RNDesktopGlobalShortcuts"
-      }
+      },
+      "componentProvider": {}
     }
   },
   "spark": {
@@ -40,7 +41,7 @@
     ]
   },
   "dependencies": {
-    "@legendapp/spark-desktop-app": "0.0.1-next.2"
+    "@legendapp/spark-desktop-app": "0.0.1-next.4"
   },
   "private": true
 }

package/vendor/node_modules/@legendapp/spark-global-shortcuts/src/NativeDesktopGlobalShortcuts.ts

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

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

@@ -1,16 +1,45 @@
 import { Platform } from "react-native";
 import Native from "./NativeDesktopGlobalShortcuts";
-import { onDesktopEvent } from "@legendapp/spark-desktop-app";
-import { parseAccelerator } from "./accelerator";
+import { onDesktopEvent } from "@legendapp/spark-desktop-app/src/events";
+import { parseAccelerator } from "@legendapp/spark-desktop-app/src/contracts/accelerator";
+import { SparkError, invokeNative, parseNativeResult, asyncRegistration, type AsyncRegistration, type Availability } from "@legendapp/spark-desktop-app/src/contracts";
+export type { AsyncRegistration } from "@legendapp/spark-desktop-app/src/contracts";
+export interface GlobalShortcutOptions {
+  /** Fire on keyboard auto-repeat. Windows registers without MOD_NOREPEAT; macOS hotkeys never deliver repeats, so true rejects there. */
+  repeat?: boolean;
+}
 let sequence = 0;
-export async function registerGlobalShortcut(accelerator: string, handler: () => void) {
+export function getGlobalShortcutAvailability(): Availability {
+  if (Platform.OS !== "macos" && Platform.OS !== "windows") return { available: false, reason: "unsupported-platform" };
+  return Native ? { available: true } : { available: false, reason: "missing-module" };
+}
+function native() {
+  const availability = getGlobalShortcutAvailability();
+  if (!availability.available) throw new SparkError(availability.reason === "unsupported-platform" ? "E_UNSUPPORTED_PLATFORM" : "E_MODULE_UNAVAILABLE", "Global shortcuts are unavailable");
+  return Native!;
+}
+async function call(method: string, args: object) {
+  parseNativeResult(await invokeNative(() => native().call(method, JSON.stringify(args))), (value): value is null => value === null);
+}
+/** Conflicts/reserved shortcuts reject E_BUSY. Layout is resolved at registration. */
+export async function registerGlobalShortcut(accelerator: string, handler: () => void, options: GlobalShortcutOptions = {}): Promise<AsyncRegistration> {
+  if (typeof handler !== "function" || !options || typeof options !== "object" || Array.isArray(options)) throw new SparkError("E_INVALID_ARGUMENT", "Expected global shortcut handler and options");
+  for (const key of Object.keys(options)) if (!["repeat"].includes(key)) throw new SparkError("E_UNSUPPORTED_OPTION", `Unsupported global shortcut option: ${key}`);
+  if (options.repeat !== undefined && typeof options.repeat !== "boolean") throw new SparkError("E_INVALID_ARGUMENT", "Global shortcut repeat must be boolean");
+  if (options.repeat === true && Platform.OS === "macos") throw new SparkError("E_UNSUPPORTED_OPTION", "macOS global shortcuts never deliver keyboard repeats");
   const parsed = parseAccelerator(accelerator, Platform.OS === "windows" ? "windows" : "macos"), id = `global-${Date.now()}-${++sequence}`;
+  native();
   let removed = false;
-  const subscription = onDesktopEvent(event => { if (!removed && event.type === "globalShortcut" && event.id === id) handler(); });
-  try { await Native.call("register", JSON.stringify({ id, ...parsed })); }
-  catch (error) { subscription.remove(); throw error; }
-  return { async remove() {
-    if (removed) return;
-    await Native.call("remove", JSON.stringify({ id })); removed = true; subscription.remove();
-  } };
+  const subscription = onDesktopEvent(event => { if (!removed && event.type === "globalShortcut" && event.id === id) {
+    try { handler(); }
+    catch (cause) { console.error(new SparkError("E_NATIVE", "Global shortcut handler failed", { cause })); }
+  } }, { types: ["globalShortcut"], target: { field: "id", value: id } });
+  try { await call("register", { id, repeat: options.repeat ?? false, ...parsed }); }
+  catch (cause) {
+    removed = true; subscription.remove();
+    try { await call("remove", { id }); }
+    catch (cleanup) { throw new SparkError("E_NATIVE", "Shortcut registration and cleanup failed", { cause: new AggregateError([cause, cleanup]) }); }
+    throw cause;
+  }
+  return asyncRegistration(() => { removed = true; subscription.remove(); }, async () => { await call("remove", { id }); });
 }

package/vendor/node_modules/@legendapp/spark-global-shortcuts/windows/SparkGlobalShortcuts/SparkGlobalShortcuts.h

@@ -58,18 +58,19 @@ struct SparkGlobalShortcuts {
         auto args = Json::JsonObject::Parse(to_hstring(encoded)); auto id = to_string(args.GetNamedString(L"id"));
         current->EnsureWindow();
         if (method == "remove") {
-          for (auto item = current->keys.begin(); item != current->keys.end(); ++item) if (item->second == id) { UnregisterHotKey(current->hwnd, item->first); current->keys.erase(item); break; }
+          for (auto item = current->keys.begin(); item != current->keys.end(); ++item) if (item->second == id) { if (!UnregisterHotKey(current->hwnd, item->first)) winrt::throw_last_error(); current->keys.erase(item); break; }
         } else if (method == "register") {
-          for (auto const &[key, existing] : current->keys) if (existing == id) { promise.Reject(React::ReactError{"E_SHORTCUT_CONFLICT", "Shortcut id already exists"}); return; }
+          for (auto const &[key, existing] : current->keys) if (existing == id) { promise.Reject(React::ReactError{"E_BUSY", "Shortcut id already exists"}); return; }
           auto flags = static_cast<int>(args.GetNamedNumber(L"modifiers"));
-          UINT modifiers = MOD_NOREPEAT;
+          // MOD_NOREPEAT suppresses OS auto-repeat; repeat:true registers with repeats.
+          UINT modifiers = args.GetNamedBoolean(L"repeat", false) ? 0 : MOD_NOREPEAT;
           if (flags & (1 << 17)) modifiers |= MOD_SHIFT; if (flags & (1 << 18)) modifiers |= MOD_CONTROL;
           if (flags & (1 << 19)) modifiers |= MOD_ALT; if (flags & (1 << 20)) modifiers |= MOD_WIN;
           const auto key = Hotkeys::Key(args.GetNamedString(L"key"), modifiers);
           // Window-local registration IDs must remain within the documented range.
           int identifier = 0;
           for (int i = 0; i < 0xbfff; ++i) { int candidate = current->sequence = current->sequence % 0xbfff + 1; if (!current->keys.count(candidate)) { identifier = candidate; break; } }
-          if (!identifier || !RegisterHotKey(current->hwnd, identifier, modifiers, key)) { promise.Reject(React::ReactError{"E_SHORTCUT_CONFLICT", "Shortcut is unavailable or reserved by another app"}); return; }
+          if (!identifier || !RegisterHotKey(current->hwnd, identifier, modifiers, key)) { promise.Reject(React::ReactError{"E_BUSY", "Shortcut is unavailable or reserved by another app"}); return; }
           current->keys.emplace(identifier, id);
         } else throw hresult_invalid_argument(L"Unknown global shortcut operation");
         promise.Resolve("null");

package/vendor/node_modules/@legendapp/spark-message-dialog/macos/RNDesktopMessageDialog.mm

@@ -9,9 +9,9 @@ RCT_EXPORT_MODULE(NativeDesktopMessageDialog)
   [NSRunLoop.mainRunLoop performBlock:^{
     if (![method isEqual:@"show"]) { SparkInvalid(reject, @"Unknown dialog operation"); return; }
     if (self.alert) { reject(@"E_BUSY", @"A message dialog is already open", nil); return; }
-    NSDictionary *args = SparkArgs(json); NSWindow *parent;
+    NSDictionary *args = SparkArgs(json); NSWindow *parent = nil;
     if (args[@"windowId"]) {
-      for (NSWindow *window in NSApp.windows) if ([window.identifier isEqual:[@"spark." stringByAppendingString:args[@"windowId"]]]) parent = window;
+      for (NSWindow *window in NSApp.windows) if ([window.identifier isEqual:args[@"windowId"]] || [window.identifier isEqual:[@"spark." stringByAppendingString:args[@"windowId"]]]) { parent = window; break; }
       if (!parent) { reject(@"E_NOT_FOUND", @"Dialog parent does not exist", nil); return; }
       if (parent.attachedSheet) { reject(@"E_BUSY", @"Parent already has a sheet", nil); return; }
     }