diff --git a/README.md b/README.md
index aae98b7..da1c122 100644
--- a/README.md
+++ b/README.md
@@ -8,7 +8,7 @@ LiveStyle provides a type-safe, composable styling system with:
 - **Deterministic hashing**: Same styles always produce same class names
 - **CSS Variables**: Type-safe design tokens with `vars/1`
 - **Constants**: Static values inlined at compile time with `consts/1`
-- **Theming**: Override variables with `theme/2`
+- **Theming**: Override CSS variables with `theme_class/2`
 - **@layer support**: CSS cascade layers for predictable specificity
 - **Last-wins merging**: Like StyleX, later styles override earlier ones
 
@@ -19,7 +19,7 @@ Add `live_style` to your dependencies in `mix.exs`:
 ```elixir
 def deps do
   [
-    {:live_style, "~> 0.14.0"}
+    {:live_style, "~> 0.16.2"}
   ]
 end
 ```
@@ -174,7 +174,7 @@ LiveStyle brings Meta's StyleX philosophy to Phoenix LiveView:
 ```elixir
 def deps do
   [
-    {:live_style, "~> 0.14.0"},
+    {:live_style, "~> 0.16.2"},
     # Automatic vendor prefixing
     {:autoprefixer_ex, "~> 0.1.0"},
     # Deprecation warnings for CSS properties
diff --git a/config/config.exs b/config/config.exs
index ef34308..49ec4c5 100644
--- a/config/config.exs
+++ b/config/config.exs
@@ -1,9 +1,14 @@
 import Config
 
-config :git_ops,
-  mix_project: LiveStyle.MixProject,
-  changelog_file: "CHANGELOG.md",
-  repository_url: "https://github.com/lifeiscontent/live_style",
-  manage_mix_version?: true,
-  manage_readme_version?: "README.md",
-  version_tag_prefix: "v"
+if config_env() == :dev do
+  config :git_ops,
+    mix_project: LiveStyle.MixProject,
+    changelog_file: "CHANGELOG.md",
+    repository_url: "https://github.com/lifeiscontent/live_style",
+    manage_mix_version?: true,
+    manage_readme_version: "README.md",
+    managed_files: [
+      {"guides/getting-started.md", :string}
+    ],
+    version_tag_prefix: "v"
+end
diff --git a/guides/advanced-features.md b/guides/advanced-features.md
index 3846096..444c705 100644
--- a/guides/advanced-features.md
+++ b/guides/advanced-features.md
@@ -26,7 +26,7 @@ defmodule MyAppWeb.Card do
 
   def render(assigns) do
     ~H"""
-    <div class={LiveStyle.default_marker()}>
+    <div {css([LiveStyle.default_marker()])}>
       <div {css(:card_content)}>
         Hover the parent to move me
       </div>
@@ -58,8 +58,7 @@ defmodule MyAppWeb.Table do
   use LiveStyle
   alias LiveStyle.When
 
-  @row_marker LiveStyle.marker(:row)
-  @row_hover When.ancestor(":hover", @row_marker)
+  @row_hover When.ancestor(":hover", marker(:row))
 
   class :cell,
     opacity: [
@@ -75,9 +74,9 @@ defmodule MyAppWeb.Table do
 
   def render(assigns) do
     ~H"""
-    <div class={LiveStyle.default_marker()}>
+    <div {css([LiveStyle.default_marker()])}>
       <table>
-        <tr :for={row <- @rows} class={@row_marker}>
+        <tr :for={row <- @rows} {css([marker(:row)])}>
           <td :for={cell <- row} {css(:cell)}>
             <%= cell %>
           </td>
@@ -278,7 +277,7 @@ export function createViewTransitionDom(options = {}) {
           types: transitionTypes.length ? transitionTypes : ["same-document"],
         })
       } catch (error) {
-        // Firefox 144+ doesn't support callbackOptions yet
+        // Some browsers do not support callbackOptions yet.
         document.startViewTransition(update)
       }
     },
@@ -483,7 +482,10 @@ end
 
 ### Browser Support
 
-View Transitions are supported in Chrome 111+, Edge 111+, Safari 18+, and Firefox 144+. They gracefully degrade in unsupported browsers.
+View Transitions are available in current major browsers, but support details
+continue to move as the API evolves. The adapter above checks
+`document.startViewTransition`, so unsupported browsers render the update
+without an animated transition.
 
 ## Scroll-Driven Animations
 
@@ -637,7 +639,11 @@ Range keywords:
 
 ### Browser Support
 
-Scroll-driven animations are supported in Chrome 115+, Edge 115+, and Safari 18+. They require no JavaScript - the browser handles all animation timing based on scroll position.
+Scroll-driven animation support is still uneven across widely used browsers.
+Treat these as progressive enhancements and consider wrapping critical effects in
+`@supports (animation-timeline: scroll())`. They require no JavaScript in
+supporting browsers - the browser handles animation timing based on scroll
+position.
 
 ## CSS Anchor Positioning
 
@@ -717,7 +723,9 @@ Only positioning-related properties are allowed in `position_try`:
 
 ### Browser Support
 
-CSS Anchor Positioning is available in Chromium 125+ (June 2024). Firefox and Safari don't yet support this feature. Consider feature detection or fallback positioning.
+CSS Anchor Positioning is newly available across current major browser engines,
+but older browser versions still need fallback positioning. Consider feature
+detection when the anchored UI is critical.
 
 ## Combining Features
 
@@ -729,26 +737,24 @@ defmodule MyAppWeb.Dropdown do
   use LiveStyle
   alias LiveStyle.When
 
-  @trigger_marker LiveStyle.marker(:trigger)
-
   class :menu,
     position: "absolute",
     position_anchor: "--dropdown-trigger",
     top: "anchor(bottom)",
     opacity: [
       {:default, "0"},
-      {When.sibling_before(":focus", @trigger_marker), "1"}
+      {When.sibling_before(":focus", marker(:trigger)), "1"}
     ],
     transform: [
       {:default, "translateY(-10px)"},
-      {When.sibling_before(":focus", @trigger_marker), "translateY(0)"}
+      {When.sibling_before(":focus", marker(:trigger)), "translateY(0)"}
     ],
     transition: "opacity 200ms, transform 200ms"
 
   def dropdown(assigns) do
     ~H"""
     <div>
-      <button class={[@trigger_marker]} style="anchor-name: --dropdown-trigger">
+      <button {css([marker(:trigger)])} style="anchor-name: --dropdown-trigger">
         Menu
       </button>
       <div {css(:menu)}>
diff --git a/guides/configuration.md b/guides/configuration.md
index 5f94ae3..41a7205 100644
--- a/guides/configuration.md
+++ b/guides/configuration.md
@@ -247,10 +247,20 @@ end
 
 | Option | Type | Default | Description |
 |--------|------|---------|-------------|
+| `manifest_path` | string | `_build/{env}/live_style/{app}/manifest.etf` | Override where compiled style data is stored |
+| `usage_path` | string | `_build/{env}/live_style/{app}/usage.etf` | Override where class usage data is stored |
 | `shorthand_behavior` | atom | `:accept_shorthands` | How to handle CSS shorthands |
+| `class_name_prefix` | string | `"x"` | Prefix for generated classes, variables, and keyframes |
+| `debug_class_names` | boolean | `false` | Include property names in generated class names |
+| `font_size_px_to_rem` | boolean | `false` | Convert numeric `font_size` px values to rem |
+| `font_size_root_px` | number | `16` | Root pixel size used for px-to-rem conversion |
 | `use_css_layers` | boolean | `false` | Use CSS `@layer` for specificity |
-| `prefix_css` | mfa | `nil` | Vendor prefixing function |
-| `deprecated?` | mfa | `nil` | Deprecation check function |
+| `validate_properties` | boolean | `true` | Validate CSS property names at compile time |
+| `unknown_property_level` | atom | `:warn` | `:warn`, `:error`, or `:ignore` for unknown CSS properties |
+| `vendor_prefix_level` | atom | `:warn` | `:warn` or `:ignore` for unnecessary vendor-prefixed properties |
+| `deprecated_property_level` | atom | `:warn` | `:warn` or `:ignore` for deprecated properties |
+| `prefix_css` | function or MFA | `nil` | Vendor prefixing function |
+| `deprecated?` | function or MFA | `nil` | Deprecation check function |
 
 ### Profile Options
 
diff --git a/guides/design-tokens.md b/guides/design-tokens.md
index 4717238..7d70ebc 100644
--- a/guides/design-tokens.md
+++ b/guides/design-tokens.md
@@ -120,10 +120,10 @@ defmodule MyAppWeb.Breakpoints do
   use LiveStyle
 
   consts [
-    sm: "@media (min-width: 640px)",
-    md: "@media (min-width: 768px)",
-    lg: "@media (min-width: 1024px)",
-    xl: "@media (min-width: 1280px)"
+    sm: "(min-width: 640px)",
+    md: "(min-width: 768px)",
+    lg: "(min-width: 1024px)",
+    xl: "(min-width: 1280px)"
   ]
 end
 
@@ -235,28 +235,39 @@ end
 | Function | CSS Syntax |
 |----------|------------|
 | `color/1` | `<color>` |
-| `length/1` | `<length>` |
 | `angle/1` | `<angle>` |
+| `custom/2` | custom syntax |
+| `custom_ident/1` | `<custom-ident>` |
+| `image/1` | `<image>` |
 | `integer/1` | `<integer>` |
+| `length/1` | `<length>` |
+| `length_percentage/1` | `<length-percentage>` |
+| `no_inherit/1` | sets `inherits: false` |
 | `number/1` | `<number>` |
-| `time/1` | `<time>` |
 | `percentage/1` | `<percentage>` |
+| `resolution/1` | `<resolution>` |
+| `string/1` | `<string>` |
+| `time/1` | `<time>` |
+| `transform_function/1` | `<transform-function>` |
+| `transform_list/1` | `<transform-list>` |
+| `url/1` | `<url>` |
+| `any/1` | `*` |
 
 ## Recommended Token Structure
 
 A recommended structure for larger applications:
 
 ```
-lib/my_app/tokens/
-├── colors.ex          # MyAppWeb.Colors - raw color palette
-├── semantic.ex        # MyAppWeb.Semantic - themed semantic tokens
-├── spacing.ex         # MyAppWeb.Spacing - spacing scale
-├── font_size.ex       # MyAppWeb.FontSize - typography sizes
-├── radius.ex          # MyAppWeb.Radius - border radii
-├── shadow.ex          # MyAppWeb.Shadow - box shadows
-├── breakpoints.ex     # MyAppWeb.Breakpoints - media queries
-├── z_index.ex         # MyAppWeb.ZIndex - z-index values
-└── animations.ex      # MyAppWeb.Animations - keyframes
+lib/my_app_web/style/
+├── colors.ex          # MyAppWeb.Style.Colors - raw color palette
+├── semantic.ex        # MyAppWeb.Style.Semantic - themed semantic tokens
+├── spacing.ex         # MyAppWeb.Style.Spacing - spacing scale
+├── font_size.ex       # MyAppWeb.Style.FontSize - typography sizes
+├── radius.ex          # MyAppWeb.Style.Radius - border radii
+├── shadow.ex          # MyAppWeb.Style.Shadow - box shadows
+├── breakpoints.ex     # MyAppWeb.Style.Breakpoints - media query conditions
+├── z_index.ex         # MyAppWeb.Style.ZIndex - z-index values
+└── animations.ex      # MyAppWeb.Style.Animations - keyframes
 ```
 
 Example Colors module:
diff --git a/guides/getting-started.md b/guides/getting-started.md
index 91ee335..26d0cd3 100644
--- a/guides/getting-started.md
+++ b/guides/getting-started.md
@@ -4,12 +4,12 @@ LiveStyle is a compile-time CSS-in-Elixir library for Phoenix.
 
 ## Migrating from Tailwind
 
-It's a find-and-replace:
+The setup follows the same shape as Tailwind:
 
 | Find | Replace |
 |------|---------|
 | `@import "tailwindcss"` | `@import "live_style"` |
-| `{:tailwind, ...}` | `{:live_style, "~> 0.0"}` |
+| `{:tailwind, ...}` | `{:live_style, "~> 0.16.2"}` |
 | `config :tailwind, my_app: [...]` | `config :live_style, my_app: [...]` |
 | `tailwind my_app` | `live_style my_app` |
 | `Tailwind` | `LiveStyle` |
@@ -38,7 +38,7 @@ end
 
 def deps do
   [
-    {:live_style, "~> 0.0"},
+    {:live_style, "~> 0.16.2"},
     ...
   ]
 end
@@ -70,7 +70,7 @@ watchers: [
 ]
 ```
 
-Run `mix deps.get` and you're done.
+Run `mix deps.get`, then build assets with your normal Phoenix alias.
 
 ### Incremental Migration
 
@@ -94,7 +94,7 @@ For new Phoenix projects without Tailwind:
 # mix.exs
 def deps do
   [
-    {:live_style, "~> 0.0"}
+    {:live_style, "~> 0.16.2"}
   ]
 end
 ```
diff --git a/guides/styling-components.md b/guides/styling-components.md
index 1faa35c..892044c 100644
--- a/guides/styling-components.md
+++ b/guides/styling-components.md
@@ -95,7 +95,9 @@ class :container,
   ]
 ```
 
-Using breakpoint constants with string interpolation:
+Using breakpoint constants with string interpolation. Define those constants as
+media query conditions like `"(min-width: 768px)"`, then add the `@media` prefix
+at the call site:
 
 ```elixir
 class :grid,
diff --git a/guides/theming.md b/guides/theming.md
index 9029156..68f597d 100644
--- a/guides/theming.md
+++ b/guides/theming.md
@@ -143,14 +143,13 @@ Apply the theme at the root level:
 
 ### JavaScript Integration
 
-Since theme class names are generated at compile time, you need to bridge them to JavaScript for runtime theme switching. Use data attributes to pass the class names:
+Since theme class names are generated at compile time, you need to bridge them to JavaScript for runtime theme switching. Use a data attribute to pass the dark theme class. The light theme is the default `vars` output, so clearing theme classes restores it:
 
 ```heex
 <!-- In root.html.heex -->
 <html
   lang="en"
   data-theme-dark={theme_class({MyAppWeb.Semantic, :dark})}
