@aihu/css-engine 0.2.5 → 0.4.0

package/crates/aihu-css-core/src/variants.rs

@@ -32,14 +32,56 @@ pub enum Variant {
     HostContextDark,
 
     // ── standard ─────────────────────────────────────────────────────────────
-    /// `hover:`, `focus:`, `focus-visible:`, `active:`, `disabled:` → `&:<pc>`.
+    /// `hover:`, `focus:`, `focus-visible:`, `active:`, `disabled:`, `first:`
+    /// (→ `:first-child`), `last:`, `open:` → `&:<pc>`.
     Pseudo(String),
+    /// `marker:` → `&::marker`, `placeholder:` → `&::placeholder`,
+    /// `before:`/`after:`/`selection:`/`file:` → `&::<pe>`. Pseudo-*element*
+    /// variants attach with a double colon (distinct from [`Variant::Pseudo`]).
+    PseudoElement(String),
     /// `dark:` — dark cascade (NOT `:host-context()`).
     Dark,
     /// `sm:`/`md:`/`lg:`/`xl:`/`2xl:` → `@media (min-width: …)`.
     Breakpoint(String),
     /// `[&>div]:` arbitrary selector → native nesting (`& > div`).
     ArbitrarySelector(String),
+
+    // ── relational (group / peer) ────────────────────────────────────────────
+    /// `group-hover:`, `group-focus:`, `group-focus-visible:`, `group-active:`,
+    /// `group-disabled:` → ancestor-state selector
+    /// (`.group:<state> <base>`). The `Option<String>` is the ancestor state
+    /// pseudo-class. A bare `group` (no state) is NOT a variant prefix — it is a
+    /// marker utility (see `tokens::fixed_utility`) applied directly to the
+    /// ancestor element; this arm only ever carries `Some(state)`.
+    Group(Option<String>),
+    /// `peer-hover:`, `peer-focus:`, `peer-focus-visible:`, `peer-checked:`,
+    /// `peer-disabled:` → previous-sibling-state selector
+    /// (`.peer:<state> ~ <base>`). As with [`Variant::Group`], the bare `peer`
+    /// marker is a utility, not a prefix; this arm only carries `Some(state)`.
+    Peer(Option<String>),
+
+    // ── attribute / container (round 2) ───────────────────────────────────────
+    /// `aria-checked:` → `&[aria-checked="true"]` (keyword form, implicit
+    /// `="true"`). `aria-[expanded=false]:` carries an explicit `name=value`
+    /// payload → `&[aria-expanded="false"]`.
+    Aria(AttrMatch),
+    /// `data-[state=open]:` → `&[data-state="open"]` (bracket payload
+    /// `name=value`). `data-active:` (keyword) → `&[data-active]` (presence).
+    Data(AttrMatch),
+    /// Container-query breakpoint variant: `@sm:`/`@md:`/`@lg:`/`@xl:`/`@2xl:`
+    /// → `@container (min-width: …)`. Wraps the rule like `Breakpoint`, but in
+    /// an `@container` at-rule instead of `@media`.
+    Container(String),
+}
+
+/// An attribute-selector match payload for `aria-*` / `data-*` variants.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum AttrMatch {
+    /// `aria-checked` → `[aria-checked="true"]` (aria) or `[data-active]`
+    /// presence (data). The bool records whether to imply `="true"`.
+    Name { name: String, imply_true: bool },
+    /// Explicit `name=value` → `[<full>-name="value"]`.
+    NameValue { name: String, value: String },
 }
 
 impl Variant {
@@ -108,17 +150,223 @@ fn parse_prefix(prefix: &str) -> Option<Variant> {
         "host-context-dark" => Variant::HostContextDark,
         "slotted" => Variant::Slotted,
         "dark" => Variant::Dark,
-        "hover" | "focus" | "focus-visible" | "active" | "disabled" | "visited"
-        | "checked" => Variant::Pseudo(prefix.to_string()),
+        "hover" | "focus" | "focus-visible" | "active" | "disabled" | "visited" | "checked"
+        | "required" | "open" => Variant::Pseudo(prefix.to_string()),
+        // Structural pseudo-classes map to their `:…-child` / `:nth-child()` form.
+        "first" => Variant::Pseudo("first-child".to_string()),
+        "last" => Variant::Pseudo("last-child".to_string()),
+        "only" => Variant::Pseudo("only-child".to_string()),
+        "odd" => Variant::Pseudo("nth-child(odd)".to_string()),
+        "even" => Variant::Pseudo("nth-child(even)".to_string()),
+        "empty" => Variant::Pseudo("empty".to_string()),
+        // Pseudo-elements (double colon).
+        "marker" => Variant::PseudoElement("marker".to_string()),
+        "placeholder" => Variant::PseudoElement("placeholder".to_string()),
+        "before" => Variant::PseudoElement("before".to_string()),
+        "after" => Variant::PseudoElement("after".to_string()),
+        "selection" => Variant::PseudoElement("selection".to_string()),
+        "file" => Variant::PseudoElement("file-selector-button".to_string()),
         "sm" | "md" | "lg" | "xl" | "2xl" => Variant::Breakpoint(prefix.to_string()),
+        // Container-query breakpoints: `@sm`/`@md`/`@lg`/`@xl`/`@2xl`.
+        "@sm" | "@md" | "@lg" | "@xl" | "@2xl" => Variant::Container(prefix[1..].to_string()),
         _ => {
             if let Some(tag) = prefix.strip_prefix("slotted-") {
                 Variant::SlottedTag(tag.to_string())
             } else if let Some(name) = prefix.strip_prefix("part-") {
                 Variant::Part(name.to_string())
+            } else if let Some(state) = group_state(prefix) {
+                Variant::Group(state)
+            } else if let Some(state) = peer_state(prefix) {
+                Variant::Peer(state)
+            } else if let Some(payload) = prefix.strip_prefix("aria-") {
+                Variant::Aria(parse_attr_match(payload, true))
+            } else if let Some(payload) = prefix.strip_prefix("data-") {
+                // data-* never implies `="true"`: bare `data-active` is a
+                // presence selector `[data-active]`.
+                Variant::Data(parse_attr_match(payload, false))
             } else {
                 return None;
             }
         }
     })
 }
