ziplayer 0.3.1 → 0.3.2

package/src/structures/PreloadManager.ts

@@ -0,0 +1,274 @@
+import { createAudioResource, AudioResource } from "@discordjs/voice";
+import type { Track, StreamInfo, StreamSlot } from "../types";
+import type { StreamManager } from "./StreamManager";
+
+interface PreloadManagerDeps {
+	streamManager: StreamManager;
+	debug: (message?: any, ...optionalParams: any[]) => void;
+	getNextTrack: () => Track | null;
+	getStream: (track: Track) => Promise<StreamInfo | null>;
+	isDestroyed: () => boolean;
+	isEnabled: () => boolean;
+}
+
+export class PreloadManager {
+	private readonly streamManager: StreamManager;
+	private readonly debugLog: (message?: any, ...optionalParams: any[]) => void;
+	private readonly getNextTrack: () => Track | null;
+	private readonly getStream: (track: Track) => Promise<StreamInfo | null>;
+	private readonly isDestroyed: () => boolean;
+	private readonly isEnabled: () => boolean;
+
+	private preloadLock = false;
+	private readonly preloadSlot: StreamSlot = {
+		resource: null,
+		track: null,
+		streamId: null,
+		abortController: null,
+		isValid: false,
+		isLoading: false,
+		loadPromise: null,
+	};
+
+	constructor(deps: PreloadManagerDeps) {
+		this.streamManager = deps.streamManager;
+		this.debugLog = deps.debug;
+		this.getNextTrack = deps.getNextTrack;
+		this.getStream = deps.getStream;
+		this.isDestroyed = deps.isDestroyed;
+		this.isEnabled = deps.isEnabled;
+	}
+
+	public hasValidPreload(track: Track): boolean {
+		return !!(
+			this.preloadSlot.isValid &&
+			this.preloadSlot.track?.id === track.id &&
+			this.preloadSlot.resource &&
+			this.preloadSlot.resource.playStream?.readable !== false
+		);
+	}
+
+	public promoteToCurrent(track: Track, currentSlot: StreamSlot): AudioResource | null {
+		const promotedResource = this.preloadSlot.resource;
+		const promotedStreamId = this.preloadSlot.streamId;
+		if (!promotedResource) return null;
+
+		currentSlot.resource = promotedResource;
+		currentSlot.track = track;
+		currentSlot.streamId = promotedStreamId;
+		currentSlot.abortController = null;
+		currentSlot.isValid = true;
+		currentSlot.isLoading = false;
+		currentSlot.loadPromise = null;
+
+		this.preloadSlot.resource = null;
+		this.preloadSlot.track = null;
+		this.preloadSlot.streamId = null;
+		this.preloadSlot.abortController = null;
+		this.preloadSlot.isValid = false;
+		this.preloadSlot.isLoading = false;
+		this.preloadSlot.loadPromise = null;
+
+		return promotedResource;
+	}
+
+	public async preloadNextTrack(): Promise<void> {
+		if (this.isDestroyed()) return;
+		if (!this.isEnabled()) {
+			this.debugLog(`[Preload] Disabled by options/runtime profile`);
+			return;
+		}
+
+		if (this.preloadLock) {
+			this.debugLog(`[Preload] Already preloading, skipping`);
+			return;
+		}
+
+		const nextTrack = this.getNextTrack();
+		if (!nextTrack) {
+			this.debugLog(`[Preload] No next track to preload`);
+			return;
+		}
+
+		if (this.preloadSlot.isValid && this.preloadSlot.track?.id === nextTrack.id && this.preloadSlot.resource) {
+			this.debugLog(`[Preload] Already have valid preload for: ${nextTrack.title}`);
+			return;
+		}
+
+		if (this.preloadSlot.isLoading && this.preloadSlot.track?.id === nextTrack.id) {
+			this.debugLog(`[Preload] Currently loading same track, waiting...`);
+			if (this.preloadSlot.loadPromise) {
+				await this.preloadSlot.loadPromise;
+			}
+			return;
+		}
+
+		if (this.preloadSlot.isValid && this.preloadSlot.track?.id !== nextTrack.id) {
+			this.debugLog(`[Preload] Cancelling old preload for different track: ${this.preloadSlot.track?.title}`);
+			await this.safeCancelPreload();
+		}
+
+		this.preloadLock = true;
+		const abortController = new AbortController();
+		this.preloadSlot.track = nextTrack;
+		this.preloadSlot.abortController = abortController;
+		this.preloadSlot.isLoading = true;
+
+		const loadPromise = this.executePreload(nextTrack, abortController);
+		this.preloadSlot.loadPromise = loadPromise;
+
+		try {
+			await loadPromise;
+		} catch (err) {
+			if (err instanceof Error && err.message === "PRELOAD_CANCELLED") {
+				this.debugLog(`[Preload] Cancelled for ${nextTrack.title}`);
+			} else {
+				this.debugLog(`[Preload] Failed for ${nextTrack.title}:`, err);
+			}
+			this.clearPreloadSlot();
+		} finally {
+			this.preloadLock = false;
+			this.preloadSlot.isLoading = false;
+			this.preloadSlot.loadPromise = null;
+		}
+	}
+
+	public async safeCancelPreload(): Promise<void> {
+		if (!this.preloadSlot.abortController && !this.preloadSlot.resource) {
+			return;
+		}
+
+		this.debugLog(`[Preload] Safely cancelling preload for: ${this.preloadSlot.track?.title || "unknown"}`);
+
+		if (this.preloadSlot.abortController) {
+			this.preloadSlot.abortController.abort();
+			this.preloadSlot.abortController = null;
+		}
+
+		if (this.preloadSlot.streamId) {
+			this.streamManager.unregisterStream(this.preloadSlot.streamId, true);
+		}
+
+		if (this.preloadSlot.resource) {
+			try {
+				const stream = this.preloadSlot.resource.playStream;
+				if (stream && typeof stream.destroy === "function" && !stream.destroyed) {
+					stream.destroy();
+				}
+			} catch {
+				// ignore
+			}
+		}
+
+		this.clearPreloadSlot();
+	}
+
+	public cancelPreload(): void {
+		if (this.preloadSlot.abortController) {
+			this.debugLog(`[Preload] Cancelling preload for: ${this.preloadSlot.track?.title}`);
+			this.preloadSlot.abortController.abort();
+		}
+		if (this.preloadSlot.streamId) {
+			this.streamManager.unregisterStream(this.preloadSlot.streamId, true);
+		}
+		this.clearPreloadSlot();
+	}
+
+	public clearPreloadSlot(): void {
+		if (this.preloadSlot.resource) {
+			try {
+				const stream = this.preloadSlot.resource.playStream;
+				if (stream && typeof stream.destroy === "function" && !stream.destroyed) {
+					stream.destroy();
+				}
+			} catch {
+				// ignore
+			}
+		}
+
+		if (this.preloadSlot.streamId) {
+			this.streamManager.unregisterStream(this.preloadSlot.streamId, true);
+		}
+
+		this.preloadSlot.resource = null;
+		this.preloadSlot.track = null;
+		this.preloadSlot.streamId = null;
+		this.preloadSlot.abortController = null;
+		this.preloadSlot.isValid = false;
+		this.preloadSlot.isLoading = false;
+		this.preloadSlot.loadPromise = null;
+	}
+
+	private async executePreload(track: Track, abortController: AbortController): Promise<void> {
+		if (this.isDestroyed()) throw new Error("PLAYER_DESTROYED");
+		this.debugLog(`[Preload] Starting preload for: ${track.title}`);
+
+		if (abortController.signal.aborted) {
+			throw new Error("PRELOAD_CANCELLED");
+		}
+
+		if (this.getNextTrack()?.id !== track.id) {
+			this.debugLog(`[Preload] Track changed, cancelling`);
+			throw new Error("PRELOAD_CANCELLED");
+		}
+
+		const streamInfo = await this.getStreamWithCancel(track, abortController.signal);
+		if (abortController.signal.aborted) {
+			throw new Error("PRELOAD_CANCELLED");
+		}
+		if (this.getNextTrack()?.id !== track.id) {
+			this.debugLog(`[Preload] Track changed after stream fetch`);
+			throw new Error("PRELOAD_CANCELLED");
+		}
+		if (!streamInfo?.stream) {
+			throw new Error(`No stream available`);
+		}
+
+		const streamId = this.streamManager.registerStream(streamInfo.stream, track, {
+			source: track.source || "preload",
+			isPreload: true,
+			priority: 5,
+		});
+
+		const resource = createAudioResource(streamInfo.stream, {
+			inlineVolume: true,
+			metadata: { ...track, preloaded: true },
+		});
+
+		if (!resource.playStream || resource.playStream.readable === false) {
+			throw new Error("Resource not readable");
+		}
+
+		this.preloadSlot.resource = resource;
+		this.preloadSlot.streamId = streamId;
+		this.preloadSlot.isValid = true;
+		this.preloadSlot.track = track;
+
+		this.debugLog(`[Preload] Successfully preloaded: ${track.title} (Stream ID: ${streamId})`);
+	}
+
+	private async getStreamWithCancel(track: Track, signal: AbortSignal): Promise<StreamInfo | null> {
+		if (this.isDestroyed()) throw new Error("PLAYER_DESTROYED");
+		const abortPromise = new Promise<never>((_, reject) => {
+			if (signal.aborted) {
+				reject(new Error("PRELOAD_CANCELLED"));
+				return;
+			}
+			const handler = () => {
+				signal.removeEventListener("abort", handler);
+				reject(new Error("PRELOAD_CANCELLED"));
+			};
+			signal.addEventListener("abort", handler);
+		});
+
+		const existingStream = this.streamManager.getStreamByTrack(track.id || track.title);
+		if (existingStream && !existingStream.destroyed && existingStream.readable !== false) {
+			this.debugLog(`[Stream] Using existing stream for preload: ${track.title}`);
+			return { stream: existingStream, type: "arbitrary" };
+		}
+
+		const streamPromise = this.getStream(track);
+		const result = await Promise.race([streamPromise, abortPromise]);
+		return result as StreamInfo | null;
+	}
+}