-  data-theme-light={theme_class({MyAppWeb.Semantic, :light})}
 >
 ```
 
@@ -161,8 +160,7 @@ Then in a blocking `<script>` tag in `<head>` (to prevent flash of unstyled cont
   (function() {
     const html = document.documentElement;
     const themes = {
-      dark: html.dataset.themeDark,
-      light: html.dataset.themeLight
+      dark: html.dataset.themeDark
     };
 
     const getStoredTheme = () => localStorage.getItem("theme");
@@ -176,9 +174,9 @@ Then in a blocking `<script>` tag in `<head>` (to prevent flash of unstyled cont
       // Apply the appropriate theme class
       if (theme === "system") {
         const systemTheme = getSystemTheme();
-        if (themes[systemTheme]) html.classList.add(themes[systemTheme]);
-      } else if (themes[theme]) {
-        html.classList.add(themes[theme]);
+        if (systemTheme === "dark" && themes.dark) html.classList.add(themes.dark);
+      } else if (theme === "dark" && themes.dark) {
+        html.classList.add(themes.dark);
       }
     };
 
diff --git a/lib/live_style.ex b/lib/live_style.ex
index 4c2fdbd..fdde64c 100644
--- a/lib/live_style.ex
+++ b/lib/live_style.ex
@@ -2,8 +2,10 @@ defmodule LiveStyle do
   @moduledoc """
   LiveStyle - Compile-time CSS-in-Elixir for Phoenix LiveView.
 
-  All style definitions compile away to string constants. At runtime,
-  only class name strings exist - no function calls or manifest lookups.
+  Static style references resolve to deterministic class payloads at compile time.
+  Dynamic classes and forward references use a small runtime attribute payload so
+  component spreads can preserve last-wins merging semantics without manifest
+  lookups during render.
 
   ## Basic Usage
 
@@ -60,13 +62,14 @@ defmodule LiveStyle do
 
   ## Public API Functions
 
-  - `LiveStyle.default_marker/0` - Get the default marker class for contextual selectors
-  - `LiveStyle.marker/1` - Get a custom marker class
+  - `LiveStyle.default_marker/0` - Get the default marker for contextual selectors
+  - `LiveStyle.marker/1` - Get a custom marker
 
   See the README for comprehensive documentation and examples.
   """
 
   alias LiveStyle.Compiler.ModuleData
+  alias LiveStyle.Runtime.StyleMerger
 
   defmacro __using__(_opts \\ []) do
     # Register attributes IMMEDIATELY during macro expansion (not in quote)
@@ -79,6 +82,7 @@ defmodule LiveStyle do
     Module.register_attribute(module, :__live_style_theme_classes__, accumulate: true)
     Module.register_attribute(module, :__live_style_view_transition_classes__, accumulate: true)
     Module.register_attribute(module, :__live_style_position_try__, accumulate: true)
+    Module.register_attribute(module, :__live_style_usage__, accumulate: true)
 
     quote do
       import LiveStyle,
@@ -181,8 +185,15 @@ defmodule LiveStyle do
     # Write module data to per-module file (no lock needed - each module has its own file)
     alias LiveStyle.Compiler.ModuleData
 
+    usage =
+      env.module
+      |> Module.get_attribute(:__live_style_usage__, [])
+      |> MapSet.new()
+
     ModuleData.write(module, %{
       module: module,
+      source: env.file,
+      source_fingerprint: ModuleData.source_fingerprint(env.file),
       module_hash: module_hash,
       vars: vars,
       consts: consts,
@@ -193,6 +204,8 @@ defmodule LiveStyle do
       classes: local_manifest.classes
     })
 
+    ModuleData.write_usage(module, usage)
+
     # Use local manifest to build class maps (no file read needed)
     manifest = local_manifest
 
@@ -380,9 +393,9 @@ defmodule LiveStyle do
   end
 
   @doc """
-  References a CSS variable, returning `var(--vhash)`.
+  References a CSS variable, returning a `var(--<prefix><hash>)` reference.
 
-  When used as a value, returns `var(--vhash)` for CSS variable references.
+  When used as a value, returns a `var(...)` reference for CSS variables.
   When used as a map key in keyframes, the `var()` wrapper is automatically
   stripped to produce valid CSS (matching StyleX behavior).
 
@@ -448,8 +461,8 @@ defmodule LiveStyle do
 
   ## Examples
 
-      consts breakpoint_sm: "@media (max-width: 640px)",
-             breakpoint_lg: "@media (min-width: 1025px)",
+      consts breakpoint_sm: "(max-width: 640px)",
+             breakpoint_lg: "(min-width: 1025px)",
              z_modal: "50",
              z_tooltip: "100"
   """
@@ -976,8 +989,8 @@ defmodule LiveStyle do
   Returns CSS attributes for spreading in HEEx templates.
 
   When all references can be resolved at compile time, returns a literal
-  keyword list like `[class: ["x1234"]]` that Phoenix LiveView's tag engine
-  embeds in `Rendered.static` (sent once, never re-transmitted on updates).
+  keyword list with a precomputed class payload, avoiding runtime class merging
+  for static references.
 
   Falls back to `%LiveStyle.Attrs{}` at runtime for forward references,
   dynamic args, or non-literal style values.
@@ -1010,18 +1023,22 @@ defmodule LiveStyle do
     # Record usage at compile time for tree shaking
     record_class_usage(caller_module, caller_module, name)
 
-    case compute_static_class_string(caller_module, name) do
-      {:ok, ""} ->
-        quote do: []
-
-      {:ok, class_string} ->
-        quote do: [{:class, [unquote(class_string)]}]
+    if all_static_refs?([name], __CALLER__) do
+      case compute_static_class_string(caller_module, name) do
+        {:ok, class_string} ->
+          prop_classes = static_prop_classes_source(caller_module, [name], __CALLER__)
+          Macro.escape(build_static_attr_list(class_string, nil, prop_classes))
 
-      :error ->
-        # Class not found yet (forward reference) — fall back to runtime
-        quote do
-          LiveStyle.resolve_attrs(__MODULE__, [unquote(name)], nil)
-        end
+        :error ->
+          quote do
+            LiveStyle.resolve_attrs(__MODULE__, [unquote(name)], nil)
+          end
+      end
+    else
+      # Class not found yet (forward reference) — fall back to runtime
+      quote do
+        LiveStyle.resolve_attrs(__MODULE__, [unquote(name)], nil)
+      end
     end
   end
 
@@ -1037,10 +1054,11 @@ defmodule LiveStyle do
     end)
 
     if all_static_refs?(refs, __CALLER__) do
-      {class_string, style_string} =
+      {class_string, style_string, _prop_classes} =
         compute_static_attrs!(caller_module, refs, __CALLER__)
 
-      Macro.escape(build_static_attr_list(class_string, style_string))
+      prop_classes = static_prop_classes_source(caller_module, refs, __CALLER__)
+      Macro.escape(build_static_attr_list(class_string, style_string, prop_classes))
     else
       case try_branch_optimization(refs, __CALLER__) do
         :error ->
@@ -1090,13 +1108,14 @@ defmodule LiveStyle do
 
     cond do
       all_static_refs?(refs_list, __CALLER__) and static_style_opts?(opts, __CALLER__) ->
-        {class_string, dynamic_style_string} =
+        {class_string, dynamic_style_string, _prop_classes} =
           compute_static_attrs!(caller_module, refs_list, __CALLER__)
 
         extra_style = compute_static_extra_styles(opts, __CALLER__)
         style_string = merge_style_strings(dynamic_style_string, extra_style)
 
-        Macro.escape(build_static_attr_list(class_string, style_string))
+        prop_classes = static_prop_classes_source(caller_module, refs_list, __CALLER__)
+        Macro.escape(build_static_attr_list(class_string, style_string, prop_classes))
 
       static_style_opts?(opts, __CALLER__) ->
         try_branch_with_style_opts(refs_list, refs, opts, caller_module, __CALLER__)
@@ -1149,43 +1168,67 @@ defmodule LiveStyle do
   @doc false
   def record_class_usage(defining_module, class_name)
       when is_atom(defining_module) and is_atom(class_name) do
-    ModuleData.record_usage(defining_module, defining_module, class_name)
+    record_class_usage(defining_module, defining_module, class_name)
   end
 
   # 3-arg version with explicit consuming module
   @doc false
   def record_class_usage(consuming_module, defining_module, class_name)
       when is_atom(consuming_module) and is_atom(defining_module) and is_atom(class_name) do
-    ModuleData.record_usage(consuming_module, defining_module, class_name)
+    usage = {defining_module, class_name}
+
+    if accumulate_class_usage(consuming_module, usage) do
+      :ok
+    else
+      ModuleData.record_usage(consuming_module, defining_module, class_name)
+    end
+  end
+
+  defp accumulate_class_usage(module, usage) do
+    if Module.open?(module) and Module.has_attribute?(module, :__live_style_usage__) do
+      Module.put_attribute(module, :__live_style_usage__, usage)
+      true
+    else
+      false
+    end
+  rescue
+    ArgumentError -> false
   end
 
   # Extracts static class references from a list of refs (for usage tracking)
   # Returns list of {module, class_name} tuples
   @doc false
   def extract_class_refs(refs, caller_module, caller) when is_list(refs) do
+    context = %{caller_module: caller_module, caller: caller}
+
     refs
-    |> Enum.flat_map(fn ref -> extract_single_ref(ref, caller_module, caller) end)
+    |> Enum.flat_map(fn ref -> extract_single_ref(ref, context) end)
     |> Enum.uniq()
   end
 
-  defp extract_single_ref(ref, caller_module, _caller) when is_atom(ref) do
-    # Simple atom ref like :button
-    [{caller_module, ref}]
-  end
+  defp extract_single_ref(ref, context) do
+    case ref do
+      class_name when is_atom(class_name) ->
+        local_ref(class_name, context.caller_module)
 
-  defp extract_single_ref({module, class_name}, _caller_module, _caller)
-       when is_atom(module) and is_atom(class_name) do
-    # Cross-module ref like {OtherModule, :btn}
-    [{module, class_name}]
+      {module, class_name} when is_atom(module) and is_atom(class_name) ->
+        cross_module_ref(module, class_name)
+
+      {class_name, _value} when is_atom(class_name) ->
+        local_ref(class_name, context.caller_module)
+
+      ast ->
+        extract_refs_from_ast(ast, context.caller_module, context.caller)
+    end
   end
 
-  defp extract_single_ref({class_name, _value}, caller_module, _caller)
-       when is_atom(class_name) do
-    # Dynamic tuple like {:dynamic_color, @color} - track the class name
-    [{caller_module, class_name}]
+  defp local_ref(class_name, caller_module), do: [{caller_module, class_name}]
+
+  defp cross_module_ref(module, class_name) do
+    [{module, class_name}]
   end
 
-  defp extract_single_ref(ast, caller_module, caller) do
+  defp extract_refs_from_ast(ast, caller_module, caller) do
     # Complex expression like @active && :primary
     # Use Macro.prewalk to find all atom literals (potential class refs)
     {_, refs} =
@@ -1366,9 +1409,10 @@ defmodule LiveStyle do
     case find_first_conditional_with_info(refs) do
       nil ->
         # Base case: all refs are static atoms — compute attrs
-        {c, s} = compute_static_attrs!(caller_module, refs, caller)
+        {c, s, _prop_classes} = compute_static_attrs!(caller_module, refs, caller)
         style = if style_fn, do: style_fn.(s), else: s
-        Macro.escape(build_static_attr_list(c, style))
+        prop_classes = static_prop_classes_source(caller_module, refs, caller)
+        Macro.escape(build_static_attr_list(c, style, prop_classes))
 
       {idx, {:and, condition, ref}} ->
         truthy =
@@ -1483,13 +1527,22 @@ defmodule LiveStyle do
   end
 
   # Build a keyword list of static attributes from pre-computed class and style strings.
-  defp build_static_attr_list(class_string, style_string) do
-    attrs = []
-    attrs = if style_string, do: [{:style, [style_string]} | attrs], else: attrs
-    attrs = if class_string != "", do: [{:class, [class_string]} | attrs], else: attrs
-    attrs
+  defp build_static_attr_list(class_string, style_string, prop_classes) do
+    %LiveStyle.Attrs{class: class_string, style: style_string, prop_classes: prop_classes}
+    |> LiveStyle.Attrs.to_list()
+  end
+
+  defp static_prop_classes_source(caller_module, refs, caller) do
+    {:live_style_static_refs, caller_module, Enum.map(refs, &normalize_static_ref(&1, caller))}
+  end
+
+  defp normalize_static_ref({{:__aliases__, _meta, _parts} = module_ast, class_name}, caller)
+       when is_atom(class_name) do
+    {Macro.expand(module_ast, caller), class_name}
   end
 
+  defp normalize_static_ref(ref, _caller), do: ref
+
   # Check if a class name has been defined in the accumulated classes so far.
   defp class_defined?(name, classes) do
     Enum.any?(classes, fn
@@ -1586,13 +1639,8 @@ defmodule LiveStyle do
   defp format_style_declaration(key, value), do: "#{key}: #{value}"
 
   # Merge dynamic class var styles with extra style opts.
-  defp merge_style_strings(nil, nil), do: nil
-  defp merge_style_strings(nil, extra) when is_binary(extra), do: extra
-  defp merge_style_strings(dynamic, nil) when is_binary(dynamic), do: dynamic
-
-  defp merge_style_strings(dynamic, extra)
-       when is_binary(dynamic) and is_binary(extra) do
-    "#{dynamic}; #{extra}"
+  defp merge_style_strings(dynamic, extra) do
+    StyleMerger.merge_style_strings(dynamic, extra)
   end
 
   # Compute class string for a single local atom ref at compile time.
@@ -1600,103 +1648,87 @@ defmodule LiveStyle do
   # (forward reference — class defined later in the module).
   @doc false
   def compute_static_class_string(caller_module, name) do
-    manifest = get_or_build_manifest(caller_module)
-    key = LiveStyle.Manifest.key(caller_module, name)
+    cache = get_or_build_static_cache(caller_module)
 
-    case LiveStyle.Manifest.get_class(manifest, key) do
-      entry when is_list(entry) ->
-        {:ok, Keyword.fetch!(entry, :class_string)}
+    case Keyword.fetch(cache.class_strings, name) do
+      {:ok, class_string} ->
+        {:ok, class_string}
 
-      nil ->
+      :error ->
         :error
     end
   end
 
   # Compute merged attrs (class string + optional style) for a list of static refs.
   # Handles local atoms, cross-module refs, and dynamic refs with literal args.
-  # Returns {class_string, style_string | nil}.
+  # Returns {class_string, style_string | nil, prop_classes}.
   @doc false
   def compute_static_attrs!(caller_module, refs, caller) do
-    alias LiveStyle.Compiler.BeforeCompile
-    alias LiveStyle.Runtime.PropertyMerger
-
-    classes = Module.get_attribute(caller_module, :__live_style_classes__) || []
-    manifest = get_or_build_manifest(caller_module)
+    alias LiveStyle.Runtime.StyleMerger
 
-    # Build property_classes map for local classes
-    classes_reversed = Enum.reverse(classes)
-
-    {_class_strings, local_property_classes} =
-      BeforeCompile.build_class_maps(classes_reversed, caller_module, manifest)
+    cache = get_or_build_static_cache(caller_module)
 
-    # Merge property classes and collect CSS variable lists in order
-    {merged_props, var_lists} =
-      Enum.reduce(refs, {[], []}, fn ref, {props_acc, vars_acc} ->
-        {prop_classes, var_list} =
-          fetch_static_ref_data!(ref, caller_module, local_property_classes, caller)
-
-        new_props = PropertyMerger.merge(prop_classes, props_acc)
-        new_vars = if var_list, do: [var_list | vars_acc], else: vars_acc
-        {new_props, new_vars}
-      end)
+    context = %{caller_module: caller_module, cache: cache, caller: caller}
 
-    class_string =
-      merged_props
-      |> PropertyMerger.to_class_list()
-      |> Enum.uniq()
-      |> Enum.join(" ")
+    attrs =
+      refs
+      |> Enum.map(&resolve_static_ref!(&1, context))
+      |> StyleMerger.merge_resolved_refs()
 
-    style_string = build_static_style_string(var_lists)
+    {attrs.class, attrs.style, attrs.prop_classes}
+  end
 
-    {class_string, style_string}
+  defp resolve_static_ref!(name, %{
+         caller_module: caller_module,
+         cache: cache,
+         caller: caller
+       })
+       when is_atom(name) do
+    name
+    |> fetch_local_static_ref!(caller_module, cache, caller)
+    |> to_resolved_static_ref()
   end
 
-  # Build a style string from collected CSS variable lists.
-  defp build_static_style_string([]), do: nil
+  defp resolve_static_ref!(
+         {{:__aliases__, _, _} = module_ast, class_name},
+         %{caller: caller}
+       )
+       when is_atom(class_name) do
+    module_ast
+    |> fetch_cross_module_static_ref!(class_name, caller)
+    |> to_resolved_static_ref()
+  end
 
-  defp build_static_style_string(var_lists) do
-    # Reverse to get original order, then merge (last wins per variable name)
-    merged_vars =
-      var_lists
-      |> Enum.reverse()
-      |> Enum.reduce([], fn var_list, acc ->
-        Enum.reduce(var_list, acc, fn {key, value}, inner_acc ->
-          List.keystore(inner_acc, key, 0, {key, value})
-        end)
-      end)
+  defp resolve_static_ref!(
+         {class_name, args},
+         %{caller_module: caller_module, cache: cache, caller: caller}
+       )
+       when is_atom(class_name) do
+    class_name
+    |> fetch_dynamic_static_ref!(args, caller_module, cache, caller)
+    |> to_resolved_static_ref()
+  end
 
-    case merged_vars do
-      [] -> nil
-      vars -> Enum.map_join(vars, "; ", fn {name, value} -> "#{name}: #{value}" end)
+  defp to_resolved_static_ref(ref_data) do
+    case ref_data do
+      {prop_classes, nil} -> {:static, prop_classes}
+      {prop_classes, var_list} -> {:dynamic, prop_classes, var_list}
     end
   end
 
-  # Fetch property classes (and optional var_list) for a static ref at compile time.
-  # Returns {prop_classes, var_list | nil}.
-  defp fetch_static_ref_data!(name, caller_module, local_property_classes, caller)
-       when is_atom(name) do
-    case Keyword.fetch(local_property_classes, name) do
-      {:ok, prop_classes} ->
-        {prop_classes, nil}
+  defp fetch_local_static_ref!(class_name, caller_module, cache, caller) do
+    prop_classes =
+      fetch_local_prop_classes!(
+        class_name,
+        caller_module,
+        cache.property_classes,
+        caller
+      )
 
-      :error ->
-        raise CompileError,
-          description:
-            "Class :#{name} not found in #{inspect(caller_module)}. " <>
-              "Make sure `class :#{name}, ...` is defined before this reference.",
-          file: caller.file,
-          line: caller.line
-    end
+    {prop_classes, nil}
   end
 
-  # Cross-module ref: {OtherModule, :class_name}
-  defp fetch_static_ref_data!(
-         {{:__aliases__, _, _} = module_ast, class_name},
-         _caller_module,
-         _local_property_classes,
-         caller
-       )
-       when is_atom(class_name) do
+  defp fetch_cross_module_static_ref!(module_ast, class_name, caller) do
     module = Macro.expand(module_ast, caller)
 
     case Keyword.fetch(module.__live_style__(:property_classes), class_name) do
@@ -1713,45 +1745,18 @@ defmodule LiveStyle do
     end
   end
 
-  # Dynamic ref with literal args: {:opacity, 0.5} or {:size, ["100px", "200px"]}
-  defp fetch_static_ref_data!(
-         {class_name, args},
-         caller_module,
-         local_property_classes,
-         caller
-       )
-       when is_atom(class_name) do
-    # Get property classes (same as bare atom ref)
+  defp fetch_dynamic_static_ref!(class_name, args, caller_module, cache, caller) do
     prop_classes =
-      case Keyword.fetch(local_property_classes, class_name) do
-        {:ok, pc} ->
-          pc
-
-        :error ->
-          raise CompileError,
-            description:
-              "Class :#{class_name} not found in #{inspect(caller_module)}. " <>
-                "Make sure `class :#{class_name}, ...` is defined before this reference.",
-            file: caller.file,
-            line: caller.line
-      end
-
-    # Compute CSS variable list at compile time
-    classes = Module.get_attribute(caller_module, :__live_style_classes__) || []
-    classes_reversed = Enum.reverse(classes)
-
-    dynamic_names =
-      classes_reversed
-      |> Enum.filter(fn
-        {_name, {:__dynamic__, _, _}} -> true
-        _ -> false
-      end)
-      |> Enum.map(fn {name, _} -> name end)
+      fetch_local_prop_classes!(
+        class_name,
+        caller_module,
+        cache.property_classes,
+        caller
+      )
 
-    if class_name in dynamic_names do
-      # Find the dynamic class entry to get all_props and has_computed
+    if class_name in cache.dynamic_names do
       {^class_name, {:__dynamic__, all_props, has_computed}} =
-        Enum.find(classes_reversed, fn
+        Enum.find(cache.dynamic_classes, fn
           {^class_name, {:__dynamic__, _, _}} -> true
           _ -> false
         end)
@@ -1776,6 +1781,21 @@ defmodule LiveStyle do
     end
   end
 
+  defp fetch_local_prop_classes!(class_name, caller_module, property_classes, caller) do
+    case Keyword.fetch(property_classes, class_name) do
+      {:ok, prop_classes} ->
+        prop_classes
+
+      :error ->
+        raise CompileError,
+          description:
+            "Class :#{class_name} not found in #{inspect(caller_module)}. " <>
+              "Make sure `class :#{class_name}, ...` is defined before this reference.",
+          file: caller.file,
+          line: caller.line
+    end
+  end
+
   # Build a local manifest from accumulated class definitions.
   # Reuses the same pipeline as __before_compile__.
   defp build_local_manifest(classes, module) do
@@ -1784,12 +1804,7 @@ defmodule LiveStyle do
 
     classes_reversed = Enum.reverse(classes)
 
-    {static_classes, dynamic_classes} =
-      Enum.split_with(classes_reversed, fn
-        {_name, {:__dynamic__, _, _}} -> false
-        {_name, _declarations, _opts} -> true
-        {_name, decl} -> not match?({:__dynamic__, _, _}, decl)
-      end)
+    {static_classes, dynamic_classes} = split_class_entries(classes_reversed)
 
     manifest = LiveStyle.Manifest.empty()
 
@@ -1805,24 +1820,49 @@ defmodule LiveStyle do
     end)
   end
 
-  # Get or build a cached manifest for the module being compiled.
-  # Caches the result in a module attribute to avoid recomputation
-  # across multiple css() calls in the same module.
-  defp get_or_build_manifest(module) do
+  defp get_or_build_static_cache(module) do
     classes = Module.get_attribute(module, :__live_style_classes__) || []
     class_count = length(classes)
 
-    case Module.get_attribute(module, :__live_style_manifest_cache__) do
-      {^class_count, manifest} ->
-        manifest
+    case Module.get_attribute(module, :__live_style_static_cache__) do
+      {^class_count, cache} ->
+        cache
 
       _ ->
-        manifest = build_local_manifest(classes, module)
-        Module.put_attribute(module, :__live_style_manifest_cache__, {class_count, manifest})
-        manifest
+        cache = build_static_cache(classes, module)
+        Module.put_attribute(module, :__live_style_static_cache__, {class_count, cache})
+        cache
     end
   end
 
+  defp build_static_cache(classes, module) do
+    alias LiveStyle.Compiler.BeforeCompile
+
+    classes_reversed = Enum.reverse(classes)
+    {static_classes, dynamic_classes} = split_class_entries(classes_reversed)
+    manifest = build_local_manifest(classes, module)
+    all_classes = static_classes ++ dynamic_classes
+
+    {class_strings, property_classes} =
+      BeforeCompile.build_class_maps(all_classes, module, manifest)
+
+    %{
+      manifest: manifest,
+      class_strings: class_strings,
+      property_classes: property_classes,
+      dynamic_classes: dynamic_classes,
+      dynamic_names: Enum.map(dynamic_classes, fn {name, _} -> name end)
+    }
+  end
+
+  defp split_class_entries(classes) do
+    Enum.split_with(classes, fn
+      {_name, {:__dynamic__, _, _}} -> false
+      {_name, _declarations, _opts} -> true
+      {_name, decl} -> not match?({:__dynamic__, _, _}, decl)
+    end)
+  end
+
   @doc """
   Defines a theme class (variable overrides).
 
@@ -1995,18 +2035,18 @@ defmodule LiveStyle do
     to: LiveStyle.Runtime
 
   @doc """
-  Returns the default marker class name for use with `LiveStyle.When` selectors.
+  Returns the default marker for use with `LiveStyle.When` selectors.
 
   ## Example
 
-      <div class={default_marker()}>
+      <div {css([default_marker()])}>
         <div {css(:card)}>Hover parent to move me</div>
       </div>
   """
   defdelegate default_marker(), to: LiveStyle.Marker, as: :default
 
   @doc """
-  Returns a marker class name for use with `LiveStyle.When` selectors.
+  Returns a marker for use with `LiveStyle.When` selectors.
 
   Custom markers allow you to have multiple independent sets of contextual selectors
   in the same component tree.
@@ -2021,7 +2061,7 @@ defmodule LiveStyle do
 
   ## Usage
 
-      <tr class={marker(:row)}>
+      <tr {css([marker(:row)])}>
         <td {css(:cell)}>...</td>
       </tr>
   """
diff --git a/lib/live_style/attrs.ex b/lib/live_style/attrs.ex
index b0713b9..8726497 100644
--- a/lib/live_style/attrs.ex
+++ b/lib/live_style/attrs.ex
@@ -17,10 +17,15 @@ defmodule LiveStyle.Attrs do
   defstruct [:class, :style, :prop_classes]
 
   @type prop_classes :: [{atom() | String.t(), String.t() | :__unset__}]
+  @type prop_classes_source ::
+          prop_classes()
+          | {:live_style_static_refs, module(), list()}
+          | nil
+
   @type t :: %__MODULE__{
           class: String.t() | nil,
           style: String.t() | nil,
-          prop_classes: prop_classes() | nil
+          prop_classes: prop_classes_source()
         }
 
   @doc """
