claude: fix surrogate exclusion in exclude_categories and add coverage tests

CharactersGenerator::exclude_categories was replacing the default Cs
(surrogate) exclusion, allowing the server to generate surrogate code
points that cannot be represented as valid UTF-8 in Rust. Now Cs is
always included in the exclusion list.

Also adds tests for uncovered code paths: CharactersGenerator::as_basic,
TextGenerator::exclude_categories/include_characters, and value.rs
ciborium::Value::Text conversion and tag-6 error handling.

Author: Liam-DeVoe

src/generators/strings.rs

@@ -42,8 +42,15 @@ impl CharactersGenerator {
 
     /// Exclude characters from these Unicode categories.
     /// Mutually exclusive with [`categories`](Self::categories).
+    ///
+    /// The `Cs` (surrogate) category is always excluded because Rust strings
+    /// must be valid UTF-8 and cannot represent surrogate code points.
     pub fn exclude_categories(mut self, cats: &[&str]) -> Self {
-        self.exclude_categories = Some(cats.iter().map(|s| s.to_string()).collect());
+        let mut all: Vec<String> = cats.iter().map(|s| s.to_string()).collect();
+        if !all.iter().any(|c| c == "Cs") {
+            all.push("Cs".to_string());
+        }
+        self.exclude_categories = Some(all);
         self.categories = None;
         self
     }

tests/embedded/generators/value_tests.rs

@@ -94,6 +94,31 @@ fn test_from_ciborium_array_with_nan() {
     assert!(result[3].is_infinite() && result[3].is_sign_negative());
 }
 
+#[test]
+fn test_from_ciborium_text() {
+    let cbor = ciborium::Value::Text("hello".to_string());
+    let hegel = HegelValue::from(cbor);
+    if let HegelValue::String(s) = hegel {
+        assert_eq!(s, "hello");
+    } else {
+        panic!("expected String");
+    }
+}
+
+#[test]
+#[should_panic(expected = "Expected Bytes inside string tag 6")]
+fn test_from_ciborium_tag6_non_bytes() {
+    let cbor = ciborium::Value::Tag(6, Box::new(ciborium::Value::Text("not bytes".to_string())));
+    let _ = HegelValue::from(cbor);
+}
+
+#[test]
+#[should_panic(expected = "Expected valid UTF-8 string")]
+fn test_from_ciborium_tag6_invalid_utf8() {
+    let cbor = ciborium::Value::Tag(6, Box::new(ciborium::Value::Bytes(vec![0xFF])));
+    let _ = HegelValue::from(cbor);
+}
+
 #[test]
 fn test_deserialize_struct() {
     #[derive(serde::Deserialize, Debug)]

tests/test_strings.rs

@@ -105,6 +105,25 @@ fn test_text_categories() {
     });
 }
 
+#[test]
+fn test_text_exclude_categories() {
+    assert_all_examples(
+        gs::text().exclude_categories(&["Lu"]).max_size(20),
+        |s: &String| s.chars().all(|c| !c.is_uppercase()),
+    );
+}
+
+#[test]
+fn test_text_include_characters() {
+    assert_all_examples(
+        gs::text()
+            .categories(&[])
+            .include_characters("xyz")
+            .max_size(20),
+        |s: &String| s.chars().all(|c| "xyz".contains(c)),
+    );
+}
+
 #[hegel::test]
 fn test_text_exclude_characters(tc: hegel::TestCase) {
     let exclude = tc.draw(gs::text().codec("ascii"));

tests/test_validation.rs

@@ -1,5 +1,11 @@
 use hegel::generators::{self as gs, Generator};
 
+#[test]
+fn test_characters_as_basic() {
+    let g = gs::characters();
+    assert!(g.as_basic().is_some());
+}
+
 #[test]
 #[should_panic(expected = "max_value < min_value")]
 fn test_integers_min_greater_than_max() {