fix(extractor): preserve styled creation and qualify naming coverage

Preserve whole styled argument creation-time evaluation and qualify the inherited naming/extractor coverage union, including sticky getCss proof.

Refs #694

Ultraworked with [Sisyphus](https://github.com/code-yeongyu/oh-my-openagent)

Co-authored-by: Sisyphus <clio-agent@sisyphuslabs.ai>

Author: owjs3901

.changepacks/changepack_log_styled_creation.json

@@ -0,0 +1,7 @@
+{
+  "changes": {
+    "bindings/devup-ui-wasm/package.json": "Patch"
+  },
+  "note": "Evaluate supported conditional styled rule arguments once when the component is created, preserving branch laziness, authored field order, static selectors and layers, typography and runtime value associations. Keep rule capture outside attrs wrappers while authored attrs callbacks remain render-time. Responsive typography retains its shared base class and order-aware class selection without introducing empty styles for proven inert base-preset lookups. This scheduling repair adds no build errors or styling runtime.",
+  "date": "2026-10-07T00:00:00.000Z"
+}

bindings/devup-ui-wasm/src/cache_admission_tests.rs

@@ -2,10 +2,14 @@ use super::*;
 
 #[path = "cache_allocator_tests.rs"]
 mod allocators;
+#[path = "cache_naming_coverage_tests.rs"]
+mod naming_coverage;
 #[path = "cache_reset_tests.rs"]
 mod resets;
 #[path = "cache_seed_tests.rs"]
 mod seeds;
+#[path = "cache_typography_coverage_tests.rs"]
+mod typography_coverage;
 
 fn fresh() {
     reset_build_state_internal();

bindings/devup-ui-wasm/src/cache_allocator_proof.rs

@@ -23,26 +23,23 @@ fn counter_label(number: usize) -> String {
     }
 }
 
-fn variable_owner(value: &str, prefix: &str, owner: u32) -> bool {
+fn variable_owner(value: &str, prefix: &str, owner_label: &str) -> bool {
     let variable = value.strip_prefix("var(").and_then(|value| {
         value
             .strip_suffix(')')
             .or_else(|| value.strip_suffix(") !important"))
     });
-    let Ok(owner) = usize::try_from(owner) else {
-        return false;
-    };
-    let mut number = counter_label(owner);
+    let mut number = owner_label.to_string();
     number.retain(|character| character != '-');
     variable.is_some_and(|variable| variable.starts_with(&format!("---{prefix}S{number}-")))
 }
 
 fn declaration_matches(
     property: &StyleSheetProperty,
     position: (u8, u8),
-    slot: (&str, u32),
+    slot: (&str, &str),
 ) -> bool {
-    let (key, owner) = slot;
+    let (key, owner_label) = slot;
     let prefix = css::get_prefix().unwrap_or_default();
     [false, true].into_iter().any(|dynamic| {
         let content = AtomContent {
@@ -57,7 +54,7 @@ fn declaration_matches(
         }
         .content();
         css::atom_name::hex(&content.lossless) == key
-            && (!dynamic || variable_owner(&property.value, &prefix, owner))
+            && (!dynamic || variable_owner(&property.value, &prefix, owner_label))
     })
 }
 
@@ -112,7 +109,11 @@ pub(super) fn validate(sheet: &StyleSheet, classes: &ClassMap) -> bool {
                                     other.owner_reset && other.class_name == property.class_name
                                 });
                                 (!owns_reset || key.starts_with("642d"))
-                                    && declaration_matches(property, (*level, *order), (key, owner))
+                                    && declaration_matches(
+                                        property,
+                                        (*level, *order),
+                                        (key, &owner_label),
+                                    )
                             }
                     })
                 })

bindings/devup-ui-wasm/src/cache_names.rs

@@ -165,6 +165,7 @@ mod tests {
             "OHshort",
             "OLlonger_than_sixteen_payload",
             "prefix-L",
+            "OXred",
         ] {
             assert!(!content_name(name), "{name}");
         }

bindings/devup-ui-wasm/src/cache_naming_coverage_tests.rs

