@pipecat-ai/daily-transport 1.6.8 → 1.7.0

package/dist/index.js

@@ -1,5 +1,6 @@
-var $jrPAn$dailycodailyjs = require("@daily-co/daily-js");
-var $jrPAn$pipecataiclientjs = require("@pipecat-ai/client-js");
+var $1clrS$dailycodailyjs = require("@daily-co/daily-js");
+var $1clrS$pipecataiclientjs = require("@pipecat-ai/client-js");
+var $1clrS$events = require("events");
 
 
 function $parcel$exportWildcard(dest, source) {
@@ -26,13 +27,49 @@ function $parcel$interopDefault(a) {
 function $parcel$export(e, n, v, s) {
   Object.defineProperty(e, n, {get: v, set: s, enumerable: true, configurable: true});
 }
-var $28bdeb35415d61e8$exports = {};
+var $1c83796b12dd4e49$exports = {};
 
-$parcel$export($28bdeb35415d61e8$exports, "DailyRTVIMessageType", () => $28bdeb35415d61e8$export$ef180de88fd317cc);
-$parcel$export($28bdeb35415d61e8$exports, "DailyTransport", () => $28bdeb35415d61e8$export$b1ca982aa1e488c1);
+$parcel$export($1c83796b12dd4e49$exports, "DailyRTVIMessageType", () => $1c83796b12dd4e49$export$ef180de88fd317cc);
+$parcel$export($1c83796b12dd4e49$exports, "DailyTransport", () => $1c83796b12dd4e49$export$b1ca982aa1e488c1);
 
 
 /**
+ * Whether this browser can share a screen. Most mobile browsers, including
+ * iOS Safari, have no `getDisplayMedia`.
+ */ function $15398512372f76d1$export$7f8f33b9b54c8307() {
+    return typeof navigator?.mediaDevices?.getDisplayMedia === "function";
+}
+
+
+/*!
+ * wavtools is adapted from openai-realtime-console
+ * (https://github.com/openai/openai-realtime-console) and modified by Daily.
+ *
+ * @license MIT
+ *
+ * Copyright (c) 2024 OpenAI
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */ /*!
+ * Adapted from openai-realtime-console (https://github.com/openai/openai-realtime-console).
+ * Copyright (c) 2024 OpenAI. Modified by Daily. MIT License; see wavtools/index.js.
+ */ /**
  * Raw wav audio file contents
  * @typedef {Object} WavPackerAudioType
  * @property {Blob} blob
@@ -43,7 +80,7 @@ $parcel$export($28bdeb35415d61e8$exports, "DailyTransport", () => $28bdeb35415d6
  */ /**
  * Utility class for assembling PCM16 "audio/wav" data
  * @class
- */ class $a61750b8fbee4dae$export$13afda237b1c9846 {
+ */ class $45766326c6faa3c4$export$13afda237b1c9846 {
     /**
    * Converts Float32Array of amplitude data to ArrayBuffer in Int16Array format
    * @param {Float32Array} float32Array
@@ -131,16 +168,22 @@ $parcel$export($28bdeb35415d61e8$exports, "DailyTransport", () => $28bdeb35415d6
         };
     }
 }
-globalThis.WavPacker = $a61750b8fbee4dae$export$13afda237b1c9846;
+globalThis.WavPacker = $45766326c6faa3c4$export$13afda237b1c9846;
 
 
-/**
+/*!
+ * Adapted from openai-realtime-console (https://github.com/openai/openai-realtime-console).
+ * Copyright (c) 2024 OpenAI. Modified by Daily. MIT License; see wavtools/index.js.
+ */ /*!
+ * Adapted from openai-realtime-console (https://github.com/openai/openai-realtime-console).
+ * Copyright (c) 2024 OpenAI. Modified by Daily. MIT License; see wavtools/index.js.
+ */ /**
  * Constants for help with visualization
  * Helps map frequency ranges from Fast Fourier Transform
  * to human-interpretable ranges, notably music ranges and
  * human vocal ranges.
  */ // Eighth octave frequencies
-const $e10a9de47f58e137$var$octave8Frequencies = [
+const $550c0e438054ce18$var$octave8Frequencies = [
     4186.01,
     4434.92,
     4698.63,
@@ -155,7 +198,7 @@ const $e10a9de47f58e137$var$octave8Frequencies = [
     7902.13
 ];
 // Labels for each of the above frequencies
-const $e10a9de47f58e137$var$octave8FrequencyLabels = [
+const $550c0e438054ce18$var$octave8FrequencyLabels = [
     "C",
     "C#",
     "D",
@@ -169,29 +212,29 @@ const $e10a9de47f58e137$var$octave8FrequencyLabels = [
     "A#",
     "B"
 ];
-const $e10a9de47f58e137$export$776c63898ae5b636 = [];
-const $e10a9de47f58e137$export$facd167cc27ea9b0 = [];
-for(let i = 1; i <= 8; i++)for(let f = 0; f < $e10a9de47f58e137$var$octave8Frequencies.length; f++){
-    const freq = $e10a9de47f58e137$var$octave8Frequencies[f];
-    $e10a9de47f58e137$export$776c63898ae5b636.push(freq / Math.pow(2, 8 - i));
-    $e10a9de47f58e137$export$facd167cc27ea9b0.push($e10a9de47f58e137$var$octave8FrequencyLabels[f] + i);
+const $550c0e438054ce18$export$776c63898ae5b636 = [];
+const $550c0e438054ce18$export$facd167cc27ea9b0 = [];
+for(let i = 1; i <= 8; i++)for(let f = 0; f < $550c0e438054ce18$var$octave8Frequencies.length; f++){
+    const freq = $550c0e438054ce18$var$octave8Frequencies[f];
+    $550c0e438054ce18$export$776c63898ae5b636.push(freq / Math.pow(2, 8 - i));
+    $550c0e438054ce18$export$facd167cc27ea9b0.push($550c0e438054ce18$var$octave8FrequencyLabels[f] + i);
 }
 /**
  * Subset of the note frequencies between 32 and 2000 Hz
  * 6 octave range: C1 to B6
- */ const $e10a9de47f58e137$var$voiceFrequencyRange = [
+ */ const $550c0e438054ce18$var$voiceFrequencyRange = [
     32.0,
     2000.0
 ];
-const $e10a9de47f58e137$export$dbc1581ed2cfa183 = $e10a9de47f58e137$export$776c63898ae5b636.filter((_, i)=>{
-    return $e10a9de47f58e137$export$776c63898ae5b636[i] > $e10a9de47f58e137$var$voiceFrequencyRange[0] && $e10a9de47f58e137$export$776c63898ae5b636[i] < $e10a9de47f58e137$var$voiceFrequencyRange[1];
+const $550c0e438054ce18$export$dbc1581ed2cfa183 = $550c0e438054ce18$export$776c63898ae5b636.filter((_, i)=>{
+    return $550c0e438054ce18$export$776c63898ae5b636[i] > $550c0e438054ce18$var$voiceFrequencyRange[0] && $550c0e438054ce18$export$776c63898ae5b636[i] < $550c0e438054ce18$var$voiceFrequencyRange[1];
 });
-const $e10a9de47f58e137$export$30a6f2881311088f = $e10a9de47f58e137$export$facd167cc27ea9b0.filter((_, i)=>{
-    return $e10a9de47f58e137$export$776c63898ae5b636[i] > $e10a9de47f58e137$var$voiceFrequencyRange[0] && $e10a9de47f58e137$export$776c63898ae5b636[i] < $e10a9de47f58e137$var$voiceFrequencyRange[1];
+const $550c0e438054ce18$export$30a6f2881311088f = $550c0e438054ce18$export$facd167cc27ea9b0.filter((_, i)=>{
+    return $550c0e438054ce18$export$776c63898ae5b636[i] > $550c0e438054ce18$var$voiceFrequencyRange[0] && $550c0e438054ce18$export$776c63898ae5b636[i] < $550c0e438054ce18$var$voiceFrequencyRange[1];
 });
 
 
-class $5853841ab58516d4$export$2c3136da0bf130f9 {
+class $3f7a723e434a4b86$export$2c3136da0bf130f9 {
     /**
    * Retrieves frequency domain data from an AnalyserNode adjusted to a decibel range
    * returns human-readable formatting and labels
@@ -213,7 +256,7 @@ class $5853841ab58516d4$export$2c3136da0bf130f9 {
         let frequencies;
         let labels;
         if (analysisType === "music" || analysisType === "voice") {
-            const useFrequencies = analysisType === "voice" ? (0, $e10a9de47f58e137$export$dbc1581ed2cfa183) : (0, $e10a9de47f58e137$export$776c63898ae5b636);
+            const useFrequencies = analysisType === "voice" ? (0, $550c0e438054ce18$export$dbc1581ed2cfa183) : (0, $550c0e438054ce18$export$776c63898ae5b636);
             const aggregateOutput = Array(useFrequencies.length).fill(minDecibels);
             for(let i = 0; i < fftResult.length; i++){
                 const frequency = i * frequencyStep;
@@ -224,8 +267,8 @@ class $5853841ab58516d4$export$2c3136da0bf130f9 {
                 }
             }
             outputValues = aggregateOutput;
-            frequencies = analysisType === "voice" ? (0, $e10a9de47f58e137$export$dbc1581ed2cfa183) : (0, $e10a9de47f58e137$export$776c63898ae5b636);
-            labels = analysisType === "voice" ? (0, $e10a9de47f58e137$export$30a6f2881311088f) : (0, $e10a9de47f58e137$export$facd167cc27ea9b0);
+            frequencies = analysisType === "voice" ? (0, $550c0e438054ce18$export$dbc1581ed2cfa183) : (0, $550c0e438054ce18$export$776c63898ae5b636);
+            labels = analysisType === "voice" ? (0, $550c0e438054ce18$export$30a6f2881311088f) : (0, $550c0e438054ce18$export$facd167cc27ea9b0);
         } else {
             outputValues = Array.from(fftResult);
             frequencies = outputValues.map((_, i)=>frequencyStep * i);
@@ -318,7 +361,7 @@ class $5853841ab58516d4$export$2c3136da0bf130f9 {
             const index = Math.min(pct * this.fftResults.length | 0, this.fftResults.length - 1);
             fftResult = this.fftResults[index];
         }
-        return $5853841ab58516d4$export$2c3136da0bf130f9.getFrequencies(this.analyser, this.sampleRate, fftResult, analysisType, minDecibels, maxDecibels);
+        return $3f7a723e434a4b86$export$2c3136da0bf130f9.getFrequencies(this.analyser, this.sampleRate, fftResult, analysisType, minDecibels, maxDecibels);
     }
     /**
    * Resume the internal AudioContext if it was suspended due to the lack of
@@ -329,10 +372,16 @@ class $5853841ab58516d4$export$2c3136da0bf130f9 {
         return true;
     }
 }
-globalThis.AudioAnalysis = $5853841ab58516d4$export$2c3136da0bf130f9;
+globalThis.AudioAnalysis = $3f7a723e434a4b86$export$2c3136da0bf130f9;
 
 
-const $d6d3743ef65c7519$export$50b76700e2b15e9 = `
+/*!
+ * Adapted from openai-realtime-console (https://github.com/openai/openai-realtime-console).
+ * Copyright (c) 2024 OpenAI. Modified by Daily. MIT License; see wavtools/index.js.
+ */ /*!
+ * Adapted from openai-realtime-console (https://github.com/openai/openai-realtime-console).
+ * Copyright (c) 2024 OpenAI. Modified by Daily. MIT License; see wavtools/index.js.
+ */ const $ff75ae50979bb4fc$export$50b76700e2b15e9 = `
 class StreamProcessor extends AudioWorkletProcessor {
   constructor() {
     super();
@@ -422,23 +471,23 @@ class StreamProcessor extends AudioWorkletProcessor {
 
 registerProcessor('stream_processor', StreamProcessor);
 `;
-const $d6d3743ef65c7519$var$script = new Blob([
-    $d6d3743ef65c7519$export$50b76700e2b15e9
+const $ff75ae50979bb4fc$var$script = new Blob([
+    $ff75ae50979bb4fc$export$50b76700e2b15e9
 ], {
     type: "application/javascript"
 });
-const $d6d3743ef65c7519$var$src = URL.createObjectURL($d6d3743ef65c7519$var$script);
-const $d6d3743ef65c7519$export$bfa8c596114d74df = $d6d3743ef65c7519$var$src;
+const $ff75ae50979bb4fc$var$src = URL.createObjectURL($ff75ae50979bb4fc$var$script);
+const $ff75ae50979bb4fc$export$bfa8c596114d74df = $ff75ae50979bb4fc$var$src;
 
 
 
-class $1e7ce9484a3c4077$export$9698d62c78b8f366 {
+class $347522367945ce82$export$9698d62c78b8f366 {
     /**
    * Creates a new WavStreamPlayer instance
    * @param {{sampleRate?: number}} options
    * @returns {WavStreamPlayer}
    */ constructor({ sampleRate: sampleRate = 44100 } = {}){
-        this.scriptSrc = (0, $d6d3743ef65c7519$export$bfa8c596114d74df);
+        this.scriptSrc = (0, $ff75ae50979bb4fc$export$bfa8c596114d74df);
         this.sampleRate = sampleRate;
         this.context = null;
         this.stream = null;
@@ -475,7 +524,7 @@ class $1e7ce9484a3c4077$export$9698d62c78b8f366 {
    * @returns {import('./analysis/audio_analysis.js').AudioAnalysisOutputType}
    */ getFrequencies(analysisType = "frequency", minDecibels = -100, maxDecibels = -30) {
         if (!this.analyser) throw new Error("Not connected, please call .connect() first");
-        return (0, $5853841ab58516d4$export$2c3136da0bf130f9).getFrequencies(this.analyser, this.sampleRate, null, analysisType, minDecibels, maxDecibels);
+        return (0, $3f7a723e434a4b86$export$2c3136da0bf130f9).getFrequencies(this.analyser, this.sampleRate, null, analysisType, minDecibels, maxDecibels);
     }
     /**
    * @param {string} speaker deviceId
@@ -566,10 +615,16 @@ class $1e7ce9484a3c4077$export$9698d62c78b8f366 {
         return this.getTrackSampleOffset(true);
     }
 }
-globalThis.WavStreamPlayer = $1e7ce9484a3c4077$export$9698d62c78b8f366;
+globalThis.WavStreamPlayer = $347522367945ce82$export$9698d62c78b8f366;
 
 
-const $2cf6a2d8a6d031bc$var$AudioProcessorWorklet = `
+/*!
+ * Adapted from openai-realtime-console (https://github.com/openai/openai-realtime-console).
+ * Copyright (c) 2024 OpenAI. Modified by Daily. MIT License; see wavtools/index.js.
+ */ /*!
+ * Adapted from openai-realtime-console (https://github.com/openai/openai-realtime-console).
+ * Copyright (c) 2024 OpenAI. Modified by Daily. MIT License; see wavtools/index.js.
+ */ const $5a5c5ac16a3be24c$var$AudioProcessorWorklet = `
 class AudioProcessor extends AudioWorkletProcessor {
 
   constructor() {
@@ -777,25 +832,25 @@ class AudioProcessor extends AudioWorkletProcessor {
 
 registerProcessor('audio_processor', AudioProcessor);
 `;
-const $2cf6a2d8a6d031bc$var$script = new Blob([
-    $2cf6a2d8a6d031bc$var$AudioProcessorWorklet
+const $5a5c5ac16a3be24c$var$script = new Blob([
+    $5a5c5ac16a3be24c$var$AudioProcessorWorklet
 ], {
     type: "application/javascript"
 });
-const $2cf6a2d8a6d031bc$var$src = URL.createObjectURL($2cf6a2d8a6d031bc$var$script);
-const $2cf6a2d8a6d031bc$export$1f65f50a8cbff43c = $2cf6a2d8a6d031bc$var$src;
+const $5a5c5ac16a3be24c$var$src = URL.createObjectURL($5a5c5ac16a3be24c$var$script);
+const $5a5c5ac16a3be24c$export$1f65f50a8cbff43c = $5a5c5ac16a3be24c$var$src;
 
 
 
 
-class $0d471c38435bdab6$export$439b217ca659a877 {
+class $35ad6181fc724add$export$439b217ca659a877 {
     /**
    * Create a new WavRecorder instance
    * @param {{sampleRate?: number, outputToSpeakers?: boolean, debug?: boolean}} [options]
    * @returns {WavRecorder}
    */ constructor({ sampleRate: sampleRate = 44100, outputToSpeakers: outputToSpeakers = false, debug: debug = false } = {}){
         // Script source
-        this.scriptSrc = (0, $2cf6a2d8a6d031bc$export$1f65f50a8cbff43c);
+        this.scriptSrc = (0, $5a5c5ac16a3be24c$export$1f65f50a8cbff43c);
         // Config
         this.sampleRate = sampleRate;
         this.outputToSpeakers = outputToSpeakers;
@@ -858,7 +913,7 @@ class $0d471c38435bdab6$export$439b217ca659a877 {
             else throw new Error(`"audioData" must be one of: Blob, Float32Arrray, Int16Array, ArrayBuffer, Array<number>`);
             if (fromSampleRate === -1) throw new Error(`Must specify "fromSampleRate" when reading from Float32Array, In16Array or Array`);
             else if (fromSampleRate < 3000) throw new Error(`Minimum "fromSampleRate" is 3000 (3kHz)`);
-            if (!data) data = (0, $a61750b8fbee4dae$export$13afda237b1c9846).floatTo16BitPCM(float32Array);
+            if (!data) data = (0, $45766326c6faa3c4$export$13afda237b1c9846).floatTo16BitPCM(float32Array);
             const audio = {
                 bitsPerSample: 16,
                 channels: [
@@ -866,7 +921,7 @@ class $0d471c38435bdab6$export$439b217ca659a877 {
                 ],
                 data: data
             };
-            const packer = new (0, $a61750b8fbee4dae$export$13afda237b1c9846)();
+            const packer = new (0, $45766326c6faa3c4$export$13afda237b1c9846)();
             const result = packer.pack(fromSampleRate, audio);
             blob = result.blob;
             arrayBuffer = await blob.arrayBuffer();
@@ -1088,8 +1143,8 @@ class $0d471c38435bdab6$export$439b217ca659a877 {
                 if (this._chunkProcessorSize) {
                     const buffer = this._chunkProcessorBuffer;
                     this._chunkProcessorBuffer = {
-                        raw: (0, $a61750b8fbee4dae$export$13afda237b1c9846).mergeBuffers(buffer.raw, data.raw),
-                        mono: (0, $a61750b8fbee4dae$export$13afda237b1c9846).mergeBuffers(buffer.mono, data.mono)
+                        raw: (0, $45766326c6faa3c4$export$13afda237b1c9846).mergeBuffers(buffer.raw, data.raw),
+                        mono: (0, $45766326c6faa3c4$export$13afda237b1c9846).mergeBuffers(buffer.mono, data.mono)
                     };
                     if (this._chunkProcessorBuffer.mono.byteLength >= this._chunkProcessorSize) {
                         this._chunkProcessor(this._chunkProcessorBuffer);
@@ -1126,7 +1181,7 @@ class $0d471c38435bdab6$export$439b217ca659a877 {
    * @returns {import('./analysis/audio_analysis.js').AudioAnalysisOutputType}
    */ getFrequencies(analysisType = "frequency", minDecibels = -100, maxDecibels = -30) {
         if (!this.processor) throw new Error("Session ended: please call .begin() first");
-        return (0, $5853841ab58516d4$export$2c3136da0bf130f9).getFrequencies(this.analyser, this.sampleRate, null, analysisType, minDecibels, maxDecibels);
+        return (0, $3f7a723e434a4b86$export$2c3136da0bf130f9).getFrequencies(this.analyser, this.sampleRate, null, analysisType, minDecibels, maxDecibels);
     }
     /**
    * Pauses the recording
@@ -1143,7 +1198,7 @@ class $0d471c38435bdab6$export$439b217ca659a877 {
     }
     /**
    * Start recording stream and storing to memory from the connected audio source
-   * @param {(data: { mono: Int16Array; raw: Int16Array }) => any} [chunkProcessor]
+   * @param {(data: { mono: ArrayBuffer; raw: ArrayBuffer }) => any} [chunkProcessor]
    * @param {number} [chunkSize] chunkProcessor will not be triggered until this size threshold met in mono audio
    * @returns {Promise<true>}
    */ async record(chunkProcessor = ()=>{}, chunkSize = 8192) {
@@ -1187,7 +1242,7 @@ class $0d471c38435bdab6$export$439b217ca659a877 {
         if (!force && this.recording) throw new Error("Currently recording: please call .pause() first, or call .save(true) to force");
         this.log("Exporting ...");
         const exportData = await this._event("export");
-        const packer = new (0, $a61750b8fbee4dae$export$13afda237b1c9846)();
+        const packer = new (0, $45766326c6faa3c4$export$13afda237b1c9846)();
         const result = packer.pack(this.sampleRate, exportData.audio);
         return result;
     }
@@ -1212,7 +1267,7 @@ class $0d471c38435bdab6$export$439b217ca659a877 {
         this.processor = null;
         this.source = null;
         this.node = null;
-        const packer = new (0, $a61750b8fbee4dae$export$13afda237b1c9846)();
+        const packer = new (0, $45766326c6faa3c4$export$13afda237b1c9846)();
         const result = packer.pack(this.sampleRate, exportData.audio);
         return result;
     }
@@ -1228,10 +1283,13 @@ class $0d471c38435bdab6$export$439b217ca659a877 {
         return true;
     }
 }
-globalThis.WavRecorder = $0d471c38435bdab6$export$439b217ca659a877;
-
+globalThis.WavRecorder = $35ad6181fc724add$export$439b217ca659a877;
 
 
+/*!
+ * Adapted from openai-realtime-console (https://github.com/openai/openai-realtime-console).
+ * Copyright (c) 2024 OpenAI. Modified by Daily. MIT License; see wavtools/index.js.
+ */ 
 
 
 /**
@@ -1240,7 +1298,7 @@ globalThis.WavRecorder = $0d471c38435bdab6$export$439b217ca659a877;
  * @param {number} inputSampleRate - Sample rate of input audio
  * @param {number} outputSampleRate - Desired output sample rate
  * @returns {ArrayBuffer} - Resampled audio data as Int16 PCM
- */ function $7cef7a69bdf8f84d$var$resampleAudioBuffer(inputBuffer, inputSampleRate, outputSampleRate) {
+ */ function $ab812aec7679ec67$var$resampleAudioBuffer(inputBuffer, inputSampleRate, outputSampleRate) {
     if (inputSampleRate === outputSampleRate) return inputBuffer;
     const inputView = new Int16Array(inputBuffer);
     const ratio = inputSampleRate / outputSampleRate;
@@ -1257,14 +1315,14 @@ globalThis.WavRecorder = $0d471c38435bdab6$export$439b217ca659a877;
     }
     return outputBuffer;
 }
-class $7cef7a69bdf8f84d$export$2934cf2d25c67a48 {
+class $ab812aec7679ec67$export$2934cf2d25c67a48 {
     /**
    * Create a new MediaStreamRecorder instance
    * @param {{sampleRate?: number, outputToSpeakers?: boolean, debug?: boolean}} [options]
    * @returns {MediaStreamRecorder}
    */ constructor({ sampleRate: sampleRate = 44100, outputToSpeakers: outputToSpeakers = false, debug: debug = false } = {}){
         // Script source
-        this.scriptSrc = (0, $2cf6a2d8a6d031bc$export$1f65f50a8cbff43c);
+        this.scriptSrc = (0, $5a5c5ac16a3be24c$export$1f65f50a8cbff43c);
         // Config
         this.sampleRate = sampleRate;
         this.outputToSpeakers = outputToSpeakers;
@@ -1376,14 +1434,14 @@ class $7cef7a69bdf8f84d$export$2934cf2d25c67a48 {
                 // Resample chunk data from native sample rate to target sample rate
                 // (no-op if rates match, i.e. for non-Firefox browsers)
                 const resampledData = {
-                    raw: $7cef7a69bdf8f84d$var$resampleAudioBuffer(data.raw, contextSampleRate, this.sampleRate),
-                    mono: $7cef7a69bdf8f84d$var$resampleAudioBuffer(data.mono, contextSampleRate, this.sampleRate)
+                    raw: $ab812aec7679ec67$var$resampleAudioBuffer(data.raw, contextSampleRate, this.sampleRate),
+                    mono: $ab812aec7679ec67$var$resampleAudioBuffer(data.mono, contextSampleRate, this.sampleRate)
                 };
                 if (this._chunkProcessorSize) {
                     const buffer = this._chunkProcessorBuffer;
                     this._chunkProcessorBuffer = {
-                        raw: (0, $a61750b8fbee4dae$export$13afda237b1c9846).mergeBuffers(buffer.raw, resampledData.raw),
-                        mono: (0, $a61750b8fbee4dae$export$13afda237b1c9846).mergeBuffers(buffer.mono, resampledData.mono)
+                        raw: (0, $45766326c6faa3c4$export$13afda237b1c9846).mergeBuffers(buffer.raw, resampledData.raw),
+                        mono: (0, $45766326c6faa3c4$export$13afda237b1c9846).mergeBuffers(buffer.mono, resampledData.mono)
                     };
                     if (this._chunkProcessorBuffer.mono.byteLength >= this._chunkProcessorSize) {
                         this._chunkProcessor(this._chunkProcessorBuffer);
@@ -1419,7 +1477,7 @@ class $7cef7a69bdf8f84d$export$2934cf2d25c67a48 {
    * @returns {import('./analysis/audio_analysis.js').AudioAnalysisOutputType}
    */ getFrequencies(analysisType = "frequency", minDecibels = -100, maxDecibels = -30) {
         if (!this.processor) throw new Error("Session ended: please call .begin() first");
-        return (0, $5853841ab58516d4$export$2c3136da0bf130f9).getFrequencies(this.analyser, this.sampleRate, null, analysisType, minDecibels, maxDecibels);
+        return (0, $3f7a723e434a4b86$export$2c3136da0bf130f9).getFrequencies(this.analyser, this.sampleRate, null, analysisType, minDecibels, maxDecibels);
     }
     /**
    * Pauses the recording
@@ -1436,7 +1494,7 @@ class $7cef7a69bdf8f84d$export$2934cf2d25c67a48 {
     }
     /**
    * Start recording stream and storing to memory from the connected audio source
-   * @param {(data: { mono: Int16Array; raw: Int16Array }) => any} [chunkProcessor]
+   * @param {(data: { mono: ArrayBuffer; raw: ArrayBuffer }) => any} [chunkProcessor]
    * @param {number} [chunkSize] chunkProcessor will not be triggered until this size threshold met in mono audio
    * @returns {Promise<true>}
    */ async record(chunkProcessor = ()=>{}, chunkSize = 8192) {
@@ -1480,7 +1538,7 @@ class $7cef7a69bdf8f84d$export$2934cf2d25c67a48 {
         if (!force && this.recording) throw new Error("Currently recording: please call .pause() first, or call .save(true) to force");
         this.log("Exporting ...");
         const exportData = await this._event("export");
-        const packer = new (0, $a61750b8fbee4dae$export$13afda237b1c9846)();
+        const packer = new (0, $45766326c6faa3c4$export$13afda237b1c9846)();
         const result = packer.pack(this.sampleRate, exportData.audio);
         return result;
     }
@@ -1503,7 +1561,7 @@ class $7cef7a69bdf8f84d$export$2934cf2d25c67a48 {
         this.processor = null;
         this.source = null;
         this.node = null;
-        const packer = new (0, $a61750b8fbee4dae$export$13afda237b1c9846)();
+        const packer = new (0, $45766326c6faa3c4$export$13afda237b1c9846)();
         const result = packer.pack(this.sampleRate, exportData.audio);
         return result;
     }
@@ -1522,16 +1580,986 @@ globalThis.WavRecorder = WavRecorder;
 
 
 
-var $c2e964a535c1120e$exports = {};
-$c2e964a535c1120e$exports = JSON.parse("{\"name\":\"@pipecat-ai/daily-transport\",\"version\":\"1.6.8\",\"license\":\"BSD-2-Clause\",\"main\":\"dist/index.js\",\"module\":\"dist/index.module.js\",\"types\":\"dist/index.d.ts\",\"source\":\"src/index.ts\",\"repository\":{\"type\":\"git\",\"url\":\"git+https://github.com/pipecat-ai/pipecat-client-web-transports.git\"},\"exports\":{\".\":{\"types\":\"./dist/index.d.ts\",\"import\":\"./dist/index.module.js\",\"require\":\"./dist/index.js\"}},\"files\":[\"dist\",\"package.json\",\"README.md\"],\"scripts\":{\"build\":\"parcel build --no-cache\",\"dev\":\"parcel watch\",\"lint\":\"eslint . --ext ts --report-unused-disable-directives --max-warnings 0\"},\"devDependencies\":{\"@pipecat-ai/client-js\":\"^1.13.0\",\"eslint\":\"9.39.1\",\"eslint-config-prettier\":\"^9.1.0\",\"eslint-plugin-simple-import-sort\":\"^12.1.1\"},\"peerDependencies\":{\"@pipecat-ai/client-js\":\"~1.13.0\"},\"dependencies\":{\"@daily-co/daily-js\":\"^0.90.0\"},\"description\":\"Pipecat Daily Transport Package\",\"author\":\"Daily.co\",\"bugs\":{\"url\":\"https://github.com/pipecat-ai/pipecat-client-web-transports/issues\"},\"homepage\":\"https://github.com/pipecat-ai/pipecat-client-web-transports/blob/main/transports/daily-webrtc/README.md\"}");
+
+class $48faeb169c82673e$export$4a0c46dbbe2ddb67 {
+    constructor(){
+        this._callbacks = {};
+        this._micEnabled = true;
+        this._camEnabled = false;
+        this._supportsScreenShare = false;
+    }
+    setUserAudioCallback(userAudioCallback) {
+        this._userAudioCallback = userAudioCallback;
+    }
+    setClientOptions(options, override = false) {
+        if (this._options && !override) return;
+        this._options = options;
+        this._callbacks = options.callbacks ?? {};
+        this._micEnabled = options.enableMic ?? true;
+        this._camEnabled = options.enableCam ?? false;
+    }
+    get supportsScreenShare() {
+        return this._supportsScreenShare;
+    }
+    /**
+     * The kinds of media this media manager can capture, for the transport's
+     * `mediaSupport`. `false` rules a kind out, and a missing key leaves it unknown.
+     * By default only screen share can be ruled out: `screenShare` is `false` when
+     * `supportsScreenShare` is, because this media manager or the browser can't
+     * share the screen. Media managers that know more override this.
+     */ get mediaSupport() {
+        return this._supportsScreenShare ? {} : {
+            screenShare: false
+        };
+    }
+}
+class $48faeb169c82673e$export$45c5b9bfba2f6304 extends $48faeb169c82673e$export$4a0c46dbbe2ddb67 {
+    constructor(recorderChunkSize, recorderSampleRate = 24000){
+        super();
+        this._initialized = false;
+        this._recorderChunkSize = undefined;
+        this._recorderChunkSize = recorderChunkSize;
+        this._wavRecorder = new (0, $35ad6181fc724add$export$439b217ca659a877)({
+            sampleRate: recorderSampleRate
+        });
+        this._wavStreamPlayer = new (0, $347522367945ce82$export$9698d62c78b8f366)({
+            sampleRate: 24000
+        });
+    }
+    /** Captures the microphone only. */ get mediaSupport() {
+        return {
+            mic: true,
+            cam: false,
+            screenShare: false
+        };
+    }
+    async initialize() {
+        try {
+            await this._wavRecorder.begin();
+        } catch (error) {
+        // void. swallow the error. we still want to set up
+        // the listeners and the player.
+        }
+        this._wavRecorder.listenForDeviceChange(null);
+        this._wavRecorder.listenForDeviceChange(this._handleAvailableDevicesUpdated.bind(this));
+        this._wavRecorder.listenForDeviceErrors(null);
+        this._wavRecorder.listenForDeviceErrors(this._handleDeviceError.bind(this));
+        await this._wavStreamPlayer.connect();
+        this._initialized = true;
+    }
+    async connect() {
+        if (!this._initialized) await this.initialize();
+        const isAlreadyRecording = this._wavRecorder.getStatus() == "recording";
+        if (this._micEnabled && !isAlreadyRecording) await this._startRecording();
+        if (this._camEnabled) console.warn("WavMediaManager does not support video input.");
+    }
+    async disconnect() {
+        if (!this._initialized) return;
+        await this._wavRecorder.end();
+        await this._wavStreamPlayer.interrupt();
+        this._initialized = false;
+    }
+    async interruptBotAudio() {
+        return this._wavStreamPlayer.interrupt();
+    }
+    bufferBotAudio(data, id) {
+        return this._wavStreamPlayer.add16BitPCM(data, id);
+    }
+    getAllMics() {
+        return this._wavRecorder.listDevices();
+    }
+    getAllCams() {
+        // TODO: Video not supported yet
+        return Promise.resolve([]);
+    }
+    getAllSpeakers() {
+        // TODO: Implement speaker support
+        return Promise.resolve([]);
+    }
+    async updateMic(micId) {
+        const prevMic = this._wavRecorder.deviceSelection;
+        if (this._wavRecorder.getStatus() !== "ended") await this._wavRecorder.end();
+        try {
+            await this._wavRecorder.begin(micId);
+            if (this._micEnabled) await this._startRecording();
+            const curMic = this._wavRecorder.deviceSelection;
+            if (curMic && prevMic && prevMic.label !== curMic.label) this._callbacks.onMicUpdated?.(curMic);
+        } catch (error) {
+        // void. If begin() fails, it will have already logged and called
+        // onDeviceError if necessary.
+        }
+    }
+    updateCam(camId) {
+    // TODO: Video not supported yet
+    }
+    updateSpeaker(speakerId) {
+    // TODO: Implement speaker support
+    }
+    get selectedMic() {
+        return this._wavRecorder.deviceSelection ?? {};
+    }
+    get selectedCam() {
+        // TODO: Video not supported yet
+        return {};
+    }
+    get selectedSpeaker() {
+        // TODO: Implement speaker support
+        return {};
+    }
+    async enableMic(enable) {
+        this._micEnabled = enable;
+        if (!this._wavRecorder.stream) return;
+        this._wavRecorder.stream.getAudioTracks().forEach((track)=>{
+            track.enabled = enable;
+            if (!enable) this._callbacks.onTrackStopped?.(track, $48faeb169c82673e$var$localParticipant());
+        });
+        if (enable) await this._startRecording();
+        else await this._wavRecorder.pause();
+    }
+    enableCam(enable) {
+        // TODO: Video not supported yet
+        console.warn("WavMediaManager does not support video input.");
+    }
+    enableScreenShare(enable) {
+        // TODO: Screensharing not supported yet
+        console.warn("WavMediaManager does not support screen sharing.");
+    }
+    get isCamEnabled() {
+        // TODO: Video not supported yet
+        return false;
+    }
+    get isMicEnabled() {
+        return this._micEnabled;
+    }
+    get isSharingScreen() {
+        // TODO: Screensharing not supported yet
+        return false;
+    }
+    tracks() {
+        const tracks = this._wavRecorder.stream?.getTracks()[0];
+        return {
+            local: tracks ? {
+                audio: tracks
+            } : {}
+        };
+    }
+    async _startRecording() {
+        await this._wavRecorder.record((data)=>{
+            this._userAudioCallback?.(data.mono);
+        }, this._recorderChunkSize);
+        const track = this._wavRecorder.stream?.getAudioTracks()[0];
+        if (track) this._callbacks.onTrackStarted?.(track, $48faeb169c82673e$var$localParticipant());
+    }
+    _handleAvailableDevicesUpdated(devices) {
+        this._callbacks.onAvailableCamsUpdated?.(devices.filter((d)=>d.kind === "videoinput"));
+        this._callbacks.onAvailableMicsUpdated?.(devices.filter((d)=>d.kind === "audioinput"));
+        // if the current device went away or we're using the default and
+        // the default changed, reset the mic.
+        const defaultDevice = devices.find((d)=>d.deviceId === "default");
+        const currentDevice = this._wavRecorder.deviceSelection;
+        if (currentDevice && (!devices.some((d)=>d.deviceId === currentDevice.deviceId) || currentDevice.deviceId === "default" && currentDevice.label !== defaultDevice?.label)) this.updateMic("");
+    }
+    _handleDeviceError({ devices: devices, type: type, error: error }) {
+        const deviceError = new (0, $1clrS$pipecataiclientjs.DeviceError)(devices, type, error?.message, error ? {
+            sourceError: error
+        } : undefined);
+        this._callbacks.onDeviceError?.(deviceError);
+    }
+}
+const $48faeb169c82673e$var$localParticipant = ()=>{
+    return {
+        id: "local",
+        name: "",
+        local: true
+    };
+};
+
+
+
+
+
 
 
-var $28bdeb35415d61e8$export$ef180de88fd317cc;
+class $00a190ef6aa79f0d$export$c95c65abc5f47125 extends (0, $48faeb169c82673e$export$4a0c46dbbe2ddb67) {
+    constructor(enablePlayer = true, enableRecording = true, onTrackStartedCallback, onTrackStoppedCallback, recorderChunkSize, recorderSampleRate = 24000, playerSampleRate = 24000){
+        super();
+        this._selectedCam = {};
+        this._selectedMic = {};
+        this._selectedSpeaker = {};
+        this._remoteAudioLevelInterval = null;
+        this._recorderChunkSize = undefined;
+        this._initialized = false;
+        this._connected = false;
+        this._currentAudioTrack = null;
+        this._connectResolve = null;
+        this.onTrackStartedCallback = onTrackStartedCallback;
+        this.onTrackStoppedCallback = onTrackStoppedCallback;
+        this._recorderChunkSize = recorderChunkSize;
+        this._supportsScreenShare = (0, $15398512372f76d1$export$7f8f33b9b54c8307)();
+        this._daily = (0, ($parcel$interopDefault($1clrS$dailycodailyjs))).getCallInstance() ?? (0, ($parcel$interopDefault($1clrS$dailycodailyjs))).createCallObject();
+        if (enableRecording) this._mediaStreamRecorder = new (0, $ab812aec7679ec67$export$2934cf2d25c67a48)({
+            sampleRate: recorderSampleRate
+        });
+        if (enablePlayer) this._wavStreamPlayer = new (0, $347522367945ce82$export$9698d62c78b8f366)({
+            sampleRate: playerSampleRate
+        });
+        this._daily.on("track-started", this.handleTrackStarted.bind(this));
+        this._daily.on("track-stopped", this.handleTrackStopped.bind(this));
+        this._daily.on("available-devices-updated", this._handleAvailableDevicesUpdated.bind(this));
+        this._daily.on("selected-devices-updated", this._handleSelectedDevicesUpdated.bind(this));
+        this._daily.on("camera-error", this.handleDeviceError.bind(this));
+        this._daily.on("local-audio-level", this._handleLocalAudioLevel.bind(this));
+    }
+    async initialize() {
+        if (this._initialized) {
+            console.warn("DailyMediaManager already initialized");
+            return;
+        }
+        const infos = await this._daily.startCamera({
+            startVideoOff: !this._camEnabled,
+            startAudioOff: !this._micEnabled,
+            dailyConfig: {
+                useDevicePreferenceCookies: true
+            }
+        });
+        const { devices: devices } = await this._daily.enumerateDevices();
+        const cams = devices.filter((d)=>d.kind === "videoinput");
+        const mics = devices.filter((d)=>d.kind === "audioinput");
+        const speakers = devices.filter((d)=>d.kind === "audiooutput");
+        this._callbacks.onAvailableCamsUpdated?.(cams);
+        this._callbacks.onAvailableMicsUpdated?.(mics);
+        this._callbacks.onAvailableSpeakersUpdated?.(speakers);
+        this._selectedCam = infos.camera;
+        this._callbacks.onCamUpdated?.(infos.camera);
+        this._selectedMic = infos.mic;
+        this._callbacks.onMicUpdated?.(infos.mic);
+        this._selectedSpeaker = infos.speaker;
+        this._callbacks.onSpeakerUpdated?.(infos.speaker);
+        // Instantiate audio observers
+        if (!this._daily.isLocalAudioLevelObserverRunning()) await this._daily.startLocalAudioLevelObserver(100);
+        if (this._wavStreamPlayer) {
+            await this._wavStreamPlayer.connect();
+            if (!this._remoteAudioLevelInterval) this._remoteAudioLevelInterval = setInterval(()=>{
+                const frequencies = this._wavStreamPlayer.getFrequencies();
+                let aveVal = 0;
+                if (frequencies.values?.length) aveVal = frequencies.values.reduce((a, c)=>a + c, 0) / frequencies.values.length;
+                this._handleRemoteAudioLevel(aveVal);
+            }, 100);
+        }
+        this._initialized = true;
+    }
+    async connect() {
+        if (this._connected) {
+            console.warn("DailyMediaManager already connected");
+            return;
+        }
+        this._connected = true;
+        if (!this._initialized) return new Promise((resolve)=>{
+            (async ()=>{
+                this._connectResolve = resolve;
+                await this.initialize();
+                // Without a recorder, handleTrackStarted never fires to resolve this
+                // promise, so resolve here once initialization is complete.
+                if (this._connectResolve && !this._mediaStreamRecorder) {
+                    this._connectResolve();
+                    this._connectResolve = null;
+                }
+            })();
+        });
+        if (this._micEnabled) this._startRecording();
+    }
+    async disconnect() {
+        if (this._remoteAudioLevelInterval) clearInterval(this._remoteAudioLevelInterval);
+        this._remoteAudioLevelInterval = null;
+        this._daily.leave();
+        this._currentAudioTrack = null;
+        await this._mediaStreamRecorder?.end();
+        this._wavStreamPlayer?.interrupt();
+        this._initialized = false;
+        this._connected = false;
+    }
+    async interruptBotAudio() {
+        return this._wavStreamPlayer?.interrupt();
+    }
+    bufferBotAudio(data, id) {
+        return this._wavStreamPlayer?.add16BitPCM(data, id);
+    }
+    async getAllMics() {
+        let devices = (await this._daily.enumerateDevices()).devices;
+        return devices.filter((device)=>device.kind === "audioinput");
+    }
+    async getAllCams() {
+        let devices = (await this._daily.enumerateDevices()).devices;
+        return devices.filter((device)=>device.kind === "videoinput");
+    }
+    async getAllSpeakers() {
+        let devices = (await this._daily.enumerateDevices()).devices;
+        return devices.filter((device)=>device.kind === "audiooutput");
+    }
+    updateMic(micId) {
+        this._daily.setInputDevicesAsync({
+            audioDeviceId: micId
+        }).then((deviceInfo)=>{
+            this._selectedMic = deviceInfo.mic;
+        });
+    }
+    updateCam(camId) {
+        this._daily.setInputDevicesAsync({
+            videoDeviceId: camId
+        }).then((deviceInfo)=>{
+            this._selectedCam = deviceInfo.camera;
+        });
+    }
+    async updateSpeaker(speakerId) {
+        if (!this._wavStreamPlayer) {
+            try {
+                const dInfo = await this._daily.setOutputDeviceAsync({
+                    outputDeviceId: speakerId
+                });
+                this._selectedSpeaker = dInfo.speaker;
+                this._callbacks.onSpeakerUpdated?.(this._selectedSpeaker);
+            } catch (e) {
+                console.error("Error setting output device", e);
+            }
+            return;
+        }
+        if (speakerId !== "default" && this._selectedSpeaker.deviceId === speakerId) return;
+        let sID = speakerId;
+        if (sID === "default") {
+            const speakers = await this.getAllSpeakers();
+            const defaultSpeaker = speakers.find((s)=>s.deviceId === "default");
+            if (!defaultSpeaker) {
+                console.warn("No default speaker found");
+                return;
+            }
+            speakers.splice(speakers.indexOf(defaultSpeaker), 1);
+            const defaultSpeakerCp = speakers.find((s)=>defaultSpeaker.label.includes(s.label));
+            sID = defaultSpeakerCp?.deviceId ?? speakerId;
+        }
+        this._wavStreamPlayer?.updateSpeaker(sID).then(()=>{
+            this._selectedSpeaker = {
+                deviceId: speakerId
+            };
+            this._callbacks.onSpeakerUpdated?.(this._selectedSpeaker);
+        });
+    }
+    get selectedMic() {
+        return this._selectedMic;
+    }
+    get selectedCam() {
+        return this._selectedCam;
+    }
+    get selectedSpeaker() {
+        return this._selectedSpeaker;
+    }
+    async enableMic(enable) {
+        this._micEnabled = enable;
+        if (!this._daily.participants()?.local) return;
+        this._daily.setLocalAudio(enable);
+        if (this._mediaStreamRecorder) {
+            if (enable) {
+                if (this._mediaStreamRecorder.getStatus() === "paused") this._startRecording();
+                 // else, we'll record on the track-started event
+            } else if (this._mediaStreamRecorder.getStatus() === "recording") this._mediaStreamRecorder.pause();
+        }
+    }
+    enableCam(enable) {
+        this._camEnabled = enable;
+        this._daily.setLocalVideo(enable);
+    }
+    enableScreenShare(enable) {
+        if (enable) this._daily.startScreenShare();
+        else this._daily.stopScreenShare();
+    }
+    // NOTE: deliberately not `this._daily.localVideo()` / `localAudio()`. Daily
+    // fires 'track-started'/'track-stopped' *before* it commits the new state
+    // to the participant object those getters read from (see daily-js's
+    // DAILY_EVENT_PARTICIPANT_UPDATED handling: maybeEventTrackStopped/Started
+    // run, then `this._participants[id]` is reassigned). Callers that react to
+    // TrackStarted/TrackStopped by reading isCamEnabled/isMicEnabled — e.g. to
+    // resync UI state — would otherwise always observe the pre-toggle value.
+    // _camEnabled/_micEnabled are updated synchronously in
+    // handleTrackStarted/handleTrackStopped below, before those callbacks fire.
+    get isCamEnabled() {
+        return this._camEnabled;
+    }
+    get isMicEnabled() {
+        return this._micEnabled;
+    }
+    /** Captures the microphone, the camera and, where the browser can, the screen. */ get mediaSupport() {
+        return {
+            mic: true,
+            cam: true,
+            screenShare: this._supportsScreenShare
+        };
+    }
+    get isSharingScreen() {
+        return this._daily.localScreenAudio() || this._daily.localScreenVideo();
+    }
+    tracks() {
+        const participants = this._daily.participants();
+        return {
+            local: {
+                audio: participants?.local?.tracks?.audio?.persistentTrack,
+                screenAudio: participants?.local?.tracks?.screenAudio?.persistentTrack,
+                screenVideo: participants?.local?.tracks?.screenVideo?.persistentTrack,
+                video: participants?.local?.tracks?.video?.persistentTrack
+            }
+        };
+    }
+    _startRecording() {
+        if (!this._connected || !this._mediaStreamRecorder) return;
+        try {
+            this._mediaStreamRecorder.record((data)=>{
+                this._userAudioCallback(data.mono);
+            }, this._recorderChunkSize);
+        } catch (e) {
+            const err = e;
+            if (!err.message.includes("Already recording")) console.error("Error starting recording", e);
+        }
+    }
+    _handleAvailableDevicesUpdated(event) {
+        this._callbacks.onAvailableCamsUpdated?.(event.availableDevices.filter((d)=>d.kind === "videoinput"));
+        this._callbacks.onAvailableMicsUpdated?.(event.availableDevices.filter((d)=>d.kind === "audioinput"));
+        this._callbacks.onAvailableSpeakersUpdated?.(event.availableDevices.filter((d)=>d.kind === "audiooutput"));
+        if (this._selectedSpeaker.deviceId === "default") this.updateSpeaker("default");
+    }
+    _handleSelectedDevicesUpdated(event) {
+        if (this._selectedCam?.deviceId !== event.devices.camera) {
+            this._selectedCam = event.devices.camera;
+            this._callbacks.onCamUpdated?.(event.devices.camera);
+        }
+        if (this._selectedMic?.deviceId !== event.devices.mic) {
+            this._selectedMic = event.devices.mic;
+            this._callbacks.onMicUpdated?.(event.devices.mic);
+        }
+    }
+    handleDeviceError(ev) {
+        const generateDeviceError = (error)=>{
+            const devices = [];
+            switch(error.type){
+                case "permissions":
+                    error.blockedMedia.forEach((d)=>{
+                        devices.push(d === "video" ? "cam" : "mic");
+                    });
+                    return new (0, $1clrS$pipecataiclientjs.DeviceError)(devices, error.type, error.msg, {
+                        blockedBy: error.blockedBy
+                    });
+                case "not-found":
+                    error.missingMedia.forEach((d)=>{
+                        devices.push(d === "video" ? "cam" : "mic");
+                    });
+                    return new (0, $1clrS$pipecataiclientjs.DeviceError)(devices, error.type, error.msg);
+                case "constraints":
+                    error.failedMedia.forEach((d)=>{
+                        devices.push(d === "video" ? "cam" : "mic");
+                    });
+                    return new (0, $1clrS$pipecataiclientjs.DeviceError)(devices, error.type, error.msg, {
+                        reason: error.reason
+                    });
+                case "cam-in-use":
+                    devices.push("cam");
+                    return new (0, $1clrS$pipecataiclientjs.DeviceError)(devices, "in-use", error.msg);
+                case "mic-in-use":
+                    devices.push("mic");
+                    return new (0, $1clrS$pipecataiclientjs.DeviceError)(devices, "in-use", error.msg);
+                case "cam-mic-in-use":
+                    devices.push("cam");
+                    devices.push("mic");
+                    return new (0, $1clrS$pipecataiclientjs.DeviceError)(devices, "in-use", error.msg);
+                case "undefined-mediadevices":
+                case "unknown":
+                default:
+                    devices.push("cam");
+                    devices.push("mic");
+                    return new (0, $1clrS$pipecataiclientjs.DeviceError)(devices, error.type, error.msg);
+            }
+        };
+        const deviceError = generateDeviceError(ev.error);
+        // enableMic()/enableCam() set _micEnabled/_camEnabled optimistically,
+        // but setLocalAudio()/setLocalVideo() are fire-and-forget — no promise,
+        // no synchronous failure signal — so a failed request (blocked
+        // permission, device in use, etc.) leaves that optimistic value wrong
+        // with nothing to correct it: no track-started/stopped ever fires for
+        // an operation that didn't actually take effect. This is the only
+        // signal we get that the request failed, so resync from Daily's actual
+        // state for whichever device(s) it implicates.
+        if (deviceError.devices.includes("mic")) this._micEnabled = this._daily.localAudio();
+        if (deviceError.devices.includes("cam")) this._camEnabled = this._daily.localVideo();
+        this._callbacks.onDeviceError?.(deviceError);
+    }
+    _handleLocalAudioLevel(ev) {
+        this._callbacks.onLocalAudioLevel?.(ev.audioLevel);
+    }
+    _handleRemoteAudioLevel(audioLevel) {
+        this._callbacks.onRemoteAudioLevel?.(audioLevel, $00a190ef6aa79f0d$var$botParticipant());
+    }
+    async handleTrackStarted(event) {
+        if (!event.participant?.local) return;
+        if (event.track.kind === "audio") {
+            this._micEnabled = true;
+            if (this._mediaStreamRecorder) {
+                const status = this._mediaStreamRecorder.getStatus();
+                switch(status){
+                    case "ended":
+                        try {
+                            await this._mediaStreamRecorder.begin(event.track);
+                            if (this._connected) {
+                                this._startRecording();
+                                if (this._connectResolve) {
+                                    this._connectResolve();
+                                    this._connectResolve = null;
+                                }
+                            }
+                        } catch (e) {
+                        // void. nothing to do.
+                        }
+                        break;
+                    case "paused":
+                        this._startRecording();
+                        break;
+                    case "recording":
+                    default:
+                        if (this._currentAudioTrack !== event.track) {
+                            await this._mediaStreamRecorder.end();
+                            try {
+                                await this._mediaStreamRecorder.begin(event.track);
+                                this._startRecording();
+                            } catch (e) {
+                            // void. nothing to do.
+                            }
+                        } else console.warn("track-started event received for current track and already recording");
+                        break;
+                }
+            }
+            this._currentAudioTrack = event.track;
+        } else if (event.track.kind === "video") this._camEnabled = true;
+        this._callbacks.onTrackStarted?.(event.track, event.participant ? $00a190ef6aa79f0d$var$dailyParticipantToParticipant(event.participant) : undefined);
+        this.onTrackStartedCallback?.(event);
+    }
+    handleTrackStopped(event) {
+        if (!event.participant?.local) return;
+        if (event.track.kind === "audio") {
+            this._micEnabled = false;
+            if (this._mediaStreamRecorder && this._mediaStreamRecorder.getStatus() === "recording") this._mediaStreamRecorder.pause();
+        } else if (event.track.kind === "video") this._camEnabled = false;
+        this._callbacks.onTrackStopped?.(event.track, event.participant ? $00a190ef6aa79f0d$var$dailyParticipantToParticipant(event.participant) : undefined);
+        this.onTrackStoppedCallback?.(event);
+    }
+}
+const $00a190ef6aa79f0d$var$dailyParticipantToParticipant = (p)=>({
+        id: p.user_id,
+        local: p.local,
+        name: p.user_name
+    });
+const $00a190ef6aa79f0d$var$botParticipant = ()=>({
+        id: "bot",
+        local: false,
+        name: "Bot"
+    });
+
+
+
+const $7f41aaa208a19660$var$readyStates = [
+    "CONNECTING",
+    "OPEN",
+    "CLOSING",
+    "CLOSED"
+];
+const $7f41aaa208a19660$var$KEEP_ALIVE_INTERVAL = 5000;
+const $7f41aaa208a19660$var$KEEP_ALIVE_TIMEOUT = 15000;
+// client side code in soupSFU has a timeout of 15 seconds for command response
+// 5 seconds seems reasonable that it provides roughly 3 retry attempts
+const $7f41aaa208a19660$var$WEBSOCKET_CONNECTION_TIMEOUT = 150000;
+const $7f41aaa208a19660$var$DEFAULT_RECONNECT_ATTEMPTS = 2;
+const $7f41aaa208a19660$var$MAX_RECONNECT_ATTEMPTS = 10;
+const $7f41aaa208a19660$var$DEFAULT_RECONNECT_INTERVAL = 1000;
+const $7f41aaa208a19660$var$MAX_RECONNECT_INTERVAL = 30000;
+const $7f41aaa208a19660$var$DEFAULT_RECONNECT_DECAY = 1.5;
+const $7f41aaa208a19660$var$WEBSOCKET_TIMEOUT_CODE = 4100;
+const $7f41aaa208a19660$var$SIG_CONNECTION_CANCELED = "SIG_CONNECTION_CANCELED";
+const $7f41aaa208a19660$var$WEBSOCKET_ERROR = "WEBSOCKET_ERROR";
+var $7f41aaa208a19660$var$LOG_LEVEL;
+(function(LOG_LEVEL) {
+    LOG_LEVEL[LOG_LEVEL["DEBUG"] = 0] = "DEBUG";
+    LOG_LEVEL[LOG_LEVEL["ERROR"] = 1] = "ERROR";
+    LOG_LEVEL[LOG_LEVEL["INFO"] = 2] = "INFO";
+    LOG_LEVEL[LOG_LEVEL["WARN"] = 3] = "WARN";
+})($7f41aaa208a19660$var$LOG_LEVEL || ($7f41aaa208a19660$var$LOG_LEVEL = {}));
+class $7f41aaa208a19660$var$rWebSocket {
+    constructor(url, protocols){
+        this._closedManually = false;
+        this._errored = false;
+        this._rejected = false;
+        this._timed_out = false;
+        this._initialConnectionOk = false;
+        this._ws = new WebSocket(url, protocols);
+    }
+    addEventListener(type, listener) {
+        this._ws.addEventListener(type, listener);
+    }
+    // Add other WebSocket methods as needed
+    close(code, reason) {
+        this._ws.close(code, reason);
+    }
+    send(data) {
+        this._ws.send(data);
+    }
+    // Add getters for WebSocket properties
+    get url() {
+        return this._ws.url;
+    }
+    get readyState() {
+        return this._ws.readyState;
+    }
+}
+class $7f41aaa208a19660$export$4f3d0ffd941ebefb extends (0, $1clrS$events.EventEmitter) {
+    constructor(address, protocols, options = {}){
+        super();
+        if (!address) throw new Error("Need a valid WebSocket URL");
+        this._ws = null;
+        this._url = address;
+        this._protocols = protocols;
+        this._parseBlobToJson = options?.parseBlobToJson ?? true;
+        this.init();
+    }
+    init() {
+        this._keepAliveTimeout = $7f41aaa208a19660$var$KEEP_ALIVE_TIMEOUT;
+        this._keepAliveInterval = $7f41aaa208a19660$var$KEEP_ALIVE_INTERVAL;
+        this._disconnected = false;
+        this._keepIntervalID = null;
+        this._shouldRetryFn = null;
+        this._connectionTimeout = $7f41aaa208a19660$var$WEBSOCKET_CONNECTION_TIMEOUT;
+        this._reconnectAttempts = 0;
+        this._allowedReconnectAttempts = $7f41aaa208a19660$var$DEFAULT_RECONNECT_ATTEMPTS;
+        this._reconnectInterval = $7f41aaa208a19660$var$DEFAULT_RECONNECT_INTERVAL;
+        this._maxReconnectInterval = $7f41aaa208a19660$var$MAX_RECONNECT_INTERVAL;
+        this._reconnectDecay = $7f41aaa208a19660$var$DEFAULT_RECONNECT_DECAY;
+    }
+    async connect() {
+        return new Promise((resolve, reject)=>{
+            this._disconnected = false;
+            this.clearReconnectTimeout();
+            let ws = new $7f41aaa208a19660$var$rWebSocket(this._url, this._protocols);
+            this.setConnectionTimeout();
+            ws.addEventListener("close", (evt)=>{
+                const closeEvent = evt;
+                let code = ws._timed_out ? $7f41aaa208a19660$var$WEBSOCKET_TIMEOUT_CODE : closeEvent.code;
+                let reason = ws._timed_out ? "websocket connection timed out" : closeEvent.reason;
+                ws._timed_out = false;
+                if (!ws._closedManually && ws._initialConnectionOk) {
+                    console.warn(`signaling socket closed unexpectedly: ${code}${reason ? " " + reason : ""}`);
+                    this._closeSocket();
+                    this.emit("close", code, reason);
+                } else this.log("signaling socket closed");
+                if (!ws._closedManually && (ws._errored || ws._timed_out)) {
+                    console.warn(`signaling socket closed on error: ${code}${reason ? " " + reason : ""}`);
+                    if (!ws._rejected) {
+                        ws._rejected = true;
+                        const err = new Error(`WebSocket connection error (${code}): ${reason}`);
+                        err.name = $7f41aaa208a19660$var$WEBSOCKET_ERROR;
+                        reject(err);
+                    }
+                }
+            });
+            ws.addEventListener("open", (evt)=>{
+                this.log("wss connection opened to", $7f41aaa208a19660$var$LOG_LEVEL.DEBUG, this._url);
+                this.clearConnectionTimeout();
+                // now that the timeout closes the socket, in theory this onopen
+                // callback should never happen in the first place, but seems
+                // harmless to leave these safeguards in
+                if (ws._rejected || ws._timed_out) return;
+                if (ws._closedManually || this._ws && this._ws !== ws) {
+                    ws._rejected = true;
+                    ws.close();
+                    let err = Error("wss connection interrupted by disconnect or newer connection");
+                    err.name = $7f41aaa208a19660$var$SIG_CONNECTION_CANCELED;
+                    reject(err);
+                    return;
+                }
+                ws._initialConnectionOk = this._url;
+                this._lastMsgRecvTime = Date.now();
+                if (this._keepAliveInterval) this._keepIntervalID = setInterval(()=>this.checkSocketHealthAndSendKeepAlive(), this._keepAliveInterval);
+                this._ws = ws;
+                this.emit("open");
+                resolve(ws);
+            });
+            ws.addEventListener("error", (evt)=>{
+                // fyi: evt is an Event here, with 0 amount of helpful info. If there
+                //   happens to be info about the error, it's included in the
+                //   accompanying close event (because that make sense. shakes head)
+                //   SO. We do not reject here. Instead, we just set the _errored
+                //   flag on the socket so when the close event occurs, it knows to
+                //   reject the promise
+                if (!ws._closedManually) {
+                    const wsTarget = evt.currentTarget;
+                    this.log(`websocket error event: ${wsTarget?.url}`);
+                }
+                ws._errored = true;
+            });
+            ws.addEventListener("message", (msg)=>{
+                this._handleMessage(msg);
+            });
+        });
+    }
+    setConnectionTimeout() {
+        this._connectionTimeoutID = setTimeout(async ()=>{
+            this.log("Connection reconnect attempt timed out.");
+            this.emit("connection-timeout");
+            this.clearConnectionTimeout();
+            await this._closeSocket();
+        }, this._connectionTimeout);
+    }
+    clearConnectionTimeout() {
+        clearTimeout(this._connectionTimeoutID);
+        this._connectionTimeoutID = undefined;
+    }
+    clearReconnectTimeout() {
+        clearTimeout(this._reconnectTimeoutID);
+        this._reconnectTimeoutID = undefined;
+    }
+    clearKeepAliveInterval() {
+        if (this._keepIntervalID) {
+            clearInterval(this._keepIntervalID);
+            this._keepIntervalID = null;
+        }
+    }
+    async checkSocketHealthAndSendKeepAlive() {
+        if (!(this._ws && this._ws.readyState === WebSocket.OPEN)) return;
+        if (!this._keepAliveTimeout || !this._keepAliveInterval) return;
+        // See if we haven't gotten a message back recently, and if we
+        // haven't, close the socket. the os timeouts to detect if a socket
+        // has gone stale are longer than we want.
+        if (Date.now() - this._lastMsgRecvTime > this._keepAliveTimeout) {
+            this.log("Connection is stale, need to reconnect", $7f41aaa208a19660$var$LOG_LEVEL.WARN);
+            await this._closeSocket();
+            return;
+        }
+        // Only emit the keep-alive event if we haven't sent anything else recently
+        if (Date.now() - this._lastMsgSendTime < this._keepAliveInterval) return;
+        this.log("Emitting keep-alive", $7f41aaa208a19660$var$LOG_LEVEL.DEBUG);
+        this.emit("keep-alive");
+    }
+    // We use the word manually here to imply the application using this code
+    // or this code itself will decide to close the socket.
+    async _closeSocket() {
+        this.log("Closing");
+        try {
+            this.clearKeepAliveInterval();
+            this._lastMsgRecvTime = 0;
+            if (this._ws) {
+                this._ws._closedManually = true;
+                this._ws.close();
+            }
+            // query retry function if we want to retry.
+            const shouldRetry = this._ws?._initialConnectionOk && this._shouldRetryFn && this._shouldRetryFn();
+            this._ws = null;
+            if (shouldRetry) {
+                this.log("Emitting reconnect", $7f41aaa208a19660$var$LOG_LEVEL.DEBUG);
+                this.emit("reconnecting");
+                await this.retryFailedConnection();
+            }
+        } catch (error) {
+            this.log(`Error while closing and retrying: ${error}`, $7f41aaa208a19660$var$LOG_LEVEL.ERROR);
+        }
+    }
+    async retryFailedConnection() {
+        if (this._reconnectAttempts < this._allowedReconnectAttempts) {
+            if (this._reconnectTimeoutID) {
+                this.log("Retry already scheduled");
+                return;
+            }
+            this.log("Retrying failed connection");
+            let timeout = // The timeout logic is taken from
+            // https://github.com/joewalnes/reconnecting-websocket
+            this._reconnectInterval * Math.pow(this._reconnectDecay, this._reconnectAttempts);
+            timeout = timeout > this._maxReconnectInterval ? this._maxReconnectInterval : timeout;
+            this.log(`Reconnecting in ${timeout / 1000} seconds`);
+            this._reconnectAttempts += 1;
+            this._reconnectTimeoutID = setTimeout(()=>this.connect(), timeout);
+        } else {
+            this.log("Maximum connection retry attempts exceeded", $7f41aaa208a19660$var$LOG_LEVEL.ERROR);
+            this.emit("reconnect-failed");
+        }
+    }
+    log(msg, log_level = $7f41aaa208a19660$var$LOG_LEVEL.DEBUG, ...args) {
+        switch(log_level){
+            case $7f41aaa208a19660$var$LOG_LEVEL.DEBUG:
+                console.debug(`websocket: ${msg}`, ...args);
+                break;
+            case $7f41aaa208a19660$var$LOG_LEVEL.ERROR:
+                console.error(`websocket: ${msg}`, ...args);
+                break;
+            case $7f41aaa208a19660$var$LOG_LEVEL.WARN:
+                console.warn(`websocket: ${msg}`, ...args);
+                break;
+            case $7f41aaa208a19660$var$LOG_LEVEL.INFO:
+            default:
+                console.log(`websocket: ${msg}`, ...args);
+                break;
+        }
+    }
+    async send(data) {
+        try {
+            if (this._ws && this._ws.readyState === WebSocket.OPEN) {
+                this._lastMsgSendTime = Date.now();
+                this._ws.send(data);
+            } else this.log(`Failed to send data, web socket not open.`, $7f41aaa208a19660$var$LOG_LEVEL.ERROR);
+        } catch (error) {
+            this.log(`Failed to send data. ${error}`, $7f41aaa208a19660$var$LOG_LEVEL.ERROR);
+        }
+    }
+    async close() {
+        try {
+            this.log("Closing websocket");
+            this._disconnected = true;
+            this.clearReconnectTimeout();
+            this._closeSocket();
+        } catch (error) {
+            this.log(`Failed to close websocket. ${error}`);
+        }
+    }
+    get readyState() {
+        return this._ws?.readyState ?? WebSocket.CLOSED;
+    }
+    get url() {
+        return this._url;
+    }
+    get keepAliveTimeout() {
+        return this._keepAliveTimeout;
+    }
+    set keepAliveTimeout(keepAliveTimeout) {
+        if (typeof keepAliveTimeout === "number") {
+            this.log(`Setting ACK freshness timeout to ${keepAliveTimeout}`);
+            this._keepAliveTimeout = keepAliveTimeout;
+        }
+    }
+    get keepAliveInterval() {
+        return this._keepAliveInterval;
+    }
+    set keepAliveInterval(keepAliveInterval) {
+        if (typeof keepAliveInterval === "number") {
+            this.log(`Setting keep-alive interval to ${keepAliveInterval}`);
+            this._keepAliveInterval = keepAliveInterval;
+        }
+    }
+    set shouldRetryFn(cb) {
+        if (typeof cb === "function") this._shouldRetryFn = cb;
+    }
+    get connectionTimeout() {
+        return this._connectionTimeout;
+    }
+    set connectionTimeout(timeout) {
+        if (typeof timeout === "number") this._connectionTimeout = timeout;
+    }
+    get maxReconnectAttempts() {
+        return this._allowedReconnectAttempts;
+    }
+    set maxReconnectAttempts(attempts) {
+        if (attempts > 0 && attempts < $7f41aaa208a19660$var$MAX_RECONNECT_ATTEMPTS) {
+            this.log(`Setting maximum connection retry attempts to ${attempts}`);
+            this._allowedReconnectAttempts = attempts;
+        } else this._allowedReconnectAttempts = $7f41aaa208a19660$var$DEFAULT_RECONNECT_ATTEMPTS;
+    }
+    get reconnectInterval() {
+        return this._reconnectInterval;
+    }
+    set reconnectInterval(interval) {
+        if (typeof interval === "number") this._reconnectInterval = interval < this._maxReconnectInterval ? interval : this._maxReconnectInterval;
+    }
+    async _handleMessage(event) {
+        this._lastMsgRecvTime = Date.now();
+        const data = event.data;
+        const _parsePromise = new Promise((resolve, reject)=>{
+            if (typeof data === "string") // Handle text message
+            resolve(data);
+            else if (data instanceof ArrayBuffer) {
+                // Handle binary message
+                const arrayBuffer = data;
+                // Parse the ArrayBuffer as needed
+                // Example: Convert ArrayBuffer to Uint8Array
+                resolve(new Uint8Array(arrayBuffer));
+            // Process the Uint8Array as needed
+            } else if (data instanceof Blob) {
+                if (!this._parseBlobToJson) {
+                    resolve(data);
+                    return;
+                }
+                // Handle Blob message
+                const blob = data;
+                // Convert Blob to ArrayBuffer
+                const reader = new FileReader();
+                reader.onload = ()=>{
+                    const text = reader.result;
+                    try {
+                        const json = JSON.parse(text);
+                        resolve(json);
+                    } catch (e) {
+                        console.error("Failed to parse JSON from Blob:", e);
+                    }
+                };
+                reader.readAsText(blob);
+            }
+        });
+        let msg = await _parsePromise;
+        this.emit("message", msg);
+    }
+}
+[
+    "binaryType",
+    "bufferedAmount",
+    "extensions",
+    "protocol",
+    "readyState",
+    "url",
+    "keepAliveTimeout",
+    "keepAliveInterval",
+    "shouldRetryFn",
+    "connectionTimeout",
+    "maxReconnectAttempts",
+    "reconnectInterval"
+].forEach((property)=>{
+    Object.defineProperty($7f41aaa208a19660$export$4f3d0ffd941ebefb.prototype, property, {
+        enumerable: true
+    });
+});
+[
+    "CONNECTING",
+    "OPEN",
+    "CLOSING",
+    "CLOSED"
+].forEach((property)=>{
+    Object.defineProperty($7f41aaa208a19660$export$4f3d0ffd941ebefb.prototype, property, {
+        enumerable: true,
+        value: $7f41aaa208a19660$var$readyStates.indexOf(property)
+    });
+});
+[
+    "CONNECTING",
+    "OPEN",
+    "CLOSING",
+    "CLOSED"
+].forEach((property)=>{
+    Object.defineProperty($7f41aaa208a19660$export$4f3d0ffd941ebefb, property, {
+        enumerable: true,
+        value: $7f41aaa208a19660$var$readyStates.indexOf(property)
+    });
+});
+
+
+
+
+
+var $48b67f1ef231aa26$exports = {};
+$48b67f1ef231aa26$exports = JSON.parse("{\"name\":\"@pipecat-ai/daily-transport\",\"version\":\"1.7.0\",\"license\":\"BSD-2-Clause\",\"main\":\"dist/index.js\",\"module\":\"dist/index.module.js\",\"types\":\"dist/index.d.ts\",\"source\":\"src/index.ts\",\"repository\":{\"type\":\"git\",\"url\":\"git+https://github.com/pipecat-ai/pipecat-client-web-transports.git\"},\"exports\":{\".\":{\"types\":\"./dist/index.d.ts\",\"import\":\"./dist/index.module.js\",\"require\":\"./dist/index.js\"}},\"files\":[\"dist\",\"package.json\",\"README.md\"],\"targets\":{\"main\":{\"includeNodeModules\":[\"@pipecat-ai/transport-lib\"]},\"module\":{\"includeNodeModules\":[\"@pipecat-ai/transport-lib\"]}},\"scripts\":{\"build\":\"parcel build --no-cache\",\"dev\":\"parcel watch\",\"lint\":\"eslint . --ext ts --report-unused-disable-directives --max-warnings 0\"},\"devDependencies\":{\"@pipecat-ai/client-js\":\"^1.14.0\",\"@pipecat-ai/transport-lib\":\"^0.2.0\",\"eslint\":\"9.39.1\",\"eslint-config-prettier\":\"^9.1.0\",\"eslint-plugin-simple-import-sort\":\"^12.1.1\"},\"peerDependencies\":{\"@pipecat-ai/client-js\":\"~1.14.0\"},\"dependencies\":{\"@daily-co/daily-js\":\"^0.94.0\"},\"description\":\"Pipecat Daily Transport Package\",\"author\":\"Daily.co\",\"bugs\":{\"url\":\"https://github.com/pipecat-ai/pipecat-client-web-transports/issues\"},\"homepage\":\"https://github.com/pipecat-ai/pipecat-client-web-transports/blob/main/transports/daily-webrtc/README.md\"}");
+
+
+var $1c83796b12dd4e49$export$ef180de88fd317cc;
 (function(DailyRTVIMessageType) {
     DailyRTVIMessageType["AUDIO_BUFFERING_STARTED"] = "audio-buffering-started";
     DailyRTVIMessageType["AUDIO_BUFFERING_STOPPED"] = "audio-buffering-stopped";
-})($28bdeb35415d61e8$export$ef180de88fd317cc || ($28bdeb35415d61e8$export$ef180de88fd317cc = {}));
-class $28bdeb35415d61e8$var$DailyCallWrapper {
+})($1c83796b12dd4e49$export$ef180de88fd317cc || ($1c83796b12dd4e49$export$ef180de88fd317cc = {}));
+class $1c83796b12dd4e49$var$DailyCallWrapper {
     constructor(daily){
         this._daily = daily;
         this._proxy = new Proxy(this._daily, {
@@ -1574,7 +2602,7 @@ class $28bdeb35415d61e8$var$DailyCallWrapper {
         return this._proxy;
     }
 }
-class $28bdeb35415d61e8$export$b1ca982aa1e488c1 extends (0, $jrPAn$pipecataiclientjs.Transport) {
+class $1c83796b12dd4e49$export$b1ca982aa1e488c1 extends (0, $1clrS$pipecataiclientjs.Transport) {
     constructor(opts = {}){
         super();
         this._botId = "";
@@ -1583,6 +2611,19 @@ class $28bdeb35415d61e8$export$b1ca982aa1e488c1 extends (0, $jrPAn$pipecataiclie
         this._selectedSpeaker = {};
         this._currentAudioTrack = null;
         this._audioQueue = [];
+        // NOTE: deliberately not read live off `this._daily.localAudio()` /
+        // `localVideo()` in the isMicEnabled/isCamEnabled getters below. Daily
+        // fires 'track-started'/'track-stopped' *before* it commits the new state
+        // to the participant object those calls read from (daily-js emits the
+        // track event from within its participant-updated handling, then
+        // reassigns its internal participant cache afterwards). Code that reacts
+        // to TrackStarted/TrackStopped by reading isMicEnabled/isCamEnabled to
+        // resync UI state — e.g. PipecatClientState's mic/cam sync — would
+        // otherwise always observe the pre-toggle value. These fields are updated
+        // synchronously in enableMic/enableCam and in handleTrackStarted/
+        // handleTrackStopped, before those callbacks fire.
+        this._micEnabled = true;
+        this._camEnabled = false;
         this._callbacks = {};
         const { bufferLocalAudioUntilBotReady: bufferLocalAudioUntilBotReady, ...dailyOpts } = opts;
         this._dailyFactoryOptions = dailyOpts;
@@ -1593,15 +2634,15 @@ class $28bdeb35415d61e8$export$b1ca982aa1e488c1 extends (0, $jrPAn$pipecataiclie
             this._dailyFactoryOptions.dailyConfig.useDevicePreferenceCookies = true;
         }
         this._bufferLocalAudioUntilBotReady = bufferLocalAudioUntilBotReady || false;
-        this._daily = (0, ($parcel$interopDefault($jrPAn$dailycodailyjs))).createCallObject({
+        this._daily = (0, ($parcel$interopDefault($1clrS$dailycodailyjs))).createCallObject({
             ...this._dailyFactoryOptions,
             allowMultipleCallInstances: true
         });
-        this._dailyWrapper = new $28bdeb35415d61e8$var$DailyCallWrapper(this._daily);
+        this._dailyWrapper = new $1c83796b12dd4e49$var$DailyCallWrapper(this._daily);
     }
     setupRecorder() {
-        this._mediaStreamRecorder = new (0, $7cef7a69bdf8f84d$export$2934cf2d25c67a48)({
-            sampleRate: $28bdeb35415d61e8$export$b1ca982aa1e488c1.RECORDER_SAMPLE_RATE
+        this._mediaStreamRecorder = new (0, $ab812aec7679ec67$export$2934cf2d25c67a48)({
+            sampleRate: $1c83796b12dd4e49$export$b1ca982aa1e488c1.RECORDER_SAMPLE_RATE
         });
     }
     handleUserAudioStream(data) {
@@ -1610,7 +2651,7 @@ class $28bdeb35415d61e8$export$b1ca982aa1e488c1 extends (0, $jrPAn$pipecataiclie
     flushAudioQueue() {
         const batchSize = 10; // Number of buffers to send in one message
         if (this._audioQueue.length === 0) return;
-        (0, $jrPAn$pipecataiclientjs.logger).debug(`Will flush audio queue: ${this._audioQueue.length}`);
+        (0, $1clrS$pipecataiclientjs.logger).debug(`Will flush audio queue: ${this._audioQueue.length}`);
         while(this._audioQueue.length > 0){
             const batch = [];
             // Collect up to `batchSize` items
@@ -1632,7 +2673,7 @@ class $28bdeb35415d61e8$export$b1ca982aa1e488c1 extends (0, $jrPAn$pipecataiclie
             type: "raw-audio-batch",
             data: {
                 base64AudioBatch: encodedBatch,
-                sampleRate: $28bdeb35415d61e8$export$b1ca982aa1e488c1.RECORDER_SAMPLE_RATE,
+                sampleRate: $1c83796b12dd4e49$export$b1ca982aa1e488c1.RECORDER_SAMPLE_RATE,
                 numChannels: 1
             }
         };
@@ -1646,9 +2687,11 @@ class $28bdeb35415d61e8$export$b1ca982aa1e488c1 extends (0, $jrPAn$pipecataiclie
         this._dailyFactoryOptions.startVideoOff = !(options.enableCam ?? false);
         if (this._dailyFactoryOptions.startAudioOff == null || options.enableMic != null) // Default is mic on
         this._dailyFactoryOptions.startAudioOff = !(options.enableMic ?? true);
+        this._camEnabled = !this._dailyFactoryOptions.startVideoOff;
+        this._micEnabled = !this._dailyFactoryOptions.startAudioOff;
         this.attachEventListeners();
         this.state = "disconnected";
-        (0, $jrPAn$pipecataiclientjs.logger).debug("[Daily Transport] Initialized", (0, (/*@__PURE__*/$parcel$interopDefault($c2e964a535c1120e$exports))).version);
+        (0, $1clrS$pipecataiclientjs.logger).debug("[Daily Transport] Initialized", (0, (/*@__PURE__*/$parcel$interopDefault($48b67f1ef231aa26$exports))).version);
     }
     get dailyCallClient() {
         return this._dailyWrapper.proxy;
@@ -1702,7 +2745,7 @@ class $28bdeb35415d61e8$export$b1ca982aa1e488c1 extends (0, $jrPAn$pipecataiclie
         }).then((infos)=>{
             this._selectedSpeaker = infos.speaker;
         }).catch((e)=>{
-            this._callbacks.onDeviceError?.(new (0, $jrPAn$pipecataiclientjs.DeviceError)([
+            this._callbacks.onDeviceError?.(new (0, $1clrS$pipecataiclientjs.DeviceError)([
                 "speaker"
             ], e.type ?? "unknown", e.message));
         });
@@ -1717,17 +2760,19 @@ class $28bdeb35415d61e8$export$b1ca982aa1e488c1 extends (0, $jrPAn$pipecataiclie
         // joined — pre-session, daily-js can't act on the request because the
         // call object isn't part of a meeting yet.
         this._dailyFactoryOptions.startAudioOff = !enable;
+        this._micEnabled = enable;
         if (this._daily.participants()?.local) this._daily.setLocalAudio(enable);
     }
     get isMicEnabled() {
-        return this._daily.localAudio();
+        return this._micEnabled;
     }
     enableCam(enable) {
         this._dailyFactoryOptions.startVideoOff = !enable;
+        this._camEnabled = enable;
         if (this._daily.participants()?.local) this._daily.setLocalVideo(enable);
     }
     get isCamEnabled() {
-        return this._daily.localVideo();
+        return this._camEnabled;
     }
     enableScreenShare(enable) {
         if (enable) this._daily.startScreenShare();
@@ -1736,6 +2781,15 @@ class $28bdeb35415d61e8$export$b1ca982aa1e488c1 extends (0, $jrPAn$pipecataiclie
     get isSharingScreen() {
         return this._daily.localScreenAudio() || this._daily.localScreenVideo();
     }
+    /** Carries every kind of media; screen share where the browser can. */ get mediaSupport() {
+        return {
+            mic: true,
+            cam: true,
+            screenShare: (0, $15398512372f76d1$export$7f8f33b9b54c8307)(),
+            botAudio: true,
+            botVideo: true
+        };
+    }
     tracks() {
         const participants = this._daily.participants() ?? {};
         const bot = participants?.[this._botId];
@@ -1755,15 +2809,15 @@ class $28bdeb35415d61e8$export$b1ca982aa1e488c1 extends (0, $jrPAn$pipecataiclie
     }
     async startRecording() {
         try {
-            (0, $jrPAn$pipecataiclientjs.logger).info("[Daily Transport] Initializing recording");
+            (0, $1clrS$pipecataiclientjs.logger).info("[Daily Transport] Initializing recording");
             await this._mediaStreamRecorder.record((data)=>{
                 this.handleUserAudioStream(data.mono);
-            }, $28bdeb35415d61e8$export$b1ca982aa1e488c1.RECORDER_CHUNK_SIZE);
+            }, $1c83796b12dd4e49$export$b1ca982aa1e488c1.RECORDER_CHUNK_SIZE);
             this._callbacks.onAudioBufferingStarted?.();
-            (0, $jrPAn$pipecataiclientjs.logger).info("[Daily Transport] Recording Initialized");
+            (0, $1clrS$pipecataiclientjs.logger).info("[Daily Transport] Recording Initialized");
         } catch (e) {
             const err = e;
-            if (!err.message.includes("Already recording")) (0, $jrPAn$pipecataiclientjs.logger).error("Error starting recording", e);
+            if (!err.message.includes("Already recording")) (0, $1clrS$pipecataiclientjs.logger).error("Error starting recording", e);
         }
     }
     async preAuth(dailyCallOptions) {
@@ -1771,7 +2825,7 @@ class $28bdeb35415d61e8$export$b1ca982aa1e488c1 extends (0, $jrPAn$pipecataiclie
         await this._daily.preAuth(dailyCallOptions);
     }
     async initDevices() {
-        if (!this._daily) throw new (0, $jrPAn$pipecataiclientjs.RTVIError)("Transport instance not initialized");
+        if (!this._daily) throw new (0, $1clrS$pipecataiclientjs.RTVIError)("Transport instance not initialized");
         this.state = "initializing";
         const infos = await this._daily.startCamera(this._dailyFactoryOptions);
         const { devices: devices } = await this._daily.enumerateDevices();
@@ -1787,14 +2841,20 @@ class $28bdeb35415d61e8$export$b1ca982aa1e488c1 extends (0, $jrPAn$pipecataiclie
         this._callbacks.onCamUpdated?.(infos.camera);
         this._callbacks.onMicUpdated?.(infos.mic);
         this._callbacks.onSpeakerUpdated?.(infos.speaker);
-        // Instantiate audio observers
-        if (!this._daily.isLocalAudioLevelObserverRunning()) await this._daily.startLocalAudioLevelObserver(100);
-        if (!this._daily.isRemoteParticipantsAudioLevelObserverRunning()) await this._daily.startRemoteParticipantsAudioLevelObserver(100);
+        await this.startAudioLevelObservers();
         this.state = "initialized";
     }
+    async startAudioLevelObservers() {
+        try {
+            if (!this._daily.isLocalAudioLevelObserverRunning()) await this._daily.startLocalAudioLevelObserver(100);
+            if (!this._daily.isRemoteParticipantsAudioLevelObserverRunning()) await this._daily.startRemoteParticipantsAudioLevelObserver(100);
+        } catch (e) {
+            (0, $1clrS$pipecataiclientjs.logger).warn("[Daily Transport] Failed to start audio level observers", e);
+        }
+    }
     _validateConnectionParams(connectParams) {
         if (connectParams === undefined || connectParams === null) return undefined;
-        if (typeof connectParams !== "object") throw new (0, $jrPAn$pipecataiclientjs.RTVIError)("Invalid connection parameters");
+        if (typeof connectParams !== "object") throw new (0, $1clrS$pipecataiclientjs.RTVIError)("Invalid connection parameters");
         const tmpParams = connectParams;
         if (tmpParams.room_url) {
             tmpParams.url = tmpParams.room_url;
@@ -1812,7 +2872,7 @@ class $28bdeb35415d61e8$export$b1ca982aa1e488c1 extends (0, $jrPAn$pipecataiclie
         return tmpParams;
     }
     async _connect(connectParams) {
-        if (!this._daily) throw new (0, $jrPAn$pipecataiclientjs.RTVIError)("Transport instance not initialized");
+        if (!this._daily) throw new (0, $1clrS$pipecataiclientjs.RTVIError)("Transport instance not initialized");
         if (connectParams) this._dailyFactoryOptions = {
             ...this._dailyFactoryOptions,
             ...connectParams
@@ -1821,11 +2881,17 @@ class $28bdeb35415d61e8$export$b1ca982aa1e488c1 extends (0, $jrPAn$pipecataiclie
         try {
             await this._daily.join(this._dailyFactoryOptions);
         } catch (e) {
-            (0, $jrPAn$pipecataiclientjs.logger).error("Failed to join room", e);
+            (0, $1clrS$pipecataiclientjs.logger).error("Failed to join room", e);
             this.state = "error";
-            throw new (0, $jrPAn$pipecataiclientjs.TransportStartError)();
+            throw new (0, $1clrS$pipecataiclientjs.TransportStartError)();
         }
         if (this._abortController?.signal.aborted) return;
+        // initDevices() is not guaranteed to have run before we get here:
+        // PipecatClient skips it when both mic and cam start disabled, and on a
+        // reconnect once devices are already initialized. _disconnect() stops
+        // the observers, so make sure they are running for this session or
+        // onLocalAudioLevel / onRemoteAudioLevel never fire.
+        await this.startAudioLevelObservers();
         const r = await this._daily.room();
         this._maxMessageSize = r?.domainConfig?.max_app_message_size || 10485760;
         this.state = "connected";
@@ -1844,7 +2910,7 @@ class $28bdeb35415d61e8$export$b1ca982aa1e488c1 extends (0, $jrPAn$pipecataiclie
                 //       we've received the bot_ready signal
                 this.state = "ready";
                 this.flushAudioQueue();
-                this.sendMessage((0, $jrPAn$pipecataiclientjs.RTVIMessage).clientReady());
+                this.sendMessage((0, $1clrS$pipecataiclientjs.RTVIMessage).clientReady());
                 this.stopRecording();
                 resolve();
             };
@@ -1862,7 +2928,7 @@ class $28bdeb35415d61e8$export$b1ca982aa1e488c1 extends (0, $jrPAn$pipecataiclie
                     this._daily.off("track-started", readyHandler);
                     // Check if it's an iOS device
                     if (isIOS()) {
-                        (0, $jrPAn$pipecataiclientjs.logger).debug("[Daily Transport] iOS device detected, adding 0.5 second delay before sending ready message");
+                        (0, $1clrS$pipecataiclientjs.logger).debug("[Daily Transport] iOS device detected, adding 0.5 second delay before sending ready message");
                         // Add 500ms delay for iOS devices:
                         // This is a workaround for iOS devices clipping a portion
                         // of the audio after the track becomes playable.
@@ -1909,7 +2975,7 @@ class $28bdeb35415d61e8$export$b1ca982aa1e488c1 extends (0, $jrPAn$pipecataiclie
         try {
             this._daily.sendAppMessage(message, "*");
         } catch (error) {
-            if (error instanceof Error && error.message.includes("Message data too large")) throw new (0, $jrPAn$pipecataiclientjs.MessageTooLargeError)(error.message);
+            if (error instanceof Error && error.message.includes("Message data too large")) throw new (0, $1clrS$pipecataiclientjs.MessageTooLargeError)(error.message);
             throw error;
         }
     }
@@ -1948,40 +3014,51 @@ class $28bdeb35415d61e8$export$b1ca982aa1e488c1 extends (0, $jrPAn$pipecataiclie
                     error.blockedMedia.forEach((d)=>{
                         devices.push(d === "video" ? "cam" : "mic");
                     });
-                    return new (0, $jrPAn$pipecataiclientjs.DeviceError)(devices, error.type, error.msg, {
+                    return new (0, $1clrS$pipecataiclientjs.DeviceError)(devices, error.type, error.msg, {
                         blockedBy: error.blockedBy
                     });
                 case "not-found":
                     error.missingMedia.forEach((d)=>{
                         devices.push(d === "video" ? "cam" : "mic");
                     });
-                    return new (0, $jrPAn$pipecataiclientjs.DeviceError)(devices, error.type, error.msg);
+                    return new (0, $1clrS$pipecataiclientjs.DeviceError)(devices, error.type, error.msg);
                 case "constraints":
                     error.failedMedia.forEach((d)=>{
                         devices.push(d === "video" ? "cam" : "mic");
                     });
-                    return new (0, $jrPAn$pipecataiclientjs.DeviceError)(devices, error.type, error.msg, {
+                    return new (0, $1clrS$pipecataiclientjs.DeviceError)(devices, error.type, error.msg, {
                         reason: error.reason
                     });
                 case "cam-in-use":
                     devices.push("cam");
-                    return new (0, $jrPAn$pipecataiclientjs.DeviceError)(devices, "in-use", error.msg);
+                    return new (0, $1clrS$pipecataiclientjs.DeviceError)(devices, "in-use", error.msg);
                 case "mic-in-use":
                     devices.push("mic");
-                    return new (0, $jrPAn$pipecataiclientjs.DeviceError)(devices, "in-use", error.msg);
+                    return new (0, $1clrS$pipecataiclientjs.DeviceError)(devices, "in-use", error.msg);
                 case "cam-mic-in-use":
                     devices.push("cam");
                     devices.push("mic");
-                    return new (0, $jrPAn$pipecataiclientjs.DeviceError)(devices, "in-use", error.msg);
+                    return new (0, $1clrS$pipecataiclientjs.DeviceError)(devices, "in-use", error.msg);
                 case "undefined-mediadevices":
                 case "unknown":
                 default:
                     devices.push("cam");
                     devices.push("mic");
-                    return new (0, $jrPAn$pipecataiclientjs.DeviceError)(devices, error.type, error.msg);
+                    return new (0, $1clrS$pipecataiclientjs.DeviceError)(devices, error.type, error.msg);
             }
         };
-        this._callbacks.onDeviceError?.(generateDeviceError(ev.error));
+        const deviceError = generateDeviceError(ev.error);
+        // enableMic()/enableCam() set _micEnabled/_camEnabled optimistically,
+        // but setLocalAudio()/setLocalVideo() are fire-and-forget — no promise,
+        // no synchronous failure signal — so a failed request (blocked
+        // permission, device in use, etc.) leaves that optimistic value wrong
+        // with nothing to correct it: no track-started/stopped ever fires for
+        // an operation that didn't actually take effect. This is the only
+        // signal we get that the request failed, so resync from Daily's actual
+        // state for whichever device(s) it implicates.
+        if (deviceError.devices.includes("mic")) this._micEnabled = this._daily.localAudio();
+        if (deviceError.devices.includes("cam")) this._camEnabled = this._daily.localVideo();
+        this._callbacks.onDeviceError?.(deviceError);
     }
     async handleLocalAudioTrack(track) {
         if (this.state == "ready" || !this._bufferLocalAudioUntilBotReady) return;
@@ -2007,31 +3084,42 @@ class $28bdeb35415d61e8$export$b1ca982aa1e488c1 extends (0, $jrPAn$pipecataiclie
                 } catch (e) {
                 // void. nothing to do.
                 }
-                else (0, $jrPAn$pipecataiclientjs.logger).warn("track-started event received for current track and already recording");
+                else (0, $1clrS$pipecataiclientjs.logger).warn("track-started event received for current track and already recording");
                 break;
         }
         this._currentAudioTrack = track;
     }
     handleTrackStarted(ev) {
-        if (ev.type === "screenAudio" || ev.type === "screenVideo") this._callbacks.onScreenTrackStarted?.(ev.track, ev.participant ? $28bdeb35415d61e8$var$dailyParticipantToParticipant(ev.participant) : undefined);
+        if (ev.type === "screenAudio" || ev.type === "screenVideo") this._callbacks.onScreenTrackStarted?.(ev.track, ev.participant ? $1c83796b12dd4e49$var$dailyParticipantToParticipant(ev.participant) : undefined);
         else {
-            if (ev.participant?.local && ev.track.kind === "audio") this.handleLocalAudioTrack(ev.track);
-            this._callbacks.onTrackStarted?.(ev.track, ev.participant ? $28bdeb35415d61e8$var$dailyParticipantToParticipant(ev.participant) : undefined);
+            if (ev.participant?.local) {
+                if (ev.track.kind === "audio") {
+                    this._micEnabled = true;
+                    this.handleLocalAudioTrack(ev.track);
+                } else if (ev.track.kind === "video") this._camEnabled = true;
+            }
+            this._callbacks.onTrackStarted?.(ev.track, ev.participant ? $1c83796b12dd4e49$var$dailyParticipantToParticipant(ev.participant) : undefined);
         }
     }
     handleTrackStopped(ev) {
-        if (ev.type === "screenAudio" || ev.type === "screenVideo") this._callbacks.onScreenTrackStopped?.(ev.track, ev.participant ? $28bdeb35415d61e8$var$dailyParticipantToParticipant(ev.participant) : undefined);
-        else this._callbacks.onTrackStopped?.(ev.track, ev.participant ? $28bdeb35415d61e8$var$dailyParticipantToParticipant(ev.participant) : undefined);
+        if (ev.type === "screenAudio" || ev.type === "screenVideo") this._callbacks.onScreenTrackStopped?.(ev.track, ev.participant ? $1c83796b12dd4e49$var$dailyParticipantToParticipant(ev.participant) : undefined);
+        else {
+            if (ev.participant?.local) {
+                if (ev.track.kind === "audio") this._micEnabled = false;
+                else if (ev.track.kind === "video") this._camEnabled = false;
+            }
+            this._callbacks.onTrackStopped?.(ev.track, ev.participant ? $1c83796b12dd4e49$var$dailyParticipantToParticipant(ev.participant) : undefined);
+        }
     }
     handleParticipantJoined(ev) {
-        const p = $28bdeb35415d61e8$var$dailyParticipantToParticipant(ev.participant);
+        const p = $1c83796b12dd4e49$var$dailyParticipantToParticipant(ev.participant);
         this._callbacks.onParticipantJoined?.(p);
         if (p.local) return;
         this._botId = ev.participant.session_id;
         this._callbacks.onBotConnected?.(p);
     }
     handleParticipantLeft(ev) {
-        const p = $28bdeb35415d61e8$var$dailyParticipantToParticipant(ev.participant);
+        const p = $1c83796b12dd4e49$var$dailyParticipantToParticipant(ev.participant);
         this._callbacks.onParticipantLeft?.(p);
         if (p.local) return;
         this._botId = "";
@@ -2046,7 +3134,7 @@ class $28bdeb35415d61e8$export$b1ca982aa1e488c1 extends (0, $jrPAn$pipecataiclie
         for(let i = 0; i < ids.length; i++){
             const id = ids[i];
             const level = ev.participantsAudioLevel[id];
-            this._callbacks.onRemoteAudioLevel?.(level, $28bdeb35415d61e8$var$dailyParticipantToParticipant(participants[id]));
+            this._callbacks.onRemoteAudioLevel?.(level, $1c83796b12dd4e49$var$dailyParticipantToParticipant(participants[id]));
         }
     }
     handleLeftMeeting() {
@@ -2055,10 +3143,10 @@ class $28bdeb35415d61e8$export$b1ca982aa1e488c1 extends (0, $jrPAn$pipecataiclie
         this._callbacks.onDisconnected?.();
     }
     handleFatalError(ev) {
-        (0, $jrPAn$pipecataiclientjs.logger).error("Daily fatal error", ev.errorMsg);
+        (0, $1clrS$pipecataiclientjs.logger).error("Daily fatal error", ev.errorMsg);
         this.state = "error";
         this._botId = "";
-        this._callbacks.onError?.((0, $jrPAn$pipecataiclientjs.RTVIMessage).error(ev.errorMsg, true));
+        this._callbacks.onError?.((0, $1clrS$pipecataiclientjs.RTVIMessage).error(ev.errorMsg, true));
     }
     handleNonFatalError(ev) {
         switch(ev.type){
@@ -2068,16 +3156,16 @@ class $28bdeb35415d61e8$export$b1ca982aa1e488c1 extends (0, $jrPAn$pipecataiclie
         }
     }
 }
-$28bdeb35415d61e8$export$b1ca982aa1e488c1.RECORDER_SAMPLE_RATE = 16000;
-$28bdeb35415d61e8$export$b1ca982aa1e488c1.RECORDER_CHUNK_SIZE = 512;
-const $28bdeb35415d61e8$var$dailyParticipantToParticipant = (p)=>({
+$1c83796b12dd4e49$export$b1ca982aa1e488c1.RECORDER_SAMPLE_RATE = 16000;
+$1c83796b12dd4e49$export$b1ca982aa1e488c1.RECORDER_CHUNK_SIZE = 512;
+const $1c83796b12dd4e49$var$dailyParticipantToParticipant = (p)=>({
         id: p.user_id,
         local: p.local,
         name: p.user_name
     });
 
 
-$parcel$exportWildcard(module.exports, $28bdeb35415d61e8$exports);
+$parcel$exportWildcard(module.exports, $1c83796b12dd4e49$exports);
 
 
 //# sourceMappingURL=index.js.map