VideoSDK namespace

import { VideoSDK } from '@videosdk/js';

try {
  const room = await VideoSDK.join({
    token: getAuthToken(),
    roomId: 'team-standup',
    name: 'Alice',
    metadata: { role: 'host' },
    subscribeEvents: ['active-speaker-changed'],  // pre-warm lazy events
  });
  console.log('connected', room.localParticipant.id);
} catch (err) {
  if (err.kind === ErrorKind.Auth)        showLoginUI();             // any auth failure
  else if (err.code === 'TIMEOUT')        showNetworkError();
  else if (err.code === 'ROOM_FULL')      showRoomFullToast();
  else                                    showGenericError(err);
}

const cameras = await VideoSDK.getCameras();
const mics    = await VideoSDK.getMicrophones();

const room = await VideoSDK.join({
  token: getAuthToken(),
  roomId: 'team-standup',
  name: 'Alice',
  publishVideo: { device: cameras[0], resolution: 'h720' },
  publishAudio: { device: mics[0], noiseSuppression: true },
});
// Connected AND publishing — single round-trip.

const cameras = await VideoSDK.getCameras();

// Pre-call screen
const previewVideo = await VideoSDK.createVideoStream({ device: cameras[0], resolution: 'h720' });
const previewAudio = await VideoSDK.createAudioStream({ device: (await VideoSDK.getMicrophones())[0] });
previewVideo.attach(previewEl);
await VideoSDK.testNetwork();

// Join — local streams auto-promote
const room = await VideoSDK.join({ token, roomId, name });
// previewVideo === room.localParticipant.video (no re-acquisition, no flicker)

// Same join() call. With an 'ask' token, the Promise stays pending while the
// joiner is in the lobby — onWaiting fires once so you can render the lobby UI.
const controller = new AbortController();
ui.onCancelClick = () => controller.abort();   // explicit "Cancel" button

try {
  const room = await VideoSDK.join({
    token,
    roomId,
    name: 'Patient 9',
    onWaiting: () => ui.showLobbyScreen('Waiting for the doctor…'),
    signal:    controller.signal,
  });
  ui.showCallScreen(room);
} catch (err) {
  if (err.code === 'ENTRY_DENIED')        ui.showDeniedScreen();
  else if (err.code === 'ENTRY_TIMEOUT')  ui.showTimeoutScreen();
  else if (err.name === 'AbortError')     ui.showHome();
  else                                    showGenericError(err);
}
// Tab close needs no code — the SDK's socket disconnect cancels the lobby entry.
// Full reference: waiting-lobby.html

const cameras = await VideoSDK.getCameras();
const front = cameras.find(c => c.label.includes('FaceTime'));
await me.video.setInputDevice(front);   // pass the typed object

const mics = await VideoSDK.getMicrophones();
console.log(mics.map(m => m.label));

const speakers = await VideoSDK.getSpeakers();
const headset = speakers.find(s => s.label.toLowerCase().includes('headset'));
await room.setOutputDevice(headset);

const perms = await VideoSDK.checkPermissions([MediaKind.Audio, MediaKind.Video]);
if (!perms.get(MediaKind.Video)) showRequestUI();

const granted = await VideoSDK.requestPermissions([MediaKind.Audio, MediaKind.Video]);
if (granted.get(MediaKind.Video)) {
  const preview = await VideoSDK.createVideoStream({ deviceId: 'default' });
  preview.attach(previewEl);
}

const result = await VideoSDK.runPreCallTest({ token });

if (result.quality?.audioOnly) {
  showWarning('Network is too slow for video — audio-only recommended');
}
if (result.connectivity?.turnUsed) {
  showWarning('Using TURN relay — may add latency');
}

const test = VideoSDK.runPreCallTest({
  token,
  onProgress: ({ phase, data }) => {
    if (phase === 'media')        renderDeviceStatus(data);
    if (phase === 'connectivity') renderServerStatus(data);
  },
  onError: ({ code, message, phase }) => {
    showWarning(`[${phase}] ${message}`);
  },
});

joinButton.onclick = async () => {
  test.stop();                  // skip remaining quality test
  const result = await test;    // resolves with partial results, aborted: true
  await VideoSDK.join({ token, roomId, name });   // local streams auto-promote
};

const result = await VideoSDK.runPreCallTest({
  token,
  tests: [PreCallPhase.Connectivity],
});

console.log('Region:', result.connectivity?.region);
console.log('Protocol:', result.connectivity?.protocol);
console.log('TURN used:', result.connectivity?.turnUsed);

const cameras = await VideoSDK.getCameras();
const mics    = await VideoSDK.getMicrophones();

// Show pre-call UI with live local stream
const camStream = await VideoSDK.createVideoStream({ device: cameras[0], resolution: 'h720' });
const micStream = await VideoSDK.createAudioStream({ device: mics[0] });

camStream.attach(previewEl);
levelMeter.bind(() => micStream.audioLevel);
await camStream.setInputDevice(cameras[1]);   // hot-swap to another camera

await VideoSDK.runPreCallTest({ token });

// Join — local streams auto-promote, no flicker
const room = await VideoSDK.join({ token, roomId, name });
// camStream === room.localParticipant.video

// User clicks "Beach background"
const beachBg: VideoFrameProcessor = {
  async process(frame) {
    const mask = await segmentationModel.segment(frame);
    return composite(frame, mask, beachImage);
  },
};
await VideoSDK.applyVideoProcessor(beachBg);
// me.video now publishes with beach background — no flicker, no unpublish

const noiseSuppress: AudioFrameProcessor = {
  process(frame) { return rnnoise.run(frame); },
};
await VideoSDK.applyAudioProcessor(noiseSuppress);

VideoSDK.on('devices-changed', async () => {
  cameraSelect.options = await VideoSDK.getCameras();
  micSelect.options    = await VideoSDK.getMicrophones();
});

import { VideoSDK, LogLevel } from '@videosdk/js';

// At app startup — silence SDK logs in production
VideoSDK.setLogLevel(LogLevel.Warn);

// Bump up when collecting a bug report
debugButton.onclick = () => VideoSDK.setLogLevel(LogLevel.Debug);