@@ -0,0 +1,109 @@
+use super::*;
+
+#[rstest]
+#[case(0)]
+#[case(30)]
+#[serial]
+fn dynamic_counter_owner_round_trip_keeps_the_validated_label(#[case] owner: usize) {
+    // Given: real dynamic declarations at the plain and ad-blocker owner-label boundaries.
+    let configure = || {
+        fresh();
+        set_prefix(Some("du-FLa-".into()));
+        seed_file_map((0..=owner).map(|id| format!("{id:02}.tsx")).collect());
+    };
+    configure();
+    let file = format!("{owner:02}.tsx");
+    let source = "import {Box} from '@devup-ui/react';export const x=(p)=><Box color={p.color}/>;";
+    let cold = output(&file, source, false);
+    let value = snapshot();
+    assert!(cold.2.contains("color:var(---du-FLa-S"), "{}", cold.2);
+    configure();
+    // When: current admission reuses the already validated owner label for variable proof.
+    assert_eq!(import(value.clone()), Ok(()));
+    // Then: the complete allocator/reset/declaration snapshot and full output round trip.
+    assert_eq!(snapshot(), value);
+    assert_eq!(output(&file, source, false), cold);
+    fresh();
+}
+
+#[test]
+#[serial]
+fn hoisted_declaration_without_bucket_proof_is_cold() {
+    // Given: a genuine current atom whose stored placement falsely claims hoisting.
+    fresh();
+    let source = "import {Box} from '@devup-ui/react';export const x=<Box color='red'/>;";
+    let cold = output("fresh.tsx", source, false);
+    let mut value = snapshot();
+    value["properties"]["fresh.tsx"]["255"]["0"][0]["h"] = true.into();
+    fresh();
+    let before = snapshot();
+    companions(&value);
+    // When: admission checks actual placement against the frozen plan.
+    assert_eq!(import(value), Ok(()));
+    // Then: the entire snapshot remains cold and extraction remains usable.
+    assert_eq!(snapshot(), before);
+    assert_eq!(output("fresh.tsx", source, false), cold);
+    fresh();
+}
+
+#[test]
+#[serial]
+fn invalid_manual_generated_claim_does_not_replace_live_sheet() {
+    // Given: authored manual controls plus a generated-looking name lacking its claim.
+    fresh();
+    let mut live = StyleSheet::default();
+    live.add_property(
+        "manual-card",
+        "color",
+        0,
+        "red",
+        None,
+        None,
+        Some("fresh.tsx"),
+    );
+    assert_eq!(import_sheet_internal(live), Ok(()));
+    let before = snapshot();
+    let css = with_style_sheet(|sheet| sheet.create_css(Some("fresh.tsx"), false));
+    assert!(
+        css.contains(&format!(".manual-card{{color:{}}}", "red")),
+        "{css}"
+    );
+    let mut incoming = StyleSheet::default();
+    incoming.add_property("OLcolor-vblue", "color", 0, "blue", None, Some(0), None);
+    // When: in-memory manual import still enforces the generated-name contract.
+    assert_eq!(import_sheet_internal(incoming), Ok(()));
+    // Then: authored controls stay intact and the rejected claim is not sticky.
+    assert_eq!(snapshot(), before);
+    assert_eq!(
+        with_style_sheet(|sheet| sheet.create_css(Some("fresh.tsx"), false)),
+        css
+    );
+    assert_eq!(cache_names::check(), Ok(()));
+    fresh();
+}
+
+#[test]
+#[serial]
+fn wrong_keyframe_descriptor_variant_is_cold() {
+    // Given: actual keyframe output, with an atom variant substituted in the frame proof.
+    fresh();
+    let source = "import {keyframes} from '@devup-ui/react';export const x=keyframes({from:{opacity:0},to:{opacity:1}});";
+    let cold = output("fresh.tsx", source, false);
+    let mut value = snapshot();
+    let claim = value["names"]
+        .as_object_mut()
+        .unwrap_or_else(|| panic!("names object"))
+        .iter_mut()
+        .find(|(name, _)| name.starts_with('K'))
+        .unwrap_or_else(|| panic!("keyframe claim"))
+        .1;
+    claim["descriptor"][1] = 1.into();
+    fresh();
+    let before = snapshot();
+    // When: exact frame decoding rejects the wrong semantic variant.
+    assert_eq!(import(value), Ok(()));
+    // Then: no cached state is installed and complete binding output is cold.
+    assert_eq!(snapshot(), before);
+    assert_eq!(output("fresh.tsx", source, false), cold);
+    fresh();
+}

bindings/devup-ui-wasm/src/cache_typography_coverage_tests.rs

