audio-channel-queue 1.5.0 → 1.6.0

package/dist/volume.d.ts

@@ -0,0 +1,98 @@
+/**
+ * @fileoverview Volume management functions for the audio-channel-queue package
+ */
+import { VolumeConfig } from './types';
+/**
+ * Smoothly transitions volume for a specific channel over time
+ * @param channelNumber - The channel number to transition
+ * @param targetVolume - Target volume level (0-1)
+ * @param duration - Transition duration in milliseconds
+ * @param easing - Easing function type
+ * @returns Promise that resolves when transition completes
+ * @example
+ * ```typescript
+ * await transitionVolume(0, 0.2, 500, 'ease-out'); // Duck to 20% over 500ms
+ * ```
+ */
+export declare const transitionVolume: (channelNumber: number, targetVolume: number, duration?: number, easing?: "linear" | "ease-in" | "ease-out" | "ease-in-out") => Promise<void>;
+/**
+ * Sets the volume for a specific channel with optional smooth transition
+ * @param channelNumber - The channel number to set volume for
+ * @param volume - Volume level (0-1)
+ * @param transitionDuration - Optional transition duration in milliseconds
+ * @param easing - Optional easing function
+ * @example
+ * ```typescript
+ * setChannelVolume(0, 0.5); // Set channel 0 to 50%
+ * setChannelVolume(0, 0.5, 300, 'ease-out'); // Smooth transition over 300ms
+ * ```
+ */
+export declare const setChannelVolume: (channelNumber: number, volume: number, transitionDuration?: number, easing?: "linear" | "ease-in" | "ease-out" | "ease-in-out") => Promise<void>;
+/**
+ * Gets the current volume for a specific channel
+ * @param channelNumber - The channel number to get volume for (defaults to 0)
+ * @returns Current volume level (0-1) or 1.0 if channel doesn't exist
+ * @example
+ * ```typescript
+ * const volume = getChannelVolume(0);
+ * const defaultChannelVolume = getChannelVolume(); // Gets channel 0
+ * console.log(`Channel 0 volume: ${volume * 100}%`);
+ * ```
+ */
+export declare const getChannelVolume: (channelNumber?: number) => number;
+/**
+ * Gets the volume levels for all channels
+ * @returns Array of volume levels (0-1) for each channel
+ * @example
+ * ```typescript
+ * const volumes = getAllChannelsVolume();
+ * volumes.forEach((volume, index) => {
+ *   console.log(`Channel ${index}: ${volume * 100}%`);
+ * });
+ * ```
+ */
+export declare const getAllChannelsVolume: () => number[];
+/**
+ * Sets volume for all channels to the same level
+ * @param volume - Volume level (0-1) to apply to all channels
+ * @example
+ * ```typescript
+ * await setAllChannelsVolume(0.6); // Set all channels to 60% volume
+ * ```
+ */
+export declare const setAllChannelsVolume: (volume: number) => Promise<void>;
+/**
+ * Configures volume ducking for channels. When the priority channel plays audio,
+ * all other channels will be automatically reduced to the ducking volume level
+ * @param config - Volume ducking configuration
+ * @example
+ * ```typescript
+ * // When channel 1 plays, reduce all other channels to 20% volume
+ * setVolumeDucking({
+ *   priorityChannel: 1,
+ *   priorityVolume: 1.0,
+ *   duckingVolume: 0.2
+ * });
+ * ```
+ */
+export declare const setVolumeDucking: (config: VolumeConfig) => void;
+/**
+ * Removes volume ducking configuration from all channels
+ * @example
+ * ```typescript
+ * clearVolumeDucking(); // Remove all volume ducking effects
+ * ```
+ */
+export declare const clearVolumeDucking: () => void;
+/**
+ * Applies volume ducking effects based on current playback state with smooth transitions
+ * @param activeChannelNumber - The channel that just started playing
+ * @internal
+ */
+export declare const applyVolumeDucking: (activeChannelNumber: number) => Promise<void>;
+/**
+ * Restores normal volume levels when priority channel stops with smooth transitions
+ * @param stoppedChannelNumber - The channel that just stopped playing
+ * @internal
+ */
+export declare const restoreVolumeLevels: (stoppedChannelNumber: number) => Promise<void>;

