From e8d4c8585caf06a3ac93fdef4ae87741e154ccef Mon Sep 17 00:00:00 2001
From: myypo <nikirsmcgl@gmail.com>
Date: Sat, 26 Sep 2026 23:13:32 +0300
Subject: [PATCH] fix!: support `@async` inside `@for`, `@if` and `@match`

---
 README.md                         |   2 +-
 crates/ast/src/component.rs       |  16 +-
 crates/ast/src/control.rs         | 365 +++++++++++++--------
 crates/ast/src/generate.rs        | 247 ++++++++------
 crates/ast/src/lib.rs             |   1 +
 crates/ast/src/uses.rs            | 512 ++++++++++++++++++++++++++++++
 crates/cheers/src/async_stream.rs | 308 ++++++++++++++----
 crates/cheers/src/internal/mod.rs |   4 +-
 crates/cheers/src/lib.rs          |   2 +-
 crates/cheers/src/response.rs     |  62 +++-
 crates/cheers/tests/main.rs       | 324 +++++++++++++++++--
 examples/readme/src/main.rs       |   2 +-
 examples/realtime/src/main.rs     |   2 +-
 13 files changed, 1512 insertions(+), 335 deletions(-)
 create mode 100644 crates/ast/src/uses.rs

diff --git a/README.md b/README.md
index 4908d71..39ab373 100644
--- a/README.md
+++ b/README.md
@@ -106,7 +106,7 @@ impl Render for DwarfList {
     }
 }
 
