@viji-dev/sdk 1.0.0 → 1.0.1

package/src/stores/scene-player/input-manager.store.ts

@@ -1,1045 +0,0 @@
-import { create } from 'zustand';
-import { persist, createJSONStorage } from 'zustand/middleware';
-
-// Input Source Types
-export enum AudioInputType {
-  NONE = 'none',
-  MICROPHONE = 'microphone', 
-  SCREEN_AUDIO = 'screen_audio',
-  FILES = 'files'
-}
-
-export enum VideoInputType {
-  NONE = 'none',
-  CAMERA = 'camera',
-  SCREEN_VIDEO = 'screen_video',
-  FILES = 'files'
-}
-
-// File Input Types
-export interface AudioFile {
-  id: string;
-  name: string;
-  url: string;
-  size: number;
-  type: string;
-  duration?: number;
-}
-
-export interface VideoFile {
-  id: string;
-  name: string;
-  url: string;
-  size: number;
-  type: string;
-  duration?: number;
-  width?: number;
-  height?: number;
-}
-
-// Player State Types
-export interface AudioPlayerState {
-  isPlaying: boolean;
-  isPaused: boolean;
-  currentTime: number;
-  duration: number;
-  volume: number;
-  isMuted: boolean;
-  playbackRate: number;
-  currentTrackId?: string;
-}
-
-export interface VideoPlayerState {
-  isPlaying: boolean;
-  isPaused: boolean;
-  currentTime: number;
-  duration: number;
-  volume: number;
-  isMuted: boolean;
-  playbackRate: number;
-  currentFileId?: string;
-}
-
-export interface AudioInputConfig {
-  type: AudioInputType;
-  enabled: boolean;
-  
-  // Device Input (Microphone)
-  deviceId?: string;
-  deviceLabel?: string;
-  volume: number;
-  isMuted: boolean;
-  
-  // File Input
-  files: AudioFile[];
-  playerState: AudioPlayerState;
-  
-  // Screen Audio
-  screenAudioEnabled: boolean;
-  
-  // Generated Stream
-  stream?: MediaStream;
-}
-
-export interface VideoInputConfig {
-  type: VideoInputType;
-  enabled: boolean;
-  
-  // Device Input (Camera)
-  deviceId?: string;
-  deviceLabel?: string;
-  resolution?: { width: number; height: number };
-  
-  // File Input
-  files: VideoFile[];
-  playerState: VideoPlayerState;
-  
-  // Screen Video
-  screenVideoEnabled: boolean;
-  
-  // Generated Stream
-  stream?: MediaStream;
-}
-
-export interface InputPermissions {
-  audio: boolean;
-  video: boolean;
-  screenCapture: boolean;
-}
-
-export interface InputConfiguration {
-  audio: AudioInputConfig;
-  video: VideoInputConfig;
-  permissions: InputPermissions;
-  interactionEnabled: boolean;
-}
-
-// Input Manager Store State
-interface InputManagerState {
-  inputConfiguration: InputConfiguration;
-  
-  // Available Devices
-  availableDevices: {
-    audioDevices: MediaDeviceInfo[];
-    videoDevices: MediaDeviceInfo[];
-  };
-  
-  // Permission Management
-  isRequestingPermissions: boolean;
-  lastPermissionError: string | null;
-  
-  // File Management
-  isLoadingFiles: boolean;
-  fileLoadError: string | null;
-  
-  // Stream Management
-  isCreatingStream: boolean;
-  streamError: string | null;
-  
-  // Player Management
-  audioElement?: HTMLAudioElement;
-  videoElement?: HTMLVideoElement;
-  canvasElement?: HTMLCanvasElement;
-  imageAnimationFrameId?: number;
-  
-  // Device Fallback Management
-  previousWorkingAudioDevice: {
-    deviceId?: string;
-    deviceLabel?: string;
-  } | null;
-  previousWorkingVideoDevice: {
-    deviceId?: string;
-    deviceLabel?: string;
-  } | null;
-}
-
-// Input Manager Store Actions
-interface InputManagerActions {
-  // Configuration Management
-  setInputConfiguration: (config: InputConfiguration) => void;
-  updateAudioConfig: (config: Partial<AudioInputConfig>) => void;
-  updateVideoConfig: (config: Partial<VideoInputConfig>) => void;
-  updatePermissions: (permissions: Partial<InputPermissions>) => void;
-  
-  // Audio Input Management
-  setAudioInputType: (type: AudioInputType) => Promise<void>;
-  selectAudioDevice: (deviceId: string, deviceLabel: string) => Promise<void>;
-  setAudioVolume: (volume: number) => void;
-  setAudioMuted: (muted: boolean) => void;
-  enableScreenAudio: () => Promise<void>;
-  
-  // Video Input Management
-  setVideoInputType: (type: VideoInputType) => Promise<void>;
-  selectVideoDevice: (deviceId: string, deviceLabel: string) => Promise<void>;
-  setVideoResolution: (width: number, height: number) => void;
-  enableScreenVideo: () => Promise<void>;
-  
-  // File Management
-  addAudioFiles: (files: File[]) => Promise<void>;
-  removeAudioFile: (fileId: string) => void;
-  addVideoFiles: (files: File[]) => Promise<void>;
-  removeVideoFile: (fileId: string) => void;
-  clearAllFiles: () => void;
-  
-  // Audio Player Controls
-  playAudio: (trackId?: string) => Promise<void>;
-  pauseAudio: () => void;
-  stopAudio: () => void;
-  nextTrack: () => void;
-  previousTrack: () => void;
-  seekAudio: (time: number) => void;
-  setPlaybackRate: (rate: number) => void;
-  
-  // Video Player Controls
-  playVideo: (fileId?: string) => Promise<void>;
-  pauseVideo: () => void;
-  stopVideo: () => void;
-  seekVideo: (time: number) => void;
-  setVideoPlaybackRate: (rate: number) => void;
-  
-  // Device Management
-  setAvailableDevices: (devices: { audioDevices: MediaDeviceInfo[], videoDevices: MediaDeviceInfo[] }) => void;
-  refreshAvailableDevices: () => Promise<void>;
-  syncDevicesFromActiveStreams: () => void;
-  
-  // Permission Management
-  requestPermissions: (audio?: boolean, video?: boolean) => Promise<boolean>;
-  setPermissionRequesting: (requesting: boolean) => void;
-  
-  // Stream Management
-  createAudioStream: () => Promise<void>;
-  createVideoStream: () => Promise<void>;
-  updateStreamsForCore: () => Promise<{ audioStream?: MediaStream; videoStream?: MediaStream }>;
-  clearStreams: () => void;
-  
-  // Interaction Management
-  setInteractionEnabled: (enabled: boolean) => void;
-  
-  // Error Handling
-  setPermissionError: (error: string) => void;
-  setFileLoadError: (error: string) => void;
-  setStreamError: (error: string | null) => void;
-  clearErrors: () => void;
-  
-  // Device Fallback Management
-  storePreviousWorkingAudioDevice: (deviceId?: string, deviceLabel?: string) => void;
-  storePreviousWorkingVideoDevice: (deviceId?: string, deviceLabel?: string) => void;
-  revertToWorkingAudioDevice: () => Promise<boolean>;
-  revertToWorkingVideoDevice: () => Promise<boolean>;
-  
-  // Utility Methods
-  hasAudioPermission: () => boolean;
-  hasVideoPermission: () => boolean;
-  hasScreenCapturePermission: () => boolean;
-  hasActiveAudioStream: () => boolean;
-  hasActiveVideoStream: () => boolean;
-  resetToDefaults: () => void;
-}
-
-// Combined Store Type
-type InputManagerStore = InputManagerState & InputManagerActions;
-
-// Default configurations
-const createDefaultAudioConfig = (): AudioInputConfig => ({
-  type: AudioInputType.NONE,
-  enabled: false,
-  volume: 1.0,
-  isMuted: false,
-  files: [],
-  playerState: {
-    isPlaying: false,
-    isPaused: false,
-    currentTime: 0,
-    duration: 0,
-    volume: 1.0,
-    isMuted: false,
-    playbackRate: 1.0,
-  },
-  screenAudioEnabled: false,
-});
-
-const createDefaultVideoConfig = (): VideoInputConfig => ({
-  type: VideoInputType.NONE,
-  enabled: false,
-  files: [],
-  playerState: {
-    isPlaying: false,
-    isPaused: false,
-    currentTime: 0,
-    duration: 0,
-    volume: 1.0,
-    isMuted: false,
-    playbackRate: 1.0,
-  },
-  screenVideoEnabled: false,
-});
-
-const createDefaultInputConfiguration = (): InputConfiguration => ({
-  audio: createDefaultAudioConfig(),
-  video: createDefaultVideoConfig(),
-  permissions: {
-    audio: false,
-    video: false,
-    screenCapture: false,
-  },
-  interactionEnabled: true,
-});
-
-// Initial State
-const initialState: InputManagerState = {
-  inputConfiguration: createDefaultInputConfiguration(),
-  availableDevices: {
-    audioDevices: [],
-    videoDevices: [],
-  },
-  isRequestingPermissions: false,
-  lastPermissionError: null,
-  isLoadingFiles: false,
-  fileLoadError: null,
-  isCreatingStream: false,
-  streamError: null,
-  previousWorkingAudioDevice: null,
-  previousWorkingVideoDevice: null,
-};
-
-// Create Zustand Store with Persistence
-export const useInputManagerStore = create<InputManagerStore>()(
-  persist(
-    (set, get) => ({
-      // Initial State
-      ...initialState,
-      
-      // Configuration Management Actions
-      setInputConfiguration: (inputConfiguration: InputConfiguration) => {
-        set({ inputConfiguration });
-      },
-      
-      updateAudioConfig: (config: Partial<AudioInputConfig>) => {
-        const { inputConfiguration } = get();
-        set({
-          inputConfiguration: {
-            ...inputConfiguration,
-            audio: {
-              ...inputConfiguration.audio,
-              ...config,
-            },
-          },
-        });
-      },
-      
-      updateVideoConfig: (config: Partial<VideoInputConfig>) => {
-        const { inputConfiguration } = get();
-        set({
-          inputConfiguration: {
-            ...inputConfiguration,
-            video: {
-              ...inputConfiguration.video,
-              ...config,
-            },
-          },
-        });
-      },
-      
-      updatePermissions: (permissions: Partial<InputPermissions>) => {
-        const { inputConfiguration } = get();
-        set({
-          inputConfiguration: {
-            ...inputConfiguration,
-            permissions: {
-              ...inputConfiguration.permissions,
-              ...permissions,
-            },
-          },
-        });
-      },
-      
-      // Audio Input Management (simplified implementations)
-      setAudioInputType: async (type: AudioInputType) => {
-        get().stopAudio();
-        get().updateAudioConfig({ stream: undefined });
-        get().updateAudioConfig({ 
-          type, 
-          enabled: type !== AudioInputType.NONE,
-          screenAudioEnabled: type === AudioInputType.SCREEN_AUDIO
-        });
-        
-        if (type === AudioInputType.SCREEN_AUDIO) {
-          await get().enableScreenAudio();
-          const { useSceneSessionStore } = await import('./scene-session.store');
-          const { updateCoreConfig } = useSceneSessionStore.getState();
-          await updateCoreConfig({ audioStream: get().inputConfiguration.audio.stream });
-          return;
-        }
-        
-        if (type !== AudioInputType.NONE) {
-          await get().createAudioStream();
-        }
-      },
-      
-      selectAudioDevice: async (deviceId: string, deviceLabel: string) => {
-        console.debug(`🎤 [SDK INPUT] selectAudioDevice`, { deviceId, deviceLabel });
-        get().updateAudioConfig({ deviceId, deviceLabel });
-        
-        if (get().inputConfiguration.audio.type === AudioInputType.MICROPHONE) {
-          await get().createAudioStream();
-        }
-      },
-      
-      setAudioVolume: (volume: number) => {
-        // Clamp and persist
-        const clamped = Math.max(0, Math.min(1, volume));
-        get().updateAudioConfig({ volume: clamped });
-        // Apply to active audio element
-        const el = get().audioElement;
-        if (el) {
-          el.volume = clamped;
-        }
-      },
-      
-      setAudioMuted: (isMuted: boolean) => {
-        get().updateAudioConfig({ isMuted });
-        const el = get().audioElement;
-        if (el) {
-          el.muted = isMuted;
-        }
-      },
-      
-      enableScreenAudio: async () => {
-        try {
-          set({ isCreatingStream: true, streamError: null });
-          // Must include video:true to get audio in some browsers
-          const screen = await (navigator.mediaDevices as any).getDisplayMedia({ audio: true, video: true });
-          const audioTracks = screen.getAudioTracks();
-          if (audioTracks.length === 0) {
-            // Stop video tracks and error out
-            screen.getVideoTracks().forEach((t: MediaStreamTrack) => t.stop());
-            throw new Error('No audio available from screen share. Ensure "Share audio" is enabled.');
-          }
-          const audioOnly = new MediaStream(audioTracks);
-          // Stop video tracks (we only need audio here)
-          screen.getVideoTracks().forEach((t: MediaStreamTrack) => t.stop());
-          get().updateAudioConfig({ stream: audioOnly, screenAudioEnabled: true });
-          // Apply to core
-          const { useSceneSessionStore } = await import('./scene-session.store');
-          await useSceneSessionStore.getState().updateCoreConfig({ audioStream: audioOnly });
-        } catch (err) {
-          const msg = err instanceof Error ? err.message : 'Failed to capture screen audio';
-          set({ streamError: msg });
-        } finally {
-          set({ isCreatingStream: false });
-        }
-      },
-      
-      // Video Input Management
-      setVideoInputType: async (type: VideoInputType) => {
-        get().stopVideo();
-        get().updateVideoConfig({ stream: undefined });
-        get().updateVideoConfig({ 
-          type, 
-          enabled: type !== VideoInputType.NONE 
-        });
-        
-        if (type !== VideoInputType.NONE) {
-          await get().createVideoStream();
-        }
-      },
-      
-      selectVideoDevice: async (deviceId: string, deviceLabel: string) => {
-        console.debug(`📹 [SDK INPUT] selectVideoDevice`, { deviceId, deviceLabel });
-        get().updateVideoConfig({ deviceId, deviceLabel });
-        
-        if (get().inputConfiguration.video.type === VideoInputType.CAMERA) {
-          await get().createVideoStream();
-        }
-      },
-      
-      setVideoResolution: (width: number, height: number) => {
-        get().updateVideoConfig({ resolution: { width, height } });
-      },
-      
-      enableScreenVideo: async () => {
-        console.debug('📺 [SDK INPUT] enableScreenVideo');
-        get().updateVideoConfig({ screenVideoEnabled: true });
-      },
-      
-      // File Management (simplified implementations)
-      addAudioFiles: async (files: File[]) => {
-        console.debug('🎵 [SDK INPUT] addAudioFiles', { count: files.length });
-        const audioFiles: AudioFile[] = files.map(file => ({
-          id: crypto.randomUUID(),
-          name: file.name,
-          url: URL.createObjectURL(file),
-          size: file.size,
-          type: file.type,
-        }));
-        const { inputConfiguration } = get();
-        get().updateAudioConfig({ files: [...inputConfiguration.audio.files, ...audioFiles] });
-      },
-      
-      removeAudioFile: (fileId: string) => {
-        const { inputConfiguration } = get();
-        const updatedFiles = inputConfiguration.audio.files.filter(f => f.id !== fileId);
-        get().updateAudioConfig({ files: updatedFiles });
-      },
-      
-      addVideoFiles: async (files: File[]) => {
-        console.debug('🎬 [SDK INPUT] addVideoFiles', { count: files.length });
-        const videoFiles: VideoFile[] = files.map(file => ({
-          id: crypto.randomUUID(),
-          name: file.name,
-          url: URL.createObjectURL(file),
-          size: file.size,
-          type: file.type,
-        }));
-        const { inputConfiguration } = get();
-        get().updateVideoConfig({ files: [...inputConfiguration.video.files, ...videoFiles] });
-      },
-      
-      removeVideoFile: (fileId: string) => {
-        const { inputConfiguration } = get();
-        const updatedFiles = inputConfiguration.video.files.filter(f => f.id !== fileId);
-        get().updateVideoConfig({ files: updatedFiles });
-      },
-      
-      clearAllFiles: () => {
-        get().updateAudioConfig({ files: [] });
-        get().updateVideoConfig({ files: [] });
-      },
-      
-      // Player controls
-      playAudio: async (trackId?: string) => {
-        try {
-          const { inputConfiguration } = get();
-          const files = inputConfiguration.audio.files;
-          if (files.length === 0) return;
-          const id = trackId || inputConfiguration.audio.playerState.currentTrackId || files[0].id;
-          const file = files.find(f => f.id === id) || files[0];
-
-          // Create or reuse audio element
-          let el = get().audioElement;
-          if (!el) {
-            el = new Audio();
-            el.crossOrigin = 'anonymous';
-            set({ audioElement: el });
-          }
-
-          // Wire up events to keep store in sync
-          el.onloadedmetadata = () => {
-            // Update duration on file item and player state
-            const state = get();
-            const list = state.inputConfiguration.audio.files.map(f => (
-              f.id === file.id ? { ...f, duration: el!.duration } : f
-            ));
-            state.updateAudioConfig({ files: list, playerState: { ...state.inputConfiguration.audio.playerState, duration: el!.duration } });
-          };
-          el.ontimeupdate = () => {
-            const state = get();
-            state.updateAudioConfig({ playerState: { ...state.inputConfiguration.audio.playerState, currentTime: el!.currentTime } });
-          };
-          el.onended = () => {
-            try { get().nextTrack(); } catch {}
-          };
-
-          // Apply settings
-          el.src = file.url;
-          el.volume = inputConfiguration.audio.volume;
-          el.muted = inputConfiguration.audio.isMuted;
-          el.playbackRate = inputConfiguration.audio.playerState.playbackRate;
-
-          await el.play();
-
-          // Update player state
-          get().updateAudioConfig({ playerState: { ...inputConfiguration.audio.playerState, currentTrackId: file.id, isPlaying: true, isPaused: false } });
-
-          // Create/update stream and push to core
-          await get().createAudioStream();
-          const { audioStream } = await get().updateStreamsForCore();
-          const { useSceneSessionStore } = await import('./scene-session.store');
-          await useSceneSessionStore.getState().updateCoreConfig({ audioStream });
-        } catch (error) {
-          console.error('Failed to play audio:', error);
-        }
-      },
-      
-      pauseAudio: () => {
-        const el = get().audioElement;
-        if (el) {
-          el.pause();
-        }
-        const ps = get().inputConfiguration.audio.playerState;
-        get().updateAudioConfig({ playerState: { ...ps, isPlaying: false, isPaused: true } });
-      },
-      
-      stopAudio: () => {
-        const el = get().audioElement;
-        if (el) {
-          el.pause();
-          el.currentTime = 0;
-        }
-        const ps = get().inputConfiguration.audio.playerState;
-        get().updateAudioConfig({ playerState: { ...ps, isPlaying: false, isPaused: false, currentTime: 0 } });
-      },
-      
-      nextTrack: () => {
-        const audio = get().inputConfiguration.audio;
-        if (audio.files.length === 0) return;
-        const idx = audio.files.findIndex(f => f.id === audio.playerState.currentTrackId);
-        const nextIdx = idx >= 0 ? (idx + 1) % audio.files.length : 0;
-        get().playAudio(audio.files[nextIdx].id);
-      },
-      
-      previousTrack: () => {
-        const audio = get().inputConfiguration.audio;
-        if (audio.files.length === 0) return;
-        const idx = audio.files.findIndex(f => f.id === audio.playerState.currentTrackId);
-        const prevIdx = idx > 0 ? idx - 1 : audio.files.length - 1;
-        get().playAudio(audio.files[prevIdx].id);
-      },
-      
-      seekAudio: (time: number) => {
-        const el = get().audioElement;
-        if (el) {
-          el.currentTime = Math.max(0, Math.min(Number.isFinite(el.duration) ? el.duration : time, time));
-        }
-        const ps = get().inputConfiguration.audio.playerState;
-        get().updateAudioConfig({ playerState: { ...ps, currentTime: time } });
-      },
-      
-      setPlaybackRate: (rate: number) => {
-        const el = get().audioElement;
-        if (el) {
-          el.playbackRate = rate;
-        }
-        const ps = get().inputConfiguration.audio.playerState;
-        get().updateAudioConfig({ playerState: { ...ps, playbackRate: rate } });
-      },
-      
-      // Video player controls
-      playVideo: async (fileId?: string) => {
-        try {
-          const { inputConfiguration } = get();
-          const files = inputConfiguration.video.files;
-          if (files.length === 0) return;
-          const id = fileId || inputConfiguration.video.playerState.currentFileId || files[0].id;
-          const file = files.find(f => f.id === id) || files[0];
-
-          // Create or reuse video element
-          let el = get().videoElement;
-          if (!el) {
-            el = document.createElement('video');
-            el.playsInline = true;
-            set({ videoElement: el });
-          }
-
-          // Wire up events
-          el.onloadedmetadata = () => {
-            const state = get();
-            const list = state.inputConfiguration.video.files.map(f => (
-              f.id === file.id ? { ...f, duration: el!.duration } : f
-            ));
-            state.updateVideoConfig({ files: list, playerState: { ...state.inputConfiguration.video.playerState, duration: el!.duration } });
-          };
-          el.ontimeupdate = () => {
-            const state = get();
-            state.updateVideoConfig({ playerState: { ...state.inputConfiguration.video.playerState, currentTime: el!.currentTime } });
-          };
-
-          // Apply settings
-          el.src = file.url;
-          el.muted = true; // avoid autoplay restrictions
-          el.loop = true;
-          el.playbackRate = inputConfiguration.video.playerState.playbackRate;
-
-          await el.play();
-
-          // Update state
-          get().updateVideoConfig({ playerState: { ...inputConfiguration.video.playerState, currentFileId: file.id, isPlaying: true, isPaused: false } });
-
-          // Create/update stream and push to core
-          await get().createVideoStream();
-          const { videoStream } = await get().updateStreamsForCore();
-          const { useSceneSessionStore } = await import('./scene-session.store');
-          await useSceneSessionStore.getState().updateCoreConfig({ videoStream });
-        } catch (error) {
-          console.error('Failed to play video:', error);
-        }
-      },
-      
-      pauseVideo: () => {
-        const el = get().videoElement;
-        if (el) {
-          el.pause();
-        }
-        const ps = get().inputConfiguration.video.playerState;
-        get().updateVideoConfig({ playerState: { ...ps, isPlaying: false, isPaused: true } });
-      },
-      
-      stopVideo: () => {
-        const el = get().videoElement;
-        if (el) {
-          el.pause();
-          el.currentTime = 0;
-        }
-        const ps = get().inputConfiguration.video.playerState;
-        get().updateVideoConfig({ playerState: { ...ps, isPlaying: false, isPaused: false, currentTime: 0 } });
-      },
-      
-      seekVideo: (time: number) => {
-        const el = get().videoElement;
-        if (el) {
-          el.currentTime = Math.max(0, Math.min(Number.isFinite(el.duration) ? el.duration : time, time));
-        }
-        const ps = get().inputConfiguration.video.playerState;
-        get().updateVideoConfig({ playerState: { ...ps, currentTime: time } });
-      },
-      
-      setVideoPlaybackRate: (rate: number) => {
-        const el = get().videoElement;
-        if (el) {
-          el.playbackRate = rate;
-        }
-        const ps = get().inputConfiguration.video.playerState;
-        get().updateVideoConfig({ playerState: { ...ps, playbackRate: rate } });
-      },
-      
-      // Device Management
-      setAvailableDevices: (devices) => {
-        set({ availableDevices: devices });
-      },
-      
-      refreshAvailableDevices: async () => {
-        try {
-          const devices = await navigator.mediaDevices.enumerateDevices();
-          const audioDevices = devices.filter(device => device.kind === 'audioinput');
-          const videoDevices = devices.filter(device => device.kind === 'videoinput');
-          
-          get().setAvailableDevices({ audioDevices, videoDevices });
-        } catch (error) {
-          console.error('Failed to enumerate devices:', error);
-        }
-      },
-      
-      syncDevicesFromActiveStreams: () => {
-        console.debug('🔄 [SDK INPUT] syncDevicesFromActiveStreams');
-      },
-      
-      // Permission Management
-      requestPermissions: async (audio = true, video = true) => {
-        set({ isRequestingPermissions: true, lastPermissionError: null });
-        
-        try {
-          const constraints: MediaStreamConstraints = {};
-          if (audio) constraints.audio = true;
-          if (video) constraints.video = true;
-          
-          const stream = await navigator.mediaDevices.getUserMedia(constraints);
-          
-          // Stop the stream immediately - we just wanted permissions
-          stream.getTracks().forEach(track => track.stop());
-          
-          get().updatePermissions({
-            audio: audio,
-            video: video,
-          });
-          
-          // Refresh available devices after getting permissions
-          await get().refreshAvailableDevices();
-          
-          return true;
-        } catch (error) {
-          const errorMessage = error instanceof Error ? error.message : 'Permission denied';
-          get().setPermissionError(errorMessage);
-          console.error('Permission request failed:', error);
-          return false;
-        } finally {
-          set({ isRequestingPermissions: false });
-        }
-      },
-      
-      setPermissionRequesting: (isRequestingPermissions: boolean) => {
-        set({ isRequestingPermissions });
-      },
-      
-      // Stream Management (simplified)
-      createAudioStream: async () => {
-        const { inputConfiguration } = get();
-        const audioConfig = inputConfiguration.audio;
-        
-        if (audioConfig.type === AudioInputType.MICROPHONE && audioConfig.deviceId) {
-          try {
-            set({ isCreatingStream: true, streamError: null });
-            
-            const stream = await navigator.mediaDevices.getUserMedia({
-              audio: { deviceId: { exact: audioConfig.deviceId } }
-            });
-            
-            get().updateAudioConfig({ stream });
-            console.debug('🎤 [SDK INPUT] Audio stream created');
-            
-          } catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Failed to create audio stream';
-            get().setStreamError(errorMessage);
-            console.error('Failed to create audio stream:', error);
-          } finally {
-            set({ isCreatingStream: false });
-          }
-        } else if (audioConfig.type === AudioInputType.FILES && audioConfig.files.length > 0) {
-          try {
-            set({ isCreatingStream: true, streamError: null });
-            // Capture from existing audio element if present; otherwise construct and start it
-            let audioEl = get().audioElement;
-            const trackId = audioConfig.playerState.currentTrackId || audioConfig.files[0].id;
-            const file = audioConfig.files.find(f => f.id === trackId) || audioConfig.files[0];
-            if (!audioEl) {
-              audioEl = new Audio();
-              audioEl.crossOrigin = 'anonymous';
-              audioEl.loop = true;
-              audioEl.src = file.url;
-              audioEl.volume = audioConfig.volume;
-              audioEl.muted = audioConfig.isMuted;
-              await audioEl.play().catch(() => {});
-              set({ audioElement: audioEl });
-            }
-            // @ts-ignore
-            const stream: MediaStream = (audioEl as any).captureStream ? (audioEl as any).captureStream() : (audioEl as any).mozCaptureStream?.();
-            if (stream) {
-              get().updateAudioConfig({ stream });
-              console.debug('🎵 [SDK INPUT] Audio file stream captured');
-            } else {
-              throw new Error('Audio captureStream not supported');
-            }
-          } catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Failed to create audio stream from file';
-            get().setStreamError(errorMessage);
-            console.error('Failed to create audio file stream:', error);
-          } finally {
-            set({ isCreatingStream: false });
-          }
-        }
-      },
-      
-      createVideoStream: async () => {
-        const { inputConfiguration } = get();
-        const videoConfig = inputConfiguration.video;
-        
-        if (videoConfig.type === VideoInputType.CAMERA && videoConfig.deviceId) {
-          try {
-            set({ isCreatingStream: true, streamError: null });
-            
-            const constraints: MediaStreamConstraints = {
-              video: {
-                deviceId: { exact: videoConfig.deviceId },
-                ...(videoConfig.resolution && {
-                  width: { exact: videoConfig.resolution.width },
-                  height: { exact: videoConfig.resolution.height }
-                })
-              }
-            };
-            
-            const stream = await navigator.mediaDevices.getUserMedia(constraints);
-            
-            get().updateVideoConfig({ stream });
-            console.debug('📹 [SDK INPUT] Video stream created');
-            
-          } catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Failed to create video stream';
-            get().setStreamError(errorMessage);
-            console.error('Failed to create video stream:', error);
-          } finally {
-            set({ isCreatingStream: false });
-          }
-        } else if (videoConfig.type === VideoInputType.SCREEN_VIDEO) {
-          try {
-            set({ isCreatingStream: true, streamError: null });
-            const stream = await navigator.mediaDevices.getDisplayMedia({
-              audio: false,
-              video: true,
-            });
-
-            // keep stream alive by binding to hidden video element
-            let videoEl = get().videoElement;
-            if (!videoEl) {
-              videoEl = document.createElement('video');
-              videoEl.style.display = 'none';
-              videoEl.playsInline = true;
-              videoEl.muted = true;
-              document.body.appendChild(videoEl);
-              set({ videoElement: videoEl });
-            }
-            try {
-              // @ts-ignore
-              if ('srcObject' in videoEl) {
-                // @ts-ignore
-                videoEl.srcObject = stream;
-              } else {
-                // @ts-ignore
-                videoEl.src = URL.createObjectURL(stream);
-              }
-              await videoEl.play().catch(() => {});
-            } catch {}
-
-            get().updateVideoConfig({ stream, screenVideoEnabled: true });
-            console.debug('📺 [SDK INPUT] Screen video stream created');
-
-          } catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Failed to capture screen video';
-            set({ streamError: errorMessage });
-          } finally {
-            set({ isCreatingStream: false });
-          }
-        } else if (videoConfig.type === VideoInputType.FILES && videoConfig.files.length > 0) {
-          try {
-            set({ isCreatingStream: true, streamError: null });
-            const file = videoConfig.files.find(f => f.id === videoConfig.playerState.currentFileId) || videoConfig.files[0];
-            let videoEl = get().videoElement;
-            if (!videoEl) {
-              videoEl = document.createElement('video');
-              videoEl.src = file.url;
-              videoEl.muted = true;
-              videoEl.loop = true;
-              videoEl.playsInline = true;
-              await videoEl.play().catch(() => {});
-              set({ videoElement: videoEl });
-            }
-            // @ts-ignore
-            const stream: MediaStream = (videoEl as any).captureStream ? (videoEl as any).captureStream() : (videoEl as any).mozCaptureStream?.();
-            if (stream) {
-              get().updateVideoConfig({ stream });
-              console.debug('🎬 [SDK INPUT] Video file stream captured');
-            } else {
-              throw new Error('Video captureStream not supported');
-            }
-          } catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Failed to create video stream from file';
-            get().setStreamError(errorMessage);
-            console.error('Failed to create video file stream:', error);
-          } finally {
-            set({ isCreatingStream: false });
-          }
-        }
-      },
-      
-      updateStreamsForCore: async () => {
-        const config = get().inputConfiguration;
-        if (config.audio.enabled && config.audio.type !== AudioInputType.NONE && !config.audio.stream) {
-          await get().createAudioStream();
-        }
-        if (config.video.enabled && config.video.type !== VideoInputType.NONE && !config.video.stream) {
-          await get().createVideoStream();
-        }
-        return {
-          audioStream: (config.audio.enabled && config.audio.type !== AudioInputType.NONE) ? get().inputConfiguration.audio.stream : undefined,
-          videoStream: (config.video.enabled && config.video.type !== VideoInputType.NONE) ? get().inputConfiguration.video.stream : undefined,
-        };
-      },
-      
-      clearStreams: () => {
-        const { inputConfiguration } = get();
-        
-        // Stop audio stream
-        if (inputConfiguration.audio.stream) {
-          inputConfiguration.audio.stream.getTracks().forEach(track => track.stop());
-          get().updateAudioConfig({ stream: undefined });
-        }
-        
-        // Stop video stream
-        if (inputConfiguration.video.stream) {
-          inputConfiguration.video.stream.getTracks().forEach(track => track.stop());
-          get().updateVideoConfig({ stream: undefined });
-        }
-      },
-      
-      // Interaction Management
-      setInteractionEnabled: (interactionEnabled: boolean) => {
-        const { inputConfiguration } = get();
-        set({
-          inputConfiguration: {
-            ...inputConfiguration,
-            interactionEnabled,
-          },
-        });
-      },
-      
-      // Error Handling
-      setPermissionError: (lastPermissionError: string) => {
-        set({ lastPermissionError });
-      },
-      
-      setFileLoadError: (fileLoadError: string) => {
-        set({ fileLoadError });
-      },
-      
-      setStreamError: (streamError: string | null) => {
-        set({ streamError });
-      },
-      
-      clearErrors: () => {
-        set({
-          lastPermissionError: null,
-          fileLoadError: null,
-          streamError: null,
-        });
-      },
-      
-      // Device Fallback Management
-      storePreviousWorkingAudioDevice: (deviceId?: string, deviceLabel?: string) => {
-        set({
-          previousWorkingAudioDevice: deviceId ? { deviceId, deviceLabel } : null
-        });
-      },
-      
-      storePreviousWorkingVideoDevice: (deviceId?: string, deviceLabel?: string) => {
-        set({
-          previousWorkingVideoDevice: deviceId ? { deviceId, deviceLabel } : null
-        });
-      },
-      
-      revertToWorkingAudioDevice: async () => {
-        const { previousWorkingAudioDevice } = get();
-        if (previousWorkingAudioDevice?.deviceId && previousWorkingAudioDevice?.deviceLabel) {
-          await get().selectAudioDevice(previousWorkingAudioDevice.deviceId, previousWorkingAudioDevice.deviceLabel);
-          return true;
-        }
-        return false;
-      },
-      
-      revertToWorkingVideoDevice: async () => {
-        const { previousWorkingVideoDevice } = get();
-        if (previousWorkingVideoDevice?.deviceId && previousWorkingVideoDevice?.deviceLabel) {
-          await get().selectVideoDevice(previousWorkingVideoDevice.deviceId, previousWorkingVideoDevice.deviceLabel);
-          return true;
-        }
-        return false;
-      },
-      
-      // Utility Methods
-      hasAudioPermission: () => get().inputConfiguration.permissions.audio,
-      hasVideoPermission: () => get().inputConfiguration.permissions.video,
-      hasScreenCapturePermission: () => get().inputConfiguration.permissions.screenCapture,
-      hasActiveAudioStream: () => !!get().inputConfiguration.audio.stream,
-      hasActiveVideoStream: () => !!get().inputConfiguration.video.stream,
-
-      resetToDefaults: () => {
-        try {
-          get().clearStreams();
-        } catch {}
-        set({
-          inputConfiguration: createDefaultInputConfiguration(),
-          lastPermissionError: null,
-          fileLoadError: null,
-          streamError: null,
-          isCreatingStream: false,
-        });
-      },
-    }),
-    {
-      name: 'input-manager-store',
-      storage: createJSONStorage(() => sessionStorage),
-      // Drop all input settings on page refresh: don't rehydrate or persist anything
-      onRehydrateStorage: () => {
-        try { sessionStorage.removeItem('input-manager-store'); } catch {}
-      },
-      partialize: () => ({}),
-    }
-  )
-);