impl<T> From<T> for PatternPolicy
 where
     T: AsRef<str>,
 {
     fn from(value: T) -> Self {
-        match value.as_ref() {
-            "DropField" => Self::DropField,
-            "Redact" => Self::Redact,
-            "Hash" => Self::Hash,
+        match value.as_ref().to_ascii_lowercase().as_str() {
+            "dropfield" => Self::DropField,
+            "redact" => Self::Redact,
+            "hash" => Self::Hash,
             _ => Self::Redact,
         }
     }
 }

 let pattern = req.pattern;
 let inputs = req.test_records;
 // Default to Redact if policy not specified for backward compatibility
-let policy = req.policy.as_ref().map(|p| p.as_str()).unwrap_or("Redact");
-let policy = PatternPolicy::from(policy);
+let policy_str = req
+    .policy
+    .as_deref()
+    .map(|p| p.trim())
+    .filter(|p| !p.is_empty())
+    .unwrap_or("Redact");
+let policy = PatternPolicy::from(policy_str);

 fn check_re_pattern_config(cfg: &mut Config) -> Result<(), anyhow::Error> {
-    // Ensure hash_length is within valid range (minimum 12, maximum 64)
+    // Clamp hash_length to [12, 64] and warn instead of erroring
     if cfg.re_pattern.hash_length < 12 {
-        return Err(anyhow::anyhow!(
-            "ZO_RE_PATTERN_HASH_LENGTH must be at least 12 characters (configured: {})",
+        log::warn!(
+            "ZO_RE_PATTERN_HASH_LENGTH too small ({}). Using minimum 12.",
             cfg.re_pattern.hash_length
-        ));
-    }
-    if cfg.re_pattern.hash_length > 64 {
-        return Err(anyhow::anyhow!(
-            "ZO_RE_PATTERN_HASH_LENGTH must be at most 64 characters (configured: {})",
+        );
+        cfg.re_pattern.hash_length = 12;
+    } else if cfg.re_pattern.hash_length > 64 {
+        log::warn!(
+            "ZO_RE_PATTERN_HASH_LENGTH too large ({}). Using maximum 64.",
             cfg.re_pattern.hash_length
-        ));
+        );
+        cfg.re_pattern.hash_length = 64;
     }
     Ok(())
 }