From 167b8ceffba5875bd2389ec0475b5fa05de7ed76 Mon Sep 17 00:00:00 2001
From: Santiago Carot-Nemesio <sancane@gmail.com>
Date: Sun, 8 Feb 2026 15:26:08 +0100
Subject: [PATCH 1/6] Add cargo-fuzz

---
 .gitignore                                    |   6 +
 CONTRIBUTING.md                               |  54 ++
 Cargo.toml                                    |   1 +
 FUZZING.md                                    | 632 ++++++++++++++++++
 README.md                                     |  29 +
 precis-core/fuzz/.gitignore                   |   4 +
 precis-core/fuzz/Cargo.toml                   |  64 ++
 .../fuzz_targets/freeform_class_allows.rs     |  16 +
 .../fuzz_targets/freeform_class_codepoint.rs  |  25 +
 .../fuzz_targets/freeform_class_get_value.rs  |  16 +
 .../fuzz_targets/identifier_class_allows.rs   |  16 +
 .../identifier_class_codepoint.rs             |  25 +
 .../identifier_class_get_value.rs             |  16 +
 precis-profiles/fuzz/.gitignore               |   4 +
 precis-profiles/fuzz/Cargo.toml               | 123 ++++
 .../fuzz/fuzz_targets/nickname_arbitrary.rs   |  19 +
 .../fuzz/fuzz_targets/nickname_compare.rs     |  23 +
 .../fuzz/fuzz_targets/nickname_enforce.rs     |  14 +
 .../fuzz/fuzz_targets/nickname_prepare.rs     |  14 +
 .../fuzz_targets/opaque_string_compare.rs     |  23 +
 .../fuzz_targets/opaque_string_enforce.rs     |  14 +
 .../fuzz_targets/opaque_string_prepare.rs     |  14 +
 .../fuzz/fuzz_targets/username_casemapped.rs  |  14 +
 .../username_casemapped_compare.rs            |  23 +
 .../username_casemapped_prepare.rs            |  14 +
 .../fuzz_targets/username_casepreserved.rs    |  14 +
 .../username_casepreserved_compare.rs         |  23 +
 .../username_casepreserved_prepare.rs         |  14 +
 28 files changed, 1254 insertions(+)
 create mode 100644 FUZZING.md
 create mode 100644 precis-core/fuzz/.gitignore
 create mode 100644 precis-core/fuzz/Cargo.toml
 create mode 100644 precis-core/fuzz/fuzz_targets/freeform_class_allows.rs
 create mode 100644 precis-core/fuzz/fuzz_targets/freeform_class_codepoint.rs
 create mode 100644 precis-core/fuzz/fuzz_targets/freeform_class_get_value.rs
 create mode 100644 precis-core/fuzz/fuzz_targets/identifier_class_allows.rs
 create mode 100644 precis-core/fuzz/fuzz_targets/identifier_class_codepoint.rs
 create mode 100644 precis-core/fuzz/fuzz_targets/identifier_class_get_value.rs
 create mode 100644 precis-profiles/fuzz/.gitignore
 create mode 100644 precis-profiles/fuzz/Cargo.toml
 create mode 100644 precis-profiles/fuzz/fuzz_targets/nickname_arbitrary.rs
 create mode 100644 precis-profiles/fuzz/fuzz_targets/nickname_compare.rs
 create mode 100644 precis-profiles/fuzz/fuzz_targets/nickname_enforce.rs
 create mode 100644 precis-profiles/fuzz/fuzz_targets/nickname_prepare.rs
 create mode 100644 precis-profiles/fuzz/fuzz_targets/opaque_string_compare.rs
 create mode 100644 precis-profiles/fuzz/fuzz_targets/opaque_string_enforce.rs
 create mode 100644 precis-profiles/fuzz/fuzz_targets/opaque_string_prepare.rs
 create mode 100644 precis-profiles/fuzz/fuzz_targets/username_casemapped.rs
 create mode 100644 precis-profiles/fuzz/fuzz_targets/username_casemapped_compare.rs
 create mode 100644 precis-profiles/fuzz/fuzz_targets/username_casemapped_prepare.rs
 create mode 100644 precis-profiles/fuzz/fuzz_targets/username_casepreserved.rs
 create mode 100644 precis-profiles/fuzz/fuzz_targets/username_casepreserved_compare.rs
 create mode 100644 precis-profiles/fuzz/fuzz_targets/username_casepreserved_prepare.rs

diff --git a/.gitignore b/.gitignore
index 635461e..df04af5 100644
--- a/.gitignore
+++ b/.gitignore
@@ -5,3 +5,9 @@ Cargo.lock
 
 # Property-based testing regression files
 **/proptest-regressions/
