enerthya.dev-audio-core 1.0.0

package/README.md

@@ -0,0 +1,5 @@
+# enerthya.dev-audio-core
+
+Part of the Enerthya audio system.
+
+See `src/index.js` for full API documentation.

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "enerthya.dev-audio-core",
+  "version": "1.0.0",
+  "description": "Enerthya Audio Core \u2014 Audio processing engine built from scratch. Resolves and streams audio from YouTube, SoundCloud and direct URLs using native HTTP requests and FFmpeg. No play-dl, no ytdl-core.",
+  "main": "src/index.js",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "keywords": [
+    "enerthya",
+    "audio",
+    "youtube",
+    "soundcloud",
+    "ffmpeg"
+  ],
+  "dependencies": {},
+  "scripts": {
+    "test": "node test.js"
+  }
+}

package/src/constants/index.js

@@ -0,0 +1,36 @@
+/**
+ * constants/index.js — Constantes do enerthya.dev-audio-core
+ */
+
+const Source = {
+  YOUTUBE:    "youtube",
+  SOUNDCLOUD: "soundcloud",
+  DIRECT:     "direct",
+};
+
+const LoadType = {
+  TRACK:    "track",
+  PLAYLIST: "playlist",
+  SEARCH:   "search",
+  EMPTY:    "empty",
+  ERROR:    "error",
+};
+
+const StreamType = {
+  OPUS:      "opus",
+  OGG_OPUS:  "ogg/opus",
+  WEBM_OPUS: "webm/opus",
+  MP3:       "mp3",
+  AAC:       "aac",
+  ARBITRARY: "arbitrary",
+};
+
+const Limits = {
+  MAX_SEARCH_RESULTS:   10,
+  MAX_PLAYLIST_TRACKS: 500,
+};
+
+// User-Agent moderno para não ser bloqueado pelas APIs
+const USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36";
+
+module.exports = { Source, LoadType, StreamType, Limits, USER_AGENT };

package/src/decoder/AudioDecoder.js

@@ -0,0 +1,191 @@
+/**
+ * decoder/AudioDecoder.js — Pipeline de decodificação de áudio via FFmpeg
+ *
+ * Equivalente ao AudioTrackDecoder do lavaplayer.
+ * Usa FFmpeg (do sistema ou ffmpeg-static) para:
+ *   - Decodificar qualquer formato de entrada (mp3, aac, opus, webm, m3u8)
+ *   - Transcodificar para PCM s16le (formato aceito pelo @discordjs/voice)
+ *   - Suportar seek por posição (ms)
+ *   - Controlar volume via filtro de áudio do FFmpeg
+ *
+ * O stream PCM resultante é enviado pelo enerthya.dev-audio-server
+ * para o bot via WebSocket, que usa @discordjs/voice para tocar.
+ */
+
+const { spawn }  = require("child_process");
+const { EventEmitter } = require("events");
+const path       = require("path");
+
+// Tenta usar ffmpeg-static se disponível, senão usa o do PATH
+function getFfmpegPath() {
+  try {
+    return require("ffmpeg-static");
+  } catch {
+    return "ffmpeg"; // assume que está no PATH
+  }
+}
+
+const FFMPEG_PATH = getFfmpegPath();
+
+// ── Formatos de saída suportados ──────────────────────────────────────────────
+const OutputFormat = {
+  PCM:   "pcm",   // s16le — para @discordjs/voice
+  OPUS:  "opus",  // opus raw — mais eficiente, mas requer Opus encoder
+  MP3:   "mp3",   // mp3 — compatível com qualquer player
+};
+
+/**
+ * Cria um processo FFmpeg que transcodifica um stream de entrada para PCM.
+ *
+ * @param {object} opts
+ * @param {NodeJS.ReadableStream|string} opts.input  — stream ou URL de entrada
+ * @param {number} [opts.seek]                       — posição inicial em ms
+ * @param {number} [opts.volume]                     — volume 0–1000 (100 = normal)
+ * @param {string} [opts.format]                     — formato de saída (padrão: pcm)
+ * @returns {{ process: ChildProcess, stream: NodeJS.ReadableStream }}
+ */
+function createDecoder(opts = {}) {
+  const {
+    input,
+    seek   = 0,
+    volume = 100,
+    format = OutputFormat.PCM,
+  } = opts;
+
+  const args = [];
+
+  // Seek antes do input (mais rápido — evita decodificar frames desnecessários)
+  if (seek > 0) {
+    args.push("-ss", String(seek / 1000));
+  }
+
+  // Input
+  if (typeof input === "string") {
+    // URL — FFmpeg baixa diretamente
+    args.push(
+      "-reconnect",        "1",
+      "-reconnect_streamed","1",
+      "-reconnect_delay_max","5",
+      "-i", input
+    );
+  } else {
+    // Stream — pipe stdin
+    args.push("-i", "pipe:0");
+  }
+
+  // Filtros de áudio
+  const filters = [];
+  if (volume !== 100) {
+    filters.push(`volume=${volume / 100}`);
+  }
+  if (filters.length) {
+    args.push("-af", filters.join(","));
+  }
+
+  // Output format
+  if (format === OutputFormat.PCM) {
+    args.push(
+      "-ac",  "2",          // 2 canais (stereo)
+      "-ar",  "48000",      // 48kHz (Discord usa 48kHz)
+      "-f",   "s16le",      // PCM signed 16-bit little-endian
+      "-acodec", "pcm_s16le",
+      "pipe:1"              // output para stdout
+    );
+  } else if (format === OutputFormat.OPUS) {
+    args.push(
+      "-ac",  "2",
+      "-ar",  "48000",
+      "-acodec", "libopus",
+      "-b:a", "128k",
+      "-f",   "opus",
+      "pipe:1"
+    );
+  } else if (format === OutputFormat.MP3) {
+    args.push(
+      "-ac",  "2",
+      "-ar",  "48000",
+      "-acodec", "libmp3lame",
+      "-b:a", "192k",
+      "-f",   "mp3",
+      "pipe:1"
+    );
+  }
+
+  // Suprime logs desnecessários do FFmpeg
+  args.unshift("-loglevel", "error");
+
+  const proc = spawn(FFMPEG_PATH, args, {
+    stdio: typeof input === "string" ? ["ignore", "pipe", "pipe"] : ["pipe", "pipe", "pipe"],
+  });
+
+  // Pipe stream de entrada se necessário
+  if (typeof input !== "string" && input?.pipe) {
+    input.pipe(proc.stdin);
+    proc.stdin.on("error", () => {}); // evita crash se FFmpeg fechar antes
+  }
+
+  // Erros do FFmpeg vão para stderr — logar mas não crashar
+  proc.stderr.on("data", (data) => {
+    const msg = data.toString();
+    if (msg.includes("Error") || msg.includes("error")) {
+      proc.emit("ffmpeg-error", msg.trim());
+    }
+  });
+
+  return { process: proc, stream: proc.stdout };
+}
+
+/**
+ * AudioDecoder — gerencia o ciclo de vida de um processo FFmpeg por player.
+ * Emite eventos: "data", "end", "error", "start"
+ */
+class AudioDecoder extends EventEmitter {
+  constructor() {
+    super();
+    this._proc   = null;
+    this._active = false;
+  }
+
+  /**
+   * Inicia a decodificação de uma track.
+   * @param {NodeJS.ReadableStream|string} input
+   * @param {object} [opts]
+   */
+  start(input, opts = {}) {
+    this.stop(); // para qualquer decoder anterior
+
+    const { process: proc, stream } = createDecoder({ input, ...opts });
+    this._proc   = proc;
+    this._active = true;
+
+    stream.on("data",  (chunk) => this.emit("data", chunk));
+    stream.on("end",   ()      => { this._active = false; this.emit("end"); });
+    stream.on("error", (err)   => { this._active = false; this.emit("error", err); });
+
+    proc.on("ffmpeg-error", (msg) => this.emit("error", new Error(msg)));
+    proc.on("close", (code) => {
+      this._active = false;
+      if (code !== 0 && code !== null) {
+        this.emit("error", new Error(`FFmpeg saiu com código ${code}`));
+      }
+    });
+
+    this.emit("start");
+    return this;
+  }
+
+  /** Para o decoder e mata o processo FFmpeg. */
+  stop() {
+    if (this._proc) {
+      this._proc.stdout?.destroy();
+      this._proc.kill("SIGKILL");
+      this._proc   = null;
+      this._active = false;
+    }
+    return this;
+  }
+
+  get active() { return this._active; }
+}
+
+module.exports = { AudioDecoder, createDecoder, OutputFormat, FFMPEG_PATH };

