@legendapp/spark 0.0.1-next.2

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

@@ -0,0 +1,211 @@
+#import "RNDesktopFileSystem.h"
+#import <RNDesktopApp/SparkDesktop.h>
+#import <fcntl.h>
+#import <unistd.h>
+#import <stdlib.h>
+#import <sys/stat.h>
+#import <errno.h>
+#import <math.h>
+#import <CoreServices/CoreServices.h>
+
+@interface SparkRecursiveWatch : NSObject
+@property FSEventStreamRef stream;
+@property NSString *path;
+@property (copy) void (^changed)(void);
+- (void)stop;
+@end
+@implementation SparkRecursiveWatch
+- (void)stop { if (_stream) { FSEventStreamStop(_stream); FSEventStreamInvalidate(_stream); FSEventStreamRelease(_stream); _stream = NULL; } }
+- (void)dealloc { [self stop]; }
+@end
+static void RecursiveChanges(ConstFSEventStreamRef stream, void *info, size_t count, void *paths, const FSEventStreamEventFlags flags[], const FSEventStreamEventId ids[]) {
+  SparkRecursiveWatch *watch = (__bridge SparkRecursiveWatch *)info;
+  NSArray *changed = (__bridge NSArray *)paths;
+  for (NSUInteger i = 0; i < count; i++) {
+    NSString *path = changed[i];
+    if ([watch.path isEqual:@"/"] || (flags[i] & (kFSEventStreamEventFlagMustScanSubDirs | kFSEventStreamEventFlagRootChanged)) || [path isEqual:watch.path] || [path hasPrefix:[watch.path stringByAppendingString:@"/"]] || [watch.path hasPrefix:[path stringByAppendingString:@"/"]]) { watch.changed(); break; }
+  }
+}
+
+@interface SparkOpenFile : NSObject
+@property int descriptor;
+@end
+@implementation SparkOpenFile
+- (instancetype)init { if (self = [super init]) _descriptor = -1; return self; }
+- (void)dealloc { if (_descriptor >= 0) close(_descriptor); }
+@end
+
+@interface RNDesktopFileSystem ()
+@property dispatch_queue_t ioQueue;
+@property NSMutableDictionary<NSString *, SparkOpenFile *> *files;
+@property NSMutableDictionary<NSString *, dispatch_source_t> *watches;
+@property NSMutableDictionary<NSString *, SparkRecursiveWatch *> *recursiveWatches;
+@end
+static NSURL *FileURL(id value) {
+  if (![value isKindOfClass:NSString.class] || ![value length]) return nil;
+  if ([value hasPrefix:@"file://"]) return [NSURL URLWithString:value];
+  return [value hasPrefix:@"/"] ? [NSURL fileURLWithPath:value] : nil;
+}
+@implementation RNDesktopFileSystem
+RCT_EXPORT_MODULE(NativeDesktopFileSystem)
++ (BOOL)requiresMainQueueSetup { return NO; }
+- (instancetype)init { if (self = [super init]) { _ioQueue = dispatch_queue_create("spark.files", DISPATCH_QUEUE_SERIAL); _files = [NSMutableDictionary new]; _watches = [NSMutableDictionary new]; _recursiveWatches = [NSMutableDictionary new]; } return self; }
+- (NSArray<NSString *> *)supportedEvents { return @[@"change"]; }
+- (void)call:(NSString *)method args:(NSString *)json resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {
+  dispatch_async(self.ioQueue, ^{
+    NSDictionary *args = SparkArgs(json); NSFileManager *fm = NSFileManager.defaultManager;
+    NSError *error = nil; id result = NSNull.null;
+    if ([@[@"readChunk", @"writeChunk", @"flushFile", @"closeFile"] containsObject:method]) {
+      NSString *identifier = args[@"id"]; SparkOpenFile *file = self.files[identifier];
+      if ([method isEqual:@"closeFile"]) { [self.files removeObjectForKey:identifier]; resolve(@"null"); return; }
+      if (!file) { reject(@"E_CLOSED", @"Unknown or closed file handle", nil); return; }
+      if ([method isEqual:@"flushFile"]) { if (fsync(file.descriptor)) error = [NSError errorWithDomain:NSPOSIXErrorDomain code:errno userInfo:nil]; }
+      else {
+        double position = [args[@"offset"] doubleValue];
+        if (![args[@"offset"] isKindOfClass:NSNumber.class] || !isfinite(position) || position < 0 || floor(position) != position || position > 9007199254740991.0) { SparkInvalid(reject, @"Invalid file offset"); return; }
+        if ([method isEqual:@"readChunk"]) {
+          double size = [args[@"length"] doubleValue];
+          if (!isfinite(size) || size < 1 || size > 1048576 || floor(size) != size || position + size > 9007199254740991.0) { SparkInvalid(reject, @"Invalid chunk length"); return; }
+          NSMutableData *data = [NSMutableData dataWithLength:(NSUInteger)size]; ssize_t count;
+          do { count = pread(file.descriptor, data.mutableBytes, data.length, (off_t)position); } while (count < 0 && errno == EINTR);
+          if (count < 0) error = [NSError errorWithDomain:NSPOSIXErrorDomain code:errno userInfo:nil];
+          else { data.length = count; result = [data base64EncodedStringWithOptions:0]; }
+        } else {
+          NSString *base64 = args[@"base64"];
+          if (![base64 isKindOfClass:NSString.class] || base64.length > 1398104) { SparkInvalid(reject, @"Chunk exceeds 1 MiB"); return; }
+          NSData *data = [[NSData alloc] initWithBase64EncodedString:base64 options:0];
+          if (!data || data.length > 1048576 || position + data.length > 9007199254740991.0) { SparkInvalid(reject, @"Invalid chunk"); return; }
+          NSUInteger written = 0;
+          while (written < data.length) {
+            ssize_t count = pwrite(file.descriptor, (const char *)data.bytes + written, data.length - written, (off_t)position + written);
+            if (count < 0 && errno == EINTR) continue;
+            if (count <= 0) { error = [NSError errorWithDomain:NSPOSIXErrorDomain code:count < 0 ? errno : EIO userInfo:nil]; break; }
+            written += count;
+          }
+          result = @(written);
+        }
+      }
+    } else if ([method isEqual:@"directory"]) {
+      NSString *kind = args[@"kind"];
+      NSURL *base;
+      if ([kind isEqual:@"data"]) base = [fm URLForDirectory:NSApplicationSupportDirectory inDomain:NSUserDomainMask appropriateForURL:nil create:YES error:&error];
+      else if ([kind isEqual:@"cache"]) base = [fm URLForDirectory:NSCachesDirectory inDomain:NSUserDomainMask appropriateForURL:nil create:YES error:&error];
+      else if ([kind isEqual:@"temp"]) base = [NSURL fileURLWithPath:NSTemporaryDirectory() isDirectory:YES];
+      else { SparkInvalid(reject, @"Unknown directory kind"); return; }
+      NSURL *url = [base URLByAppendingPathComponent:SparkNamespace() isDirectory:YES];
+      if (!error) [fm createDirectoryAtURL:url withIntermediateDirectories:YES attributes:nil error:&error];
+      result = url.path;
+    } else if ([method isEqual:@"unwatch"]) {
+      [self.recursiveWatches[args[@"id"]] stop]; [self.recursiveWatches removeObjectForKey:args[@"id"]];
+      dispatch_source_t source = self.watches[args[@"id"]];
+      if (source) { dispatch_source_cancel(source); [self.watches removeObjectForKey:args[@"id"]]; }
+    } else {
+      NSURL *url = FileURL(args[@"path"]);
+      if (!url || !url.isFileURL || (url.host.length && ![url.host isEqual:@"localhost"])) { SparkInvalid(reject, @"Expected an absolute local path or file URL"); return; }
+      if ([method isEqual:@"openFile"]) {
+        NSString *mode = args[@"mode"]; int flags;
+        if ([mode isEqual:@"read"]) flags = O_RDONLY;
+        else if ([mode isEqual:@"readWrite"]) flags = O_RDWR;
+        else if ([mode isEqual:@"write"]) flags = O_WRONLY | O_CREAT;
+        else if ([mode isEqual:@"createNew"]) flags = O_WRONLY | O_CREAT | O_EXCL;
+        else { SparkInvalid(reject, @"Invalid file mode"); return; }
+        int fd = open(url.fileSystemRepresentation, flags | O_CLOEXEC | O_NONBLOCK, 0666);
+        if (fd < 0) error = [NSError errorWithDomain:NSPOSIXErrorDomain code:errno userInfo:nil];
+        else {
+          struct stat info; int code = 0;
+          if (fstat(fd, &info)) code = errno;
+          else if (!S_ISREG(info.st_mode)) code = EINVAL;
+          else if ([mode isEqual:@"write"] && ftruncate(fd, 0)) code = errno;
+          if (code) { close(fd); error = [NSError errorWithDomain:NSPOSIXErrorDomain code:code userInfo:nil]; }
+          else { SparkOpenFile *file = [SparkOpenFile new]; file.descriptor = fd; NSString *identifier = NSUUID.UUID.UUIDString; self.files[identifier] = file; result = identifier; }
+        }
+      } else if ([method isEqual:@"trash"]) { [fm trashItemAtURL:url resultingItemURL:nil error:&error]; }
+      else if ([method isEqual:@"readText"]) result = [NSString stringWithContentsOfURL:url encoding:NSUTF8StringEncoding error:&error];
+      else if ([method isEqual:@"readBytes"]) {
+        NSData *data = [NSData dataWithContentsOfURL:url options:0 error:&error];
+        result = [data base64EncodedStringWithOptions:0];
+      }
+      else if ([method isEqual:@"writeText"]) [args[@"text"] writeToURL:url atomically:YES encoding:NSUTF8StringEncoding error:&error];
+      else if ([method isEqual:@"writeBytes"]) {
+        NSData *data = [[NSData alloc] initWithBase64EncodedString:args[@"base64"] options:0];
+        if (!data) { SparkInvalid(reject, @"Invalid base64 data"); return; }
+        [data writeToURL:url options:NSDataWritingAtomic error:&error];
+      }
+      else if ([method isEqual:@"mkdir"]) [fm createDirectoryAtURL:url withIntermediateDirectories:[args[@"recursive"] boolValue] attributes:nil error:&error];
+      else if ([method isEqual:@"remove"]) {
+        BOOL directory = NO;
+        if (![fm fileExistsAtPath:url.path isDirectory:&directory]) { resolve(@"false"); return; }
+        if (directory && ![args[@"recursive"] boolValue] && [fm contentsOfDirectoryAtPath:url.path error:&error].count) {
+          reject(@"E_NOT_EMPTY", @"Directory is not empty; pass recursive: true", nil); return;
+        }
+        if (!error) result = @([fm removeItemAtURL:url error:&error]);
+      }
+      else if ([method isEqual:@"copy"] || [method isEqual:@"move"]) {
+        NSURL *to = FileURL(args[@"to"]);
+        if (!to || !to.isFileURL || (to.host.length && ![to.host isEqual:@"localhost"])) { SparkInvalid(reject, @"Expected an absolute destination"); return; }
+        if ([method isEqual:@"copy"]) [fm copyItemAtURL:url toURL:to error:&error];
+        else [fm moveItemAtURL:url toURL:to error:&error];
+      }
+      else if ([method isEqual:@"stat"]) {
+        NSDictionary *attrs = [fm attributesOfItemAtPath:url.path error:&error];
+        if (attrs) result = @{ @"size": attrs[NSFileSize], @"modifiedAt": @([attrs[NSFileModificationDate] timeIntervalSince1970] * 1000),
+          @"type": [attrs[NSFileType] isEqual:NSFileTypeDirectory] ? @"directory" : [attrs[NSFileType] isEqual:NSFileTypeSymbolicLink] ? @"symlink" : @"file" };
+      }
+      else if ([method isEqual:@"list"]) {
+        NSArray *names = [fm contentsOfDirectoryAtPath:url.path error:&error];
+        result = [names sortedArrayUsingSelector:@selector(compare:)];
+      }
+      else if ([method isEqual:@"watch"]) {
+        NSString *watchID = args[@"id"];
+        if (self.watches[watchID] || self.recursiveWatches[watchID]) { SparkInvalid(reject, @"Watch id already exists"); return; }
+        if ([args[@"recursive"] boolValue]) {
+          BOOL directory = NO;
+          if (![fm fileExistsAtPath:url.path isDirectory:&directory] || !directory) { SparkInvalid(reject, @"Recursive watch requires an existing directory"); return; }
+          SparkRecursiveWatch *watch = [SparkRecursiveWatch new];
+          // Keep real filesystem paths: Foundation can strip /private while a path
+          // exists, then preserve it after deletion, breaking event comparisons.
+          char *resolved = realpath(url.fileSystemRepresentation, NULL);
+          if (!resolved) { SparkReject(reject, [NSError errorWithDomain:NSPOSIXErrorDomain code:errno userInfo:nil]); return; }
+          watch.path = [NSString stringWithUTF8String:resolved]; free(resolved);
+          __weak RNDesktopFileSystem *weakSelf = self;
+          watch.changed = ^{ [weakSelf sendEventWithName:@"change" body:@{ @"id": watchID, @"path": url.path }]; };
+          FSEventStreamContext context = {0, (__bridge void *)watch, NULL, NULL, NULL};
+          // Observe the parent too, keeping deletion/replacement of the root visible.
+          NSArray *roots = @[[watch.path stringByDeletingLastPathComponent]];
+          watch.stream = FSEventStreamCreate(NULL, RecursiveChanges, &context, (__bridge CFArrayRef)roots, kFSEventStreamEventIdSinceNow, 0.05,
+            kFSEventStreamCreateFlagUseCFTypes | kFSEventStreamCreateFlagFileEvents | kFSEventStreamCreateFlagWatchRoot | kFSEventStreamCreateFlagNoDefer);
+          if (!watch.stream) { reject(@"E_WATCH", @"Could not create directory watcher", nil); return; }
+          FSEventStreamSetDispatchQueue(watch.stream, self.ioQueue);
+          if (!FSEventStreamStart(watch.stream)) { [watch stop]; reject(@"E_WATCH", @"Could not start directory watcher", nil); return; }
+          self.recursiveWatches[watchID] = watch; resolve(@"null"); return;
+        }
+        // Observe the parent so replacing a file atomically does not lose its watch.
+        BOOL isDirectory = NO;
+        [fm fileExistsAtPath:url.path isDirectory:&isDirectory];
+        NSURL *observed = isDirectory ? url : [url URLByDeletingLastPathComponent];
+        int fd = open(observed.fileSystemRepresentation, O_EVTONLY);
+        if (fd < 0) { SparkReject(reject, [NSError errorWithDomain:NSPOSIXErrorDomain code:errno userInfo:nil]); return; }
+        dispatch_source_t source = dispatch_source_create(DISPATCH_SOURCE_TYPE_VNODE, fd,
+          DISPATCH_VNODE_WRITE | DISPATCH_VNODE_DELETE | DISPATCH_VNODE_RENAME | DISPATCH_VNODE_EXTEND | DISPATCH_VNODE_ATTRIB,
+          self.ioQueue);
+        __weak RNDesktopFileSystem *weakSelf = self;
+        dispatch_source_set_event_handler(source, ^{
+          RNDesktopFileSystem *strongSelf = weakSelf;
+          if (strongSelf) [strongSelf sendEventWithName:@"change" body:@{ @"id": watchID, @"path": url.path }];
+        });
+        dispatch_source_set_cancel_handler(source, ^{ close(fd); });
+        self.watches[watchID] = source; dispatch_resume(source);
+      }
+      else { SparkInvalid(reject, @"Unknown filesystem operation"); return; }
+    }
+    if (error) SparkReject(reject, error); else resolve(SparkJSON(result));
+  });
+}
+- (void)invalidate {
+  dispatch_async(self.ioQueue, ^{ [self.files removeAllObjects]; for (SparkRecursiveWatch *watch in self.recursiveWatches.allValues) [watch stop]; [self.recursiveWatches removeAllObjects]; for (dispatch_source_t source in self.watches.allValues) dispatch_source_cancel(source); [self.watches removeAllObjects]; });
+  [super invalidate];
+}
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:(const facebook::react::ObjCTurboModule::InitParams &)params {
+  return std::make_shared<facebook::react::NativeDesktopFileSystemSpecJSI>(params);
+}
+@end

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