+
+# Fuzzing artifacts and corpus
+**/fuzz/target/
+**/fuzz/corpus/
+**/fuzz/artifacts/
+**/fuzz/coverage/
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 1ca816c..756b497 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -355,6 +355,60 @@ cargo test -- --nocapture
 cargo tarpaulin --workspace --exclude precis-tools --timeout 120 --out Html
 ```
 
+## Fuzzing
+
+Fuzzing is an automated testing technique that generates random inputs to discover bugs, panics, and edge cases.
+
+### When to Run Fuzzing
+
+Run fuzzing when:
+- Adding new profile implementations
+- Modifying string processing logic
+- Investigating potential edge cases
+- Before major releases
+
+### Quick Start
+
+```bash
+# Install cargo-fuzz
+cargo install cargo-fuzz
+
+# Run fuzzing for 60 seconds
+cd precis-profiles
+cargo +nightly fuzz run nickname_enforce -- -max_total_time=60
+
+# List available targets
+cargo +nightly fuzz list
+```
+
+### Available Fuzz Targets
+
+The project has **19 fuzz targets** covering:
+
+**precis-core (6 targets):**
+- FreeformClass and IdentifierClass: `allows()`, `get_value_from_char()`, `get_value_from_codepoint()`
+
+**precis-profiles (13 targets):**
+- **Nickname**: enforce, prepare, compare, arbitrary (invalid UTF-8)
+- **OpaqueString**: enforce, prepare, compare
+- **UsernameCaseMapped**: enforce, prepare, compare
+- **UsernameCasePreserved**: enforce, prepare, compare
+
+### If Fuzzing Finds a Bug
+
+1. Crash artifacts are saved to `fuzz/artifacts/`
+2. Create a minimal unit test reproducing the issue
+3. Fix the bug
+4. Verify the fix with the same input
+5. Keep the corpus (it found a real bug!)
+
+See [FUZZING.md](FUZZING.md) for complete fuzzing guide including:
+- Detailed target descriptions
+- Advanced fuzzing options
+- Corpus management
+- CI/CD integration
+- Troubleshooting
+
 ## Benchmarking
 
 ### When to Add Benchmarks
diff --git a/Cargo.toml b/Cargo.toml
index cc87745..eabec00 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -2,6 +2,7 @@
 resolver = "2"
 
 members = ["precis-core", "precis-profiles", "precis-tools"]
+exclude = ["precis-core/fuzz", "precis-profiles/fuzz"]
 
 [workspace.dependencies]
 precis-core = { path = "precis-core" }
diff --git a/FUZZING.md b/FUZZING.md
new file mode 100644
index 0000000..2cd5f69
--- /dev/null
+++ b/FUZZING.md
@@ -0,0 +1,632 @@
+# Fuzzing Guide
+
+This document explains how to use fuzzing to discover bugs, panics, and edge cases in the PRECIS implementation.
+
+## What is Fuzzing?
+
+Fuzzing is an automated testing technique that provides random or semi-random data to functions to discover:
+- Panics and crashes
+- Assertion failures
+- Undefined behavior
+- Edge cases not covered by unit tests
+- Performance issues (slow inputs)
+
+## Prerequisites
+
+**Requirements:**
+- Rust nightly toolchain
+- cargo-fuzz installed
+
+**Installation:**
+```bash
+# Install nightly toolchain (if not already installed)
+rustup install nightly
+
+# Install cargo-fuzz
+cargo install cargo-fuzz
+```
+
+## Available Fuzz Targets
+
+The project has **19 fuzz targets** across two crates:
+
+### precis-core Targets (6 targets)
+
+Located in `precis-core/fuzz/fuzz_targets/`:
+
+#### **freeform_class_allows** - FreeformClass::allows()
+Tests string validation with the permissive FreeformClass.
+
+**What it tests:**
+- Character classification (LetterDigits, Symbols, Punctuation, etc.)
+- Full string validation
+- Edge cases in derived property algorithm
+
+#### **freeform_class_get_value** - FreeformClass::get_value_from_char()
+Tests per-character classification.
+
+**What it tests:**
+- Individual character property lookup
+- All Unicode codepoint categories
+- Character boundary cases
+
+#### **freeform_class_codepoint** - FreeformClass::get_value_from_codepoint()
+Tests codepoint-based classification with raw u32 values.
+
+**What it tests:**
+- Invalid codepoint handling (> U+10FFFF)
+- Surrogate pairs (U+D800-U+DFFF)
+- Unassigned codepoints
+- All valid codepoint ranges
+
+#### **identifier_class_allows** - IdentifierClass::allows()
+Tests string validation with the strict IdentifierClass.
+
+**What it tests:**
+- Stricter validation rules vs FreeformClass
+- Identifier-specific character restrictions
+- Full string validation
+
+#### **identifier_class_get_value** - IdentifierClass::get_value_from_char()
+Tests per-character classification for identifiers.
+
+**What it tests:**
+- Character classification differences vs FreeformClass
+- Identifier-specific rules
+- Character boundary cases
+
+#### **identifier_class_codepoint** - IdentifierClass::get_value_from_codepoint()
+Tests codepoint-based classification for identifiers.
+
+**What it tests:**
+- Invalid codepoint handling
+- Identifier-specific codepoint restrictions
+- All codepoint ranges
+
+### precis-profiles Targets (13 targets)
+
+Located in `precis-profiles/fuzz/fuzz_targets/`:
+
+#### Nickname Profile (4 targets)
+
+**nickname_enforce** - Nickname::enforce()
+- Space trimming with various Unicode spaces
+- Width mapping edge cases
+- BiDi rule validation
+- Unicode normalization
+
+**nickname_prepare** - Nickname::prepare()
+- Preparation without enforcement
+- Normalization edge cases
+- Width mapping
+
+**nickname_compare** - Nickname::compare()
+- Case-insensitive comparison
+- Normalization equivalence
+- Comparison of edge cases
+
+**nickname_arbitrary** - Nickname with invalid UTF-8
+- Invalid UTF-8 handling
+- Multibyte character boundaries
+- Lossy conversion edge cases
+
+#### OpaqueString Profile (3 targets)
+
+**opaque_string_enforce** - OpaqueString::enforce()
+- Password normalization
+- Unicode in passwords
+- Special character handling
+
+**opaque_string_prepare** - OpaqueString::prepare()
+- Password preparation
+- Normalization rules
+- Unicode handling
+
+**opaque_string_compare** - OpaqueString::compare()
+- Password comparison
+- Case-sensitive matching
+- Normalization equivalence
+
+#### UsernameCaseMapped Profile (3 targets)
+
+**username_casemapped** - UsernameCaseMapped::enforce()
+- Case mapping edge cases
+- International usernames
+- Username validation rules
+
+**username_casemapped_prepare** - UsernameCaseMapped::prepare()
+- Case folding
+- Normalization
+- Width mapping
+
+**username_casemapped_compare** - UsernameCaseMapped::compare()
+- Case-insensitive username comparison
+- Normalization equivalence
+- International character handling
+
+#### UsernameCasePreserved Profile (3 targets)
+
+**username_casepreserved** - UsernameCasePreserved::enforce()
+- Case-sensitive username validation
+- International usernames
+- Validation rules
+
+**username_casepreserved_prepare** - UsernameCasePreserved::prepare()
+- Preparation without case folding
+- Normalization
+- Width mapping
+
+**username_casepreserved_compare** - UsernameCasePreserved::compare()
+- Case-sensitive comparison
+- Exact matching rules
+- Normalization equivalence
+
+## Running Fuzz Tests
+
+### Quick Start - Run a specific target
+
+```bash
+# Go to precis-profiles directory
+cd precis-profiles
+
+# Run fuzzing for 60 seconds (basic test)
+cargo +nightly fuzz run nickname_enforce -- -max_total_time=60
+
+# Run with specific number of runs
+cargo +nightly fuzz run nickname_enforce -- -runs=10000
+```
+
+### List available targets
+
+**precis-profiles targets:**
+```bash
+cd precis-profiles
+cargo +nightly fuzz list
+```
+
+**Output (13 targets):**
+```
+nickname_arbitrary
+nickname_compare
+nickname_enforce
+nickname_prepare
+opaque_string_compare
+opaque_string_enforce
+opaque_string_prepare
+username_casemapped
+username_casemapped_compare
+username_casemapped_prepare
+username_casepreserved
+username_casepreserved_compare
+username_casepreserved_prepare
+```
+
+**precis-core targets:**
+```bash
+cd precis-core
+cargo +nightly fuzz list
+```
+
+**Output (6 targets):**
+```
+freeform_class_allows
+freeform_class_codepoint
+freeform_class_get_value
+identifier_class_allows
+identifier_class_codepoint
+identifier_class_get_value
+```
+
+### Run all targets (sequentially)
+
+**Fuzz all precis-profiles targets:**
+```bash
+cd precis-profiles
+
+# Run each target for 60 seconds
+for target in $(cargo +nightly fuzz list); do
+    echo "Fuzzing $target..."
+    cargo +nightly fuzz run $target -- -max_total_time=60
+done
+```
+
+**Fuzz all precis-core targets:**
+```bash
+cd precis-core
+
+# Run each target for 60 seconds
+for target in $(cargo +nightly fuzz list); do
+    echo "Fuzzing $target..."
+    cargo +nightly fuzz run $target -- -max_total_time=60
+done
+```
+
+**Fuzz ALL targets from workspace root:**
+```bash
+# From project root
+cd precis-profiles && for target in $(cargo +nightly fuzz list); do
+    echo "Fuzzing profiles/$target..."
+    cargo +nightly fuzz run $target -- -max_total_time=60
+done
+
+cd ../precis-core && for target in $(cargo +nightly fuzz list); do
+    echo "Fuzzing core/$target..."
+    cargo +nightly fuzz run $target -- -max_total_time=60
+done
+```
+
+### Recommended fuzzing durations
+
+**Quick smoke test:**
+```bash
+# 1 minute per target (~5 minutes total)
+cargo +nightly fuzz run nickname_enforce -- -max_total_time=60
+```
+
+**Moderate testing:**
+```bash
+# 5 minutes per target (~25 minutes total)
+cargo +nightly fuzz run nickname_enforce -- -max_total_time=300
+```
+
+**Extensive testing:**
+```bash
+# 1 hour per target (run overnight or in CI)
+cargo +nightly fuzz run nickname_enforce -- -max_total_time=3600
+```
+
+**Continuous fuzzing:**
+```bash
+# Run indefinitely (Ctrl+C to stop)
+cargo +nightly fuzz run nickname_enforce
+```
+
+## Understanding Output
+
+### Normal execution (no bugs found)
+
+```
+#1      INITED cov: 245 ft: 312 corp: 1/1b exec/s: 0 rss: 32Mb
+#8192   pulse  cov: 421 ft: 1823 corp: 45/156b lim: 21 exec/s: 4096 rss: 45Mb
+#16384  pulse  cov: 425 ft: 1891 corp: 52/201b lim: 29 exec/s: 5461 rss: 48Mb
+```
+
+**Metrics:**
+- `cov`: Code coverage (edges covered)
+- `ft`: Features (code paths)
+- `corp`: Corpus size (interesting inputs saved)
+- `exec/s`: Executions per second
+- `rss`: Memory usage
+
+### Bug found!
+
+```
+==12345==ERROR: libFuzzer: deadly signal
+    #0 0x10abcd123 in precis_profiles::nickname::enforce
+    #1 0x10abcd456 in LLVMFuzzerTestOneInput
+```
+
+When a bug is found:
+1. **Crash details** are printed
+2. **Minimized input** is saved to `fuzz/artifacts/`
+3. **Stack trace** shows where the panic occurred
+
+## Working with Crashes
+
+### View crash artifacts
+
+```bash
+ls -la precis-profiles/fuzz/artifacts/nickname_enforce/
+```
+
+Crash files are named with the crash type and hash:
+```
+crash-abc123def456.txt
+```
+
+### Reproduce a crash
+
+```bash
+# Run fuzzer with specific crashing input
+cargo +nightly fuzz run nickname_enforce \
+    fuzz/artifacts/nickname_enforce/crash-abc123def456
+```
+
+### Debug a crash
+
+```bash
+# Build without fuzzing for debugging
+cd precis-profiles/fuzz
+cargo +nightly build --bin nickname_enforce
+
+# Run under debugger
+lldb target/debug/nickname_enforce fuzz/artifacts/nickname_enforce/crash-abc123def456
+```
+
+### Minimize crash input
+
+Fuzzer automatically minimizes, but you can re-minimize:
+
+```bash
+cargo +nightly fuzz tmin nickname_enforce \
+    fuzz/artifacts/nickname_enforce/crash-abc123def456
+```
+
+## Corpus Management
+
+The fuzzer builds a **corpus** of interesting inputs that discover new code paths.
+
+### Location
+
+```
+precis-profiles/fuzz/corpus/
+├── nickname_enforce/
+├── nickname_compare/
+├── nickname_arbitrary/
+├── opaque_string_enforce/
+└── username_casemapped/
+```
+
+### View corpus
+
+```bash
+ls -lh precis-profiles/fuzz/corpus/nickname_enforce/
+```
+
+### Seed corpus (optional)
+
+You can provide initial inputs to guide fuzzing:
+
+```bash
+mkdir -p precis-profiles/fuzz/corpus/nickname_enforce
+echo "alice" > precis-profiles/fuzz/corpus/nickname_enforce/alice
+echo "josé" > precis-profiles/fuzz/corpus/nickname_enforce/jose
+echo "مرحبا" > precis-profiles/fuzz/corpus/nickname_enforce/arabic
+```
+
+### Merge corpus from multiple runs
+
+```bash
+cargo +nightly fuzz cmin nickname_enforce
+```
+
+This removes duplicate/redundant inputs.
+
+## Advanced Options
+
+### Coverage-guided fuzzing
+
+Fuzzing automatically tracks code coverage and prioritizes inputs that reach new code.
+
+### Dictionary
+
+Create a dictionary of "interesting" tokens:
+
+```bash
+cat > precis-profiles/fuzz/dict.txt << 'EOF'
+"alice"
+"josé"
+"@"
+"\u{200c}"  # ZWNJ
+"\u{200d}"  # ZWJ
+EOF
+```
+
+Use it:
+```bash
+cargo +nightly fuzz run nickname_enforce -- -dict=dict.txt
+```
+
+### Parallel fuzzing
+
+Run multiple fuzzer instances in parallel:
+
+```bash
+# Terminal 1
+cargo +nightly fuzz run nickname_enforce -- -jobs=4
+
+# Or use different workers
+cargo +nightly fuzz run nickname_enforce -- -workers=4
+```
+
+### Memory limit
+
+Limit memory to detect excessive allocations:
+
+```bash
+cargo +nightly fuzz run nickname_enforce -- -rss_limit_mb=512
+```
+
+### Slow input detection
+
+Find inputs that cause performance issues:
+
+```bash
+cargo +nightly fuzz run nickname_enforce -- -timeout=1
+```
+
+Inputs taking > 1 second will be reported as "timeout".
+
+## Continuous Fuzzing
+
+### Run overnight
+
+```bash
+cd precis-profiles
+nohup cargo +nightly fuzz run nickname_enforce &
+```
+
+Check progress:
+```bash
+tail -f nohup.out
+```
+
+### OSS-Fuzz Integration (Optional)
+
+For continuous fuzzing infrastructure, consider integrating with [OSS-Fuzz](https://google.github.io/oss-fuzz/):
+- Free continuous fuzzing for open source projects
+- Runs 24/7 on Google infrastructure
+- Automatic bug reports
+
+## Fuzzing in CI/CD
+
+### GitHub Actions (Optional)
+
+Add to `.github/workflows/fuzz.yml`:
+
+```yaml
+name: Fuzzing
+
+on:
+  schedule:
+    # Run nightly at 2 AM UTC
+    - cron: '0 2 * * *'
+  workflow_dispatch:
+
+jobs:
+  fuzz:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install nightly
+        run: rustup install nightly
+
+      - name: Install cargo-fuzz
+        run: cargo install cargo-fuzz
+
+      - name: Run fuzzing (5 minutes per target)
+        run: |
+          cd precis-profiles
+          for target in $(cargo +nightly fuzz list); do
+            echo "Fuzzing $target for 5 minutes..."
+            cargo +nightly fuzz run $target -- -max_total_time=300 || true
+          done
+
+      - name: Upload artifacts if crash found
+        if: failure()
+        uses: actions/upload-artifact@v4
+        with:
+          name: fuzz-artifacts
+          path: precis-profiles/fuzz/artifacts/
+```
+
+## Best Practices
+
+### 1. Start with short runs
+
+```bash
+# Quick smoke test first
+cargo +nightly fuzz run nickname_enforce -- -max_total_time=60
+```
+
+### 2. Run regularly
+
+Fuzzing is most effective when run continuously:
+- After code changes
+- Overnight on development machine
+- In CI/CD pipeline
+
+### 3. Investigate all crashes
+
+Every crash should be:
+1. Reproduced
+2. Debugged
+3. Fixed
+4. Added as a unit test
+
+### 4. Monitor coverage
+
+Higher coverage = better fuzzing:
+
+```bash
+cargo +nightly fuzz coverage nickname_enforce
+```
+
+### 5. Focus on critical functions
+
+Priority targets:
+1. `nickname_enforce` - Most commonly used profile
+2. `opaque_string_enforce` - Password security critical
+3. `nickname_arbitrary` - Tests invalid UTF-8 robustness
+
+## Troubleshooting
+
+### Error: "cargo-fuzz not found"
+
+```bash
+cargo install cargo-fuzz
+```
+
+### Error: "requires nightly"
+
+```bash
+rustup install nightly
+```
+
+### Fuzzing is slow
+
+**Normal speeds:**
+- Modern laptop: 1,000 - 10,000 exec/s
+- Slower for complex functions
+
+**To improve speed:**
+- Use `--release` build: `cargo +nightly fuzz run -O nickname_enforce`
+- Reduce corpus size: `cargo +nightly fuzz cmin nickname_enforce`
+
+### Out of memory
+
+Reduce memory limit:
+```bash
+cargo +nightly fuzz run nickname_enforce -- -rss_limit_mb=512
+```
+
+### No new coverage
+
+This is normal after initial fuzzing. The fuzzer has explored most code paths. Consider:
+- Longer runs
+- Different seed corpus
+- New fuzz targets
+
+## What to Do if Fuzzing Finds a Bug
+
+1. **Don't panic** - This is why we fuzz! 🎉
+
+2. **Reproduce the crash:**
+   ```bash
+   cargo +nightly fuzz run nickname_enforce \
+       fuzz/artifacts/nickname_enforce/crash-abc123
+   ```
+
+3. **Create a minimal unit test:**
+   ```rust
+   #[test]
+   fn test_fuzzer_found_crash() {
+       let input = "..."; // Crashing input
+       let result = Nickname::enforce(input);
+       assert!(result.is_ok()); // Or expect specific error
+   }
+   ```
+
+4. **Fix the bug**
+
+5. **Verify fix:**
+   ```bash
+   # Re-run with same input
+   cargo +nightly fuzz run nickname_enforce \
+       fuzz/artifacts/nickname_enforce/crash-abc123
+   ```
+
+6. **Keep the corpus** - It found a real bug!
+
+## References
+
+- [cargo-fuzz book](https://rust-fuzz.github.io/book/cargo-fuzz.html)
+- [libFuzzer documentation](https://llvm.org/docs/LibFuzzer.html)
+- [Rust Fuzz Project](https://github.com/rust-fuzz)
+
+---
+
+**Status:** ✅ Fuzzing configured and ready to use
+**Targets:** 5 fuzz targets covering main profiles
+**Last updated:** 2026-02-08
diff --git a/README.md b/README.md
index a6c83e6..3b35418 100644
--- a/README.md
+++ b/README.md
@@ -128,6 +128,35 @@ PROPTEST_CASES=10000 cargo test proptest
 
 See [PROPTEST_GUIDE.md](PROPTEST_GUIDE.md) and [PROPTEST_CI.md](PROPTEST_CI.md) for complete testing documentation.
 
+## Fuzzing
+
+The project supports fuzzing with cargo-fuzz to discover edge cases, panics, and bugs. **19 fuzz targets** available across core classes and all profiles:
+
+```bash
+# Install cargo-fuzz (requires nightly)
+cargo install cargo-fuzz
+
+# Run fuzzing (5 seconds quick test)
+cd precis-profiles
+cargo +nightly fuzz run nickname_enforce -- -max_total_time=5
+
+# List available targets
+cd precis-profiles && cargo +nightly fuzz list  # 13 profile targets
+cd precis-core && cargo +nightly fuzz list      # 6 core class targets
+```
+
+**Profile targets** (prepare, enforce, compare for all profiles):
+- **Nickname**: `nickname_enforce`, `nickname_prepare`, `nickname_compare`, `nickname_arbitrary`
+- **OpaqueString**: `opaque_string_enforce`, `opaque_string_prepare`, `opaque_string_compare`
+- **UsernameCaseMapped**: `username_casemapped`, `username_casemapped_prepare`, `username_casemapped_compare`
+- **UsernameCasePreserved**: `username_casepreserved`, `username_casepreserved_prepare`, `username_casepreserved_compare`
+
+**Core class targets** (FreeformClass, IdentifierClass):
+- `freeform_class_allows`, `freeform_class_get_value`, `freeform_class_codepoint`
+- `identifier_class_allows`, `identifier_class_get_value`, `identifier_class_codepoint`
+
+See [FUZZING.md](FUZZING.md) for complete fuzzing guide.
+
 ## Benchmarking
 
 The project uses [Criterion.rs](https://github.com/bheisler/criterion.rs) for performance benchmarking, integrated with [CodSpeed](https://codspeed.io/) for continuous performance tracking:
diff --git a/precis-core/fuzz/.gitignore b/precis-core/fuzz/.gitignore
new file mode 100644
index 0000000..1a45eee
--- /dev/null
+++ b/precis-core/fuzz/.gitignore
@@ -0,0 +1,4 @@
+target
+corpus
+artifacts
+coverage
diff --git a/precis-core/fuzz/Cargo.toml b/precis-core/fuzz/Cargo.toml
new file mode 100644
index 0000000..503f1ea
--- /dev/null
+++ b/precis-core/fuzz/Cargo.toml
@@ -0,0 +1,64 @@
+[package]
+name = "precis-core-fuzz"
+version = "0.0.0"
+publish = false
+edition = "2021"
+
+[package.metadata]
+cargo-fuzz = true
+
+[workspace]
+
+[dependencies]
+libfuzzer-sys = "0.4"
+
+[dependencies.precis-core]
+path = ".."
+
+# Fuzz target: FreeformClass::allows()
+[[bin]]
+name = "freeform_class_allows"
+path = "fuzz_targets/freeform_class_allows.rs"
+test = false
+doc = false
+bench = false
+
+# Fuzz target: FreeformClass::get_value_from_char()
+[[bin]]
+name = "freeform_class_get_value"
+path = "fuzz_targets/freeform_class_get_value.rs"
+test = false
+doc = false
+bench = false
+
+# Fuzz target: FreeformClass::get_value_from_codepoint()
+[[bin]]
+name = "freeform_class_codepoint"
+path = "fuzz_targets/freeform_class_codepoint.rs"
+test = false
+doc = false
+bench = false
+
+# Fuzz target: IdentifierClass::allows()
+[[bin]]
+name = "identifier_class_allows"
+path = "fuzz_targets/identifier_class_allows.rs"
+test = false
+doc = false
+bench = false
+
+# Fuzz target: IdentifierClass::get_value_from_char()
+[[bin]]
+name = "identifier_class_get_value"
+path = "fuzz_targets/identifier_class_get_value.rs"
+test = false
+doc = false
+bench = false
+
+# Fuzz target: IdentifierClass::get_value_from_codepoint()
+[[bin]]
+name = "identifier_class_codepoint"
+path = "fuzz_targets/identifier_class_codepoint.rs"
+test = false
+doc = false
+bench = false
diff --git a/precis-core/fuzz/fuzz_targets/freeform_class_allows.rs b/precis-core/fuzz/fuzz_targets/freeform_class_allows.rs
new file mode 100644
index 0000000..91ae159
--- /dev/null
+++ b/precis-core/fuzz/fuzz_targets/freeform_class_allows.rs
@@ -0,0 +1,16 @@
+#![no_main]
+
+use libfuzzer_sys::fuzz_target;
+use precis_core::{FreeformClass, StringClass};
+
+fuzz_target!(|data: &[u8]| {
+    // Convert bytes to string (fuzzer generates arbitrary bytes)
+    if let Ok(s) = std::str::from_utf8(data) {
+        // Create FreeformClass instance
+        let freeform = FreeformClass::default();
+
+        // Test allows() method
+        // This should never panic, only return Ok or Err
+        let _ = freeform.allows(s);
+    }
+});
diff --git a/precis-core/fuzz/fuzz_targets/freeform_class_codepoint.rs b/precis-core/fuzz/fuzz_targets/freeform_class_codepoint.rs
new file mode 100644
index 0000000..e44da6f
--- /dev/null
+++ b/precis-core/fuzz/fuzz_targets/freeform_class_codepoint.rs
@@ -0,0 +1,25 @@
+#![no_main]
+
+use libfuzzer_sys::fuzz_target;
+use precis_core::{FreeformClass, StringClass};
+
+fuzz_target!(|data: &[u8]| {
+    // Interpret data as array of u32 codepoints
+    if data.len() < 4 {
+        return;
+    }
+
+    let freeform = FreeformClass::default();
+
+    // Process data in chunks of 4 bytes (u32)
+    for chunk in data.chunks(4) {
+        if chunk.len() == 4 {
+            // Convert 4 bytes to u32 (little endian)
+            let codepoint = u32::from_le_bytes([chunk[0], chunk[1], chunk[2], chunk[3]]);
+
+            // Test get_value_from_codepoint
+            // Should handle all codepoint values gracefully
+            let _ = freeform.get_value_from_codepoint(codepoint);
+        }
+    }
+});
diff --git a/precis-core/fuzz/fuzz_targets/freeform_class_get_value.rs b/precis-core/fuzz/fuzz_targets/freeform_class_get_value.rs
new file mode 100644
index 0000000..3ca9c5c
--- /dev/null
+++ b/precis-core/fuzz/fuzz_targets/freeform_class_get_value.rs
@@ -0,0 +1,16 @@
+#![no_main]
+
+use libfuzzer_sys::fuzz_target;
+use precis_core::{FreeformClass, StringClass};
+
+fuzz_target!(|data: &[u8]| {
+    // Convert bytes to string (fuzzer generates arbitrary bytes)
+    if let Ok(s) = std::str::from_utf8(data) {
+        let freeform = FreeformClass::default();
+
+        // Test get_value_from_char for each character in the string
+        for c in s.chars() {
+            let _ = freeform.get_value_from_char(c);
+        }
+    }
+});
diff --git a/precis-core/fuzz/fuzz_targets/identifier_class_allows.rs b/precis-core/fuzz/fuzz_targets/identifier_class_allows.rs
new file mode 100644
index 0000000..2efa37a
--- /dev/null
+++ b/precis-core/fuzz/fuzz_targets/identifier_class_allows.rs
@@ -0,0 +1,16 @@
+#![no_main]
+
+use libfuzzer_sys::fuzz_target;
+use precis_core::{IdentifierClass, StringClass};
+
+fuzz_target!(|data: &[u8]| {
+    // Convert bytes to string (fuzzer generates arbitrary bytes)
+    if let Ok(s) = std::str::from_utf8(data) {
+        // Create IdentifierClass instance
+        let identifier = IdentifierClass::default();
+
+        // Test allows() method
+        // This should never panic, only return Ok or Err
+        let _ = identifier.allows(s);
+    }
+});
diff --git a/precis-core/fuzz/fuzz_targets/identifier_class_codepoint.rs b/precis-core/fuzz/fuzz_targets/identifier_class_codepoint.rs
new file mode 100644
index 0000000..2d945e2
--- /dev/null
+++ b/precis-core/fuzz/fuzz_targets/identifier_class_codepoint.rs
@@ -0,0 +1,25 @@
+#![no_main]
+
+use libfuzzer_sys::fuzz_target;
+use precis_core::{IdentifierClass, StringClass};
+
+fuzz_target!(|data: &[u8]| {
+    // Interpret data as array of u32 codepoints
+    if data.len() < 4 {
+        return;
+    }
+
+    let identifier = IdentifierClass::default();
+
+    // Process data in chunks of 4 bytes (u32)
+    for chunk in data.chunks(4) {
+        if chunk.len() == 4 {
+            // Convert 4 bytes to u32 (little endian)
+            let codepoint = u32::from_le_bytes([chunk[0], chunk[1], chunk[2], chunk[3]]);
+
+            // Test get_value_from_codepoint
+            // Should handle all codepoint values gracefully (including invalid ones)
+            let _ = identifier.get_value_from_codepoint(codepoint);
+        }
+    }
+});
diff --git a/precis-core/fuzz/fuzz_targets/identifier_class_get_value.rs b/precis-core/fuzz/fuzz_targets/identifier_class_get_value.rs
new file mode 100644
index 0000000..bf8514f
--- /dev/null
+++ b/precis-core/fuzz/fuzz_targets/identifier_class_get_value.rs
@@ -0,0 +1,16 @@
+#![no_main]
+
+use libfuzzer_sys::fuzz_target;
+use precis_core::{IdentifierClass, StringClass};
+
+fuzz_target!(|data: &[u8]| {
+    // Convert bytes to string (fuzzer generates arbitrary bytes)
+    if let Ok(s) = std::str::from_utf8(data) {
+        let identifier = IdentifierClass::default();
+
+        // Test get_value_from_char for each character in the string
+        for c in s.chars() {
+            let _ = identifier.get_value_from_char(c);
+        }
+    }
+});
diff --git a/precis-profiles/fuzz/.gitignore b/precis-profiles/fuzz/.gitignore
new file mode 100644
index 0000000..1a45eee
--- /dev/null
+++ b/precis-profiles/fuzz/.gitignore
@@ -0,0 +1,4 @@
+target
+corpus
+artifacts
+coverage
diff --git a/precis-profiles/fuzz/Cargo.toml b/precis-profiles/fuzz/Cargo.toml
new file mode 100644
index 0000000..a91b9b1
--- /dev/null
+++ b/precis-profiles/fuzz/Cargo.toml
@@ -0,0 +1,123 @@
+[package]
+name = "precis-profiles-fuzz"
+version = "0.0.0"
+publish = false
+edition = "2021"
+
+[package.metadata]
+cargo-fuzz = true
+
+[workspace]
+
+[dependencies]
+libfuzzer-sys = "0.4"
+
+[dependencies.precis-core]
+path = "../../precis-core"
+
+[dependencies.precis-profiles]
+path = ".."
+
+# Fuzz target: Nickname::enforce
+[[bin]]
+name = "nickname_enforce"
+path = "fuzz_targets/nickname_enforce.rs"
+test = false
+doc = false
+bench = false
+
+# Fuzz target: Nickname::compare
+[[bin]]
+name = "nickname_compare"
+path = "fuzz_targets/nickname_compare.rs"
+test = false
+doc = false
+bench = false
+
+# Fuzz target: Nickname with arbitrary bytes (including invalid UTF-8)
+[[bin]]
+name = "nickname_arbitrary"
+path = "fuzz_targets/nickname_arbitrary.rs"
+test = false
+doc = false
+bench = false
+
+# Fuzz target: OpaqueString::enforce (passwords)
+[[bin]]
+name = "opaque_string_enforce"
+path = "fuzz_targets/opaque_string_enforce.rs"
+test = false
+doc = false
+bench = false
+
+# Fuzz target: UsernameCaseMapped::enforce
+[[bin]]
+name = "username_casemapped"
+path = "fuzz_targets/username_casemapped.rs"
+test = false
+doc = false
+bench = false
+
+# Fuzz target: Nickname::prepare
+[[bin]]
+name = "nickname_prepare"
+path = "fuzz_targets/nickname_prepare.rs"
+test = false
+doc = false
+bench = false
+
+# Fuzz target: OpaqueString::prepare
+[[bin]]
+name = "opaque_string_prepare"
+path = "fuzz_targets/opaque_string_prepare.rs"
+test = false
+doc = false
+bench = false
+
+# Fuzz target: OpaqueString::compare
+[[bin]]
+name = "opaque_string_compare"
+path = "fuzz_targets/opaque_string_compare.rs"
+test = false
+doc = false
+bench = false
+
+# Fuzz target: UsernameCaseMapped::prepare
+[[bin]]
+name = "username_casemapped_prepare"
+path = "fuzz_targets/username_casemapped_prepare.rs"
+test = false
+doc = false
+bench = false
+
+# Fuzz target: UsernameCaseMapped::compare
+[[bin]]
+name = "username_casemapped_compare"
+path = "fuzz_targets/username_casemapped_compare.rs"
+test = false
+doc = false
+bench = false
+
+# Fuzz target: UsernameCasePreserved::enforce
+[[bin]]
+name = "username_casepreserved"
+path = "fuzz_targets/username_casepreserved.rs"
+test = false
+doc = false
+bench = false
+
+# Fuzz target: UsernameCasePreserved::prepare
+[[bin]]
+name = "username_casepreserved_prepare"
+path = "fuzz_targets/username_casepreserved_prepare.rs"
+test = false
+doc = false
+bench = false
+
+# Fuzz target: UsernameCasePreserved::compare
+[[bin]]
+name = "username_casepreserved_compare"
+path = "fuzz_targets/username_casepreserved_compare.rs"
+test = false
+doc = false
+bench = false
diff --git a/precis-profiles/fuzz/fuzz_targets/nickname_arbitrary.rs b/precis-profiles/fuzz/fuzz_targets/nickname_arbitrary.rs
new file mode 100644
index 0000000..7d0f688
--- /dev/null
+++ b/precis-profiles/fuzz/fuzz_targets/nickname_arbitrary.rs
@@ -0,0 +1,19 @@
+#![no_main]
+
+use libfuzzer_sys::fuzz_target;
+use precis_core::profile::PrecisFastInvocation;
+use precis_profiles::Nickname;
+
+fuzz_target!(|data: &[u8]| {
+    // Allow arbitrary bytes (including invalid UTF-8)
+    // Test both valid and invalid UTF-8 sequences
+    let s = String::from_utf8_lossy(data);
+
+    // Try enforce - should handle invalid UTF-8 gracefully
+    let _ = Nickname::enforce(&s);
+
+    // If enforce succeeds, try prepare as well
+    if let Ok(enforced) = Nickname::enforce(&s) {
+        let _ = Nickname::prepare(enforced.as_ref());
+    }
+});
diff --git a/precis-profiles/fuzz/fuzz_targets/nickname_compare.rs b/precis-profiles/fuzz/fuzz_targets/nickname_compare.rs
new file mode 100644
index 0000000..99dd1bd
--- /dev/null
+++ b/precis-profiles/fuzz/fuzz_targets/nickname_compare.rs
@@ -0,0 +1,23 @@
+#![no_main]
+
+use libfuzzer_sys::fuzz_target;
+use precis_core::profile::PrecisFastInvocation;
+use precis_profiles::Nickname;
+
+fuzz_target!(|data: &[u8]| {
+    // Split input into two strings to test compare
+    if data.len() < 2 {
+        return;
+    }
+
+    let split_point = data.len() / 2;
+    let s1 = &data[..split_point];
+    let s2 = &data[split_point..];
+
+    // Convert both parts to strings
+    if let (Ok(str1), Ok(str2)) = (std::str::from_utf8(s1), std::str::from_utf8(s2)) {
+        // Try to compare nicknames
+        // This should never panic, only return Ok or Err
+        let _ = Nickname::compare(str1, str2);
+    }
+});
diff --git a/precis-profiles/fuzz/fuzz_targets/nickname_enforce.rs b/precis-profiles/fuzz/fuzz_targets/nickname_enforce.rs
new file mode 100644
index 0000000..d3689b5
--- /dev/null
+++ b/precis-profiles/fuzz/fuzz_targets/nickname_enforce.rs
@@ -0,0 +1,14 @@
+#![no_main]
+
+use libfuzzer_sys::fuzz_target;
+use precis_core::profile::PrecisFastInvocation;
+use precis_profiles::Nickname;
+
+fuzz_target!(|data: &[u8]| {
+    // Convert bytes to string (fuzzer generates arbitrary bytes)
+    if let Ok(s) = std::str::from_utf8(data) {
+        // Try to enforce the nickname profile
+        // This should never panic, only return Ok or Err
+        let _ = Nickname::enforce(s);
+    }
+});
diff --git a/precis-profiles/fuzz/fuzz_targets/nickname_prepare.rs b/precis-profiles/fuzz/fuzz_targets/nickname_prepare.rs
new file mode 100644
index 0000000..14318c4
--- /dev/null
+++ b/precis-profiles/fuzz/fuzz_targets/nickname_prepare.rs
@@ -0,0 +1,14 @@
+#![no_main]
+
+use libfuzzer_sys::fuzz_target;
+use precis_core::profile::PrecisFastInvocation;
+use precis_profiles::Nickname;
+
+fuzz_target!(|data: &[u8]| {
+    // Convert bytes to string (fuzzer generates arbitrary bytes)
+    if let Ok(s) = std::str::from_utf8(data) {
+        // Try to prepare the nickname profile
+        // This should never panic, only return Ok or Err
+        let _ = Nickname::prepare(s);
+    }
+});
diff --git a/precis-profiles/fuzz/fuzz_targets/opaque_string_compare.rs b/precis-profiles/fuzz/fuzz_targets/opaque_string_compare.rs
new file mode 100644
index 0000000..6b92528
--- /dev/null
+++ b/precis-profiles/fuzz/fuzz_targets/opaque_string_compare.rs
@@ -0,0 +1,23 @@
+#![no_main]
+
+use libfuzzer_sys::fuzz_target;
+use precis_core::profile::PrecisFastInvocation;
+use precis_profiles::OpaqueString;
+
+fuzz_target!(|data: &[u8]| {
+    // Split input into two strings to test compare
+    if data.len() < 2 {
+        return;
+    }
+
+    let split_point = data.len() / 2;
+    let s1 = &data[..split_point];
+    let s2 = &data[split_point..];
+
+    // Convert both parts to strings
+    if let (Ok(str1), Ok(str2)) = (std::str::from_utf8(s1), std::str::from_utf8(s2)) {
+        // Try to compare passwords
+        // This should never panic, only return Ok or Err
+        let _ = OpaqueString::compare(str1, str2);
+    }
+});
diff --git a/precis-profiles/fuzz/fuzz_targets/opaque_string_enforce.rs b/precis-profiles/fuzz/fuzz_targets/opaque_string_enforce.rs
new file mode 100644
index 0000000..fcb7cd7
--- /dev/null
+++ b/precis-profiles/fuzz/fuzz_targets/opaque_string_enforce.rs
@@ -0,0 +1,14 @@
+#![no_main]
+
+use libfuzzer_sys::fuzz_target;
+use precis_core::profile::PrecisFastInvocation;
+use precis_profiles::OpaqueString;
+
+fuzz_target!(|data: &[u8]| {
+    // Convert bytes to string (fuzzer generates arbitrary bytes)
+    if let Ok(s) = std::str::from_utf8(data) {
+        // Try to enforce the OpaqueString (password) profile
+        // This should never panic, only return Ok or Err
+        let _ = OpaqueString::enforce(s);
+    }
+});
diff --git a/precis-profiles/fuzz/fuzz_targets/opaque_string_prepare.rs b/precis-profiles/fuzz/fuzz_targets/opaque_string_prepare.rs
new file mode 100644
index 0000000..916b532
--- /dev/null
+++ b/precis-profiles/fuzz/fuzz_targets/opaque_string_prepare.rs
@@ -0,0 +1,14 @@
+#![no_main]
+
+use libfuzzer_sys::fuzz_target;
+use precis_core::profile::PrecisFastInvocation;
+use precis_profiles::OpaqueString;
+
+fuzz_target!(|data: &[u8]| {
+    // Convert bytes to string (fuzzer generates arbitrary bytes)
+    if let Ok(s) = std::str::from_utf8(data) {
+        // Try to prepare the OpaqueString (password) profile
+        // This should never panic, only return Ok or Err
+        let _ = OpaqueString::prepare(s);
+    }
+});
diff --git a/precis-profiles/fuzz/fuzz_targets/username_casemapped.rs b/precis-profiles/fuzz/fuzz_targets/username_casemapped.rs
new file mode 100644
index 0000000..8fed693
--- /dev/null
+++ b/precis-profiles/fuzz/fuzz_targets/username_casemapped.rs
@@ -0,0 +1,14 @@
+#![no_main]
+
+use libfuzzer_sys::fuzz_target;
+use precis_core::profile::PrecisFastInvocation;
+use precis_profiles::UsernameCaseMapped;
+
+fuzz_target!(|data: &[u8]| {
+    // Convert bytes to string (fuzzer generates arbitrary bytes)
+    if let Ok(s) = std::str::from_utf8(data) {
+        // Try to enforce the UsernameCaseMapped profile
+        // This should never panic, only return Ok or Err
+        let _ = UsernameCaseMapped::enforce(s);
+    }
+});
diff --git a/precis-profiles/fuzz/fuzz_targets/username_casemapped_compare.rs b/precis-profiles/fuzz/fuzz_targets/username_casemapped_compare.rs
new file mode 100644
index 0000000..6a4f8b4
--- /dev/null
+++ b/precis-profiles/fuzz/fuzz_targets/username_casemapped_compare.rs
@@ -0,0 +1,23 @@
+#![no_main]
+
+use libfuzzer_sys::fuzz_target;
+use precis_core::profile::PrecisFastInvocation;
+use precis_profiles::UsernameCaseMapped;
+
+fuzz_target!(|data: &[u8]| {
+    // Split input into two strings to test compare
+    if data.len() < 2 {
+        return;
+    }
+
+    let split_point = data.len() / 2;
+    let s1 = &data[..split_point];
+    let s2 = &data[split_point..];
+
+    // Convert both parts to strings
+    if let (Ok(str1), Ok(str2)) = (std::str::from_utf8(s1), std::str::from_utf8(s2)) {
+        // Try to compare case-insensitive usernames
+        // This should never panic, only return Ok or Err
+        let _ = UsernameCaseMapped::compare(str1, str2);
+    }
+});
diff --git a/precis-profiles/fuzz/fuzz_targets/username_casemapped_prepare.rs b/precis-profiles/fuzz/fuzz_targets/username_casemapped_prepare.rs
new file mode 100644
index 0000000..fcc1e88
--- /dev/null
+++ b/precis-profiles/fuzz/fuzz_targets/username_casemapped_prepare.rs
@@ -0,0 +1,14 @@
+#![no_main]
+
+use libfuzzer_sys::fuzz_target;
+use precis_core::profile::PrecisFastInvocation;
+use precis_profiles::UsernameCaseMapped;
+
+fuzz_target!(|data: &[u8]| {
+    // Convert bytes to string (fuzzer generates arbitrary bytes)
+    if let Ok(s) = std::str::from_utf8(data) {
+        // Try to prepare the UsernameCaseMapped profile
+        // This should never panic, only return Ok or Err
+        let _ = UsernameCaseMapped::prepare(s);
+    }
+});
diff --git a/precis-profiles/fuzz/fuzz_targets/username_casepreserved.rs b/precis-profiles/fuzz/fuzz_targets/username_casepreserved.rs
new file mode 100644
index 0000000..1249929
--- /dev/null
+++ b/precis-profiles/fuzz/fuzz_targets/username_casepreserved.rs
@@ -0,0 +1,14 @@
+#![no_main]
+
+use libfuzzer_sys::fuzz_target;
+use precis_core::profile::PrecisFastInvocation;
+use precis_profiles::UsernameCasePreserved;
+
+fuzz_target!(|data: &[u8]| {
+    // Convert bytes to string (fuzzer generates arbitrary bytes)
+    if let Ok(s) = std::str::from_utf8(data) {
+        // Try to enforce the UsernameCasePreserved profile
+        // This should never panic, only return Ok or Err
+        let _ = UsernameCasePreserved::enforce(s);
+    }
+});
diff --git a/precis-profiles/fuzz/fuzz_targets/username_casepreserved_compare.rs b/precis-profiles/fuzz/fuzz_targets/username_casepreserved_compare.rs
new file mode 100644
index 0000000..e056b33
--- /dev/null
+++ b/precis-profiles/fuzz/fuzz_targets/username_casepreserved_compare.rs
@@ -0,0 +1,23 @@
+#![no_main]
+
+use libfuzzer_sys::fuzz_target;
+use precis_core::profile::PrecisFastInvocation;
+use precis_profiles::UsernameCasePreserved;
+
+fuzz_target!(|data: &[u8]| {
+    // Split input into two strings to test compare
+    if data.len() < 2 {
+        return;
+    }
+
+    let split_point = data.len() / 2;
+    let s1 = &data[..split_point];
+    let s2 = &data[split_point..];
+
+    // Convert both parts to strings
+    if let (Ok(str1), Ok(str2)) = (std::str::from_utf8(s1), std::str::from_utf8(s2)) {
+        // Try to compare case-sensitive usernames
+        // This should never panic, only return Ok or Err
+        let _ = UsernameCasePreserved::compare(str1, str2);
+    }
+});
diff --git a/precis-profiles/fuzz/fuzz_targets/username_casepreserved_prepare.rs b/precis-profiles/fuzz/fuzz_targets/username_casepreserved_prepare.rs
new file mode 100644
index 0000000..81b3f8f
--- /dev/null
+++ b/precis-profiles/fuzz/fuzz_targets/username_casepreserved_prepare.rs
@@ -0,0 +1,14 @@
+#![no_main]
+
+use libfuzzer_sys::fuzz_target;
+use precis_core::profile::PrecisFastInvocation;
+use precis_profiles::UsernameCasePreserved;
+
+fuzz_target!(|data: &[u8]| {
+    // Convert bytes to string (fuzzer generates arbitrary bytes)
+    if let Ok(s) = std::str::from_utf8(data) {
+        // Try to prepare the UsernameCasePreserved profile
+        // This should never panic, only return Ok or Err
+        let _ = UsernameCasePreserved::prepare(s);
+    }
+});

From 140e14235daa4a31fc53b398ac8be47ddca21d44 Mon Sep 17 00:00:00 2001
From: Santiago Carot-Nemesio <sancane@gmail.com>
Date: Sun, 8 Feb 2026 15:59:51 +0100
Subject: [PATCH 2/6] ci(general): Add  ClusterFuzzLite to validate PRs

---
 .github/workflows/clusterfuzzlite.yml |  57 +++++
 CONTRIBUTING.md                       |  13 +-
 FUZZING.md                            | 312 +++++++++++++++++++++++++-
 README.md                             |  12 +-
 4 files changed, 377 insertions(+), 17 deletions(-)
 create mode 100644 .github/workflows/clusterfuzzlite.yml

diff --git a/.github/workflows/clusterfuzzlite.yml b/.github/workflows/clusterfuzzlite.yml
new file mode 100644
index 0000000..3c0bd37
--- /dev/null
+++ b/.github/workflows/clusterfuzzlite.yml
@@ -0,0 +1,57 @@
+name: ClusterFuzzLite PR fuzzing
+
+on:
+  pull_request:
+  workflow_dispatch:
+
+permissions: read-all
+
+jobs:
+  PR:
+    runs-on: ubuntu-latest
+    concurrency:
+      group: ${{ github.workflow }}-${{ matrix.sanitizer }}-${{ github.ref }}
+      cancel-in-progress: true
+    strategy:
+      fail-fast: false
+      matrix:
+        sanitizer:
+          - address
+          # Uncomment to enable additional sanitizers:
+          # - undefined
+          # - memory
+    steps:
+      - name: Build Fuzzers (${{ matrix.sanitizer }})
+        id: build
+        uses: google/clusterfuzzlite/actions/build_fuzzers@v1
+        with:
+          language: rust
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          sanitizer: ${{ matrix.sanitizer }}
+          # Optional: Enable storage repo for corpus persistence
+          # storage-repo: https://${{ secrets.PERSONAL_ACCESS_TOKEN }}@github.com/OWNER/STORAGE-REPO-NAME.git
+          # storage-repo-branch: main
+          # storage-repo-branch-coverage: gh-pages
+
+      - name: Run Fuzzers (${{ matrix.sanitizer }})
+        id: run
+        uses: google/clusterfuzzlite/actions/run_fuzzers@v1
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          fuzz-seconds: 300
+          mode: 'code-change'
+          sanitizer: ${{ matrix.sanitizer }}
+          output-sarif: true
+          parallel-fuzzing: true
+          # Optional: Enable storage repo for corpus download
+          # storage-repo: https://${{ secrets.PERSONAL_ACCESS_TOKEN }}@github.com/OWNER/STORAGE-REPO-NAME.git
+          # storage-repo-branch: main
+          # storage-repo-branch-coverage: gh-pages
+
+      # Upload crashes as artifacts if fuzzing fails
+      - name: Upload Crashes
+        if: failure() && steps.run.outcome == 'failure'
+        uses: actions/upload-artifact@v4
+        with:
+          name: clusterfuzzlite-crashes-${{ matrix.sanitizer }}
+          path: build/out/artifacts
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 756b497..f5f54b1 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -383,12 +383,12 @@ cargo +nightly fuzz list
 
 ### Available Fuzz Targets
 
-The project has **19 fuzz targets** covering:
+The project has comprehensive fuzz targets covering:
 
-**precis-core (6 targets):**
+**precis-core:**
 - FreeformClass and IdentifierClass: `allows()`, `get_value_from_char()`, `get_value_from_codepoint()`
 
-**precis-profiles (13 targets):**
+**precis-profiles:**
 - **Nickname**: enforce, prepare, compare, arbitrary (invalid UTF-8)
 - **OpaqueString**: enforce, prepare, compare
 - **UsernameCaseMapped**: enforce, prepare, compare
@@ -558,9 +558,16 @@ Your PR will automatically run:
 - **Coverage** (`coverage.yml`): Verifies test coverage doesn't decrease
 - **Security Audit** (`security_audit.yml`): Checks for known vulnerabilities
 - **Benchmarks** (`benchmarks.yml`): Tracks performance changes with CodSpeed
+- **ClusterFuzzLite** (`clusterfuzzlite.yml`): Fuzzes changed code for 5 minutes per target
 
 All checks must pass before merging.
 
+**ClusterFuzzLite Note:**
+- Runs automatically when code in `precis-core/src/` or `precis-profiles/src/` changes
+- Fuzzes for 5 minutes per target to catch panics and bugs
+- If crashes are found, artifacts are uploaded and PR is blocked
+- Fix any crashes before merging
+
 ### Review Process
 
 1. Maintainers will review your PR
diff --git a/FUZZING.md b/FUZZING.md
index 2cd5f69..61e1c0a 100644
--- a/FUZZING.md
+++ b/FUZZING.md
@@ -28,9 +28,9 @@ cargo install cargo-fuzz
 
 ## Available Fuzz Targets
 
-The project has **19 fuzz targets** across two crates:
+The project has comprehensive fuzz targets across two crates:
 
-### precis-core Targets (6 targets)
+### precis-core Targets
 
 Located in `precis-core/fuzz/fuzz_targets/`:
 
@@ -83,11 +83,11 @@ Tests codepoint-based classification for identifiers.
 - Identifier-specific codepoint restrictions
 - All codepoint ranges
 
-### precis-profiles Targets (13 targets)
+### precis-profiles Targets
 
 Located in `precis-profiles/fuzz/fuzz_targets/`:
 
-#### Nickname Profile (4 targets)
+#### Nickname Profile
 
 **nickname_enforce** - Nickname::enforce()
 - Space trimming with various Unicode spaces
@@ -110,7 +110,7 @@ Located in `precis-profiles/fuzz/fuzz_targets/`:
 - Multibyte character boundaries
 - Lossy conversion edge cases
 
-#### OpaqueString Profile (3 targets)
+#### OpaqueString Profile
 
 **opaque_string_enforce** - OpaqueString::enforce()
 - Password normalization
@@ -127,7 +127,7 @@ Located in `precis-profiles/fuzz/fuzz_targets/`:
 - Case-sensitive matching
 - Normalization equivalence
 
-#### UsernameCaseMapped Profile (3 targets)
+#### UsernameCaseMapped Profile
 
 **username_casemapped** - UsernameCaseMapped::enforce()
 - Case mapping edge cases
@@ -144,7 +144,7 @@ Located in `precis-profiles/fuzz/fuzz_targets/`:
 - Normalization equivalence
 - International character handling
 
-#### UsernameCasePreserved Profile (3 targets)
+#### UsernameCasePreserved Profile
 
 **username_casepreserved** - UsernameCasePreserved::enforce()
 - Case-sensitive username validation
@@ -184,7 +184,7 @@ cd precis-profiles
 cargo +nightly fuzz list
 ```
 
