@jubbio/voice 1.0.0

package/dist/AudioResource.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AudioResource = void 0;
+exports.createAudioResource = createAudioResource;
+exports.createAudioResourceFromUrl = createAudioResourceFromUrl;
+exports.probeAudioInfo = probeAudioInfo;
+const child_process_1 = require("child_process");
+const enums_1 = require("./enums");
+/**
+ * Represents an audio resource that can be played
+ */
+class AudioResource {
+    /** Metadata attached to this resource */
+    metadata;
+    /** Whether playback has started */
+    started = false;
+    /** Whether playback has ended */
+    ended = false;
+    /** The input source (URL or file path) */
+    inputSource;
+    /** Stream type */
+    streamType;
+    /** Volume (0-1) */
+    volume = 1;
+    constructor(input, options = {}) {
+        this.metadata = options.metadata;
+        this.streamType = options.inputType || enums_1.StreamType.Arbitrary;
+        if (typeof input === 'string') {
+            this.inputSource = input;
+        }
+        else {
+            // For streams, we'd need to handle differently
+            // For now, throw an error
+            throw new Error('Stream input not yet supported. Use URL or file path.');
+        }
+    }
+    /**
+     * Get the input source for FFmpeg
+     * @internal
+     */
+    getInputSource() {
+        return this.inputSource;
+    }
+    /**
+     * Set the volume (0-1)
+     */
+    setVolume(volume) {
+        this.volume = Math.max(0, Math.min(1, volume));
+    }
+    /**
+     * Get the current volume
+     */
+    getVolume() {
+        return this.volume;
+    }
+}
+exports.AudioResource = AudioResource;
+/**
+ * Create an audio resource from various inputs
+ */
+function createAudioResource(input, options) {
+    return new AudioResource(input, options);
+}
+/**
+ * Create an audio resource from a YouTube/streaming URL
+ * Stores the original URL - extraction happens at playback time
+ */
+function createAudioResourceFromUrl(url, options = {}) {
+    // Don't extract stream URL here - just store the original URL
+    // The AudioPlayer will use yt-dlp at playback time
+    return new AudioResource(url, options);
+}
+/**
+ * Check if URL is a streaming service URL
+ */
+function isStreamingUrl(url) {
+    const streamingDomains = [
+        'youtube.com',
+        'youtu.be',
+        'soundcloud.com',
+        'spotify.com',
+        'twitch.tv',
+        'vimeo.com'
+    ];
+    return streamingDomains.some(domain => url.includes(domain));
+}
+/**
+ * Check if input is a valid URL
+ */
+function isValidUrl(input) {
+    try {
+        new URL(input);
+        return true;
+    }
+    catch {
+        return input.startsWith('http://') || input.startsWith('https://');
+    }
+}
+/**
+ * Probe audio info from a URL or search query
+ * If input is not a URL, it will search YouTube
+ */
+async function probeAudioInfo(input, ytDlpPath = '~/.local/bin/yt-dlp') {
+    return new Promise((resolve, reject) => {
+        // If not a valid URL, treat as YouTube search
+        let searchQuery = input;
+        if (!isValidUrl(input)) {
+            searchQuery = `ytsearch1:${input}`;
+        }
+        const ytdlp = (0, child_process_1.spawn)('bash', [
+            '-c',
+            `${ytDlpPath} --no-playlist --no-warnings -j "${searchQuery}"`
+        ]);
+        let stdout = '';
+        let stderr = '';
+        ytdlp.stdout.on('data', (data) => {
+            stdout += data.toString();
+        });
+        ytdlp.stderr.on('data', (data) => {
+            stderr += data.toString();
+        });
+        ytdlp.on('close', (code) => {
+            if (code !== 0) {
+                reject(new Error(`Failed to probe audio info: ${stderr || 'Unknown error'}`));
+                return;
+            }
+            try {
+                const info = JSON.parse(stdout);
+                resolve({
+                    title: info.title || 'Unknown',
+                    duration: info.duration || 0,
+                    thumbnail: info.thumbnail,
+                    url: info.webpage_url || info.url || input
+                });
+            }
+            catch (e) {
+                reject(new Error(`Failed to parse audio info: ${e.message}`));
+            }
+        });
+        ytdlp.on('error', (err) => {
+            reject(new Error(`Failed to probe audio info: ${err.message}`));
+        });
+        // Timeout after 30 seconds
+        setTimeout(() => {
+            ytdlp.kill();
+            reject(new Error('Timeout waiting for audio info'));
+        }, 30000);
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"AudioResource.js","sourceRoot":"","sources":["../src/AudioResource.ts"],"names":[],"mappings":"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","sourcesContent":["import { Readable } from 'stream';\r\nimport { spawn } from 'child_process';\r\nimport { StreamType } from './enums';\r\nimport { CreateAudioResourceOptions, AudioResourceInput } from './types';\r\n\r\n/**\r\n * Represents an audio resource that can be played\r\n */\r\nexport class AudioResource<T = unknown> {\r\n  /** Metadata attached to this resource */\r\n  public readonly metadata: T;\r\n  \r\n  /** Whether playback has started */\r\n  public started = false;\r\n  \r\n  /** Whether playback has ended */\r\n  public ended = false;\r\n  \r\n  /** The input source (URL or file path) */\r\n  private inputSource: string;\r\n  \r\n  /** Stream type */\r\n  private streamType: StreamType;\r\n  \r\n  /** Volume (0-1) */\r\n  private volume = 1;\r\n\r\n  constructor(\r\n    input: AudioResourceInput,\r\n    options: CreateAudioResourceOptions<T> = {}\r\n  ) {\r\n    this.metadata = options.metadata as T;\r\n    this.streamType = options.inputType || StreamType.Arbitrary;\r\n    \r\n    if (typeof input === 'string') {\r\n      this.inputSource = input;\r\n    } else {\r\n      // For streams, we'd need to handle differently\r\n      // For now, throw an error\r\n      throw new Error('Stream input not yet supported. Use URL or file path.');\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Get the input source for FFmpeg\r\n   * @internal\r\n   */\r\n  getInputSource(): string {\r\n    return this.inputSource;\r\n  }\r\n\r\n  /**\r\n   * Set the volume (0-1)\r\n   */\r\n  setVolume(volume: number): void {\r\n    this.volume = Math.max(0, Math.min(1, volume));\r\n  }\r\n\r\n  /**\r\n   * Get the current volume\r\n   */\r\n  getVolume(): number {\r\n    return this.volume;\r\n  }\r\n}\r\n\r\n/**\r\n * Options for creating audio resource from URL\r\n */\r\nexport interface CreateAudioResourceFromUrlOptions<T = unknown> extends CreateAudioResourceOptions<T> {\r\n  /** Use yt-dlp to extract audio URL */\r\n  useYtDlp?: boolean;\r\n  /** Path to yt-dlp binary */\r\n  ytDlpPath?: string;\r\n}\r\n\r\n/**\r\n * Create an audio resource from various inputs\r\n */\r\nexport function createAudioResource<T = unknown>(\r\n  input: AudioResourceInput,\r\n  options?: CreateAudioResourceOptions<T>\r\n): AudioResource<T> {\r\n  return new AudioResource(input, options);\r\n}\r\n\r\n/**\r\n * Create an audio resource from a YouTube/streaming URL\r\n * Stores the original URL - extraction happens at playback time\r\n */\r\nexport function createAudioResourceFromUrl<T = unknown>(\r\n  url: string,\r\n  options: CreateAudioResourceFromUrlOptions<T> = {}\r\n): AudioResource<T> {\r\n  // Don't extract stream URL here - just store the original URL\r\n  // The AudioPlayer will use yt-dlp at playback time\r\n  return new AudioResource(url, options);\r\n}\r\n\r\n/**\r\n * Check if URL is a streaming service URL\r\n */\r\nfunction isStreamingUrl(url: string): boolean {\r\n  const streamingDomains = [\r\n    'youtube.com',\r\n    'youtu.be',\r\n    'soundcloud.com',\r\n    'spotify.com',\r\n    'twitch.tv',\r\n    'vimeo.com'\r\n  ];\r\n  \r\n  return streamingDomains.some(domain => url.includes(domain));\r\n}\r\n\r\n/**\r\n * Check if input is a valid URL\r\n */\r\nfunction isValidUrl(input: string): boolean {\r\n  try {\r\n    new URL(input);\r\n    return true;\r\n  } catch {\r\n    return input.startsWith('http://') || input.startsWith('https://');\r\n  }\r\n}\r\n\r\n/**\r\n * Probe audio info from a URL or search query\r\n * If input is not a URL, it will search YouTube\r\n */\r\nexport async function probeAudioInfo(input: string, ytDlpPath = '~/.local/bin/yt-dlp'): Promise<{\r\n  title: string;\r\n  duration: number;\r\n  thumbnail?: string;\r\n  url: string;\r\n}> {\r\n  return new Promise((resolve, reject) => {\r\n    // If not a valid URL, treat as YouTube search\r\n    let searchQuery = input;\r\n    if (!isValidUrl(input)) {\r\n      searchQuery = `ytsearch1:${input}`;\r\n    }\r\n    \r\n    const ytdlp = spawn('bash', [\r\n      '-c',\r\n      `${ytDlpPath} --no-playlist --no-warnings -j \"${searchQuery}\"`\r\n    ]);\r\n    \r\n    let stdout = '';\r\n    let stderr = '';\r\n    \r\n    ytdlp.stdout.on('data', (data) => {\r\n      stdout += data.toString();\r\n    });\r\n    \r\n    ytdlp.stderr.on('data', (data) => {\r\n      stderr += data.toString();\r\n    });\r\n    \r\n    ytdlp.on('close', (code) => {\r\n      if (code !== 0) {\r\n        reject(new Error(`Failed to probe audio info: ${stderr || 'Unknown error'}`));\r\n        return;\r\n      }\r\n      \r\n      try {\r\n        const info = JSON.parse(stdout);\r\n        resolve({\r\n          title: info.title || 'Unknown',\r\n          duration: info.duration || 0,\r\n          thumbnail: info.thumbnail,\r\n          url: info.webpage_url || info.url || input\r\n        });\r\n      } catch (e) {\r\n        reject(new Error(`Failed to parse audio info: ${(e as Error).message}`));\r\n      }\r\n    });\r\n    \r\n    ytdlp.on('error', (err) => {\r\n      reject(new Error(`Failed to probe audio info: ${err.message}`));\r\n    });\r\n    \r\n    // Timeout after 30 seconds\r\n    setTimeout(() => {\r\n      ytdlp.kill();\r\n      reject(new Error('Timeout waiting for audio info'));\r\n    }, 30000);\r\n  });\r\n}\r\n"]}

package/dist/VoiceConnection.d.ts

@@ -0,0 +1,66 @@
+import { EventEmitter } from 'events';
+import { Room } from '@livekit/rtc-node';
+import { JoinVoiceChannelOptions, VoiceConnectionState } from './types';
+import { AudioPlayer } from './AudioPlayer';
+/**
+ * Represents a voice connection to a channel
+ */
+export declare class VoiceConnection extends EventEmitter {
+    /** Current connection state */
+    state: VoiceConnectionState;
+    /** The channel ID this connection is for */
+    readonly channelId: string;
+    /** The guild ID this connection is for */
+    readonly guildId: string;
+    /** LiveKit room instance */
+    private room;
+    /** LiveKit connection info */
+    private livekitEndpoint;
+    private livekitToken;
+    private livekitRoomName;
+    /** Subscribed audio player */
+    private subscribedPlayer;
+    /** Gateway adapter methods */
+    private adapterMethods;
+    /** Adapter implementer (for sending payloads) */
+    private adapter;
+    constructor(options: JoinVoiceChannelOptions);
+    /**
+     * Subscribe an audio player to this connection
+     */
+    subscribe(player: AudioPlayer): void;
+    /**
+     * Unsubscribe the current audio player
+     */
+    unsubscribe(): void;
+    /**
+     * Get the LiveKit room (for audio player to publish tracks)
+     */
+    getRoom(): Room | null;
+    /**
+     * Disconnect from the voice channel
+     */
+    disconnect(): boolean;
+    /**
+     * Destroy the connection completely
+     */
+    destroy(): void;
+    /**
+     * Rejoin the voice channel (after disconnect)
+     */
+    rejoin(): boolean;
+    private sendVoiceStateUpdate;
+    private handleVoiceServerUpdate;
+    private handleVoiceStateUpdate;
+    private connectToLiveKit;
+    private disconnectFromLiveKit;
+    private setState;
+}
+/**
+ * Join a voice channel - main entry point
+ */
+export declare function joinVoiceChannel(options: JoinVoiceChannelOptions): VoiceConnection;
+/**
+ * Get an existing voice connection
+ */
+export declare function getVoiceConnection(guildId: string): VoiceConnection | undefined;

package/dist/VoiceConnection.js

@@ -0,0 +1,191 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VoiceConnection = void 0;
+exports.joinVoiceChannel = joinVoiceChannel;
+exports.getVoiceConnection = getVoiceConnection;
+const events_1 = require("events");
+const rtc_node_1 = require("@livekit/rtc-node");
+const enums_1 = require("./enums");
+/**
+ * Represents a voice connection to a channel
+ */
+class VoiceConnection extends events_1.EventEmitter {
+    /** Current connection state */
+    state = { status: enums_1.VoiceConnectionStatus.Connecting };
+    /** The channel ID this connection is for */
+    channelId;
+    /** The guild ID this connection is for */
+    guildId;
+    /** LiveKit room instance */
+    room = null;
+    /** LiveKit connection info */
+    livekitEndpoint = null;
+    livekitToken = null;
+    livekitRoomName = null;
+    /** Subscribed audio player */
+    subscribedPlayer = null;
+    /** Gateway adapter methods */
+    adapterMethods;
+    /** Adapter implementer (for sending payloads) */
+    adapter = null;
+    constructor(options) {
+        super();
+        this.channelId = options.channelId;
+        this.guildId = options.guildId;
+        // Create adapter methods that will receive gateway events
+        this.adapterMethods = {
+            onVoiceServerUpdate: (data) => this.handleVoiceServerUpdate(data),
+            onVoiceStateUpdate: (data) => this.handleVoiceStateUpdate(data),
+            destroy: () => this.destroy()
+        };
+        // Get adapter from creator
+        this.adapter = options.adapterCreator(this.adapterMethods);
+        // Send voice state update to join channel
+        this.sendVoiceStateUpdate(options.channelId, options.selfMute, options.selfDeaf);
+    }
+    /**
+     * Subscribe an audio player to this connection
+     */
+    subscribe(player) {
+        if (this.subscribedPlayer) {
+            this.subscribedPlayer.unsubscribe(this);
+        }
+        this.subscribedPlayer = player;
+        player.subscribe(this);
+    }
+    /**
+     * Unsubscribe the current audio player
+     */
+    unsubscribe() {
+        if (this.subscribedPlayer) {
+            this.subscribedPlayer.unsubscribe(this);
+            this.subscribedPlayer = null;
+        }
+    }
+    /**
+     * Get the LiveKit room (for audio player to publish tracks)
+     */
+    getRoom() {
+        return this.room;
+    }
+    /**
+     * Disconnect from the voice channel
+     */
+    disconnect() {
+        this.sendVoiceStateUpdate(null);
+        return true;
+    }
+    /**
+     * Destroy the connection completely
+     */
+    destroy() {
+        this.unsubscribe();
+        this.disconnectFromLiveKit();
+        this.adapter?.destroy();
+        this.setState({ status: enums_1.VoiceConnectionStatus.Destroyed });
+    }
+    /**
+     * Rejoin the voice channel (after disconnect)
+     */
+    rejoin() {
+        this.sendVoiceStateUpdate(this.channelId);
+        return true;
+    }
+    sendVoiceStateUpdate(channelId, selfMute = false, selfDeaf = false) {
+        if (!this.adapter)
+            return;
+        this.adapter.sendPayload({
+            op: 4, // VOICE_STATE_UPDATE
+            d: {
+                guild_id: this.guildId,
+                channel_id: channelId,
+                self_mute: selfMute,
+                self_deaf: selfDeaf
+            }
+        });
+    }
+    handleVoiceServerUpdate(data) {
+        this.livekitEndpoint = data.endpoint;
+        this.livekitToken = data.token;
+        this.livekitRoomName = data.room;
+        this.setState({ status: enums_1.VoiceConnectionStatus.Signalling });
+        this.connectToLiveKit();
+    }
+    handleVoiceStateUpdate(data) {
+        if (data.channel_id === null) {
+            // Disconnected
+            this.disconnectFromLiveKit();
+            this.setState({ status: enums_1.VoiceConnectionStatus.Disconnected });
+        }
+    }
+    async connectToLiveKit() {
+        if (!this.livekitEndpoint || !this.livekitToken) {
+            this.emit('error', new Error('Missing LiveKit connection info'));
+            return;
+        }
+        try {
+            // Disconnect existing room if any
+            await this.disconnectFromLiveKit();
+            this.room = new rtc_node_1.Room();
+            this.room.on(rtc_node_1.RoomEvent.Disconnected, () => {
+                this.setState({ status: enums_1.VoiceConnectionStatus.Disconnected });
+            });
+            await this.room.connect(this.livekitEndpoint, this.livekitToken);
+            this.setState({ status: enums_1.VoiceConnectionStatus.Ready });
+            // Notify subscribed player that connection is ready
+            if (this.subscribedPlayer) {
+                this.subscribedPlayer.onConnectionReady(this);
+            }
+        }
+        catch (error) {
+            this.emit('error', error);
+            this.setState({ status: enums_1.VoiceConnectionStatus.Disconnected });
+        }
+    }
+    async disconnectFromLiveKit() {
+        if (this.room) {
+            try {
+                await this.room.disconnect();
+            }
+            catch (e) {
+                // Ignore disconnect errors
+            }
+            this.room = null;
+        }
+    }
+    setState(newState) {
+        const oldState = this.state;
+        this.state = newState;
+        this.emit('stateChange', oldState, newState);
+    }
+}
+exports.VoiceConnection = VoiceConnection;
+// Store active connections
+const connections = new Map();
+/**
+ * Join a voice channel - main entry point
+ */
+function joinVoiceChannel(options) {
+    const key = `${options.guildId}:${options.channelId}`;
+    // Destroy existing connection if any
+    const existing = connections.get(key);
+    if (existing) {
+        existing.destroy();
+        connections.delete(key);
+    }
+    const connection = new VoiceConnection(options);
+    connections.set(key, connection);
+    return connection;
+}
+/**
+ * Get an existing voice connection
+ */
+function getVoiceConnection(guildId) {
+    for (const [key, connection] of connections) {
+        if (key.startsWith(`${guildId}:`)) {
+            return connection;
+        }
+    }
+    return undefined;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"VoiceConnection.js","sourceRoot":"","sources":["../src/VoiceConnection.ts"],"names":[],"mappings":"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","sourcesContent":["import { EventEmitter } from 'events';\r\nimport { Room, RoomEvent } from '@livekit/rtc-node';\r\nimport { VoiceConnectionStatus } from './enums';\r\nimport { \r\n  JoinVoiceChannelOptions, \r\n  VoiceConnectionState,\r\n  GatewayAdapterLibraryMethods,\r\n  VoiceServerUpdate\r\n} from './types';\r\nimport { AudioPlayer } from './AudioPlayer';\r\n\r\n/**\r\n * Represents a voice connection to a channel\r\n */\r\nexport class VoiceConnection extends EventEmitter {\r\n  /** Current connection state */\r\n  public state: VoiceConnectionState = { status: VoiceConnectionStatus.Connecting };\r\n  \r\n  /** The channel ID this connection is for */\r\n  public readonly channelId: string;\r\n  \r\n  /** The guild ID this connection is for */\r\n  public readonly guildId: string;\r\n  \r\n  /** LiveKit room instance */\r\n  private room: Room | null = null;\r\n  \r\n  /** LiveKit connection info */\r\n  private livekitEndpoint: string | null = null;\r\n  private livekitToken: string | null = null;\r\n  private livekitRoomName: string | null = null;\r\n  \r\n  /** Subscribed audio player */\r\n  private subscribedPlayer: AudioPlayer | null = null;\r\n  \r\n  /** Gateway adapter methods */\r\n  private adapterMethods: GatewayAdapterLibraryMethods;\r\n  \r\n  /** Adapter implementer (for sending payloads) */\r\n  private adapter: { sendPayload: (payload: any) => boolean; destroy: () => void } | null = null;\r\n\r\n  constructor(options: JoinVoiceChannelOptions) {\r\n    super();\r\n    this.channelId = options.channelId;\r\n    this.guildId = options.guildId;\r\n    \r\n    // Create adapter methods that will receive gateway events\r\n    this.adapterMethods = {\r\n      onVoiceServerUpdate: (data: VoiceServerUpdate) => this.handleVoiceServerUpdate(data),\r\n      onVoiceStateUpdate: (data) => this.handleVoiceStateUpdate(data),\r\n      destroy: () => this.destroy()\r\n    };\r\n    \r\n    // Get adapter from creator\r\n    this.adapter = options.adapterCreator(this.adapterMethods);\r\n    \r\n    // Send voice state update to join channel\r\n    this.sendVoiceStateUpdate(options.channelId, options.selfMute, options.selfDeaf);\r\n  }\r\n\r\n  /**\r\n   * Subscribe an audio player to this connection\r\n   */\r\n  subscribe(player: AudioPlayer): void {\r\n    if (this.subscribedPlayer) {\r\n      this.subscribedPlayer.unsubscribe(this);\r\n    }\r\n    this.subscribedPlayer = player;\r\n    player.subscribe(this);\r\n  }\r\n\r\n  /**\r\n   * Unsubscribe the current audio player\r\n   */\r\n  unsubscribe(): void {\r\n    if (this.subscribedPlayer) {\r\n      this.subscribedPlayer.unsubscribe(this);\r\n      this.subscribedPlayer = null;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Get the LiveKit room (for audio player to publish tracks)\r\n   */\r\n  getRoom(): Room | null {\r\n    return this.room;\r\n  }\r\n\r\n  /**\r\n   * Disconnect from the voice channel\r\n   */\r\n  disconnect(): boolean {\r\n    this.sendVoiceStateUpdate(null);\r\n    return true;\r\n  }\r\n\r\n  /**\r\n   * Destroy the connection completely\r\n   */\r\n  destroy(): void {\r\n    this.unsubscribe();\r\n    this.disconnectFromLiveKit();\r\n    this.adapter?.destroy();\r\n    this.setState({ status: VoiceConnectionStatus.Destroyed });\r\n  }\r\n\r\n  /**\r\n   * Rejoin the voice channel (after disconnect)\r\n   */\r\n  rejoin(): boolean {\r\n    this.sendVoiceStateUpdate(this.channelId);\r\n    return true;\r\n  }\r\n\r\n  private sendVoiceStateUpdate(channelId: string | null, selfMute = false, selfDeaf = false): void {\r\n    if (!this.adapter) return;\r\n    \r\n    this.adapter.sendPayload({\r\n      op: 4, // VOICE_STATE_UPDATE\r\n      d: {\r\n        guild_id: this.guildId,\r\n        channel_id: channelId,\r\n        self_mute: selfMute,\r\n        self_deaf: selfDeaf\r\n      }\r\n    });\r\n  }\r\n\r\n  private handleVoiceServerUpdate(data: VoiceServerUpdate): void {\r\n    this.livekitEndpoint = data.endpoint;\r\n    this.livekitToken = data.token;\r\n    this.livekitRoomName = data.room;\r\n    \r\n    this.setState({ status: VoiceConnectionStatus.Signalling });\r\n    this.connectToLiveKit();\r\n  }\r\n\r\n  private handleVoiceStateUpdate(data: any): void {\r\n    if (data.channel_id === null) {\r\n      // Disconnected\r\n      this.disconnectFromLiveKit();\r\n      this.setState({ status: VoiceConnectionStatus.Disconnected });\r\n    }\r\n  }\r\n\r\n  private async connectToLiveKit(): Promise<void> {\r\n    if (!this.livekitEndpoint || !this.livekitToken) {\r\n      this.emit('error', new Error('Missing LiveKit connection info'));\r\n      return;\r\n    }\r\n\r\n    try {\r\n      // Disconnect existing room if any\r\n      await this.disconnectFromLiveKit();\r\n      \r\n      this.room = new Room();\r\n      \r\n      this.room.on(RoomEvent.Disconnected, () => {\r\n        this.setState({ status: VoiceConnectionStatus.Disconnected });\r\n      });\r\n\r\n      await this.room.connect(this.livekitEndpoint, this.livekitToken);\r\n      \r\n      this.setState({ status: VoiceConnectionStatus.Ready });\r\n      \r\n      // Notify subscribed player that connection is ready\r\n      if (this.subscribedPlayer) {\r\n        this.subscribedPlayer.onConnectionReady(this);\r\n      }\r\n    } catch (error) {\r\n      this.emit('error', error);\r\n      this.setState({ status: VoiceConnectionStatus.Disconnected });\r\n    }\r\n  }\r\n\r\n  private async disconnectFromLiveKit(): Promise<void> {\r\n    if (this.room) {\r\n      try {\r\n        await this.room.disconnect();\r\n      } catch (e) {\r\n        // Ignore disconnect errors\r\n      }\r\n      this.room = null;\r\n    }\r\n  }\r\n\r\n  private setState(newState: VoiceConnectionState): void {\r\n    const oldState = this.state;\r\n    this.state = newState;\r\n    this.emit('stateChange', oldState, newState);\r\n  }\r\n}\r\n\r\n// Store active connections\r\nconst connections = new Map<string, VoiceConnection>();\r\n\r\n/**\r\n * Join a voice channel - main entry point\r\n */\r\nexport function joinVoiceChannel(options: JoinVoiceChannelOptions): VoiceConnection {\r\n  const key = `${options.guildId}:${options.channelId}`;\r\n  \r\n  // Destroy existing connection if any\r\n  const existing = connections.get(key);\r\n  if (existing) {\r\n    existing.destroy();\r\n    connections.delete(key);\r\n  }\r\n  \r\n  const connection = new VoiceConnection(options);\r\n  connections.set(key, connection);\r\n  \r\n  return connection;\r\n}\r\n\r\n/**\r\n * Get an existing voice connection\r\n */\r\nexport function getVoiceConnection(guildId: string): VoiceConnection | undefined {\r\n  for (const [key, connection] of connections) {\r\n    if (key.startsWith(`${guildId}:`)) {\r\n      return connection;\r\n    }\r\n  }\r\n  return undefined;\r\n}\r\n"]}

package/dist/enums.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Voice connection status
+ */
+export declare enum VoiceConnectionStatus {
+    /** Connection is being established */
+    Connecting = "connecting",
+    /** Connection is ready to use */
+    Ready = "ready",
+    /** Connection is disconnected */
+    Disconnected = "disconnected",
+    /** Connection is destroyed */
+    Destroyed = "destroyed",
+    /** Connection is signalling (exchanging info with server) */
+    Signalling = "signalling"
+}
+/**
+ * Audio player status
+ */
+export declare enum AudioPlayerStatus {
+    /** Player is idle (not playing anything) */
+    Idle = "idle",
+    /** Player is buffering audio */
+    Buffering = "buffering",
+    /** Player is playing audio */
+    Playing = "playing",
+    /** Player is paused */
+    Paused = "paused",
+    /** Player is auto-paused (no subscribers) */
+    AutoPaused = "autopaused"
+}
+/**
+ * Audio resource type
+ */
+export declare enum StreamType {
+    /** Arbitrary audio stream */
+    Arbitrary = "arbitrary",
+    /** Raw PCM audio */
+    Raw = "raw",
+    /** Opus encoded audio */
+    Opus = "opus",
+    /** OGG/Opus container */
+    OggOpus = "ogg/opus",
+    /** WebM/Opus container */
+    WebmOpus = "webm/opus"
+}

package/dist/enums.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamType = exports.AudioPlayerStatus = exports.VoiceConnectionStatus = void 0;
+/**
+ * Voice connection status
+ */
+var VoiceConnectionStatus;
+(function (VoiceConnectionStatus) {
+    /** Connection is being established */
+    VoiceConnectionStatus["Connecting"] = "connecting";
+    /** Connection is ready to use */
+    VoiceConnectionStatus["Ready"] = "ready";
+    /** Connection is disconnected */
+    VoiceConnectionStatus["Disconnected"] = "disconnected";
+    /** Connection is destroyed */
+    VoiceConnectionStatus["Destroyed"] = "destroyed";
+    /** Connection is signalling (exchanging info with server) */
+    VoiceConnectionStatus["Signalling"] = "signalling";
+})(VoiceConnectionStatus || (exports.VoiceConnectionStatus = VoiceConnectionStatus = {}));
+/**
+ * Audio player status
+ */
+var AudioPlayerStatus;
+(function (AudioPlayerStatus) {
+    /** Player is idle (not playing anything) */
+    AudioPlayerStatus["Idle"] = "idle";
+    /** Player is buffering audio */
+    AudioPlayerStatus["Buffering"] = "buffering";
+    /** Player is playing audio */
+    AudioPlayerStatus["Playing"] = "playing";
+    /** Player is paused */
+    AudioPlayerStatus["Paused"] = "paused";
+    /** Player is auto-paused (no subscribers) */
+    AudioPlayerStatus["AutoPaused"] = "autopaused";
+})(AudioPlayerStatus || (exports.AudioPlayerStatus = AudioPlayerStatus = {}));
+/**
+ * Audio resource type
+ */
+var StreamType;
+(function (StreamType) {
+    /** Arbitrary audio stream */
+    StreamType["Arbitrary"] = "arbitrary";
+    /** Raw PCM audio */
+    StreamType["Raw"] = "raw";
+    /** Opus encoded audio */
+    StreamType["Opus"] = "opus";
+    /** OGG/Opus container */
+    StreamType["OggOpus"] = "ogg/opus";
+    /** WebM/Opus container */
+    StreamType["WebmOpus"] = "webm/opus";
+})(StreamType || (exports.StreamType = StreamType = {}));
+//# sourceMappingURL=data:application/json;base64,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

package/dist/index.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @jubbio/voice - Voice library for Jubbio bots
+ *
+ * Usage:
+ * ```typescript
+ * import { joinVoiceChannel, createAudioPlayer, createAudioResource } from '@jubbio/voice';
+ *
+ * const connection = joinVoiceChannel({
+ *   channelId: '123456789',
+ *   guildId: '987654321',
+ *   adapterCreator: client.guilds.cache.get('987654321')!.voiceAdapterCreator
+ * });
+ *
+ * const player = createAudioPlayer();
+ * const resource = createAudioResource('https://example.com/audio.mp3');
+ *
+ * player.play(resource);
+ * connection.subscribe(player);
+ * ```
+ */
+export * from './VoiceConnection';
+export * from './AudioPlayer';
+export * from './AudioResource';
+export * from './types';
+export * from './enums';

package/dist/index.js

@@ -0,0 +1,42 @@
+"use strict";
+/**
+ * @jubbio/voice - Voice library for Jubbio bots
+ *
+ * Usage:
+ * ```typescript
+ * import { joinVoiceChannel, createAudioPlayer, createAudioResource } from '@jubbio/voice';
+ *
+ * const connection = joinVoiceChannel({
+ *   channelId: '123456789',
+ *   guildId: '987654321',
+ *   adapterCreator: client.guilds.cache.get('987654321')!.voiceAdapterCreator
+ * });
+ *
+ * const player = createAudioPlayer();
+ * const resource = createAudioResource('https://example.com/audio.mp3');
+ *
+ * player.play(resource);
+ * connection.subscribe(player);
+ * ```
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./VoiceConnection"), exports);
+__exportStar(require("./AudioPlayer"), exports);
+__exportStar(require("./AudioResource"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./enums"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBOzs7Ozs7Ozs7Ozs7Ozs7Ozs7O0dBbUJHOzs7Ozs7Ozs7Ozs7Ozs7O0FBRUgsb0RBQWtDO0FBQ2xDLGdEQUE4QjtBQUM5QixrREFBZ0M7QUFDaEMsMENBQXdCO0FBQ3hCLDBDQUF3QiIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxyXG4gKiBAanViYmlvL3ZvaWNlIC0gVm9pY2UgbGlicmFyeSBmb3IgSnViYmlvIGJvdHNcclxuICogXHJcbiAqIFVzYWdlOlxyXG4gKiBgYGB0eXBlc2NyaXB0XHJcbiAqIGltcG9ydCB7IGpvaW5Wb2ljZUNoYW5uZWwsIGNyZWF0ZUF1ZGlvUGxheWVyLCBjcmVhdGVBdWRpb1Jlc291cmNlIH0gZnJvbSAnQGp1YmJpby92b2ljZSc7XHJcbiAqIFxyXG4gKiBjb25zdCBjb25uZWN0aW9uID0gam9pblZvaWNlQ2hhbm5lbCh7XHJcbiAqICAgY2hhbm5lbElkOiAnMTIzNDU2Nzg5JyxcclxuICogICBndWlsZElkOiAnOTg3NjU0MzIxJyxcclxuICogICBhZGFwdGVyQ3JlYXRvcjogY2xpZW50Lmd1aWxkcy5jYWNoZS5nZXQoJzk4NzY1NDMyMScpIS52b2ljZUFkYXB0ZXJDcmVhdG9yXHJcbiAqIH0pO1xyXG4gKiBcclxuICogY29uc3QgcGxheWVyID0gY3JlYXRlQXVkaW9QbGF5ZXIoKTtcclxuICogY29uc3QgcmVzb3VyY2UgPSBjcmVhdGVBdWRpb1Jlc291cmNlKCdodHRwczovL2V4YW1wbGUuY29tL2F1ZGlvLm1wMycpO1xyXG4gKiBcclxuICogcGxheWVyLnBsYXkocmVzb3VyY2UpO1xyXG4gKiBjb25uZWN0aW9uLnN1YnNjcmliZShwbGF5ZXIpO1xyXG4gKiBgYGBcclxuICovXHJcblxyXG5leHBvcnQgKiBmcm9tICcuL1ZvaWNlQ29ubmVjdGlvbic7XHJcbmV4cG9ydCAqIGZyb20gJy4vQXVkaW9QbGF5ZXInO1xyXG5leHBvcnQgKiBmcm9tICcuL0F1ZGlvUmVzb3VyY2UnO1xyXG5leHBvcnQgKiBmcm9tICcuL3R5cGVzJztcclxuZXhwb3J0ICogZnJvbSAnLi9lbnVtcyc7XHJcbiJdfQ==