@@ -0,0 +1,47 @@
+{
+  "name": "@legendapp/spark-file-system",
+  "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": "RNDesktopFileSystemSpec",
+    "type": "modules",
+    "jsSrcsDir": "src",
+    "ios": {
+      "modulesProvider": {
+        "NativeDesktopFileSystem": "RNDesktopFileSystem"
+      }
+    }
+  },
+  "spark": {
+    "sdk": true,
+    "nativeModules": [
+      "NativeDesktopFileSystem"
+    ],
+    "pod": "RNDesktopFileSystem",
+    "platforms": [
+      "macos",
+      "windows"
+    ],
+    "requires": [
+      "@legendapp/spark-desktop-app"
+    ]
+  },
+  "dependencies": {
+    "@legendapp/spark-desktop-app": "0.0.1-next.2",
+    "base64-js": "1.5.1"
+  },
+  "private": true
+}

package/vendor/node_modules/@legendapp/spark-file-system/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-file-system/src/NativeDesktopFileSystem.ts

@@ -0,0 +1,8 @@
+import type { TurboModule } from "react-native";
+import { TurboModuleRegistry } from "react-native";
+export interface Spec extends TurboModule {
+  call(method: string, args: string): Promise<string>;
+  addListener(eventName: string): void;
+  removeListeners(count: number): void;
+}
+export default TurboModuleRegistry.getEnforcing<Spec>("NativeDesktopFileSystem");

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

