scrubber_rb 0.1.0-aarch64-linux

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 38b7f7083ba67ffba5ffe8b11514f3155e3ce1a00ce5d7c560226ad989851297
+  data.tar.gz: 38cbd81c6131110fd9a59178f5ac4da72bd8a7e8a764b0b88c4c289d5c35acdf
+SHA512:
+  metadata.gz: 0bc769a88fe5611ad89484aa0a43c90b698d8ca623a2aab72b44de57600771f8b36ba5a2efa855e8c02227ea06c2c1dff7b27ab25de63507ea9a35df538c13de
+  data.tar.gz: 02d2457b57e429711fb18f1576020a35b780179377736381c991743bca28a0b3c3ff077428fac1b4dab6946c12b841085c43cd70eb8511b5be1f5216b520180a

data/.cargo/config.toml

@@ -0,0 +1,21 @@
+# musl targets static-link the C runtime by default, and a statically linked
+# CRT cannot produce a shared library. Cargo decides whether a target supports
+# `cdylib` *before* it invokes rustc, so the `-C target-feature=-crt-static`
+# that rb_sys appends after `cargo rustc --` arrives too late:
+#
+#     error: cannot produce cdylib for `scrubber_rb` as the target
+#     `x86_64-unknown-linux-musl` does not support these crate types
+#
+# Setting it here instead means cargo sees it while probing the target, decides
+# cdylib is buildable, and the cross-compiled gem links. This also fixes source
+# builds on Alpine, which is why the file ships inside the gem.
+#
+# Note the precedence rule: a `RUSTFLAGS` environment variable *replaces* these
+# rather than merging with them. Anything that sets `RUSTFLAGS` for a musl build
+# has to include `-C target-feature=-crt-static` itself.
+
+[target.x86_64-unknown-linux-musl]
+rustflags = ["-C", "target-feature=-crt-static"]
+
+[target.aarch64-unknown-linux-musl]
+rustflags = ["-C", "target-feature=-crt-static"]

data/CHANGELOG.md

