diff --git a/.changeset/async-attr-method-shorthand.md b/.changeset/async-attr-method-shorthand.md
new file mode 100644
index 00000000..5518e067
--- /dev/null
+++ b/.changeset/async-attr-method-shorthand.md
@@ -0,0 +1,5 @@
+---
+"htmljs-parser": minor
+---
+
+Support an `async` keyword before shorthand methods, eg `<button async onClick() {}>` and the default attribute form `<foo async (event) {}>`. `onAttrMethod` reports these with `async: true` and a range starting at the keyword. A shorthand method can no longer be named `async`, but an `async` that is not followed by a shorthand method is still an ordinary attribute, so `<script async src="x">` is unchanged.
diff --git a/agent-feedback/bugs.md b/agent-feedback/bugs.md
index 2b85c2ec..ec5c66f3 100644
--- a/agent-feedback/bugs.md
+++ b/agent-feedback/bugs.md
@@ -7,3 +7,11 @@ Out-of-scope defects noticed while working on something else. Format and rules:
 `src/states/PARSED_TEXT_CONTENT.ts` › `PARSED_TEXT_CONTENT` | 2026-07-30 | impact:med | effort:low
 
 Inside a `TagType.text` body the only backslash handling is `STATE.checkForPlaceholder`, which declines unless the run of backslashes leads to `${`, so in `PARSED_TEXT_CONTENT.parse` a `\` falls through to the eager text run and the `"`/`'` after it still enters `STATE.PARSED_STRING`; `src/states/PARSED_STRING.ts` › `PARSED_STRING` has the mirror hole, where the quote of `\"` matches `str.quoteCharCode` and closes the string. An odd number of escaped quotes therefore runs to EOF and `PARSED_STRING.parse` emits `INVALID_TEMPLATE_STRING` "EOF reached while parsing string expression" — marko, which maps `<style>`/`<script>` to `TagType.text`, surfaces it as a code frame on the line _after_ the tag. Escaped quotes are legal in CSS selectors and `content:` strings, so `<style>.a\" { color: red }</style>` and `content: 'it\'s'` are both unparseable today; `src/__tests__/fixtures/parsed-text-style-tag` only passes because its escaped quotes happen to come in pairs, and `\2014` parses fine, so the defect is quote-specific rather than backslash-general. The fix is symmetric in the two files: when `checkForPlaceholder` declines a `CODE.BACK_SLASH` and the next char is a quote (the active `quoteCharCode` in `PARSED_STRING`), consume both chars as text instead of letting the quote change state. Re-verify with `node --input-type=module -e 'import{createParser,TagType}from"./src/index.ts";const p=createParser({onError:e=>console.log("ERR",e.message),onText:r=>console.log("text",JSON.stringify(p.read(r))),onOpenTagName:()=>TagType.text});p.parse("<style>.a\\\" { color: red }</style>")'` — it prints `ERR EOF reached while parsing string expression` today and should print a single `text` range; lock it in with a new `src/__tests__/fixtures/` dir plus `pnpm test:update`.
