I don't think you need the .catch here. Doing return loadDataFile(.. should be enough to reject the promise if loadDataFile fails/rejects.

Also, I think just using top-level-await might be more clear here:

var module = await loadModule();
await loadDataFile(module):
module._test_fun();

I will apply that later, I have changed some logic to be more universal and to allow catching thrown error, take a look please

I wonder, if I shouldn't add some throw error method to clear run dependencies - or maybe generate separate stub that allows to do that if we want ourselfs in external catch block

I wonder, if I shouldn't add some throw error method to clear run dependencies - or maybe generate separate stub that allows to do that if we want ourselfs in external catch block

It could be other PR tho, I have just observed anoying behaviour that when it fails, main module constantly spams run dependencies message, being able to clean those to graceful escape error would be nice

I'm not sure that removing the run dependency is the way to fix that.. since that would result in the module running. If a dependency fails we want to block the running forever I think.. not just ignore it. But I think the existing code might not do that :(

I'm not sure that removing the run dependency is the way to fix that.. since that would result in the module running. If a dependency fails we want to block the running forever I think.. not just ignore it. But I think the existing code might not do that :(

It looks like there is no current error handling here, for this fetch. It looks like the code is trying to do a pre-fetch and maybe we can just ignore failures (like we currently do) for the pre-fetch?

In that case this block could be reverted

Huh, without this catch here in es6 mode, i can't handle error on my own, the whole js crashes because of 'unhandled error on promise'

Fine:

async function F1() {
    throw new Error();
}

F1().catch((err)=>console.log(err))

Unhandled error in promise:

async function F1() {
    async function F2(){
    throw new Error();
    }
    F2();
}

F1().catch((err)=>console.log(err))

But isn't that just the existing behaviour? There is not catch mechanism for this particular fetch and so errors here will always go the to the global error handlers. I think that is the current/expected behaviour. We could change that perhaps?

Given that there is not really any way to recover from such errors why not just let the global error handler handle these errors? Or the global unhandledRejection handler.

I meant that when the throw is two or more level deep I cant catch the error even with top level try catch block which is an issue - most likely es6 mode will be used together with some frontend and we don't want to crash whole JS but rather give some information and maybe possibility to retry

And inside webworker we can't access window context to get access to unhandledrejection handler

You can handle unhandled rejections using the worker global scope:

    // worker.js
    self.addEventListener('unhandledrejection', (event) => {
        console.error('Unhandled Promise Rejection in Worker:', event.reason);
    });

But I understand that it would be nice to correctly reject the promise here, so this part lgtm.

We can refactor later perhaps.

Sure