diff --git a/CLAUDE.md b/CLAUDE.md
index 7579509..f1faa66 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -6,7 +6,7 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
 
 Cargo workspace (`afterglow`, `afterglow-macros`, `supernova`, `supernovi`, `web-shove`) plus a standalone frontend in `app/` that is **not** part of the workspace.
 
-- **`afterglow/`** + **`afterglow-macros/`** — Suspense-style streaming HTML templating: trees with `Node::Pending` futures render as a shell with `<?marker>`/`<?start>…<?end>` placeholders, backfilled by streamed `<template for="N">` chunks (Chrome declarative partial updates wire format). `render_stream` fills in completion order, `render_stream_ordered` in registration order. The `html!{}` proc macro (in `afterglow-macros`) supports `@{future} else { fallback }` for async widgets. Widget futures are driven by the response stream itself — never `tokio::spawn` them, or drop-based cancellation breaks. See `afterglow/README.md` and `cargo run --example axum_demo`.
+- **`afterglow/`** + **`afterglow-macros/`** — Suspense-style streaming HTML templating: trees with `Node::Pending` futures or `Node::Stream` sources render as a shell with `<?marker name="N">`/`<?start name="N">…<?end>` placeholders (Chrome declarative partial updates wire format), backfilled by streamed `<template for="N">` chunks — one chunk for a `Pending` slot, repeated patches to the same slot for a `Stream` source (live-updating regions). `render_stream` fills in completion order, `render_stream_ordered` in registration order. The `html!{}` proc macro (in `afterglow-macros`) supports `@{future} else { fallback }` for one-shot async widgets and `@*{stream} else { fallback }` for `IntoNodeStream` sources, and folds all static markup (plus `const { expr }` compile-time splices via `concat!`) at expansion time into `&'static str` segments (escaping happens in the macro — keep `afterglow-macros`' escape/void-element copies in sync with `afterglow/src/escape.rs` and `render.rs`); fully static templates are const-constructible. Widget futures and stream sources are driven by the response stream itself — never `tokio::spawn` them, or drop-based cancellation breaks. `IntoNodeStream` is a deliberate abstraction boundary so `std::async_iter`/`async gen` can plug in later without touching the driver or wire format. See `afterglow/README.md` and `cargo run --example axum_demo`.
 - **`web-shove/`** — Library crate implementing Web Push from scratch: RFC 8291 message encryption (ECDH P-256 key exchange, HKDF key derivation, AES-128-GCM, `aes128gcm` content-coding header) in `src/lib.rs`, VAPID key handling in `src/vapid.rs`, and the VAPID JWT `Authorization` header in `src/authorization_header.rs`. Also has a small binary (`src/main.rs`) that generates and prints a new base64url-encoded VAPID private key. Tests use `rstest` fixtures and assert against the RFC 8291 Appendix A test vectors.
 - **`supernova/`** — Axum web server (binds `127.0.0.1:3000`). Routes: `GET /` (server-rendered page from `templates/`), `POST /signin`, `POST /notifications/subscriptions`, `POST /notifications/push`. Static files served from `supernova/public/` (includes the service worker and push-subscription JS). Depends on `web-shove` for push payload encryption. Push subscriptions are held in-memory (`Arc<Mutex<Vec<Subscription>>>` in `AppState`) — nothing is persisted yet.
 - **`supernovi/`** — Minimal scratch binary that only tests Bitwarden Secrets Manager login.
diff --git a/afterglow-macros/src/lib.rs b/afterglow-macros/src/lib.rs
index bbae4c5..9119b4d 100644
--- a/afterglow-macros/src/lib.rs
+++ b/afterglow-macros/src/lib.rs
@@ -13,17 +13,43 @@ use quote::quote;
 /// - **Attributes**: `name="literal"`, `name={expr}` (the expression is
 ///   converted with `ToString` and escaped on render), or bare boolean
 ///   attributes like `disabled`.
-/// - **Text**: string literals in child position, escaped on render:
-///   `<p>"a < b"</p>`.
+/// - **Text**: string literals in child position, escaped: `<p>"a < b"</p>`.
 /// - **Interpolation**: `{expr}` in child position converts the expression
 ///   via `afterglow::Render` (strings and numbers render as escaped text).
 /// - **Async widgets**: `@{expr}` where `expr` is a future. Renders a
-///   `<?marker id="N">` placeholder in the shell; the resolved value is
+///   `<?marker name="N">` placeholder in the shell; the resolved value is
 ///   converted via `Render` (so `Result<impl Render, E: Display>` works and
 ///   an `Err` renders as an error slot).
 /// - **Fallback form**: `@{expr} else { <span>"loading…"</span> }` renders
-///   the fallback markup between `<?start id="N">` and `<?end>` until the
+///   the fallback markup between `<?start name="N">` and `<?end>` until the
 ///   future resolves. The fallback may itself contain `@{...}` widgets.
+/// - **Streamed values**: `@*{expr}` where `expr` implements
+///   `IntoNodeStream` (any `Stream` whose items implement `Render`). Renders
+///   the same placeholder as `@{...}`; each value is streamed as its own
+///   `<template for="N">` patch as it arrives. Takes the same optional
+///   `else { fallback }` form; an empty source simply leaves the fallback in
+///   place. See `Node::stream` for cancellation and termination semantics.
+/// - **Const interpolation**: `const { expr }` in child position splices a
+///   compile-time string into the surrounding static segment via `concat!`,
+///   e.g. `const { env!("CARGO_PKG_NAME") }`. The expression must be a
+///   literal or a built-in literal macro (`env!`, `include_str!`,
+///   `stringify!`, ...) — arbitrary `const` items are not accepted by
+///   `concat!`. The value is spliced **verbatim** (no escaping; it is
+///   developer-controlled), and the segment stays a single `&'static str`,
+///   so fully static templates using it remain const-constructible.
+///
+/// # Compile-time prerendering
+///
+/// All static markup is rendered and escaped at macro expansion time:
+/// adjacent tags, literal attribute values, and literal text collapse into
+/// `&'static str` segments stored in the binary. Dynamic holes — `{expr}`,
+/// `@{...}`, and elements with `attr={expr}` — are the only per-request
+/// construction work. A fully static template expands to a single
+/// `Node::Html(Cow::Borrowed(...))`, which is legal in const context:
+///
+/// ```ignore
+/// const FOOTER: Node = html! { <footer>"© 2026"</footer> };
+/// ```
 ///
 /// # Example
 ///
@@ -38,11 +64,51 @@ use quote::quote;
 #[proc_macro]
 pub fn html(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
     match Parser::new(input.into()).parse_root() {
-        Ok(output) => output.into(),
+        Ok(nodes) => generate(nodes).into(),
         Err(error) => error.to_compile_error().into(),
     }
 }
 
+// ---------------------------------------------------------------------------
+// AST
+// ---------------------------------------------------------------------------
+
+enum Ast {
+    Element {
+        tag: String,
+        attributes: Vec<Attribute>,
+        children: Vec<Ast>,
+    },
+    Text(String),
+    Interpolation(syn::Expr),
+    /// `const { expr }` — a compile-time string spliced verbatim into the
+    /// surrounding static segment via `concat!`.
+    ConstHtml(syn::Expr),
+    Pending {
+        future: syn::Expr,
+        fallback: Option<Vec<Ast>>,
+    },
+    Stream {
+        source: syn::Expr,
+        fallback: Option<Vec<Ast>>,
+    },
+}
+
+struct Attribute {
+    name: String,
+    value: AttributeValue,
+}
+
+enum AttributeValue {
+    Bare,
+    Literal(String),
+    Expression(syn::Expr),
+}
+
+// ---------------------------------------------------------------------------
+// Parsing
+// ---------------------------------------------------------------------------
+
 struct Parser {
     tokens: Vec<TokenTree>,
     position: usize,
@@ -95,17 +161,17 @@ impl Parser {
         matches!(self.peek(), Some(TokenTree::Punct(punct)) if punct.as_char() == expected)
     }
 
-    fn parse_root(mut self) -> syn::Result<TokenStream> {
+    fn parse_root(mut self) -> syn::Result<Vec<Ast>> {
         let nodes = self.parse_nodes()?;
         if self.peek().is_some() {
             return Err(self.error_here("unexpected token after markup"));
         }
-        Ok(combine_nodes(nodes))
+        Ok(nodes)
     }
 
     /// Parses child nodes until a closing tag (`</`) or end of input. The
     /// closing tag itself is left for the caller.
-    fn parse_nodes(&mut self) -> syn::Result<Vec<TokenStream>> {
+    fn parse_nodes(&mut self) -> syn::Result<Vec<Ast>> {
         let mut nodes = Vec::new();
         loop {
             match self.peek() {
@@ -125,11 +191,22 @@ impl Parser {
                     nodes.push(self.parse_interpolation()?);
                 }
                 Some(TokenTree::Punct(punct)) if punct.as_char() == '@' => {
-                    nodes.push(self.parse_pending()?);
+                    let is_stream = matches!(
+                        self.peek_second(),
+                        Some(TokenTree::Punct(second)) if second.as_char() == '*'
+                    );
+                    nodes.push(if is_stream {
+                        self.parse_stream()?
+                    } else {
+                        self.parse_pending()?
+                    });
+                }
+                Some(TokenTree::Ident(ident)) if ident == "const" => {
+                    nodes.push(self.parse_const()?);
                 }
                 Some(_) => {
                     return Err(self.error_here(
-                        "expected an element, a quoted string, `{expr}`, or `@{future}`",
+                        "expected an element, a quoted string, `{expr}`, `@{future}`, or `@*{stream}`",
                     ));
                 }
             }
@@ -159,7 +236,7 @@ impl Parser {
         Ok((name, span))
     }
 
-    fn parse_element(&mut self) -> syn::Result<TokenStream> {
+    fn parse_element(&mut self) -> syn::Result<Ast> {
         self.expect_punct('<')?;
         let (tag, tag_span) = self.parse_name()?;
 
@@ -169,7 +246,11 @@ impl Parser {
                 Some(TokenTree::Punct(punct)) if punct.as_char() == '/' => {
                     self.advance();
                     self.expect_punct('>')?;
-                    return Ok(build_element(&tag, attributes, Vec::new()));
+                    return Ok(Ast::Element {
+                        tag,
+                        attributes,
+                        children: Vec::new(),
+                    });
                 }
                 Some(TokenTree::Punct(punct)) if punct.as_char() == '>' => {
                     self.advance();
@@ -195,10 +276,14 @@ impl Parser {
         }
         self.expect_punct('>')?;
 
-        Ok(build_element(&tag, attributes, children))
+        Ok(Ast::Element {
+            tag,
+            attributes,
+            children,
+        })
     }
 
-    fn parse_attribute(&mut self) -> syn::Result<TokenStream> {
+    fn parse_attribute(&mut self) -> syn::Result<Attribute> {
         let (name, _) = self.parse_name()?;
 
         let value = if self.peek_is_punct('=') {
@@ -211,17 +296,10 @@ impl Parser {
                             "attribute values must be string literals or `{expr}`",
                         ));
                     };
-                    quote! {
-                        ::std::option::Option::Some(::std::string::String::from(#string))
-                    }
+                    AttributeValue::Literal(string.value())
                 }
                 Some(TokenTree::Group(group)) if group.delimiter() == Delimiter::Brace => {
-                    let expression: syn::Expr = syn::parse2(group.stream())?;
-                    quote! {
-                        ::std::option::Option::Some(
-                            ::std::string::ToString::to_string(&(#expression)),
-                        )
-                    }
+                    AttributeValue::Expression(syn::parse2(group.stream())?)
                 }
                 _ => {
                     return Err(
@@ -230,13 +308,13 @@ impl Parser {
                 }
             }
         } else {
-            quote! { ::std::option::Option::None }
+            AttributeValue::Bare
         };
 
-        Ok(quote! { (::std::borrow::Cow::Borrowed(#name), #value) })
+        Ok(Attribute { name, value })
     }
 
-    fn parse_text(&mut self) -> syn::Result<TokenStream> {
+    fn parse_text(&mut self) -> syn::Result<Ast> {
         let Some(TokenTree::Literal(literal)) = self.advance() else {
             unreachable!("parse_text is only called when peeking a literal");
         };
@@ -246,32 +324,66 @@ impl Parser {
                 "text content must be a quoted string; interpolate other values with `{expr}`",
             ));
         };
-        Ok(quote! { ::afterglow::Node::text(#string) })
+        Ok(Ast::Text(string.value()))
     }
 
-    fn parse_interpolation(&mut self) -> syn::Result<TokenStream> {
+    fn parse_interpolation(&mut self) -> syn::Result<Ast> {
         let Some(TokenTree::Group(group)) = self.advance() else {
             unreachable!("parse_interpolation is only called when peeking a brace group");
         };
-        let expression: syn::Expr = syn::parse2(group.stream())?;
-        Ok(quote! { ::afterglow::Render::into_node(#expression) })
+        Ok(Ast::Interpolation(syn::parse2(group.stream())?))
+    }
+
+    /// Parses `const { expr }`.
+    fn parse_const(&mut self) -> syn::Result<Ast> {
+        self.advance(); // the `const` keyword
+        let Some(TokenTree::Group(group)) = self.peek() else {
+            return Err(self.error_here("expected `{ expr }` after `const`"));
+        };
+        if group.delimiter() != Delimiter::Brace {
+            return Err(self.error_here("expected `{ expr }` after `const`"));
+        }
+        let Some(TokenTree::Group(group)) = self.advance() else {
+            unreachable!("peeked above");
+        };
+        Ok(Ast::ConstHtml(syn::parse2(group.stream())?))
     }
 
     /// Parses `@{future}` with an optional `else { fallback markup }`.
-    fn parse_pending(&mut self) -> syn::Result<TokenStream> {
+    fn parse_pending(&mut self) -> syn::Result<Ast> {
+        self.expect_punct('@')?;
+        let future = self.parse_brace_expr("expected `{future}` after `@`")?;
+        let fallback = self.parse_optional_else_fallback()?;
+        Ok(Ast::Pending { future, fallback })
+    }
+
+    /// Parses `@*{stream}` with an optional `else { fallback markup }`.
+    fn parse_stream(&mut self) -> syn::Result<Ast> {
         self.expect_punct('@')?;
+        self.expect_punct('*')?;
+        let source = self.parse_brace_expr("expected `{stream}` after `@*`")?;
+        let fallback = self.parse_optional_else_fallback()?;
+        Ok(Ast::Stream { source, fallback })
+    }
+
+    /// Parses a `{ expr }` group, used by both `@{...}` and `@*{...}`.
+    fn parse_brace_expr(&mut self, error_message: &str) -> syn::Result<syn::Expr> {
         let Some(TokenTree::Group(group)) = self.peek() else {
-            return Err(self.error_here("expected `{future}` after `@`"));
+            return Err(self.error_here(error_message));
         };
         if group.delimiter() != Delimiter::Brace {
-            return Err(self.error_here("expected `{future}` after `@`"));
+            return Err(self.error_here(error_message));
         }
         let Some(TokenTree::Group(group)) = self.advance() else {
             unreachable!("peeked above");
         };
-        let expression: syn::Expr = syn::parse2(group.stream())?;
+        syn::parse2(group.stream())
+    }
 
-        let fallback = match self.peek() {
+    /// Parses an optional `else { fallback markup }`, used by both `@{...}`
+    /// and `@*{...}`.
+    fn parse_optional_else_fallback(&mut self) -> syn::Result<Option<Vec<Ast>>> {
+        match self.peek() {
             Some(TokenTree::Ident(ident)) if ident == "else" => {
                 self.advance();
                 let Some(TokenTree::Group(group)) = self.peek() else {
@@ -283,48 +395,247 @@ impl Parser {
                 let Some(TokenTree::Group(group)) = self.advance() else {
                     unreachable!("peeked above");
                 };
-                let mut fallback_parser = Parser::new(group.stream());
-                let nodes = fallback_parser.parse_nodes()?;
-                if fallback_parser.peek().is_some() {
-                    return Err(fallback_parser.error_here("unexpected token in fallback markup"));
-                }
-                Some(combine_nodes(nodes))
+                Ok(Some(Parser::new(group.stream()).parse_root()?))
             }
-            _ => None,
+            _ => Ok(None),
+        }
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Code generation with static folding
+// ---------------------------------------------------------------------------
+
+fn generate(nodes: Vec<Ast>) -> TokenStream {
+    combine_parts(fold_to_parts(nodes))
+}
+
+/// One piece of a static segment: HTML rendered at expansion time, or a
+/// compile-time `const { ... }` expression spliced in via `concat!`.
+enum Piece {
+    Literal(String),
+    Const(syn::Expr),
+}
+
+/// Accumulates one static segment between dynamic holes.
+#[derive(Default)]
+struct SegmentBuffer {
+    pieces: Vec<Piece>,
+}
+
+impl SegmentBuffer {
+    /// The literal accumulator at the end of the segment, for content the
+    /// macro renders itself.
+    fn literal_mut(&mut self) -> &mut String {
+        if !matches!(self.pieces.last(), Some(Piece::Literal(_))) {
+            self.pieces.push(Piece::Literal(String::new()));
+        }
+        let Some(Piece::Literal(literal)) = self.pieces.last_mut() else {
+            unreachable!("pushed above");
         };
+        literal
+    }
 
-        Ok(match fallback {
-            None => quote! {
-                ::afterglow::Node::pending(async move { (#expression).await })
-            },
-            Some(fallback) => quote! {
-                ::afterglow::Node::pending_with_fallback(
-                    async move { (#expression).await },
-                    #fallback,
-                )
-            },
-        })
+    fn push_const(&mut self, expression: syn::Expr) {
+        self.pieces.push(Piece::Const(expression));
     }
 }
 
-fn combine_nodes(mut nodes: Vec<TokenStream>) -> TokenStream {
-    match nodes.len() {
-        0 => quote! { ::afterglow::Node::Fragment(::std::vec::Vec::new()) },
-        1 => nodes.pop().expect("length checked above"),
-        _ => quote! { ::afterglow::Node::fragment(::std::vec![#(#nodes),*]) },
+/// Folds a node list into alternating parts: pre-rendered `&'static str`
+/// segments for everything static, and one expression per dynamic hole.
+fn fold_to_parts(nodes: Vec<Ast>) -> Vec<TokenStream> {
+    let mut buffer = SegmentBuffer::default();
+    let mut parts = Vec::new();
+    fold_nodes(nodes, &mut buffer, &mut parts);
+    flush(&mut buffer, &mut parts);
+    parts
+}
+
+fn fold_nodes(nodes: Vec<Ast>, buffer: &mut SegmentBuffer, parts: &mut Vec<TokenStream>) {
+    for node in nodes {
+        match node {
+            Ast::Text(text) => escape_text_into(&text, buffer.literal_mut()),
+            Ast::ConstHtml(expression) => buffer.push_const(expression),
+            Ast::Interpolation(expression) => {
+                flush(buffer, parts);
+                parts.push(quote! { ::afterglow::Render::into_node(#expression) });
+            }
+            Ast::Pending { future, fallback } => {
+                flush(buffer, parts);
+                parts.push(match fallback {
+                    None => quote! {
+                        ::afterglow::Node::pending(async move { (#future).await })
+                    },
+                    Some(fallback) => {
+                        let fallback = combine_parts(fold_to_parts(fallback));
+                        quote! {
+                            ::afterglow::Node::pending_with_fallback(
+                                async move { (#future).await },
+                                #fallback,
+                            )
+                        }
+                    }
+                });
+            }
+            Ast::Stream { source, fallback } => {
+                flush(buffer, parts);
+                parts.push(match fallback {
+                    None => quote! {
+                        ::afterglow::Node::stream(#source)
+                    },
+                    Some(fallback) => {
+                        let fallback = combine_parts(fold_to_parts(fallback));
+                        quote! {
+                            ::afterglow::Node::stream_with_fallback(#source, #fallback)
+                        }
+                    }
+                });
+            }
+            Ast::Element {
+                tag,
+                attributes,
+                children,
+            } => {
+                let all_attributes_static = attributes
+                    .iter()
+                    .all(|attribute| !matches!(attribute.value, AttributeValue::Expression(_)));
+
+                if all_attributes_static {
+                    let out = buffer.literal_mut();
+                    out.push('<');
+                    out.push_str(&tag);
+                    for attribute in attributes {
+                        out.push(' ');
+                        out.push_str(&attribute.name);
+                        match attribute.value {
+                            AttributeValue::Bare => {}
+                            AttributeValue::Literal(value) => {
+                                out.push_str("=\"");
+                                escape_attribute_into(&value, out);
+                                out.push('"');
+                            }
+                            AttributeValue::Expression(_) => unreachable!("checked above"),
+                        }
+                    }
+                    out.push('>');
+                    // Void elements ignore children and have no closing tag,
+                    // matching the runtime renderer.
+                    if !is_void_element(&tag) {
+                        fold_nodes(children, buffer, parts);
+                        let out = buffer.literal_mut();
+                        out.push_str("</");
+                        out.push_str(&tag);
+                        out.push('>');
+                    }
+                } else {
+                    // A dynamic attribute value can only be escaped at
+                    // runtime, so this element keeps its structured form; its
+                    // children still fold.
+                    flush(buffer, parts);
+                    let attributes: Vec<_> =
+                        attributes.into_iter().map(attribute_tokens).collect();
+                    let children = fold_to_parts(children);
+                    parts.push(quote! {
+                        ::afterglow::Node::element(
+                            #tag,
+                            ::std::vec![#(#attributes),*],
+                            ::std::vec![#(#children),*],
+                        )
+                    });
+                }
+            }
+        }
     }
 }
 
-fn build_element(
-    tag: &str,
-    attributes: Vec<TokenStream>,
-    children: Vec<TokenStream>,
-) -> TokenStream {
-    quote! {
-        ::afterglow::Node::element(
-            #tag,
-            ::std::vec![#(#attributes),*],
-            ::std::vec![#(#children),*],
-        )
+fn flush(buffer: &mut SegmentBuffer, parts: &mut Vec<TokenStream>) {
+    let pieces: Vec<Piece> = std::mem::take(&mut buffer.pieces)
+        .into_iter()
+        .filter(|piece| !matches!(piece, Piece::Literal(literal) if literal.is_empty()))
+        .collect();
+    if pieces.is_empty() {
+        return;
+    }
+
+    // A plain segment stays a plain string literal; segments containing
+    // `const { ... }` pieces go through `concat!`, which eagerly expands
+    // built-in literal macros like `env!` and still yields one
+    // `&'static str` — so const-constructibility is preserved either way.
+    if let [Piece::Literal(segment)] = pieces.as_slice() {
+        parts.push(quote! {
+            ::afterglow::Node::Html(::std::borrow::Cow::Borrowed(#segment))
+        });
+        return;
+    }
+
+    let arguments = pieces.into_iter().map(|piece| match piece {
+        Piece::Literal(literal) => quote! { #literal },
+        Piece::Const(expression) => quote! { #expression },
+    });
+    parts.push(quote! {
+        ::afterglow::Node::Html(::std::borrow::Cow::Borrowed(
+            ::std::concat!(#(#arguments),*),
+        ))
+    });
+}
+
+fn combine_parts(mut parts: Vec<TokenStream>) -> TokenStream {
+    match parts.len() {
+        0 => quote! { ::afterglow::Node::Html(::std::borrow::Cow::Borrowed("")) },
+        1 => parts.pop().expect("length checked above"),
+        _ => quote! { ::afterglow::Node::fragment(::std::vec![#(#parts),*]) },
+    }
+}
+
+fn attribute_tokens(attribute: Attribute) -> TokenStream {
+    let name = attribute.name;
+    let value = match attribute.value {
+        AttributeValue::Bare => quote! { ::std::option::Option::None },
+        AttributeValue::Literal(value) => quote! {
+            ::std::option::Option::Some(::std::string::String::from(#value))
+        },
+        AttributeValue::Expression(expression) => quote! {
+            ::std::option::Option::Some(::std::string::ToString::to_string(&(#expression)))
+        },
+    };
+    quote! { (::std::borrow::Cow::Borrowed(#name), #value) }
+}
+
+// ---------------------------------------------------------------------------
+// Static rendering rules — keep in sync with the runtime renderer
+// (afterglow/src/escape.rs and afterglow/src/render.rs), so content folded at
+// expansion time is byte-identical to what runtime rendering would produce.
+// ---------------------------------------------------------------------------
+
+const VOID_ELEMENTS: &[&str] = &[
+    "area", "base", "br", "col", "embed", "hr", "img", "input", "link", "meta", "param", "source",
+    "track", "wbr",
+];
+
+fn is_void_element(tag: &str) -> bool {
+    VOID_ELEMENTS.contains(&tag)
+}
+
+fn escape_text_into(input: &str, out: &mut String) {
+    for character in input.chars() {
+        match character {
+            '&' => out.push_str("&amp;"),
+            '<' => out.push_str("&lt;"),
+            '>' => out.push_str("&gt;"),
+            character => out.push(character),
+        }
+    }
+}
+
+fn escape_attribute_into(input: &str, out: &mut String) {
+    for character in input.chars() {
+        match character {
+            '&' => out.push_str("&amp;"),
+            '<' => out.push_str("&lt;"),
+            '>' => out.push_str("&gt;"),
+            '"' => out.push_str("&quot;"),
+            '\'' => out.push_str("&#39;"),
+            character => out.push(character),
+        }
     }
 }
diff --git a/afterglow/README.md b/afterglow/README.md
index 0eb030d..6452ac4 100644
--- a/afterglow/README.md
+++ b/afterglow/README.md
@@ -5,7 +5,7 @@ some subtrees are futures: the renderer emits a **shell** immediately with
 placeholder markers for the pending parts, then streams filled-in content as
 each future resolves. The wire format is the one from Chrome's
 [declarative partial updates](https://developer.chrome.com/blog/declarative-partial-updates)
-feature: `<?marker id="N">` / `<?start id="N">fallback<?end>` placeholders,
+feature: `<?marker name="N">` / `<?start name="N">fallback<?end>` placeholders,
 filled later by `<template for="N">...</template>` blocks.
 
 This is a one-shot streaming model — no client-side state, no re-renders.
@@ -30,8 +30,8 @@ let page = html! {
 let body = render_stream(page);
 ```
 
-- `@{future}` renders a bare `<?marker id="N">` placeholder; add
-  `else { markup }` for fallback content between `<?start id="N">` and
+- `@{future}` renders a bare `<?marker name="N">` placeholder; add
+  `else { markup }` for fallback content between `<?start name="N">` and
   `<?end>`.
 - Async widgets return `Result<impl Render, E: Display>`; an `Err` renders as
   `<span class="afterglow-error">…</span>` in the slot instead of killing the
@@ -43,6 +43,30 @@ let body = render_stream(page);
 - Cancellation is free: dropping the stream (client disconnect) drops all
   pending widget futures. For that to work, **never `tokio::spawn` widget
   futures** — let the render stream drive them.
+- **Compile-time prerendering**: `html!` escapes and folds all static markup
+  at macro expansion time into `&'static str` segments stored in the binary;
+  the only per-request work is the dynamic holes (`{expr}`, `@{...}`, and
+  elements with `attr={expr}` values). A fully static template expands to a
+  single borrowed segment — it is const-constructible
+  (`const FOOTER: Node = html! { <footer>"© 2026"</footer> };`) and its shell
+  is streamed via `Bytes::from_static` without copying.
+- **Const interpolation**: `const { expr }` splices compile-time strings into
+  the static fold via `concat!`, e.g.
+  `const { env!("CARGO_PKG_NAME") }` — verbatim (no escaping), literals and
+  built-in literal macros only, and the template stays const-constructible.
+- **Streamed (live-updating) holes**: `@*{source}` where `source` implements
+  `IntoNodeStream` — any `Stream` whose items implement `Render`. Renders the
+  same placeholder as `@{...}` (with the same optional `else { fallback }`),
+  but instead of resolving once, each value from the source is streamed as
+  its own `<template for="N">` patch — per the declarative partial updates
+  format, repeated patches at the same marker are how a client expresses a
+  live-updating region. The response stays open until every future has
+  resolved *and* every stream has ended, so an infinite source means a
+  held-open, forever-streaming response. `IntoNodeStream` is the crate's
+  single intake point for "many values over time" — kept separate from
+  `futures::Stream` so that `std::async_iter::AsyncIterator` / `async gen`
+  blocks can plug in without changing `Node`, the driver, or the wire format,
+  once they stabilize.
 
 ## Streaming demo
 
@@ -61,16 +85,22 @@ shell immediately:
 
 ```html
 <html><head><title>afterglow demo</title></head><body><h1>Dashboard</h1>
-<section><h2>Weather</h2><?start id="0"><p>checking the sky…</p><?end></section>
-<section><h2>News</h2><?start id="1"><p>fetching headlines…</p><?end></section>
-<section><h2>Stocks</h2><?marker id="2"></section></body></html>
+<section><h2>Weather</h2><?start name="0"><p>checking the sky…</p><?end></section>
+<section><h2>News</h2><?start name="1"><p>fetching headlines…</p><?end></section>
+<section><h2>Stocks</h2><?marker name="2"></section></body></html>
 ```
 
 followed by the widget fills as their (artificial) delays elapse, in
-completion order:
+completion order. Slot 3, the "Live price" section, patches five times as new
+ticks arrive instead of resolving once:
 
 ```html
-<template for="0"><p>21 °C, clear skies</p></template>          <!-- t+0.8s -->
+<template for="3"><span>$101.00</span></template>                <!-- t+0.4s -->
+<template for="0"><p>21 °C, clear skies</p></template>            <!-- t+0.8s -->
+<template for="3"><span>$102.01</span></template>                 <!-- t+0.8s -->
+<template for="3"><span>$103.03</span></template>                 <!-- t+1.2s -->
 <template for="2"><span class="afterglow-error">stock service unavailable</span></template>  <!-- t+1.5s -->
+<template for="3"><span>$104.06</span></template>                 <!-- t+1.6s -->
+<template for="3"><span>$105.10</span></template>                 <!-- t+2.0s -->
 <template for="1"><ul><li>Streaming HTML lands in afterglow</li>…</ul></template>  <!-- t+2.5s -->
 ```
diff --git a/afterglow/examples/axum_demo.rs b/afterglow/examples/axum_demo.rs
index 3ec9549..c569738 100644
--- a/afterglow/examples/axum_demo.rs
+++ b/afterglow/examples/axum_demo.rs
@@ -6,7 +6,10 @@
 //! ```
 //!
 //! The shell arrives immediately with spinners; the widget `<template>`
-//! chunks trickle in over the next ~2.5 seconds.
+//! chunks trickle in over the next ~2.5 seconds. The "Live price" section
+//! uses `@*{...}` (a stream hole) instead of `@{...}` (a future hole): it
+//! patches the same slot five times as new ticks arrive, rather than
+//! resolving once.
 
 use std::net::Ipv4Addr;
 use std::time::Duration;
@@ -16,6 +19,7 @@ use axum::body::Body;
 use axum::http::header;
 use axum::response::{IntoResponse, Response};
 use axum::routing::get;
+use futures::Stream;
 use tokio::time::sleep;
 
 use afterglow::{Node, html, render_stream};
@@ -42,6 +46,30 @@ async fn stock_ticker() -> Result<Node, &'static str> {
     Err("stock service unavailable")
 }
 
+/// A stream hole: unlike the futures above, which fill their slot once, this
+/// patches the same `<template for="N">` slot repeatedly as ticks arrive —
+/// the wire-format mechanism the declarative partial updates format calls
+/// out for live-updating regions. Held open for ~2s total.
+fn live_price() -> impl Stream<Item = Node> {
+    async_stream::stream! {
+        let mut price = 100.0_f32;
+        for _ in 0..5 {
+            sleep(Duration::from_millis(400)).await;
+            price += (price * 0.01).max(0.5);
+            yield html! { <span>"$" {format!("{price:.2}")}</span> };
+        }
+    }
+}
+
+// Fully static — evaluated at compile time; the crate name and version are
+// spliced in via `concat!`, so the whole footer is one `&'static str` in the
+// binary.
+const FOOTER: Node = html! {
+    <footer>
+        "Created with " const { env!("CARGO_PKG_NAME") } " v" const { env!("CARGO_PKG_VERSION") }
+    </footer>
+};
+
 async fn index() -> Response {
     let page = html! {
         <html>
@@ -60,6 +88,11 @@ async fn index() -> Response {
                     <h2>"Stocks"</h2>
                     @{stock_ticker()}
                 </section>
+                <section>
+                    <h2>"Live price"</h2>
+                    @*{live_price()} else { <span>"waiting for first tick…"</span> }
+                </section>
+                {FOOTER}
             </body>
         </html>
     };
diff --git a/afterglow/src/escape.rs b/afterglow/src/escape.rs
index 2f433c0..0d880b1 100644
--- a/afterglow/src/escape.rs
+++ b/afterglow/src/escape.rs
@@ -1,3 +1,6 @@
+// Keep in sync with the copies in afterglow-macros/src/lib.rs — the macro
+// applies the same escaping at expansion time when folding static content.
+
 /// Escapes text content: `&`, `<`, `>`.
 pub(crate) fn escape_text(input: &str, out: &mut String) {
     for character in input.chars() {
diff --git a/afterglow/src/lib.rs b/afterglow/src/lib.rs
index 391da74..529a5ee 100644
--- a/afterglow/src/lib.rs
+++ b/afterglow/src/lib.rs
@@ -1,23 +1,29 @@
 //! Suspense-style streaming HTML rendering.
 //!
-//! Render trees where some subtrees are futures ([`Node::Pending`]). The
-//! renderer emits a "shell" immediately with placeholder markers for the
-//! pending subtrees, then streams filled-in content as each future resolves,
-//! using the wire format from Chrome's declarative partial updates feature:
-//! `<?marker id="N">` / `<?start id="N">fallback<?end>` placeholders, filled
-//! later by `<template for="N">...</template>` blocks.
+//! Render trees where some subtrees are futures ([`Node::Pending`]) or
+//! sequences of values arriving over time ([`Node::Stream`]). The renderer
+//! emits a "shell" immediately with placeholder markers for those holes,
+//! then streams filled-in content as it becomes available, using the wire
+//! format from Chrome's declarative partial updates feature:
+//! `<?marker name="N">` / `<?start name="N">fallback<?end>` placeholders,
+//! filled later by `<template for="N">...</template>` blocks. A `Pending`
+//! hole is patched once; a `Stream` hole is patched once per value — per the
+//! wire format, repeated patches at the same marker express a live-updating
+//! region.
 //!
-//! This is a one-shot streaming model, not a reactive or resumable one: write
-//! the parts you have now, backfill the rest as they arrive.
+//! There is no client-side state and no re-rendering: each patch is applied
+//! declaratively as it arrives, and a `Stream` hole is a live region only in
+//! the sense that its slot keeps being patched — nothing is diffed or
+//! reconciled.
 //!
 //! # Cancellation
 //!
-//! Widget futures are driven inside the returned stream and are dropped when
-//! the stream is dropped (for example when the client disconnects and the
-//! server drops the response body). To keep that free cancellation, do **not**
-//! `tokio::spawn` widget futures and hand their `JoinHandle`s to the tree —
-//! spawned tasks detach from drop-based cancellation and keep running after
-//! the response is gone.
+//! Widget futures and stream sources are driven inside the returned stream
+//! and are dropped when the stream is dropped (for example when the client
+//! disconnects and the server drops the response body). To keep that free
+//! cancellation, do **not** `tokio::spawn` them and hand their `JoinHandle`s
+//! to the tree — spawned tasks detach from drop-based cancellation and keep
+//! running after the response is gone.
 
 // Allows macro-generated `::afterglow::...` paths to resolve inside this
 // crate's own tests and examples.
@@ -30,6 +36,6 @@ mod shell;
 mod stream;
 
 pub use afterglow_macros::html;
-pub use node::{Node, Render};
+pub use node::{IntoNodeStream, Node, NodeStream, Render};
 pub use render::render_to_string;
 pub use stream::{render_stream, render_stream_ordered};
diff --git a/afterglow/src/node.rs b/afterglow/src/node.rs
index 286fef7..abb7609 100644
--- a/afterglow/src/node.rs
+++ b/afterglow/src/node.rs
@@ -2,6 +2,7 @@ use std::borrow::Cow;
 use std::fmt::Display;
 
 use futures::future::BoxFuture;
+use futures::stream::{BoxStream, Stream, StreamExt};
 
 /// An attribute name paired with its value. `None` renders as a bare
 /// (boolean) attribute, e.g. `disabled`.
@@ -11,10 +12,12 @@ pub type Attribute = (Cow<'static, str>, Option<String>);
 pub enum Node {
     /// Pre-escaped HTML written to the output verbatim. All `Html` content is
     /// assumed trusted / already escaped (the `html!` macro only produces
-    /// escaped content; use [`Node::raw`] deliberately).
-    Html(String),
+    /// escaped content; use [`Node::raw`] deliberately). The `html!` macro
+    /// folds all static markup into `Cow::Borrowed` segments that live in the
+    /// binary and are streamed without copying.
+    Html(Cow<'static, str>),
     /// Text content, escaped when rendered.
-    Text(String),
+    Text(Cow<'static, str>),
     /// An element with attributes and children. Void elements (`br`, `img`,
     /// ...) render without a closing tag and their children are ignored.
     Element {
@@ -31,17 +34,62 @@ pub enum Node {
         future: BoxFuture<'static, Node>,
         fallback: Option<Box<Node>>,
     },
+    /// A subtree whose content arrives as a sequence of values over time.
+    /// Renders the same placeholder as [`Node::Pending`]; each value from the
+    /// source is streamed as its own `<template for="N">` patch. Per the
+    /// declarative partial updates format, successive patches at a bare
+    /// marker insert before it — how patches apply is client-side behavior.
+    /// Values may themselves contain further pending or stream holes.
+    Stream {
+        stream: NodeStream,
+        fallback: Option<Box<Node>>,
+    },
+}
+
+/// Opaque handle to a sequence of nodes arriving over time — the payload of
+/// a [`Node::Stream`] hole. Construct one via [`IntoNodeStream`].
+pub struct NodeStream {
+    pub(crate) inner: BoxStream<'static, Node>,
+}
+
+/// Conversion into a [`NodeStream`] — the [`Render`] counterpart for "many
+/// values over time". This trait is the single intake point for stream
+/// holes, keeping the rest of the crate (driver, wire format, macro)
+/// independent of any particular streaming trait.
+///
+/// Implemented for every [`futures::Stream`] whose items implement
+/// [`Render`]. When `std::async_iter::AsyncIterator` / `async gen` blocks
+/// stabilize they integrate here: if `futures::Stream` converges with
+/// `AsyncIterator` (the stated long-term direction) the existing blanket
+/// impl covers them with no changes; otherwise a `from_async_iter` adapter
+/// will be added (`poll_next` maps 1:1). A second blanket impl is not
+/// possible under today's coherence rules, which is why this trait is public
+/// — you can bridge your own source types by implementing it directly.
+pub trait IntoNodeStream {
+    fn into_node_stream(self) -> NodeStream;
+}
+
+impl<S, T> IntoNodeStream for S
+where
+    S: Stream<Item = T> + Send + 'static,
+    T: Render + 'static,
+{
+    fn into_node_stream(self) -> NodeStream {
+        NodeStream {
+            inner: Box::pin(self.map(Render::into_node)),
+        }
+    }
 }
 
 impl Node {
     /// Creates a raw, pre-escaped HTML node. The content is written verbatim;
     /// the caller is responsible for it being safe.
-    pub fn raw(html: impl Into<String>) -> Node {
+    pub fn raw(html: impl Into<Cow<'static, str>>) -> Node {
         Node::Html(html.into())
     }
 
     /// Creates a text node; the content is escaped when rendered.
-    pub fn text(text: impl Into<String>) -> Node {
+    pub fn text(text: impl Into<Cow<'static, str>>) -> Node {
         Node::Text(text.into())
     }
 
@@ -64,7 +112,7 @@ impl Node {
     }
 
     /// Creates a pending node without fallback content; the shell renders a
-    /// bare `<?marker id="N">` in its place.
+    /// bare `<?marker name="N">` in its place.
     ///
     /// The future is driven by the render stream itself and dropped with it —
     /// do not `tokio::spawn` it (see the crate docs on cancellation).
@@ -80,8 +128,8 @@ impl Node {
     }
 
     /// Creates a pending node with fallback content; the shell renders
-    /// `<?start id="N">fallback<?end>` in its place. The fallback may itself
-    /// contain further pending nodes.
+    /// `<?start name="N">fallback<?end>` in its place. The fallback may
+    /// itself contain further pending nodes.
     pub fn pending_with_fallback<F, T>(future: F, fallback: Node) -> Node
     where
         F: Future<Output = T> + Send + 'static,
@@ -92,6 +140,32 @@ impl Node {
             fallback: Some(Box::new(fallback)),
         }
     }
+
+    /// Creates a stream hole without fallback content; the shell renders a
+    /// bare `<?marker name="N">` and each value from the source is streamed
+    /// as its own `<template for="N">` patch.
+    ///
+    /// Like widget futures, the source is driven by the render stream and
+    /// dropped with it — do not `tokio::spawn` producers feeding it (see the
+    /// crate docs on cancellation). The response stream terminates only once
+    /// every source has ended, so an infinite source means a held-open
+    /// response.
+    pub fn stream(source: impl IntoNodeStream) -> Node {
+        Node::Stream {
+            stream: source.into_node_stream(),
+            fallback: None,
+        }
+    }
+
+    /// Creates a stream hole with fallback content; the shell renders
+    /// `<?start name="N">fallback<?end>`. If the source ends without ever
+    /// yielding a value, no patch is emitted and the fallback remains.
+    pub fn stream_with_fallback(source: impl IntoNodeStream, fallback: Node) -> Node {
+        Node::Stream {
+            stream: source.into_node_stream(),
+            fallback: Some(Box::new(fallback)),
+        }
+    }
 }
 
 /// Conversion into a [`Node`]. This is what interpolated values in the `html!`
@@ -108,25 +182,25 @@ impl Render for Node {
 
 impl Render for String {
     fn into_node(self) -> Node {
-        Node::Text(self)
+        Node::Text(Cow::Owned(self))
     }
 }
 
 impl Render for &str {
     fn into_node(self) -> Node {
-        Node::Text(self.to_owned())
+        Node::Text(Cow::Owned(self.to_owned()))
     }
 }
 
 impl Render for Cow<'_, str> {
     fn into_node(self) -> Node {
-        Node::Text(self.into_owned())
+        Node::Text(Cow::Owned(self.into_owned()))
     }
 }
 
 impl Render for char {
     fn into_node(self) -> Node {
-        Node::Text(self.to_string())
+        Node::Text(Cow::Owned(self.to_string()))
     }
 }
 
@@ -141,7 +215,7 @@ macro_rules! impl_render_via_display {
         $(
             impl Render for $type {
                 fn into_node(self) -> Node {
-                    Node::Text(self.to_string())
+                    Node::Text(Cow::Owned(self.to_string()))
                 }
             }
         )+
@@ -158,6 +232,16 @@ impl<T: Render> Render for Vec<T> {
     }
 }
 
+/// Collects synchronously available values into a fragment. This is the
+/// bridge for plain iterators (and future sync `gen` blocks, which produce
+/// `Iterator`s): all values are rendered up front. For values arriving over
+/// time, use [`Node::stream`].
+impl<T: Render> FromIterator<T> for Node {
+    fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Node {
+        Node::Fragment(iter.into_iter().map(Render::into_node).collect())
+    }
+}
+
 impl<T: Render> Render for Option<T> {
     fn into_node(self) -> Node {
         match self {
diff --git a/afterglow/src/render.rs b/afterglow/src/render.rs
index 31cf7c6..c1cc6b6 100644
--- a/afterglow/src/render.rs
+++ b/afterglow/src/render.rs
@@ -69,6 +69,9 @@ fn write_resolved(node: Node, out: &mut String) {
         Node::Pending { .. } => {
             panic!("render_to_string cannot render Node::Pending; use render_stream instead")
         }
+        Node::Stream { .. } => {
+            panic!("render_to_string cannot render Node::Stream; use render_stream instead")
+        }
     }
 }
 
diff --git a/afterglow/src/shell.rs b/afterglow/src/shell.rs
index dc5cb57..a70714a 100644
--- a/afterglow/src/shell.rs
+++ b/afterglow/src/shell.rs
@@ -1,4 +1,8 @@
+use std::borrow::Cow;
+
+use bytes::Bytes;
 use futures::future::BoxFuture;
+use futures::stream::BoxStream;
 
 use crate::escape::escape_text;
 use crate::node::Node;
@@ -6,22 +10,82 @@ use crate::render::{is_void_element, write_close_tag, write_open_tag};
 
 pub(crate) type SlotId = u64;
 
+/// What fills a slot: a future resolving to one node, or a stream of nodes
+/// each patched into the slot as it arrives.
+pub(crate) enum SlotSource {
+    Future(BoxFuture<'static, Node>),
+    Stream(BoxStream<'static, Node>),
+}
+
+/// Accumulates shell HTML while preserving zero-copy for the fully static
+/// case: the `html!` macro folds static templates into a single
+/// `Node::Html(Cow::Borrowed(...))` segment living in the binary, and a shell
+/// consisting of only that segment is sent via [`Bytes::from_static`] without
+/// ever being copied. Anything else falls back to one owned buffer.
+pub(crate) enum HtmlBuf {
+    Empty,
+    Static(&'static str),
+    Owned(String),
+}
+
+impl HtmlBuf {
+    fn push_cow(&mut self, content: Cow<'static, str>) {
+        if content.is_empty() {
+            return;
+        }
+        match (&mut *self, content) {
+            (HtmlBuf::Empty, Cow::Borrowed(content)) => *self = HtmlBuf::Static(content),
+            (HtmlBuf::Empty, Cow::Owned(content)) => *self = HtmlBuf::Owned(content),
+            (_, content) => self.owned_mut().push_str(&content),
+        }
+    }
+
+    fn owned_mut(&mut self) -> &mut String {
+        match self {
+            HtmlBuf::Owned(_) => {}
+            HtmlBuf::Empty => *self = HtmlBuf::Owned(String::new()),
+            HtmlBuf::Static(existing) => *self = HtmlBuf::Owned((*existing).to_owned()),
+        }
+        let HtmlBuf::Owned(owned) = self else {
+            unreachable!("converted to Owned above");
+        };
+        owned
+    }
+
+    pub(crate) fn as_str(&self) -> &str {
+        match self {
+            HtmlBuf::Empty => "",
+            HtmlBuf::Static(content) => content,
+            HtmlBuf::Owned(content) => content,
+        }
+    }
+
+    pub(crate) fn into_bytes(self) -> Bytes {
+        match self {
+            HtmlBuf::Empty => Bytes::new(),
+            HtmlBuf::Static(content) => Bytes::from_static(content.as_bytes()),
+            HtmlBuf::Owned(content) => Bytes::from(content),
+        }
+    }
+}
+
 /// The synchronous part of a render pass: everything already resolved is in
 /// `html` (with placeholder markers where `Pending` nodes were), and the
 /// extracted futures wait in `slots` to be driven by the stream.
 pub(crate) struct Shell {
-    pub(crate) html: String,
-    pub(crate) slots: Vec<(SlotId, BoxFuture<'static, Node>)>,
+    pub(crate) html: HtmlBuf,
+    pub(crate) slots: Vec<(SlotId, SlotSource)>,
 }
 
-/// Renders a tree without awaiting anything. Each `Pending` node gets a
-/// unique id from `next_id` and renders as `<?marker id="N">` (no fallback)
-/// or `<?start id="N">fallback<?end>`; its future is pulled out into the
-/// returned queue. Fallbacks are walked too, so a pending node nested inside
-/// another pending node's fallback is registered as its own slot.
+/// Renders a tree without awaiting anything. Each `Pending` or `Stream` node
+/// gets a unique id from `next_id` and renders as `<?marker name="N">` (no
+/// fallback) or `<?start name="N">fallback<?end>`; its source is pulled out
+/// into the returned queue. Fallbacks are walked too, so a pending node
+/// nested inside another pending node's fallback is registered as its own
+/// slot.
 pub(crate) fn render_shell(node: Node, next_id: &mut SlotId) -> Shell {
     let mut shell = Shell {
-        html: String::new(),
+        html: HtmlBuf::Empty,
         slots: Vec::new(),
     };
     write_shell(node, next_id, &mut shell);
@@ -30,19 +94,19 @@ pub(crate) fn render_shell(node: Node, next_id: &mut SlotId) -> Shell {
 
 fn write_shell(node: Node, next_id: &mut SlotId, shell: &mut Shell) {
     match node {
-        Node::Html(html) => shell.html.push_str(&html),
-        Node::Text(text) => escape_text(&text, &mut shell.html),
+        Node::Html(html) => shell.html.push_cow(html),
+        Node::Text(text) => escape_text(&text, shell.html.owned_mut()),
         Node::Element {
             tag,
             attributes,
             children,
         } => {
-            write_open_tag(&tag, &attributes, &mut shell.html);
+            write_open_tag(&tag, &attributes, shell.html.owned_mut());
             if !is_void_element(&tag) {
                 for child in children {
                     write_shell(child, next_id, shell);
                 }
-                write_close_tag(&tag, &mut shell.html);
+                write_close_tag(&tag, shell.html.owned_mut());
             }
         }
         Node::Fragment(children) => {
@@ -51,19 +115,37 @@ fn write_shell(node: Node, next_id: &mut SlotId, shell: &mut Shell) {
             }
         }
         Node::Pending { future, fallback } => {
-            let id = *next_id;
-            *next_id += 1;
-            shell.slots.push((id, future));
-            match fallback {
-                None => {
-                    shell.html.push_str(&format!("<?marker id=\"{id}\">"));
-                }
-                Some(fallback) => {
-                    shell.html.push_str(&format!("<?start id=\"{id}\">"));
-                    write_shell(*fallback, next_id, shell);
-                    shell.html.push_str("<?end>");
-                }
-            }
+            write_slot(SlotSource::Future(future), fallback, next_id, shell);
+        }
+        Node::Stream { stream, fallback } => {
+            write_slot(SlotSource::Stream(stream.inner), fallback, next_id, shell);
+        }
+    }
+}
+
+fn write_slot(
+    source: SlotSource,
+    fallback: Option<Box<Node>>,
+    next_id: &mut SlotId,
+    shell: &mut Shell,
+) {
+    let id = *next_id;
+    *next_id += 1;
+    shell.slots.push((id, source));
+    match fallback {
+        None => {
+            shell
+                .html
+                .owned_mut()
+                .push_str(&format!("<?marker name=\"{id}\">"));
+        }
+        Some(fallback) => {
+            shell
+                .html
+                .owned_mut()
+                .push_str(&format!("<?start name=\"{id}\">"));
+            write_shell(*fallback, next_id, shell);
+            shell.html.owned_mut().push_str("<?end>");
         }
     }
 }
@@ -86,7 +168,7 @@ mod test {
         let mut next_id = 0;
         let shell = render_shell(tree, &mut next_id);
 
-        assert_eq!("<div><?marker id=\"0\"></div>", shell.html);
+        assert_eq!("<div><?marker name=\"0\"></div>", shell.html.as_str());
         assert_eq!(1, shell.slots.len());
         assert_eq!(0, shell.slots[0].0);
         assert_eq!(1, next_id);
@@ -99,13 +181,30 @@ mod test {
         let mut next_id = 0;
         let mut shell = render_shell(tree, &mut next_id);
 
-        let (_, future) = shell.slots.pop().unwrap();
+        let (_, source) = shell.slots.pop().unwrap();
+        let SlotSource::Future(future) = source else {
+            panic!("pending node should register a future slot");
+        };
         let resolved = future
             .now_or_never()
             .expect("ready future should resolve immediately");
         assert_eq!("late &amp; escaped", crate::render_to_string(resolved));
     }
 
+    #[test]
+    fn stream_node_renders_marker_and_queues_stream_source() {
+        let tree = Node::stream(futures::stream::iter([Node::text("a"), Node::text("b")]));
+
+        let mut next_id = 0;
+        let shell = render_shell(tree, &mut next_id);
+
+        assert_eq!("<?marker name=\"0\">", shell.html.as_str());
+        assert!(matches!(
+            shell.slots.as_slice(),
+            [(0, SlotSource::Stream(_))]
+        ));
+    }
+
     #[test]
     fn sibling_pending_nodes_get_distinct_ids() {
         let tree = Node::element(
@@ -123,8 +222,8 @@ mod test {
         let shell = render_shell(tree, &mut next_id);
 
         assert_eq!(
-            "<div><?marker id=\"0\">between<?marker id=\"1\"><?marker id=\"2\"></div>",
-            shell.html
+            "<div><?marker name=\"0\">between<?marker name=\"1\"><?marker name=\"2\"></div>",
+            shell.html.as_str()
         );
         let ids: Vec<_> = shell.slots.iter().map(|(id, _)| *id).collect();
         assert_eq!(vec![0, 1, 2], ids);
@@ -141,8 +240,8 @@ mod test {
         let shell = render_shell(tree, &mut next_id);
 
         assert_eq!(
-            "<?start id=\"0\"><span>loading…</span><?end>",
-            shell.html
+            "<?start name=\"0\"><span>loading…</span><?end>",
+            shell.html.as_str()
         );
         assert_eq!(1, shell.slots.len());
     }
@@ -165,8 +264,8 @@ mod test {
         let shell = render_shell(tree, &mut next_id);
 
         assert_eq!(
-            "<?start id=\"0\"><div>outer fallback with <?marker id=\"1\"></div><?end>",
-            shell.html
+            "<?start name=\"0\"><div>outer fallback with <?marker name=\"1\"></div><?end>",
+            shell.html.as_str()
         );
         let ids: Vec<_> = shell.slots.iter().map(|(id, _)| *id).collect();
         assert_eq!(vec![0, 1], ids);
@@ -179,8 +278,21 @@ mod test {
         let mut next_id = 0;
         let shell = render_shell(tree, &mut next_id);
 
-        assert_eq!("<p>done</p>", shell.html);
+        assert_eq!("<p>done</p>", shell.html.as_str());
         assert!(shell.slots.is_empty());
         assert_eq!(0, next_id);
     }
+
+    #[test]
+    fn fully_static_shell_reuses_the_bytes_baked_into_the_binary() {
+        static HTML: &str = "<p>prerendered</p>";
+
+        let mut next_id = 0;
+        let shell = render_shell(Node::raw(HTML), &mut next_id);
+        let bytes = shell.html.into_bytes();
+
+        assert_eq!(HTML.as_bytes(), bytes.as_ref());
+        // Zero-copy: the Bytes point directly at the static data.
+        assert_eq!(HTML.as_ptr(), bytes.as_ptr());
+    }
 }
diff --git a/afterglow/src/stream.rs b/afterglow/src/stream.rs
index 23f6ab2..93fc754 100644
--- a/afterglow/src/stream.rs
+++ b/afterglow/src/stream.rs
@@ -1,19 +1,32 @@
-use std::collections::BTreeMap;
+use std::collections::{BTreeMap, BTreeSet};
 use std::io;
 
 use async_stream::stream;
 use bytes::Bytes;
-use futures::future::BoxFuture;
-use futures::stream::{FuturesUnordered, Stream, StreamExt};
+use futures::stream::{BoxStream, SelectAll, Stream, StreamExt};
 
 use crate::node::{Node, Render};
-use crate::shell::{Shell, SlotId, render_shell};
+use crate::shell::{HtmlBuf, Shell, SlotId, SlotSource, render_shell};
 
-/// A slot's future tagged with its id so we know which placeholder to fill.
-type TaggedFuture = BoxFuture<'static, (SlotId, Node)>;
+/// A slot event tagged with the slot's id: a value to patch into the slot,
+/// or the end of the slot's source (used by the ordered driver's gate).
+enum SlotEvent {
+    Value(SlotId, Node),
+    End(SlotId),
+}
+
+type TaggedStream = BoxStream<'static, SlotEvent>;
 
-fn tag(id: SlotId, future: BoxFuture<'static, Node>) -> TaggedFuture {
-    Box::pin(async move { (id, future.await) })
+fn tag(id: SlotId, source: SlotSource) -> TaggedStream {
+    let values: BoxStream<'static, Node> = match source {
+        SlotSource::Future(future) => Box::pin(futures::stream::once(future)),
+        SlotSource::Stream(stream) => stream,
+    };
+    Box::pin(
+        values
+            .map(move |node| SlotEvent::Value(id, node))
+            .chain(futures::stream::once(async move { SlotEvent::End(id) })),
+    )
 }
 
 fn template_chunk(id: SlotId, html: &str) -> Bytes {
@@ -21,16 +34,25 @@ fn template_chunk(id: SlotId, html: &str) -> Bytes {
 }
 
 /// Renders `root` as a byte stream: the shell (with placeholder markers for
-/// pending subtrees) is yielded first, then each resolved subtree is yielded
-/// as a `<template for="N">...</template>` chunk **in completion order** —
-/// whichever future resolves first is streamed first.
+/// pending subtrees) is yielded first, then resolved content is yielded as
+/// `<template for="N">...</template>` chunks **in completion order** —
+/// whichever slot produces a value first is streamed first.
+///
+/// Future slots ([`Node::Pending`]) produce exactly one chunk; stream slots
+/// ([`Node::Stream`]) produce one chunk per value, in value order — per the
+/// declarative partial updates format, repeated patches at the same marker
+/// express a live-updating region. Values may themselves contain new pending
+/// or stream holes; those are registered as new slots and filled by later
+/// chunks, to any nesting depth.
 ///
-/// Resolved subtrees may themselves contain pending nodes; those are
-/// registered as new slots and filled by later chunks, to any nesting depth.
+/// The stream terminates once every future has resolved and every stream
+/// source has ended — an infinite source means a never-ending response.
+/// Sources are only polled when the response stream is polled, so a fast
+/// producer is throttled by the client rather than buffered.
 ///
 /// Dropping the stream (e.g. because the client disconnected) drops all
-/// still-pending widget futures — cancellation is free as long as widget
-/// futures are not `tokio::spawn`ed (see the crate docs).
+/// still-pending widget futures and stream sources — cancellation is free as
+/// long as they are not `tokio::spawn`ed (see the crate docs).
 ///
 /// The stream never yields `Err`; the item type is `io::Result<Bytes>` so it
 /// can feed `axum::body::Body::from_stream` directly.
@@ -39,30 +61,34 @@ pub fn render_stream(root: impl Render) -> impl Stream<Item = io::Result<Bytes>>
     stream! {
         let mut next_id: SlotId = 0;
         let shell = render_shell(root, &mut next_id);
-        let mut pending: FuturesUnordered<TaggedFuture> = shell
-            .slots
-            .into_iter()
-            .map(|(id, future)| tag(id, future))
-            .collect();
+        let mut pending: SelectAll<TaggedStream> = futures::stream::select_all(
+            shell.slots.into_iter().map(|(id, source)| tag(id, source)),
+        );
 
-        yield Ok(Bytes::from(shell.html));
+        yield Ok(shell.html.into_bytes());
 
-        while let Some((id, node)) = pending.next().await {
+        while let Some(event) = pending.next().await {
+            let SlotEvent::Value(id, node) = event else {
+                continue;
+            };
             let Shell { html, slots } = render_shell(node, &mut next_id);
-            for (new_id, future) in slots {
-                pending.push(tag(new_id, future));
+            for (new_id, source) in slots {
+                pending.push(tag(new_id, source));
             }
-            yield Ok(template_chunk(id, &html));
+            yield Ok(template_chunk(id, html.as_str()));
         }
     }
 }
 
-/// Like [`render_stream`], but fills slots **in registration order** (slot 0
-/// first, then 1, ...) regardless of which future resolves first. Futures
-/// still run concurrently; completed chunks are buffered until it is their
-/// turn. Useful for deterministic snapshot testing.
+/// Like [`render_stream`], but slots unblock **in registration order**: slot
+/// N's first chunk is emitted before anything from slot N+1. A slot unblocks
+/// once it produces its first value (or its source ends without one — the
+/// fallback then simply remains); afterwards its further values pass through
+/// in arrival order. Sources still run concurrently; early chunks are
+/// buffered until it is their slot's turn. Useful for deterministic snapshot
+/// testing.
 ///
-/// Slots registered by resolved subtrees always get higher ids than the slot
+/// Slots registered by resolved content always get higher ids than the slot
 /// that produced them, so waiting for ids in ascending order cannot deadlock.
 pub fn render_stream_ordered(
     root: impl Render,
@@ -71,26 +97,52 @@ pub fn render_stream_ordered(
     stream! {
         let mut next_id: SlotId = 0;
         let shell = render_shell(root, &mut next_id);
-        let mut pending: FuturesUnordered<TaggedFuture> = shell
-            .slots
-            .into_iter()
-            .map(|(id, future)| tag(id, future))
-            .collect();
+        let mut pending: SelectAll<TaggedStream> = futures::stream::select_all(
+            shell.slots.into_iter().map(|(id, source)| tag(id, source)),
+        );
 
-        yield Ok(Bytes::from(shell.html));
+        yield Ok(shell.html.into_bytes());
 
-        let mut buffered: BTreeMap<SlotId, String> = BTreeMap::new();
+        // The gate: `emit_next` is the lowest still-blocked slot. Chunks for
+        // blocked slots are buffered; ends without a value are remembered so
+        // an empty source cannot jam the gate.
+        let mut buffered: BTreeMap<SlotId, Vec<HtmlBuf>> = BTreeMap::new();
+        let mut ended: BTreeSet<SlotId> = BTreeSet::new();
         let mut emit_next: SlotId = 0;
-        while let Some((id, node)) = pending.next().await {
-            let Shell { html, slots } = render_shell(node, &mut next_id);
-            for (new_id, future) in slots {
-                pending.push(tag(new_id, future));
+
+        while let Some(event) = pending.next().await {
+            match event {
+                SlotEvent::Value(id, node) => {
+                    let Shell { html, slots } = render_shell(node, &mut next_id);
+                    for (new_id, source) in slots {
+                        pending.push(tag(new_id, source));
+                    }
+                    if id < emit_next {
+                        yield Ok(template_chunk(id, html.as_str()));
+                    } else {
+                        buffered.entry(id).or_default().push(html);
+                    }
+                }
+                SlotEvent::End(id) => {
+                    if id >= emit_next {
+                        ended.insert(id);
+                    }
+                }
             }
-            buffered.insert(id, html);
 
-            while let Some(html) = buffered.remove(&emit_next) {
-                yield Ok(template_chunk(emit_next, &html));
-                emit_next += 1;
+            // Advance the gate as far as possible.
+            loop {
+                if let Some(chunks) = buffered.remove(&emit_next) {
+                    ended.remove(&emit_next);
+                    for html in chunks {
+                        yield Ok(template_chunk(emit_next, html.as_str()));
+                    }
+                    emit_next += 1;
+                } else if ended.remove(&emit_next) {
+                    emit_next += 1;
+                } else {
+                    break;
+                }
             }
         }
     }
diff --git a/afterglow/tests/macro.rs b/afterglow/tests/macro.rs
index 40def01..e4d751d 100644
--- a/afterglow/tests/macro.rs
+++ b/afterglow/tests/macro.rs
@@ -1,6 +1,7 @@
 //! Verifies `html!` expansion produces trees matching what the earlier
 //! phases' tests built by hand, by comparing rendered output.
 
+use std::borrow::Cow;
 use std::io;
 use std::time::Duration;
 
@@ -81,7 +82,7 @@ fn empty_macro_renders_nothing() {
 }
 
 #[test]
-fn multiple_top_level_nodes_form_a_fragment() {
+fn multiple_top_level_nodes_render_in_sequence() {
     let tree = html! {
         <dt>"term"</dt>
         <dd>"definition"</dd>
@@ -90,6 +91,66 @@ fn multiple_top_level_nodes_form_a_fragment() {
     assert_eq!("<dt>term</dt><dd>definition</dd>", render_to_string(tree));
 }
 
+#[test]
+fn fully_static_template_folds_to_a_single_prerendered_node() {
+    let tree = html! {
+        <div class="a & b">
+            <p>"x < y"</p>
+            <br/>
+        </div>
+    };
+
+    // The macro escaped and concatenated everything at expansion time; the
+    // whole template is one borrowed segment living in the binary.
+    let Node::Html(Cow::Borrowed(html)) = tree else {
+        panic!("fully static templates should fold to one borrowed Html node");
+    };
+    assert_eq!("<div class=\"a &amp; b\"><p>x &lt; y</p><br></div>", html);
+}
+
+const FOOTER: Node = html! { <footer>"© 2026 — a < b"</footer> };
+
+#[test]
+fn fully_static_template_is_const_constructible() {
+    assert_eq!(
+        "<footer>© 2026 — a &lt; b</footer>",
+        render_to_string(FOOTER)
+    );
+}
+
+const BUILT_WITH: Node = html! {
+    <footer>"Built with " const { env!("CARGO_PKG_NAME") } " v" const { env!("CARGO_PKG_VERSION") }</footer>
+};
+
+#[test]
+fn const_interpolation_folds_into_a_single_const_constructible_segment() {
+    // Still one borrowed segment: the `const { env!(...) }` pieces were
+    // spliced in through `concat!` at compile time.
+    let Node::Html(Cow::Borrowed(html)) = BUILT_WITH else {
+        panic!("const-interpolated static template should fold to one borrowed Html node");
+    };
+    assert_eq!(
+        concat!(
+            "<footer>Built with ",
+            env!("CARGO_PKG_NAME"),
+            " v",
+            env!("CARGO_PKG_VERSION"),
+            "</footer>",
+        ),
+        html
+    );
+}
+
+#[test]
+fn const_interpolation_mixes_with_dynamic_holes() {
+    let user = "Ada";
+    let tree = html! {
+        <p>"hi " {user} ", this is " const { env!("CARGO_PKG_NAME") }</p>
+    };
+
+    assert_eq!("<p>hi Ada, this is afterglow</p>", render_to_string(tree));
+}
+
 struct Article {
     title: String,
 }
@@ -125,8 +186,8 @@ async fn async_widgets_stream_through_the_phase_3_driver() {
 
     assert_eq!(
         vec![
-            "<main><?start id=\"0\"><p class=\"spinner\">loading article…</p><?end>\
-             <aside>score: <?marker id=\"1\"></aside></main>",
+            "<main><?start name=\"0\"><p class=\"spinner\">loading article…</p><?end>\
+             <aside>score: <?marker name=\"1\"></aside></main>",
             "<template for=\"0\"><article><h2>Streaming HTML</h2></article></template>",
             "<template for=\"1\">9001</template>",
         ],
@@ -147,7 +208,7 @@ async fn failing_widget_written_with_macro_renders_error_slot() {
 
     assert_eq!(
         vec![
-            "<div><?marker id=\"0\"></div>",
+            "<div><?marker name=\"0\"></div>",
             "<template for=\"0\"><span class=\"afterglow-error\">upstream unavailable</span></template>",
         ],
         chunks
@@ -164,10 +225,87 @@ async fn pending_widget_inside_fallback_matches_hand_built_tree() {
 
     assert_eq!(
         vec![
-            "<?start id=\"0\"><span>waiting for <?marker id=\"1\"></span><?end>",
+            "<?start name=\"0\"><span>waiting for <?marker name=\"1\"></span><?end>",
             "<template for=\"0\">9001</template>",
             "<template for=\"1\">9001</template>",
         ],
         chunks
     );
 }
+
+fn scores() -> impl futures::Stream<Item = u32> {
+    async_stream::stream! {
+        for score in [10u32, 20, 30] {
+            sleep(Duration::from_millis(10)).await;
+            yield score;
+        }
+    }
+}
+
+#[tokio::test(start_paused = true)]
+async fn stream_hole_written_with_macro_patches_repeatedly() {
+    let page = html! { <div>@*{scores()}</div> };
+
+    let chunks = collect_chunks(render_stream(page)).await;
+
+    assert_eq!(
+        vec![
+            "<div><?marker name=\"0\"></div>",
+            "<template for=\"0\">10</template>",
+            "<template for=\"0\">20</template>",
+            "<template for=\"0\">30</template>",
+        ],
+        chunks
+    );
+}
+
+#[tokio::test(start_paused = true)]
+async fn stream_hole_with_fallback_matches_hand_built_tree() {
+    let by_macro = html! {
+        @*{scores()} else { <p class="spinner">"waiting for scores…"</p> }
+    };
+    let by_hand = Node::stream_with_fallback(
+        scores(),
+        Node::element(
+            "p",
+            vec![("class".into(), Some("spinner".to_owned()))],
+            vec![Node::text("waiting for scores…")],
+        ),
+    );
+
+    let macro_chunks = collect_chunks(render_stream(by_macro)).await;
+    let hand_chunks = collect_chunks(render_stream(by_hand)).await;
+
+    assert_eq!(hand_chunks, macro_chunks);
+}
+
+async fn final_score() -> u32 {
+    // Resolves after all of scores()'s 10/20/30ms ticks, with no tie, so
+    // completion order between the two holes is unambiguous.
+    sleep(Duration::from_millis(35)).await;
+    9001
+}
+
+#[tokio::test(start_paused = true)]
+async fn stream_and_pending_holes_compose_in_one_template() {
+    let page = html! {
+        <main>
+            <aside>"live: " @*{scores()}</aside>
+            @{final_score()} else { <p>"loading final score…"</p> }
+        </main>
+    };
+
+    let chunks = collect_chunks(render_stream(page)).await;
+
+    assert_eq!(
+        vec![
+            "<main><aside>live: <?marker name=\"0\"></aside>\
+             <?start name=\"1\"><p>loading final score…</p><?end></main>",
+            "<template for=\"0\">10</template>",
+            "<template for=\"0\">20</template>",
+            "<template for=\"0\">30</template>",
+            "<template for=\"1\">9001</template>",
+        ],
+        chunks
+    );
+}
diff --git a/afterglow/tests/streaming.rs b/afterglow/tests/streaming.rs
index acc97d3..3bd8cfa 100644
--- a/afterglow/tests/streaming.rs
+++ b/afterglow/tests/streaming.rs
@@ -41,7 +41,7 @@ async fn render_stream_fills_slots_in_completion_order() {
 
     assert_eq!(
         vec![
-            "<div><?marker id=\"0\"><?marker id=\"1\"><?marker id=\"2\"></div>",
+            "<div><?marker name=\"0\"><?marker name=\"1\"><?marker name=\"2\"></div>",
             "<template for=\"1\">fastest</template>",
             "<template for=\"2\">middle</template>",
             "<template for=\"0\">slowest</template>",
@@ -56,7 +56,7 @@ async fn render_stream_ordered_fills_slots_in_registration_order() {
 
     assert_eq!(
         vec![
-            "<div><?marker id=\"0\"><?marker id=\"1\"><?marker id=\"2\"></div>",
+            "<div><?marker name=\"0\"><?marker name=\"1\"><?marker name=\"2\"></div>",
             "<template for=\"0\">slowest</template>",
             "<template for=\"1\">fastest</template>",
             "<template for=\"2\">middle</template>",
@@ -88,8 +88,8 @@ async fn nested_pending_nodes_are_registered_and_filled() {
 
     assert_eq!(
         vec![
-            "<?start id=\"0\">loading outer…<?end>",
-            "<template for=\"0\"><section>outer resolved, inner <?marker id=\"1\"></section></template>",
+            "<?start name=\"0\">loading outer…<?end>",
+            "<template for=\"0\"><section>outer resolved, inner <?marker name=\"1\"></section></template>",
             "<template for=\"1\">inner resolved</template>",
         ],
         chunks
@@ -114,7 +114,7 @@ async fn failed_widget_renders_error_slot_without_killing_the_stream() {
 
     assert_eq!(
         vec![
-            "<div><?marker id=\"0\"><?marker id=\"1\"></div>",
+            "<div><?marker name=\"0\"><?marker name=\"1\"></div>",
             "<template for=\"0\"><span class=\"afterglow-error\">widget exploded</span></template>",
             "<template for=\"1\">still fine</template>",
         ],
@@ -122,6 +122,216 @@ async fn failed_widget_renders_error_slot_without_killing_the_stream() {
     );
 }
 
+#[tokio::test(start_paused = true)]
+async fn stream_slot_patches_repeatedly_and_ends_the_response() {
+    let ticker = async_stream::stream! {
+        for i in 1..=3u32 {
+            sleep(Duration::from_millis(10)).await;
+            yield Node::text(format!("tick {i}"));
+        }
+    };
+    let tree = Node::element(
+        "div",
+        vec![],
+        vec![Node::stream_with_fallback(ticker, Node::text("waiting…"))],
+    );
+
+    let chunks = collect_chunks(render_stream(tree)).await;
+
+    assert_eq!(
+        vec![
+            "<div><?start name=\"0\">waiting…<?end></div>",
+            "<template for=\"0\">tick 1</template>",
+            "<template for=\"0\">tick 2</template>",
+            "<template for=\"0\">tick 3</template>",
+        ],
+        chunks
+    );
+}
+
+#[tokio::test(start_paused = true)]
+async fn stream_and_future_slots_interleave_in_completion_order() {
+    let updates = async_stream::stream! {
+        sleep(Duration::from_millis(10)).await;
+        yield Node::text("first update");
+        sleep(Duration::from_millis(20)).await; // t = 30ms
+        yield Node::text("second update");
+    };
+    let tree = Node::element(
+        "div",
+        vec![],
+        vec![
+            Node::stream(updates),
+            Node::pending(delayed(20, "widget")),
+        ],
+    );
+
+    let chunks = collect_chunks(render_stream(tree)).await;
+
+    assert_eq!(
+        vec![
+            "<div><?marker name=\"0\"><?marker name=\"1\"></div>",
+            "<template for=\"0\">first update</template>",
+            "<template for=\"1\">widget</template>",
+            "<template for=\"0\">second update</template>",
+        ],
+        chunks
+    );
+}
+
+#[tokio::test(start_paused = true)]
+async fn pending_widget_inside_stream_value_registers_a_new_slot() {
+    let feed = async_stream::stream! {
+        sleep(Duration::from_millis(10)).await;
+        yield Node::element(
+            "article",
+            vec![],
+            vec![
+                Node::text("item with "),
+                Node::pending(delayed(10, "details")),
+            ],
+        );
+    };
+
+    let chunks = collect_chunks(render_stream(Node::stream(feed))).await;
+
+    assert_eq!(
+        vec![
+            "<?marker name=\"0\">",
+            "<template for=\"0\"><article>item with <?marker name=\"1\"></article></template>",
+            "<template for=\"1\">details</template>",
+        ],
+        chunks
+    );
+}
+
+#[tokio::test(start_paused = true)]
+async fn empty_stream_leaves_the_fallback_and_terminates() {
+    let tree = Node::stream_with_fallback(
+        futures::stream::empty::<Node>(),
+        Node::text("nothing yet"),
+    );
+
+    let chunks = collect_chunks(render_stream(tree)).await;
+
+    assert_eq!(vec!["<?start name=\"0\">nothing yet<?end>"], chunks);
+}
+
+#[tokio::test(start_paused = true)]
+async fn stream_of_results_renders_error_slots_per_value() {
+    let flaky = async_stream::stream! {
+        sleep(Duration::from_millis(10)).await;
+        yield Result::<&str, &str>::Ok("good value");
+        sleep(Duration::from_millis(10)).await;
+        yield Err("bad value");
+        sleep(Duration::from_millis(10)).await;
+        yield Ok("recovered");
+    };
+
+    let chunks = collect_chunks(render_stream(Node::stream(flaky))).await;
+
+    assert_eq!(
+        vec![
+            "<?marker name=\"0\">",
+            "<template for=\"0\">good value</template>",
+            "<template for=\"0\"><span class=\"afterglow-error\">bad value</span></template>",
+            "<template for=\"0\">recovered</template>",
+        ],
+        chunks
+    );
+}
+
+#[tokio::test(start_paused = true)]
+async fn ordered_stream_gates_on_first_value_then_flows() {
+    // Completion order would be: slot 1 (10ms), slot 1 (20ms), slot 0 (30ms),
+    // slot 1 (40ms). The gate holds slot 1's early values until slot 0 has
+    // emitted, then lets later values flow immediately.
+    let updates = async_stream::stream! {
+        sleep(Duration::from_millis(10)).await;
+        yield Node::text("one");
+        sleep(Duration::from_millis(10)).await;
+        yield Node::text("two");
+        sleep(Duration::from_millis(20)).await; // t = 40ms
+        yield Node::text("three");
+    };
+    let tree = Node::element(
+        "div",
+        vec![],
+        vec![
+            Node::pending(delayed(30, "late widget")),
+            Node::stream(updates),
+        ],
+    );
+
+    let chunks = collect_chunks(render_stream_ordered(tree)).await;
+
+    assert_eq!(
+        vec![
+            "<div><?marker name=\"0\"><?marker name=\"1\"></div>",
+            "<template for=\"0\">late widget</template>",
+            "<template for=\"1\">one</template>",
+            "<template for=\"1\">two</template>",
+            "<template for=\"1\">three</template>",
+        ],
+        chunks
+    );
+}
+
+#[tokio::test(start_paused = true)]
+async fn ordered_gate_is_not_jammed_by_an_empty_stream() {
+    let tree = Node::element(
+        "div",
+        vec![],
+        vec![
+            Node::stream_with_fallback(futures::stream::empty::<Node>(), Node::text("quiet")),
+            Node::pending(delayed(10, "loud")),
+        ],
+    );
+
+    let chunks = collect_chunks(render_stream_ordered(tree)).await;
+
+    assert_eq!(
+        vec![
+            "<div><?start name=\"0\">quiet<?end><?marker name=\"1\"></div>",
+            "<template for=\"1\">loud</template>",
+        ],
+        chunks
+    );
+}
+
+#[tokio::test]
+async fn dropping_the_stream_cancels_a_pending_stream_source() {
+    let dropped = Arc::new(AtomicBool::new(false));
+    let completed = Arc::new(AtomicBool::new(false));
+
+    let guard = DropGuard {
+        dropped: Arc::clone(&dropped),
+        completed: Arc::clone(&completed),
+    };
+    let source = async_stream::stream! {
+        let guard = guard;
+        futures::future::pending::<()>().await;
+        guard.completed.store(true, Ordering::SeqCst);
+        yield Node::text("unreachable");
+    };
+
+    let mut stream = Box::pin(render_stream(Node::stream(source)));
+    let shell = stream.next().await.expect("shell chunk").unwrap();
+    assert_eq!(Bytes::from("<?marker name=\"0\">"), shell);
+    assert!(!dropped.load(Ordering::SeqCst));
+
+    drop(stream);
+
+    assert!(
+        dropped.load(Ordering::SeqCst),
+        "stream source must be dropped with the response stream"
+    );
+    assert!(
+        !completed.load(Ordering::SeqCst),
+        "stream source must have been cancelled, not run to completion"
+    );
+}
+
 /// Records on drop whether the future it lives in ever completed.
 struct DropGuard {
     dropped: Arc<AtomicBool>,
@@ -151,7 +361,7 @@ async fn dropping_the_stream_cancels_pending_widget_futures() {
 
     let mut stream = Box::pin(render_stream(tree));
     let shell = stream.next().await.expect("shell chunk").unwrap();
-    assert_eq!(Bytes::from("<?marker id=\"0\">"), shell);
+    assert_eq!(Bytes::from("<?marker name=\"0\">"), shell);
     // The widget future is now owned by the stream and still pending.
     assert!(!dropped.load(Ordering::SeqCst));