+
+## Emit the trailing attribute name when EOF ends an HTML mode open tag
+
+`src/states/EXPRESSION.ts` › `EXPRESSION` | 2026-08-11 | impact:med | effort:med
+
+An attribute name is only emitted from `ATTRIBUTE.return`, which requires its `STATE.EXPRESSION` child to terminate, so in HTML mode a name that runs into EOF is never reported: `<div foo` emits only the `MALFORMED_OPEN_TAG` error, while `<div foo bar` emits `attrName "foo"` and drops `bar`. Concise mode is already correct — the EOF branch of `EXPRESSION.parse` calls `exitState()` when `this.isConcise`, so `div foo` does emit `attrName "foo"` — so this is the HTML-only half of that branch, where the `!attr.spread && !attr.name` case returns `emitError` instead. It matters because that is the state a document is in while an attribute is being typed, leaving `packages/language-tools` in marko-js/language-server with no name range to anchor completions or hover to.
+
+Replacing that `emitError` with `this.exitState()` (letting `ATTRIBUTE.parse`'s own EOF branch report) does fix it, but it is not a self-contained change and wants its own PR: it breaks two fixtures whose behavior a maintainer should sign off on. `src/__tests__/fixtures/eof-attr-name` (`<a><b selected`) gains `attrName "selected"` and its error text shifts from "EOF reached while parsing attribute name for the \"b\" tag" to "EOF reached while parsing attribute \"selected\" for the \"b\" tag" — an improvement. But `src/__tests__/fixtures/attr-eof-default-value` (`<div =foo`) also changes: it starts emitting `attrValue "=foo"` and its error coarsens to "EOF reached while parsing open tag", so the fix reaches value parsing and loses a specific diagnostic, not just names. Re-verify the defect with `node --input-type=module -e 'import{createParser}from"./src/index.ts";const p=createParser({onAttrName:r=>console.log("name",JSON.stringify(p.read(r))),onError:e=>console.log("ERR",e.message)});p.parse("<div foo")'` — it prints only `ERR` today and should also print `name "foo"`.
diff --git a/src/__tests__/fixtures/attr-method-shorthand-async-fallback/__snapshots__/attr-method-shorthand-async-fallback.expected.txt b/src/__tests__/fixtures/attr-method-shorthand-async-fallback/__snapshots__/attr-method-shorthand-async-fallback.expected.txt
new file mode 100644
index 00000000..2e7a3353
--- /dev/null
+++ b/src/__tests__/fixtures/attr-method-shorthand-async-fallback/__snapshots__/attr-method-shorthand-async-fallback.expected.txt
@@ -0,0 +1,118 @@
+1╭─ <script async src="x"/>
+ │  ││      │     │  ││  ╰─ openTagEnd:selfClosed "/>"
+ │  ││      │     │  │╰─ attrValue.value "\"x\""
+ │  ││      │     │  ╰─ attrValue "=\"x\""
+ │  ││      │     ╰─ attrName "src"
+ │  ││      ╰─ attrName "async"
+ │  │╰─ tagName "script"
+ ╰─ ╰─ openTagStart
+2├─ 
+3╭─ <div async/>
+ │  ││   │    ╰─ openTagEnd:selfClosed "/>"
+ │  ││   ╰─ attrName "async"
+ │  │╰─ tagName "div"
+ ╰─ ╰─ openTagStart
+4├─ 
+5╭─ <div async>hi</div>
+ │  ││   │    ││ │ │  ╰─ closeTagEnd(div)
+ │  ││   │    ││ │ ╰─ closeTagName "div"
+ │  ││   │    ││ ╰─ closeTagStart "</"
+ │  ││   │    │╰─ text "hi"
+ │  ││   │    ╰─ openTagEnd
+ │  ││   ╰─ attrName "async"
+ │  │╰─ tagName "div"
+ ╰─ ╰─ openTagStart
+6├─ 
+7╭─ <div async=true/>
+ │  ││   │    ││   ╰─ openTagEnd:selfClosed "/>"
+ │  ││   │    │╰─ attrValue.value "true"
+ │  ││   │    ╰─ attrValue "=true"
+ │  ││   ╰─ attrName "async"
+ │  │╰─ tagName "div"
+ ╰─ ╰─ openTagStart
+8├─ 
+9╭─ <div async foo bar/>
+ │  ││   │     │   │  ╰─ openTagEnd:selfClosed "/>"
+ │  ││   │     │   ╰─ attrName "bar"
+ │  ││   │     ╰─ attrName "foo"
+ │  ││   ╰─ attrName "async"
+ │  │╰─ tagName "div"
+ ╰─ ╰─ openTagStart
+10├─ 
+11╭─ <div async foo(1)/>
+  │  ││   │     │  ││ ╰─ openTagEnd:selfClosed "/>"
+  │  ││   │     │  │╰─ attrArgs.value
+  │  ││   │     │  ╰─ attrArgs "(1)"
+  │  ││   │     ╰─ attrName "foo"
+  │  ││   ╰─ attrName "async"
+  │  │╰─ tagName "div"
+  ╰─ ╰─ openTagStart
+12├─ 
+13╭─ <div async foo=1/>
+  │  ││   │     │  ││╰─ openTagEnd:selfClosed "/>"
+  │  ││   │     │  │╰─ attrValue.value
+  │  ││   │     │  ╰─ attrValue "=1"
+  │  ││   │     ╰─ attrName "foo"
+  │  ││   ╰─ attrName "async"
+  │  │╰─ tagName "div"
+  ╰─ ╰─ openTagStart
+14├─ 
+15╭─ <div async ...spread/>
+  │  ││   │     │  │     ╰─ openTagEnd:selfClosed "/>"
+  │  ││   │     │  ╰─ attrSpread.value "spread"
+  │  ││   │     ╰─ attrSpread "...spread"
+  │  ││   ╰─ attrName "async"
+  │  │╰─ tagName "div"
+  ╰─ ╰─ openTagStart
+16├─ 
+17╭─ <div async:mod onClick() {}/>
+  │  ││   │         │      ││ ││╰─ openTagEnd:selfClosed "/>"
+  │  ││   │         │      ││ │╰─ attrMethod.body.value
+  │  ││   │         │      ││ ╰─ attrMethod.body "{}"
+  │  ││   │         │      │╰─ attrMethod.params.value
+  │  ││   │         │      ├─ attrMethod.params "()"
+  │  ││   │         │      ╰─ attrMethod "() {}"
+  │  ││   │         ╰─ attrName "onClick"
+  │  ││   ╰─ attrName "async:mod"
+  │  │╰─ tagName "div"
+  ╰─ ╰─ openTagStart
+18├─ 
+19╭─ <div asyncfoo onClick() {}/>
+  │  ││   │        │      ││ ││╰─ openTagEnd:selfClosed "/>"
+  │  ││   │        │      ││ │╰─ attrMethod.body.value
+  │  ││   │        │      ││ ╰─ attrMethod.body "{}"
+  │  ││   │        │      │╰─ attrMethod.params.value
+  │  ││   │        │      ├─ attrMethod.params "()"
+  │  ││   │        │      ╰─ attrMethod "() {}"
+  │  ││   │        ╰─ attrName "onClick"
+  │  ││   ╰─ attrName "asyncfoo"
+  │  │╰─ tagName "div"
+  ╰─ ╰─ openTagStart
+20├─ 
+21╭─ <foo async(1)/>
+  │  ││   │    ││ ╰─ openTagEnd:selfClosed "/>"
+  │  ││   │    │╰─ attrArgs.value
+  │  ││   │    ╰─ attrArgs "(1)"
+  │  ││   ╰─ attrName "async"
+  │  │╰─ tagName "foo"
+  ╰─ ╰─ openTagStart
+22├─ 
+23╭─ <foo async (1)/>
+  │  ││   │     ││ ╰─ openTagEnd:selfClosed "/>"
+  │  ││   │     │╰─ attrArgs.value
+  │  ││   │     ╰─ attrArgs "(1)"
+  │  ││   ╰─ attrName "async"
+  │  │╰─ tagName "foo"
+  ╰─ ╰─ openTagStart
+24├─ 
+25╭─ <foo async<T> />
+  │  ││   │     ╰─ error(INVALID_ATTR_TYPE_PARAMS:Attribute cannot contain type parameters unless it is a shorthand method)
+  │  ││   ╰─ attrName "async"
+  │  │╰─ tagName "foo"
+  ╰─ ╰─ openTagStart
+26├─ 
+27├─ div [
+28├─   async
+29├─   onClick() {}
+30├─ ]
+31╰─ 
\ No newline at end of file
diff --git a/src/__tests__/fixtures/attr-method-shorthand-async-fallback/input.marko b/src/__tests__/fixtures/attr-method-shorthand-async-fallback/input.marko
new file mode 100644
index 00000000..e0d1b9da
--- /dev/null
+++ b/src/__tests__/fixtures/attr-method-shorthand-async-fallback/input.marko
@@ -0,0 +1,30 @@
+<script async src="x"/>
+
+<div async/>
+
+<div async>hi</div>
+
+<div async=true/>
+
+<div async foo bar/>
+
+<div async foo(1)/>
+
+<div async foo=1/>
+
+<div async ...spread/>
+
+<div async:mod onClick() {}/>
+
+<div asyncfoo onClick() {}/>
+
+<foo async(1)/>
+
+<foo async (1)/>
+
+<foo async<T> />
+
+div [
+  async
+  onClick() {}
+]
diff --git a/src/__tests__/fixtures/attr-method-shorthand-async/__snapshots__/attr-method-shorthand-async.expected.txt b/src/__tests__/fixtures/attr-method-shorthand-async/__snapshots__/attr-method-shorthand-async.expected.txt
new file mode 100644
index 00000000..8558c363
--- /dev/null
+++ b/src/__tests__/fixtures/attr-method-shorthand-async/__snapshots__/attr-method-shorthand-async.expected.txt
@@ -0,0 +1,168 @@
+1╭─ <button async onClick() {}/>
+ │  ││      │     │      ││ ││╰─ openTagEnd:selfClosed "/>"
+ │  ││      │     │      ││ │╰─ attrMethod.body.value
+ │  ││      │     │      ││ ╰─ attrMethod.body "{}"
+ │  ││      │     │      │╰─ attrMethod.params.value
+ │  ││      │     │      ╰─ attrMethod.params "()"
+ │  ││      │     ╰─ attrName "onClick"
+ │  ││      ╰─ attrMethod:async "async onClick() {}"
+ │  │╰─ tagName "button"
+ ╰─ ╰─ openTagStart
+2├─ 
+3╭─ <button async onClick(event) {
+ │  ││      │     │      ││      ╰─ attrMethod.body "{\n  await save(event);\n}"
+ │  ││      │     │      │╰─ attrMethod.params.value "event"
+ │  ││      │     │      ╰─ attrMethod.params "(event)"
+ │  ││      │     ╰─ attrName "onClick"
+ │  ││      ╰─ attrMethod:async "async onClick(event) {\n  await save(event);\n}"
+ │  │╰─ tagName "button"
+ ╰─ ╰─ openTagStart
+4╭─   await save(event);
+ ╰─ ╰─ attrMethod.body.value "\n  await save(event);\n"
+5╭─ }/>
+ ╰─  ╰─ openTagEnd:selfClosed "/>"
+6├─ 
+7╭─ <button async onClick<T>(event: T) {
+ │  ││      │     │      ││ ││         ╰─ attrMethod.body "{\n  await save(event);\n}"
+ │  ││      │     │      ││ │╰─ attrMethod.params.value "event: T"
+ │  ││      │     │      ││ ╰─ attrMethod.params "(event: T)"
+ │  ││      │     │      │╰─ attrMethod.typeParams.value
+ │  ││      │     │      ╰─ attrMethod.typeParams "<T>"
+ │  ││      │     ╰─ attrName "onClick"
+ │  ││      ╰─ attrMethod:async "async onClick<T>(event: T) {\n  await save(event);\n}"
+ │  │╰─ tagName "button"
+ ╰─ ╰─ openTagStart
+8╭─   await save(event);
+ ╰─ ╰─ attrMethod.body.value "\n  await save(event);\n"
+9╭─ }/>
+ ╰─  ╰─ openTagEnd:selfClosed "/>"
+10├─ 
+11╭─ <button
+  │  │╰─ tagName "button"
+  ╰─ ╰─ openTagStart
+12╭─   async
+  ╰─   ╰─ attrMethod:async "async\n  onClick() {}"
+13╭─   onClick() {}
+  │    │      ││ │╰─ attrMethod.body.value
+  │    │      ││ ╰─ attrMethod.body "{}"
+  │    │      │╰─ attrMethod.params.value
+  │    │      ╰─ attrMethod.params "()"
+  ╰─   ╰─ attrName "onClick"
+14╭─ />
+  ╰─ ╰─ openTagEnd:selfClosed "/>"
+15├─ 
+16╭─ button async onClick() {}
+  │  │      │     │      ││ │╰─ attrMethod.body.value
+  │  │      │     │      ││ ╰─ attrMethod.body "{}"
+  │  │      │     │      │╰─ attrMethod.params.value
+  │  │      │     │      ╰─ attrMethod.params "()"
+  │  │      │     ╰─ attrName "onClick"
+  │  │      ╰─ attrMethod:async "async onClick() {}"
+  ╰─ ╰─ tagName "button"
+17╭─ 
+  ╰─ ╰─ openTagEnd
+18╭─ button async onClick(event) {
+  │  │      │     │      ││      ╰─ attrMethod.body "{\n  await save(event);\n}"
+  │  │      │     │      │╰─ attrMethod.params.value "event"
+  │  │      │     │      ╰─ attrMethod.params "(event)"
+  │  │      │     ╰─ attrName "onClick"
+  │  │      ╰─ attrMethod:async "async onClick(event) {\n  await save(event);\n}"
+  │  ├─ closeTagEnd(button)
+  ╰─ ╰─ tagName "button"
+19╭─   await save(event);
+  ╰─ ╰─ attrMethod.body.value "\n  await save(event);\n"
+20├─ }
+21╭─ 
+  ╰─ ╰─ openTagEnd
+22╭─ <a async b() {} async c() {}/>
+  │  ││ │     │││ ││ │     │││ ││╰─ openTagEnd:selfClosed "/>"
+  │  ││ │     │││ ││ │     │││ │╰─ attrMethod.body.value
+  │  ││ │     │││ ││ │     │││ ╰─ attrMethod.body "{}"
+  │  ││ │     │││ ││ │     ││╰─ attrMethod.params.value
+  │  ││ │     │││ ││ │     │╰─ attrMethod.params "()"
+  │  ││ │     │││ ││ │     ╰─ attrName
+  │  ││ │     │││ ││ ╰─ attrMethod:async "async c() {}"
+  │  ││ │     │││ │╰─ attrMethod.body.value
+  │  ││ │     │││ ╰─ attrMethod.body "{}"
+  │  ││ │     ││╰─ attrMethod.params.value
+  │  ││ │     │╰─ attrMethod.params "()"
+  │  ││ │     ╰─ attrName
+  │  ││ ╰─ attrMethod:async "async b() {}"
+  │  │╰─ tagName
+  │  ├─ closeTagEnd(button)
+  ╰─ ╰─ openTagStart
+23├─ 
+24╭─ <foo async (event) {
+  │  ││   │     ││      ╰─ attrMethod.body "{\n  await save(event);\n}"
+  │  ││   │     │╰─ attrMethod.params.value "event"
+  │  ││   │     ╰─ attrMethod.params "(event)"
+  │  ││   ├─ attrMethod:async "async (event) {\n  await save(event);\n}"
+  │  ││   ╰─ attrName
+  │  │╰─ tagName "foo"
+  ╰─ ╰─ openTagStart
+25╭─   await save(event);
+  ╰─ ╰─ attrMethod.body.value "\n  await save(event);\n"
+26╭─ }/>
+  ╰─  ╰─ openTagEnd:selfClosed "/>"
+27├─ 
+28╭─ <foo async(event) {}/>
+  │  ││   │    ││      ││╰─ openTagEnd:selfClosed "/>"
+  │  ││   │    ││      │╰─ attrMethod.body.value
+  │  ││   │    ││      ╰─ attrMethod.body "{}"
+  │  ││   │    │╰─ attrMethod.params.value "event"
+  │  ││   │    ╰─ attrMethod.params "(event)"
+  │  ││   ├─ attrMethod:async "async(event) {}"
+  │  ││   ╰─ attrName
+  │  │╰─ tagName "foo"
+  ╰─ ╰─ openTagStart
+29├─ 
+30╭─ <foo async<T>(a: T) {}/>
+  │  ││   │    ││ ││     ││╰─ openTagEnd:selfClosed "/>"
+  │  ││   │    ││ ││     │╰─ attrMethod.body.value
+  │  ││   │    ││ ││     ╰─ attrMethod.body "{}"
+  │  ││   │    ││ │╰─ attrMethod.params.value "a: T"
+  │  ││   │    ││ ╰─ attrMethod.params "(a: T)"
+  │  ││   │    │╰─ attrMethod.typeParams.value
+  │  ││   │    ╰─ attrMethod.typeParams "<T>"
+  │  ││   ├─ attrMethod:async "async<T>(a: T) {}"
+  │  ││   ╰─ attrName
+  │  │╰─ tagName "foo"
+  ╰─ ╰─ openTagStart
+31├─ 
+32╭─ <foo async <T>(a: T) {}/>
+  │  ││   │     ││ ││     ││╰─ openTagEnd:selfClosed "/>"
+  │  ││   │     ││ ││     │╰─ attrMethod.body.value
+  │  ││   │     ││ ││     ╰─ attrMethod.body "{}"
+  │  ││   │     ││ │╰─ attrMethod.params.value "a: T"
+  │  ││   │     ││ ╰─ attrMethod.params "(a: T)"
+  │  ││   │     │╰─ attrMethod.typeParams.value
+  │  ││   │     ╰─ attrMethod.typeParams "<T>"
+  │  ││   ├─ attrMethod:async "async <T>(a: T) {}"
+  │  ││   ╰─ attrName
+  │  │╰─ tagName "foo"
+  ╰─ ╰─ openTagStart
+33├─ 
+34╭─ foo async (event) {
+  │  │   │     ││      ╰─ attrMethod.body "{\n  await save(event);\n}"
+  │  │   │     │╰─ attrMethod.params.value "event"
+  │  │   │     ╰─ attrMethod.params "(event)"
+  │  │   ├─ attrMethod:async "async (event) {\n  await save(event);\n}"
+  │  │   ╰─ attrName
+  ╰─ ╰─ tagName "foo"
+35╭─   await save(event);
+  ╰─ ╰─ attrMethod.body.value "\n  await save(event);\n"
+36├─ }
+37╭─ 
+  ╰─ ╰─ openTagEnd
+38╭─ foo async(event) {}
+  │  │   │    ││      │╰─ attrMethod.body.value
+  │  │   │    ││      ╰─ attrMethod.body "{}"
+  │  │   │    │╰─ attrMethod.params.value "event"
+  │  │   │    ╰─ attrMethod.params "(event)"
+  │  │   ├─ attrMethod:async "async(event) {}"
+  │  │   ╰─ attrName
+  │  ├─ closeTagEnd(foo)
+  ╰─ ╰─ tagName "foo"
+39╭─ 
+  │  ├─ openTagEnd
+  ╰─ ╰─ closeTagEnd(foo)
\ No newline at end of file
diff --git a/src/__tests__/fixtures/attr-method-shorthand-async/input.marko b/src/__tests__/fixtures/attr-method-shorthand-async/input.marko
new file mode 100644
index 00000000..aef1807a
--- /dev/null
+++ b/src/__tests__/fixtures/attr-method-shorthand-async/input.marko
@@ -0,0 +1,38 @@
+<button async onClick() {}/>
+
+<button async onClick(event) {
+  await save(event);
+}/>
+
+<button async onClick<T>(event: T) {
+  await save(event);
+}/>
+
+<button
+  async
+  onClick() {}
+/>
+
+button async onClick() {}
+
+button async onClick(event) {
+  await save(event);
+}
+
+<a async b() {} async c() {}/>
+
+<foo async (event) {
+  await save(event);
+}/>
+
+<foo async(event) {}/>
+
+<foo async<T>(a: T) {}/>
+
+<foo async <T>(a: T) {}/>
+
+foo async (event) {
+  await save(event);
+}
+
+foo async(event) {}
diff --git a/src/__tests__/main.test.ts b/src/__tests__/main.test.ts
index e9806ae6..0138e50d 100644
--- a/src/__tests__/main.test.ts
+++ b/src/__tests__/main.test.ts
@@ -178,7 +178,7 @@ for (const entry of fs.readdirSync(FIXTURES)) {
         addValueRange(range.bound ? `attrValue:bound` : `attrValue`, range);
       },
       onAttrMethod(range) {
-        addRange("attrMethod", range);
+        addRange(range.async ? "attrMethod:async" : "attrMethod", range);
         if (range.typeParams)
           addValueRange("attrMethod.typeParams", range.typeParams);
         addValueRange("attrMethod.params", range.params);
diff --git a/src/states/ATTRIBUTE.ts b/src/states/ATTRIBUTE.ts
index ad7553a6..16dd3e74 100644
--- a/src/states/ATTRIBUTE.ts
+++ b/src/states/ATTRIBUTE.ts
@@ -25,6 +25,10 @@ export interface AttrMeta extends Meta {
   typeParams: undefined | Ranges.Value;
   spread: boolean;
   bound: boolean;
+  /** A pending `async`, held until the args close reveals what it modifies. */
+  async: undefined | Range;
+  /** Range of an `async` keyword already confirmed to modify a method. */
+  asyncMethod: undefined | Range;
 }
 
 // We enter STATE.ATTRIBUTE when we see a non-whitespace
@@ -45,10 +49,15 @@ export const ATTRIBUTE: StateDefinition<AttrMeta> = {
       typeParams: undefined,
       bound: false,
       spread: false,
+      async: undefined,
+      asyncMethod: undefined,
     });
   },
 
