function outer(signal) {
  const myController = new AbortController();
  const combinedSignal = AbortSignal.any([signal, myController.signal]);
  const promise = inner(combinedSignal);
  ...
  // we've progressed to a point where cancellation shouldn't occur, 
  // but we can't signal that to `inner`
  myController.dispose(); 
}

But if any returns a controller, then I can exert this level of control:

function outer(signal) {
  const combinedController = AbortController.any([signal]);
  const promise = inner(combinedController.signal);
  ...
  // we've progressed to a point where cancellation shouldn't occur
  combinedController.dispose(); 
}

Lets assume for a moment that an AbortController has a dispose() method. In example one, you have an outer abort controller A (and signal a) and create an inner abort controller B (and signal b). Calling AbortSignal.any([a, b]) produces a signal ab with the following semantics:

• Aborting A aborts a and ab
• Aborting B aborts b and ab
• Disposing A disposes a but not ab, because ab could still be aborted by B.
• Disposing B disposes b but not ab, because ab could still be aborted by A.

My algorithm reaches a point of no return where I no longer want inner to be cancelable, at which point any subscriptions added by inner can be collected. Unfortunately, AbortSignal.any does not give me this capability since neither A nor B dominates the token ab.

In the new CancellationTokenSource(linkedTokens?) approach, you produce a new source/controller that dominates the cancellation interaction with inner. You have the same outer controller A (and signal a), and you wrap it with an inner controller B(a) (with signal b(a)). Signal b(a) has the following semantics:

• Aborting A aborts a and b(a) so long as a link still remains between a and B(a).
• Aborting B(a) aborts b(a).
• Disposing A disposes a but not b(a), because b(a) could still be aborted by B(a). However, the link between B(a) and a can be removed and the subscription can be GC'd.
• Disposing B(a) disposes b(a), but not a. Any subscriptions to b(a) can be GC'd.