@qualified-salesforce/web 0.0.1-oidc-bootstrap

package/widget/multimodal_v2/stores/call_ui_adapter.js

@@ -0,0 +1,225 @@
+import { signals_core_module_w } from "../../../js/multimodal_v2.js";
+
+
+/**
+ * Creates a real call UI adapter that uses CallStore/DeviceStore/TavusStore.
+ *
+ * All state is derived via computed signals that react to store changes.
+ * The callStore is lazily loaded, so computeds handle the null case with defaults.
+ */ function createRealCallUiAdapter(rootStore) {
+    // Computed signals for stores - these automatically update when callStore loads
+    const callStore = signals_core_module_w(()=>rootStore.callStore.value);
+    const deviceStore = signals_core_module_w(()=>{
+        var _ref;
+        var _callStore_value;
+        return (_ref = (_callStore_value = callStore.value) == null ? void 0 : _callStore_value.deviceStore) != null ? _ref : null;
+    });
+    // State signals derived from stores (with safe defaults when stores aren't loaded)
+    const isInCall = signals_core_module_w(()=>{
+        var _callStore_value;
+        return ((_callStore_value = callStore.value) == null ? void 0 : _callStore_value.dailyCall.value) != null;
+    });
+    const isVideoLoading = signals_core_module_w(()=>rootStore.isVideoLoading.value);
+    const isBlurredVideoActive = signals_core_module_w(()=>rootStore.isBlurredVideoActive.value);
+    const isReconnecting = signals_core_module_w(()=>{
+        var _ref;
+        var _callStore_value;
+        return (_ref = (_callStore_value = callStore.value) == null ? void 0 : _callStore_value.isReconnecting.value) != null ? _ref : false;
+    });
+    const isSilentRestart = signals_core_module_w(()=>{
+        var _ref;
+        var _callStore_value;
+        return (_ref = (_callStore_value = callStore.value) == null ? void 0 : _callStore_value.isSilentRestart.value) != null ? _ref : false;
+    });
+    const isAudioConnected = signals_core_module_w(()=>{
+        var _ref;
+        var _callStore_value;
+        return (_ref = (_callStore_value = callStore.value) == null ? void 0 : _callStore_value.isCoffeeAudioReady.value) != null ? _ref : false;
+    });
+    const showConnecting = signals_core_module_w(()=>isInCall.value && !isAudioConnected.value);
+    const showMicControls = signals_core_module_w(()=>isInCall.value ? isAudioConnected.value : true);
+    const isMicMuted = signals_core_module_w(()=>{
+        var _ref;
+        var _deviceStore_value;
+        return (_ref = (_deviceStore_value = deviceStore.value) == null ? void 0 : _deviceStore_value.isMicMuted.value) != null ? _ref : false;
+    });
+    const microphoneDevices = signals_core_module_w(()=>{
+        var _deviceStore_value;
+        const devices = (_deviceStore_value = deviceStore.value) == null ? void 0 : _deviceStore_value.microphoneDevices.value;
+        return devices != null ? devices : [];
+    });
+    const noMicrophonesAvailable = signals_core_module_w(()=>microphoneDevices.value.length === 0);
+    const selectedMicId = signals_core_module_w(()=>{
+        var _deviceStore_value;
+        const selected = (_deviceStore_value = deviceStore.value) == null ? void 0 : _deviceStore_value.selectedMicrophoneDevice.value;
+        return selected && "deviceId" in selected ? selected.deviceId : null;
+    });
+    const conversationMode = signals_core_module_w(()=>rootStore.conversationMode.value);
+    const displayMode = signals_core_module_w(()=>rootStore.displayMode.value);
+    const alreadyInCall = signals_core_module_w(()=>{
+        var _ref;
+        var _callStore_value;
+        return (_ref = (_callStore_value = callStore.value) == null ? void 0 : _callStore_value.aiConversationStore.alreadyInCall.value) != null ? _ref : false;
+    });
+    const state = {
+        isInCall,
+        isVideoLoading,
+        isBlurredVideoActive,
+        isReconnecting,
+        isSilentRestart,
+        isAudioConnected,
+        showConnecting,
+        showMicControls,
+        isMicMuted,
+        noMicrophonesAvailable,
+        microphoneDevices,
+        selectedMicId,
+        conversationMode,
+        displayMode,
+        alreadyInCall
+    };
+    // Actions delegate to the appropriate store (no-ops if store not loaded)
+    const actions = {
+        toggleMic: ()=>{
+            var _deviceStore_value;
+            return (_deviceStore_value = deviceStore.value) == null ? void 0 : _deviceStore_value.toggleMic();
+        },
+        endCall: ()=>{
+            var _callStore_value;
+            return (_callStore_value = callStore.value) == null ? void 0 : _callStore_value.aiConversationStore.endConversation();
+        },
+        selectMic: (deviceId)=>{
+            var _deviceStore_value;
+            return (_deviceStore_value = deviceStore.value) == null ? void 0 : _deviceStore_value.updateSelectedMic(deviceId);
+        },
+        toggleVideoMode: (mode)=>rootStore.toggleVideoMode(mode),
+        startCall: (startCallContext, displayState)=>{
+            var _rootStore_postCallSurveyStore_value;
+            const currentlyInCall = state.isInCall.value;
+            const currentlyConnecting = state.isVideoLoading.value;
+            if (currentlyInCall || currentlyConnecting) return;
+            (_rootStore_postCallSurveyStore_value = rootStore.postCallSurveyStore.value) == null ? void 0 : _rootStore_postCallSurveyStore_value.dismiss();
+            rootStore.startCall(startCallContext, displayState);
+        }
+    };
+    return {
+        state,
+        actions,
+        isDebugMode: false
+    };
+}
+/**
+ * Creates a debug call UI adapter that uses DebugMultimodalScenarioStore.
+ * All state comes from the scenario store - no real call/device stores involved.
+ */ function createDebugCallUiAdapter(rootStore, scenarioStore) {
+    // State signals from scenario store (already computed signals)
+    const isInCall = signals_core_module_w(()=>scenarioStore.inCall.value);
+    const isVideoLoading = signals_core_module_w(()=>scenarioStore.videoLoading.value);
+    const isBlurredVideoActive = signals_core_module_w(()=>scenarioStore.inCall.value && !scenarioStore.preloadedVideoReady.value);
+    const isReconnecting = signals_core_module_w(()=>scenarioStore.isReconnecting.value);
+    const isSilentRestart = signals_core_module_w(()=>scenarioStore.isSilentRestart.value);
+    const isAudioConnected = signals_core_module_w(()=>scenarioStore.audioConnected.value);
+    const isMicMuted = signals_core_module_w(()=>scenarioStore.micMuted.value);
+    const microphoneDevices = signals_core_module_w(()=>scenarioStore.microphoneDevices.value);
+    const selectedMicId = signals_core_module_w(()=>scenarioStore.selectedMicId.value);
+    const conversationMode = signals_core_module_w(()=>scenarioStore.conversationMode.value);
+    const displayMode = signals_core_module_w(()=>rootStore.displayMode.value);
+    const state = {
+        isInCall,
+        isVideoLoading,
+        isBlurredVideoActive,
+        isReconnecting,
+        isSilentRestart,
+        isAudioConnected,
+        showConnecting: scenarioStore.showConnecting,
+        showMicControls: scenarioStore.showMicControls,
+        isMicMuted,
+        noMicrophonesAvailable: scenarioStore.noMicrophonesAvailable,
+        microphoneDevices,
+        selectedMicId,
+        conversationMode,
+        displayMode,
+        alreadyInCall: signals_core_module_w(()=>false)
+    };
+    const actions = {
+        toggleMic: ()=>scenarioStore.toggleMic(),
+        endCall: ()=>scenarioStore.endCall(),
+        selectMic: (deviceId)=>scenarioStore.selectMic(deviceId),
+        // Update both scenario store (for override) and rootStore (for actual state)
+        toggleVideoMode: (mode)=>{
+            scenarioStore.setConversationMode(mode);
+            rootStore.toggleVideoMode(mode);
+        },
+        startCall: ()=>scenarioStore.startCall()
+    };
+    return {
+        state,
+        actions,
+        isDebugMode: true
+    };
+}
+/**
+ * Get the appropriate CallUiAdapter for the current context.
+ *
+ * Debug mode is determined once at bootstrap by the `q_debug_multimodal` URL param.
+ * In debug mode, returns an adapter backed by DebugMultimodalScenarioStore.
+ * In normal mode, returns an adapter backed by the real CallStore/DeviceStore.
+ */ function getCallUiAdapter(rootStore) {
+    const isDebug = rootStore.isDebugMultimodal.value;
+    const scenarioStore = rootStore.debugScenarioStore.value;
+    if (isDebug) {
+        if (scenarioStore) {
+            return createDebugCallUiAdapter(rootStore, scenarioStore);
+        }
+        // Debug mode is enabled but scenario store hasn't loaded yet.
+        // Trigger the load and return a "pending" adapter that won't start real calls.
+        rootStore.debugScenarioStore.load();
+        return createPendingDebugAdapter(rootStore);
+    }
+    return createRealCallUiAdapter(rootStore);
+}
+/**
+ * Creates a "pending" debug adapter used while the scenario store is loading.
+ * All actions are no-ops to prevent starting real calls before debug mode is fully initialized.
+ */ function createPendingDebugAdapter(rootStore) {
+    const falseSignal = signals_core_module_w(()=>false);
+    const trueSignal = signals_core_module_w(()=>true);
+    const emptyArraySignal = signals_core_module_w(()=>[]);
+    const nullStringSignal = signals_core_module_w(()=>null);
+    const state = {
+        isInCall: falseSignal,
+        isVideoLoading: falseSignal,
+        isBlurredVideoActive: falseSignal,
+        isReconnecting: falseSignal,
+        isSilentRestart: falseSignal,
+        isAudioConnected: trueSignal,
+        showConnecting: falseSignal,
+        showMicControls: trueSignal,
+        isMicMuted: falseSignal,
+        noMicrophonesAvailable: falseSignal,
+        microphoneDevices: emptyArraySignal,
+        selectedMicId: nullStringSignal,
+        conversationMode: signals_core_module_w(()=>rootStore.conversationMode.value),
+        displayMode: signals_core_module_w(()=>rootStore.displayMode.value),
+        alreadyInCall: falseSignal
+    };
+    // No-op actions - prevent any real calls while loading
+    const noop = ()=>{};
+    const noopSelect = (_deviceId)=>{};
+    const actions = {
+        toggleMic: noop,
+        endCall: noop,
+        selectMic: noopSelect,
+        toggleVideoMode: noop,
+        startCall: noop
+    };
+    return {
+        state,
+        actions,
+        isDebugMode: true
+    };
+}
+
+var call_ui_adapter_createDebugCallUiAdapter = /* unused export */ undefined;
+var call_ui_adapter_createRealCallUiAdapter = /* unused export */ undefined;
+export { call_ui_adapter_createDebugCallUiAdapter as createDebugCallUiAdapter, call_ui_adapter_createRealCallUiAdapter as createRealCallUiAdapter, getCallUiAdapter };

