yukimu 1.3.0 → 2.0.8

package/src/Constants.ts

@@ -1,45 +0,0 @@
-export const VERSION = "1.3.0";
-export const CLIENT_NAME = `Yukimu/${VERSION}`;
-
-export enum State {
-  CONNECTING = 0,
-  NEARLY = 1,
-  CONNECTED = 2,
-  DISCONNECTING = 3,
-  DISCONNECTED = 4,
-  RECONNECTING = 5,
-}
-
-export enum PlayerState {
-  CONNECTING = 0,
-  CONNECTED = 1,
-  DISCONNECTING = 2,
-  DISCONNECTED = 3,
-}
-
-export const SOURCE_PREFIXES: Record<string, string> = {
-  youtube: "ytsearch",
-  youtubemusic: "ytmsearch",
-  spotify: "spsearch",
-  deezer: "dzsearch",
-  applemusic: "amsearch",
-  soundcloud: "scsearch",
-  tidal: "tdsearch",
-  jiosaavn: "jssearch",
-  yandexmusic: "ymsearch",
-};
-
-export const URL_PATTERNS: Record<string, RegExp[]> = {
-  youtube: [/^https?:\/\/(www\.)?(youtube\.com|youtu\.be)\/.+/, /^https?:\/\/music\.youtube\.com\/.+/],
-  spotify: [/^https?:\/\/open\.spotify\.com\/(track|album|playlist|artist)\/.+/],
-  soundcloud: [/^https?:\/\/(www\.)?soundcloud\.com\/.+/],
-  deezer: [/^https?:\/\/(www\.)?deezer\.com\/(track|album|playlist)\/.+/],
-  applemusic: [/^https?:\/\/music\.apple\.com\/.+/],
-  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

@@ -1,302 +0,0 @@
-import WebSocket from "ws";
-import { Rest } from "./Rest";
-import { WsQueue } from "./WsQueue";
-import { State } from "./Constants";
-import { NodeError } from "./errors/YukimuError";
-import type { Yukimu } from "./Yukimu";
-import type { NodeOptions, NodeStats, NodeInfo, Track, SearchResult, LavalinkException } from "./types";
-
-const WS_CLOSE_NORMAL = 1000;
-const HEARTBEAT_INTERVAL = 30000;
-
-export class Node {
-  public readonly manager: Yukimu;
-  public readonly options: NodeOptions;
-  public readonly rest: Rest;
-  public readonly wsQueue: WsQueue;
-  public readonly version: 3 | 4;
-
-  public ws: WebSocket | null = null;
-  public state: State = State.DISCONNECTED;
-  public stats: NodeStats | null = null;
-  public info: NodeInfo | null = null;
-  public sessionId: string | null = null;
-  public resumed: boolean = false;
-  public penalties: number = 0;
-  public ping: number = -1;
-
-  private restQueue: Promise<any> = Promise.resolve();
-  private reconnectAttempts = 0;
-  private reconnectTimeout?: ReturnType<typeof setTimeout>;
-  private heartbeatInterval?: ReturnType<typeof setInterval>;
-  private lastHeartbeatAt = 0;
-
-  constructor(manager: Yukimu, options: NodeOptions) {
-    this.manager = manager;
-    this.options = { secure: false, retries: 5, version: 4, resumeTimeout: 60, ...options };
-    this.version = (this.options.version ?? 4) as 3 | 4;
-    this.rest = new Rest(this);
-    this.wsQueue = new WsQueue();
-  }
-
-  get connected(): boolean {
-    return this.state === State.CONNECTED || this.state === State.NEARLY;
-  }
-
-  get wsUrl(): string {
-    const protocol = this.options.secure ? "wss" : "ws";
-    const base = `${protocol}://${this.options.host}:${this.options.port}`;
-    return this.version === 4 ? `${base}/v4/websocket` : base;
-  }
-
-  get wsHeaders(): Record<string, string> {
-    const h: Record<string, string> = {
-      Authorization: this.options.password,
-      "User-Id": this.manager.options.clientId,
-      "Client-Name": "Yukimu/1.3.0",
-    };
-    if (this.version === 3) h["Num-Shards"] = "1";
-    if (this.options.resumeKey) h["Resume-Key"] = this.options.resumeKey;
-    return h;
-  }
-
-  public calculatePenalties(): number {
-    if (!this.stats) return Infinity;
-    const cpu = Math.pow(1.05, 100 * this.stats.cpu.systemLoad) * 10 - 10;
-    const fs = this.stats.frameStats;
-    const deficit = fs ? Math.pow(1.03, 500 * fs.deficit / 3000) * 600 - 600 : 0;
-    const nulled = fs ? Math.pow(1.03, 500 * fs.nulled / 3000) * 300 - 300 : 0;
-    this.penalties = ~~(cpu + deficit + nulled + this.stats.playingPlayers);
-    return this.penalties;
-  }
-
-  public connect(): void {
-    if (this.ws?.readyState === WebSocket.OPEN) return;
-    this.state = State.CONNECTING;
-    this.manager.emit("nodeConnecting", this);
-    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: 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));
-  }
-
-  public destroy(reconnect = false): void {
-    if (this.reconnectTimeout) clearTimeout(this.reconnectTimeout);
-    if (this.heartbeatInterval) clearInterval(this.heartbeatInterval);
-    this.wsQueue.clear();
-    this.wsQueue.setSocket(null);
-    this.ws?.removeAllListeners();
-    this.ws?.close(WS_CLOSE_NORMAL, "destroy");
-    this.ws = null;
-    this.state = State.DISCONNECTED;
-    if (!reconnect) this.sessionId = null;
-  }
-
-  private async onOpen(): Promise<void> {
-    this.state = State.NEARLY;
-    this.reconnectAttempts = 0;
-    this.manager.emit("nodeConnect", this);
-    console.log(`[Yukimu] Node "${this.options.name}" connected (v${this.version})`);
-
-    try { this.info = await this.rest.getInfo(); } catch {}
-
-    if (this.version === 4 && this.options.resumeKey) {
-      await this.rest.updateSession({ resuming: true, timeout: this.options.resumeTimeout ?? 60 }).catch(() => {});
-    }
-
-    if (this.version === 3) {
-      this.state = State.CONNECTED;
-      this.sessionId = this.options.resumeKey ?? `v3-${Date.now()}`;
-      this.manager.emit("nodeReady", this);
-    }
-
-    this.startHeartbeat();
-  }
-
-  private onMessage(raw: any): void {
-    let payload: any;
-    try { payload = JSON.parse(raw.toString()); } catch { return; }
-    const op = payload.op as string;
-
-    if (this.version === 4) {
-      switch (op) {
-        case "ready":
-          this.state = State.CONNECTED;
-          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;
-          this.calculatePenalties();
-          break;
-        case "playerUpdate":
-          this.handlePlayerUpdate(payload);
-          break;
-        case "event":
-          this.handleEvent(payload);
-          break;
-      }
-      return;
-    }
-
-    switch (op) {
-      case "stats": this.stats = payload; this.calculatePenalties(); break;
-      case "playerUpdate": this.handlePlayerUpdate(payload); break;
-      case "event": this.handleEvent(payload); break;
-    }
-  }
-
-  private onClose(code: number, reason: string): void {
-    if (this.heartbeatInterval) clearInterval(this.heartbeatInterval);
-    this.state = State.DISCONNECTED;
-    this.manager.emit("nodeDisconnect", this, code, reason);
-    console.warn(`[Yukimu] Node "${this.options.name}" disconnected (${code}): ${reason || "No reason"}`);
-    if (code !== WS_CLOSE_NORMAL) this.scheduleReconnect();
-    else this.movePlayers();
-  }
-
-  private onError(error: Error): void {
-    this.manager.emit("nodeError", this, error);
-    console.error(`[Yukimu] Node "${this.options.name}" error:`, error.message);
-  }
-
-  private startHeartbeat(): void {
-    if (this.heartbeatInterval) clearInterval(this.heartbeatInterval);
-    this.heartbeatInterval = setInterval(async () => {
-      if (!this.connected) return;
-      this.lastHeartbeatAt = Date.now();
-      try {
-        this.stats = await this.rest.getStats();
-        this.ping = Date.now() - this.lastHeartbeatAt;
-        this.calculatePenalties();
-      } catch {}
-    }, HEARTBEAT_INTERVAL);
-  }
-
-  private scheduleReconnect(): void {
-    const max = this.options.retries ?? 5;
-    if (this.reconnectAttempts >= max) {
-      this.manager.emit("nodeError", this, new NodeError(`Node "${this.options.name}" max retries reached`));
-      this.movePlayers();
-      return;
-    }
-    const delay = Math.min(1000 * Math.pow(2, this.reconnectAttempts), 30000);
-    this.reconnectAttempts++;
-    this.state = State.RECONNECTING;
-    console.log(`[Yukimu] Reconnecting "${this.options.name}" in ${delay}ms (${this.reconnectAttempts}/${max})`);
-    this.reconnectTimeout = setTimeout(() => { this.destroy(true); this.connect(); }, delay);
-  }
-
-  private movePlayers(): void {
-    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 as any).moveToNode(best).catch(console.error);
-  }
-
-  private reconnectPlayers(): void {
-    for (const player of this.manager.players.values()) {
-      if ((player as any).node === this) (player as any).checkVoiceReady();
-    }
-  }
-
-  private handlePlayerUpdate(payload: any): void {
-    const player = this.manager.players.get(payload.guildId);
-    if (!player) return;
-    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: any): void {
-    const player = this.manager.players.get(payload.guildId);
-    if (!player) return;
-
-    let track: Track;
-    if (this.version === 3) {
-      track = { encoded: payload.track, info: {} as any, pluginInfo: {} };
-    } else {
-      track = payload.track;
-      if (track?.encoded) this.manager.trackCache.set(track.encoded, track);
-    }
-
-    const p = player as any;
-
-    switch (payload.type) {
-      case "TrackStartEvent":
-        p.playing = true;
-        p.paused = false;
-        p.lastUpdated = Date.now();
-        this.manager.emit("trackStart", player, track);
-        break;
-
-      case "TrackEndEvent": {
-        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 (p.loop === "track" && p.queue.current) {
-            p.play(p.queue.current).catch(() => {});
-          } else {
-            if (p.loop === "queue" && p.queue.current) p.queue.add(p.queue.current);
-            const next = p.queue.next();
-            if (next) {
-              p.play(next).catch(() => {});
-            } else {
-              this.manager.emit("queueEnd", player);
-              if (p.autoplay && track.info?.uri) {
-                this.manager.emit("autoplayRequest", player, track);
-              }
-            }
-          }
-        }
-        break;
-      }
-
-      case "TrackExceptionEvent":
-        this.manager.emit("trackError", player, track, payload.exception);
-        break;
-
-      case "TrackStuckEvent":
-        this.manager.emit("trackStuck", player, track, payload.thresholdMs);
-        p.skip().catch(() => {});
-        break;
-
-      case "WebSocketClosedEvent":
-        this.manager.emit("socketClosed", player, payload.code, payload.reason, payload.byRemote);
-        break;
-    }
-  }
-
-  public send(data: Record<string, any>): Promise<void> {
-    return this.wsQueue.send(data);
-  }
-
-  public enqueueRest<T>(fn: () => Promise<T>): Promise<T> {
-    const result = this.restQueue.then(() => fn());
-    this.restQueue = result.catch(() => {});
-    return result;
-  }
-
-  public async loadTracks(identifier: string): Promise<SearchResult> {
-    return this.rest.loadTracks(identifier);
-  }
-
-  public playerPath(guildId: string): string {
-    return this.version === 4
-      ? `/sessions/${this.sessionId}/players/${guildId}`
-      : `/players/${guildId}`;
-  }
-}

