Plan-execute on async vs defer on <script>

async and defer both let an external script download while the HTML parser keeps going. They differ in when the script runs: async runs as soon as the file arrives, and defer waits until parsing has finished. I read MDN and the HTML Standard's scripting section. I could not open the Standard's parsing page, because every URL I tried there returned a 404. So the DOMContentLoaded timing comes from MDN only.

Plain classic <script src> (no attributes). The script is fetched and run immediately, and the parser waits for it. The Standard says "If neither attribute is present, then the script is fetched and evaluated immediately, blocking parsing until these are both complete." (https://html.spec.whatwg.org/multipage/scripting.html) MDN agrees (https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/script).

defer (external classic scripts).

• Parsing: The script is fetched in parallel with parsing and evaluated "when the page has finished parsing" (https://html.spec.whatwg.org/multipage/scripting.html).
• DOMContentLoaded: MDN says defer scripts run "after the document has been parsed, but before firing DOMContentLoaded event" and that they hold that event back until they have loaded and finished running (https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/script). The DOMContentLoaded page says the event fires after the deferred scripts and module scripts have executed (https://developer.mozilla.org/en-US/docs/Web/API/Document/DOMContentLoaded_event).
• Order: Deferred scripts run in document order. MDN states this directly. The Standard's processing model matches: parser-inserted deferred scripts are appended to a "list of scripts that will execute when the document has finished parsing", and a list is ordered (https://html.spec.whatwg.org/multipage/scripting.html).

async (external classic scripts).

• Parsing: The script is fetched in parallel with parsing and "evaluated as soon as it is available (potentially before parsing completes)". Parsing pauses only while the script runs.
• Order: There is no ordering guarantee. The Standard puts async scripts into a set ("set of scripts that will execute as soon as possible") and runs each one when its own result is ready. Whichever file arrives first runs first. This is my reading of the processing model, not a sentence the spec states outright.
• DOMContentLoaded: There is no fixed relationship. MDN says DOMContentLoaded doesn't wait for "async scripts to finish loading". An async script may therefore run before the event or after it, and MDN notes it can run after DOMContentLoaded has already fired. MDN says document.readyState becomes "complete" after async scripts execute.

Both attributes set.

• MDN says defer plus async makes the element "act as if only the async attribute is specified".
• The Standard explains the reason. Authors may set both so that old browsers that only know defer fall back to deferred behavior instead of blocking.
• The two statements are consistent. I read them as the same rule from two angles, not a conflict.

Inline scripts.

• Classic inline scripts: async and defer do nothing. MDN's wording is that the attribute "must not be used if the src attribute is absent… in this case it would have no effect". The Standard's algorithm agrees: its async, in-order and deferred branches apply only to classic scripts with src. A classic inline script otherwise executes immediately (https://html.spec.whatwg.org/multipage/scripting.html).
• Inline module scripts: These behave differently, as described in the next section.

type="module".

• Default timing: Module scripts defer by default. The Standard says the module and its dependencies are fetched in parallel and "evaluated when the page has finished parsing", and "The defer attribute has no effect on module scripts". MDN says the same.
• With async: The module and all its dependencies are fetched in parallel and the module runs as soon as it is available, possibly before parsing completes. This is the same behavior as async classic scripts.
• DOMContentLoaded: MDN lists <script type="module"> among the deferred scripts that DOMContentLoaded waits for.
• Inline modules: The Standard's algorithm treats a module script whether or not it has src. It deferred-queues inline modules, and async applies to them too. The async warning on MDN is limited to classic scripts. The Standard also queues a task even for an inline module, so it never runs synchronously.

Dynamically inserted scripts. A script created by document.createElement has a "force async" flag that starts out true. So it acts as async unless you set script.async = false. The Standard's algorithm then runs non-async, non-parser-inserted external scripts in insertion order, via the "list of scripts that will execute in order as soon as possible". MDN adds that dynamically injected scripts can run after DOMContentLoaded has already fired.

Where the sources differ or are thin. The main gap is that I did not read the Standard's parsing page, so the DOMContentLoaded relationship rests on MDN. MDN also words the inline-script case as an async and defer "warning", while the Standard encodes it only through the algorithm. Neither source contradicts the other on substance.

{"evidence": [
{"claim": "A classic external script with neither async nor defer is fetched and run immediately, blocking the parser.", "quote": "If neither attribute is present, then the script is fetched and evaluated immediately, blocking parsing until these are both complete.", "url": "https://html.spec.whatwg.org/multipage/scripting.html"},
{"claim": "Classic async scripts are fetched in parallel with parsing and run as soon as available, possibly before parsing completes.", "quote": "For external classic scripts, if the async attribute is present, then the classic script will be fetched in parallel to parsing and evaluated as soon as it is available (potentially before parsing completes).", "url": "https://html.spec.whatwg.org/multipage/scripting.html"},
{"claim": "Classic defer scripts are fetched in parallel and evaluated once parsing has finished.", "quote": "If the async attribute is not present but the defer attribute is present, then the classic script will be fetched in parallel and evaluated when the page has finished parsing.", "url": "https://html.spec.whatwg.org/multipage/scripting.html"},
{"claim": "Module scripts are deferred by default, with async making them run as soon as available; defer has no effect on them.", "quote": "Otherwise, the module script and its dependencies will be fetched in parallel to parsing and evaluated when the page has finished parsing. (The defer attribute has no effect on module scripts.)", "url": "https://html.spec.whatwg.org/multipage/scripting.html"},
{"claim": "Deferred scripts run before DOMContentLoaded and hold that event back until they finish.", "quote": "Scripts with the defer attribute will prevent the DOMContentLoaded event from firing until the script has loaded and finished evaluating.", "url": "https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/script"},
{"claim": "Deferred scripts execute in document order.", "quote": "Scripts with the defer attribute will execute in the order in which they appear in the document.", "url": "https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/script"},
{"claim": "DOMContentLoaded waits for defer and module scripts but not async scripts.", "quote": "It doesn't wait for other things like images, subframes, and async scripts to finish loading.", "url": "https://developer.mozilla.org/en-US/docs/Web/API/Document/DOMContentLoaded_event"},
{"claim": "DOMContentLoaded fires after defer/module scripts but before async scripts; readyState becomes complete after async scripts.", "quote": "DOMContentLoaded is fired after the execution of these scripts, but before the execution of scripts with async.", "url": "https://developer.mozilla.org/en-US/docs/Web/API/Document/DOMContentLoaded_event"},
{"claim": "async and defer have no effect on classic inline scripts.", "quote": "This attribute must not be used if the src attribute is absent (i.e., for inline scripts), in this case it would have no effect.", "url": "https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/script"},
{"claim": "If both async and defer are present, the element acts as async only.", "quote": "If the attribute is specified with the defer attribute, the element will act as if only the async attribute is specified.", "url": "https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/script"},
{"claim": "Setting defer alongside async exists as a fallback for legacy browsers that only support defer.", "quote": "The defer attribute may be specified even if the async attribute is specified, to cause legacy web browsers that only support defer (and not async) to fall back to the defer behavior instead of the blocking behavior that is the default.", "url": "https://html.spec.whatwg.org/multipage/scripting.html"},
{"claim": "Module scripts with async are fetched along with all dependencies in parallel and run as soon as available.", "quote": "For module scripts, if the async attribute is present then the scripts and all their dependencies will be fetched in parallel to parsing and evaluated as soon as they are available.", "url": "https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/script"},
{"claim": "Dynamically inserted (non-parser-inserted) scripts have force async true by default, so they behave as async.", "quote": "A script element has a force async boolean, initially true.", "url": "https://html.spec.whatwg.org/multipage/scripting.html"},
{"claim": "Async scripts are tracked in an unordered set, and parser-inserted deferred scripts in a list that runs after parsing.", "quote": "Each Document has a set of scripts that will execute as soon as possible, which is a set of script elements, initially empty.", "url": "https://html.spec.whatwg.org/multipage/scripting.html"},
{"claim": "Async scripts can run after DOMContentLoaded has already fired.", "quote": "If it's included via <script async>, or it's dynamically injected, then by the time it executes, DOMContentLoaded has already fired.", "url": "https://developer.mozilla.org/en-US/docs/Web/API/Document/DOMContentLoaded_event"}
]}