package/widget/multimodal_v2/stores/debug_multimodal_scenario_store.js

@@ -0,0 +1,471 @@
+import { signals_core_module_r, signals_core_module_d, signals_core_module_w } from "../../../js/multimodal_v2.js";
+import { ConversationMode as types_ConversationMode } from "../types.js";
+
+function _extends() {
+    _extends = Object.assign || function(target) {
+        for(var i = 1; i < arguments.length; i++){
+            var source = arguments[i];
+            for(var key in source){
+                if (Object.prototype.hasOwnProperty.call(source, key)) {
+                    target[key] = source[key];
+                }
+            }
+        }
+        return target;
+    };
+    return _extends.apply(this, arguments);
+}
+
+
+const STORAGE_KEY = "q_debug_multimodal_scenario";
+const DEFAULT_MIC_DEVICES = [
+    {
+        deviceId: "mic-1",
+        kind: "audioinput",
+        label: "Built-in Microphone",
+        groupId: "default",
+        toJSON: ()=>({
+                deviceId: "mic-1",
+                label: "Built-in Microphone",
+                groupId: "default"
+            })
+    },
+    {
+        deviceId: "mic-2",
+        kind: "audioinput",
+        label: "External USB Microphone",
+        groupId: "default",
+        toJSON: ()=>({
+                deviceId: "mic-2",
+                label: "External USB Microphone",
+                groupId: "default"
+            })
+    }
+];
+const DEFAULT_CAMERA_DEVICES = [
+    {
+        deviceId: "cam-1",
+        kind: "videoinput",
+        label: "Built-in Camera",
+        groupId: "default",
+        toJSON: ()=>({
+                deviceId: "cam-1",
+                label: "Built-in Camera",
+                groupId: "default"
+            })
+    },
+    {
+        deviceId: "cam-2",
+        kind: "videoinput",
+        label: "External Webcam",
+        groupId: "default",
+        toJSON: ()=>({
+                deviceId: "cam-2",
+                label: "External Webcam",
+                groupId: "default"
+            })
+    }
+];
+/**
+ * Returns default (idle) scenario state.
+ * Note: conversationMode is NOT included to preserve query param settings.
+ * Note: videoOff defaults to true (camera off) to match real mode behavior
+ * where DeviceStore.isVideoOff starts as true.
+ */ function getDefaultState() {
+    return {
+        inCall: false,
+        videoLoading: false,
+        preloadedVideoReady: true,
+        isReconnecting: false,
+        isSilentRestart: false,
+        audioConnected: true,
+        micMuted: false,
+        videoOff: true,
+        microphoneDevices: DEFAULT_MIC_DEVICES,
+        cameraDevices: DEFAULT_CAMERA_DEVICES,
+        selectedMicId: "mic-1",
+        selectedCameraId: "cam-1",
+        displayMode: null
+    };
+}
+/**
+ * Preset configurations for common scenarios.
+ */ const PRESETS = {
+    idle: getDefaultState(),
+    loading: {
+        inCall: false,
+        videoLoading: true,
+        preloadedVideoReady: false,
+        isReconnecting: false,
+        audioConnected: false
+    },
+    connectingAudio: {
+        inCall: true,
+        videoLoading: false,
+        preloadedVideoReady: true,
+        isReconnecting: false,
+        audioConnected: false
+    },
+    reconnecting: {
+        inCall: true,
+        videoLoading: false,
+        preloadedVideoReady: true,
+        isReconnecting: true,
+        audioConnected: true
+    },
+    inCall: {
+        inCall: true,
+        videoLoading: false,
+        preloadedVideoReady: true,
+        isReconnecting: false,
+        audioConnected: true,
+        micMuted: false
+    }
+};
+class DebugMultimodalScenarioStore {
+    /**
+   * Get current state as a serializable object.
+   */ getState() {
+        return {
+            inCall: this.inCall.value,
+            videoLoading: this.videoLoading.value,
+            preloadedVideoReady: this.preloadedVideoReady.value,
+            isReconnecting: this.isReconnecting.value,
+            isSilentRestart: this.isSilentRestart.value,
+            audioConnected: this.audioConnected.value,
+            micMuted: this.micMuted.value,
+            videoOff: this.videoOff.value,
+            microphoneDevices: this.microphoneDevices.value,
+            cameraDevices: this.cameraDevices.value,
+            selectedMicId: this.selectedMicId.value,
+            selectedCameraId: this.selectedCameraId.value,
+            conversationMode: this.conversationMode.value,
+            displayMode: this.displayModeOverride.value
+        };
+    }
+    /**
+   * Set state from a partial object.
+   */ setState(state) {
+        signals_core_module_r(()=>{
+            if (state.inCall !== undefined) this.inCall.value = state.inCall;
+            if (state.videoLoading !== undefined) this.videoLoading.value = state.videoLoading;
+            if (state.preloadedVideoReady !== undefined) this.preloadedVideoReady.value = state.preloadedVideoReady;
+            if (state.isReconnecting !== undefined) this.isReconnecting.value = state.isReconnecting;
+            if (state.isSilentRestart !== undefined) this.isSilentRestart.value = state.isSilentRestart;
+            if (state.audioConnected !== undefined) this.audioConnected.value = state.audioConnected;
+            if (state.micMuted !== undefined) this.micMuted.value = state.micMuted;
+            if (state.videoOff !== undefined) this.videoOff.value = state.videoOff;
+            if (state.microphoneDevices !== undefined) this.microphoneDevices.value = state.microphoneDevices;
+            if (state.cameraDevices !== undefined) this.cameraDevices.value = state.cameraDevices;
+            if (state.selectedMicId !== undefined) this.selectedMicId.value = state.selectedMicId;
+            if (state.selectedCameraId !== undefined) this.selectedCameraId.value = state.selectedCameraId;
+            if (state.conversationMode !== undefined) this.conversationModeOverride.value = state.conversationMode;
+            if (state.displayMode !== undefined) this.displayModeOverride.value = state.displayMode;
+            this.syncToRootStore();
+            this.saveToStorage();
+        });
+    }
+    /**
+   * Apply a preset scenario.
+   * Sets camera state based on conversation mode (matches real mode behavior).
+   */ applyPreset(preset) {
+        const presetState = PRESETS[preset];
+        signals_core_module_r(()=>{
+            // Reset to default first, then apply preset overrides
+            this.setState(_extends({}, getDefaultState(), presetState));
+            this.currentPreset.value = preset;
+            // Set camera state based on conversation mode (matches real mode behavior)
+            // In VOICE mode, camera should always be off
+            // In VIDEO mode, camera should be on when entering a call
+            const isVoiceMode = this.conversationMode.value === types_ConversationMode.VOICE;
+            if (preset === "inCall") {
+                this.videoOff.value = isVoiceMode;
+            }
+        });
+    }
+    /**
+   * Reset to idle state.
+   */ reset() {
+        this.applyPreset("idle");
+    }
+    /**
+   * Toggle microphone muted state.
+   */ toggleMic() {
+        this.setState({
+            micMuted: !this.micMuted.value
+        });
+    }
+    /**
+   * Toggle video off state.
+   */ toggleVideo() {
+        this.setState({
+            videoOff: !this.videoOff.value
+        });
+    }
+    /**
+   * Set audio connected state.
+   */ setAudioConnected(connected) {
+        this.setState({
+            audioConnected: connected
+        });
+    }
+    /**
+   * Set in-call state.
+   */ setInCall(inCall) {
+        this.setState({
+            inCall
+        });
+    }
+    /**
+   * Set video loading state.
+   */ setVideoLoading(loading) {
+        this.setState({
+            videoLoading: loading
+        });
+    }
+    /**
+   * Set reconnecting state.
+   */ setReconnecting(reconnecting) {
+        this.setState({
+            isReconnecting: reconnecting
+        });
+    }
+    /**
+   * Set conversation mode.
+   * Handles camera state toggle to match real mode behavior (rootStore.toggleVideoMode).
+   */ setConversationMode(mode) {
+        const previousMode = this.conversationMode.value;
+        const isVideoOff = this.videoOff.value;
+        signals_core_module_r(()=>{
+            this.setState({
+                conversationMode: mode
+            });
+            // Toggle camera based on mode (matches rootStore.toggleVideoMode behavior)
+            // When switching to VOICE and camera is on, turn it off
+            // When switching to VIDEO and camera is off, turn it on
+            if (mode !== previousMode) {
+                if (mode === types_ConversationMode.VOICE && !isVideoOff) {
+                    this.videoOff.value = true;
+                } else if (mode === types_ConversationMode.VIDEO && isVideoOff) {
+                    this.videoOff.value = false;
+                }
+            }
+        });
+    }
+    /**
+   * Set display mode override.
+   */ setDisplayMode(mode) {
+        this.setState({
+            displayMode: mode
+        });
+    }
+    /**
+   * Select a microphone by device ID.
+   */ selectMic(deviceId) {
+        this.setState({
+            selectedMicId: deviceId
+        });
+    }
+    /**
+   * Select a camera by device ID.
+   */ selectCamera(deviceId) {
+        this.setState({
+            selectedCameraId: deviceId
+        });
+    }
+    /**
+   * End the simulated call.
+   */ endCall() {
+        signals_core_module_r(()=>{
+            // Reset call state without triggering applyPreset's display mode constraints
+            this.setState({
+                inCall: false,
+                videoLoading: false,
+                isReconnecting: false,
+                audioConnected: true
+            });
+            this.currentPreset.value = "idle";
+        });
+    }
+    /**
+   * Start a simulated call (for "Speak now" button).
+   * Camera state will be set based on conversation mode when transitioning to inCall.
+   * Expands to opened display mode if currently minimized.
+   */ startCall() {
+        signals_core_module_r(()=>{
+            this.applyPreset("loading");
+            // Expand to opened display mode if minimized
+            if (this.rootStore.displayMode.minimized.value) {
+                this.rootStore.setOpenedDisplayMode();
+            }
+        });
+    }
+    /**
+   * Sync scenario state to rootStore signals where applicable.
+   * This ensures the UI components read the debug values.
+   *
+   * Note: conversationMode is NOT synced here because:
+   * 1. The debug adapter reads directly from the debug store's conversationMode
+   * 2. Syncing would override query params like ?conversation_mode=voice
+   */ syncToRootStore() {
+        // Sync videoLoading and preloadedVideoReady to rootStore
+        this.rootStore.isVideoLoading.value = this.videoLoading.value;
+        // Sync display mode override if set
+        if (this.displayModeOverride.value !== null && this.displayModeOverride.value !== this.rootStore.displayMode.value) {
+            this.rootStore.setDisplayMode(this.displayModeOverride.value);
+        }
+    }
+    /**
+   * Persist current state to localStorage.
+   */ saveToStorage() {
+        try {
+            const state = this.getState();
+            localStorage.setItem(STORAGE_KEY, JSON.stringify(state));
+        } catch (unused) {
+        // Silently fail if localStorage is not available
+        }
+    }
+    /**
+   * Load persisted state from localStorage.
+   * Note: conversationMode is only restored if there's no query param specifying it.
+   */ loadFromStorage() {
+        try {
+            const stored = localStorage.getItem(STORAGE_KEY);
+            if (stored) {
+                const state = JSON.parse(stored);
+                // Only skip restoring conversationMode if there's a query param specifying it
+                const urlParams = new URLSearchParams(window.location.search);
+                const hasConversationModeParam = urlParams.has("conversation_mode");
+                if (hasConversationModeParam) {
+                    // Query param takes precedence - don't restore from localStorage
+                    delete state.conversationMode;
+                }
+                this.setState(state);
+                // Detect which preset matches the restored state
+                this.currentPreset.value = this.detectCurrentPreset();
+            }
+        } catch (unused) {
+        // Silently fail if localStorage is not available or data is corrupt
+        }
+    }
+    /**
+   * Detect which preset matches the current state (if any).
+   */ detectCurrentPreset() {
+        const currentState = {
+            inCall: this.inCall.value,
+            videoLoading: this.videoLoading.value,
+            preloadedVideoReady: this.preloadedVideoReady.value,
+            isReconnecting: this.isReconnecting.value,
+            audioConnected: this.audioConnected.value
+        };
+        // Check each preset to see if it matches the current state
+        // Order matters - check more specific presets first
+        if (currentState.inCall && !currentState.videoLoading && currentState.isReconnecting) {
+            return "reconnecting";
+        }
+        if (currentState.inCall && !currentState.videoLoading && !currentState.audioConnected) {
+            return "connectingAudio";
+        }
+        if (currentState.inCall && !currentState.videoLoading && currentState.preloadedVideoReady && currentState.audioConnected && !currentState.isReconnecting) {
+            return "inCall";
+        }
+        if (!currentState.inCall && currentState.videoLoading && !currentState.preloadedVideoReady) {
+            return "loading";
+        }
+        if (!currentState.inCall && !currentState.videoLoading && currentState.preloadedVideoReady && !currentState.isReconnecting) {
+            return "idle";
+        }
+        // No matching preset
+        return null;
+    }
+    /**
+   * Clear persisted state from localStorage.
+   */ clearStorage() {
+        try {
+            localStorage.removeItem(STORAGE_KEY);
+        } catch (unused) {
+        // Silently fail
+        }
+    }
+    constructor(rootStore){
+        this.rootStore = rootStore;
+        // Individual signals for each piece of scenario state
+        this.inCall = signals_core_module_d(false);
+        this.videoLoading = signals_core_module_d(false);
+        this.preloadedVideoReady = signals_core_module_d(true);
+        this.isReconnecting = signals_core_module_d(false);
+        this.isSilentRestart = signals_core_module_d(false);
+        this.audioConnected = signals_core_module_d(true);
+        this.micMuted = signals_core_module_d(false);
+        this.videoOff = signals_core_module_d(true); // Camera off by default, matches real mode (DeviceStore.isVideoOff = true)
+        this.microphoneDevices = signals_core_module_d(DEFAULT_MIC_DEVICES);
+        this.cameraDevices = signals_core_module_d(DEFAULT_CAMERA_DEVICES);
+        this.selectedMicId = signals_core_module_d("mic-1");
+        this.selectedCameraId = signals_core_module_d("cam-1");
+        // Optional override for conversation mode - when null, reads from rootStore
+        this.conversationModeOverride = signals_core_module_d(null);
+        this.displayModeOverride = signals_core_module_d(null);
+        /**
+   * Conversation mode - reads from rootStore by default, uses override if explicitly set.
+   * This ensures query params like ?conversation_mode=voice are respected.
+   */ this.conversationMode = signals_core_module_w(()=>{
+            const override = this.conversationModeOverride.value;
+            if (override !== null) {
+                return override;
+            }
+            return this.rootStore.conversationMode.value;
+        });
+        /**
+   * Current preset name (if any). Computed from state.
+   */ this.currentPreset = signals_core_module_d(null);
+        /**
+   * Whether debug mode is enabled (derived from rootStore).
+   */ this.enabled = signals_core_module_w(()=>this.rootStore.isDebugMultimodal.value);
+        /**
+   * Derived: whether there are no microphones available.
+   */ this.noMicrophonesAvailable = signals_core_module_w(()=>this.microphoneDevices.value.length === 0);
+        /**
+   * Derived: whether there are no cameras available.
+   */ this.noCamerasAvailable = signals_core_module_w(()=>this.cameraDevices.value.length === 0);
+        /**
+   * Derived: show "Connecting audio..." message.
+   */ this.showConnecting = signals_core_module_w(()=>this.inCall.value && !this.audioConnected.value);
+        /**
+   * Derived: show mic controls (hide while connecting audio).
+   */ this.showMicControls = signals_core_module_w(()=>this.inCall.value ? this.audioConnected.value : true);
+        // Load persisted state on construction
+        this.loadFromStorage();
+    }
+}
+/**
+ * Store for managing debug multimodal scenario state.
+ * Only active when `?q_debug_multimodal=1` is in the URL.
+ * Persists state to localStorage so you can refresh while iterating.
+ */ 
+/**
+ * List of available presets for UI dropdown.
+ */ const SCENARIO_PRESET_OPTIONS = [
+    {
+        value: "idle",
+        label: "Idle (not in call)"
+    },
+    {
+        value: "loading",
+        label: "Loading / Connecting"
+    },
+    {
+        value: "connectingAudio",
+        label: "Connecting audio"
+    },
+    {
+        value: "reconnecting",
+        label: "Weak connection / Reconnecting"
+    },
+    {
+        value: "inCall",
+        label: "In Call"
+    }
+];
+
+export { SCENARIO_PRESET_OPTIONS };
+export default DebugMultimodalScenarioStore;