package/src/Player.ts

@@ -1,332 +0,0 @@
-import { Queue } from "./Queue";
-import { PlayerState } from "./Constants";
-import { PlayerError } from "./errors/YukimuError";
-import type { Yukimu } from "./Yukimu";
-import type { Node } from "./Node";
-import type { Track, PlayerOptions, FilterOptions } from "./types";
-
-export class Player {
-  public readonly manager: Yukimu;
-  public node: Node;
-  public readonly queue: Queue;
-
-  public readonly guildId: string;
-  public voiceChannelId: string | null;
-  public textChannelId?: string;
-
-  public state: PlayerState = PlayerState.DISCONNECTED;
-  public playing: boolean = false;
-  public paused: boolean = false;
-  public position: number = 0;
-  public ping: number = -1;
-  public lastUpdated: number = Date.now();
-  public volume: number;
-  public loop: "none" | "track" | "queue" = "none";
-  public autoplay: boolean = false;
-
-  public sessionId: string | null = null;
-  public voiceToken: string | null = null;
-  public voiceEndpoint: string | null = null;
-  public selfDeaf: boolean;
-  public selfMute: boolean;
-
-  public filters: FilterOptions = {};
-  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;
-  }
-
-  get connected(): boolean { return this.state === PlayerState.CONNECTED; }
-
-  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);
-  }
-
-  public sendVoicePayload(channelId: string | null, selfDeaf: boolean, selfMute: boolean): void {
-    this.manager.connector.sendPayload(this.guildId, {
-      op: 4,
-      d: { guild_id: this.guildId, channel_id: channelId, self_deaf: selfDeaf, self_mute: selfMute },
-    });
-  }
-
-  public checkVoiceReady(): void {
-    if (!this.sessionId || !this.voiceToken || !this.voiceEndpoint) return;
-
-    const voiceState: any = {
-      token: this.voiceToken,
-      endpoint: this.voiceEndpoint,
-      sessionId: this.sessionId,
-      channelId: this.voiceChannelId,
-    };
-
-    if (this.node.version === 4) {
-      this.node.rest.updatePlayer(this.guildId, { voice: voiceState }).catch(console.error);
-    } else {
-      this.node.send({
-        op: "voiceUpdate",
-        guildId: this.guildId,
-        sessionId: this.sessionId,
-        event: { token: this.voiceToken, guild_id: this.guildId, endpoint: this.voiceEndpoint },
-      });
-    }
-
-    this.state = PlayerState.CONNECTED;
-  }
-
-  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) {
-      await this.node.rest.updatePlayer(this.guildId, {
-        track: { encoded: toPlay.encoded },
-        volume: this.volume,
-        ...(options?.startTime !== undefined && { position: options.startTime }),
-        ...(options?.endTime !== undefined && { endTime: options.endTime }),
-      }, options?.noReplace ?? false);
-    } else {
-      this.node.send({
-        op: "play",
-        guildId: this.guildId,
-        track: toPlay.encoded,
-        volume: String(this.volume),
-        ...(options?.startTime !== undefined && { startTime: String(options.startTime) }),
-        ...(options?.endTime !== undefined && { endTime: String(options.endTime) }),
-      });
-    }
-
-    this.playing = true;
-    this.paused = false;
-    this.lastUpdated = Date.now();
-  }
-
-  public async pause(state: boolean = true): Promise<void> {
-    if (this.node.version === 4) {
-      await this.node.rest.updatePlayer(this.guildId, { paused: state });
-    } else {
-      this.node.send({ op: "pause", guildId: this.guildId, pause: state });
-    }
-    this.paused = state;
-    this.playing = !state;
-  }
-
-  public async resume(): Promise<void> { return this.pause(false); }
-
-  public async stop(): Promise<void> {
-    if (this.node.version === 4) {
-      await this.node.rest.updatePlayer(this.guildId, { track: { encoded: null } });
-    } else {
-      this.node.send({ op: "stop", guildId: this.guildId });
-    }
-    this.playing = false;
-    this.paused = false;
-    this.position = 0;
-    this.queue.current = null;
-  }
-
-  public async skip(): Promise<Track | null> {
-    const next = this.queue.next();
-    if (next) {
-      await this.play(next);
-    } else {
-      await this.stop();
-      this.manager.emit("queueEnd", this);
-    }
-    return next;
-  }
-
-  public async seek(position: number): Promise<void> {
-    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 {
-      this.node.send({ op: "seek", guildId: this.guildId, position });
-    }
-    this.position = position;
-    this.lastUpdated = Date.now();
-  }
-
-  public async setVolume(volume: number): Promise<void> {
-    if (volume < 0 || volume > 1000) throw new PlayerError("Volume must be between 0 and 1000");
-    if (this.node.version === 4) {
-      await this.node.rest.updatePlayer(this.guildId, { volume });
-    } else {
-      this.node.send({ op: "volume", guildId: this.guildId, volume });
-    }
-    this.volume = volume;
-  }
-
-  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 });
-      const rest = { ...filters };
-      delete rest.equalizer;
-      if (Object.keys(rest).length > 0) this.node.send({ op: "filters", guildId: this.guildId, ...rest });
-    }
-  }
-
-  public async clearFilters(): Promise<void> {
-    this.filters = {};
-    if (this.node.version === 4) {
-      await this.node.rest.updatePlayer(this.guildId, { filters: {} });
-    } else {
-      this.node.send({ op: "filters", guildId: this.guildId });
-    }
-  }
-
-  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.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 } : {} });
-  }
-
-  public async setVaporwave(enabled: boolean): Promise<void> {
-    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 } : {} });
-  }
-
-  public async setKaraoke(enabled: boolean): Promise<void> {
-    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 } : {} });
-  }
-
-  public async setVibrato(enabled: boolean, frequency = 2.0, depth = 0.5): Promise<void> {
-    await this.setFilters({ vibrato: enabled ? { frequency, depth } : {} });
-  }
-
-  public async setLowPass(enabled: boolean, smoothing = 20.0): Promise<void> {
-    await this.setFilters({ lowPass: enabled ? { smoothing } : {} });
-  }
-
-  public async add(tracks: Track | Track[], requester?: any): Promise<void> {
-    const arr = Array.isArray(tracks) ? tracks : [tracks];
-    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);
-      await this.play(first);
-    } else {
-      this.queue.add(arr);
-    }
-  }
-
-  public setLoop(mode: "none" | "track" | "queue"): void { this.loop = mode; }
-  public setAutoplay(enabled: boolean): void { this.autoplay = enabled; }
-
-  public async moveToNode(node: Node): Promise<void> {
-    if (this.node === node) return;
-    const oldNode = this.node;
-    this.node = node;
-    await oldNode.rest.destroyPlayer(this.guildId).catch(() => {});
-    if (this.queue.current) {
-      await this.play(this.queue.current, { startTime: this.realPosition });
-    }
-    if (Object.keys(this.filters).length > 0) await this.setFilters(this.filters).catch(() => {});
-    if (this.volume !== 100) await this.setVolume(this.volume).catch(() => {});
-  }
-
-  public async move(channelId: string): Promise<void> {
-    this.voiceChannelId = channelId;
-    this.sendVoicePayload(channelId, this.selfDeaf, this.selfMute);
-  }
-
-  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,7 +0,0 @@
-import type { Yukimu } from "./Yukimu";
-
-export abstract class Plugin {
-  public abstract name: string;
-  public abstract load(manager: Yukimu): void;
-  public unload?(manager: Yukimu): void;
-}