ziplayer 0.3.2 → 0.3.3

package/dist/types/index.js

@@ -14,6 +14,12 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeTrackMiddleware = normalizeTrackMiddleware;
+function normalizeTrackMiddleware(input) {
+    if (!input)
+        return [];
+    return Array.isArray(input) ? input : [input];
+}
 __exportStar(require("./fillter"), exports);
 __exportStar(require("./plugin"), exports);
 __exportStar(require("./extension"), exports);

package/dist/types/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAiiBA,4CAA0B;AAC1B,2CAAyB;AACzB,8CAA4B"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AA4JA,4DAGC;AAHD,SAAgB,wBAAwB,CAAC,KAA2C;IACnF,IAAI,CAAC,KAAK;QAAE,OAAO,EAAE,CAAC;IACtB,OAAO,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;AAC/C,CAAC;AAgbD,4CAA0B;AAC1B,2CAAyB;AACzB,8CAA4B"}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "ziplayer",
-	"version": "0.3.2",
+	"version": "0.3.3",
 	"description": "A modular Discord voice player with plugin system",
 	"keywords": [
 		"ZiPlayer",

package/src/plugins/index.ts

@@ -848,7 +848,7 @@ export class PluginManager {
 			return [];
 		}
 
-		const history = this.player.queue.previousTracks;
+		const history = this.player?.queue?.previousTracks || [];
 		const historyUrls = new Set(history.map((t) => t.url));
 		const currentTrackUrl = track.url;
 

package/src/structures/Player.ts

@@ -16,22 +16,24 @@ import {
 import { Readable } from "stream";
 import { LRUCache } from "lru-cache";
 import type { BaseExtension } from "../extensions";
-import type {
-	Track,
-	PlayerOptions,
-	PlayerEvents,
-	SourcePlugin,
-	SearchResult,
-	ProgressBarOptions,
-	LoopMode,
-	StreamInfo,
-	SaveOptions,
-	VoiceChannel,
-	PlayerSession,
-	ExtensionPlayRequest,
-	ExtensionPlayResponse,
-	ExtensionAfterPlayPayload,
-	StreamSlot,
+import {
+	normalizeTrackMiddleware,
+	type Track,
+	type PlayerOptions,
+	type PlayerEvents,
+	type SourcePlugin,
+	type SearchResult,
+	type ProgressBarOptions,
+	type LoopMode,
+	type StreamInfo,
+	type SaveOptions,
+	type VoiceChannel,
+	type PlayerSession,
+	type ExtensionPlayRequest,
+	type ExtensionPlayResponse,
+	type ExtensionAfterPlayPayload,
+	type StreamSlot,
+	type TrackMiddleware,
 } from "../types";
 import type { PlayerManager } from "./PlayerManager";
 
@@ -96,6 +98,7 @@ export class Player extends EventEmitter {
 	public extensionManager: ExtensionManager;
 	public streamManager: StreamManager;
 	public preloadManager: PreloadManager;
+	public forwardMode: Boolean = false;
 
 	public userdata?: Record<string, any>;
 	public _lastActivity: number = Date.now();
@@ -154,6 +157,7 @@ export class Player extends EventEmitter {
 	private loudnessMaxCutDb = 10;
 	private loudnessLimiterCeiling = 0.95;
 	private destroyed = false;
+	private readonly trackMiddlewareChain: TrackMiddleware[];
 
 	// Cache for search results to avoid duplicate calls
 	private searchCache: LRUCache<string, SearchResult>;
@@ -247,6 +251,9 @@ export class Player extends EventEmitter {
 		this.debug(
 			`[Player] Runtime options resolved: lowPerformance=${this.lowPerformanceMode}, preload=${this.preloadEnabled}, crossfade=${this.crossfadeEnabled} (${this.crossfadeDurationMs}ms), smartTransition=${this.smartTransitionEnabled}, antiStuck=${this.antiStuckEnabled}, loudnessNormalization=${this.loudnessNormalizationEnabled}`,
 		);
+
+		this.trackMiddlewareChain = [...this.manager.getTrackMiddlewareChain(), ...normalizeTrackMiddleware(options.trackMiddleware)];
+
 		this.filter = new FilterManager(this, this.manager);
 		this.extensionManager = new ExtensionManager(this, this.manager);
 		this.pluginManager = new PluginManager(this, this.manager, {
@@ -906,10 +913,36 @@ export class Player extends EventEmitter {
 		}
 	}
 
+	private mergeTrackPreserveRef(target: Track, source: Track): void {
+		if (source === target) return;
+		const mergedMeta = {
+			...(target.metadata || {}),
+			...(source.metadata || {}),
+		};
+		Object.assign(target, source);
+		target.metadata = mergedMeta;
+	}
+
+	private async applyTrackMiddleware(track: Track): Promise<void> {
+		if (this.trackMiddlewareChain.length === 0) return;
+		const ctx = { player: this, manager: this.manager };
+		for (const mw of this.trackMiddlewareChain) {
+			try {
+				const out = await mw(track, ctx);
+				if (out != null && out !== track) {
+					this.mergeTrackPreserveRef(track, out);
+				}
+			} catch (err) {
+				this.debug(`[TrackMiddleware] Error:`, err);
+			}
+		}
+	}
+
 	private async getStream(track: Track): Promise<StreamInfo | null> {
 		if (this.destroyed) {
 			throw new Error("PLAYER_DESTROYED");
 		}
+		await this.applyTrackMiddleware(track);
 		const trackId = track.id || track.url || track.title;
 		const existingStream = this.streamManager.getStreamByTrack(trackId);
 
@@ -1263,6 +1296,8 @@ export class Player extends EventEmitter {
 			if (!this.connection) throw new Error("No voice connection for TTS");
 			const ttsPlayer = this.ensureTTSPlayer();
 
+			await this.applyTrackMiddleware(track);
+
 			// Build resource from plugin stream
 			const streamInfo = await this.pluginManager.getStream(track);
 			if (!streamInfo) {
@@ -1387,6 +1422,56 @@ export class Player extends EventEmitter {
 		}
 	}
 
+	/**
+	 * Subscribe this player's voice connection
+	 * to another player's audio stream.
+	 *
+	 * This is primarily used for:
+	 * - playback mirroring
+	 * - radio/broadcast systems
+	 * - multi-guild synchronized playback
+	 * - forwardMode shared streaming
+	 *
+	 * Instead of creating a separate audio stream,
+	 * this player will directly receive audio packets
+	 * from the target player's AudioPlayer instance.
+	 *
+	 * Benefits:
+	 * - drastically lower CPU usage
+	 * - only one ffmpeg/extractor stream
+	 * - lower bandwidth and memory usage
+	 * - perfect sync across guilds
+	 *
+	 * Important:
+	 * - both players must already have active voice connections
+	 * - this does NOT transfer queue ownership
+	 * - this does NOT clone playback state automatically
+	 *
+	 * @param {Player} player - Source player to subscribe to
+	 *
+	 * @returns {boolean}
+	 * Returns true if subscription succeeded,
+	 * otherwise false.
+	 *
+	 * @example
+	 * follower.subscribeTo(leader);
+	 *
+	 * @example
+	 * if (!player.subscribeTo(leader)) {
+	 *   console.log("Failed to subscribe");
+	 * }
+	 */
+	public subscribeTo(player: Player): boolean {
+		if (!this.connection) return false;
+
+		this.connection.subscribe(player.audioPlayer);
+
+		this.isPlaying = player.isPlaying;
+		this.isPaused = player.isPaused;
+		this.forwardMode = true;
+		return true;
+	}
+
 	/**
 	 * Pause the current track
 	 *
@@ -1590,6 +1675,8 @@ export class Player extends EventEmitter {
 		}
 
 		try {
+			await this.applyTrackMiddleware(track);
+
 			// Skip extension manager for saving - we want the raw stream without filters/seek applied, and extensions may not support this
 			let streamInfo: StreamInfo | null = await this.pluginManager.getStream(track);
 

package/src/structures/PlayerManager.ts

@@ -1,8 +1,20 @@
 import { EventEmitter } from "events";
 import { Player } from "./Player";
-import { PlayerManagerOptions, PlayerOptions, Track, SourcePlugin, SearchResult, ManagerEvents, PlayerStats } from "../types";
+import {
+	PlayerManagerOptions,
+	PlayerOptions,
+	type Track,
+	SourcePlugin,
+	SearchResult,
+	ManagerEvents,
+	PlayerStats,
+	type PlaybackMirrorOptions,
+	type TrackMiddleware,
+	normalizeTrackMiddleware,
+} from "../types";
 import type { BaseExtension } from "../extensions";
 import { withTimeout } from "../utils/timeout";
+import { PluginManager } from "../plugins";
 
 const GLOBAL_MANAGER_KEY: symbol = Symbol.for("ziplayer.PlayerManager.instance");
 
@@ -92,12 +104,15 @@ export class PlayerManager extends EventEmitter {
 	}
 
 	private plugins: SourcePlugin[];
+	private pluginManager: PluginManager;
 	private extensions: any[];
 	private B_debug: boolean = false;
 	private extractorTimeout: number = 10000;
 	private autoCleanup: boolean = true;
 	private cleanupTimeout: number = 60000; // 1 minute
 	private enableSearchCache: boolean = true;
+	private trackMiddlewareFromOptions: TrackMiddleware[] = [];
+	private playbackMirrorUnsubscribes = new Map<string, () => void>();
 
 	private debug(message?: any, ...optionalParams: any[]): void {
 		if (this.listenerCount("debug") > 0) {
@@ -111,17 +126,26 @@ export class PlayerManager extends EventEmitter {
 	constructor(options: PlayerManagerOptions = {}) {
 		super();
 		this.plugins = [];
+		this.pluginManager = new PluginManager(null as any, this, {
+			extractorTimeout: this.extractorTimeout,
+		});
 		this.searchCache = new Map();
 
 		// Initialize plugins
 		const provided = options.plugins || [];
 		for (const p of provided as any[]) {
 			try {
+				let instance: SourcePlugin | null = null;
+
 				if (p && typeof p === "object") {
-					this.plugins.push(p as SourcePlugin);
+					instance = p as SourcePlugin;
 				} else if (typeof p === "function") {
-					const instance = new (p as any)();
-					this.plugins.push(instance as SourcePlugin);
+					instance = new (p as any)();
+				}
+
+				if (instance) {
+					this.plugins.push(instance);
+					this.pluginManager.register(instance);
 				}
 				this.debug(`Registered plugin: ${p.name || "unnamed"}`);
 			} catch (e) {
@@ -134,6 +158,7 @@ export class PlayerManager extends EventEmitter {
 		this.autoCleanup = options.autoCleanup ?? true;
 		this.cleanupTimeout = options.cleanupInterval ?? 60000;
 		this.enableSearchCache = options.enableSearchCache ?? true;
+		this.trackMiddlewareFromOptions = normalizeTrackMiddleware(options.trackMiddleware);
 
 		// Setup auto cleanup
 		if (this.autoCleanup) {
@@ -149,11 +174,6 @@ export class PlayerManager extends EventEmitter {
 		this.debug(`Initialized with ${this.plugins.length} plugins, ${this.extensions.length} extensions`);
 	}
 
-	private withTimeout<T>(promise: Promise<T>, message: string): Promise<T> {
-		const timeout = this.extractorTimeout;
-		return Promise.race([promise, new Promise<never>((_, reject) => setTimeout(() => reject(new Error(message)), timeout))]);
-	}
-
 	private resolveGuildId(guildOrId: string | { id: string }): string {
 		if (typeof guildOrId === "string") return guildOrId;
 		if (guildOrId && typeof guildOrId === "object" && "id" in guildOrId) return guildOrId.id;
@@ -571,12 +591,208 @@ export class PlayerManager extends EventEmitter {
 		}
 	}
 
+	/**
+	 * Like {@link broadcast} but awaits every return value (for async methods such as `play`).
+	 * Uses `Promise.allSettled` — failures are captured per guild, not thrown as a whole.
+	 */
+	async broadcastAsync(action: string, ...args: any[]): Promise<PromiseSettledResult<unknown>[]> {
+		const pending: Promise<unknown>[] = [];
+		for (const player of this.players.values()) {
+			const fn = (player as any)[action];
+			if (typeof fn !== "function") continue;
+			try {
+				pending.push(Promise.resolve(fn.apply(player, args)));
+			} catch (error) {
+				pending.push(Promise.reject(error));
+			}
+		}
+		return Promise.allSettled(pending);
+	}
+
+	/**
+	 * Broadcast a player method only to the given guild ids (players must already exist).
+	 */
+	broadcastGuilds(guildIds: readonly string[], action: string, ...args: any[]): void {
+		const wanted = new Set(guildIds);
+		for (const player of this.players.values()) {
+			if (!wanted.has(player.guildId)) continue;
+			if (typeof (player as any)[action] === "function") {
+				try {
+					(player as any)[action](...args);
+				} catch (error) {
+					this.debug(`Error broadcasting ${action} to ${player.guildId}:`, error);
+				}
+			}
+		}
+	}
+
+	/**
+	 * Global {@link TrackMiddleware} configured on this manager (applied before per-player middleware).
+	 */
+	getTrackMiddlewareChain(): TrackMiddleware[] {
+		return [...this.trackMiddlewareFromOptions];
+	}
+
+	/**
+	 * Mirror playback controls from a leader guild to follower guilds (each guild must already have a {@link Player} via
+	 * {@link create}). Followers receive the same track on `trackStart`, and pause/resume/stop/volume from the leader when
+	 * applicable.
+	 *
+	 * @returns Unsubscribe function — also runs when the leader player is destroyed.
+	 */
+	subscribePlaybackMirror(options: PlaybackMirrorOptions): () => void {
+		const leader = this.get(options.leaderGuildId);
+		if (!leader) {
+			throw new Error(`subscribePlaybackMirror: no player for leader guild ${options.leaderGuildId}`);
+		}
+
+		const followers = [...new Set(options.followerGuildIds)].filter((id) => id !== options.leaderGuildId);
+		const mirrorUserId = options.mirrorUserId;
+		const syncVolume = options.syncVolume ?? true;
+		const forwardMode = options.forwardMode ?? true;
+
+		const existing = this.playbackMirrorUnsubscribes.get(options.leaderGuildId);
+		existing?.();
+
+		const runFollowers = (fn: (p: Player) => void | Promise<void>) => {
+			for (const gid of followers) {
+				const fp = this.get(gid);
+				if (!fp) {
+					this.debug(`Playback mirror: no player for follower guild ${gid}`);
+					continue;
+				}
+				Promise.resolve(fn(fp)).catch((e) => this.debug(`Playback mirror follower error (${gid}):`, e));
+			}
+		};
+
+		const onTrackStart = async (track: Track) => {
+			if (!forwardMode) {
+				runFollowers(async (fp) => {
+					fp.stop();
+					await fp.play(track, mirrorUserId);
+				});
+				return;
+			}
+
+			runFollowers((fp) => {
+				if (!fp.connection || !leader.connection) {
+					this.debug(`Playback mirror forwardMode: missing connection for follower ${fp.guildId}`);
+					return;
+				}
+
+				try {
+					// sync state
+					fp.queue.clear();
+
+					// optional fake current track sync
+					if (track) {
+						fp.queue.setCurrentTrack(track);
+					}
+
+					// subscribe directly to leader player
+					fp.subscribeTo(leader);
+					fp.isPlaying = leader.isPlaying;
+					fp.isPaused = leader.isPaused;
+
+					fp.emit("trackStart", track);
+					this.debug(`Playback mirror forwardMode subscribed ${fp.guildId} -> ${leader.guildId}`);
+				} catch (e) {
+					this.debug(`Playback mirror forwardMode error (${fp.guildId}):`, e);
+				}
+			});
+		};
+
+		const onPause = () => {
+			runFollowers((fp) => {
+				if (forwardMode) {
+					fp.isPaused = true;
+					fp.isPlaying = false;
+					return;
+				}
+
+				fp.pause();
+			});
+		};
+
+		const onResume = () => {
+			runFollowers((fp) => {
+				if (forwardMode) {
+					fp.isPaused = false;
+					fp.isPlaying = true;
+					return;
+				}
+
+				fp.resume();
+			});
+		};
+
+		const onStop = () => {
+			runFollowers((fp) => {
+				if (forwardMode) {
+					try {
+						fp.connection?.subscribe(fp.audioPlayer);
+
+						fp.isPlaying = false;
+						fp.isPaused = false;
+
+						fp.audioPlayer.stop(true);
+					} catch {}
+					return;
+				}
+
+				fp.stop();
+			});
+		};
+
+		const onVolume = (_oldVol: number, newVol: number) => {
+			if (!syncVolume) return;
+			runFollowers((fp) => {
+				fp.setVolume(newVol);
+			});
+		};
+
+		let closed = false;
+		const unsubscribe = () => {
+			if (closed) return;
+			closed = true;
+			leader.off("trackStart", onTrackStart);
+			leader.off("playerPause", onPause);
+			leader.off("playerResume", onResume);
+			leader.off("playerStop", onStop);
+			leader.off("volumeChange", onVolume);
+			leader.off("playerDestroy", onLeaderDestroy);
+			onStop();
+			this.playbackMirrorUnsubscribes.delete(options.leaderGuildId);
+		};
+
+		const onLeaderDestroy = () => {
+			unsubscribe();
+		};
+
+		leader.on("trackStart", onTrackStart);
+		leader.on("playerPause", onPause);
+		leader.on("playerResume", onResume);
+		leader.on("playerStop", onStop);
+		leader.on("volumeChange", onVolume);
+		leader.on("playerDestroy", onLeaderDestroy);
+		if (leader?.currentTrack) onTrackStart(leader.currentTrack);
+		this.playbackMirrorUnsubscribes.set(options.leaderGuildId, unsubscribe);
+		return unsubscribe;
+	}
+
 	/**
 	 * Destroy all players and clean up
 	 */
 	destroy(): void {
 		this.debug(`Destroying all players`);
 
+		for (const unsub of this.playbackMirrorUnsubscribes.values()) {
+			try {
+				unsub();
+			} catch {}
+		}
+		this.playbackMirrorUnsubscribes.clear();
+
 		// Stop cleanup intervals
 		if (this.cleanupInterval) {
 			clearInterval(this.cleanupInterval);
@@ -600,30 +816,42 @@ export class PlayerManager extends EventEmitter {
 	}
 
 	/**
-	 * Search using registered plugins without creating a Player.
+	 * Search using PluginManager without creating a Player.
 	 *
-	 * @param {string} query - The query to search for
-	 * @param {string} requestedBy - The user ID who requested the search
-	 * @returns {Promise<SearchResult>} The search result
+	 * Uses the same search pipeline as Player.search():
+	 * - cache
+	 * - plugin deduplication
+	 * - plugin scoring/evaluation
+	 * - fallback handling
+	 *
+	 * @param {string} query
+	 * @param {string} requestedBy
+	 * @returns {Promise<SearchResult>}
 	 */
 	async search(query: string, requestedBy: string): Promise<SearchResult> {
 		this.debug(`Search called with query: ${query}, requestedBy: ${requestedBy}`);
 
-		// Check cache first
+		// Cache
 		const cached = this.getCachedSearch(query);
 		if (cached) {
 			return cached;
 		}
 
-		const plugin = this.plugins.find((p) => p.canHandle(query));
-		if (!plugin) {
-			this.debug(`No plugin found to handle: ${query}`);
-			throw new Error(`No plugin found to handle: ${query}`);
-		}
-
 		try {
-			const result = await this.withTimeout(plugin.search(query, requestedBy), "Search operation timed out");
+			const result = await this.pluginManager.search(query, requestedBy);
+
+			if (!result || !Array.isArray(result.tracks) || result.tracks.length === 0) {
+				throw new Error(`No results found for: ${query}`);
+			}
+
+			this.debug(`Plugin search returned ${result.tracks.length} tracks (score: ${result.score?.score ?? "unknown"}%)`);
+
+			if (result.score) {
+				this.debug(`Search evaluation - ${result.score.reason}`);
+			}
+
 			this.setCachedSearch(query, result);
+
 			return result;
 		} catch (error) {
 			this.debug(`Search error:`, error);
@@ -647,9 +875,10 @@ export class PlayerManager extends EventEmitter {
 	 */
 	registerPlugin(plugin: SourcePlugin): void {
 		this.plugins.push(plugin);
+		this.pluginManager.register(plugin);
+
 		this.debug(`Registered plugin: ${plugin.name}`);
 
-		// Register plugin with all existing players
 		for (const player of this.players.values()) {
 			player.addPlugin(plugin);
 		}
@@ -666,9 +895,10 @@ export class PlayerManager extends EventEmitter {
 		if (index === -1) return false;
 
 		this.plugins.splice(index, 1);
+		this.pluginManager.unregister(name);
+
 		this.debug(`Unregistered plugin: ${name}`);
 
-		// Note: Cannot easily remove plugins from existing players
 		return true;
 	}
 

package/src/structures/Queue.ts

@@ -400,6 +400,28 @@ export class Queue {
 		return this.current;
 	}
 
+	/**
+	 * Force set current playing track.
+	 *
+	 * Mainly used internally for playback synchronization,
+	 * playback mirroring, restoring player state,
+	 * or forward-mode shared audio sessions.
+	 *
+	 * This does NOT modify queue order/history automatically.
+	 * It only updates the current active track reference.
+	 *
+	 * @param {Track | null} track - Track to set as current
+	 *
+	 * @example
+	 * queue.setCurrentTrack(track);
+	 *
+	 * @example
+	 * queue.setCurrentTrack(null);
+	 */
+	setCurrentTrack(track: Track | null): void {
+		this.current = track;
+	}
+	
 	/**
 	 * Get the previous tracks
 	 */

package/src/types/index.ts

@@ -122,6 +122,43 @@ export interface StreamInfo {
 	metadata?: Record<string, any>;
 }
 
+/** Passed to each {@link TrackMiddleware} run (before stream resolution). */
+export interface TrackMiddlewareContext {
+	player: Player;
+	manager: PlayerManager;
+}
+
+/**
+ * Runs immediately before stream extraction (`Player.getStream`): after enqueue, before extension `provideStream` and plugins.
+ * Prefer mutating `track` in place (especially `metadata`). If you return another object, its fields are merged into the original
+ * `track` reference so queue/current-track pointers stay valid.
+ */
+export type TrackMiddleware = (track: Track, context: TrackMiddlewareContext) => void | Track | Promise<void | Track>;
+
+/** Options for {@link PlayerManager.subscribePlaybackMirror}. */
+export interface PlaybackMirrorOptions {
+	leaderGuildId: string;
+	followerGuildIds: string[];
+	/** User id passed to follower `play()` (often the bot application id). */
+	mirrorUserId: string;
+	/** When true (default), follower `setVolume` tracks the leader. */
+	syncVolume?: boolean;
+	/**
+	 * When enabled, follower connections subscribe directly
+	 * to leader.audioPlayer instead of creating their own streams.
+	 *
+	 * Greatly reduces bandwidth/CPU usage.
+	 *
+	 * Default: true
+	 */
+	forwardMode?: boolean;
+}
+
+export function normalizeTrackMiddleware(input?: TrackMiddleware | TrackMiddleware[]): TrackMiddleware[] {
+	if (!input) return [];
+	return Array.isArray(input) ? input : [input];
+}
+
 /**
  * Configuration options for creating a new player instance.
  *
@@ -302,6 +339,11 @@ export interface PlayerOptions {
 		 */
 		limiterCeiling?: number;
 	};
+	/**
+	 * Chain of middleware applied to every track immediately before stream extraction (after queueing).
+	 * Merged after {@link PlayerManagerOptions.trackMiddleware} from the manager.
+	 */
+	trackMiddleware?: TrackMiddleware | TrackMiddleware[];
 }
 
 export interface PlayerManagerOptions {
@@ -312,6 +354,10 @@ export interface PlayerManagerOptions {
 	cleanupInterval?: number; // Cleanup interval in ms
 	enableSearchCache?: boolean; // Enable search result caching
 	enableStatsCollection?: boolean; // Enable stats collection events
+	/**
+	 * Global track middleware for every {@link Player} created from this manager (before per-player middleware).
+	 */
+	trackMiddleware?: TrackMiddleware | TrackMiddleware[];
 }
 
 /**