+
+/// States a `group-*:` prefix may carry. Returns `Some(Some(state))` when
+/// `prefix` is a recognized `group-<state>` form. (`group` alone is a marker
+/// utility, not a variant — so it is NOT matched here.)
+fn group_state(prefix: &str) -> Option<Option<String>> {
+    let state = prefix.strip_prefix("group-")?;
+    relational_state(state).map(Some)
+}
+
+/// States a `peer-*:` prefix may carry. See [`group_state`].
+fn peer_state(prefix: &str) -> Option<Option<String>> {
+    let state = prefix.strip_prefix("peer-")?;
+    relational_state(state).map(Some)
+}
+
+/// The closed set of states `group-*:` / `peer-*:` accept. They map 1:1 to a
+/// pseudo-class on the ancestor / previous-sibling marker element.
+fn relational_state(state: &str) -> Option<String> {
+    matches!(
+        state,
+        "hover" | "focus" | "focus-visible" | "active" | "disabled" | "checked" | "open"
+    )
+    .then(|| state.to_string())
+}
+
+/// How a (possibly empty) variant list resolves against a base selector for the
+/// `@apply` expansion path (`apply.rs`). This is the SHARED structural resolver
+/// (R-APPLY-PARSE): `@apply hover:bg-accent` inside a `.btn { … }` rule must map
+/// to a nested `&:hover { … }` block on the *recipe's own* selector — NOT to a
+/// `.hover\:bg-accent:hover` class rule (Codex confirmed `emit_token` +
+/// string-strip produces wrong output).
+///
+/// The emitter ([`emit_token`](crate::emit)) starts from a class selector
+/// (`.token`); the `@apply` path starts from `&` (the parent rule). Both walk the
+/// same variant arms, so the per-variant selector transforms live here as
+/// [`apply_variant_to_selector`] and the wrapping/cascade decisions in
+/// [`ResolvedVariants`].
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ResolvedVariants {
+    /// The selector the declarations attach to, with each variant applied
+    /// against the starting base (`&` for `@apply`). E.g. `&:hover`,
+    /// `&[data-state="open"]`, `.group:hover &`.
+    pub selector: String,
+    /// A wrapping at-rule (`@media (min-width: …)` / `@container (…)`) the rule
+    /// nests inside, if a breakpoint/container variant was present.
+    pub at_rule: Option<String>,
+    /// True when a dark-cascade variant (`dark:`/`host-context-dark:`) was
+    /// present — the caller emits the Firefox-safe dark gate instead of a plain
+    /// rule.
+    pub dark_cascade: bool,
+    /// True when any variant implies host/`&`/relational scoping. Used to reject
+    /// such variants inside a `$global` `@apply` (Task 1.4 — variants that imply
+    /// `&`/host scoping are rejected in `$global`; base utilities allowed).
+    pub needs_scope: bool,
+}
+
+/// Apply one [`Variant`] to a running selector, mirroring the emitter's arms but
+/// starting from an arbitrary base (`&` for the `@apply` path). Returns the new
+/// selector, plus optional `(at_rule)` / `dark_cascade` / `needs_scope` signals
+/// via the accumulator the caller threads.
+fn apply_variant_to_selector(
+    v: &Variant,
+    selector: String,
+    theme: &crate::theme::ThemeRegistry,
+    acc: &mut ResolvedVariants,
+) -> String {
+    match v {
+        Variant::Host => {
+            acc.needs_scope = true;
+            format!(":host({selector})")
+        }
+        Variant::Slotted => {
+            acc.needs_scope = true;
+            format!("::slotted({selector})")
+        }
+        Variant::SlottedTag(tag) => {
+            acc.needs_scope = true;
+            format!("::slotted({tag}{selector})")
+        }
+        Variant::Part(name) => {
+            acc.needs_scope = true;
+            format!("::part({name})")
+        }
+        Variant::Pseudo(pc) => {
+            acc.needs_scope = true;
+            format!("{selector}:{pc}")
+        }
+        Variant::PseudoElement(pe) => {
+            acc.needs_scope = true;
+            format!("{selector}::{pe}")
+        }
+        Variant::ArbitrarySelector(sel) => {
+            acc.needs_scope = true;
+            sel.replace('&', &selector)
+        }
+        Variant::Group(Some(state)) => {
+            acc.needs_scope = true;
+            format!(".group:{state} {selector}")
+        }
+        Variant::Peer(Some(state)) => {
+            acc.needs_scope = true;
+            format!(".peer:{state} ~ {selector}")
+        }
+        Variant::Group(None) | Variant::Peer(None) => selector,
+        Variant::Aria(m) => {
+            acc.needs_scope = true;
+            format!("{selector}{}", crate::emit::attr_selector("aria", m))
+        }
+        Variant::Data(m) => {
+            acc.needs_scope = true;
+            format!("{selector}{}", crate::emit::attr_selector("data", m))
+        }
+        Variant::Breakpoint(bp) => {
+            if let Some(min) = theme.breakpoint(bp) {
+                acc.at_rule = Some(format!("@media (min-width: {min})"));
+            }
+            selector
+        }
+        Variant::Container(bp) => {
+            if let Some(min) = theme.container_breakpoint(bp) {
+                acc.at_rule = Some(format!("@container (min-width: {min})"));
+            }
+            selector
+        }
+        Variant::Dark | Variant::HostContextDark => {
+            // The dark cascade rewrites `&` to a `:host([data-theme])`/`:root.dark`
+            // gate — host/root scope that a `$global` `@apply` cannot express.
+            acc.dark_cascade = true;
+            acc.needs_scope = true;
+            selector
+        }
+    }
+}
+
+/// Resolve a variant list against `base` (`&` for `@apply`) into the structural
+/// selector + wrapping decisions shared by `@apply` expansion.
+pub fn resolve_variants(
+    variants: &[Variant],
+    base: &str,
+    theme: &crate::theme::ThemeRegistry,
+) -> ResolvedVariants {
+    let mut acc = ResolvedVariants {
+        selector: base.to_string(),
+        at_rule: None,
+        dark_cascade: false,
+        needs_scope: false,
+    };
+    let mut selector = base.to_string();
+    for v in variants {
+        selector = apply_variant_to_selector(v, selector, theme, &mut acc);
+    }
+    acc.selector = selector;
+    acc
+}
+
+/// Parse the payload after `aria-`/`data-` into an [`AttrMatch`].
+///
+/// Two shapes:
+/// - `checked` (keyword) → `Name { name: "checked", imply_true }`.
+/// - `[state=open]` (bracket, from `data-[state=open]`) → `NameValue`. The
+///   bracket-aware splitter in [`split_variants`] keeps the `[...]` attached to
+///   the prefix, so the payload arrives here as `[state=open]`.
+fn parse_attr_match(payload: &str, imply_true: bool) -> AttrMatch {
+    // Strip an outer `[...]` if present (arbitrary form).
+    let inner = payload
+        .strip_prefix('[')
+        .and_then(|s| s.strip_suffix(']'))
+        .unwrap_or(payload);
+    if let Some((name, value)) = inner.split_once('=') {
+        AttrMatch::NameValue {
+            name: name.trim().to_string(),
+            value: value.trim().trim_matches('"').to_string(),
+        }
+    } else {
+        AttrMatch::Name {
+            name: inner.trim().to_string(),
+            imply_true,
+        }
+    }
+}