@@ -0,0 +1,158 @@
+use super::*;
+
+#[path = "cache_typography_descriptor_tests.rs"]
+mod descriptors;
+
+fn configure(numbered: bool) {
+    fresh();
+    register_theme_internal(
+        serde_json::from_value(serde_json::json!({
+            "typography":{"body":[{"fontSize":"14px","fontFamily":"Sans"},null,{"fontSize":"18px"}]}
+        }))
+        .unwrap_or_else(|error| panic!("{error}")),
+    );
+    if numbered {
+        seed_file_map(vec!["fresh.tsx".into()]);
+    }
+}
+
+fn source(responsive: bool) -> &'static str {
+    if responsive {
+        "import {Box} from '@devup-ui/react';export const x=<Box _hover={[null,null,{typography:'body'}]}/>;"
+    } else {
+        "import {Box} from '@devup-ui/react';export const x=<Box _hover={{typography:'body'}}/>;"
+    }
+}
+
+#[rstest]
+#[serial]
+fn current_typography_restores_exact_state_without_fresh_theme_authority(
+    #[values(false, true)] numbered: bool,
+    #[values(false, true)] responsive: bool,
+    #[values(false, true)] matching: bool,
+) {
+    // Given: actual preset expansion, including the original-owner counter path.
+    configure(numbered);
+    let cold = output("fresh.tsx", source(responsive), false);
+    let value = snapshot();
+    assert!(cold.2.contains("font-size:18px"), "{}", cold.2);
+    if numbered {
+        assert!(cold.0.contains("a-a"), "{}", cold.0);
+        assert_eq!(
+            value["classMap"]["D9-0"]
+                .as_object()
+                .unwrap_or_else(|| panic!("counter class map"))
+                .len(),
+            1
+        );
+    }
+    fresh();
+    let configured_theme = with_style_sheet(|sheet| sheet.theme.typography.len());
+    if matching {
+        companions(&value);
+    }
+    // When: the cache alone proves its declarations with no current preset available.
+    assert_eq!(import(value.clone()), Ok(()));
+    // Then: this is admission, not a silent cold miss, and fresh theme stays fresh.
+    assert_eq!(snapshot(), value);
+    assert_eq!(
+        with_style_sheet(|sheet| sheet.theme.typography.len()),
+        configured_theme
+    );
+    assert_eq!(
+        with_style_sheet(|sheet| sheet.create_css(Some("fresh.tsx"), false)),
+        cold.2
+    );
+    register_theme_internal(
+        serde_json::from_value(serde_json::json!({
+            "typography":{"body":[{"fontSize":"14px","fontFamily":"Sans"},null,{"fontSize":"18px"}]}
+        }))
+        .unwrap_or_else(|error| panic!("{error}")),
+    );
+    assert_eq!(output("fresh.tsx", source(responsive), false), cold);
+    fresh();
+}
+
+#[rstest]
+#[serial]
+fn corrupt_typography_declarations_are_cold_not_sticky(
+    #[values(false, true)] numbered: bool,
+    #[values(false, true)] responsive: bool,
+) {
+    // Given: a real cache with one expanded declaration changed but its identity retained.
+    configure(numbered);
+    let cold = output("fresh.tsx", source(responsive), false);
+    let mut value = snapshot();
+    let mut changed = false;
+    for orders in value["properties"]
+        .as_object_mut()
+        .unwrap_or_else(|| panic!("properties object"))
+        .values_mut()
+    {
+        for levels in orders
+            .as_object_mut()
+            .unwrap_or_else(|| panic!("orders object"))
+            .values_mut()
+        {
+            for properties in levels
+                .as_object_mut()
+                .unwrap_or_else(|| panic!("levels object"))
+                .values_mut()
+            {
+                for property in properties
+                    .as_array_mut()
+                    .unwrap_or_else(|| panic!("declaration array"))
+                {
+                    if property["t"] == true && property["p"] == "font-size" {
+                        property["v"] = "99px".into();
+                        changed = true;
+                    }
+                }
+            }
+        }
+    }
+    assert!(changed);
+    configure(numbered);
+    let before = snapshot();
+    companions(&value);
+    // When: matching companions cannot excuse the corrupt declaration proof.
+    assert_eq!(import(value), Ok(()));
+    // Then: state and complete JS/global/local CSS are independently cold; no error latched.
+    assert_eq!(snapshot(), before);
+    assert_eq!(output("fresh.tsx", source(responsive), false), cold);
+    assert_eq!(cache_names::check(), Ok(()));
+    fresh();
+}
+
+#[rstest]
+#[case("g0")]
+#[case("0g")]
+#[case("0")]
+#[serial]
+fn malformed_counter_identity_is_cold_with_matching_companions(#[case] key: &str) {
+    // Given: a real current counter typography cache with a non-hex or truncated slot key.
+    configure(true);
+    let cold = output("fresh.tsx", source(false), false);
+    let mut value = snapshot();
+    let classes = value["classMap"]["D9-0"]
+        .as_object_mut()
+        .unwrap_or_else(|| panic!("counter class map"));
+    let previous = classes
+        .keys()
+        .next()
+        .cloned()
+        .unwrap_or_else(|| panic!("counter slot key"));
+    let slot = classes
+        .remove(&previous)
+        .unwrap_or_else(|| panic!("counter slot value"));
+    classes.insert(key.into(), slot);
+    configure(true);
+    let before = snapshot();
+    companions(&value);
+    // When: the malformed identity reaches the counter proof itself.
+    assert_eq!(import(value), Ok(()));
+    // Then: no partial adoption or false collision, with full cold output preserved.
+    assert_eq!(snapshot(), before);
+    assert_eq!(output("fresh.tsx", source(false), false), cold);
+    fresh();
+}