yukimu 1.2.0 → 1.3.0

package/src/Queue.ts

@@ -5,21 +5,16 @@ export class Queue {
   public previous: Track[] = [];
   private tracks: Track[] = [];
 
-  // ─── Add / Remove ─────────────────────────────────────────────────
-
   public add(tracks: Track | Track[], position?: number): void {
     const arr = Array.isArray(tracks) ? tracks : [tracks];
-    if (position !== undefined) {
-      this.tracks.splice(position, 0, ...arr);
-    } else {
-      this.tracks.push(...arr);
-    }
+    if (position !== undefined) this.tracks.splice(position, 0, ...arr);
+    else this.tracks.push(...arr);
   }
 
   public next(): Track | null {
     if (this.current) {
       this.previous.unshift(this.current);
-      if (this.previous.length > 10) this.previous.pop(); // keep last 10
+      if (this.previous.length > 10) this.previous.pop();
     }
     this.current = this.tracks.shift() ?? null;
     return this.current;
@@ -41,8 +36,6 @@ export class Queue {
     this.previous = [];
   }
 
-  // ─── Reorder ──────────────────────────────────────────────────────
-
   public shuffle(): void {
     for (let i = this.tracks.length - 1; i > 0; i--) {
       const j = Math.floor(Math.random() * (i + 1));
@@ -56,36 +49,18 @@ export class Queue {
     this.tracks.splice(to, 0, track);
   }
 
-  /** Skip to a specific position in queue */
   public skipto(index: number): Track | null {
     if (index < 0 || index >= this.tracks.length) return null;
     this.tracks.splice(0, index);
     return this.next();
   }
 
-  // ─── Peek / Find ──────────────────────────────────────────────────
-
-  public peek(count: number = 10): Track[] {
-    return this.tracks.slice(0, count);
-  }
-
-  public find(predicate: (track: Track) => boolean): Track | undefined {
-    return this.tracks.find(predicate);
-  }
-
-  public filter(predicate: (track: Track) => boolean): Track[] {
-    return this.tracks.filter(predicate);
-  }
-
-  // ─── Getters ──────────────────────────────────────────────────────
+  public peek(count: number = 10): Track[] { return this.tracks.slice(0, count); }
+  public find(predicate: (track: Track) => boolean): Track | undefined { return this.tracks.find(predicate); }
+  public filter(predicate: (track: Track) => boolean): Track[] { return this.tracks.filter(predicate); }
 
   get size(): number { return this.tracks.length; }
-
   get isEmpty(): boolean { return this.tracks.length === 0; }
-
-  get totalDuration(): number {
-    return this.tracks.reduce((acc, t) => acc + (t.info?.length ?? 0), 0);
-  }
-
+  get totalDuration(): number { return this.tracks.reduce((acc, t) => acc + (t.info?.length ?? 0), 0); }
   get list(): ReadonlyArray<Track> { return this.tracks; }
 }

package/src/Resolver.ts

@@ -7,19 +7,28 @@ export class Resolver {
   private spotifyToken: string | null = null;
   private spotifyExpiry: number = 0;
 
-  constructor(manager: Yukimu) {
-    this.manager = manager;
-  }
+  constructor(manager: Yukimu) { this.manager = manager; }
 
-  public async resolve(query: string, source: SearchSource, requester?: unknown): Promise<SearchResult> {
+  public async resolve(query: string, source: SearchSource, requester?: any): Promise<SearchResult> {
     const node = this.manager.getBestNode();
     const isUrl = /^https?:\/\//.test(query);
     const identifier = isUrl ? query : `${SOURCE_PREFIXES[source] ?? "ytsearch"}:${query}`;
 
-    const result = await node.loadTracks(identifier);
+    let result: SearchResult;
+    try {
+      result = await node.loadTracks(identifier);
+    } catch (err: any) {
+      console.error("[Resolver] loadTracks error:", err.message);
+      return { loadType: "error", tracks: [] };
+    }
+
+    if (!result) return { loadType: "empty", tracks: [] };
+    if (!result.tracks) result.tracks = [];
 
-    // Attach requester
-    if (requester) result.tracks.forEach(t => { (t as Track & { requester: unknown }).requester = requester; });
+    // Attach requester to all tracks
+    if (requester && result.tracks.length > 0) {
+      result.tracks.forEach((t: any) => { t.requester = requester; });
+    }
 
     // Spotify fallback — if LavaSrc not installed
     if ((result.loadType === "error" || result.loadType === "empty") && isUrl) {
@@ -30,9 +39,11 @@ export class Resolver {
       }
     }
 
-    // Cache all returned tracks
-    for (const track of result.tracks) {
-      if (track.encoded) this.manager.trackCache.set(track.encoded, track);
+    // Cache tracks
+    if (result.tracks.length > 0) {
+      for (const track of result.tracks) {
+        if (track?.encoded) this.manager.trackCache.set(track.encoded, track);
+      }
     }
 
     return result;
@@ -50,7 +61,7 @@ export class Resolver {
     if (!opts) return null;
     if (this.spotifyToken && Date.now() < this.spotifyExpiry) return this.spotifyToken;
     try {
-      const res = await fetch("https://accounts.spotify.com/api/token", {
+      const res = await (globalThis as any).fetch("https://accounts.spotify.com/api/token", {
         method: "POST",
         headers: {
           "Content-Type": "application/x-www-form-urlencoded",
@@ -58,7 +69,7 @@ export class Resolver {
         },
         body: "grant_type=client_credentials",
       });
-      const data = await res.json() as { access_token: string; expires_in: number };
+      const data = await res.json();
       this.spotifyToken = data.access_token;
       this.spotifyExpiry = Date.now() + data.expires_in * 1000 - 5000;
       return this.spotifyToken;
@@ -69,10 +80,10 @@ export class Resolver {
     const token = await this.getSpotifyToken();
     if (!token) return null;
     try {
-      const res = await fetch(`https://api.spotify.com/v1/tracks/${trackId}`, {
+      const res = await (globalThis as any).fetch(`https://api.spotify.com/v1/tracks/${trackId}`, {
         headers: { Authorization: `Bearer ${token}` },
       });
-      const data = await res.json() as { name: string; artists: { name: string }[] };
+      const data = await res.json();
       return { title: data.name, artist: data.artists[0]?.name ?? "Unknown" };
     } catch { return null; }
   }

package/src/Rest.ts

@@ -2,35 +2,31 @@ import { RestError } from "./errors/YukimuError";
 import type { Node } from "./Node";
 import type { SearchResult, Track, NodeStats, NodeInfo } from "./types";
 
-const TIMEOUT_MS = 15000;
+const TIMEOUT_MS = 30000;
 
 export class Rest {
   private node: Node;
 
-  constructor(node: Node) {
-    this.node = node;
-  }
+  constructor(node: Node) { this.node = node; }
 
   get baseUrl(): string {
     const protocol = this.node.options.secure ? "https" : "http";
     return `${protocol}://${this.node.options.host}:${this.node.options.port}`;
   }
 
-  get prefix(): string {
-    return this.node.version === 4 ? "/v4" : "";
-  }
+  get prefix(): string { return this.node.version === 4 ? "/v4" : ""; }
 
   get headers(): Record<string, string> {
     return {
       Authorization: this.node.options.password,
       "User-Id": this.node.manager.options.clientId,
-      "Client-Name": "Yukimu/1.2.0",
+      "Client-Name": "Yukimu/1.3.0",
       "Content-Type": "application/json",
       ...(this.node.version === 3 ? { "Num-Shards": "1" } : {}),
     };
   }
 
-  public async request<T = unknown>(method: string, path: string, body?: unknown): Promise<T> {
+  public async request<T = any>(method: string, path: string, body?: any): Promise<T> {
     const url = `${this.baseUrl}${this.prefix}${path}`;
     const controller = new AbortController();
     const timeout = setTimeout(() => controller.abort(), TIMEOUT_MS);
@@ -51,7 +47,17 @@ export class Rest {
       }
 
       if (res.status === 204) return undefined as T;
-      return res.json() as Promise<T>;
+
+      const text = await res.text();
+      let parsed: any;
+      try { parsed = JSON.parse(text); } catch { return null as T; }
+
+      // Normalize Lavalink v4.2+ response — uses "data" instead of "tracks"
+      if (parsed && parsed.data !== undefined && !parsed.tracks) {
+        parsed.tracks = Array.isArray(parsed.data) ? parsed.data : [parsed.data];
+      }
+
+      return parsed as T;
     } catch (err: any) {
       clearTimeout(timeout);
       if (err.name === "AbortError") throw new RestError(`REST timeout on ${method} ${path}`, 408, path);
@@ -60,8 +66,9 @@ export class Rest {
   }
 
   public async loadTracks(identifier: string): Promise<SearchResult> {
-    const raw = await this.request<Record<string, unknown>>("GET", `/loadtracks?identifier=${encodeURIComponent(identifier)}`);
-    return this.node.version === 3 ? this.normalizeV3(raw) : raw as unknown as SearchResult;
+    const raw = await this.request<any>("GET", `/loadtracks?identifier=${encodeURIComponent(identifier)}`);
+    if (!raw) return { loadType: "empty", tracks: [] };
+    return this.node.version === 3 ? this.normalizeV3(raw) : raw;
   }
 
   public async decodeTrack(encoded: string): Promise<Track> {
@@ -80,12 +87,7 @@ export class Rest {
     return this.request("GET", "/stats");
   }
 
-  public async getVersion(): Promise<string> {
-    const res = await (globalThis as any).fetch(`${this.baseUrl}/version`, { headers: this.headers });
-    return res.text();
-  }
-
-  public async updatePlayer(guildId: string, body: unknown, noReplace = false): Promise<unknown> {
+  public async updatePlayer(guildId: string, body: any, noReplace = false): Promise<any> {
     const path = this.node.version === 4
       ? `/sessions/${this.node.sessionId}/players/${guildId}?noReplace=${noReplace}`
       : `/players/${guildId}`;
@@ -96,25 +98,29 @@ export class Rest {
     const path = this.node.version === 4
       ? `/sessions/${this.node.sessionId}/players/${guildId}`
       : `/players/${guildId}`;
-    await this.request("DELETE", path);
+    await this.request("DELETE", path).catch(() => {});
   }
 
-  public async updateSession(body: { resuming?: boolean; timeout?: number }): Promise<unknown> {
+  public async updateSession(body: { resuming?: boolean; timeout?: number }): Promise<any> {
     if (this.node.version !== 4) return;
     return this.request("PATCH", `/sessions/${this.node.sessionId}`, body);
   }
 
-  private normalizeV3(raw: Record<string, unknown>): SearchResult {
-    const loadType = ((raw.loadType as string) ?? "").toLowerCase();
-    const norm = (tracks: unknown[]): Track[] =>
-      (tracks ?? []).map((t: any) => ({ encoded: t.track ?? t.encoded, info: t.info, pluginInfo: t.pluginInfo ?? {} }));
+  private normalizeV3(raw: any): SearchResult {
+    const loadType = (raw?.loadType ?? "").toLowerCase();
+    const norm = (tracks: any[]): Track[] =>
+      (tracks ?? []).map((t: any) => ({
+        encoded: t.track ?? t.encoded,
+        info: t.info,
+        pluginInfo: t.pluginInfo ?? {},
+      }));
 
     switch (loadType) {
-      case "track_loaded": return { loadType: "track", tracks: norm(raw.tracks as unknown[]) };
-      case "playlist_loaded": return { loadType: "playlist", tracks: norm(raw.tracks as unknown[]), playlistInfo: raw.playlistInfo as any };
-      case "search_result": return { loadType: "search", tracks: norm(raw.tracks as unknown[]) };
+      case "track_loaded": return { loadType: "track", tracks: norm(raw.tracks) };
+      case "playlist_loaded": return { loadType: "playlist", tracks: norm(raw.tracks), playlistInfo: raw.playlistInfo };
+      case "search_result": return { loadType: "search", tracks: norm(raw.tracks) };
       case "no_matches": return { loadType: "empty", tracks: [] };
-      case "load_failed": return { loadType: "error", tracks: [], exception: raw.exception as any };
+      case "load_failed": return { loadType: "error", tracks: [], exception: raw.exception };
       default: return { loadType: "empty", tracks: [] };
     }
   }

package/src/TrackCache.ts

@@ -5,51 +5,30 @@ interface CacheEntry {
   expiresAt: number;
 }
 
-/**
- * Track Decode Cache
- * Caches decoded tracks to avoid repeated Lavalink decode calls.
- * TTL-based expiry — default 1 hour.
- */
 export class TrackCache {
   private cache: Map<string, CacheEntry> = new Map();
   private readonly ttl: number;
   private sweepInterval: ReturnType<typeof setInterval>;
 
-  constructor(ttlMs: number = 3600000 /* 1 hour */) {
+  constructor(ttlMs: number = 3600000) {
     this.ttl = ttlMs;
-
-    // Sweep expired entries every 10 minutes
     this.sweepInterval = setInterval(() => this.sweep(), 600000);
   }
 
   public set(encoded: string, track: Track): void {
-    this.cache.set(encoded, {
-      track,
-      expiresAt: Date.now() + this.ttl,
-    });
+    this.cache.set(encoded, { track, expiresAt: Date.now() + this.ttl });
   }
 
   public get(encoded: string): Track | null {
     const entry = this.cache.get(encoded);
     if (!entry) return null;
-    if (Date.now() > entry.expiresAt) {
-      this.cache.delete(encoded);
-      return null;
-    }
+    if (Date.now() > entry.expiresAt) { this.cache.delete(encoded); return null; }
     return entry.track;
   }
 
-  public has(encoded: string): boolean {
-    return this.get(encoded) !== null;
-  }
-
-  public delete(encoded: string): void {
-    this.cache.delete(encoded);
-  }
-
-  public clear(): void {
-    this.cache.clear();
-  }
+  public has(encoded: string): boolean { return this.get(encoded) !== null; }
+  public delete(encoded: string): void { this.cache.delete(encoded); }
+  public clear(): void { this.cache.clear(); }
 
   private sweep(): void {
     const now = Date.now();
@@ -63,7 +42,5 @@ export class TrackCache {
     this.cache.clear();
   }
 
-  get size(): number {
-    return this.cache.size;
-  }
+  get size(): number { return this.cache.size; }
 }

package/src/WsQueue.ts

@@ -1,4 +1,4 @@
-import type WebSocket from "ws";
+import WebSocket from "ws";
 
 interface QueuedMessage {
   data: string;
@@ -6,14 +6,8 @@ interface QueuedMessage {
   reject: (err: Error) => void;
 }
 
-/**
- * WebSocket Message Queue
- * Queues outgoing WS messages and flushes them on reconnect.
- * Prevents message loss when node briefly disconnects.
- */
 export class WsQueue {
   private queue: QueuedMessage[] = [];
-  private flushing = false;
   private ws: WebSocket | null = null;
 
   public setSocket(ws: WebSocket | null): void {
@@ -23,56 +17,42 @@ export class WsQueue {
     }
   }
 
-  /** Send immediately if connected, else queue */
-  public send(data: Record<string, unknown>): Promise<void> {
+  public send(data: Record<string, any>): Promise<void> {
     return new Promise((resolve, reject) => {
       const serialized = JSON.stringify(data);
-
-      if (this.ws?.readyState === 1 /* OPEN */) {
-        this.ws.send(serialized, (err) => {
+      if (this.ws?.readyState === 1) {
+        this.ws.send(serialized, (err: any) => {
           if (err) reject(err);
           else resolve();
         });
       } else {
-        // Queue for later when reconnected
         this.queue.push({ data: serialized, resolve, reject });
       }
     });
   }
 
-  /** Flush all queued messages after reconnect */
   public flush(): void {
-    if (this.flushing || !this.ws) return;
-    this.flushing = true;
-
+    if (!this.ws) return;
     const toSend = [...this.queue];
     this.queue = [];
-
     for (const msg of toSend) {
-      if (this.ws.readyState !== 1 /* OPEN */) {
-        // Re-queue if disconnected again
+      if (this.ws.readyState !== 1) {
         this.queue.unshift(msg);
-        this.flushing = false;
         return;
       }
-      this.ws.send(msg.data, (err) => {
+      this.ws.send(msg.data, (err: any) => {
         if (err) msg.reject(err);
         else msg.resolve();
       });
     }
-
-    this.flushing = false;
   }
 
-  /** Drop all queued messages (on intentional destroy) */
   public clear(): void {
     for (const msg of this.queue) {
-      msg.reject(new Error("WsQueue cleared — node destroyed"));
+      msg.reject(new Error("WsQueue cleared"));
     }
     this.queue = [];
   }
 
-  get size(): number {
-    return this.queue.length;
-  }
+  get size(): number { return this.queue.length; }
 }

package/src/Yukimu.ts

@@ -8,10 +8,7 @@ import { URL_PATTERNS } from "./Constants";
 import { YukimuError } from "./errors/YukimuError";
 import type { Plugin } from "./Plugin";
 import type { Connector } from "./connector/Connector";
-import type {
-  YukimuOptions, NodeOptions, PlayerOptions,
-  YukimuEvents, SearchSource, SearchResult,
-} from "./types";
+import type { YukimuOptions, NodeOptions, PlayerOptions, YukimuEvents, SearchSource, SearchResult } from "./types";
 
 export class Yukimu extends EventEmitter {
   public readonly options: YukimuOptions;
@@ -21,40 +18,27 @@ export class Yukimu extends EventEmitter {
   public readonly resolver: Resolver;
   public readonly pool: ConnectionPool;
   public readonly trackCache: TrackCache;
-
   private readonly plugins: Map<string, Plugin> = new Map();
-
   public nodeResolver?: (nodes: Map<string, Node>) => Node | undefined;
 
-  constructor(
-    options: YukimuOptions,
-    connector: Connector,
-    nodes: NodeOptions[],
-    plugins: Plugin[] = []
-  ) {
+  constructor(options: YukimuOptions, connector: Connector, nodes: NodeOptions[], plugins: Plugin[] = []) {
     super();
-    this.options = {
-      moveOnDisconnect: true,
-      voiceConnectionTimeout: 15000,
-      ...options,
-    };
+    this.options = { moveOnDisconnect: true, voiceConnectionTimeout: 15000, ...options };
     this.connector = connector.set(this);
     this.resolver = new Resolver(this);
     this.pool = new ConnectionPool(this);
     this.trackCache = new TrackCache();
-
     for (const plugin of plugins) this.use(plugin);
     this.connector.listen();
     for (const node of nodes) this.addNode(node);
   }
 
   // ─── Plugin System ────────────────────────────────────────────────
-
   public use(plugin: Plugin): this {
     if (this.plugins.has(plugin.name)) throw new YukimuError(`Plugin "${plugin.name}" already loaded`);
     plugin.load(this);
     this.plugins.set(plugin.name, plugin);
-    console.log(`[Yukimu] 🧩 Plugin "${plugin.name}" loaded`);
+    console.log(`[Yukimu] Plugin "${plugin.name}" loaded`);
     return this;
   }
 
@@ -71,7 +55,6 @@ export class Yukimu extends EventEmitter {
   }
 
   // ─── Node Management ──────────────────────────────────────────────
-
   public addNode(options: NodeOptions): Node {
     if (this.nodes.has(options.name)) throw new YukimuError(`Node "${options.name}" already exists`);
     const node = new Node(this, options);
@@ -107,7 +90,6 @@ export class Yukimu extends EventEmitter {
   }
 
   // ─── Player Management ────────────────────────────────────────────
-
   public createPlayer(options: PlayerOptions): Player {
     const existing = this.players.get(options.guildId);
     if (existing) return existing;
@@ -133,8 +115,7 @@ export class Yukimu extends EventEmitter {
   }
 
   // ─── Search ───────────────────────────────────────────────────────
-
-  public async search(query: string, options?: { source?: SearchSource; requester?: unknown }): Promise<SearchResult> {
+  public async search(query: string, options?: { source?: SearchSource; requester?: any }): Promise<SearchResult> {
     return this.resolver.resolve(
       query,
       options?.source ?? this.options.defaultSource ?? "youtube",
@@ -143,13 +124,7 @@ export class Yukimu extends EventEmitter {
   }
 
   // ─── Voice Gateway ────────────────────────────────────────────────
-
-  public handleVoiceStateUpdate(data: {
-    guild_id?: string;
-    user_id: string;
-    session_id: string;
-    channel_id?: string | null;
-  }): void {
+  public handleVoiceStateUpdate(data: any): void {
     if (data.user_id !== this.options.clientId) return;
     if (!data.guild_id) return;
 
@@ -184,11 +159,7 @@ export class Yukimu extends EventEmitter {
     }
   }
 
-  public handleVoiceServerUpdate(data: {
-    guild_id: string;
-    token: string;
-    endpoint?: string | null;
-  }): void {
+  public handleVoiceServerUpdate(data: any): void {
     if (!data.endpoint) return;
     this.pool.updateServer(data.guild_id, data.token, data.endpoint);
     const player = this.players.get(data.guild_id);
@@ -202,7 +173,6 @@ export class Yukimu extends EventEmitter {
   }
 
   // ─── Utility ─────────────────────────────────────────────────────
-
   public detectSource(url: string): SearchSource | null {
     for (const [source, patterns] of Object.entries(URL_PATTERNS)) {
       if (patterns.some(p => p.test(url))) return source as SearchSource;
@@ -223,25 +193,20 @@ export class Yukimu extends EventEmitter {
 
   public destroy(): void {
     for (const node of this.nodes.values()) node.destroy();
-    for (const guildId of this.players.keys()) this.destroyPlayer(guildId).catch(() => {});
     this.trackCache.destroy();
     this.nodes.clear();
   }
 
   // ─── Typed EventEmitter ───────────────────────────────────────────
-
   public on<K extends keyof YukimuEvents>(event: K, listener: (...args: YukimuEvents[K]) => void): this {
-    return super.on(event, listener as (...args: unknown[]) => void);
+    return super.on(event, listener as any);
   }
-
   public once<K extends keyof YukimuEvents>(event: K, listener: (...args: YukimuEvents[K]) => void): this {
-    return super.once(event, listener as (...args: unknown[]) => void);
+    return super.once(event, listener as any);
   }
-
   public off<K extends keyof YukimuEvents>(event: K, listener: (...args: YukimuEvents[K]) => void): this {
-    return super.off(event, listener as (...args: unknown[]) => void);
+    return super.off(event, listener as any);
   }
-
   public emit<K extends keyof YukimuEvents>(event: K, ...args: YukimuEvents[K]): boolean {
     return super.emit(event, ...args);
   }

package/src/connector/DiscordJS.ts

@@ -1,27 +1,20 @@
 import { Connector } from "./Connector";
-import type { Yukimu } from "../Yukimu";
-
-interface DiscordJSClient {
-  user: { id: string } | null;
-  guilds: { cache: Map<string, { shard: { send(payload: unknown): void } }> };
-  on(event: "raw", listener: (packet: { t: string; d: unknown }) => void): this;
-}
 
 export class DiscordJS extends Connector {
-  private client: DiscordJSClient;
+  private client: any;
 
-  constructor(client: DiscordJSClient) {
+  constructor(client: any) {
     super();
     this.client = client;
   }
 
   public listen(): void {
-    this.client.on("raw", (packet: { t: string; d: unknown }) => {
+    this.client.on("raw", (packet: any) => {
       if (packet.t === "VOICE_STATE_UPDATE") {
-        this.manager.handleVoiceStateUpdate(packet.d as Parameters<Yukimu["handleVoiceStateUpdate"]>[0]);
+        this.manager.handleVoiceStateUpdate(packet.d);
       }
       if (packet.t === "VOICE_SERVER_UPDATE") {
-        this.manager.handleVoiceServerUpdate(packet.d as Parameters<Yukimu["handleVoiceServerUpdate"]>[0]);
+        this.manager.handleVoiceServerUpdate(packet.d);
       }
     });
   }

package/src/connector/Eris.ts

@@ -1,28 +1,17 @@
 import { Connector } from "./Connector";
-import type { Yukimu } from "../Yukimu";
-
-interface ErisClient {
-  guilds: Map<string, { shard: { id: number } }>;
-  shards: Map<number, { sendWS(op: number, data: unknown): void }>;
-  on(event: "rawWS", listener: (packet: { t: string; d: unknown }) => void): this;
-}
 
 export class Eris extends Connector {
-  private client: ErisClient;
+  private client: any;
 
-  constructor(client: ErisClient) {
+  constructor(client: any) {
     super();
     this.client = client;
   }
 
   public listen(): void {
-    this.client.on("rawWS", (packet: { t: string; d: unknown }) => {
-      if (packet.t === "VOICE_STATE_UPDATE") {
-        this.manager.handleVoiceStateUpdate(packet.d as Parameters<Yukimu["handleVoiceStateUpdate"]>[0]);
-      }
-      if (packet.t === "VOICE_SERVER_UPDATE") {
-        this.manager.handleVoiceServerUpdate(packet.d as Parameters<Yukimu["handleVoiceServerUpdate"]>[0]);
-      }
+    this.client.on("rawWS", (packet: any) => {
+      if (packet.t === "VOICE_STATE_UPDATE") this.manager.handleVoiceStateUpdate(packet.d);
+      if (packet.t === "VOICE_SERVER_UPDATE") this.manager.handleVoiceServerUpdate(packet.d);
     });
   }
 
@@ -30,6 +19,6 @@ export class Eris extends Connector {
     const guild = this.client.guilds.get(guildId);
     if (!guild) return;
     const shard = this.client.shards.get(guild.shard.id);
-    if (shard) shard.sendWS(4, (payload as { d: unknown }).d);
+    if (shard) shard.sendWS(4, (payload as any).d);
   }
 }