Q:

If the async attribute is used to load non blocking 

Without the async or defer attribute the loading of JavaScript blocks the browser and any scripts loaded in the <head> are always loaded before the dom is loaded and body.readyState == 'loaded'. 
My question is specific to the use of the async attribute to allow a non blocking <script> in the <head>.  Some browsers can then start rendering the DOM while the javascript is still being retrieved.  I have found situations where at least Chrome definitely does render prior to the async JavaScript load in the <head> completing. 
Are these async loaded scripts and as a result the <head> guaranteed to be loaded before body.readyState == 'loaded' and traditional dom ready javascript is executed? 
I can confirm in waterfalls using Chrome, Firefox and IE11 that in practice in my test cases the onload processing always occurred after all the JavaScript had loaded, and immediately afterwards in some cases, giving the impression that in current browsers the async does not break the assumption that JavaScript has loaded before the body state changes. 
This however is anecdotal evidence and what I am looking for is a standard reference or reference/reasoning regarding the browser architecture that gives comfort that for a large javascript loaded in the <head> with async and a small <body> I will not find situations where the <body> completes loading and has a state of loaded before the <head> due to the use of non blocking async script loads. 

A:

readyState is actually implemented by document and as a result the <body> only has a readyState of 'loaded' when the complete document (Both the <head> and the <body>) have loaded.  Using the async attribute to load JavaScript in the <head> is safe in that all JavaScript will have loaded before the <body>, or actually anything, appears to be 'loaded'. 
When the <body> is asked for its readyState the request is being responded to by its parentNode which is the document.  Document implements readyState. 
The code initiating the on-load processing was:
var body = document.getElementsByTagName('BODY')[0];
if (body && body.readyState == 'loaded')
    { ... }

So yes, it is guaranteed that even async JavaScript files will be fully loaded before any on-load processing that tests a <body>'s readyState receives 'loaded'. 
It however, would be far clearer, just to ask the document for its readyState. 
Many thanks to @Bergi for pointing out, in a comment to the question, that it is actually document that is implementing readyState and for locating the documentation:
https://developer.mozilla.org/en-US/docs/Web/API/Document/readyState

