@boruto_vk7/opus-ogg 1.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 eduh_dev021 (Borutovk7)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,92 @@
+# @boruto_vk7/opus-ogg
+
+> **High-performance audio conversion engine for Node.js.**  
+> Seamless OGG Opus encoding for WhatsApp (iOS/Android) and Discord.js.
+
+---
+
+### Core Capabilities
+
+*   **WhatsApp iOS Compatibility**: Automatic mono-downmixing for native iPhone support.
+*   **Native Ogg/Opus Demuxer**: Built-in frame extraction for `@discordjs/voice` (no `prism-media` required).
+*   **Smart Provisioning**: Automatic FFmpeg binary resolution for Windows, Linux, and macOS.
+*   **Zero-Latency Streaming**: Optimized piping architecture for minimal CPU and memory footprint.
+*   **Termux Optimized**: Fully compatible with Android environments via Termux.
+
+---
+
+### Installation
+
+```bash
+npm install @boruto_vk7/opus-ogg
+```
+
+*Note: In Termux environments, manual installation of FFmpeg is required via `pkg install ffmpeg`.*
+
+---
+
+### Implementation Examples
+
+#### WhatsApp Voice Messaging
+Ensures full compatibility with iOS devices by enforcing mono-channel OGG Opus.
+
+```javascript
+const { EngineOgg } = require('@boruto_vk7/opus-ogg');
+const fs = require('fs');
+
+const stream = EngineOgg('./audio.mp3', {
+  profile: 'voip',
+  forceStereo: false
+});
+
+stream.pipe(fs.createWriteStream('./output.ogg'));
+```
+
+#### Discord.js Audio Resource
+Direct extraction of raw Opus packets for high-efficiency voice streaming.
+
+```javascript
+const { EngineOgg, OggToOpusStream } = require('@boruto_vk7/opus-ogg');
+const { createAudioResource, StreamType } = require('@discordjs/voice');
+
+const oggStream = EngineOgg('https://example.com/audio.mp3', {
+  profile: 'audio',
+  forceStereo: true
+});
+
+const opusStream = OggToOpusStream(oggStream);
+
+const resource = createAudioResource(opusStream, {
+  inputType: StreamType.Opus
+});
+```
+
+---
+
+### API Specification
+
+#### `EngineOgg(input, options)`
+Returns a `Readable` stream of OGG Opus data.
+
+| Parameter | Type | Description |
+| :--- | :--- | :--- |
+| `input` | `string \| Readable` | Local path, URL, or readable stream. |
+| `options.profile` | `'voip' \| 'audio'` | Voice vs. Music optimization. |
+| `options.forceStereo` | `boolean` | Enforce 2-channel output (not for WhatsApp iOS). |
+| `options.bitrate` | `string` | Target bitrate (e.g., `64k`, `128k`). |
+| `options.ffmpegPath` | `string` | Optional path to a custom FFmpeg binary. |
+
+#### `OggToOpusStream(oggStream)`
+A native demuxer that transforms OGG Opus data into raw Opus packets (Buffers).
+
+#### `EngineOggFile(id, input, options)`
+Async utility to convert and store audio in a temporary file. Returns `Promise<string>`.
+
+---
+
+### License
+MIT
+
+---
+
+**Developed by eduh_dev021 ([Borutovk7](https://github.com/Borutovk7))**

package/dist/cjs/index.js

@@ -0,0 +1,177 @@
+"use strict";
+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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EngineOgg = EngineOgg;
+exports.OggToOpusStream = OggToOpusStream;
+exports.EngineOggFile = EngineOggFile;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const https = __importStar(require("node:https"));
+const http = __importStar(require("node:http"));
+const node_child_process_1 = require("node:child_process");
+const node_stream_1 = require("node:stream");
+const os = __importStar(require("node:os"));
+const oggDemuxer_1 = require("./oggDemuxer"); // Import the new demuxer
+// Fallback to system ffmpeg if local bin is not found
+let ffmpegPath = 'ffmpeg';
+/**
+ * Resolves the path to the FFmpeg binary.
+ * Priority:
+ * 1. Local bin/ folder (downloaded via postinstall)
+ * 2. System PATH
+ */
+function resolveFFmpeg() {
+    const possiblePaths = [
+        path.join(process.cwd(), 'bin', os.platform() === 'win32' ? 'ffmpeg.exe' : 'ffmpeg'),
+        path.join(__dirname, '..', '..', 'bin', os.platform() === 'win32' ? 'ffmpeg.exe' : 'ffmpeg'),
+        path.join(__dirname, '..', 'bin', os.platform() === 'win32' ? 'ffmpeg.exe' : 'ffmpeg')
+    ];
+    for (const p of possiblePaths) {
+        try {
+            if (fs.existsSync(p))
+                return p;
+        }
+        catch { /* ignore */ }
+    }
+    return 'ffmpeg';
+}
+try {
+    ffmpegPath = resolveFFmpeg();
+}
+catch {
+    ffmpegPath = 'ffmpeg';
+}
+/**
+ * Converts audio to OGG Opus compatible with WhatsApp (iPhone) and Discord.
+ * Optimized for ultra-low latency and minimal CPU stress using streaming.
+ */
+function EngineOgg(input, options = {}) {
+    const outputStream = new node_stream_1.PassThrough({ highWaterMark: 128 * 1024 });
+    const channels = options.forceStereo ? 2 : 1;
+    const profile = options.profile || 'voip';
+    const bitrate = options.bitrate || (profile === 'audio' ? '128k' : '64k');
+    const bin = options.ffmpegPath || ffmpegPath;
+    const args = [
+        '-hide_banner',
+        '-loglevel', 'error',
+        '-probesize', '32',
+        '-analyzeduration', '0',
+        '-i', 'pipe:0',
+        '-vn',
+        '-c:a', 'libopus',
+        '-ac', channels.toString(),
+        '-ar', '48000',
+        '-b:a', bitrate,
+        '-application', profile,
+        '-vbr', 'on',
+        '-compression_level', '0',
+        '-frame_duration', '20',
+        '-map_metadata', '-1',
+        '-f', 'opus',
+        'pipe:1'
+    ];
+    const ffmpeg = (0, node_child_process_1.spawn)(bin, args);
+    // Handle Input
+    if (typeof input === 'string') {
+        if (/^https?:\/\//.test(input)) {
+            const lib = input.startsWith('https') ? https : http;
+            lib.get(input, { headers: { 'User-Agent': 'Mozilla/5.0' } }, (res) => {
+                if (res.statusCode !== 200) {
+                    outputStream.emit('error', new Error(`HTTP ${res.statusCode}`));
+                    return;
+                }
+                res.pipe(ffmpeg.stdin);
+            }).on('error', (err) => {
+                outputStream.emit('error', err);
+            });
+        }
+        else {
+            if (!fs.existsSync(input)) {
+                outputStream.emit('error', new Error(`File not found: ${input}`));
+            }
+            else {
+                fs.createReadStream(input).pipe(ffmpeg.stdin);
+            }
+        }
+    }
+    else if (input instanceof node_stream_1.Readable) {
+        input.pipe(ffmpeg.stdin);
+    }
+    // Handle Output
+    ffmpeg.stdout.pipe(outputStream);
+    // Error Handling
+    ffmpeg.on('error', (err) => {
+        if (err.code === 'ENOENT') {
+            const msg = `FFmpeg not found at "${bin}". Please ensure it is installed.`;
+            outputStream.emit('error', new Error(msg));
+        }
+        else {
+            outputStream.emit('error', err);
+        }
+    });
+    ffmpeg.stdin.on('error', () => { });
+    return outputStream;
+}
+/**
+ * Converts an Ogg Opus stream into a stream of raw Opus packets,
+ * suitable for `@discordjs/voice` with `StreamType.Opus`.
+ *
+ * @param oggInput A Readable stream containing Ogg Opus data.
+ * @returns A Readable stream emitting raw Opus packets (Buffers).
+ */
+function OggToOpusStream(oggInput) {
+    const demuxer = new oggDemuxer_1.OggDemuxer();
+    oggInput.pipe(demuxer);
+    return demuxer;
+}
+/**
+ * Legacy support for file-based conversion (Async)
+ */
+async function EngineOggFile(id, input, options = {}) {
+    const TEMP_DIR = path.resolve(process.cwd(), 'temp_audio');
+    if (!fs.existsSync(TEMP_DIR))
+        fs.mkdirSync(TEMP_DIR, { recursive: true });
+    const ts = Date.now();
+    const outputFile = path.join(TEMP_DIR, `out_${id}_${ts}.ogg`);
+    const stream = EngineOgg(input, options);
+    const writeStream = fs.createWriteStream(outputFile);
+    return new Promise((resolve, reject) => {
+        stream.pipe(writeStream);
+        writeStream.on('finish', () => resolve(outputFile));
+        writeStream.on('error', reject);
+        stream.on('error', reject);
+    });
+}
+exports.default = EngineOgg;

package/dist/cjs/oggDemuxer.js

@@ -0,0 +1,169 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OggDemuxer = void 0;
+const node_stream_1 = require("node:stream");
+// Constants for Ogg parsing
+const OGG_CAPTURE_PATTERN = 0x4f676753; // 'OggS'
+const OGG_HEADER_SIZE = 27; // Fixed size of Ogg page header
+// Opus header types
+const OPUS_HEAD_SIGNATURE = Buffer.from('OpusHead');
+const OPUS_TAGS_SIGNATURE = Buffer.from('OpusTags');
+/**
+ * A Transform stream that demuxes Ogg Opus streams, extracting raw Opus packets.
+ * It parses Ogg pages and emits individual Opus packets as Buffers.
+ */
+class OggDemuxer extends node_stream_1.Transform {
+    buffer;
+    currentGranulePosition;
+    bitstreamSerialNumber;
+    pageSequenceNumber;
+    opusHeadParsed;
+    opusTagsParsed;
+    constructor() {
+        super({ readableObjectMode: true }); // Emits Opus packets as objects (Buffers)
+        this.buffer = Buffer.alloc(0);
+        this.currentGranulePosition = 0n;
+        this.bitstreamSerialNumber = null;
+        this.pageSequenceNumber = 0;
+        this.opusHeadParsed = false;
+        this.opusTagsParsed = false;
+    }
+    _transform(chunk, encoding, callback) {
+        this.buffer = Buffer.concat([this.buffer, chunk]);
+        this.parseBuffer();
+        callback();
+    }
+    _flush(callback) {
+        // Attempt to parse any remaining data in the buffer
+        this.parseBuffer();
+        if (this.buffer.length > 0) {
+            this.emit('warn', `OggDemuxer: Remaining unparsed data in buffer: ${this.buffer.length} bytes`);
+        }
+        callback();
+    }
+    parseBuffer() {
+        while (this.buffer.length >= OGG_HEADER_SIZE) {
+            const header = this.parsePageHeader(this.buffer);
+            if (!header) {
+                // No valid OggS pattern found at current position, try to resync
+                const nextOggS = this.buffer.indexOf(Buffer.from("OggS"), 1); // Search from next byte
+                if (nextOggS === -1) {
+                    // No more OggS patterns, clear buffer and wait for more data
+                    this.buffer = Buffer.alloc(0);
+                    break;
+                }
+                else {
+                    // Resync: discard data until next OggS
+                    this.emit("debug", `OggDemuxer: Resyncing, discarding ${nextOggS} bytes.`);
+                    this.buffer = this.buffer.subarray(nextOggS);
+                    continue;
+                }
+            }
+            const pageLength = OGG_HEADER_SIZE + header.pageSegments + header.segmentTable.reduce((a, b) => a + b, 0);
+            if (this.buffer.length < pageLength) {
+                // Not enough data for the full page, wait for more
+                break;
+            }
+            // Validate bitstream serial number for logical stream continuity
+            if (this.bitstreamSerialNumber === null) {
+                this.bitstreamSerialNumber = header.bitstreamSerialNumber;
+            }
+            else if (this.bitstreamSerialNumber !== header.bitstreamSerialNumber) {
+                // This indicates a new logical bitstream, which is fine for concatenated Ogg files
+                // For simplicity, we'll just reset state for the new stream
+                this.bitstreamSerialNumber = header.bitstreamSerialNumber;
+                this.opusHeadParsed = false;
+                this.opusTagsParsed = false;
+                this.pageSequenceNumber = 0;
+                this.currentGranulePosition = 0n;
+                this.emit('warn', `OggDemuxer: Detected new logical bitstream (serial: ${header.bitstreamSerialNumber})`);
+            }
+            // Check page sequence number for continuity (optional, but good for error detection)
+            if (!(header.headerTypeFlag & 0x02) && header.pageSequenceNumber !== this.pageSequenceNumber) {
+                this.emit("warn", `OggDemuxer: Page sequence discontinuity detected. Expected ${this.pageSequenceNumber}, got ${header.pageSequenceNumber}.`);
+                // We can still try to process, but this might indicate corruption
+            }
+            this.pageSequenceNumber = header.pageSequenceNumber + 1;
+            this.currentGranulePosition = header.granulePosition;
+            // Extract packet data
+            let packetOffset = OGG_HEADER_SIZE + header.pageSegments;
+            let currentPacketBuffer = Buffer.alloc(0);
+            for (let i = 0; i < header.segmentTable.length; i++) {
+                const segmentLength = header.segmentTable[i];
+                const segmentData = this.buffer.subarray(packetOffset, packetOffset + segmentLength);
+                currentPacketBuffer = Buffer.concat([currentPacketBuffer, segmentData]);
+                packetOffset += segmentLength;
+                // If segment is less than 255, it's the end of a packet
+                if (segmentLength < 255 || i === header.segmentTable.length - 1) {
+                    this.processPacket(currentPacketBuffer);
+                    currentPacketBuffer = Buffer.alloc(0);
+                }
+            }
+            // Remove processed page from buffer
+            this.buffer = this.buffer.subarray(pageLength);
+        }
+    }
+    parsePageHeader(buffer) {
+        // Check capture pattern 'OggS'
+        // OGG_CAPTURE_PATTERN is 0x4f676753. buffer.readUInt32LE(0) reads 0x5367674f on little-endian systems.
+        // So we need to compare with Buffer.from("OggS").readUInt32LE(0)
+        if (buffer.readUInt32LE(0) !== Buffer.from("OggS").readUInt32LE(0)) {
+            return null;
+        }
+        const header = {
+            capturePattern: buffer.readUInt32LE(0),
+            streamStructureVersion: buffer.readUInt8(4),
+            headerTypeFlag: buffer.readUInt8(5),
+            granulePosition: buffer.readBigInt64LE(6),
+            bitstreamSerialNumber: buffer.readUInt32LE(14),
+            pageSequenceNumber: buffer.readUInt32LE(18),
+            pageChecksum: buffer.readUInt32LE(22),
+            pageSegments: buffer.readUInt8(26),
+            segmentTable: [],
+        };
+        // Read segment table
+        const segmentTableOffset = OGG_HEADER_SIZE;
+        for (let i = 0; i < header.pageSegments; i++) {
+            header.segmentTable.push(buffer.readUInt8(segmentTableOffset + i));
+        }
+        return header;
+    }
+    processPacket(packet) {
+        // The first two packets in an Ogg Opus stream are OpusHead and OpusTags
+        if (!this.opusHeadParsed) {
+            if (packet.subarray(0, 8).equals(OPUS_HEAD_SIGNATURE)) {
+                // This is the OpusHead packet (identification header)
+                // We don't need to emit it as a raw Opus frame for @discordjs/voice
+                this.opusHeadParsed = true;
+                this.emit("debug", `OggDemuxer: Parsed OpusHead packet. Length: ${packet.length}`);
+            }
+            else {
+                this.emit("warn", `OggDemuxer: Expected OpusHead packet but got something else. Packet length: ${packet.length}, first 8 bytes: ${packet.subarray(0, 8).toString()}`);
+                // Potentially a malformed stream or not an Opus stream
+            }
+            return;
+        }
+        if (!this.opusTagsParsed) {
+            if (packet.subarray(0, 8).equals(OPUS_TAGS_SIGNATURE)) {
+                // This is the OpusTags packet (comment header)
+                // We don't need to emit it as a raw Opus frame for @discordjs/voice
+                this.opusTagsParsed = true;
+                this.emit("debug", `OggDemuxer: Parsed OpusTags packet. Length: ${packet.length}`);
+            }
+            else {
+                this.emit("warn", `OggDemuxer: Expected OpusTags packet but got something else. Packet length: ${packet.length}, first 8 bytes: ${packet.subarray(0, 8).toString()}`);
+                // Potentially a malformed stream or not an Opus stream
+            }
+            return;
+        }
+        // After OpusHead and OpusTags, all subsequent packets are raw Opus frames
+        if (this.opusHeadParsed && this.opusTagsParsed) {
+            this.emit("debug", `OggDemuxer: Emitting Opus packet. Length: ${packet.length}`);
+            this.push(packet);
+        }
+        else {
+            this.emit("debug", `OggDemuxer: Skipping non-Opus data before headers. Length: ${packet.length}`);
+        }
+    }
+}
+exports.OggDemuxer = OggDemuxer;

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/dist/cjs/src/index.js

@@ -0,0 +1,177 @@
+"use strict";
+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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EngineOgg = EngineOgg;
+exports.OggToOpusStream = OggToOpusStream;
+exports.EngineOggFile = EngineOggFile;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const https = __importStar(require("node:https"));
+const http = __importStar(require("node:http"));
+const node_child_process_1 = require("node:child_process");
+const node_stream_1 = require("node:stream");
+const os = __importStar(require("node:os"));
+const oggDemuxer_1 = require("./oggDemuxer"); // Import the new demuxer
+// Fallback to system ffmpeg if local bin is not found
+let ffmpegPath = 'ffmpeg';
+/**
+ * Resolves the path to the FFmpeg binary.
+ * Priority:
+ * 1. Local bin/ folder (downloaded via postinstall)
+ * 2. System PATH
+ */
+function resolveFFmpeg() {
+    const possiblePaths = [
+        path.join(process.cwd(), 'bin', os.platform() === 'win32' ? 'ffmpeg.exe' : 'ffmpeg'),
+        path.join(__dirname, '..', '..', 'bin', os.platform() === 'win32' ? 'ffmpeg.exe' : 'ffmpeg'),
+        path.join(__dirname, '..', 'bin', os.platform() === 'win32' ? 'ffmpeg.exe' : 'ffmpeg')
+    ];
+    for (const p of possiblePaths) {
+        try {
+            if (fs.existsSync(p))
+                return p;
+        }
+        catch { /* ignore */ }
+    }
+    return 'ffmpeg';
+}
+try {
+    ffmpegPath = resolveFFmpeg();
+}
+catch {
+    ffmpegPath = 'ffmpeg';
+}
+/**
+ * Converts audio to OGG Opus compatible with WhatsApp (iPhone) and Discord.
+ * Optimized for ultra-low latency and minimal CPU stress using streaming.
+ */
+function EngineOgg(input, options = {}) {
+    const outputStream = new node_stream_1.PassThrough({ highWaterMark: 128 * 1024 });
+    const channels = options.forceStereo ? 2 : 1;
+    const profile = options.profile || 'voip';
+    const bitrate = options.bitrate || (profile === 'audio' ? '128k' : '64k');
+    const bin = options.ffmpegPath || ffmpegPath;
+    const args = [
+        '-hide_banner',
+        '-loglevel', 'error',
+        '-probesize', '32',
+        '-analyzeduration', '0',
+        '-i', 'pipe:0',
+        '-vn',
+        '-c:a', 'libopus',
+        '-ac', channels.toString(),
+        '-ar', '48000',
+        '-b:a', bitrate,
+        '-application', profile,
+        '-vbr', 'on',
+        '-compression_level', '0',
+        '-frame_duration', '20',
+        '-map_metadata', '-1',
+        '-f', 'opus',
+        'pipe:1'
+    ];
+    const ffmpeg = (0, node_child_process_1.spawn)(bin, args);
+    // Handle Input
+    if (typeof input === 'string') {
+        if (/^https?:\/\//.test(input)) {
+            const lib = input.startsWith('https') ? https : http;
+            lib.get(input, { headers: { 'User-Agent': 'Mozilla/5.0' } }, (res) => {
+                if (res.statusCode !== 200) {
+                    outputStream.emit('error', new Error(`HTTP ${res.statusCode}`));
+                    return;
+                }
+                res.pipe(ffmpeg.stdin);
+            }).on('error', (err) => {
+                outputStream.emit('error', err);
+            });
+        }
+        else {
+            if (!fs.existsSync(input)) {
+                outputStream.emit('error', new Error(`File not found: ${input}`));
+            }
+            else {
+                fs.createReadStream(input).pipe(ffmpeg.stdin);
+            }
+        }
+    }
+    else if (input instanceof node_stream_1.Readable) {
+        input.pipe(ffmpeg.stdin);
+    }
+    // Handle Output
+    ffmpeg.stdout.pipe(outputStream);
+    // Error Handling
+    ffmpeg.on('error', (err) => {
+        if (err.code === 'ENOENT') {
+            const msg = `FFmpeg not found at "${bin}". Please ensure it is installed.`;
+            outputStream.emit('error', new Error(msg));
+        }
+        else {
+            outputStream.emit('error', err);
+        }
+    });
+    ffmpeg.stdin.on('error', () => { });
+    return outputStream;
+}
+/**
+ * Converts an Ogg Opus stream into a stream of raw Opus packets,
+ * suitable for `@discordjs/voice` with `StreamType.Opus`.
+ *
+ * @param oggInput A Readable stream containing Ogg Opus data.
+ * @returns A Readable stream emitting raw Opus packets (Buffers).
+ */
+function OggToOpusStream(oggInput) {
+    const demuxer = new oggDemuxer_1.OggDemuxer();
+    oggInput.pipe(demuxer);
+    return demuxer;
+}
+/**
+ * Legacy support for file-based conversion (Async)
+ */
+async function EngineOggFile(id, input, options = {}) {
+    const TEMP_DIR = path.resolve(process.cwd(), 'temp_audio');
+    if (!fs.existsSync(TEMP_DIR))
+        fs.mkdirSync(TEMP_DIR, { recursive: true });
+    const ts = Date.now();
+    const outputFile = path.join(TEMP_DIR, `out_${id}_${ts}.ogg`);
+    const stream = EngineOgg(input, options);
+    const writeStream = fs.createWriteStream(outputFile);
+    return new Promise((resolve, reject) => {
+        stream.pipe(writeStream);
+        writeStream.on('finish', () => resolve(outputFile));
+        writeStream.on('error', reject);
+        stream.on('error', reject);
+    });
+}
+exports.default = EngineOgg;