@aihu/css-engine 0.2.5 → 0.4.0

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;

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

@@ -1,6 +1,6 @@
 //! Scoped-output, variant, and @theme emission tests (Plan 2 Tasks 4–7).
 
-use aihu_css_core::{compile_sfc_scoped, parse_ast};
+use aihu_css_core::{compile_sfc_scoped, parse_ast, CompileError};
 
 fn ast(json: &str) -> aihu_css_core::SfcAst {
     parse_ast(json).unwrap()
@@ -21,7 +21,7 @@ fn sfc_with_classes(classes: &str) -> aihu_css_core::SfcAst {
 
 #[test]
 fn scoped_output_has_no_bare_global_utility_sheet() {
-    let css = compile_sfc_scoped(&sfc_with_classes("bg-primary p-4"));
+    let css = compile_sfc_scoped(&sfc_with_classes("bg-primary p-4")).unwrap();
     // The utility rules are class selectors inside the shadow <style>; they are
     // scoped by living in the shadow root. There is no separate global sheet.
     assert!(css.contains(".bg-primary"));
@@ -38,9 +38,13 @@ fn scoped_folds_authored_style_block() {
       "meta":{"name":"X"},
       "template":[{"kind":"element","tag":"div","attrs":[
         {"kind":"static","name":"class","value":"p-4"}],"children":[]}]}"#;
-    let css = compile_sfc_scoped(&ast(json));
+    let css = compile_sfc_scoped(&ast(json)).unwrap();
     assert!(css.contains(".p-4"));
-    assert!(css.contains(".extra { color: red; }"), "authored scoped @style folded in");
+    // Authored @style now flows through the shared parser (R-SHARED-PARSER) so
+    // the verbatim text is re-rendered (whitespace-normalized). Assert the
+    // selector + declaration survive rather than exact single-line formatting.
+    assert!(css.contains(".extra"), "authored scoped @style folded in: {css}");
+    assert!(css.contains("color: red;"), "authored declaration preserved: {css}");
 }
 
 #[test]
@@ -48,8 +52,10 @@ fn global_style_block_passes_through_edge_e6() {
     let json = r#"{"tag":"X","astVersion":1,
       "style":{"content":"body { margin: 0; }","scope":"global"},
       "meta":{"name":"X"},"template":null}"#;
-    let css = compile_sfc_scoped(&ast(json));
-    assert!(css.contains("body { margin: 0; }"));
+    let css = compile_sfc_scoped(&ast(json)).unwrap();
+    // Re-rendered through the shared parser (whitespace-normalized).
+    assert!(css.contains("body"), "global block selector preserved: {css}");
+    assert!(css.contains("margin: 0;"), "global declaration preserved: {css}");
     assert!(css.contains("unscoped"), "global block annotated as unscoped");
 }
 
@@ -57,27 +63,27 @@ fn global_style_block_passes_through_edge_e6() {
 
 #[test]
 fn host_variant_emits_host_rule() {
-    let css = compile_sfc_scoped(&sfc_with_classes("host:bg-primary"));
+    let css = compile_sfc_scoped(&sfc_with_classes("host:bg-primary")).unwrap();
     assert!(css.contains(":host("), "host: → :host(...) selector: {css}");
     assert!(css.contains("background-color: var(--color-primary)"));
 }
 
 #[test]
 fn slotted_variants() {
-    let css = compile_sfc_scoped(&sfc_with_classes("slotted:p-4 slotted-img:rounded-lg"));
+    let css = compile_sfc_scoped(&sfc_with_classes("slotted:p-4 slotted-img:rounded-lg")).unwrap();
     assert!(css.contains("::slotted("));
     assert!(css.contains("::slotted(img"));
 }
 
 #[test]
 fn part_variant_emits_part_selector() {
-    let css = compile_sfc_scoped(&sfc_with_classes("part-thumb:bg-accent"));
+    let css = compile_sfc_scoped(&sfc_with_classes("part-thumb:bg-accent")).unwrap();
     assert!(css.contains("::part(thumb)"));
 }
 
 #[test]
 fn host_context_dark_uses_cascade_not_host_context() {
-    let css = compile_sfc_scoped(&sfc_with_classes("host-context-dark:bg-surface"));
+    let css = compile_sfc_scoped(&sfc_with_classes("host-context-dark:bg-surface")).unwrap();
     assert!(
         !css.contains(":host-context("),
         "Firefox-safe: must NOT emit :host-context(): {css}"
@@ -90,38 +96,104 @@ fn host_context_dark_uses_cascade_not_host_context() {
 
 #[test]
 fn hover_variant_appends_pseudo_class() {
-    let css = compile_sfc_scoped(&sfc_with_classes("hover:bg-primary"));
+    let css = compile_sfc_scoped(&sfc_with_classes("hover:bg-primary")).unwrap();
     assert!(css.contains(":hover"), "hover: → :hover pseudo-class: {css}");
 }
 
 #[test]
 fn dark_variant_no_host_context() {
-    let css = compile_sfc_scoped(&sfc_with_classes("dark:bg-surface"));
+    let css = compile_sfc_scoped(&sfc_with_classes("dark:bg-surface")).unwrap();
     assert!(!css.contains(":host-context("), "dark: must NOT emit :host-context()");
     assert!(css.contains("dark cascade"));
 }
 
 #[test]
 fn responsive_md_wraps_media_query() {
-    let css = compile_sfc_scoped(&sfc_with_classes("md:p-8"));
+    let css = compile_sfc_scoped(&sfc_with_classes("md:p-8")).unwrap();
     assert!(css.contains("@media (min-width:"), "md: → @media: {css}");
     assert!(css.contains("padding: 2rem"));
 }
 
 #[test]
 fn arbitrary_selector_variant() {
-    let css = compile_sfc_scoped(&sfc_with_classes("[&>div]:text-primary"));
+    let css = compile_sfc_scoped(&sfc_with_classes("[&>div]:text-primary")).unwrap();
     assert!(css.contains(">div"), "[&>div]: → child selector: {css}");
     assert!(css.contains("color: var(--color-primary)"));
 }
 
 #[test]
 fn stacked_variants_md_hover() {
-    let css = compile_sfc_scoped(&sfc_with_classes("md:hover:bg-primary"));
+    let css = compile_sfc_scoped(&sfc_with_classes("md:hover:bg-primary")).unwrap();
     assert!(css.contains("@media (min-width:"));
     assert!(css.contains(":hover"));
 }
 
+// ── Round 2: group / peer relational variants ────────────────────────────────
+
+#[test]
+fn group_hover_emits_ancestor_state_selector() {
+    let css = compile_sfc_scoped(&sfc_with_classes("group-hover:bg-primary")).unwrap();
+    // Ancestor descendant-combinator: `.group:hover .group-hover\:bg-primary`.
+    assert!(
+        css.contains(".group:hover .group-hover\\:bg-primary"),
+        "group-hover: → `.group:hover <base>` ancestor selector: {css}"
+    );
+    assert!(css.contains("background-color: var(--color-primary)"));
+}
+
+#[test]
+fn group_focus_variants_emit_each_state() {
+    for (cls, sel) in [
+        ("group-focus:bg-primary", ".group:focus "),
+        ("group-focus-visible:bg-primary", ".group:focus-visible "),
+        ("group-active:bg-primary", ".group:active "),
+        ("group-disabled:bg-primary", ".group:disabled "),
+    ] {
+        let css = compile_sfc_scoped(&sfc_with_classes(cls)).unwrap();
+        assert!(css.contains(sel), "{cls} → `{sel}` prefix: {css}");
+    }
+}
+
+#[test]
+fn peer_checked_emits_sibling_state_selector() {
+    let css = compile_sfc_scoped(&sfc_with_classes("peer-checked:bg-primary")).unwrap();
+    // Subsequent-sibling combinator: `.peer:checked ~ .peer-checked\:bg-primary`.
+    assert!(
+        css.contains(".peer:checked ~ .peer-checked\\:bg-primary"),
+        "peer-checked: → `.peer:checked ~ <base>` sibling selector: {css}"
+    );
+    assert!(css.contains("background-color: var(--color-primary)"));
+}
+
+#[test]
+fn peer_state_variants_emit_each_state() {
+    for (cls, sel) in [
+        ("peer-hover:bg-primary", ".peer:hover ~ "),
+        ("peer-focus:bg-primary", ".peer:focus ~ "),
+        ("peer-focus-visible:bg-primary", ".peer:focus-visible ~ "),
+        ("peer-disabled:bg-primary", ".peer:disabled ~ "),
+    ] {
+        let css = compile_sfc_scoped(&sfc_with_classes(cls)).unwrap();
+        assert!(css.contains(sel), "{cls} → `{sel}` prefix: {css}");
+    }
+}
+
+#[test]
+fn bare_group_and_peer_markers_emit_empty_rules() {
+    let css = compile_sfc_scoped(&sfc_with_classes("group peer")).unwrap();
+    // Markers survive as empty-body rules so the relational selectors resolve.
+    assert!(css.contains(".group {"), "bare `group` marker kept: {css}");
+    assert!(css.contains(".peer {"), "bare `peer` marker kept: {css}");
+}
+
+#[test]
+fn group_peer_stack_with_responsive() {
+    // `md:group-hover:bg-primary` — breakpoint wraps the relational rule.
+    let css = compile_sfc_scoped(&sfc_with_classes("md:group-hover:bg-primary")).unwrap();
+    assert!(css.contains("@media (min-width:"), "breakpoint wrapper: {css}");
+    assert!(css.contains(".group:hover "), "relational selector inside media: {css}");
+}
+
 // ── Task 7: @theme directive ─────────────────────────────────────────────────
 
 #[test]
@@ -131,7 +203,7 @@ fn theme_override_registers_token() {
       "meta":{"name":"X"},
       "template":[{"kind":"element","tag":"div","attrs":[
         {"kind":"static","name":"class","value":"bg-primary"}],"children":[]}]}"#;
-    let css = compile_sfc_scoped(&ast(json));
+    let css = compile_sfc_scoped(&ast(json)).unwrap();
     // The override value is registered as a :host token...
     assert!(css.contains("--color-primary: oklch(0.7 0.2 30)"), "@theme override registered: {css}");
     // ...and the utility references it.
@@ -142,7 +214,202 @@ fn theme_override_registers_token() {
 
 #[test]
 fn default_aihu_brand_tokens_present() {
-    let css = compile_sfc_scoped(&sfc_with_classes("bg-accent"));
+    let css = compile_sfc_scoped(&sfc_with_classes("bg-accent")).unwrap();
     // Default accent is the aihu terracotta.
     assert!(css.contains("--color-accent: #c8543a"), "baked aihu brand default present: {css}");
 }
+
+// ── Round 2: aria-* / data-* attribute variants ─────────────────────────────
+
+#[test]
+fn aria_keyword_variant_emits_true_attr_selector() {
+    let css = compile_sfc_scoped(&sfc_with_classes("aria-checked:bg-accent")).unwrap();
+    assert!(
+        css.contains(r#"[aria-checked="true"]"#),
+        "aria-checked: → [aria-checked=\"true\"] selector: {css}"
+    );
+    assert!(css.contains("background-color: var(--color-accent)"));
+}
+
+#[test]
+fn aria_expanded_variant() {
+    let css = compile_sfc_scoped(&sfc_with_classes("aria-expanded:underline")).unwrap();
+    assert!(
+        css.contains(r#"[aria-expanded="true"]"#),
+        "aria-expanded: → [aria-expanded=\"true\"]: {css}"
+    );
+    assert!(css.contains("text-decoration-line: underline"));
+}
+
+#[test]
+fn aria_disabled_selected_pressed_variants() {
+    for (cls, attr) in [
+        ("aria-disabled:opacity-50", r#"[aria-disabled="true"]"#),
+        ("aria-selected:bg-primary", r#"[aria-selected="true"]"#),
+        ("aria-pressed:bg-accent", r#"[aria-pressed="true"]"#),
+    ] {
+        let css = compile_sfc_scoped(&sfc_with_classes(cls)).unwrap();
+        assert!(css.contains(attr), "{cls} → {attr}: {css}");
+    }
+}
+
+#[test]
+fn aria_arbitrary_value_variant() {
+    let css = compile_sfc_scoped(&sfc_with_classes("aria-[expanded=false]:underline")).unwrap();
+    assert!(
+        css.contains(r#"[aria-expanded="false"]"#),
+        "aria-[expanded=false]: → [aria-expanded=\"false\"]: {css}"
+    );
+}
+
+#[test]
+fn data_state_variant_emits_attr_selector() {
+    let css = compile_sfc_scoped(&sfc_with_classes("data-[state=open]:bg-accent")).unwrap();
+    assert!(
+        css.contains(r#"[data-state="open"]"#),
+        "data-[state=open]: → [data-state=\"open\"] selector: {css}"
+    );
+    assert!(css.contains("background-color: var(--color-accent)"));
+}
+
+#[test]
+fn data_keyword_variant_is_presence_selector() {
+    // Bare `data-active:` is a presence selector (no implicit ="true").
+    let css = compile_sfc_scoped(&sfc_with_classes("data-active:underline")).unwrap();
+    assert!(
+        css.contains("[data-active]"),
+        "data-active: → [data-active] presence selector: {css}"
+    );
+    assert!(!css.contains(r#"[data-active="true"]"#));
+}
+
+// ── Round 2: container queries (@container) ──────────────────────────────────
+
+#[test]
+fn container_marker_sets_container_type() {
+    let css = compile_sfc_scoped(&sfc_with_classes("@container")).unwrap();
+    assert!(
+        css.contains("container-type: inline-size"),
+        "@container marker → container-type: inline-size: {css}"
+    );
+}
+
+#[test]
+fn named_container_marker_sets_type_and_name() {
+    let css = compile_sfc_scoped(&sfc_with_classes("@container/sidebar")).unwrap();
+    assert!(css.contains("container-type: inline-size"), "{css}");
+    assert!(
+        css.contains("container-name: sidebar"),
+        "@container/sidebar → container-name: sidebar: {css}"
+    );
+}
+
+#[test]
+fn container_md_wraps_rule_in_container_at_rule() {
+    let css = compile_sfc_scoped(&sfc_with_classes("@md:flex")).unwrap();
+    assert!(
+        css.contains("@container (min-width:"),
+        "@md: → @container (min-width: ...): {css}"
+    );
+    // Container scale differs from the viewport breakpoint scale (md = 28rem).
+    assert!(css.contains("28rem"), "container @md = 28rem: {css}");
+    assert!(css.contains("display: flex"));
+    // Must NOT be an @media rule.
+    assert!(!css.contains("@media"), "@md: is a container query, not @media: {css}");
+}
+
+#[test]
+fn container_sm_lg_scale() {
+    let sm = compile_sfc_scoped(&sfc_with_classes("@sm:block")).unwrap();
+    assert!(sm.contains("@container (min-width: 24rem)"), "@sm = 24rem: {sm}");
+    let lg = compile_sfc_scoped(&sfc_with_classes("@lg:hidden")).unwrap();
+    assert!(lg.contains("@container (min-width: 32rem)"), "@lg = 32rem: {lg}");
+}
+
+#[test]
+fn container_parent_and_child_pair() {
+    // A @container parent + @md:flex child — the proven user-visible pattern.
+    let json = r#"{"tag":"X","astVersion":1,"style":null,"meta":{"name":"X"},
+      "template":[{"kind":"element","tag":"div","attrs":[
+        {"kind":"static","name":"class","value":"@container"}],
+        "children":[{"kind":"element","tag":"div","attrs":[
+          {"kind":"static","name":"class","value":"@md:flex"}],"children":[]}]}]}"#;
+    let css = compile_sfc_scoped(&ast(json)).unwrap();
+    assert!(css.contains("container-type: inline-size"), "{css}");
+    assert!(css.contains("@container (min-width: 28rem)"), "{css}");
+}
+
+// ── Over-implementation probe: no spurious rules for unknown base utilities ──
+
+#[test]
+fn aria_data_without_known_base_emits_nothing() {
+    // Unknown base utility behind an aria/data variant must not emit a rule.
+    let css = compile_sfc_scoped(&sfc_with_classes(
+        "aria-checked:notathing data-[state=open]:alsonope @md:bogus",
+    )).unwrap();
+    assert!(
+        !css.contains("[aria-checked"),
+        "no aria selector for unknown base: {css}"
+    );
+    assert!(
+        !css.contains("[data-state"),
+        "no data selector for unknown base: {css}"
+    );
+    assert!(
+        !css.contains("@container"),
+        "no container at-rule for unknown base: {css}"
+    );
+}
+
+// ── R-RESULT: emit returns Result; an induced emit error propagates ──────────
+
+#[test]
+fn malformed_theme_block_is_a_compile_error() {
+    // An `@theme` opener with no `{` body is malformed; the emit path now
+    // hard-errors (CompileError) instead of silently keeping the broken text.
+    let json = r#"{"tag":"X","astVersion":1,
+      "style":{"content":"@theme --color-primary: red;","scope":"scoped"},
+      "meta":{"name":"X"},"template":null}"#;
+    let err = compile_sfc_scoped(&ast(json)).unwrap_err();
+    assert!(
+        matches!(err, CompileError::MalformedTheme { .. }),
+        "expected MalformedTheme, got {err:?}"
+    );
+    assert!(
+        err.to_string().contains("malformed @theme"),
+        "actionable message: {err}"
+    );
+}
+
+#[test]
+fn well_formed_theme_block_still_succeeds() {
+    // Success path is byte-identical to before the Result conversion.
+    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 css = compile_sfc_scoped(&ast(json)).unwrap();
+    assert!(css.contains("--color-primary: red"), "{css}");
+    assert!(css.contains("background-color: var(--color-primary)"), "{css}");
+    assert!(!css.contains("@theme"), "directive consumed, not emitted: {css}");
+}
+
+// ── Issue #280: Preflight border-style reset ─────────────────────────────────
+
+#[test]
+fn preflight_border_reset_precedes_utilities() {
+    // `.unwrap()` added in the PR-1 merge: compile_sfc_scoped now returns Result.
+    let css = compile_sfc_scoped(&sfc_with_classes("border")).unwrap();
+    // Tailwind v4 Preflight: borders default to solid + zero width.
+    assert!(
+        css.contains("*, ::before, ::after { border-style: solid; border-width: 0; }"),
+        "preflight border reset present: {css}"
+    );
+    // The `.border` utility still wins by specificity.
+    assert!(css.contains(".border { border-width: 1px; }"), "border utility emitted: {css}");
+    // Preflight must come before the utility rule so the utility cascades over it.
+    let pre = css.find("border-style: solid").unwrap();
+    let util = css.find(".border {").unwrap();
+    assert!(pre < util, "preflight precedes utility rules: {css}");
+}