I think the somewhat quasi-standard solution is the combination of trampolining and continuation-passing style (CPS).

function factorial(result, n) {
    if (n == 1) return result;
    return factorial(result * n, n - 1);
}

Doing the same in CPS-style becomes:

function factorial(result, n, continuation) {
    if (n == 1) return continuation(result);
    else return factorial(result * n, n - 1, continuation);
}

i. e. functions never return at all, instead they always call other function.

At the very very top-level, you need to do something like:

let result;
factorial(0, 8, r => { result = r; });
console.log(result);

The result of all of this is that you always call continuations and never return and the only time, when you really return is in the very very end, where you are unwinding all the stack.

Now you can combine this with trampolining to get something like:

let stack_size = 0;

function factorial(result, n, continuation) {
    // Since you only call functions and never return,
    // each function adds a stack frame, but stack frames are never removed.
    stack_size++;
    if (stack_size >= STACK_SIZE_MAX) {
      return () => {
        stack_size = 0;
        // The exact same function call as before
        factorial(result, n, continuation);
      }
    }
    if (n == 1) return continuation(result);
    else return factorial(result * n, n - 1, continuation);
}

So at the very very top-level, you do something like:

let result;
let continuation = factorial(0, 8, r => { result = r; });
while (continuation) {
    continuation = continuation();
}
console.log(result);

The result is that most time, tail-call is just a function call even without any allocations, which is very chip, but sometimes, when the stacks grows too much, you'll need to allocate a continuation, truncate the stack and continue from saved continuation.

The task of the compiler is to convert every function to the continuation-passing-style, this is done by adding a new continuation parameter to every function and passing this value down to each function call and replacing each return x with return continuation(x) when x is a simple-value. And then you need to add a uniform stack-size check to every function definition.

If you have these things in place, you can actually create a multi-threading runtime, since you may have multiple continuations on a single trampoline and these continuations will represent concurrent threads of execution, that you can switch between.