package/src/index.js

@@ -0,0 +1,157 @@
+/**
+ * enerthya.dev-audio-core
+ *
+ * Motor de processamento de áudio da Enerthya.
+ * Equivalente ao lavaplayer (Java) — implementado do zero em Node.js.
+ *
+ * Funcionalidades:
+ *   - Resolução de tracks: YouTube (Innertube API), SoundCloud (API v2), URLs diretas
+ *   - Extração de streams de áudio sem ytdl-core ou play-dl
+ *   - Pipeline FFmpeg para decodificação e transcodificação
+ *   - Formato de track compatível com Lavalink v4
+ *   - Zero dependências externas de áudio (apenas FFmpeg do sistema)
+ *
+ * @example
+ *   const { loadItem, getAudioStream, AudioDecoder } = require("enerthya.dev-audio-core");
+ *
+ *   // Resolver uma track
+ *   const result = await loadItem("ytsearch:lofi hip hop");
+ *   console.log(result.tracks[0].info.title);
+ *
+ *   // Obter stream de áudio
+ *   const stream = await getAudioStream(result.tracks[0].info.uri);
+ *
+ *   // Decodificar com FFmpeg
+ *   const decoder = new AudioDecoder();
+ *   decoder.start(stream, { volume: 100 });
+ *   decoder.on("data", (chunk) => { // PCM s16le });
+ */
+
+const YouTube    = require("./sources/youtube");
+const SoundCloud = require("./sources/soundcloud");
+const { AudioDecoder, createDecoder, OutputFormat } = require("./decoder/AudioDecoder");
+const { normalizeQuery, buildTrack, decodeTrack, formatDuration } = require("./utils");
+const { Source, LoadType, StreamType, Limits } = require("./constants");
+
+// ── loadItem — ponto de entrada principal ─────────────────────────────────────
+
+/**
+ * Resolve uma query para tracks.
+ * Equivalente ao AudioPlayerManager.loadItem() do lavaplayer.
+ *
+ * @param {string} query
+ * @param {object} [opts]
+ * @param {number} [opts.limit]         — máx resultados para busca (padrão: 1)
+ * @param {string} [opts.requesterId]
+ * @param {string} [opts.requesterTag]
+ * @returns {Promise<{ loadType: string, tracks: object[], playlist: object|null, error: string|null }>}
+ */
+async function loadItem(query, opts = {}) {
+  const limit  = opts.limit || 1;
+  const extra  = { requesterId: opts.requesterId, requesterTag: opts.requesterTag };
+  const { isUrl, source, query: q } = normalizeQuery(query);
+
+  try {
+    // ── YouTube ───────────────────────────────────────────────────────────────
+    if (source === "youtube") {
+      if (isUrl) {
+        // Playlist
+        if (q.includes("list=")) {
+          const pl = await YouTube.loadPlaylist(q, extra);
+          return { loadType: LoadType.PLAYLIST, tracks: pl.tracks, playlist: { name: pl.name, uri: q }, error: null };
+        }
+        // Vídeo único
+        const track = await YouTube.loadVideo(q, extra);
+        return { loadType: LoadType.TRACK, tracks: [track], playlist: null, error: null };
+      }
+      // Busca de texto
+      const tracks = await YouTube.search(q, limit, extra);
+      if (!tracks.length) return { loadType: LoadType.EMPTY, tracks: [], playlist: null, error: null };
+      return { loadType: LoadType.SEARCH, tracks, playlist: null, error: null };
+    }
+
+    // ── SoundCloud ────────────────────────────────────────────────────────────
+    if (source === "soundcloud") {
+      if (isUrl) {
+        // Verifica se é playlist
+        try {
+          const pl = await SoundCloud.loadPlaylist(q, extra);
+          return { loadType: LoadType.PLAYLIST, tracks: pl.tracks, playlist: { name: pl.name, uri: q }, error: null };
+        } catch {
+          // Não é playlist — tenta como track
+        }
+        const track = await SoundCloud.loadTrack(q, extra);
+        return { loadType: LoadType.TRACK, tracks: [track], playlist: null, error: null };
+      }
+      const tracks = await SoundCloud.search(q, limit, extra);
+      if (!tracks.length) return { loadType: LoadType.EMPTY, tracks: [], playlist: null, error: null };
+      return { loadType: LoadType.SEARCH, tracks, playlist: null, error: null };
+    }
+
+    // ── URL direta ────────────────────────────────────────────────────────────
+    if (source === "direct") {
+      const track = buildTrack({
+        identifier: q,
+        title:      q.split("/").pop()?.split("?")[0] || "Stream",
+        author:     "Desconhecido",
+        uri:        q,
+        length:     0,
+        isStream:   true,
+        sourceName: "direct",
+        ...extra,
+      });
+      return { loadType: LoadType.TRACK, tracks: [track], playlist: null, error: null };
+    }
+
+    return { loadType: LoadType.EMPTY, tracks: [], playlist: null, error: null };
+
+  } catch (err) {
+    return { loadType: LoadType.ERROR, tracks: [], playlist: null, error: err.message };
+  }
+}
+
+// ── getAudioStream — retorna stream de áudio de uma track ─────────────────────
+
+/**
+ * Retorna o stream de áudio de uma track para uso com o AudioDecoder.
+ *
+ * @param {object} track — objeto track (com track.info.uri e track.info.sourceName)
+ * @returns {Promise<NodeJS.ReadableStream>}
+ */
+async function getAudioStream(track) {
+  const { uri, sourceName } = track.info || track;
+
+  if (sourceName === "youtube") return YouTube.getAudioStream(uri);
+  if (sourceName === "soundcloud") return SoundCloud.getAudioStream(uri);
+
+  // URL direta
+  const { getStream } = require("./utils/http");
+  return getStream(uri);
+}
+
+module.exports = {
+  // Principal
+  loadItem,
+  getAudioStream,
+
+  // Decoder
+  AudioDecoder,
+  createDecoder,
+  OutputFormat,
+
+  // Sources individuais
+  YouTube,
+  SoundCloud,
+
+  // Utilitários
+  buildTrack,
+  decodeTrack,
+  formatDuration,
+  normalizeQuery,
+
+  // Constantes
+  Source,
+  LoadType,
+  StreamType,
+  Limits,
+};