@@ -0,0 +1,45 @@
+import { fromByteArray, toByteArray } from "base64-js";
+export const MAX_CHUNK_SIZE = 1024 * 1024;
+export type FileMode = "read" | "readWrite" | "write" | "createNew";
+export type FileHandle = {
+  read(length: number, offset: number): Promise<Uint8Array>;
+  write(bytes: Uint8Array, offset: number): Promise<number>;
+  flush(): Promise<void>;
+  close(): Promise<void>;
+};
+export type FileCall = <T>(method: string, args: object) => Promise<T>;
+function offset(value: number) { if (!Number.isSafeInteger(value) || value < 0) throw new RangeError("Offset must be a nonnegative safe integer"); }
+function length(value: number) { if (!Number.isInteger(value) || value < 1 || value > MAX_CHUNK_SIZE) throw new RangeError("Chunk size must be between 1 byte and 1 MiB"); }
+function aborted(signal?: AbortSignal) { if (signal?.aborted) throw signal.reason ?? new Error("File operation aborted"); }
+/** Positional I/O: handles have no shared cursor. Calls are serialized natively. */
+export async function createFileHandle(call: FileCall, path: string, mode: FileMode = "read"): Promise<FileHandle> {
+  if (!["read", "readWrite", "write", "createNew"].includes(mode)) throw new TypeError("Invalid file mode");
+  const id = await call<string>("openFile", { path, mode });
+  let closing: Promise<void> | undefined;
+  const active = () => { if (closing) throw new Error("File handle is closed"); };
+  return {
+    async read(size, position) { active(); length(size); offset(position); if (!Number.isSafeInteger(position + size)) throw new RangeError("Read range exceeds safe integer bounds"); return toByteArray(await call<string>("readChunk", { id, length: size, offset: position })); },
+    async write(bytes, position) { active(); if (!(bytes instanceof Uint8Array)) throw new TypeError("Expected Uint8Array"); offset(position); if (!Number.isSafeInteger(position + bytes.byteLength)) throw new RangeError("Write range exceeds safe integer bounds"); if (!bytes.length) return 0; length(bytes.length); return call<number>("writeChunk", { id, base64: fromByteArray(bytes), offset: position }); },
+    async flush() { active(); await call("flushFile", { id }); },
+    close() { return closing ??= call<void>("closeFile", { id }); },
+  };
+}
+export type ReadChunksOptions = { offset?: number; chunkSize?: number; signal?: AbortSignal };
+export async function* iterateFile(open: () => Promise<FileHandle>, options: ReadChunksOptions = {}) {
+  let position = options.offset ?? 0; offset(position); const size = options.chunkSize ?? 64 * 1024; length(size); aborted(options.signal);
+  const file = await open();
+  try {
+    for (;;) { aborted(options.signal); const bytes = await file.read(size, position); aborted(options.signal); if (!bytes.length) break; position += bytes.length; yield bytes; }
+  } finally { await file.close(); }
+}
+export async function writeFileChunks(open: () => Promise<FileHandle>, chunks: AsyncIterable<Uint8Array> | Iterable<Uint8Array>, signal?: AbortSignal) {
+  aborted(signal); const file = await open(); let position = 0;
+  try {
+    for await (const bytes of chunks) {
+      aborted(signal);
+      if (!(bytes instanceof Uint8Array)) throw new TypeError("Expected Uint8Array chunks");
+      for (let start = 0; start < bytes.length; start += MAX_CHUNK_SIZE) { aborted(signal); const part = bytes.subarray(start, start + MAX_CHUNK_SIZE); position += await file.write(part, position); }
+    }
+    aborted(signal); await file.flush(); return position;
+  } finally { await file.close(); }
+}

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

@@ -0,0 +1,61 @@
+import { NativeEventEmitter, Platform } from "react-native";
+import Native from "./NativeDesktopFileSystem";
+import { absolutePath } from "./path";
+export type FileStat = { type: "file" | "directory" | "symlink"; size: number; modifiedAt: number };
+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) {
+  try { await stat(path); return true; } catch (error) {
+    if ((error as { code?: string }).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) });
+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");
+  const id = `watch-${Date.now()}-${++nextWatch}`;
+  let removed = false;
+  const subscription = emitter.addListener("change", (event: { id: string; path: string }) => {
+    if (!removed && event.id === id) listener(event.path);
+  });
+  try { await call("watch", { path: absolute(path), id, recursive: options.recursive ?? false }); }
+  catch (error) { subscription.remove(); throw error; }
+  return { async remove() {
+    if (removed) return;
+    removed = true; subscription.remove(); 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");
+  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) });

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

@@ -0,0 +1,9 @@
+/** 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;
+}

package/vendor/node_modules/@legendapp/spark-file-system/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-file-system/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-file-system/windows/SparkFileSystem/ReactPackageProvider.cpp

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

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

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

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

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

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

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

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

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