-async fn hall_of_ancestors(_: State<Ctx>) -> AsyncLazy<impl Render> {
+async fn hall_of_ancestors(_: State<Ctx>) -> AsyncLazy<impl AsyncRender> {
     let thorin = async {
         tokio::time::sleep(Duration::from_millis(300)).await;
         Dwarf {
diff --git a/crates/ast/src/component.rs b/crates/ast/src/component.rs
index 13e30c1..4a8cf7f 100644
--- a/crates/ast/src/component.rs
+++ b/crates/ast/src/component.rs
@@ -31,13 +31,15 @@ impl Component {
             ElementBody::Normal { children, .. } => {
                 let buffer_ident = Generator::buffer_ident();
 
-                let block = g.block_with(
-                    Brace::default(),
-                    |g| {
-                        g.push(children);
-                    },
-                    true,
-                );
+                let block = g.with_in_shared_closure(true, |g| {
+                    g.block_with(
+                        Brace::default(),
+                        |g| {
+                            g.push(children);
+                        },
+                        true,
+                    )
+                });
 
                 Some(quote! {
                     ::cheers::prelude::Lazy::dangerously_create(
diff --git a/crates/ast/src/control.rs b/crates/ast/src/control.rs
index 6d103ce..488bf02 100644
--- a/crates/ast/src/control.rs
+++ b/crates/ast/src/control.rs
@@ -14,7 +14,8 @@ use syn::{
 use super::{AnyBlock, Generate, Generator, Node, Nodes};
 use crate::{
     Attribute, AttributeKind, AttributeName, AttributeValueNode, Context, ElementNode,
-    SyntaxStatic, basics::Literal,
+    SyntaxStatic,
+    generate::{async_key_ident, async_scope_ident},
 };
 
 fn tokens_contain_ident(tokens: &TokenStream, needle: &str) -> bool {
@@ -33,7 +34,7 @@ fn tokens_contain_any_ident(tokens: &TokenStream, needles: &[Ident]) -> bool {
     })
 }
 
-fn for_each_pat_ident(pat: &Pat, f: &mut impl FnMut(&PatIdent)) {
+pub(crate) fn for_each_pat_ident(pat: &Pat, f: &mut impl FnMut(&PatIdent)) {
     match pat {
         Pat::Ident(pat) => {
             f(pat);
@@ -554,7 +555,9 @@ impl<N: Node> Generate for For<N> {
         let pat = &self.pat;
         let in_token = self.in_token;
         let expr = &self.expr;
-        let block = self.block.block_with_bindings(g, pat_binding_idents(pat));
+        let block = g.with_in_loop(true, |g| {
+            self.block.block_with_bindings(g, pat_binding_idents(pat))
+        });
 
         g.push_stmt(quote! {
             #for_token #pat #in_token #expr
@@ -585,7 +588,9 @@ impl<N: Node> Generate for While<N> {
     fn generate(&mut self, g: &mut Generator<'_>) {
         let while_token = self.while_token;
         let cond = &self.cond;
-        let block = self.block.block_with_bindings(g, cond_binding_idents(cond));
+        let block = g.with_in_loop(true, |g| {
+            self.block.block_with_bindings(g, cond_binding_idents(cond))
+        });
 
         g.push_stmt(quote! {
             #while_token #cond
@@ -750,27 +755,51 @@ impl Parse for Async {
     }
 }
 
+fn stream_template_start() -> TokenStream {
+    let key_ident = async_key_ident();
+    quote! {
+        // XSS SAFETY: the key is computed by us
+        #key_ident.write_template_start(buffer.dangerously_get_string());
+    }
+}
+
+fn stream_script() -> TokenStream {
+    let key_ident = async_key_ident();
+    quote! {
+        // XSS SAFETY: the key is computed by us
+        #key_ident.write_script(buffer.dangerously_get_string());
+    }
+}
+
+fn static_async_key_expr(key: &str) -> TokenStream {
+    let template_start = format!("<template data-ssr=\"{key}-t\">");
+    let script = format!("</template><script data-ssr=\"{key}-s\">__ssrStream('{key}')</script>");
+    let island_open = format!("<div data-cheers-async-root=\"{key}\" data-ssr=\"{key}\">");
+
+    quote! {
+        &::cheers::__internal::async_streams::StaticAsyncKey {
+            key: #key,
+            template_start: #template_start,
+            script: #script,
+            island_open: #island_open,
+        }
+    }
+}
+
 impl Async {
-    fn stream_tokens_expr(
-        async_token: Token![async],
-        content_code: &TokenStream,
-        key: &str,
-    ) -> TokenStream {
+    fn stream_tokens_expr(async_token: Token![async], content_code: &TokenStream) -> TokenStream {
         let marker_ident = ElementNode::CONTEXT.marker_type();
         let buffer_ident = Generator::buffer_ident();
-        let template_start = format!(r#"<template data-ssr="{key}-t">"#);
-        let stream_script =
-            format!(r#"</template><script data-ssr="{key}-s">__ssrStream('{key}')</script>"#);
+        let template_start = stream_template_start();
+        let stream_script = stream_script();
 
         quote! {
             ::cheers::__internal::futures::stream::once(#async_token move {
                 let mut buffer = ::cheers::prelude::Buffer::<#marker_ident>::new();
-                // XSS SAFETY: the key is computed by us
-                buffer.dangerously_get_string().push_str(#template_start);
+                #template_start
                 let #buffer_ident = &mut buffer;
                 #content_code
-                // XSS SAFETY: the key is computed by us
-                buffer.dangerously_get_string().push_str(#stream_script);
+                #stream_script
 
                 ::cheers::Raw::<_, #marker_ident>::dangerously_create(
                     buffer.rendered().into_inner()
@@ -784,13 +813,11 @@ impl Async {
         load_code: &TokenStream,
         render_code: &TokenStream,
         leading_bindings: &[(TokenStream, Ident)],
-        key: &str,
     ) -> TokenStream {
         let marker_ident = ElementNode::CONTEXT.marker_type();
         let buffer_ident = Generator::buffer_ident();
-        let template_start = format!(r#"<template data-ssr="{key}-t">"#);
-        let stream_script =
-            format!(r#"</template><script data-ssr="{key}-s">__ssrStream('{key}')</script>"#);
+        let template_start = stream_template_start();
+        let stream_script = stream_script();
         let binding_params = leading_bindings.iter().map(|(param, _)| param);
         let binding_args = leading_bindings.iter().map(|(_, arg)| arg);
 
@@ -799,8 +826,7 @@ impl Async {
                 #load_code
 
                 let mut buffer = ::cheers::prelude::Buffer::<#marker_ident>::new();
-                // XSS SAFETY: the key is computed by us
-                buffer.dangerously_get_string().push_str(#template_start);
+                #template_start
                 let #buffer_ident = &mut buffer;
                 ::cheers::__internal::subsecond::hot_call_with_arg(
                     |(#buffer_ident, #(#binding_params),*)| {
@@ -809,8 +835,7 @@ impl Async {
                     },
                     (#buffer_ident, #(#binding_args),*),
                 );
-                // XSS SAFETY: the key is computed by us
-                buffer.dangerously_get_string().push_str(#stream_script);
+                #stream_script
 
                 ::cheers::Raw::<_, #marker_ident>::dangerously_create(
                     buffer.rendered().into_inner()
@@ -821,37 +846,34 @@ impl Async {
 
     fn stream_with_nested_tokens_expr(
         async_token: Token![async],
+        scope_items: &[TokenStream],
         content_code: &TokenStream,
-        key: &str,
     ) -> TokenStream {
         let marker_ident = ElementNode::CONTEXT.marker_type();
         let buffer_ident = Generator::buffer_ident();
-        let template_start = format!(r#"<template data-ssr="{key}-t">"#);
-        let stream_script =
-            format!(r#"</template><script data-ssr="{key}-s">__ssrStream('{key}')</script>"#);
+        let key_ident = async_key_ident();
+        let scope_ident = async_scope_ident();
+        let template_start = stream_template_start();
+        let stream_script = stream_script();
 
         quote! {
             ::cheers::__internal::futures::StreamExt::flat_map(
                 ::cheers::__internal::futures::stream::once(#async_token move {
-                    let mut buffer = ::std::boxed::Box::new(
-                        ::cheers::prelude::Buffer::<#marker_ident>::new()
+                    let #scope_ident = ::cheers::__internal::async_streams::AsyncScope::nested(
+                        &#key_ident,
                     );
-                    let __cheers_async_stream_collection =
-                        ::cheers::__internal::async_streams::enter(&mut *buffer);
-                    // XSS SAFETY: the key is computed by us
-                    buffer.dangerously_get_string().push_str(#template_start);
-                    let #buffer_ident = &mut *buffer;
+                    #(#scope_items)*
+                    let mut buffer = ::cheers::prelude::Buffer::<#marker_ident>::new();
+                    #template_start
+                    let #buffer_ident = &mut buffer;
                     #content_code
-                    // XSS SAFETY: the key is computed by us
-                    buffer.dangerously_get_string().push_str(#stream_script);
+                    #stream_script
 
-                    let __cheers_nested_streams = __cheers_async_stream_collection.finish();
-                    let buffer = *buffer;
                     let __cheers_parent_rendered = ::cheers::Raw::<_, #marker_ident>::dangerously_create(
                         buffer.rendered().into_inner()
                     ).render();
 
-                    (__cheers_parent_rendered, __cheers_nested_streams)
+                    (__cheers_parent_rendered, #scope_ident.into_streams())
                 }),
                 |(__cheers_parent_rendered, __cheers_nested_streams)| {
                     ::cheers::__internal::futures::StreamExt::chain(
@@ -871,13 +893,12 @@ impl Async {
         async_token: Token![async],
         load_code: &TokenStream,
         render_code: &TokenStream,
-        key: &str,
     ) -> TokenStream {
         let marker_ident = ElementNode::CONTEXT.marker_type();
         let buffer_ident = Generator::buffer_ident();
-        let template_start = format!(r#"<template data-ssr="{key}-t">"#);
-        let stream_script =
-            format!(r#"</template><script data-ssr="{key}-s">__ssrStream('{key}')</script>"#);
+        let key_ident = async_key_ident();
+        let template_start = stream_template_start();
+        let stream_script = stream_script();
 
         quote! {
             ::cheers::__internal::futures::stream::once(#async_token move {
@@ -896,17 +917,15 @@ impl Async {
 
                 let __cheers_async_island_html = __cheers_async_island_render();
                 ::cheers::__internal::async_islands::register(
-                    #key,
+                    #key_ident.as_str(),
                     __cheers_async_island_render,
                 );
 
                 let mut buffer = ::cheers::prelude::Buffer::<#marker_ident>::new();
-                // XSS SAFETY: the key is computed by us
-                buffer.dangerously_get_string().push_str(#template_start);
+                #template_start
                 // XSS SAFETY: the async-island render body is generated by Cheers' renderer.
                 buffer.dangerously_get_string().push_str(&__cheers_async_island_html);
-                // XSS SAFETY: the key is computed by us
-                buffer.dangerously_get_string().push_str(#stream_script);
+                #stream_script
 
                 ::cheers::Raw::<_, #marker_ident>::dangerously_create(
                     buffer.rendered().into_inner()
@@ -949,10 +968,7 @@ impl Async {
             elem.attrs.push(Attribute::Regular {
                 name: AttributeName::Unchecked(LitStr::new("data-ssr", Span::mixed_site())),
                 kind: AttributeKind::Value {
-                    value: AttributeValueNode::Literal(Literal::Str(LitStr::new(
-                        &key,
-                        Span::mixed_site(),
-                    ))),
+                    value: AttributeValueNode::Ident(async_key_ident()),
                     toggle: None,
                 },
             });
@@ -968,7 +984,15 @@ impl Generate for Async {
     const CONTEXT: Context = ElementNode::CONTEXT;
 
     fn generate(&mut self, g: &mut Generator<'_>) {
-        let source_key = self.add_data_ssr_key();
+        g.mark_async();
+        // Code in a shared closure cannot move its captures, so a block there is built ahead of
+        // rendering unless it runs once per loop iteration or uses template bindings, which do not
+        // exist ahead of rendering.
+        let build_in_place = !g.in_shared_closure()
+            || g.in_loop()
+            || g.nodes_use_local_bindings(&self.async_block.nodes);
+
+        let static_key = self.add_data_ssr_key();
         let leading_let_count = self
             .async_block
             .nodes
@@ -993,12 +1017,12 @@ impl Generate for Async {
         let async_token = self.async_token;
         let else_block = self.else_block.block(g);
         let buffer_ident = Generator::buffer_ident();
-        let async_root_start =
-            format!(r#"<div data-cheers-async-root="{source_key}" data-ssr="{source_key}">"#);
+        let key_ident = async_key_ident();
+        let scope_ident = async_scope_ident();
         let else_block = quote! {
             if ::cheers::__internal::async_islands::enabled() {
                 // XSS SAFETY: the key is computed by us
-                #buffer_ident.dangerously_get_string().push_str(#async_root_start);
+                #key_ident.write_island_open(#buffer_ident.dangerously_get_string());
                 #else_block
                 // XSS SAFETY: static wrapper markup
                 #buffer_ident.dangerously_get_string().push_str("</div>");
@@ -1007,42 +1031,37 @@ impl Generate for Async {
             }
         };
 
-        let async_block = if has_nested_async {
-            g.with_async_stream_collection(|g| {
-                g.block_with(
-                    self.async_block.brace_token,
-                    |g| {
-                        g.push(&mut self.async_block.nodes);
-                    },
-                    false,
-                )
+        let async_block = g.with_in_loop(false, |g| {
+            g.with_in_shared_closure(false, |g| {
+                if can_split_leading_lets {
+                    g.block_with(
+                        self.async_block.brace_token,
+                        |g| {
+                            g.declare_local_bindings(
+                                leading_bindings.iter().map(|(_, ident)| ident.clone()),
+                            );
+                            for node in self.async_block.nodes.0.iter_mut().skip(leading_let_count)
+                            {
+                                g.push(node);
+                            }
+                        },
+                        false,
+                    )
+                } else {
+                    g.block_with(
+                        self.async_block.brace_token,
+                        |g| {
+                            g.push(&mut self.async_block.nodes);
+                        },
+                        false,
+                    )
+                }
             })
-        } else if can_split_leading_lets {
-            g.block_with(
-                self.async_block.brace_token,
-                |g| {
-                    g.declare_local_bindings(
-                        leading_bindings.iter().map(|(_, ident)| ident.clone()),
-                    );
-                    for node in self.async_block.nodes.0.iter_mut().skip(leading_let_count) {
-                        g.push(node);
-                    }
-                },
-                false,
-            )
-        } else {
-            g.block_with(
-                self.async_block.brace_token,
-                |g| {
-                    g.push(&mut self.async_block.nodes);
-                },
-                false,
-            )
-        };
+        });
         let content_code = &async_block.stmts;
         debug_assert!(
-            async_block.async_stmts.is_empty(),
-            "nested @async streams should be emitted through the buffer-scoped collector"
+            has_nested_async || async_block.async_scope_items.is_empty(),
+            "only bodies with nested @async blocks define async scope items"
         );
 
         let load_code = if can_split_leading_lets {
@@ -1081,48 +1100,57 @@ impl Generate for Async {
         let can_hot_call_dynamic_render =
             can_move_leading_lets_into_hot_args && !render_contains_await;
 
-        let async_stream = if !has_nested_async {
-            let stream = if can_register_hot_island {
-                Self::hot_island_stream_tokens_expr(
-                    async_token,
-                    &load_code,
-                    content_code,
-                    &source_key,
-                )
-            } else if can_hot_call_dynamic_render {
-                Self::stream_with_hot_render_call_tokens_expr(
-                    async_token,
-                    &load_code,
-                    content_code,
-                    &leading_bindings,
-                    &source_key,
-                )
-            } else if can_split_leading_lets {
-                let stream_content_code = quote! {
-                    #load_code
-                    #content_code
-                };
-                Self::stream_tokens_expr(async_token, &stream_content_code, &source_key)
-            } else {
-                Self::stream_tokens_expr(async_token, content_code, &source_key)
+        let async_stream = if has_nested_async {
+            Self::stream_with_nested_tokens_expr(
+                async_token,
+                &async_block.async_scope_items,
+                content_code,
+            )
+        } else if can_register_hot_island {
+            Self::hot_island_stream_tokens_expr(async_token, &load_code, content_code)
+        } else if can_hot_call_dynamic_render {
+            Self::stream_with_hot_render_call_tokens_expr(
+                async_token,
+                &load_code,
+                content_code,
+                &leading_bindings,
+            )
+        } else if can_split_leading_lets {
+            let stream_content_code = quote! {
+                #load_code
+                #content_code
             };
-            quote! {
-                {
-                    ::std::boxed::Box::pin(#stream) as ::std::pin::Pin<::std::boxed::Box<dyn ::cheers::__internal::futures::stream::Stream<Item = ::cheers::Rendered<::std::string::String>> + ::std::marker::Send>>
-                }
-            }
+            Self::stream_tokens_expr(async_token, &stream_content_code)
         } else {
-            let stream =
-                Self::stream_with_nested_tokens_expr(async_token, content_code, &source_key);
-            quote! {
-                {
-                    #stream
-                }
-            }
+            Self::stream_tokens_expr(async_token, content_code)
+        };
+
+        let static_key = static_async_key_expr(&static_key);
+        let (instance, start_stream) = if build_in_place {
+            let instances_ident = g.push_async_instances();
+            (
+                quote!(#instances_ident.next()),
+                quote! {
+                    #scope_ident.push(::std::boxed::Box::pin(#async_stream));
+                },
+            )
+        } else {
+            let slot_ident = g.push_async_slot(async_stream);
+            (
+                quote!(0),
+                quote! {
+                    #scope_ident.activate(&#slot_ident, #key_ident);
+                },
+            )
         };
 
-        g.push_async_stmt(async_stream);
-        g.push_stmt(else_block);
+        g.push_stmt(quote! {
+            {
+                let #key_ident = #scope_ident.key(#static_key, #instance);
+                #else_block
+                #start_stream
+            }
+        });
     }
 }
 
@@ -1201,4 +1229,85 @@ mod tests {
 
         assert!(!expanded.contains("hot_call_with_arg"), "{expanded}");
     }
+
+    fn expand(tokens: proc_macro2::TokenStream) -> String {
+        lazy::<Document>(tokens)
+            .expect("document should generate")
+            .to_string()
+    }
+
+    #[test]
+    fn binding_free_async_uses_a_slot() {
+        let expanded = expand(quote! {
+            @if show {
+                @async { p { (load().await) } } @else { p { "Loading" } }
+            }
+        });
+
+        assert!(expanded.contains("AsyncSlot"), "{expanded}");
+        assert!(!expanded.contains("AsyncInstances"), "{expanded}");
+    }
+
+    #[test]
+    fn single_instance_async_markers_are_literals() {
+        let expanded = expand(quote! {
+            @async { p { (load().await) } } @else { p { "Loading" } }
+        });
+
+        assert!(!expanded.contains("format"), "{expanded}");
+        assert!(
+            expanded.contains("template_start : \"<template data-ssr="),
+            "{expanded}"
+        );
+        assert!(expanded.contains("__ssrStream('"), "{expanded}");
+    }
+
+    #[test]
+    fn async_in_loop_or_using_bindings_is_built_in_place() {
+        for tokens in [
+            quote! {
+                @for _ in 0..3 {
+                    @async { p { (load().await) } } @else { p { "Loading" } }
+                }
+            },
+            quote! {
+                @let id = 1;
+                @async { p { (load(id).await) } } @else { p { "Loading" } }
+            },
+            quote! {
+                @if let Some(name) = name {
+                    @async { p { (format!("{name}")) } } @else { p { "Loading" } }
+                }
+            },
+        ] {
+            let expanded = expand(tokens);
+            assert!(!expanded.contains("AsyncSlot"), "{expanded}");
+            assert!(expanded.contains("AsyncInstances"), "{expanded}");
+        }
+    }
+
+    #[test]
+    fn names_that_are_not_binding_uses_do_not_force_in_place_async() {
+        for tokens in [
+            quote! {
+                @let id = 1;
+                @async { p { (user.id) } } @else { p { "Loading" } }
+            },
+            quote! {
+                @let id = 1;
+                @let p = 2;
+                @async { p id="x" { "Loaded" } } @else { p { "Loading" } }
+            },
+            quote! {
+                @let data = 1;
+                @async {
+                    @let data = load().await;
+                    p { (data) }
+                } @else { p { "Loading" } }
+            },
+        ] {
+            let expanded = expand(tokens);
+            assert!(expanded.contains("AsyncSlot"), "{expanded}");
+        }
+    }
 }
diff --git a/crates/ast/src/generate.rs b/crates/ast/src/generate.rs
index a645fa7..f4d7860 100644
--- a/crates/ast/src/generate.rs
+++ b/crates/ast/src/generate.rs
@@ -8,7 +8,10 @@ use syn::{
     token::{Brace, Paren},
 };
 
-use super::{AttributeValueNode, DataModifierPart, DataModifiers, SyntaxStatic, UnquotedName};
+use super::{
+    AttributeValueNode, DataModifierPart, DataModifiers, ElementNode, Nodes, SyntaxStatic,
+    UnquotedName,
+};
 
 fn escape_script_source_literal(value: &str) -> std::borrow::Cow<'_, str> {
     let bytes = value.as_bytes();
@@ -41,10 +44,12 @@ fn escape_script_source_literal(value: &str) -> std::borrow::Cow<'_, str> {
     }
 }
 
-fn pinned_stream_tokens_expr(stream: &TokenStream) -> TokenStream {
-    quote! {
-        ::std::boxed::Box::pin(#stream) as ::std::pin::Pin<::std::boxed::Box<dyn ::cheers::__internal::futures::stream::Stream<Item = ::cheers::Rendered<::std::string::String>> + ::std::marker::Send>>
-    }
+pub fn async_key_ident() -> Ident {
+    Ident::new("__cheers_async_key", Span::mixed_site())
+}
+
+pub fn async_scope_ident() -> Ident {
+    Ident::new("__cheers_async_scope", Span::mixed_site())
 }
 
 pub fn lazy<T: Parse + Generate + SyntaxStatic>(tokens: TokenStream) -> Result<TokenStream, Error> {
@@ -55,75 +60,83 @@ pub fn lazy_with_flavour<T: Parse + Generate + SyntaxStatic>(
     tokens: TokenStream,
     flavour: NodeFlavour,
 ) -> Result<TokenStream, Error> {
-    let mut borrow_state = BorrowState::new();
-    let mut g = Generator::new_closure(T::CONTEXT, flavour, &mut borrow_state);
+    let mut state = GeneratorState::new();
+    let mut g = Generator::new_closure(T::CONTEXT, flavour, &mut state);
 
     let mut input = syn::parse2::<T>(tokens)?;
     let syntax_static = input.is_static();
     g.push(&mut input);
 
     let block = g.finish();
-    let borrow_captures = borrow_state.captures;
+    let borrow_captures = state.captures;
+    let has_async = state.has_async;
 
     let buffer_ident = Generator::buffer_ident();
 
     let marker_ident = T::CONTEXT.marker_type();
-    let lazy = if !syntax_static {
-        // Dynamic render bodies can contain arbitrary Rust expressions. Keep them as normal
-        // closures instead of guessing whether their paths capture caller locals.
+    let rendered = if has_async {
+        let async_scope_items = &block.async_scope_items;
+        let async_scope_ident = async_scope_ident();
+
         quote! {
-            ::cheers::prelude::Lazy::<_, #marker_ident>::dangerously_create(
-                move |#buffer_ident: &mut ::cheers::prelude::Buffer<#marker_ident>| {
-                    ::cheers::__internal::subsecond::call(|| {
-                        #block
-                    })
-                }
-            )
+            {
+                use ::cheers::validation::attributes::*;
+                #(#borrow_captures)*
+                #(#async_scope_items)*
+
+                ::cheers::prelude::AsyncLazy::__new(
+                    move |
+                        #buffer_ident: &mut ::cheers::prelude::Buffer<#marker_ident>,
+                        #async_scope_ident: &::cheers::__internal::async_streams::AsyncScope,
+                    | {
+                        ::cheers::__internal::subsecond::call(|| {
+                            #block
+                        })
+                    }
+                )
+            }
         }
     } else {
-        // Syntactically static render bodies cannot reference caller locals. Coerce the generated
-        // closure into a real function pointer so Subsecond has a precise hot boundary.
-        quote! {
-            {
-                let __cheers_subsecond_hot_render: fn(&mut ::cheers::prelude::Buffer<#marker_ident>) = |#buffer_ident| {
-                    #block
-                };
-
+        let lazy = if !syntax_static {
+            // Dynamic render bodies can contain arbitrary Rust expressions. Keep them as normal
+            // closures instead of guessing whether their paths capture caller locals.
+            quote! {
                 ::cheers::prelude::Lazy::<_, #marker_ident>::dangerously_create(
                     move |#buffer_ident: &mut ::cheers::prelude::Buffer<#marker_ident>| {
-                        ::cheers::__internal::subsecond::hot_call(
-                            __cheers_subsecond_hot_render,
-                            (#buffer_ident,),
-                        );
+                        ::cheers::__internal::subsecond::call(|| {
+                            #block
+                        })
                     }
                 )
             }
-        }
-    };
-
-    let rendered = if block.async_stmts.is_empty() {
-        quote! {
-            {
-                use ::cheers::validation::attributes::*;
-                #(#borrow_captures)*
-
-                #lazy
+        } else {
+            // Syntactically static render bodies cannot reference caller locals. Coerce the
+            // generated closure into a real function pointer so Subsecond has a precise hot
+            // boundary.
+            quote! {
+                {
+                    let __cheers_subsecond_hot_render: fn(&mut ::cheers::prelude::Buffer<#marker_ident>) = |#buffer_ident| {
+                        #block
+                    };
+
+                    ::cheers::prelude::Lazy::<_, #marker_ident>::dangerously_create(
+                        move |#buffer_ident: &mut ::cheers::prelude::Buffer<#marker_ident>| {
+                            ::cheers::__internal::subsecond::hot_call(
+                                __cheers_subsecond_hot_render,
+                                (#buffer_ident,),
+                            );
+                        }
+                    )
+                }
             }
-        }
-    } else {
-        let streams = &block.async_stmts;
-        let streams = streams.iter().map(pinned_stream_tokens_expr);
+        };
 
         quote! {
             {
                 use ::cheers::validation::attributes::*;
                 #(#borrow_captures)*
 
-                let lazy = #lazy;
-                let stream = ::cheers::__internal::futures::stream::select_all([
-                    #(#streams),*
-                ]);
-                ::cheers::prelude::AsyncLazy::__select_all(lazy, stream)
+                #lazy
             }
         }
     };
@@ -206,20 +219,24 @@ impl ToTokens for ValidationModule {
     }
 }
 
-struct BorrowState {
+struct GeneratorState {
     captures: Vec<TokenStream>,
     counter: usize,
     /// Names bound by template control flow (`@let`, `@for`, `@if let`, ...) that are in scope
     /// at the current generation point. They do not exist where borrows are hoisted to.
     local_bindings: Vec<Ident>,
+    async_item_counter: usize,
+    has_async: bool,
 }
 
-impl BorrowState {
+impl GeneratorState {
     fn new() -> Self {
         Self {
             captures: Vec::new(),
             counter: 0,
             local_bindings: Vec::new(),
+            async_item_counter: 0,
+            has_async: false,
         }
     }
 
@@ -257,10 +274,13 @@ pub struct Generator<'a> {
     brace_token: Brace,
     parts: Vec<Part>,
     checks: Checks,
-    async_stmts: Vec<TokenStream>,
-    collect_async_stmts_into_buffer: bool,
+    async_scope_items: Vec<TokenStream>,
+    in_loop: bool,
+    /// Whether the code generated here runs inside a closure that may be called more than once,
+    /// and so cannot move values it captures.
+    in_shared_closure: bool,
     context_override: Option<Context>,
-    borrow_state: &'a mut BorrowState,
+    state: &'a mut GeneratorState,
 }
 
 impl<'a> Generator<'a> {
@@ -268,19 +288,15 @@ impl<'a> Generator<'a> {
         Ident::new("__hypertext_buffer", Span::mixed_site())
     }
 
-    fn new_closure(
-        context: Context,
-        flavour: NodeFlavour,
-        borrow_state: &'a mut BorrowState,
-    ) -> Self {
-        Self::new_root_with_brace(context, Brace::default(), flavour, borrow_state)
+    fn new_closure(context: Context, flavour: NodeFlavour, state: &'a mut GeneratorState) -> Self {
+        Self::new_root_with_brace(context, Brace::default(), flavour, state)
     }
 
     fn new_root_with_brace(
         context: Context,
         brace_token: Brace,
         flavour: NodeFlavour,
-        borrow_state: &'a mut BorrowState,
+        state: &'a mut GeneratorState,
     ) -> Self {
         Self {
             context,
@@ -288,10 +304,11 @@ impl<'a> Generator<'a> {
             brace_token,
             parts: Vec::new(),
             checks: Checks::new(),
-            async_stmts: Vec::new(),
-            collect_async_stmts_into_buffer: false,
+            async_scope_items: Vec::new(),
+            in_loop: false,
+            in_shared_closure: true,
             context_override: None,
-            borrow_state,
+            state,
         }
     }
 
@@ -306,10 +323,11 @@ impl<'a> Generator<'a> {
             brace_token,
             parts: Vec::new(),
             checks: Checks::new(),
-            async_stmts: Vec::new(),
-            collect_async_stmts_into_buffer: self.collect_async_stmts_into_buffer,
+            async_scope_items: Vec::new(),
+            in_loop: self.in_loop,
+            in_shared_closure: self.in_shared_closure,
             context_override: self.context_override,
-            borrow_state: &mut *self.borrow_state,
+            state: &mut *self.state,
         }
     }
 
@@ -361,7 +379,7 @@ impl<'a> Generator<'a> {
                 #checks
                 #render
             },
-            async_stmts: self.async_stmts,
+            async_scope_items: self.async_scope_items,
         }
     }
 
@@ -381,7 +399,7 @@ impl<'a> Generator<'a> {
         f: impl for<'b> FnOnce(&mut Generator<'b>),
         append_async: bool,
     ) -> AnyBlock {
-        let local_bindings_len = self.borrow_state.local_bindings.len();
+        let local_bindings_len = self.state.local_bindings.len();
         let (mut child_checks, mut block) = {
             let mut g = self.new_child_with_brace(brace_token, flavour);
 
@@ -392,13 +410,11 @@ impl<'a> Generator<'a> {
 
             (child_checks, block)
         };
-        self.borrow_state
-            .local_bindings
-            .truncate(local_bindings_len);
+        self.state.local_bindings.truncate(local_bindings_len);
 
         self.checks.append(&mut child_checks);
         if append_async {
-            self.async_stmts.append(&mut block.async_stmts);
+            self.async_scope_items.append(&mut block.async_scope_items);
         }
 
         block
@@ -538,7 +554,7 @@ impl<'a> Generator<'a> {
         expr: impl ToTokens,
         root: Option<&Ident>,
     ) -> TokenStream {
-        self.borrow_state.hoist_ref_expr(paren_token, expr, root)
+        self.state.hoist_ref_expr(paren_token, expr, root)
     }
 
     pub fn push_ref_expr(
@@ -553,30 +569,75 @@ impl<'a> Generator<'a> {
     }
 
     pub fn declare_local_bindings(&mut self, bindings: impl IntoIterator<Item = Ident>) {
-        self.borrow_state.local_bindings.extend(bindings);
+        self.state.local_bindings.extend(bindings);
     }
 
-    pub fn push_async_stmt(&mut self, async_stmt: impl ToTokens) {
-        let async_stmt = async_stmt.to_token_stream();
-        if self.collect_async_stmts_into_buffer {
-            let buffer_ident = Self::buffer_ident();
-            let async_stmt = pinned_stream_tokens_expr(&async_stmt);
-            self.push_stmt(quote! {
-                ::cheers::__internal::async_streams::push(&mut *#buffer_ident, #async_stmt);
-            });
-        } else {
-            self.async_stmts.push(async_stmt);
-        }
+    pub fn nodes_use_local_bindings(&self, nodes: &Nodes<ElementNode>) -> bool {
+        let bindings = &self.state.local_bindings;
+        !bindings.is_empty() && crate::uses::nodes_use_any(nodes, bindings)
+    }
+
+    pub const fn in_loop(&self) -> bool {
+        self.in_loop
     }
 
-    pub fn with_async_stream_collection<R>(&mut self, f: impl FnOnce(&mut Self) -> R) -> R {
-        let prev = self.collect_async_stmts_into_buffer;
-        self.collect_async_stmts_into_buffer = true;
+    pub fn with_in_loop<R>(&mut self, in_loop: bool, f: impl FnOnce(&mut Self) -> R) -> R {
+        let prev = std::mem::replace(&mut self.in_loop, in_loop);
+        let result = f(self);
+        self.in_loop = prev;
+        result
+    }
+
+    pub const fn in_shared_closure(&self) -> bool {
+        self.in_shared_closure
+    }
+
+    pub fn with_in_shared_closure<R>(
+        &mut self,
+        in_shared_closure: bool,
+        f: impl FnOnce(&mut Self) -> R,
+    ) -> R {
+        let prev = std::mem::replace(&mut self.in_shared_closure, in_shared_closure);
         let result = f(self);
-        self.collect_async_stmts_into_buffer = prev;
+        self.in_shared_closure = prev;
         result
     }
 
+    pub fn push_async_slot(&mut self, stream: impl ToTokens) -> Ident {
+        let slot_ident = self.next_async_item_ident("slot");
+        let key_ident = async_key_ident();
+
+        self.async_scope_items.push(quote! {
+            let #slot_ident = ::cheers::__internal::async_streams::AsyncSlot::new(
+                move |#key_ident: ::cheers::__internal::async_streams::AsyncKey| -> ::cheers::__internal::async_streams::AsyncStream {
+                    ::std::boxed::Box::pin(#stream)
+                }
+            );
+        });
+
+        slot_ident
+    }
+
+    pub fn push_async_instances(&mut self) -> Ident {
+        let instances_ident = self.next_async_item_ident("instances");
+
+        self.async_scope_items.push(quote! {
+            let #instances_ident = ::cheers::__internal::async_streams::AsyncInstances::new();
+        });
+
+        instances_ident
+    }
+
+    fn next_async_item_ident(&mut self, kind: &str) -> Ident {
+        let idx = self.state.async_item_counter;
+        self.state.async_item_counter += 1;
+        format_ident!("__cheers_async_{kind}_{idx}", span = Span::mixed_site())
+    }
+
+    pub fn mark_async(&mut self) {
+        self.state.has_async = true;
+    }
+
     pub fn push_stmt(&mut self, stmt: impl ToTokens) {
         self.parts.push(Part::Dynamic(stmt.to_token_stream()));
     }
@@ -903,7 +964,9 @@ pub enum AttributeNameCheckKind {
 pub struct AnyBlock {
     pub brace_token: Brace,
     pub stmts: TokenStream,
-    pub async_stmts: Vec<TokenStream>,
+    /// `@async` slots and instance counters that must be defined at the root of the enclosing
+    /// async scope.
+    pub async_scope_items: Vec<TokenStream>,
 }
 
 impl Parse for AnyBlock {
@@ -913,7 +976,7 @@ impl Parse for AnyBlock {
         Ok(Self {
             brace_token: braced!(content in input),
             stmts: content.parse()?,
-            async_stmts: Vec::new(),
+            async_scope_items: Vec::new(),
         })
     }
 }
diff --git a/crates/ast/src/lib.rs b/crates/ast/src/lib.rs
index b8f067e..6b787ea 100644
--- a/crates/ast/src/lib.rs
+++ b/crates/ast/src/lib.rs
@@ -3,6 +3,7 @@ pub mod component;
 pub mod control;
 pub mod generate;
 mod syntax;
+mod uses;
 
 use std::marker::PhantomData;
 
diff --git a/crates/ast/src/uses.rs b/crates/ast/src/uses.rs
new file mode 100644
index 0000000..2773992
--- /dev/null
+++ b/crates/ast/src/uses.rs
@@ -0,0 +1,512 @@
+//! Decides whether markup uses template-local bindings, which `@async` needs to know to pick
+//! where its future is built.
+
+use proc_macro2::{Spacing, TokenStream, TokenTree};
+use syn::{
+    Expr, ExprClosure, ExprPath, Ident, Item, Local, Macro, Pat,
+    visit::{self, Visit},
+};
+
+use crate::{
+    Attribute, AttributeKind, AttributeValueNode, DataContent, DataExpr, ElementBody, ElementNode,
+    Node, Nodes, ParenExpr, ParenExprBody,
+    component::{Component, ComponentAttribute, ComponentAttributeValue},
+    control::{
+        Control, ControlIfOrBlock, ControlKind, If, Let, MatchNodeArmBody, for_each_pat_ident,
+    },
+};
+
+/// Whether `nodes` use any of `bindings`, not counting uses of names that `nodes` bind themselves
+/// before the use.
+///
+/// Element, attribute and component names are not uses. Macro bodies are scanned as tokens, so
+/// uncertain cases there count as uses.
+pub fn nodes_use_any(nodes: &Nodes<ElementNode>, bindings: &[Ident]) -> bool {
+    let mut scan = Scan {
+        bindings,
+        shadowed: Vec::new(),
+        found: false,
+    };
+    nodes.uses(&mut scan);
+    scan.found
+}
+
+struct Scan<'a> {
+    bindings: &'a [Ident],
+    shadowed: Vec<Ident>,
+    found: bool,
+}
+
+impl Scan<'_> {
+    fn use_ident(&mut self, ident: &Ident) {
+        if !self.found && self.bindings.contains(ident) && !self.shadowed.contains(ident) {
+            self.found = true;
+        }
+    }
+
+    fn use_name(&mut self, name: &str) {
+        if !self.found
+            && self.bindings.iter().any(|binding| binding == name)
+            && !self.shadowed.iter().any(|shadowed| shadowed == name)
+        {
+            self.found = true;
+        }
+    }
+
+    fn scoped(&mut self, f: impl FnOnce(&mut Self)) {
+        let len = self.shadowed.len();
+        f(self);
+        self.shadowed.truncate(len);
+    }
+
+    fn shadow_pat(&mut self, pat: &Pat) {
+        for_each_pat_ident(pat, &mut |pat| self.shadowed.push(pat.ident.clone()));
+    }
+
+    fn expr(&mut self, expr: &Expr) {
+        self.visit_expr(expr);
+    }
+
+    fn data_expr(&mut self, expr: &DataExpr) {
+        self.expr(&expr.expr);
+    }
+
+    /// Scans `cond`, then `body` with the bindings of `cond`'s `let` chain in scope.
+    fn cond(&mut self, cond: &Expr, body: impl FnOnce(&mut Self)) {
+        fn chain(scan: &mut Scan<'_>, cond: &Expr) {
+            match cond {
+                Expr::Let(let_) => {
+                    scan.expr(&let_.expr);
+                    scan.shadow_pat(&let_.pat);
+                }
+                Expr::Binary(binary) if matches!(binary.op, syn::BinOp::And(_)) => {
+                    chain(scan, &binary.left);
+                    chain(scan, &binary.right);
+                }
+                cond => scan.expr(cond),
+            }
+        }
+
+        self.scoped(|scan| {
+            chain(scan, cond);
+            body(scan);
+        });
+    }
+
+    fn tokens(&mut self, tokens: TokenStream) {
+        let tokens = tokens.into_iter().collect::<Vec<_>>();
+        let is_punct = |idx: Option<usize>, ch: char, spacing: Option<Spacing>| {
+            idx.and_then(|idx| tokens.get(idx)).is_some_and(|token| {
+                matches!(token, TokenTree::Punct(punct)
+                    if punct.as_char() == ch && spacing.is_none_or(|spacing| punct.spacing() == spacing))
+            })
+        };
+
+        for (idx, token) in tokens.iter().enumerate() {
+            match token {
+                TokenTree::Ident(ident) => {
+                    let prev = idx.checked_sub(1);
+                    let prev_prev = prev.and_then(|prev| prev.checked_sub(1));
+                    // `a..b` puts a joint `.` before the last one, while `a.b` does not.
+                    let after_member_dot = is_punct(prev, '.', None)
+                        && !is_punct(prev_prev, '.', Some(Spacing::Joint));
+                    let after_path_sep =
+                        is_punct(prev, ':', None) && is_punct(prev_prev, ':', Some(Spacing::Joint));
+                    let before_path_sep = is_punct(Some(idx + 1), ':', Some(Spacing::Joint))
+                        && is_punct(Some(idx + 2), ':', None);
+
+                    if !after_member_dot && !after_path_sep && !before_path_sep {
+                        self.use_ident(ident);
+                    }
+                }
+                TokenTree::Group(group) => self.tokens(group.stream()),
+                TokenTree::Literal(lit) => self.format_captures(&lit.to_string()),
+                TokenTree::Punct(_) => {}
+            }
+        }
+    }
+
+    /// Scans the implicit captures of `format!`-style placeholders in a string literal: the
+    /// argument in `{name}` and `{name:..}`, and width or precision arguments like `{:>w$}`.
+    fn format_captures(&mut self, lit: &str) {
+        if !lit.ends_with(['"', '#']) {
+            return;
+        }
+
+        let mut rest = lit;
+        while let Some(open) = rest.find('{') {
+            rest = &rest[open + 1..];
+            if let Some(escaped) = rest.strip_prefix('{') {
+                rest = escaped;
+                continue;
+            }
+            let Some(close) = rest.find('}') else {
+                break;
+            };
+            let placeholder = &rest[..close];
+            rest = &rest[close + 1..];
+
+            let (argument, spec) = placeholder.split_once(':').unwrap_or((placeholder, ""));
+            self.use_name(argument);
+            for (dollar, _) in spec.match_indices('$') {
+                let before = &spec[..dollar];
+                let name_start = before
+                    .rfind(|c: char| !(c.is_alphanumeric() || c == '_'))
+                    .map_or(0, |idx| idx + 1);
+                self.use_name(&before[name_start..]);
+            }
+        }
+    }
+}
+
+impl<'ast> Visit<'ast> for Scan<'_> {
+    fn visit_expr_path(&mut self, path: &'ast ExprPath) {
+        if path.qself.is_none()
+            && let Some(ident) = path.path.get_ident()
+        {
+            self.use_ident(ident);
+        }
+    }
+
+    fn visit_expr_closure(&mut self, closure: &'ast ExprClosure) {
+        self.scoped(|scan| {
+            for input in &closure.inputs {
+                scan.shadow_pat(input);
+            }
+            scan.visit_expr(&closure.body);
+        });
+    }
+
+    fn visit_block(&mut self, block: &'ast syn::Block) {
+        self.scoped(|scan| visit::visit_block(scan, block));
+    }
+
+    fn visit_local(&mut self, local: &'ast Local) {
+        if let Some(init) = &local.init {
+            self.visit_expr(&init.expr);
+            if let Some((_, diverge)) = &init.diverge {
+                self.visit_expr(diverge);
+            }
+        }
+        self.shadow_pat(&local.pat);
+    }
+
+    fn visit_macro(&mut self, mac: &'ast Macro) {
+        self.tokens(mac.tokens.clone());
+    }
+
+    fn visit_item(&mut self, _item: &'ast Item) {}
+}
+
+trait Uses {
+    fn uses(&self, scan: &mut Scan<'_>);
+}
+
+impl<N: Node + Uses> Uses for Nodes<N> {
+    fn uses(&self, scan: &mut Scan<'_>) {
+        scan.scoped(|scan| {
+            for node in &self.0 {
+                node.uses(scan);
+            }
+        });
+    }
+}
+
+impl Uses for ElementNode {
+    fn uses(&self, scan: &mut Scan<'_>) {
+        match self {
+            Self::Element(element) => {
+                for attr in &element.attrs {
+                    attr.uses(scan);
+                }
+                element.body.uses(scan);
+            }
+            Self::Component(component) => component.uses(scan),
+            Self::Literal(_) => {}
+            Self::Control(control) => control.uses(scan),
+            Self::Expr(expr) => expr.uses(scan),
+            Self::Group(group) => group.nodes.uses(scan),
+        }
+    }
+}
+
+impl Uses for AttributeValueNode {
+    fn uses(&self, scan: &mut Scan<'_>) {
+        match self {
+            Self::Literal(_) => {}
+            Self::Group(group) => group.nodes.uses(scan),
+            Self::Control(control) => control.uses(scan),
+            Self::Expr(expr) => expr.uses(scan),
+            Self::Ident(ident) => scan.use_ident(ident),
+        }
+    }
+}
+
+impl Uses for ElementBody {
+    fn uses(&self, scan: &mut Scan<'_>) {
+        match self {
+            Self::Normal { children, .. } => children.uses(scan),
+            Self::Void { .. } => {}
+        }
+    }
+}
+
+impl Uses for Attribute {
+    fn uses(&self, scan: &mut Scan<'_>) {
+        match self {
+            Self::Regular { kind, .. } => match kind {
+                AttributeKind::Value { value, toggle } => {
+                    value.uses(scan);
+                    if let Some(toggle) = toggle {
+                        scan.expr(&toggle.expr);
+                    }
+                }
+                AttributeKind::Empty(toggle) => {
+                    if let Some(toggle) = toggle {
+                        scan.expr(&toggle.expr);
+                    }
+                }
+                AttributeKind::Option(toggle) => scan.expr(&toggle.expr),
+            },
+            Self::Data { data, .. } => data.content.uses(scan),
+        }
+    }
+}
+
+impl Uses for DataContent {
+    fn uses(&self, scan: &mut Scan<'_>) {
+        match self {
+            Self::Node(node) => node.uses(scan),
+            Self::Signals(signals) => {
+                for signal in signals {
+                    scan.data_expr(&signal.ident);
+                    scan.expr(&signal.value);
+                }
+            }
+            Self::Kv(pairs) | Self::Computed(pairs) => {
+                for pair in pairs {
+                    scan.data_expr(&pair.ident);
+                    pair.value.uses(scan);
+                }
+            }
+            Self::Bind(expr) => scan.data_expr(expr),
+            Self::Show { value, initially } => {
+                value.uses(scan);
+                scan.expr(initially);
+            }
+            Self::Empty | Self::Recovered => {}
+        }
+    }
+}
+
+impl Uses for Component {
+    fn uses(&self, scan: &mut Scan<'_>) {
+        let default_attrs = self
+            .default_attrs
+            .iter()
+            .flat_map(|default_attrs| &default_attrs.attrs);
+        for attr in self.attrs.iter().chain(default_attrs) {
+            attr.uses(scan);
+        }
+        self.body.uses(scan);
+    }
+}
+
+impl Uses for ComponentAttribute {
+    fn uses(&self, scan: &mut Scan<'_>) {
+        match &self.value {
+            Some(ComponentAttributeValue::Literal(_)) => {}
+            Some(ComponentAttributeValue::Ident(ident)) => scan.use_ident(ident),
+            Some(ComponentAttributeValue::Expr(expr)) => expr.uses(scan),
+            None => scan.use_ident(&self.name),
+        }
+    }
+}
+
+impl<N: Node> Uses for ParenExpr<N> {
+    fn uses(&self, scan: &mut Scan<'_>) {
+        match &self.body {
+            ParenExprBody::Unit => {}
+            ParenExprBody::Expr(expr) => scan.expr(expr),
+            ParenExprBody::Tuple(exprs) => {
+                for expr in exprs {
+                    scan.expr(expr);
+                }
+            }
+        }
+    }
+}
+
+impl<N: Node + Uses> Uses for Control<N> {
+    fn uses(&self, scan: &mut Scan<'_>) {
+        match &self.kind {
+            ControlKind::Let(Let(local)) => scan.visit_local(local),
+            ControlKind::If(if_) => if_.uses(scan),
+            ControlKind::For(for_) => {
+                scan.expr(&for_.expr);
+                scan.scoped(|scan| {
+                    scan.shadow_pat(&for_.pat);
+                    for_.block.nodes.uses(scan);
+                });
+            }
+            ControlKind::While(while_) => {
+                scan.cond(&while_.cond, |scan| while_.block.nodes.uses(scan));
+            }
+            ControlKind::Match(match_) => {
+                scan.expr(&match_.expr);
+                for arm in &match_.arms {
+                    scan.scoped(|scan| {
+                        scan.shadow_pat(&arm.pat);
+                        if let Some((_, guard)) = &arm.guard {
+                            scan.expr(guard);
+                        }
+                        match &arm.body {
+                            MatchNodeArmBody::Block(block) => block.nodes.uses(scan),
+                            MatchNodeArmBody::Node(node) => node.uses(scan),
+                        }
+                    });
+                }
+            }
+            ControlKind::Async(async_) => {
+                async_.async_block.nodes.uses(scan);
+                async_.else_block.nodes.uses(scan);
+            }
+        }
+    }
+}
+
+impl<N: Node + Uses> Uses for If<N> {
+    fn uses(&self, scan: &mut Scan<'_>) {
+        scan.cond(&self.cond, |scan| self.then_block.nodes.uses(scan));
+        if let Some((_, _, else_branch)) = &self.else_branch {
+            match &**else_branch {
+                ControlIfOrBlock::If(if_) => if_.uses(scan),
+                ControlIfOrBlock::Block(block) => block.nodes.uses(scan),
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use proc_macro2::TokenStream;
+    use quote::{format_ident, quote};
+
+    use super::nodes_use_any;
+    use crate::Document;
+
+    fn uses(bindings: &[&str], tokens: TokenStream) -> bool {
+        let nodes = syn::parse2::<Document>(tokens).expect("markup should parse");
+        let bindings = bindings
+            .iter()
+            .map(|binding| format_ident!("{binding}"))
+            .collect::<Vec<_>>();
+        nodes_use_any(&nodes, &bindings)
+    }
+
+    #[test]
+    fn names_in_markup_syntax_are_not_uses() {
+        assert!(!uses(
+            &["id", "p", "Card", "title", "bind"],
+            quote! {
+                p id="x" {}
+                input !bind(signal) {}
+                Card title="x" {}
+            }
+        ));
+    }
+
+    #[test]
+    fn paths_fields_and_methods_are_not_uses() {
+        assert!(!uses(
+            &["item", "len"],
+            quote! {
+                (item::render(other.item, other.len()))
+            }
+        ));
+    }
+
+    #[test]
+    fn own_bindings_shadow_later_uses() {
+        assert!(!uses(
+            &["data", "x", "row"],
+            quote! {
+                @let data = load().await;
+                (data)
+                (items.iter().map(|x| x + 1).count())
+                @for row in rows { (row) }
+            }
+        ));
+    }
+
+    #[test]
+    fn own_binding_initializer_is_a_use() {
+        assert!(uses(
+            &["client"],
+            quote! {
+                @let client = client.clone();
+                (client)
+            }
+        ));
+    }
+
+    #[test]
+    fn shadowing_ends_with_its_block() {
+        assert!(uses(
+            &["row"],
+            quote! {
+                @for row in rows { (row) }
+                (row)
+            }
+        ));
+    }
+
+    #[test]
+    fn expression_uses_are_found() {
+        for (binding, tokens) in [
+            ("name", quote!(Card name;)),
+            ("title", quote!(Card title=title;)),
+            ("user", quote!((Foo { user }))),
+            ("user", quote!((format!("{user}")))),
+            ("user", quote!((format!("{user:?}")))),
+            ("user", quote!((vec![user]))),
+            ("user", quote!(p class=(user) {})),
+            ("user", quote!(p { (user) })),
+            ("user", quote!(@if user.admin { p {} })),
+            ("user", quote!(@async { (user) } @else { p {} })),
+            ("user", quote!(@async { p {} } @else { p { (user) } })),
+        ] {
+            assert!(uses(&[binding], tokens.clone()), "{tokens}");
+        }
+    }
+
+    #[test]
+    fn macro_paths_and_named_arguments_are_scanned_conservatively() {
+        assert!(!uses(&["item"], quote!((format!("{}", item::NAME)))));
+        assert!(!uses(&["name"], quote!((format!("{}", user.name)))));
+        assert!(uses(&["value"], quote!((json!({ "a": value })))));
+    }
+
+    #[test]
+    fn macro_ranges_and_struct_updates_are_uses() {
+        for (binding, tokens) in [
+            ("n", quote!((format!("{:?}", (0..n).collect::<Vec<_>>())))),
+            ("n", quote!((format!("{:?}", (0..=n).collect::<Vec<_>>())))),
+            ("base", quote!((vec![Foo { a: 1, ..base }]))),
+        ] {
+            assert!(uses(&[binding], tokens.clone()), "{tokens}");
+        }
+    }
+
+    #[test]
+    fn format_width_and_precision_captures_are_uses() {
+        for (binding, tokens) in [
+            ("w", quote!((format!("{:>w$}", "a")))),
+            ("p", quote!((format!("{:.p$}", 1.5)))),
+            ("p", quote!((format!("{value:>8.p$}")))),
+        ] {
+            assert!(uses(&[binding], tokens.clone()), "{tokens}");
+        }
+        assert!(!uses(&["w"], quote!((format!("{:>1$}", "a", 3)))));
+    }
+}
diff --git a/crates/cheers/src/async_stream.rs b/crates/cheers/src/async_stream.rs
index b3abb17..1aa5646 100644
--- a/crates/cheers/src/async_stream.rs
+++ b/crates/cheers/src/async_stream.rs
@@ -1,12 +1,8 @@
-use std::{
-    collections::BTreeMap,
-    ptr,
-    sync::{LazyLock, Mutex, MutexGuard},
-};
+use std::cell::{Cell, RefCell};
 
 use crate::{
-    context::Context,
-    render::{Buffer, Rendered},
+    context::AttributeValue,
+    render::{AttributeBuffer, Render, Rendered},
 };
 
 #[doc(hidden)]
@@ -16,93 +12,283 @@ use crate::{
 /// Cheers' stable public API.
 pub type AsyncStream = ::std::pin::Pin<Box<dyn futures::Stream<Item = Rendered<String>> + Send>>;
 
-type AsyncStreamCollections = BTreeMap<usize, Vec<Vec<AsyncStream>>>;
+#[doc(hidden)]
+/// Streaming key of an `@async` block with its markers precomputed by the
+/// `html!` macro.
+///
+/// This is an implementation detail of the `html!` macro and is not part of
+/// Cheers' stable public API.
+pub struct StaticAsyncKey {
+    pub key: &'static str,
+    pub template_start: &'static str,
+    pub script: &'static str,
+    pub island_open: &'static str,
+}
 
-static ASYNC_STREAM_COLLECTIONS: LazyLock<Mutex<AsyncStreamCollections>> =
-    LazyLock::new(|| Mutex::new(BTreeMap::new()));
+#[doc(hidden)]
+/// Streaming key of one rendered instance of an `@async` block.
+///
+/// Keys only contain URL-safe base64, `.`, `-` and digits, so they are written
+/// without escaping.
+///
+/// This is an implementation detail of the `html!` macro and is not part of
+/// Cheers' stable public API.
+pub enum AsyncKey {
+    Static(&'static StaticAsyncKey),
+    Dynamic(Box<str>),
+}
 
-fn async_stream_collections() -> MutexGuard<'static, AsyncStreamCollections> {
-    match ASYNC_STREAM_COLLECTIONS.lock() {
-        Ok(collections) => collections,
-        Err(poisoned) => poisoned.into_inner(),
+impl AsyncKey {
+    #[doc(hidden)]
+    #[inline]
+    #[must_use]
+    pub fn as_str(&self) -> &str {
+        match self {
+            Self::Static(key) => key.key,
+            Self::Dynamic(key) => key,
+        }
     }
-}
 
-fn async_stream_collection_key<C: Context>(buffer: &mut Buffer<C>) -> usize {
-    ptr::from_mut(buffer).cast::<()>() as usize
-}
+    #[doc(hidden)]
+    #[inline]
+    pub fn write_template_start(&self, out: &mut String) {
+        match self {
+            Self::Static(key) => out.push_str(key.template_start),
+            Self::Dynamic(key) => {
+                out.push_str("<template data-ssr=\"");
+                out.push_str(key);
+                out.push_str("-t\">");
+            }
+        }
+    }
 
-fn pop_async_stream_collection(key: usize) -> Vec<AsyncStream> {
-    let mut collections = async_stream_collections();
-    let Some(stack) = collections.get_mut(&key) else {
-        return Vec::new();
-    };
+    #[doc(hidden)]
+    #[inline]
+    pub fn write_script(&self, out: &mut String) {
+        match self {
+            Self::Static(key) => out.push_str(key.script),
+            Self::Dynamic(key) => {
+                out.push_str("</template><script data-ssr=\"");
+                out.push_str(key);
+                out.push_str("-s\">__ssrStream('");
+                out.push_str(key);
+                out.push_str("')</script>");
+            }
+        }
+    }
 
-    let streams = stack.pop().unwrap_or_else(Vec::new);
-    if stack.is_empty() {
-        collections.remove(&key);
+    #[doc(hidden)]
+    #[inline]
+    pub fn write_island_open(&self, out: &mut String) {
+        match self {
+            Self::Static(key) => out.push_str(key.island_open),
+            Self::Dynamic(key) => {
+                out.push_str("<div data-cheers-async-root=\"");
+                out.push_str(key);
+                out.push_str("\" data-ssr=\"");
+                out.push_str(key);
+                out.push_str("\">");
+            }
+        }
     }
+}
 
-    streams
+impl Render<AttributeValue> for AsyncKey {
+    #[inline]
+    fn render_to(&self, buffer: &mut AttributeBuffer) {
+        // XSS SAFETY: keys are generated by Cheers and never need escaping
+        buffer.dangerously_get_string().push_str(self.as_str());
+    }
 }
 
 #[doc(hidden)]
-/// Guard for a generated nested-async stream collection scope.
+/// Streams started while rendering one async scope: the page itself, or the
+/// body of an `@async` block that contains nested `@async` blocks.
 ///
-/// Dropping the guard without finishing discards the collected streams and
-/// cleans up the internal sidecar registry.
-#[must_use]
-pub struct AsyncStreamCollectionGuard {
-    key: usize,
-    active: bool,
+/// This is an implementation detail of the `html!` macro and is not part of
+/// Cheers' stable public API.
+pub struct AsyncScope {
+    streams: RefCell<Vec<AsyncStream>>,
+    key_prefix: Option<Box<str>>,
 }
 
-impl AsyncStreamCollectionGuard {
+impl AsyncScope {
     #[doc(hidden)]
     #[inline]
-    pub fn finish(mut self) -> Vec<AsyncStream> {
-        self.active = false;
-        pop_async_stream_collection(self.key)
+    #[must_use]
+    pub const fn root() -> Self {
+        Self {
+            streams: RefCell::new(Vec::new()),
+            key_prefix: None,
+        }
     }
-}
 
-impl Drop for AsyncStreamCollectionGuard {
+    #[doc(hidden)]
+    /// Scope for the body of the `@async` block keyed `parent`.
+    ///
+    /// Blocks nested in a repeated parent get the parent's key as a prefix,
+    /// which keeps their keys distinct between parent instances.
     #[inline]
-    fn drop(&mut self) {
-        if self.active {
-            let _streams = pop_async_stream_collection(self.key);
+    #[must_use]
+    pub fn nested(parent: &AsyncKey) -> Self {
+        Self {
+            streams: RefCell::new(Vec::new()),
+            key_prefix: match parent {
+                AsyncKey::Static(_) => None,
+                AsyncKey::Dynamic(key) => Some(key.clone()),
+            },
+        }
+    }
+
+    #[doc(hidden)]
+    /// Returns the key of the `instance`-th rendered instance of a block.
+    ///
+    /// The first instance in an unprefixed scope keeps the static key, so
+    /// single-instance blocks have the same key on every render.
+    #[must_use]
+    pub fn key(&self, key: &'static StaticAsyncKey, instance: u32) -> AsyncKey {
+        if instance == 0 && self.key_prefix.is_none() {
+            return AsyncKey::Static(key);
+        }
+
+        let mut instance_buffer = itoa::Buffer::new();
+        let instance = (instance > 0).then(|| instance_buffer.format(instance));
+        let prefix = self.key_prefix.as_deref();
+
+        let mut dynamic = String::with_capacity(
+            prefix.map_or(0, |prefix| prefix.len() + 1)
+                + key.key.len()
+                + instance.map_or(0, |instance| instance.len() + 1),
+        );
+        if let Some(prefix) = prefix {
+            dynamic.push_str(prefix);
+            dynamic.push('.');
+        }
+        dynamic.push_str(key.key);
+        if let Some(instance) = instance {
+            dynamic.push('-');
+            dynamic.push_str(instance);
         }
+
+        AsyncKey::Dynamic(dynamic.into_boxed_str())
+    }
+
+    #[doc(hidden)]
+    #[inline]
+    pub fn push(&self, stream: AsyncStream) {
+        self.streams.borrow_mut().push(stream);
+    }
+
+    #[doc(hidden)]
+    #[inline]
+    pub fn activate<F: FnOnce(AsyncKey) -> AsyncStream>(&self, slot: &AsyncSlot<F>, key: AsyncKey) {
+        let Some(stream) = slot.stream.take() else {
+            debug_assert!(
+                false,
+                "an `@async` block was rendered more than once from a single prebuilt stream, \
+                 likely by a component that renders its children more than once; only the first \
+                 copy of its fallback is replaced"
+            );
+            return;
+        };
+
+        self.push(stream(key));
+    }
+
+    #[doc(hidden)]
+    #[inline]
+    #[must_use]
+    pub fn into_streams(self) -> Vec<AsyncStream> {
+        self.streams.into_inner()
     }
 }
 
 #[doc(hidden)]
-/// Starts collecting nested async streams rendered into `buffer`.
+/// An `@async` stream built ahead of rendering, started only when its block
+/// is rendered.
 ///
 /// This is an implementation detail of the `html!` macro and is not part of
 /// Cheers' stable public API.
-#[inline]
-pub fn enter<C: Context>(buffer: &mut Buffer<C>) -> AsyncStreamCollectionGuard {
-    let key = async_stream_collection_key(buffer);
-    async_stream_collections()
-        .entry(key)
-        .or_default()
-        .push(Vec::new());
-
-    AsyncStreamCollectionGuard { key, active: true }
+pub struct AsyncSlot<F> {
+    stream: Cell<Option<F>>,
+}
+
+impl<F: FnOnce(AsyncKey) -> AsyncStream> AsyncSlot<F> {
+    #[doc(hidden)]
+    #[inline]
+    pub const fn new(stream: F) -> Self {
+        Self {
+            stream: Cell::new(Some(stream)),
+        }
+    }
 }
 
 #[doc(hidden)]
-/// Pushes a nested async stream into the collection scope for `buffer`.
+/// Counts the rendered instances of an `@async` block built in place.
 ///
 /// This is an implementation detail of the `html!` macro and is not part of
 /// Cheers' stable public API.
-#[inline]
-pub fn push<C: Context>(buffer: &mut Buffer<C>, stream: AsyncStream) {
-    let key = async_stream_collection_key(buffer);
-    let mut collections = async_stream_collections();
-    let Some(streams) = collections.get_mut(&key).and_then(|stack| stack.last_mut()) else {
-        panic!("nested async stream pushed without active buffer async collector");
+pub struct AsyncInstances(Cell<u32>);
+
+impl AsyncInstances {
+    #[doc(hidden)]
+    #[inline]
+    #[must_use]
+    pub const fn new() -> Self {
+        Self(Cell::new(0))
+    }
+
+    #[doc(hidden)]
+    #[inline]
+    #[must_use]
+    pub fn next(&self) -> u32 {
+        let instance = self.0.get();
+        self.0.set(instance + 1);
+        instance
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{AsyncKey, AsyncScope, StaticAsyncKey};
+
+    const KEY: StaticAsyncKey = StaticAsyncKey {
+        key: "Ab3_xQ",
+        template_start: "<template data-ssr=\"Ab3_xQ-t\">",
+        script: "</template><script data-ssr=\"Ab3_xQ-s\">__ssrStream('Ab3_xQ')</script>",
+        island_open: "<div data-cheers-async-root=\"Ab3_xQ\" data-ssr=\"Ab3_xQ\">",
     };
 
-    streams.push(stream);
+    fn markers(key: &AsyncKey) -> [String; 3] {
+        let mut template_start = String::new();
+        let mut script = String::new();
+        let mut island_open = String::new();
+        key.write_template_start(&mut template_start);
+        key.write_script(&mut script);
+        key.write_island_open(&mut island_open);
+        [template_start, script, island_open]
+    }
+
+    #[test]
+    fn dynamic_markers_match_static_markers() {
+        let static_key = AsyncScope::root().key(&KEY, 0);
+        let dynamic_key = AsyncKey::Dynamic(KEY.key.into());
+
+        assert!(matches!(static_key, AsyncKey::Static(_)));
+        assert_eq!(markers(&static_key), markers(&dynamic_key));
+    }
+
+    #[test]
+    fn repeated_and_nested_instances_get_distinct_keys() {
+        let root = AsyncScope::root();
+        let second = root.key(&KEY, 1);
+        assert_eq!(second.as_str(), "Ab3_xQ-1");
+
+        let nested = AsyncScope::nested(&second);
+        assert_eq!(nested.key(&KEY, 0).as_str(), "Ab3_xQ-1.Ab3_xQ");
+        assert_eq!(nested.key(&KEY, 2).as_str(), "Ab3_xQ-1.Ab3_xQ-2");
+
+        let under_static = AsyncScope::nested(&root.key(&KEY, 0));
+        assert!(matches!(under_static.key(&KEY, 0), AsyncKey::Static(_)));
+    }
 }
diff --git a/crates/cheers/src/internal/mod.rs b/crates/cheers/src/internal/mod.rs
index da36085..b4b5ac4 100644
--- a/crates/cheers/src/internal/mod.rs
+++ b/crates/cheers/src/internal/mod.rs
@@ -27,7 +27,9 @@ pub use custom_event::{__render_custom_event_component, __render_custom_event_to
 pub use signal_path::{__push_signal_path_dynamic_segment, __push_signal_path_segment};
 
 pub mod async_streams {
-    pub use crate::async_stream::{AsyncStream, AsyncStreamCollectionGuard, enter, push};
+    pub use crate::async_stream::{
+        AsyncInstances, AsyncKey, AsyncScope, AsyncSlot, AsyncStream, StaticAsyncKey,
+    };
 }
 
 pub mod subsecond {
diff --git a/crates/cheers/src/lib.rs b/crates/cheers/src/lib.rs
index 7aaf016..3a626c5 100644
--- a/crates/cheers/src/lib.rs
+++ b/crates/cheers/src/lib.rs
@@ -59,7 +59,7 @@ pub mod prelude {
             Buffer, Lazy, LazyAttribute, LazyScript, RawDatastarSource, RawScript, Render,
             RenderExt as _,
         },
-        response::AsyncLazy,
+        response::{AsyncLazy, AsyncRender},
         router::{Action, ActionDef, ActionOptions, ActionRetry, ActionRouterExt as _},
         track::TrackAction,
     };
diff --git a/crates/cheers/src/response.rs b/crates/cheers/src/response.rs
index 070b571..6af18bd 100644
--- a/crates/cheers/src/response.rs
+++ b/crates/cheers/src/response.rs
@@ -1,35 +1,63 @@
-use std::{convert::Infallible, pin::Pin};
+use std::convert::Infallible;
 
-use futures::{Stream, StreamExt, stream::SelectAll};
+use futures::StreamExt;
 
 use crate::{
+    async_stream::AsyncScope,
     context::Context,
     render::{Buffer, Lazy, Render, Rendered},
 };
 
-pub struct AsyncLazy<R: Render> {
-    immediate: R,
-    stream: SelectAll<Pin<Box<dyn Stream<Item = Rendered<String>> + Send>>>,
+/// A page rendered by `html!` from a template containing `@async` blocks.
+///
+/// The response streams the page with each block's fallback first, then each block's content as
+/// it loads.
+pub struct AsyncLazy<F: AsyncRender> {
+    render: F,
 }
 
-impl<R: Render> AsyncLazy<R> {
+mod sealed {
+    pub trait Sealed {}
+}
+
+/// The render body of an [`AsyncLazy`], as generated by `html!`.
+pub trait AsyncRender: sealed::Sealed {
+    #[doc(hidden)]
+    fn render_async(&self, buffer: &mut Buffer, scope: &AsyncScope);
+}
+
+impl<F: Fn(&mut Buffer, &AsyncScope)> sealed::Sealed for F {}
+
+impl<F: Fn(&mut Buffer, &AsyncScope)> AsyncRender for F {
+    #[inline]
+    fn render_async(&self, buffer: &mut Buffer, scope: &AsyncScope) {
+        self(buffer, scope);
+    }
+}
+
+impl<F: Fn(&mut Buffer, &AsyncScope)> AsyncLazy<F> {
     #[doc(hidden)]
-    /// Used by the `html!` and `attribute!` macros when combining immediate output
-    /// with async streams. Not part of the stable public API.
-    pub fn __select_all(
-        immediate: R,
-        stream: SelectAll<Pin<Box<dyn Stream<Item = Rendered<String>> + Send>>>,
-    ) -> Self {
-        Self { immediate, stream }
+    /// Used by the `html!` macro for templates containing `@async` blocks.
+    /// Not part of the stable public API.
+    pub const fn __new(render: F) -> Self {
+        Self { render }
     }
 }
 
-impl<R: Render> axum::response::IntoResponse for AsyncLazy<R> {
+impl<F: AsyncRender> axum::response::IntoResponse for AsyncLazy<F> {
     fn into_response(self) -> axum::response::Response {
-        let immediate = self.immediate.render().into_inner();
+        let mut buffer = Buffer::new();
+        let scope = AsyncScope::root();
+        self.render.render_async(&mut buffer, &scope);
+        let streams = scope.into_streams();
+        let immediate = buffer.rendered().into_inner();
+
         let body = axum::body::Body::from_stream(
-            futures::stream::once(async { Ok(immediate) })
-                .chain(self.stream.map(|s| s.into_inner()).map(Ok::<_, Infallible>)),
+            futures::stream::once(async { Ok(immediate) }).chain(
+                futures::stream::select_all(streams)
+                    .map(|s| s.into_inner())
+                    .map(Ok::<_, Infallible>),
+            ),
         );
 
         (
diff --git a/crates/cheers/tests/main.rs b/crates/cheers/tests/main.rs
index ced0925..8248daa 100644
--- a/crates/cheers/tests/main.rs
+++ b/crates/cheers/tests/main.rs
@@ -1249,8 +1249,7 @@ async fn page_is_rendered() {
 
 #[tokio::test]
 async fn ref_expr_can_borrow_async_leading_let_bindings() {
-    async fn main_page() -> cheers::prelude::AsyncLazy<cheers::prelude::Lazy<impl Fn(&mut Buffer)>>
-    {
+    async fn main_page() -> cheers::prelude::AsyncLazy<impl AsyncRender> {
         html! {
             Base {
                 @async {
@@ -1276,8 +1275,7 @@ async fn ref_expr_can_borrow_async_leading_let_bindings() {
 
 #[tokio::test]
 async fn page_async_block_is_streamed() {
-    async fn main_page() -> cheers::prelude::AsyncLazy<cheers::prelude::Lazy<impl Fn(&mut Buffer)>>
-    {
+    async fn main_page() -> cheers::prelude::AsyncLazy<impl AsyncRender> {
         html! {
             Base {
                 article {
@@ -1316,8 +1314,7 @@ async fn page_async_block_is_streamed() {
 
 #[tokio::test]
 async fn whitespace_separated_async_blocks_get_distinct_ssr_keys() {
-    async fn main_page() -> cheers::prelude::AsyncLazy<cheers::prelude::Lazy<impl Fn(&mut Buffer)>>
-    {
+    async fn main_page() -> cheers::prelude::AsyncLazy<impl AsyncRender> {
         html! {
             @async {
                 div { "First" }
@@ -1349,8 +1346,7 @@ async fn whitespace_separated_async_blocks_get_distinct_ssr_keys() {
 
 #[tokio::test]
 async fn nested_async_can_use_outer_async_let_binding() {
-    async fn main_page() -> cheers::prelude::AsyncLazy<cheers::prelude::Lazy<impl Fn(&mut Buffer)>>
-    {
+    async fn main_page() -> cheers::prelude::AsyncLazy<impl AsyncRender> {
         html! {
             @async {
                 @let data = async { "outer data" }.await;
@@ -1383,8 +1379,7 @@ async fn nested_async_can_use_outer_async_let_binding() {
 
 #[tokio::test]
 async fn nested_async_inside_component_body_can_use_outer_binding() {
-    async fn main_page() -> cheers::prelude::AsyncLazy<cheers::prelude::Lazy<impl Fn(&mut Buffer)>>
-    {
+    async fn main_page() -> cheers::prelude::AsyncLazy<impl AsyncRender> {
         html! {
             @async {
                 @let data = async { "component data" }.await;
@@ -1419,8 +1414,7 @@ async fn nested_async_inside_component_body_can_use_outer_binding() {
 
 #[tokio::test]
 async fn nested_async_can_use_enclosing_for_binding() {
-    async fn main_page() -> cheers::prelude::AsyncLazy<cheers::prelude::Lazy<impl Fn(&mut Buffer)>>
-    {
+    async fn main_page() -> cheers::prelude::AsyncLazy<impl AsyncRender> {
         html! {
             @async {
                 @for data in ::std::iter::once("loop data") {
@@ -1454,8 +1448,7 @@ async fn nested_async_can_use_enclosing_for_binding() {
 
 #[tokio::test]
 async fn nested_async_collector_is_scoped_before_later_awaits() {
-    async fn main_page() -> cheers::prelude::AsyncLazy<cheers::prelude::Lazy<impl Fn(&mut Buffer)>>
-    {
+    async fn main_page() -> cheers::prelude::AsyncLazy<impl AsyncRender> {
         html! {
             @async {
                 @async {
@@ -1499,8 +1492,7 @@ async fn nested_async_collector_is_scoped_before_later_awaits() {
 
 #[tokio::test]
 async fn async_leading_let_borrow_dependency_renders() {
-    async fn main_page() -> cheers::prelude::AsyncLazy<cheers::prelude::Lazy<impl Fn(&mut Buffer)>>
-    {
+    async fn main_page() -> cheers::prelude::AsyncLazy<impl AsyncRender> {
         html! {
             @async {
                 @let owner = String::from("borrowed data");
@@ -1525,11 +1517,296 @@ async fn async_leading_let_borrow_dependency_renders() {
     assert!(got.contains("<div>borrowed data</div>"), "{got}");
 }
 
+async fn all_axum_chunks(response: impl IntoResponse) -> Vec<String> {
+    use futures::StreamExt;
+
+    let mut body = response.into_response().into_body().into_data_stream();
+    let mut chunks = Vec::new();
+    while let Some(chunk) = body.next().await {
+        let chunk = chunk.expect("body chunk should be readable");
+        chunks.push(String::from_utf8(chunk.to_vec()).expect("body chunk should be valid UTF-8"));
+    }
+    chunks
+}
+
+/// Keys of rendered `@async` fallbacks, in document order. With async islands enabled, the island
+/// wrapper repeats its fallback's key.
+fn fallback_ssr_keys(html: &str) -> Vec<&str> {
+    let mut keys = Vec::new();
+    for key in html
+        .split("data-ssr=\"")
+        .skip(1)
+        .filter_map(|rest| rest.split('"').next())
+        .filter(|key| !key.ends_with("-t") && !key.ends_with("-s"))
+    {
+        if keys.last() != Some(&key) {
+            keys.push(key);
+        }
+    }
+    keys
+}
+
+#[tokio::test]
+async fn async_inside_for_streams_once_per_iteration() {
+    let chunks = all_axum_chunks(html! {
+        @for id in 0..3_u32 {
+            @async {
+                div { "item " (id) }
+            } @else {
+                p { "Loading " (id) }
+            }
+        }
+    })
+    .await;
+
+    let keys = fallback_ssr_keys(&chunks[0]);
+    assert_eq!(
+        keys.iter().collect::<std::collections::BTreeSet<_>>().len(),
+        3,
+        "{chunks:?}"
+    );
+
+    assert_eq!(chunks.len(), 4, "{chunks:?}");
+    for (id, key) in keys.iter().enumerate() {
+        let chunk = chunks[1..]
+            .iter()
+            .find(|chunk| chunk.contains(&format!("<div>item {id}</div>")))
+            .unwrap_or_else(|| panic!("missing stream for item {id}: {chunks:?}"));
+        assert!(chunk.contains(&format!(r#"data-ssr="{key}-t""#)), "{chunk}");
+        assert!(chunk.contains(&format!("__ssrStream('{key}')")), "{chunk}");
+    }
+}
+
+#[tokio::test]
+async fn async_in_unrendered_branch_is_not_started() {
+    let started = Arc::new(AtomicBool::new(false));
+    let flag = Arc::clone(&started);
+    let show = false;
+
+    let chunks = all_axum_chunks(html! {
+        @if show {
+            @async {
+                @let () = flag.store(true, Ordering::SeqCst);
+                div { "Loaded" }
+            } @else {
+                p { "Loading" }
+            }
+        }
+    })
+    .await;
+
+    assert_eq!(chunks.len(), 1, "{chunks:?}");
+    assert!(!chunks[0].contains("Loading"), "{chunks:?}");
+    assert!(!started.load(Ordering::SeqCst));
+}
+
+#[tokio::test]
+async fn async_in_rendered_branch_can_move_outer_future() {
+    let data = async { String::from("moved data") };
+    let show = true;
+
+    let chunks = all_axum_chunks(html! {
+        Base {
+            @if show {
+                @async {
+                    @let data = data.await;
+                    div { (data) }
+                } @else {
+                    p { "Loading" }
+                }
+            }
+        }
+    })
+    .await;
+
+    assert!(chunks[0].contains("Loading"), "{chunks:?}");
+    assert_eq!(chunks.len(), 2, "{chunks:?}");
+    assert!(chunks[1].contains("<div>moved data</div>"), "{chunks:?}");
+}
+
+#[tokio::test]
+async fn async_moving_outer_future_ignores_names_that_are_not_binding_uses() {
+    let loaded = async { String::from("moved data") };
+
+    let chunks = all_axum_chunks(html! {
+        @let id = "page";
+        @let data = "template data";
+        Base {
+            p id=(id) { (data) }
+            @async {
+                @let data = loaded.await;
+                div id="loaded" { (data) }
+            } @else {
+                p { "Loading" }
+            }
+        }
+    })
+    .await;
+
+    assert!(chunks[0].contains("template data"), "{chunks:?}");
+    assert_eq!(chunks.len(), 2, "{chunks:?}");
+    assert!(
+        chunks[1].contains("<div id=\"loaded\">moved data</div>"),
+        "{chunks:?}"
+    );
+}
+
+#[tokio::test]
+async fn nested_async_can_move_a_value_its_parent_body_uses() {
+    let text = String::from("abc");
+
+    let chunks = all_axum_chunks(html! {
+        @async {
+            p { (text.len()) }
+            @async {
+                div { (text) }
+            } @else {
+                p { "Loading inner" }
+            }
+        } @else {
+            p { "Loading outer" }
+        }
+    })
+    .await;
+
+    assert_eq!(chunks.len(), 3, "{chunks:?}");
+    assert!(chunks[1].contains("<p>3</p>"), "{chunks:?}");
+    assert!(chunks[2].contains("<div>abc</div>"), "{chunks:?}");
+}
+
+#[tokio::test]
+async fn async_detects_bindings_used_through_macro_ranges_and_width_captures() {
+    let chunks = all_axum_chunks(html! {
+        @let n = 3_u32;
+        @let w = 4_usize;
+        @async {
+            div { (format!("{:?}", (0..n).collect::<Vec<_>>())) }
+            span { (format!("[{:>w$}]", "a")) }
+        } @else {
+            p { "Loading" }
+        }
+    })
+    .await;
+
+    assert_eq!(chunks.len(), 2, "{chunks:?}");
+    assert!(chunks[1].contains("[0, 1, 2]"), "{chunks:?}");
+    assert!(chunks[1].contains("[   a]"), "{chunks:?}");
+}
+
+#[derive(Cheers)]
+struct RendersChildrenSeparately<T> {
+    children: T,
+}
+
+impl<T: Render> Render for RendersChildrenSeparately<T> {
+    fn render_to(&self, buffer: &mut Buffer<Element>) {
+        let mut children = Buffer::new();
+        self.children.render_to(&mut children);
+        // XSS SAFETY: `children` holds markup rendered by `Render`
+        buffer
+            .dangerously_get_string()
+            .push_str(&children.rendered().into_inner());
+    }
+}
+
+#[tokio::test]
+async fn async_in_children_rendered_into_another_buffer_streams() {
+    let chunks = all_axum_chunks(html! {
+        RendersChildrenSeparately {
+            @async {
+                div { (async { "streamed" }.await) }
+            } @else {
+                p { "Loading" }
+            }
+        }
+    })
+    .await;
+
+    assert!(chunks[0].contains("Loading"), "{chunks:?}");
+    assert_eq!(chunks.len(), 2, "{chunks:?}");
+    assert!(chunks[1].contains("<div>streamed</div>"), "{chunks:?}");
+}
+
+#[tokio::test]
+async fn async_can_use_if_let_and_match_bindings() {
+    let name = Some("if-let data");
+    let count = 2_u32;
+
+    let chunks = all_axum_chunks(html! {
+        @if let Some(name) = name {
+            @async {
+                div { (name) }
+            } @else {
+                p { "Loading name" }
+            }
+        }
+        @match count {
+            n @ 1.. => @async {
+                div { "count " (n) }
+            } @else {
+                p { "Loading count" }
+            },
+            _ => {}
+        }
+    })
+    .await;
+
+    let streamed = chunks[1..].concat();
+    assert_eq!(chunks.len(), 3, "{chunks:?}");
+    assert!(streamed.contains("<div>if-let data</div>"), "{chunks:?}");
+    assert!(streamed.contains("<div>count 2</div>"), "{chunks:?}");
+}
+
+#[tokio::test]
+async fn async_detects_bindings_used_through_format_captures() {
+    let chunks = all_axum_chunks(html! {
+        @for item in ["a", "b"] {
+            @async {
+                div { (format!("item {item}")) }
+            } @else {
+                p { "Loading" }
+            }
+        }
+    })
+    .await;
+
+    let streamed = chunks[1..].concat();
+    assert!(streamed.contains("<div>item a</div>"), "{chunks:?}");
+    assert!(streamed.contains("<div>item b</div>"), "{chunks:?}");
+}
+
+#[tokio::test]
+async fn nested_async_in_repeated_parent_gets_distinct_keys() {
+    let chunks = all_axum_chunks(html! {
+        @for id in 0..2_u32 {
+            @async {
+                @async {
+                    div { "inner " (id) }
+                } @else {
+                    p { "Inner loading" }
+                }
+            } @else {
+                p { "Outer loading" }
+            }
+        }
+    })
+    .await;
+
+    let all = chunks.concat();
+    let keys = fallback_ssr_keys(&all);
+    assert_eq!(
+        keys.iter().collect::<std::collections::BTreeSet<_>>().len(),
+        4,
+        "{chunks:?}"
+    );
+    assert!(all.contains("<div>inner 0</div>"), "{chunks:?}");
+    assert!(all.contains("<div>inner 1</div>"), "{chunks:?}");
+}
+
 #[cfg(all(debug_assertions, feature = "subsecond"))]
 #[tokio::test]
 async fn async_block_gets_hot_root_without_cached_syntax() {
-    async fn main_page() -> cheers::prelude::AsyncLazy<cheers::prelude::Lazy<impl Fn(&mut Buffer)>>
-    {
+    async fn main_page() -> cheers::prelude::AsyncLazy<impl AsyncRender> {
         html! {
             Base {
                 article {
@@ -1588,8 +1865,7 @@ async fn async_block_gets_hot_root_without_cached_syntax() {
 #[cfg(all(debug_assertions, feature = "subsecond"))]
 #[tokio::test]
 async fn async_block_registers_static_hot_render_continuation() {
-    async fn main_page() -> cheers::prelude::AsyncLazy<cheers::prelude::Lazy<impl Fn(&mut Buffer)>>
-    {
+    async fn main_page() -> cheers::prelude::AsyncLazy<impl AsyncRender> {
         html! {
             Base {
                 article {
@@ -1630,8 +1906,7 @@ async fn async_block_registers_static_hot_render_continuation() {
 #[cfg(all(debug_assertions, feature = "subsecond"))]
 #[tokio::test]
 async fn async_block_with_dynamic_control_flow_does_not_register_hot_render_continuation() {
-    async fn main_page() -> cheers::prelude::AsyncLazy<cheers::prelude::Lazy<impl Fn(&mut Buffer)>>
-    {
+    async fn main_page() -> cheers::prelude::AsyncLazy<impl AsyncRender> {
         html! {
             Base {
                 article {
@@ -1676,8 +1951,7 @@ async fn async_block_with_dynamic_control_flow_does_not_register_hot_render_cont
 #[cfg(all(debug_assertions, feature = "subsecond"))]
 #[tokio::test]
 async fn async_block_with_outer_capture_does_not_register_hot_render_continuation() {
-    async fn main_page() -> cheers::prelude::AsyncLazy<cheers::prelude::Lazy<impl Fn(&mut Buffer)>>
-    {
+    async fn main_page() -> cheers::prelude::AsyncLazy<impl AsyncRender> {
         let title = String::from("Title: ");
 
         html! {
@@ -1846,7 +2120,7 @@ async fn async_can_render_concurrently_in_order() {
         content: String,
         outages_today: i32,
         sync: SyncPrimitives,
-    ) -> AsyncLazy<Lazy<impl Fn(&mut Buffer)>> {
+    ) -> AsyncLazy<impl AsyncRender> {
         let post_html = {
             let barrier = sync.barrier.clone();
             let mutex_a = sync.mutex_a.clone();
diff --git a/examples/readme/src/main.rs b/examples/readme/src/main.rs
index a21dbce..d6bbd5a 100644
--- a/examples/readme/src/main.rs
+++ b/examples/readme/src/main.rs
@@ -71,7 +71,7 @@ impl Render for DwarfList {
     }
 }
 
-async fn hall_of_ancestors(_: State<Ctx>) -> AsyncLazy<impl Render> {
+async fn hall_of_ancestors(_: State<Ctx>) -> AsyncLazy<impl AsyncRender> {
     let thorin = async {
         tokio::time::sleep(Duration::from_millis(300)).await;
         Dwarf {
diff --git a/examples/realtime/src/main.rs b/examples/realtime/src/main.rs
index fb7c7b3..01a675d 100644
--- a/examples/realtime/src/main.rs
+++ b/examples/realtime/src/main.rs
@@ -82,7 +82,7 @@ impl<'a> Render for Stock<'a> {
     }
 }
 
-async fn home_page(ctx: State<Ctx>) -> AsyncLazy<impl Render> {
+async fn home_page(ctx: State<Ctx>) -> AsyncLazy<impl AsyncRender> {
     let get_stocks = async move || {
         tokio::time::sleep(Duration::from_millis(500)).await;
         ctx.stocks