package/src/sources/soundcloud/index.js

@@ -0,0 +1,145 @@
+/**
+ * sources/soundcloud/index.js — SoundCloud source nativo
+ *
+ * Extrai metadados e streams do SoundCloud sem bibliotecas externas.
+ *
+ * Mecanismo:
+ *   1. Extrai client_id da página principal do SoundCloud (renovado automaticamente)
+ *   2. Usa a API pública /resolve para metadados
+ *   3. Usa /tracks/:id/streams para URL de stream
+ *   4. Suporta HLS (m3u8) e stream progressivo
+ */
+
+const { request, getJson, getStream } = require("../../utils/http");
+const { buildTrack } = require("../../utils");
+const { Source }     = require("../../constants");
+
+// ── Client ID (cache em memória — renovado quando expirar) ────────────────────
+
+let _clientId    = null;
+let _clientIdExp = 0;
+
+const CLIENT_ID_TTL = 60 * 60 * 1000; // 1 hora
+
+async function getClientId() {
+  if (_clientId && Date.now() < _clientIdExp) return _clientId;
+
+  // Busca a página principal e extrai scripts
+  const page = await request("https://soundcloud.com/", {
+    headers: { "Accept": "text/html" },
+  });
+
+  // Extrai URLs dos scripts JS
+  const scriptUrls = [];
+  const scriptRegex = /<script[^>]+src="(https:\/\/a-v2\.sndcdn\.com\/assets\/[^"]+\.js)"/g;
+  let match;
+  while ((match = scriptRegex.exec(page.body)) !== null) {
+    scriptUrls.push(match[1]);
+  }
+
+  // Busca client_id nos scripts (começa pelos últimos, que são mais prováveis)
+  for (const url of scriptUrls.slice(-5).reverse()) {
+    try {
+      const { body } = await request(url);
+      const m = body.match(/client_id\s*:\s*"([a-zA-Z0-9]{32})"/);
+      if (m) {
+        _clientId    = m[1];
+        _clientIdExp = Date.now() + CLIENT_ID_TTL;
+        return _clientId;
+      }
+    } catch { /* tenta o próximo */ }
+  }
+
+  throw new Error("SoundCloud: não foi possível extrair client_id");
+}
+
+// ── API helpers ───────────────────────────────────────────────────────────────
+
+async function scApi(path, params = {}) {
+  const clientId = await getClientId();
+  const qs = new URLSearchParams({ ...params, client_id: clientId }).toString();
+  return getJson(`https://api-v2.soundcloud.com${path}?${qs}`);
+}
+
+async function resolveUrl(url) {
+  return scApi("/resolve", { url });
+}
+
+// ── Formatadores ──────────────────────────────────────────────────────────────
+
+function trackFromData(t, extra = {}) {
+  return buildTrack({
+    identifier:  String(t.id),
+    title:       t.title || "Desconhecido",
+    author:      t.user?.username || "Desconhecido",
+    uri:         t.permalink_url || "",
+    length:      t.duration || 0,
+    isStream:    false,
+    artworkUrl:  t.artwork_url?.replace("-large", "-t500x500") || null,
+    sourceName:  Source.SOUNDCLOUD,
+    // Armazena internamente para o decoder
+    _scTrackId:  t.id,
+    ...extra,
+  });
+}
+
+// ── API pública ───────────────────────────────────────────────────────────────
+
+/**
+ * Carrega uma track do SoundCloud por URL.
+ */
+async function loadTrack(url, extra = {}) {
+  const data = await resolveUrl(url);
+  if (data.kind !== "track") throw new Error("URL não é uma track SoundCloud");
+  return trackFromData(data, extra);
+}
+
+/**
+ * Carrega uma playlist/set do SoundCloud.
+ */
+async function loadPlaylist(url, extra = {}) {
+  const data = await resolveUrl(url);
+  if (data.kind !== "playlist") throw new Error("URL não é uma playlist SoundCloud");
+
+  const tracks = (data.tracks || []).map((t) => trackFromData(t, extra));
+  return { name: data.title, uri: url, tracks };
+}
+
+/**
+ * Busca tracks no SoundCloud por texto.
+ */
+async function search(query, limit = 5, extra = {}) {
+  const data = await scApi("/search/tracks", { q: query, limit });
+  return (data.collection || []).slice(0, limit).map((t) => trackFromData(t, extra));
+}
+
+/**
+ * Retorna o stream de áudio de uma track SoundCloud.
+ * @param {string} uri — URL da track SoundCloud
+ * @returns {Promise<NodeJS.ReadableStream>}
+ */
+async function getAudioStream(uri) {
+  const clientId = await getClientId();
+  const data     = await resolveUrl(uri);
+
+  if (data.kind !== "track") throw new Error("URI não é uma track SoundCloud");
+
+  // Busca as streams disponíveis
+  const streamsUrl = `https://api-v2.soundcloud.com/tracks/${data.id}/streams?client_id=${clientId}`;
+  const streams    = await getJson(streamsUrl);
+
+  // Prioridade: opus_0_0 > hls > http_mp3
+  const streamUrl =
+    streams["preview/opus-64000"] ||
+    streams["hls/opus-64000"]     ||
+    streams["hls/mp3-128000"]     ||
+    streams["progressive/mp3-128000"];
+
+  if (!streamUrl) throw new Error("SoundCloud: nenhum stream disponível");
+
+  // Se for HLS (m3u8), retorna a URL do manifesto
+  // O decoder vai lidar com HLS via FFmpeg
+  return getStream(streamUrl);
+}
+
+module.exports = { loadTrack, loadPlaylist, search, getAudioStream, getClientId };