-  exit() {
+  exit(attr) {
+    // Catches the paths that leave the attribute without resolving a pending
+    // `async`, notably EOF part way through typing `<div async onCl`.
+    flushPendingAsync(this, attr);
     this.activeAttr = undefined;
   },
 
@@ -80,6 +89,7 @@ export const ATTRIBUTE: StateDefinition<AttrMeta> = {
         (code === CODE.PERIOD && this.lookAheadFor(".."))
       ) {
         attr.valueStart = this.pos;
+        flushPendingAsync(this, attr); // a value means no method follows
 
         if (code === CODE.COLON) {
           ensureAttrName(this, attr);
@@ -106,14 +116,18 @@ export const ATTRIBUTE: StateDefinition<AttrMeta> = {
           : shouldTerminateHtmlAttrValue;
         return;
       } else if (code === CODE.OPEN_PAREN) {
-        ensureAttrName(this, attr);
+        // With a pending `async` the name is emitted once we know whether this
+        // is a method, since `<foo async(1)/>` is an attribute named `async`.
+        if (!attr.async) ensureAttrName(this, attr);
         attr.stage = ATTR_STAGE.ARGUMENT;
         this.pos++; // skip (
         this.enterState(STATE.EXPRESSION).shouldTerminate = matchesCloseParen;
         return;
       } else if (
         code === CODE.OPEN_ANGLE_BRACKET &&
-        attr.stage === ATTR_STAGE.NAME
+        // A pending `async` leaves the stage UNKNOWN, but type params can
+        // still follow it for a default attribute method.
+        (attr.stage === ATTR_STAGE.NAME || attr.async)
       ) {
         attr.stage = ATTR_STAGE.TYPE_PARAMS;
         this.pos++; // skip <
@@ -158,12 +172,14 @@ export const ATTRIBUTE: StateDefinition<AttrMeta> = {
           : shouldTerminateHtmlAttrName;
         return;
       } else {
+        flushPendingAsync(this, attr);
         this.exitState();
         return;
       }
     }
 
     // EOF
+    flushPendingAsync(this, attr);
     if (this.isConcise) {
       this.exitState();
     } else {
@@ -182,12 +198,24 @@ export const ATTRIBUTE: StateDefinition<AttrMeta> = {
   return(child, attr) {
     switch (attr.stage) {
       case ATTR_STAGE.NAME: {
-        attr.name = {
+        const name = {
           start: child.start,
           end: child.end,
         };
 
-        this.options.onAttrName?.(attr.name);
+        if (!attr.async && !attr.name && isAsyncMethodPrefix(this, name)) {
+          // Both names stay unemitted until a method is confirmed or
+          // flushPendingAsync replays them as ordinary attributes.
+          attr.async = name;
+          attr.stage = ATTR_STAGE.UNKNOWN;
+          return;
+        }
+
+        attr.name = name;
+
+        // With a pending `async` this name is emitted later, once we know
+        // which attribute it belongs to.
+        if (!attr.async) this.options.onAttrName?.(attr.name);
 
         if (!this.isConcise && detectAmbiguousCloseAngleBracket(this, child)) {
           return;
@@ -212,18 +240,30 @@ export const ATTRIBUTE: StateDefinition<AttrMeta> = {
         };
 
         if (this.consumeWhitespaceIfBefore("{")) {
+          // A shorthand method: any pending `async` is a modifier on this
+          // method rather than an attribute, so only the name is emitted.
+          if (attr.async) {
+            // A default attribute method has no name to emit here; the "{"
+            // branch of parse emits its empty name range.
+            if (attr.name) this.options.onAttrName?.(attr.name);
+            attr.asyncMethod = attr.async;
+            attr.async = undefined;
+          }
+
           attr.args = {
             start,
             end,
             value,
           };
         } else if (attr.typeParams) {
+          flushPendingAsync(this, attr);
           this.emitError(
             child,
             ErrorCode.INVALID_ATTRIBUTE_ARGUMENT,
             "An attribute cannot have both type parameters and arguments",
           );
         } else {
+          flushPendingAsync(this, attr); // args without a body is not a method
           attr.args = true;
           this.options.onAttrArgs?.({
             start,
@@ -237,14 +277,19 @@ export const ATTRIBUTE: StateDefinition<AttrMeta> = {
       case ATTR_STAGE.BLOCK: {
         const params = attr.args as Ranges.Value;
         const end = ++this.pos; // include }
-        const { typeParams } = attr;
-        const start = typeParams ? typeParams.start : params.start;
+        const { typeParams, asyncMethod } = attr;
+        const start = asyncMethod
+          ? asyncMethod.start
+          : typeParams
+            ? typeParams.start
+            : params.start;
 
         this.options.onAttrMethod?.({
           start,
           end,
           params,
           typeParams,
+          async: asyncMethod !== undefined,
           body: {
             start: child.start - 1, // include {
             end,
@@ -263,6 +308,7 @@ export const ATTRIBUTE: StateDefinition<AttrMeta> = {
         const end = ++this.pos; // include >
 
         if (!this.consumeWhitespaceIfBefore("(")) {
+          flushPendingAsync(this, attr);
           return this.emitError(
             child,
             ErrorCode.INVALID_ATTR_TYPE_PARAMS,
@@ -479,6 +525,50 @@ function isOperandEndCode(code: number) {
   }
 }
 
+/**
+ * Whether a method name, or a default attribute method's params, follows the
+ * keyword. Anything else keeps `async` ordinary, eg `<script async src=x>`.
+ */
+function isAsyncMethodPrefix(parser: Parser, name: Range) {
+  const { data } = parser;
+  if (
+    name.end - name.start !== 5 ||
+    // Cheap reject for the many five character attribute names, eg
+    // "class", "style", "value", before comparing the rest.
+    data.charCodeAt(name.start) !== CODE.LOWER_A ||
+    !parser.lookAheadFor("async", name.start)
+  ) {
+    return false;
+  }
+
+  // In concise mode a newline ends the attribute, so a name on the following
+  // line belongs to a separate attribute and cannot be this method's name.
+  const skip = parser.isConcise ? isIndentCode : isWhitespaceCode;
+  let pos = parser.pos;
+  while (skip(data.charCodeAt(pos))) pos++;
+
+  const code = data.charCodeAt(pos);
+  return (
+    isWordCode(code) || // the method name
+    code === CODE.OPEN_PAREN || // a default attribute method's params
+    // a default attribute method's type params, but not a close tag
+    (code === CODE.OPEN_ANGLE_BRACKET &&
+      data.charCodeAt(pos + 1) !== CODE.FORWARD_SLASH)
+  );
+}
+
+/**
+ * Replays a deferred `async`, and the name held behind it, as attribute names
+ * once the attribute turns out not to be a shorthand method.
+ */
+function flushPendingAsync(parser: Parser, attr: AttrMeta) {
+  if (attr.async) {
+    parser.options.onAttrName?.(attr.async);
+    attr.async = undefined;
+    if (attr.name) parser.options.onAttrName?.(attr.name);
+  }
+}
+
 function ensureAttrName(parser: Parser, attr: AttrMeta) {
   if (!attr.name) {
     parser.options.onAttrName?.({
diff --git a/src/util/constants.ts b/src/util/constants.ts
index b0502acf..e9b7ee3b 100644
--- a/src/util/constants.ts
+++ b/src/util/constants.ts
@@ -61,6 +61,8 @@ export namespace Ranges {
     body: Value;
     params: Value;
     typeParams: Value | undefined;
+    /** Whether an `async` keyword preceded it; the range starts there. */
+    async: boolean;
   }
 
   export interface OpenTagEnd extends Range {