@aihu/css-engine 0.3.0 → 0.4.1

package/README.md

@@ -198,7 +198,7 @@ npm install @aihu/css-engine
 bun add @aihu/css-engine
 ```
 
-<sub><i>Auto-generated against `@aihu/css-engine@0.3.0`.</i></sub>
+<sub><i>Auto-generated against `@aihu/css-engine@0.4.1`.</i></sub>
 
 <!-- END_AUTOGEN: install -->
 
@@ -209,12 +209,12 @@ bun add @aihu/css-engine
 
 | | |
 |---|---|
-| **Version** | `0.3.0` |
+| **Version** | `0.4.1` |
 | **Tier** | D — Compiler — CSS engine (Tailwind v4 hard fork, WC-native scoped output) |
 | **Published files** | 5 entries |
 | **License** | MIT |
 
-<sub><i>Auto-generated against `@aihu/css-engine@0.3.0`.</i></sub>
+<sub><i>Auto-generated against `@aihu/css-engine@0.4.1`.</i></sub>
 
 <!-- END_AUTOGEN: stats -->
 
@@ -233,7 +233,7 @@ bun add @aihu/css-engine
 | `./runtime/cn` | `./dist/runtime/cn.js` | `—` |
 | `./runtime/progressive` | `./dist/runtime/progressive.js` | `—` |
 
-<sub><i>Auto-generated against `@aihu/css-engine@0.3.0`.</i></sub>
+<sub><i>Auto-generated against `@aihu/css-engine@0.4.1`.</i></sub>
 
 <!-- END_AUTOGEN: exports -->
 
@@ -248,12 +248,12 @@ bun add @aihu/css-engine
 
 **Optional dependencies (platform-specific):**
 
-- `@aihu/css-engine-darwin-arm64` — `0.1.2`
-- `@aihu/css-engine-darwin-x64` — `0.1.2`
-- `@aihu/css-engine-linux-x64-gnu` — `0.1.2`
-- `@aihu/css-engine-win32-x64-msvc` — `0.1.2`
+- `@aihu/css-engine-darwin-arm64` — `0.1.3`
+- `@aihu/css-engine-darwin-x64` — `0.1.3`
+- `@aihu/css-engine-linux-x64-gnu` — `0.1.3`
+- `@aihu/css-engine-win32-x64-msvc` — `0.1.3`
 
-<sub><i>Auto-generated against `@aihu/css-engine@0.3.0`.</i></sub>
+<sub><i>Auto-generated against `@aihu/css-engine@0.4.1`.</i></sub>
 
 <!-- END_AUTOGEN: deps -->
 
@@ -266,7 +266,7 @@ bun add @aihu/css-engine
 - [@aihu/compiler](../compiler)
 - [Aihu framework root](../../README.md)
 
-<sub><i>Auto-generated against `@aihu/css-engine@0.3.0`.</i></sub>
+<sub><i>Auto-generated against `@aihu/css-engine@0.4.1`.</i></sub>
 
 <!-- END_AUTOGEN: see-also -->
 
@@ -277,6 +277,6 @@ bun add @aihu/css-engine
 
 MIT — see [LICENSE](../../LICENSE).
 
-<sub><i>Auto-generated against `@aihu/css-engine@0.3.0`.</i></sub>
+<sub><i>Auto-generated against `@aihu/css-engine@0.4.1`.</i></sub>
 
 <!-- END_AUTOGEN: license -->

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

@@ -0,0 +1,314 @@
+//! `apply.rs` — `@apply` expansion inside `@style` (Task 1.4, R-APPLY-PARSE).
+//!
+//! Consumes the structured rule tree from [`crate::style_parser`] and replaces
+//! every rule's `@apply <tokens>` directives in place:
+//!
+//! - **Base** tokens (no variant prefix) inline the *same declarations* their
+//!   utility class produces ([`utility_to_css`]) directly into the current
+//!   rule's declaration list, in source order, before the rule's authored
+//!   declarations? No — appended after, so authored declarations can override
+//!   (last-wins, matching CSS). Actually `@apply` directives are emitted in
+//!   source order relative to the rule body; we splice the inlined declarations
+//!   at the point the directive appears. See [`expand_rule`].
+//! - **Variant** tokens (`hover:`, `data-[state=open]:`, `group:`, `md:`,
+//!   `dark:`, arbitrary `[&>x]:`, host/slotted/part, …) resolve STRUCTURALLY via
+//!   [`crate::variants::resolve_variants`] against `&` (the recipe's own
+//!   selector) to a *nested* rule on the current rule — `@apply hover:bg-accent`
+//!   inside `.btn {}` becomes `.btn { & { … } &:hover { background: … } }`. We
+//!   do NOT call `emit_token` + strip the class selector (that yields the wrong
+//!   `.hover\:bg-accent:hover` output — Codex).
+//!
+//! Unknown base utility → [`CompileError::UnknownApplyUtility`]. In a `$global`
+//! block, a variant token that implies `&`/host/relational scoping →
+//! [`CompileError::GlobalApplyVariant`] (base utilities still allowed).
+
+use crate::ast::SfcStyleScope;
+use crate::emit::CompileError;
+use crate::style_parser::{
+    parse_style, ApplyDirective, AtRule, Declaration, StyleNode, StyleRule, StyleSheet,
+};
+use crate::theme::ThemeRegistry;
+use crate::tokens::utility_to_css;
+use crate::variants::{resolve_variants, split_variants};
+
+/// Parse an authored `@style` body, expand every `@apply`, and render back to
+/// CSS. This is the single entry the emitter calls in place of folding the raw
+/// `@style` text verbatim.
+pub fn expand_apply(
+    style_content: &str,
+    scope: SfcStyleScope,
+    theme: &ThemeRegistry,
+) -> Result<String, CompileError> {
+    let mut sheet = parse_style(style_content).map_err(|e| CompileError::StyleParse {
+        detail: e.to_string(),
+    })?;
+    expand_sheet(&mut sheet, scope, theme)?;
+    Ok(sheet.to_css())
+}
+
+/// Expand `@apply` across every node in a parsed sheet, in place.
+fn expand_sheet(
+    sheet: &mut StyleSheet,
+    scope: SfcStyleScope,
+    theme: &ThemeRegistry,
+) -> Result<(), CompileError> {
+    for node in &mut sheet.nodes {
+        expand_node(node, scope, theme)?;
+    }
+    Ok(())
+}
+
+fn expand_node(
+    node: &mut StyleNode,
+    scope: SfcStyleScope,
+    theme: &ThemeRegistry,
+) -> Result<(), CompileError> {
+    match node {
+        StyleNode::Rule(rule) => expand_rule(rule, scope, theme),
+        StyleNode::AtRule(at) => expand_at_rule(at, scope, theme),
+        StyleNode::AtStatement(_) => Ok(()),
+    }
+}
+
+fn expand_at_rule(
+    at: &mut AtRule,
+    scope: SfcStyleScope,
+    theme: &ThemeRegistry,
+) -> Result<(), CompileError> {
+    for node in &mut at.body {
+        expand_node(node, scope, theme)?;
+    }
+    Ok(())
+}
+
+/// Expand a single rule: inline base-utility declarations, lift variant tokens
+/// into nested rules, recurse into already-nested rules, then drop the consumed
+/// `@apply` directives.
+fn expand_rule(
+    rule: &mut StyleRule,
+    scope: SfcStyleScope,
+    theme: &ThemeRegistry,
+) -> Result<(), CompileError> {
+    // Take the directives out; we re-classify their tokens into inline
+    // declarations (base) and nested rules (variant).
+    let applies = std::mem::take(&mut rule.applies);
+    let mut inlined: Vec<Declaration> = Vec::new();
+    let mut nested_from_apply: Vec<StyleNode> = Vec::new();
+
+    for ApplyDirective { tokens } in &applies {
+        for token in tokens {
+            let (variants, base) = split_variants(token);
+            let body = utility_to_css(&base).ok_or_else(|| CompileError::UnknownApplyUtility {
+                token: token.clone(),
+            })?;
+
+            if variants.is_empty() {
+                // Base utility: inline its declarations into the current rule.
+                inlined.extend(parse_declarations(&body));
+                continue;
+            }
+
+            // Variant token → structural nested rule on `&`.
+            let resolved = resolve_variants(&variants, "&", theme);
+
+            // `$global` blocks have no `&`/host scope: reject scope-implying
+            // variants; a bare breakpoint/container/dark variant has no
+            // host/relational implication and is allowed.
+            if matches!(scope, SfcStyleScope::Global) && resolved.needs_scope {
+                return Err(CompileError::GlobalApplyVariant {
+                    token: token.clone(),
+                });
+            }
+
+            let decls = parse_declarations(&body);
+            let nested_rule = StyleRule {
+                selector: resolved.selector,
+                declarations: decls,
+                applies: Vec::new(),
+                nested: Vec::new(),
+            };
+
+            // Wrap in dark-cascade and/or at-rule layers as needed. The dark
+            // cascade rewrites the selector to the Firefox-safe gate; the
+            // at-rule (media/container) wraps the whole thing.
+            let mut node = if resolved.dark_cascade {
+                dark_cascade_node(nested_rule)
+            } else {
+                StyleNode::Rule(nested_rule)
+            };
+            if let Some(at) = resolved.at_rule {
+                let (name, prelude) = split_at_prelude(&at);
+                node = StyleNode::AtRule(AtRule {
+                    name,
+                    prelude,
+                    body: vec![node],
+                });
+            }
+            nested_from_apply.push(node);
+        }
+    }
+
+    // Inlined base declarations come first (so the rule's own authored
+    // declarations, appended after, win on conflict — CSS last-declaration
+    // wins). Prepend to preserve that ordering.
+    if !inlined.is_empty() {
+        let mut decls = inlined;
+        decls.append(&mut rule.declarations);
+        rule.declarations = decls;
+    }
+
+    // Variant-derived nested rules go before any authored nested nodes so the
+    // expanded output reads `&:hover {…}` right after the base declarations.
+    if !nested_from_apply.is_empty() {
+        nested_from_apply.append(&mut rule.nested);
+        rule.nested = nested_from_apply;
+    }
+
+    // Recurse into nested rules (authored or expanded — expanded ones carry no
+    // further `@apply`, so this is a no-op for them but keeps the walk uniform).
+    for node in &mut rule.nested {
+        expand_node(node, scope, theme)?;
+    }
+
+    Ok(())
+}
+
+/// Build the Firefox-safe dark-cascade node for a resolved variant rule. Mirrors
+/// the gate the emitter uses (`emit_token`): the rule applies only under
+/// `:host([data-theme="dark"])` or `:root.dark`. The nested `&` in the resolved
+/// selector is expanded against each gate prefix.
+fn dark_cascade_node(rule: StyleRule) -> StyleNode {
+    // `rule.selector` is the resolved selector starting from `&` (e.g. `&` for a
+    // bare `dark:`, or `&:hover` for `dark:hover:`). Compose the two gated
+    // selectors by substituting the host/root prefix for the leading `&`.
+    let sel = rule.selector;
+    let host = sel.replacen('&', ":host([data-theme=\"dark\"]) &", 1);
+    let root = sel.replacen('&', ":root.dark &", 1);
+    StyleNode::Rule(StyleRule {
+        selector: format!("{host}, {root}"),
+        declarations: rule.declarations,
+        applies: Vec::new(),
+        nested: Vec::new(),
+    })
+}
+
+/// Split a wrapping at-rule string (`@media (min-width: 600px)`) into its name
+/// (`@media`) and prelude (`(min-width: 600px)`).
+fn split_at_prelude(at: &str) -> (String, String) {
+    let at = at.trim();
+    match at.find(char::is_whitespace) {
+        Some(i) => (at[..i].to_string(), at[i..].trim().to_string()),
+        None => (at.to_string(), String::new()),
+    }
+}
+
+/// Split a utility's emitted CSS body (`"display: flex; align-items: center;"`)
+/// into individual [`Declaration`]s. The bodies the token table produces are
+/// simple `prop: value;` lists, but values can contain `:` (e.g.
+/// `cubic-bezier(...)`) and `;` inside parens — so split on top-level `;`/`:`
+/// honouring parens/brackets/strings (reusing the same discipline as the parser).
+fn parse_declarations(body: &str) -> Vec<Declaration> {
+    let mut out = Vec::new();
+    for chunk in split_top_level_semicolons(body) {
+        let chunk = chunk.trim();
+        if chunk.is_empty() {
+            continue;
+        }
+        if let Some((prop, value)) = split_first_colon(chunk) {
+            out.push(Declaration {
+                prop: prop.trim().to_string(),
+                value: value.trim().to_string(),
+            });
+        }
+        // A chunk with no top-level `:` (e.g. a nested `& > * + * { … }` body
+        // from `divide-*`/`space-*`) is not a flat declaration; those utilities
+        // are not used via `@apply` in the current recipes, and emitting them as
+        // a raw declaration would be wrong. We drop such non-declaration chunks
+        // here rather than mis-emit; if a recipe needs them, they should be
+        // authored directly (R-NO-PREMIGRATION-BREAK regression guards this).
+    }
+    out
+}
+
+/// Split on top-level `;` (not inside `(...)`, `[...]`, or strings).
+fn split_top_level_semicolons(body: &str) -> Vec<&str> {
+    let bytes = body.as_bytes();
+    let mut out = Vec::new();
+    let mut start = 0usize;
+    let mut paren = 0u32;
+    let mut bracket = 0u32;
+    let mut i = 0usize;
+    while i < bytes.len() {
+        match bytes[i] {
+            b'"' | b'\'' => {
+                let q = bytes[i];
+                i += 1;
+                while i < bytes.len() {
+                    if bytes[i] == b'\\' {
+                        i += 2;
+                        continue;
+                    }
+                    if bytes[i] == q {
+                        i += 1;
+                        break;
+                    }
+                    i += 1;
+                }
+                continue;
+            }
+            b'(' => paren += 1,
+            b')' => paren = paren.saturating_sub(1),
+            b'[' => bracket += 1,
+            b']' => bracket = bracket.saturating_sub(1),
+            b';' if paren == 0 && bracket == 0 => {
+                out.push(&body[start..i]);
+                start = i + 1;
+            }
+            _ => {}
+        }
+        i += 1;
+    }
+    if start < body.len() {
+        out.push(&body[start..]);
+    }
+    out
+}
+
+/// Split a declaration chunk on its first top-level `:` (none inside
+/// `(...)`/`[...]`/strings).
+fn split_first_colon(chunk: &str) -> Option<(&str, &str)> {
+    let bytes = chunk.as_bytes();
+    let mut paren = 0u32;
+    let mut bracket = 0u32;
+    let mut i = 0usize;
+    while i < bytes.len() {
+        match bytes[i] {
+            b'"' | b'\'' => {
+                let q = bytes[i];
+                i += 1;
+                while i < bytes.len() {
+                    if bytes[i] == b'\\' {
+                        i += 2;
+                        continue;
+                    }
+                    if bytes[i] == q {
+                        i += 1;
+                        break;
+                    }
+                    i += 1;
+                }
+                continue;
+            }
+            b'(' => paren += 1,
+            b')' => paren = paren.saturating_sub(1),
+            b'[' => bracket += 1,
+            b']' => bracket = bracket.saturating_sub(1),
+            b':' if paren == 0 && bracket == 0 => {
+                return Some((&chunk[..i], &chunk[i + 1..]));
+            }
+            _ => {}
+        }
+        i += 1;
+    }
+    None
+}

package/crates/aihu-css-core/src/bin/main.rs

@@ -48,13 +48,14 @@ fn main() {
     }
 
     let css = if ast_mode {
-        match aihu_css_core::parse_ast(&buf) {
-            Ok(ast) => aihu_css_core::compile_sfc_scoped(&ast),
-            Err(e) => {
-                eprintln!("aihu-css-compile: {e}");
-                std::process::exit(1);
-            }
-        }
+        let ast = aihu_css_core::parse_ast(&buf).unwrap_or_else(|e| {
+            eprintln!("aihu-css-compile: {e}");
+            std::process::exit(1);
+        });
+        aihu_css_core::compile_sfc_scoped(&ast).unwrap_or_else(|e| {
+            eprintln!("aihu-css-compile: {e}");
+            std::process::exit(1);
+        })
     } else {
         let classes: Vec<String> = buf
             .lines()

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

@@ -11,7 +11,7 @@ use std::collections::HashMap;
 use std::hash::{Hash, Hasher};
 
 use crate::ast::{SfcAst, SfcAttr, SfcNode, SfcStyleScope};
-use crate::emit::emit_sfc_scoped;
+use crate::emit::{emit_sfc_scoped, CompileError};
 
 /// An in-process compilation cache. Construct one per dev session / build run.
 #[derive(Debug, Default)]
@@ -32,16 +32,19 @@ impl CssCache {
     /// Compile an SFC, returning a cached result on an unchanged-input hit.
     /// `theme_version` participates in the key so a theme change invalidates
     /// every entry.
-    pub fn compile(&mut self, ast: &SfcAst, theme_version: u64) -> String {
+    ///
+    /// On a compile error (R-RESULT) the error propagates and nothing is
+    /// cached, so a later fixed input re-runs the full compile path.
+    pub fn compile(&mut self, ast: &SfcAst, theme_version: u64) -> Result<String, CompileError> {
         let key = hash_ast(ast, theme_version);
         if let Some(cached) = self.entries.get(&key) {
             self.hits += 1;
-            return cached.clone();
+            return Ok(cached.clone());
         }
         self.recompiles += 1;
-        let css = emit_sfc_scoped(ast);
+        let css = emit_sfc_scoped(ast)?;
         self.entries.insert(key, css.clone());
-        css
+        Ok(css)
     }
 
     /// Total full recompiles since construction.

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

@@ -29,6 +29,54 @@ pub enum OutputMode {
     Scoped,
 }
 
+/// A recoverable error raised while emitting CSS from an SFC AST.
+///
+/// This is the precursor error channel (R-RESULT): `emit_sfc_scoped` /
+/// `compile_sfc_scoped` / the per-SFC cache return `Result<String, CompileError>`
+/// so later passes (`@apply` unknown-utility, variant validation) can hard-error
+/// instead of silently dropping. The `aihu-css-compile` binary prints the
+/// `Display` message to stderr and exits non-zero; the TS bridge surfaces it as
+/// a thrown `Error` carrying that message.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum CompileError {
+    /// An authored `@style` block opened `@theme` with no `{ … }` body.
+    MalformedTheme { detail: String },
+    /// An `@apply` directive referenced a utility token whose base utility is
+    /// not in the table (Task 1.4 — unknown utility hard-errors).
+    UnknownApplyUtility { token: String },
+    /// An `@apply` inside a `$global` `@style` block used a variant token that
+    /// implies `&`/host/relational scoping (Task 1.4 — base utilities allowed in
+    /// `$global`, scope-implying variants rejected).
+    GlobalApplyVariant { token: String },
+    /// A `@style` block failed to parse structurally (R-SHARED-PARSER).
+    StyleParse { detail: String },
+}
+
+impl std::fmt::Display for CompileError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            CompileError::MalformedTheme { detail } => {
+                write!(f, "malformed @theme block in authored @style: {detail}")
+            }
+            CompileError::UnknownApplyUtility { token } => {
+                write!(f, "unknown utility in @apply: `{token}`")
+            }
+            CompileError::GlobalApplyVariant { token } => {
+                write!(
+                    f,
+                    "@apply in a $global @style block may not use the scope-implying \
+                     variant `{token}` (only base utilities are allowed in $global)"
+                )
+            }
+            CompileError::StyleParse { detail } => {
+                write!(f, "failed to parse @style block: {detail}")
+            }
+        }
+    }
+}
+
+impl std::error::Error for CompileError {}
+
 /// CSS-escape a class name for use in a selector (`bg-[#fff]` → `bg-\[\#fff\]`).
 fn escape_class(class: &str) -> String {
     let mut out = String::with_capacity(class.len() + 4);
@@ -88,6 +136,7 @@ fn emit_token(token: &str, theme: &ThemeRegistry, prog: &ProgressiveRegistry) ->
             Variant::SlottedTag(tag) => selector = format!("::slotted({tag}{selector})"),
             Variant::Part(name) => selector = format!("::part({name})"),
             Variant::Pseudo(pc) => selector = format!("{selector}:{pc}"),
+            Variant::PseudoElement(pe) => selector = format!("{selector}::{pe}"),
             Variant::ArbitrarySelector(sel) => {
                 // `[&>div]:` → substitute `&` for the base selector.
                 selector = sel.replace('&', &selector);
@@ -173,7 +222,7 @@ fn emit_token(token: &str, theme: &ThemeRegistry, prog: &ProgressiveRegistry) ->
 /// `attr_selector("aria", Name{checked, true})` → `[aria-checked="true"]`;
 /// `attr_selector("data", NameValue{state, open})` → `[data-state="open"]`;
 /// `attr_selector("data", Name{active, false})` → `[data-active]` (presence).
-fn attr_selector(family: &str, m: &AttrMatch) -> String {
+pub(crate) fn attr_selector(family: &str, m: &AttrMatch) -> String {
     match m {
         AttrMatch::Name { name, imply_true } => {
             if *imply_true {
@@ -226,7 +275,7 @@ pub fn emit_with_progressive(
 
 /// Compile a full SFC AST to scoped CSS: theme tokens (`:host`-level custom
 /// props) + scanned utility rules + the folded authored `@style` block.
-pub fn emit_sfc_scoped(ast: &SfcAst) -> String {
+pub fn emit_sfc_scoped(ast: &SfcAst) -> Result<String, CompileError> {
     let mut theme = ThemeRegistry::with_aihu_defaults();
 
     // Parse @theme directives from the authored style block first so utilities
@@ -240,57 +289,88 @@ pub fn emit_sfc_scoped(ast: &SfcAst) -> String {
 
     let result = scan(ast);
     let prog = ProgressiveRegistry::with_builtins();
-    let mut out = String::new();
 
-    // 1. Theme tokens at :host so var(--color-*) resolves inside the shadow.
-    out.push_str(&theme.emit_host_tokens());
+    // Build the rule body first — preflight + scanned utilities + folded
+    // `@style` — so we can discover which palette `--color-*` tokens it
+    // references and register them before emitting the `:host` token block.
+    let mut body = String::new();
+
+    // Preflight border reset (Tailwind v4 parity). Browsers default
+    // `border-style: none`, so a bare `.border { border-width: 1px }` paints
+    // nothing. Emit a single one-time rule so every border utility renders a
+    // visible solid line. This is one rule per sheet (not per token), so the
+    // size impact is negligible; the matching utility wins by specificity.
+    body.push_str("*, ::before, ::after { border-style: solid; border-width: 0; }\n");
 
-    // 2. Scanned utility rules (scoped) — progressive prefixes routed via `prog`.
-    out.push_str(&emit_with_progressive(
+    // Scanned utility rules (scoped) — progressive prefixes routed via `prog`.
+    body.push_str(&emit_with_progressive(
         &result,
         &theme,
         &prog,
         OutputMode::Scoped,
     ));
 
-    // 3. Fold the authored @style block (minus @theme directives).
+    // Fold the authored @style block (minus @theme directives), expanding any
+    // `@apply` directives first (Task 1.4). Base utilities inline as
+    // declarations; variant tokens lift to nested `&…` rules on the recipe's
+    // own selector. Unknown utilities / illegal `$global` variants hard-error.
     if let Some(style) = &ast.style {
-        let authored = strip_theme_blocks(&style.content);
-        let authored = authored.trim();
-        if !authored.is_empty() {
-            match style.scope {
-                // Scoped: it already lives in the shadow <style>; pass through.
-                SfcStyleScope::Scoped => {
-                    out.push_str("/* authored @style (scoped) */\n");
-                    out.push_str(authored);
-                    out.push('\n');
-                }
-                // Global ($global): passed through unscoped (edge E6). The
-                // compiler hoists this out of the shadow root.
-                SfcStyleScope::Global => {
-                    out.push_str("/* authored @style ($global — unscoped) */\n");
-                    out.push_str(authored);
-                    out.push('\n');
+        let stripped = strip_theme_blocks(&style.content)?;
+        if !stripped.trim().is_empty() {
+            let authored = crate::apply::expand_apply(&stripped, style.scope, &theme)?;
+            let authored = authored.trim();
+            if !authored.is_empty() {
+                match style.scope {
+                    // Scoped: it already lives in the shadow <style>; pass through.
+                    SfcStyleScope::Scoped => {
+                        body.push_str("/* authored @style (scoped) */\n");
+                        body.push_str(authored);
+                        body.push('\n');
+                    }
+                    // Global ($global): passed through unscoped (edge E6). The
+                    // compiler hoists this out of the shadow root.
+                    SfcStyleScope::Global => {
+                        body.push_str("/* authored @style ($global — unscoped) */\n");
+                        body.push_str(authored);
+                        body.push('\n');
+                    }
                 }
             }
         }
     }
 
-    out
+    // Register the palette tokens the body references (Tailwind ships the full
+    // palette in its default theme) so `var(--color-amber-200)` resolves at
+    // `:host`. Only the referenced tokens are added — not all 286.
+    crate::tokens::register_used_palette(&body, &mut theme);
+
+    // Theme tokens at :host (now incl. used palette) so var(--color-*) resolves
+    // inside the shadow root, then the rule body.
+    let mut out = theme.emit_host_tokens();
+    out.push_str(&body);
+
+    Ok(out)
 }
 
 /// Remove `@theme { ... }` blocks from style content (they become host tokens,
 /// not raw CSS).
-fn strip_theme_blocks(style_content: &str) -> String {
+///
+/// An `@theme` opener with no `{ … }` body is a malformed authored block and
+/// now hard-errors via [`CompileError`] (R-RESULT) instead of silently keeping
+/// the broken text verbatim — the first real error this `Result` channel
+/// surfaces. Later passes (`@apply`, variant validation) add more variants.
+fn strip_theme_blocks(style_content: &str) -> Result<String, CompileError> {
     let mut out = String::new();
     let mut rest = style_content;
     while let Some(at) = rest.find("@theme") {
         out.push_str(&rest[..at]);
         let after = &rest[at + "@theme".len()..];
         let Some(open) = after.find('{') else {
-            // Malformed — keep the rest verbatim and stop.
-            out.push_str(&rest[at..]);
-            return out;
+            // Malformed: `@theme` with no `{` body. Hard-error rather than
+            // emitting the broken text verbatim.
+            return Err(CompileError::MalformedTheme {
+                detail: "expected `{` after `@theme`".to_string(),
+            });
         };
         let body_start = open + 1;
         let mut depth = 1u32;
@@ -311,5 +391,5 @@ fn strip_theme_blocks(style_content: &str) -> String {
         rest = &after[end + 1..];
     }
     out.push_str(rest);
-    out
+    Ok(out)
 }