This is simple example without async and await with manual timeout counter implementation.

// Function, which accepts time out value in seconds (counting from 0)
const myFunct = (timeOutSec) => {
  // Get current time
  const ct = Date.now();
  // Set counter for example function logic
  let secCounter = ct - 1000;
  // Start eternal loop
  while(true) {
    // Get in loop time
    const ilt = Date.now();
    
    // Compare current time and in loop time
    // If current time + timeout sec < in loop time, break it
    if(ct + timeOutSec * 1000 < ilt) break;
    
    // Here do main function logic in loop
    // for example, console log each second
    if(ilt - secCounter > 1000) {
      console.log(`time ${ilt}`);
      secCounter += 1000;
    }
  }
}

// Test running function for 4 sec
myFunct(3);
console.log(`Completed at ${Date.now()}`);

Or similar with promises

// Async timeout function
const timeout = (ms) => new Promise(resolve => setTimeout(resolve, ms));

// Promise function which accepts timout value in seconds (counting from 0)
const myPFunct = (timeOutSec) => {
  return new Promise(async (resolve, reject) => {
    // Current time
    const ct = Date.now();
    // start eternal loop
    while(true) {
      // In loop time
      const ilt = Date.now();
      
      // Check in-loop time, current time and timeout
      if(ct + timeOutSec * 1000 < ilt) {
        resolve(`completed at ${ilt}`);
        break;
      }
      
      // Do something
      console.log(`time: ${ilt}`);
      // Wait 1 sec
      await timeout(1000);
    }
  });
}

// Test async function
const test = async () => {
  // Run myPFunct for 4 sec
  const result = await myPFunct(3);
  console.log(`Test function result: ${result}`);
}

// Run test function
test();

Thanks to @tarkh solution. If someone try to do an horizontal slider like me, or something with loop, I have to modify the code (because with the source solution, the resolve goes up to all the async methods).

Here is the final solution (I have to name the loop to break it and resolve the current promise - there are maybe simplest solution ?) :

    window.onload = function () {
        scrollThumbnails();
    }

    const scrollThumbnails = async () => {
        const thumbnails = document.querySelectorAll('.thumbnail');

        for (thumbnail of thumbnails) {
            thumbnail.classList.add('active');
            await verticalSliderWithTimeout(thumbnail, 45000);
            thumbnail.classList.remove('active');
        }

        scrollThumbnails();
    }

    const timeout = (ms) => new Promise(resolve => setTimeout(resolve, ms));

    const verticalSliderWithTimeout = (element, timeoutDelay) => {
        return new Promise(async (resolve, reject) => {
            const currentTime = Date.now();

            const slider = element.querySelector('.vertical-carrousel');
            const max = slider.offsetHeight - slider.parentElement.offsetHeight;
            var toTop = 0;
            slider.style.top = toTop + 'px';

            sliderLoop: while (toTop > -max) {
                const inLoopTime = Date.now();

                if(currentTime + timeoutDelay < inLoopTime) {
                    break sliderLoop;
                }

            
                await timeout(50);
                toTop--;
                slider.style.top = toTop + 'px';
            }

            resolve();
        });
    }

HTML code if needed (Handlebars) :

<div class="thumbnail">
    <div class="photos-slider">
        <div id="vertical-carrousel" class="vertical-carrousel">
            {{#each this.photos}}
            <img src="/image/{{../this.agency.product_type}}/{{../this.agency.id}}/{{../this.reference}}/{{urlencode this}}"
                onerror="{{this}}" />
            {{/each}}
        </div>
    </div>
</div>