@@ -43,11 +48,19 @@ defmodule LiveStyle.Attrs do
     result = []
     result = if style && style != "", do: [{:style, style} | result], else: result
     has_class = is_binary(class) and class != ""
-    has_prop_classes = is_list(attrs.prop_classes) and attrs.prop_classes != []
+    has_prop_classes = prop_classes_source?(attrs.prop_classes)
     result = if has_class or has_prop_classes, do: [{:class, attrs} | result], else: result
     result
   end
 
+  defp prop_classes_source?(prop_classes) when is_list(prop_classes), do: prop_classes != []
+
+  defp prop_classes_source?({:live_style_static_refs, module, refs})
+       when is_atom(module) and is_list(refs),
+       do: refs != []
+
+  defp prop_classes_source?(_prop_classes), do: false
+
   @doc """
   Extracts just the class string from an Attrs struct.
   """
diff --git a/lib/live_style/class/processor/conditional.ex b/lib/live_style/class/processor/conditional.ex
index 83dc088..bdadbbd 100644
--- a/lib/live_style/class/processor/conditional.ex
+++ b/lib/live_style/class/processor/conditional.ex
@@ -15,9 +15,12 @@ defmodule LiveStyle.Class.Processor.Conditional do
   """
 
   alias LiveStyle.Class.{Builder, Conditional}
-  alias LiveStyle.{CSSValue, ShorthandBehavior}
+  alias LiveStyle.Config
+  alias LiveStyle.CSSValue
   alias LiveStyle.MediaQuery.Transform, as: MediaQueryTransform
+  alias LiveStyle.Property.Validation
   alias LiveStyle.Selector.Condition, as: ConditionSelector
+  alias LiveStyle.ShorthandBehavior
 
   @doc """
   Processes a list of conditional declarations into atomic class entries.
@@ -38,11 +41,12 @@ defmodule LiveStyle.Class.Processor.Conditional do
       ]
   """
   @spec transform(list(), keyword()) :: list()
-  def transform(declarations, _opts \\ []) do
+  def transform(declarations, opts \\ []) do
     declarations
     |> Enum.flat_map(fn {prop, conditions} ->
       # Convert key to CSS string at boundary
       css_prop = CSSValue.to_css_property(prop)
+      maybe_validate_property(css_prop, opts)
 
       # Use style resolution for conditional properties
       ShorthandBehavior.expand_shorthand_conditions(css_prop, conditions)
@@ -50,6 +54,12 @@ defmodule LiveStyle.Class.Processor.Conditional do
     |> Enum.flat_map(&process_expanded/1)
   end
 
+  defp maybe_validate_property(css_prop, opts) do
+    if Config.validate_properties?() do
+      Validation.validate!(css_prop, opts)
+    end
+  end
+
   # Process an expanded conditional declaration
   defp process_expanded({css_prop, conditions}) do
     # Apply StyleX's "last media query wins" transformation
diff --git a/lib/live_style/class/processor/pseudo_element.ex b/lib/live_style/class/processor/pseudo_element.ex
index 1fbb46e..06a7c2e 100644
--- a/lib/live_style/class/processor/pseudo_element.ex
+++ b/lib/live_style/class/processor/pseudo_element.ex
@@ -17,7 +17,9 @@ defmodule LiveStyle.Class.Processor.PseudoElement do
   """
 
   alias LiveStyle.Class.{Builder, Conditional}
+  alias LiveStyle.Config
   alias LiveStyle.CSSValue
+  alias LiveStyle.Property.Validation
 
   @doc """
   Processes a list of pseudo-element declarations into atomic class entries.
@@ -34,23 +36,24 @@ defmodule LiveStyle.Class.Processor.PseudoElement do
       ]
   """
   @spec transform(list(), keyword()) :: list()
-  def transform(declarations, _opts \\ []) do
+  def transform(declarations, opts \\ []) do
     Enum.flat_map(declarations, fn {pseudo_element, props} ->
-      process_props(to_string(pseudo_element), props)
+      process_props(to_string(pseudo_element), props, opts)
     end)
   end
 
   # Process all properties within a pseudo-element
   # Values are pre-sorted at entry point for deterministic iteration
-  defp process_props(pseudo_str, props) do
+  defp process_props(pseudo_str, props, opts) do
     Enum.flat_map(props, fn {prop, value} ->
-      process_prop(pseudo_str, prop, value)
+      process_prop(pseudo_str, prop, value, opts)
     end)
   end
 
   # Process a single property within a pseudo-element
-  defp process_prop(pseudo_str, prop, value) do
+  defp process_prop(pseudo_str, prop, value, opts) do
     css_prop = CSSValue.to_css_property(prop)
+    maybe_validate_property(css_prop, opts)
 
     if Conditional.conditional?(value) do
       process_conditional_prop(pseudo_str, css_prop, value)
@@ -59,6 +62,12 @@ defmodule LiveStyle.Class.Processor.PseudoElement do
     end
   end
 
+  defp maybe_validate_property(css_prop, opts) do
+    if Config.validate_properties?() do
+      Validation.validate!(css_prop, opts)
+    end
+  end
+
   # Process a conditional property within a pseudo-element
   # e.g., "::before": [color: [default: "red", ":hover": "blue"]]
   defp process_conditional_prop(pseudo_str, css_prop, value) do
diff --git a/lib/live_style/compiler.ex b/lib/live_style/compiler.ex
index fc6de4a..5c5a32f 100644
--- a/lib/live_style/compiler.ex
+++ b/lib/live_style/compiler.ex
@@ -8,7 +8,7 @@ defmodule LiveStyle.Compiler do
   ## CSS Generation
 
       css = LiveStyle.Compiler.generate_css()
-      # => "@layer live_style { .x1234{display:flex} ... }"
+      # => ".x1234:not(#\\#){display:flex} ..."
 
   ## Class Resolution (useful for testing)
 
diff --git a/lib/live_style/compiler/css/classes/collector.ex b/lib/live_style/compiler/css/classes/collector.ex
index 00f9551..44cba43 100644
--- a/lib/live_style/compiler/css/classes/collector.ex
+++ b/lib/live_style/compiler/css/classes/collector.ex
@@ -13,12 +13,11 @@ defmodule LiveStyle.Compiler.CSS.Classes.Collector do
   def collect(manifest) do
     usage = LiveStyle.Storage.read_usage()
 
-    manifest.classes
+    LiveStyle.Manifest.entries(manifest, :classes)
     # Filter by usage (StyleX-style tree shaking)
     |> Enum.filter(fn {key, _entry} ->
       key_used?(key, usage)
     end)
