docs: document Node 24 and lifecycle behavior

.gitea/ISSUE_TEMPLATE/request.yaml

@@ -1,21 +0,0 @@
-name: 📝 Service Request
-description: Request a service or support task
-title: '📝 [Service Request]: '
-body:
-    - type: textarea
-      id: information
-      attributes:
-          label: Description
-          description: Provide all information.
-          placeholder: 'What happened? What did you expect to happen?'
-      validations:
-          required: false
-
-    - type: textarea
-      id: criteria
-      attributes:
-          label: Acceptance Criteria
-          description: What are the expectations?
-          placeholder: 'How do you want it implemented? How should it be tested?'
-      validations:
-          required: false

.gitea/ISSUE_TEMPLATE/story.yaml

@@ -1,21 +0,0 @@
-name: 👮 Story
-description: Describe a user story
-title: '👮 [Story]: '
-body:
-    - type: textarea
-      id: information
-      attributes:
-          label: Description
-          description: Provide all information.
-          placeholder: 'What happened? What did you expect to happen?'
-      validations:
-          required: false
-
-    - type: textarea
-      id: criteria
-      attributes:
-          label: Acceptance Criteria
-          description: What are the expectations?
-          placeholder: 'How do you want it implemented? How should it be tested?'
-      validations:
-          required: false

.gitea/workflows/Build-Rollout.yml

@@ -22,10 +22,10 @@ jobs:
                   fetch-depth: 0
                   fetch-tags: true
 
-            - name: Use NodeJS v22.22.3
+            - name: Use NodeJS 24
               uses: actions/setup-node@v6
               with:
-                  node-version: '22.22.3'
+                  node-version: '24'
                   registry-url: 'https://registry.npmjs.org'
                   package-manager-cache: false
 

.gitea/workflows/Build-Validation.yml

@@ -15,10 +15,10 @@ jobs:
             - name: Checkout Repository
               uses: actions/checkout@v4
 
-            - name: use NodeJS v22.22.3
+            - name: use NodeJS 24
               uses: actions/setup-node@v4
               with:
-                  node-version: '22.22.3'
+                  node-version: '24'
 
             - name: Install Dependencies
               run: npm ci

.github/FUNDING.yml

@@ -0,0 +1,15 @@
+# These are supported funding model platforms
+
+github: # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
+patreon: # Replace with a single Patreon username
+open_collective: # Replace with a single Open Collective username
+ko_fi: FrauJulian
+tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
+community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
+liberapay: # Replace with a single Liberapay username
+issuehunt: # Replace with a single IssueHunt username
+lfx_crowdfunding: # Replace with a single LFX Crowdfunding project-name e.g., cloud-foundry
+polar: # Replace with a single Polar username
+buy_me_a_coffee: # Replace with a single Buy Me a Coffee username
+thanks_dev: # Replace with a single thanks.dev username
+custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']

.prettierrc

@@ -9,5 +9,5 @@
     "bracketSpacing": true,
     "bracketSameLine": false,
     "quoteProps": "as-needed",
-    "endOfLine": "auto"
+    "endOfLine": "lf"
 }

README.md

