vue-parley 4.0.0

package/dist/chunks/session-B3KIrj3_.mjs

@@ -0,0 +1,711 @@
+import { ref, watch, markRaw, computed, effectScope } from "vue";
+import { nanoid } from "nanoid";
+import { C as CallMessageType } from "./index-JU_JZkSC.mjs";
+function createSignaling(handlers, self) {
+  let subscription;
+  const publish = (message) => handlers.publisher(JSON.stringify(message));
+  async function listen(on) {
+    subscription = await handlers.subscriber(async (message) => {
+      const from = message.payload.from;
+      if (from === self.id) return;
+      switch (message.type) {
+        case CallMessageType.Signal:
+          if (message.payload.to === self.id && message.payload.signal)
+            on.onSignal(from, message.payload.name, message.payload.signal);
+          break;
+        case CallMessageType.Join:
+          on.onJoin(from, message.payload.name);
+          break;
+        case CallMessageType.TrackType:
+          on.onTrackTypes(from, message.payload.types);
+          break;
+        case CallMessageType.Hangup:
+          on.onHangup(from);
+          break;
+      }
+    });
+  }
+  function stop() {
+    if (subscription !== void 0) void handlers.unSubscriber(subscription);
+    subscription = void 0;
+  }
+  return {
+    listen,
+    stop,
+    join: () => publish({
+      type: CallMessageType.Join,
+      payload: { from: self.id, name: self.name() }
+    }),
+    trackTypes: (types) => publish({
+      type: CallMessageType.TrackType,
+      payload: { from: self.id, types }
+    }),
+    signal: (to, signal) => publish({
+      type: CallMessageType.Signal,
+      payload: {
+        from: self.id,
+        to,
+        name: self.name(),
+        signal
+      }
+    }),
+    /** Rings the other side of `channel`. */
+    ring: (channel, avatar) => publish({
+      type: CallMessageType.Call,
+      payload: { from: self.id, name: self.name(), channel, avatar: avatar ?? "" }
+    }),
+    hangup: (channel) => publish({
+      type: CallMessageType.Hangup,
+      payload: { from: self.id, channel }
+    })
+  };
+}
+const ICE_COMPLETE_TIMEOUT_MS = 5e3;
+const withoutTrickle = (sdp) => sdp.replace(/a=ice-options:trickle\s\n/g, "");
+const randomLabel = () => Array.from(
+  crypto.getRandomValues(new Uint8Array(20)),
+  (b) => b.toString(16).padStart(2, "0")
+).join("");
+function createPeer(opts) {
+  const { initiator } = opts;
+  const pc = new RTCPeerConnection(opts.config);
+  let destroyed = false;
+  let negotiating = false;
+  let queuedNegotiation = false;
+  let batched = false;
+  let firstNegotiation = true;
+  let channel = null;
+  const pendingCandidates = [];
+  const knownStreams = /* @__PURE__ */ new Set();
+  const requestedTransceivers = /* @__PURE__ */ new WeakSet();
+  function destroy(error) {
+    if (destroyed) return;
+    destroyed = true;
+    try {
+      channel == null ? void 0 : channel.close();
+    } catch {
+    }
+    pc.ontrack = pc.ondatachannel = pc.onconnectionstatechange = pc.onsignalingstatechange = null;
+    pc.close();
+    if (error) opts.onError(error);
+    opts.onClose();
+  }
+  const fail = (code) => (err) => destroy(Object.assign(err instanceof Error ? err : new Error(String(err)), { code }));
+  function setupChannel(dc) {
+    channel = dc;
+    dc.onclose = () => destroy();
+  }
+  function waitForIce() {
+    if (pc.iceGatheringState === "complete") return Promise.resolve();
+    return new Promise((resolve) => {
+      const timer = setTimeout(done, ICE_COMPLETE_TIMEOUT_MS);
+      function done() {
+        clearTimeout(timer);
+        pc.removeEventListener("icegatheringstatechange", check);
+        resolve();
+      }
+      function check() {
+        if (pc.iceGatheringState === "complete") done();
+      }
+      pc.addEventListener("icegatheringstatechange", check);
+    });
+  }
+  async function sendDescription() {
+    await waitForIce();
+    if (destroyed || !pc.localDescription) return;
+    opts.onSignal({ type: pc.localDescription.type, sdp: pc.localDescription.sdp });
+  }
+  async function createOffer() {
+    if (destroyed) return;
+    try {
+      const offer = await pc.createOffer();
+      await pc.setLocalDescription({ type: "offer", sdp: withoutTrickle(offer.sdp ?? "") });
+      await sendDescription();
+    } catch (err) {
+      fail("ERR_CREATE_OFFER")(err);
+    }
+  }
+  async function createAnswer() {
+    if (destroyed) return;
+    try {
+      const answer = await pc.createAnswer();
+      await pc.setLocalDescription({ type: "answer", sdp: withoutTrickle(answer.sdp ?? "") });
+      await sendDescription();
+      if (!initiator) requestMissingTransceivers();
+    } catch (err) {
+      fail("ERR_CREATE_ANSWER")(err);
+    }
+  }
+  function requestMissingTransceivers() {
+    for (const transceiver of pc.getTransceivers()) {
+      if (transceiver.mid || !transceiver.sender.track || requestedTransceivers.has(transceiver))
+        continue;
+      requestedTransceivers.add(transceiver);
+      opts.onSignal({
+        type: "transceiverRequest",
+        transceiverRequest: { kind: transceiver.sender.track.kind }
+      });
+    }
+  }
+  function negotiate() {
+    if (destroyed) return;
+    if (negotiating) {
+      queuedNegotiation = true;
+      return;
+    }
+    negotiating = true;
+    if (initiator) setTimeout(() => void createOffer(), 0);
+    else opts.onSignal({ type: "renegotiate", renegotiate: true });
+  }
+  function needsNegotiation() {
+    if (batched) return;
+    batched = true;
+    queueMicrotask(() => {
+      batched = false;
+      if (initiator || !firstNegotiation) negotiate();
+      firstNegotiation = false;
+    });
+  }
+  pc.onsignalingstatechange = () => {
+    if (destroyed || pc.signalingState !== "stable") return;
+    negotiating = false;
+    if (queuedNegotiation) {
+      queuedNegotiation = false;
+      needsNegotiation();
+    }
+  };
+  pc.onconnectionstatechange = () => {
+    if (pc.connectionState === "failed") fail("ERR_CONNECTION_FAILURE")(new Error("Connection failed."));
+  };
+  pc.ontrack = (event) => {
+    for (const stream of event.streams) {
+      if (knownStreams.has(stream.id)) continue;
+      knownStreams.add(stream.id);
+      queueMicrotask(() => !destroyed && opts.onStream(stream));
+    }
+  };
+  if (initiator) setupChannel(pc.createDataChannel(randomLabel()));
+  else pc.ondatachannel = (event) => setupChannel(event.channel);
+  opts.stream.getTracks().forEach((track) => pc.addTrack(track, opts.stream));
+  needsNegotiation();
+  return {
+    /** Applies a message from the other side. */
+    signal(data) {
+      var _a;
+      if (destroyed) return;
+      if (data.renegotiate && initiator) needsNegotiation();
+      if (data.transceiverRequest && initiator) {
+        const { kind, init } = data.transceiverRequest;
+        pc.addTransceiver(kind, init);
+        needsNegotiation();
+      }
+      if (data.candidate) {
+        if ((_a = pc.remoteDescription) == null ? void 0 : _a.type) void pc.addIceCandidate(data.candidate).catch(() => {
+        });
+        else pendingCandidates.push(data.candidate);
+      }
+      if (data.sdp) {
+        const type = data.type;
+        pc.setRemoteDescription({ type, sdp: data.sdp }).then(() => {
+          if (destroyed) return;
+          pendingCandidates.splice(0).forEach((c) => void pc.addIceCandidate(c).catch(() => {
+          }));
+          if (type === "offer") void createAnswer();
+        }).catch(fail("ERR_SET_REMOTE_DESCRIPTION"));
+      }
+    },
+    addTrack(track, stream) {
+      if (destroyed) return;
+      pc.addTrack(track, stream);
+      needsNegotiation();
+    },
+    removeTrack(track) {
+      if (destroyed) return;
+      const sender = pc.getSenders().find((s) => s.track === track);
+      if (!sender) return;
+      pc.removeTrack(sender);
+      needsNegotiation();
+    },
+    /** Swaps the outgoing video track in place (no renegotiation), or adds it if none is sent. */
+    replaceVideoTrack(track, stream) {
+      if (destroyed) return;
+      const sender = pc.getSenders().find((s) => {
+        var _a;
+        return ((_a = s.track) == null ? void 0 : _a.kind) === "video";
+      });
+      if (sender) void sender.replaceTrack(track);
+      else this.addTrack(track, stream);
+    },
+    /** Whether we currently send this track. */
+    isSending(track) {
+      return pc.getSenders().some((s) => s.track === track);
+    },
+    destroy: () => destroy()
+  };
+}
+function usePeers(opts) {
+  const { selfId, signaling, localStream, screenStream, log } = opts;
+  const peers = ref({});
+  const remoteVideos = ref({});
+  const remoteScreens = ref({});
+  const remoteStreamTypes = ref({});
+  const pending = ref({});
+  const pendingSignals = {};
+  const lastSdp = {};
+  const isInitiator = (remoteId) => selfId > remoteId;
+  const has = (remoteId) => !!peers.value[remoteId] || !!pending.value[remoteId];
+  function remove(remoteId) {
+    const peer = peers.value[remoteId];
+    delete peers.value[remoteId];
+    peer == null ? void 0 : peer.destroy();
+    delete remoteVideos.value[remoteId];
+    delete remoteScreens.value[remoteId];
+    delete pending.value[remoteId];
+    delete pendingSignals[remoteId];
+    delete lastSdp[remoteId];
+  }
+  function isScreen(remoteId, stream) {
+    const announced = remoteStreamTypes.value[remoteId] ?? [];
+    const match = announced.find((t) => t.id === stream.id);
+    if (match) return match.type === "screen";
+    return announced.some((t) => t.type === "screen");
+  }
+  function onRemoteStream(remoteId, name, stream) {
+    log("stream from", remoteId, stream.getTracks().map((t) => t.kind));
+    const target = isScreen(remoteId, stream) && stream.getVideoTracks().length > 0 ? remoteScreens : remoteVideos;
+    target.value[remoteId] = { name, stream };
+    stream.addEventListener("removetrack", () => {
+      var _a;
+      if (stream.getTracks().length > 0) return;
+      if (((_a = target.value[remoteId]) == null ? void 0 : _a.stream) === stream) delete target.value[remoteId];
+    });
+  }
+  function add(remoteId, name) {
+    if (peers.value[remoteId]) return;
+    if (!localStream.value) {
+      log("local media not ready, deferring peer", remoteId);
+      pending.value[remoteId] = { name };
+      return;
+    }
+    const config = opts.rtcConfig();
+    if (!config) {
+      log("no ICE servers available, cannot create peer for", remoteId);
+      return;
+    }
+    const initiator = isInitiator(remoteId);
+    let peer;
+    try {
+      peer = createPeer({
+        initiator,
+        stream: localStream.value,
+        config,
+        onSignal: (signal2) => void signaling.signal(remoteId, signal2),
+        onStream: (stream) => onRemoteStream(remoteId, name, stream),
+        onError(err) {
+          console.error("[vue-chat] Peer error for", remoteId, err);
+          void signaling.join();
+        },
+        onClose() {
+          log("peer closed", remoteId);
+          if (peers.value[remoteId] === peer) remove(remoteId);
+        }
+      });
+    } catch (err) {
+      console.error("[vue-chat] Could not create peer connection:", err);
+      return;
+    }
+    log("created peer", remoteId, "initiator:", initiator);
+    const screen = screenStream.value;
+    screen == null ? void 0 : screen.getVideoTracks().forEach((track) => peer.addTrack(track, screen));
+    peers.value[remoteId] = markRaw(peer);
+    const queued = pendingSignals[remoteId];
+    if (queued) {
+      delete pendingSignals[remoteId];
+      peer.signal(queued);
+    }
+  }
+  function signal(remoteId, name, data) {
+    if (data.sdp && lastSdp[remoteId] === data.sdp) return;
+    if (!peers.value[remoteId]) add(remoteId, name);
+    const peer = peers.value[remoteId];
+    if (peer) {
+      if (data.sdp) lastSdp[remoteId] = data.sdp;
+      peer.signal(data);
+    } else {
+      log("peer still deferred, queueing signal for", remoteId);
+      pendingSignals[remoteId] = data;
+    }
+  }
+  function addTrackToAll(track, stream) {
+    Object.values(peers.value).forEach((peer) => peer.addTrack(track, stream));
+  }
+  function removeTrackFromAll(track) {
+    Object.values(peers.value).forEach((peer) => peer.removeTrack(track));
+  }
+  function replaceVideoTrack(track, stream) {
+    Object.values(peers.value).forEach((peer) => peer.replaceVideoTrack(track, stream));
+  }
+  function destroyAll() {
+    const all = Object.values(peers.value);
+    peers.value = {};
+    all.forEach((peer) => peer.destroy());
+  }
+  watch(
+    localStream,
+    (stream) => {
+      if (!stream) return;
+      const waiting = { ...pending.value };
+      pending.value = {};
+      for (const [remoteId, { name }] of Object.entries(waiting)) add(remoteId, name);
+    },
+    { immediate: true }
+  );
+  return {
+    peers,
+    remoteVideos,
+    remoteScreens,
+    remoteStreamTypes,
+    isInitiator,
+    has,
+    add,
+    remove,
+    signal,
+    addTrackToAll,
+    removeTrackFromAll,
+    replaceVideoTrack,
+    destroyAll
+  };
+}
+function deviceError(err, kind, isMobile2) {
+  const name = err == null ? void 0 : err.name;
+  if (kind === "screen") {
+    if (name === "NotAllowedError") return "screenShareDenied";
+    if (name === "NotFoundError" || name === "NotReadableError") return "screenAccessError";
+    return isMobile2 ? "screenShareMobileMaybeUnavailable" : "screenShareStartFailed";
+  }
+  const Kind = kind === "mic" ? "Mic" : "Camera";
+  if (name === "NotAllowedError") return `${kind}Denied`;
+  if (name === "NotFoundError") return `no${Kind}Found`;
+  return `${kind}AccessError`;
+}
+function useCallMedia({ notify, isMobile: isMobile2 }) {
+  const error = (key) => notify(`chat.call.errors.${key}`);
+  const localStream = ref(null);
+  const screenStream = ref(null);
+  const trackTypes = ref([]);
+  const videoTrack = ref(null);
+  const cameras = ref([]);
+  const isAudioOn = ref(true);
+  const isVideoOn = ref(true);
+  const isScreenSharing = ref(false);
+  const isFlashlightOn = ref(false);
+  const permissions = ref({ camera: null, microphone: null });
+  const isFlashlightSupported = computed(() => {
+    var _a, _b;
+    const capabilities = (_b = (_a = videoTrack.value) == null ? void 0 : _a.getCapabilities) == null ? void 0 : _b.call(_a);
+    return !!capabilities && "torch" in capabilities;
+  });
+  async function checkPermissions() {
+    try {
+      const devices = await navigator.mediaDevices.enumerateDevices();
+      cameras.value = devices.filter((d) => d.kind === "videoinput");
+      if (!devices.some((d) => d.kind === "audioinput")) {
+        error("noMicDevice");
+        isAudioOn.value = false;
+      }
+      if (!cameras.value.length) {
+        error("noCameraDevice");
+        isVideoOn.value = false;
+      }
+      const query = (name) => navigator.permissions.query({ name });
+      permissions.value.camera = (await query("camera")).state;
+      permissions.value.microphone = (await query("microphone")).state;
+      if (permissions.value.camera === "denied") isVideoOn.value = false;
+      if (permissions.value.microphone === "denied") isAudioOn.value = false;
+    } catch (err) {
+      console.error("[vue-chat] Error checking permissions:", err);
+    }
+  }
+  async function start() {
+    var _a;
+    const { camera, microphone } = permissions.value;
+    if (camera === "denied" || microphone === "denied") {
+      if (camera === "denied") error("cameraDenied");
+      if (microphone === "denied") error("micDenied");
+      return;
+    }
+    try {
+      localStream.value = await navigator.mediaDevices.getUserMedia({
+        video: true,
+        audio: true
+      });
+      trackTypes.value = [
+        ...trackTypes.value,
+        { id: localStream.value.id, type: "webcam_audio" }
+      ];
+    } catch {
+      const tracks = [];
+      try {
+        const audio = await navigator.mediaDevices.getUserMedia({ audio: true });
+        trackTypes.value = [...trackTypes.value, { id: audio.id, type: "audio" }];
+        tracks.push(...audio.getAudioTracks());
+      } catch (err) {
+        console.error("[vue-chat] Error accessing microphone:", err);
+        error(deviceError(err, "mic", isMobile2()));
+        isAudioOn.value = false;
+      }
+      try {
+        const video = await navigator.mediaDevices.getUserMedia({ video: true });
+        trackTypes.value = [...trackTypes.value, { id: video.id, type: "webcam" }];
+        tracks.push(...video.getVideoTracks());
+      } catch (err) {
+        console.error("[vue-chat] Error accessing camera:", err);
+        error(deviceError(err, "camera", isMobile2()));
+        isVideoOn.value = false;
+      }
+      if (tracks.length) localStream.value = new MediaStream(tracks);
+    }
+    videoTrack.value = ((_a = localStream.value) == null ? void 0 : _a.getVideoTracks()[0]) ?? null;
+  }
+  function toggleAudio() {
+    var _a;
+    isAudioOn.value = !isAudioOn.value;
+    const track = (_a = localStream.value) == null ? void 0 : _a.getAudioTracks()[0];
+    if (track) track.enabled = isAudioOn.value;
+  }
+  function toggleVideo() {
+    var _a;
+    isVideoOn.value = !isVideoOn.value;
+    const track = (_a = localStream.value) == null ? void 0 : _a.getVideoTracks()[0];
+    if (track) track.enabled = isVideoOn.value;
+  }
+  async function switchCamera(deviceId) {
+    try {
+      const stream = await navigator.mediaDevices.getUserMedia({
+        video: { deviceId: { exact: deviceId } },
+        audio: isAudioOn.value
+      });
+      const track = stream.getVideoTracks()[0];
+      if (!track || !localStream.value) return null;
+      const old = localStream.value.getVideoTracks()[0];
+      if (old) {
+        localStream.value.removeTrack(old);
+        old.stop();
+      }
+      localStream.value.addTrack(track);
+      videoTrack.value = track;
+      return track;
+    } catch (err) {
+      console.error("[vue-chat] Error switching camera:", err);
+      return null;
+    }
+  }
+  async function startScreenShare(onEnded) {
+    var _a;
+    if (screenStream.value) {
+      screenStream.value.getVideoTracks()[0].enabled = true;
+      isScreenSharing.value = true;
+      return null;
+    }
+    if (!((_a = navigator.mediaDevices) == null ? void 0 : _a.getDisplayMedia)) {
+      error(
+        isMobile2() ? "screenShareMobileUnsupported" : "screenShareBrowserUnsupported"
+      );
+      return null;
+    }
+    try {
+      const stream = await navigator.mediaDevices.getDisplayMedia({
+        video: true,
+        audio: false
+      });
+      screenStream.value = stream;
+      trackTypes.value = [...trackTypes.value, { id: stream.id, type: "screen" }];
+      stream.getTracks().forEach((track) => track.onended = onEnded);
+      isScreenSharing.value = true;
+      return stream;
+    } catch (err) {
+      console.error("[vue-chat] Screen share failed:", err);
+      error(deviceError(err, "screen", isMobile2()));
+      isScreenSharing.value = false;
+      return null;
+    }
+  }
+  function stopScreenShare() {
+    const stream = screenStream.value;
+    if (!stream) return null;
+    stream.getTracks().forEach((track) => {
+      track.stop();
+      track.enabled = false;
+    });
+    trackTypes.value = trackTypes.value.filter((t) => t.type !== "screen");
+    screenStream.value = null;
+    isScreenSharing.value = false;
+    return stream;
+  }
+  async function toggleFlashlight() {
+    const track = videoTrack.value;
+    if (!track) {
+      error("cameraUnavailable");
+      return;
+    }
+    if (!isFlashlightSupported.value) return;
+    try {
+      await track.applyConstraints({
+        advanced: [{ torch: !isFlashlightOn.value }]
+      });
+      isFlashlightOn.value = !isFlashlightOn.value;
+    } catch (err) {
+      console.error("[vue-chat] Flashlight toggle failed:", err);
+      error("flashlightToggleFailed");
+    }
+  }
+  function stopAll() {
+    if (isFlashlightOn.value && videoTrack.value) {
+      void videoTrack.value.applyConstraints({ advanced: [{ torch: false }] }).catch(() => {
+      });
+    }
+    for (const stream of [localStream.value, screenStream.value]) {
+      stream == null ? void 0 : stream.getTracks().forEach((track) => {
+        track.stop();
+        track.enabled = false;
+      });
+    }
+    localStream.value = null;
+    screenStream.value = null;
+    videoTrack.value = null;
+  }
+  return {
+    localStream,
+    screenStream,
+    trackTypes,
+    videoTrack,
+    cameras,
+    isAudioOn,
+    isVideoOn,
+    isScreenSharing,
+    isFlashlightOn,
+    isFlashlightSupported,
+    checkPermissions,
+    start,
+    toggleAudio,
+    toggleVideo,
+    switchCamera,
+    startScreenShare,
+    stopScreenShare,
+    toggleFlashlight,
+    stopAll
+  };
+}
+const toIceUrl = (url) => url.startsWith("stun:") || url.startsWith("turn:") ? url : `turn:${url}`;
+const isMobile = () => {
+  var _a;
+  return /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent) || !!((_a = window.matchMedia) == null ? void 0 : _a.call(window, "(max-width: 768px)").matches);
+};
+function createCallSession(opts) {
+  const { handlers, channel } = opts;
+  const scope = effectScope(true);
+  const log = handlers.debug ? (...args) => console.log("[vue-chat:call]", ...args) : () => {
+  };
+  const selfId = `${opts.self.id}:${nanoid()}`;
+  const session = scope.run(() => {
+    const signaling2 = createSignaling(handlers, { id: selfId, name: opts.self.name });
+    const media2 = useCallMedia({ notify: opts.notify, isMobile });
+    const peers2 = usePeers({
+      selfId,
+      signaling: signaling2,
+      localStream: media2.localStream,
+      screenStream: media2.screenStream,
+      log,
+      rtcConfig() {
+        var _a;
+        const policy = handlers.iceTransportPolicy ?? "relay";
+        const cred = handlers.credential;
+        const iceServers = ((_a = cred == null ? void 0 : cred.urls) == null ? void 0 : _a.length) ? [{ urls: cred.urls.map(toIceUrl), username: cred.user, credential: cred.pass }] : [];
+        if (policy === "relay" && !iceServers.length) return null;
+        return { iceTransportPolicy: policy, iceServers };
+      }
+    });
+    const participantCount = computed(() => Object.keys(peers2.peers.value).length + 1);
+    const tileCount = computed(
+      () => (media2.screenStream.value ? 1 : 0) + Object.keys(peers2.remoteVideos.value).length + Object.keys(peers2.remoteScreens.value).length
+    );
+    return { signaling: signaling2, media: media2, peers: peers2, participantCount, tileCount };
+  });
+  const { signaling, media, peers } = session;
+  let ended = false;
+  async function ringOtherSide() {
+    const blob = opts.self.avatar();
+    let avatar;
+    if (blob) {
+      const bytes = new Uint8Array(await blob.arrayBuffer());
+      avatar = `data:${blob.type};base64,${btoa(String.fromCharCode(...bytes))}`;
+    }
+    await signaling.ring(channel, avatar);
+  }
+  async function start() {
+    var _a;
+    await signaling.listen({
+      onSignal: (from, name, signal) => peers.signal(from, name, signal),
+      onJoin(from, name) {
+        log("join from", from, name);
+        void signaling.trackTypes(media.trackTypes.value);
+        const isNew = !peers.has(from);
+        peers.add(from, name);
+        if (isNew && !peers.isInitiator(from)) void signaling.join();
+      },
+      onTrackTypes(from, types) {
+        peers.remoteStreamTypes.value[from] = types;
+      },
+      onHangup(from) {
+        log("hangup from", from);
+        peers.remove(from);
+      }
+    });
+    await handlers.handleGenerateCred();
+    await media.checkPermissions();
+    await media.start();
+    if (ended) return media.stopAll();
+    log("local media ready:", (_a = media.localStream.value) == null ? void 0 : _a.getTracks().map((t) => t.kind));
+    void signaling.trackTypes(media.trackTypes.value);
+    void ringOtherSide();
+    void signaling.join();
+  }
+  function stopScreenShare() {
+    const stream = media.stopScreenShare();
+    stream == null ? void 0 : stream.getVideoTracks().forEach((track) => peers.removeTrackFromAll(track));
+  }
+  async function toggleScreenShare() {
+    if (media.isScreenSharing.value) return stopScreenShare();
+    const stream = await media.startScreenShare(stopScreenShare);
+    if (!stream) return;
+    await signaling.trackTypes(media.trackTypes.value);
+    stream.getVideoTracks().forEach((track) => peers.addTrackToAll(track, stream));
+  }
+  async function switchCamera(deviceId) {
+    const track = await media.switchCamera(deviceId);
+    const stream = media.localStream.value;
+    if (track && stream) peers.replaceVideoTrack(track, stream);
+    return stream;
+  }
+  function end() {
+    if (ended) return;
+    ended = true;
+    void signaling.hangup(channel);
+    signaling.stop();
+    peers.destroyAll();
+    media.stopAll();
+    scope.stop();
+  }
+  return {
+    ...session,
+    channel,
+    start,
+    end,
+    toggleScreenShare,
+    switchCamera
+  };
+}
+export {
+  createCallSession
+};
+//# sourceMappingURL=session-B3KIrj3_.mjs.map