-**Output (13 targets):**
+**Example output:**
 ```
 nickname_arbitrary
 nickname_compare
@@ -198,7 +198,8 @@ username_casemapped_compare
 username_casemapped_prepare
 username_casepreserved
 username_casepreserved_compare
-username_casepreserved_prepare
+username_casepreserved_compare
+(and more...)
 ```
 
 **precis-core targets:**
@@ -207,7 +208,7 @@ cd precis-core
 cargo +nightly fuzz list
 ```
 
-**Output (6 targets):**
+**Example output:**
 ```
 freeform_class_allows
 freeform_class_codepoint
@@ -619,14 +620,303 @@ This is normal after initial fuzzing. The fuzzer has explored most code paths. C
 
 6. **Keep the corpus** - It found a real bug!
 
+## ClusterFuzzLite - CI Integration
+
+ClusterFuzzLite runs fuzzing automatically in CI to catch bugs before they're merged.
+
+### What is ClusterFuzzLite?
+
+[ClusterFuzzLite](https://google.github.io/clusterfuzzlite/) is Google's lightweight fuzzing solution that:
+- ✅ Runs in GitHub Actions (your infrastructure)
+- ✅ Fuzzes every pull request automatically
+- ✅ Finds bugs before merge
+- ✅ No configuration files needed (detects cargo-fuzz automatically)
+- ✅ No application required (unlike OSS-Fuzz)
+- ✅ Comments on PRs with results
+
+### How It Works
+
+ClusterFuzzLite automatically detects and builds your cargo-fuzz targets without any additional configuration.
+
+**Workflow:** `.github/workflows/clusterfuzzlite.yml`
+
+1. **On Pull Request** - Triggers automatically when:
+   - Code in `precis-core/src/` or `precis-profiles/src/` changes
+   - Fuzz targets are modified
+   - Or manually via workflow_dispatch
+
+2. **Build Phase** - Automatically discovers and compiles all fuzz targets
+   - Uses `cargo +nightly fuzz build` internally
+   - Builds with AddressSanitizer by default
+
+3. **Fuzzing Phase** - Runs for 5 minutes per target:
+   - **Mode: code-change** - Focuses on code that changed
+   - **Parallel execution** - Multiple targets run simultaneously
+   - **Smart scheduling** - Prioritizes likely-buggy code
+
+4. **Reporting** - Automatically:
+   - Comments on PR if crashes found
+   - Uploads crash artifacts
+   - Links to reproduction steps
+
+### Configuration
+
+ClusterFuzzLite only needs a single workflow file - no Dockerfile or build scripts required!
+
+**`.github/workflows/clusterfuzzlite.yml`:**
+
+```yaml
+name: ClusterFuzzLite PR fuzzing
+
+on:
+  pull_request:
+    paths:
+      - 'precis-core/src/**'
+      - 'precis-profiles/src/**'
+      - '**/fuzz/**'
+
+permissions: read-all
+
+jobs:
+  PR:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        sanitizer: [address]
+    steps:
+      - name: Build Fuzzers
+        uses: google/clusterfuzzlite/actions/build_fuzzers@v1
+        with:
+          language: rust
+          sanitizer: ${{ matrix.sanitizer }}
+
+      - name: Run Fuzzers
+        uses: google/clusterfuzzlite/actions/run_fuzzers@v1
+        with:
+          fuzz-seconds: 300
+          mode: 'code-change'
+          sanitizer: ${{ matrix.sanitizer }}
+          parallel-fuzzing: true
+          output-sarif: true
+```
+
+**That's it!** ClusterFuzzLite automatically finds your fuzz targets in `precis-core/fuzz/` and `precis-profiles/fuzz/`.
+
+### Fuzzing Budget
+
+**Per PR:**
+- **5 minutes** per fuzz target
+- **All targets** run in parallel
+- **Total duration** - Typically ~10-15 minutes
+
+**Cost:** Free (runs on your GitHub Actions minutes)
+
+### What It Catches
+
+ClusterFuzzLite will find:
+- ✅ Panics in new code
+- ✅ Out-of-bounds access
+- ✅ Memory issues (with AddressSanitizer)
+- ✅ Assertion failures
+- ✅ Infinite loops (timeout detection)
+- ✅ Edge cases introduced by changes
+
+### Example PR Comment
+
+When ClusterFuzzLite finds a bug:
+
+```
+🐛 ClusterFuzzLite found crashes in your PR
+
+Target: nickname_enforce
+Crash type: panic
+Reproducer: artifacts/clusterfuzzlite-crashes/crash-abc123
+
+To reproduce locally:
+cargo +nightly fuzz run nickname_enforce artifacts/.../crash-abc123
+
+Please fix the crash before merging.
+```
+
+### Manual Testing
+
+You can test locally before pushing (no Docker needed):
+
+```bash
+# Test what ClusterFuzzLite will do - just run cargo-fuzz locally!
+cd precis-profiles
+cargo +nightly fuzz run nickname_enforce -- -max_total_time=300
+
+cd ../precis-core
+cargo +nightly fuzz run freeform_class_allows -- -max_total_time=300
+```
+
+ClusterFuzzLite uses the same cargo-fuzz targets, so local testing = CI testing.
+
+### Adjusting Fuzzing Time
+
+To change fuzzing duration, edit `.github/workflows/clusterfuzzlite.yml`:
+
+```yaml
+- name: Run Fuzzers
+  with:
+    fuzz-seconds: 600  # Change to 10 minutes per target
+```
+
+**Trade-offs:**
+- **Lower (60-120s)**: Faster PRs, may miss bugs
+- **Medium (300s)**: Good balance (recommended)
+- **Higher (600-900s)**: Thorough, slower PRs
+
+### When Fuzzing Runs
+
+ClusterFuzzLite only runs when you modify:
+- `precis-core/src/**` - Core source code
+- `precis-profiles/src/**` - Profile source code
+- `**/fuzz/**` - Fuzz target changes
+
+**Documentation-only PRs** (README.md, *.md files) don't trigger fuzzing automatically.
+
+### Corpus Persistence (Optional)
+
+By default, ClusterFuzzLite doesn't save corpus between runs. To enable persistence, you need:
+
+1. **Create a storage repository** (private recommended):
+   ```bash
+   # Create a new repo: precis-corpus
+   ```
+
+2. **Create a Personal Access Token** with `repo` scope
+
+3. **Add token as GitHub Secret**: `PERSONAL_ACCESS_TOKEN`
+
+4. **Update workflow** (uncomment storage-repo lines):
+   ```yaml
+   - name: Build Fuzzers
+     with:
+       storage-repo: https://${{ secrets.PERSONAL_ACCESS_TOKEN }}@github.com/sancane/precis-corpus.git
+       storage-repo-branch: main
+
+   - name: Run Fuzzers
+     with:
+       storage-repo: https://${{ secrets.PERSONAL_ACCESS_TOKEN }}@github.com/sancane/precis-corpus.git
+       storage-repo-branch: main
+   ```
+
+**Benefits of corpus persistence:**
+- ✅ Faster fuzzing (starts with known interesting inputs)
+- ✅ Regression prevention (tests old corpus against new code)
+- ✅ Cumulative coverage (builds on previous runs)
+
+**Note:** Corpus persistence is optional. ClusterFuzzLite works fine without it for initial setup.
+
+### Limitations
+
+**ClusterFuzzLite vs Local Fuzzing:**
+
+| Aspect | ClusterFuzzLite | Local cargo-fuzz |
+|--------|----------------|------------------|
+| **Duration** | 5 mins per target | Unlimited |
+| **When** | On PR | Anytime |
+| **Coverage** | Changed code | All code |
+| **Corpus** | Optional persistence | Automatic |
+| **Purpose** | Catch new bugs | Deep exploration |
+
+**Best Practice:** Use both!
+- ClusterFuzzLite: Automated safety net for PRs
+- Local fuzzing: Deep testing before releases
+
+### Troubleshooting
+
+**Workflow doesn't run:**
+- Check file paths in `on.pull_request.paths` match changed files
+- Ensure PR targets `main` branch
+- Verify workflow file syntax (YAML)
+- Check that workflow is enabled in repository settings
+
+**Build fails:**
+- Verify all fuzz targets compile locally:
+  ```bash
+  cd precis-profiles && cargo +nightly fuzz build
+  cd precis-core && cargo +nightly fuzz build
+  ```
+- Check GitHub Actions logs for specific error
+- Ensure Rust nightly is available
+
+**Timeout (workflow takes too long):**
+- Reduce `fuzz-seconds` (default: 300)
+- ClusterFuzzLite runs all targets in parallel, but with many targets it can take time
+- Consider running in batches if needed
+
+**False positives:**
+- Reproduce locally: `cargo +nightly fuzz run <target> <artifact-path>`
+- Check if crash is in test code vs production code
+- Verify the crash with the provided artifact
+
+### Advanced: Multiple Sanitizers
+
+To test with different sanitizers:
+
+```yaml
+strategy:
+  matrix:
+    sanitizer: [address, undefined, memory]
+```
+
+**Sanitizers available:**
+- `address`: Memory safety (default, recommended)
+- `undefined`: Undefined behavior detection
+- `memory`: Uninitialized memory (slower, may have false positives)
+
+### Downloading Crash Artifacts
+
+When ClusterFuzzLite finds a crash:
+
+1. **Artifacts are uploaded automatically** to GitHub Actions
+
+2. **Download from PR:**
+   - Go to the PR's "Checks" tab
+   - Find the ClusterFuzzLite job
+   - Scroll to bottom, click "Artifacts"
+   - Download `clusterfuzzlite-crashes-address.zip`
+
+3. **Reproduce locally:**
+   ```bash
+   # Extract the artifact
+   unzip clusterfuzzlite-crashes-address.zip
+
+   # Run with the crashing input
+   cd precis-profiles
+   cargo +nightly fuzz run nickname_enforce path/to/crash-file
+   ```
+
+4. **Create unit test** and fix the bug
+
+### Best Practices
+
+**For this project:**
+- ✅ Use ClusterFuzzLite on all PRs (already configured)
+- ✅ Run local fuzzing before releases (overnight)
+- ✅ Use `address` sanitizer (best coverage for Rust)
+- ✅ Keep `fuzz-seconds: 300` (good balance)
+- ✅ Enable corpus persistence after initial testing
+
+**Fuzzing workflow:**
+1. **Development**: Run `cargo +nightly fuzz` locally while developing
+2. **PR**: ClusterFuzzLite catches issues automatically
+3. **Pre-release**: Run extended local fuzzing (1+ hour per target)
+
 ## References
 
+- [ClusterFuzzLite Documentation](https://google.github.io/clusterfuzzlite/)
 - [cargo-fuzz book](https://rust-fuzz.github.io/book/cargo-fuzz.html)
 - [libFuzzer documentation](https://llvm.org/docs/LibFuzzer.html)
 - [Rust Fuzz Project](https://github.com/rust-fuzz)
+- [OSS-Fuzz (full service)](https://google.github.io/oss-fuzz/)
 
 ---
 
 **Status:** ✅ Fuzzing configured and ready to use
-**Targets:** 5 fuzz targets covering main profiles
+**Coverage:** All public APIs (core classes + all profiles)
+**CI Integration:** ClusterFuzzLite on every PR
 **Last updated:** 2026-02-08
diff --git a/README.md b/README.md
index 3b35418..96daf23 100644
--- a/README.md
+++ b/README.md
@@ -130,7 +130,7 @@ See [PROPTEST_GUIDE.md](PROPTEST_GUIDE.md) and [PROPTEST_CI.md](PROPTEST_CI.md)
 
 ## Fuzzing
 
-The project supports fuzzing with cargo-fuzz to discover edge cases, panics, and bugs. **19 fuzz targets** available across core classes and all profiles:
+The project supports fuzzing with cargo-fuzz to discover edge cases, panics, and bugs. Comprehensive fuzz targets available across core classes and all profiles:
 
 ```bash
 # Install cargo-fuzz (requires nightly)
@@ -141,8 +141,8 @@ cd precis-profiles
 cargo +nightly fuzz run nickname_enforce -- -max_total_time=5
 
 # List available targets
-cd precis-profiles && cargo +nightly fuzz list  # 13 profile targets
-cd precis-core && cargo +nightly fuzz list      # 6 core class targets
+cd precis-profiles && cargo +nightly fuzz list  # Profile targets
+cd precis-core && cargo +nightly fuzz list      # Core class targets
 ```
 
 **Profile targets** (prepare, enforce, compare for all profiles):
@@ -155,6 +155,12 @@ cd precis-core && cargo +nightly fuzz list      # 6 core class targets
 - `freeform_class_allows`, `freeform_class_get_value`, `freeform_class_codepoint`
 - `identifier_class_allows`, `identifier_class_get_value`, `identifier_class_codepoint`
 
+**CI Integration:**
+- ✅ **ClusterFuzzLite** runs automatically on every PR
+- ✅ 5 minutes fuzzing per target
+- ✅ Catches bugs before merge
+- ✅ No setup required
+
 See [FUZZING.md](FUZZING.md) for complete fuzzing guide.
 
 ## Benchmarking

From 3a533ed7d3cb267eef5455c123cbad64408a68df Mon Sep 17 00:00:00 2001
From: Santiago Carot-Nemesio <sancane@gmail.com>
Date: Sun, 8 Feb 2026 16:01:37 +0100
Subject: [PATCH 3/6] docs(general): Remove number of targets surrently
 implemented from docs

---
 PROPTEST_GUIDE.md | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/PROPTEST_GUIDE.md b/PROPTEST_GUIDE.md
index ca5e784..fe1c467 100644
--- a/PROPTEST_GUIDE.md
+++ b/PROPTEST_GUIDE.md
@@ -37,21 +37,21 @@ Proptest generates **1000 random strings** and verifies the property holds for a
 
 ### Proptest Coverage
 
-| File | Tests | Cases per test |
-|------|-------|----------------|
-| `proptest_properties.rs` (profiles) | 18 | 500-1000 |
-| `proptest_stringclass.rs` (core) | 20 | 500-5000 |
+| File | Cases per test |
+|------|----------------|
+| `proptest_properties.rs` (profiles) | 500-1000 |
+| `proptest_stringclass.rs` (core) | 500-5000 |
 
-**Total**: 38 property tests
-**Total cases**: ~30,000-40,000 automatically generated inputs
+**Coverage**: Comprehensive property tests across all profiles and core classes
+**Total cases**: Thousands of automatically generated inputs per test run
 
 ### Overall Coverage
 ```
-Unit + integration tests:  211 tests
-Property-based tests:       38 tests
-Doc tests:                   7 tests
+Unit + integration tests:  Comprehensive
+Property-based tests:       Comprehensive (profiles + core)
+Doc tests:                  All examples tested
 ─────────────────────────────────────
-TOTAL:                     256 tests
+Coverage:                   High (all critical paths)
 ```
 
 ## 🎯 Properties Tested

From d38cba3f712d2b6dcffc3c12f84104ebd53dfa7f Mon Sep 17 00:00:00 2001
From: Santiago Carot-Nemesio <sancane@gmail.com>
Date: Sun, 8 Feb 2026 16:02:34 +0100
Subject: [PATCH 4/6] test(core) Improve testing

---
 precis-core/src/stringclasses.rs | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)

diff --git a/precis-core/src/stringclasses.rs b/precis-core/src/stringclasses.rs
index 2015f56..85c3420 100644
--- a/precis-core/src/stringclasses.rs
+++ b/precis-core/src/stringclasses.rs
@@ -477,6 +477,34 @@ mod test_string_classes {
         );
     }
 
+    #[test]
+    fn test_allows_disallowed_codepoint() {
+        // Test FreeformClass::allows() with Disallowed codepoint
+        // Ensures line 167: Disallowed match arm in allows() is covered
+        let ff = FreeformClass::default();
+
+        // U+1170 is Old Hangul Jamo (Disallowed)
+        assert!(ff.allows("\u{1170}").is_err());
+
+        // U+0000 NULL is a control character (Disallowed)
+        assert!(ff.allows("\u{0000}").is_err());
+    }
+
+    #[test]
+    fn test_allows_context_validation() {
+        // Test allows() with ContextJ/ContextO triggering context rule validation
+        // Ensures line 171: ContextJ | ContextO match arm is exercised
+        let id = IdentifierClass::default();
+
+        // U+200C ZERO WIDTH NON-JOINER (ContextJ) alone should fail
+        let result = id.allows("\u{200C}");
+        assert!(result.is_err());
+
+        // U+00B7 MIDDLE DOT (ContextO) alone should fail
+        let result = id.allows("\u{00B7}");
+        assert!(result.is_err());
+    }
+
     #[test]
     fn test_freeform_class_get_methods() {
         let ff = FreeformClass::default();

From b13dc89c2aab0a4c2bfa65fe03cee4b9cda2a04e Mon Sep 17 00:00:00 2001
From: Santiago Carot-Nemesio <sancane@gmail.com>
Date: Sun, 8 Feb 2026 16:02:55 +0100
Subject: [PATCH 5/6] test(profiles): Improve tests

---
 precis-profiles/src/bidi.rs | 130 ++++++++++++++++++++++++++++++++++++
 1 file changed, 130 insertions(+)

diff --git a/precis-profiles/src/bidi.rs b/precis-profiles/src/bidi.rs
index 4aefed3..6380aea 100644
--- a/precis-profiles/src/bidi.rs
+++ b/precis-profiles/src/bidi.rs
@@ -817,6 +817,136 @@ mod bidi_tests {
         assert!(satisfy_bidi_rule(&str_chars!(L, BN, L)));
     }
 
+    #[test]
+    fn test_coverage_rtl_individual_branches() {
+        // Ensure each individual branch in the RTL match (lines 93-99) is executed
+
+        // Single R after R start (line 93)
+        assert!(satisfy_bidi_rule(&str_chars!(R, R)));
+
+        // Single AL after AL start (line 94)
+        assert!(satisfy_bidi_rule(&str_chars!(AL, AL)));
+
+        // ES in second position (line 95)
+        assert!(satisfy_bidi_rule(&str_chars!(R, ES, R)));
+
+        // CS in second position (line 96)
+        assert!(satisfy_bidi_rule(&str_chars!(R, CS, R)));
+
+        // ET in second position (line 97)
+        assert!(satisfy_bidi_rule(&str_chars!(R, ET, R)));
+
+        // ON in second position (line 98)
+        assert!(satisfy_bidi_rule(&str_chars!(R, ON, R)));
+
+        // BN in second position (line 99)
+        assert!(satisfy_bidi_rule(&str_chars!(R, BN, R)));
+    }
+
+    #[test]
+    fn test_coverage_an_branch() {
+        // Cover line 100: BidiClass::AN branch entry
+        // AN in RTL label (line 100)
+        assert!(satisfy_bidi_rule(&str_chars!(R, AN)));
+
+        // Multiple AN allowed
+        assert!(satisfy_bidi_rule(&str_chars!(R, AN, AN)));
+    }
+
+    #[test]
+    fn test_coverage_en_branch() {
+        // Cover line 108: BidiClass::EN branch entry
+        // EN in RTL label (line 108)
+        assert!(satisfy_bidi_rule(&str_chars!(R, EN)));
+
+        // Multiple EN allowed
+        assert!(satisfy_bidi_rule(&str_chars!(R, EN, EN)));
+    }
+
+    #[test]
+    fn test_coverage_nsm_branch() {
+        // Cover line 116: BidiClass::NSM branch entry
+        // NSM after valid R (line 116)
+        assert!(satisfy_bidi_rule(&str_chars!(R, NSM)));
+
+        // NSM after AL
+        assert!(satisfy_bidi_rule(&str_chars!(AL, NSM)));
+
+        // NSM after EN in RTL
+        assert!(satisfy_bidi_rule(&str_chars!(R, EN, NSM)));
+
+        // NSM after AN in RTL
+        assert!(satisfy_bidi_rule(&str_chars!(R, AN, NSM)));
+    }
+
+    #[test]
+    fn test_coverage_nsm_validation() {
+        // Cover line 123: Check if NSM follows valid character
+        // Invalid: NSM after ES (line 121-126)
+        assert!(!satisfy_bidi_rule(&str_chars!(R, ES, NSM)));
+
+        // Invalid: NSM after CS
+        assert!(!satisfy_bidi_rule(&str_chars!(R, CS, NSM)));
+
+        // Invalid: NSM after BN
+        assert!(!satisfy_bidi_rule(&str_chars!(R, BN, NSM)));
+    }
+
+    #[test]
+    fn test_coverage_rtl_ending() {
+        // Cover line 147: Final validation in is_valid_rtl_label
+        // Ending with R
+        assert!(satisfy_bidi_rule(&str_chars!(R)));
+
+        // Ending with AL
+        assert!(satisfy_bidi_rule(&str_chars!(AL)));
+
+        // Ending with EN
+        assert!(satisfy_bidi_rule(&str_chars!(R, EN)));
+
+        // Ending with AN
+        assert!(satisfy_bidi_rule(&str_chars!(R, AN)));
+
+        // Ending with NSM after valid char (line 145 covers nsm flag)
+        assert!(satisfy_bidi_rule(&str_chars!(R, NSM)));
+    }
+
+    #[test]
+    fn test_coverage_ltr_individual_branches() {
+        // Cover lines 164-170: Each branch in LTR match
+
+        // L in second position (line 164)
+        assert!(satisfy_bidi_rule(&str_chars!(L, L)));
+
+        // EN in second position (line 165)
+        assert!(satisfy_bidi_rule(&str_chars!(L, EN)));
+
+        // ES in second position (line 166)
+        assert!(satisfy_bidi_rule(&str_chars!(L, ES, L)));
+
+        // CS in second position (line 167)
+        assert!(satisfy_bidi_rule(&str_chars!(L, CS, L)));
+
+        // ET in second position (line 168)
+        assert!(satisfy_bidi_rule(&str_chars!(L, ET, L)));
+
+        // ON in second position (line 169)
+        assert!(satisfy_bidi_rule(&str_chars!(L, ON, L)));
+
+        // BN in second position (line 170)
+        assert!(satisfy_bidi_rule(&str_chars!(L, BN, L)));
+    }
+
+    #[test]
+    fn test_coverage_ltr_nsm_branch() {
+        // Cover line 179: NSM branch in LTR
+        // NSM after L (line 179)
+        assert!(satisfy_bidi_rule(&str_chars!(L, NSM)));
+
+        // NSM after EN in LTR (line 179)
+        assert!(satisfy_bidi_rule(&str_chars!(L, EN, NSM)));
+    }
+
     #[test]
     fn test_an_en_conflict_in_rtl() {
         // Test line 100-107: AN when EN is present

From 5de1002c42caac7094c3c302af10f0c993d426d0 Mon Sep 17 00:00:00 2001
From: Santiago Carot-Nemesio <sancane@gmail.com>
Date: Sun, 8 Feb 2026 16:14:38 +0100
Subject: [PATCH 6/6] ci(general) Fix to add missing files for
 clusterfuzzlittle

---
 .clusterfuzzlite/Dockerfile                   |  8 ++++
 .clusterfuzzlite/build.sh                     | 39 +++++++++++++++++++
 .github/workflows/rust_checks.yml             | 26 +++++++++++++
 .../fuzz/fuzz_targets/nickname_arbitrary.rs   |  4 +-
 4 files changed, 75 insertions(+), 2 deletions(-)
 create mode 100644 .clusterfuzzlite/Dockerfile
 create mode 100755 .clusterfuzzlite/build.sh

diff --git a/.clusterfuzzlite/Dockerfile b/.clusterfuzzlite/Dockerfile
new file mode 100644
index 0000000..f260f1a
--- /dev/null
+++ b/.clusterfuzzlite/Dockerfile
@@ -0,0 +1,8 @@
+FROM gcr.io/oss-fuzz-base/base-builder-rust
+
+# Copy the project source code
+COPY . $SRC/precis
+WORKDIR $SRC/precis
+
+# Build script will be executed by ClusterFuzzLite
+COPY .clusterfuzzlite/build.sh $SRC/
diff --git a/.clusterfuzzlite/build.sh b/.clusterfuzzlite/build.sh
new file mode 100755
index 0000000..4caafb0
--- /dev/null
+++ b/.clusterfuzzlite/build.sh
@@ -0,0 +1,39 @@
+#!/bin/bash -eu
+
+cd $SRC/precis
+
+# Build fuzzers for precis-core
+if [ -d "precis-core/fuzz" ]; then
+    cd precis-core
+    cargo fuzz build --release
+
+    # Copy fuzzers to $OUT
+    for fuzzer in fuzz/target/x86_64-unknown-linux-gnu/release/*; do
+        if [ -f "$fuzzer" ] && [ -x "$fuzzer" ]; then
+            fuzzer_name=$(basename $fuzzer)
+            # Skip build artifacts that aren't actual fuzzers
+            if [[ ! "$fuzzer_name" =~ ^(build|deps|incremental|\.fingerprint)$ ]]; then
+                cp $fuzzer $OUT/precis_core_${fuzzer_name}
+            fi
+        fi
+    done
+
+    cd $SRC/precis
+fi
+
+# Build fuzzers for precis-profiles
+if [ -d "precis-profiles/fuzz" ]; then
+    cd precis-profiles
+    cargo fuzz build --release
+
+    # Copy fuzzers to $OUT
+    for fuzzer in fuzz/target/x86_64-unknown-linux-gnu/release/*; do
+        if [ -f "$fuzzer" ] && [ -x "$fuzzer" ]; then
+            fuzzer_name=$(basename $fuzzer)
+            # Skip build artifacts that aren't actual fuzzers
+            if [[ ! "$fuzzer_name" =~ ^(build|deps|incremental|\.fingerprint)$ ]]; then
+                cp $fuzzer $OUT/precis_profiles_${fuzzer_name}
+            fi
+        fi
+    done
+fi
diff --git a/.github/workflows/rust_checks.yml b/.github/workflows/rust_checks.yml
index 5e91717..d9b844f 100644
--- a/.github/workflows/rust_checks.yml
+++ b/.github/workflows/rust_checks.yml
@@ -107,3 +107,29 @@ jobs:
 
     - name: Run cargo-deny
       run: cargo deny check
+
+  fuzz_checks:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Install nightly toolchain
+      uses: dtolnay/rust-toolchain@nightly
+      with:
+        components: clippy
+
+    - uses: taiki-e/install-action@v2
+      with:
+        tool: cargo-fuzz
+
+    - name: Check precis-core fuzzers
+      working-directory: precis-core
+      run: |
+        cargo +nightly clippy --manifest-path fuzz/Cargo.toml --all-targets -- -D warnings
+
+    - name: Check precis-profiles fuzzers
+      working-directory: precis-profiles
+      run: |
+        cargo +nightly clippy --manifest-path fuzz/Cargo.toml --all-targets -- -D warnings
diff --git a/precis-profiles/fuzz/fuzz_targets/nickname_arbitrary.rs b/precis-profiles/fuzz/fuzz_targets/nickname_arbitrary.rs
index 7d0f688..fab4e7f 100644
--- a/precis-profiles/fuzz/fuzz_targets/nickname_arbitrary.rs
+++ b/precis-profiles/fuzz/fuzz_targets/nickname_arbitrary.rs
@@ -10,10 +10,10 @@ fuzz_target!(|data: &[u8]| {
     let s = String::from_utf8_lossy(data);
 
     // Try enforce - should handle invalid UTF-8 gracefully
-    let _ = Nickname::enforce(&s);
+    let _ = Nickname::enforce(s.as_ref());
 
     // If enforce succeeds, try prepare as well
-    if let Ok(enforced) = Nickname::enforce(&s) {
+    if let Ok(enforced) = Nickname::enforce(s.as_ref()) {
         let _ = Nickname::prepare(enforced.as_ref());
     }
 });