@aihu/css-engine 0.3.0 → 0.4.0

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

@@ -32,8 +32,13 @@ 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: …)`.
@@ -145,13 +150,25 @@ 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())
-        }
+        "@sm" | "@md" | "@lg" | "@xl" | "@2xl" => Variant::Container(prefix[1..].to_string()),
         _ => {
             if let Some(tag) = prefix.strip_prefix("slotted-") {
                 Variant::SlottedTag(tag.to_string())
@@ -193,11 +210,141 @@ fn peer_state(prefix: &str) -> Option<Option<String>> {
 fn relational_state(state: &str) -> Option<String> {
     matches!(
         state,
-        "hover" | "focus" | "focus-visible" | "active" | "disabled" | "checked"
+        "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:

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"
+    );
+}

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

@@ -0,0 +1,61 @@
+//! Binary-level error propagation (R-RESULT): an induced emit error must exit
+//! the `aihu-css-compile` binary non-zero AND print the message to stderr.
+//! Cargo sets `CARGO_BIN_EXE_aihu-css-compile` for this integration test.
+
+use std::io::Write;
+use std::process::{Command, Stdio};
+
+fn run_ast_mode(ast_json: &str) -> std::process::Output {
+    let bin = env!("CARGO_BIN_EXE_aihu-css-compile");
+    let mut child = Command::new(bin)
+        .arg("--ast-json")
+        .stdin(Stdio::piped())
+        .stdout(Stdio::piped())
+        .stderr(Stdio::piped())
+        .spawn()
+        .expect("spawn aihu-css-compile");
+    child
+        .stdin
+        .as_mut()
+        .expect("stdin")
+        .write_all(ast_json.as_bytes())
+        .expect("write stdin");
+    child.wait_with_output().expect("wait")
+}
+
+#[test]
+fn malformed_theme_exits_nonzero_with_stderr_message() {
+    // `@theme` with no `{` body → CompileError::MalformedTheme.
+    let json = r#"{"tag":"X","astVersion":1,
+      "style":{"content":"@theme --color-primary: red;","scope":"scoped"},
+      "meta":{"name":"X"},"template":null}"#;
+    let out = run_ast_mode(json);
+    assert!(
+        !out.status.success(),
+        "binary must exit non-zero on emit error; status={:?}",
+        out.status
+    );
+    let stderr = String::from_utf8_lossy(&out.stderr);
+    assert!(
+        stderr.contains("aihu-css-compile:") && stderr.contains("malformed @theme"),
+        "stderr must carry the actionable message, got: {stderr:?}"
+    );
+    assert!(
+        out.stdout.is_empty(),
+        "no CSS should be written on error; stdout={:?}",
+        String::from_utf8_lossy(&out.stdout)
+    );
+}
+
+#[test]
+fn well_formed_input_exits_zero_and_emits_css() {
+    let json = r#"{"tag":"X","astVersion":1,
+      "style":{"content":"@theme { --color-primary: red; }","scope":"scoped"},
+      "meta":{"name":"X"},
+      "template":[{"kind":"element","tag":"div","attrs":[
+        {"kind":"static","name":"class","value":"bg-primary"}],"children":[]}]}"#;
+    let out = run_ast_mode(json);
+    assert!(out.status.success(), "well-formed input exits zero");
+    let css = String::from_utf8_lossy(&out.stdout);
+    assert!(css.contains("background-color: var(--color-primary)"), "{css}");
+}

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

@@ -20,11 +20,11 @@ fn hit_returns_identical_output_and_skips_recompile() {
     let mut cache = CssCache::new();
     let ast = sfc("bg-primary p-4");
 
-    let first = cache.compile(&ast, 1);
+    let first = cache.compile(&ast, 1).unwrap();
     assert_eq!(cache.recompiles(), 1, "first compile is a miss");
     assert_eq!(cache.hits(), 0);
 
-    let second = cache.compile(&ast, 1);
+    let second = cache.compile(&ast, 1).unwrap();
     assert_eq!(second, first, "cache hit returns byte-identical output");
     assert_eq!(cache.recompiles(), 1, "second compile must NOT recompile");
     assert_eq!(cache.hits(), 1, "second compile is a hit");
@@ -33,8 +33,8 @@ fn hit_returns_identical_output_and_skips_recompile() {
 #[test]
 fn ast_change_invalidates_entry() {
     let mut cache = CssCache::new();
-    cache.compile(&sfc("p-4"), 1);
-    cache.compile(&sfc("p-8"), 1); // different class → different hash
+    cache.compile(&sfc("p-4"), 1).unwrap();
+    cache.compile(&sfc("p-8"), 1).unwrap(); // different class → different hash
     assert_eq!(cache.recompiles(), 2, "a changed AST recompiles");
     assert_eq!(cache.hits(), 0);
 }
@@ -43,8 +43,8 @@ fn ast_change_invalidates_entry() {
 fn theme_version_change_invalidates_entry() {
     let mut cache = CssCache::new();
     let ast = sfc("bg-primary");
-    cache.compile(&ast, 1);
-    cache.compile(&ast, 2); // theme bumped → invalidate
+    cache.compile(&ast, 1).unwrap();
+    cache.compile(&ast, 2).unwrap(); // theme bumped → invalidate
     assert_eq!(cache.recompiles(), 2, "a theme-version bump recompiles");
 }
 
@@ -53,12 +53,12 @@ fn cache_hit_is_well_under_30ms() {
     let mut cache = CssCache::new();
     // Warm the cache.
     let ast = sfc("bg-primary p-4 rounded-lg hover:bg-accent md:p-8 host:text-primary");
-    let _ = cache.compile(&ast, 1);
+    let _ = cache.compile(&ast, 1).unwrap();
 
     // Time 1000 cache hits; each must be far below the 30 ms per-SFC bar.
     let start = Instant::now();
     for _ in 0..1000 {
-        let _ = cache.compile(&ast, 1);
+        let _ = cache.compile(&ast, 1).unwrap();
     }
     let elapsed = start.elapsed();
     let per_hit = elapsed / 1000;