ziplayer 0.2.7-dev.0 → 0.2.7-dev.1

package/dist/types/persistence.d.ts

@@ -0,0 +1,55 @@
+import type { LoopMode, PlayerOptions } from ".";
+export interface SerializedTrack {
+    id: string;
+    title: string;
+    url: string;
+    source: string;
+    duration: number;
+    thumbnail?: string;
+    author?: string;
+    requestedBy?: string;
+    isLive?: boolean;
+    artwork?: string;
+    [key: string]: any;
+}
+export interface SerializedQueue {
+    tracks: SerializedTrack[];
+    current: SerializedTrack | null;
+    history: SerializedTrack[];
+    loopMode: LoopMode;
+    autoPlay: boolean;
+    position?: number;
+}
+export interface SerializedPlayer {
+    guildId: string;
+    queue: SerializedQueue;
+    volume: number;
+    isPlaying: boolean;
+    isPaused: boolean;
+    options: PlayerOptions;
+    filters?: string[];
+    lastUpdate: number;
+    version: string;
+}
+export interface PersistenceOptions {
+    enabled: boolean;
+    provider?: "file" | "redis" | "database";
+    saveInterval?: number;
+    autoLoad?: boolean;
+    maxBackups?: number;
+    compress?: boolean;
+    filePath?: string;
+    redisUrl?: string;
+    redisPrefix?: string;
+    save?: (data: Map<string, SerializedPlayer>) => Promise<void>;
+    load?: () => Promise<Map<string, SerializedPlayer>>;
+    delete?: (guildId: string) => Promise<void>;
+    list?: () => Promise<string[]>;
+}
+export interface PersistenceProvider {
+    save(key: string, data: any, compress?: boolean): Promise<void>;
+    load(key: string): Promise<any>;
+    delete(key: string): Promise<void>;
+    list(): Promise<string[]>;
+}
+//# sourceMappingURL=persistence.d.ts.map

package/dist/types/persistence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"persistence.d.ts","sourceRoot":"","sources":["../../src/types/persistence.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAS,QAAQ,EAAE,aAAa,EAAE,MAAM,GAAG,CAAC;AAExD,MAAM,WAAW,eAAe;IAC/B,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACnB;AAED,MAAM,WAAW,eAAe;IAC/B,MAAM,EAAE,eAAe,EAAE,CAAC;IAC1B,OAAO,EAAE,eAAe,GAAG,IAAI,CAAC;IAChC,OAAO,EAAE,eAAe,EAAE,CAAC;IAC3B,QAAQ,EAAE,QAAQ,CAAC;IACnB,QAAQ,EAAE,OAAO,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,gBAAgB;IAChC,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,eAAe,CAAC;IACvB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;IACnB,QAAQ,EAAE,OAAO,CAAC;IAClB,OAAO,EAAE,aAAa,CAAC;IACvB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,kBAAkB;IAClC,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,GAAG,UAAU,CAAC;IACzC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,OAAO,CAAC;IAGnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAGlB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;IAGrB,IAAI,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC,MAAM,EAAE,gBAAgB,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9D,IAAI,CAAC,EAAE,MAAM,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC,CAAC;IACpD,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5C,IAAI,CAAC,EAAE,MAAM,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;CAC/B;AAED,MAAM,WAAW,mBAAmB;IACnC,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,EAAE,QAAQ,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAChE,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;IAChC,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACnC,IAAI,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;CAC1B"}

package/dist/types/persistence.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=persistence.js.map

package/dist/types/persistence.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"persistence.js","sourceRoot":"","sources":["../../src/types/persistence.ts"],"names":[],"mappings":""}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "ziplayer",
-	"version": "0.2.7-dev.0",
+	"version": "0.2.7-dev.1",
 	"description": "A modular Discord voice player with plugin system",
 	"keywords": [
 		"ZiPlayer",
@@ -10,7 +10,7 @@
 		"voice",
 		"@ziplayer/plugin"
 	],
-	"homepage": "https://player.ziji.world",
+	"homepage": "https://player.ziji.best",
 	"bugs": {
 		"url": "https://github.com/ZiProject/ZiPlayer/issues"
 	},
@@ -31,6 +31,7 @@
 		"discord-api-types": "^0.38.37",
 		"ffmpeg-static": "^5.2.0",
 		"libsodium-wrappers": "^0.7.15",
+		"lru-cache": "^11.3.6",
 		"opusscript": "^0.1.1",
 		"prism-media": "^1.3.5"
 	},

package/src/extensions/BaseExtension.ts

