It would be nice if we could find a way to support something like

import Decimal from 'std:decimal/v1'

As in, a versioned standard library that doesn't necessarily communicate native implementation speeds to all users. With something like that, I at least would find it much easier to positively support e.g. Decimal.

nicolo-ribaudo: I missed the timing for the TC39 meeting earlier today. I was looking at your indirect eval proposal and one thing that might be great is the parity with shadowRealms functionality on the import and evaluate methods. IIRC they follow their respective realm origin rather than the script where they are called. You can't really make the new instantiated realm aware of the incubating realm calling it. Your change makes import() a bit similar where it respects the origin.

For clarity, all I'm saying is a mean for feature parity, because you can't really use the indirect eval from another shadowrealm other than a wrapped function or evalute/import methods.

danielrosenwasser: I think it would be very useful if TS could enforce immediate callbacks are actually called immediately. It would make them even more useful. Specifically TS errors on the following cases:

• User passes immediate function to a function as a parameter where that callback param is not marked as immediate:

function x(foo: immediate () => void) {
  y(foo); // error here, immediate function escapes from immediate body
}

function y(bar: () => void) {
  bar();
}

• An immediate callback is captured by non immediate closure.

function x(foo: immediate () => void) {
  delay(100).then(() => foo()); // error because `immediate` callback is called from a `deferred` callback
}

• An immediate callback is assigned to a variable outside the "immediate" body:

let cb: () => void;

function x(foo: immediate () => void) {
  cb = foo; // error because `immediate` callback is assigned to a variable outside of the immediate scope
}

We should come to an agreement of what "immediate" means. Consider the following cases of a function Foo that takes an immediate callback f:
A. Foo returns without doing anything.
B. Foo might call f immediately.
C. Foo always calls f immediately.
D. Foo might save f to be called later.
E. Foo might call f immediately and might save f to call later.
F. Foo always calls f immediately and might save f to call later.
G. Foo always saves f to call later.
H. Foo might call f immediately and always saves f to call later.
I. Foo always calls f immediately and always saves f to call later.

Which ones of these would be properly annotated with the "immediate" keyword?
Bonus question: What if Foo is an async function?