Plan-execute-verify on async vs defer on <script>

I've finished the research. Some planned sources returned 404 (the spec's parsing.html page and javascript.info), so the answer relies on the WHATWG scripting section, MDN and web.dev. Where they differ, I treat the WHATWG spec as normative.

Short answer

With no attributes, a classic script stops the HTML parser until it has downloaded and run. defer downloads in parallel and runs the scripts in document order after parsing ends, before DOMContentLoaded. async downloads in parallel and runs each script as soon as it arrives, in no fixed order, possibly mid-parse. Both are ignored on inline classic scripts. Module scripts are deferred by default, defer does nothing to them, and async works on them even when inline.

No attributes (the baseline)

For a classic script with src and neither attribute, "the script is fetched and evaluated immediately, blocking parsing until these are both complete" (https://html.spec.whatwg.org/multipage/scripting.html). MDN adds that inline scripts without type="module" behave the same way: they run immediately, before parsing continues (https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/script).

defer (classic scripts with src)

• Parsing: The script downloads in parallel with parsing and runs "when the page has finished parsing" (https://html.spec.whatwg.org/multipage/scripting.html). It doesn't block the parser.
• DOMContentLoaded: It runs after the document is parsed but before DOMContentLoaded fires. Deferred scripts hold back DOMContentLoaded until they have loaded and run (https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/script). document.readyState is already "interactive" while they run (https://developer.mozilla.org/en-US/docs/Web/API/Document/DOMContentLoaded_event).
• Order: Deferred scripts run in the order they appear in the document (MDN, same page). In the spec, a parser-inserted deferred script is added to the document's "list of scripts that will execute when the document has finished parsing", and the parser runs that list (https://html.spec.whatwg.org/multipage/scripting.html).

async (classic scripts with src)

• Parsing: The script downloads in parallel and runs "as soon as it is available (potentially before parsing completes)" (https://html.spec.whatwg.org/multipage/scripting.html). The download doesn't block parsing, but running it can: an async script "can interrupt DOM building" if it arrives mid-parse (https://web.dev/articles/efficiently-load-third-party-javascript).
• Order: Each async script goes into a set (not a list) of "scripts that will execute as soon as possible" and runs when its own fetch completes (spec, same page). MDN puts it plainly: "You get no guarantee that scripts will run in any specific order." In practice, whichever finishes downloading first runs first.

• DOMContentLoaded: DOMContentLoaded does not wait for async scripts (https://developer.mozilla.org/en-US/docs/Web/API/Document/DOMContentLoaded_event). An async script may run before or after it.

  • Where sources disagree: A note on that same MDN page says DOMContentLoaded fires "before the execution of scripts with async". That conflicts with the spec, which says async scripts may run before parsing finishes, and therefore before DOMContentLoaded. I follow the spec. Read MDN's note as describing a common case, not a rule.
• Both attributes together: async wins (MDN). The spec says adding defer alongside async exists only so that old browsers without async support fall back to deferring instead of blocking.

Inline classic scripts

Both attributes do nothing when there is no src. MDN warns about this for each attribute. In the spec's processing steps, the async and defer branches apply only "If el's type is \"classic\" and el has a src attribute, or el's type is \"module\"". Inline classic scripts take the other path and normally run immediately, while the parser waits (https://html.spec.whatwg.org/multipage/scripting.html).

type="module"

• Default: Module scripts behave as if deferred. The module and its imports download in parallel and run when parsing finishes. "The defer attribute has no effect on module scripts" (https://html.spec.whatwg.org/multipage/scripting.html). MDN agrees (https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Modules). Like deferred classic scripts, they run before DOMContentLoaded.
• With async: The module and all its imports are fetched in parallel and the module runs as soon as everything is ready, possibly mid-parse, in no fixed order.
• Inline modules: The type check covers all module scripts, not just ones with src, so async applies to inline modules too. Even an inline module with no imports never runs synchronously, because the spec queues a task first.

Summary

{"evidence": [
{"claim": "A classic external script with neither attribute blocks parsing while it is fetched and run.", "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": "A defer classic script downloads in parallel and runs after parsing finishes.", "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": "Deferred scripts run after parsing and before DOMContentLoaded, and DOMContentLoaded waits for them.", "quote": "This Boolean attribute is set to indicate to a browser that the script is meant to be executed after the document has been parsed, but before firing DOMContentLoaded event.", "url": "https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/script"},
{"claim": "Deferred scripts run 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": "An async classic script downloads in parallel and runs as soon as it is available, possibly before parsing ends.", "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": "An async script that arrives mid-parse interrupts parsing while it runs.", "quote": "It also means they can interrupt DOM building if they finish downloading while the parser is still at work.", "url": "https://web.dev/articles/efficiently-load-third-party-javascript"},
{"claim": "Async scripts have no guaranteed execution order.", "quote": "You get no guarantee that scripts will run in any specific order.", "url": "https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/script"},
{"claim": "DOMContentLoaded does not wait for 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": "MDN's DOMContentLoaded page says async scripts run after DOMContentLoaded, which conflicts with the spec's statement that they may run before parsing completes.", "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": "If both attributes are present, async takes precedence; defer exists only as a fallback for old browsers.", "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": "async has no effect on inline classic scripts.", "quote": "This attribute must not be used if the src attribute is absent (i.e., for inline scripts) for classic scripts, in this case it would have no effect.", "url": "https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/script"},
{"claim": "The spec's async and defer handling applies only to classic scripts with src or to any module script; inline classic scripts take a different path.", "quote": "If el's type is \"classic\" and el has a src attribute, or el's type is \"module\":", "url": "https://html.spec.whatwg.org/multipage/scripting.html"},
{"claim": "Module scripts without async are deferred by default.", "quote": "Otherwise, the module script and its dependencies will be fetched in parallel to parsing and evaluated when the page has finished parsing.", "url": "https://html.spec.whatwg.org/multipage/scripting.html"},
{"claim": "defer has no effect on module scripts because they are deferred automatically.", "quote": "The defer attribute has no effect on module scripts — they defer by default.", "url": "https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/script"},
{"claim": "An async module script runs as soon as it and its imports are fetched.", "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": "Even an inline module script never runs synchronously during parsing.", "quote": "Queueing a task here means that, even if the inline module script has no dependencies or synchronously results in a parse error, we won't proceed to execute the script element synchronously.", "url": "https://html.spec.whatwg.org/multipage/scripting.html"}
]}