@@ -14,6 +14,7 @@ import type { Player } from "../structures/Player";
 export abstract class BaseExtension implements SourceExtension {
 	abstract name: string;
 	abstract version: string;
+	priority?: number; // Higher = run first
 	abstract player: Player | null;
 	abstract active(alas: any): boolean | Promise<boolean>;
 

package/src/extensions/index.ts

@@ -16,19 +16,57 @@ import { BaseExtension } from "./BaseExtension";
 
 export { BaseExtension } from "./BaseExtension";
 
-// Extension factory
+interface ExtensionCacheEntry<T> {
+	data: T;
+	timestamp: number;
+	expiresAt: number;
+}
+
+interface ExtensionMetadata {
+	name: string;
+	priority: number;
+	registeredAt: number;
+	hasSearch: boolean;
+	hasStream: boolean;
+	hasBeforePlay: boolean;
+	hasAfterPlay: boolean;
+}
+
 export class ExtensionManager {
 	private extensions: Map<string, BaseExtension>;
+	private extensionMetadata: Map<string, ExtensionMetadata>;
 	private player: Player;
 	private manager: PlayerManager;
 	private extensionContext: ExtensionContext;
 
+	// Caches for different operations
+	private searchCache: Map<string, ExtensionCacheEntry<SearchResult>>;
+	private streamCache: Map<string, ExtensionCacheEntry<StreamInfo>>;
+
+	// Cache TTLs
+	private readonly SEARCH_CACHE_TTL = 60 * 1000; // 1 minute
+	private readonly STREAM_CACHE_TTL = 5 * 60 * 1000; // 5 minutes
+	private readonly MAX_CACHE_SIZE = 100;
+
+	// Pending requests for deduplication
+	private pendingSearches: Map<string, Promise<SearchResult | null>>;
+	private pendingStreams: Map<string, Promise<StreamInfo | null>>;
+
 	constructor(player: Player, manager: PlayerManager) {
 		this.player = player;
 		this.manager = manager;
 		this.extensions = new Map();
+		this.extensionMetadata = new Map();
+		this.searchCache = new Map();
+		this.streamCache = new Map();
+		this.pendingSearches = new Map();
+		this.pendingStreams = new Map();
 		this.extensionContext = Object.freeze({ player, manager });
+
+		// Auto-cleanup caches periodically
+		setInterval(() => this.cleanupCaches(), 5 * 60 * 1000);
 	}
+
 	debug(message?: any, ...optionalParams: any[]): void {
 		if (this.manager.debugEnabled) {
 			this.manager.emit("debug", `[ExtensionManager] ${message}`, ...optionalParams);
@@ -37,29 +75,55 @@ export class ExtensionManager {
 
 	register(extension: BaseExtension): void {
 		if (this.extensions.has(extension.name)) {
+			this.debug(`Extension ${extension.name} already registered, skipping`);
 			return;
 		}
+
 		if (!extension.player) {
 			extension.player = this.player;
 		}
+
+		// Set default priority if not set
+		extension.priority ??= 0;
+
+		// Store metadata for optimization
+		const metadata: ExtensionMetadata = {
+			name: extension.name,
+			priority: extension.priority,
+			registeredAt: Date.now(),
+			hasSearch: typeof (extension as any).provideSearch === "function",
+			hasStream: typeof (extension as any).provideStream === "function",
+			hasBeforePlay: typeof (extension as any).beforePlay === "function",
+			hasAfterPlay: typeof (extension as any).afterPlay === "function",
+		};
+
 		this.extensions.set(extension.name, extension);
+		this.extensionMetadata.set(extension.name, metadata);
+		this.invokeExtensionLifecycle(extension, "onRegister");
+		this.debug(`Registered extension: ${extension.name} (priority: ${extension.priority})`);
 	}
 
 	unregister(extension: BaseExtension): boolean {
 		const name = extension.name;
 		const result = this.extensions.delete(name);
 		if (result) {
+			this.extensionMetadata.delete(name);
 			this.invokeExtensionLifecycle(extension, "onDestroy");
+			this.debug(`Unregistered extension: ${name}`);
 		}
 		return result;
 	}
 
 	destroy(): void {
-		this.debug(`[ExtensionManager] destroying all extensions`);
+		this.debug(`Destroying all extensions`);
 		for (const extension of this.extensions.values()) {
 			this.unregister(extension);
 		}
 		this.extensions.clear();
+		this.extensionMetadata.clear();
+		this.clearAllCaches();
+		this.pendingSearches.clear();
+		this.pendingStreams.clear();
 	}
 
 	get(name: string): BaseExtension | undefined {
@@ -67,15 +131,41 @@ export class ExtensionManager {
 	}
 
 	getAll(): BaseExtension[] {
-		return Array.from(this.extensions.values());
+		// Sort by priority (higher first)
+		return Array.from(this.extensions.values()).sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
+	}
+
+	getMetadata(name: string): ExtensionMetadata | undefined {
+		return this.extensionMetadata.get(name);
 	}
 
-	findExtension(alas: any): BaseExtension | undefined {
-		return this.getAll().find((extension) => extension.active(alas));
+	getAllMetadata(): ExtensionMetadata[] {
+		return Array.from(this.extensionMetadata.values()).sort((a, b) => b.priority - a.priority);
+	}
+
+	findExtension(query: unknown): BaseExtension | undefined {
+		return this.getAll().find((extension) => extension.active?.(query) ?? false);
+	}
+
+	findExtensionsByCapability(capability: "search" | "stream" | "beforePlay" | "afterPlay"): BaseExtension[] {
+		const capabilityMap = {
+			search: "hasSearch",
+			stream: "hasStream",
+			beforePlay: "hasBeforePlay",
+			afterPlay: "hasAfterPlay",
+		};
+
+		const metaKey = capabilityMap[capability];
+		return this.getAll().filter((ext) => {
+			const meta = this.extensionMetadata.get(ext.name);
+			return meta?.[metaKey as keyof ExtensionMetadata] ?? false;
+		});
 	}
 
 	clear(): void {
 		this.extensions.clear();
+		this.extensionMetadata.clear();
+		this.clearAllCaches();
 	}
 
 	private invokeExtensionLifecycle(extension: BaseExtension | undefined, hook: "onRegister" | "onDestroy"): void {
@@ -85,60 +175,204 @@ export class ExtensionManager {
 		try {
 			const result = fn.call(extension, this.extensionContext);
 			if (result && typeof (result as Promise<unknown>).then === "function") {
-				(result as Promise<unknown>).catch((err) => this.debug(`[Player] Extension ${extension.name} ${hook} error:`, err));
+				(result as Promise<unknown>).catch((err) => this.debug(`Extension ${extension.name} ${hook} error:`, err));
 			}
 		} catch (err) {
-			this.debug(`[Player] Extension ${extension.name} ${hook} error:`, err);
+			this.debug(`Extension ${extension.name} ${hook} error:`, err);
+		}
+	}
+
+	private getCacheKey(prefix: string, ...parts: string[]): string {
+		return `${prefix}:${parts.join(":")}`;
+	}
+
+	private cleanupCaches(): void {
+		const now = Date.now();
+
+		// Clean search cache
+		for (const [key, entry] of this.searchCache) {
+			if (now >= entry.expiresAt) {
+				this.searchCache.delete(key);
+			}
+		}
+
+		// Clean stream cache
+		for (const [key, entry] of this.streamCache) {
+			if (now >= entry.expiresAt) {
+				this.streamCache.delete(key);
+			}
+		}
+
+		this.debug(`Cache cleanup completed - Search: ${this.searchCache.size}, Stream: ${this.streamCache.size}`);
+	}
+
+	private clearAllCaches(): void {
+		this.searchCache.clear();
+		this.streamCache.clear();
+		this.debug("All caches cleared");
+	}
+
+	private getCachedSearch(query: string): SearchResult | null {
+		const key = this.getCacheKey("search", query.toLowerCase().trim());
+		const cached = this.searchCache.get(key);
+		if (cached && Date.now() < cached.expiresAt) {
+			this.debug(`[Cache] Search hit for: ${query}`);
+			return cached.data;
+		}
+		return null;
+	}
+
+	private setCachedSearch(query: string, result: SearchResult): void {
+		if (this.searchCache.size >= this.MAX_CACHE_SIZE) {
+			// Remove oldest entries (LRU approximation)
+			const oldest = Array.from(this.searchCache.entries()).sort((a, b) => a[1].timestamp - b[1].timestamp)[0];
+			if (oldest) this.searchCache.delete(oldest[0]);
+		}
+
+		const key = this.getCacheKey("search", query.toLowerCase().trim());
+		this.searchCache.set(key, {
+			data: result,
+			timestamp: Date.now(),
+			expiresAt: Date.now() + this.SEARCH_CACHE_TTL,
+		});
+		this.debug(`[Cache] Search stored for: ${query}`);
+	}
+
+	private getCachedStream(track: Track): StreamInfo | null {
+		const key = this.getCacheKey("stream", track.url || track.id || track.title);
+		const cached = this.streamCache.get(key);
+		if (cached && Date.now() < cached.expiresAt) {
+			this.debug(`[Cache] Stream hit for: ${track.title}`);
+			return cached.data;
+		}
+		return null;
+	}
+
+	private setCachedStream(track: Track, stream: StreamInfo): void {
+		if (this.streamCache.size >= this.MAX_CACHE_SIZE) {
+			const oldest = Array.from(this.streamCache.entries()).sort((a, b) => a[1].timestamp - b[1].timestamp)[0];
+			if (oldest) this.streamCache.delete(oldest[0]);
 		}
+
+		const key = this.getCacheKey("stream", track.url || track.id || track.title);
+		this.streamCache.set(key, {
+			data: stream,
+			timestamp: Date.now(),
+			expiresAt: Date.now() + this.STREAM_CACHE_TTL,
+		});
+		this.debug(`[Cache] Stream stored for: ${track.title}`);
 	}
 
 	async provideSearch(query: string, requestedBy: string): Promise<SearchResult | null> {
+		if (!query) return null;
+
+		// Check cache first
+		const cached = this.getCachedSearch(query);
+		if (cached) return cached;
+
+		// Deduplicate concurrent requests
+		const cacheKey = this.getCacheKey("search", query.toLowerCase().trim());
+		if (this.pendingSearches.has(cacheKey)) {
+			this.debug(`[Dedupe] Waiting for pending search: ${query}`);
+			return this.pendingSearches.get(cacheKey)!;
+		}
+
 		const request: ExtensionSearchRequest = { query, requestedBy };
-		for (const extension of this.getAll()) {
-			const hook = (extension as any).provideSearch;
-			if (typeof hook !== "function") continue;
-			try {
-				const result = await Promise.resolve(hook.call(extension, this.extensionContext, request));
-				if (result && Array.isArray(result.tracks) && result.tracks.length > 0) {
-					this.debug(`[Player] Extension ${extension.name} handled search for query: ${query}`);
-					return result as SearchResult;
+		const searchPromise = (async () => {
+			// Only query extensions that have provideSearch capability
+			const searchExtensions = this.findExtensionsByCapability("search");
+
+			for (const extension of searchExtensions) {
+				const hook = (extension as any).provideSearch;
+				if (typeof hook !== "function") continue;
+
+				try {
+					const result = await Promise.resolve(hook.call(extension, this.extensionContext, request));
+					if (result && Array.isArray(result.tracks) && result.tracks.length > 0) {
+						this.debug(`Extension ${extension.name} handled search for: ${query}`);
+						this.setCachedSearch(query, result as SearchResult);
+						return result as SearchResult;
+					}
+				} catch (err) {
+					this.debug(`Extension ${extension.name} provideSearch error:`, err);
 				}
-			} catch (err) {
-				this.debug(`[Player] Extension ${extension.name} provideSearch error:`, err);
 			}
+			return null;
+		})();
+
+		this.pendingSearches.set(cacheKey, searchPromise);
+
+		try {
+			return await searchPromise;
+		} finally {
+			this.pendingSearches.delete(cacheKey);
 		}
-		return null;
 	}
 
 	async provideStream(track: Track): Promise<StreamInfo | null> {
+		if (!track) return null;
+
+		// Check cache first
+		const cached = this.getCachedStream(track);
+		if (cached) return cached;
+
+		// Deduplicate concurrent requests
+		const cacheKey = this.getCacheKey("stream", track.url || track.id || track.title);
+		if (this.pendingStreams.has(cacheKey)) {
+			this.debug(`[Dedupe] Waiting for pending stream: ${track.title}`);
+			return this.pendingStreams.get(cacheKey)!;
+		}
+
 		const request: ExtensionStreamRequest = { track };
-		for (const extension of this.getAll()) {
-			const hook = (extension as any).provideStream;
-			if (typeof hook !== "function") continue;
-			try {
-				const result = await Promise.resolve(hook.call(extension, this.extensionContext, request));
-				if (result && (result as StreamInfo).stream) {
-					this.debug(`[Player] Extension ${extension.name} provided stream for track: ${track.title}`);
-					return result as StreamInfo;
+		const streamPromise = (async () => {
+			// Only query extensions that have provideStream capability
+			const streamExtensions = this.findExtensionsByCapability("stream");
+
+			for (const extension of streamExtensions) {
+				const hook = (extension as any).provideStream;
+				if (typeof hook !== "function") continue;
+
+				try {
+					const result = await Promise.resolve(hook.call(extension, this.extensionContext, request));
+					if (result && (result as StreamInfo).stream) {
+						this.debug(`Extension ${extension.name} provided stream for: ${track.title}`);
+						this.setCachedStream(track, result as StreamInfo);
+						return result as StreamInfo;
+					}
+				} catch (err) {
+					this.debug(`Extension ${extension.name} provideStream error:`, err);
 				}
-			} catch (err) {
-				this.debug(`[Player] Extension ${extension.name} provideStream error:`, err);
 			}
+			return null;
+		})();
+
+		this.pendingStreams.set(cacheKey, streamPromise);
+
+		try {
+			return await streamPromise;
+		} finally {
+			this.pendingStreams.delete(cacheKey);
 		}
-		return null;
 	}
 
-	async BeforePlayHooks(
+	async beforePlayHooks(
 		initial: ExtensionPlayRequest,
 	): Promise<{ request: ExtensionPlayRequest; response: ExtensionPlayResponse }> {
 		const request: ExtensionPlayRequest = { ...initial };
 		const response: ExtensionPlayResponse = {};
-		for (const extension of this.getAll()) {
+
+		// Only query extensions that have beforePlay capability
+		const beforePlayExtensions = this.findExtensionsByCapability("beforePlay");
+
+		for (const extension of beforePlayExtensions) {
 			const hook = (extension as any).beforePlay;
 			if (typeof hook !== "function") continue;
+
 			try {
 				const result = await Promise.resolve(hook.call(extension, this.extensionContext, request));
 				if (!result) continue;
+
+				// Merge results
 				if (result.query !== undefined) {
 					request.query = result.query;
 					response.query = result.query;
@@ -164,27 +398,76 @@ export class ExtensionManager {
 					if (result.handled) break;
 				}
 			} catch (err) {
-				this.debug(`[Player] Extension ${extension.name} beforePlay error:`, err);
+				this.debug(`Extension ${extension.name} beforePlay error:`, err);
 			}
 		}
+
 		return { request, response };
 	}
 
-	async AfterPlayHooks(payload: ExtensionAfterPlayPayload): Promise<void> {
-		if (this.getAll().length === 0) return;
+	async afterPlayHooks(payload: ExtensionAfterPlayPayload): Promise<void> {
+		const afterPlayExtensions = this.findExtensionsByCapability("afterPlay");
+		if (afterPlayExtensions.length === 0) return;
+
+		// Create immutable payload
 		const safeTracks = payload.tracks ? [...payload.tracks] : undefined;
 		if (safeTracks) {
 			Object.freeze(safeTracks);
 		}
 		const immutablePayload = Object.freeze({ ...payload, tracks: safeTracks });
-		for (const extension of this.getAll()) {
+
+		// Execute hooks in parallel for better performance
+		const hooks = afterPlayExtensions.map(async (extension) => {
 			const hook = (extension as any).afterPlay;
-			if (typeof hook !== "function") continue;
+			if (typeof hook !== "function") return;
+
 			try {
 				await Promise.resolve(hook.call(extension, this.extensionContext, immutablePayload));
 			} catch (err) {
-				this.debug(`[Player] Extension ${extension.name} afterPlay error:`, err);
+				this.debug(`Extension ${extension.name} afterPlay error:`, err);
 			}
+		});
+
+		await Promise.allSettled(hooks);
+	}
+
+	/**
+	 * Get extension statistics
+	 */
+	getStats(): object {
+		const metadata = this.getAllMetadata();
+		return {
+			totalExtensions: this.extensions.size,
+			extensions: metadata.map((m) => ({
+				name: m.name,
+				priority: m.priority,
+				capabilities: {
+					search: m.hasSearch,
+					stream: m.hasStream,
+					beforePlay: m.hasBeforePlay,
+					afterPlay: m.hasAfterPlay,
+				},
+			})),
+			cacheStats: {
+				searchCacheSize: this.searchCache.size,
+				streamCacheSize: this.streamCache.size,
+				pendingSearches: this.pendingSearches.size,
+				pendingStreams: this.pendingStreams.size,
+			},
+		};
+	}
+
+	/**
+	 * Clear specific cache
+	 */
+	clearCache(type?: "search" | "stream"): void {
+		if (!type || type === "search") {
+			this.searchCache.clear();
+			this.debug("Search cache cleared");
+		}
+		if (!type || type === "stream") {
+			this.streamCache.clear();
+			this.debug("Stream cache cleared");
 		}
 	}
 }