package/src/sources/youtube/index.js

@@ -0,0 +1,282 @@
+/**
+ * sources/youtube/index.js — YouTube source nativo
+ *
+ * Extrai metadados e URLs de stream do YouTube usando
+ * requisições HTTP diretas à API interna, sem ytdl-core ou play-dl.
+ *
+ * Mecanismo:
+ *   1. Busca via YouTube Data API v1 (innertube) — sem API key
+ *   2. Extrai playerResponse via ytInitialPlayerResponse
+ *   3. Decifra nsig (assinatura de URL) quando necessário
+ *   4. Retorna URL de stream opus/webm para uso com FFmpeg
+ */
+
+const { getJson, getStream } = require("../../utils/http");
+const { buildTrack }         = require("../../utils");
+const { Source }             = require("../../constants");
+
+// ── Innertube API ─────────────────────────────────────────────────────────────
+
+const INNERTUBE_KEY    = "AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8";
+const INNERTUBE_CLIENT = {
+  clientName:    "WEB",
+  clientVersion: "2.20240101.00.00",
+  hl:            "pt",
+  gl:            "BR",
+};
+
+const INNERTUBE_HEADERS = {
+  "Content-Type":  "application/json",
+  "X-YouTube-Client-Name":    "1",
+  "X-YouTube-Client-Version": "2.20240101.00.00",
+  "Origin":        "https://www.youtube.com",
+  "Referer":       "https://www.youtube.com/",
+};
+
+/**
+ * Faz uma requisição POST à API Innertube do YouTube.
+ */
+async function innertubeRequest(endpoint, body) {
+  const url = `https://www.youtube.com/youtubei/v1/${endpoint}?key=${INNERTUBE_KEY}`;
+  const { request } = require("../../utils/http");
+  const res = await request(url, {
+    method: "POST",
+    headers: INNERTUBE_HEADERS,
+    body: JSON.stringify({ context: { client: INNERTUBE_CLIENT }, ...body }),
+  });
+  try {
+    return JSON.parse(res.body);
+  } catch {
+    throw new Error("YouTube Innertube: resposta inválida");
+  }
+}
+
+// ── Extração de formato de áudio ──────────────────────────────────────────────
+
+/**
+ * Extrai a melhor URL de stream de áudio dos formatos do playerResponse.
+ * Prioriza: opus/webm → ogg_opus → mp4a → qualquer áudio
+ *
+ * @param {object[]} formats — streamingData.adaptiveFormats
+ * @returns {string|null} URL do stream
+ */
+function extractAudioUrl(formats) {
+  const audio = formats.filter((f) => f.mimeType?.startsWith("audio/"));
+  if (!audio.length) return null;
+
+  // Prioridade: webm/opus > ogg > mp4
+  const priority = [
+    (f) => f.mimeType?.includes("webm") && f.mimeType?.includes("opus"),
+    (f) => f.mimeType?.includes("ogg"),
+    (f) => f.mimeType?.includes("mp4"),
+    () => true,
+  ];
+
+  for (const check of priority) {
+    const match = audio.find(check);
+    if (match) {
+      // URL direta (não cifrada)
+      if (match.url) return match.url;
+      // URL cifrada — precisa decifrar signatureCipher
+      if (match.signatureCipher) {
+        return decipherUrl(match.signatureCipher);
+      }
+    }
+  }
+  return null;
+}
+
+/**
+ * Decifra uma signatureCipher do YouTube.
+ * Extrai url, s (assinatura) e sp (parâmetro de assinatura).
+ * NOTA: a decifragem completa do nsig requer o JS player —
+ * aqui usamos a abordagem mais simples que funciona para a maioria dos casos.
+ */
+function decipherUrl(signatureCipher) {
+  try {
+    const params = new URLSearchParams(signatureCipher);
+    const url = params.get("url");
+    const sig = params.get("s");
+    const sp  = params.get("sp") || "sig";
+    if (!url) return null;
+    return sig ? `${url}&${sp}=${encodeURIComponent(sig)}` : url;
+  } catch {
+    return null;
+  }
+}
+
+// ── Extração de playerResponse ────────────────────────────────────────────────
+
+/**
+ * Busca o playerResponse de um vídeo via Innertube.
+ * @param {string} videoId
+ */
+async function getPlayerResponse(videoId) {
+  const data = await innertubeRequest("player", {
+    videoId,
+    playbackContext: {
+      contentPlaybackContext: { signatureTimestamp: 19950 },
+    },
+  });
+
+  if (data.playabilityStatus?.status !== "OK") {
+    throw new Error(`Vídeo indisponível: ${data.playabilityStatus?.reason || "desconhecido"}`);
+  }
+
+  return data;
+}
+
+// ── Extração de videoId ───────────────────────────────────────────────────────
+
+function extractVideoId(url) {
+  const patterns = [
+    /(?:v=|youtu\.be\/)([a-zA-Z0-9_-]{11})/,
+    /(?:embed|shorts)\/([a-zA-Z0-9_-]{11})/,
+  ];
+  for (const p of patterns) {
+    const m = url.match(p);
+    if (m) return m[1];
+  }
+  return null;
+}
+
+function extractPlaylistId(url) {
+  const m = url.match(/[?&]list=([a-zA-Z0-9_-]+)/);
+  return m ? m[1] : null;
+}
+
+// ── API pública do source ─────────────────────────────────────────────────────
+
+/**
+ * Carrega um vídeo único do YouTube.
+ */
+async function loadVideo(url, extra = {}) {
+  const videoId = extractVideoId(url);
+  if (!videoId) throw new Error(`ID de vídeo inválido: ${url}`);
+
+  const data    = await getPlayerResponse(videoId);
+  const details = data.videoDetails;
+  const formats = data.streamingData?.adaptiveFormats || data.streamingData?.formats || [];
+  const audioUrl = extractAudioUrl(formats);
+
+  if (!audioUrl) throw new Error("Nenhum formato de áudio disponível");
+
+  return buildTrack({
+    identifier:  videoId,
+    title:       details.title,
+    author:      details.author,
+    uri:         `https://www.youtube.com/watch?v=${videoId}`,
+    length:      parseInt(details.lengthSeconds || 0) * 1000,
+    isStream:    details.isLiveContent || false,
+    artworkUrl:  details.thumbnail?.thumbnails?.slice(-1)[0]?.url || null,
+    sourceName:  Source.YOUTUBE,
+    // _streamUrl armazenado internamente para uso pelo decoder
+    _streamUrl:  audioUrl,
+    ...extra,
+  });
+}
+
+/**
+ * Carrega uma playlist do YouTube.
+ */
+async function loadPlaylist(url, extra = {}) {
+  const playlistId = extractPlaylistId(url);
+  if (!playlistId) throw new Error(`ID de playlist inválido: ${url}`);
+
+  const data = await innertubeRequest("browse", {
+    browseId: `VL${playlistId}`,
+  });
+
+  const header = data.header?.playlistHeaderRenderer;
+  const name   = header?.title?.simpleText || "Playlist";
+
+  // Extrai vídeos da playlist
+  const items = data.contents?.twoColumnBrowseResultsRenderer
+    ?.tabs?.[0]?.tabRenderer?.content?.sectionListRenderer
+    ?.contents?.[0]?.itemSectionRenderer?.contents?.[0]
+    ?.playlistVideoListRenderer?.contents || [];
+
+  const tracks = items
+    .filter((i) => i.playlistVideoRenderer)
+    .map((i) => {
+      const v = i.playlistVideoRenderer;
+      const id = v.videoId;
+      return buildTrack({
+        identifier: id,
+        title:      v.title?.runs?.[0]?.text || "Desconhecido",
+        author:     v.shortBylineText?.runs?.[0]?.text || "Desconhecido",
+        uri:        `https://www.youtube.com/watch?v=${id}`,
+        length:     parseInt(v.lengthSeconds || 0) * 1000,
+        artworkUrl: v.thumbnail?.thumbnails?.slice(-1)[0]?.url || null,
+        sourceName: Source.YOUTUBE,
+        ...extra,
+      });
+    });
+
+  return { name, uri: url, tracks };
+}
+
+/**
+ * Busca vídeos no YouTube por texto.
+ */
+async function search(query, limit = 5, extra = {}) {
+  const data = await innertubeRequest("search", {
+    query,
+    params: "EgIQAQ==", // filtro: apenas vídeos
+  });
+
+  const contents = data.contents?.twoColumnSearchResultsRenderer
+    ?.primaryContents?.sectionListRenderer?.contents?.[0]
+    ?.itemSectionRenderer?.contents || [];
+
+  const tracks = [];
+  for (const item of contents) {
+    if (tracks.length >= limit) break;
+    const v = item.videoRenderer;
+    if (!v?.videoId) continue;
+
+    const durationText = v.lengthText?.simpleText || "0:00";
+    const parts = durationText.split(":").map(Number).reverse();
+    const durationMs = (
+      (parts[0] || 0) +
+      (parts[1] || 0) * 60 +
+      (parts[2] || 0) * 3600
+    ) * 1000;
+
+    tracks.push(buildTrack({
+      identifier: v.videoId,
+      title:      v.title?.runs?.[0]?.text || "Desconhecido",
+      author:     v.ownerText?.runs?.[0]?.text || "Desconhecido",
+      uri:        `https://www.youtube.com/watch?v=${v.videoId}`,
+      length:     durationMs,
+      artworkUrl: v.thumbnail?.thumbnails?.slice(-1)[0]?.url || null,
+      sourceName: Source.YOUTUBE,
+      ...extra,
+    }));
+  }
+
+  return tracks;
+}
+
+/**
+ * Retorna o stream de áudio de um vídeo para uso com FFmpeg.
+ * @param {string} uri — URL do vídeo YouTube
+ * @returns {Promise<NodeJS.ReadableStream>}
+ */
+async function getAudioStream(uri) {
+  const videoId = extractVideoId(uri);
+  if (!videoId) throw new Error(`ID inválido: ${uri}`);
+
+  const data    = await getPlayerResponse(videoId);
+  const formats = data.streamingData?.adaptiveFormats || data.streamingData?.formats || [];
+  const audioUrl = extractAudioUrl(formats);
+
+  if (!audioUrl) throw new Error("Nenhum formato de áudio disponível");
+
+  return getStream(audioUrl, {
+    "Referer": "https://www.youtube.com/",
+    "Origin":  "https://www.youtube.com",
+  });
+}
+
+module.exports = { loadVideo, loadPlaylist, search, getAudioStream, extractVideoId };

