const controller = new AbortController();
scheduler.postTask(async () => {
  try {
    // this "inherits" the signal set by postTask, and if it
    // gets aborted before the task is scheduled, the promise rejects
    await scheduler.yield();
  } catch(err) {
    console.log("Signal was aborted!");
  }
}, {signal: controller.signal})

So this is equivalent to doing the following with AsyncContext?

globalThis.scheduler = new class Scheduler {
  #signals = new AsyncContext.Variable();

  postTask(fn, { signal }) {
    this.#signals.run(signal, fn);
  }

  async yield() {
    const signal = this.#signals.get();
    while (shouldWaitABitMore()) {
      await yieldToTheEventLopo();
      if (signal.aborted) throw new Error("Abort");
    }
  }
};

And I see the principle of avoiding observable global mutable state as an ideological purity concern, way below the use cases authors might have.

I think this attitude from web platform people is part of the reason that so much of the web is such a painful experience. it's not an ideological purity concern. it's a reasoning about code concern: the point is that it makes it easier to avoid bugs, which is directly to the benefit of users.