diff --git a/Cargo.lock b/Cargo.lock
index 5b5a2ae..09264f7 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -12,6 +12,15 @@ dependencies = [
  "syn",
 ]
 
+[[package]]
+name = "misses-rt"
+version = "0.1.0"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "prettyplease"
 version = "0.2.37"
diff --git a/Cargo.toml b/Cargo.toml
index d0af0f8..b54ae9e 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,3 +1,3 @@
 [workspace]
-members = ["misses-compiler"]
+members = ["misses-compiler", "misses-rt"]
 resolver = "2"
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..ad3bece
--- /dev/null
+++ b/README.md
@@ -0,0 +1,229 @@
+# Misses
+
+**Misses** is a DSL compiler that transforms `.mrs` macro definitions into ready-to-use Rust proc macro source files. Write your macro once in a concise, readable syntax; Misses generates the full `syn`/`quote` boilerplate for you.
+
+---
+
+## Quick start
+
+```bash
+# Build everything
+cargo build
+
+# Run a bundled example (compare .mrs source with generated Rust)
+cargo run --example make_id_type
+cargo run --example derive_builder
+cargo run --example derive_getters
+cargo run --example declare_table
+cargo run --example component
+
+# Compile a .mrs file to Rust
+cargo run --bin misses -- path/to/my_macro.mrs > src/generated.rs
+```
+
+---
+
+## The `.mrs` syntax
+
+A `.mrs` file contains one or more macro definitions:
+
+```
+macro macro_name! {
+    <pattern> => {
+        <output>
+    }
+}
+```
+
+### Pattern bindings
+
+| Syntax | Parsed as |
+|---|---|
+| `$name:ident` | A single identifier |
+| `$expr:expr` | Any Rust expression |
+| `$ty:ty` | A Rust type |
+| `$body:tt` | A raw token-tree (brace group) |
+| `$($field:ident : $ty:ty),*` | Variadic — zero-or-more comma-separated pairs |
+
+Literal tokens in the pattern are matched verbatim. Rust keywords use `syn::Token![…]`; arbitrary identifiers are matched by value.
+
+### Output blocks
+
+An output block may contain any mix of:
+
+**Escape block** `@{ … }` — arbitrary Rust code executed at macro-expansion time:
+
+```
+@{
+    let builder_name = format_ident!("{}_Builder", name.to_string());
+}
+```
+
+**Token template** `T~{ … }` — generates the `quote::quote! { … }` call. Inside a template you may use:
+
+| Syntax | Meaning |
+|---|---|
+| `$name` | Interpolate the bound variable `name` |
+| `$field.name` / `$field.ty` | Access a field of a variadic element |
+| `${ expr }` | Evaluate an arbitrary Rust expression and interpolate the result |
+| `for x in $xs => …` | Spread — iterate the variadic collection and repeat a line |
+| `#[a => b_$name]` | Construct an identifier from parts (uses `format_ident!`) |
+
+---
+
+## Examples
+
+### `make_id_type.mrs` — newtype ID wrapper
+
+```
+macro make_id_type! {
+    $name:ident => {
+        T~{
+            #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+            pub struct $name(pub u64);
+
+            impl $name {
+                pub fn new(val: u64) -> Self { Self(val) }
+                pub fn value(self) -> u64 { self.0 }
+            }
+        }
+    }
+}
+```
+
+### `derive_builder.mrs` — builder pattern
+
+```
+macro derive_builder! {
+    struct $name:ident { $($field:ident : $ty:ty),* } => {
+        @{
+            let builder_name = format_ident!("{}_Builder", name.to_string());
+        }
+        T~{
+            pub struct ${ builder_name } {
+                for field in $fields =>
+                    pub $field.name: Option<$field.ty>,
+            }
+            impl ${ builder_name } {
+                pub fn build(self) -> $name {
+                    $name {
+                        for field in $fields =>
+                            $field.name: self.$field.name.unwrap(),
+                    }
+                }
+            }
+        }
+    }
+}
+```
+
+### `declare_table.mrs` — DSL to struct with runtime helper
+
+```
+macro declare_table! {
+    $name:ident { $body:tt } => {
+        @{
+            let table_str = misses_rt::to_table_name(&name);
+        }
+        T~{
+            pub struct $name {
+                pub id: u64,
+            }
+            impl $name {
+                pub const TABLE: &'static str = ${ table_str.as_str() };
+            }
+        }
+    }
+}
+```
+
+---
+
+## The `misses-rt` runtime library
+
+`misses-rt` provides helpers that generated proc macro code can call at expansion time. Add it to your proc macro crate:
+
+```toml
+[dependencies]
+misses-rt = { path = "../misses-rt" }
+```
+
+### Name helpers
+
+```rust
+misses_rt::to_table_name(&ident)  // UsersAccount → "users_accounts"
+misses_rt::to_snake_case(&ident)  // MyType → "my_type"
+misses_rt::to_snake_case_str(s)   // "MyType" → "my_type"
+misses_rt::to_pascal_case(s)      // "my_type" → MyType (Ident)
+misses_rt::concat_ident(&[a, b])  // ["foo", "Bar"] → fooBar (Ident)
+```
+
+### Type helpers
+
+```rust
+misses_rt::is_option(&ty)         // Option<T> → true
+misses_rt::unwrap_option(&ty)     // Option<T> → Some(&T)
+misses_rt::to_sql_type(&ty)       // syn::Type → "TEXT", "INTEGER", …
+```
+
+### HTML template helpers
+
+```rust
+let mut buf = misses_rt::Buffer::new();
+buf.push_str("<b>");
+buf.push_escaped("<script>"); // → "&lt;script&gt;"
+let markup: misses_rt::Markup = misses_rt::Markup::from_buffer(buf);
+println!("{}", markup.into_string());
+```
+
+### Section / key-value parsing
+
+```rust
+// Parse `props { … } slots { … }` blocks from a token stream
+let map = misses_rt::parse_sections(tokens, &["props", "slots"]);
+let props_tokens = map.get("props");
+
+// Parse `key = value, …` pairs
+let kv = misses_rt::parse_kv(tokens);
+let val = kv.get("name");
+```
+
+---
+
+## Project layout
+
+```
+misses/
+├── misses-compiler/       # The .mrs → Rust transpiler
+│   ├── src/
+│   │   ├── ast.rs         # Full AST types
+│   │   ├── parser.rs      # Hand-written recursive descent parser
+│   │   ├── codegen.rs     # AST → Rust source string
+│   │   ├── lib.rs         # Library API (parse + codegen)
+│   │   └── main.rs        # CLI binary
+│   └── examples/          # Runnable .mrs demonstrations
+│       ├── make_id_type.{mrs,rs}
+│       ├── derive_builder.{mrs,rs}
+│       ├── derive_getters.{mrs,rs}
+│       ├── declare_table.{mrs,rs}
+│       └── component.{mrs,rs}
+└── misses-rt/             # Runtime helpers for generated proc macros
+    └── src/
+        ├── lib.rs         # Buffer, Markup, name/type helpers
+        ├── parse_helpers.rs
+        └── template.rs    # HTML template AST + code-gen
+```
+
+---
+
+## How code generation works
+
+For each `.mrs` macro, the compiler generates:
+
+1. A `#[proc_macro]` function that receives `proc_macro::TokenStream`.
+2. Parser statements that destructure the input according to the pattern.
+3. Any `@{}` escape-block statements, executed inline.
+4. A `quote::quote! { … }` call whose body mirrors the `T~{}` template, with spread iterators for variadic bindings.
+5. The `quote!` result is returned as `proc_macro::TokenStream`.
+
+The generated file is formatted with [prettyplease](https://github.com/dtolnay/prettyplease) for readable output.
diff --git a/misses-compiler/examples/component.mrs b/misses-compiler/examples/component.mrs
new file mode 100644
index 0000000..ba6e500
--- /dev/null
+++ b/misses-compiler/examples/component.mrs
@@ -0,0 +1,32 @@
+// component.mrs — Vue-like component macro generator
+// Demonstrates: named literal tokens, variadic binding, $body:tt capture,
+//               escape block using misses_rt, expression injection
+macro component! {
+    $name:ident { $($prop_name:ident : $prop_type:ty),* } $body:tt => {
+        @{
+            let struct_name = format_ident!("{}", name.to_string());
+        }
+        T~{
+            pub struct $name {
+                for prop in $prop_names =>
+                    pub $prop_name.name: $prop_name.ty,
+            }
+
+            impl $name {
+                pub fn new(${ struct_name }(
+                    for prop in $prop_names =>
+                        $prop_name.name: $prop_name.ty,
+                )) -> Self {
+                    Self {
+                        for prop in $prop_names =>
+                            $prop_name.name,
+                    }
+                }
+
+                pub fn render(&self) -> misses_rt::Markup {
+                    misses_rt::parse_template($body)
+                }
+            }
+        }
+    }
+}
diff --git a/misses-compiler/examples/component.rs b/misses-compiler/examples/component.rs
new file mode 100644
index 0000000..5aafd39
--- /dev/null
+++ b/misses-compiler/examples/component.rs
@@ -0,0 +1,8 @@
+fn main() {
+    let source = include_str!("component.mrs");
+    println!("=== SOURCE ===\n{source}");
+
+    let file = misses::parse(source).expect("parse error");
+    let generated = misses::codegen(&file);
+    println!("=== GENERATED ===\n{generated}");
+}
diff --git a/misses-compiler/src/codegen.rs b/misses-compiler/src/codegen.rs
index 648ee39..9e59e0c 100644
--- a/misses-compiler/src/codegen.rs
+++ b/misses-compiler/src/codegen.rs
@@ -170,13 +170,20 @@ fn codegen_parser_stmts(pattern: &Pattern) -> Vec<String> {
                 } else if tok == "}" {
                     // already consumed by braced!
                     in_brace = false;
-                } else if tok.chars().all(|c| c.is_alphanumeric() || c == '_') {
-                    stmts.push(format!(
-                        "_input.parse::<syn::Token![{tok}]>()?;",
-                        tok = tok
-                    ));
                 } else if tok == "," {
                     stmts.push("_input.parse::<syn::Token![,]>()?;".to_string());
+                } else if tok.chars().all(|c| c.is_alphanumeric() || c == '_') {
+                    if is_syn_keyword(tok) {
+                        stmts.push(format!(
+                            "_input.parse::<syn::Token![{tok}]>()?;",
+                            tok = tok
+                        ));
+                    } else {
+                        stmts.push(format!(
+                            r#"{{ let __lit: syn::Ident = _input.parse()?; if __lit != "{tok}" {{ return Err(syn::Error::new(__lit.span(), concat!("expected `", "{tok}", "`"))); }} }}"#,
+                            tok = tok
+                        ));
+                    }
                 }
             }
             PatternItem::Binding { name, kind } => {
@@ -213,6 +220,22 @@ fn codegen_parser_stmts(pattern: &Pattern) -> Vec<String> {
     stmts
 }
 
+/// Returns true if `tok` is a valid operand for `syn::Token![...]`.
+/// This covers Rust keywords and built-in punctuation recognized by syn.
+fn is_syn_keyword(tok: &str) -> bool {
+    matches!(
+        tok,
+        "as" | "async" | "await" | "break" | "const" | "continue" | "crate"
+            | "dyn" | "else" | "enum" | "extern" | "false" | "fn" | "for"
+            | "if" | "impl" | "in" | "let" | "loop" | "match" | "mod"
+            | "move" | "mut" | "pub" | "ref" | "return" | "self" | "Self"
+            | "static" | "struct" | "super" | "trait" | "true" | "type"
+            | "union" | "unsafe" | "use" | "where" | "while" | "abstract"
+            | "become" | "box" | "do" | "final" | "macro" | "override"
+            | "priv" | "try" | "typeof" | "unsized" | "virtual" | "yield"
+    )
+}
+
 /// Generate code for the output body
 fn codegen_output_body(body: &OutputBody) -> String {
     let mut out = String::new();
diff --git a/misses-compiler/src/parser.rs b/misses-compiler/src/parser.rs
index 97348b8..d2c5d0a 100644
--- a/misses-compiler/src/parser.rs
+++ b/misses-compiler/src/parser.rs
@@ -224,22 +224,25 @@ impl<'a> Parser<'a> {
                 self.advance(1);
                 items.push(self.parse_binding()?);
             } else {
-                // literal token: collect until whitespace or $ or =>
-                let len: usize = rest.chars()
-                    .take_while(|&c| !c.is_whitespace() && c != '$')
-                    .map(|c| c.len_utf8())
-                    .sum();
-                // check if it starts with =>
-                let tok = &rest[..len];
-                if tok.is_empty() {
-                    break;
+                let c = rest.chars().next().unwrap();
+                if c.is_ascii_punctuation() {
+                    // Single-character punctuation token (`:`, `{`, `}`, `,`, `;`, etc.)
+                    // But first check that it's not the start of `=>`
+                    if rest.starts_with("=>") {
+                        break;
+                    }
+                    items.push(PatternItem::LiteralToken(c.to_string()));
+                    self.advance(c.len_utf8());
+                } else {
+                    // Identifier / keyword token: collect alphanumeric + underscore
+                    let len: usize = rest.chars()
+                        .take_while(|&c| c.is_alphanumeric() || c == '_')
+                        .map(|c| c.len_utf8())
+                        .sum();
+                    if len == 0 { break; }
+                    items.push(PatternItem::LiteralToken(rest[..len].to_string()));
+                    self.advance(len);
                 }
-                // Check if this token starts with =>
-                if tok.starts_with("=>") {
-                    break;
-                }
-                items.push(PatternItem::LiteralToken(tok.to_string()));
-                self.advance(len);
             }
         }
 
diff --git a/misses-rt/Cargo.toml b/misses-rt/Cargo.toml
new file mode 100644
index 0000000..bbe0bc3
--- /dev/null
+++ b/misses-rt/Cargo.toml
@@ -0,0 +1,9 @@
+[package]
+name = "misses-rt"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+syn = { version = "2", features = ["full"] }
+quote = "1"
+proc-macro2 = "1"
diff --git a/misses-rt/src/lib.rs b/misses-rt/src/lib.rs
new file mode 100644
index 0000000..b8e9a65
--- /dev/null
+++ b/misses-rt/src/lib.rs
@@ -0,0 +1,207 @@
+pub mod template;
+pub mod parse_helpers;
+
+pub use template::{TemplateAst, parse_template};
+pub use parse_helpers::{SectionMap, KvMap, parse_sections, parse_kv};
+
+// ── Runtime types ────────────────────────────────────────────
+
+/// Accumulation buffer for HTML rendering.
+pub struct Buffer {
+    inner: String,
+}
+
+impl Buffer {
+    pub fn new() -> Self {
+        Buffer { inner: String::new() }
+    }
+
+    /// Push literal HTML (already safe / already escaped).
+    pub fn push_str(&mut self, s: &str) {
+        self.inner.push_str(s);
+    }
+
+    /// Push a user-supplied value, HTML-escaping it.
+    pub fn push_escaped(&mut self, s: &str) {
+        for ch in s.chars() {
+            match ch {
+                '&'  => self.inner.push_str("&amp;"),
+                '<'  => self.inner.push_str("&lt;"),
+                '>'  => self.inner.push_str("&gt;"),
+                '"'  => self.inner.push_str("&quot;"),
+                '\'' => self.inner.push_str("&#x27;"),
+                c    => self.inner.push(c),
+            }
+        }
+    }
+}
+
+impl Default for Buffer {
+    fn default() -> Self { Self::new() }
+}
+
+/// A string of trusted HTML markup produced by a component.
+pub struct Markup {
+    inner: String,
+}
+
+impl Markup {
+    pub fn from_buffer(buf: Buffer) -> Self {
+        Markup { inner: buf.inner }
+    }
+
+    pub fn into_string(self) -> String {
+        self.inner
+    }
+
+    pub fn as_str(&self) -> &str {
+        &self.inner
+    }
+}
+
+impl std::fmt::Display for Markup {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str(&self.inner)
+    }
+}
+
+// ── Name helpers ─────────────────────────────────────────────
+
+/// `BlogPost` → `blog_posts`  (table name: snake_case + plural)
+pub fn to_table_name(ident: &syn::Ident) -> String {
+    let snake = pascal_to_snake(&ident.to_string());
+    format!("{}s", snake)
+}
+
+/// `BlogPost` → `blog_post`
+pub fn to_snake_case(ident: &syn::Ident) -> String {
+    pascal_to_snake(&ident.to_string())
+}
+
+/// Works on a `&str` (useful inside codegen where you have String/&str).
+pub fn to_snake_case_str(s: &str) -> String {
+    pascal_to_snake(s)
+}
+
+/// `blog_post` → `BlogPost`  (returns a `proc_macro2::Ident` for use in quote!)
+pub fn to_pascal_case(s: &str) -> proc_macro2::Ident {
+    let pascal = snake_to_pascal(s);
+    quote::format_ident!("{}", pascal)
+}
+
+/// Join parts into a single snake_case identifier.
+/// Each part that looks like PascalCase is first converted to snake_case.
+pub fn concat_ident(parts: &[&str]) -> proc_macro2::Ident {
+    let snake_parts: Vec<String> = parts.iter().map(|p| pascal_to_snake(p)).collect();
+    let joined = snake_parts.join("_");
+    quote::format_ident!("{}", joined)
+}
+
+// ── Type helpers ─────────────────────────────────────────────
+
+/// Returns `true` if `ty` is `Option<T>` for any `T`.
+pub fn is_option(ty: &syn::Type) -> bool {
+    unwrap_option(ty).is_some()
+}
+
+/// If `ty` is `Option<T>`, returns `Some(&T)`, else `None`.
+pub fn unwrap_option(ty: &syn::Type) -> Option<&syn::Type> {
+    if let syn::Type::Path(tp) = ty {
+        let seg = tp.path.segments.last()?;
+        if seg.ident != "Option" {
+            return None;
+        }
+        if let syn::PathArguments::AngleBracketed(args) = &seg.arguments {
+            if let Some(syn::GenericArgument::Type(inner)) = args.args.first() {
+                return Some(inner);
+            }
+        }
+    }
+    None
+}
+
+/// Best-effort mapping of a Rust type to a SQL column type string.
+pub fn to_sql_type(ty: &syn::Type) -> String {
+    let s = quote::quote!(#ty).to_string();
+    let s = s.replace(' ', "");
+    match s.as_str() {
+        "i8"|"i16"|"i32"|"i64"|"u8"|"u16"|"u32"|"u64"|"usize"|"isize" => "INTEGER".into(),
+        "f32"|"f64" => "REAL".into(),
+        "bool"      => "BOOLEAN".into(),
+        "String"|"&str"|"&'staticstr" => "TEXT".into(),
+        _ if s.starts_with("Option<") => {
+            // unwrap and recurse
+            if let Some(inner) = unwrap_option(ty) {
+                to_sql_type(inner) + " NULL"
+            } else {
+                "TEXT NULL".into()
+            }
+        }
+        _ => "BLOB".into(),
+    }
+}
+
+// ── Internal conversion utilities ────────────────────────────
+
+fn pascal_to_snake(s: &str) -> String {
+    if s.is_empty() {
+        return String::new();
+    }
+    let mut out = String::new();
+    let mut prev_upper = false;
+    let chars: Vec<char> = s.chars().collect();
+    for (i, &c) in chars.iter().enumerate() {
+        if c.is_uppercase() {
+            let next_is_lower = chars.get(i + 1).map(|c| c.is_lowercase()).unwrap_or(false);
+            if i > 0 && (!prev_upper || next_is_lower) {
+                out.push('_');
+            }
+            out.push(c.to_lowercase().next().unwrap());
+            prev_upper = true;
+        } else {
+            out.push(c);
+            prev_upper = false;
+        }
+    }
+    out
+}
+
+fn snake_to_pascal(s: &str) -> String {
+    s.split('_')
+        .filter(|p| !p.is_empty())
+        .map(|p| {
+            let mut c = p.chars();
+            match c.next() {
+                None    => String::new(),
+                Some(f) => f.to_uppercase().to_string() + c.as_str(),
+            }
+        })
+        .collect()
+}
+
+// ── Tests ─────────────────────────────────────────────────────
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn snake_cases() {
+        assert_eq!(pascal_to_snake("BlogPost"), "blog_post");
+        assert_eq!(pascal_to_snake("UserID"), "user_id");
+        assert_eq!(pascal_to_snake("HTTPSRequest"), "https_request");
+        assert_eq!(pascal_to_snake("simple"), "simple");
+    }
+
+    #[test]
+    fn pascal_cases() {
+        assert_eq!(snake_to_pascal("blog_post"), "BlogPost");
+        assert_eq!(snake_to_pascal("user_id"), "UserId");
+    }
+
+    #[test]
+    fn table_names() {
+        let ident = quote::format_ident!("BlogPost");
+        assert_eq!(to_table_name(&ident), "blog_posts");
+    }
+}
diff --git a/misses-rt/src/parse_helpers.rs b/misses-rt/src/parse_helpers.rs
new file mode 100644
index 0000000..50c54fe
--- /dev/null
+++ b/misses-rt/src/parse_helpers.rs
@@ -0,0 +1,130 @@
+use std::collections::HashMap;
+use proc_macro2::TokenStream;
+
+// ── SectionMap ────────────────────────────────────────────────
+
+/// A map from section name → TokenStream, parsed from a token tree like:
+/// ```text
+/// fields { ... }
+/// methods { ... }
+/// ```
+pub struct SectionMap {
+    sections: HashMap<String, TokenStream>,
+}
+
+impl SectionMap {
+    /// Get the token stream for a named section. Returns empty stream if absent.
+    pub fn get(&self, name: &str) -> TokenStream {
+        self.sections.get(name).cloned().unwrap_or_default()
+    }
+
+    /// Returns true if the section exists (even if empty).
+    pub fn has(&self, name: &str) -> bool {
+        self.sections.contains_key(name)
+    }
+
+    /// Iterate over all (name, tokens) pairs.
+    pub fn iter(&self) -> impl Iterator<Item = (&str, &TokenStream)> {
+        self.sections.iter().map(|(k, v)| (k.as_str(), v))
+    }
+}
+
+/// Parse a token stream as named sections: `name { ... } name { ... }`.
+///
+/// # Example
+/// Input tokens: `fields { x: u32, y: u32 } methods { fn sum(&self) -> u32 { ... } }`
+/// Result: `{ "fields" → tokens, "methods" → tokens }`
+pub fn parse_sections(tokens: TokenStream, _sections: &[&str]) -> SectionMap {
+    use proc_macro2::{TokenTree, Delimiter};
+
+    let mut sections = HashMap::new();
+    let mut iter = tokens.into_iter().peekable();
+
+    while let Some(tt) = iter.next() {
+        // Expect an Ident (section name)
+        let name = match &tt {
+            TokenTree::Ident(id) => id.to_string(),
+            _ => continue,
+        };
+        // Expect the next token to be a braced group
+        match iter.peek() {
+            Some(TokenTree::Group(g)) if g.delimiter() == Delimiter::Brace => {
+                let group = match iter.next() {
+                    Some(TokenTree::Group(g)) => g,
+                    _ => unreachable!(),
+                };
+                sections.insert(name, group.stream());
+            }
+            _ => {}
+        }
+    }
+
+    SectionMap { sections }
+}
+
+// ── KvMap ─────────────────────────────────────────────────────
+
+/// A map of key = value pairs parsed from a token stream like:
+/// ```text
+/// table = "users", primary_key = id, nullable = true
+/// ```
+pub struct KvMap {
+    entries: HashMap<String, String>,
+}
+
+impl KvMap {
+    /// Get a value by key (as the string representation of the token(s)).
+    pub fn get(&self, key: &str) -> Option<&str> {
+        self.entries.get(key).map(|s| s.as_str())
+    }
+
+    pub fn get_str(&self, key: &str) -> Option<&str> {
+        self.get(key)
+    }
+
+    /// Returns true if the key is present.
+    pub fn has(&self, key: &str) -> bool {
+        self.entries.contains_key(key)
+    }
+}
+
+/// Parse `key = value, key = value, ...` from a token stream.
+pub fn parse_kv(tokens: TokenStream) -> KvMap {
+    use proc_macro2::TokenTree;
+
+    let mut entries = HashMap::new();
+    let tts: Vec<TokenTree> = tokens.into_iter().collect();
+    let mut i = 0;
+
+    while i < tts.len() {
+        // key: must be an ident
+        let key = match &tts[i] {
+            TokenTree::Ident(id) => id.to_string(),
+            _ => { i += 1; continue; }
+        };
+        i += 1;
+
+        // skip whitespace (handled by tokenizer) — expect `=`
+        if i >= tts.len() { break; }
+        match &tts[i] {
+            TokenTree::Punct(p) if p.as_char() == '=' => { i += 1; }
+            _ => continue,
+        }
+
+        // value: collect tokens until `,` or end
+        let mut value_parts: Vec<String> = Vec::new();
+        while i < tts.len() {
+            match &tts[i] {
+                TokenTree::Punct(p) if p.as_char() == ',' => { i += 1; break; }
+                tt => {
+                    value_parts.push(tt.to_string());
+                    i += 1;
+                }
+            }
+        }
+
+        entries.insert(key, value_parts.join(" "));
+    }
+
+    KvMap { entries }
+}
diff --git a/misses-rt/src/template.rs b/misses-rt/src/template.rs
new file mode 100644
index 0000000..e3df5f3
--- /dev/null
+++ b/misses-rt/src/template.rs
@@ -0,0 +1,485 @@
+use proc_macro2::{TokenStream, TokenTree, Delimiter};
+
+// ── Public surface ────────────────────────────────────────────
+
+pub struct TemplateAst {
+    pub nodes: Vec<TemplateNode>,
+}
+
+/// Parse a proc_macro2::TokenStream containing HTML-ish template markup.
+///
+/// Recognised constructs:
+/// - `{{ expr }}`          → escaped interpolation  (→ push_escaped)
+/// - `{{{ expr }}}`        → raw interpolation      (→ push_str of .to_string())
+/// - `<tag @if="cond">…</tag>` → conditional block
+/// - `<tag @for="x in y">…</tag>` → loop block
+/// - `<tag @else>…</tag>`  → else branch
+/// - `<Component …/>`      → component rendering call (PascalCase tag)
+/// - `<tag attr="val">…</tag>` → HTML element
+/// - everything else       → emitted as literal text
+pub fn parse_template(tokens: TokenStream) -> TemplateAst {
+    let flat = flatten(tokens);
+    let (nodes, _) = parse_nodes(&flat, 0, None);
+    TemplateAst { nodes }
+}
+
+// ── AST types ─────────────────────────────────────────────────
+
+#[derive(Debug, Clone)]
+pub enum TemplateNode {
+    Text(String),
+    Escape { expr: String },
+    Raw    { expr: String },
+    Element(Box<Element>),
+}
+
+#[derive(Debug, Clone)]
+pub struct Element {
+    pub tag: String,
+    pub is_component: bool,
+    pub attrs: Vec<(String, String)>,
+    pub directives: Vec<Directive>,
+    pub children: Vec<TemplateNode>,
+    pub self_closing: bool,
+}
+
+#[derive(Debug, Clone)]
+pub enum Directive {
+    If(String),
+    For { var: String, iter: String },
+    Else,
+}
+
+// ── Flat token representation ─────────────────────────────────
+
+#[derive(Debug, Clone)]
+enum Tok {
+    Lt,
+    Gt,
+    Slash,
+    At,
+    Eq,
+    Comma,
+    Ident(String),
+    Lit(String),    // string literal — includes the outer quotes
+    BraceGroup(Vec<Tok>),  // { ... }
+    Other(String),
+}
+
+fn flatten(ts: TokenStream) -> Vec<Tok> {
+    ts.into_iter().flat_map(flatten_tt).collect()
+}
+
+fn flatten_tt(tt: TokenTree) -> Vec<Tok> {
+    match tt {
+        TokenTree::Ident(i) => vec![Tok::Ident(i.to_string())],
+        TokenTree::Literal(l) => vec![Tok::Lit(l.to_string())],
+        TokenTree::Punct(p) => vec![match p.as_char() {
+            '<' => Tok::Lt,
+            '>' => Tok::Gt,
+            '/' => Tok::Slash,
+            '@' => Tok::At,
+            '=' => Tok::Eq,
+            ',' => Tok::Comma,
+            c   => Tok::Other(c.to_string()),
+        }],
+        TokenTree::Group(g) if g.delimiter() == Delimiter::Brace => {
+            vec![Tok::BraceGroup(flatten(g.stream()))]
+        }
+        TokenTree::Group(g) => {
+            // Other delimiters (parens, brackets) — flatten inline with pseudo-tokens
+            let (open, close) = match g.delimiter() {
+                Delimiter::Parenthesis => ("(", ")"),
+                Delimiter::Bracket     => ("[", "]"),
+                _                      => ("{", "}"),
+            };
+            let mut v = vec![Tok::Other(open.to_string())];
+            v.extend(flatten(g.stream()));
+            v.push(Tok::Other(close.to_string()));
+            v
+        }
+    }
+}
+
+// ── Parser ────────────────────────────────────────────────────
+
+/// Returns (nodes, next_pos).
+/// `stop_at` — stop when we encounter `</stop_at>`.
+fn parse_nodes(toks: &[Tok], mut pos: usize, stop_at: Option<&str>) -> (Vec<TemplateNode>, usize) {
+    let mut nodes: Vec<TemplateNode> = Vec::new();
+
+    while pos < toks.len() {
+        // ── {{ expr }} / {{{ expr }}} interpolation ──────────
+        if let Tok::BraceGroup(inner) = &toks[pos] {
+            // Check for nested brace group → {{ }}
+            if inner.len() == 1 {
+                if let Tok::BraceGroup(inner2) = &inner[0] {
+                    // {{{ }}} → raw
+                    if inner2.len() == 1 {
+                        if let Tok::BraceGroup(expr_toks) = &inner2[0] {
+                            let expr = toks_to_str(expr_toks);
+                            nodes.push(TemplateNode::Raw { expr });
+                            pos += 1;
+                            continue;
+                        }
+                    }
+                    // {{ }} → escaped
+                    let expr = toks_to_str(inner2);
+                    nodes.push(TemplateNode::Escape { expr });
+                    pos += 1;
+                    continue;
+                }
+            }
+            // Other brace group → treat as text `{ ... }`
+            let text = format!("{{ {} }}", toks_to_str(inner));
+            push_text(&mut nodes, &text);
+            pos += 1;
+            continue;
+        }
+
+        // ── HTML tag ─────────────────────────────────────────
+        if let Tok::Lt = &toks[pos] {
+            // closing tag?
+            if pos + 1 < toks.len() {
+                if let Tok::Slash = &toks[pos + 1] {
+                    // </tag> — check if it matches our stop_at
+                    if let Some(stop) = stop_at {
+                        if let Some(Tok::Ident(tag)) = toks.get(pos + 2) {
+                            if tag == stop {
+                                // consume </tag>
+                                let end = find_gt(toks, pos + 3).unwrap_or(pos + 3);
+                                pos = end + 1;
+                                return (nodes, pos);
+                            }
+                        }
+                    }
+                    // Unknown closing tag → emit as text
+                    let end = find_gt(toks, pos + 1).unwrap_or(pos + 1);
+                    let text = reconstruct_tag(toks, pos, end);
+                    push_text(&mut nodes, &text);
+                    pos = end + 1;
+                    continue;
+                }
+            }
+
+            // Opening / self-closing tag
+            if let Some((elem, next_pos)) = parse_element(toks, pos) {
+                let tag_name = elem.tag.clone();
+                let is_self = elem.self_closing;
+                let mut elem = elem;
+
+                if !is_self {
+                    // parse children until </tag>
+                    let (children, after) = parse_nodes(toks, next_pos, Some(&tag_name));
+                    elem.children = children;
+                    pos = after;
+                } else {
+                    pos = next_pos;
+                }
+
+                nodes.push(TemplateNode::Element(Box::new(elem)));
+                continue;
+            }
+
+            // Couldn't parse as element — treat `<` as text
+            push_text(&mut nodes, "<");
+            pos += 1;
+            continue;
+        }
+
+        // ── Anything else → text ─────────────────────────────
+        let text = tok_to_str(&toks[pos]);
+        push_text(&mut nodes, &text);
+        pos += 1;
+    }
+
+    (nodes, pos)
+}
+
+/// Parse an element starting at `<`.  Returns (Element, pos_after_closing_`>`).
+fn parse_element(toks: &[Tok], start: usize) -> Option<(Element, usize)> {
+    debug_assert!(matches!(toks.get(start), Some(Tok::Lt)));
+    let mut pos = start + 1;
+
+    // tag name
+    let tag = match toks.get(pos) {
+        Some(Tok::Ident(t)) => t.clone(),
+        _ => return None,
+    };
+    pos += 1;
+
+    let is_component = tag.chars().next().map(|c| c.is_uppercase()).unwrap_or(false);
+
+    // attributes + directives
+    let mut attrs: Vec<(String, String)> = Vec::new();
+    let mut directives: Vec<Directive> = Vec::new();
+    let mut self_closing = false;
+
+    loop {
+        match toks.get(pos) {
+            None | Some(Tok::Gt) => {
+                if matches!(toks.get(pos), Some(Tok::Gt)) { pos += 1; }
+                break;
+            }
+            Some(Tok::Slash) => {
+                // /> self-closing
+                self_closing = true;
+                if matches!(toks.get(pos + 1), Some(Tok::Gt)) { pos += 2; } else { pos += 1; }
+                break;
+            }
+            Some(Tok::At) => {
+                // directive: @name or @name="value"
+                pos += 1;
+                let name = match toks.get(pos) {
+                    Some(Tok::Ident(n)) => n.clone(),
+                    _ => continue,
+                };
+                pos += 1;
+                if matches!(toks.get(pos), Some(Tok::Eq)) {
+                    pos += 1;
+                    let val = match toks.get(pos) {
+                        Some(Tok::Lit(s)) => unquote(s),
+                        Some(other) => tok_to_str(other),
+                        None => String::new(),
+                    };
+                    pos += 1;
+                    match name.as_str() {
+                        "if"   => directives.push(Directive::If(val)),
+                        "for"  => {
+                            let (var, iter) = split_for_expr(&val);
+                            directives.push(Directive::For { var, iter });
+                        }
+                        _other => attrs.push((format!("@{name}"), val)),
+                    }
+                } else {
+                    match name.as_str() {
+                        "else" => directives.push(Directive::Else),
+                        _ => {}
+                    }
+                }
+            }
+            Some(Tok::Ident(name)) => {
+                // regular attribute: name or name="value"
+                let name = name.clone();
+                pos += 1;
+                if matches!(toks.get(pos), Some(Tok::Eq)) {
+                    pos += 1;
+                    let val = match toks.get(pos) {
+                        Some(Tok::Lit(s)) => unquote(s),
+                        Some(other) => tok_to_str(other),
+                        None => String::new(),
+                    };
+                    pos += 1;
+                    attrs.push((name, val));
+                } else {
+                    attrs.push((name, String::new()));
+                }
+            }
+            _ => { pos += 1; }
+        }
+    }
+
+    Some((Element { tag, is_component, attrs, directives, children: vec![], self_closing }, pos))
+}
+
+// ── Codegen ───────────────────────────────────────────────────
+
+impl TemplateAst {
+    /// Returns the loop variable names used in `@for` directives.
+    pub fn for_bindings(&self) -> Vec<String> {
+        let mut out = Vec::new();
+        collect_for_bindings(&self.nodes, &mut out);
+        out
+    }
+
+    /// Produce the body of a `render()` function as a TokenStream:
+    /// ```rust
+    /// let mut __buf = misses_rt::Buffer::new();
+    /// // ... push_str / push_escaped / if / for ...
+    /// misses_rt::Markup::from_buffer(__buf)
+    /// ```
+    pub fn codegen(&self) -> TokenStream {
+        let mut code = String::new();
+        code.push_str("let mut __buf = misses_rt :: Buffer :: new () ;\n");
+        for node in &self.nodes {
+            codegen_node(&mut code, node, 0);
+        }
+        code.push_str("misses_rt :: Markup :: from_buffer ( __buf )\n");
+        code.parse()
+            .unwrap_or_else(|_| TokenStream::new())
+    }
+}
+
+fn collect_for_bindings(nodes: &[TemplateNode], out: &mut Vec<String>) {
+    for node in nodes {
+        if let TemplateNode::Element(e) = node {
+            for d in &e.directives {
+                if let Directive::For { var, .. } = d {
+                    out.push(var.clone());
+                }
+            }
+            collect_for_bindings(&e.children, out);
+        }
+    }
+}
+
+fn codegen_node(code: &mut String, node: &TemplateNode, depth: usize) {
+    let indent = "    ".repeat(depth);
+    match node {
+        TemplateNode::Text(s) => {
+            if !s.trim().is_empty() {
+                let escaped = s.replace('\\', "\\\\").replace('"', "\\\"");
+                code.push_str(&format!("{indent}__buf . push_str ( \"{}\" ) ;\n", escaped));
+            }
+        }
+        TemplateNode::Escape { expr } => {
+            code.push_str(&format!(
+                "{indent}__buf . push_escaped ( & ({expr}) . to_string () ) ;\n"
+            ));
+        }
+        TemplateNode::Raw { expr } => {
+            code.push_str(&format!(
+                "{indent}__buf . push_str ( & ({expr}) . to_string () ) ;\n"
+            ));
+        }
+        TemplateNode::Element(elem) => codegen_element(code, elem, depth),
+    }
+}
+
+fn codegen_element(code: &mut String, elem: &Element, depth: usize) {
+    let indent = "    ".repeat(depth);
+
+    // Determine wrapping control flow from directives
+    for dir in &elem.directives {
+        match dir {
+            Directive::If(cond) => {
+                code.push_str(&format!("{indent}if {cond} {{\n"));
+            }
+            Directive::For { var, iter } => {
+                code.push_str(&format!("{indent}for {var} in {iter} {{\n"));
+            }
+            Directive::Else => {
+                code.push_str(&format!("{indent}}} else {{\n"));
+            }
+        }
+    }
+
+    let inner_depth = if elem.directives.is_empty() { depth } else { depth + 1 };
+    let inner_indent = "    ".repeat(inner_depth);
+
+    if elem.is_component {
+        // Component invocation
+        let tag = &elem.tag;
+        let mut prop_args = String::new();
+        for (k, v) in &elem.attrs {
+            if !k.starts_with('@') {
+                prop_args.push_str(&format!("{k} : ({v}) . into () , "));
+            }
+        }
+        code.push_str(&format!(
+            "{inner_indent}__buf . push_str ( & {tag} :: new ( {prop_args}) . render () . into_string () ) ;\n"
+        ));
+    } else {
+        // HTML element: open tag
+        let open_tag = build_open_tag(elem);
+        let escaped = open_tag.replace('\\', "\\\\").replace('"', "\\\"");
+        code.push_str(&format!("{inner_indent}__buf . push_str ( \"{escaped}\" ) ;\n"));
+
+        // Children
+        for child in &elem.children {
+            codegen_node(code, child, inner_depth);
+        }
+
+        // Close tag
+        if !elem.self_closing {
+            let close = format!("</{}>", elem.tag);
+            code.push_str(&format!("{inner_indent}__buf . push_str ( \"{}\" ) ;\n", close));
+        }
+    }
+
+    if !elem.directives.is_empty() {
+        code.push_str(&format!("{indent}}}\n"));
+    }
+}
+
+fn build_open_tag(elem: &Element) -> String {
+    let mut s = format!("<{}", elem.tag);
+    for (name, val) in &elem.attrs {
+        if name.starts_with('@') { continue; }
+        if val.is_empty() {
+            s.push_str(&format!(" {name}"));
+        } else {
+            s.push_str(&format!(" {name}=\"{val}\""));
+        }
+    }
+    if elem.self_closing {
+        s.push_str(" />");
+    } else {
+        s.push('>');
+    }
+    s
+}
+
+// ── Helpers ───────────────────────────────────────────────────
+
+fn toks_to_str(toks: &[Tok]) -> String {
+    toks.iter().map(tok_to_str).collect::<Vec<_>>().join(" ")
+}
+
+fn tok_to_str(tok: &Tok) -> String {
+    match tok {
+        Tok::Lt          => "<".into(),
+        Tok::Gt          => ">".into(),
+        Tok::Slash       => "/".into(),
+        Tok::At          => "@".into(),
+        Tok::Eq          => "=".into(),
+        Tok::Comma       => ",".into(),
+        Tok::Ident(s)    => s.clone(),
+        Tok::Lit(s)      => s.clone(),
+        Tok::BraceGroup(inner) => format!("{{ {} }}", toks_to_str(inner)),
+        Tok::Other(s)    => s.clone(),
+    }
+}
+
+/// Remove surrounding `"..."` from a string literal token.
+fn unquote(s: &str) -> String {
+    if s.starts_with('"') && s.ends_with('"') && s.len() >= 2 {
+        s[1..s.len()-1].to_string()
+    } else {
+        s.to_string()
+    }
+}
+
+/// Split `"item in &self.items"` → ("item", "&self.items")
+fn split_for_expr(s: &str) -> (String, String) {
+    if let Some(idx) = s.find(" in ") {
+        let var = s[..idx].trim().to_string();
+        let iter = s[idx + 4..].trim().to_string();
+        (var, iter)
+    } else {
+        (s.to_string(), String::new())
+    }
+}
+
+fn find_gt(toks: &[Tok], from: usize) -> Option<usize> {
+    for i in from..toks.len() {
+        if matches!(toks[i], Tok::Gt) { return Some(i); }
+    }
+    None
+}
+
+fn reconstruct_tag(toks: &[Tok], start: usize, end: usize) -> String {
+    toks[start..=end].iter().map(tok_to_str).collect::<Vec<_>>().join("")
+}
+
+fn push_text(nodes: &mut Vec<TemplateNode>, text: &str) {
+    // Normalise whitespace runs to a single space when appending to existing Text
+    let text = text.replace('\n', " ").replace('\r', "");
+    if text.trim().is_empty() {
+        return;
+    }
+    match nodes.last_mut() {
+        Some(TemplateNode::Text(prev)) => prev.push_str(&text),
+        _ => nodes.push(TemplateNode::Text(text)),
+    }
+}