package/src/utils/http.js

@@ -0,0 +1,141 @@
+/**
+ * utils/http.js — HTTP client nativo do Node.js
+ *
+ * Faz requisições HTTP/HTTPS sem nenhuma dependência externa.
+ * Suporta redirects automáticos, timeout e headers customizados.
+ */
+
+const https = require("https");
+const http  = require("http");
+const { USER_AGENT } = require("../constants");
+
+const DEFAULT_TIMEOUT = 10_000; // 10s
+
+/**
+ * Faz uma requisição HTTP/HTTPS e retorna o body como string.
+ *
+ * @param {string} url
+ * @param {object} [opts]
+ * @param {object} [opts.headers]
+ * @param {number} [opts.timeout]
+ * @param {number} [opts.maxRedirects]
+ * @returns {Promise<{ body: string, status: number, headers: object }>}
+ */
+function request(url, opts = {}) {
+  return new Promise((resolve, reject) => {
+    const {
+      headers      = {},
+      timeout      = DEFAULT_TIMEOUT,
+      maxRedirects = 5,
+      method       = "GET",
+      body         = null,
+    } = opts;
+
+    let redirectCount = 0;
+
+    function doRequest(currentUrl) {
+      const parsed   = new URL(currentUrl);
+      const lib      = parsed.protocol === "https:" ? https : http;
+      const reqHeaders = {
+        "User-Agent":      USER_AGENT,
+        "Accept":          "*/*",
+        "Accept-Language": "pt-BR,pt;q=0.9,en;q=0.8",
+        ...headers,
+      };
+
+      if (body) {
+        reqHeaders["Content-Type"]   = "application/json";
+        reqHeaders["Content-Length"] = Buffer.byteLength(body);
+      }
+
+      const req = lib.request(
+        {
+          hostname: parsed.hostname,
+          port:     parsed.port || (parsed.protocol === "https:" ? 443 : 80),
+          path:     parsed.pathname + parsed.search,
+          method,
+          headers:  reqHeaders,
+        },
+        (res) => {
+          // Redirect
+          if ([301, 302, 303, 307, 308].includes(res.statusCode) && res.headers.location) {
+            if (redirectCount >= maxRedirects) {
+              return reject(new Error(`Muitos redirects: ${currentUrl}`));
+            }
+            redirectCount++;
+            const nextUrl = res.headers.location.startsWith("http")
+              ? res.headers.location
+              : `${parsed.protocol}//${parsed.host}${res.headers.location}`;
+            return doRequest(nextUrl);
+          }
+
+          const chunks = [];
+          res.on("data", (chunk) => chunks.push(chunk));
+          res.on("end", () => {
+            resolve({
+              body:    Buffer.concat(chunks).toString("utf8"),
+              status:  res.statusCode,
+              headers: res.headers,
+            });
+          });
+          res.on("error", reject);
+        }
+      );
+
+      req.setTimeout(timeout, () => {
+        req.destroy(new Error(`Timeout após ${timeout}ms: ${currentUrl}`));
+      });
+
+      req.on("error", reject);
+      if (body) req.write(body);
+      req.end();
+    }
+
+    doRequest(url);
+  });
+}
+
+/**
+ * GET e retorna JSON parseado.
+ */
+async function getJson(url, opts = {}) {
+  const res = await request(url, opts);
+  try {
+    return JSON.parse(res.body);
+  } catch {
+    throw new Error(`Resposta não é JSON válido: ${url}`);
+  }
+}
+
+/**
+ * Retorna o stream de uma URL para pipe com FFmpeg.
+ * @param {string} url
+ * @param {object} [headers]
+ * @returns {Promise<import("stream").Readable>}
+ */
+function getStream(url, headers = {}) {
+  return new Promise((resolve, reject) => {
+    const parsed = new URL(url);
+    const lib    = parsed.protocol === "https:" ? https : http;
+
+    lib.get(
+      {
+        hostname: parsed.hostname,
+        port:     parsed.port || (parsed.protocol === "https:" ? 443 : 80),
+        path:     parsed.pathname + parsed.search,
+        headers:  { "User-Agent": USER_AGENT, ...headers },
+      },
+      (res) => {
+        if ([301, 302, 307, 308].includes(res.statusCode) && res.headers.location) {
+          return getStream(res.headers.location, headers).then(resolve).catch(reject);
+        }
+        if (res.statusCode < 200 || res.statusCode >= 300) {
+          return reject(new Error(`HTTP ${res.statusCode}: ${url}`));
+        }
+        resolve(res);
+      }
+    ).on("error", reject);
+  });
+}
+
+module.exports = { request, getJson, getStream };