package/dist/volume.js

@@ -0,0 +1,302 @@
+"use strict";
+/**
+ * @fileoverview Volume management functions for the audio-channel-queue package
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.restoreVolumeLevels = exports.applyVolumeDucking = exports.clearVolumeDucking = exports.setVolumeDucking = exports.setAllChannelsVolume = exports.getAllChannelsVolume = exports.getChannelVolume = exports.setChannelVolume = exports.transitionVolume = void 0;
+const info_1 = require("./info");
+// Store active volume transitions to handle interruptions
+const activeTransitions = new Map();
+/**
+ * Easing functions for smooth volume transitions
+ */
+const easingFunctions = {
+    linear: (t) => t,
+    'ease-in': (t) => t * t,
+    'ease-out': (t) => t * (2 - t),
+    'ease-in-out': (t) => t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t
+};
+/**
+ * Smoothly transitions volume for a specific channel over time
+ * @param channelNumber - The channel number to transition
+ * @param targetVolume - Target volume level (0-1)
+ * @param duration - Transition duration in milliseconds
+ * @param easing - Easing function type
+ * @returns Promise that resolves when transition completes
+ * @example
+ * ```typescript
+ * await transitionVolume(0, 0.2, 500, 'ease-out'); // Duck to 20% over 500ms
+ * ```
+ */
+const transitionVolume = (channelNumber_1, targetVolume_1, ...args_1) => __awaiter(void 0, [channelNumber_1, targetVolume_1, ...args_1], void 0, function* (channelNumber, targetVolume, duration = 250, easing = 'ease-out') {
+    const channel = info_1.audioChannels[channelNumber];
+    if (!channel || channel.queue.length === 0)
+        return;
+    const currentAudio = channel.queue[0];
+    const startVolume = currentAudio.volume;
+    const volumeDelta = targetVolume - startVolume;
+    // Cancel any existing transition for this channel
+    if (activeTransitions.has(channelNumber)) {
+        clearTimeout(activeTransitions.get(channelNumber));
+        activeTransitions.delete(channelNumber);
+    }
+    // If no change needed, resolve immediately
+    if (Math.abs(volumeDelta) < 0.001) {
+        channel.volume = targetVolume;
+        return Promise.resolve();
+    }
+    // Handle zero duration - instant change
+    if (duration <= 0) {
+        channel.volume = targetVolume;
+        if (channel.queue.length > 0) {
+            channel.queue[0].volume = targetVolume;
+        }
+        return Promise.resolve();
+    }
+    const startTime = performance.now();
+    const easingFn = easingFunctions[easing];
+    return new Promise((resolve) => {
+        const updateVolume = () => {
+            const elapsed = performance.now() - startTime;
+            const progress = Math.min(elapsed / duration, 1);
+            const easedProgress = easingFn(progress);
+            const currentVolume = startVolume + (volumeDelta * easedProgress);
+            const clampedVolume = Math.max(0, Math.min(1, currentVolume));
+            // Apply volume to both channel config and current audio
+            channel.volume = clampedVolume;
+            if (channel.queue.length > 0) {
+                channel.queue[0].volume = clampedVolume;
+            }
+            if (progress >= 1) {
+                // Transition complete
+                activeTransitions.delete(channelNumber);
+                resolve();
+            }
+            else {
+                // Use requestAnimationFrame in browser, setTimeout in tests
+                if (typeof requestAnimationFrame !== 'undefined') {
+                    const rafId = requestAnimationFrame(updateVolume);
+                    activeTransitions.set(channelNumber, rafId);
+                }
+                else {
+                    // In test environment, use shorter intervals
+                    const timeoutId = setTimeout(updateVolume, 1);
+                    activeTransitions.set(channelNumber, timeoutId);
+                }
+            }
+        };
+        updateVolume();
+    });
+});
+exports.transitionVolume = transitionVolume;
+/**
+ * Sets the volume for a specific channel with optional smooth transition
+ * @param channelNumber - The channel number to set volume for
+ * @param volume - Volume level (0-1)
+ * @param transitionDuration - Optional transition duration in milliseconds
+ * @param easing - Optional easing function
+ * @example
+ * ```typescript
+ * setChannelVolume(0, 0.5); // Set channel 0 to 50%
+ * setChannelVolume(0, 0.5, 300, 'ease-out'); // Smooth transition over 300ms
+ * ```
+ */
+const setChannelVolume = (channelNumber, volume, transitionDuration, easing) => __awaiter(void 0, void 0, void 0, function* () {
+    const clampedVolume = Math.max(0, Math.min(1, volume));
+    if (!info_1.audioChannels[channelNumber]) {
+        info_1.audioChannels[channelNumber] = {
+            audioCompleteCallbacks: new Set(),
+            audioPauseCallbacks: new Set(),
+            audioResumeCallbacks: new Set(),
+            audioStartCallbacks: new Set(),
+            isPaused: false,
+            progressCallbacks: new Map(),
+            queue: [],
+            queueChangeCallbacks: new Set(),
+            volume: clampedVolume
+        };
+        return;
+    }
+    if (transitionDuration && transitionDuration > 0) {
+        // Smooth transition
+        yield (0, exports.transitionVolume)(channelNumber, clampedVolume, transitionDuration, easing);
+    }
+    else {
+        // Instant change (backward compatibility)
+        info_1.audioChannels[channelNumber].volume = clampedVolume;
+        const channel = info_1.audioChannels[channelNumber];
+        if (channel.queue.length > 0) {
+            const currentAudio = channel.queue[0];
+            currentAudio.volume = clampedVolume;
+        }
+    }
+});
+exports.setChannelVolume = setChannelVolume;
+/**
+ * Gets the current volume for a specific channel
+ * @param channelNumber - The channel number to get volume for (defaults to 0)
+ * @returns Current volume level (0-1) or 1.0 if channel doesn't exist
+ * @example
+ * ```typescript
+ * const volume = getChannelVolume(0);
+ * const defaultChannelVolume = getChannelVolume(); // Gets channel 0
+ * console.log(`Channel 0 volume: ${volume * 100}%`);
+ * ```
+ */
+const getChannelVolume = (channelNumber = 0) => {
+    const channel = info_1.audioChannels[channelNumber];
+    return (channel === null || channel === void 0 ? void 0 : channel.volume) || 1.0;
+};
+exports.getChannelVolume = getChannelVolume;
+/**
+ * Gets the volume levels for all channels
+ * @returns Array of volume levels (0-1) for each channel
+ * @example
+ * ```typescript
+ * const volumes = getAllChannelsVolume();
+ * volumes.forEach((volume, index) => {
+ *   console.log(`Channel ${index}: ${volume * 100}%`);
+ * });
+ * ```
+ */
+const getAllChannelsVolume = () => {
+    return info_1.audioChannels.map((channel) => (channel === null || channel === void 0 ? void 0 : channel.volume) || 1.0);
+};
+exports.getAllChannelsVolume = getAllChannelsVolume;
+/**
+ * Sets volume for all channels to the same level
+ * @param volume - Volume level (0-1) to apply to all channels
+ * @example
+ * ```typescript
+ * await setAllChannelsVolume(0.6); // Set all channels to 60% volume
+ * ```
+ */
+const setAllChannelsVolume = (volume) => __awaiter(void 0, void 0, void 0, function* () {
+    const promises = [];
+    info_1.audioChannels.forEach((_channel, index) => {
+        promises.push((0, exports.setChannelVolume)(index, volume));
+    });
+    yield Promise.all(promises);
+});
+exports.setAllChannelsVolume = setAllChannelsVolume;
+/**
+ * Configures volume ducking for channels. When the priority channel plays audio,
+ * all other channels will be automatically reduced to the ducking volume level
+ * @param config - Volume ducking configuration
+ * @example
+ * ```typescript
+ * // When channel 1 plays, reduce all other channels to 20% volume
+ * setVolumeDucking({
+ *   priorityChannel: 1,
+ *   priorityVolume: 1.0,
+ *   duckingVolume: 0.2
+ * });
+ * ```
+ */
+const setVolumeDucking = (config) => {
+    // First, ensure we have enough channels for the priority channel
+    while (info_1.audioChannels.length <= config.priorityChannel) {
+        info_1.audioChannels.push({
+            audioCompleteCallbacks: new Set(),
+            audioPauseCallbacks: new Set(),
+            audioResumeCallbacks: new Set(),
+            audioStartCallbacks: new Set(),
+            isPaused: false,
+            progressCallbacks: new Map(),
+            queue: [],
+            queueChangeCallbacks: new Set(),
+            volume: 1.0
+        });
+    }
+    // Apply the config to all existing channels
+    info_1.audioChannels.forEach((channel, index) => {
+        if (!info_1.audioChannels[index]) {
+            info_1.audioChannels[index] = {
+                audioCompleteCallbacks: new Set(),
+                audioPauseCallbacks: new Set(),
+                audioResumeCallbacks: new Set(),
+                audioStartCallbacks: new Set(),
+                isPaused: false,
+                progressCallbacks: new Map(),
+                queue: [],
+                queueChangeCallbacks: new Set(),
+                volume: 1.0
+            };
+        }
+        info_1.audioChannels[index].volumeConfig = config;
+    });
+};
+exports.setVolumeDucking = setVolumeDucking;
+/**
+ * Removes volume ducking configuration from all channels
+ * @example
+ * ```typescript
+ * clearVolumeDucking(); // Remove all volume ducking effects
+ * ```
+ */
+const clearVolumeDucking = () => {
+    info_1.audioChannels.forEach((channel) => {
+        if (channel) {
+            delete channel.volumeConfig;
+        }
+    });
+};
+exports.clearVolumeDucking = clearVolumeDucking;
+/**
+ * Applies volume ducking effects based on current playback state with smooth transitions
+ * @param activeChannelNumber - The channel that just started playing
+ * @internal
+ */
+const applyVolumeDucking = (activeChannelNumber) => __awaiter(void 0, void 0, void 0, function* () {
+    const transitionPromises = [];
+    info_1.audioChannels.forEach((channel, channelNumber) => {
+        if (channel === null || channel === void 0 ? void 0 : channel.volumeConfig) {
+            const config = channel.volumeConfig;
+            if (activeChannelNumber === config.priorityChannel) {
+                const duration = config.duckTransitionDuration || 250;
+                const easing = config.transitionEasing || 'ease-out';
+                // Priority channel is active, duck other channels
+                if (channelNumber === config.priorityChannel) {
+                    transitionPromises.push((0, exports.transitionVolume)(channelNumber, config.priorityVolume, duration, easing));
+                }
+                else {
+                    transitionPromises.push((0, exports.transitionVolume)(channelNumber, config.duckingVolume, duration, easing));
+                }
+            }
+        }
+    });
+    // Wait for all transitions to complete
+    yield Promise.all(transitionPromises);
+});
+exports.applyVolumeDucking = applyVolumeDucking;
+/**
+ * Restores normal volume levels when priority channel stops with smooth transitions
+ * @param stoppedChannelNumber - The channel that just stopped playing
+ * @internal
+ */
+const restoreVolumeLevels = (stoppedChannelNumber) => __awaiter(void 0, void 0, void 0, function* () {
+    const transitionPromises = [];
+    info_1.audioChannels.forEach((channel, channelNumber) => {
+        if (channel === null || channel === void 0 ? void 0 : channel.volumeConfig) {
+            const config = channel.volumeConfig;
+            if (stoppedChannelNumber === config.priorityChannel) {
+                const duration = config.restoreTransitionDuration || 500;
+                const easing = config.transitionEasing || 'ease-out';
+                // Priority channel stopped, restore normal volumes
+                transitionPromises.push((0, exports.transitionVolume)(channelNumber, channel.volume || 1.0, duration, easing));
+            }
+        }
+    });
+    // Wait for all transitions to complete
+    yield Promise.all(transitionPromises);
+});
+exports.restoreVolumeLevels = restoreVolumeLevels;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "audio-channel-queue",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "description": "Allows you to queue audio files to different playback channels.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -31,6 +31,9 @@
     "url": "https://github.com/tonycarpenter21/audio-queue-package/issues"
   },
   "homepage": "https://github.com/tonycarpenter21/audio-queue-package#readme",
