@vidtreo/recorder 1.3.4 → 1.4.0

package/dist/index.d.ts

@@ -69,6 +69,16 @@ export {};
 
 export {};
 
+export {};
+
+export {};
+
+export {};
+
+export {};
+
+export {};
+
 export type VidtreoRecorderConfig = {
     apiKey: string;
     apiUrl?: string;
@@ -350,6 +360,15 @@ export declare function createBrowserUnsupportedError(options?: BrowserUnsupport
 export declare function validateBrowserSupport(): void;
 export {};
 
+type PermissionName = "camera" | "microphone";
+type PermissionStateChangeHandler = (state: PermissionState) => void;
+export declare function queryPermissionState(permissionName: PermissionName): Promise<PermissionState>;
+export declare function queryAllPermissions(): Promise<PermissionStatus>;
+export declare function isPermissionGranted(state: PermissionState): boolean;
+export declare function isPermissionBlocked(state: PermissionState): boolean;
+export declare function createPermissionChangeListener(permissionName: PermissionName, onStateChange: PermissionStateChangeHandler): () => void;
+export {};
+
 export type AvailableDevices = {
     audioinput: MediaDeviceInfo[];
     videoinput: MediaDeviceInfo[];
@@ -359,6 +378,41 @@ export type DeviceCallbacks = {
     onDeviceSelected: (type: "camera" | "mic", deviceId: string | null) => void;
 };
 
+export declare function createPermissionFlowOrchestratorDependencies(): PermissionFlowOrchestratorDependencies;
+export declare class PermissionFlowOrchestrator {
+    private readonly dependencies;
+    private readonly callbacks;
+    private readonly language;
+    private currentState;
+    private cleanupCameraListener;
+    private cleanupMicrophoneListener;
+    private isInitialized;
+    private hasCompleted;
+    constructor(dependencies: PermissionFlowOrchestratorDependencies, options?: PermissionFlowOrchestratorOptions);
+    initialize(): Promise<PermissionFlowState>;
+    requestCurrentStep(): Promise<PermissionFlowState>;
+    retryCurrentStep(): Promise<PermissionFlowState>;
+    getState(): PermissionFlowState;
+    private requestPermissionAndRefresh;
+    destroy(): void;
+    private setupPermissionListeners;
+    private handlePermissionStateChange;
+    private refreshPermissions;
+    private createStateFromPermissions;
+    private transitionToBlockedFromFailedProbe;
+    private createInsecureContextState;
+    private updateStateForChecking;
+    private emitChange;
+    private tryComplete;
+}
+
+export declare const DEVICE_PERSISTENCE_KEY_PREFIX = "vidtreo_device_prefs_";
+export declare function createDevicePersistenceKey(apiKey: string): string;
+export declare function saveDevicePreferences(apiKey: string, preferences: DevicePreferences): void;
+export declare function loadDevicePreferences(apiKey: string): DevicePreferences | null;
+export declare function clearDevicePreferences(apiKey: string): void;
+export declare function validateSavedDeviceExists(savedDeviceId: string, availableDevices: MediaDeviceInfo[]): boolean;
+
 import type { CameraStreamManager } from "../stream/stream";
 export declare class DeviceManager {
     private readonly streamManager;
@@ -375,6 +429,96 @@ export declare class DeviceManager {
     getAvailableDevicesList(): AvailableDevices;
 }
 
+export declare function createPermissionRecoveryData(errorCode: DeviceIssueCode, browserInfo: {
+    name: string;
+    version: string;
+}, language?: "en" | "es"): PermissionRecoveryData;
+
+export type PermissionState = "granted" | "denied" | "prompt" | "unknown";
+export type PermissionStatus = {
+    camera: PermissionState;
+    microphone: PermissionState;
+};
+export type DeviceIssueCode = "permission-denied-camera" | "permission-denied-microphone" | "permission-denied-both" | "device-not-found" | "device-in-use" | "device-disconnected" | "silent-microphone" | "track-muted" | "track-ended" | "insecure-context";
+export type DeviceIssue = {
+    code: DeviceIssueCode;
+    severity: "error" | "warning";
+    deviceType: "camera" | "microphone" | "both";
+    recoveryData?: PermissionRecoveryData;
+};
+export type PermissionRecoveryData = {
+    errorCode: DeviceIssueCode;
+    browserName: string;
+    browserVersion: string;
+    resetInstructions: string;
+    resetUrl?: string;
+    canRetry: boolean;
+};
+export type DevicePreflightResult = {
+    isReady: boolean;
+    permissions: PermissionStatus;
+    hasCamera: boolean;
+    hasMicrophone: boolean;
+    issues: DeviceIssue[];
+};
+export type DevicePreferences = {
+    cameraDeviceId?: string;
+    micDeviceId?: string;
+};
+export type DeviceHealthCallbacks = {
+    onDeviceDisconnected?: (deviceType: "camera" | "microphone", deviceId: string, fallbackDeviceId?: string) => void;
+    onDeviceFallback?: (requestedDeviceId: string, actualDeviceId: string, deviceType: "camera" | "microphone") => void;
+    onSilentMicDetected?: () => void;
+    onSilentMicRecovered?: () => void;
+    onTrackHealthChange?: (trackType: "audio" | "video", event: "muted" | "unmuted" | "ended") => void;
+    onPermissionStateChange?: (permissions: PermissionStatus) => void;
+    onPreflightComplete?: (result: DevicePreflightResult) => void;
+};
+export type DeviceAccessConfig = {
+    enableDevicePersistence?: boolean;
+    enableSilentMicDetection?: boolean;
+    enableTrackHealthMonitoring?: boolean;
+    silentMicThresholdLevel?: number;
+    silentMicThresholdDuration?: number;
+    deviceChangeDebounceMs?: number;
+};
+export type PermissionFlowStep = "idle" | "checking" | "awaiting-user" | "blocked" | "ready";
+export type PermissionDenialType = "none" | "soft" | "hard";
+export type PermissionFlowChangeReason = "initialized" | "permission-refresh" | "permission-change" | "current-step-requested" | "retry-requested" | "probe-complete" | "insecure-context" | "destroyed";
+export type PermissionFlowSnapshot = {
+    step: PermissionFlowStep;
+    permissions: PermissionStatus;
+    denialType: PermissionDenialType;
+    issueCode?: DeviceIssueCode;
+    recoveryData?: PermissionRecoveryData;
+    isSecureContext: boolean;
+    isComplete: boolean;
+    canRetry: boolean;
+    shouldProbeUnknown: boolean;
+};
+export type PermissionFlowState = PermissionFlowSnapshot;
+export type PermissionFlowCallbacks = {
+    onChange?: (state: PermissionFlowState, reason: PermissionFlowChangeReason) => void;
+    onComplete?: (state: PermissionFlowState) => void;
+};
+export type PermissionFlowLanguage = "en" | "es";
+export type PermissionFlowBrowserInfo = {
+    name: string;
+    version: string;
+};
+export type PermissionFlowOrchestratorDependencies = {
+    queryAllPermissions: () => Promise<PermissionStatus>;
+    createPermissionChangeListener: (permissionName: "camera" | "microphone", onStateChange: (state: PermissionState) => void) => () => void;
+    createPermissionRecoveryData: (errorCode: DeviceIssueCode, browserInfo: PermissionFlowBrowserInfo, language?: PermissionFlowLanguage) => PermissionRecoveryData;
+    getBrowserInfo: () => PermissionFlowBrowserInfo;
+    getIsSecureContext: () => boolean;
+    requestPermissionProbe: () => Promise<void>;
+};
+export type PermissionFlowOrchestratorOptions = {
+    callbacks?: PermissionFlowCallbacks;
+    language?: PermissionFlowLanguage;
+};
+
 export type NativeCameraFile = {
     file: File;
     previewUrl: string;

package/dist/index.js

@@ -704,6 +704,488 @@ class DeviceManager {
     return this.availableDevices;
   }
 }
+// src/core/device/permission-checker.ts
+var noOperation = () => {
+  return;
+};
+function isPermissionsApiAvailable() {
+  if (typeof navigator === "undefined") {
+    return false;
+  }
+  if (!navigator.permissions) {
+    return false;
+  }
+  return typeof navigator.permissions.query === "function";
+}
+function queryPermissionState(permissionName) {
+  if (!isPermissionsApiAvailable()) {
+    return Promise.resolve("unknown");
+  }
+  return navigator.permissions.query({ name: permissionName }).then((status) => status.state).catch(() => "unknown");
+}
+async function queryAllPermissions() {
+  const [camera, microphone] = await Promise.all([
+    queryPermissionState("camera"),
+    queryPermissionState("microphone")
+  ]);
+  return { camera, microphone };
+}
+function createPermissionChangeListener(permissionName, onStateChange) {
+  if (!isPermissionsApiAvailable()) {
+    return noOperation;
+  }
+  let permissionStatus = null;
+  let isDestroyed = false;
+  const handleChange = () => {
+    if (!permissionStatus) {
+      return;
+    }
+    onStateChange(permissionStatus.state);
+  };
+  navigator.permissions.query({ name: permissionName }).then((status) => {
+    if (isDestroyed) {
+      return;
+    }
+    permissionStatus = status;
+    permissionStatus.addEventListener("change", handleChange);
+  }).catch(noOperation);
+  return () => {
+    isDestroyed = true;
+    if (permissionStatus) {
+      permissionStatus.removeEventListener("change", handleChange);
+      permissionStatus = null;
+    }
+  };
+}
+
+// src/core/device/permission-recovery.ts
+var CHROME_INSTRUCTIONS = {
+  en: "Click the lock/tune icon in the address bar → Site settings → Camera/Microphone → Allow",
+  es: "Haz clic en el icono de candado/ajustes en la barra de direcciones → Configuración del sitio → Cámara/Micrófono → Permitir",
+  resetUrl: "chrome://settings/content/camera"
+};
+var SAFARI_INSTRUCTIONS = {
+  en: "Go to Safari → Settings → Websites → Camera/Microphone → Allow for this site",
+  es: "Ve a Safari → Ajustes → Sitios web → Cámara/Micrófono → Permitir para este sitio"
+};
+var EDGE_INSTRUCTIONS = {
+  en: "Click the lock icon in the address bar → Permissions → Camera/Microphone → Allow",
+  es: "Haz clic en el icono de candado en la barra de direcciones → Permisos → Cámara/Micrófono → Permitir",
+  resetUrl: "edge://settings/content/camera"
+};
+var OPERA_INSTRUCTIONS = {
+  en: "Click the lock icon → Site settings → Camera/Microphone → Allow",
+  es: "Haz clic en el icono de candado → Configuración del sitio → Cámara/Micrófono → Permitir",
+  resetUrl: "opera://settings/content/camera"
+};
+var UNKNOWN_BROWSER_INSTRUCTIONS = {
+  en: "Please check your browser settings to allow camera and microphone access for this site",
+  es: "Por favor, revisa la configuración de tu navegador para permitir el acceso a la cámara y el micrófono en este sitio"
+};
+var INSECURE_CONTEXT_INSTRUCTIONS = {
+  en: "This site must be accessed over HTTPS (secure connection) to use camera and microphone",
+  es: "Este sitio debe ser accedido a través de HTTPS (conexión segura) para usar cámara y micrófono"
+};
+var BROWSER_INSTRUCTIONS_MAP = {
+  chrome: CHROME_INSTRUCTIONS,
+  safari: SAFARI_INSTRUCTIONS,
+  edge: EDGE_INSTRUCTIONS,
+  opera: OPERA_INSTRUCTIONS,
+  unknown: UNKNOWN_BROWSER_INSTRUCTIONS
+};
+var RETRYABLE_ERROR_CODES = new Set([
+  "permission-denied-camera",
+  "permission-denied-microphone",
+  "permission-denied-both",
+  "device-not-found",
+  "device-in-use"
+]);
+function resolveBrowserKey(browserName) {
+  const normalizedName = browserName.toLowerCase();
+  if (normalizedName.includes("edge")) {
+    return "edge";
+  }
+  if (normalizedName.includes("opera") || normalizedName.includes("opr")) {
+    return "opera";
+  }
+  if (normalizedName.includes("chrome")) {
+    return "chrome";
+  }
+  if (normalizedName.includes("safari")) {
+    return "safari";
+  }
+  return "unknown";
+}
+function createPermissionRecoveryData(errorCode, browserInfo, language = "en") {
+  if (errorCode === "insecure-context") {
+    return {
+      errorCode,
+      browserName: browserInfo.name,
+      browserVersion: browserInfo.version,
+      resetInstructions: INSECURE_CONTEXT_INSTRUCTIONS[language],
+      resetUrl: undefined,
+      canRetry: false
+    };
+  }
+  const browserKey = resolveBrowserKey(browserInfo.name);
+  const instructions = BROWSER_INSTRUCTIONS_MAP[browserKey];
+  const canRetry = RETRYABLE_ERROR_CODES.has(errorCode);
+  return {
+    errorCode,
+    browserName: browserInfo.name,
+    browserVersion: browserInfo.version,
+    resetInstructions: instructions[language],
+    resetUrl: instructions.resetUrl,
+    canRetry
+  };
+}
+
+// src/core/device/permission-flow-orchestrator.ts
+var GRANTED_PERMISSION_COUNT = 2;
+var DEFAULT_PERMISSION_STATUS = {
+  camera: "unknown",
+  microphone: "unknown"
+};
+function noOperation2() {
+  return;
+}
+function getIsSecureContext() {
+  const globalWindow = globalThis.window;
+  if (!globalWindow) {
+    return false;
+  }
+  return globalWindow.isSecureContext;
+}
+function stopStreamTracks(stream) {
+  const tracks = stream.getTracks();
+  for (const track of tracks) {
+    track.stop();
+  }
+}
+async function requestPermissionProbe() {
+  const mediaDevices = globalThis.navigator?.mediaDevices;
+  if (!mediaDevices) {
+    return;
+  }
+  const canGetUserMedia = typeof mediaDevices.getUserMedia === "function";
+  if (!canGetUserMedia) {
+    return;
+  }
+  const stream = await mediaDevices.getUserMedia({ audio: true, video: true });
+  stopStreamTracks(stream);
+  await mediaDevices.getUserMedia({
+    audio: true,
+    video: { width: { ideal: 1920 }, height: { ideal: 1080 } }
+  }).then((stream2) => {
+    stopStreamTracks(stream2);
+    return;
+  }).catch(noOperation2);
+}
+function countGrantedPermissions(permissions) {
+  let grantedCount = 0;
+  if (permissions.camera === "granted") {
+    grantedCount += 1;
+  }
+  if (permissions.microphone === "granted") {
+    grantedCount += 1;
+  }
+  return grantedCount;
+}
+function hasUnknownPermissionState(permissions) {
+  if (permissions.camera === "unknown") {
+    return true;
+  }
+  if (permissions.microphone === "unknown") {
+    return true;
+  }
+  return false;
+}
+function hasPromptPermissionState(permissions) {
+  if (permissions.camera === "prompt") {
+    return true;
+  }
+  if (permissions.microphone === "prompt") {
+    return true;
+  }
+  return false;
+}
+function hasHardPermissionDenial(permissions) {
+  if (permissions.camera === "denied") {
+    return true;
+  }
+  if (permissions.microphone === "denied") {
+    return true;
+  }
+  return false;
+}
+function getPermissionDeniedIssueCode(permissions) {
+  const hasCameraDenied = permissions.camera === "denied";
+  const hasMicrophoneDenied = permissions.microphone === "denied";
+  if (hasCameraDenied && hasMicrophoneDenied) {
+    return "permission-denied-both";
+  }
+  if (hasCameraDenied) {
+    return "permission-denied-camera";
+  }
+  return "permission-denied-microphone";
+}
+function createPermissionFlowOrchestratorDependencies() {
+  return {
+    queryAllPermissions,
+    createPermissionChangeListener,
+    createPermissionRecoveryData,
+    getBrowserInfo: () => {
+      const browserInfo = getBrowserInfo();
+      return {
+        name: browserInfo.name,
+        version: browserInfo.version
+      };
+    },
+    getIsSecureContext,
+    requestPermissionProbe
+  };
+}
+
+class PermissionFlowOrchestrator {
+  dependencies;
+  callbacks;
+  language;
+  currentState;
+  cleanupCameraListener = noOperation2;
+  cleanupMicrophoneListener = noOperation2;
+  isInitialized = false;
+  hasCompleted = false;
+  constructor(dependencies, options = {}) {
+    this.dependencies = dependencies;
+    let callbacks = {};
+    if (options.callbacks) {
+      callbacks = options.callbacks;
+    }
+    this.callbacks = callbacks;
+    let language = "en";
+    if (options.language === "es") {
+      language = "es";
+    }
+    this.language = language;
+    this.currentState = {
+      step: "idle",
+      permissions: DEFAULT_PERMISSION_STATUS,
+      denialType: "none",
+      isSecureContext: true,
+      isComplete: false,
+      canRetry: true,
+      shouldProbeUnknown: true
+    };
+  }
+  initialize() {
+    if (this.isInitialized) {
+      return Promise.resolve(this.currentState);
+    }
+    this.isInitialized = true;
+    this.hasCompleted = false;
+    this.setupPermissionListeners();
+    this.updateStateForChecking();
+    this.emitChange("initialized");
+    const isSecureContext = this.dependencies.getIsSecureContext();
+    if (!isSecureContext) {
+      this.currentState = this.createInsecureContextState();
+      this.emitChange("insecure-context");
+      this.tryComplete();
+      return Promise.resolve(this.currentState);
+    }
+    return this.refreshPermissions("permission-refresh");
+  }
+  requestCurrentStep() {
+    if (!this.isInitialized) {
+      return this.initialize();
+    }
+    if (!this.currentState.canRetry) {
+      return Promise.resolve(this.currentState);
+    }
+    this.updateStateForChecking();
+    this.emitChange("current-step-requested");
+    return this.requestPermissionAndRefresh();
+  }
+  retryCurrentStep() {
+    if (!this.isInitialized) {
+      return this.initialize();
+    }
+    if (!this.currentState.canRetry) {
+      return Promise.resolve(this.currentState);
+    }
+    this.updateStateForChecking();
+    this.emitChange("retry-requested");
+    return this.requestPermissionAndRefresh();
+  }
+  getState() {
+    return this.currentState;
+  }
+  requestPermissionAndRefresh() {
+    return this.dependencies.requestPermissionProbe().then(() => {
+      const grantedPermissions = {
+        camera: "granted",
+        microphone: "granted"
+      };
+      this.currentState = this.createStateFromPermissions(grantedPermissions);
+      this.emitChange("probe-complete");
+      this.tryComplete();
+      return this.currentState;
+    }).catch(() => this.refreshPermissions("permission-refresh").then((state) => {
+      if (state.step !== "awaiting-user") {
+        return state;
+      }
+      return this.transitionToBlockedFromFailedProbe();
+    }));
+  }
+  destroy() {
+    this.cleanupCameraListener();
+    this.cleanupCameraListener = noOperation2;
+    this.cleanupMicrophoneListener();
+    this.cleanupMicrophoneListener = noOperation2;
+    this.isInitialized = false;
+    this.hasCompleted = false;
+    this.emitChange("destroyed");
+  }
+  setupPermissionListeners() {
+    this.cleanupCameraListener = this.dependencies.createPermissionChangeListener("camera", (state) => {
+      this.handlePermissionStateChange("camera", state);
+    });
+    this.cleanupMicrophoneListener = this.dependencies.createPermissionChangeListener("microphone", (state) => {
+      this.handlePermissionStateChange("microphone", state);
+    });
+  }
+  handlePermissionStateChange(permissionName, state) {
+    if (!this.isInitialized) {
+      return;
+    }
+    const nextPermissions = {
+      ...this.currentState.permissions,
+      [permissionName]: state
+    };
+    const previousStep = this.currentState.step;
+    this.currentState = this.createStateFromPermissions(nextPermissions);
+    const isFlowReactivating = previousStep === "ready" && this.currentState.step !== "ready";
+    if (isFlowReactivating) {
+      this.hasCompleted = false;
+    }
+    this.emitChange("permission-change");
+    this.tryComplete();
+  }
+  async refreshPermissions(reason) {
+    const permissions = await this.dependencies.queryAllPermissions();
+    this.currentState = this.createStateFromPermissions(permissions);
+    this.emitChange(reason);
+    this.tryComplete();
+    return this.currentState;
+  }
+  createStateFromPermissions(permissions) {
+    const isSecureContext = this.dependencies.getIsSecureContext();
+    if (!isSecureContext) {
+      return this.createInsecureContextState();
+    }
+    const grantedCount = countGrantedPermissions(permissions);
+    if (grantedCount === GRANTED_PERMISSION_COUNT) {
+      return {
+        step: "ready",
+        permissions,
+        denialType: "none",
+        isSecureContext: true,
+        isComplete: true,
+        canRetry: false,
+        shouldProbeUnknown: false
+      };
+    }
+    if (hasHardPermissionDenial(permissions)) {
+      const issueCode = getPermissionDeniedIssueCode(permissions);
+      const recoveryData = this.dependencies.createPermissionRecoveryData(issueCode, this.dependencies.getBrowserInfo(), this.language);
+      return {
+        step: "blocked",
+        permissions,
+        denialType: "hard",
+        issueCode,
+        recoveryData,
+        isSecureContext: true,
+        isComplete: true,
+        canRetry: recoveryData.canRetry,
+        shouldProbeUnknown: false
+      };
+    }
+    const shouldProbeUnknown = hasUnknownPermissionState(permissions);
+    const hasPromptState = hasPromptPermissionState(permissions);
+    let canRetry = false;
+    if (shouldProbeUnknown) {
+      canRetry = true;
+    }
+    if (hasPromptState) {
+      canRetry = true;
+    }
+    return {
+      step: "awaiting-user",
+      permissions,
+      denialType: "soft",
+      isSecureContext: true,
+      isComplete: false,
+      canRetry,
+      shouldProbeUnknown
+    };
+  }
+  transitionToBlockedFromFailedProbe() {
+    const issueCode = "permission-denied-both";
+    const recoveryData = this.dependencies.createPermissionRecoveryData(issueCode, this.dependencies.getBrowserInfo(), this.language);
+    this.currentState = {
+      step: "blocked",
+      permissions: this.currentState.permissions,
+      denialType: "hard",
+      issueCode,
+      recoveryData,
+      isSecureContext: true,
+      isComplete: true,
+      canRetry: recoveryData.canRetry,
+      shouldProbeUnknown: false
+    };
+    this.emitChange("probe-complete");
+    this.tryComplete();
+    return this.currentState;
+  }
+  createInsecureContextState() {
+    const issueCode = "insecure-context";
+    const recoveryData = this.dependencies.createPermissionRecoveryData(issueCode, this.dependencies.getBrowserInfo(), this.language);
+    return {
+      step: "blocked",
+      permissions: this.currentState.permissions,
+      denialType: "hard",
+      issueCode,
+      recoveryData,
+      isSecureContext: false,
+      isComplete: true,
+      canRetry: false,
+      shouldProbeUnknown: false
+    };
+  }
+  updateStateForChecking() {
+    this.currentState = {
+      ...this.currentState,
+      step: "checking"
+    };
+  }
+  emitChange(reason) {
+    if (this.callbacks.onChange) {
+      this.callbacks.onChange(this.currentState, reason);
+    }
+  }
+  tryComplete() {
+    if (this.hasCompleted) {
+      return;
+    }
+    if (!this.currentState.isComplete) {
+      return;
+    }
+    this.hasCompleted = true;
+    if (this.callbacks.onComplete) {
+      this.callbacks.onComplete(this.currentState);
+    }
+  }
+}
 // src/core/utils/video-utils.ts
 import { BlobSource, Input, MP4 } from "mediabunny";
 async function extractVideoDuration(file) {
@@ -2136,7 +2618,7 @@ function stopLiveTracks(tracks) {
     }
   }
 }
-function stopStreamTracks(stream) {
+function stopStreamTracks2(stream) {
   stopLiveTracks(stream.getTracks());
 }
 function stopStreamVideoTracks(stream) {
@@ -2153,7 +2635,7 @@ function areTracksLive(videoTrack, audioTrack) {
 }
 function validateTrack(track, trackType, stream) {
   if (!isTrackLive(track)) {
-    stopStreamTracks(stream);
+    stopStreamTracks2(stream);
     let readyState = "undefined";
     if (track) {
       readyState = track.readyState;
@@ -2311,7 +2793,7 @@ class CameraStreamBuilder {
     }
     const managerStream = this.dependencies.streamManager.getStream();
     if (!isRecording && managerStream && managerStream !== this.dependencies.getOriginalCameraStream()) {
-      stopStreamTracks(managerStream);
+      stopStreamTracks2(managerStream);
       this.dependencies.streamManager.setMediaStream(null);
     }
     if (isRecording) {
@@ -2639,7 +3121,7 @@ class SourceSwitchManager {
       callbacks: this.callbacks,
       streamManager: this.streamManager,
       combineScreenShareWithOriginalAudio: (screenVideoTrack) => this.combineScreenShareWithOriginalAudio(screenVideoTrack),
-      stopStreamTracks: (stream) => stopStreamTracks(stream),
+      stopStreamTracks: (stream) => stopStreamTracks2(stream),
       stopStreamVideoTracks: (stream) => stopStreamVideoTracks(stream),
       getCurrentSourceType: () => this.currentSourceType,
       setCurrentSourceType: (sourceType) => {
@@ -3909,7 +4391,7 @@ class CameraStreamManager {
 // package.json
 var package_default = {
   name: "@vidtreo/recorder",
-  version: "1.3.4",
+  version: "1.4.0",
   type: "module",
   description: "Vidtreo SDK for browser-based video recording and transcoding. Features include camera/screen recording, real-time MP4 transcoding, audio level analysis, mute/pause controls, source switching, device selection, and automatic backend uploads. Similar to Ziggeo and Addpipe, Vidtreo provides enterprise-grade video processing capabilities for web applications.",
   main: "./dist/index.js",
@@ -18258,6 +18740,7 @@ export {
   extractVideoDuration,
   extractLastFrame,
   extractErrorMessage,
+  createPermissionFlowOrchestratorDependencies,
   checkRecorderSupport,
   calculateVideoBitrate,
   calculateTotalBitrateFromMbPerMinute,
@@ -18271,6 +18754,7 @@ export {
   RecordingManager,
   RecorderController,
   QuotaManager,
+  PermissionFlowOrchestrator,
   PRESET_SIZE_LIMIT_MB_PER_MINUTE,
   NativeCameraHandler,
   FORMAT_DEFAULT_CODECS,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vidtreo/recorder",
-  "version": "1.3.4",
+  "version": "1.4.0",
   "type": "module",
   "description": "Vidtreo SDK for browser-based video recording and transcoding. Features include camera/screen recording, real-time MP4 transcoding, audio level analysis, mute/pause controls, source switching, device selection, and automatic backend uploads. Similar to Ziggeo and Addpipe, Vidtreo provides enterprise-grade video processing capabilities for web applications.",
   "main": "./dist/index.js",