package/src/utils/index.js

@@ -0,0 +1,71 @@
+/**
+ * utils/index.js — Utilitários gerais do enerthya.dev-audio-core
+ */
+
+const { getJson, getStream } = require("./http");
+
+/**
+ * Detecta source e tipo da query.
+ */
+function normalizeQuery(query) {
+  const q = String(query || "").trim();
+
+  if (q.startsWith("ytsearch:"))  return { isUrl: false, source: "youtube",    query: q.slice(9).trim() };
+  if (q.startsWith("scsearch:"))  return { isUrl: false, source: "soundcloud", query: q.slice(9).trim() };
+
+  if (/^https?:\/\//i.test(q)) {
+    if (/youtu\.?be|youtube\.com/i.test(q))  return { isUrl: true, source: "youtube",    query: q };
+    if (/soundcloud\.com/i.test(q))          return { isUrl: true, source: "soundcloud", query: q };
+    return { isUrl: true, source: "direct", query: q };
+  }
+
+  return { isUrl: false, source: "youtube", query: q };
+}
+
+/**
+ * Constrói objeto Track padronizado — mesmo formato do Lavalink v4.
+ */
+function buildTrack(data) {
+  const info = {
+    identifier:   data.identifier   || data.uri || "",
+    isSeekable:   data.isSeekable   !== false,
+    author:       data.author       || "Desconhecido",
+    length:       data.length       || data.duration || 0,
+    isStream:     data.isStream     || false,
+    position:     0,
+    title:        data.title        || "Desconhecido",
+    uri:          data.uri          || "",
+    artworkUrl:   data.artworkUrl   || null,
+    sourceName:   data.sourceName   || data.source || "unknown",
+    requesterId:  data.requesterId  || null,
+    requesterTag: data.requesterTag || null,
+  };
+  const encoded = Buffer.from(JSON.stringify(info)).toString("base64");
+  return { encoded, info };
+}
+
+/**
+ * Decodifica track encoded (base64 → JSON).
+ */
+function decodeTrack(encoded) {
+  try {
+    return JSON.parse(Buffer.from(encoded, "base64").toString("utf8"));
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Formata duração em ms para string legível.
+ */
+function formatDuration(ms) {
+  if (!ms || ms <= 0) return "0:00";
+  const s   = Math.floor(ms / 1000);
+  const h   = Math.floor(s / 3600);
+  const m   = Math.floor((s % 3600) / 60);
+  const sec = s % 60;
+  if (h > 0) return `${h}:${String(m).padStart(2,"0")}:${String(sec).padStart(2,"0")}`;
+  return `${m}:${String(sec).padStart(2,"0")}`;
+}
+
+module.exports = { normalizeQuery, buildTrack, decodeTrack, formatDuration, getJson, getStream };

package/test.js

@@ -0,0 +1,283 @@
+/**
+ * enerthya.dev-audio-core — test suite
+ * Run: node test.js
+ * Uses Node built-in assert only.
+ * Network tests are skipped by default (set AUDIO_CORE_NETWORK_TESTS=1 to enable).
+ */
+
+const assert  = require("assert");
+const { EventEmitter } = require("events");
+
+const {
+  normalizeQuery,
+  buildTrack,
+  decodeTrack,
+  formatDuration,
+  Source,
+  LoadType,
+  StreamType,
+  Limits,
+  AudioDecoder,
+  OutputFormat,
+} = require("./src/index");
+
+let passed = 0;
+let failed = 0;
+
+function test(name, fn) {
+  try {
+    const result = fn();
+    if (result && typeof result.then === "function") {
+      // async — não bloqueia, reporta depois
+      result
+        .then(() => { console.log(`  ✅ ${name}`); passed++; })
+        .catch((err) => { console.error(`  ❌ ${name}\n     ${err.message}`); failed++; });
+      return;
+    }
+    console.log(`  ✅ ${name}`);
+    passed++;
+  } catch (err) {
+    console.error(`  ❌ ${name}\n     ${err.message}`);
+    failed++;
+  }
+}
+
+function skip(name) {
+  console.log(`  ⏭  ${name} (skipped)`);
+}
+
+const NETWORK = process.env.AUDIO_CORE_NETWORK_TESTS === "1";
+
+// ── normalizeQuery ────────────────────────────────────────────────────────────
+
+console.log("\n── normalizeQuery ────────────────────────────────────────────────────────────");
+
+test("texto simples → youtube search", () => {
+  const r = normalizeQuery("lofi hip hop");
+  assert.strictEqual(r.isUrl,  false);
+  assert.strictEqual(r.source, "youtube");
+  assert.strictEqual(r.query,  "lofi hip hop");
+});
+
+test("prefixo ytsearch:", () => {
+  const r = normalizeQuery("ytsearch:lofi");
+  assert.strictEqual(r.isUrl,  false);
+  assert.strictEqual(r.source, "youtube");
+  assert.strictEqual(r.query,  "lofi");
+});
+
+test("prefixo scsearch:", () => {
+  const r = normalizeQuery("scsearch:jazz");
+  assert.strictEqual(r.isUrl,  false);
+  assert.strictEqual(r.source, "soundcloud");
+  assert.strictEqual(r.query,  "jazz");
+});
+
+test("URL YouTube vídeo", () => {
+  const r = normalizeQuery("https://www.youtube.com/watch?v=dQw4w9WgXcQ");
+  assert.strictEqual(r.isUrl,  true);
+  assert.strictEqual(r.source, "youtube");
+});
+
+test("URL YouTube curta (youtu.be)", () => {
+  const r = normalizeQuery("https://youtu.be/dQw4w9WgXcQ");
+  assert.strictEqual(r.isUrl,  true);
+  assert.strictEqual(r.source, "youtube");
+});
+
+test("URL SoundCloud", () => {
+  const r = normalizeQuery("https://soundcloud.com/artist/track");
+  assert.strictEqual(r.isUrl,  true);
+  assert.strictEqual(r.source, "soundcloud");
+});
+
+test("URL direta (.mp3)", () => {
+  const r = normalizeQuery("https://example.com/audio.mp3");
+  assert.strictEqual(r.isUrl,  true);
+  assert.strictEqual(r.source, "direct");
+});
+
+test("query vazia → youtube", () => {
+  const r = normalizeQuery("");
+  assert.strictEqual(r.source, "youtube");
+});
+
+test("query null → youtube", () => {
+  const r = normalizeQuery(null);
+  assert.strictEqual(r.source, "youtube");
+});
+
+// ── buildTrack / decodeTrack ──────────────────────────────────────────────────
+
+console.log("\n── buildTrack / decodeTrack ─────────────────────────────────────────────────");
+
+test("buildTrack retorna encoded + info", () => {
+  const t = buildTrack({
+    title: "Test Track", author: "Test Author",
+    uri: "https://youtube.com/watch?v=abc", length: 180000,
+    sourceName: "youtube",
+  });
+  assert.ok(t.encoded, "deve ter encoded");
+  assert.ok(t.info,    "deve ter info");
+  assert.strictEqual(t.info.title,  "Test Track");
+  assert.strictEqual(t.info.author, "Test Author");
+  assert.strictEqual(t.info.length, 180000);
+});
+
+test("buildTrack preenche defaults para campos ausentes", () => {
+  const t = buildTrack({});
+  assert.strictEqual(t.info.title,      "Desconhecido");
+  assert.strictEqual(t.info.author,     "Desconhecido");
+  assert.strictEqual(t.info.length,     0);
+  assert.strictEqual(t.info.sourceName, "unknown");
+});
+
+test("encoded é base64 válido", () => {
+  const t = buildTrack({ title: "X", uri: "https://x.com", length: 1000 });
+  const decoded = Buffer.from(t.encoded, "base64").toString("utf8");
+  assert.doesNotThrow(() => JSON.parse(decoded));
+});
+
+test("decodeTrack recupera info corretamente", () => {
+  const t    = buildTrack({ title: "ABC", uri: "https://abc.com", length: 5000, sourceName: "youtube" });
+  const info = decodeTrack(t.encoded);
+  assert.strictEqual(info.title,      "ABC");
+  assert.strictEqual(info.length,     5000);
+  assert.strictEqual(info.sourceName, "youtube");
+});
+
+test("decodeTrack retorna null para encoded inválido", () => {
+  assert.strictEqual(decodeTrack("not-base64!!!"), null);
+});
+
+test("requesterId e requesterTag são preservados", () => {
+  const t = buildTrack({ requesterId: "123", requesterTag: "User#0001" });
+  assert.strictEqual(t.info.requesterId,  "123");
+  assert.strictEqual(t.info.requesterTag, "User#0001");
+});
+
+// ── formatDuration ────────────────────────────────────────────────────────────
+
+console.log("\n── formatDuration ────────────────────────────────────────────────────────────");
+
+test("0ms → 0:00", () => {
+  assert.strictEqual(formatDuration(0), "0:00");
+});
+
+test("null/undefined → 0:00", () => {
+  assert.strictEqual(formatDuration(null),      "0:00");
+  assert.strictEqual(formatDuration(undefined), "0:00");
+});
+
+test("60s → 1:00", () => {
+  assert.strictEqual(formatDuration(60_000), "1:00");
+});
+
+test("90s → 1:30", () => {
+  assert.strictEqual(formatDuration(90_000), "1:30");
+});
+
+test("3m45s → 3:45", () => {
+  assert.strictEqual(formatDuration(225_000), "3:45");
+});
+
+test("1h2m30s → 1:02:30", () => {
+  assert.strictEqual(formatDuration(3_750_000), "1:02:30");
+});
+
+test("segundos com padding → 3:05", () => {
+  assert.strictEqual(formatDuration(185_000), "3:05");
+});
+
+// ── Constantes ────────────────────────────────────────────────────────────────
+
+console.log("\n── Constantes ────────────────────────────────────────────────────────────────");
+
+test("Source contém youtube, soundcloud, direct", () => {
+  assert.ok(Source.YOUTUBE);
+  assert.ok(Source.SOUNDCLOUD);
+  assert.ok(Source.DIRECT);
+});
+
+test("LoadType contém todos os tipos", () => {
+  assert.ok(LoadType.TRACK);
+  assert.ok(LoadType.PLAYLIST);
+  assert.ok(LoadType.SEARCH);
+  assert.ok(LoadType.EMPTY);
+  assert.ok(LoadType.ERROR);
+});
+
+test("OutputFormat contém PCM, OPUS, MP3", () => {
+  assert.ok(OutputFormat.PCM);
+  assert.ok(OutputFormat.OPUS);
+  assert.ok(OutputFormat.MP3);
+});
+
+test("Limits.MAX_SEARCH_RESULTS é número positivo", () => {
+  assert.ok(typeof Limits.MAX_SEARCH_RESULTS === "number");
+  assert.ok(Limits.MAX_SEARCH_RESULTS > 0);
+});
+
+// ── AudioDecoder (estrutura) ──────────────────────────────────────────────────
+
+console.log("\n── AudioDecoder ──────────────────────────────────────────────────────────────");
+
+test("AudioDecoder é instanciável", () => {
+  const d = new AudioDecoder();
+  assert.ok(d instanceof EventEmitter);
+  assert.strictEqual(d.active, false);
+});
+
+test("AudioDecoder.stop() não crasha quando não iniciado", () => {
+  const d = new AudioDecoder();
+  assert.doesNotThrow(() => d.stop());
+});
+
+test("AudioDecoder é EventEmitter", () => {
+  const d = new AudioDecoder();
+  let called = false;
+  d.on("end", () => { called = true; });
+  d.emit("end");
+  assert.ok(called);
+});
+
+// ── Testes de rede (opcionais) ────────────────────────────────────────────────
+
+console.log("\n── Testes de rede (AUDIO_CORE_NETWORK_TESTS=1 para ativar) ──────────────────");
+
+if (NETWORK) {
+  const { loadItem } = require("./src/index");
+
+  test("loadItem: busca YouTube retorna tracks", async () => {
+    const result = await loadItem("ytsearch:lofi hip hop", { limit: 1 });
+    assert.ok(["track","search"].includes(result.loadType), `loadType inesperado: ${result.loadType}`);
+    assert.ok(result.tracks.length > 0, "deve ter ao menos 1 track");
+    assert.ok(result.tracks[0].info.title, "track deve ter título");
+  });
+
+  test("loadItem: busca SoundCloud retorna tracks", async () => {
+    const result = await loadItem("scsearch:jazz", { limit: 1 });
+    assert.ok(["track","search","empty"].includes(result.loadType));
+  });
+
+  test("loadItem: URL inválida retorna error ou empty", async () => {
+    const result = await loadItem("https://youtube.com/watch?v=INVALID_ID_XYZ");
+    assert.ok(["error","empty"].includes(result.loadType));
+  });
+} else {
+  skip("loadItem: busca YouTube retorna tracks");
+  skip("loadItem: busca SoundCloud retorna tracks");
+  skip("loadItem: URL inválida retorna error ou empty");
+}
+
+// ── Resultado ─────────────────────────────────────────────────────────────────
+
+setTimeout(() => {
+  console.log(`\n── Resultado ─────────────────────────────────────────────────────────────────`);
+  console.log(`  ✅ ${passed} passed`);
+  if (failed > 0) {
+    console.error(`  ❌ ${failed} failed`);
+    process.exit(1);
+  }
+  console.log("  All tests passed.\n");
+}, 500);