I'm not sure I quite understand your example. You've written [[AsyncContext]] = 'FOO' but (syntax aside) the current proposal doesn't allow just setting the context. Are you assuming something like

{
  using _ = asyncVar.setWithDisposable('FOO');
  foo();
}

or are you thinking of something else entirely?

That said, we're currently thinking about the impact of whether yield preserves context (i.e. the initialization context from the initial generator call), or whether it brings in the context from the surrounding next() caller (i.e. the dispatch context). If it uses initialization context then context is sensibly block-scoped, and using makes a lot more sense. If context might change across a yield then it's a lot less clear that using is at all viable, since the state to clean up at the end of the block scope may have changed out from under it. So if yield exposes the dispatch context, then we're back to reconsidering what an enterWith or set semantics might look like. In particular is the question of whether set in an inner/outer function body should change the value out from under an outer/inner function. I.e.

async function f() {
  g();  // n.b. not awaited
  x.set(2);
  await 1;
  console.log(y.get()); // 3 ?
}
async function g() {
  await 1;
  console.log(x.get()); // 2 ?
  y.set(3);
}

snek I'm also not fully understanding your question, but it seems similar to a discussion we had in the past:

runWithContext(1, async () => {
  console.log(getContext()) // 1
  await new Promise(resolve => runWithContext(2, resolve));
  console.log(getContext()) // ?
});

Is answering what the second getContext() call logs the same as answering your question?

Async functions capture the scope right before pausing and restore them when resuming:

• right before pausing, step 7 of await (https://tc39.es/ecma262/#await) calls PerformPromiseThen

• step 7 of PerformPromiseThen (https://tc39.es/proposal-async-context/#sec-performpromisethen) takes a snapshot of the async context

• when the promise is resolved, step 1.d of the reaction job created in NewPromiseReactionJob (https://tc39.es/proposal-async-context/#sec-newpromisereactionjob) restores the context before running the code after the await

but it still leaves the question of what happens if you write

const d1 = v.enter(1);
d1[Symbol.enter]();
const d2 = v.enter(2);
d2[Symbol.enter]();
d1[Symbol.dispose]();
d2[Symbol.dispose]();

?

Independently, I think snek's original question was how do the following two snippets work?

async function f() {
  await 1;
  console.log(v.get());
}
{
  using _ = v.enter(2);
  f();
}

and

async function f() {
  using _ = v.enter(2);
  await 1;
}
f();
console.log(v.get());

async function f() {
  using _ = v.enter(2);
  await 1;
}
f();
console.log(v.get());