package/crates/aihu-css-core/tests/apply.rs

@@ -0,0 +1,203 @@
+//! `@apply` expansion edge matrix (Task 1.4 — R-APPLY-PARSE, R-APPLY-TESTS).
+//!
+//! Drives `compile_sfc_scoped` with authored `@style` blocks containing `@apply`
+//! directives and snapshots the folded output. The matrix (per R-APPLY-TESTS):
+//! base; single variant → nested; multi-token `@apply a b c`; multiple `@apply`
+//! per rule; `@apply` in a nested rule; arbitrary-value `bg-[#fff]`; unknown-
+//! utility error; `$global` variant rejection.
+
+use aihu_css_core::{compile_sfc_scoped, parse_ast, CompileError, SfcStyleScope};
+
+/// Build an SFC AST with the given authored `@style` content + scope. No
+/// template classes so the snapshot is JUST theme tokens + the folded `@style`,
+/// isolating the `@apply` expansion.
+fn sfc_style(content: &str, scope: &str) -> aihu_css_core::SfcAst {
+    let json = format!(
+        r#"{{"tag":"X","astVersion":1,
+          "style":{{"content":{content},"scope":"{scope}"}},
+          "meta":{{"name":"X"}},"template":null}}"#,
+        content = serde_json::to_string(content).unwrap()
+    );
+    parse_ast(&json).unwrap()
+}
+
+fn scoped(content: &str) -> String {
+    compile_sfc_scoped(&sfc_style(content, "scoped")).unwrap()
+}
+
+/// Compile via `expand_apply` directly (parser → expand → css) so the snapshot
+/// is just the expanded `@style`, with no theme-token preamble.
+fn expand(content: &str, scope: SfcStyleScope) -> Result<String, CompileError> {
+    aihu_css_core::expand_apply(content, scope, &aihu_css_core::ThemeRegistry::with_aihu_defaults())
+}
+
+// ── base utility inline ──────────────────────────────────────────────────────
+
+#[test]
+fn base_utility_inlines_declarations() {
+    let css = expand(".btn { @apply inline-flex items-center; }", SfcStyleScope::Scoped).unwrap();
+    insta::assert_snapshot!(css);
+}
+
+// ── single variant → nested rule ─────────────────────────────────────────────
+
+#[test]
+fn single_variant_lifts_to_nested_rule() {
+    // hover: → &:hover { … } on the recipe's OWN selector (NOT a
+    // `.hover\:bg-accent:hover` class rule).
+    let css = expand(".btn { @apply hover:bg-accent; }", SfcStyleScope::Scoped).unwrap();
+    assert!(css.contains("&:hover"), "variant lifts to nested &:hover: {css}");
+    assert!(
+        !css.contains(r"\:"),
+        "must NOT emit an escaped class selector: {css}"
+    );
+    insta::assert_snapshot!(css);
+}
+
+// ── multi-token @apply a b c ─────────────────────────────────────────────────
+
+#[test]
+fn multi_token_apply() {
+    let css = expand(
+        ".btn { @apply inline-flex items-center justify-center rounded-md; }",
+        SfcStyleScope::Scoped,
+    )
+    .unwrap();
+    insta::assert_snapshot!(css);
+}
+
+// ── multiple @apply per rule ─────────────────────────────────────────────────
+
+#[test]
+fn multiple_apply_directives_per_rule() {
+    let css = expand(
+        ".btn {\n  @apply inline-flex;\n  @apply rounded-md;\n  @apply hover:bg-accent;\n}",
+        SfcStyleScope::Scoped,
+    )
+    .unwrap();
+    insta::assert_snapshot!(css);
+}
+
+// ── @apply in a nested rule ──────────────────────────────────────────────────
+
+#[test]
+fn apply_inside_nested_rule() {
+    let css = expand(
+        ".card {\n  display: grid;\n  & .title { @apply font-medium; }\n}",
+        SfcStyleScope::Scoped,
+    )
+    .unwrap();
+    assert!(css.contains("font-weight: 500"), "nested @apply inlined: {css}");
+    insta::assert_snapshot!(css);
+}
+
+// ── arbitrary-value utility ──────────────────────────────────────────────────
+
+#[test]
+fn arbitrary_value_utility_in_apply() {
+    let css = expand(".swatch { @apply bg-[#fff]; }", SfcStyleScope::Scoped).unwrap();
+    assert!(
+        css.contains("background-color: #fff"),
+        "arbitrary value inlined verbatim: {css}"
+    );
+    insta::assert_snapshot!(css);
+}
+
+#[test]
+fn arbitrary_value_variant_in_apply() {
+    let css = expand(".swatch { @apply hover:bg-[#fff]; }", SfcStyleScope::Scoped).unwrap();
+    assert!(css.contains("&:hover"));
+    assert!(css.contains("background-color: #fff"));
+    insta::assert_snapshot!(css);
+}
+
+// ── responsive + data + group variants ───────────────────────────────────────
+
+#[test]
+fn responsive_variant_wraps_media() {
+    let css = expand(".grid { @apply md:flex; }", SfcStyleScope::Scoped).unwrap();
+    assert!(css.contains("@media (min-width:"), "md: wraps @media: {css}");
+    insta::assert_snapshot!(css);
+}
+
+#[test]
+fn data_attribute_variant() {
+    let css = expand(
+        r#".btn { @apply data-[state=open]:bg-accent; }"#,
+        SfcStyleScope::Scoped,
+    )
+    .unwrap();
+    assert!(css.contains(r#"&[data-state="open"]"#), "{css}");
+    insta::assert_snapshot!(css);
+}
+
+#[test]
+fn dark_variant_cascade_in_apply() {
+    let css = expand(".panel { @apply dark:bg-surface; }", SfcStyleScope::Scoped).unwrap();
+    assert!(
+        !css.contains(":host-context("),
+        "Firefox-safe: no :host-context(): {css}"
+    );
+    assert!(css.contains(r#":host([data-theme="dark"])"#), "{css}");
+    assert!(css.contains(":root.dark"), "{css}");
+    insta::assert_snapshot!(css);
+}
+
+// ── unknown utility error ────────────────────────────────────────────────────
+
+#[test]
+fn unknown_utility_is_compile_error() {
+    let err = expand(".btn { @apply totally-not-a-utility; }", SfcStyleScope::Scoped)
+        .expect_err("unknown utility must hard-error");
+    match err {
+        CompileError::UnknownApplyUtility { ref token } => {
+            assert_eq!(token, "totally-not-a-utility")
+        }
+        other => panic!("expected UnknownApplyUtility, got {other:?}"),
+    }
+    assert!(err.to_string().contains("unknown utility in @apply"));
+}
+
+#[test]
+fn unknown_utility_propagates_through_compile_sfc_scoped() {
+    let err = compile_sfc_scoped(&sfc_style(".btn { @apply nope-nope; }", "scoped"))
+        .expect_err("must propagate");
+    assert!(matches!(err, CompileError::UnknownApplyUtility { .. }));
+}
+
+// ── $global variant rejection ────────────────────────────────────────────────
+
+#[test]
+fn global_apply_rejects_scope_implying_variant() {
+    let err = expand("body { @apply hover:bg-accent; }", SfcStyleScope::Global)
+        .expect_err("$global may not use a scope-implying variant");
+    match err {
+        CompileError::GlobalApplyVariant { ref token } => assert_eq!(token, "hover:bg-accent"),
+        other => panic!("expected GlobalApplyVariant, got {other:?}"),
+    }
+}
+
+#[test]
+fn global_apply_allows_base_utility() {
+    // Base utilities are fine in $global — they inline as flat declarations.
+    let css = expand("body { @apply inline-flex; }", SfcStyleScope::Global).unwrap();
+    assert!(css.contains("display: inline-flex"), "{css}");
+}
+
+#[test]
+fn global_apply_allows_media_variant() {
+    // A breakpoint variant implies no host/`&` scope (it only wraps in @media),
+    // so it is allowed in $global.
+    let css = expand("body { @apply md:flex; }", SfcStyleScope::Global).unwrap();
+    assert!(css.contains("@media (min-width:"), "{css}");
+}
+
+// ── end-to-end through compile_sfc_scoped (theme preamble included) ───────────
+
+#[test]
+fn end_to_end_scoped_with_theme_preamble() {
+    let css = scoped(".btn { @apply inline-flex hover:bg-accent; }");
+    assert!(css.contains(":host {"), "theme tokens present: {css}");
+    assert!(css.contains("display: inline-flex"));
+    assert!(css.contains("&:hover"));
+}

package/crates/aihu-css-core/tests/apply_regression.rs

@@ -0,0 +1,150 @@
+//! R-NO-PREMIGRATION-BREAK (CRITICAL): every current `packages/ui/registry/*`
+//! recipe's authored `@style` block must pass through `@apply` expansion with no
+//! hard-error. If a recipe uses a utility token the table does not cover, this
+//! test fails — and the fix is to cover the token in `tokens.rs` (or fix the
+//! recipe) BEFORE enabling expansion, so turning `@apply` on does not break the
+//! shipped recipes.
+//!
+//! The test reads the `.aihu` SFC files directly (relative to the crate, two
+//! levels up to the repo root), extracts each `@style { … }` block body with a
+//! brace-matched scan, strips `@theme` blocks (handled separately by the
+//! emitter), and runs `expand_apply` on the remainder.
+
+use std::path::PathBuf;
+
+use aihu_css_core::{expand_apply, SfcStyleScope, ThemeRegistry};
+
+/// The repo root, derived from this crate's manifest dir
+/// (`<root>/packages/css-engine/crates/aihu-css-core`).
+fn repo_root() -> PathBuf {
+    let mut p = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+    for _ in 0..4 {
+        p.pop();
+    }
+    p
+}
+
+/// Extract the body inside `@style { … }` (brace-matched), or `None` if the file
+/// has no `@style` block. `$global @style` is not used by the current recipes,
+/// but we treat any `@style` block as scoped for this regression (the only
+/// concern is whether tokens RESOLVE, which is scope-independent for base
+/// utilities; variant tokens resolve identically — only the $global *rejection*
+/// path differs, and none of these recipes use $global).
+fn extract_style_body(src: &str) -> Option<String> {
+    // Find the `@style` BLOCK opener — `@style` followed only by whitespace then
+    // `{`. (A naive `find("@style")` would match the word inside a comment such
+    // as "see @style below"; the recipes contain exactly that.)
+    let mut search = 0usize;
+    let (at, after) = loop {
+        let rel = src[search..].find("@style")?;
+        let at = search + rel;
+        let after = &src[at + "@style".len()..];
+        let trimmed = after.trim_start();
+        if trimmed.starts_with('{') {
+            break (at, after);
+        }
+        search = at + "@style".len();
+    };
+    let _ = at;
+    let open = after.find('{')?;
+    let body_start = open + 1;
+    let bytes = after.as_bytes();
+    let mut depth = 1i32;
+    let mut i = body_start;
+    while i < bytes.len() {
+        match bytes[i] {
+            b'{' => depth += 1,
+            b'}' => {
+                depth -= 1;
+                if depth == 0 {
+                    return Some(after[body_start..i].to_string());
+                }
+            }
+            _ => {}
+        }
+        i += 1;
+    }
+    None
+}
+
+/// Remove `@theme { … }` blocks (brace-matched) — the emitter strips these
+/// before folding, so the `@apply` pass never sees them.
+fn strip_theme(body: &str) -> String {
+    let mut out = String::new();
+    let mut rest = body;
+    while let Some(at) = rest.find("@theme") {
+        out.push_str(&rest[..at]);
+        let after = &rest[at + "@theme".len()..];
+        let Some(open) = after.find('{') else {
+            out.push_str(after);
+            return out;
+        };
+        let bytes = after.as_bytes();
+        let mut depth = 1i32;
+        let mut i = open + 1;
+        while i < bytes.len() {
+            match bytes[i] {
+                b'{' => depth += 1,
+                b'}' => {
+                    depth -= 1;
+                    if depth == 0 {
+                        break;
+                    }
+                }
+                _ => {}
+            }
+            i += 1;
+        }
+        rest = &after[i + 1..];
+    }
+    out.push_str(rest);
+    out
+}
+
+#[test]
+fn every_registry_recipe_apply_resolves() {
+    let registry = repo_root().join("packages/ui/registry");
+    assert!(
+        registry.is_dir(),
+        "registry dir not found at {}",
+        registry.display()
+    );
+
+    let theme = ThemeRegistry::with_aihu_defaults();
+    let mut checked = 0usize;
+
+    for entry in std::fs::read_dir(&registry).unwrap() {
+        let dir = entry.unwrap().path();
+        if !dir.is_dir() {
+            continue;
+        }
+        for file in std::fs::read_dir(&dir).unwrap() {
+            let path = file.unwrap().path();
+            if path.extension().and_then(|s| s.to_str()) != Some("aihu") {
+                continue;
+            }
+            let src = std::fs::read_to_string(&path).unwrap();
+            let Some(body) = extract_style_body(&src) else {
+                continue;
+            };
+            if !body.contains("@apply") {
+                // No @apply → nothing to expand, but still assert it parses.
+                continue;
+            }
+            let stripped = strip_theme(&body);
+            let result = expand_apply(&stripped, SfcStyleScope::Scoped, &theme);
+            assert!(
+                result.is_ok(),
+                "recipe {} @apply expansion failed: {:?}",
+                path.display(),
+                result.err()
+            );
+            checked += 1;
+        }
+    }
+
+    assert!(
+        checked > 0,
+        "expected at least one recipe with @apply (button) to be checked"
+    );
+}