feat(downloads): dash progress / remove nearly duplicate downloadTrackBlob logic from downloads.js

js/api.js

@@ -7,12 +7,13 @@ import {
     getExtensionFromBlob,
     getTrackTitle,
     getFullArtistString,
+    getTrackDiscNumber,
     getMimeType,
 } from './utils.js';
 import { trackDateSettings } from './storage.js';
 import { APICache } from './cache.js';
 import { addMetadataToAudio, prefetchMetadataObjects } from './metadata.js';
-import { DashDownloader } from './dash-downloader.js';
+import { DashDownloader } from './dash-downloader.ts';
 import { HlsDownloader } from './hls-downloader.js';
 import { MP3EncodingError } from './mp3-encoder.js';
 import { loadFfmpeg, FfmpegError } from './ffmpeg.js';
@@ -1288,11 +1289,36 @@ export class LosslessAPI {
         return streamUrl;
     }
 
+    /**
+     * Downloads a track or video from TIDAL in the specified quality.
+     *
+     * Handles multiple stream types (DASH, HLS, and direct HTTP), applies post-processing
+     * for audio tracks, adds metadata, and optionally triggers a browser download.
+     *
+     * @async
+     * @param {string} id - The TIDAL track or video ID
+     * @param {string} [quality='HI_RES_LOSSLESS'] - The desired audio quality (e.g., 'HI_RES_LOSSLESS', 'LOSSLESS', 'HIGH', 'NORMAL').
+     *                                               Custom FFMPEG formats are transcoded from LOSSLESS.
+     * @param {string} filename - The filename to save the downloaded content as
+     * @param {Object} [options={}] - Additional download options
+     * @param {Function} [options.onProgress] - Callback function for progress updates with signature:
+     *                                          `(progressEvent) => void`
+     * @param {Object} [options.track] - Track metadata object to attach to the audio file
+     * @param {boolean} [options.calculateDashBytes=true] - Whether to calculate total bytes for DASH streams
+     * @param {AbortSignal} [options.signal] - AbortSignal to cancel the download
+     * @param {boolean} [options.triggerDownload=true] - Whether to trigger browser download after completion
+     *
+     * @returns {Promise<Blob>} The downloaded content as a Blob object
+     *
+     * @throws {Error} If stream URL cannot be resolved, manifest is missing, or download fails
+     * @throws {AbortError} If the download is aborted via the signal
+     * @throws {MP3EncodingError|FfmpegError} If audio transcoding fails
+     */
     async downloadTrack(id, quality = 'HI_RES_LOSSLESS', filename, options = {}) {
         // Load ffmpeg in the background.
         loadFfmpeg().catch(console.error);
 
-        const { onProgress, track } = options;
+        const { onProgress, track, calculateDashBytes = true } = options;
         const prefetchPromises = prefetchMetadataObjects(track, this);
         const isVideo = track?.type === 'video';
 
@@ -1345,7 +1371,8 @@ export class LosslessAPI {
                     const downloader = new DashDownloader();
                     blob = await downloader.downloadDashStream(streamUrl, {
                         signal: options.signal,
-                        onProgress: options.onProgress,
+                        onProgress,
+                        calculateDashBytes: calculateDashBytes ?? true,
                     });
                 } catch (dashError) {
                     console.error('DASH download failed:', dashError);
@@ -1363,7 +1390,7 @@ export class LosslessAPI {
                     const downloader = new HlsDownloader();
                     blob = await downloader.downloadHlsStream(streamUrl, {
                         signal: options.signal,
-                        onProgress: options.onProgress,
+                        onProgress,
                     });
                 } catch (hlsError) {
                     console.error('HLS download failed:', hlsError);
@@ -1384,7 +1411,7 @@ export class LosslessAPI {
 
                 let receivedBytes = 0;
 
-                if (response.body && onProgress) {
+                if (response.body) {
                     const reader = response.body.getReader();
                     const chunks = [];
 
@@ -1396,7 +1423,7 @@ export class LosslessAPI {
                             chunks.push(value);
                             receivedBytes += value.byteLength;
 
-                            onProgress({
+                            onProgress?.({
                                 stage: 'downloading',
                                 receivedBytes,
                                 totalBytes: totalBytes || undefined,
@@ -1408,27 +1435,23 @@ export class LosslessAPI {
                     blob = new Blob(chunks, { type: response.headers.get('Content-Type') || defaultMime });
                 } else {
                     blob = await response.blob();
-                    if (onProgress) {
+                    onProgress?.({
-                        onProgress({
                         stage: 'downloading',
                         receivedBytes: blob.size,
                         totalBytes: blob.size,
                     });
                 }
             }
-            }
 
             if (!isVideo) {
                 blob = await applyAudioPostProcessing(blob, quality, onProgress, options.signal);
 
                 // Add metadata if track information is provided
                 if (track) {
-                    if (onProgress) {
+                    onProgress?.({
-                        onProgress({
                         stage: 'processing',
                         message: 'Adding metadata...',
                     });
-                    }
 
                     const enrichedTrack = { ...track };
                     if (lookup.info) {
@@ -1445,38 +1468,17 @@ export class LosslessAPI {
                         (track.album?.totalDiscs == null || track.album?.numberOfTracksOnDisc == null)
                     ) {
                         try {
-                            // Broad disc-field resolver — mirrors getExplicitTrackDiscNumber in downloads.js
-                            const resolveDiscNumber = (t) => {
-                                const candidates = [
-                                    t.volumeNumber,
-                                    t.discNumber,
-                                    t.mediaNumber,
-                                    t.media_number,
-                                    t.volume,
-                                    t.disc,
-                                    t.disc_no,
-                                    t.discNo,
-                                    t.disc_number,
-                                    t.mediaMetadata?.discNumber,
-                                ];
-                                for (const c of candidates) {
-                                    const parsed = parseInt(c, 10);
-                                    if (Number.isFinite(parsed) && parsed > 0) return parsed;
-                                }
-                                return 1;
-                            };
-
                             const albumData = await this.getAlbum(track.album.id);
                             if (albumData.tracks?.length > 0) {
                                 const discTrackCounts = new Map();
                                 let maxDiscNumber = 0;
                                 for (const t of albumData.tracks) {
-                                    const dn = resolveDiscNumber(t);
+                                    const dn = getTrackDiscNumber(t);
                                     discTrackCounts.set(dn, (discTrackCounts.get(dn) || 0) + 1);
                                     if (dn > maxDiscNumber) maxDiscNumber = dn;
                                 }
                                 const totalDiscs = maxDiscNumber || 1;
-                                const discNumber = resolveDiscNumber(track);
+                                const discNumber = getTrackDiscNumber(track);
                                 enrichedTrack.album = {
                                     ...(enrichedTrack.album || {}),
                                     totalDiscs: track.album?.totalDiscs ?? totalDiscs,
@@ -1493,6 +1495,7 @@ export class LosslessAPI {
                 }
             }
 
+            if (options.triggerDownload ?? true) {
                 // Detect actual format and fix filename extension if needed
                 const detectedExtension = await getExtensionFromBlob(blob);
                 let finalFilename = filename;
@@ -1504,6 +1507,8 @@ export class LosslessAPI {
                 }
 
                 triggerDownload(blob, finalFilename);
+            }
+
             return blob;
         } catch (error) {
             if (error.name === 'AbortError') {

js/dash-downloader.ts

@@ -1,8 +1,67 @@
+import { AbortError } from './errorTypes';
+import { DownloadProgress } from './progressEvents';
+
+export class DashDownloadProgress extends DownloadProgress {
+    public readonly stage = 'downloading';
+
+    constructor(
+        public readonly receivedBytes: number,
+        public readonly totalBytes: number | undefined,
+        public readonly currentSegment: number,
+        public readonly totalSegments: number
+    ) {
+        super(receivedBytes, totalBytes);
+    }
+}
+
+export interface DashDownloadOptions {
+    onProgress?: MonochromeProgressListener<DashDownloadProgress>;
+    signal?: AbortSignal;
+    calculateDashBytes?: boolean;
+}
+
+interface DashSegment {
+    number: number;
+    time: number;
+}
+
+interface DashManifest {
+    baseUrl: string;
+    initialization: string | null;
+    media: string | null;
+    segments: DashSegment[];
+    repId: string | null;
+    mimeType: string | null;
+}
+
 export class DashDownloader {
     constructor() {}
 
-    async downloadDashStream(manifestBlobUrl, options = {}) {
+    async getTotalSize(urls: string[], signal?: AbortSignal): Promise<number | undefined> {
-        const { onProgress, signal } = options;
+        try {
+            let totalSize = 0;
+
+            await Promise.all(
+                urls.map(async (url) => {
+                    const result = await fetch(url, { method: 'HEAD', signal });
+
+                    if (result.ok) {
+                        const contentLength = result.headers.get('Content-Length');
+                        if (contentLength) totalSize += parseInt(contentLength, 10);
+                    } else {
+                        throw new Error(`Failed to fetch segment HEAD: ${result.status}`);
+                    }
+                })
+            );
+
+            return totalSize;
+        } catch {
+            return undefined;
+        }
+    }
+
+    async downloadDashStream(manifestBlobUrl: string, options: DashDownloadOptions = {}): Promise<Blob> {
+        const { onProgress, signal, calculateDashBytes = true } = options;
 
         // 1. Fetch and Parse Manifest
         const response = await fetch(manifestBlobUrl);
@@ -18,24 +77,30 @@ export class DashDownloader {
         const mimeType = manifest.mimeType || 'audio/mp4';
 
         // 3. Download Segments
-        const chunks = [];
+        const chunks: ArrayBuffer[] = [];
         let downloadedBytes = 0;
-        // Estimate total size? Hard to know exactly without Content-Length of each.
+
-        // We can just track progress by segment count.
         const totalSegments = urls.length;
+        const totalSize = calculateDashBytes ? await this.getTotalSize(urls, signal) : undefined;
 
         for (let i = 0; i < urls.length; i++) {
-            if (signal?.aborted) throw new Error('AbortError');
+            if (signal?.aborted) throw new AbortError();
+
+            onProgress?.(new DashDownloadProgress(downloadedBytes, totalSize ?? undefined, i, totalSegments));
 
             const url = urls[i];
             const segmentResponse = await fetch(url, { signal });
 
             if (!segmentResponse.ok) {
-                // Retry once?
                 console.warn(`Failed to fetch segment ${i}, retrying...`);
                 await new Promise((r) => setTimeout(r, 1000));
+
                 const retryResponse = await fetch(url, { signal });
-                if (!retryResponse.ok) throw new Error(`Failed to fetch segment ${i}: ${retryResponse.status}`);
+
+                if (!retryResponse.ok) {
+                    throw new Error(`Failed to fetch segment ${i}: ${retryResponse.status}`);
+                }
+
                 const chunk = await retryResponse.arrayBuffer();
                 chunks.push(chunk);
                 downloadedBytes += chunk.byteLength;
@@ -45,22 +110,20 @@ export class DashDownloader {
                 downloadedBytes += chunk.byteLength;
             }
 
-            if (onProgress) {
+            onProgress?.({
-                onProgress({
                 stage: 'downloading',
-                    receivedBytes: downloadedBytes, // accurate byte count
+                receivedBytes: downloadedBytes,
-                    totalBytes: undefined, // Unknown total
+                totalBytes: totalSize ?? undefined,
                 currentSegment: i + 1,
-                    totalSegments: totalSegments,
+                totalSegments,
             });
         }
-        }
 
         // 4. Concatenate
         return new Blob(chunks, { type: mimeType });
     }
 
-    parseManifest(manifestText) {
+    parseManifest(manifestText: string): DashManifest {
         const parser = new DOMParser();
         const xml = parser.parseFromString(manifestText, 'text/xml');
 
@@ -70,25 +133,22 @@ export class DashDownloader {
         const period = mpd.querySelector('Period');
         if (!period) throw new Error('Invalid DASH manifest: No Period tag');
 
-        // Prefer highest bandwidth audio adaptation set
         const adaptationSets = Array.from(period.querySelectorAll('AdaptationSet'));
 
         adaptationSets.sort((a, b) => {
-            const getMaxBandwidth = (set) => {
+            const getMaxBandwidth = (set: Element) => {
                 const reps = Array.from(set.querySelectorAll('Representation'));
                 return reps.length ? Math.max(...reps.map((r) => parseInt(r.getAttribute('bandwidth') || '0', 10))) : 0;
             };
+
             return getMaxBandwidth(b) - getMaxBandwidth(a);
         });
 
-        let audioSet = adaptationSets.find((as) => as.getAttribute('mimeType')?.startsWith('audio'));
+        let audioSet = adaptationSets.find((as) => as.getAttribute('mimeType')?.startsWith('audio')) ?? null;
 
-        // Fallback: look for any adaptation set if mimeType is missing (rare)
         if (!audioSet && adaptationSets.length > 0) audioSet = adaptationSets[0];
         if (!audioSet) throw new Error('No AdaptationSet found');
 
-        // Find Representation
-        // Get all representations and sort by bandwidth descending
         const representations = Array.from(audioSet.querySelectorAll('Representation')).sort((a, b) => {
             const bwA = parseInt(a.getAttribute('bandwidth') || '0');
             const bwB = parseInt(b.getAttribute('bandwidth') || '0');
@@ -96,55 +156,47 @@ export class DashDownloader {
         });
 
         if (representations.length === 0) throw new Error('No Representation found');
+
         const rep = representations[0];
         const repId = rep.getAttribute('id');
 
-        // Find SegmentTemplate
-        // Can be in Representation or AdaptationSet
         const segmentTemplate = rep.querySelector('SegmentTemplate') || audioSet.querySelector('SegmentTemplate');
+
         if (!segmentTemplate) throw new Error('No SegmentTemplate found');
 
         const initialization = segmentTemplate.getAttribute('initialization');
         const media = segmentTemplate.getAttribute('media');
         const startNumber = parseInt(segmentTemplate.getAttribute('startNumber') || '1', 10);
 
-        // BaseURL
-        // Can be at MPD, Period, AdaptationSet, or Representation level.
-        // We strictly need to find the "deepest" one or combine them?
-        // Usually simpler manifests have it at one level.
-        // Let's resolve closest BaseURL.
         const baseUrlTag =
             rep.querySelector('BaseURL') ||
             audioSet.querySelector('BaseURL') ||
             period.querySelector('BaseURL') ||
             mpd.querySelector('BaseURL');
-        const baseUrl = baseUrlTag ? baseUrlTag.textContent.trim() : '';
 
-        // SegmentTimeline
+        const baseUrl = baseUrlTag?.textContent?.trim() || '';
+
         const segmentTimeline = segmentTemplate.querySelector('SegmentTimeline');
-        const segments = [];
+        const segments: DashSegment[] = [];
 
         if (segmentTimeline) {
             const sElements = segmentTimeline.querySelectorAll('S');
+
             let currentTime = 0;
             let currentNumber = startNumber;
 
             sElements.forEach((s) => {
-                // t is optional, defaults to previous end
                 const tAttr = s.getAttribute('t');
                 if (tAttr) currentTime = parseInt(tAttr, 10);
 
-                const d = parseInt(s.getAttribute('d'), 10);
+                const d = parseInt(s.getAttribute('d') || '0', 10);
                 const r = parseInt(s.getAttribute('r') || '0', 10);
 
-                // Initial segment
                 segments.push({ number: currentNumber, time: currentTime });
+
                 currentTime += d;
                 currentNumber++;
 
-                // Repeats
-                // r is the number of REPEATS (so total occurrences = 1 + r)
-                // If r is negative, it refers to open-ended? (Usually not in static manifests)
                 for (let i = 0; i < r; i++) {
                     segments.push({ number: currentNumber, time: currentTime });
                     currentTime += d;
@@ -163,43 +215,40 @@ export class DashDownloader {
         };
     }
 
-    generateSegmentUrls(manifest) {
+    generateSegmentUrls(manifest: DashManifest): string[] {
         const { baseUrl, initialization, media, segments, repId } = manifest;
-        const urls = [];
 
-        // Helper to resolve template strings
+        const urls: string[] = [];
-        const resolveTemplate = (template, number, time) => {
+
+        const resolveTemplate = (template: string, number: number, time: number): string => {
             return template
-                .replace(/\$RepresentationID\$/g, repId)
+                .replace(/\$RepresentationID\$/g, repId ?? '')
-                .replace(/\$Number(?:%0([0-9]+)d)?\$/g, (match, width) => {
+                .replace(/\$Number(?:%0([0-9]+)d)?\$/g, (_, width) => {
                     if (width) {
                         return number.toString().padStart(parseInt(width), '0');
                     }
-                    return number;
+                    return number.toString();
                 })
-                .replace(/\$Time(?:%0([0-9]+)d)?\$/g, (match, width) => {
+                .replace(/\$Time(?:%0([0-9]+)d)?\$/g, (_, width) => {
                     if (width) {
                         return time.toString().padStart(parseInt(width), '0');
                     }
-                    return time;
+                    return time.toString();
                 });
         };
 
-        // Helper to join paths handling slashes
+        const joinPath = (base: string, part: string): string => {
-        const joinPath = (base, part) => {
             if (!base) return part;
-            if (part.startsWith('http')) return part; // Absolute path
+            if (part.startsWith('http')) return part;
             return base.endsWith('/') ? base + part : base + '/' + part;
         };
 
-        // 1. Initialization Segment
         if (initialization) {
-            const initPath = resolveTemplate(initialization, 0, 0); // Init often doesn't use Number/Time but just in case
+            const initPath = resolveTemplate(initialization, 0, 0);
             urls.push(joinPath(baseUrl, initPath));
         }
 
-        // 2. Media Segments
+        if (media && segments.length > 0) {
-        if (segments && segments.length > 0) {
             segments.forEach((seg) => {
                 const path = resolveTemplate(media, seg.number, seg.time);
                 urls.push(joinPath(baseUrl, path));

js/downloads.js

@@ -11,16 +11,11 @@ import {
     getExtensionFromBlob,
     escapeHtml,
     getTrackDiscNumber,
-    getFullArtistString,
-    getMimeType,
 } from './utils.js';
+import { AbortError } from './errorTypes.ts';
 import { lyricsSettings, bulkDownloadSettings, playlistSettings } from './storage.js';
-import { addMetadataToAudio, prefetchMetadataObjects } from './metadata.js';
-import { DashDownloader } from './dash-downloader.js';
 import { generateM3U, generateM3U8, generateCUE, generateNFO, generateJSON } from './playlist-generator.js';
-import { loadFfmpeg } from './ffmpeg.js';
+import { triggerDownload } from './download-utils.ts';
-import { triggerDownload, applyAudioPostProcessing } from './download-utils.ts';
-import { isCustomFormat } from './ffmpegFormats.ts';
 import { ZipStreamWriter, ZipBlobWriter, ZipNeutralinoWriter, FolderPickerWriter } from './bulk-download-writer.ts';
 
 const downloadTasks = new Map();
@@ -296,168 +291,18 @@ function removeBulkDownloadTask(notifEl) {
     }, 300);
 }
 
-async function downloadTrackBlob(
+async function downloadTrackBlob(track, quality, api, signal = null, onProgress = null) {
+    const blob = await api.downloadTrack(track.id, quality, undefined, {
         track,
-    quality,
+        signal,
-    api,
+        onProgress,
-    lyricsManager = null,
+        triggerDownload: false,
-    signal = null,
+        calculateDashBytes: false,
-    onProgress = null,
-    coverBlob = null
-) {
-    // Load ffmpeg in the background.
-    loadFfmpeg().catch(console.error);
-
-    const prefetchPromises = prefetchMetadataObjects(track, api, coverBlob);
-
-    let enrichedTrack = {
-        ...track,
-        artist: track.artist || (track.artists && track.artists.length > 0 ? track.artists[0] : null),
-    };
-
-    // Custom FFMPEG formats are not native TIDAL qualities; download LOSSLESS and transcode
-    const downloadQuality = isCustomFormat(quality) ? 'LOSSLESS' : quality;
-
-    try {
-        const fullTrack = await api.getTrackMetadata(track.id);
-        if (fullTrack) {
-            enrichedTrack = {
-                ...fullTrack,
-                ...enrichedTrack,
-                artist: enrichedTrack.artist || fullTrack.artist,
-                album: {
-                    ...(fullTrack.album || {}),
-                    ...(enrichedTrack.album || {}),
-                },
-                // Preserve explicit disc fields from either source
-                discNumber: enrichedTrack.discNumber ?? fullTrack.discNumber,
-                volumeNumber: enrichedTrack.volumeNumber ?? fullTrack.volumeNumber,
-            };
-        }
-    } catch {
-        // Non-fatal: continue with best available track payload
-    }
-
-    if (enrichedTrack.album?.id) {
-        try {
-            const albumData = await api.getAlbum(enrichedTrack.album.id);
-            if (albumData.album && (!enrichedTrack.album.title || !enrichedTrack.album.artist)) {
-                enrichedTrack.album = {
-                    ...enrichedTrack.album,
-                    ...albumData.album,
-                };
-            }
-            if (albumData.tracks?.length > 0) {
-                const { totalDiscs, tracksPerDisc } = await computeDiscInfo(albumData.tracks, api);
-                const discNumber = getTrackDiscNumber(enrichedTrack) || 1;
-                enrichedTrack.album = {
-                    ...enrichedTrack.album,
-                    totalDiscs,
-                    numberOfTracksOnDisc: tracksPerDisc.get(discNumber),
-                };
-            }
-        } catch (error) {
-            console.warn('Failed to fetch album data for metadata:', error);
-        }
-    }
-
-    const lookup = await api.getTrack(track.id, downloadQuality);
-    let streamUrl;
-
-    if (lookup.originalTrackUrl) {
-        streamUrl = lookup.originalTrackUrl;
-    } else {
-        streamUrl = api.extractStreamUrlFromManifest(lookup.info.manifest);
-        if (!streamUrl) {
-            throw new Error('Could not resolve stream URL');
-        }
-    }
-
-    if (lookup.info) {
-        enrichedTrack.replayGain = {
-            trackReplayGain: lookup.info.trackReplayGain,
-            trackPeakAmplitude: lookup.info.trackPeakAmplitude,
-            albumReplayGain: lookup.info.albumReplayGain,
-            albumPeakAmplitude: lookup.info.albumPeakAmplitude,
-        };
-    }
-
-    // Handle DASH streams (blob URLs)
-    let blob;
-    if (streamUrl.startsWith('blob:')) {
-        try {
-            const downloader = new DashDownloader();
-            blob = await downloader.downloadDashStream(streamUrl, { signal });
-        } catch (dashError) {
-            console.error('DASH download failed:', dashError);
-            // Fallback
-            if (downloadQuality !== 'LOSSLESS') {
-                console.warn('Falling back to LOSSLESS (16-bit) download.');
-                return downloadTrackBlob(track, 'LOSSLESS', api, lyricsManager, signal, onProgress, coverBlob);
-            }
-            throw dashError;
-        }
-    } else {
-        const response = await fetch(streamUrl, { signal });
-        if (!response.ok) {
-            throw new Error(`Failed to fetch track: ${response.status}`);
-        }
-        blob = await response.blob();
-    }
-
-    const coverBlobToEmbed = await prefetchPromises.coverFetch;
-    const extraFiles = [];
-    const ffmpegMetadataArgs = [];
-
-    if (coverBlobToEmbed) {
-        const coverBuffer = await coverBlobToEmbed.arrayBuffer();
-        const coverExt = getMimeType(new Uint8Array(coverBuffer)) === 'image/png' ? 'png' : 'jpg';
-        const coverName = `cover.${coverExt}`;
-        extraFiles.push({
-            name: coverName,
-            data: coverBuffer,
     });
-        ffmpegMetadataArgs.push('-i', coverName);
-    }
-
-    if (enrichedTrack) {
-        ffmpegMetadataArgs.push(
-            '-metadata',
-            `title=${getTrackTitle(enrichedTrack)}`,
-            '-metadata',
-            `artist=${getFullArtistString(enrichedTrack)}`,
-            '-metadata',
-            `album=${enrichedTrack.album?.title || ''}`,
-            '-metadata',
-            `album_artist=${enrichedTrack.album?.artist?.name || enrichedTrack.artist?.name || ''}`
-        );
-
-        const trackNum = enrichedTrack.trackNumber;
-        if (trackNum) {
-            const totalTracks = enrichedTrack.album?.numberOfTracks;
-            ffmpegMetadataArgs.push('-metadata', `track=${trackNum}${totalTracks ? `/${totalTracks}` : ''}`);
-        }
-
-        const discNum = enrichedTrack.volumeNumber || enrichedTrack.discNumber;
-        if (discNum) {
-            ffmpegMetadataArgs.push('-metadata', `disc=${discNum}`);
-        }
-
-        const releaseDate = enrichedTrack.album?.releaseDate || enrichedTrack?.streamStartDate;
-        if (releaseDate) {
-            ffmpegMetadataArgs.push('-metadata', `date=${releaseDate.split('-')[0]}`);
-        }
-    }
-
-    // Apply audio post-processing (custom format transcoding + lossless container conversion)
-    blob = await applyAudioPostProcessing(blob, quality, onProgress, signal);
 
     // Detect actual format from blob signature BEFORE adding metadata
     const extension = await getExtensionFromBlob(blob);
 
-    // Add metadata to the blob
-    blob = await addMetadataToAudio(blob, enrichedTrack, api, quality, prefetchPromises);
-
     return { blob, extension };
 }
 
@@ -473,7 +318,7 @@ async function bulkDownloadSequentially(tracks, api, quality, lyricsManager, not
         updateBulkDownloadProgress(notification, i, tracks.length, trackTitle);
 
         try {
-            const { blob, extension } = await downloadTrackBlob(track, quality, api, null, signal, null, coverBlob);
+            const { blob, extension } = await downloadTrackBlob(track, quality, api, signal, null);
             const filename = buildTrackFilename(track, quality, extension);
             triggerDownload(blob, filename);
 
@@ -499,7 +344,7 @@ async function bulkDownloadSequentially(tracks, api, quality, lyricsManager, not
     }
 }
 
-async function bulkDownloadToZip(
+async function bulkDownload(
     tracks,
     folderName,
     api,
@@ -530,21 +375,22 @@ async function bulkDownloadToZip(
             if (signal.aborted) break;
             const track = tracks[i];
             const trackTitle = getTrackTitle(track);
+            let fileFraction = 0;
 
             updateBulkDownloadProgress(notification, i, tracks.length, trackTitle);
 
             try {
-                const { blob, extension } = await downloadTrackBlob(
+                const { blob, extension } = await downloadTrackBlob(track, quality, api, signal, (p) => {
-                    track,
+                    if (p && p.stage === 'downloading') {
-                    quality,
+                        if (p.totalBytes && p.receivedBytes) {
-                    api,
+                            fileFraction = p.receivedBytes / p.totalBytes;
-                    null,
+                        } else if (p.currentSegment && p.totalSegments) {
-                    signal,
+                            fileFraction = p.currentSegment / p.totalSegments;
-                    (p) => {
+                        }
-                        updateBulkDownloadProgress(notification, i, tracks.length, trackTitle, p);
+                    }
-                    },
+                    fileFraction = Math.min(fileFraction, 0.99); // Cap at 99% to avoid showing 100% before finalization
-                    coverBlob
+                    updateBulkDownloadProgress(notification, i + fileFraction, tracks.length, trackTitle, p);
-                );
+                });
                 const filename = buildTrackFilename(track, quality, extension);
                 const discNumber = discLayout.resolveDiscNumber(i);
                 const discPath = separateByDisc ? `${getDiscFolderName(discNumber)}/${filename}` : filename;
@@ -717,7 +563,7 @@ async function startBulkDownload(
         const writer = await createBulkWriter(defaultName);
 
         if (writer) {
-            await bulkDownloadToZip(
+            await bulkDownload(
                 tracks,
                 defaultName,
                 api,
@@ -846,15 +692,7 @@ export async function downloadDiscography(artist, selectedReleases, api, quality
                     const track = tracks[i];
                     if (signal.aborted) break;
                     try {
-                        const { blob, extension } = await downloadTrackBlob(
+                        const { blob, extension } = await downloadTrackBlob(track, quality, api, signal, null);
-                            track,
-                            quality,
-                            api,
-                            null,
-                            signal,
-                            null,
-                            coverBlob
-                        );
                         const filename = buildTrackFilename(track, quality, extension);
                         const discNumber = discLayout.resolveDiscNumber(i);
                         const discPath = separateByDisc ? `${getDiscFolderName(discNumber)}/${filename}` : filename;
@@ -1034,14 +872,14 @@ function updateBulkDownloadProgress(notifEl, current, total, currentItem, ffmpeg
         const percent = ffmpegProgress.progress ? Math.round(ffmpegProgress.progress) : 100;
         progressFill.style.width = `${percent}%`;
         progressFill.style.background = '#3b82f6'; // Blue for encoding
-        statusEl.textContent = `Converting ${current}/${total}: ${percent}%`;
+        statusEl.textContent = `Converting ${Math.ceil(current)}/${total}: ${percent}%`;
         return;
     }
 
     const percent = total > 0 ? Math.round((current / total) * 100) : 0;
     progressFill.style.width = `${percent}%`;
     progressFill.style.background = 'var(--highlight)';
-    statusEl.textContent = `${current}/${total} - ${currentItem}`;
+    statusEl.textContent = `${Math.floor(current)}/${total} - ${currentItem}`;
 }
 
 function completeBulkDownload(notifEl, success = true, message = null) {
@@ -1143,6 +981,7 @@ export async function downloadTrackWithMetadata(track, quality, api, lyricsManag
             onProgress: (progress) => {
                 updateDownloadProgress(track.id, progress);
             },
+            calculateDashBytes: true,
         });
 
         completeDownloadTask(track.id, true);

js/errorTypes.ts

@@ -0,0 +1,6 @@
+export class AbortError extends Error {
+    constructor(cause: string = 'The task was aborted.') {
+        super(cause);
+        this.name = 'AbortError';
+    }
+}

js/progressEvents.ts

@@ -0,0 +1,20 @@
+declare global {
+    type MonochromeProgress<T = {}> = {
+        stage: string;
+    } & T;
+
+    type MonochromeProgressMessage<T = MonochromeProgress> = {
+        message: string;
+    };
+
+    type MonochromeProgressListener<T = MonochromeProgress> = (progress: T) => void;
+}
+
+export class DownloadProgress implements MonochromeProgress {
+    public readonly stage = 'downloading';
+
+    constructor(
+        public readonly receivedBytes: number,
+        public readonly totalBytes: number | undefined
+    ) {}
+}