yukimu 1.3.0 → 2.0.0

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;
-}

package/src/Queue.ts

@@ -1,66 +0,0 @@
-import type { Track } from "./types";
-
-export class Queue {
-  public current: Track | null = null;
-  public previous: Track[] = [];
-  private tracks: Track[] = [];
-
-  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);
-  }
-
-  public next(): Track | null {
-    if (this.current) {
-      this.previous.unshift(this.current);
-      if (this.previous.length > 10) this.previous.pop();
-    }
-    this.current = this.tracks.shift() ?? null;
-    return this.current;
-  }
-
-  public remove(index: number): Track | null {
-    if (index < 0 || index >= this.tracks.length) return null;
-    const [removed] = this.tracks.splice(index, 1);
-    return removed;
-  }
-
-  public removeRange(start: number, end: number): Track[] {
-    return this.tracks.splice(start, end - start);
-  }
-
-  public clear(): void {
-    this.tracks = [];
-    this.current = null;
-    this.previous = [];
-  }
-
-  public shuffle(): void {
-    for (let i = this.tracks.length - 1; i > 0; i--) {
-      const j = Math.floor(Math.random() * (i + 1));
-      [this.tracks[i], this.tracks[j]] = [this.tracks[j], this.tracks[i]];
-    }
-  }
-
-  public move(from: number, to: number): void {
-    if (from < 0 || to < 0 || from >= this.tracks.length || to >= this.tracks.length) return;
-    const [track] = this.tracks.splice(from, 1);
-    this.tracks.splice(to, 0, track);
-  }
-
-  public skipto(index: number): Track | null {
-    if (index < 0 || index >= this.tracks.length) return null;
-    this.tracks.splice(0, index);
-    return this.next();
-  }
-
-  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 list(): ReadonlyArray<Track> { return this.tracks; }
-}

package/src/Resolver.ts

@@ -1,90 +0,0 @@
-import { SOURCE_PREFIXES, URL_PATTERNS } from "./Constants";
-import type { Yukimu } from "./Yukimu";
-import type { SearchResult, SearchSource, Track } from "./types";
-
-export class Resolver {
-  private manager: Yukimu;
-  private spotifyToken: string | null = null;
-  private spotifyExpiry: number = 0;
-
-  constructor(manager: Yukimu) { this.manager = manager; }
-
-  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}`;
-
-    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 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) {
-      const spotifyMatch = query.match(/spotify\.com\/track\/([a-zA-Z0-9]+)/);
-      if (spotifyMatch) {
-        const meta = await this.resolveSpotifyMeta(spotifyMatch[1]);
-        if (meta) return this.resolve(`${meta.title} ${meta.artist}`, "youtube", requester);
-      }
-    }
-
-    // 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;
-  }
-
-  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;
-    }
-    return null;
-  }
-
-  private async getSpotifyToken(): Promise<string | null> {
-    const opts = this.manager.options.spotify;
-    if (!opts) return null;
-    if (this.spotifyToken && Date.now() < this.spotifyExpiry) return this.spotifyToken;
-    try {
-      const res = await (globalThis as any).fetch("https://accounts.spotify.com/api/token", {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/x-www-form-urlencoded",
-          Authorization: `Basic ${Buffer.from(`${opts.clientId}:${opts.clientSecret}`).toString("base64")}`,
-        },
-        body: "grant_type=client_credentials",
-      });
-      const data = await res.json();
-      this.spotifyToken = data.access_token;
-      this.spotifyExpiry = Date.now() + data.expires_in * 1000 - 5000;
-      return this.spotifyToken;
-    } catch { return null; }
-  }
-
-  private async resolveSpotifyMeta(trackId: string): Promise<{ title: string; artist: string } | null> {
-    const token = await this.getSpotifyToken();
-    if (!token) return null;
-    try {
-      const res = await (globalThis as any).fetch(`https://api.spotify.com/v1/tracks/${trackId}`, {
-        headers: { Authorization: `Bearer ${token}` },
-      });
-      const data = await res.json();
-      return { title: data.name, artist: data.artists[0]?.name ?? "Unknown" };
-    } catch { return null; }
-  }
-}

package/src/Rest.ts

@@ -1,127 +0,0 @@
-import { RestError } from "./errors/YukimuError";
-import type { Node } from "./Node";
-import type { SearchResult, Track, NodeStats, NodeInfo } from "./types";
-
-const TIMEOUT_MS = 30000;
-
-export class Rest {
-  private 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 headers(): Record<string, string> {
-    return {
-      Authorization: this.node.options.password,
-      "User-Id": this.node.manager.options.clientId,
-      "Client-Name": "Yukimu/1.3.0",
-      "Content-Type": "application/json",
-      ...(this.node.version === 3 ? { "Num-Shards": "1" } : {}),
-    };
-  }
-
-  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);
-
-    try {
-      const res = await (globalThis as any).fetch(url, {
-        method,
-        headers: this.headers,
-        body: body ? JSON.stringify(body) : undefined,
-        signal: controller.signal,
-      });
-
-      clearTimeout(timeout);
-
-      if (!res.ok) {
-        const text = await res.text().catch(() => "Unknown error");
-        throw new RestError(`REST ${res.status} on ${method} ${path}: ${text}`, res.status, path);
-      }
-
-      if (res.status === 204) return undefined as 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);
-      throw err;
-    }
-  }
-
-  public async loadTracks(identifier: string): Promise<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> {
-    return this.request("GET", `/decodetrack?encodedTrack=${encodeURIComponent(encoded)}`);
-  }
-
-  public async decodeTracks(encoded: string[]): Promise<Track[]> {
-    return this.request("POST", `/decodetracks`, encoded);
-  }
-
-  public async getInfo(): Promise<NodeInfo> {
-    return this.request("GET", "/info");
-  }
-
-  public async getStats(): Promise<NodeStats> {
-    return this.request("GET", "/stats");
-  }
-
-  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}`;
-    return this.request("PATCH", path, body);
-  }
-
-  public async destroyPlayer(guildId: string): Promise<void> {
-    const path = this.node.version === 4
-      ? `/sessions/${this.node.sessionId}/players/${guildId}`
-      : `/players/${guildId}`;
-    await this.request("DELETE", path).catch(() => {});
-  }
-
-  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: 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) };
-      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 };
-      default: return { loadType: "empty", tracks: [] };
-    }
-  }
-}

package/src/TrackCache.ts

@@ -1,46 +0,0 @@
-import type { Track } from "./types";
-
-interface CacheEntry {
-  track: Track;
-  expiresAt: number;
-}
-
-export class TrackCache {
-  private cache: Map<string, CacheEntry> = new Map();
-  private readonly ttl: number;
-  private sweepInterval: ReturnType<typeof setInterval>;
-
-  constructor(ttlMs: number = 3600000) {
-    this.ttl = ttlMs;
-    this.sweepInterval = setInterval(() => this.sweep(), 600000);
-  }
-
-  public set(encoded: string, track: Track): void {
-    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; }
-    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(); }
-
-  private sweep(): void {
-    const now = Date.now();
-    for (const [key, entry] of this.cache) {
-      if (now > entry.expiresAt) this.cache.delete(key);
-    }
-  }
-
-  public destroy(): void {
-    clearInterval(this.sweepInterval);
-    this.cache.clear();
-  }
-
-  get size(): number { return this.cache.size; }
-}