@@ -18,12 +18,14 @@ Create an [issue](https://git.lechner-systems.at/FrauJulian/Discord-Audio-Stream
 
 ## Installation
 
-Node.js `22.22.3` or newer is required.
+Node.js `24.x` is required.
 
 ```bash
-npm install discord-audio-stream @discordjs/voice prism-media @snazzah/davey opusscript
+npm install discord-audio-stream @discordjs/voice @discordjs/opus
 ```
 
+Use `opusscript@^0.0.8` only as a slower JavaScript fallback when `@discordjs/opus` cannot be installed.
+
 `ffmpeg` must be available either on the host PATH or through the optional `ffmpeg-static` package:
 
 ```bash
@@ -32,13 +34,6 @@ npm install ffmpeg-static
 
 Use `ffmpeg.mode: 'native'` for PATH-based ffmpeg and `ffmpeg.mode: 'static'` for `ffmpeg-static`.
 
-`libsodium-wrappers` is optional. Install it only when your runtime does not support `aes-256-gcm`:
-
-```bash
-node -e "console.log(require('node:crypto').getCiphers().includes('aes-256-gcm'))"
-npm install libsodium-wrappers
-```
-
 ## Basic Usage
 
 ```ts
@@ -93,6 +88,15 @@ manager.dispose(); // final cleanup; the manager cannot be reused
 `connect()` joins the configured voice channel. `play(source?)` starts playback on an existing connection. Use `start()`
 when you want both.
 
+For scoped playback, `AudioManager` supports explicit resource management:
+
+```ts
+{
+    using manager = new AudioManager(options);
+    await manager.start();
+} // disposed automatically
+```
+
 ## API
 
 ```ts
@@ -111,6 +115,7 @@ type AudioManagerOptions = {
     source?: { type: 'url'; url: string } | { type: 'file'; path: string };
     renewIntervalMs?: number | false;
     connectTimeoutMs?: number;
+    onError?: (error: Error) => void;
     volume?: {
         enabled?: boolean;
         initialPercent?: number;
@@ -121,10 +126,10 @@ type AudioManagerOptions = {
 ### Defaults
 
 | Option             | Default    |
-| ------------------ | ----------- |
+| ------------------ | ---------- |
 | `ffmpeg.mode`      | `'native'` |
 | `connectTimeoutMs` | `20_000`   |
-| `renewIntervalMs`  | `5_400_000` |
+| `renewIntervalMs`  | `false`    |
 | `volume.enabled`   | `false`    |
 
 ### Methods
@@ -141,6 +146,7 @@ type AudioManagerOptions = {
 | `stop()`                 | Stops playback, clears renewal, and destroys the voice connection.                 |
 | `setVolume(percent)`     | Sets volume from `0` to `100`; requires `volume.enabled: true`.                    |
 | `dispose()`              | Idempotently releases timers, ffmpeg, streams, player state, and voice connection. |
+| `[Symbol.dispose]()`     | Enables automatic cleanup with TypeScript's `using` declaration.                   |
 
 ### State
 
@@ -175,8 +181,9 @@ Default ffmpeg output is raw Discord-compatible PCM: `s16le`, `48000 Hz`, `2 cha
 You can override ffmpeg arguments through `ffmpeg.inputArgs` and `ffmpeg.outputArgs`. When you override them, you are
 responsible for keeping the output compatible with `StreamType.Raw`.
 
-By default, the manager schedules a renewal after `5_400_000 ms` so long-running streams can reconnect periodically.
-Set `renewIntervalMs: false` to disable it. `stop()` and `dispose()` always clear the renewal timer.
+Connection renewal is disabled by default because `@discordjs/voice` handles recoverable disconnects. Set
+`renewIntervalMs` only when an application has a measured need for periodic restarts. `stop()` and `dispose()` always
+clear the renewal timer.
 
 ## Errors
 
@@ -190,6 +197,9 @@ The package exports these error classes:
 Configuration problems, such as a missing source or invalid URL, throw `AudioManagerConfigError`. Invalid lifecycle
 operations, such as calling `pause()` while nothing is playing, throw `AudioManagerStateError`.
 
+Use `onError` to observe asynchronous audio player and voice connection errors. The manager cleans up failed playback
+and unrecoverable connections before invoking the callback.
+
 ## Development
 
 ```bash

eslint.config.cjs

@@ -1,7 +1,9 @@
 /** @type {import('eslint').Linter.FlatConfig[]} */
+const prettierConfig = require('eslint-config-prettier/flat');
+
 const config = [
     {
-        ignores: ['dist/', 'node_modules/'],
+        ignores: ['coverage/', 'dist/', 'node_modules/'],
     },
 
     {
@@ -77,6 +79,23 @@ const config = [
         },
     },
 
+    {
+        files: ['**/*.{ts,tsx}'],
+        languageOptions: {
+            parserOptions: {
+                project: ['./tsconfig.eslint.json'],
+                tsconfigRootDir: __dirname,
+            },
+        },
+        rules: {
+            '@typescript-eslint/no-floating-promises': 'error',
+            '@typescript-eslint/no-misused-promises': ['error', { checksVoidReturn: false }],
+            '@typescript-eslint/no-unsafe-assignment': 'error',
+            '@typescript-eslint/no-unsafe-member-access': 'error',
+            '@typescript-eslint/no-unsafe-argument': 'error',
+        },
+    },
+
     {
         files: ['**/*.{js,cjs}'],
         languageOptions: {
@@ -88,4 +107,4 @@ const config = [
     },
 ];
 
-module.exports = config;
+module.exports = [...config, prettierConfig];

eslint.config.typeaware.cjs

@@ -1,25 +0,0 @@
-/** @type {import('eslint').Linter.FlatConfig[]} */
-const base = require('./eslint.config.cjs');
-
-const typeAwareLayer = {
-    files: ['**/*.{ts,tsx}'],
-    languageOptions: {
-        parser: require('@typescript-eslint/parser'),
-        parserOptions: {
-            project: ['./tsconfig.eslint.json'],
-            tsconfigRootDir: __dirname,
-        },
-    },
-    plugins: {
-        '@typescript-eslint': require('@typescript-eslint/eslint-plugin'),
-    },
-    rules: {
-        '@typescript-eslint/no-floating-promises': 'warn',
-        '@typescript-eslint/no-misused-promises': ['warn', { checksVoidReturn: false }],
-        '@typescript-eslint/no-unsafe-assignment': 'warn',
-        '@typescript-eslint/no-unsafe-member-access': 'warn',
-        '@typescript-eslint/no-unsafe-argument': 'warn',
-    },
-};
-
-module.exports = [...base, typeAwareLayer];

package.json

@@ -22,23 +22,20 @@
     "files": [
         "dist"
     ],
-    "directories": {
-        "lib": "src"
-    },
+    "sideEffects": false,
     "scripts": {
         "version:place": "node set-version.js set-ci-version",
         "version:check": "node set-version.js check-placeholder",
         "version:fix": "node set-version.js fix-placeholder",
         "lint": "eslint . --ext .ts,.tsx,.js,.cjs,.mjs",
         "lint:fix": "eslint . --ext .ts,.tsx,.js,.cjs,.mjs --fix",
-        "lint:types": "eslint . --config eslint.config.typeaware.cjs --ext .ts,.tsx",
         "format": "prettier --write .",
         "format:check": "prettier --check .",
-        "typecheck": "tsc --noEmit",
+        "typecheck": "tsc --noEmit --declaration --isolatedDeclarations",
         "test": "jest --runInBand",
-        "check": "npm run version:check && npm run format:check && npm run lint && npm run lint:types && npm run typecheck && npm run test",
+        "check": "npm run version:check && npm run format:check && npm run lint && npm run typecheck && npm run test",
         "fix": "npm run version:fix && npm run format && npm run lint:fix",
-        "build": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\" && tsup && tsc -p tsconfig.build.json && node scripts/copy-dts.cjs",
+        "build": "tsup",
         "prepare": "husky"
     },
     "repository": {
@@ -70,46 +67,52 @@
         ]
     },
     "devDependencies": {
+        "@discordjs/opus": "^0.10.0",
         "@jest/globals": "^30.4.1",
         "@types/ejs": "^3.1.5",
-        "@types/node": "^26.0.0",
-        "@typescript-eslint/eslint-plugin": "^8.61.1",
-        "@typescript-eslint/parser": "^8.61.1",
-        "eslint": "^9.39.4",
+        "@types/node": "^24.0.0",
+        "@typescript-eslint/eslint-plugin": "^8.67.0",
+        "@typescript-eslint/parser": "^8.67.0",
+        "eslint": "^9.39.5",
         "eslint-config-prettier": "^10.1.8",
         "eslint-import-resolver-typescript": "^4.4.5",
         "eslint-plugin-import": "^2.32.0",
-        "eslint-plugin-n": "^18.1.0",
+        "eslint-plugin-n": "^18.3.0",
         "eslint-plugin-promise": "^7.3.0",
         "eslint-plugin-unused-imports": "^4.4.1",
         "husky": "^9.1.7",
         "jest": "^30.4.2",
-        "prettier": "^3.8.4",
-        "ts-jest": "^29.4.11",
+        "prettier": "^3.9.6",
+        "ts-jest": "^29.4.12",
         "tsup": "^8.5.1",
-        "typescript": "^6.0.3"
+        "@typescript/native": "npm:typescript@^7.0.2",
+        "typescript": "npm:@typescript/typescript6@^6.0.2"
     },
     "peerDependencies": {
+        "@discordjs/opus": "^0.10.0",
         "@discordjs/voice": "^0.19.2",
-        "@snazzah/davey": "^0.1.12",
         "ffmpeg-static": "^5.3.0",
-        "libsodium-wrappers": "^0.8.4",
-        "opusscript": "^0.0.8",
-        "prism-media": "^1.3.5"
+        "opusscript": "^0.0.8"
     },
     "peerDependenciesMeta": {
+        "@discordjs/opus": {
+            "optional": true
+        },
         "ffmpeg-static": {
             "optional": true
         },
-        "libsodium-wrappers": {
+        "opusscript": {
             "optional": true
         }
     },
     "overrides": {
-        "esbuild": "^0.28.1"
+        "@discordjs/node-pre-gyp": {
+            "tar": "^7.5.22"
+        },
+        "esbuild": "^0.28.2"
     },
     "engines": {
-        "node": ">=22.22.3"
+        "node": "24.x"
     },
     "private": false,
     "publishConfig": {

scripts/copy-dts.cjs

@@ -1,11 +0,0 @@
-const { copyFileSync, existsSync } = require('node:fs');
-const { join } = require('node:path');
-
-const declarationFile = join(__dirname, '..', 'dist', 'index.d.ts');
-const esmDeclarationFile = join(__dirname, '..', 'dist', 'index.d.mts');
-
-if (!existsSync(declarationFile)) {
-    throw new Error(`Missing declaration file: ${declarationFile}`);
-}
-
-copyFileSync(declarationFile, esmDeclarationFile);

src/audio-manager.ts

@@ -4,6 +4,7 @@ import {
     createAudioResource,
     entersState,
     joinVoiceChannel,
+    AudioPlayerStatus,
     NoSubscriberBehavior,
     StreamType,
     VoiceConnectionStatus,
@@ -21,14 +22,30 @@ import type {
 } from './types';
 
 const DEFAULT_CONNECT_TIMEOUT_MS = 20_000;
-const DEFAULT_RENEW_INTERVAL_MS = 5_400_000;
+const DISCONNECT_RECOVERY_TIMEOUT_MS = 5_000;
+const MAX_TIMER_DELAY_MS = 2_147_483_647;
 
-export default class AudioManager {
+function assertValidTimerDelay(value: number, optionName: string): void {
+    if (!Number.isSafeInteger(value) || value <= 0 || value > MAX_TIMER_DELAY_MS) {
+        throw new AudioManagerConfigError(
+            `${optionName} must be an integer between 1 and ${MAX_TIMER_DELAY_MS} milliseconds.`,
+        );
+    }
+}
+
+function assertValidVolumePercent(value: number): void {
+    if (!Number.isFinite(value) || value < 0 || value > 100) {
+        throw new AudioManagerConfigError('Volume must be between 0 and 100 percent.');
+    }
+}
+
+export default class AudioManager implements Disposable {
     private readonly audioPlayer: AudioPlayer;
 
     private connection: VoiceConnection | undefined;
     private resource: AudioResource | undefined;
     private ffmpeg: FfmpegProcessHandle | undefined;
+    private connectAttempt: AbortController | undefined;
     private renewTimer: NodeJS.Timeout | undefined;
     private playbackState: PlaybackState = 'idle';
     private connectionOptions: VoiceConnectionOptions | undefined;
@@ -37,9 +54,23 @@ export default class AudioManager {
         Omit<AudioManagerOptions, 'connectTimeoutMs'>;
 
     public constructor(options: AudioManagerOptions = {}) {
+        const connectTimeoutMs = options.connectTimeoutMs ?? DEFAULT_CONNECT_TIMEOUT_MS;
+        assertValidTimerDelay(connectTimeoutMs, 'connectTimeoutMs');
+
+        if (typeof options.renewIntervalMs === 'number') {
+            assertValidTimerDelay(options.renewIntervalMs, 'renewIntervalMs');
+        }
+
+        if (options.volume?.initialPercent !== undefined) {
+            if (options.volume.enabled !== true) {
+                throw new AudioManagerConfigError('volume.initialPercent requires volume.enabled to be true.');
+            }
+            assertValidVolumePercent(options.volume.initialPercent);
+        }
+
         this.options = {
             ...options,
-            connectTimeoutMs: options.connectTimeoutMs ?? DEFAULT_CONNECT_TIMEOUT_MS,
+            connectTimeoutMs,
         };
         this.connectionOptions = options.connection;
         this.audioSource = options.source;
@@ -48,6 +79,15 @@ export default class AudioManager {
                 noSubscriber: NoSubscriberBehavior.Play,
             },
         });
+        this.audioPlayer.on('error', (error) => {
+            this.finishPlayback(error.resource);
+            this.reportError(error);
+        });
+        this.audioPlayer.on(AudioPlayerStatus.Idle, (oldState) => {
+            if ('resource' in oldState) {
+                this.finishPlayback(oldState.resource);
+            }
+        });
     }
 
     public get state(): PlaybackState {
@@ -59,7 +99,7 @@ export default class AudioManager {
     }
 
     public get isConnected(): boolean {
-        return Boolean(this.connection);
+        return this.connection?.state.status === VoiceConnectionStatus.Ready;
     }
 
     public setConnection(options: VoiceConnectionOptions): void {
@@ -79,30 +119,55 @@ export default class AudioManager {
             throw new AudioManagerConfigError('Voice connection options are required before connecting.');
         }
 
+        this.cancelConnectAttempt();
+        const attempt = new AbortController();
+        this.connectAttempt = attempt;
         this.clearRenewTimer();
         this.playbackState = 'connecting';
-        this.connection?.destroy();
-        const connection = joinVoiceChannel({
+
+        const previousConnection = this.connection;
+        this.connection = undefined;
+        let connection: VoiceConnection | undefined;
+
+        try {
+            previousConnection?.destroy();
+            connection = joinVoiceChannel({
                 guildId: this.connectionOptions.guildId,
                 channelId: this.connectionOptions.channelId,
                 adapterCreator: this.connectionOptions.adapterCreator,
             });
             this.connection = connection;
+            this.observeConnection(connection);
             connection.subscribe(this.audioPlayer);
 
-        try {
-            await entersState(connection, VoiceConnectionStatus.Ready, this.options.connectTimeoutMs);
+            await entersState(
+                connection,
+                VoiceConnectionStatus.Ready,
+                AbortSignal.any([attempt.signal, AbortSignal.timeout(this.options.connectTimeoutMs)]),
+            );
         } catch (error) {
+            if (this.connectAttempt !== attempt) {
+                throw new AudioManagerStateError('Voice connection was stopped before it became ready.', {
+                    cause: error,
+                });
+            }
+
+            this.connectAttempt = undefined;
+            if (connection && connection.state.status !== VoiceConnectionStatus.Destroyed) {
                 connection.destroy();
+            }
             if (this.connection === connection) {
                 this.connection = undefined;
             }
             this.playbackState = 'stopped';
             throw error;
         }
-        if (this.connection !== connection) {
+
+        if (this.connectAttempt !== attempt || this.connection !== connection) {
             throw new AudioManagerStateError('Voice connection was stopped before it became ready.');
         }
+
+        this.connectAttempt = undefined;
         this.playbackState = 'ready';
         this.scheduleRenewal();
     }
@@ -114,7 +179,7 @@ export default class AudioManager {
             this.setSource(source);
         }
 
-        if (!this.connection) {
+        if (!this.isConnected) {
             throw new AudioManagerStateError('A voice connection is required before audio can be played.');
         }
 
@@ -132,17 +197,22 @@ export default class AudioManager {
                 inlineVolume: this.options.volume?.enabled === true,
             });
         } catch (error) {
-            if (this.ffmpeg === ffmpeg) {
-                this.stopCurrentPlayback();
+            if (this.ffmpeg !== ffmpeg) {
+                throw error instanceof AudioManagerStateError
+                    ? error
+                    : new AudioManagerStateError('Playback was stopped before ffmpeg became ready.', {
+                          cause: error,
+                      });
             }
+
+            this.stopCurrentPlayback();
             throw error;
         }
 
+        try {
             if (this.options.volume?.enabled === true && this.options.volume.initialPercent !== undefined) {
                 this.setVolume(this.options.volume.initialPercent);
             }
-
-        try {
             this.audioPlayer.play(this.resource);
             this.playbackState = 'playing';
         } catch (error) {
@@ -184,6 +254,7 @@ export default class AudioManager {
             return;
         }
 
+        this.cancelConnectAttempt();
         this.clearRenewTimer();
         this.stopCurrentPlayback();
         this.audioPlayer.stop(true);
@@ -200,9 +271,7 @@ export default class AudioManager {
             throw new AudioManagerStateError('Volume control requires volume.enabled to be true.');
         }
 
-        if (!Number.isFinite(volumeInPercent) || volumeInPercent < 0 || volumeInPercent > 100) {
-            throw new AudioManagerConfigError('Volume must be between 0 and 100 percent.');
-        }
+        assertValidVolumePercent(volumeInPercent);
 
         if (!this.resource?.volume) {
             throw new AudioManagerStateError('No audio resource with volume control is currently active.');
@@ -216,6 +285,7 @@ export default class AudioManager {
             return;
         }
 
+        this.cancelConnectAttempt();
         this.clearRenewTimer();
         this.stopCurrentPlayback();
         this.audioPlayer.stop(true);
@@ -226,6 +296,10 @@ export default class AudioManager {
         this.playbackState = 'disposed';
     }
 
+    public [Symbol.dispose](): void {
+        this.dispose();
+    }
+
     private resolveSource(): ResolvedAudioSource {
         if (!this.audioSource) {
             throw new AudioManagerConfigError('Audio source is required before playback can start.');
@@ -238,7 +312,7 @@ export default class AudioManager {
                     source: this.audioSource,
                 };
             } catch (error) {
-                throw new AudioManagerConfigError(`Invalid audio source URL. Cause: ${String(error)}`);
+                throw new AudioManagerConfigError('Invalid audio source URL.', { cause: error });
             }
         }
 
@@ -251,14 +325,18 @@ export default class AudioManager {
     }
 
     private scheduleRenewal(): void {
-        const renewIntervalMs = this.options.renewIntervalMs ?? DEFAULT_RENEW_INTERVAL_MS;
+        const renewIntervalMs = this.options.renewIntervalMs;
 
-        if (renewIntervalMs === false) {
+        if (renewIntervalMs === undefined || renewIntervalMs === false) {
             return;
         }
 
         this.renewTimer = setTimeout(() => {
-            void this.start().catch(() => {
+            void this.start().catch((error: unknown) => {
+                if (this.playbackState === 'disposed') {
+                    return;
+                }
+
                 this.clearRenewTimer();
                 this.stopCurrentPlayback();
                 this.audioPlayer.stop(true);
@@ -266,6 +344,7 @@ export default class AudioManager {
                 this.connection?.destroy();
                 this.connection = undefined;
                 this.playbackState = 'stopped';
+                this.reportError(error);
             });
         }, renewIntervalMs);
 
@@ -274,6 +353,51 @@ export default class AudioManager {
         }
     }
 
+    private observeConnection(connection: VoiceConnection): void {
+        connection.on('error', (error) => {
+            this.reportError(error);
+        });
+        connection.on(VoiceConnectionStatus.Disconnected, () => this.handleDisconnectedConnection(connection));
+    }
+
+    private async handleDisconnectedConnection(connection: VoiceConnection): Promise<void> {
+        try {
+            await Promise.race([
+                entersState(connection, VoiceConnectionStatus.Signalling, DISCONNECT_RECOVERY_TIMEOUT_MS),
+                entersState(connection, VoiceConnectionStatus.Connecting, DISCONNECT_RECOVERY_TIMEOUT_MS),
+            ]);
+        } catch (error) {
+            if (this.connection !== connection) {
+                return;
+            }
+
+            this.clearRenewTimer();
+            this.stopCurrentPlayback();
+            this.audioPlayer.stop(true);
+            this.connection = undefined;
+            if (connection.state.status !== VoiceConnectionStatus.Destroyed) {
+                connection.destroy();
+            }
+            this.playbackState = 'stopped';
+            this.reportError(error);
+        }
+    }
+
+    private finishPlayback(resource: AudioResource): void {
+        if (this.resource !== resource) {
+            return;
+        }
+
+        this.stopCurrentPlayback();
+        if (this.playbackState !== 'disposed') {
+            this.playbackState = this.isConnected ? 'ready' : 'stopped';
+        }
+    }
+
+    private reportError(error: unknown): void {
+        this.options.onError?.(error instanceof Error ? error : new Error(String(error)));
+    }
+
     private clearRenewTimer(): void {
         if (this.renewTimer) {
             clearTimeout(this.renewTimer);
@@ -281,6 +405,11 @@ export default class AudioManager {
         }
     }
 
+    private cancelConnectAttempt(): void {
+        this.connectAttempt?.abort();
+        this.connectAttempt = undefined;
+    }
+
     private stopCurrentPlayback(): void {
         this.resource?.playStream.destroy();
         this.resource = undefined;

src/errors.ts

@@ -1,6 +1,6 @@
 export class AudioManagerError extends Error {
-    public constructor(message: string) {
-        super(message);
+    public constructor(message: string, options?: ErrorOptions) {
+        super(message, options);
         this.name = new.target.name;
     }
 }
@@ -10,10 +10,7 @@ export class AudioManagerConfigError extends AudioManagerError {}
 export class AudioManagerStateError extends AudioManagerError {}
 
 export class FfmpegProcessError extends AudioManagerError {
-    public constructor(
-        message: string,
-        public readonly cause?: unknown,
-    ) {
-        super(message);
+    public constructor(message: string, cause?: unknown) {
+        super(message, cause === undefined ? undefined : { cause });
     }
 }

src/ffmpeg.ts

@@ -14,8 +14,8 @@ const FORCE_KILL_TIMEOUT_MS = 2_000;
 const STDERR_TAIL_BYTES = 4_096;
 
 export type FfmpegProcessHandle = {
-    process: ChildProcessByStdio<null, Readable, Readable>;
-    ready: Promise<void>;
+    readonly process: ChildProcessByStdio<null, Readable, Readable>;
+    readonly ready: Promise<void>;
     stop(): void;
 };
 
@@ -36,7 +36,8 @@ export function resolveFfmpegExecutable(options: FfmpegOptions = {}): string {
         }
     } catch (error) {
         throw new AudioManagerConfigError(
-            `Unable to resolve ffmpeg-static. Install it or pass ffmpeg.executablePath. Cause: ${String(error)}`,
+            'Unable to resolve ffmpeg-static. Install it or pass ffmpeg.executablePath.',
+            { cause: error },
         );
     }
 
@@ -52,7 +53,8 @@ export function startFfmpeg(input: string, options: FfmpegOptions = {}): FfmpegP
         ...(options.outputArgs ?? DEFAULT_OUTPUT_ARGS),
     ];
     const childProcess = spawn(executable, args, { stdio: ['ignore', 'pipe', 'pipe'] });
-    const ready = waitForFfmpegOutput(childProcess);
+    const abortController = new AbortController();
+    const ready = waitForFfmpegOutput(childProcess, abortController.signal);
 
     childProcess.stderr.resume();
 
@@ -60,49 +62,76 @@ export function startFfmpeg(input: string, options: FfmpegOptions = {}): FfmpegP
         process: childProcess,
         ready,
         stop: (): void => {
-            stopProcess(childProcess);
+            stopProcess(childProcess, abortController);
         },
     };
 }
 
-function waitForFfmpegOutput(childProcess: ChildProcessByStdio<null, Readable, Readable>): Promise<void> {
+function waitForFfmpegOutput(
+    childProcess: ChildProcessByStdio<null, Readable, Readable>,
+    signal: AbortSignal,
+): Promise<void> {
+    const { promise, resolve, reject } = Promise.withResolvers<void>();
     let stderrTail = '';
+    let settled = false;
 
     const appendStderr = (chunk: Buffer | string): void => {
         stderrTail = (stderrTail + String(chunk)).slice(-STDERR_TAIL_BYTES);
     };
 
-    childProcess.stderr.on('data', appendStderr);
-
-    return new Promise((resolve, reject) => {
     const cleanup = (): void => {
-            childProcess.off('error', onError);
         childProcess.off('exit', onExit);
         childProcess.stdout.off('readable', onReadable);
+        childProcess.stderr.off('data', appendStderr);
+        signal.removeEventListener('abort', onAbort);
+    };
+
+    const settle = (complete: () => void): void => {
+        if (settled) {
+            return;
+        }
+
+        settled = true;
+        cleanup();
+        complete();
     };
 
     const fail = (message: string, cause?: unknown): void => {
-            cleanup();
-            reject(new FfmpegProcessError(addStderrTail(message, stderrTail), cause));
+        settle(() => reject(new FfmpegProcessError(addStderrTail(message, stderrTail), cause)));
     };
 
     const onError = (error: Error): void => {
+        if (!settled) {
             fail(`Unable to start ffmpeg. Cause: ${error.message}`, error);
+        }
     };
 
-        const onExit = (code: number | null, signal: NodeJS.Signals | null): void => {
-            fail(`ffmpeg exited before producing audio. Exit code: ${code ?? 'none'}, signal: ${signal ?? 'none'}.`);
+    const onExit = (code: number | null, exitSignal: NodeJS.Signals | null): void => {
+        fail(`ffmpeg exited before producing audio. Exit code: ${code ?? 'none'}, signal: ${exitSignal ?? 'none'}.`);
     };
 
     const onReadable = (): void => {
-            cleanup();
-            resolve();
+        settle(() => resolve());
     };
 
-        childProcess.once('error', onError);
+    const onAbort = (): void => {
+        const reason: unknown = signal.reason;
+        settle(() =>
+            reject(
+                reason instanceof Error
+                    ? reason
+                    : new FfmpegProcessError('ffmpeg was stopped before producing audio.', reason),
+            ),
+        );
+    };
+
+    childProcess.stderr.on('data', appendStderr);
+    childProcess.on('error', onError);
     childProcess.once('exit', onExit);
     childProcess.stdout.once('readable', onReadable);
-    });
+    signal.addEventListener('abort', onAbort, { once: true });
+
+    return promise;
 }
 
 function addStderrTail(message: string, stderrTail: string): string {
@@ -111,22 +140,30 @@ function addStderrTail(message: string, stderrTail: string): string {
     return trimmedTail ? `${message} stderr: ${trimmedTail}` : message;
 }
 
-function stopProcess(childProcess: ChildProcessByStdio<null, Readable, Readable>): void {
+function stopProcess(
+    childProcess: ChildProcessByStdio<null, Readable, Readable>,
+    abortController: AbortController,
+): void {
+    if (abortController.signal.aborted) {
+        return;
+    }
+
+    abortController.abort(new FfmpegProcessError('ffmpeg was stopped before producing audio.'));
     childProcess.stdout.destroy();
     childProcess.stderr.destroy();
-    childProcess.removeAllListeners();
 
-    if (childProcess.killed || childProcess.exitCode !== null || childProcess.signalCode !== null) {
+    if (childProcess.exitCode !== null || childProcess.signalCode !== null) {
         return;
     }
 
     childProcess.kill('SIGTERM');
 
     const forceKillTimeout = setTimeout(() => {
-        if (!childProcess.killed && childProcess.exitCode === null && childProcess.signalCode === null) {
+        if (childProcess.exitCode === null && childProcess.signalCode === null) {
             childProcess.kill('SIGKILL');
         }
     }, FORCE_KILL_TIMEOUT_MS);
 
+    childProcess.once('close', () => clearTimeout(forceKillTimeout));
     forceKillTimeout.unref();
 }

src/types.ts

@@ -143,9 +143,9 @@ export type AudioManagerOptions = {
     /**
      * Milliseconds after which the manager reconnects and restarts playback.
      *
-     * Set to `false` to disable renewal.
+     * Renewal is disabled unless an interval is provided.
      *
-     * @defaultValue `5_400_000`
+     * @defaultValue `false`
      */
     renewIntervalMs?: number | false;
 
@@ -156,6 +156,11 @@ export type AudioManagerOptions = {
      */
     connectTimeoutMs?: number;
 
+    /**
+     * Receives asynchronous audio player and voice connection errors.
+     */
+    onError?: (error: Error) => void;
+
     /**
      * Optional inline volume configuration.
      */

tests/audio-manager.test.ts

@@ -1,5 +1,12 @@
 import { jest, describe, beforeEach, afterEach, it, expect } from '@jest/globals';
-import { createAudioResource, entersState, joinVoiceChannel } from '@discordjs/voice';
+import {
+    AudioPlayerStatus,
+    createAudioPlayer,
+    createAudioResource,
+    entersState,
+    joinVoiceChannel,
+    VoiceConnectionStatus,
+} from '@discordjs/voice';
 import { resolve } from 'node:path';
 import { PassThrough } from 'node:stream';
 
@@ -10,18 +17,37 @@ import type { FfmpegProcessHandle } from '../src/ffmpeg';
 import type { AudioSource, VoiceConnectionOptions } from '../src';
 import type { VoiceConnection } from '@discordjs/voice';
 
+type MockListener = (...args: unknown[]) => unknown;
+
+const audioPlayerListeners = new Map<string, MockListener>();
+const connectionListeners = new Map<string, MockListener>();
+const secondConnectionListeners = new Map<string, MockListener>();
 const mockAudioPlayer = {
+    on: jest.fn((event: string, listener: MockListener) => {
+        audioPlayerListeners.set(event, listener);
+        return mockAudioPlayer;
+    }),
     play: jest.fn(),
     pause: jest.fn(),
     unpause: jest.fn(),
     stop: jest.fn(),
 };
 const mockConnection = {
+    state: { status: 'ready' },
+    on: jest.fn((event: string, listener: MockListener) => {
+        connectionListeners.set(event, listener);
+        return mockConnection;
+    }),
     subscribe: jest.fn(),
     disconnect: jest.fn(),
     destroy: jest.fn(),
 };
 const mockSecondConnection = {
+    state: { status: 'ready' },
+    on: jest.fn((event: string, listener: MockListener) => {
+        secondConnectionListeners.set(event, listener);
+        return mockSecondConnection;
+    }),
     subscribe: jest.fn(),
     disconnect: jest.fn(),
     destroy: jest.fn(),
@@ -45,6 +71,9 @@ const mockFfmpegHandle: FfmpegProcessHandle = {
 };
 
 jest.mock('@discordjs/voice', () => ({
+    AudioPlayerStatus: {
+        Idle: 'idle',
+    },
     NoSubscriberBehavior: {
         Play: 'play',
     },
@@ -52,7 +81,11 @@ jest.mock('@discordjs/voice', () => ({
         Raw: 'raw',
     },
     VoiceConnectionStatus: {
+        Connecting: 'connecting',
+        Destroyed: 'destroyed',
+        Disconnected: 'disconnected',
         Ready: 'ready',
+        Signalling: 'signalling',
     },
     createAudioPlayer: jest.fn(() => mockAudioPlayer),
     createAudioResource: jest.fn(() => mockAudioResource),
@@ -79,15 +112,6 @@ const fileSourcePath = 'tests/audio.mp3';
 const resolvedFileSourcePath = resolve(process.cwd(), fileSourcePath);
 type MockedEntersStateReturn = ReturnType<typeof entersState>;
 
-function deferred<T>(): { promise: Promise<T>; resolve: (value: T) => void } {
-    let resolve!: (value: T) => void;
-    const promise = new Promise<T>((promiseResolve) => {
-        resolve = promiseResolve;
-    });
-
-    return { promise, resolve };
-}
-
 function createMockFfmpegHandle(): FfmpegProcessHandle {
     return {
         process: {
@@ -98,9 +122,24 @@ function createMockFfmpegHandle(): FfmpegProcessHandle {
     };
 }
 
+function listenerFor(listeners: Map<string, MockListener>, event: string): MockListener {
+    const listener = listeners.get(event);
+
+    if (!listener) {
+        throw new Error(`No listener registered for ${event}.`);
+    }
+
+    return listener;
+}
+
 describe('AudioManager', () => {
     beforeEach(() => {
         jest.clearAllMocks();
+        audioPlayerListeners.clear();
+        connectionListeners.clear();
+        secondConnectionListeners.clear();
+        mockConnection.state.status = VoiceConnectionStatus.Ready;
+        mockSecondConnection.state.status = VoiceConnectionStatus.Ready;
     });
 
     afterEach(() => {
@@ -130,6 +169,72 @@ describe('AudioManager', () => {
         expect(mockAudioPlayer.play).toHaveBeenCalledWith(mockAudioResource);
     });
 
+    it('does not schedule connection renewal by default', async () => {
+        jest.useFakeTimers();
+        const manager = new AudioManager({ connection: connectionOptions });
+
+        await manager.connect();
+
+        expect(jest.getTimerCount()).toBe(0);
+        manager.dispose();
+    });
+
+    it('reports voice connection errors without interrupting playback', async () => {
+        const connectionError = new Error('voice connection failed');
+        const onError = jest.fn();
+        const manager = new AudioManager({
+            connection: connectionOptions,
+            source: liveStreamSource,
+            renewIntervalMs: false,
+            onError,
+        });
+        await manager.start();
+
+        listenerFor(connectionListeners, 'error')(connectionError);
+
+        expect(onError).toHaveBeenCalledWith(connectionError);
+        expect(manager.state).toBe('playing');
+    });
+
+    it('keeps playback while a disconnected voice connection recovers', async () => {
+        const manager = new AudioManager({
+            connection: connectionOptions,
+            source: liveStreamSource,
+            renewIntervalMs: false,
+        });
+        await manager.start();
+
+        await listenerFor(connectionListeners, VoiceConnectionStatus.Disconnected)();
+
+        expect(entersState).toHaveBeenCalledWith(mockVoiceConnection, VoiceConnectionStatus.Signalling, 5_000);
+        expect(entersState).toHaveBeenCalledWith(mockVoiceConnection, VoiceConnectionStatus.Connecting, 5_000);
+        expect(mockConnection.destroy).not.toHaveBeenCalled();
+        expect(manager.state).toBe('playing');
+    });
+
+    it('stops playback after an unrecoverable voice disconnect', async () => {
+        const disconnectError = new Error('voice connection did not recover');
+        const onError = jest.fn();
+        const manager = new AudioManager({
+            connection: connectionOptions,
+            source: liveStreamSource,
+            renewIntervalMs: false,
+            onError,
+        });
+        await manager.start();
+        jest.mocked(entersState).mockRejectedValueOnce(disconnectError).mockRejectedValueOnce(disconnectError);
+        mockConnection.state.status = VoiceConnectionStatus.Disconnected;
+
+        await listenerFor(connectionListeners, VoiceConnectionStatus.Disconnected)();
+
+        expect(mockFfmpegHandle.stop).toHaveBeenCalledTimes(1);
+        expect(mockAudioPlayer.stop).toHaveBeenCalledWith(true);
+        expect(mockConnection.destroy).toHaveBeenCalledTimes(1);
+        expect(onError).toHaveBeenCalledWith(disconnectError);
+        expect(manager.state).toBe('stopped');
+        expect(manager.isConnected).toBe(false);
+    });
+
     it('cleans up when connection startup fails', async () => {
         jest.useFakeTimers();
 
@@ -148,9 +253,22 @@ describe('AudioManager', () => {
         expect(jest.getTimerCount()).toBe(0);
     });
 
+    it('restores the stopped state when voice setup throws synchronously', async () => {
+        const connectionError = new Error('voice setup failed');
+        jest.mocked(joinVoiceChannel).mockImplementationOnce(() => {
+            throw connectionError;
+        });
+        const manager = new AudioManager({ connection: connectionOptions, renewIntervalMs: false });
+
+        await expect(manager.connect()).rejects.toBe(connectionError);
+
+        expect(manager.state).toBe('stopped');
+        expect(manager.isConnected).toBe(false);
+    });
+
     it('does not become ready when stopped during connection startup', async () => {
         jest.useFakeTimers();
-        const ready = deferred<VoiceConnection>();
+        const ready = Promise.withResolvers<VoiceConnection>();
         jest.mocked(entersState).mockReturnValueOnce(ready.promise as unknown as MockedEntersStateReturn);
         const manager = new AudioManager({
             connection: connectionOptions,
@@ -168,9 +286,9 @@ describe('AudioManager', () => {
         expect(jest.getTimerCount()).toBe(0);
     });
 
-    it('keeps the latest connection when concurrent connects resolve out of order', async () => {
-        const firstReady = deferred<VoiceConnection>();
-        const secondReady = deferred<VoiceConnection>();
+    it('keeps the latest connection when a stale connection attempt rejects', async () => {
+        const firstReady = Promise.withResolvers<VoiceConnection>();
+        const secondReady = Promise.withResolvers<VoiceConnection>();
         jest.mocked(joinVoiceChannel)
             .mockReturnValueOnce(mockVoiceConnection)
             .mockReturnValueOnce(mockSecondVoiceConnection);
@@ -184,7 +302,7 @@ describe('AudioManager', () => {
 
         const firstConnect = manager.connect();
         const secondConnect = manager.connect();
-        firstReady.resolve(mockVoiceConnection);
+        firstReady.reject(new Error('stale connection failed'));
         secondReady.resolve(mockSecondVoiceConnection);
 
         await expect(firstConnect).rejects.toThrow(AudioManagerStateError);
@@ -197,7 +315,7 @@ describe('AudioManager', () => {
     });
 
     it('does not become ready when disposed during connection startup', async () => {
-        const ready = deferred<VoiceConnection>();
+        const ready = Promise.withResolvers<VoiceConnection>();
         jest.mocked(entersState).mockReturnValueOnce(ready.promise as unknown as MockedEntersStateReturn);
         const manager = new AudioManager({
             connection: connectionOptions,
@@ -206,7 +324,7 @@ describe('AudioManager', () => {
 
         const connectPromise = manager.connect();
         manager.dispose();
-        ready.resolve(mockVoiceConnection);
+        ready.reject(new Error('disposed connection failed'));
 
         await expect(connectPromise).rejects.toThrow(AudioManagerStateError);
 
@@ -318,8 +436,44 @@ describe('AudioManager', () => {
         expect(mockAudioResource.playStream.destroy).toHaveBeenCalledTimes(1);
     });
 
+    it('cleans up and reports asynchronous audio player errors', async () => {
+        const playerError = Object.assign(new Error('audio stream failed'), { resource: mockAudioResource });
+        const onError = jest.fn();
+        const manager = new AudioManager({
+            connection: connectionOptions,
+            source: liveStreamSource,
+            renewIntervalMs: false,
+            onError,
+        });
+        await manager.start();
+
+        listenerFor(audioPlayerListeners, 'error')(playerError);
+
+        expect(mockFfmpegHandle.stop).toHaveBeenCalledTimes(1);
+        expect(mockAudioResource.playStream.destroy).toHaveBeenCalledTimes(1);
+        expect(onError).toHaveBeenCalledWith(playerError);
+        expect(manager.state).toBe('ready');
+        expect(manager.isPlaying).toBe(false);
+    });
+
+    it('returns to ready when the current audio resource becomes idle', async () => {
+        const manager = new AudioManager({
+            connection: connectionOptions,
+            source: liveStreamSource,
+            renewIntervalMs: false,
+        });
+        await manager.start();
+
+        listenerFor(audioPlayerListeners, AudioPlayerStatus.Idle)({ resource: mockAudioResource });
+
+        expect(mockFfmpegHandle.stop).toHaveBeenCalledTimes(1);
+        expect(mockAudioResource.playStream.destroy).toHaveBeenCalledTimes(1);
+        expect(manager.state).toBe('ready');
+        expect(manager.isPlaying).toBe(false);
+    });
+
     it('does not report playback when stopped before ffmpeg is ready', async () => {
-        const ready = deferred<void>();
+        const ready = Promise.withResolvers<void>();
         jest.mocked(startFfmpeg).mockReturnValueOnce({
             ...mockFfmpegHandle,
             ready: ready.promise,
@@ -342,7 +496,7 @@ describe('AudioManager', () => {
     });
 
     it('does not report playback when disposed before ffmpeg is ready', async () => {
-        const ready = deferred<void>();
+        const ready = Promise.withResolvers<void>();
         jest.mocked(startFfmpeg).mockReturnValueOnce({
             ...mockFfmpegHandle,
             ready: ready.promise,
@@ -365,7 +519,7 @@ describe('AudioManager', () => {
     });
 
     it('keeps only the latest concurrent playback', async () => {
-        const firstReady = deferred<void>();
+        const firstReady = Promise.withResolvers<void>();
         const firstHandle = {
             ...createMockFfmpegHandle(),
             ready: firstReady.promise,
@@ -461,6 +615,36 @@ describe('AudioManager', () => {
         expect(mockAudioResource.volume.setVolume).toHaveBeenCalledWith(0.35);
     });
 
+    it('rejects invalid initial volume before allocating audio resources', () => {
+        expect(
+            () =>
+                new AudioManager({
+                    volume: {
+                        enabled: true,
+                        initialPercent: 101,
+                    },
+                }),
+        ).toThrow(AudioManagerConfigError);
+        expect(
+            () =>
+                new AudioManager({
+                    volume: {
+                        enabled: false,
+                        initialPercent: 50,
+                    },
+                }),
+        ).toThrow(AudioManagerConfigError);
+
+        expect(createAudioPlayer).not.toHaveBeenCalled();
+        expect(createAudioResource).not.toHaveBeenCalled();
+        expect(startFfmpeg).not.toHaveBeenCalled();
+    });
+
+    it('rejects timer delays that Node.js cannot schedule safely', () => {
+        expect(() => new AudioManager({ connectTimeoutMs: 0 })).toThrow(AudioManagerConfigError);
+        expect(() => new AudioManager({ renewIntervalMs: 2_147_483_648 })).toThrow(AudioManagerConfigError);
+    });
+
     it('rejects volume changes when inline volume is disabled', () => {
         const manager = new AudioManager({ renewIntervalMs: false });
 
@@ -617,6 +801,15 @@ describe('AudioManager', () => {
         expect(() => manager.setConnection(connectionOptions)).toThrow(AudioManagerStateError);
     });
 
+    it('supports explicit resource management', () => {
+        const manager = (() => {
+            using disposableManager = new AudioManager({ renewIntervalMs: false });
+            return disposableManager;
+        })();
+
+        expect(manager.state).toBe('disposed');
+    });
+
     it('prevents use after disposal', async () => {
         const manager = new AudioManager({
             connection: connectionOptions,

tests/ffmpeg.test.ts

@@ -20,11 +20,12 @@ type MockChildProcess = {
     stderr: {
         destroy: jest.Mock;
         on: jest.Mock;
+        off: jest.Mock;
         resume: jest.Mock;
     };
+    on: jest.Mock;
     once: jest.Mock;
     off: jest.Mock;
-    removeAllListeners: jest.Mock;
     kill: jest.Mock;
     killed: boolean;
     exitCode: number | null;
@@ -41,11 +42,12 @@ function createMockChildProcess(): MockChildProcess {
         stderr: {
             destroy: jest.fn(),
             on: jest.fn(),
+            off: jest.fn(),
             resume: jest.fn(),
         },
+        on: jest.fn(),
         once: jest.fn(),
         off: jest.fn(),
-        removeAllListeners: jest.fn(),
         kill: jest.fn(),
         killed: false,
         exitCode: null,
@@ -61,6 +63,10 @@ function getProcessHandler(childProcess: MockChildProcess, eventName: string): (
     return childProcess.once.mock.calls.find(([event]) => event === eventName)?.[1] as (...args: unknown[]) => void;
 }
 
+function getPersistentProcessHandler(childProcess: MockChildProcess, eventName: string): (...args: unknown[]) => void {
+    return childProcess.on.mock.calls.find(([event]) => event === eventName)?.[1] as (...args: unknown[]) => void;
+}
+
 function getStdoutHandler(childProcess: MockChildProcess, eventName: string): (...args: unknown[]) => void {
     return childProcess.stdout.once.mock.calls.find(([event]) => event === eventName)?.[1] as (
         ...args: unknown[]
@@ -117,7 +123,7 @@ describe('ffmpeg helpers', () => {
             ],
             { stdio: ['ignore', 'pipe', 'pipe'] },
         );
-        expect(childProcess.once).toHaveBeenCalledWith('error', expect.any(Function));
+        expect(childProcess.on).toHaveBeenCalledWith('error', expect.any(Function));
         expect(childProcess.once).toHaveBeenCalledWith('exit', expect.any(Function));
         expect(childProcess.stdout.once).toHaveBeenCalledWith('readable', expect.any(Function));
         expect(childProcess.stderr.on).toHaveBeenCalledWith('data', expect.any(Function));
@@ -129,12 +135,16 @@ describe('ffmpeg helpers', () => {
         mockSpawnReturn(childProcess);
 
         const handle = startFfmpeg('tests/audio.mp3');
-        const errorHandler = getProcessHandler(childProcess, 'error');
+        const errorHandler = getPersistentProcessHandler(childProcess, 'error');
+        const spawnError = new Error('spawn ENOENT');
 
-        errorHandler(new Error('spawn ENOENT'));
+        errorHandler(spawnError);
 
-        await expect(handle.ready).rejects.toThrow(FfmpegProcessError);
-        await expect(handle.ready).rejects.toThrow('spawn ENOENT');
+        await expect(handle.ready).rejects.toMatchObject({
+            cause: spawnError,
+            message: expect.stringContaining('spawn ENOENT'),
+            name: FfmpegProcessError.name,
+        });
     });
 
     it('includes stderr when ffmpeg exits before producing audio', async () => {
@@ -172,8 +182,10 @@ describe('ffmpeg helpers', () => {
         const handle = startFfmpeg('tests/audio.mp3');
         const readableHandler = getStdoutHandler(childProcess, 'readable');
         const exitHandler = getProcessHandler(childProcess, 'exit');
+        const errorHandler = getPersistentProcessHandler(childProcess, 'error');
 
         readableHandler();
+        errorHandler(new Error('late process error'));
         exitHandler(1, null);
 
         await expect(handle.ready).resolves.toBeUndefined();
@@ -196,17 +208,22 @@ describe('ffmpeg helpers', () => {
         );
     });
 
-    it('stops a running child process and schedules a force kill fallback', () => {
+    it('stops a running child process and schedules a force kill fallback', async () => {
         jest.useFakeTimers();
         const childProcess = createMockChildProcess();
+        childProcess.kill.mockImplementation(() => {
+            childProcess.killed = true;
+            return true;
+        });
         mockSpawnReturn(childProcess);
 
         const handle = startFfmpeg('tests/audio.mp3');
+        const readyExpectation = expect(handle.ready).rejects.toThrow('stopped before producing audio');
         handle.stop();
 
+        await readyExpectation;
         expect(childProcess.stdout.destroy).toHaveBeenCalledTimes(1);
         expect(childProcess.stderr.destroy).toHaveBeenCalledTimes(1);
-        expect(childProcess.removeAllListeners).toHaveBeenCalledTimes(1);
         expect(childProcess.kill).toHaveBeenCalledWith('SIGTERM');
 
         jest.advanceTimersByTime(2_000);
@@ -214,14 +231,16 @@ describe('ffmpeg helpers', () => {
         expect(childProcess.kill).toHaveBeenNthCalledWith(2, 'SIGKILL');
     });
 
-    it('does not signal a process that already exited', () => {
+    it('does not signal a process that already exited', async () => {
         const childProcess = createMockChildProcess();
         childProcess.exitCode = 0;
         mockSpawnReturn(childProcess);
 
         const handle = startFfmpeg('tests/audio.mp3');
+        const readyExpectation = expect(handle.ready).rejects.toThrow('stopped before producing audio');
         handle.stop();
 
+        await readyExpectation;
         expect(childProcess.kill).not.toHaveBeenCalled();
     });
 });

tsconfig.build.json

@@ -1,10 +0,0 @@
-{
-    "extends": "./tsconfig.json",
-    "compilerOptions": {
-        "declaration": true,
-        "declarationMap": false,
-        "emitDeclarationOnly": true,
-        "rootDir": "./src"
-    },
-    "include": ["src/**/*.ts"]
-}

tsconfig.eslint.json

@@ -1,4 +1,7 @@
 {
     "extends": "./tsconfig.json",
+    "compilerOptions": {
+        "skipLibCheck": true
+    },
     "include": ["src/**/*.ts", "tests/**/*.ts", "tsup.config.ts"]
 }

tsconfig.json

@@ -1,31 +1,22 @@
 {
     "compilerOptions": {
-        "target": "ES2022",
-        "lib": ["ES2022"],
-        "module": "Node16",
-        "moduleResolution": "node16",
-        "resolveJsonModule": true,
+        "target": "ES2024",
+        "lib": ["ES2024"],
+        "module": "Node20",
         "types": [],
         "rootDir": "./",
         "outDir": "./dist",
         "esModuleInterop": true,
-        "allowSyntheticDefaultImports": true,
         "forceConsistentCasingInFileNames": true,
         "strict": true,
-        "noImplicitAny": true,
-        "strictNullChecks": true,
-        "strictFunctionTypes": true,
-        "strictBindCallApply": true,
-        "strictPropertyInitialization": true,
-        "alwaysStrict": true,
+        "isolatedModules": true,
+        "erasableSyntaxOnly": true,
         "noUnusedLocals": true,
         "noUnusedParameters": true,
         "noImplicitReturns": true,
         "noUncheckedIndexedAccess": true,
         "exactOptionalPropertyTypes": true,
         "noFallthroughCasesInSwitch": true,
-        "useUnknownInCatchVariables": true,
-        "skipLibCheck": true,
         "noEmitOnError": true
     },
     "include": ["src"],

tsconfig.test.json

@@ -1,8 +1,8 @@
 {
     "extends": "./tsconfig.json",
     "compilerOptions": {
-        "isolatedModules": true,
-        "outDir": "./dist-test"
+        "outDir": "./dist-test",
+        "skipLibCheck": true
     },
     "include": ["src/**/*.ts", "tests/**/*.ts", "tsup.config.ts"]
 }

tsup.config.ts

@@ -3,7 +3,12 @@ import { defineConfig } from 'tsup';
 export default defineConfig({
     format: ['cjs', 'esm'],
     entry: ['./src/index.ts'],
-    dts: false,
+    dts: {
+        compilerOptions: {
+            // tsup's declaration bundler still sets the removed baseUrl option internally.
+            ignoreDeprecations: '6.0',
+        },
+    },
     shims: true,
     skipNodeModulesBundle: true,
     clean: true,