@juspay/neurolink 11.2.2 → 11.2.4

package/dist/lib/utils/sttProcessor.d.ts

@@ -27,11 +27,10 @@ import type { STTOptions, STTResult, STTHandler } from "../types/index.js";
 export declare class STTProcessor {
     /**
      * Handler registry mapping provider names to STT handlers
-     * Uses Map for O(1) lookups and better type safety
      *
      * @private
      */
-    private static readonly handlers;
+    private static readonly registry;
     /**
      * Default maximum audio duration for STT transcription (in seconds)
      *
@@ -72,6 +71,15 @@ export declare class STTProcessor {
      * @returns Handler instance or undefined if not registered
      */
     static getHandler(providerName: string): STTHandler | undefined;
+    /**
+     * List the names of all registered providers.
+     */
+    static listProviders(): string[];
+    /**
+     * Removes every registered STT handler. Primarily for test isolation —
+     * production code should not need to call this.
+     */
+    static clearHandlers(): void;
     /**
      * Check if a provider is supported (has a registered STT handler)
      *

package/dist/lib/utils/sttProcessor.js

@@ -10,6 +10,7 @@ import { logger } from "./logger.js";
 import { STT_ERROR_CODES } from "../types/index.js";
 import { ErrorCategory, ErrorSeverity } from "../constants/enums.js";
 import { STTError } from "../voice/errors.js";
+import { HandlerRegistry } from "../core/handlerRegistry.js";
 import { SpanSerializer, SpanType, SpanStatus, getMetricsAggregator, } from "../observability/index.js";
 /**
  * STT processor class for orchestrating speech-to-text operations
@@ -31,11 +32,10 @@ import { SpanSerializer, SpanType, SpanStatus, getMetricsAggregator, } from "../
 export class STTProcessor {
     /**
      * Handler registry mapping provider names to STT handlers
-     * Uses Map for O(1) lookups and better type safety
      *
      * @private
      */
-    static handlers = new Map();
+    static registry = new HandlerRegistry("STTProcessor");
     /**
      * Default maximum audio duration for STT transcription (in seconds)
      *
@@ -66,17 +66,10 @@ export class STTProcessor {
      * ```
      */
     static registerHandler(providerName, handler) {
-        if (!providerName) {
-            throw new Error("Provider name is required");
-        }
-        if (!handler) {
-            throw new Error("Handler is required");
-        }
-        const normalizedName = providerName.toLowerCase();
-        if (this.handlers.has(normalizedName)) {
-            logger.warn(`[STTProcessor] Overwriting existing handler for provider: ${normalizedName}`);
-        }
-        this.handlers.set(normalizedName, handler);
+        const normalizedName = providerName
+            ? providerName.toLowerCase()
+            : providerName;
+        this.registry.register(providerName, handler);
         logger.debug(`[STTProcessor] Registered STT handler for provider: ${normalizedName}`);
     }
     /**
@@ -89,8 +82,20 @@ export class STTProcessor {
      * @returns Handler instance or undefined if not registered
      */
     static getHandler(providerName) {
-        const normalizedName = providerName.toLowerCase();
-        return this.handlers.get(normalizedName);
+        return this.registry.get(providerName);
+    }
+    /**
+     * List the names of all registered providers.
+     */
+    static listProviders() {
+        return this.registry.list();
+    }
+    /**
+     * Removes every registered STT handler. Primarily for test isolation —
+     * production code should not need to call this.
+     */
+    static clearHandlers() {
+        this.registry.clear();
     }
     /**
      * Check if a provider is supported (has a registered STT handler)
@@ -110,8 +115,7 @@ export class STTProcessor {
             logger.error("[STTProcessor] Provider name is required for supports check");
             return false;
         }
-        const normalizedName = providerName.toLowerCase();
-        const isSupported = this.handlers.has(normalizedName);
+        const isSupported = this.registry.supports(providerName);
         if (!isSupported) {
             logger.debug(`[STTProcessor] Provider ${providerName} is not supported`);
         }
@@ -192,7 +196,7 @@ export class STTProcessor {
                     retriable: false,
                     context: {
                         provider,
-                        availableProviders: Array.from(this.handlers.keys()),
+                        availableProviders: this.registry.list(),
                     },
                 });
             }

package/dist/lib/utils/ttsProcessor.d.ts

@@ -54,11 +54,10 @@ export declare class TTSError extends NeuroLinkError {
 export declare class TTSProcessor {
     /**
      * Handler registry mapping provider names to TTS handlers
-     * Uses Map for O(1) lookups and better type safety
      *
      * @private
      */
-    private static readonly handlers;
+    private static readonly registry;
     /**
      * Default maximum text length for TTS synthesis (in bytes)
      *
@@ -100,6 +99,15 @@ export declare class TTSProcessor {
      * @returns Handler instance or undefined if not registered
      */
     static getHandler(providerName: string): TTSHandler | undefined;
+    /**
+     * List the names of all registered providers.
+     */
+    static listProviders(): string[];
+    /**
+     * Removes every registered TTS handler. Primarily for test isolation —
+     * production code should not need to call this.
+     */
+    static clearHandlers(): void;
     /**
      * Check if a provider is supported (has a registered TTS handler)
      *

package/dist/lib/utils/ttsProcessor.js

@@ -9,6 +9,7 @@
 import { logger } from "./logger.js";
 import { ErrorCategory, ErrorSeverity } from "../constants/enums.js";
 import { NeuroLinkError } from "./errorHandling.js";
+import { HandlerRegistry } from "../core/handlerRegistry.js";
 import { SpanSerializer, SpanType, SpanStatus, getMetricsAggregator, } from "../observability/index.js";
 /**
  * TTS-specific error codes
@@ -58,11 +59,10 @@ export class TTSError extends NeuroLinkError {
 export class TTSProcessor {
     /**
      * Handler registry mapping provider names to TTS handlers
-     * Uses Map for O(1) lookups and better type safety
      *
      * @private
      */
-    static handlers = new Map();
+    static registry = new HandlerRegistry("TTSProcessor");
     /**
      * Default maximum text length for TTS synthesis (in bytes)
      *
@@ -93,17 +93,10 @@ export class TTSProcessor {
      * ```
      */
     static registerHandler(providerName, handler) {
-        if (!providerName) {
-            throw new Error("Provider name is required");
-        }
-        if (!handler) {
-            throw new Error("Handler is required");
-        }
-        const normalizedName = providerName.toLowerCase();
-        if (this.handlers.has(normalizedName)) {
-            logger.warn(`[TTSProcessor] Overwriting existing handler for provider: ${normalizedName}`);
-        }
-        this.handlers.set(normalizedName, handler);
+        const normalizedName = providerName
+            ? providerName.toLowerCase()
+            : providerName;
+        this.registry.register(providerName, handler);
         logger.debug(`[TTSProcessor] Registered TTS handler for provider: ${normalizedName}`);
     }
     /**
@@ -117,8 +110,20 @@ export class TTSProcessor {
      * @returns Handler instance or undefined if not registered
      */
     static getHandler(providerName) {
-        const normalizedName = providerName.toLowerCase();
-        return this.handlers.get(normalizedName);
+        return this.registry.get(providerName);
+    }
+    /**
+     * List the names of all registered providers.
+     */
+    static listProviders() {
+        return this.registry.list();
+    }
+    /**
+     * Removes every registered TTS handler. Primarily for test isolation —
+     * production code should not need to call this.
+     */
+    static clearHandlers() {
+        this.registry.clear();
     }
     /**
      * Check if a provider is supported (has a registered TTS handler)
@@ -138,8 +143,7 @@ export class TTSProcessor {
             logger.error("[TTSProcessor] Provider name is required for supports check");
             return false;
         }
-        const normalizedName = providerName.toLowerCase();
-        const isSupported = this.handlers.has(normalizedName);
+        const isSupported = this.registry.supports(providerName);
         if (!isSupported) {
             logger.debug(`[TTSProcessor] Provider ${providerName} is not supported`);
         }
@@ -211,7 +215,7 @@ export class TTSProcessor {
                     retriable: false,
                     context: {
                         provider,
-                        availableProviders: Array.from(this.handlers.keys()),
+                        availableProviders: this.registry.list(),
                     },
                 });
             }

package/dist/lib/utils/videoProcessor.d.ts

@@ -22,7 +22,7 @@ export { VideoError, VIDEO_ERROR_CODES };
  * O(1) on a normalised lower-case provider key.
  */
 export declare class VideoProcessor {
-    private static readonly handlers;
+    private static readonly registry;
     /**
      * Register a video handler for a specific provider.
      */
@@ -36,6 +36,10 @@ export declare class VideoProcessor {
      */
     static listProviders(): string[];
     private static getHandler;
+    /**
+     * Clear all registered handlers (for testing).
+     */
+    static clearHandlers(): void;
     private static buildSpanAttributes;
     /**
      * Generate a single video clip via the registered handler.

package/dist/lib/utils/videoProcessor.js

@@ -19,6 +19,7 @@ import { logger } from "./logger.js";
 // the same module. Both throws and instanceof checks resolve to the same
 // class.
 import { VideoError } from "../adapters/video/vertexVideoHandler.js";
+import { HandlerRegistry } from "../core/handlerRegistry.js";
 export { VideoError, VIDEO_ERROR_CODES };
 /**
  * Static processor managing the video handler registry.
@@ -28,41 +29,35 @@ export { VideoError, VIDEO_ERROR_CODES };
  * O(1) on a normalised lower-case provider key.
  */
 export class VideoProcessor {
-    static handlers = new Map();
+    static registry = new HandlerRegistry("VideoProcessor");
     /**
      * Register a video handler for a specific provider.
      */
     static registerHandler(providerName, handler) {
-        if (!providerName) {
-            throw new Error("Provider name is required");
-        }
-        if (!handler) {
-            throw new Error("Handler is required");
-        }
-        const key = providerName.toLowerCase();
-        if (this.handlers.has(key)) {
-            logger.warn(`[VideoProcessor] Overwriting existing handler for provider: ${key}`);
-        }
-        this.handlers.set(key, handler);
+        const key = providerName ? providerName.toLowerCase() : providerName;
+        this.registry.register(providerName, handler);
         logger.debug(`[VideoProcessor] Registered video handler: ${key}`);
     }
     /**
      * Check if a provider has a registered video handler.
      */
     static supports(providerName) {
-        if (!providerName) {
-            return false;
-        }
-        return this.handlers.has(providerName.toLowerCase());
+        return this.registry.supports(providerName);
     }
     /**
      * List the names of all registered providers.
      */
     static listProviders() {
-        return Array.from(this.handlers.keys());
+        return this.registry.list();
     }
     static getHandler(providerName) {
-        return this.handlers.get(providerName.toLowerCase());
+        return this.registry.get(providerName);
+    }
+    /**
+     * Clear all registered handlers (for testing).
+     */
+    static clearHandlers() {
+        this.registry.clear();
     }
     static buildSpanAttributes(provider, options) {
         return {

package/dist/lib/voice/RealtimeVoiceAPI.d.ts

@@ -36,7 +36,7 @@ export declare class RealtimeProcessor {
     /**
      * Handler registry mapping provider names to Realtime handlers
      */
-    private static readonly handlers;
+    private static readonly registry;
     /**
      * Active sessions by provider
      */

package/dist/lib/voice/RealtimeVoiceAPI.js

@@ -10,6 +10,7 @@ import { logger } from "../utils/logger.js";
 import { RealtimeError } from "./errors.js";
 import { DEFAULT_REALTIME_CONFIG, REALTIME_ERROR_CODES, } from "../types/index.js";
 import { ErrorCategory, ErrorSeverity } from "../constants/enums.js";
+import { HandlerRegistry } from "../core/handlerRegistry.js";
 /**
  * Realtime Processor class for orchestrating realtime voice operations
  *
@@ -39,7 +40,7 @@ export class RealtimeProcessor {
     /**
      * Handler registry mapping provider names to Realtime handlers
      */
-    static handlers = new Map();
+    static registry = new HandlerRegistry("RealtimeProcessor");
     /**
      * Active sessions by provider
      */
@@ -51,17 +52,10 @@ export class RealtimeProcessor {
      * @param handler - Realtime handler implementation
      */
     static registerHandler(providerName, handler) {
-        if (!providerName) {
-            throw new Error("Provider name is required");
-        }
-        if (!handler) {
-            throw new Error("Handler is required");
-        }
-        const normalizedName = providerName.toLowerCase();
-        if (this.handlers.has(normalizedName)) {
-            logger.warn(`[RealtimeProcessor] Overwriting existing handler for provider: ${normalizedName}`);
-        }
-        this.handlers.set(normalizedName, handler);
+        const normalizedName = providerName
+            ? providerName.toLowerCase()
+            : providerName;
+        this.registry.register(providerName, handler);
         logger.debug(`[RealtimeProcessor] Registered Realtime handler for provider: ${normalizedName}`);
     }
     /**
@@ -71,24 +65,19 @@ export class RealtimeProcessor {
      * already-registered primary handler when backfilling its aliases.
      */
     static getHandler(providerName) {
-        const normalizedName = providerName.toLowerCase();
-        return this.handlers.get(normalizedName);
+        return this.registry.get(providerName);
     }
     /**
      * Check if a provider is supported
      */
     static supports(providerName) {
-        if (!providerName) {
-            return false;
-        }
-        const normalizedName = providerName.toLowerCase();
-        return this.handlers.has(normalizedName);
+        return this.registry.supports(providerName);
     }
     /**
      * Get list of all registered providers
      */
     static getProviders() {
-        return Array.from(this.handlers.keys());
+        return this.registry.list();
     }
     /**
      * Connect to a realtime session
@@ -101,7 +90,7 @@ export class RealtimeProcessor {
     static async connect(provider, config, handlers) {
         const handler = this.getHandler(provider);
         if (!handler) {
-            throw RealtimeError.providerNotSupported(provider, Array.from(this.handlers.keys()));
+            throw RealtimeError.providerNotSupported(provider, this.registry.list());
         }
         if (!handler.isConfigured()) {
             throw RealtimeError.providerNotConfigured(provider);
@@ -145,7 +134,7 @@ export class RealtimeProcessor {
     static async disconnect(provider) {
         const handler = this.getHandler(provider);
         if (!handler) {
-            throw RealtimeError.providerNotSupported(provider, Array.from(this.handlers.keys()));
+            throw RealtimeError.providerNotSupported(provider, this.registry.list());
         }
         if (!handler.isConnected()) {
             logger.warn(`[RealtimeProcessor] No active session for provider: ${provider}`);
@@ -174,7 +163,7 @@ export class RealtimeProcessor {
     static async sendAudio(provider, audio) {
         const handler = this.getHandler(provider);
         if (!handler) {
-            throw RealtimeError.providerNotSupported(provider, Array.from(this.handlers.keys()));
+            throw RealtimeError.providerNotSupported(provider, this.registry.list());
         }
         if (!handler.isConnected()) {
             throw RealtimeError.sessionNotActive(provider);
@@ -199,7 +188,7 @@ export class RealtimeProcessor {
     static async sendText(provider, text) {
         const handler = this.getHandler(provider);
         if (!handler) {
-            throw RealtimeError.providerNotSupported(provider, Array.from(this.handlers.keys()));
+            throw RealtimeError.providerNotSupported(provider, this.registry.list());
         }
         if (!handler.isConnected()) {
             throw RealtimeError.sessionNotActive(provider);
@@ -243,7 +232,7 @@ export class RealtimeProcessor {
     static async triggerResponse(provider) {
         const handler = this.getHandler(provider);
         if (!handler) {
-            throw RealtimeError.providerNotSupported(provider, Array.from(this.handlers.keys()));
+            throw RealtimeError.providerNotSupported(provider, this.registry.list());
         }
         if (!handler.isConnected()) {
             throw RealtimeError.sessionNotActive(provider);
@@ -276,7 +265,7 @@ export class RealtimeProcessor {
     static async cancelResponse(provider) {
         const handler = this.getHandler(provider);
         if (!handler) {
-            throw RealtimeError.providerNotSupported(provider, Array.from(this.handlers.keys()));
+            throw RealtimeError.providerNotSupported(provider, this.registry.list());
         }
         if (!handler.isConnected()) {
             return; // Nothing to cancel
@@ -335,15 +324,15 @@ export class RealtimeProcessor {
     static clearHandlers() {
         // Disconnect all active sessions
         for (const [provider] of this.sessions) {
-            const handler = this.handlers.get(provider);
+            const handler = this.registry.get(provider);
             if (handler?.isConnected()) {
                 handler.disconnect().catch(() => {
                     // Ignore errors during cleanup
                 });
             }
         }
-        this.handlers.clear();
         this.sessions.clear();
+        this.registry.clear();
         logger.debug("[RealtimeProcessor] Cleared all handlers and sessions");
     }
 }

package/dist/providers/configuredOpenAICompat.js

@@ -2,6 +2,7 @@ import { logger } from "../utils/logger.js";
 import { redactUrlCredentials } from "../utils/logSanitize.js";
 import { getProviderModel, resolveOpenAICompatConfig, } from "../utils/providerConfig.js";
 import { classifyProviderError } from "../utils/errorClassifier.js";
+import { TimeoutError } from "../utils/timeout.js";
 import { OpenAIChatCompletionsProvider } from "./openaiChatCompletionsBase.js";
 /**
  * Generic OpenAI-compatible provider driven entirely by an
@@ -51,9 +52,15 @@ export class ConfiguredOpenAICompatProvider extends OpenAIChatCompletionsProvide
         return this.entry.fallbackModels;
     }
     formatProviderError(error) {
-        // classifyProviderError handles TimeoutError internally (always maps
-        // to NetworkError, ahead of any rule table) — no local pre-check
-        // needed or wanted here; see this task's design note.
+        // classifyProviderError hard-codes TimeoutError -> NetworkError ahead
+        // of any rule table and does not allow a per-provider override. An
+        // entry can opt out of that default via timeoutErrorClass (currently
+        // only Groq, reproducing its pre-migration subclass's own TimeoutError
+        // interception) — checked here, before ever reaching the shared
+        // classifier, so every other entry still gets its unmodified default.
+        if (error instanceof TimeoutError && this.entry.timeoutErrorClass) {
+            return new this.entry.timeoutErrorClass(`${this.entry.configOptions.providerName} request timed out: ${error.message}`, this.entry.providerName);
+        }
         return classifyProviderError(error, this.entry.errorRules, this.entry.providerName, this.modelName);
     }
 }

package/dist/providers/openaiCompatCatalog.js

@@ -49,17 +49,15 @@ export const OPENAI_COMPAT_CATALOG = [
             GroqModels.LLAMA_3_2_90B_VISION_PREVIEW,
             GroqModels.LLAMA_3_2_11B_VISION_PREVIEW,
         ],
-        // KNOWN GAP (not reproducible by this data-only array — flagged for PR C,
-        // see plan-05/task-A-report.md): live GroqProvider.formatProviderError()
-        // intercepts TimeoutError and returns a plain ProviderError BEFORE ever
-        // calling classifyProviderError, overriding that function's own
-        // (non-overridable) rule that TimeoutError always maps to NetworkError.
-        // ConfiguredOpenAICompatProvider.formatProviderError() has no such
-        // pre-check hook, so migrating Groq onto it as-is would silently
-        // reclassify Groq timeouts as NetworkError. This entry's errorRules
-        // still mirrors Groq's live rule array faithfully for every other error
-        // shape; the TimeoutError special case is a structural gap in
-        // ConfiguredOpenAICompatProvider, not a data error here.
+        // Groq's pre-migration subclass intercepted TimeoutError itself and
+        // returned a plain ProviderError, ahead of classifyProviderError's own
+        // non-overridable TimeoutError -> NetworkError default. Expressed here
+        // as data — see OpenAICompatCatalogEntry.timeoutErrorClass and
+        // ConfiguredOpenAICompatProvider.formatProviderError, which consults
+        // this field before ever delegating to the shared classifier. No other
+        // entry in this catalog sets it, so every other provider still gets
+        // the classifier's unmodified default.
+        timeoutErrorClass: ProviderError,
         errorRules: [
             {
                 match: (ctx) => ctx.statusCode === 401 ||

package/dist/types/providers.d.ts

@@ -8,7 +8,7 @@ import type { ValidationSchema } from "./aliases.js";
 import type { EnhancedGenerateResult, GenerateResult, TextGenerationOptions } from "./generate.js";
 import type { MultimodalAudioEntry } from "./file.js";
 import type { StreamOptions, StreamResult } from "./stream.js";
-import type { ProviderErrorRule } from "./errors.js";
+import type { ProviderError, ProviderErrorRule } from "./errors.js";
 import type { ExternalMCPToolInfo } from "./externalMcp.js";
 import type { ClaudeSubscriptionTier, AnthropicAuthMethod, AnthropicAuthConfig, SubscriptionInfo, OAuthToken } from "./subscription.js";
 import type { Tool } from "./tools.js";
@@ -671,6 +671,20 @@ export type OpenAICompatCatalogEntry = {
      * Task 4, so nothing actually mutates it at runtime.
      */
     errorRules: ProviderErrorRule[];
+    /**
+     * Optional override for the Error subclass a TimeoutError should produce
+     * for this entry. classifyProviderError() hard-codes
+     * TimeoutError -> NetworkError unconditionally, ahead of any rule table,
+     * and does not make that mapping overridable per-provider (see
+     * errorClassifier.ts). Groq's pre-migration subclass predates that
+     * shared classifier and intercepted TimeoutError itself, returning a
+     * plain ProviderError instead — this field lets
+     * ConfiguredOpenAICompatProvider reproduce that one documented
+     * divergence as data (see its formatProviderError), rather than adding a
+     * class-level hook back in. Omit for every entry whose timeout should use
+     * the classifier's default (six of the seven catalog entries).
+     */
+    timeoutErrorClass?: new (message: string, provider?: string) => ProviderError;
 };
 /** The subset of OpenAICompatCatalogEntry that resolveOpenAICompatConfig()
  *  needs — lets call sites pass a minimal object without the full catalog

package/dist/utils/avatarProcessor.d.ts

@@ -43,7 +43,7 @@ export declare class AvatarError extends NeuroLinkError {
  * Static processor managing the avatar handler registry.
  */
 export declare class AvatarProcessor {
-    private static readonly handlers;
+    private static readonly registry;
     /**
      * Register an avatar handler for a specific provider.
      */
@@ -63,6 +63,10 @@ export declare class AvatarProcessor {
      * already-registered primary handler when backfilling its aliases.
      */
     static getHandler(providerName: string): AvatarHandler | undefined;
+    /**
+     * Clear all registered handlers (for testing).
+     */
+    static clearHandlers(): void;
     private static buildSpanAttributes;
     /**
      * Generate an avatar video via the registered handler.

package/dist/utils/avatarProcessor.js

@@ -13,6 +13,7 @@ import { ErrorCategory, ErrorSeverity } from "../constants/enums.js";
 import { SpanSerializer, SpanStatus, SpanType, getMetricsAggregator, } from "../observability/index.js";
 import { NeuroLinkError } from "./errorHandling.js";
 import { logger } from "./logger.js";
+import { HandlerRegistry } from "../core/handlerRegistry.js";
 /**
  * Avatar-specific error codes.
  */
@@ -47,38 +48,26 @@ export class AvatarError extends NeuroLinkError {
  * Static processor managing the avatar handler registry.
  */
 export class AvatarProcessor {
-    static handlers = new Map();
+    static registry = new HandlerRegistry("AvatarProcessor");
     /**
      * Register an avatar handler for a specific provider.
      */
     static registerHandler(providerName, handler) {
-        if (!providerName) {
-            throw new Error("Provider name is required");
-        }
-        if (!handler) {
-            throw new Error("Handler is required");
-        }
-        const key = providerName.toLowerCase();
-        if (this.handlers.has(key)) {
-            logger.warn(`[AvatarProcessor] Overwriting existing handler for provider: ${key}`);
-        }
-        this.handlers.set(key, handler);
+        const key = providerName ? providerName.toLowerCase() : providerName;
+        this.registry.register(providerName, handler);
         logger.debug(`[AvatarProcessor] Registered avatar handler: ${key}`);
     }
     /**
      * Check if a provider has a registered avatar handler.
      */
     static supports(providerName) {
-        if (!providerName) {
-            return false;
-        }
-        return this.handlers.has(providerName.toLowerCase());
+        return this.registry.supports(providerName);
     }
     /**
      * List the names of all registered providers.
      */
     static listProviders() {
-        return Array.from(this.handlers.keys());
+        return this.registry.list();
     }
     /**
      * Get a registered avatar handler by provider name.
@@ -87,7 +76,13 @@ export class AvatarProcessor {
      * already-registered primary handler when backfilling its aliases.
      */
     static getHandler(providerName) {
-        return this.handlers.get(providerName.toLowerCase());
+        return this.registry.get(providerName);
+    }
+    /**
+     * Clear all registered handlers (for testing).
+     */
+    static clearHandlers() {
+        this.registry.clear();
     }
     static buildSpanAttributes(provider, options) {
         return {

package/dist/utils/musicProcessor.d.ts

@@ -42,7 +42,7 @@ export declare class MusicError extends NeuroLinkError {
  * Static processor managing the music handler registry.
  */
 export declare class MusicProcessor {
-    private static readonly handlers;
+    private static readonly registry;
     /**
      * Register a music handler for a specific provider.
      */
@@ -62,6 +62,10 @@ export declare class MusicProcessor {
      * already-registered primary handler when backfilling its aliases.
      */
     static getHandler(providerName: string): MusicHandler | undefined;
+    /**
+     * Clear all registered handlers (for testing).
+     */
+    static clearHandlers(): void;
     private static buildSpanAttributes;
     /**
      * Generate a music track via the registered handler.