Uncaught Exception, even with Try Catch

The thing is, async/await offers a way to write a chain of promises/then (of even just callbacks) with a simple writing, as if all asynchronous operations were synchronous. But, still, under the hood, they are still asynchronous.

Just an over simplification of your example

async function connect(){
    throw "failed connect";
}

async function start(){
    await connect();
    dosomethingelse();
}

start();

It is important to understand, that this is the equivalent of

function start(){
     connect().then(function(){
         dosomethingelse();
     })
}

It is a wonderful improvement to JS, since sometimes you may have a sequence of 10 asynchronous operations to perform. So it is convenient to write them in sequence with just a plain ; separator, as if it was a simple connect(); dosomething();, when in reality is connect(continuation); end this function, continuation being that do something. But, still, it is a bunch of promises and then

So, if you add a try/catch block now

async function connect(){
    throw "failed connect";
}

async function start(){
    try{
        await connect();
    }catch(e){
        console.log("catch", e);
    }
}

Well, it is still in reality

    try{
        connect().then(continuation)
    }catch(e){
        ...
    }

the try englobes only the calls to asynchronous connect

So a little bit like

try{
    setTimeout(trytoconnect, 1000);
}catch(e){
}

wouldn't catch anything happening in trytoconnect, your try/catch has no reason to catch what happens in your connect (unless the error happens in the creation of the promise itself, not in its execution)

As for a solution, you can find one here

function okOrError(promise){
    return promise.then((arg) => {return {ok: arg}}).catch((arg) => {return {error: arg}});
}

async function connect(){
    if(Math.random()<0.5) return "success";
    throw "failed connect";
}

async function start(){
    let x=await okOrError(connect())
    if(x.error) throw x.error;
    console.log(x.ok);
}


start();

Let me say this... You're not doing it right...

async functions always will return a promise. Then you must use .then() and/or .catch() on the async function call, even if you await for the fulfillment. try/catch will never get the error because they run outside of this block context.

Here's a working example:

// Let's say you have an async function...
async function doSomething ()
{
  // And it do something that causes an error.
  window.inexistentMethod();
}

// If you want to catch the error...
async function doTest()
{
  const value = await doSomething()
    .then
    (
      result =>
      {
        console.log('Result:', result)
        
        // What will go into `value`.
        return result ?? true;
      }
    )
    .catch
    (
      error =>
      {
        console.warn('Error:', error.message);
        
        // What will go into `value`.
        return false;
      }
    );
  
  console.log('Final value:', value);
}

// TEST THE ERROR:
doTest();

NOTE that .then() and .catch() both return a different promise than the one they're called upon. So, in the above example, first is parsed doSomething() that returns a promise, then .then() that returns another promise that fulfills if there's no error in doSomething() and .then(), then .catch() that returns another promise that fulfills if doSomething() and .then() produces no error or call the callback on .catch if there's any error and then returns what the callback returned. Only then, the await will retrieve the promise return value.

There are those two other answers I gave to other questions that shows how to handle unhandled errors that may come from setTimeout, events and other async sources:

https://stackoverflow.com/a/79189671/2804429

https://stackoverflow.com/a/79184566/2804429