Speed ​​problem when downloading files larger than 2 GB

[NabiKAZ]

The client.downloadMedia command works fine and downloads files with a bandwidth of about 50 Mbps.
My problem is with files larger than 2 GB, which after downloading give this error:

Error: The value of "length" is out of range.It must be >= 0 && <= 2147483647. Received 2197627698

and creates a file with zero size.
This is my code:

try {
    const filepath = 'file';
    const fileInfo = filesToDownload[0];
    let startTime = Date.now();
    let lastProgress = 0;

    // Download file with progress tracking
    const buffer = await client.downloadMedia(fileInfo.media, {
        progressCallback: (receivedBytes, totalBytes) => {
            if (totalBytes && totalBytes > 0) {
                const percent = Math.round((receivedBytes / totalBytes) * 100);
                const elapsed = (Date.now() - startTime) / 1000;
                const speed = elapsed > 0 ? (receivedBytes / elapsed) : 0;
                const speedStr = formatSpeed(speed);

                // Fixed width formatting to prevent jumping
                const percentStr = percent.toString().padStart(3, ' ');
                const receivedStr = formatBytes(receivedBytes).padStart(10, ' ');
                const totalStr = formatBytes(totalBytes).padStart(10, ' ');
                const speedFormatted = speedStr.padStart(12, ' ');

                // Update progress in same line with fixed width
                const progressLine = `   Progress: ${percentStr}% | ${receivedStr} / ${totalStr} | ${speedFormatted}`;
                process.stdout.write(`\r${progressLine.padEnd(80, ' ')}`);

                lastProgress = percent;
            }
        },
        workers: 8, // Increased workers for better speed
        chunkSize: 1048576, // 1MB chunks for better speed
        requestDelay: 0 // No delay for better speed
    });

    // Write buffer to file
    fs.writeFileSync(filepath, buffer);

} catch (error) {
    console.error(`Error: ${error.message}`);
}

// Helper functions for formatting
function formatBytes(bytes) {
    if (!bytes || bytes === 0) return '0.00 B';
    const k = 1024;
    const sizes = ['B', 'KB', 'MB', 'GB'];
    const i = Math.floor(Math.log(bytes) / Math.log(k));
    return (bytes / Math.pow(k, i)).toFixed(2) + ' ' + sizes[i];
}

function formatSpeed(bytesPerSecond) {
    if (!bytesPerSecond || bytesPerSecond === 0) return '0.00 bps';
    const bitsPerSecond = bytesPerSecond * 8; // Convert bytes to bits
    const k = 1000; // Use 1000 for network speeds (not 1024)
    const sizes = ['bps', 'Kbps', 'Mbps', 'Gbps'];
    const i = Math.floor(Math.log(bitsPerSecond) / Math.log(k));
    return (bitsPerSecond / Math.pow(k, i)).toFixed(2) + ' ' + sizes[i];
}

(Actually the complexity of the code is to implement the progress bar and it is actually a simple client.downloadMedia code.)

I asked AI about this problem and he said that this is due to nodejs limitations and suggested a solution to write a stream and changed my code to the following:

if (fileInfo.fileSize && fileInfo.fileSize > 2000000000) {
    // Real-time progress tracking for large files only
    const progressInterval = setInterval(() => {
        if (fs.existsSync(filepath)) {
            const stats = fs.statSync(filepath);
            const currentSize = stats.size;
            if (currentSize > 0) {
                const elapsed = (Date.now() - startTime) / 1000;
                const percent = Math.round((currentSize / fileInfo.fileSize) * 100);
                const speed = elapsed > 0 ? (currentSize / elapsed) : 0;
                const speedStr = formatSpeed(speed);

                const percentStr = percent.toString().padStart(3, ' ');
                const receivedStr = formatBytes(currentSize).padStart(10, ' ');
                const totalStr = formatBytes(fileInfo.fileSize).padStart(10, ' ');
                const speedFormatted = speedStr.padStart(12, ' ');

                const progressLine = `   Progress: ${percentStr}% | ${receivedStr} / ${totalStr} | ${speedFormatted}`;
                process.stdout.write(`\r${progressLine.padEnd(80, ' ')}`);
            }
        } else {
            // Show waiting message for large files
            const elapsed = (Date.now() - startTime) / 1000;
            if (elapsed > 5) {
                process.stdout.write(`\r⏳ Preparing large file download... (${elapsed.toFixed(0)}s)`.padEnd(80, ' '));
            }
        }
    }, 100); // Update every 0.1 seconds for ultra-smooth progress

    // For large files, use downloadFile with streaming
    await client.downloadFile(fileInfo.media, {
        outputFile: filepath,
        workers: 8,
        chunkSize: 1048576,
        requestDelay: 0
    });
    clearInterval(progressInterval);

}

This code also works for files larger than 2 GB.
But the problem here is that my download speed is around 15 Mbps, which is much lower than the previous method.

What is a better solution that is as integrated as possible and of course gives me the highest possible speed?