But I think that's the problem - it can't be limited to scoped using because of composability: you need to be able to write

function enterSpan(id) {
  const span = new Span({id, parent: currentSpan.get()});
  span[Symbol.dispose] = currentSpan.enter(span)[Symbol.dispose];
  log('new span', currentSpan.get());
  return span;
}

That function gives no syntactic indication that it needs any extra transpilation... in fact, thinking about it further, it violates the principle that functions you call shouldn't be able to change your context.

For using with Symbol.enter/Symbol.dispose, I don't think we need to enforce it syntactically. Does this provide enough guarantees, or are there still ways to mess up the context and not get an explicit error about it?

function enterWith(variable, value) {
  let oldContext, updatedContext

  return {
    [Symbol.enter]() {
      if (oldContext) throw new Error("Cannot enter twice");
      oldContext = AsyncContextSnapshot();
      updatedContext = { ...oldContext, [variable]: value };

      AsyncContextSwap(updatedContext);
    },
    [Symbol.dispose]() {
      if (!oldContext) throw new Error("Cannot dispose before entering");

      const current = AsyncContextSnapshot();
      if (current !== updatedContext) {
        throw new Error("Cannot dispose, as it's not the current context");
      }

      AsyncContextSwap(oldContext);
    }
  }
}

AsyncContext.Variable.prototype.run = function (value, callback) {
  const oldContext = AsyncContextSnapshot();
  const updatedContext = { ...oldContext, [this]: value };

  AsyncContextSwap(updatedContext);
  try {
    return callback();
  } finally {
    const current = AsyncContextSnapshot();
    AsyncContextSwap(oldContext);

    if (current !== updatedContext) {
      throw new Error(".run ended before that its context was restored");
    }
  }
}

{
  // context: root

  x1[Symbol.enter]();
  // context: x1

  x2[Symbol.enter]();
  // context: x2

  x1[Symbol.dispose](); // error: "Cannot dispose, as it's not the current context"
}


{
  // context: root

  x1[Symbol.enter]();
  // context: x1

  myVar.run("foo", () => {
    // context: foo

    x1[Symbol.dispose](); // error: "Cannot dispose, as it's not the current context"
  })
}

{
  // context: root

  myVar.run("foo", () => {
    // context: foo

    x1[Symbol.enter]();
    // context: x1
  }); // closes the foo context, then error: ".run ended before that its context was restored"
}

And you can still leak a little bit, but:

• .run is a hard boundary you cannot leak accross
• if you leak, basically as soon as some other context ends you'll get an error

And then the idea is that

async function f() {
  using _ = enterWith(v, 2);
  await 1;
}
{
  using _ = enterWith(v, 1);
  f();
}

would work because the suspension would restore the entry context? But if f were an ordinary function that leaked then the dispose after f() would fail.

I don't think an analogous approach would work for yield.nextCallerContext - you'd be forced to at least go back to transpiling all generators (to wrap with a function that set the nextCallerContext in some reasonable way)

Scratch that - you need to transpile the keyword anyway, and if you do so, you only need to wrap that particular generator.