-    # Already sorted by key in manifest (sorted list storage)
     |> Enum.flat_map(fn {_key, entry} ->
       # Sort atomic_classes by property name for deterministic order
       Keyword.fetch!(entry, :atomic_classes)
diff --git a/lib/live_style/compiler/css/dynamic_properties.ex b/lib/live_style/compiler/css/dynamic_properties.ex
index ce751d1..0765263 100644
--- a/lib/live_style/compiler/css/dynamic_properties.ex
+++ b/lib/live_style/compiler/css/dynamic_properties.ex
@@ -28,7 +28,7 @@ defmodule LiveStyle.Compiler.CSS.DynamicProperties do
   - Dynamic style vars: `inherits: false` (unless pseudo element)
   """
 
-  alias LiveStyle.{Config, Manifest.ClassEntry}
+  alias LiveStyle.{Config, Manifest, Manifest.ClassEntry}
 
   @doc """
   Generates @property rules for all dynamic CSS variables in the manifest.
@@ -39,7 +39,7 @@ defmodule LiveStyle.Compiler.CSS.DynamicProperties do
   def generate(manifest) do
     prefix = Config.class_name_prefix()
 
-    manifest.classes
+    Manifest.entries(manifest, :classes)
     |> Enum.filter(fn {_key, entry} -> ClassEntry.dynamic?(entry) end)
     |> Enum.flat_map(fn {_key, entry} ->
       Keyword.fetch!(entry, :atomic_classes)
diff --git a/lib/live_style/compiler/css/keyframes.ex b/lib/live_style/compiler/css/keyframes.ex
index e9a21db..7d05d32 100644
--- a/lib/live_style/compiler/css/keyframes.ex
+++ b/lib/live_style/compiler/css/keyframes.ex
@@ -26,7 +26,7 @@ defmodule LiveStyle.Compiler.CSS.Keyframes do
   """
   @spec generate(Manifest.t()) :: String.t()
   def generate(manifest) do
-    manifest.keyframes
+    Manifest.entries(manifest, :keyframes)
     |> Enum.sort_by(fn {_key, entry} -> Keyword.fetch!(entry, :ident) end)
     # Deduplicate by ident (same keyframes defined in multiple modules get same hash)
     |> Enum.uniq_by(fn {_key, entry} -> Keyword.fetch!(entry, :ident) end)
diff --git a/lib/live_style/compiler/css/pipeline.ex b/lib/live_style/compiler/css/pipeline.ex
index 3fe7f45..57f2fe3 100644
--- a/lib/live_style/compiler/css/pipeline.ex
+++ b/lib/live_style/compiler/css/pipeline.ex
@@ -25,6 +25,7 @@ defmodule LiveStyle.Compiler.CSS.Pipeline do
 
   alias LiveStyle.Compiler.CSS
   alias LiveStyle.Compiler.CSS.Writer.Stats
+  alias LiveStyle.Manifest
   alias LiveStyle.Storage
 
   @doc """
@@ -92,12 +93,12 @@ defmodule LiveStyle.Compiler.CSS.Pipeline do
   @spec stats(LiveStyle.Manifest.t()) :: keyword()
   def stats(manifest) do
     [
-      vars: length(manifest.vars),
-      keyframes: length(manifest.keyframes),
-      classes: length(manifest.classes),
-      theme_classes: length(manifest.theme_classes),
-      position_try: length(manifest.position_try),
-      view_transition_classes: length(manifest.view_transition_classes)
+      vars: Manifest.count(manifest, :vars),
+      keyframes: Manifest.count(manifest, :keyframes),
+      classes: Manifest.count(manifest, :classes),
+      theme_classes: Manifest.count(manifest, :theme_classes),
+      position_try: Manifest.count(manifest, :position_try),
+      view_transition_classes: Manifest.count(manifest, :view_transition_classes)
     ]
   end
 end
diff --git a/lib/live_style/compiler/css/position_try.ex b/lib/live_style/compiler/css/position_try.ex
index 5c2d64b..003461d 100644
--- a/lib/live_style/compiler/css/position_try.ex
+++ b/lib/live_style/compiler/css/position_try.ex
@@ -13,6 +13,7 @@ defmodule LiveStyle.Compiler.CSS.PositionTry do
 
   """
 
+  alias LiveStyle.Manifest
   alias LiveStyle.Utils
 
   @doc """
@@ -23,7 +24,7 @@ defmodule LiveStyle.Compiler.CSS.PositionTry do
   """
   @spec generate(LiveStyle.Manifest.t()) :: String.t()
   def generate(manifest) do
-    manifest.position_try
+    Manifest.entries(manifest, :position_try)
     |> Enum.sort_by(fn {_key, entry} -> Keyword.fetch!(entry, :ident) end)
     |> Enum.flat_map(fn {_key, entry} -> generate_entry(entry) end)
     |> Enum.join("\n")
diff --git a/lib/live_style/compiler/css/theme_classes.ex b/lib/live_style/compiler/css/theme_classes.ex
index 6bf8a3f..51c77e1 100644
--- a/lib/live_style/compiler/css/theme_classes.ex
+++ b/lib/live_style/compiler/css/theme_classes.ex
@@ -23,7 +23,7 @@ defmodule LiveStyle.Compiler.CSS.ThemeClasses do
   """
   @spec generate(Manifest.t()) :: String.t()
   def generate(manifest) do
-    manifest.theme_classes
+    Manifest.entries(manifest, :theme_classes)
     |> Enum.sort_by(fn {_key, entry} -> Keyword.fetch!(entry, :ident) end)
     |> Enum.flat_map(fn {_key, entry} ->
       ident = Keyword.fetch!(entry, :ident)
diff --git a/lib/live_style/compiler/css/vars.ex b/lib/live_style/compiler/css/vars.ex
index 3e178f7..2329c3e 100644
--- a/lib/live_style/compiler/css/vars.ex
+++ b/lib/live_style/compiler/css/vars.ex
@@ -35,7 +35,7 @@ defmodule LiveStyle.Compiler.CSS.Vars do
   """
   @spec generate_properties(Manifest.t()) :: String.t()
   def generate_properties(manifest) do
-    manifest.vars
+    Manifest.entries(manifest, :vars)
     |> Enum.filter(fn {_key, entry} -> Keyword.get(entry, :type) != nil end)
     |> Enum.sort_by(fn {_key, entry} -> Keyword.fetch!(entry, :ident) end)
     |> Enum.map_join("\n", fn {_key, entry} ->
@@ -60,7 +60,7 @@ defmodule LiveStyle.Compiler.CSS.Vars do
   """
   @spec generate_vars(Manifest.t()) :: String.t()
   def generate_vars(manifest) do
-    vars = manifest.vars
+    vars = Manifest.entries(manifest, :vars)
 
     if vars == [] do
       ""
diff --git a/lib/live_style/compiler/css/view_transition_classes.ex b/lib/live_style/compiler/css/view_transition_classes.ex
index ed80bc4..ec81482 100644
--- a/lib/live_style/compiler/css/view_transition_classes.ex
+++ b/lib/live_style/compiler/css/view_transition_classes.ex
@@ -20,6 +20,7 @@ defmodule LiveStyle.Compiler.CSS.ViewTransitionClasses do
   ```
   """
 
+  alias LiveStyle.Manifest
   alias LiveStyle.Utils
 
   # Map view transition keys (snake_case atoms) to CSS pseudo-elements
@@ -45,7 +46,7 @@ defmodule LiveStyle.Compiler.CSS.ViewTransitionClasses do
   """
   @spec generate(LiveStyle.Manifest.t()) :: String.t()
   def generate(manifest) do
-    manifest.view_transition_classes
+    Manifest.entries(manifest, :view_transition_classes)
     |> Enum.sort_by(fn {_key, entry} -> Keyword.fetch!(entry, :ident) end)
     |> Enum.map_join("\n", fn {_key, entry} ->
       generate_entry(entry)
diff --git a/lib/live_style/compiler/css/writer/stats.ex b/lib/live_style/compiler/css/writer/stats.ex
index 85311eb..0bd8b90 100644
--- a/lib/live_style/compiler/css/writer/stats.ex
+++ b/lib/live_style/compiler/css/writer/stats.ex
@@ -3,10 +3,10 @@ defmodule LiveStyle.Compiler.CSS.Writer.Stats do
 
   @spec comment(LiveStyle.Manifest.t()) :: String.t()
   def comment(manifest) do
-    vars_count = length(manifest.vars)
-    keyframes_count = length(manifest.keyframes)
-    classes_count = length(manifest.classes)
-    themes_count = length(manifest.theme_classes)
+    vars_count = LiveStyle.Manifest.count(manifest, :vars)
+    keyframes_count = LiveStyle.Manifest.count(manifest, :keyframes)
+    classes_count = LiveStyle.Manifest.count(manifest, :classes)
+    themes_count = LiveStyle.Manifest.count(manifest, :theme_classes)
 
     "/* LiveStyle: #{vars_count} vars, #{keyframes_count} keyframes, #{classes_count} classes, #{themes_count} themes */"
   end
diff --git a/lib/live_style/compiler/module_data.ex b/lib/live_style/compiler/module_data.ex
index 1ce536c..25af294 100644
--- a/lib/live_style/compiler/module_data.ex
+++ b/lib/live_style/compiler/module_data.ex
@@ -41,6 +41,22 @@ defmodule LiveStyle.Compiler.ModuleData do
     :ok
   end
 
+  @doc """
+  Returns a cheap fingerprint for a source file.
+
+  The fingerprint lets stale cleanup skip source parsing when the source has not
+  changed since the LiveStyle module data was written.
+  """
+  @spec source_fingerprint(String.t() | nil) :: {term(), non_neg_integer()} | nil
+  def source_fingerprint(source) when is_binary(source) do
+    case File.stat(source) do
+      {:ok, %{mtime: mtime, size: size}} -> {mtime, size}
+      {:error, _reason} -> nil
+    end
+  end
+
+  def source_fingerprint(_source), do: nil
+
   @doc """
   Reads module data from a per-module file.
 
@@ -120,6 +136,31 @@ defmodule LiveStyle.Compiler.ModuleData do
     :ok
   end
 
+  @doc """
+  Removes stale per-module files before manifest merge.
+
+  A file is stale when its source file was deleted, or when the source no longer
+  matches the source fingerprint recorded during compilation and the fallback
+  loaded-module/source checks show the module no longer uses LiveStyle. This
+  keeps incremental compiles from preserving CSS for modules that were deleted
+  or migrated away from LiveStyle.
+  """
+  @spec cleanup_stale() :: :ok
+  def cleanup_stale do
+    case File.ls(modules_dir()) do
+      {:ok, files} ->
+        for file <- files, String.ends_with?(file, ".etf") do
+          path = Path.join(modules_dir(), file)
+          cleanup_stale_module_file(path)
+        end
+
+      {:error, _} ->
+        :ok
+    end
+
+    :ok
+  end
+
   @doc """
   Returns the modules directory path.
   """
@@ -147,6 +188,109 @@ defmodule LiveStyle.Compiler.ModuleData do
     end
   end
 
+  defp cleanup_stale_module_file(path) do
+    case read_module_file(path) do
+      [{module, data}] ->
+        if stale_module_data?(module, data), do: File.rm(path)
+
+      [] ->
+        File.rm(path)
+    end
+  end
+
+  defp stale_module_data?(module, data) do
+    source = data[:source]
+
+    cond do
+      is_binary(source) and not File.exists?(source) ->
+        true
+
+      source_unchanged?(source, data[:source_fingerprint]) ->
+        false
+
+      Code.ensure_loaded?(module) ->
+        not function_exported?(module, :__live_style__, 1)
+
+      is_binary(source) ->
+        not source_declares_live_style_module?(source, module)
+
+      true ->
+        false
+    end
+  end
+
+  defp source_unchanged?(source, fingerprint)
+       when is_binary(source) and not is_nil(fingerprint) do
+    source_fingerprint(source) == fingerprint
+  end
+
+  defp source_unchanged?(_source, _fingerprint), do: false
+
+  defp source_declares_live_style_module?(source, module) do
+    with {:ok, contents} <- File.read(source),
+         {:ok, ast} <- Code.string_to_quoted(contents) do
+      live_style_module_in_ast?(ast, module, nil)
+    else
+      _ -> true
+    end
+  end
+
+  defp live_style_module_in_ast?({:defmodule, _meta, [module_ast, [do: body]]}, target, parent) do
+    module = expand_module_ast(module_ast, parent)
+
+    (module == target and body_uses_live_style?(body)) or
+      live_style_module_in_ast?(body, target, module)
+  end
+
+  defp live_style_module_in_ast?({left, right}, target, parent) do
+    live_style_module_in_ast?(left, target, parent) or
+      live_style_module_in_ast?(right, target, parent)
+  end
+
+  defp live_style_module_in_ast?(tuple, target, parent) when is_tuple(tuple) do
+    tuple
+    |> Tuple.to_list()
+    |> live_style_module_in_ast?(target, parent)
+  end
+
+  defp live_style_module_in_ast?(list, target, parent) when is_list(list) do
+    Enum.any?(list, &live_style_module_in_ast?(&1, target, parent))
+  end
+
+  defp live_style_module_in_ast?(_ast, _target, _parent), do: false
+
+  defp expand_module_ast({:__aliases__, _meta, parts}, nil), do: Module.concat(parts)
+
+  defp expand_module_ast({:__aliases__, _meta, [part]}, parent) when not is_nil(parent),
+    do: Module.concat(parent, part)
+
+  defp expand_module_ast({:__aliases__, _meta, parts}, _parent), do: Module.concat(parts)
+
+  defp expand_module_ast(module, _parent) when is_atom(module), do: module
+
+  defp body_uses_live_style?({:defmodule, _meta, _args}), do: false
+  defp body_uses_live_style?({:use, _meta, [module_ast | _]}), do: live_style_alias?(module_ast)
+
+  defp body_uses_live_style?({left, right}) do
+    body_uses_live_style?(left) or body_uses_live_style?(right)
+  end
+
+  defp body_uses_live_style?(tuple) when is_tuple(tuple) do
+    tuple
+    |> Tuple.to_list()
+    |> body_uses_live_style?()
+  end
+
+  defp body_uses_live_style?(list) when is_list(list) do
+    Enum.any?(list, &body_uses_live_style?/1)
+  end
+
+  defp body_uses_live_style?(_), do: false
+
+  defp live_style_alias?({:__aliases__, _meta, [:LiveStyle]}), do: true
+  defp live_style_alias?(LiveStyle), do: true
+  defp live_style_alias?(_), do: false
+
   defp module_path(module) do
     # Use a hash of the module name to avoid filesystem issues with long names
     hash = :crypto.hash(:md5, inspect(module)) |> Base.encode16(case: :lower)
@@ -171,20 +315,31 @@ defmodule LiveStyle.Compiler.ModuleData do
   @doc """
   Records class usage for a consuming module.
 
-  Called during macro expansion of `css/1`. Each module that uses classes
-  gets its own usage file - no locking needed.
+  Used as a fallback for usage recorded outside a compiling LiveStyle module.
+  During normal compilation, LiveStyle's before-compile hook writes all usage
+  for the module in one batch.
   """
   @spec record_usage(module(), module(), atom()) :: :ok
   def record_usage(consuming_module, defining_module, class_name)
       when is_atom(consuming_module) and is_atom(defining_module) and is_atom(class_name) do
+    # Read existing usage, add new entry, write back atomically
+    path = usage_path(consuming_module)
+    usage = read_usage_file(path)
+    updated = MapSet.put(usage, {defining_module, class_name})
+    write_usage(consuming_module, updated)
+  end
+
+  @doc """
+  Writes all usage for a consuming module in one atomic operation.
+  """
+  @spec write_usage(module(), MapSet.t({module(), atom()})) :: :ok
+  def write_usage(consuming_module, usage)
+      when is_atom(consuming_module) and is_struct(usage, MapSet) do
     path = usage_path(consuming_module)
     dir = Path.dirname(path)
     File.mkdir_p!(dir)
 
-    # Read existing usage, add new entry, write back atomically
-    usage = read_usage_file(path)
-    updated = MapSet.put(usage, {defining_module, class_name})
-    write_atomic(path, :erlang.term_to_binary(updated))
+    write_atomic(path, :erlang.term_to_binary(%{module: consuming_module, usage: usage}))
     :ok
   end
 
@@ -204,11 +359,9 @@ defmodule LiveStyle.Compiler.ModuleData do
     if File.exists?(path) do
       case File.read(path) do
         {:ok, binary} ->
-          try do
-            :erlang.binary_to_term(binary)
-          rescue
-            ArgumentError -> MapSet.new()
-          end
+          binary
+          |> decode_usage_data()
+          |> usage_from_data()
 
         {:error, _} ->
           MapSet.new()
@@ -218,6 +371,33 @@ defmodule LiveStyle.Compiler.ModuleData do
     end
   end
 
+  defp read_usage_owner(path) do
+    if File.exists?(path) do
+      case File.read(path) do
+        {:ok, binary} ->
+          binary
+          |> decode_usage_data()
+          |> usage_owner_from_data()
+
+        {:error, _} ->
+          nil
+      end
+    end
+  end
+
+  defp decode_usage_data(binary) do
+    :erlang.binary_to_term(binary)
+  rescue
+    ArgumentError -> MapSet.new()
+  end
+
+  defp usage_from_data(%{usage: %MapSet{} = usage}), do: usage
+  defp usage_from_data(%MapSet{} = usage), do: usage
+  defp usage_from_data(_), do: MapSet.new()
+
+  defp usage_owner_from_data(%{module: module}) when is_atom(module), do: module
+  defp usage_owner_from_data(_), do: nil
+
   @doc """
   Collects all usage from per-module usage files.
 
@@ -242,13 +422,37 @@ defmodule LiveStyle.Compiler.ModuleData do
     end
   end
 
+  @doc """
+  Removes per-module usage files for consumers that are no longer active.
+  """
+  @spec cleanup_stale_usage(MapSet.t(module())) :: :ok
+  def cleanup_stale_usage(active_modules) do
+    with {:ok, files} <- File.ls(usage_dir()) do
+      files
+      |> Enum.filter(&String.ends_with?(&1, ".etf"))
+      |> Enum.each(&cleanup_stale_usage_file(&1, active_modules))
+    end
+
+    :ok
+  end
+
+  defp cleanup_stale_usage_file(file, active_modules) do
+    path = Path.join(usage_dir(), file)
+
+    case read_usage_owner(path) do
+      nil -> :ok
+      module -> remove_stale_usage_file(path, module, active_modules)
+    end
+  end
+
+  defp remove_stale_usage_file(path, module, active_modules) do
+    unless MapSet.member?(active_modules, module), do: File.rm(path)
+  end
+
   @doc """
   Clears all usage files.
 
   Called during `mix compile.live_style --clean` to remove stale usage data.
-  Usage files for deleted modules persist until a clean build since tracking
-  consuming modules across incremental builds is complex. The impact is minimal
-  (slightly larger CSS until clean) and a clean build fixes it.
   """
   @spec clear_usage() :: :ok
   def clear_usage do
diff --git a/lib/live_style/config.ex b/lib/live_style/config.ex
index 9094fd3..6ae92e7 100644
--- a/lib/live_style/config.ex
+++ b/lib/live_style/config.ex
@@ -3,10 +3,8 @@ defmodule LiveStyle.Config do
   Configuration management for LiveStyle.
 
   This module provides access to all LiveStyle configuration options.
-  Complex configuration logic is split into focused submodules:
-
-  - `LiveStyle.Config.Validation` - property validation settings
-  - `LiveStyle.Config.Shorthand` - shorthand expansion behavior
+  Complex configuration logic is split into focused internal helpers for
+  property validation settings and shorthand expansion behavior.
 
   ## Profiles
 
@@ -26,7 +24,10 @@ defmodule LiveStyle.Config do
   There are several global configurations for the LiveStyle application:
 
     * `:manifest_path` - path where the manifest file is stored
-      (default: `"_build/live_style_manifest.etf"`)
+      (default: `"_build/{env}/live_style/{app}/manifest.etf"`)
+
+    * `:usage_path` - path where the usage manifest file is stored
+      (default: `"_build/{env}/live_style/{app}/usage.etf"`)
 
     * `:shorthand_behavior` - the shorthand expansion behavior
       (default: `LiveStyle.ShorthandBehavior.AcceptShorthands`)
diff --git a/lib/live_style/dev.ex b/lib/live_style/dev.ex
index fc8160a..e786fbd 100644
--- a/lib/live_style/dev.ex
+++ b/lib/live_style/dev.ex
@@ -146,21 +146,7 @@ defmodule LiveStyle.Dev do
 
     # Show each class's contribution
     for ref <- class_refs do
-      name = if is_tuple(ref), do: elem(ref, 0), else: ref
-      props = Keyword.get(prop_classes, name, [])
-
-      IO.puts("#{IO.ANSI.cyan()}:#{name}#{IO.ANSI.reset()}")
-
-      if props == [] do
-        IO.puts("  (no properties)")
-      else
-        for {prop, class} <- props do
-          class_display = format_class_value(class)
-          IO.puts("  #{prop}: #{class_display}")
-        end
-      end
-
-      IO.puts("")
+      output_class_diff(ref, prop_classes)
     end
 
     # Show merged result
@@ -178,6 +164,24 @@ defmodule LiveStyle.Dev do
     :ok
   end
 
+  defp output_class_diff(ref, prop_classes) do
+    name = if is_tuple(ref), do: elem(ref, 0), else: ref
+    props = Keyword.get(prop_classes, name, [])
+
+    IO.puts("#{IO.ANSI.cyan()}:#{name}#{IO.ANSI.reset()}")
+    output_class_props(props)
+    IO.puts("")
+  end
+
+  defp output_class_props([]), do: IO.puts("  (no properties)")
+
+  defp output_class_props(props) do
+    for {prop, class} <- props do
+      class_display = format_class_value(class)
+      IO.puts("  #{prop}: #{class_display}")
+    end
+  end
+
   @doc """
   Returns the generated CSS for the given classes.
 
diff --git a/lib/live_style/manifest.ex b/lib/live_style/manifest.ex
index 7f6a980..1a012f4 100644
--- a/lib/live_style/manifest.ex
+++ b/lib/live_style/manifest.ex
@@ -47,8 +47,21 @@ defmodule LiveStyle.Manifest do
   @type class_entry :: ClassEntry.t()
   @type theme_class_entry :: ThemeClassEntry.t()
 
-  # All collections use sorted lists of {key, entry} tuples for deterministic ordering
+  # Collections are map-backed internally for fast put/get operations. Use
+  # `entries/2` when deterministic sorted traversal is needed.
   @type t :: %{
+          version: pos_integer(),
+          vars: %{optional(String.t()) => var_entry()},
+          consts: %{optional(String.t()) => const_entry()},
+          keyframes: %{optional(String.t()) => keyframes_entry()},
+          position_try: %{optional(String.t()) => position_try_entry()},
+          view_transition_classes: %{optional(String.t()) => view_transition_class_entry()},
+          classes: %{optional(String.t()) => class_entry()},
+          theme_classes: %{optional(String.t()) => theme_class_entry()},
+          module_hashes: %{optional(module()) => binary()}
+        }
+
+  @type serializable_t :: %{
           version: pos_integer(),
           vars: [{String.t(), var_entry()}],
           consts: [{String.t(), const_entry()}],
@@ -60,6 +73,17 @@ defmodule LiveStyle.Manifest do
           module_hashes: [{module(), binary()}]
         }
 
+  @collections [
+    :vars,
+    :consts,
+    :keyframes,
+    :position_try,
+    :view_transition_classes,
+    :classes,
+    :theme_classes,
+    :module_hashes
+  ]
+
   @doc """
   Returns the current manifest version.
   """
@@ -70,14 +94,14 @@ defmodule LiveStyle.Manifest do
   def empty do
     %{
       version: @current_version,
-      vars: [],
-      consts: [],
-      keyframes: [],
-      position_try: [],
-      view_transition_classes: [],
-      classes: [],
-      theme_classes: [],
-      module_hashes: []
+      vars: %{},
+      consts: %{},
+      keyframes: %{},
+      position_try: %{},
+      view_transition_classes: %{},
+      classes: %{},
+      theme_classes: %{},
+      module_hashes: %{}
     }
   end
 
@@ -93,7 +117,9 @@ defmodule LiveStyle.Manifest do
     # If manifest version doesn't match current, discard old data and return fresh
     # This handles format changes that would otherwise cause runtime errors
     if current?(manifest) do
-      struct_merge(empty(), manifest)
+      manifest
+      |> struct_merge(empty())
+      |> normalize_collections()
     else
       old_version = Map.get(manifest, :version, "unknown")
 
@@ -113,9 +139,35 @@ defmodule LiveStyle.Manifest do
   @spec key(module(), atom()) :: String.t()
   def key(module, name), do: "#{to_string(module)}.#{name}"
 
-  defp struct_merge(base, updates) when is_map(base) and is_map(updates) do
-    Enum.reduce(updates, base, fn {k, v}, acc ->
-      if is_map_key(acc, k), do: %{acc | k => v}, else: acc
+  @doc """
+  Returns a deterministic sorted entry list for a collection.
+  """
+  @spec entries(t(), atom()) :: list()
+  def entries(manifest, collection) when collection in @collections do
+    manifest
+    |> Map.get(collection, %{})
+    |> sorted_entries()
+  end
+
+  @doc """
+  Returns the number of entries in a collection.
+  """
+  @spec count(t(), atom()) :: non_neg_integer()
+  def count(manifest, collection) when collection in @collections do
+    case Map.get(manifest, collection, %{}) do
+      entries when is_map(entries) -> map_size(entries)
+      entries when is_list(entries) -> length(entries)
+      _ -> 0
+    end
+  end
+
+  @doc """
+  Converts the manifest to a deterministic list-backed representation for disk.
+  """
+  @spec to_serializable(t()) :: serializable_t()
+  def to_serializable(manifest) do
+    Enum.reduce(@collections, manifest, fn collection, acc ->
+      Map.put(acc, collection, entries(acc, collection))
     end)
   end
 
@@ -152,9 +204,7 @@ defmodule LiveStyle.Manifest do
   """
   @spec put_module_hash(t(), module(), binary()) :: t()
   def put_module_hash(manifest, module, hash) when is_atom(module) and is_binary(hash) do
-    list = Map.get(manifest, :module_hashes, [])
-    updated = sorted_list_put(list, module, hash)
-    Map.put(manifest, :module_hashes, updated)
+    put_entry(manifest, :module_hashes, module, hash)
   end
 
   @doc """
@@ -164,40 +214,49 @@ defmodule LiveStyle.Manifest do
   """
   @spec get_module_hash(t(), module()) :: binary() | nil
   def get_module_hash(manifest, module) when is_atom(module) do
-    list = Map.get(manifest, :module_hashes, [])
-    sorted_list_get(list, module)
+    get_entry(manifest, :module_hashes, module)
   end
 
-  # Private helpers for sorted list operations
-
-  # Insert or update entry in sorted list, maintaining sort order by key
   defp put_entry(manifest, collection, key, entry) do
-    list = Map.get(manifest, collection, [])
-    updated = sorted_list_put(list, key, entry)
+    updated =
+      manifest
+      |> Map.get(collection, %{})
+      |> entries_to_map()
+      |> Map.put(key, entry)
+
     Map.put(manifest, collection, updated)
   end
 
-  # Get entry from sorted list by key
   defp get_entry(manifest, collection, key) do
-    list = Map.get(manifest, collection, [])
-    sorted_list_get(list, key)
+    manifest
+    |> Map.get(collection, %{})
+    |> entries_to_map()
+    |> Map.get(key)
+  end
+
+  defp struct_merge(updates, base) when is_map(base) and is_map(updates) do
+    Enum.reduce(updates, base, fn {k, v}, acc ->
+      if is_map_key(acc, k), do: %{acc | k => v}, else: acc
+    end)
   end
 
-  # Single-pass insert or update in a sorted list, maintaining sort order
-  defp sorted_list_put([], key, entry), do: [{key, entry}]
+  defp normalize_collections(manifest) do
+    Enum.reduce(@collections, manifest, fn collection, acc ->
+      Map.update!(acc, collection, &entries_to_map/1)
+    end)
+  end
 
-  defp sorted_list_put([{k, _v} = head | rest], key, entry) when key < k,
-    do: [{key, entry}, head | rest]
+  defp entries_to_map(entries) when is_map(entries), do: entries
+  defp entries_to_map(entries) when is_list(entries), do: Map.new(entries)
+  defp entries_to_map(_entries), do: %{}
 
-  defp sorted_list_put([{k, _} | rest], key, entry) when key == k,
-    do: [{key, entry} | rest]
+  defp sorted_entries(entries) when is_map(entries) do
+    Enum.sort_by(entries, fn {key, _entry} -> key end)
+  end
 
-  defp sorted_list_put([head | rest], key, entry),
-    do: [head | sorted_list_put(rest, key, entry)]
+  defp sorted_entries(entries) when is_list(entries) do
+    Enum.sort_by(entries, fn {key, _entry} -> key end)
+  end
 
-  # Single-pass get from sorted list with early stop
-  defp sorted_list_get([], _key), do: nil
-  defp sorted_list_get([{k, _} | _rest], key) when key < k, do: nil
-  defp sorted_list_get([{k, entry} | _rest], key) when key == k, do: entry
-  defp sorted_list_get([_ | rest], key), do: sorted_list_get(rest, key)
+  defp sorted_entries(_entries), do: []
 end
diff --git a/lib/live_style/marker.ex b/lib/live_style/marker.ex
index 755b75e..1fe8f1f 100644
--- a/lib/live_style/marker.ex
+++ b/lib/live_style/marker.ex
@@ -25,7 +25,7 @@ defmodule LiveStyle.Marker do
 
         def render(assigns) do
           ~H\"\"\"
-          <div {css(default_marker())}>
+          <div {css([default_marker()])}>
             <div {css(:card)}>Hover parent to move me</div>
           </div>
           \"\"\"
@@ -43,7 +43,7 @@ defmodule LiveStyle.Marker do
         ]
 
       # In template:
-      <tr {css(marker(:row))}>
+      <tr {css([marker(:row)])}>
         <td {css(:cell)}>...</td>
       </tr>
 
@@ -52,7 +52,7 @@ defmodule LiveStyle.Marker do
   Use `{Module, :name}` syntax to reference markers from other modules:
 
       # In template:
-      <tr {css(marker({OtherModule, :row}))}>
+      <tr {css([marker({OtherModule, :row})])}>
 
   Different modules using the same marker name get independent markers:
 
@@ -82,7 +82,7 @@ defmodule LiveStyle.Marker do
 
   ## Example
 
-      <div {css(default_marker())}>
+      <div {css([default_marker()])}>
         <div {css(:card)}>Hover parent to move me</div>
       </div>
   """
diff --git a/lib/live_style/runtime/attrs.ex b/lib/live_style/runtime/attrs.ex
index a44fae4..5fe4bd7 100644
--- a/lib/live_style/runtime/attrs.ex
+++ b/lib/live_style/runtime/attrs.ex
@@ -3,28 +3,26 @@ defmodule LiveStyle.Runtime.Attrs do
 
   alias LiveStyle.CSSValue
   alias LiveStyle.Marker
-  alias LiveStyle.Runtime.{PropertyMerger, RefResolver}
+  alias LiveStyle.Runtime.{RefResolver, StyleMerger}
 
   @spec resolve_attrs(module(), list(), keyword() | nil) :: LiveStyle.Attrs.t()
   def resolve_attrs(module, refs, opts) when is_atom(module) and is_list(refs) do
     property_classes_map = module.__live_style__(:property_classes)
 
-    {merged_props, var_styles, ordered_classes, _prop_classes_by_key} =
+    state =
       refs
       |> List.flatten()
       |> Enum.reject(&falsy?/1)
-      |> Enum.reduce({[], [], [], %{}}, &process_ref(&1, &2, module, property_classes_map))
-
-    class_string =
-      ordered_classes
-      |> Enum.uniq()
-      |> Enum.join(" ")
+      |> Enum.reduce(StyleMerger.new_state(), fn ref, state ->
+        if resolved_value_ref?(ref) do
+          merge_value_ref(ref, state)
+        else
+          resolve_and_merge_ref(ref, state, module, property_classes_map)
+        end
+      end)
 
     extra_styles = extract_extra_styles(opts)
-    style_string = build_style_string(var_styles, extra_styles)
-
-    # Return Attrs with prop_classes for component merging
-    %LiveStyle.Attrs{class: class_string, style: style_string, prop_classes: merged_props}
+    StyleMerger.to_attrs(state, extra_styles)
   end
 
   defp falsy?(nil), do: true
@@ -32,74 +30,42 @@ defmodule LiveStyle.Runtime.Attrs do
   defp falsy?(""), do: true
   defp falsy?(_), do: false
 
-  defp process_ref(%Marker{class: class}, state, _module, _map) do
-    append_class_string(state, class)
-  end
+  defp resolved_value_ref?(%Marker{}), do: true
+  defp resolved_value_ref?(%LiveStyle.Attrs{}), do: true
+  defp resolved_value_ref?(binary) when is_binary(binary), do: true
+  defp resolved_value_ref?(_ref), do: false
 
-  defp process_ref(%LiveStyle.Attrs{} = attrs, state, _module, _map) do
-    process_attrs_ref(attrs, state)
+  defp merge_value_ref(%Marker{class: class}, state) do
+    StyleMerger.append_class_string(state, class)
   end
 
-  defp process_ref(binary, state, _module, _map) when is_binary(binary) do
-    append_class_string(state, binary)
+  defp merge_value_ref(%LiveStyle.Attrs{} = attrs, state) do
+    process_attrs_ref(attrs, state)
   end
 
-  defp process_ref(
-         ref,
-         {props_acc, vars_acc, class_order, prop_classes_by_key},
-         module,
-         property_classes_map
-       ) do
-    {new_props, new_vars, new_class_order, new_prop_classes_by_key} =
-      RefResolver.resolve(module, ref, property_classes_map)
-      |> merge_resolved_ref(props_acc, vars_acc, class_order, prop_classes_by_key)
-
-    {new_props, new_vars, new_class_order, new_prop_classes_by_key}
+  defp merge_value_ref(binary, state) when is_binary(binary) do
+    StyleMerger.append_class_string(state, binary)
   end
 
-  defp process_attrs_ref(
-         %LiveStyle.Attrs{prop_classes: prop_classes, class: class},
-         {props_acc, vars_acc, class_order, prop_classes_by_key}
-       )
-       when is_list(prop_classes) and prop_classes != [] do
-    # Merge the property classes from the Attrs struct
-    new_props = PropertyMerger.merge(prop_classes, props_acc)
-
-    {new_class_order, new_prop_classes_by_key} =
-      apply_prop_classes(prop_classes, class_order, prop_classes_by_key)
-
-    # Also preserve any extra classes (like markers) that aren't in prop_classes
-    extra_from_attrs = extract_extra_classes(class, prop_classes)
-    ordered_with_extra = new_class_order ++ extra_from_attrs
-
-    {new_props, vars_acc, ordered_with_extra, new_prop_classes_by_key}
+  defp resolve_and_merge_ref(ref, state, module, property_classes_map) do
+    module
+    |> RefResolver.resolve(ref, property_classes_map)
+    |> StyleMerger.merge_resolved(state)
   end
 
   defp process_attrs_ref(
-         %LiveStyle.Attrs{class: class},
-         {props_acc, vars_acc, class_order, prop_classes_by_key}
+         %LiveStyle.Attrs{
+           prop_classes: {:live_style_static_refs, source_module, refs}
+         } = attrs,
+         state
        )
-       when is_binary(class) and class != "" do
-    # No property classes - treat as extra class string
-    {props_acc, vars_acc, class_order ++ split_class_string(class), prop_classes_by_key}
-  end
-
-  defp process_attrs_ref(
-         %LiveStyle.Attrs{},
-         {props_acc, vars_acc, class_order, prop_classes_by_key}
-       ) do
-    {props_acc, vars_acc, class_order, prop_classes_by_key}
+       when is_atom(source_module) and is_list(refs) do
+    resolved = resolve_attrs(source_module, refs, nil)
+    StyleMerger.merge_attrs(%{attrs | prop_classes: resolved.prop_classes}, state)
   end
 
-  defp extract_extra_classes(class, prop_classes) when is_binary(class) and class != "" do
-    prop_class_values = MapSet.new(Enum.map(prop_classes, fn {_prop, cls} -> cls end))
-
-    class
-    |> String.split(" ", trim: true)
-    |> Enum.reject(&MapSet.member?(prop_class_values, &1))
-  end
-
-  defp extract_extra_classes(_, _), do: []
+  defp process_attrs_ref(%LiveStyle.Attrs{} = attrs, state),
+    do: StyleMerger.merge_attrs(attrs, state)
 
   defp extract_extra_styles(nil), do: nil
   defp extract_extra_styles([]), do: nil
@@ -121,121 +87,4 @@ defmodule LiveStyle.Runtime.Attrs do
 
   defp format_style_key(key) when is_atom(key), do: CSSValue.to_css_property(key)
   defp format_style_key(key) when is_binary(key), do: key
-
-  defp build_style_string([], nil), do: nil
-  defp build_style_string([], extra) when is_binary(extra), do: extra
-
-  defp build_style_string(var_styles, nil) do
-    var_styles
-    |> Enum.reverse()
-    |> Enum.reduce([], &merge_var_list/2)
-    |> Enum.map_join("; ", fn {var_name, value} -> "#{var_name}: #{value}" end)
-  end
-
-  defp build_style_string(var_styles, extra) when is_binary(extra) do
-    var_string =
-      var_styles
-      |> Enum.reverse()
-      |> Enum.reduce([], &merge_var_list/2)
-      |> Enum.map_join("; ", fn {var_name, value} -> "#{var_name}: #{value}" end)
-
-    if var_string == "" do
-      extra
-    else
-      "#{var_string}; #{extra}"
-    end
-  end
-
-  defp merge_var_list(new_vars, acc) when is_list(new_vars) do
-    Enum.reduce(new_vars, acc, fn {key, value}, inner_acc ->
-      List.keystore(inner_acc, key, 0, {key, value})
-    end)
-  end
-
-  defp merge_resolved_ref(
-         {:static, prop_classes},
-         props_acc,
-         vars_acc,
-         class_order,
-         prop_classes_by_key
-       ) do
-    merged = PropertyMerger.merge(prop_classes, props_acc)
-
-    {new_class_order, new_prop_classes_by_key} =
-      apply_prop_classes(prop_classes, class_order, prop_classes_by_key)
-
-    {merged, vars_acc, new_class_order, new_prop_classes_by_key}
-  end
-
-  defp merge_resolved_ref(
-         {:dynamic, prop_classes, var_list},
-         props_acc,
-         vars_acc,
-         class_order,
-         prop_classes_by_key
-       ) do
-    # Dynamic classes now merge by property just like static classes (StyleX behavior)
-    merged = PropertyMerger.merge(prop_classes, props_acc)
-
-    {new_class_order, new_prop_classes_by_key} =
-      apply_prop_classes(prop_classes, class_order, prop_classes_by_key)
-
-    {merged, [var_list | vars_acc], new_class_order, new_prop_classes_by_key}
-  end
-
-  defp merge_resolved_ref(:skip, props_acc, vars_acc, class_order, prop_classes_by_key) do
-    {props_acc, vars_acc, class_order, prop_classes_by_key}
-  end
-
-  defp append_class_string({props_acc, vars_acc, class_order, prop_classes_by_key}, class_string) do
-    {props_acc, vars_acc, class_order ++ split_class_string(class_string), prop_classes_by_key}
-  end
-
-  defp split_class_string(class_string) when is_binary(class_string) do
-    String.split(class_string, " ", trim: true)
-  end
-
-  defp apply_prop_classes(prop_classes, class_order, prop_classes_by_key)
-       when is_list(prop_classes) do
-    Enum.reduce(prop_classes, {class_order, prop_classes_by_key}, fn
-      {prop_key, :__unset__}, {order_acc, prop_map_acc} ->
-        case Map.pop(prop_map_acc, prop_key) do
-          {nil, updated_map} ->
-            {order_acc, updated_map}
-
-          {old_class, updated_map} ->
-            {remove_last(order_acc, old_class), updated_map}
-        end
-
-      {prop_key, class_name}, {order_acc, prop_map_acc}
-      when is_binary(class_name) and class_name != "" ->
-        {trimmed_order, updated_map} =
-          case Map.pop(prop_map_acc, prop_key) do
-            {nil, map_without_prop} ->
-              {order_acc, map_without_prop}
-
-            {old_class, map_without_prop} ->
-              {remove_last(order_acc, old_class), map_without_prop}
-          end
-
-        {trimmed_order ++ [class_name], Map.put(updated_map, prop_key, class_name)}
-
-      _entry, acc ->
-        acc
-    end)
-  end
-
-  defp remove_last(list, target) do
-    list
-    |> Enum.reverse()
-    |> remove_first_reversed(target)
-    |> Enum.reverse()
-  end
-
-  defp remove_first_reversed([target | rest], target), do: rest
-
-  defp remove_first_reversed([head | rest], target),
-    do: [head | remove_first_reversed(rest, target)]
-
-  defp remove_first_reversed([], _target), do: []
 end
diff --git a/lib/live_style/runtime/style_merger.ex b/lib/live_style/runtime/style_merger.ex
new file mode 100644
index 0000000..30b77a5
--- /dev/null
+++ b/lib/live_style/runtime/style_merger.ex
@@ -0,0 +1,214 @@
+defmodule LiveStyle.Runtime.StyleMerger do
+  @moduledoc false
+
+  alias LiveStyle.Runtime.PropertyMerger
+
+  defstruct merged_props: [],
+            var_styles: [],
+            class_stack: [],
+            prop_classes_by_key: %{}
+
+  @type state :: %__MODULE__{
+          merged_props: LiveStyle.Attrs.prop_classes(),
+          var_styles: [keyword()],
+          class_stack: [String.t()],
+          prop_classes_by_key: %{optional(atom() | String.t()) => String.t()}
+        }
+
+  @spec new_state() :: state()
+  def new_state, do: %__MODULE__{}
+
+  @spec merge_resolved(
+          {:static, LiveStyle.Attrs.prop_classes()}
+          | {:dynamic, LiveStyle.Attrs.prop_classes(), keyword()}
+          | :skip,
+          state()
+        ) :: state()
+  def merge_resolved({:static, prop_classes}, state) do
+    merge_prop_classes(prop_classes, state)
+  end
+
+  def merge_resolved({:dynamic, prop_classes, var_list}, state) do
+    prop_classes
+    |> merge_prop_classes(state)
+    |> append_var_list(var_list)
+  end
+
+  def merge_resolved(:skip, state), do: state
+
+  @spec merge_resolved_refs(list(), String.t() | nil) :: LiveStyle.Attrs.t()
+  def merge_resolved_refs(resolved_refs, extra_styles \\ nil) do
+    resolved_refs
+    |> Enum.reduce(new_state(), &merge_resolved/2)
+    |> to_attrs(extra_styles)
+  end
+
+  @spec merge_attrs(LiveStyle.Attrs.t(), state()) :: state()
+  def merge_attrs(
+        %LiveStyle.Attrs{prop_classes: prop_classes, class: class},
+        state
+      )
+      when is_list(prop_classes) and prop_classes != [] do
+    prop_classes
+    |> merge_prop_classes(state)
+    |> append_extra_classes(class, prop_classes)
+  end
+
+  def merge_attrs(%LiveStyle.Attrs{class: class}, state)
+      when is_binary(class) and class != "" do
+    append_class_string(state, class)
+  end
+
+  def merge_attrs(%LiveStyle.Attrs{}, state), do: state
+
+  @spec append_class_string(state(), String.t()) :: state()
+  def append_class_string(%__MODULE__{} = state, class_string) do
+    class_string
+    |> split_class_string()
+    |> Enum.reduce(state, &append_class/2)
+  end
+
+  @spec to_attrs(state(), String.t() | nil) :: LiveStyle.Attrs.t()
+  def to_attrs(
+        %__MODULE__{
+          merged_props: merged_props,
+          var_styles: var_styles,
+          class_stack: class_stack
+        },
+        extra_styles
+      ) do
+    class_string =
+      class_stack
+      |> Enum.reverse()
+      |> Enum.uniq()
+      |> Enum.join(" ")
+
+    %LiveStyle.Attrs{
+      class: class_string,
+      style: build_style_string(var_styles, extra_styles),
+      prop_classes: merged_props
+    }
+  end
+
+  @spec merge_style_strings(String.t() | nil, String.t() | nil) :: String.t() | nil
+  def merge_style_strings(nil, nil), do: nil
+  def merge_style_strings(nil, extra) when is_binary(extra), do: extra
+  def merge_style_strings(dynamic, nil) when is_binary(dynamic), do: dynamic
+
+  def merge_style_strings(dynamic, extra)
+      when is_binary(dynamic) and is_binary(extra) do
+    "#{dynamic}; #{extra}"
+  end
+
+  defp merge_prop_classes(prop_classes, %__MODULE__{} = state) do
+    merged = PropertyMerger.merge(prop_classes, state.merged_props)
+
+    {new_class_stack, new_prop_classes_by_key} =
+      apply_prop_classes(prop_classes, state.class_stack, state.prop_classes_by_key)
+
+    %{
+      state
+      | merged_props: merged,
+        class_stack: new_class_stack,
+        prop_classes_by_key: new_prop_classes_by_key
+    }
+  end
+
+  defp append_var_list(%__MODULE__{var_styles: var_styles} = state, var_list)
+       when is_list(var_list) do
+    %{state | var_styles: [var_list | var_styles]}
+  end
+
+  defp append_extra_classes(state, class, prop_classes) do
+    extra_from_attrs = extract_extra_classes(class, prop_classes)
+
+    Enum.reduce(extra_from_attrs, state, fn class_name, acc ->
+      append_class_string(acc, class_name)
+    end)
+  end
+
+  defp extract_extra_classes(class, prop_classes) when is_binary(class) and class != "" do
+    prop_class_values = MapSet.new(Enum.map(prop_classes, fn {_prop, cls} -> cls end))
+
+    class
+    |> String.split(" ", trim: true)
+    |> Enum.reject(&MapSet.member?(prop_class_values, &1))
+  end
+
+  defp extract_extra_classes(_, _), do: []
+
+  defp build_style_string([], nil), do: nil
+  defp build_style_string([], extra) when is_binary(extra), do: extra
+
+  defp build_style_string(var_styles, nil) do
+    var_styles
+    |> Enum.reverse()
+    |> Enum.reduce([], &merge_var_list/2)
+    |> Enum.map_join("; ", fn {var_name, value} -> "#{var_name}: #{value}" end)
+  end
+
+  defp build_style_string(var_styles, extra) when is_binary(extra) do
+    var_string =
+      var_styles
+      |> Enum.reverse()
+      |> Enum.reduce([], &merge_var_list/2)
+      |> Enum.map_join("; ", fn {var_name, value} -> "#{var_name}: #{value}" end)
+
+    if var_string == "" do
+      extra
+    else
+      "#{var_string}; #{extra}"
+    end
+  end
+
+  defp merge_var_list(new_vars, acc) when is_list(new_vars) do
+    Enum.reduce(new_vars, acc, fn {key, value}, inner_acc ->
+      List.keystore(inner_acc, key, 0, {key, value})
+    end)
+  end
+
+  defp split_class_string(class_string) when is_binary(class_string) do
+    String.split(class_string, " ", trim: true)
+  end
+
+  defp append_class(class_name, %__MODULE__{class_stack: class_stack} = state) do
+    %{state | class_stack: [class_name | class_stack]}
+  end
+
+  defp apply_prop_classes(prop_classes, class_stack, prop_classes_by_key)
+       when is_list(prop_classes) do
+    Enum.reduce(prop_classes, {class_stack, prop_classes_by_key}, fn
+      {prop_key, :__unset__}, {stack_acc, prop_map_acc} ->
+        case Map.pop(prop_map_acc, prop_key) do
+          {nil, updated_map} ->
+            {stack_acc, updated_map}
+
+          {old_class, updated_map} ->
+            {remove_first(stack_acc, old_class), updated_map}
+        end
+
+      {prop_key, class_name}, {stack_acc, prop_map_acc}
+      when is_binary(class_name) and class_name != "" ->
+        {trimmed_stack, updated_map} =
+          case Map.pop(prop_map_acc, prop_key) do
+            {nil, map_without_prop} ->
+              {stack_acc, map_without_prop}
+
+            {old_class, map_without_prop} ->
+              {remove_first(stack_acc, old_class), map_without_prop}
+          end
+
+        {[class_name | trimmed_stack], Map.put(updated_map, prop_key, class_name)}
+
+      _entry, acc ->
+        acc
+    end)
+  end
+
+  defp remove_first([target | rest], target), do: rest
+
+  defp remove_first([head | rest], target),
+    do: [head | remove_first(rest, target)]
+
+  defp remove_first([], _target), do: []
+end
diff --git a/lib/live_style/shorthand_behavior.ex b/lib/live_style/shorthand_behavior.ex
index a83936e..b9071fb 100644
--- a/lib/live_style/shorthand_behavior.ex
+++ b/lib/live_style/shorthand_behavior.ex
@@ -4,7 +4,7 @@ defmodule LiveStyle.ShorthandBehavior do
 
   LiveStyle supports three built-in behaviors for handling CSS shorthand properties:
 
-  - `LiveStyle.ShorthandBehavior.AcceptShorthands` (default) - Keeps shorthand properties with nil resets
+  - `LiveStyle.ShorthandBehavior.AcceptShorthands` (default) - Keeps shorthand declarations intact while tracking related longhands
   - `LiveStyle.ShorthandBehavior.FlattenShorthands` - Expands shorthands to their longhand equivalents
   - `LiveStyle.ShorthandBehavior.ForbidShorthands` - Forbids disallowed shorthand properties at compile time
 
diff --git a/lib/live_style/shorthand_behavior/accept_shorthands.ex b/lib/live_style/shorthand_behavior/accept_shorthands.ex
index 8047d91..8432338 100644
--- a/lib/live_style/shorthand_behavior/accept_shorthands.ex
+++ b/lib/live_style/shorthand_behavior/accept_shorthands.ex
@@ -1,16 +1,16 @@
 defmodule LiveStyle.ShorthandBehavior.AcceptShorthands do
   @moduledoc """
-  Keeps shorthand properties intact with nil resets for longhands.
+  Keeps shorthand properties intact while tracking related longhands for merging.
 
   This is the default behavior. Shorthand properties are preserved,
-  but conflicting longhand properties are reset to `nil` to ensure
-  deterministic cascade behavior.
+  and related longhands are considered during expansion so later declarations
+  can merge with deterministic cascade behavior.
 
   ## How It Works
 
   When you use a shorthand like `margin: "10px"`, this behavior:
-  1. Keeps the shorthand as the main value
-  2. Returns the shorthand without nil resets (nils are filtered out)
+  1. Expands the shorthand through the same data used by the merger
+  2. Keeps only the emitted shorthand declaration after filtering internal nil resets
 
   This ensures that later longhands properly override earlier shorthands
   through CSS cascade, while keeping the output minimal.
diff --git a/lib/live_style/shorthand_behavior/forbid_shorthands.ex b/lib/live_style/shorthand_behavior/forbid_shorthands.ex
index c691be0..f56efc0 100644
--- a/lib/live_style/shorthand_behavior/forbid_shorthands.ex
+++ b/lib/live_style/shorthand_behavior/forbid_shorthands.ex
@@ -11,10 +11,10 @@ defmodule LiveStyle.ShorthandBehavior.ForbidShorthands do
 
   ## Example
 
-      iex> ForbidShorthands.expand("margin", "10px")
+      iex> ForbidShorthands.expand_declaration("margin", "10px")
       [{"margin", "10px"}]
 
-      iex> ForbidShorthands.expand("border", "1px solid black")
+      iex> ForbidShorthands.expand_declaration("border", "1px solid black")
       ** (ArgumentError) 'border' is not supported...
 
   """
diff --git a/lib/live_style/storage.ex b/lib/live_style/storage.ex
index 8502373..6c39711 100644
--- a/lib/live_style/storage.ex
+++ b/lib/live_style/storage.ex
@@ -310,8 +310,8 @@ defmodule LiveStyle.Storage do
     alias LiveStyle.Compiler.ModuleData
     alias LiveStyle.Manifest
 
+    ModuleData.cleanup_stale()
     module_data = ModuleData.list_all()
-    active_modules = MapSet.new(module_data, fn {module, _data} -> module end)
 
     # Build manifest from per-module data
     manifest =
@@ -323,12 +323,11 @@ defmodule LiveStyle.Storage do
     write(manifest)
 
     # Merge per-module usage files into usage manifest
+    active_modules = MapSet.new(module_data, fn {module, _data} -> module end)
+    ModuleData.cleanup_stale_usage(active_modules)
     usage = ModuleData.collect_all_usage()
     write_usage_direct(usage)
 
-    # Clean up outdated module files (modules that no longer use LiveStyle)
-    ModuleData.cleanup_outdated(active_modules)
-
     length(module_data)
   end
 
@@ -480,6 +479,7 @@ defmodule LiveStyle.Storage do
     temp_path = file_path <> ".tmp"
 
     try do
+      manifest = LiveStyle.Manifest.to_serializable(manifest)
       File.write!(temp_path, :erlang.term_to_binary(manifest))
       File.rename!(temp_path, file_path)
     rescue
diff --git a/lib/live_style/types.ex b/lib/live_style/types.ex
index faf179e..0d847fc 100644
--- a/lib/live_style/types.ex
+++ b/lib/live_style/types.ex
@@ -150,8 +150,8 @@ defmodule LiveStyle.Types do
   ## Examples
 
       Types.transform_list([
-        Functions.rotate(Units.deg(45)),
-        Functions.scale(1.5)
+        "rotate(45deg)",
+        "scale(1.5)"
       ])
   """
   @spec transform_list(list(String.t())) :: property_type()
diff --git a/lib/live_style/when.ex b/lib/live_style/when.ex
index 3f52165..3fca4ab 100644
--- a/lib/live_style/when.ex
+++ b/lib/live_style/when.ex
@@ -3,8 +3,8 @@ defmodule LiveStyle.When do
   Contextual selectors for styling elements based on ancestor, descendant, or sibling state.
 
   These functions generate CSS selectors that allow you to style an element based on
-  the state of related elements in the DOM tree. They work by using marker classes
-  that you apply to the elements you want to observe.
+  the state of related elements in the DOM tree. They work by using markers that
+  you apply as classes to the elements you want to observe.
 
   ## Browser Support
 
@@ -13,7 +13,7 @@ defmodule LiveStyle.When do
 
   ## Using Markers
 
-  To use these selectors, you must mark the element being observed with a marker class.
+  To use these selectors, you must mark the element being observed with a marker.
   Use `LiveStyle.default_marker/0` for the default marker, or `LiveStyle.marker/1`
   for custom markers.
 
@@ -33,7 +33,7 @@ defmodule LiveStyle.When do
 
         def render(assigns) do
           ~H\"\"\"
-          <div class={LiveStyle.default_marker()}>
+          <div {css([LiveStyle.default_marker()])}>
             <div {css(:card)}>Hover parent to move me</div>
           </div>
           \"\"\"
@@ -65,7 +65,7 @@ defmodule LiveStyle.When do
   ## Parameters
 
     * `pseudo` - The pseudo selector (e.g., `":hover"`, `":focus"`)
-    * `marker` - Optional custom marker class name. Defaults to the configured default marker.
+    * `marker` - Optional custom marker. Defaults to the configured default marker.
 
   ## Example
 
@@ -79,6 +79,9 @@ defmodule LiveStyle.When do
   """
   def ancestor(pseudo), do: ancestor(pseudo, Marker.default())
 
+  @doc """
+  Creates an ancestor selector using a custom marker.
+  """
   def ancestor(pseudo, marker) do
     validate_pseudo!(pseudo)
     class = Marker.to_class(marker)
@@ -94,7 +97,7 @@ defmodule LiveStyle.When do
   ## Parameters
 
     * `pseudo` - The pseudo selector (e.g., `":hover"`, `":focus"`)
-    * `marker` - Optional custom marker class name. Defaults to the configured default marker.
+    * `marker` - Optional custom marker. Defaults to the configured default marker.
 
   ## Example
 
@@ -108,6 +111,9 @@ defmodule LiveStyle.When do
   """
   def descendant(pseudo), do: descendant(pseudo, Marker.default())
 
+  @doc """
+  Creates a descendant selector using a custom marker.
+  """
   def descendant(pseudo, marker) do
     validate_pseudo!(pseudo)
     class = Marker.to_class(marker)
@@ -123,7 +129,7 @@ defmodule LiveStyle.When do
   ## Parameters
 
     * `pseudo` - The pseudo selector (e.g., `":hover"`, `":focus"`)
-    * `marker` - Optional custom marker class name. Defaults to the configured default marker.
+    * `marker` - Optional custom marker. Defaults to the configured default marker.
 
   ## Example
 
@@ -137,6 +143,9 @@ defmodule LiveStyle.When do
   """
   def sibling_before(pseudo), do: sibling_before(pseudo, Marker.default())
 
+  @doc """
+  Creates a preceding-sibling selector using a custom marker.
+  """
   def sibling_before(pseudo, marker) do
     validate_pseudo!(pseudo)
     class = Marker.to_class(marker)
@@ -152,7 +161,7 @@ defmodule LiveStyle.When do
   ## Parameters
 
     * `pseudo` - The pseudo selector (e.g., `":hover"`, `":focus"`)
-    * `marker` - Optional custom marker class name. Defaults to the configured default marker.
+    * `marker` - Optional custom marker. Defaults to the configured default marker.
 
   ## Example
 
@@ -166,6 +175,9 @@ defmodule LiveStyle.When do
   """
   def sibling_after(pseudo), do: sibling_after(pseudo, Marker.default())
 
+  @doc """
+  Creates a following-sibling selector using a custom marker.
+  """
   def sibling_after(pseudo, marker) do
     validate_pseudo!(pseudo)
     class = Marker.to_class(marker)
@@ -181,7 +193,7 @@ defmodule LiveStyle.When do
   ## Parameters
 
     * `pseudo` - The pseudo selector (e.g., `":hover"`, `":focus"`)
-    * `marker` - Optional custom marker class name. Defaults to the configured default marker.
+    * `marker` - Optional custom marker. Defaults to the configured default marker.
 
   ## Example
 
@@ -195,6 +207,9 @@ defmodule LiveStyle.When do
   """
   def any_sibling(pseudo), do: any_sibling(pseudo, Marker.default())
 
+  @doc """
+  Creates an any-sibling selector using a custom marker.
+  """
   def any_sibling(pseudo, marker) do
     validate_pseudo!(pseudo)
     class = Marker.to_class(marker)
diff --git a/lib/mix/tasks/live_style.audit.ex b/lib/mix/tasks/live_style.audit.ex
index 5d17bbf..5776922 100644
--- a/lib/mix/tasks/live_style.audit.ex
+++ b/lib/mix/tasks/live_style.audit.ex
@@ -14,6 +14,7 @@ defmodule Mix.Tasks.LiveStyle.Audit do
 
     * `--path` - Directory to scan (default: "lib")
     * `--format` - Output format: "text" or "json" (default: "text")
+      JSON output requires the optional `:jason` dependency.
 
   ## How It Works
 
@@ -204,15 +205,7 @@ defmodule Mix.Tasks.LiveStyle.Audit do
       )
 
       for {module, classes} <- Enum.sort(unused) do
-        Mix.shell().info("  #{IO.ANSI.bright()}#{module}#{IO.ANSI.reset()}")
-
-        for %{class: class, file: file, line: line} <- Enum.sort_by(classes, & &1.line) do
-          Mix.shell().info(
-            "    #{IO.ANSI.yellow()}#{class}#{IO.ANSI.reset()} #{IO.ANSI.faint()}(#{file}:#{line})#{IO.ANSI.reset()}"
-          )
-        end
-
-        Mix.shell().info("")
+        output_module_unused_classes(module, classes)
       end
 
       Mix.shell().info(
@@ -221,7 +214,23 @@ defmodule Mix.Tasks.LiveStyle.Audit do
     end
   end
 
+  defp output_module_unused_classes(module, classes) do
+    Mix.shell().info("  #{IO.ANSI.bright()}#{module}#{IO.ANSI.reset()}")
+
+    classes
+    |> Enum.sort_by(& &1.line)
+    |> Enum.each(fn %{class: class, file: file, line: line} ->
+      Mix.shell().info(
+        "    #{IO.ANSI.yellow()}#{class}#{IO.ANSI.reset()} #{IO.ANSI.faint()}(#{file}:#{line})#{IO.ANSI.reset()}"
+      )
+    end)
+
+    Mix.shell().info("")
+  end
+
   defp output_json(unused) do
+    ensure_jason!()
+
     items =
       unused
       |> Enum.flat_map(fn {module, classes} ->
@@ -232,4 +241,12 @@ defmodule Mix.Tasks.LiveStyle.Audit do
 
     Mix.shell().info(Jason.encode!(items))
   end
+
+  defp ensure_jason! do
+    unless Code.ensure_loaded?(Jason) do
+      Mix.raise(
+        "JSON output requires Jason. Add {:jason, \"~> 1.4\"} to your deps or use --format text."
+      )
+    end
+  end
 end
diff --git a/mix.exs b/mix.exs
index 4bc6ea8..6e29fba 100644
--- a/mix.exs
+++ b/mix.exs
@@ -3,6 +3,39 @@ defmodule LiveStyle.MixProject do
 
   @version "0.16.2"
   @source_url "https://github.com/lifeiscontent/live_style"
+  @docs_modules [
+    LiveStyle,
+    LiveStyle.Attrs,
+    LiveStyle.Compiler,
+    LiveStyle.Config,
+    LiveStyle.Dev,
+    LiveStyle.Marker,
+    LiveStyle.ShorthandBehavior,
+    LiveStyle.ShorthandBehavior.AcceptShorthands,
+    LiveStyle.ShorthandBehavior.FlattenShorthands,
+    LiveStyle.ShorthandBehavior.ForbidShorthands,
+    LiveStyle.Types,
+    LiveStyle.When,
+    Mix.Tasks.Compile.LiveStyle,
+    Mix.Tasks.LiveStyle,
+    Mix.Tasks.LiveStyle.Audit,
+    Mix.Tasks.LiveStyle.Inspect,
+    Mix.Tasks.LiveStyle.SetupTests
+  ]
+  @docs_skip_autolinks [
+    "LiveStyle.CSSValue",
+    "LiveStyle.Compiler.CSS",
+    "LiveStyle.Data",
+    "LiveStyle.PropertyMetadata",
+    "LiveStyle.Registry",
+    "LiveStyle.Storage",
+    "LiveStyle.Value",
+    "Mix.Tasks.Compile.LiveStyle",
+    "live_style.audit",
+    "live_style.inspect",
+    "mix live_style.audit",
+    "mix live_style.inspect"
+  ]
 
   def project do
     [
@@ -50,13 +83,15 @@ defmodule LiveStyle.MixProject do
 
   defp deps do
     [
-      {:phoenix_live_view, "~> 1.1", optional: true},
-      {:file_system, "~> 1.0", optional: true},
-      {:ex_doc, "~> 0.31", only: [:dev, :test], runtime: false},
+      {:phoenix_live_view, "~> 1.1", optional: true, runtime: false},
+      {:phoenix_html, "~> 3.3 or ~> 4.0", optional: true, runtime: false},
+      {:file_system, "~> 1.0", optional: true, runtime: false},
+      {:jason, "~> 1.4", optional: true, runtime: false},
+      {:ex_doc, "~> 0.40", only: :dev, runtime: false},
       {:credo, "~> 1.7", only: [:dev, :test], runtime: false},
       {:dialyxir, "~> 1.4", only: [:dev, :test], runtime: false},
-      {:benchee, "~> 1.0", only: :dev, optional: true},
-      {:git_ops, "~> 2.6", only: :dev, runtime: false}
+      {:benchee, "~> 1.5", only: :dev, runtime: false},
+      {:git_ops, "~> 2.10", only: :dev, runtime: false}
     ]
   end
 
@@ -88,6 +123,21 @@ defmodule LiveStyle.MixProject do
       groups_for_extras: [
         Guides: ~r/guides\/.*/
       ],
+      groups_for_modules: [
+        {"Core", [LiveStyle, LiveStyle.Attrs]},
+        {"Advanced Helpers", [LiveStyle.Marker, LiveStyle.Types, LiveStyle.When]},
+        {"Configuration", [LiveStyle.Config, LiveStyle.ShorthandBehavior]},
+        {"Shorthand Behaviors",
+         [
+           LiveStyle.ShorthandBehavior.AcceptShorthands,
+           LiveStyle.ShorthandBehavior.FlattenShorthands,
+           LiveStyle.ShorthandBehavior.ForbidShorthands
+         ]},
+        {"Developer Tools", [LiveStyle.Compiler, LiveStyle.Dev]}
+      ],
+      filter_modules: fn module, _metadata -> module in @docs_modules end,
+      skip_code_autolink_to: fn reference -> reference in @docs_skip_autolinks end,
+      skip_undefined_reference_warnings_on: ["CHANGELOG.md"],
       source_ref: "v#{@version}",
       source_url: @source_url
     ]
@@ -96,7 +146,7 @@ defmodule LiveStyle.MixProject do
   defp dialyzer do
     [
       plt_file: {:no_warn, "priv/plts/dialyzer.plt"},
-      plt_add_apps: [:mix, :ex_unit]
+      plt_add_apps: [:mix, :ex_unit, :jason, :phoenix_html]
     ]
   end
 end
diff --git a/mix.lock b/mix.lock
index af8fd8d..c867f7f 100644
--- a/mix.lock
+++ b/mix.lock
@@ -1,36 +1,36 @@
 %{
   "benchee": {:hex, :benchee, "1.5.0", "4d812c31d54b0ec0167e91278e7de3f596324a78a096fd3d0bea68bb0c513b10", [:mix], [{:deep_merge, "~> 1.0", [hex: :deep_merge, repo: "hexpm", optional: false]}, {:statistex, "~> 1.1", [hex: :statistex, repo: "hexpm", optional: false]}, {:table, "~> 0.1.0", [hex: :table, repo: "hexpm", optional: true]}], "hexpm", "5b075393aea81b8ae74eadd1c28b1d87e8a63696c649d8293db7c4df3eb67535"},
   "bunt": {:hex, :bunt, "1.0.0", "081c2c665f086849e6d57900292b3a161727ab40431219529f13c4ddcf3e7a44", [:mix], [], "hexpm", "dc5f86aa08a5f6fa6b8096f0735c4e76d54ae5c9fa2c143e5a1fc7c1cd9bb6b5"},
-  "credo": {:hex, :credo, "1.7.15", "283da72eeb2fd3ccf7248f4941a0527efb97afa224bcdef30b4b580bc8258e1c", [:mix], [{:bunt, "~> 0.2.1 or ~> 1.0", [hex: :bunt, repo: "hexpm", optional: false]}, {:file_system, "~> 0.2 or ~> 1.0", [hex: :file_system, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: false]}], "hexpm", "291e8645ea3fea7481829f1e1eb0881b8395db212821338e577a90bf225c5607"},
+  "credo": {:hex, :credo, "1.7.18", "5c5596bf7aedf9c8c227f13272ac499fe8eae6237bd326f2f07dfc173786f042", [:mix], [{:bunt, "~> 0.2.1 or ~> 1.0", [hex: :bunt, repo: "hexpm", optional: false]}, {:file_system, "~> 0.2 or ~> 1.0", [hex: :file_system, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: false]}], "hexpm", "a189d164685fd945809e862fe76a7420c4398fa288d76257662aecb909d6b3e5"},
   "deep_merge": {:hex, :deep_merge, "1.0.0", "b4aa1a0d1acac393bdf38b2291af38cb1d4a52806cf7a4906f718e1feb5ee961", [:mix], [], "hexpm", "ce708e5f094b9cd4e8f2be4f00d2f4250c4095be93f8cd6d018c753894885430"},
   "dialyxir": {:hex, :dialyxir, "1.4.7", "dda948fcee52962e4b6c5b4b16b2d8fa7d50d8645bbae8b8685c3f9ecb7f5f4d", [:mix], [{:erlex, ">= 0.2.8", [hex: :erlex, repo: "hexpm", optional: false]}], "hexpm", "b34527202e6eb8cee198efec110996c25c5898f43a4094df157f8d28f27d9efe"},
   "earmark_parser": {:hex, :earmark_parser, "1.4.44", "f20830dd6b5c77afe2b063777ddbbff09f9759396500cdbe7523efd58d7a339c", [:mix], [], "hexpm", "4778ac752b4701a5599215f7030989c989ffdc4f6df457c5f36938cc2d2a2750"},
   "erlex": {:hex, :erlex, "0.2.8", "cd8116f20f3c0afe376d1e8d1f0ae2452337729f68be016ea544a72f767d9c12", [:mix], [], "hexpm", "9d66ff9fedf69e49dc3fd12831e12a8a37b76f8651dd21cd45fcf5561a8a7590"},
-  "ex_doc": {:hex, :ex_doc, "0.39.3", "519c6bc7e84a2918b737aec7ef48b96aa4698342927d080437f61395d361dcee", [:mix], [{:earmark_parser, "~> 1.4.44", [hex: :earmark_parser, repo: "hexpm", optional: false]}, {:makeup_c, ">= 0.1.0", [hex: :makeup_c, repo: "hexpm", optional: true]}, {:makeup_elixir, "~> 0.14 or ~> 1.0", [hex: :makeup_elixir, repo: "hexpm", optional: false]}, {:makeup_erlang, "~> 0.1 or ~> 1.0", [hex: :makeup_erlang, repo: "hexpm", optional: false]}, {:makeup_html, ">= 0.1.0", [hex: :makeup_html, repo: "hexpm", optional: true]}], "hexpm", "0590955cf7ad3b625780ee1c1ea627c28a78948c6c0a9b0322bd976a079996e1"},
+  "ex_doc": {:hex, :ex_doc, "0.40.1", "67542e4b6dde74811cfd580e2c0149b78010fd13001fda7cfeb2b2c2ffb1344d", [:mix], [{:earmark_parser, "~> 1.4.44", [hex: :earmark_parser, repo: "hexpm", optional: false]}, {:makeup_c, ">= 0.1.0", [hex: :makeup_c, repo: "hexpm", optional: true]}, {:makeup_elixir, "~> 0.14 or ~> 1.0", [hex: :makeup_elixir, repo: "hexpm", optional: false]}, {:makeup_erlang, "~> 0.1 or ~> 1.0", [hex: :makeup_erlang, repo: "hexpm", optional: false]}, {:makeup_html, ">= 0.1.0", [hex: :makeup_html, repo: "hexpm", optional: true]}], "hexpm", "bcef0e2d360d93ac19f01a85d58f91752d930c0a30e2681145feea6bd3516e00"},
   "file_system": {:hex, :file_system, "1.1.1", "31864f4685b0148f25bd3fbef2b1228457c0c89024ad67f7a81a3ffbc0bbad3a", [:mix], [], "hexpm", "7a15ff97dfe526aeefb090a7a9d3d03aa907e100e262a0f8f7746b78f8f87a5d"},
   "finch": {:hex, :finch, "0.21.0", "b1c3b2d48af02d0c66d2a9ebfb5622be5c5ecd62937cf79a88a7f98d48a8290c", [:mix], [{:mime, "~> 1.0 or ~> 2.0", [hex: :mime, repo: "hexpm", optional: false]}, {:mint, "~> 1.6.2 or ~> 1.7", [hex: :mint, repo: "hexpm", optional: false]}, {:nimble_options, "~> 0.4 or ~> 1.0", [hex: :nimble_options, repo: "hexpm", optional: false]}, {:nimble_pool, "~> 1.1", [hex: :nimble_pool, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "87dc6e169794cb2570f75841a19da99cfde834249568f2a5b121b809588a4377"},
   "git_cli": {:hex, :git_cli, "0.3.0", "a5422f9b95c99483385b976f5d43f7e8233283a47cda13533d7c16131cb14df5", [:mix], [], "hexpm", "78cb952f4c86a41f4d3511f1d3ecb28edb268e3a7df278de2faa1bd4672eaf9b"},
-  "git_ops": {:hex, :git_ops, "2.9.0", "b74f6040084f523055b720cc7ef718da47f2cbe726a5f30c2871118635cb91c1", [:mix], [{:git_cli, "~> 0.2", [hex: :git_cli, repo: "hexpm", optional: false]}, {:igniter, ">= 0.5.27 and < 1.0.0-0", [hex: :igniter, repo: "hexpm", optional: true]}, {:nimble_parsec, "~> 1.0", [hex: :nimble_parsec, repo: "hexpm", optional: false]}, {:req, "~> 0.5", [hex: :req, repo: "hexpm", optional: false]}], "hexpm", "7fdf84be3490e5692c5dc1f8a1084eed47a221c1063e41938c73312f0bfea259"},
+  "git_ops": {:hex, :git_ops, "2.10.0", "225780d8dcf9ef3393d26fa8d41d6a454a71149393c040e4b708c7c0b9c2b0f1", [:mix], [{:git_cli, "~> 0.2", [hex: :git_cli, repo: "hexpm", optional: false]}, {:igniter, ">= 0.5.27 and < 1.0.0-0", [hex: :igniter, repo: "hexpm", optional: true]}, {:nimble_parsec, "~> 1.0", [hex: :nimble_parsec, repo: "hexpm", optional: false]}, {:req, "~> 0.5", [hex: :req, repo: "hexpm", optional: false]}], "hexpm", "acd4a542eb425a58ce54505de69be704af3d0ef23c9b8cf9a3299d88e5d098ae"},
   "hpax": {:hex, :hpax, "1.0.3", "ed67ef51ad4df91e75cc6a1494f851850c0bd98ebc0be6e81b026e765ee535aa", [:mix], [], "hexpm", "8eab6e1cfa8d5918c2ce4ba43588e894af35dbd8e91e6e55c817bca5847df34a"},
-  "jason": {:hex, :jason, "1.4.4", "b9226785a9aa77b6857ca22832cffa5d5011a667207eb2a0ad56adb5db443b8a", [:mix], [{:decimal, "~> 1.0 or ~> 2.0", [hex: :decimal, repo: "hexpm", optional: true]}], "hexpm", "c5eb0cab91f094599f94d55bc63409236a8ec69a21a67814529e8d5f6cc90b3b"},
+  "jason": {:hex, :jason, "1.4.5", "2e3a008590b0b8d7388c20293e9dcc9cf3e5d642fd2a114e4cbbb52e595d940a", [:mix], [{:decimal, "~> 1.0 or ~> 2.0 or ~> 3.0", [hex: :decimal, repo: "hexpm", optional: true]}], "hexpm", "b0c823996102bcd0239b3c2444eb00409b72f6a140c1950bc8b457d836b30684"},
   "makeup": {:hex, :makeup, "1.2.1", "e90ac1c65589ef354378def3ba19d401e739ee7ee06fb47f94c687016e3713d1", [:mix], [{:nimble_parsec, "~> 1.4", [hex: :nimble_parsec, repo: "hexpm", optional: false]}], "hexpm", "d36484867b0bae0fea568d10131197a4c2e47056a6fbe84922bf6ba71c8d17ce"},
   "makeup_elixir": {:hex, :makeup_elixir, "1.0.1", "e928a4f984e795e41e3abd27bfc09f51db16ab8ba1aebdba2b3a575437efafc2", [:mix], [{:makeup, "~> 1.0", [hex: :makeup, repo: "hexpm", optional: false]}, {:nimble_parsec, "~> 1.2.3 or ~> 1.3", [hex: :nimble_parsec, repo: "hexpm", optional: false]}], "hexpm", "7284900d412a3e5cfd97fdaed4f5ed389b8f2b4cb49efc0eb3bd10e2febf9507"},
-  "makeup_erlang": {:hex, :makeup_erlang, "1.0.2", "03e1804074b3aa64d5fad7aa64601ed0fb395337b982d9bcf04029d68d51b6a7", [:mix], [{:makeup, "~> 1.0", [hex: :makeup, repo: "hexpm", optional: false]}], "hexpm", "af33ff7ef368d5893e4a267933e7744e46ce3cf1f61e2dccf53a111ed3aa3727"},
+  "makeup_erlang": {:hex, :makeup_erlang, "1.0.3", "4252d5d4098da7415c390e847c814bad3764c94a814a0b4245176215615e1035", [:mix], [{:makeup, "~> 1.0", [hex: :makeup, repo: "hexpm", optional: false]}], "hexpm", "953297c02582a33411ac6208f2c6e55f0e870df7f80da724ed613f10e6706afd"},
   "mime": {:hex, :mime, "2.0.7", "b8d739037be7cd402aee1ba0306edfdef982687ee7e9859bee6198c1e7e2f128", [:mix], [], "hexpm", "6171188e399ee16023ffc5b76ce445eb6d9672e2e241d2df6050f3c771e80ccd"},
   "mint": {:hex, :mint, "1.7.1", "113fdb2b2f3b59e47c7955971854641c61f378549d73e829e1768de90fc1abf1", [:mix], [{:castore, "~> 0.1.0 or ~> 1.0", [hex: :castore, repo: "hexpm", optional: true]}, {:hpax, "~> 0.1.1 or ~> 0.2.0 or ~> 1.0", [hex: :hpax, repo: "hexpm", optional: false]}], "hexpm", "fceba0a4d0f24301ddee3024ae116df1c3f4bb7a563a731f45fdfeb9d39a231b"},
   "nimble_options": {:hex, :nimble_options, "1.1.1", "e3a492d54d85fc3fd7c5baf411d9d2852922f66e69476317787a7b2bb000a61b", [:mix], [], "hexpm", "821b2470ca9442c4b6984882fe9bb0389371b8ddec4d45a9504f00a66f650b44"},
   "nimble_parsec": {:hex, :nimble_parsec, "1.4.2", "8efba0122db06df95bfaa78f791344a89352ba04baedd3849593bfce4d0dc1c6", [:mix], [], "hexpm", "4b21398942dda052b403bbe1da991ccd03a053668d147d53fb8c4e0efe09c973"},
   "nimble_pool": {:hex, :nimble_pool, "1.1.0", "bf9c29fbdcba3564a8b800d1eeb5a3c58f36e1e11d7b7fb2e084a643f645f06b", [:mix], [], "hexpm", "af2e4e6b34197db81f7aad230c1118eac993acc0dae6bc83bac0126d4ae0813a"},
-  "phoenix": {:hex, :phoenix, "1.8.3", "49ac5e485083cb1495a905e47eb554277bdd9c65ccb4fc5100306b350151aa95", [:mix], [{:bandit, "~> 1.0", [hex: :bandit, repo: "hexpm", optional: true]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:phoenix_pubsub, "~> 2.1", [hex: :phoenix_pubsub, repo: "hexpm", optional: false]}, {:phoenix_template, "~> 1.0", [hex: :phoenix_template, repo: "hexpm", optional: false]}, {:phoenix_view, "~> 2.0", [hex: :phoenix_view, repo: "hexpm", optional: true]}, {:plug, "~> 1.14", [hex: :plug, repo: "hexpm", optional: false]}, {:plug_cowboy, "~> 2.7", [hex: :plug_cowboy, repo: "hexpm", optional: true]}, {:plug_crypto, "~> 1.2 or ~> 2.0", [hex: :plug_crypto, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}, {:websock_adapter, "~> 0.5.3", [hex: :websock_adapter, repo: "hexpm", optional: false]}], "hexpm", "36169f95cc2e155b78be93d9590acc3f462f1e5438db06e6248613f27c80caec"},
+  "phoenix": {:hex, :phoenix, "1.8.7", "d8d755b4ff4b449f610223dd706b4ae64155cb720d3dc09c706c079ecea189e4", [:mix], [{:bandit, "~> 1.0", [hex: :bandit, repo: "hexpm", optional: true]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:phoenix_pubsub, "~> 2.1", [hex: :phoenix_pubsub, repo: "hexpm", optional: false]}, {:phoenix_template, "~> 1.0", [hex: :phoenix_template, repo: "hexpm", optional: false]}, {:phoenix_view, "~> 2.0", [hex: :phoenix_view, repo: "hexpm", optional: true]}, {:plug, "~> 1.14", [hex: :plug, repo: "hexpm", optional: false]}, {:plug_cowboy, "~> 2.7", [hex: :plug_cowboy, repo: "hexpm", optional: true]}, {:plug_crypto, "~> 1.2 or ~> 2.0", [hex: :plug_crypto, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}, {:websock_adapter, "~> 0.5.3", [hex: :websock_adapter, repo: "hexpm", optional: false]}], "hexpm", "47352f72d6ab31009ef77516b1b3a14745be97b54061fd458031b9d8294869d5"},
   "phoenix_html": {:hex, :phoenix_html, "4.3.0", "d3577a5df4b6954cd7890c84d955c470b5310bb49647f0a114a6eeecc850f7ad", [:mix], [], "hexpm", "3eaa290a78bab0f075f791a46a981bbe769d94bc776869f4f3063a14f30497ad"},
-  "phoenix_live_view": {:hex, :phoenix_live_view, "1.1.23", "5e41c63377d508dc9b22dcebcefa0a3a243695932f72eac6003831fd4ed96165", [:mix], [{:igniter, ">= 0.6.16 and < 1.0.0-0", [hex: :igniter, repo: "hexpm", optional: true]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:lazy_html, "~> 0.1.0", [hex: :lazy_html, repo: "hexpm", optional: true]}, {:phoenix, "~> 1.6.15 or ~> 1.7.0 or ~> 1.8.0-rc", [hex: :phoenix, repo: "hexpm", optional: false]}, {:phoenix_html, "~> 3.3 or ~> 4.0", [hex: :phoenix_html, repo: "hexpm", optional: false]}, {:phoenix_template, "~> 1.0", [hex: :phoenix_template, repo: "hexpm", optional: false]}, {:phoenix_view, "~> 2.0", [hex: :phoenix_view, repo: "hexpm", optional: true]}, {:plug, "~> 1.15", [hex: :plug, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4.2 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "f5296ef67b41da7fe345e139ebaa621ceb5e7e84e37c89a12574cc0536a80604"},
+  "phoenix_live_view": {:hex, :phoenix_live_view, "1.1.30", "a84af1610755dc208da35d4d45564485edbf18c3f3c77373c4a650dc994cdcdb", [:mix], [{:igniter, ">= 0.6.16 and < 1.0.0-0", [hex: :igniter, repo: "hexpm", optional: true]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:lazy_html, "~> 0.1.0", [hex: :lazy_html, repo: "hexpm", optional: true]}, {:phoenix, "~> 1.6.15 or ~> 1.7.0 or ~> 1.8.0-rc", [hex: :phoenix, repo: "hexpm", optional: false]}, {:phoenix_html, "~> 3.3 or ~> 4.0", [hex: :phoenix_html, repo: "hexpm", optional: false]}, {:phoenix_template, "~> 1.0", [hex: :phoenix_template, repo: "hexpm", optional: false]}, {:phoenix_view, "~> 2.0", [hex: :phoenix_view, repo: "hexpm", optional: true]}, {:plug, "~> 1.15", [hex: :plug, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4.2 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "a353c51ac1e3190910f01a6100c7d5cc02c5e22e7374fd817bd3aedd21149039"},
   "phoenix_pubsub": {:hex, :phoenix_pubsub, "2.2.0", "ff3a5616e1bed6804de7773b92cbccfc0b0f473faf1f63d7daf1206c7aeaaa6f", [:mix], [], "hexpm", "adc313a5bf7136039f63cfd9668fde73bba0765e0614cba80c06ac9460ff3e96"},
   "phoenix_template": {:hex, :phoenix_template, "1.0.4", "e2092c132f3b5e5b2d49c96695342eb36d0ed514c5b252a77048d5969330d639", [:mix], [{:phoenix_html, "~> 2.14.2 or ~> 3.0 or ~> 4.0", [hex: :phoenix_html, repo: "hexpm", optional: true]}], "hexpm", "2c0c81f0e5c6753faf5cca2f229c9709919aba34fab866d3bc05060c9c444206"},
   "plug": {:hex, :plug, "1.19.1", "09bac17ae7a001a68ae393658aa23c7e38782be5c5c00c80be82901262c394c0", [:mix], [{:mime, "~> 1.0 or ~> 2.0", [hex: :mime, repo: "hexpm", optional: false]}, {:plug_crypto, "~> 1.1.1 or ~> 1.2 or ~> 2.0", [hex: :plug_crypto, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4.3 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "560a0017a8f6d5d30146916862aaf9300b7280063651dd7e532b8be168511e62"},
   "plug_crypto": {:hex, :plug_crypto, "2.1.1", "19bda8184399cb24afa10be734f84a16ea0a2bc65054e23a62bb10f06bc89491", [:mix], [], "hexpm", "6470bce6ffe41c8bd497612ffde1a7e4af67f36a15eea5f921af71cf3e11247c"},
   "req": {:hex, :req, "0.5.17", "0096ddd5b0ed6f576a03dde4b158a0c727215b15d2795e59e0916c6971066ede", [:mix], [{:brotli, "~> 0.3.1", [hex: :brotli, repo: "hexpm", optional: true]}, {:ezstd, "~> 1.0", [hex: :ezstd, repo: "hexpm", optional: true]}, {:finch, "~> 0.17", [hex: :finch, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: false]}, {:mime, "~> 2.0.6 or ~> 2.1", [hex: :mime, repo: "hexpm", optional: false]}, {:nimble_csv, "~> 1.0", [hex: :nimble_csv, repo: "hexpm", optional: true]}, {:plug, "~> 1.0", [hex: :plug, repo: "hexpm", optional: true]}], "hexpm", "0b8bc6ffdfebbc07968e59d3ff96d52f2202d0536f10fef4dc11dc02a2a43e39"},
   "statistex": {:hex, :statistex, "1.1.0", "7fec1eb2f580a0d2c1a05ed27396a084ab064a40cfc84246dbfb0c72a5c761e5", [:mix], [], "hexpm", "f5950ea26ad43246ba2cce54324ac394a4e7408fdcf98b8e230f503a0cba9cf5"},
-  "telemetry": {:hex, :telemetry, "1.3.0", "fedebbae410d715cf8e7062c96a1ef32ec22e764197f70cda73d82778d61e7a2", [:rebar3], [], "hexpm", "7015fc8919dbe63764f4b4b87a95b7c0996bd539e0d499be6ec9d7f3875b79e6"},
+  "telemetry": {:hex, :telemetry, "1.4.1", "ab6de178e2b29b58e8256b92b382ea3f590a47152ca3651ea857a6cae05ac423", [:rebar3], [], "hexpm", "2172e05a27531d3d31dd9782841065c50dd5c3c7699d95266b2edd54c2dafa1c"},
   "websock": {:hex, :websock, "0.5.3", "2f69a6ebe810328555b6fe5c831a851f485e303a7c8ce6c5f675abeb20ebdadc", [:mix], [], "hexpm", "6105453d7fac22c712ad66fab1d45abdf049868f253cf719b625151460b8b453"},
   "websock_adapter": {:hex, :websock_adapter, "0.5.9", "43dc3ba6d89ef5dec5b1d0a39698436a1e856d000d84bf31a3149862b01a287f", [:mix], [{:bandit, ">= 0.6.0", [hex: :bandit, repo: "hexpm", optional: true]}, {:plug, "~> 1.14", [hex: :plug, repo: "hexpm", optional: false]}, {:plug_cowboy, "~> 2.6", [hex: :plug_cowboy, repo: "hexpm", optional: true]}, {:websock, "~> 0.5", [hex: :websock, repo: "hexpm", optional: false]}], "hexpm", "5534d5c9adad3c18a0f58a9371220d75a803bf0b9a3d87e6fe072faaeed76a08"},
 }
diff --git a/test/live_style/compiler/module_hash_test.exs b/test/live_style/compiler/module_hash_test.exs
index 29c7630..5bc62fe 100644
--- a/test/live_style/compiler/module_hash_test.exs
+++ b/test/live_style/compiler/module_hash_test.exs
@@ -526,7 +526,7 @@ defmodule LiveStyle.Compiler.ModuleHashTest do
         |> Manifest.put_module_hash(AModule, <<1::128>>)
         |> Manifest.put_module_hash(MModule, <<2::128>>)
 
-      modules = Enum.map(manifest.module_hashes, fn {mod, _} -> mod end)
+      modules = manifest |> Manifest.entries(:module_hashes) |> Enum.map(fn {mod, _} -> mod end)
       assert modules == Enum.sort(modules)
     end
 
@@ -539,7 +539,7 @@ defmodule LiveStyle.Compiler.ModuleHashTest do
         |> Manifest.put_module_hash(TestModule, old_hash)
         |> Manifest.put_module_hash(TestModule, new_hash)
 
-      assert length(manifest.module_hashes) == 1
+      assert Manifest.count(manifest, :module_hashes) == 1
       assert Manifest.get_module_hash(manifest, TestModule) == new_hash
     end
 
@@ -550,7 +550,7 @@ defmodule LiveStyle.Compiler.ModuleHashTest do
 
     test "module_hashes included in empty manifest" do
       manifest = Manifest.empty()
-      assert manifest.module_hashes == []
+      assert manifest.module_hashes == %{}
     end
   end
 end
diff --git a/test/live_style/css_statics_test.exs b/test/live_style/css_statics_test.exs
index bc1e21f..890214f 100644
--- a/test/live_style/css_statics_test.exs
+++ b/test/live_style/css_statics_test.exs
@@ -3,8 +3,8 @@ defmodule LiveStyle.CssStaticsTest do
   Tests for compile-time css() macro optimization.
 
   Phoenix LiveView PR #4145 expands root attr macros in the tag engine.
-  When css() returns a literal list of {:class, [class_string]} tuples,
-  the class string ends up in Rendered.static instead of being dynamic.
+  When css() returns a literal attrs list with a precomputed class payload,
+  the class string can be prepared at compile time instead of runtime.
   """
   use LiveStyle.TestCase
 
@@ -179,23 +179,55 @@ defmodule LiveStyle.CssStaticsTest do
     end
   end
 
+  defmodule ComponentParentStyles do
+    use LiveStyle
+
+    class(:override_color, color: "red")
+
+    def static_single_spread, do: css(:override_color)
+    def static_list_spread, do: css([:override_color])
+  end
+
+  defmodule ComponentChildStyles do
+    use LiveStyle
+
+    class(:base_color, color: "white")
+  end
+
+  defp class_attrs(result) do
+    assert {:class, %LiveStyle.Attrs{} = attrs} = List.keyfind(result, :class, 0)
+    attrs
+  end
+
+  defp class_string(result), do: class_attrs(result).class
+
+  defp prop_class(module, class_name, prop_name) do
+    module.__live_style__(:property_classes)
+    |> Keyword.fetch!(class_name)
+    |> Enum.find_value(fn
+      {^prop_name, class} -> class
+      _ -> nil
+    end)
+  end
+
   describe "css/1 single atom returns literal list" do
-    test "returns list of {:class, [class_string]} tuples" do
+    test "returns class attrs with merge metadata" do
       result = StaticStyles.single_ref()
       assert is_list(result)
-      assert [{:class, [class_string]}] = result
-      assert is_binary(class_string)
-      assert class_string != ""
+      attrs = class_attrs(result)
+      assert is_binary(attrs.class)
+      assert attrs.class != ""
+      assert attrs.prop_classes != nil
     end
 
     test "class string matches module's class_strings" do
-      [{:class, [class_string]}] = StaticStyles.single_ref()
+      class_string = class_string(StaticStyles.single_ref())
       expected = StaticStyles.__live_style__(:class_strings) |> Keyword.get(:button)
       assert class_string == expected
     end
 
     test "hover class contains all condition classes" do
-      [{:class, [class_string]}] = StaticStyles.single_hover()
+      class_string = class_string(StaticStyles.single_hover())
       expected = StaticStyles.__live_style__(:class_strings) |> Keyword.get(:with_hover)
       assert class_string == expected
       # Two classes: default color + :hover color
@@ -203,7 +235,7 @@ defmodule LiveStyle.CssStaticsTest do
     end
 
     test "dynamic class bare atom returns class string" do
-      [{:class, [class_string]}] = StaticStyles.dynamic_bare()
+      class_string = class_string(StaticStyles.dynamic_bare())
       expected = StaticStyles.__live_style__(:class_strings) |> Keyword.get(:dynamic_opacity)
       assert class_string == expected
     end
@@ -212,12 +244,12 @@ defmodule LiveStyle.CssStaticsTest do
   describe "css/1 list of static atoms returns literal list" do
     test "returns merged class string" do
       result = StaticStyles.list_refs()
-      assert [{:class, [class_string]}] = result
+      class_string = class_string(result)
       assert is_binary(class_string)
     end
 
     test "merged class string includes classes from all refs (no overlap)" do
-      [{:class, [merged]}] = StaticStyles.list_refs()
+      merged = class_string(StaticStyles.list_refs())
 
       # :button has display + padding, :primary has background-color + color
       # No property overlap, so all 4 classes should be present
@@ -226,7 +258,7 @@ defmodule LiveStyle.CssStaticsTest do
     end
 
     test "last-wins merging removes overridden property classes" do
-      [{:class, [merged]}] = StaticStyles.merged_overlap()
+      merged = class_string(StaticStyles.merged_overlap())
 
       # :primary has background-color + color, :secondary has background-color + color
       # Both properties overlap, so only :secondary's classes should win
@@ -248,16 +280,52 @@ defmodule LiveStyle.CssStaticsTest do
     end
   end
 
+  describe "static css component spreads" do
+    test "single atom static css carries property metadata for component merging" do
+      parent_attrs = class_attrs(ComponentParentStyles.static_single_spread())
+
+      merged =
+        LiveStyle.Runtime.resolve_attrs(
+          ComponentChildStyles,
+          [:base_color, parent_attrs],
+          nil
+        )
+
+      child_color_class = prop_class(ComponentChildStyles, :base_color, "color")
+      parent_color_class = prop_class(ComponentParentStyles, :override_color, "color")
+
+      refute child_color_class in String.split(merged.class)
+      assert parent_color_class in String.split(merged.class)
+    end
+
+    test "list static css carries property metadata for component merging" do
+      parent_attrs = class_attrs(ComponentParentStyles.static_list_spread())
+
+      merged =
+        LiveStyle.Runtime.resolve_attrs(
+          ComponentChildStyles,
+          [:base_color, parent_attrs],
+          nil
+        )
+
+      child_color_class = prop_class(ComponentChildStyles, :base_color, "color")
+      parent_color_class = prop_class(ComponentParentStyles, :override_color, "color")
+
+      refute child_color_class in String.split(merged.class)
+      assert parent_color_class in String.split(merged.class)
+    end
+  end
+
   describe "cross-module refs in list" do
     test "resolves cross-module refs at compile time" do
       result = StaticStyles.cross_module_list()
-      assert [{:class, [class_string]}] = result
+      class_string = class_string(result)
       assert is_binary(class_string)
       assert class_string != ""
     end
 
     test "cross-module merge produces correct number of classes" do
-      [{:class, [class_string]}] = StaticStyles.cross_module_list()
+      class_string = class_string(StaticStyles.cross_module_list())
 
       # shared_base has display + margin, button has display + padding
       # display overlaps (button wins since it's last), so 3 unique properties:
@@ -275,11 +343,11 @@ defmodule LiveStyle.CssStaticsTest do
       class_pair = List.keyfind(result, :class, 0)
       style_pair = List.keyfind(result, :style, 0)
 
-      assert {:class, [class_string]} = class_pair
-      assert is_binary(class_string)
-      assert class_string != ""
+      assert {:class, %LiveStyle.Attrs{} = attrs} = class_pair
+      assert is_binary(attrs.class)
+      assert attrs.class != ""
 
-      assert {:style, [style_string]} = style_pair
+      assert {:style, style_string} = style_pair
       assert is_binary(style_string)
       assert String.contains?(style_string, "0.5")
     end
@@ -293,11 +361,11 @@ defmodule LiveStyle.CssStaticsTest do
       class_pair = List.keyfind(result, :class, 0)
       style_pair = List.keyfind(result, :style, 0)
 
-      assert {:class, [class_string]} = class_pair
-      assert is_binary(class_string)
-      assert class_string != ""
+      assert {:class, %LiveStyle.Attrs{} = attrs} = class_pair
+      assert is_binary(attrs.class)
+      assert attrs.class != ""
 
-      assert {:style, [style_string]} = style_pair
+      assert {:style, style_string} = style_pair
       assert is_binary(style_string)
       assert String.contains?(style_string, "opacity")
       assert String.contains?(style_string, "0.5")
@@ -310,11 +378,11 @@ defmodule LiveStyle.CssStaticsTest do
       class_pair = List.keyfind(result, :class, 0)
       style_pair = List.keyfind(result, :style, 0)
 
-      assert {:class, [class_string]} = class_pair
-      assert is_binary(class_string)
-      assert class_string != ""
+      assert {:class, %LiveStyle.Attrs{} = attrs} = class_pair
+      assert is_binary(attrs.class)
+      assert attrs.class != ""
 
-      assert {:style, [style_string]} = style_pair
+      assert {:style, style_string} = style_pair
       assert is_binary(style_string)
       assert String.contains?(style_string, "view-transition-class:")
       assert String.contains?(style_string, "view-transition-name: my-card")
@@ -325,7 +393,7 @@ defmodule LiveStyle.CssStaticsTest do
     test "truthy branch returns merged class string" do
       result = StaticStyles.conditional_ref(true)
       assert is_list(result)
-      assert [{:class, [class_string]}] = result
+      class_string = class_string(result)
       assert is_binary(class_string)
       # :button has display + padding, :primary has background-color + color = 4 classes
       assert length(String.split(class_string)) == 4
@@ -334,7 +402,7 @@ defmodule LiveStyle.CssStaticsTest do
     test "falsy branch returns only base classes" do
       result = StaticStyles.conditional_ref(false)
       assert is_list(result)
-      assert [{:class, [class_string]}] = result
+      class_string = class_string(result)
       assert is_binary(class_string)
       # Only :button (display + padding) = 2 classes
       assert length(String.split(class_string)) == 2
@@ -345,7 +413,7 @@ defmodule LiveStyle.CssStaticsTest do
     test "truthy branch returns do-branch classes" do
       result = StaticStyles.if_else_ref(true)
       assert is_list(result)
-      assert [{:class, [class_string]}] = result
+      class_string = class_string(result)
 
       expected = StaticStyles.__live_style__(:class_strings) |> Keyword.get(:primary)
       assert MapSet.new(String.split(class_string)) == MapSet.new(String.split(expected))
@@ -354,7 +422,7 @@ defmodule LiveStyle.CssStaticsTest do
     test "falsy branch returns else-branch classes" do
       result = StaticStyles.if_else_ref(false)
       assert is_list(result)
-      assert [{:class, [class_string]}] = result
+      class_string = class_string(result)
 
       expected = StaticStyles.__live_style__(:class_strings) |> Keyword.get(:secondary)
       assert MapSet.new(String.split(class_string)) == MapSet.new(String.split(expected))
@@ -362,14 +430,14 @@ defmodule LiveStyle.CssStaticsTest do
 
     test "if/else with base class merges correctly on truthy" do
       result = StaticStyles.if_else_with_base(true)
-      assert [{:class, [class_string]}] = result
+      class_string = class_string(result)
       # :button (display + padding) + :primary (background-color + color) = 4 classes
       assert length(String.split(class_string)) == 4
     end
 
     test "if/else with base class merges correctly on falsy" do
       result = StaticStyles.if_else_with_base(false)
-      assert [{:class, [class_string]}] = result
+      class_string = class_string(result)
       # :button (display + padding) + :secondary (background-color + color) = 4 classes
       assert length(String.split(class_string)) == 4
     end
@@ -378,24 +446,24 @@ defmodule LiveStyle.CssStaticsTest do
   describe "branch optimization for case" do
     test "each branch returns correct pre-computed classes" do
       primary_result = StaticStyles.case_ref(:primary)
-      assert [{:class, [primary_class]}] = primary_result
+      primary_class = class_string(primary_result)
       expected = StaticStyles.__live_style__(:class_strings) |> Keyword.get(:primary)
       assert MapSet.new(String.split(primary_class)) == MapSet.new(String.split(expected))
 
       secondary_result = StaticStyles.case_ref(:secondary)
-      assert [{:class, [secondary_class]}] = secondary_result
+      secondary_class = class_string(secondary_result)
       expected = StaticStyles.__live_style__(:class_strings) |> Keyword.get(:secondary)
       assert MapSet.new(String.split(secondary_class)) == MapSet.new(String.split(expected))
 
       default_result = StaticStyles.case_ref(:unknown)
-      assert [{:class, [default_class]}] = default_result
+      default_class = class_string(default_result)
       expected = StaticStyles.__live_style__(:class_strings) |> Keyword.get(:button)
       assert MapSet.new(String.split(default_class)) == MapSet.new(String.split(expected))
     end
 
     test "case with base class merges correctly" do
       result = StaticStyles.case_with_base(:primary)
-      assert [{:class, [class_string]}] = result
+      class_string = class_string(result)
       # :button (display + padding) + :primary (background-color + color) = 4 classes
       assert length(String.split(class_string)) == 4
     end
@@ -404,17 +472,17 @@ defmodule LiveStyle.CssStaticsTest do
   describe "branch optimization for cond" do
     test "each branch returns correct pre-computed classes" do
       large_result = StaticStyles.cond_ref(150)
-      assert [{:class, [class_string]}] = large_result
+      class_string = class_string(large_result)
       expected = StaticStyles.__live_style__(:class_strings) |> Keyword.get(:primary)
       assert MapSet.new(String.split(class_string)) == MapSet.new(String.split(expected))
 
       medium_result = StaticStyles.cond_ref(75)
-      assert [{:class, [class_string]}] = medium_result
+      class_string = class_string(medium_result)
       expected = StaticStyles.__live_style__(:class_strings) |> Keyword.get(:secondary)
       assert MapSet.new(String.split(class_string)) == MapSet.new(String.split(expected))
 
       small_result = StaticStyles.cond_ref(10)
-      assert [{:class, [class_string]}] = small_result
+      class_string = class_string(small_result)
       expected = StaticStyles.__live_style__(:class_strings) |> Keyword.get(:button)
       assert MapSet.new(String.split(class_string)) == MapSet.new(String.split(expected))
     end
@@ -437,17 +505,17 @@ defmodule LiveStyle.CssStaticsTest do
     test "multiple && conditionals are branch-optimized" do
       # Both true: :button + :primary = 4 classes
       result = StaticStyles.two_conditionals(true, true)
-      assert [{:class, [class_string]}] = result
+      class_string = class_string(result)
       assert length(String.split(class_string)) == 4
 
       # First true only: just :button = 2 classes
       result = StaticStyles.two_conditionals(true, false)
-      assert [{:class, [class_string]}] = result
+      class_string = class_string(result)
       assert length(String.split(class_string)) == 2
 
       # Second true only: just :primary = 2 classes
       result = StaticStyles.two_conditionals(false, true)
-      assert [{:class, [class_string]}] = result
+      class_string = class_string(result)
       assert length(String.split(class_string)) == 2
 
       # Neither: empty
@@ -458,14 +526,14 @@ defmodule LiveStyle.CssStaticsTest do
     test "case + && multi-conditional is branch-optimized" do
       # :button + :primary + :with_hover
       result = StaticStyles.case_and_conditional(:primary, true)
-      assert [{:class, [class_string]}] = result
+      class_string = class_string(result)
       # button(display+padding) + primary(bg+color) + with_hover(2 color conditions)
       # display, padding, bg-color, color(last wins from with_hover's 2 classes)
       assert length(String.split(class_string)) > 2
 
       # :button + :secondary, no with_hover
       result = StaticStyles.case_and_conditional(:secondary, false)
-      assert [{:class, [class_string]}] = result
+      class_string = class_string(result)
       assert length(String.split(class_string)) > 2
     end
   end
diff --git a/test/live_style/manifest_test.exs b/test/live_style/manifest_test.exs
index 4fa91b2..7f42c33 100644
--- a/test/live_style/manifest_test.exs
+++ b/test/live_style/manifest_test.exs
@@ -2,8 +2,8 @@ defmodule LiveStyle.ManifestTest do
   @moduledoc """
   Tests for LiveStyle.Manifest structure and operations.
 
-  These tests verify the sorted list operations that ensure deterministic
-  CSS output ordering across Elixir versions.
+  These tests verify map-backed manifest operations and deterministic entry
+  traversal for CSS output across Elixir versions.
   """
   use ExUnit.Case, async: true
 
@@ -18,14 +18,14 @@ defmodule LiveStyle.ManifestTest do
     test "returns manifest with empty collections" do
       manifest = Manifest.empty()
 
-      assert manifest.vars == []
-      assert manifest.consts == []
-      assert manifest.keyframes == []
-      assert manifest.position_try == []
-      assert manifest.view_transition_classes == []
-      assert manifest.classes == []
-      assert manifest.theme_classes == []
-      assert manifest.module_hashes == []
+      assert manifest.vars == %{}
+      assert manifest.consts == %{}
+      assert manifest.keyframes == %{}
+      assert manifest.position_try == %{}
+      assert manifest.view_transition_classes == %{}
+      assert manifest.classes == %{}
+      assert manifest.theme_classes == %{}
+      assert manifest.module_hashes == %{}
     end
   end
 
@@ -57,7 +57,7 @@ defmodule LiveStyle.ManifestTest do
         |> Manifest.put_var("A.first", value: "a")
         |> Manifest.put_var("M.middle", value: "m")
 
-      keys = Enum.map(manifest.vars, fn {k, _} -> k end)
+      keys = manifest |> Manifest.entries(:vars) |> Enum.map(fn {k, _} -> k end)
       assert keys == ["A.first", "M.middle", "Z.last"]
     end
 
@@ -67,7 +67,7 @@ defmodule LiveStyle.ManifestTest do
         |> Manifest.put_var("Test.color", value: "red")
         |> Manifest.put_var("Test.color", value: "blue")
 
-      assert length(manifest.vars) == 1
+      assert Manifest.count(manifest, :vars) == 1
       assert Manifest.get_var(manifest, "Test.color") == [value: "blue"]
     end
 
@@ -92,7 +92,7 @@ defmodule LiveStyle.ManifestTest do
         |> Manifest.put_const("A.first", "a")
         |> Manifest.put_const("B.second", "b")
 
-      keys = Enum.map(manifest.consts, fn {k, _} -> k end)
+      keys = manifest |> Manifest.entries(:consts) |> Enum.map(fn {k, _} -> k end)
       assert keys == ["A.first", "B.second", "C.third"]
     end
   end
@@ -113,7 +113,7 @@ defmodule LiveStyle.ManifestTest do
         |> Manifest.put_class("A.first", [])
         |> Manifest.put_class("M.middle", [])
 
-      keys = Enum.map(manifest.classes, fn {k, _} -> k end)
+      keys = manifest |> Manifest.entries(:classes) |> Enum.map(fn {k, _} -> k end)
       assert keys == ["A.first", "M.middle", "Z.last"]
     end
   end
@@ -134,7 +134,7 @@ defmodule LiveStyle.ManifestTest do
         |> Manifest.put_keyframes("Bounce.in", [])
         |> Manifest.put_keyframes("Spin.rotate", [])
 
-      keys = Enum.map(manifest.keyframes, fn {k, _} -> k end)
+      keys = manifest |> Manifest.entries(:keyframes) |> Enum.map(fn {k, _} -> k end)
       assert keys == ["Bounce.in", "Fade.out", "Spin.rotate"]
     end
   end
@@ -156,7 +156,7 @@ defmodule LiveStyle.ManifestTest do
       result = Manifest.ensure_keys(old_manifest)
 
       assert result.version == Manifest.current_version()
-      assert result.vars == []
+      assert result.vars == %{}
     end
 
     test "preserves data for current version" do
@@ -213,8 +213,8 @@ defmodule LiveStyle.ManifestTest do
         |> Manifest.put_var("C.c", value: "c")
         |> Manifest.put_var("A.a", value: "a")
 
-      assert manifest1.vars == manifest2.vars
-      assert manifest2.vars == manifest3.vars
+      assert Manifest.entries(manifest1, :vars) == Manifest.entries(manifest2, :vars)
+      assert Manifest.entries(manifest2, :vars) == Manifest.entries(manifest3, :vars)
     end
 
     test "multiple puts maintain consistent order" do
@@ -225,7 +225,7 @@ defmodule LiveStyle.ManifestTest do
           Manifest.put_var(acc, key, value: "#{i}")
         end)
 
-      keys = Enum.map(manifest.vars, fn {k, _} -> k end)
+      keys = manifest |> Manifest.entries(:vars) |> Enum.map(fn {k, _} -> k end)
 
       # Keys should be sorted
       assert keys == Enum.sort(keys)
diff --git a/test/live_style/property_validation_test.exs b/test/live_style/property_validation_test.exs
new file mode 100644
index 0000000..a8b0063
--- /dev/null
+++ b/test/live_style/property_validation_test.exs
@@ -0,0 +1,29 @@
+defmodule LiveStyle.PropertyValidationTest do
+  use ExUnit.Case, async: true
+
+  alias LiveStyle.Class.Processor
+
+  describe "conditional property validation" do
+    test "raises for unknown conditional property when configured as error" do
+      assert_raise CompileError, ~r/Unknown CSS property 'opactiy'/, fn ->
+        Processor.Conditional.transform(
+          [opactiy: [default: "1", ":hover": "0.5"]],
+          level: :error,
+          file: "test.ex",
+          line: 1
+        )
+      end
+    end
+
+    test "raises for unknown pseudo-element property when configured as error" do
+      assert_raise CompileError, ~r/Unknown CSS property 'opactiy'/, fn ->
+        Processor.PseudoElement.transform(
+          ["::before": [opactiy: "1"]],
+          level: :error,
+          file: "test.ex",
+          line: 1
+        )
+      end
+    end
+  end
+end
diff --git a/test/live_style/storage_test.exs b/test/live_style/storage_test.exs
index 3d2f99d..fed0d58 100644
--- a/test/live_style/storage_test.exs
+++ b/test/live_style/storage_test.exs
@@ -6,6 +6,7 @@ defmodule LiveStyle.StorageTest do
   """
   use ExUnit.Case, async: false
 
+  alias LiveStyle.Compiler.ModuleData
   alias LiveStyle.{Manifest, Storage}
 
   @test_manifest_path "test/tmp/test_manifest.etf"
@@ -32,8 +33,8 @@ defmodule LiveStyle.StorageTest do
       manifest = Storage.read()
 
       assert manifest.version == Manifest.current_version()
-      assert manifest.vars == []
-      assert manifest.classes == []
+      assert manifest.vars == %{}
+      assert manifest.classes == %{}
     end
 
     test "write and read roundtrip preserves data" do
@@ -70,7 +71,7 @@ defmodule LiveStyle.StorageTest do
       Storage.clear()
       # File is recreated with empty manifest
       manifest = Storage.read()
-      assert manifest.vars == []
+      assert manifest.vars == %{}
     end
   end
 
@@ -93,7 +94,7 @@ defmodule LiveStyle.StorageTest do
                "var#{i} should exist in manifest"
       end
 
-      assert length(manifest.vars) == 10
+      assert Manifest.count(manifest, :vars) == 10
     end
 
     test "parallel updates don't lose data" do
@@ -209,7 +210,68 @@ defmodule LiveStyle.StorageTest do
 
       # Should return fresh manifest, not old data
       assert manifest.version == Manifest.current_version()
-      assert manifest.vars == []
+      assert manifest.vars == %{}
     end
   end
+
+  describe "stale module data cleanup" do
+    test "merge_module_data removes entries for deleted source files" do
+      module = LiveStyle.StorageTest.DeletedSourceModule
+      source = "test/tmp/deleted_source_module.ex"
+      key = Manifest.key(module, :stale_class)
+
+      ModuleData.write(module, %{
+        module: module,
+        source: source,
+        classes: [{key, [class_string: "x-stale", atomic_classes: []]}]
+      })
+
+      assert File.exists?(module_data_path(module))
+
+      Storage.merge_module_data()
+
+      refute File.exists?(module_data_path(module))
+      refute Manifest.get_class(Storage.read(), key)
+    end
+
+    test "merge_module_data removes entries when source no longer uses LiveStyle" do
+      module = LiveStyle.StorageTest.NoLongerLiveStyle
+      source = "test/tmp/no_longer_live_style.ex"
+      key = Manifest.key(module, :stale_class)
+
+      File.write!(source, """
+      defmodule LiveStyle.StorageTest.NoLongerLiveStyle do
+        def plain, do: :ok
+      end
+      """)
+
+      ModuleData.write(module, %{
+        module: module,
+        source: source,
+        classes: [{key, [class_string: "x-stale", atomic_classes: []]}]
+      })
+
+      Storage.merge_module_data()
+
+      refute File.exists?(module_data_path(module))
+      refute Manifest.get_class(Storage.read(), key)
+    end
+
+    test "cleanup_stale_usage removes usage for inactive consumers" do
+      consumer = LiveStyle.StorageTest.DeletedConsumer
+      defining = LiveStyle.StorageTest.DefiningStyles
+
+      ModuleData.record_usage(consumer, defining, :button)
+      assert MapSet.member?(ModuleData.collect_all_usage(), {defining, :button})
+
+      Storage.merge_module_data()
+
+      refute MapSet.member?(ModuleData.collect_all_usage(), {defining, :button})
+    end
+  end
+
+  defp module_data_path(module) do
+    hash = :crypto.hash(:md5, inspect(module)) |> Base.encode16(case: :lower)
+    Path.join(ModuleData.modules_dir(), "#{hash}.etf")
+  end
 end