+  "engines": {
+    "node": ">=14.0.0"
+  },
   "devDependencies": {
     "@types/jest": "^29.5.13",
     "jest": "^29.7.0",

package/src/core.ts

@@ -2,7 +2,7 @@
  * @fileoverview Core queue management functions for the audio-channel-queue package
  */
 
-import { ExtendedAudioQueueChannel } from './types';
+import { ExtendedAudioQueueChannel, AudioQueueOptions } from './types';
 import { audioChannels } from './info';
 import { extractFileName } from './utils';
 import { 
@@ -12,39 +12,103 @@ import {
   setupProgressTracking, 
   cleanupProgressTracking 
 } from './events';
+import { applyVolumeDucking, restoreVolumeLevels } from './volume';
 
 /**
  * Queues an audio file to a specific channel and starts playing if it's the first in queue
  * @param audioUrl - The URL of the audio file to queue
  * @param channelNumber - The channel number to queue the audio to (defaults to 0)
+ * @param options - Optional configuration for the audio file
  * @returns Promise that resolves when the audio is queued and starts playing (if first in queue)
  * @example
  * ```typescript
  * await queueAudio('https://example.com/song.mp3', 0);
  * await queueAudio('./sounds/notification.wav'); // Uses default channel 0
+ * await queueAudio('./music/loop.mp3', 1, { loop: true }); // Loop the audio
+ * await queueAudio('./urgent.wav', 0, { addToFront: true }); // Add to front of queue
  * ```
  */
-export const queueAudio = async (audioUrl: string, channelNumber: number = 0): Promise<void> => {
+export const queueAudio = async (
+  audioUrl: string, 
+  channelNumber: number = 0, 
+  options?: AudioQueueOptions
+): Promise<void> => {
   if (!audioChannels[channelNumber]) {
     audioChannels[channelNumber] = { 
       audioCompleteCallbacks: new Set(),
+      audioPauseCallbacks: new Set(),
+      audioResumeCallbacks: new Set(),
       audioStartCallbacks: new Set(),
+      isPaused: false,
       progressCallbacks: new Map(),
       queue: [],
-      queueChangeCallbacks: new Set()
+      queueChangeCallbacks: new Set(),
+      volume: 1.0
     };
   }
 
   const audio: HTMLAudioElement = new Audio(audioUrl);
-  audioChannels[channelNumber].queue.push(audio);
+  
+  // Apply audio configuration from options
+  if (options?.loop) {
+    audio.loop = true;
+  }
+  
+  if (options?.volume !== undefined) {
+    const clampedVolume: number = Math.max(0, Math.min(1, options.volume));
+    // Handle NaN case - default to channel volume or 1.0
+    const safeVolume: number = isNaN(clampedVolume) ? (audioChannels[channelNumber].volume || 1.0) : clampedVolume;
+    audio.volume = safeVolume;
+    // Also update the channel volume
+    audioChannels[channelNumber].volume = safeVolume;
+  } else {
+    // Use channel volume if no specific volume is set
+    const channelVolume: number = audioChannels[channelNumber].volume || 1.0;
+    audio.volume = channelVolume;
+  }
+
+  // Add to front or back of queue based on options
+  if ((options?.addToFront || options?.priority) && audioChannels[channelNumber].queue.length > 0) {
+    // Insert after the currently playing audio (index 1)
+    audioChannels[channelNumber].queue.splice(1, 0, audio);
+  } else if ((options?.addToFront || options?.priority) && audioChannels[channelNumber].queue.length === 0) {
+    // If queue is empty, just add normally
+    audioChannels[channelNumber].queue.push(audio);
+  } else {
+    // Default behavior - add to back of queue
+    audioChannels[channelNumber].queue.push(audio);
+  }
 
   emitQueueChange(channelNumber, audioChannels);
 
   if (audioChannels[channelNumber].queue.length === 1) {
-    playAudioQueue(channelNumber);
+    // Don't await - let playback happen asynchronously
+    playAudioQueue(channelNumber).catch(console.error);
   }
 };
 
+/**
+ * Adds an audio file to the front of the queue in a specific channel
+ * This is a convenience function that places the audio right after the currently playing track
+ * @param audioUrl - The URL of the audio file to queue
+ * @param channelNumber - The channel number to queue the audio to (defaults to 0)
+ * @param options - Optional configuration for the audio file
+ * @returns Promise that resolves when the audio is queued
+ * @example
+ * ```typescript
+ * await queueAudioPriority('./urgent-announcement.wav', 0);
+ * await queueAudioPriority('./priority-sound.mp3', 1, { loop: true });
+ * ```
+ */
+export const queueAudioPriority = async (
+  audioUrl: string, 
+  channelNumber: number = 0, 
+  options?: AudioQueueOptions
+): Promise<void> => {
+  const priorityOptions: AudioQueueOptions = { ...options, addToFront: true };
+  return queueAudio(audioUrl, channelNumber, priorityOptions);
+};
+
 /**
  * Plays the audio queue for a specific channel
  * @param channelNumber - The channel number to play
@@ -57,12 +121,20 @@ export const queueAudio = async (audioUrl: string, channelNumber: number = 0): P
 export const playAudioQueue = async (channelNumber: number): Promise<void> => {
   const channel: ExtendedAudioQueueChannel = audioChannels[channelNumber];
 
-  if (channel.queue.length === 0) return;
+  if (!channel || channel.queue.length === 0) return;
 
   const currentAudio: HTMLAudioElement = channel.queue[0];
 
+  // Apply channel volume if not already set
+  if (currentAudio.volume === 1.0 && channel.volume !== undefined) {
+    currentAudio.volume = channel.volume;
+  }
+
   setupProgressTracking(currentAudio, channelNumber, audioChannels);
 
+  // Apply volume ducking when audio starts
+  await applyVolumeDucking(channelNumber);
+
   return new Promise<void>((resolve) => {
     let hasStarted: boolean = false;
     let metadataLoaded: boolean = false;
@@ -102,19 +174,33 @@ export const playAudioQueue = async (channelNumber: number): Promise<void> => {
         src: currentAudio.src
       }, audioChannels);
 
+      // Restore volume levels when priority channel stops
+      await restoreVolumeLevels(channelNumber);
+
       // Clean up event listeners
       currentAudio.removeEventListener('loadedmetadata', handleLoadedMetadata);
       currentAudio.removeEventListener('play', handlePlay);
       currentAudio.removeEventListener('ended', handleEnded);
       
       cleanupProgressTracking(currentAudio, channelNumber, audioChannels);
-      channel.queue.shift();
-      
-      // Emit queue change after completion
-      setTimeout(() => emitQueueChange(channelNumber, audioChannels), 10);
       
-      await playAudioQueue(channelNumber);
-      resolve();
+      // Handle looping vs non-looping audio
+      if (currentAudio.loop) {
+        // For looping audio, reset current time and continue playing
+        currentAudio.currentTime = 0;
+        await currentAudio.play();
+        // Don't remove from queue, but resolve the promise so tests don't hang
+        resolve();
+      } else {
+        // For non-looping audio, remove from queue and play next
+        channel.queue.shift();
+        
+        // Emit queue change after completion
+        setTimeout(() => emitQueueChange(channelNumber, audioChannels), 10);
+        
+        await playAudioQueue(channelNumber);
+        resolve();
+      }
     };
 
     // Add event listeners
@@ -136,11 +222,11 @@ export const playAudioQueue = async (channelNumber: number): Promise<void> => {
  * @param channelNumber - The channel number (defaults to 0)
  * @example
  * ```typescript
- * stopCurrentAudioInChannel(0); // Stop current audio in channel 0
- * stopCurrentAudioInChannel(); // Stop current audio in default channel
+ * await stopCurrentAudioInChannel(); // Stop current audio in default channel (0)
+ * await stopCurrentAudioInChannel(1); // Stop current audio in channel 1
  * ```
  */
-export const stopCurrentAudioInChannel = (channelNumber: number = 0): void => {
+export const stopCurrentAudioInChannel = async (channelNumber: number = 0): Promise<void> => {
   const channel: ExtendedAudioQueueChannel = audioChannels[channelNumber];
   if (channel && channel.queue.length > 0) {
     const currentAudio: HTMLAudioElement = channel.queue[0];
@@ -152,13 +238,18 @@ export const stopCurrentAudioInChannel = (channelNumber: number = 0): void => {
       src: currentAudio.src
     }, audioChannels);
 
+    // Restore volume levels when stopping
+    await restoreVolumeLevels(channelNumber);
+
     currentAudio.pause();
     cleanupProgressTracking(currentAudio, channelNumber, audioChannels);
     channel.queue.shift();
+    channel.isPaused = false; // Reset pause state
 
     emitQueueChange(channelNumber, audioChannels);
     
-    playAudioQueue(channelNumber);
+    // Start next audio without waiting for it to complete
+    playAudioQueue(channelNumber).catch(console.error);
   }
 };
 
@@ -167,11 +258,11 @@ export const stopCurrentAudioInChannel = (channelNumber: number = 0): void => {
  * @param channelNumber - The channel number (defaults to 0)
  * @example
  * ```typescript
- * stopAllAudioInChannel(0); // Clear all audio in channel 0
- * stopAllAudioInChannel(); // Clear all audio in default channel
+ * await stopAllAudioInChannel(); // Clear all audio in default channel (0)
+ * await stopAllAudioInChannel(1); // Clear all audio in channel 1
  * ```
  */
-export const stopAllAudioInChannel = (channelNumber: number = 0): void => {
+export const stopAllAudioInChannel = async (channelNumber: number = 0): Promise<void> => {
   const channel: ExtendedAudioQueueChannel = audioChannels[channelNumber];
   if (channel) {
     if (channel.queue.length > 0) {
@@ -184,12 +275,16 @@ export const stopAllAudioInChannel = (channelNumber: number = 0): void => {
         src: currentAudio.src
       }, audioChannels);
 
+      // Restore volume levels when stopping
+      await restoreVolumeLevels(channelNumber);
+
       currentAudio.pause();
       cleanupProgressTracking(currentAudio, channelNumber, audioChannels);
     }
     // Clean up all progress tracking for this channel
     channel.queue.forEach(audio => cleanupProgressTracking(audio, channelNumber, audioChannels));
     channel.queue = [];
+    channel.isPaused = false; // Reset pause state
     
     emitQueueChange(channelNumber, audioChannels);
   }
@@ -199,11 +294,13 @@ export const stopAllAudioInChannel = (channelNumber: number = 0): void => {
  * Stops all audio across all channels and clears all queues
  * @example
  * ```typescript
- * stopAllAudio(); // Emergency stop - clears everything
+ * await stopAllAudio(); // Emergency stop - clears everything
  * ```
  */
-export const stopAllAudio = (): void => {
+export const stopAllAudio = async (): Promise<void> => {
+  const stopPromises: Promise<void>[] = [];
   audioChannels.forEach((_channel: ExtendedAudioQueueChannel, index: number) => {
-    stopAllAudioInChannel(index);
+    stopPromises.push(stopAllAudioInChannel(index));
   });
+  await Promise.all(stopPromises);
 };