Gasp i almost deleted this folder I thought I'd commited these

NellowTCS · Mar 16, 2026 · Mar 16, 2026 · Mar 16, 2026 · Mar 16, 2026 · Mar 16, 2026
commit cdae3fd9568d9d220f9fbfa3a8345c6e3d1a0aa0
diff --git a/Build/package-lock.json b/Build/package-lock.json
diff --git a/Build/src/core/engine/engine.ts b/Build/src/core/engine/engine.ts
@@ -55,6 +55,7 @@ export class KomorebiEngine {
   private currentTime = 0;
   private duration = 0;
   private currentError: EngineError | null = null;
+  private currentPlaylist: Playlist | null = null;
 
   private timeUpdateInterval: number | null = null;
   private scheduledTransitionId: number | null = null;
@@ -126,11 +127,25 @@ export class KomorebiEngine {
 
     if (playlist) {
       this.queue.setPlaylist(playlist);
+      this.currentPlaylist = playlist;
+    } else if (
+      this.queue.getTracks().findIndex((t) => t.id === track.id) < 0
+    ) {
+      const solo: Playlist = {
+        id: `solo:${track.id}`,
+        name: track.title,
+        songs: [track],
+      };
+      this.queue.setPlaylist(solo);
+      this.currentPlaylist = solo;
     }
 
+    const previousTrack = this.queue.getCurrentTrack();
+
     this.queue.setCurrentIndex(
       this.queue.getTracks().findIndex((t) => t.id === track.id),
     );
+    this.emitTrackChange(previousTrack, track);
 
     this.stateMachine.transition("loading");
     this.currentError = null;
@@ -353,14 +368,15 @@ export class KomorebiEngine {
 
   setPlaylist(playlist: Playlist): void {
     this.queue.setPlaylist(playlist, false);
+    this.currentPlaylist = playlist;
     this.events.emit("queuechange", { queue: this.queue.getState() });
   }
 
   getState(): EngineState {
     return {
       state: this.stateMachine.getState(),
       currentTrack: this.queue.getCurrentTrack(),
-      currentPlaylist: null,
+      currentPlaylist: this.currentPlaylist,
       queue: this.queue.getState(),
       settings: { ...this.settings },
       currentTime: this.currentTime,
@@ -422,32 +438,39 @@ export class KomorebiEngine {
     timeout = 5000,
   ): Promise<void> {
     return new Promise((resolve, reject) => {
-      const checkState = () => {
-        if (this.stateMachine.getState() === targetState) {
-          resolve();
-          return true;
-        }
-        if (this.stateMachine.hasError()) {
-          reject(new Error("State transition failed"));
-          return true;
-        }
-        return false;
-      };
-
-      if (checkState()) return;
-
+      let settled = false;
       const timeoutId = setTimeout(() => {
-        this.events.off("statechange", stateHandler);
+        if (settled) return;
+        settled = true;
+        this.events.off("statechange", onStateChange);
         reject(new Error(`Timeout waiting for state: ${targetState}`));
       }, timeout);
 
-      const stateHandler = () => {
-        if (checkState()) {
+      const onStateChange = () => {
+        if (settled) return;
+        if (this.stateMachine.getState() === targetState) {
+          settled = true;
           clearTimeout(timeoutId);
+          this.events.off("statechange", onStateChange);
+          resolve();
+        } else if (this.stateMachine.hasError()) {
+          settled = true;
+          clearTimeout(timeoutId);
+          this.events.off("statechange", onStateChange);
+          reject(new Error("State transition failed"));
         }
       };
 
-      this.events.on("statechange", stateHandler);
+      if (this.stateMachine.getState() === targetState) {
+        onStateChange();
+        return;
+      }
+      if (this.stateMachine.hasError()) {
+        onStateChange();
+        return;
+      }
+
+      this.events.on("statechange", onStateChange);
     });
   }
 
@@ -529,6 +552,10 @@ export class KomorebiEngine {
       return;
     }
 
+    if (this.stateMachine.isTransitioning()) {
+      return;
+    }
+
     if (this.settings.autoPlayNext) {
       this.next();
     } else {

diff --git a/Build/src/helpers/addSong.ts b/Build/src/helpers/addSong.ts
@@ -0,0 +1,13 @@
+import type { Track } from "../core/engine/types";
+import { trackStorage } from "../platform/storage/trackStorage";
+
+export async function prepareAndStoreSong(
+  song: Track,
+  file: File,
+): Promise<Track> {
+  song.url = URL.createObjectURL(file);
+  song.hasStoredAudio = true;
+  const arrayBuffer = await file.arrayBuffer();
+  await trackStorage.saveTrack(song, arrayBuffer);
+  return song;
+}
diff --git a/Build/src/hooks/useFileHandler.ts b/Build/src/hooks/useFileHandler.ts
@@ -11,11 +11,11 @@ const logger = createLogger("useFileHandler");
 
 export function useFileHandler(
   addSong: (song: Track, file?: File) => Promise<void>,
-  t: any,
+  t: (key: string, options?: Record<string, unknown>) => string,
   importFiles: (
     files: File[],
     addSong: (song: Track, file?: File) => Promise<void>,
-    t: any,
+    t: (key: string, options?: Record<string, unknown>) => string,
   ) => Promise<void>,
   isInitialized?: boolean,
 ) {

diff --git a/Build/src/hooks/useKomorebi.ts b/Build/src/hooks/useKomorebi.ts
@@ -92,6 +92,8 @@ const DEFAULT_QUEUE: QueueState = {
   shuffleOrder: [],
 };
 
+const LOAD_WAIT_TIMEOUT_MS = 5000;
+
 function createInitialState(): EngineState {
   return {
     state: "idle",
@@ -125,6 +127,7 @@ export function useKomorebi(
   const backendRef = useRef<IAudioBackend | null>(null);
   const engineRef = useRef<KomorebiEngine | null>(null);
   const libraryRef = useRef<LibraryManager | null>(null);
+  const playlistsSaveTimerRef = useRef<number | null>(null);
   const settingsRef = useRef<SettingsManager | null>(null);
   const initializedRef = useRef(false);
 
@@ -170,35 +173,34 @@ export function useKomorebi(
       setCurrentTime(e.currentTime);
       setDuration(e.duration);
     };
-    const handleEnded = async () => {
-      const currentState = engine.getState();
-      if (currentState.settings.autoPlayNext) {
-        await engine.next();
-      }
-    };
     const handleError = (e: { error: { message: string } }) => {
       setError(e.error.message);
     };
     const handleLoading = () => setIsLoading(true);
     const handleReady = () => setIsLoading(false);
 
     engine.on("statechange", handleStateChange);
+    engine.on("volumechange", handleStateChange);
+    engine.on("queuechange", handleStateChange);
+    engine.on("settingschange", handleStateChange);
+    engine.on("durationchange", handleStateChange);
     engine.on("trackchange", handleTrackChange);
     engine.on("timeupdate", handleTimeUpdate);
-    engine.on("ended", handleEnded);
     engine.on("error", handleError);
     engine.on("loading", handleLoading);
     engine.on("ready", handleReady);
 
     const handleLibraryChange = () => {
-      console.log("[handleLibraryChange] called, songs:", library.getState().songs.length);
       setSongs([...library.getState().songs]);
       setState(engine.getState());
     };
     library.on("songadded", handleLibraryChange);
     library.on("songremoved", handleLibraryChange);
+    library.on("songupdated", handleLibraryChange);
     library.on("playlistadded", handleLibraryChange);
     library.on("playlistremoved", handleLibraryChange);
+    library.on("playlistupdated", handleLibraryChange);
+    library.on("playlistsupdated", handleLibraryChange);
     library.on("favoritechanged", handleLibraryChange);
 
     const loadLibrary = async () => {
@@ -209,11 +211,7 @@ export function useKomorebi(
             const reconstructed = await trackStorage.reconstructUrl(song);
             library.addSong(reconstructed);
           }
-          savedLibrary.playlists.forEach((playlist) => {
-            if ("songs" in playlist) {
-              library.addPlaylist(playlist);
-            }
-          });
+          library.seedPlaylists(savedLibrary.playlists);
           savedLibrary.favorites.forEach((id) => {
             const song = library.getSong(id);
             if (song) library.toggleFavorite(id);
@@ -226,23 +224,28 @@ export function useKomorebi(
 
     loadLibrary().then(() => {
       setIsReady(true);
-      console.log("[loadLibrary] setting songs:", library.getState().songs.length);
       setSongs([...library.getState().songs]);
       setState(engine.getState());
     });
 
     return () => {
       engine.off("statechange", handleStateChange);
+      engine.off("volumechange", handleStateChange);
+      engine.off("queuechange", handleStateChange);
+      engine.off("settingschange", handleStateChange);
+      engine.off("durationchange", handleStateChange);
       engine.off("trackchange", handleTrackChange);
       engine.off("timeupdate", handleTimeUpdate);
-      engine.off("ended", handleEnded);
       engine.off("error", handleError);
       engine.off("loading", handleLoading);
       engine.off("ready", handleReady);
       library.off("songadded", handleLibraryChange);
       library.off("songremoved", handleLibraryChange);
+      library.off("songupdated", handleLibraryChange);
       library.off("playlistadded", handleLibraryChange);
       library.off("playlistremoved", handleLibraryChange);
+      library.off("playlistupdated", handleLibraryChange);
+      library.off("playlistsupdated", handleLibraryChange);
       library.off("favoritechanged", handleLibraryChange);
       backendRef.current?.dispose();
     };
@@ -264,6 +267,23 @@ export function useKomorebi(
       }
     };
 
+    const handlePlaylistsChange = () => {
+      if (playlistsSaveTimerRef.current !== null) {
+        window.clearTimeout(playlistsSaveTimerRef.current);
+      }
+      playlistsSaveTimerRef.current = window.setTimeout(() => {
+        playlistsSaveTimerRef.current = null;
+        const current = libraryRef.current;
+        if (current) {
+          libraryPersistence
+            .savePlaylists(current.getState().playlists)
+            .catch((error: unknown) => {
+              logger.error("Failed to save playlists:", { error: String(error) });
+            });
+        }
+      }, 300);
+    };
+
     const library = libraryRef.current;
     library.on(
       "songadded",
@@ -277,8 +297,27 @@ export function useKomorebi(
       "favoritechanged",
       handleFavoritesChange as Parameters<typeof library.on>[1],
     );
+    library.on(
+      "playlistadded",
+      handlePlaylistsChange as Parameters<typeof library.on>[1],
+    );
+    library.on(
+      "playlistremoved",
+      handlePlaylistsChange as Parameters<typeof library.on>[1],
+    );
+    library.on(
+      "playlistupdated",
+      handlePlaylistsChange as Parameters<typeof library.on>[1],
+    );
+    library.on(
+      "playlistsupdated",
+      handlePlaylistsChange as Parameters<typeof library.on>[1],
+    );
 
     return () => {
+      if (playlistsSaveTimerRef.current !== null) {
+        window.clearTimeout(playlistsSaveTimerRef.current);
+      }
       library.off(
         "songadded",
         handleSongAdded as Parameters<typeof library.on>[1],
@@ -291,6 +330,22 @@ export function useKomorebi(
         "favoritechanged",
         handleFavoritesChange as Parameters<typeof library.on>[1],
       );
+      library.off(
+        "playlistadded",
+        handlePlaylistsChange as Parameters<typeof library.on>[1],
+      );
+      library.off(
+        "playlistremoved",
+        handlePlaylistsChange as Parameters<typeof library.on>[1],
+      );
+      library.off(
+        "playlistupdated",
+        handlePlaylistsChange as Parameters<typeof library.on>[1],
+      );
+      library.off(
+        "playlistsupdated",
+        handlePlaylistsChange as Parameters<typeof library.on>[1],
+      );
     };
   }, [options.persistLibrary, isReady]);
 
@@ -322,34 +377,39 @@ export function useKomorebi(
   }, []);
 
   const playSong = useCallback(async (song: Track, playlist?: Playlist) => {
-    console.log("[playSong] called", { song: song?.title, songUrl: song?.url, playlist: playlist?.name });
     setError(null);
     const engine = engineRef.current;
-    console.log("[playSong] engine:", engine);
-    if (!engine) {
-      console.log("[playSong] no engine!");
-      return;
-    }
+    if (!engine) return;
 
     const trackToPlay = await trackStorage.reconstructUrl(song);
-    console.log("[playSong] reconstructed url:", trackToPlay.url);
 
     if (playlist) {
       engine.setPlaylist(playlist);
     }
     engine.load(trackToPlay, playlist);
-    
+
     await new Promise<void>((resolve) => {
-      const handleReady = () => {
+      let settled = false;
+      const finish = () => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timeoutId);
         engine.off("ready", handleReady);
+        engine.off("error", handleError);
         resolve();
       };
+      const timeoutId = setTimeout(finish, LOAD_WAIT_TIMEOUT_MS);
+      const handleReady = () => finish();
+      const handleError = () => finish();
+
       engine.on("ready", handleReady);
+      engine.on("error", handleError);
     });
-
-    console.log("[playSong] calling engine.play()");
-    await engine.play();
-    console.log("[playSong] play() completed");
+
+    const playerState = engine.getState().state;
+    if (playerState === "ready" || playerState === "paused") {
+      await engine.play();
+    }
   }, []);
 
   const seek = useCallback((time: number) => {
@@ -396,7 +456,6 @@ export function useKomorebi(
   }, []);
 
   const addSong = useCallback((song: Track) => {
-    console.log("[addSong] called", { songId: song.id, title: song.title });
     libraryRef.current?.addSong(song);
   }, []);