package/src/structures/StreamManager.ts

@@ -37,6 +37,7 @@ export interface StreamManagerOptions {
 
 export class StreamManager extends EventEmitter {
 	private streams = new Map<string, ManagedStream>();
+	private suppressPrematureCloseErrors = new Set<string>();
 	private options: Required<StreamManagerOptions>;
 	private cleanupTimer: NodeJS.Timeout | null = null;
 	private metrics = {
@@ -72,6 +73,20 @@ export class StreamManager extends EventEmitter {
 	 * Register a new stream
 	 */
 	registerStream(stream: Readable, track: Track, metadata: Partial<ManagedStream["metadata"]> = {}): string {
+		for (const existing of this.streams.values()) {
+			if (existing.stream === stream) {
+				existing.lastAccessed = Date.now();
+				existing.track = track;
+				existing.metadata = {
+					...existing.metadata,
+					source: track.source || existing.metadata.source || "unknown",
+					...metadata,
+				};
+				this.debug(`Stream already managed, reusing ID: ${existing.id}`);
+				return existing.id;
+			}
+		}
+
 		const streamId = this.generateStreamId(track);
 
 		// Check if stream already exists
@@ -81,8 +96,9 @@ export class StreamManager extends EventEmitter {
 		}
 
 		// Check concurrent limit
-		if (this.streams.size >= this.options.maxConcurrentStreams) {
-			this.evictOldestStream();
+		while (this.streams.size >= this.options.maxConcurrentStreams) {
+			const evicted = this.evictOldestStream();
+			if (!evicted) break;
 		}
 
 		// Configure stream
@@ -141,6 +157,14 @@ export class StreamManager extends EventEmitter {
 	private createStreamListeners(streamId: string): ManagedStream["listeners"] {
 		return {
 			error: (err: Error) => {
+				const isPrematureClose = err?.message?.toLowerCase().includes("premature close");
+				if (isPrematureClose && this.suppressPrematureCloseErrors.has(streamId)) {
+					this.debug(`Ignored expected premature close [${streamId}] during controlled destroy`);
+					this.suppressPrematureCloseErrors.delete(streamId);
+					this.unregisterStream(streamId, false);
+					return;
+				}
+
 				this.debug(`Stream error [${streamId}]:`, err);
 				if (this.options.enableMetrics) {
 					this.metrics.totalErrors++;
@@ -232,6 +256,7 @@ export class StreamManager extends EventEmitter {
 	unregisterStream(streamId: string, forceDestroy: boolean = true): boolean {
 		const managed = this.streams.get(streamId);
 		if (!managed) {
+			this.suppressPrematureCloseErrors.delete(streamId);
 			return false;
 		}
 
@@ -258,9 +283,11 @@ export class StreamManager extends EventEmitter {
 			// Force destroy if needed
 			if (forceDestroy && !stream.destroyed && typeof stream.destroy === "function") {
 				try {
+					this.suppressPrematureCloseErrors.add(streamId);
 					stream.destroy();
 					managed.status = "destroyed";
 				} catch (err) {
+					this.suppressPrematureCloseErrors.delete(streamId);
 					this.debug(`Error destroying stream:`, err);
 				}
 			}
@@ -274,6 +301,7 @@ export class StreamManager extends EventEmitter {
 		}
 
 		this.emit("streamUnregistered", { streamId, track: managed.track, reason: forceDestroy ? "destroyed" : "natural" });
+		this.suppressPrematureCloseErrors.delete(streamId);
 
 		return true;
 	}
@@ -336,7 +364,7 @@ export class StreamManager extends EventEmitter {
 	/**
 	 * Evict oldest stream when limit reached
 	 */
-	private evictOldestStream(): void {
+	private evictOldestStream(): boolean {
 		// Evict lowest priority streams first
 		const sorted = Array.from(this.streams.values()).sort((a, b) => a.metadata.priority - b.metadata.priority);
 
@@ -344,9 +372,18 @@ export class StreamManager extends EventEmitter {
 			if (managed.metadata.isPreload && managed.metadata.priority < 5) {
 				this.debug(`Evicting low priority preload stream: ${managed.track.title}`);
 				this.unregisterStream(managed.id, true);
-				break;
+				return true;
 			}
 		}
+
+		if (sorted.length > 0) {
+			const fallback = sorted[0];
+			this.debug(`Evicting fallback stream to enforce limit: ${fallback.track.title}`);
+			this.unregisterStream(fallback.id, true);
+			return true;
+		}
+
+		return false;
 	}
 
 	/**

package/src/types/index.ts

@@ -228,7 +228,7 @@ export interface PlayerOptions {
 		autoDisableInLowPerformance?: boolean;
 		/**
 		 * Target crossfade duration in milliseconds.
-		 * Default: 5000
+		 * Default: 500
 		 */
 		durationMs?: number;
 	};