This is related to #1439. Currently, the typing specs say:

Only a single type variable tuple may appear in a type parameter list:

class Array(Generic[*Ts1, *Ts2]): ... # Error

In practice, this restriction seems to only apply to type parameters specified on generic types, not generic functions/methods. mypy and pyright accepts multiple TypeVarTuples in the latter, and can even solve for them indirectly:

from collections.abc import Callable
def concat_args_and_ret[*A, *R](
 f: Callable[[*A], tuple[*R]], /
#`-> tuple[*A, *R]` is rejected, but mypy and pyright can use
#`-> tuple[*A, *tuple[*R]]` to solve `R`
) -> tuple[*A, *tuple[*R]]: ...
def f(a: int, b: str, c: bytes, /) -> tuple[float, None]: ...
reveal_type(concat_args_and_ret(f)) # tuple[int, str, bytes, float, None]

The ambiguity mentioned in the specs, x: Array[int, str, bool] # Ts1 = ???, Ts2 = ???, seems to only apply when type arguments are provided to a generic type like Array (or in C++ terminology, explicit rather than deduced). The ambiguity currently does not even seem possible with functions/methods, as they can't be subscripted. So,

1. Can we still expect multiple TypeVarTuples to be allowed for generic functions/methods (def concat_args_and_ret[*A, *R]) in the future?
2. If 1. is true, can we expect some level of support for solving items like -> tuple[*A, *R] (perhaps indirectly, like -> tuple[*A, *tuple[*R]])?