@@ -0,0 +1,59 @@
+# Changelog
+
+All notable changes to this project are documented here.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.1.0] - 2026-08-16
+
+First release.
+
+### Added
+
+- **Rust scanning core** (magnus + rb-sys). Two-stage pass: one Aho-Corasick sweep over
+  literal anchors to eliminate rules that cannot match, then one `RegexSet` pass for the rest.
+  Overlaps resolved by leftmost, then most specific, then longest. Output built in a single
+  walk rather than repeated `gsub`.
+- **14 default detectors**: `email`, `phone`, `credit_card`, `ssn`, `iban`, `ip`, `ipv6`,
+  `mac`, `jwt`, `aws_key`, `api_key`, `private_key`, `password_pair`, `url_credentials`.
+- **Opt-in India pack** (`Scrubber::INDIA`): `phone_in`, `aadhaar`, `pan`, `upi`, for DPDP Act
+  workloads.
+- **Checksum validation**: Luhn for cards, Verhoeff for Aadhaar, ISO 7064 mod-97 for IBAN
+  (plus an IBAN country-registry check), SSA range rules for SSNs, PAN entity-character check,
+  and a PSP allowlist for UPI handles.
+- **19 provider-specific API key formats** under `:api_key` — GitHub, GitLab, Slack, Stripe,
+  OpenAI, Anthropic, Google, SendGrid, Twilio, npm, PyPI, Shopify, Square, Mailgun,
+  DigitalOcean, Telegram, AWS secret keys. No entropy heuristics.
+- **Four replacement strategies**: `:label`, `:mask`, `:hash` (salted, deterministic, so logs
+  stay correlatable), `:remove`.
+- **Custom detectors** from Ruby `Regexp`s, translated to Rust regex syntax. Backreferences,
+  lookaround, atomic groups and possessive quantifiers raise
+  `Scrubber::UnsupportedPatternError` at construction time, naming the construct — never
+  silent partial coverage.
+- **`Scrubber::LogFormatter`** — wraps any Logger formatter.
+- **`Scrubber::Middleware`** — Rack middleware that publishes redacted copies of the query
+  string and params at `env["scrubber.*"]` and redacts exception messages on the way out. It
+  deliberately does not rewrite the live request.
+- **`Scrubber::LLMGuard`** — a plain callable that redacts prompts, message arrays and message
+  hashes before they reach a model API. Defaults to `:hash`.
+- **`Scrubber.scrub_file`** — streams in 1MB chunks with an 8KB carry window, cutting at line
+  boundaries, with an extra guard so multi-line PEM blocks are never split.
+- **GVL released** for inputs over 64KB, so large scans don't stall other threads.
+- **Panic hygiene**: every FFI entry point is wrapped in `catch_unwind`; a Rust panic becomes
+  `Scrubber::InternalError` rather than a process abort.
+- **Invalid UTF-8 tolerance**: valid regions are scrubbed, invalid bytes pass through
+  unchanged, nothing raises.
+- **Character-accurate offsets** from `Scrubber#detect`, so spans index the Ruby string
+  correctly through emoji and Devanagari.
+- **Benchmark suite** with an honest pure-Ruby reference implementing the identical detector
+  set, a seeded 100MB corpus generator, and a spec asserting the two implementations redact
+  identical spans.
+- **Precompiled gems** for `x86_64-linux`, `x86_64-linux-musl`, `aarch64-linux`,
+  `aarch64-linux-musl`, `x86_64-darwin`, `arm64-darwin`, plus a best-effort
+  `x64-mingw-ucrt` and the source gem.
+
+[Unreleased]: https://github.com/TheSoloHacker47/scrubber-rb/compare/v0.1.0...HEAD
+[0.1.0]: https://github.com/TheSoloHacker47/scrubber-rb/releases/tag/v0.1.0

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Nikhil Nelson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,298 @@
+# scrubber_rb
+
+> Fast PII & secret redaction for Ruby — Rust-cored. Scrub logs, LLM prompts, and payloads before they leak.
+
+[![Gem Version](https://badge.fury.io/rb/scrubber_rb.svg)](https://rubygems.org/gems/scrubber_rb)
+[![CI](https://github.com/TheSoloHacker47/scrubber-rb/actions/workflows/ci.yml/badge.svg)](https://github.com/TheSoloHacker47/scrubber-rb/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+
+Your production logs contain emails. Your error tracker captures request params with credit
+cards in them. And now your app pipes user content straight into LLM APIs. `scrubber_rb`
+redacts sensitive data from any string in a single pass through a Rust engine — fast enough
+to sit in your logger, your Rack stack, and in front of every AI call.
+
+```ruby
+Scrubber.scrub("contact nik@example.com, card 4111 1111 1111 1111, key AKIAIOSFODNN7EXAMPLE")
+# => "contact [EMAIL], card [CREDIT_CARD], key [AWS_KEY]"
+```
+
+## Why this gem
+
+- **Fast.** Multi-pattern scanning runs in Rust (`regex` + `aho-corasick`) — one pass, no
+  backtracking, GVL released on large inputs. Measured **38x** a pure-Ruby implementation of
+  the identical detector set on a 100MB log corpus, and **83x** on a single log line
+  ([methodology below](#benchmarks), reproducible via `rake benchmark`).
+- **Accurate.** Checksums, not just shapes: credit cards must pass Luhn, Aadhaar must pass
+  Verhoeff, IBANs must pass mod-97. A random 16-digit number won't get redacted.
+- **Complete.** 18 detectors out of the box — emails, phones, cards, SSNs, IBANs, IPs, MACs,
+  JWTs, AWS keys, 19 provider-specific API key formats, private key blocks, `password=` pairs,
+  URL credentials — plus an opt-in India pack (Aadhaar, PAN, UPI) for DPDP Act compliance.
+- **ReDoS-immune.** Rust's regex engine is linear-time by design, so attacker-controlled log
+  content can't blow up your CPU with pathological backtracking.
+- **No toolchain needed.** Precompiled gems for Linux (x86_64/aarch64, glibc & musl) and
+  macOS (Intel & Apple Silicon). `gem install scrubber_rb` and you're done.
+
+## Installation
+
+```ruby
+# Gemfile
+gem "scrubber_rb"
+```
+
+Requires Ruby >= 3.1. If no precompiled gem matches your platform, the source gem builds
+automatically (needs a Rust toolchain).
+
+## Usage
+
+### Basic
+
+```ruby
+Scrubber.scrub(text)     # default detectors, [LABEL] replacement
+Scrubber.detect(text)    # => [#<Scrubber::Match type=:email 11...26 preview="n**@e******.com">]
+Scrubber.match?(text)    # => true/false, without building the redacted string
+```
+
+### Reusable instance (the fast path)
+
+Compile once, scrub millions of times. Compiling ~45 patterns into one automaton is the
+expensive part; scanning is cheap.
+
+```ruby
+SCRUBBER = Scrubber.new(
+  detectors:   Scrubber::DEFAULTS + Scrubber::INDIA,
+  custom:      { employee_id: /\bEMP-\d{6}\b/ },
+  replacement: :hash                                  # deterministic tokens — logs stay correlatable
+)
+
+SCRUBBER.scrub("refund to nik@example.com")           # => "refund to [EMAIL:1efaf05b]"
+SCRUBBER.scrub("refund to nik@example.com")           # => same token — grep still works
+```
+
+Instances are frozen and hold no per-call state, so one instance is safe to share across every
+thread in the process. The module-level `Scrubber.scrub` memoizes one engine per distinct
+configuration, so it's fine too — the explicit instance just makes the lifetime obvious.
+
+### Replacement strategies
+
+| strategy | `nik@example.com` | `4111 1111 1111 1111` | `AKIA…EXAMPLE` |
+|---|---|---|---|
+| `:label` (default) | `[EMAIL]` | `[CREDIT_CARD]` | `[AWS_KEY]` |
+| `:mask` | `n**@e******.com` | `**** **** **** 1111` | `********************` |
+| `:hash` | `[EMAIL:1efaf05b]` | `[CREDIT_CARD:6a7e0e79]` | `[AWS_KEY:1a5d44a2]` |
+| `:remove` | *(deleted)* | *(deleted)* | *(deleted)* |
+
+`:mask` keeps the last four characters of *identifiers* so a human can still recognise the
+record, and reveals nothing at all for *secrets* — the last four characters of an API key are
+a leak, not a convenience.
+
+`:hash` is `sha256(salt + value)[0, 8]`. Same input, same token, across processes and days, so
+logs stay correlatable without holding the value. Pass `hash_salt:` to scope tokens per tenant
+or per environment.
+
+### Rails logs — one line
+
+```ruby
+# config/initializers/scrubber.rb
+Rails.logger.formatter = Scrubber::LogFormatter.new(Rails.logger.formatter)
+```
+
+Wrapping the *formatter* rather than the logger catches everything: your own
+`Rails.logger.info`, Active Record's SQL echo, Rack's request lines, and the exception messages
+your error middleware logs on the way out.
+
+### Rack middleware
+
+```ruby
+use Scrubber::Middleware
+```
+
+The middleware is deliberately **non-destructive**. It does not rewrite `QUERY_STRING`,
+`rack.input`, or `params` — redacting the request your application is about to act on would
+break every login form in the world, because the app needs the real password to check it.
+What leaks is not the request, it's the *record* of the request.
+
+So it publishes redacted copies for you to record, and cleans exceptions on the way out:
+
+```ruby
+env["scrubber.query_string"]  # "user=nik&password=[PASSWORD_PAIR]"
+env["scrubber.params"]        # { "user" => "nik", "password" => "[PASSWORD_PAIR]" }
+env["scrubber.instance"]      # the engine, for anything else you want to log
+```
+
+Any exception raised downstream is re-raised with a redacted message (same class, same
+backtrace), so an error tracker that has never heard of this gem still gets a clean payload.
+Turn that off with `use Scrubber::Middleware, scrub_exceptions: false`.
+
+### Before your LLM calls
+
+Stop shipping raw customer PII to third-party AI APIs:
+
+```ruby
+guard = Scrubber::LLMGuard.new           # defaults to :hash
+
+chat.ask(guard.call(user_message))
+```
+
+`LLMGuard` is a plain callable that preserves the shape of what you give it — a String, a
+message Array, or a message Hash — so it drops into RubyLLM, langchainrb, ruby-openai,
+anthropic-sdk-ruby, or a hand-rolled `Net::HTTP` call the same way:
+
+```ruby
+messages = [
+  { role: "system", content: "You are a support agent." },
+  { role: "user",   content: "my email is nik@example.com and my card is 4111 1111 1111 1111" }
+]
+
+client.chat(messages: guard.call(messages))
+# => user content becomes "my email is [EMAIL:1efaf05b] and my card is [CREDIT_CARD:6a7e0e79]"
+```
+
+Deterministic `:hash` tokens mean the model can still refer to "the same email" across a
+conversation without ever seeing it. `guard.findings(messages)` returns what *would* be
+redacted, if you want a "we blocked N leaks today" metric or a test that fails when a prompt
+builder regresses.
+
+> **On RubyLLM:** as of August 2026 RubyLLM has no public middleware or interceptor hook, so
+> this gem ships the wrapper pattern above rather than a plugin. Wrapping the argument at the
+> call site is one line and doesn't depend on RubyLLM internals staying put.
+
+### Big files
+
+```ruby
+Scrubber.scrub_file("production.log", "production.scrubbed.log")
+```
+
+Streams in 1MB chunks with an 8KB carry window, cutting at line boundaries so a match spanning
+a chunk boundary is never sliced in half (multi-line PEM blocks get an extra guard). Releases
+the GVL for inputs over 64KB, so your Puma threads keep serving.
+
+## Detectors
+
+| Default | Opt-in (India pack) |
+|---|---|
+| `email`, `phone`, `credit_card` (Luhn), `ssn`, `iban` (mod-97), `ip`, `ipv6`, `mac`, `jwt`, `aws_key`, `api_key`, `private_key`, `password_pair`, `url_credentials` | `phone_in`, `aadhaar` (Verhoeff), `pan`, `upi` |
+
+```ruby
+Scrubber.new(detectors: Scrubber::DEFAULTS + Scrubber::INDIA)
+Scrubber.new(detectors: %i[email credit_card])   # narrow it down for hot paths
+Scrubber::ALL                                    # everything
+```
+
+`:api_key` covers 19 provider-specific formats (GitHub, GitLab, Slack, Stripe, OpenAI,
+Anthropic, Google, SendGrid, Twilio, npm, PyPI, Shopify, Square, Mailgun, DigitalOcean,
+Telegram, AWS secret keys). All of them are structurally unambiguous vendor formats — there is
+no entropy heuristic, because those false-positive on git SHAs and UUIDs.
+
+Add your own with `custom: { name: /regexp/ }`. Ruby patterns are translated to Rust regex
+syntax; unsupported constructs (backreferences, lookaround, atomic groups, possessive
+quantifiers) raise `Scrubber::UnsupportedPatternError` at construction time, naming the
+construct. You will never get silent partial coverage.
+
+```ruby
+Scrubber.new(custom: { dupe: /(\w)\1/ })
+# => Scrubber::UnsupportedPatternError: custom detector "dupe" uses \1, which this engine
+#    cannot compile: backreferences require backtracking.
+```
+
+### Overlapping matches
+
+When two detectors cover the same span, the more specific one wins: `password=ghp_…` reports
+`[API_KEY]`, not `[PASSWORD_PAIR]`. Redaction is always the same either way; only the label
+differs. Scrubbing already-scrubbed text is a no-op, so nested middleware won't corrupt lines.
+
+## Benchmarks
+
+<!-- BENCHMARK:START -->
+<!-- generated by `rake benchmark`; do not edit by hand -->
+
+| implementation | throughput | relative |
+|---|---|---|
+| scrubber_rb (Rust core) | **50.4 MB/s** | 1.0x |
+| pure-Ruby reference (identical detectors) | 1.3 MB/s | 38.2x slower |
+
+100MB synthetic log corpus (seed 42), all 14 default detectors, single thread, ruby 3.3.0 on arm64-darwin24.
+Best of 2 passes. Reproduce with `rake benchmark`.
+<!-- BENCHMARK:END -->
+
+Per-line latency, which is what matters when this sits in your logger:
+
+| implementation | one log line | relative |
+|---|---|---|
+| scrubber_rb | **1.24 µs** | 1.0x |
+| pure-Ruby reference | 102.98 µs | 83x slower |
+
+A Rust scan costs about a microsecond per log line, which is why it is safe to put on the
+write path of every `Rails.logger` call.
+
+**Methodology**, because a benchmark you can't audit is marketing:
+
+- The baseline in `benchmark/pure_ruby_reference.rb` implements the **identical detector set**
+  — same patterns, same Luhn/Verhoeff/mod-97 checksums, same context validators, same
+  capture-group behaviour. It is written as good Ruby, not a strawman: one combined `Regexp`,
+  one `gsub` pass, no per-detector loop.
+- `spec/benchmark_reference_spec.rb` asserts the two implementations **redact identical spans**
+  on every fixture and on a slice of the corpus. If someone tightens a Rust detector and
+  forgets the reference, the suite fails before anyone reads this table.
+- The corpus is seeded synthetic production-shaped logs (`benchmark/corpus/generate.rb`), ~12%
+  of lines carrying something redactable. Raising that rate would flatter the Rust engine,
+  since pure Ruby is fastest on lines with no matches.
+- Throughput is the best of N single-threaded full passes. CI enforces a 5x regression floor
+  (`rake benchmark:gate`) rather than restating the headline number, because shared runners
+  are noisy.
+
+The difference is architectural, not micro-optimisation. Ruby's Onigmo is a backtracking
+engine with no `RegexSet` and no Aho-Corasick prefilter, so every rule in the alternation is
+live on every byte. The Rust core runs one Aho-Corasick pass over the literal anchors
+(`AKIA`, `-----BEGIN`, `ghp_`, `password`) to eliminate roughly two thirds of the rules before
+any regex runs, then one `RegexSet` pass for the rest.
+
+`logstop` solves a narrower problem (log filtering, pure Ruby, zero native code) and solves it
+well. If that's all you need, use it — it has no native extension to build. Run
+`rake benchmark:logstop` for a scope-matched comparison.
+
+## Security
+
+- **ReDoS.** Rust's `regex` crate is a finite-automata engine with no backtracking, so match
+  time is linear in input length regardless of the pattern. Attacker-controlled log content
+  cannot pin a CPU. Custom Ruby patterns are checked at construction and rejected if they
+  require backtracking, so you can't reintroduce the problem through the back door.
+- **Panics.** Every FFI entry point is wrapped in `catch_unwind`. A bug in the Rust core
+  becomes a `Scrubber::InternalError`, never a process abort.
+- **Invalid UTF-8.** Scanning steps over invalid byte sequences and passes them through
+  unchanged, so a corrupt log line is scrubbed where it can be and never raises.
+- **No network, no persistence, no telemetry.** It's a pure function library.
+
+To report a vulnerability, see [SECURITY.md](SECURITY.md).
+
+## What this gem does NOT do
+
+Deterministic patterns can't catch free-form PII — **names, home addresses, medical notes**.
+That's NER-model territory. We'd rather be honest about this than give you false confidence.
+
+If your threat model includes free-text PII, layer a model-based pass behind this gem's fast
+structural pass: [`top_secret`](https://github.com/thoughtbot/top_secret) and its
+[`ruby_llm-top_secret`](https://github.com/thoughtbot/ruby_llm-top_secret) integration cover
+that ground in Ruby, and Microsoft Presidio does in Python. Structural first (fast, exact),
+model second (slow, fuzzy) is the right order.
+
+## Compatibility
+
+Ruby 3.1–3.4 · Linux (x86_64, aarch64; glibc & musl) · macOS (Intel, Apple Silicon) ·
+Windows best-effort. CI runs the full matrix plus a weekly ruby-head canary.
+
+## Contributing
+
+```bash
+git clone https://github.com/TheSoloHacker47/scrubber-rb && cd scrubber-rb
+bin/setup                  # bundle install + rake compile
+bundle exec rake           # compile + spec
+bundle exec rake ci        # everything CI runs, in CI's order
+```
+
+New detector proposals are welcome — include public test vectors and a false-positive analysis
+in the PR. See [CONTRIBUTING.md](CONTRIBUTING.md), and [docs/RELEASING.md](docs/RELEASING.md)
+for how a release is cut.
+
+## License
+
+[MIT](LICENSE).

data/SECURITY.md

@@ -0,0 +1,54 @@
+# Security Policy
+
+## Supported versions
+
+| Version | Supported |
+|---|---|
+| 0.1.x | ✅ |
+
+Until 1.0, security fixes land on the latest minor release.
+
+## Reporting a vulnerability
+
+Please **do not open a public issue.**
+
+Use GitHub's private reporting:
+[Report a vulnerability](https://github.com/TheSoloHacker47/scrubber-rb/security/advisories/new)
+
+Or email **thesolohacker47@gmail.com**.
+
+Please include a minimal reproduction and the version you're on. You'll get an
+acknowledgement within 72 hours and an assessment within a week.
+
+## What counts as a vulnerability here
+
+This gem's job is to remove sensitive data from text. So:
+
+- **A false negative is a security bug.** If input containing a credential or PII in a
+  supported format comes back unredacted, that's a vulnerability, not a feature request —
+  especially if the input is attacker-controlled and shaped to evade a detector (unusual
+  encodings, separator tricks, boundary manipulation).
+- **A partial redaction is a security bug.** Output that leaves part of a secret visible.
+- **A ReDoS or unbounded-resource path is a vulnerability.** The Rust `regex` crate is
+  linear-time, so this should be impossible for built-in detectors; if you find input that
+  makes scanning superlinear, we want to know.
+- **A panic or crash across the FFI boundary is a vulnerability.** Every entry point is
+  wrapped in `catch_unwind` and should surface as `Scrubber::InternalError`. A process abort
+  means the wrapping failed.
+- **Memory unsafety** in the native extension — use-after-free, out-of-bounds read, a data
+  race in the shared `Engine`.
+
+## What does not count
+
+- **Free-form PII going unredacted.** Names, street addresses, and medical notes are an
+  explicit non-goal, stated in the README. Deterministic patterns cannot find them; that needs
+  an NER model. This isn't a bug, it's the documented scope.
+- **A false positive.** Over-redacting is annoying and we'll fix it, but it doesn't leak
+  anything. Open a normal issue.
+- **Data your configuration didn't ask for.** If `:aadhaar` isn't in your `detectors:` list,
+  Aadhaar numbers won't be redacted. Check your configuration before reporting.
+
+## When you report
+
+Please redact your own reproduction input before sending it. If the input is a real credential,
+rotate it first — a bug report is not a safe place for a live key.

data/lib/scrubber/instance.rb

@@ -0,0 +1,223 @@
+# frozen_string_literal: true
+
+module Scrubber
+  # A compiled, immutable scrubber.
+  #
+  # Compiling ~35 regexes into one automaton is the expensive part; scanning is
+  # cheap. Build one of these at boot and reuse it forever:
+  #
+  #   SCRUBBER = Scrubber.new(replacement: :hash)
+  #   SCRUBBER.scrub(line)
+  #
+  # Instances are frozen and hold no per-call state, so a single instance is
+  # safe to share across every thread in the process.
+  class Instance
+    REPLACEMENTS = %i[label mask hash remove].freeze
+
+    # Read in 1MB slices, and never cut closer than this to the end of the
+    # buffer, so a match straddling a chunk boundary still sees both halves.
+    CHUNK_SIZE = 1024 * 1024
+    CARRY_SIZE = 8 * 1024
+
+    attr_reader :detectors, :custom, :replacement, :hash_salt
+
+    def initialize(detectors: Scrubber::DEFAULTS, custom: {}, replacement: :label, hash_salt: nil)
+      @detectors = normalize_detectors(detectors)
+      @custom = normalize_custom(custom)
+      @replacement = normalize_replacement(replacement)
+      @hash_salt = hash_salt&.to_s
+
+      @native = Native.new(
+        @detectors.map(&:to_s),
+        @custom.map { |name, regexp| [name.to_s, regexp.source, regexp.options] },
+        @replacement.to_s,
+        @hash_salt
+      )
+      freeze
+    end
+
+    # Redact every match in `text`, returning a new String with the same
+    # encoding. The input is never mutated, and frozen input is fine.
+    def scrub(text)
+      str = coerce(text)
+      replaced = @native.scrub(str)
+      return str.dup if replaced.nil?
+
+      replaced.force_encoding(str.encoding)
+    end
+
+    # Redact in place. Returns the same object, so it raises FrozenError on a
+    # frozen string exactly like every other Ruby bang method.
+    def scrub!(text)
+      str = coerce(text)
+      replaced = @native.scrub(str)
+      return str if replaced.nil?
+
+      str.replace(replaced.force_encoding(str.encoding))
+    end
+
+    # Find matches without replacing them.
+    #
+    #   Scrubber.detect("mail nik@example.com")
+    #   # => [#<Scrubber::Match type=:email 5...20 preview="n**@e******.com">]
+    #
+    # Offsets are character offsets into `text`, not byte offsets, so they index
+    # the Ruby string correctly even when it contains emoji or Devanagari.
+    def detect(text)
+      str = coerce(text)
+      # Only UTF-8 needs byte->character conversion; in single-byte encodings
+      # the two are the same number.
+      char_offsets = str.encoding == Encoding::UTF_8
+      @native.detect(str, char_offsets).map do |type, from, to, preview|
+        Match.new(type: type.to_sym, begin: from, end: to, preview: preview)
+      end
+    end
+
+    # True if anything at all would be redacted. Cheaper than `scrub` when you
+    # only need a yes/no (an audit check, a test assertion, a CI gate).
+    def match?(text)
+      # `detect` stops at the match list; it never builds the output string.
+      !@native.detect(coerce(text), false).empty?
+    end
+
+    # Stream a file through the engine.
+    #
+    # Reads in 1MB chunks and cuts each chunk at the last line break before an
+    # 8KB carry window, so a match spanning a chunk boundary is never sliced in
+    # half. Multi-line PEM blocks get an extra guard: if a chunk would end
+    # between BEGIN and END, the cut moves back before the BEGIN.
+    #
+    # Returns the number of bytes written.
+    def scrub_file(input_path, output_path, chunk_size: CHUNK_SIZE)
+      written = 0
+      File.open(input_path, "rb") do |input|
+        File.open(output_path, "wb") do |output|
+          each_safe_chunk(input, chunk_size) do |chunk|
+            written += output.write(@native.scrub(chunk) || chunk)
+          end
+        end
+      end
+      written
+    end
+
+    # How many compiled patterns back this instance. Detectors expand to more
+    # than one rule each in a few cases (`:api_key` alone is ~19).
+    def rule_count
+      @native.rule_count
+    end
+
+    def inspect
+      "#<Scrubber::Instance detectors=#{@detectors.size} rules=#{rule_count} " \
+        "replacement=#{@replacement.inspect}>"
+    end
+
+    # Config identity, used to memoize module-level `Scrubber.scrub` calls.
+    def cache_key
+      self.class.cache_key(
+        detectors: @detectors, custom: @custom,
+        replacement: @replacement, hash_salt: @hash_salt
+      )
+    end
+
+    def self.cache_key(detectors:, custom:, replacement:, hash_salt:)
+      customs = custom.to_a.map do |name, regexp|
+        source = regexp.respond_to?(:source) ? regexp.source : regexp.to_s
+        options = regexp.respond_to?(:options) ? regexp.options : 0
+        [name.to_sym, source, options]
+      end
+      [Array(detectors).map(&:to_sym).sort, customs.sort, replacement.to_sym, hash_salt&.to_s]
+    end
+
+    private
+
+    def coerce(text)
+      return text if text.is_a?(String)
+      raise TypeError, "expected a String, got #{text.class}" unless text.respond_to?(:to_str)
+
+      text.to_str
+    end
+
+    def normalize_detectors(detectors)
+      list = Array(detectors).map do |d|
+        unless d.respond_to?(:to_sym)
+          raise ConfigurationError,
+                "detector names must be Symbols or Strings, got #{d.class}"
+        end
+
+        d.to_sym
+      end
+      list.uniq.freeze
+    end
+
+    def normalize_custom(custom)
+      raise ConfigurationError, "custom: must be a Hash of name => Regexp" unless custom.respond_to?(:to_h)
+
+      custom.to_h.each_with_object({}) do |(name, regexp), out|
+        unless regexp.is_a?(Regexp)
+          raise ConfigurationError,
+                "custom detector #{name.inspect} must be a Regexp, got #{regexp.class}"
+        end
+
+        out[name.to_sym] = regexp
+      end.freeze
+    end
+
+    def normalize_replacement(replacement)
+      sym = replacement.to_sym
+      unless REPLACEMENTS.include?(sym)
+        raise ConfigurationError,
+              "unknown replacement #{replacement.inspect}. Expected one of: #{REPLACEMENTS.join(", ")}"
+      end
+
+      sym
+    end
+
+    # Yields byte slices that are safe to scan independently.
+    def each_safe_chunk(input, chunk_size)
+      buffer = +""
+      buffer.force_encoding(Encoding::BINARY)
+
+      while (chunk = input.read(chunk_size))
+        buffer << chunk
+        next if buffer.bytesize <= CARRY_SIZE
+
+        cut = safe_cut(buffer)
+        next if cut.zero?
+
+        yield buffer.byteslice(0, cut)
+        buffer = buffer.byteslice(cut, buffer.bytesize - cut)
+      end
+
+      yield buffer unless buffer.empty?
+    end
+
+    # Where can this buffer be cut without slicing a match in half?
+    def safe_cut(buffer)
+      limit = buffer.bytesize - CARRY_SIZE
+      return 0 if limit <= 0
+
+      cut = buffer.rindex("\n", limit - 1)
+      cut = cut ? cut + 1 : limit
+      pem_safe_cut(buffer, cut)
+    end
+
+    # A PEM block can be longer than the carry window, so cutting at a line
+    # break is not enough: if the head we are about to emit opens a block it
+    # does not close, back the cut up to just before that BEGIN.
+    def pem_safe_cut(buffer, cut)
+      # Give up on the guard rather than buffer a whole file: a PEM block this
+      # big is malformed, and unbounded memory growth is the worse failure.
+      return cut if buffer.bytesize > CHUNK_SIZE * 8
+
+      head = buffer.byteslice(0, cut)
+      opens = head.scan("-----BEGIN").size
+      closes = head.scan("-----END").size
+      return cut if opens <= closes
+
+      last_begin = head.rindex("-----BEGIN")
+      return cut if last_begin.nil? || last_begin.zero?
+
+      last_begin
+    end
+  end
+end

data/lib/scrubber/llm_guard.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Scrubber
+  # Redact prompts on their way to a third-party model API.
+  #
+  #   guard = Scrubber::LLMGuard.new(replacement: :hash)
+  #   chat.ask(guard.call(user_message))
+  #
+  # `:hash` is the interesting default here. With `[EMAIL:9f86d081]` tokens the
+  # model can still reason about "the same customer" across a conversation, and
+  # your logs of that conversation stay correlatable, without the value ever
+  # crossing the network.
+  #
+  # It accepts the shapes prompts actually come in:
+  #
+  #   guard.call("my email is nik@example.com")
+  #   guard.call([{ role: "user", content: "..." }])
+  #   guard.call({ role: "user", content: "..." })
+  #
+  # There is no framework hook here on purpose. `LLMGuard` is a plain callable,
+  # so it drops into RubyLLM, langchainrb, ruby-openai, anthropic-sdk-ruby, or a
+  # hand-rolled `Net::HTTP` call the same way. See the README for the RubyLLM
+  # wrapper pattern.
+  class LLMGuard
+    # Message hash keys whose values are prompt text.
+    CONTENT_KEYS = %w[content text prompt input].freeze
+
+    attr_reader :scrubber
+
+    def initialize(scrubber: nil, replacement: :hash, **options)
+      @scrubber = scrubber || Scrubber.new(replacement: replacement, **options)
+    end
+
+    # Redact `input`, preserving its shape.
+    def call(input)
+      case input
+      when String then @scrubber.scrub(input)
+      when Array  then input.map { |item| call(item) }
+      when Hash   then scrub_hash(input)
+      when Symbol, Numeric, NilClass, TrueClass, FalseClass then input
+      else
+        input.respond_to?(:to_str) ? @scrubber.scrub(input.to_str) : input
+      end
+    end
+    alias scrub call
+
+    # Usable directly as a block: `messages.map(&guard)`.
+    def to_proc
+      method(:call).to_proc
+    end
+
+    # What would have been redacted. Handy for a "we blocked N leaks today"
+    # metric, or for failing a test when a prompt builder regresses.
+    def findings(input)
+      case input
+      when String then @scrubber.detect(input)
+      when Array  then input.flat_map { |item| findings(item) }
+      when Hash   then content_values(input).flat_map { |v| findings(v) }
+      else []
+      end
+    end
+
+    private
+
+    def scrub_hash(hash)
+      hash.each_with_object(hash.class.new) do |(key, value), out|
+        out[key] = content_key?(key) || value.is_a?(Array) || value.is_a?(Hash) ? call(value) : value
+      end
+    end
+
+    def content_values(hash)
+      hash.filter_map { |key, value| value if content_key?(key) }
+    end
+
+    def content_key?(key)
+      CONTENT_KEYS.include?(key.to_s)
+    end
+  end
+end

data/lib/scrubber/log_formatter.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Scrubber
+  # Wraps an existing Logger formatter and redacts whatever it produces.
+  #
+  #   # config/initializers/scrubber.rb
+  #   Rails.logger.formatter = Scrubber::LogFormatter.new(Rails.logger.formatter)
+  #
+  # Wrapping the formatter rather than the logger means it catches everything:
+  # your own `Rails.logger.info`, Active Record's SQL echo, Rack's request
+  # lines, and the exception messages your error middleware logs on the way out.
+  #
+  # It runs on the log write path, so it is worth knowing what it costs: one
+  # Rust scan per line, which on typical log lines is a few microseconds. If
+  # your app is log-bound, narrow `detectors:` to what you actually care about.
+  class LogFormatter
+    attr_reader :scrubber
+
+    # @param formatter [#call] the formatter to wrap. Defaults to
+    #   `Logger::Formatter`, which is what a bare `Logger` uses.
+    # @param scrubber [Scrubber::Instance] a prebuilt engine, if you have one.
+    # @param options [Hash] otherwise, options for {Scrubber.new}.
+    def initialize(formatter = nil, scrubber: nil, **options)
+      @formatter = formatter || self.class.default_formatter
+      @scrubber = scrubber || Scrubber.new(**options)
+    end
+
+    def call(severity, time, progname, msg)
+      formatted = @formatter.call(severity, time, progname, msg)
+      return formatted unless formatted.is_a?(String)
+
+      @scrubber.scrub(formatted)
+    end
+
+    def self.default_formatter
+      require "logger"
+      ::Logger::Formatter.new
+    end
+  end
+end

data/lib/scrubber/match.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Scrubber
+  # One thing the engine found, without the thing itself.
+  #
+  # `begin` and `end` are character offsets into the string you passed, so
+  # `text[match.begin...match.end]` gives you the raw value back if you really
+  # want it. `preview` is already masked — it exists so you can log "we found an
+  # email here" without logging the email.
+  Match = Struct.new(:type, :begin, :end, :preview, keyword_init: true) do
+    # The span as a Range, ready for `String#[]`.
+    def to_range
+      self.begin...self.end
+    end
+
+    # Length of the match in characters.
+    def length
+      self.end - self.begin
+    end
+
+    def inspect
+      "#<Scrubber::Match type=#{type.inspect} #{self.begin}...#{self.end} " \
+        "preview=#{preview.inspect}>"
+    end
+    alias_method :to_s, :inspect
+  end
+end

data/lib/scrubber/middleware.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module Scrubber
+  # Rack middleware that makes a redacted view of the request available to
+  # everything downstream, and redacts exception messages on the way out.
+  #
+  #   use Scrubber::Middleware, detectors: Scrubber::DEFAULTS
+  #
+  # == What it does not do
+  #
+  # It does not rewrite `QUERY_STRING`, `rack.input`, or `params`. Redacting the
+  # request the application is about to act on would break every login form in
+  # the world: the app needs the real password to check it. What leaks is not
+  # the request, it is the *record* of the request — the log line, the error
+  # tracker payload, the APM trace.
+  #
+  # So this middleware gives you redacted copies to record:
+  #
+  #   env["scrubber.query_string"]  # "user=x&password=[PASSWORD_PAIR]"
+  #   env["scrubber.params"]        # { "user" => "x", "password" => "[PASSWORD_PAIR]" }
+  #   env["scrubber.instance"]      # the engine, for anything else you log
+  #
+  # and it redacts the message of any exception raised further down the stack
+  # before re-raising it, so an error tracker that never heard of this gem still
+  # gets a clean payload.
+  class Middleware
+    QUERY_STRING = "QUERY_STRING"
+    ENV_QUERY = "scrubber.query_string"
+    ENV_PARAMS = "scrubber.params"
+    ENV_INSTANCE = "scrubber.instance"
+
+    attr_reader :scrubber
+
+    # @param app [#call] the next Rack app.
+    # @param scrubber [Scrubber::Instance] a prebuilt engine, if you have one.
+    # @param scrub_exceptions [Boolean] redact exception messages (default true).
+    # @param options [Hash] otherwise, options for {Scrubber.new}.
+    def initialize(app, scrubber: nil, scrub_exceptions: true, **options)
+      @app = app
+      @scrubber = scrubber || Scrubber.new(**options)
+      @scrub_exceptions = scrub_exceptions
+    end
+
+    def call(env)
+      annotate(env)
+      @app.call(env)
+    rescue StandardError => e
+      raise unless @scrub_exceptions
+
+      raise redacted(e)
+    end
+
+    private
+
+    def annotate(env)
+      env[ENV_INSTANCE] = @scrubber
+      query = env[QUERY_STRING]
+      return if query.nil? || query.empty?
+
+      # Decode *before* scrubbing. `email=nik%40example.com` does not look like
+      # an email address until the `%40` is a `@`, and a redactor that can be
+      # defeated by percent-encoding is not a redactor. The decoded key is put
+      # back in front of the value before scrubbing, because `:password_pair`
+      # needs that context to recognise `hunter2` as a password at all.
+      pairs = parse_pairs(query).map { |key, value| [key, scrub_value(key, value)] }
+
+      env[ENV_PARAMS] = pairs.to_h
+      # Rebuilt from the decoded pairs, so this is a string for logs to print,
+      # not a query string to re-issue a request with.
+      env[ENV_QUERY] = pairs.map { |key, value| "#{key}=#{value}" }.join("&")
+    end
+
+    # Deliberately not `Rack::Utils.parse_nested_query`: this is a logging aid,
+    # it must never raise on a malformed query string, and the gem must stay
+    # loadable without Rack.
+    def parse_pairs(query)
+      query.split("&").filter_map do |pair|
+        key, _, value = pair.partition("=")
+        next if key.empty?
+
+        [unescape(key), unescape(value)]
+      end
+    end
+
+    def scrub_value(key, value)
+      scrubbed = @scrubber.scrub("#{key}=#{value}")
+      prefix = "#{key}="
+      scrubbed.start_with?(prefix) ? scrubbed[prefix.length..] : scrubbed.partition("=").last
+    end
+
+    def unescape(str)
+      decoded = str.tr("+", " ").gsub(/%([0-9a-fA-F]{2})/) { [Regexp.last_match(1)].pack("H2") }
+      decoded.force_encoding(Encoding::UTF_8)
+      decoded.valid_encoding? ? decoded : decoded.force_encoding(Encoding::BINARY)
+    rescue StandardError
+      str
+    end
+
+    # Rebuild the exception with a redacted message, keeping its class and
+    # backtrace so error groupers still group it the same way.
+    def redacted(error)
+      message = error.message
+      return error unless message.is_a?(String)
+
+      clean = @scrubber.scrub(message)
+      return error if clean == message
+
+      replacement = rebuild(error, clean)
+      return error if replacement.nil?
+
+      replacement.set_backtrace(error.backtrace) if error.backtrace
+      replacement
+    end
+
+    # Some exception classes have a non-standard `initialize` and cannot be
+    # rebuilt from a message. Better the original than a crash in the middleware
+    # that was supposed to protect you.
+    def rebuild(error, message)
+      error.exception(message)
+    rescue StandardError
+      nil
+    end
+  end
+end

data/lib/scrubber/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Scrubber
+  VERSION = "0.1.0"
+end

data/lib/scrubber_rb.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require_relative "scrubber/version"
+
+# Precompiled platform gems ship the extension under a Ruby ABI directory
+# (lib/scrubber_rb/3.3/scrubber_rb.so); a source build puts it one level up.
+begin
+  RUBY_VERSION =~ /(\d+\.\d+)/
+  require_relative "scrubber_rb/#{Regexp.last_match(1)}/scrubber_rb"
+rescue LoadError
+  require_relative "scrubber_rb/scrubber_rb"
+end
+
+require_relative "scrubber/match"
+require_relative "scrubber/instance"
+require_relative "scrubber/log_formatter"
+require_relative "scrubber/middleware"
+require_relative "scrubber/llm_guard"
+
+# Fast PII and secret redaction, with the scanning done in Rust.
+#
+#   Scrubber.scrub("contact nik@example.com")  # => "contact [EMAIL]"
+#
+# The module-level methods are the convenient path and memoize one compiled
+# engine per distinct configuration. For hot loops, build a {Scrubber::Instance}
+# yourself with {Scrubber.new} and keep it around.
+module Scrubber
+  # Detectors enabled unless you say otherwise. Sourced from the Rust registry
+  # so there is exactly one copy of this list in the project.
+  DEFAULTS = Native.default_detectors.map(&:to_sym).freeze
+
+  # Opt-in India pack, for DPDP Act workloads:
+  #
+  #   Scrubber.new(detectors: Scrubber::DEFAULTS + Scrubber::INDIA)
+  INDIA = Native.india_detectors.map(&:to_sym).freeze
+
+  # Every detector this build knows about.
+  ALL = Native.all_detectors.map(&:to_sym).freeze
+
+  class << self
+    # Build a reusable, frozen scrubber. See {Scrubber::Instance}.
+    def new(detectors: DEFAULTS, custom: {}, replacement: :label, hash_salt: nil)
+      Instance.new(
+        detectors: detectors, custom: custom,
+        replacement: replacement, hash_salt: hash_salt
+      )
+    end
+
+    # Redact `text` using a memoized engine for these options.
+    def scrub(text, **options)
+      engine(**options).scrub(text)
+    end
+
+    # Redact `text` in place.
+    def scrub!(text, **options)
+      engine(**options).scrub!(text)
+    end
+
+    # Locate matches without replacing them. Returns {Scrubber::Match} structs.
+    def detect(text, **options)
+      engine(**options).detect(text)
+    end
+
+    # True if anything would be redacted.
+    def match?(text, **options)
+      engine(**options).match?(text)
+    end
+
+    # Stream a file through the engine. Returns bytes written.
+    def scrub_file(input_path, output_path, **options)
+      chunk_size = options.delete(:chunk_size) || Instance::CHUNK_SIZE
+      engine(**options).scrub_file(input_path, output_path, chunk_size: chunk_size)
+    end
+
+    # The memoized {Scrubber::Instance} for a set of options. Exposed because
+    # asking for it explicitly beats accidentally rebuilding one per request.
+    def engine(detectors: DEFAULTS, custom: {}, replacement: :label, hash_salt: nil)
+      key = Instance.cache_key(
+        detectors: detectors, custom: custom,
+        replacement: replacement, hash_salt: hash_salt
+      )
+      # Double-checked: reads are lock-free on the happy path, and building the
+      # same engine twice under a race is harmless (they are identical and
+      # immutable), so the mutex only prevents wasted work.
+      cache[key] || cache_mutex.synchronize do
+        cache[key] ||= new(
+          detectors: detectors, custom: custom,
+          replacement: replacement, hash_salt: hash_salt
+        )
+      end
+    end
+
+    # Drop memoized engines. Only useful in tests.
+    def reset!
+      cache_mutex.synchronize { cache.clear }
+      nil
+    end
+
+    private
+
+    def cache
+      @cache ||= {}
+    end
+
+    def cache_mutex
+      @cache_mutex ||= Mutex.new
+    end
+  end
+end

data/sig/scrubber_rb.rbs

@@ -0,0 +1,150 @@
+# Type signatures for scrubber_rb.
+
+module Scrubber
+  VERSION: String
+
+  # Detector keys, sourced from the Rust registry at load time.
+  DEFAULTS: Array[Symbol]
+  INDIA: Array[Symbol]
+  ALL: Array[Symbol]
+
+  type detector = Symbol | String
+  type replacement = :label | :mask | :hash | :remove
+  type custom_patterns = Hash[Symbol | String, Regexp]
+
+  class Error < StandardError
+  end
+
+  # Raised when a detector key is not in the registry.
+  class UnknownDetectorError < Error
+  end
+
+  # Raised at construction time when a custom Regexp needs backtracking.
+  class UnsupportedPatternError < Error
+  end
+
+  # Raised for an invalid replacement strategy or malformed options.
+  class ConfigurationError < Error
+  end
+
+  # Raised when a panic is caught at the FFI boundary. Always a bug.
+  class InternalError < Error
+  end
+
+  class Match < Struct[untyped]
+    attr_accessor type: Symbol
+    attr_accessor begin: Integer
+    attr_accessor end: Integer
+    attr_accessor preview: String
+
+    def to_range: () -> Range[Integer]
+    def length: () -> Integer
+  end
+
+  # The compiled engine. Frozen; safe to share across threads.
+  class Instance
+    REPLACEMENTS: Array[Symbol]
+    CHUNK_SIZE: Integer
+    CARRY_SIZE: Integer
+
+    attr_reader detectors: Array[Symbol]
+    attr_reader custom: custom_patterns
+    attr_reader replacement: Symbol
+    attr_reader hash_salt: String?
+
+    def initialize: (
+      ?detectors: Array[detector],
+      ?custom: custom_patterns,
+      ?replacement: replacement | String,
+      ?hash_salt: String?
+    ) -> void
+
+    def scrub: (String | _ToStr) -> String
+    def scrub!: (String) -> String
+    def detect: (String | _ToStr) -> Array[Match]
+    def match?: (String | _ToStr) -> bool
+    def scrub_file: (String | ::Pathname, String | ::Pathname, ?chunk_size: Integer) -> Integer
+    def rule_count: () -> Integer
+    def cache_key: () -> Array[untyped]
+
+    def self.cache_key: (
+      detectors: Array[detector],
+      custom: custom_patterns,
+      replacement: replacement | String,
+      hash_salt: String?
+    ) -> Array[untyped]
+  end
+
+  # Wraps a Logger formatter and redacts its output.
+  class LogFormatter
+    attr_reader scrubber: Instance
+
+    def initialize: (?untyped formatter, ?scrubber: Instance?, **untyped) -> void
+    def call: (String severity, Time time, untyped progname, untyped msg) -> untyped
+    def self.default_formatter: () -> untyped
+  end
+
+  # Rack middleware. Non-destructive: publishes redacted copies at env["scrubber.*"].
+  class Middleware
+    QUERY_STRING: String
+    ENV_QUERY: String
+    ENV_PARAMS: String
+    ENV_INSTANCE: String
+
+    attr_reader scrubber: Instance
+
+    def initialize: (
+      untyped app,
+      ?scrubber: Instance?,
+      ?scrub_exceptions: bool,
+      **untyped
+    ) -> void
+    def call: (Hash[String, untyped] env) -> untyped
+  end
+
+  # Redacts prompts before they reach a model API.
+  class LLMGuard
+    CONTENT_KEYS: Array[String]
+
+    attr_reader scrubber: Instance
+
+    def initialize: (?scrubber: Instance?, ?replacement: replacement, **untyped) -> void
+    def call: (untyped) -> untyped
+    alias scrub call
+    def to_proc: () -> Proc
+    def findings: (untyped) -> Array[Match]
+  end
+
+  # The native extension. Not a public API; use Scrubber::Instance.
+  class Native
+    def self.new: (
+      Array[String] detectors,
+      Array[[String, String, Integer]] customs,
+      String replacement,
+      String? hash_salt
+    ) -> Native
+
+    def self.default_detectors: () -> Array[String]
+    def self.india_detectors: () -> Array[String]
+    def self.all_detectors: () -> Array[String]
+
+    def scrub: (String) -> String?
+    def detect: (String, bool) -> Array[[String, Integer, Integer, String]]
+    def rule_count: () -> Integer
+  end
+
+  def self.new: (
+    ?detectors: Array[detector],
+    ?custom: custom_patterns,
+    ?replacement: replacement | String,
+    ?hash_salt: String?
+  ) -> Instance
+
+  def self.scrub: (String | _ToStr, **untyped) -> String
+  def self.scrub!: (String, **untyped) -> String
+  def self.detect: (String | _ToStr, **untyped) -> Array[Match]
+  def self.match?: (String | _ToStr, **untyped) -> bool
+  def self.scrub_file: (String | ::Pathname, String | ::Pathname, **untyped) -> Integer
+  def self.engine: (**untyped) -> Instance
+  def self.reset!: () -> nil
+end

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification
+name: scrubber_rb
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: aarch64-linux
+authors:
+- Nikhil Nelson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2026-08-16 00:00:00.000000000 Z
+dependencies: []
+description: Redact emails, phone numbers, credit cards, SSNs, IBANs, IPs, JWTs, API
+  keys, private keys and Indian IDs (Aadhaar/PAN/UPI) from any string in a single
+  pass through a Rust engine. Checksum-validated (Luhn, Verhoeff, mod-97) so random
+  numbers are not mistaken for card numbers, and ReDoS-immune by construction. Ships
+  a Rails log formatter, Rack middleware and an LLM prompt guard.
+email:
+- thesolohacker47@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".cargo/config.toml"
+- CHANGELOG.md
+- LICENSE
+- README.md
+- SECURITY.md
+- lib/scrubber/instance.rb
+- lib/scrubber/llm_guard.rb
+- lib/scrubber/log_formatter.rb
+- lib/scrubber/match.rb
+- lib/scrubber/middleware.rb
+- lib/scrubber/version.rb
+- lib/scrubber_rb.rb
+- lib/scrubber_rb/3.1/scrubber_rb.so
+- lib/scrubber_rb/3.2/scrubber_rb.so
+- lib/scrubber_rb/3.3/scrubber_rb.so
+- lib/scrubber_rb/3.4/scrubber_rb.so
+- sig/scrubber_rb.rbs
+homepage: https://github.com/TheSoloHacker47/scrubber-rb
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/TheSoloHacker47/scrubber-rb
+  source_code_uri: https://github.com/TheSoloHacker47/scrubber-rb
+  bug_tracker_uri: https://github.com/TheSoloHacker47/scrubber-rb/issues
+  changelog_uri: https://github.com/TheSoloHacker47/scrubber-rb/blob/main/CHANGELOG.md
+  documentation_uri: https://github.com/TheSoloHacker47/scrubber-rb#readme
+  rubygems_mfa_required: 'true'
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+  - - "<"
+    - !ruby/object:Gem::Version
+      version: 3.5.dev
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.3.11
+requirements: []
+rubygems_version: 3.5.23
+signing_key: 
+specification_version: 4
+summary: Fast PII and secret redaction for Ruby, with a Rust core.
+test_files: []