yukimu 1.2.0 → 1.3.0

package/src/Constants.ts

@@ -1,6 +1,4 @@
-/** Lavalink v3/v4 supported ops and constants */
-
-export const VERSION = "2.0.0";
+export const VERSION = "1.3.0";
 export const CLIENT_NAME = `Yukimu/${VERSION}`;
 
 export enum State {
@@ -19,63 +17,6 @@ export enum PlayerState {
   DISCONNECTED = 3,
 }
 
-export enum OpCodes {
-  // v3 WebSocket ops
-  PLAY = "play",
-  STOP = "stop",
-  PAUSE = "pause",
-  SEEK = "seek",
-  VOLUME = "volume",
-  FILTERS = "filters",
-  DESTROY = "destroy",
-  VOICE_UPDATE = "voiceUpdate",
-  EQUALIZER = "equalizer",
-  // Incoming
-  STATS = "stats",
-  PLAYER_UPDATE = "playerUpdate",
-  EVENT = "event",
-  READY = "ready",
-}
-
-export enum LoadType {
-  TRACK = "track",
-  PLAYLIST = "playlist",
-  SEARCH = "search",
-  EMPTY = "empty",
-  ERROR = "error",
-  // v3 equivalents (normalized internally)
-  TRACK_LOADED = "track_loaded",
-  PLAYLIST_LOADED = "playlist_loaded",
-  SEARCH_RESULT = "search_result",
-  NO_MATCHES = "no_matches",
-  LOAD_FAILED = "load_failed",
-}
-
-export enum EventType {
-  TRACK_START = "TrackStartEvent",
-  TRACK_END = "TrackEndEvent",
-  TRACK_EXCEPTION = "TrackExceptionEvent",
-  TRACK_STUCK = "TrackStuckEvent",
-  WS_CLOSED = "WebSocketClosedEvent",
-}
-
-export enum TrackEndReason {
-  FINISHED = "finished",
-  LOAD_FAILED = "loadFailed",
-  STOPPED = "stopped",
-  REPLACED = "replaced",
-  CLEANUP = "cleanup",
-  // v3
-  FINISHED_V3 = "FINISHED",
-  STOPPED_V3 = "STOPPED",
-  REPLACED_V3 = "REPLACED",
-  CLEANUP_V3 = "CLEANUP",
-}
-
-export const STOPPED_REASONS = new Set([
-  "replaced", "stopped", "REPLACED", "STOPPED",
-]);
-
 export const SOURCE_PREFIXES: Record<string, string> = {
   youtube: "ytsearch",
   youtubemusic: "ytmsearch",
@@ -86,7 +27,6 @@ export const SOURCE_PREFIXES: Record<string, string> = {
   tidal: "tdsearch",
   jiosaavn: "jssearch",
   yandexmusic: "ymsearch",
-  flowery: "ftts",
 };
 
 export const URL_PATTERNS: Record<string, RegExp[]> = {
@@ -95,7 +35,11 @@ export const URL_PATTERNS: Record<string, RegExp[]> = {
   soundcloud: [/^https?:\/\/(www\.)?soundcloud\.com\/.+/],
   deezer: [/^https?:\/\/(www\.)?deezer\.com\/(track|album|playlist)\/.+/],
   applemusic: [/^https?:\/\/music\.apple\.com\/.+/],
-  tidal: [/^https?:\/\/(www\.)?tidal\.com\/(browse\/)?(track|album|playlist)\/.+/],
+  tidal: [/^https?:\/\/(www\.)?tidal\.com\/.+/],
   jiosaavn: [/^https?:\/\/(www\.)?jiosaavn\.com\/.+/],
   yandexmusic: [/^https?:\/\/music\.yandex\.(ru|com)\/.+/],
 };
+
+export const STOPPED_REASONS = new Set([
+  "replaced", "stopped", "REPLACED", "STOPPED",
+]);

package/src/Node.ts

@@ -25,7 +25,7 @@ export class Node {
   public penalties: number = 0;
   public ping: number = -1;
 
-  private restQueue: Promise<unknown> = Promise.resolve();
+  private restQueue: Promise<any> = Promise.resolve();
   private reconnectAttempts = 0;
   private reconnectTimeout?: ReturnType<typeof setTimeout>;
   private heartbeatInterval?: ReturnType<typeof setInterval>;
@@ -53,7 +53,7 @@ export class Node {
     const h: Record<string, string> = {
       Authorization: this.options.password,
       "User-Id": this.manager.options.clientId,
-      "Client-Name": "Yukimu/1.2.0",
+      "Client-Name": "Yukimu/1.3.0",
     };
     if (this.version === 3) h["Num-Shards"] = "1";
     if (this.options.resumeKey) h["Resume-Key"] = this.options.resumeKey;
@@ -77,8 +77,8 @@ export class Node {
     this.ws = new WebSocket(this.wsUrl, { headers: this.wsHeaders });
     this.wsQueue.setSocket(this.ws);
     this.ws.on("open", () => this.onOpen());
-    this.ws.on("message", (d: WebSocket.RawData) => this.onMessage(d));
-    this.ws.on("close", (code: number, reason: Buffer) => this.onClose(code, reason.toString()));
+    this.ws.on("message", (d: any) => this.onMessage(d));
+    this.ws.on("close", (code: number, reason: any) => this.onClose(code, reason.toString()));
     this.ws.on("error", (err: Error) => this.onError(err));
   }
 
@@ -115,8 +115,8 @@ export class Node {
     this.startHeartbeat();
   }
 
-  private onMessage(raw: WebSocket.RawData): void {
-    let payload: Record<string, unknown>;
+  private onMessage(raw: any): void {
+    let payload: any;
     try { payload = JSON.parse(raw.toString()); } catch { return; }
     const op = payload.op as string;
 
@@ -124,14 +124,14 @@ export class Node {
       switch (op) {
         case "ready":
           this.state = State.CONNECTED;
-          this.sessionId = payload.sessionId as string;
-          this.resumed = (payload.resumed as boolean) ?? false;
+          this.sessionId = payload.sessionId;
+          this.resumed = payload.resumed ?? false;
           this.manager.emit("nodeReady", this);
           console.log(`[Yukimu] Node "${this.options.name}" ready | session: ${this.sessionId} | resumed: ${this.resumed}`);
           if (this.resumed) this.reconnectPlayers();
           break;
         case "stats":
-          this.stats = payload as unknown as NodeStats;
+          this.stats = payload;
           this.calculatePenalties();
           break;
         case "playerUpdate":
@@ -145,16 +145,9 @@ export class Node {
     }
 
     switch (op) {
-      case "stats":
-        this.stats = payload as unknown as NodeStats;
-        this.calculatePenalties();
-        break;
-      case "playerUpdate":
-        this.handlePlayerUpdate(payload);
-        break;
-      case "event":
-        this.handleEvent(payload);
-        break;
+      case "stats": this.stats = payload; this.calculatePenalties(); break;
+      case "playerUpdate": this.handlePlayerUpdate(payload); break;
+      case "event": this.handleEvent(payload); break;
     }
   }
 
@@ -200,70 +193,70 @@ export class Node {
   }
 
   private movePlayers(): void {
-    const players = [...this.manager.players.values()].filter(p => p.node === this);
+    const players = [...this.manager.players.values()].filter((p: any) => p.node === this);
     if (!players.length) return;
     let best: Node;
     try { best = this.manager.getBestNode(); } catch { return; }
     if (best === this) return;
     console.log(`[Yukimu] Moving ${players.length} players to "${best.options.name}"`);
-    for (const player of players) player.moveToNode(best).catch(console.error);
+    for (const player of players) (player as any).moveToNode(best).catch(console.error);
   }
 
   private reconnectPlayers(): void {
     for (const player of this.manager.players.values()) {
-      if (player.node === this) player.checkVoiceReady();
+      if ((player as any).node === this) (player as any).checkVoiceReady();
     }
   }
 
-  private handlePlayerUpdate(payload: Record<string, unknown>): void {
-    const player = this.manager.players.get(payload.guildId as string);
+  private handlePlayerUpdate(payload: any): void {
+    const player = this.manager.players.get(payload.guildId);
     if (!player) return;
-    const state = payload.state as { position?: number; ping?: number; time?: number };
-    player.position = state.position ?? player.position;
-    player.ping = state.ping ?? player.ping;
-    player.lastUpdated = state.time ?? Date.now();
+    const state = payload.state ?? {};
+    (player as any).position = state.position ?? (player as any).position;
+    (player as any).ping = state.ping ?? (player as any).ping;
+    (player as any).lastUpdated = state.time ?? Date.now();
     this.manager.emit("playerUpdate", player);
   }
 
-  private handleEvent(payload: Record<string, unknown>): void {
-    const player = this.manager.players.get(payload.guildId as string);
+  private handleEvent(payload: any): void {
+    const player = this.manager.players.get(payload.guildId);
     if (!player) return;
 
     let track: Track;
     if (this.version === 3) {
-      track = { encoded: payload.track as string, info: {} as Track["info"], pluginInfo: {} };
+      track = { encoded: payload.track, info: {} as any, pluginInfo: {} };
     } else {
-      track = payload.track as Track;
+      track = payload.track;
       if (track?.encoded) this.manager.trackCache.set(track.encoded, track);
     }
 
+    const p = player as any;
+
     switch (payload.type) {
       case "TrackStartEvent":
-        player.playing = true;
-        player.paused = false;
-        player.lastUpdated = Date.now();
+        p.playing = true;
+        p.paused = false;
+        p.lastUpdated = Date.now();
         this.manager.emit("trackStart", player, track);
         break;
 
       case "TrackEndEvent": {
-        const reason = payload.reason as string;
-        player.playing = false;
-        player.position = 0;
+        const reason = payload.reason;
+        p.playing = false;
+        p.position = 0;
         this.manager.emit("trackEnd", player, track, reason);
         const stopped = ["replaced", "stopped", "REPLACED", "STOPPED"].includes(reason);
         if (!stopped) {
-          if (player.loop === "track" && player.queue.current) {
-            player.play(player.queue.current).catch(() => {});
+          if (p.loop === "track" && p.queue.current) {
+            p.play(p.queue.current).catch(() => {});
           } else {
-            if (player.loop === "queue" && player.queue.current) {
-              player.queue.add(player.queue.current);
-            }
-            const next = player.queue.next();
+            if (p.loop === "queue" && p.queue.current) p.queue.add(p.queue.current);
+            const next = p.queue.next();
             if (next) {
-              player.play(next).catch(() => {});
+              p.play(next).catch(() => {});
             } else {
               this.manager.emit("queueEnd", player);
-              if (player.autoplay && track.info?.uri) {
+              if (p.autoplay && track.info?.uri) {
                 this.manager.emit("autoplayRequest", player, track);
               }
             }
@@ -273,21 +266,21 @@ export class Node {
       }
 
       case "TrackExceptionEvent":
-        this.manager.emit("trackError", player, track, payload.exception as LavalinkException);
+        this.manager.emit("trackError", player, track, payload.exception);
         break;
 
       case "TrackStuckEvent":
-        this.manager.emit("trackStuck", player, track, payload.thresholdMs as number);
-        player.skip().catch(() => {});
+        this.manager.emit("trackStuck", player, track, payload.thresholdMs);
+        p.skip().catch(() => {});
         break;
 
       case "WebSocketClosedEvent":
-        this.manager.emit("socketClosed", player, payload.code as number, payload.reason as string, payload.byRemote as boolean);
+        this.manager.emit("socketClosed", player, payload.code, payload.reason, payload.byRemote);
         break;
     }
   }
 
-  public send(data: Record<string, unknown>): Promise<void> {
+  public send(data: Record<string, any>): Promise<void> {
     return this.wsQueue.send(data);
   }
 

package/src/Player.ts

@@ -3,19 +3,17 @@ import { PlayerState } from "./Constants";
 import { PlayerError } from "./errors/YukimuError";
 import type { Yukimu } from "./Yukimu";
 import type { Node } from "./Node";
-import type { Track, PlayerOptions, VoiceState, FilterOptions } from "./types";
+import type { Track, PlayerOptions, FilterOptions } from "./types";
 
 export class Player {
   public readonly manager: Yukimu;
   public node: Node;
   public readonly queue: Queue;
 
-  // IDs
   public readonly guildId: string;
   public voiceChannelId: string | null;
   public textChannelId?: string;
 
-  // State
   public state: PlayerState = PlayerState.DISCONNECTED;
   public playing: boolean = false;
   public paused: boolean = false;
@@ -24,53 +22,38 @@ export class Player {
   public lastUpdated: number = Date.now();
   public volume: number;
   public loop: "none" | "track" | "queue" = "none";
+  public autoplay: boolean = false;
 
-  // Voice
   public sessionId: string | null = null;
   public voiceToken: string | null = null;
   public voiceEndpoint: string | null = null;
   public selfDeaf: boolean;
   public selfMute: boolean;
 
-  // Filters
   public filters: FilterOptions = {};
-
-  // Data store (like Kazagumo's player.data)
-  public readonly data: Map<string, unknown> = new Map();
-
-  // Autoplay
-  public autoplay: boolean = false;
+  public readonly data: Map<string, any> = new Map();
 
   constructor(manager: Yukimu, node: Node, options: PlayerOptions) {
     this.manager = manager;
     this.node = node;
     this.queue = new Queue();
-
     this.guildId = options.guildId;
     this.voiceChannelId = options.voiceChannelId;
     this.textChannelId = options.textChannelId;
     this.volume = options.volume ?? 100;
     this.selfDeaf = options.selfDeaf ?? true;
     this.selfMute = options.selfMute ?? false;
-
     this.sendVoicePayload(options.voiceChannelId, this.selfDeaf, this.selfMute);
     this.state = PlayerState.CONNECTING;
   }
 
-  // ─── Getters ──────────────────────────────────────────────────────
+  get connected(): boolean { return this.state === PlayerState.CONNECTED; }
 
-  get connected(): boolean {
-    return this.state === PlayerState.CONNECTED;
-  }
-
-  /** Real-time position estimate */
   get realPosition(): number {
     if (!this.playing || this.paused) return this.position;
-    return Math.min(this.position + (Date.now() - this.lastUpdated), this.queue.current?.info.length ?? this.position);
+    return Math.min(this.position + (Date.now() - this.lastUpdated), this.queue.current?.info?.length ?? this.position);
   }
 
-  // ─── Voice ───────────────────────────────────────────────────────
-
   public sendVoicePayload(channelId: string | null, selfDeaf: boolean, selfMute: boolean): void {
     this.manager.connector.sendPayload(this.guildId, {
       op: 4,
@@ -81,10 +64,11 @@ export class Player {
   public checkVoiceReady(): void {
     if (!this.sessionId || !this.voiceToken || !this.voiceEndpoint) return;
 
-    const voiceState: VoiceState = {
+    const voiceState: any = {
       token: this.voiceToken,
       endpoint: this.voiceEndpoint,
       sessionId: this.sessionId,
+      channelId: this.voiceChannelId,
     };
 
     if (this.node.version === 4) {
@@ -101,12 +85,9 @@ export class Player {
     this.state = PlayerState.CONNECTED;
   }
 
-  // ─── Playback ─────────────────────────────────────────────────────
-
   public async play(track?: Track, options?: { startTime?: number; endTime?: number; noReplace?: boolean }): Promise<void> {
     const toPlay = track ?? this.queue.current;
     if (!toPlay) throw new PlayerError("No track to play");
-
     this.queue.current = toPlay;
 
     if (this.node.version === 4) {
@@ -124,7 +105,6 @@ export class Player {
         volume: String(this.volume),
         ...(options?.startTime !== undefined && { startTime: String(options.startTime) }),
         ...(options?.endTime !== undefined && { endTime: String(options.endTime) }),
-        ...(options?.noReplace !== undefined && { noReplace: options.noReplace }),
       });
     }
 
@@ -169,10 +149,7 @@ export class Player {
   }
 
   public async seek(position: number): Promise<void> {
-    if (!this.queue.current?.info.isSeekable) throw new PlayerError("Current track is not seekable");
-    if (position < 0 || position > (this.queue.current.info.length ?? Infinity)) {
-      throw new PlayerError(`Seek position out of range: ${position}`);
-    }
+    if (!this.queue.current?.info?.isSeekable) throw new PlayerError("Current track is not seekable");
     if (this.node.version === 4) {
       await this.node.rest.updatePlayer(this.guildId, { position });
     } else {
@@ -192,22 +169,15 @@ export class Player {
     this.volume = volume;
   }
 
-  // ─── Filters ──────────────────────────────────────────────────────
-
   public async setFilters(filters: FilterOptions): Promise<void> {
     this.filters = { ...this.filters, ...filters };
-
     if (this.node.version === 4) {
       await this.node.rest.updatePlayer(this.guildId, { filters: this.filters });
     } else {
-      if (filters.equalizer) {
-        this.node.send({ op: "equalizer", guildId: this.guildId, bands: filters.equalizer });
-      }
+      if (filters.equalizer) this.node.send({ op: "equalizer", guildId: this.guildId, bands: filters.equalizer });
       const rest = { ...filters };
       delete rest.equalizer;
-      if (Object.keys(rest).length > 0) {
-        this.node.send({ op: "filters", guildId: this.guildId, ...rest });
-      }
+      if (Object.keys(rest).length > 0) this.node.send({ op: "filters", guildId: this.guildId, ...rest });
     }
   }
 
@@ -220,57 +190,48 @@ export class Player {
     }
   }
 
-  // ─── Preset Filters ───────────────────────────────────────────────
-
   public async setBassBoost(level: "off" | "low" | "medium" | "high" | "extreme"): Promise<void> {
     const presets: Record<string, number[]> = {
-      off:     [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
-      low:     [0.2, 0.15, 0.1, 0.05, 0.0, -0.05, 0, 0, 0, 0, 0, 0, 0, 0, 0],
-      medium:  [0.4, 0.3, 0.2, 0.1, 0.05, -0.05, 0, 0, 0, 0, 0, 0, 0, 0, 0],
-      high:    [0.6, 0.5, 0.4, 0.25, 0.1, -0.1, 0, 0, 0, 0, 0, 0, 0, 0, 0],
-      extreme: [1.0, 0.8, 0.6, 0.4, 0.2, -0.2, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+      off:     [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
+      low:     [0.2,0.15,0.1,0.05,0,-0.05,0,0,0,0,0,0,0,0,0],
+      medium:  [0.4,0.3,0.2,0.1,0.05,-0.05,0,0,0,0,0,0,0,0,0],
+      high:    [0.6,0.5,0.4,0.25,0.1,-0.1,0,0,0,0,0,0,0,0,0],
+      extreme: [1.0,0.8,0.6,0.4,0.2,-0.2,0,0,0,0,0,0,0,0,0],
     };
     await this.setFilters({ equalizer: presets[level].map((gain, band) => ({ band, gain })) });
   }
 
   public async setNightcore(enabled: boolean): Promise<void> {
-    await this.setFilters({ timescale: enabled ? { speed: 1.2, pitch: 1.2, rate: 1.0 } : undefined });
+    await this.setFilters({ timescale: enabled ? { speed: 1.2, pitch: 1.2, rate: 1.0 } : {} });
   }
 
   public async setVaporwave(enabled: boolean): Promise<void> {
-    await this.setFilters({ timescale: enabled ? { speed: 0.8, pitch: 0.8, rate: 1.0 } : undefined });
+    await this.setFilters({ timescale: enabled ? { speed: 0.8, pitch: 0.8, rate: 1.0 } : {} });
   }
 
   public async set8D(enabled: boolean): Promise<void> {
-    await this.setFilters({ rotation: enabled ? { rotationHz: 0.2 } : undefined });
+    await this.setFilters({ rotation: enabled ? { rotationHz: 0.2 } : {} });
   }
 
   public async setKaraoke(enabled: boolean): Promise<void> {
-    await this.setFilters({
-      karaoke: enabled ? { level: 1.0, monoLevel: 1.0, filterBand: 220.0, filterWidth: 100.0 } : undefined,
-    });
+    await this.setFilters({ karaoke: enabled ? { level: 1.0, monoLevel: 1.0, filterBand: 220.0, filterWidth: 100.0 } : {} });
   }
 
   public async setTremolo(enabled: boolean, frequency = 2.0, depth = 0.5): Promise<void> {
-    await this.setFilters({ tremolo: enabled ? { frequency, depth } : undefined });
+    await this.setFilters({ tremolo: enabled ? { frequency, depth } : {} });
   }
 
   public async setVibrato(enabled: boolean, frequency = 2.0, depth = 0.5): Promise<void> {
-    await this.setFilters({ vibrato: enabled ? { frequency, depth } : undefined });
+    await this.setFilters({ vibrato: enabled ? { frequency, depth } : {} });
   }
 
   public async setLowPass(enabled: boolean, smoothing = 20.0): Promise<void> {
-    await this.setFilters({ lowPass: enabled ? { smoothing } : undefined });
+    await this.setFilters({ lowPass: enabled ? { smoothing } : {} });
   }
 
-  // ─── Queue Helpers ────────────────────────────────────────────────
-
-  public async add(tracks: Track | Track[], requester?: unknown): Promise<void> {
+  public async add(tracks: Track | Track[], requester?: any): Promise<void> {
     const arr = Array.isArray(tracks) ? tracks : [tracks];
-
-    // Attach requester to each track
     if (requester) arr.forEach(t => { (t as any).requester = requester; });
-
     if (!this.queue.current && arr.length > 0) {
       const first = arr.shift()!;
       this.queue.add(arr);
@@ -280,58 +241,92 @@ export class Player {
     }
   }
 
-  public setLoop(mode: "none" | "track" | "queue"): void {
-    this.loop = mode;
-  }
-
-  public setAutoplay(enabled: boolean): void {
-    this.autoplay = enabled;
-  }
-
-  // ─── Node Moving ──────────────────────────────────────────────────
+  public setLoop(mode: "none" | "track" | "queue"): void { this.loop = mode; }
+  public setAutoplay(enabled: boolean): void { this.autoplay = enabled; }
 
-  /** Move player to a different Lavalink node */
   public async moveToNode(node: Node): Promise<void> {
     if (this.node === node) return;
     const oldNode = this.node;
     this.node = node;
-
-    // Destroy on old node
     await oldNode.rest.destroyPlayer(this.guildId).catch(() => {});
-
-    // Recreate on new node with current state
     if (this.queue.current) {
       await this.play(this.queue.current, { startTime: this.realPosition });
     }
-
-    // Reapply filters and volume
-    if (Object.keys(this.filters).length > 0) {
-      await this.setFilters(this.filters).catch(() => {});
-    }
-    if (this.volume !== 100) {
-      await this.setVolume(this.volume).catch(() => {});
-    }
+    if (Object.keys(this.filters).length > 0) await this.setFilters(this.filters).catch(() => {});
+    if (this.volume !== 100) await this.setVolume(this.volume).catch(() => {});
   }
 
-  // ─── Voice Channel Moves ──────────────────────────────────────────
-
   public async move(channelId: string): Promise<void> {
     this.voiceChannelId = channelId;
     this.sendVoicePayload(channelId, this.selfDeaf, this.selfMute);
   }
 
-  // ─── Destroy ──────────────────────────────────────────────────────
-
   public async destroy(): Promise<void> {
     this.state = PlayerState.DISCONNECTING;
     this.sendVoicePayload(null, false, false);
-
     await this.node.rest.destroyPlayer(this.guildId).catch(() => {});
-
     this.playing = false;
     this.paused = false;
     this.queue.clear();
     this.data.clear();
     this.state = PlayerState.DISCONNECTED;
   }
-}
+
+  // ─── Audio Quality Presets ────────────────────────────────────────
+
+  /** Maximum audio quality — crystal clear, enhanced bass & treble */
+  public async setHighQuality(): Promise<void> {
+    await this.setFilters({
+      equalizer: [
+        { band: 0, gain: 0.25 },   // Sub bass boost
+        { band: 1, gain: 0.20 },   // Bass boost
+        { band: 2, gain: 0.15 },   // Low mid bass
+        { band: 3, gain: 0.05 },   // Mid bass
+        { band: 4, gain: 0.0  },   // Low mid flat
+        { band: 5, gain: 0.0  },   // Mid flat
+        { band: 6, gain: 0.0  },   // Upper mid flat
+        { band: 7, gain: 0.05 },   // Presence slight boost
+        { band: 8, gain: 0.10 },   // Upper presence
+        { band: 9, gain: 0.15 },   // Treble boost
+        { band: 10, gain: 0.15 },  // Upper treble
+        { band: 11, gain: 0.10 },  // Air
+        { band: 12, gain: 0.05 },  // Brilliance
+        { band: 13, gain: 0.0  },  // Ultra high
+        { band: 14, gain: 0.0  },  // Ultra high
+      ],
+      lowPass: { smoothing: 5.0 }, // Very light low pass for clarity
+    });
+  }
+
+  /** Studio quality — flat, neutral, most accurate */
+  public async setStudioQuality(): Promise<void> {
+    await this.clearFilters();
+    await this.setFilters({
+      equalizer: Array.from({ length: 15 }, (_, i) => ({ band: i, gain: 0 })),
+    });
+  }
+
+  /** Concert hall effect */
+  public async setConcertHall(): Promise<void> {
+    await this.setFilters({
+      equalizer: [
+        { band: 0, gain: 0.1 },
+        { band: 1, gain: 0.1 },
+        { band: 2, gain: 0.05 },
+        { band: 3, gain: 0.0 },
+        { band: 4, gain: -0.05 },
+        { band: 5, gain: 0.0 },
+        { band: 6, gain: 0.05 },
+        { band: 7, gain: 0.1 },
+        { band: 8, gain: 0.1 },
+        { band: 9, gain: 0.05 },
+        { band: 10, gain: 0.0 },
+        { band: 11, gain: 0.0 },
+        { band: 12, gain: 0.0 },
+        { band: 13, gain: 0.0 },
+        { band: 14, gain: 0.0 },
+      ],
+      rotation: { rotationHz: 0.05 },
+    });
+  }
+}

package/src/Plugin.ts

@@ -1,23 +1,7 @@
 import type { Yukimu } from "./Yukimu";
 
-/**
- * Base Plugin class — extend this to create Yukimu plugins.
- * Similar to Kazagumo's plugin system.
- *
- * Example:
- * class MyPlugin extends Plugin {
- *   public name = "MyPlugin";
- *   public load(manager: Yukimu) {
- *     manager.on("trackStart", (player, track) => { ... });
- *   }
- * }
- */
 export abstract class Plugin {
   public abstract name: string;
-
-  /** Called when plugin is loaded into Yukimu */
   public abstract load(manager: Yukimu): void;
-
-  /** Called when plugin is unloaded */
   public unload?(manager: Yukimu): void;
 }