@legendapp/spark 0.0.1-next.2

package/vendor/node_modules/@legendapp/spark-audio/macos/RNSparkAudio.mm

@@ -0,0 +1,154 @@
+#import "RNSparkAudio.h"
+#import <AVFoundation/AVFoundation.h>
+#import <MediaPlayer/MediaPlayer.h>
+@interface RNSparkAudio ()
+@property NSMutableDictionary<NSString *, AVPlayer *> *players;
+@property NSString *activeID;
+@property NSMutableDictionary<NSString *, NSDictionary *> *metadata;
+@property NSMutableDictionary<NSString *, id> *targets;
+@property NSString *sessionID;
+@property NSMutableDictionary *session;
+@property NSMutableArray *commands;
+@property NSUInteger artworkGeneration;
+@end
+static NSDictionary *MediaInfo(NSDictionary *metadata) {
+  NSMutableDictionary *info = [NSMutableDictionary new];
+  if (metadata[@"title"]) info[MPMediaItemPropertyTitle] = metadata[@"title"];
+  if (metadata[@"artist"]) info[MPMediaItemPropertyArtist] = metadata[@"artist"];
+  if (metadata[@"albumTitle"]) info[MPMediaItemPropertyAlbumTitle] = metadata[@"albumTitle"];
+  return info;
+}
+static NSDictionary<NSString *, MPRemoteCommand *> *RemoteCommands() {
+  MPRemoteCommandCenter *center = MPRemoteCommandCenter.sharedCommandCenter;
+  return @{ @"play": center.playCommand, @"pause": center.pauseCommand, @"nextTrack": center.nextTrackCommand,
+    @"previousTrack": center.previousTrackCommand, @"seekTo": center.changePlaybackPositionCommand };
+}
+@interface RNSparkAudio ()
+@end
+@implementation RNSparkAudio
+RCT_EXPORT_MODULE(NativeSparkAudio)
++ (BOOL)requiresMainQueueSetup { return YES; }
+- (instancetype)init { if (self = [super init]) {
+  _players = [NSMutableDictionary new];
+  _metadata = [NSMutableDictionary new]; _targets = [NSMutableDictionary new]; _commands = [NSMutableArray new];
+  __weak RNSparkAudio *weakSelf = self;
+  [RemoteCommands() enumerateKeysAndObjectsUsingBlock:^(NSString *name, MPRemoteCommand *command, BOOL *stop) {
+    command.enabled = [@[@"play", @"pause", @"seekTo"] containsObject:name];
+    self.targets[name] = [command addTargetWithHandler:^MPRemoteCommandHandlerStatus(MPRemoteCommandEvent *event) {
+      RNSparkAudio *owner = weakSelf;
+      if (!owner) return MPRemoteCommandHandlerStatusNoSuchContent;
+      // Deliver on the main queue, serial with session updates and disposal.
+      dispatch_async(dispatch_get_main_queue(), ^{
+        if (owner.sessionID) {
+          if (![owner.session[@"commands"] containsObject:name]) return;
+          NSMutableDictionary *value = [@{@"command": name} mutableCopy];
+          if ([event isKindOfClass:MPChangePlaybackPositionCommandEvent.class]) value[@"position"] = @(((MPChangePlaybackPositionCommandEvent *)event).positionTime);
+          if (owner.commands.count < 128) [owner.commands addObject:value];
+        } else {
+          AVPlayer *player = owner.players[owner.activeID ?: @""];
+          if ([name isEqual:@"play"]) [player play];
+          else if ([name isEqual:@"pause"]) [player pause];
+          else if ([event isKindOfClass:MPChangePlaybackPositionCommandEvent.class]) [player seekToTime:CMTimeMakeWithSeconds(((MPChangePlaybackPositionCommandEvent *)event).positionTime, 600)];
+        }
+      });
+      return MPRemoteCommandHandlerStatusSuccess;
+    }];
+  }];
+} return self; }
+- (void)publishMetadata:(NSDictionary *)metadata {
+  NSMutableDictionary *info = [MediaInfo(metadata) mutableCopy];
+  MPNowPlayingInfoCenter.defaultCenter.nowPlayingInfo = info;
+  NSUInteger generation = ++self.artworkGeneration;
+  NSString *artwork = metadata[@"artworkUrl"];
+  if (!artwork.length) return;
+  NSURL *url = [artwork hasPrefix:@"/"] ? [NSURL fileURLWithPath:artwork] : [NSURL URLWithString:artwork];
+  __weak RNSparkAudio *weakSelf = self;
+  dispatch_async(dispatch_get_global_queue(QOS_CLASS_UTILITY, 0), ^{
+    NSData *data = [NSData dataWithContentsOfURL:url];
+    NSImage *image = data ? [[NSImage alloc] initWithData:data] : nil;
+    dispatch_async(dispatch_get_main_queue(), ^{
+      RNSparkAudio *owner = weakSelf;
+      if (!owner || generation != owner.artworkGeneration || !image) return;
+      NSMutableDictionary *current = [MPNowPlayingInfoCenter.defaultCenter.nowPlayingInfo mutableCopy];
+      current[MPMediaItemPropertyArtwork] = [[MPMediaItemArtwork alloc] initWithBoundsSize:image.size requestHandler:^NSImage *(CGSize size) { return image; }];
+      MPNowPlayingInfoCenter.defaultCenter.nowPlayingInfo = current;
+    });
+  });
+}
+- (void)publishSession {
+  NSMutableDictionary *info = [MPNowPlayingInfoCenter.defaultCenter.nowPlayingInfo mutableCopy] ?: [NSMutableDictionary new];
+  info[MPNowPlayingInfoPropertyElapsedPlaybackTime] = self.session[@"position"] ?: @0;
+  info[MPMediaItemPropertyPlaybackDuration] = self.session[@"duration"] ?: @0;
+  BOOL playing = [self.session[@"playbackState"] isEqual:@"playing"];
+  info[MPNowPlayingInfoPropertyPlaybackRate] = playing ? (self.session[@"playbackRate"] ?: @1) : @0;
+  MPNowPlayingInfoCenter.defaultCenter.nowPlayingInfo = info;
+  MPNowPlayingInfoCenter.defaultCenter.playbackState = playing ? MPNowPlayingPlaybackStatePlaying : [self.session[@"playbackState"] isEqual:@"stopped"] ? MPNowPlayingPlaybackStateStopped : MPNowPlayingPlaybackStatePaused;
+  [RemoteCommands() enumerateKeysAndObjectsUsingBlock:^(NSString *key, MPRemoteCommand *command, BOOL *stop) { command.enabled = [self.session[@"commands"] containsObject:key]; }];
+}
+- (void)call:(NSString *)method args:(NSString *)json resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {
+  dispatch_async(dispatch_get_main_queue(), ^{
+    NSDictionary *args = [NSJSONSerialization JSONObjectWithData:[json dataUsingEncoding:NSUTF8StringEncoding] options:0 error:nil];
+    NSString *identifier = args[@"id"]; if (!identifier.length) { reject(@"E_AUDIO", @"Missing player id", nil); return; }
+    AVPlayer *player = self.players[identifier]; id result = NSNull.null;
+    if ([method hasPrefix:@"session"]) {
+      if ([method isEqual:@"sessionCreate"]) {
+        self.sessionID = identifier; self.session = [@{@"commands": @[@"play", @"pause"]} mutableCopy]; [self.commands removeAllObjects];
+        [self publishMetadata:args[@"metadata"] ?: @{}];
+      } else if (![self.sessionID isEqual:identifier]) { reject(@"E_SESSION_REPLACED", @"Media session has been replaced", nil); return; }
+      if ([method isEqual:@"sessionCreate"] || [method isEqual:@"sessionUpdate"]) {
+        [self.session addEntriesFromDictionary:args];
+        if (args[@"metadata"]) [self publishMetadata:args[@"metadata"]];
+        [self publishSession];
+      } else if ([method isEqual:@"sessionCommands"]) { result = [self.commands copy]; [self.commands removeAllObjects]; }
+      else if ([method isEqual:@"sessionRemove"]) {
+        self.sessionID = nil; self.session = nil; self.activeID = nil; ++self.artworkGeneration; [self.commands removeAllObjects];
+        MPNowPlayingInfoCenter.defaultCenter.nowPlayingInfo = nil; MPNowPlayingInfoCenter.defaultCenter.playbackState = MPNowPlayingPlaybackStateStopped;
+        for (MPRemoteCommand *command in RemoteCommands().allValues) command.enabled = NO;
+      } else { reject(@"E_AUDIO", @"Unknown session operation", nil); return; }
+    } else if ([method isEqual:@"create"]) {
+      NSString *uri = args[@"uri"]; NSURL *url = [uri hasPrefix:@"/"] ? [NSURL fileURLWithPath:uri] : [NSURL URLWithString:uri];
+      if (!url || (!url.isFileURL && ![@[@"https", @"http"] containsObject:url.scheme])) { reject(@"E_AUDIO", @"Expected a local file or HTTP audio URL", nil); return; }
+      if (url.isFileURL && ![NSFileManager.defaultManager isReadableFileAtPath:url.path]) { reject(@"E_NOT_FOUND", @"Audio file is not readable", nil); return; }
+      self.players[identifier] = [AVPlayer playerWithURL:url]; self.metadata[identifier] = @{@"title": args[@"title"] ?: @"Music"};
+      if (!self.sessionID) { self.activeID = identifier; [self publishMetadata:self.metadata[identifier]]; }
+    } else if (!player) { reject(@"E_AUDIO", @"Audio player is not available", nil); return; }
+    else if ([method isEqual:@"ready"]) {
+      NSError *error = player.error ?: player.currentItem.error;
+      if (error) { reject(@"E_AUDIO", error.localizedDescription, error); return; }
+      result = @(player.currentItem.status == AVPlayerItemStatusReadyToPlay);
+    }
+    else if ([method isEqual:@"volume"]) { double volume = [args[@"volume"] doubleValue]; if (!isfinite(volume) || volume < 0 || volume > 1) { reject(@"E_AUDIO", @"Invalid volume", nil); return; } player.volume = volume; }
+    else if ([method isEqual:@"metadata"]) { self.metadata[identifier] = args[@"metadata"]; if (!self.sessionID && [self.activeID isEqual:identifier]) [self publishMetadata:self.metadata[identifier]]; }
+    else if ([method isEqual:@"play"]) {
+      if (!self.sessionID) { self.activeID = identifier; [self publishMetadata:self.metadata[identifier]]; for (NSString *key in RemoteCommands()) RemoteCommands()[key].enabled = [@[@"play", @"pause", @"seekTo"] containsObject:key]; }
+      [player play];
+    }
+    else if ([method isEqual:@"pause"]) [player pause];
+    else if ([method isEqual:@"seek"]) {
+      double seconds = [args[@"seconds"] doubleValue];
+      if (!isfinite(seconds) || seconds < 0) { reject(@"E_AUDIO", @"Invalid seek position", nil); return; }
+      [player seekToTime:CMTimeMakeWithSeconds(seconds, 600) toleranceBefore:kCMTimeZero toleranceAfter:kCMTimeZero completionHandler:^(BOOL finished) { if (finished) resolve(@"null"); else reject(@"E_AUDIO", @"Seek was interrupted", nil); }]; return;
+    } else if ([method isEqual:@"status"]) {
+      double position = CMTimeGetSeconds(player.currentTime), duration = CMTimeGetSeconds(player.currentItem.duration);
+      if (!isfinite(position)) position = 0; if (!isfinite(duration)) duration = 0;
+      NSError *error = player.error ?: player.currentItem.error;
+      BOOL playing = player.timeControlStatus == AVPlayerTimeControlStatusPlaying;
+      result = @{ @"volume": @(player.volume), @"playing": @(playing), @"currentTime": @(position), @"duration": @(duration), @"didJustFinish": @(duration > 0 && position >= duration && player.rate == 0), @"error": error.localizedDescription ?: NSNull.null };
+      if (!self.sessionID && [self.activeID isEqual:identifier]) {
+        NSMutableDictionary *info = [MPNowPlayingInfoCenter.defaultCenter.nowPlayingInfo mutableCopy] ?: [NSMutableDictionary new];
+        info[MPMediaItemPropertyPlaybackDuration] = @(duration); info[MPNowPlayingInfoPropertyElapsedPlaybackTime] = @(position); info[MPNowPlayingInfoPropertyPlaybackRate] = @(player.rate); MPNowPlayingInfoCenter.defaultCenter.nowPlayingInfo = info;
+        MPNowPlayingInfoCenter.defaultCenter.playbackState = playing ? MPNowPlayingPlaybackStatePlaying : MPNowPlayingPlaybackStatePaused;
+      }
+    } else if ([method isEqual:@"remove"]) { [player pause]; [self.players removeObjectForKey:identifier]; [self.metadata removeObjectForKey:identifier]; if (!self.sessionID && [self.activeID isEqual:identifier]) { self.activeID = nil; ++self.artworkGeneration; MPNowPlayingInfoCenter.defaultCenter.nowPlayingInfo = nil; } }
+    else { reject(@"E_AUDIO", @"Unknown audio operation", nil); return; }
+    NSData *data = [NSJSONSerialization dataWithJSONObject:result options:NSJSONWritingFragmentsAllowed error:nil]; resolve([[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding]);
+  });
+}
+- (void)invalidate { dispatch_async(dispatch_get_main_queue(), ^{
+  for (AVPlayer *player in self.players.allValues) [player pause];
+  [self.players removeAllObjects]; [self.metadata removeAllObjects]; ++self.artworkGeneration;
+  for (NSString *key in self.targets) [RemoteCommands()[key] removeTarget:self.targets[key]];
+  [self.targets removeAllObjects]; self.sessionID = nil; MPNowPlayingInfoCenter.defaultCenter.nowPlayingInfo = nil;
+}); }
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:(const facebook::react::ObjCTurboModule::InitParams &)params { return std::make_shared<facebook::react::NativeSparkAudioSpecJSI>(params); }
+@end

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

@@ -0,0 +1,49 @@
+{
+  "name": "@legendapp/spark-audio",
+  "version": "0.0.1-next.2",
+  "license": "MIT",
+  "main": "src/index",
+  "react-native": "src/index",
+  "files": [
+    "src",
+    "macos",
+    "windows",
+    "*.podspec"
+  ],
+  "peerDependencies": {
+    "react": "19.1.4",
+    "react-native": "0.81.6",
+    "expo-audio": "1.1.1"
+  },
+  "peerDependenciesMeta": {
+    "expo-audio": {
+      "optional": true
+    }
+  },
+  "codegenConfig": {
+    "name": "RNSparkAudioSpec",
+    "type": "modules",
+    "jsSrcsDir": "src",
+    "ios": {
+      "modulesProvider": {
+        "NativeSparkAudio": "RNSparkAudio"
+      }
+    }
+  },
+  "spark": {
+    "sdk": true,
+    "nativeModules": [
+      "NativeSparkAudio"
+    ],
+    "pod": "RNSparkAudio",
+    "platforms": [
+      "macos",
+      "windows",
+      "ios",
+      "android",
+      "web"
+    ],
+    "requires": []
+  },
+  "private": true
+}

package/vendor/node_modules/@legendapp/spark-audio/src/NativeSparkAudio.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.get<Spec>("NativeSparkAudio");

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

@@ -0,0 +1,39 @@
+import { statusListeners } from "./status-listeners";
+import { validateVolume, validateMetadata } from "./media-types";
+export { createMediaSession } from "./media-session";
+export type * from "./media-types";
+import Native from "./NativeSparkAudio";
+import { validateSource, validateTime, type AudioPlayer, type AudioSource, type AudioStatus } from "./types";
+export type { AudioPlayer, AudioSource, AudioStatus } from "./types";
+let sequence = 0;
+export async function createAudioPlayer(source: AudioSource): Promise<AudioPlayer> {
+  validateSource(source);
+  if (!Native) throw Object.assign(new Error("Audio playback is unavailable. Build a client with @legendapp/spark-audio."), { code: "E_UNAVAILABLE" });
+  const native = Native, id = `audio-${Date.now()}-${++sequence}`;
+  let removed = false;
+  const call = async <T = void>(method: string, args = {}): Promise<T> => {
+    if (removed) throw new Error("Audio player has been removed");
+    return JSON.parse(await native.call(method, JSON.stringify({ id, ...args })));
+  };
+  await call("create", source);
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  let cancelled = false;
+  try {
+    await Promise.race([
+      (async () => { while (!cancelled && !await call<boolean>("ready")) await new Promise(resolve => setTimeout(resolve, 50)); })(),
+      new Promise<never>((_, reject) => { timer = setTimeout(() => reject(new Error("Audio loading timed out")), 15_000); }),
+    ]);
+  } catch (error) { void call("remove").catch(() => {}); throw error; }
+  finally { cancelled = true; clearTimeout(timer); }
+  const read = () => call<AudioStatus>("status");
+  const listeners = statusListeners(read);
+  return {
+    setVolume: volume => { validateVolume(volume); return call("volume", { volume }); },
+    setMetadata: metadata => { validateMetadata(metadata); return call("metadata", { metadata }); },
+    addListener: (event, listener) => { if (event !== "playbackStatusUpdate") throw new TypeError("Unknown audio event"); return listeners.add(listener); },
+    play: () => call("play"), pause: () => call("pause"),
+    seekTo: seconds => { validateTime(seconds); return call("seek", { seconds }); },
+    getStatus: read,
+    async remove() { if (!removed) { await call("remove"); removed = true; listeners.close(); } },
+  };
+}

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

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

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

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

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

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

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

@@ -0,0 +1,42 @@
+import { validateVolume, validateMetadata } from "./media-types";
+import { statusListeners } from "./status-listeners";
+import { hasExplicitMediaSession, claimPlayerMediaSession, ownsPlayerMediaSession, releasePlayerMediaSession } from "./media-session.web";
+export { createMediaSession } from "./media-session.web";
+export type * from "./media-types";
+import { validateSource, validateTime, type AudioPlayer, type AudioSource } from "./types";
+export type { AudioPlayer, AudioSource, AudioStatus } from "./types";
+
+export async function createAudioPlayer(source: AudioSource): Promise<AudioPlayer> {
+  validateSource(source);
+  const audio = new Audio(source.uri);
+  audio.preload = "metadata";
+  let removed = false;
+  const pending = new Set<() => void>();
+  const alive = () => { if (removed) throw new Error("Audio player has been removed"); };
+  const media = navigator.mediaSession;
+  if (media && !hasExplicitMediaSession()) {
+    claimPlayerMediaSession(audio);
+    media.metadata = new MediaMetadata({ title: source.title ?? "Music" });
+    media.setActionHandler("play", () => { void audio.play().catch(console.error); });
+    media.setActionHandler("pause", () => audio.pause());
+    media.setActionHandler("seekto", event => { if (event.seekTime !== undefined) audio.currentTime = event.seekTime; });
+  }
+  const read = async () => { alive(); return { playing: !audio.paused, currentTime: audio.currentTime, duration: Number.isFinite(audio.duration) ? audio.duration : 0, didJustFinish: audio.ended, error: audio.error?.message ?? null, volume: audio.volume }; };
+  const listeners = statusListeners(read);
+  return {
+    async setVolume(volume) { alive(); validateVolume(volume); audio.volume = volume; },
+    async setMetadata(metadata) { alive(); validateMetadata(metadata); if (media && ownsPlayerMediaSession(audio)) media.metadata = new MediaMetadata({ title: metadata.title, artist: metadata.artist, album: metadata.albumTitle, artwork: metadata.artworkUrl ? [{ src: metadata.artworkUrl }] : [] }); },
+    addListener(event, listener) { if (event !== "playbackStatusUpdate") throw new TypeError("Unknown audio event"); return listeners.add(listener); },
+    async play() { alive(); await audio.play(); }, async pause() { alive(); audio.pause(); },
+    async seekTo(seconds) { alive(); validateTime(seconds); if (audio.readyState === 0) await new Promise<void>((resolve, reject) => {
+      const clear = () => { clearTimeout(timer); pending.delete(cancel); audio.removeEventListener("loadedmetadata", loaded); audio.removeEventListener("error", failed); };
+      const loaded = () => { clear(); resolve(); }; const failed = () => { clear(); reject(new Error("Could not load audio")); };
+      const cancel = () => { clear(); reject(new Error("Audio player has been removed")); };
+      const timer = setTimeout(() => { clear(); reject(new Error("Audio loading timed out")); }, 15_000);
+      pending.add(cancel);
+      audio.addEventListener("loadedmetadata", loaded); audio.addEventListener("error", failed);
+    }); alive(); audio.currentTime = seconds; },
+    getStatus: read,
+    async remove() { if (!removed) { removed = true; listeners.close(); for (const cancel of pending) cancel(); audio.pause(); audio.removeAttribute("src"); audio.load(); if (media && ownsPlayerMediaSession(audio)) { for (const action of ["play", "pause", "seekto"] as const) media.setActionHandler(action, null); media.metadata = null; releasePlayerMediaSession(audio); } } },
+  };
+}

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

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

package/vendor/node_modules/@legendapp/spark-audio/src/media-session-unavailable.ts

@@ -0,0 +1,5 @@
+import type { MediaCommand, MediaSession, MediaSessionOptions } from "./media-types";
+/** Expo Audio owns mobile transport controls; it cannot attach an external engine. */
+export async function createMediaSession(_options: MediaSessionOptions, _onCommand: (command: MediaCommand) => void): Promise<MediaSession> {
+  throw Object.assign(new Error("Standalone media sessions support desktop and web. On mobile use the audio player's Expo-backed controls."), { code: "E_UNAVAILABLE" });
+}

package/vendor/node_modules/@legendapp/spark-audio/src/media-session.ts

@@ -0,0 +1,25 @@
+import Native from "./NativeSparkAudio";
+import { validateSession, type MediaCommand, type MediaSession, type MediaSessionOptions } from "./media-types";
+let owner: (() => void) | undefined, sequence = 0;
+/** One explicit session owns the app's system media controls, independent of playback. */
+export async function createMediaSession(options: MediaSessionOptions, onCommand: (command: MediaCommand) => void): Promise<MediaSession> {
+  validateSession(options);
+  if (!Native) throw Object.assign(new Error("Media sessions require @legendapp/spark-audio in the native runtime"), { code: "E_UNAVAILABLE" });
+  const native = Native, id = `media-${Date.now()}-${++sequence}`;
+  let removed = false, timer: ReturnType<typeof setTimeout> | undefined;
+  const call = async <T = void>(method: string, args = {}): Promise<T> => JSON.parse(await native.call(method, JSON.stringify({ id, ...args })));
+  const stop = () => { removed = true; clearTimeout(timer); };
+  await call("sessionCreate", options); owner?.(); owner = stop;
+  async function poll() {
+    try {
+      const commands = await call<MediaCommand[]>("sessionCommands");
+      if (!removed) for (const command of commands) { try { onCommand(command); } catch (error) { console.error(error); } }
+    } catch (error) { if (!removed) { stop(); console.error(error); } }
+    finally { if (!removed) timer = setTimeout(poll, 100); }
+  }
+  void poll();
+  return {
+    async update(patch) { if (removed) throw new Error("Media session has been removed or replaced"); validateSession(patch); await call("sessionUpdate", patch); },
+    async remove() { if (removed) return; await call("sessionRemove"); stop(); if (owner === stop) owner = undefined; },
+  };
+}

package/vendor/node_modules/@legendapp/spark-audio/src/media-session.web.ts

@@ -0,0 +1,35 @@
+import { validateSession, type MediaCommand, type MediaCommandName, type MediaSession, type MediaSessionOptions } from "./media-types";
+let owner: object | undefined, explicit = false;
+export const hasExplicitMediaSession = () => explicit;
+export const claimPlayerMediaSession = (player: object) => { owner = player; };
+export const ownsPlayerMediaSession = (player: object) => owner === player;
+export const releasePlayerMediaSession = (player: object) => { if (owner === player) owner = undefined; };
+const actions: Record<MediaCommandName, MediaSessionAction> = { play: "play", pause: "pause", nextTrack: "nexttrack", previousTrack: "previoustrack", seekTo: "seekto" };
+export async function createMediaSession(options: MediaSessionOptions, onCommand: (command: MediaCommand) => void): Promise<MediaSession> {
+  validateSession(options);
+  const available = typeof navigator === "undefined" ? undefined : navigator.mediaSession;
+  if (!available) throw Object.assign(new Error("Browser media sessions are unavailable"), { code: "E_UNAVAILABLE" });
+  const media = available;
+  const id = {}; let removed = false, state: MediaSessionOptions = { commands: ["play", "pause"] };
+  const clearActions = () => { for (const action of Object.values(actions)) { try { media.setActionHandler(action, null); } catch {} } };
+  function apply(patch: MediaSessionOptions) {
+    state = { ...state, ...patch };
+    const metadata = state.metadata ?? {};
+    media.metadata = new MediaMetadata({ title: metadata.title, artist: metadata.artist, album: metadata.albumTitle, artwork: metadata.artworkUrl ? [{ src: metadata.artworkUrl }] : [] });
+    media.playbackState = state.playbackState === "playing" ? "playing" : state.playbackState === "paused" ? "paused" : "none";
+    if (media.setPositionState) {
+      if (state.duration && (state.playbackRate ?? 1) > 0) media.setPositionState({ duration: state.duration, position: Math.min(state.position ?? 0, state.duration), playbackRate: state.playbackRate ?? 1 });
+      else media.setPositionState();
+    }
+    clearActions();
+    for (const command of state.commands ?? []) media.setActionHandler(actions[command], details => {
+      if (owner === id && !removed) onCommand({ command, ...(details.seekTime === undefined ? {} : { position: details.seekTime }) });
+    });
+  }
+  owner = id; explicit = true;
+  try { apply(options); } catch (error) { clearActions(); media.metadata = null; media.playbackState = "none"; owner = undefined; explicit = false; throw error; }
+  return {
+    async update(patch) { if (removed || owner !== id) throw new Error("Media session has been removed or replaced"); validateSession(patch); apply(patch); },
+    async remove() { if (removed) return; removed = true; if (owner !== id) return; clearActions(); media.metadata = null; media.playbackState = "none"; media.setPositionState?.(); owner = undefined; explicit = false; },
+  };
+}

package/vendor/node_modules/@legendapp/spark-audio/src/media-types.ts

@@ -0,0 +1,32 @@
+export type AudioMetadata = { title?: string; artist?: string; albumTitle?: string; artworkUrl?: string };
+export type MediaCommandName = "play" | "pause" | "nextTrack" | "previousTrack" | "seekTo";
+export type MediaCommand = { command: MediaCommandName; position?: number };
+export type MediaSessionOptions = {
+  metadata?: AudioMetadata;
+  playbackState?: "playing" | "paused" | "stopped";
+  position?: number;
+  duration?: number;
+  playbackRate?: number;
+  commands?: MediaCommandName[];
+};
+export interface MediaSession {
+  update(options: MediaSessionOptions): Promise<void>;
+  remove(): Promise<void>;
+}
+export function validateVolume(value: number) {
+  if (!Number.isFinite(value) || value < 0 || value > 1) throw new TypeError("Volume must be between 0 and 1");
+}
+export function validateMetadata(metadata: AudioMetadata) {
+  for (const [key, value] of Object.entries(metadata)) {
+    if (!["title", "artist", "albumTitle", "artworkUrl"].includes(key) || typeof value !== "string") throw new TypeError("Invalid audio metadata");
+  }
+  if (metadata.artworkUrl && !/^(https?:\/\/|file:\/\/|\/)/.test(metadata.artworkUrl)) throw new TypeError("Artwork requires an HTTP URL, file URL or absolute path");
+}
+export function validateSession(options: MediaSessionOptions) {
+  if (options.metadata) validateMetadata(options.metadata);
+  for (const key of ["position", "duration", "playbackRate"] as const) {
+    const value = options[key]; if (value !== undefined && (!Number.isFinite(value) || value < 0)) throw new TypeError(`Invalid media ${key}`);
+  }
+  if (options.playbackState !== undefined && !["playing", "paused", "stopped"].includes(options.playbackState)) throw new TypeError("Invalid playback state");
+  if (options.commands !== undefined && (!Array.isArray(options.commands) || options.commands.some(command => !["play", "pause", "nextTrack", "previousTrack", "seekTo"].includes(command)) || new Set(options.commands).size !== options.commands.length)) throw new TypeError("Invalid media commands");
+}

package/vendor/node_modules/@legendapp/spark-audio/src/mobile.ts

@@ -0,0 +1,38 @@
+import { validateVolume, validateMetadata } from "./media-types";
+import { statusListeners } from "./status-listeners";
+export type * from "./media-types";
+export { createMediaSession } from "./media-session-unavailable";
+import { createAudioPlayer as createExpoPlayer, setAudioModeAsync } from "expo-audio";
+import { validateSource, validateTime, type AudioPlayer, type AudioSource } from "./types";
+export type { AudioPlayer, AudioSource, AudioStatus } from "./types";
+export async function createAudioPlayer(source: AudioSource): Promise<AudioPlayer> {
+  validateSource(source);
+  await setAudioModeAsync({ playsInSilentMode: true, shouldPlayInBackground: true, interruptionMode: "doNotMix" });
+  const player = createExpoPlayer(source.uri);
+  let removed = false;
+  let ended = false;
+  let failed = false;
+  const subscription = player.addListener("playbackStatusUpdate", status => { if (status.didJustFinish) ended = true; failed = status.playbackState === "error"; });
+  const alive = () => { if (removed) throw new Error("Audio player has been removed"); };
+  try {
+    if (!player.isLoaded) await new Promise<void>((resolve, reject) => {
+      const timer = setTimeout(() => { loaded.remove(); reject(new Error("Audio loading timed out")); }, 15_000);
+      const loaded = player.addListener("playbackStatusUpdate", status => {
+        if (status.isLoaded || status.playbackState === "error") { clearTimeout(timer); loaded.remove(); if (status.isLoaded) resolve(); else reject(new Error("Audio could not be loaded")); }
+      });
+    });
+    player.setActiveForLockScreen(true, { title: source.title ?? "Music" });
+  } catch (error) { subscription.remove(); player.remove(); throw error; }
+  const read = async () => { alive(); const status = player.currentStatus; return { playing: status.playing, currentTime: status.currentTime, duration: status.duration, didJustFinish: ended, error: failed ? "Audio could not be decoded or loaded" : null, volume: player.volume }; };
+  const listeners = statusListeners(read);
+  return {
+    async setVolume(volume) { alive(); validateVolume(volume); player.volume = volume; },
+    async setMetadata(metadata) { alive(); validateMetadata(metadata); player.updateLockScreenMetadata(metadata); },
+    addListener(event, listener) { if (event !== "playbackStatusUpdate") throw new TypeError("Unknown audio event"); return listeners.add(listener); },
+    async play() { alive(); ended = false; player.play(); },
+    async pause() { alive(); player.pause(); },
+    async seekTo(seconds) { alive(); validateTime(seconds); ended = false; await player.seekTo(seconds); },
+    getStatus: read,
+    async remove() { if (!removed) { removed = true; listeners.close(); subscription.remove(); player.clearLockScreenControls(); player.remove(); } },
+  };
+}

package/vendor/node_modules/@legendapp/spark-audio/src/status-listeners.ts

@@ -0,0 +1,22 @@
+import type { AudioStatus } from "./types";
+/** Sample status only while observed. No React state or render is involved. */
+export function statusListeners(read: () => Promise<AudioStatus>) {
+  const listeners = new Set<(status: AudioStatus) => void>();
+  let timer: ReturnType<typeof setTimeout> | undefined, closed = false, running = false;
+  async function tick() {
+    running = true;
+    try {
+      const status = await read();
+      if (!closed) for (const listener of [...listeners]) { try { listener(status); } catch (error) { console.error(error); } }
+    } catch (error) { if (!closed) console.error(error); }
+    finally { running = false; if (!closed && listeners.size) timer = setTimeout(tick, 250); }
+  }
+  return {
+    add(listener: (status: AudioStatus) => void) {
+      if (closed) throw new Error("Audio player has been removed");
+      listeners.add(listener); if (!running && !timer) void tick();
+      return { remove() { listeners.delete(listener); if (!listeners.size) { clearTimeout(timer); timer = undefined; } } };
+    },
+    close() { closed = true; clearTimeout(timer); listeners.clear(); },
+  };
+}

package/vendor/node_modules/@legendapp/spark-audio/src/types.ts

@@ -0,0 +1,21 @@
+import type { AudioMetadata } from "./media-types";
+export * from "./media-types";
+/** Seconds throughout. Commands reject when the backend cannot complete them. */
+export type AudioStatus = { playing: boolean; currentTime: number; duration: number; didJustFinish: boolean; error: string | null; volume: number };
+export type AudioSource = { uri: string; title?: string };
+export interface AudioPlayer {
+  setVolume(volume: number): Promise<void>;
+  setMetadata(metadata: AudioMetadata): Promise<void>;
+  addListener(event: "playbackStatusUpdate", listener: (status: AudioStatus) => void): { remove(): void };
+  play(): Promise<void>;
+  pause(): Promise<void>;
+  seekTo(seconds: number): Promise<void>;
+  getStatus(): Promise<AudioStatus>;
+  remove(): Promise<void>;
+}
+export function validateSource(source: AudioSource) {
+  if (!source || typeof source.uri !== "string" || !source.uri || source.uri.includes("\0")) throw new Error("Audio requires a URI or absolute desktop file path");
+}
+export function validateTime(seconds: number) {
+  if (!Number.isFinite(seconds) || seconds < 0) throw new Error("Seek position must be a finite, nonnegative number of seconds");
+}

package/vendor/node_modules/@legendapp/spark-audio/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-audio/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-audio/windows/SparkAudio/ReactPackageProvider.cpp

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

package/vendor/node_modules/@legendapp/spark-audio/windows/SparkAudio/ReactPackageProvider.h

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

package/vendor/node_modules/@legendapp/spark-audio/windows/SparkAudio/ReactPackageProvider.idl

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

package/vendor/node_modules/@legendapp/spark-audio/windows/SparkAudio/SparkAudio.cpp

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

package/vendor/node_modules/@legendapp/spark-audio/windows/SparkAudio/SparkAudio.def

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