diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 9092d604..8c4bb9ff 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -49,11 +49,11 @@ as part of the same PR.
   spec, move the long form into the type's XML docs and leave a tight
   example in the readme.
 - **Package readmes** — each package that ships its own readme
-  ([`StrongTypes.EfCore`](src/StrongTypes.EfCore/readme.md),
+  ([`StrongTypes.Configuration`](src/StrongTypes.Configuration/readme.md),
+  [`StrongTypes.EfCore`](src/StrongTypes.EfCore/readme.md),
   [`StrongTypes.FsCheck`](src/StrongTypes.FsCheck/readme.md),
   [`StrongTypes.OpenApi.Microsoft`](src/StrongTypes.OpenApi.Microsoft/readme.md),
   [`StrongTypes.OpenApi.Swashbuckle`](src/StrongTypes.OpenApi.Swashbuckle/readme.md),
-  [`StrongTypes.Wpf`](src/StrongTypes.Wpf/readme.md),
   [`StrongTypes.AspNetCore`](src/StrongTypes.AspNetCore/readme.md))
   should reflect what the package actually does after your change. Update
   the one that matches.
diff --git a/Skill/SKILL.md b/Skill/SKILL.md
index fa8451a1..c2b4a5b7 100644
--- a/Skill/SKILL.md
+++ b/Skill/SKILL.md
@@ -9,7 +9,8 @@ Library of focused C# value wrappers (`NonEmptyString`, `Positive<T>`,
 `NonEmptyEnumerable<T>`, …) and algebraic types (`Maybe<T>`,
 `Result<T, TError>`) that push invariants into the type system. Every
 wrapper ships a `System.Text.Json` converter, so invalid input fails at
-deserialization before any endpoint code runs.
+deserialization before any endpoint code runs, and a `TypeConverter`, so
+the same invariant validates `appsettings.json` as it binds.
 
 Per-type detail lives in `references/*.md` — load the relevant file on
 demand when about to write code against that surface.
@@ -19,19 +20,20 @@ demand when about to write code against that surface.
 | Package                       | What it gives you                                                                                                  |
 | ----------------------------- | ------------------------------------------------------------------------------------------------------------------ |
 | `Kalicz.StrongTypes`          | The core types (`NonEmptyString`, numeric wrappers, `NonEmptyEnumerable<T>`, `Maybe<T>`, `Result<T, TError>`, …).  |
+| `Kalicz.StrongTypes.Configuration` | `OptionsBuilder<T>.BindStrongTypes()` — binds a section and fails when a property declared non-nullable is null once bound, which an absent key otherwise leaves silently. Reads intent from nullable annotations, so no `[Required]` per property. |
 | `Kalicz.StrongTypes.EfCore`   | EF Core value converters, interval column mapping (two endpoint columns by default, JSON opt-in), and LINQ translators (`.Unwrap()`, interval `Start`/`End`) so strong types sit directly on entity properties. |
 | `Kalicz.StrongTypes.FsCheck`  | FsCheck `Arbitrary<T>` generators registered via `[Properties(Arbitrary = new[] { typeof(Generators) })]`.         |
 | `Kalicz.StrongTypes.OpenApi.Microsoft`   | Schema transformers for `Microsoft.AspNetCore.OpenApi` (`AddOpenApi()`) so wrappers render as the wire JSON shape, not the CLR shape. |
 | `Kalicz.StrongTypes.OpenApi.Swashbuckle` | The same idea for Swashbuckle's `AddSwaggerGen()` pipeline — schema filters that produce the wire JSON shape. |
-| `Kalicz.StrongTypes.Wpf`      | `TypeConverter` infrastructure for two-way MVVM binding to strong-typed view-model properties. One `this.UseStrongTypes()` call in `App.OnStartup`. |
 | `Kalicz.StrongTypes.AspNetCore` | MVC model binder for `NonEmptyEnumerable<T>` from `[FromForm]` / `[FromQuery]` / `[FromHeader]` / `[FromRoute]`, **plus** opt-out normalization of JSON request-body validation error keys (`$.value` → `Value`) so they match data-annotation / model-binding keys. The binder is niche; `[FromBody]` round-trips wrappers via the core JSON converters without it. |
 
 Add packages only when the host project actually hits that stack:
 
+- **Configuration** — when a non-nullable reference property (`NonEmptyString`, `Email`, or a plain `string`) sits on an options class. Binding works without it (every wrapper carries a `TypeConverter`); the package only stops an absent key leaving that property null. Skip it if every reference property is nullable or has a default, or if you already use `[Required]`. See `references/configuration.md`.
 - **EfCore** — only if EF Core is in use.
 - **FsCheck** — only for property-based test projects.
 - **OpenApi.Microsoft** vs **OpenApi.Swashbuckle** — pick **one**, matching the spec generator the app already wires up. They are not interchangeable. `references/openapi.md` covers both pipelines.
-- **Wpf** — only for WPF apps that two-way bind to strong-typed VM properties. See `references/wpf.md`.
+- **WPF / WinForms** — no package. Two-way binding works off the core package's `[TypeConverter]`s; there is nothing to install or call. A `Kalicz.StrongTypes.Wpf` package existed before v2 — if you find it referenced, remove it. See `references/wpf.md`.
 - **AspNetCore** — add it when a controller takes `NonEmptyEnumerable<T>` from a non-body source (forms, repeated query params, header lists), **or** when you want JSON request-body validation errors keyed by the property name (`Value`) instead of the System.Text.Json path (`$.value`). The error-key normalization is on by default once `AddStrongTypes()` is called — opt out with `AddStrongTypes(o => o.NormalizeJsonErrorKeys = false)`, or set `o.JsonErrorKeyCasing`. The binder alone is niche — `[FromBody]` already round-trips `NonEmptyEnumerable<T>` via the core JSON converters — but the error-key normalization applies to any JSON API. See `references/aspnetcore.md`.
 
 ## Type catalog — what's in the box
@@ -62,12 +64,13 @@ demand when about to write code against that surface.
 | Topic                                                         | Reference                       |
 | ------------------------------------------------------------- | ------------------------------- |
 | Enum extensions (`Enum.Parse`, `AllValues`, `AllFlagValues`, `GetFlags`) and `string?` parsers (`AsInt`, `AsGuid`, `AsEnum<T>`, …) | `references/parsing.md`         |
+| Configuration / `IOptions<T>` binding — zero setup, invariant doubles as validation, `ValidateOnStart()`, and `BindStrongTypes()` (`Kalicz.StrongTypes.Configuration`) for the absent key | `references/configuration.md`   |
 | `T?.Map`, `bool.MapTrue` / `MapFalse`                         | `references/map.md`             |
 | `IEnumerable<T>` extensions, `ReadOnlyList`, `Result` partition helpers | `references/collections.md`     |
 | EF Core: `UseStrongTypes` value converters, interval column mapping, `.Unwrap()` LINQ marker | `references/efcore.md`          |
 | FsCheck: shared `Generators` class, shipped arbitraries       | `references/fscheck.md`         |
 | OpenAPI: `AddStrongTypes()` for either `AddOpenApi()` (`Kalicz.StrongTypes.OpenApi.Microsoft`) or `AddSwaggerGen()` (`Kalicz.StrongTypes.OpenApi.Swashbuckle`) | `references/openapi.md`         |
-| WPF: `this.UseStrongTypes()` in `App.OnStartup` for two-way MVVM binding | `references/wpf.md` |
+| WPF / WinForms two-way MVVM binding — zero setup, `ValidatesOnExceptions=True`, culture, nullable properties | `references/wpf.md` |
 | ASP.NET Core MVC: `services.AddStrongTypes()` for `NonEmptyEnumerable<T>` from `[FromForm]` & friends, plus JSON request-body validation error-key normalization | `references/aspnetcore.md` |
 
 ## Design philosophy — picking the right wrapper
diff --git a/Skill/references/configuration.md b/Skill/references/configuration.md
new file mode 100644
index 00000000..3b47704d
--- /dev/null
+++ b/Skill/references/configuration.md
@@ -0,0 +1,203 @@
+# Configuration and options binding
+
+Strong types bind from `IConfiguration` / `IOptions<T>` with **no setup** —
+every wrapper carries a `TypeConverter`, which is what `ConfigurationBinder`
+uses to turn a config string into a typed value. Put the wrapper straight on
+the options class:
+
+```csharp
+public sealed class RetryOptions
+{
+    public Positive<int> MaxRetries { get; set; }
+    public NonNegative<int> InitialDelaySeconds { get; set; }
+    public NonEmptyString? Name { get; set; }
+    public Email? Contact { get; set; }
+    public Positive<int>? OptionalLimit { get; set; }   // absent key stays null
+}
+
+builder.Services.AddOptions<RetryOptions>()
+    .Bind(builder.Configuration.GetSection("Retry"))
+    .ValidateOnStart();                                  // see "Fail at startup" below
+```
+
+```json
+{
+  "Retry": {
+    "MaxRetries": 5,
+    "InitialDelaySeconds": 0,
+    "Name": "checkout",
+    "Contact": "ops@example.com"
+  }
+}
+```
+
+## The invariant is the validation rule
+
+This is the reason to use a wrapper here rather than a plain `int`. The type
+already says "must be positive", so a bad value is rejected without a
+`[Range]` attribute or a custom `IValidateOptions<T>`:
+
+```
+InvalidOperationException: Failed to convert configuration value '-5' at 'Retry:MaxRetries'
+                           to type 'StrongTypes.Positive`1[System.Int32]'.
+  ---> ArgumentException: Value must be positive, but was '-5'. (Parameter 'value')
+```
+
+The outer frame names the **config path** and the **offending value**; the
+inner one names the **broken invariant**. Don't add a `[Range(1, int.MaxValue)]`
+on top of a `Positive<int>` — it is the same rule stated twice, and only one
+of the two is enforced by the type.
+
+## Fail at startup, not on the first request
+
+Options binding is **lazy**. Without `ValidateOnStart()`, a bad value does not
+stop the app: it starts, serves traffic, and throws on the first request that
+reads `IOptions<T>.Value` — surfacing as a 500 rather than a failed deploy.
+
+```csharp
+builder.Services.AddOptions<RetryOptions>()
+    .Bind(builder.Configuration.GetSection("Retry"))
+    .ValidateOnStart();     // conversion failures now abort startup
+```
+
+`ValidateOnStart()` forces eager binding, so it catches conversion failures
+even with **no** `IValidateOptions<T>` registered. Always add it when options
+hold strong types — otherwise the invariant buys you a later crash, not an
+earlier one.
+
+## The missing key — `BindStrongTypes()`
+
+Add [`Kalicz.StrongTypes.Configuration`](https://www.nuget.org/packages/Kalicz.StrongTypes.Configuration/)
+and the declaration becomes the spec — no `[Required]`, no `ValidateDataAnnotations()`:
+
+```csharp
+builder.Services.AddOptions<ClientOptions>()
+    .BindStrongTypes(builder.Configuration.GetSection("Client"))
+    .ValidateOnStart();
+```
+
+It fails when a property **declared non-nullable is null after binding** — the one state an absent
+key can leave that the declaration forbids. Your nullable annotations already say which properties
+those are, so no `[Required]` has to repeat it:
+
+```csharp
+public sealed class ClientOptions
+{
+    public NonEmptyString Name { get; set; } = null!;          // fails unless configured
+    public NonEmptyString? Nickname { get; set; }              // nullable — fine
+    public string ApiKey { get; set; } = null!;                // fails unless configured
+    public string Endpoint { get; set; } = "https://x.test";   // has a default — never null
+    public Positive<int> MaxRetries { get; set; }              // never checked — see below
+}
+```
+
+```
+OptionsValidationException: 'Client:Name' is null. Configure it, give ClientOptions.Name a default,
+                            or declare it nullable.
+```
+
+**Every reference property is covered, not only the wrappers** — a non-nullable `string` is as
+broken by a missing key as a `NonEmptyString`. A declared default needs nothing: it isn't null.
+
+**At every depth, not just the top level.** Nested options classes, collection elements and
+dictionary values are all walked, and the failure names the full path (`'Client:Endpoints:1:Host'`).
+The walk stops exactly where `ConfigurationBinder` stops — at a type it has a `TypeConverter` for —
+so a wrapper is a leaf, never something to recurse into.
+
+**Value types are not checked, and don't need to be.** An unconfigured `Positive<int>` is `1` and an
+unconfigured `bool` is `false` — defaults, and values those types are happy to hold. There is no
+contradiction to catch, so this will not tell you that you forgot `MaxRetries`. Declare it
+`Positive<int>?` if "not configured" must be distinguishable; that is the only way the CLR offers.
+
+An options class in an assembly with `<Nullable>disable</Nullable>` declares no intent, so nothing
+on it is enforced.
+
+Analyzer **ST0004** flags a plain `Bind` / `Configure` that would leave a non-nullable wrapper null,
+with a code fix that rewrites the call. It reports only this library's own wrappers, never a plain
+`string`, so it sees less than the check it points you at. It also stays quiet for a property
+already carrying `[Required]`, which genuinely covers that case.
+
+The rest of this section describes what happens **without** that package.
+
+## `ValidateOnStart()` does not catch a *missing* value
+
+It only surfaces failures that binding itself raises. A key that simply isn't
+there raises nothing — binding succeeds, it just doesn't assign — so the
+property keeps whatever the options class gave it. Since a real options class
+has no initialisers, that means:
+
+| declaration                 | key not in config | is that a problem?                        |
+| --------------------------- | ----------------- | ----------------------------------------- |
+| `NonEmptyString Name`       | **`null`**        | **yes** — the type says it is never null   |
+| `Positive<int> MaxRetries`  | `1` (default)     | no — a value the type is happy to hold    |
+| `Positive<int>? MaxRetries` | `null`            | no — it is nullable                       |
+
+**A non-nullable `NonEmptyString` can be null.** The invariant constrains every
+value the type can hold; it cannot make the binder assign one. Against an
+unconfigured key the wrapper is no better than `string`, and that is the only
+place an absent key produces a state the declaration forbids.
+
+Guard it with `[Required]` and `ValidateDataAnnotations()` — or with
+`BindStrongTypes()` above, which reads the same intent from the nullable
+annotation instead of an attribute:
+
+```csharp
+builder.Services.AddOptions<RetryOptions>()
+    .Bind(builder.Configuration.GetSection("Retry"))
+    .ValidateDataAnnotations()   // [Required] → catches a null reference property
+    .ValidateOnStart();          // → catches an invalid value, at startup
+```
+
+Neither can help with a struct: `default(Positive<int>)` is `1`, so nothing
+distinguishes "configured as 1" from "never configured". Declare it
+`Positive<int>?` when that distinction matters — the CLR offers no other way
+to say it.
+
+## `null` and `""` — the exact matrix
+
+Not uniform, and not guessable. Measured; `ConfigurationBinder.Get<T>` and
+`IOptions<T>.Value` agree on **every** row:
+
+| in `appsettings.json` | `NonEmptyString` | `NonEmptyString?` | `Positive<int>` | `Positive<int>?` |
+| --------------------- | ---------------- | ----------------- | --------------- | ---------------- |
+| key absent            | **`null`** †     | `null`            | `1` (`default`) | `null`           |
+| `null`                | **`null`**       | `null`            | `1` (`default`) | `null`           |
+| `""`                  | **throws**       | **throws**        | **throws**      | **`null`**       |
+| `"  "`                | **throws**       | **throws**        | throws (format) | throws (format)  |
+| valid                 | binds            | binds             | binds           | binds            |
+| invariant breach      | throws           | throws            | throws          | throws           |
+
+† unless the options class initialises the property, which is rare — an absent
+key leaves whatever was already there, and for a reference type that is `null`.
+
+Three things in there surprise people:
+
+- **`""` is not uniform.** It throws for everything *except* a nullable **struct**
+  wrapper, where it binds to `null` — a nullable struct resolves to the BCL's
+  `NullableConverter`, which maps empty to null before our converter is consulted.
+  A nullable *reference* wrapper gets no such treatment (`NonEmptyString?` is the
+  same runtime type as `NonEmptyString`), so `""` reaches `Parse` and fails.
+  Don't reach for `""` to mean "unset" — omit the key.
+- **An explicit `null` nulls even a non-nullable reference property.** Nullability
+  is erased by the time the binder runs, so `"Name": null` leaves a
+  `NonEmptyString Name` holding `null`, exactly as it would a `string` — which is
+  precisely what `BindStrongTypes` (above) catches, treating it the same as an
+  absent key. Without that package, omit the key rather than writing `null`.
+- **An explicit `null` overwrites, an absent key does not.** `"Name": null` clears
+  a property initialised in the options class; leaving the key out keeps it.
+
+## Things worth knowing
+
+- **A missing key leaves the default**, it does not throw. `default(Positive<int>)`
+  is `1` and `default(NonNegative<int>)` is `0` — both satisfy their invariant, so
+  a typo'd key is a silently valid default. Use `Positive<int>?` when "not
+  configured" must be distinguishable from a configured value.
+- **`ConfigurationBinder` parses with the invariant culture**, so `"1234.5"` is
+  a `Positive<decimal>` of 1234.5 regardless of the host's locale. Config files
+  are not localized; don't write `1234,5`.
+- **Nullable wrappers still enforce the invariant** when a value is present:
+  `OptionalLimit` may be absent, but `-1` is rejected.
+- The same `TypeConverter` powers anything that goes through `TypeDescriptor` —
+  WPF/WinForms two-way binding (`references/wpf.md`), designers,
+  `PropertyGrid`, and libraries doing generic string↔object conversion. It is
+  one mechanism on the type, so none of them need a registration call.
diff --git a/Skill/references/numeric.md b/Skill/references/numeric.md
index 4ba7fa88..15673ea6 100644
--- a/Skill/references/numeric.md
+++ b/Skill/references/numeric.md
@@ -49,8 +49,53 @@ All four types have `AsX` / `ToX` extension methods available on any
   and matching `==`, `!=`, `<`, `<=`, `>`, `>=` operators on both sides —
   so `4.ToPositive() > 2` is just a comparison, no unwrap.
 - `GetHashCode`, `Equals(object?)`, `ToString()` delegating to the value.
+- `IFormattable` / `ISpanFormattable` — format specifiers and cultures reach
+  the underlying value (see "Formatting" below).
+- `IParsable<Self>` / `ISpanParsable<Self>` — `Parse` / `TryParse` from a
+  `string` or a `ReadOnlySpan<char>`, enforcing the invariant on the way in.
+  This is also what lets ASP.NET Core bind a wrapper from `[FromQuery]` /
+  `[FromRoute]` without any package.
 - `System.Text.Json` converter via `[JsonConverter]` — serialises as the
   underlying primitive.
+- `TypeConverter` via `[TypeConverter]` — binds from `appsettings.json` /
+  `IOptions<T>`. See `references/configuration.md`.
+
+## Formatting
+
+Format specifiers and format providers pass straight through to the
+underlying value, so a wrapper formats exactly like the number it wraps:
+
+```csharp
+var price = 1234.5m.ToPositive();
+
+$"{price:N2}"                          // "1,234.50"
+$"{price:C}"                           // "$1,234.50"
+string.Format(germanCulture, "{0}", price)   // "1234,5"
+price.ToString("N2", CultureInfo.InvariantCulture);
+```
+
+Note `price.ToString()` with no provider uses the **current culture**, same
+as `decimal.ToString()`. Pass an explicit provider anywhere the output is
+machine-read (logs, URLs, files) rather than displayed.
+
+Parsing accepts a span, so a wrapper can be read out of a larger buffer
+without slicing it into a string first:
+
+```csharp
+Positive<int>.Parse(line.AsSpan(6, 2), CultureInfo.InvariantCulture);
+Positive<int>.TryParse(span, CultureInfo.InvariantCulture, out var count);
+```
+
+Both interfaces also let a wrapper satisfy generic constraints, which no
+amount of reaching for `.Value` at the call site can do for the caller:
+
+```csharp
+static T Read<T>(ReadOnlySpan<char> s) where T : ISpanParsable<T> => T.Parse(s, null);
+static string Render<T>(T v, string f) where T : IFormattable => v.ToString(f, null);
+
+Read<Positive<int>>("42");
+Render(price, "C");
+```
 
 ## Arithmetic
 
diff --git a/Skill/references/wpf.md b/Skill/references/wpf.md
index 109607e9..b43a366d 100644
--- a/Skill/references/wpf.md
+++ b/Skill/references/wpf.md
@@ -1,50 +1,34 @@
-# WPF MVVM binding — `Kalicz.StrongTypes.Wpf`
+# WPF MVVM binding
 
-Adds the `TypeConverter` infrastructure WPF needs to two-way bind a
-`TextBox` (or any other input control) to a strong-typed view-model
-property.
+**No package, no setup.** Two-way binding a `TextBox` to a strong-typed
+view-model property works off the core `Kalicz.StrongTypes` package alone.
 
-## Why a separate package
+> There was a `Kalicz.StrongTypes.Wpf` package requiring a
+> `this.UseStrongTypes()` call in `App.OnStartup`. It is **gone as of v2** —
+> the core types now carry `[TypeConverter]` themselves. Delete the package
+> reference and the call; nothing replaces them. If you see
+> `UseStrongTypes()` on an `Application` in old code or a blog post, that is
+> the removed API. (The identically-named EF Core and OpenAPI
+> `UseStrongTypes()` calls are unrelated and still current.)
+
+## Why it works
 
 WPF's binding pipeline routes `string → T` through
-`TypeDescriptor.GetConverter(T)` and never consults `IParsable<T>`
-directly. Without a converter, typing into a `TextBox` bound to e.g.
-a `NonEmptyString` view-model property silently fails to update the
-source. The core `Kalicz.StrongTypes` package deliberately carries no
-UI dependency, so the wiring lives here.
-
-## Wiring
-
-Call `this.UseStrongTypes()` once in `App.OnStartup`. One call covers
-every strong type with a string round-trip — `NonEmptyString`, `Email`,
-`Digit`, and every closed instantiation of the generic numeric wrappers
-(`Positive<int>`, `Negative<decimal>`, …) — the package installs a
-`TypeDescriptionProvider` that synthesises an `IParsable<T>`-backed
-converter on demand the first time WPF asks for it.
-
-Composite types have no single-`TextBox` string form and so get no
-converter: bind their parts instead. An interval
-(`FiniteInterval<T>`, `Interval<T>`, `IntervalFrom<T>`,
-`IntervalUntil<T>`) binds field-by-field via `.Start` / `.End`;
-`Maybe<T>` and `NonEmptyEnumerable<T>` likewise bind through their
+`TypeDescriptor.GetConverter(T)` and never consults `IParsable<T>` directly.
+Every strong type with a string round-trip carries a `[TypeConverter]` that
+bridges the two — `NonEmptyString`, `Email`, `Digit`, and every closed
+instantiation of the generic numeric wrappers (`Positive<int>`,
+`Negative<decimal>`, …). Nothing to register: the attribute travels with the
+type.
+
+Composite types have no single-`TextBox` string form and so get no converter:
+bind their parts instead. An interval (`FiniteInterval<T>`, `Interval<T>`,
+`IntervalFrom<T>`, `IntervalUntil<T>`) binds field-by-field via `.Start` /
+`.End`; `Maybe<T>` and `NonEmptyEnumerable<T>` likewise bind through their
 members, not as a whole.
 
-```csharp
-public partial class App : Application
-{
-    protected override void OnStartup(StartupEventArgs e)
-    {
-        this.UseStrongTypes();
-        base.OnStartup(e);
-    }
-}
-```
-
 ## Bindings — what to write in XAML
 
-After registration, plain MVVM bindings to strong-typed properties
-just work:
-
 ```xml
 <TextBox Text="{Binding Name,
                         Mode=TwoWay,
@@ -54,26 +38,44 @@ just work:
 
 …where `Name` is a view-model property of type `NonEmptyString`.
 
-`ValidatesOnExceptions=True` is the load-bearing piece — strong
-types throw `ArgumentException` from `Create` / `Parse` when the
-input violates the invariant; `ValidatesOnExceptions=True` turns
-that into a `ValidationError` on the binding, which drives WPF's
-standard "invalid input" red-border template. Without it, the
-binding silently swallows the failure and the view-model is left
-holding the previous valid value.
+`ValidatesOnExceptions=True` is the load-bearing piece — strong types throw
+`ArgumentException` from `Create` / `Parse` when the input violates the
+invariant; `ValidatesOnExceptions=True` turns that into a `ValidationError`
+on the binding, which drives WPF's standard "invalid input" red-border
+template. Without it, the binding silently swallows the failure and the
+view-model is left holding the previous valid value.
+
+## Culture
+
+The converter parses **and** formats in the binding's culture (`ConverterCulture`,
+or the element's `Language`), so a `Positive<decimal>` displays as `1234,5` on a
+de-DE binding and reads back unchanged. Don't add an `IValueConverter` to
+compensate — a pre-v2 `Kalicz.StrongTypes.Wpf` formatted with the ambient
+culture while parsing in the binding's, which turned `1234.5` into `12345` on
+round-trip; if a workaround exists in your code for that, delete it.
+
+## Nullable properties
+
+A nullable wrapper (`Positive<int>?`, `NonEmptyString?`) binds and validates
+normally, but **clearing the box does not set the property to null** — it
+raises a validation error. WPF unwraps `Nullable<T>` and asks for the
+underlying type's converter, so the BCL's `NullableConverter` (which maps empty
+to null, and does exactly that for configuration binding) is never consulted,
+and `""` reaches `Positive<int>.Parse`. This is long-standing behaviour, not a
+v2 change. If "cleared means null" matters, bind through a `string?` view-model
+property and convert in the view-model.
 
 ## Other XAML/MVVM frameworks
 
-The same `TypeDescriptor`-based mechanism is used by WinForms and
-some other frameworks; in practice this package is currently
-documented and tested for WPF. If a user is on Avalonia, MAUI, or
-WinForms and hits the same "binding silently fails" symptom, point
-them at issue
+The same `TypeDescriptor` mechanism is used by WinForms and some other
+frameworks, and since the converters now live on the types themselves, nothing
+WPF-specific is required for them either. In practice this is documented and
+tested for WPF. If a user is on Avalonia, MAUI, or WinForms and hits a
+"binding silently fails" symptom, point them at issue
 [#94](https://github.com/KaliCZ/StrongTypes/issues/94).
 
 ## Decision rule
 
-> **Use it whenever a WPF view-model property is a strong type that
-> the user can type into.** Display-only bindings (one-way out) work
-> without it because WPF goes through `ToString()`. The package
-> matters for the inbound (string → T) leg.
+> **Nothing to add, nothing to call.** Reference `Kalicz.StrongTypes` and bind.
+> The only thing you must remember is `ValidatesOnExceptions=True` on inbound
+> (string → T) bindings, or invalid input fails silently.
diff --git a/StrongTypes.slnx b/StrongTypes.slnx
index 8e04e7ce..5aeda2f2 100644
--- a/StrongTypes.slnx
+++ b/StrongTypes.slnx
@@ -8,6 +8,11 @@
     <Project Path="src/StrongTypes.AspNetCore.TestApi/StrongTypes.AspNetCore.TestApi.csproj" />
     <Project Path="src/StrongTypes.AspNetCore/StrongTypes.AspNetCore.csproj" />
   </Folder>
+  <Folder Name="/Configuration package/">
+    <Project Path="src/StrongTypes.Configuration/StrongTypes.Configuration.csproj" />
+    <Project Path="src/StrongTypes.Configuration.Tests/StrongTypes.Configuration.Tests.csproj" />
+    <Project Path="src/StrongTypes.Configuration.Tests.NullableDisabled/StrongTypes.Configuration.Tests.NullableDisabled.csproj" />
+  </Folder>
   <Folder Name="/EF Core package/">
     <Project Path="src/StrongTypes.EfCore/StrongTypes.EfCore.csproj" />
   </Folder>
@@ -33,7 +38,6 @@
     <Project Path="src/StrongTypes/StrongTypes.csproj" />
   </Folder>
   <Folder Name="/WPF/">
-    <Project Path="src/StrongTypes.Wpf/StrongTypes.Wpf.csproj" />
     <Project Path="src/StrongTypes.Wpf.TestApp/StrongTypes.Wpf.TestApp.csproj" />
     <Project Path="src/StrongTypes.Wpf.Tests/StrongTypes.Wpf.Tests.csproj" />
   </Folder>
diff --git a/docs/diagrams/package-layout-dark.svg b/docs/diagrams/package-layout-dark.svg
index ef8ef93c..b5d5c945 100644
--- a/docs/diagrams/package-layout-dark.svg
+++ b/docs/diagrams/package-layout-dark.svg
@@ -1,4 +1,4 @@
-<svg class="dark" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 820 470" role="img" aria-label="StrongTypes NuGet package layout">
+<svg class="dark" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 820 535" role="img" aria-label="StrongTypes NuGet package layout">
   <style>
     .core-title   { font: 700 15px ui-monospace, SFMono-Regular, 'SF Mono', Menlo, Consolas, monospace; fill: #111827; }
     .card-title   { font: 600 13px ui-monospace, SFMono-Regular, 'SF Mono', Menlo, Consolas, monospace; fill: #111827; }
@@ -124,9 +124,9 @@
   <text class="niche-body" x="453" y="239"><tspan font-family="ui-monospace, Menlo, Consolas, monospace">NonEmptyEnumerable&lt;T&gt;</tspan> binder from forms / query / headers</text>
 
   <!-- ========================================================== -->
-  <!-- Utility packages (bottom-left) — EfCore + FsCheck stacked  -->
+  <!-- Utility packages (bottom-left) — EfCore, FsCheck, Config   -->
   <!-- ========================================================== -->
-  <rect class="group-bg group-border" x="15" y="285" width="380" height="160" rx="10" stroke-width="1.2"/>
+  <rect class="group-bg group-border" x="15" y="285" width="380" height="225" rx="10" stroke-width="1.2"/>
   <text class="group-label" x="30" y="304">UTILITY PACKAGES</text>
 
   <!-- EfCore -->
@@ -142,22 +142,28 @@
   <circle class="sm-bullet" cx="45" cy="423" r="2"/>
   <text class="card-body" x="53" y="427">Predefined value generators</text>
 
+  <!-- Configuration -->
+  <rect class="card-bg card-border" x="25" y="448" width="360" height="55" rx="6" stroke-width="1.5"/>
+  <text class="card-title" x="39" y="468">Kalicz.StrongTypes.Configuration</text>
+  <circle class="sm-bullet" cx="45" cy="488" r="2"/>
+  <text class="card-body" x="53" y="492"><tspan font-family="ui-monospace, Menlo, Consolas, monospace">BindStrongTypes()</tspan> — fail on a missing key</text>
+
   <!-- ========================================================== -->
-  <!-- App surface (bottom-right) — currently just WPF            -->
+  <!-- App surface (bottom-right) — built into the core package    -->
   <!-- ========================================================== -->
-  <rect class="group-bg group-border" x="415" y="285" width="390" height="160" rx="10" stroke-width="1.2"/>
+  <rect class="group-bg group-border" x="415" y="285" width="390" height="225" rx="10" stroke-width="1.2"/>
   <text class="group-label" x="430" y="304">APP SURFACE</text>
 
-  <!-- WPF -->
+  <!-- WPF / WinForms -->
   <rect class="card-bg card-border" x="425" y="318" width="370" height="55" rx="6" stroke-width="1.5"/>
-  <text class="card-title" x="439" y="338">Kalicz.StrongTypes.Wpf</text>
+  <text class="card-title" x="439" y="338">WPF / WinForms</text>
   <circle class="sm-bullet" cx="445" cy="358" r="2"/>
-  <text class="card-body" x="453" y="362">Two-way MVVM binding</text>
+  <text class="card-body" x="453" y="362">Two-way MVVM binding — built in</text>
 
   <!-- CTA: invite issues for other UI frameworks -->
   <a href="https://github.com/KaliCZ/StrongTypes/issues/new" target="_blank">
-    <text class="cta-text" x="610" y="415" text-anchor="middle">Want WinForms, MAUI, or Avalonia?</text>
-    <text class="cta-text" x="610" y="432" text-anchor="middle">Open a GitHub issue →</text>
+    <text class="cta-text" x="610" y="435" text-anchor="middle">Want WinForms, MAUI, or Avalonia?</text>
+    <text class="cta-text" x="610" y="452" text-anchor="middle">Open a GitHub issue →</text>
   </a>
 
   <!-- ========================================================== -->
diff --git a/docs/diagrams/package-layout.svg b/docs/diagrams/package-layout.svg
index 5412897c..e78074b4 100644
--- a/docs/diagrams/package-layout.svg
+++ b/docs/diagrams/package-layout.svg
@@ -1,4 +1,4 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 820 470" role="img" aria-label="StrongTypes NuGet package layout">
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 820 535" role="img" aria-label="StrongTypes NuGet package layout">
   <style>
     .core-title   { font: 700 15px ui-monospace, SFMono-Regular, 'SF Mono', Menlo, Consolas, monospace; fill: #111827; }
     .card-title   { font: 600 13px ui-monospace, SFMono-Regular, 'SF Mono', Menlo, Consolas, monospace; fill: #111827; }
@@ -124,9 +124,9 @@
   <text class="niche-body" x="453" y="239"><tspan font-family="ui-monospace, Menlo, Consolas, monospace">NonEmptyEnumerable&lt;T&gt;</tspan> binder from forms / query / headers</text>
 
   <!-- ========================================================== -->
-  <!-- Utility packages (bottom-left) — EfCore + FsCheck stacked  -->
+  <!-- Utility packages (bottom-left) — EfCore, FsCheck, Config   -->
   <!-- ========================================================== -->
-  <rect class="group-bg group-border" x="15" y="285" width="380" height="160" rx="10" stroke-width="1.2"/>
+  <rect class="group-bg group-border" x="15" y="285" width="380" height="225" rx="10" stroke-width="1.2"/>
   <text class="group-label" x="30" y="304">UTILITY PACKAGES</text>
 
   <!-- EfCore -->
@@ -142,22 +142,28 @@
   <circle class="sm-bullet" cx="45" cy="423" r="2"/>
   <text class="card-body" x="53" y="427">Predefined value generators</text>
 
+  <!-- Configuration -->
+  <rect class="card-bg card-border" x="25" y="448" width="360" height="55" rx="6" stroke-width="1.5"/>
+  <text class="card-title" x="39" y="468">Kalicz.StrongTypes.Configuration</text>
+  <circle class="sm-bullet" cx="45" cy="488" r="2"/>
+  <text class="card-body" x="53" y="492"><tspan font-family="ui-monospace, Menlo, Consolas, monospace">BindStrongTypes()</tspan> — fail on a missing key</text>
+
   <!-- ========================================================== -->
-  <!-- App surface (bottom-right) — currently just WPF            -->
+  <!-- App surface (bottom-right) — built into the core package    -->
   <!-- ========================================================== -->
-  <rect class="group-bg group-border" x="415" y="285" width="390" height="160" rx="10" stroke-width="1.2"/>
+  <rect class="group-bg group-border" x="415" y="285" width="390" height="225" rx="10" stroke-width="1.2"/>
   <text class="group-label" x="430" y="304">APP SURFACE</text>
 
-  <!-- WPF -->
+  <!-- WPF / WinForms -->
   <rect class="card-bg card-border" x="425" y="318" width="370" height="55" rx="6" stroke-width="1.5"/>
-  <text class="card-title" x="439" y="338">Kalicz.StrongTypes.Wpf</text>
+  <text class="card-title" x="439" y="338">WPF / WinForms</text>
   <circle class="sm-bullet" cx="445" cy="358" r="2"/>
-  <text class="card-body" x="453" y="362">Two-way MVVM binding</text>
+  <text class="card-body" x="453" y="362">Two-way MVVM binding — built in</text>
 
   <!-- CTA: invite issues for other UI frameworks -->
   <a href="https://github.com/KaliCZ/StrongTypes/issues/new" target="_blank">
-    <text class="cta-text" x="610" y="415" text-anchor="middle">Want WinForms, MAUI, or Avalonia?</text>
-    <text class="cta-text" x="610" y="432" text-anchor="middle">Open a GitHub issue →</text>
+    <text class="cta-text" x="610" y="435" text-anchor="middle">Want WinForms, MAUI, or Avalonia?</text>
+    <text class="cta-text" x="610" y="452" text-anchor="middle">Open a GitHub issue →</text>
   </a>
 
   <!-- ========================================================== -->
diff --git a/readme.md b/readme.md
index f3f824c1..aa016ca3 100644
--- a/readme.md
+++ b/readme.md
@@ -2,7 +2,7 @@
 
 [![NuGet version](https://img.shields.io/nuget/v/Kalicz.StrongTypes?label=nuget)](https://www.nuget.org/packages/Kalicz.StrongTypes/) [![Downloads](https://img.shields.io/nuget/dt/Kalicz.StrongTypes?label=downloads)](https://www.nuget.org/packages/Kalicz.StrongTypes/) [![License](https://img.shields.io/github/license/KaliCZ/StrongTypes)](https://github.com/KaliCZ/StrongTypes/blob/main/license.txt)
 
-StrongTypes adds small, focused types that make everyday code safer and more expressive. Every type ships with `System.Text.Json` converters out of the box, so invalid JSON fails at deserialization. The types can be stored directly in EF Core entities via the EfCore package, OpenAPI documentation is supported through the Microsoft or Swashbuckle OpenAPI packages, and WPF is supported via the WPF package — see [Packages](#packages) below.
+StrongTypes adds small, focused types that make everyday code safer and more expressive. Every type ships with `System.Text.Json` converters out of the box, so invalid JSON fails at deserialization, and a `TypeConverter`, so the same invariant validates `appsettings.json` as it binds and WPF two-way bindings work with no setup. The types can be stored directly in EF Core entities via the EfCore package, and OpenAPI documentation is supported through the Microsoft or Swashbuckle OpenAPI packages — see [Packages](#packages) below.
 
 > 🤖 Letting Claude Code or Codex write code in a project that uses
 > StrongTypes? See [Use with Claude or Codex](#use-with-claude-or-codex)
@@ -28,6 +28,7 @@ StrongTypes adds small, focused types that make everyday code safer and more exp
   - [Numeric wrappers: `Positive<T>`, `NonNegative<T>`, `Negative<T>`, `NonPositive<T>`](#numeric-wrappers)
   - [What you get for free](#what-you-get-for-free)
   - [JSON serialization](#json-serialization)
+  - [Configuration binding](#configuration-binding)
   - [EF Core persistence](#ef-core-persistence)
   - [OpenAPI / Swagger schema](#openapi--swagger-schema)
   - [WPF MVVM binding](#wpf-mvvm-binding)
@@ -140,6 +141,37 @@ All strong types ship with `System.Text.Json` converters attached via `[JsonConv
 
 [↑ Back to contents](#contents)
 
+### Configuration binding
+
+All strong types ship a `TypeConverter` attached via `[TypeConverter]`, which is what `ConfigurationBinder` uses — so a wrapper sits directly on an options class and its invariant becomes the config validation rule. A bad value fails at startup with the path, the value, and the reason:
+
+```
+InvalidOperationException: Failed to convert configuration value '-5' at 'Retry:MaxRetries'
+                           to type 'StrongTypes.Positive`1[System.Int32]'.
+  ---> ArgumentException: Value must be positive, but was '-5'. (Parameter 'value')
+```
+
+```csharp
+public sealed class RetryOptions
+{
+    public Positive<int> MaxRetries { get; set; }
+    public NonEmptyString ApiName { get; set; } = null!;
+    public string ApiKey { get; set; } = null!;
+}
+
+// Standard C# behavior: ApiName and ApiKey can still be null. You'd need [Required] to prevent that.
+builder.Services.AddOptions<RetryOptions>()
+    .Bind(builder.Configuration.GetSection("Retry"))
+    .ValidateOnStart();
+
+// ApiName or ApiKey null → OptionsValidationException
+builder.Services.AddOptions<RetryOptions>()
+    .BindStrongTypes(builder.Configuration.GetSection("Retry")) // A special method for preventing nulls.
+    .ValidateOnStart();
+```
+
+[↑ Back to contents](#contents)
+
 ### EF Core persistence
 
 If you want to store strong types directly on your EF Core entities, add the companion package [`Kalicz.StrongTypes.EfCore`](https://www.nuget.org/packages/Kalicz.StrongTypes.EfCore/). It provides the value converters needed to map `NonEmptyString`, `Positive<T>`, and other numeric types to their underlying column types. See the package [readme](https://github.com/KaliCZ/StrongTypes/blob/main/src/StrongTypes.EfCore/readme.md) for setup details.
@@ -162,9 +194,18 @@ Pick the one that matches the generator your app already uses. They're not inter
 
 ### WPF MVVM binding
 
-For WPF applications, add the package [`Kalicz.StrongTypes.Wpf`](https://www.nuget.org/packages/Kalicz.StrongTypes.Wpf/) to enable bindings including two-way. One `this.UseStrongTypes()` call in `App.OnStartup` to register.
+Nothing to install, nothing to call. WPF resolves `string → T` through `TypeDescriptor`, and every strong type carries a `[TypeConverter]`, so two-way bindings just work:
+
+```xml
+<TextBox Text="{Binding Name,
+                        Mode=TwoWay,
+                        UpdateSourceTrigger=PropertyChanged,
+                        ValidatesOnExceptions=True}" />
+```
+
+…where `Name` is a view-model property of type `NonEmptyString`. `ValidatesOnExceptions=True` is the load-bearing piece: it turns the `ArgumentException` a strong type throws on invalid input into a `ValidationError`, driving WPF's standard red-border template. Without it the binding swallows the failure silently.
 
-Other UI frameworks (WinForms, MAUI, Avalonia, …) aren't covered yet — see [issue #94](https://github.com/KaliCZ/StrongTypes/issues/94).
+The same `TypeDescriptor` mechanism backs WinForms and designers. MAUI and Avalonia aren't covered yet — see [issue #94](https://github.com/KaliCZ/StrongTypes/issues/94).
 
 [↑ Back to contents](#contents)
 
@@ -747,12 +788,12 @@ Result<Positive<int>[], string> ParseOrderQuantities(IEnumerable<int> inputs)
 | Package | Purpose | Readme |
 | --- | --- | --- |
 | [`Kalicz.StrongTypes`](https://www.nuget.org/packages/Kalicz.StrongTypes/) | Core types: `NonEmptyString`, `Positive<T>` / `NonNegative<T>` / `Negative<T>` / `NonPositive<T>`, `NonEmptyEnumerable<T>`, `Maybe<T>`, `Result<T, TError>`, plus `System.Text.Json` converters. | (this readme) |
+| [`Kalicz.StrongTypes.Configuration`](https://www.nuget.org/packages/Kalicz.StrongTypes.Configuration/) | `OptionsBuilder<T>.BindStrongTypes()` — binds a section and fails when a property declared non-nullable is null once bound, which an absent key otherwise leaves silently. Binding itself needs no package; this is only about the key that isn't there. | [readme](src/StrongTypes.Configuration/readme.md) |
 | [`Kalicz.StrongTypes.EfCore`](https://www.nuget.org/packages/Kalicz.StrongTypes.EfCore/) | EF Core value converters + `DbContext` extension for round-tripping the wrappers through scalar columns. | [readme](src/StrongTypes.EfCore/readme.md) |
 | [`Kalicz.StrongTypes.FsCheck`](https://www.nuget.org/packages/Kalicz.StrongTypes.FsCheck/) | FsCheck `Arbitrary<T>` generators for property-based (generative) testing of code that takes or returns the wrappers. | [readme](src/StrongTypes.FsCheck/readme.md) |
 | [`Kalicz.StrongTypes.OpenApi.Microsoft`](https://www.nuget.org/packages/Kalicz.StrongTypes.OpenApi.Microsoft/) | Schema transformers for `Microsoft.AspNetCore.OpenApi` (`AddOpenApi()`) so the generated document matches the wire JSON. | [readme](src/StrongTypes.OpenApi.Microsoft/readme.md) |
 | [`Kalicz.StrongTypes.OpenApi.Swashbuckle`](https://www.nuget.org/packages/Kalicz.StrongTypes.OpenApi.Swashbuckle/) | Schema filters for `Swashbuckle.AspNetCore` (`AddSwaggerGen()`) so the generated Swagger document matches the wire JSON. | [readme](src/StrongTypes.OpenApi.Swashbuckle/readme.md) |
 | [`Kalicz.StrongTypes.AspNetCore`](https://www.nuget.org/packages/Kalicz.StrongTypes.AspNetCore/) | MVC model binder for `NonEmptyEnumerable<T>` from `[FromForm]`, `[FromQuery]`, `[FromHeader]`, and `[FromRoute]`, plus opt-out normalization of JSON request-body validation error keys (`$.value` → `Value`, configurable via `AddStrongTypes(o => o.NormalizeJsonErrorKeys = …)`). The binder isn't needed for JSON APIs — `[FromBody]` round-trips wrappers via the main package's JSON converters — but the error-key normalization applies to any JSON API. | [readme](src/StrongTypes.AspNetCore/readme.md) |
-| [`Kalicz.StrongTypes.Wpf`](https://www.nuget.org/packages/Kalicz.StrongTypes.Wpf/) | `TypeConverter`s that bridge `IParsable<T>` into `TypeDescriptor`, enabling two-way MVVM binding to strong types in WPF (and any framework that resolves converters via `TypeDescriptor`). | [readme](src/StrongTypes.Wpf/readme.md) |
 
 [↑ Back to contents](#contents)
 
diff --git a/src/StrongTypes.Analyzers.Tests/Infrastructure/AnalyzerTester.cs b/src/StrongTypes.Analyzers.Tests/Infrastructure/AnalyzerTester.cs
index e2d2644d..9e65023a 100644
--- a/src/StrongTypes.Analyzers.Tests/Infrastructure/AnalyzerTester.cs
+++ b/src/StrongTypes.Analyzers.Tests/Infrastructure/AnalyzerTester.cs
@@ -7,8 +7,7 @@ namespace StrongTypes.Analyzers.Tests.Infrastructure;
 
 /// <summary>
 /// Drives a <see cref="DiagnosticAnalyzer"/> against an in-memory compilation and returns the
-/// diagnostics it produced. Kept deliberately thin — no `Microsoft.CodeAnalysis.Testing`
-/// dependency, so tests stay portable across xUnit v2/v3 and Roslyn versions.
+/// diagnostics it produced.
 /// </summary>
 internal static class AnalyzerTester
 {
@@ -25,7 +24,27 @@ public static async Task<ImmutableArray<Diagnostic>> RunAsync(
             references,
             new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
 
+        AssertCompiles(compilation);
+
         var withAnalyzers = compilation.WithAnalyzers(ImmutableArray.Create(analyzer));
         return await withAnalyzers.GetAnalyzerDiagnosticsAsync();
     }
+
+    /// <summary>
+    /// A source missing a reference yields no diagnostics rather than an error, so every
+    /// <c>Silent_</c> test would pass for the wrong reason. Fail loudly instead.
+    /// </summary>
+    private static void AssertCompiles(CSharpCompilation compilation)
+    {
+        var errors = compilation.GetDiagnostics().Where(d => d.Severity == DiagnosticSeverity.Error).ToArray();
+        if (errors.Length == 0)
+        {
+            return;
+        }
+
+        throw new InvalidOperationException(
+            "Test source does not compile, so any assertion about what the analyzer reports is meaningless:"
+            + Environment.NewLine
+            + string.Join(Environment.NewLine, errors.Select(e => e.ToString())));
+    }
 }
diff --git a/src/StrongTypes.Analyzers.Tests/Infrastructure/DocumentCodeFixTester.cs b/src/StrongTypes.Analyzers.Tests/Infrastructure/DocumentCodeFixTester.cs
new file mode 100644
index 00000000..bf64db34
--- /dev/null
+++ b/src/StrongTypes.Analyzers.Tests/Infrastructure/DocumentCodeFixTester.cs
@@ -0,0 +1,80 @@
+using System.Collections.Immutable;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CodeActions;
+using Microsoft.CodeAnalysis.CodeFixes;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.Diagnostics;
+
+namespace StrongTypes.Analyzers.Tests.Infrastructure;
+
+/// <summary>
+/// Drives a source-editing code fix. Diagnostics come from really running the analyzer, so a fix
+/// cannot be tested against a location the analyzer would never report.
+/// </summary>
+internal static class DocumentCodeFixTester
+{
+    public static async Task<IReadOnlyList<CodeAction>> RegisterFixesAsync(
+        DiagnosticAnalyzer analyzer,
+        CodeFixProvider provider,
+        string source,
+        IEnumerable<MetadataReference> references)
+    {
+        var (document, diagnostics) = await AnalyseAsync(analyzer, source, references);
+        if (diagnostics.IsEmpty)
+        {
+            return [];
+        }
+
+        var registered = new List<CodeAction>();
+        var context = new CodeFixContext(document, diagnostics[0], (action, _) => registered.Add(action), CancellationToken.None);
+        await provider.RegisterCodeFixesAsync(context);
+        return registered;
+    }
+
+    /// <summary>Applies the first offered fix and returns the resulting source.</summary>
+    public static async Task<string> ApplySingleFixAsync(
+        DiagnosticAnalyzer analyzer,
+        CodeFixProvider provider,
+        string source,
+        IEnumerable<MetadataReference> references)
+    {
+        var (document, diagnostics) = await AnalyseAsync(analyzer, source, references);
+        if (diagnostics.IsEmpty)
+        {
+            throw new InvalidOperationException("The analyzer reported nothing, so there is no fix to apply.");
+        }
+
+        var registered = new List<CodeAction>();
+        var context = new CodeFixContext(document, diagnostics[0], (action, _) => registered.Add(action), CancellationToken.None);
+        await provider.RegisterCodeFixesAsync(context);
+
+        var operations = await registered.Single().GetOperationsAsync(CancellationToken.None);
+        var changed = operations.OfType<ApplyChangesOperation>().Single().ChangedSolution;
+        var text = await changed.GetDocument(document.Id)!.GetTextAsync();
+        return text.ToString();
+    }
+
+    private static async Task<(Document Document, ImmutableArray<Diagnostic> Diagnostics)> AnalyseAsync(
+        DiagnosticAnalyzer analyzer,
+        string source,
+        IEnumerable<MetadataReference> references)
+    {
+        var workspace = new AdhocWorkspace();
+        var projectId = ProjectId.CreateNewId();
+        var documentId = DocumentId.CreateNewId(projectId);
+
+        var solution = workspace.CurrentSolution
+            .AddProject(projectId, "Target", "Target", LanguageNames.CSharp)
+            .WithProjectCompilationOptions(projectId, new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary))
+            .AddMetadataReferences(projectId, references)
+            .AddDocument(documentId, "Test.cs", source);
+
+        var document = solution.GetDocument(documentId)!;
+        var compilation = await document.Project.GetCompilationAsync();
+        var diagnostics = await compilation!
+            .WithAnalyzers(ImmutableArray.Create(analyzer))
+            .GetAnalyzerDiagnosticsAsync();
+
+        return (document, diagnostics);
+    }
+}
diff --git a/src/StrongTypes.Analyzers.Tests/Infrastructure/TestReferences.cs b/src/StrongTypes.Analyzers.Tests/Infrastructure/TestReferences.cs
index d2aefb42..71af632a 100644
--- a/src/StrongTypes.Analyzers.Tests/Infrastructure/TestReferences.cs
+++ b/src/StrongTypes.Analyzers.Tests/Infrastructure/TestReferences.cs
@@ -4,17 +4,13 @@
 namespace StrongTypes.Analyzers.Tests.Infrastructure;
 
 /// <summary>
-/// Curated <see cref="MetadataReference"/> sets for analyzer tests. We need fine-grained control
-/// over what the test compilation "sees" — the whole point of <c>MissingEfCorePackageAnalyzer</c>
-/// is to flip behavior based on which assemblies are referenced, so we cannot just dump the
-/// host's loaded assembly list verbatim (it leaks EF Core and StrongTypes.EfCore into every case).
+/// Curated <see cref="MetadataReference"/> sets for analyzer tests: dumping the host's loaded
+/// assemblies would leak EF Core and StrongTypes.EfCore into every case and defeat the
+/// reference-sensitive analyzers.
 /// </summary>
 internal static class TestReferences
 {
-    // Keep bleed-through from the host process explicit: anything matching these prefixes is a
-    // test-host dependency that a user's project might not have, and tests need to control set
-    // membership themselves via the `Entity*` / `StrongTypesEfCore` fields. Declared FIRST so
-    // static-init order makes it available when `Core` is populated below.
+    // Must be declared before Core: Core's initializer reads this.
     private static readonly string[] _hostOnlyPrefixes =
     {
         "Microsoft.EntityFrameworkCore",
@@ -47,6 +43,23 @@ internal static class TestReferences
     public static readonly MetadataReference StrongTypesOpenApiSwashbuckle =
         MetadataReference.CreateFromFile(typeof(global::StrongTypes.OpenApi.Swashbuckle.StrongTypesSwashbuckleExtensions).Assembly.Location);
 
+    public static readonly MetadataReference StrongTypesConfiguration =
+        MetadataReference.CreateFromFile(typeof(global::StrongTypes.Configuration.OptionsBuilderExtensions).Assembly.Location);
+
+    /// <summary>What an options-binding source needs to compile: <c>IServiceCollection</c>, <c>OptionsBuilder&lt;T&gt;</c>, <c>IConfiguration</c>, the <c>Bind</c>/<c>Configure</c> extensions ST0004 matches on, <c>[Required]</c>, and <c>[TypeConverter]</c> — which ST0004 reads to know where the binder stops recursing.</summary>
+    public static readonly MetadataReference[] OptionsStack =
+    [
+        MetadataReference.CreateFromFile(typeof(global::Microsoft.Extensions.DependencyInjection.IServiceCollection).Assembly.Location),
+        MetadataReference.CreateFromFile(typeof(global::Microsoft.Extensions.Options.IOptions<object>).Assembly.Location),
+        MetadataReference.CreateFromFile(typeof(global::Microsoft.Extensions.Configuration.IConfiguration).Assembly.Location),
+        MetadataReference.CreateFromFile(typeof(global::Microsoft.Extensions.DependencyInjection.OptionsBuilderConfigurationExtensions).Assembly.Location),
+        MetadataReference.CreateFromFile(typeof(global::System.ComponentModel.DataAnnotations.RequiredAttribute).Assembly.Location),
+        // Two assemblies: the attribute lives in System.ComponentModel.Primitives, the TypeConverter
+        // base class a source needs to subclass is forwarded to System.ComponentModel.TypeConverter.
+        MetadataReference.CreateFromFile(typeof(global::System.ComponentModel.TypeConverterAttribute).Assembly.Location),
+        MetadataReference.CreateFromFile(typeof(global::System.ComponentModel.TypeConverter).Assembly.Location),
+    ];
+
     private static IReadOnlyList<MetadataReference> BuildCoreReferences()
     {
         // AppContext "TRUSTED_PLATFORM_ASSEMBLIES" isn't always populated under
diff --git a/src/StrongTypes.Analyzers.Tests/StrongTypes.Analyzers.Tests.csproj b/src/StrongTypes.Analyzers.Tests/StrongTypes.Analyzers.Tests.csproj
index 4dc5317a..09a8d51f 100644
--- a/src/StrongTypes.Analyzers.Tests/StrongTypes.Analyzers.Tests.csproj
+++ b/src/StrongTypes.Analyzers.Tests/StrongTypes.Analyzers.Tests.csproj
@@ -15,6 +15,8 @@
     <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.11.0" />
     <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Workspaces" Version="4.11.0" />
     <PackageReference Include="Microsoft.EntityFrameworkCore" Version="10.0.0" />
+    <PackageReference Include="Microsoft.Extensions.Options.ConfigurationExtensions" Version="10.0.0" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="10.0.0" />
     <PackageReference Include="Microsoft.Testing.Extensions.CodeCoverage" Version="17.14.2" />
     <PackageReference Include="xunit.v3" Version="3.2.2" />
   </ItemGroup>
@@ -26,6 +28,7 @@
                       OutputItemType="None" />
     <ProjectReference Include="..\StrongTypes\StrongTypes.csproj" />
     <!-- Needed to test the "silent when StrongTypes.EfCore is referenced" case. -->
+    <ProjectReference Include="..\StrongTypes.Configuration\StrongTypes.Configuration.csproj" />
     <ProjectReference Include="..\StrongTypes.EfCore\StrongTypes.EfCore.csproj" />
     <!-- Needed to test the OpenAPI analyzers (ST0002 / ST0003) under both the
          "generator referenced, adapter missing" and "adapter referenced" cases. -->
diff --git a/src/StrongTypes.Analyzers.Tests/UnvalidatedStrongTypeOptionsAnalyzerTests.cs b/src/StrongTypes.Analyzers.Tests/UnvalidatedStrongTypeOptionsAnalyzerTests.cs
new file mode 100644
index 00000000..e29e8281
--- /dev/null
+++ b/src/StrongTypes.Analyzers.Tests/UnvalidatedStrongTypeOptionsAnalyzerTests.cs
@@ -0,0 +1,316 @@
+using Microsoft.CodeAnalysis;
+using StrongTypes.Analyzers.Tests.Infrastructure;
+using Xunit;
+
+namespace StrongTypes.Analyzers.Tests;
+
+/// <summary>
+/// Behaviour tests for <see cref="UnvalidatedStrongTypeOptionsAnalyzer"/> (ST0004). Each source
+/// opts into nullable reference types, because required-ness for a reference wrapper is read from
+/// the annotation and the test compilation does not enable it project-wide.
+/// </summary>
+public class UnvalidatedStrongTypeOptionsAnalyzerTests
+{
+    private const string Header = """
+        #nullable enable
+        using Microsoft.Extensions.Configuration;
+        using Microsoft.Extensions.DependencyInjection;
+        using System.ComponentModel.DataAnnotations;
+        using StrongTypes;
+
+        namespace Sample;
+
+        """;
+
+    private static string Source(string options, string registration) => $$"""
+        {{Header}}
+        public class RetryOptions
+        {
+        {{options}}
+        }
+
+        public static class Startup
+        {
+            public static void Register(IServiceCollection services, IConfiguration config)
+            {
+        {{registration}}
+            }
+        }
+        """;
+
+    private const string BindRegistration = "        services.AddOptions<RetryOptions>().Bind(config.GetSection(\"Retry\"));";
+    private const string ConfigureRegistration = "        services.Configure<RetryOptions>(config.GetSection(\"Retry\"));";
+
+    private static Task<System.Collections.Immutable.ImmutableArray<Diagnostic>> RunAsync(string source) =>
+        AnalyzerTester.RunAsync(new UnvalidatedStrongTypeOptionsAnalyzer(), source, TestReferences.With(TestReferences.OptionsStack));
+
+    // ── Fires ───────────────────────────────────────────────────────────
+
+    /// <summary>A non-nullable reference wrapper is the one an absent key leaves null — the state its type forbids.</summary>
+    [Theory]
+    [InlineData(BindRegistration)]
+    [InlineData(ConfigureRegistration)]
+    public async Task Fires_for_a_non_nullable_reference_wrapper(string registration)
+    {
+        var diagnostics = await RunAsync(Source("    public NonEmptyString Name { get; set; } = null!;", registration));
+
+        var diagnostic = Assert.Single(diagnostics.WhereId(UnvalidatedStrongTypeOptionsAnalyzer.DiagnosticId));
+        Assert.Contains("RetryOptions", diagnostic.GetMessage(), StringComparison.Ordinal);
+        Assert.Contains("Name", diagnostic.GetMessage(), StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public async Task Reports_every_unguarded_property_in_one_diagnostic()
+    {
+        var diagnostics = await RunAsync(Source("""
+                public NonEmptyString Name { get; set; } = null!;
+                public Email Contact { get; set; } = null!;
+            """, BindRegistration));
+
+        var diagnostic = Assert.Single(diagnostics.WhereId(UnvalidatedStrongTypeOptionsAnalyzer.DiagnosticId));
+        Assert.Contains("Name", diagnostic.GetMessage(), StringComparison.Ordinal);
+        Assert.Contains("Contact", diagnostic.GetMessage(), StringComparison.Ordinal);
+    }
+
+    /// <summary>A wrapper nested in a child options class is left null by the same absent key, so the nudge has to reach it.</summary>
+    [Fact]
+    public async Task Fires_for_a_wrapper_nested_in_a_child_options_class()
+    {
+        var diagnostics = await RunAsync($$"""
+            {{Header}}
+            public class RetryOptions
+            {
+                public BackoffOptions Backoff { get; set; } = null!;
+            }
+
+            public class BackoffOptions
+            {
+                public NonEmptyString Name { get; set; } = null!;
+            }
+
+            public static class Startup
+            {
+                public static void Register(IServiceCollection services, IConfiguration config)
+                {
+                    services.AddOptions<RetryOptions>().Bind(config.GetSection("Retry"));
+                }
+            }
+            """);
+
+        var diagnostic = Assert.Single(diagnostics.WhereId(UnvalidatedStrongTypeOptionsAnalyzer.DiagnosticId));
+        Assert.Contains("Backoff.Name", diagnostic.GetMessage(), StringComparison.Ordinal);
+    }
+
+    /// <summary>The binder walks collection elements, so a wrapper inside one is left null by the same absent key.</summary>
+    [Fact]
+    public async Task Fires_for_a_wrapper_inside_a_collection_element()
+    {
+        var diagnostics = await RunAsync($$"""
+            {{Header}}
+            using System.Collections.Generic;
+
+            public class RetryOptions
+            {
+                public List<EndpointOptions> Endpoints { get; set; } = null!;
+            }
+
+            public class EndpointOptions
+            {
+                public NonEmptyString Host { get; set; } = null!;
+            }
+
+            public static class Startup
+            {
+                public static void Register(IServiceCollection services, IConfiguration config)
+                {
+                    services.AddOptions<RetryOptions>().Bind(config.GetSection("Retry"));
+                }
+            }
+            """);
+
+        var diagnostic = Assert.Single(diagnostics.WhereId(UnvalidatedStrongTypeOptionsAnalyzer.DiagnosticId));
+        Assert.Contains("Endpoints.Host", diagnostic.GetMessage(), StringComparison.Ordinal);
+    }
+
+    // ── Silent ──────────────────────────────────────────────────────────
+
+    /// <summary>A <c>[TypeConverter]</c> type binds from a scalar, so the binder never reaches the wrapper inside it — flagging it would invent a diagnostic for a property configuration never touches.</summary>
+    [Fact]
+    public async Task Silent_for_a_wrapper_inside_a_type_that_binds_from_a_scalar()
+    {
+        var diagnostics = await RunAsync($$"""
+            {{Header}}
+            using System.ComponentModel;
+
+            [TypeConverter(typeof(EndpointConverter))]
+            public class Endpoint
+            {
+                public NonEmptyString Host { get; set; } = null!;
+            }
+
+            public class EndpointConverter : TypeConverter { }
+
+            public class RetryOptions
+            {
+                public Endpoint Primary { get; set; } = null!;
+            }
+
+            public static class Startup
+            {
+                public static void Register(IServiceCollection services, IConfiguration config)
+                {
+                    services.AddOptions<RetryOptions>().Bind(config.GetSection("Retry"));
+                }
+            }
+            """);
+
+        Assert.Empty(diagnostics.WhereId(UnvalidatedStrongTypeOptionsAnalyzer.DiagnosticId));
+    }
+
+    [Fact]
+    public async Task Silent_for_a_nested_class_with_nothing_unguarded()
+    {
+        var diagnostics = await RunAsync($$"""
+            {{Header}}
+            public class RetryOptions
+            {
+                public BackoffOptions Backoff { get; set; } = null!;
+            }
+
+            public class BackoffOptions
+            {
+                public NonEmptyString? Name { get; set; }
+                public Positive<int> Attempts { get; set; }
+            }
+
+            public static class Startup
+            {
+                public static void Register(IServiceCollection services, IConfiguration config)
+                {
+                    services.AddOptions<RetryOptions>().Bind(config.GetSection("Retry"));
+                }
+            }
+            """);
+
+        Assert.Empty(diagnostics.WhereId(UnvalidatedStrongTypeOptionsAnalyzer.DiagnosticId));
+    }
+
+    [Fact]
+    public async Task Cyclic_options_graph_terminates()
+    {
+        var diagnostics = await RunAsync($$"""
+            {{Header}}
+            public class RetryOptions
+            {
+                public NodeOptions Head { get; set; } = null!;
+            }
+
+            public class NodeOptions
+            {
+                public NodeOptions? Next { get; set; }
+                public NonEmptyString Name { get; set; } = null!;
+            }
+
+            public static class Startup
+            {
+                public static void Register(IServiceCollection services, IConfiguration config)
+                {
+                    services.AddOptions<RetryOptions>().Bind(config.GetSection("Retry"));
+                }
+            }
+            """);
+
+        var diagnostic = Assert.Single(diagnostics.WhereId(UnvalidatedStrongTypeOptionsAnalyzer.DiagnosticId));
+        Assert.Contains("Head.Name", diagnostic.GetMessage(), StringComparison.Ordinal);
+    }
+
+    /// <summary><c>[Required]</c> does find a null reference wrapper, so nagging there would be wrong.</summary>
+    [Fact]
+    public async Task Silent_for_a_reference_wrapper_carrying_Required()
+    {
+        var diagnostics = await RunAsync(Source(
+            "    [Required] public NonEmptyString Name { get; set; } = null!;",
+            BindRegistration));
+
+        Assert.Empty(diagnostics.WhereId(UnvalidatedStrongTypeOptionsAnalyzer.DiagnosticId));
+    }
+
+    [Fact]
+    public async Task Silent_when_every_wrapper_is_nullable()
+    {
+        var diagnostics = await RunAsync(Source("    public NonEmptyString? Name { get; set; }", BindRegistration));
+
+        Assert.Empty(diagnostics.WhereId(UnvalidatedStrongTypeOptionsAnalyzer.DiagnosticId));
+    }
+
+    /// <summary>A struct wrapper cannot be null, so an absent key leaves it at a default the type is happy to hold — there is no contradiction to report.</summary>
+    [Theory]
+    [InlineData("    public Positive<int> MaxRetries { get; set; }")]
+    [InlineData("    public Positive<int>? MaxRetries { get; set; }")]
+    [InlineData("    public Digit Tier { get; set; }")]
+    public async Task Silent_for_struct_wrappers(string options)
+    {
+        var diagnostics = await RunAsync(Source(options, BindRegistration));
+
+        Assert.Empty(diagnostics.WhereId(UnvalidatedStrongTypeOptionsAnalyzer.DiagnosticId));
+    }
+
+    [Fact]
+    public async Task Silent_when_the_options_type_holds_no_strong_types()
+    {
+        var diagnostics = await RunAsync(Source("""
+                public string Name { get; set; } = "";
+                public int MaxRetries { get; set; }
+            """, BindRegistration));
+
+        Assert.Empty(diagnostics.WhereId(UnvalidatedStrongTypeOptionsAnalyzer.DiagnosticId));
+    }
+
+    /// <summary>A read-only property is not something the binder assigns, so its absence is not a configuration problem.</summary>
+    [Fact]
+    public async Task Silent_for_a_get_only_property()
+    {
+        var diagnostics = await RunAsync(Source(
+            "    public Positive<int> MaxRetries { get; } = Positive<int>.Create(3);",
+            BindRegistration));
+
+        Assert.Empty(diagnostics.WhereId(UnvalidatedStrongTypeOptionsAnalyzer.DiagnosticId));
+    }
+
+    /// <summary>Nothing to say when the project never binds options — the analyzer must no-op rather than fire on the declaration alone.</summary>
+    [Fact]
+    public async Task Silent_when_the_options_type_is_never_bound()
+    {
+        var diagnostics = await RunAsync($$"""
+            {{Header}}
+            public class RetryOptions
+            {
+                public Positive<int> MaxRetries { get; set; }
+            }
+            """);
+
+        Assert.Empty(diagnostics.WhereId(UnvalidatedStrongTypeOptionsAnalyzer.DiagnosticId));
+    }
+
+    /// <summary>Without the Options stack referenced there is no <c>Bind</c> to match, and the analyzer must stay silent rather than throw.</summary>
+    [Fact]
+    public async Task Silent_when_options_is_not_referenced()
+    {
+        var diagnostics = await AnalyzerTester.RunAsync(
+            new UnvalidatedStrongTypeOptionsAnalyzer(),
+            """
+            #nullable enable
+            using StrongTypes;
+
+            namespace Sample;
+
+            public class RetryOptions
+            {
+                public Positive<int> MaxRetries { get; set; }
+            }
+            """,
+            TestReferences.With());
+
+        Assert.Empty(diagnostics.WhereId(UnvalidatedStrongTypeOptionsAnalyzer.DiagnosticId));
+    }
+}
diff --git a/src/StrongTypes.Analyzers.Tests/UseBindStrongTypesCodeFixProviderTests.cs b/src/StrongTypes.Analyzers.Tests/UseBindStrongTypesCodeFixProviderTests.cs
new file mode 100644
index 00000000..56e01673
--- /dev/null
+++ b/src/StrongTypes.Analyzers.Tests/UseBindStrongTypesCodeFixProviderTests.cs
@@ -0,0 +1,87 @@
+using StrongTypes.Analyzers.Tests.Infrastructure;
+using Xunit;
+
+namespace StrongTypes.Analyzers.Tests;
+
+public class UseBindStrongTypesCodeFixProviderTests
+{
+    private const string BindSource = """
+        #nullable enable
+        using Microsoft.Extensions.Configuration;
+        using Microsoft.Extensions.DependencyInjection;
+        using StrongTypes;
+
+        namespace Sample;
+
+        public class RetryOptions
+        {
+            public NonEmptyString Name { get; set; } = null!;
+        }
+
+        public static class Startup
+        {
+            public static void Register(IServiceCollection services, IConfiguration config)
+            {
+                services.AddOptions<RetryOptions>().Bind(config.GetSection("Retry"));
+            }
+        }
+        """;
+
+    private static IEnumerable<Microsoft.CodeAnalysis.MetadataReference> WithConfiguration() =>
+        TestReferences.With([.. TestReferences.OptionsStack, TestReferences.StrongTypesConfiguration]);
+
+    [Fact]
+    public async Task Rewrites_Bind_to_BindStrongTypes()
+    {
+        var fixedSource = await DocumentCodeFixTester.ApplySingleFixAsync(
+            new UnvalidatedStrongTypeOptionsAnalyzer(),
+            new UseBindStrongTypesCodeFixProvider(),
+            BindSource,
+            WithConfiguration());
+
+        Assert.Contains("services.AddOptions<RetryOptions>().BindStrongTypes(config.GetSection(\"Retry\"));", fixedSource, StringComparison.Ordinal);
+        Assert.DoesNotContain(".Bind(config", fixedSource, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public async Task Adds_the_configuration_using()
+    {
+        var fixedSource = await DocumentCodeFixTester.ApplySingleFixAsync(
+            new UnvalidatedStrongTypeOptionsAnalyzer(),
+            new UseBindStrongTypesCodeFixProvider(),
+            BindSource,
+            WithConfiguration());
+
+        Assert.Contains("using StrongTypes.Configuration;", fixedSource, StringComparison.Ordinal);
+    }
+
+    /// <summary>Offered even without the package — the rewrite won't compile until it is added, and the fix title names it.</summary>
+    [Fact]
+    public async Task Offered_without_the_package_naming_it_in_the_title()
+    {
+        var actions = await DocumentCodeFixTester.RegisterFixesAsync(
+            new UnvalidatedStrongTypeOptionsAnalyzer(),
+            new UseBindStrongTypesCodeFixProvider(),
+            BindSource,
+            TestReferences.With(TestReferences.OptionsStack));
+
+        var action = Assert.Single(actions);
+        Assert.Contains("Kalicz.StrongTypes.Configuration", action.Title, StringComparison.Ordinal);
+    }
+
+    /// <summary>Rewriting <c>Configure&lt;T&gt;</c> means restructuring to <c>AddOptions&lt;T&gt;().BindStrongTypes(…)</c>; the diagnostic still fires, but the change is the caller's to make.</summary>
+    [Fact]
+    public async Task Not_offered_for_Configure()
+    {
+        var actions = await DocumentCodeFixTester.RegisterFixesAsync(
+            new UnvalidatedStrongTypeOptionsAnalyzer(),
+            new UseBindStrongTypesCodeFixProvider(),
+            BindSource.Replace(
+                "services.AddOptions<RetryOptions>().Bind(config.GetSection(\"Retry\"));",
+                "services.Configure<RetryOptions>(config.GetSection(\"Retry\"));",
+                StringComparison.Ordinal),
+            WithConfiguration());
+
+        Assert.Empty(actions);
+    }
+}
diff --git a/src/StrongTypes.Analyzers/AnalyzerReleases.Unshipped.md b/src/StrongTypes.Analyzers/AnalyzerReleases.Unshipped.md
index f2b7fad6..c9ff46a1 100644
--- a/src/StrongTypes.Analyzers/AnalyzerReleases.Unshipped.md
+++ b/src/StrongTypes.Analyzers/AnalyzerReleases.Unshipped.md
@@ -1,2 +1,8 @@
 ; Unshipped analyzer release
 ; https://github.com/dotnet/roslyn-analyzers/blob/main/src/Microsoft.CodeAnalysis.Analyzers/ReleaseTrackingAnalyzers.Help.md
+
+### New Rules
+
+Rule ID | Category | Severity | Notes
+--------|----------|----------|-------
+ST0004  | Usage    | Warning  | Bind strong-typed options with BindStrongTypes (Kalicz.StrongTypes.Configuration) so a missing configuration key fails
diff --git a/src/StrongTypes.Analyzers/UnvalidatedStrongTypeOptionsAnalyzer.cs b/src/StrongTypes.Analyzers/UnvalidatedStrongTypeOptionsAnalyzer.cs
new file mode 100644
index 00000000..d9ba3843
--- /dev/null
+++ b/src/StrongTypes.Analyzers/UnvalidatedStrongTypeOptionsAnalyzer.cs
@@ -0,0 +1,241 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Linq;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Operations;
+
+namespace StrongTypes.Analyzers;
+
+/// <summary>
+/// Flags a <c>Bind</c> / <c>Configure</c> on an options type that would leave a non-nullable
+/// reference wrapper null at any depth when the key is missing.
+/// </summary>
+[DiagnosticAnalyzer(LanguageNames.CSharp)]
+public sealed class UnvalidatedStrongTypeOptionsAnalyzer : DiagnosticAnalyzer
+{
+    public const string DiagnosticId = "ST0004";
+    public const string ConfigurationPackageId = "Kalicz.StrongTypes.Configuration";
+
+    private static readonly DiagnosticDescriptor Rule = new(
+        id: DiagnosticId,
+        title: "Bind strong-typed options with BindStrongTypes",
+        messageFormat: "Options type '{0}' will bind {1} to null when the key is missing; bind with BindStrongTypes() so that fails instead",
+        category: "Usage",
+        defaultSeverity: DiagnosticSeverity.Warning,
+        isEnabledByDefault: true,
+        description: "Binding an absent configuration key succeeds without assigning, so a non-nullable reference wrapper is left null — the one thing its type says it can never be — and nothing reports it. Kalicz.StrongTypes.Configuration's BindStrongTypes() fails on it instead, reading which properties are non-nullable from the declaration rather than from [Required] attributes. Struct wrappers are unaffected: an unconfigured Positive<int> is 1, a value the type is happy to hold.",
+        helpLinkUri: "https://www.nuget.org/packages/Kalicz.StrongTypes.Configuration");
+
+    private static readonly ImmutableHashSet<string> StrongTypeMetadataNames = ImmutableHashSet.Create(
+        "StrongTypes.NonEmptyString",
+        "StrongTypes.Email",
+        "StrongTypes.Digit",
+        "StrongTypes.Positive`1",
+        "StrongTypes.NonNegative`1",
+        "StrongTypes.Negative`1",
+        "StrongTypes.NonPositive`1");
+
+    // Get<T> / Bind(object) are excluded: one-off reads with no OptionsBuilder to rewrite to.
+    private const string OptionsBuilderBindExtensions = "Microsoft.Extensions.DependencyInjection.OptionsBuilderConfigurationExtensions";
+    private const string ServiceCollectionConfigureExtensions = "Microsoft.Extensions.DependencyInjection.OptionsConfigurationServiceCollectionExtensions";
+
+    public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; } = ImmutableArray.Create(Rule);
+
+    public override void Initialize(AnalysisContext context)
+    {
+        context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
+        context.EnableConcurrentExecution();
+
+        context.RegisterCompilationStartAction(compilationStart =>
+        {
+            var compilation = compilationStart.Compilation;
+
+            var bindExtensions = compilation.GetTypeByMetadataName(OptionsBuilderBindExtensions);
+            var configureExtensions = compilation.GetTypeByMetadataName(ServiceCollectionConfigureExtensions);
+            if (bindExtensions is null && configureExtensions is null)
+            {
+                return;
+            }
+
+            var requiredAttribute = compilation.GetTypeByMetadataName("System.ComponentModel.DataAnnotations.RequiredAttribute");
+
+            compilationStart.RegisterOperationAction(operationContext =>
+            {
+                var invocation = (IInvocationOperation)operationContext.Operation;
+                var method = invocation.TargetMethod;
+
+                if (!IsBindingCall(method, bindExtensions, configureExtensions))
+                {
+                    return;
+                }
+                if (method.TypeArguments.FirstOrDefault() is not INamedTypeSymbol optionsType)
+                {
+                    return;
+                }
+
+                var unguarded = CollectPropertiesLeftNull(optionsType, requiredAttribute);
+                if (unguarded.Count == 0)
+                {
+                    return;
+                }
+
+                operationContext.ReportDiagnostic(Diagnostic.Create(
+                    Rule,
+                    invocation.Syntax.GetLocation(),
+                    optionsType.Name,
+                    string.Join(", ", unguarded)));
+            }, OperationKind.Invocation);
+        });
+    }
+
+    private static bool IsBindingCall(IMethodSymbol method, INamedTypeSymbol? bindExtensions, INamedTypeSymbol? configureExtensions)
+    {
+        if (method.TypeArguments.Length != 1)
+        {
+            return false;
+        }
+        var containing = method.ContainingType;
+        if (method.Name == "Bind" && bindExtensions is not null && SymbolEqualityComparer.Default.Equals(containing, bindExtensions))
+        {
+            return true;
+        }
+        return method.Name == "Configure"
+               && configureExtensions is not null
+               && SymbolEqualityComparer.Default.Equals(containing, configureExtensions);
+    }
+
+    private static List<string> CollectPropertiesLeftNull(INamedTypeSymbol optionsType, INamedTypeSymbol? requiredAttribute)
+    {
+        var result = new List<string>();
+        Walk(optionsType, prefix: "", result, requiredAttribute, new HashSet<INamedTypeSymbol>(SymbolEqualityComparer.Default));
+        return result;
+    }
+
+    private static void Walk(
+        INamedTypeSymbol type,
+        string prefix,
+        List<string> result,
+        INamedTypeSymbol? requiredAttribute,
+        HashSet<INamedTypeSymbol> visited)
+    {
+        // A type reachable by two paths is reported once; without this a cycle would not terminate.
+        if (!visited.Add(type))
+        {
+            return;
+        }
+
+        for (var current = type; current is not null; current = current.BaseType)
+        {
+            foreach (var member in current.GetMembers())
+            {
+                if (member is not IPropertySymbol property || property.SetMethod is null || property.IsIndexer)
+                {
+                    continue;
+                }
+
+                var path = prefix.Length == 0 ? property.Name : prefix + "." + property.Name;
+
+                if (IsStrongType(property.Type))
+                {
+                    // A value type has no invalid state to reach, so an absent key leaves nothing wrong.
+                    if (property.Type.IsValueType
+                        || IsOptional(property)
+                        || HasRequiredAttribute(property, requiredAttribute))
+                    {
+                        continue;
+                    }
+                    result.Add(path);
+                    continue;
+                }
+
+                if (BindsAsAnObjectGraph(property.Type) is { } nested)
+                {
+                    Walk(nested, path, result, requiredAttribute, visited);
+                }
+            }
+        }
+    }
+
+    /// <summary>The type to recurse into, or <c>null</c> where the binder would convert a scalar instead. Unwraps arrays and collections to their element type.</summary>
+    private static INamedTypeSymbol? BindsAsAnObjectGraph(ITypeSymbol type)
+    {
+        if (type is IArrayTypeSymbol array)
+        {
+            return BindsAsAnObjectGraph(array.ElementType);
+        }
+        if (type is not INamedTypeSymbol named || named.SpecialType != SpecialType.None)
+        {
+            return null;
+        }
+        if (named.IsGenericType && ElementOf(named) is { } element)
+        {
+            return BindsAsAnObjectGraph(element);
+        }
+        if (named.TypeKind is not (TypeKind.Class or TypeKind.Struct) || HasTypeConverter(named))
+        {
+            return null;
+        }
+        return named.ContainingNamespace?.ToDisplayString().StartsWith("System", StringComparison.Ordinal) == true
+            ? null
+            : named;
+    }
+
+    private static ITypeSymbol? ElementOf(INamedTypeSymbol type) =>
+        type.AllInterfaces.Any(i => i.OriginalDefinition.SpecialType == SpecialType.System_Collections_Generic_IEnumerable_T)
+            ? type.TypeArguments.LastOrDefault()
+            : null;
+
+    private static bool HasTypeConverter(INamedTypeSymbol type)
+    {
+        for (var current = type; current is not null; current = current.BaseType)
+        {
+            if (current.GetAttributes().Any(a => a.AttributeClass?.ToDisplayString() == "System.ComponentModel.TypeConverterAttribute"))
+            {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private static bool HasRequiredAttribute(IPropertySymbol property, INamedTypeSymbol? requiredAttribute) =>
+        requiredAttribute is not null
+        && property.GetAttributes().Any(a => SymbolEqualityComparer.Default.Equals(a.AttributeClass, requiredAttribute));
+
+    /// <summary>Also true for a reference wrapper in an assembly compiled without NRT: no annotation, so no intent to enforce.</summary>
+    private static bool IsOptional(IPropertySymbol property)
+    {
+        if (property.Type is INamedTypeSymbol named
+            && named.IsGenericType
+            && named.ConstructedFrom.SpecialType == SpecialType.System_Nullable_T)
+        {
+            return true;
+        }
+        if (property.Type.IsValueType)
+        {
+            return false;
+        }
+        return property.NullableAnnotation != NullableAnnotation.NotAnnotated;
+    }
+
+    private static bool IsStrongType(ITypeSymbol type)
+    {
+        if (type is INamedTypeSymbol nullable
+            && nullable.IsGenericType
+            && nullable.ConstructedFrom.SpecialType == SpecialType.System_Nullable_T)
+        {
+            type = nullable.TypeArguments[0];
+        }
+        if (type is not INamedTypeSymbol named)
+        {
+            return false;
+        }
+        var definition = named.OriginalDefinition;
+        var ns = definition.ContainingNamespace?.ToDisplayString();
+        var metadataName = definition.IsGenericType
+            ? $"{ns}.{definition.Name}`{definition.TypeParameters.Length}"
+            : $"{ns}.{definition.Name}";
+        return StrongTypeMetadataNames.Contains(metadataName);
+    }
+}
diff --git a/src/StrongTypes.Analyzers/UseBindStrongTypesCodeFixProvider.cs b/src/StrongTypes.Analyzers/UseBindStrongTypesCodeFixProvider.cs
new file mode 100644
index 00000000..ea0d151f
--- /dev/null
+++ b/src/StrongTypes.Analyzers/UseBindStrongTypesCodeFixProvider.cs
@@ -0,0 +1,113 @@
+using System;
+using System.Collections.Immutable;
+using System.Composition;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CodeActions;
+using Microsoft.CodeAnalysis.CodeFixes;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace StrongTypes.Analyzers;
+
+/// <summary>
+/// Code fix for <see cref="UnvalidatedStrongTypeOptionsAnalyzer"/>: rewrites <c>.Bind(section)</c> to
+/// <c>.BindStrongTypes(section)</c>, for <c>Bind</c> only — a <c>Configure&lt;T&gt;</c> call needs
+/// restructuring, so it gets none. When <c>Kalicz.StrongTypes.Configuration</c> is not referenced the
+/// fix is still offered, with a title that names the package to add.
+/// </summary>
+[ExportCodeFixProvider(LanguageNames.CSharp, Name = nameof(UseBindStrongTypesCodeFixProvider))]
+[Shared]
+public sealed class UseBindStrongTypesCodeFixProvider : CodeFixProvider
+{
+    private const string BindStrongTypes = "BindStrongTypes";
+    private const string ConfigurationNamespace = "StrongTypes.Configuration";
+
+    public override ImmutableArray<string> FixableDiagnosticIds { get; } =
+        ImmutableArray.Create(UnvalidatedStrongTypeOptionsAnalyzer.DiagnosticId);
+
+    public override FixAllProvider? GetFixAllProvider() => WellKnownFixAllProviders.BatchFixer;
+
+    public override async Task RegisterCodeFixesAsync(CodeFixContext context)
+    {
+        var compilation = await context.Document.Project.GetCompilationAsync(context.CancellationToken).ConfigureAwait(false);
+        if (compilation is null)
+        {
+            return;
+        }
+
+        var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);
+        if (root is null)
+        {
+            return;
+        }
+
+        var title = ReferencesConfigurationPackage(compilation)
+            ? "Use BindStrongTypes()"
+            : $"Use BindStrongTypes() (add {UnvalidatedStrongTypeOptionsAnalyzer.ConfigurationPackageId})";
+
+        foreach (var diagnostic in context.Diagnostics)
+        {
+            var invocation = root.FindNode(diagnostic.Location.SourceSpan, getInnermostNodeForTie: true)
+                .AncestorsAndSelf()
+                .OfType<InvocationExpressionSyntax>()
+                .FirstOrDefault();
+
+            if (invocation?.Expression is not MemberAccessExpressionSyntax { Name.Identifier.ValueText: "Bind" } access)
+            {
+                continue;
+            }
+
+            context.RegisterCodeFix(
+                CodeAction.Create(
+                    title: title,
+                    createChangedDocument: ct => UseBindStrongTypesAsync(context.Document, access, ct),
+                    equivalenceKey: nameof(UseBindStrongTypesCodeFixProvider)),
+                diagnostic);
+        }
+    }
+
+    private static bool ReferencesConfigurationPackage(Compilation compilation) =>
+        compilation.ReferencedAssemblyNames.Any(a =>
+            string.Equals(a.Name, "StrongTypes.Configuration", StringComparison.OrdinalIgnoreCase)
+            || string.Equals(a.Name, UnvalidatedStrongTypeOptionsAnalyzer.ConfigurationPackageId, StringComparison.OrdinalIgnoreCase));
+
+    private static async Task<Document> UseBindStrongTypesAsync(
+        Document document,
+        MemberAccessExpressionSyntax access,
+        CancellationToken cancellationToken)
+    {
+        var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
+        if (root is null)
+        {
+            return document;
+        }
+
+        var renamed = access.WithName(SyntaxFactory.IdentifierName(BindStrongTypes).WithTriviaFrom(access.Name));
+        var updated = root.ReplaceNode(access, renamed);
+
+        return document.WithSyntaxRoot(AddUsing(updated));
+    }
+
+    private static SyntaxNode AddUsing(SyntaxNode root)
+    {
+        if (root is not CompilationUnitSyntax unit)
+        {
+            return root;
+        }
+        if (unit.Usings.Any(u => u.Name?.ToString() == ConfigurationNamespace))
+        {
+            return unit;
+        }
+
+        var directive = SyntaxFactory
+            .UsingDirective(SyntaxFactory.ParseName(ConfigurationNamespace))
+            .WithTrailingTrivia(SyntaxFactory.ElasticCarriageReturnLineFeed);
+
+        // Keep the file's usings sorted rather than appending to the end.
+        var insertAt = unit.Usings.TakeWhile(u => string.CompareOrdinal(u.Name?.ToString(), ConfigurationNamespace) < 0).Count();
+        return unit.WithUsings(unit.Usings.Insert(insertAt, directive));
+    }
+}
diff --git a/src/StrongTypes.Configuration.Tests.NullableDisabled/StrongTypes.Configuration.Tests.NullableDisabled.csproj b/src/StrongTypes.Configuration.Tests.NullableDisabled/StrongTypes.Configuration.Tests.NullableDisabled.csproj
new file mode 100644
index 00000000..9429db79
--- /dev/null
+++ b/src/StrongTypes.Configuration.Tests.NullableDisabled/StrongTypes.Configuration.Tests.NullableDisabled.csproj
@@ -0,0 +1,17 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+    <LangVersion>14.0</LangVersion>
+    <!-- The point of this project: options classes compiled WITHOUT nullable reference
+         types carry no annotations, so BindStrongTypes cannot read intent from them.
+         StrongTypes.Configuration.Tests references it to pin that degradation. -->
+    <Nullable>disable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+    <NoWarn>CS1591</NoWarn>
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\StrongTypes\StrongTypes.csproj" />
+  </ItemGroup>
+</Project>
diff --git a/src/StrongTypes.Configuration.Tests.NullableDisabled/UnannotatedOptions.cs b/src/StrongTypes.Configuration.Tests.NullableDisabled/UnannotatedOptions.cs
new file mode 100644
index 00000000..e047c1d0
--- /dev/null
+++ b/src/StrongTypes.Configuration.Tests.NullableDisabled/UnannotatedOptions.cs
@@ -0,0 +1,9 @@
+namespace StrongTypes.Configuration.Tests.NullableDisabled;
+
+/// <summary>An options class from an assembly with no nullable annotations: <c>Name</c> declares no intent either way, while <c>MaxRetries</c> and <c>Score</c> still differ in the type itself.</summary>
+public sealed class UnannotatedOptions
+{
+    public NonEmptyString Name { get; set; }
+    public Positive<int> MaxRetries { get; set; }
+    public Positive<int>? Score { get; set; }
+}
diff --git a/src/StrongTypes.Configuration.Tests/BindStrongTypesTests.cs b/src/StrongTypes.Configuration.Tests/BindStrongTypesTests.cs
new file mode 100644
index 00000000..7b648bbf
--- /dev/null
+++ b/src/StrongTypes.Configuration.Tests/BindStrongTypesTests.cs
@@ -0,0 +1,309 @@
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Options;
+using StrongTypes.Configuration.Tests.NullableDisabled;
+using Xunit;
+
+namespace StrongTypes.Configuration.Tests;
+
+/// <summary>
+/// The binder assigns nothing for an absent key, so a non-nullable property it never reaches keeps
+/// the null the options class gave it — the state its type forbids and plain binding never catches.
+/// </summary>
+public class BindStrongTypesTests
+{
+    private sealed class RetryOptions
+    {
+        public NonEmptyString Name { get; set; } = null!;
+        public NonEmptyString? Nickname { get; set; }
+        public Email Contact { get; set; } = null!;
+        public string PlainString { get; set; } = null!;
+        public string? OptionalString { get; set; }
+        public string WithDefault { get; set; } = "https://example.test";
+        public NestedOptions Nested { get; set; } = null!;
+        public List<string> Items { get; set; } = null!;
+    }
+
+    /// <summary>Nothing here can be null, so nothing here is checked.</summary>
+    private sealed class ValueTypeOptions
+    {
+        public Positive<int> MaxRetries { get; set; }
+        public NonNegative<int> Delay { get; set; }
+        public Digit Tier { get; set; }
+        public bool Enabled { get; set; }
+        public int Timeout { get; set; }
+        public Positive<int>? Score { get; set; }
+    }
+
+    private sealed class NestedOptions
+    {
+        public string Inner { get; set; } = "";
+    }
+
+    private const string FullyConfigured = """
+        {
+          "Retry": {
+            "Name": "checkout",
+            "Contact": "ops@example.com",
+            "PlainString": "s",
+            "Nested": { "Inner": "y" },
+            "Items": [ "a", "b" ]
+          }
+        }
+        """;
+
+    private static IConfigurationSection Section(string json) =>
+        new ConfigurationBuilder()
+            .AddJsonStream(new MemoryStream(System.Text.Encoding.UTF8.GetBytes(json)))
+            .Build()
+            .GetSection("Retry");
+
+    private static TOptions Bind<TOptions>(string json) where TOptions : class
+    {
+        var services = new ServiceCollection();
+        services.AddOptions<TOptions>().BindStrongTypes(Section(json));
+        return services.BuildServiceProvider().GetRequiredService<IOptions<TOptions>>().Value;
+    }
+
+    private static OptionsValidationException BindExpectingFailure<TOptions>(string json) where TOptions : class =>
+        Assert.Throws<OptionsValidationException>(() => Bind<TOptions>(json));
+
+    private static string Failures(OptionsValidationException exception) => string.Join(" | ", exception.Failures);
+
+    // ── The gap it closes ───────────────────────────────────────────────
+
+    [Fact]
+    public void PlainBind_LeavesANonNullableWrapperNull()
+    {
+        var services = new ServiceCollection();
+        services.AddOptions<RetryOptions>().Bind(Section("""{ "Retry": { } }"""));
+
+        var options = services.BuildServiceProvider().GetRequiredService<IOptions<RetryOptions>>().Value;
+
+        Assert.Null(options.Name);
+    }
+
+    [Fact]
+    public void MissingNonNullableWrapper_Fails()
+    {
+        var exception = BindExpectingFailure<RetryOptions>("""{ "Retry": { } }""");
+
+        Assert.Contains("'Retry:Name' is null", Failures(exception), StringComparison.Ordinal);
+        Assert.Contains("'Retry:Contact' is null", Failures(exception), StringComparison.Ordinal);
+    }
+
+    /// <summary>A plain <c>string</c> declared non-nullable is as broken by a missing key as a wrapper is.</summary>
+    [Fact]
+    public void MissingNonNullablePlainReference_Fails() =>
+        Assert.Contains("'Retry:PlainString' is null", Failures(BindExpectingFailure<RetryOptions>("""{ "Retry": { } }""")), StringComparison.Ordinal);
+
+    [Fact]
+    public void MissingNonNullableNestedObjectAndCollection_Fail()
+    {
+        var failures = Failures(BindExpectingFailure<RetryOptions>("""{ "Retry": { } }"""));
+
+        Assert.Contains("'Retry:Nested' is null", failures, StringComparison.Ordinal);
+        Assert.Contains("'Retry:Items' is null", failures, StringComparison.Ordinal);
+    }
+
+    /// <summary>An explicit <c>null</c> is no better than an absent key.</summary>
+    [Fact]
+    public void ExplicitNull_Fails() =>
+        Assert.Contains("'Retry:Name' is null", Failures(BindExpectingFailure<RetryOptions>("""{ "Retry": { "Name": null } }""")), StringComparison.Ordinal);
+
+    [Fact]
+    public void Failure_NamesTheConfigurationPathAndEveryWayOut()
+    {
+        var exception = BindExpectingFailure<RetryOptions>("""{ "Retry": { "Name": "checkout", "Contact": "a@b.test", "PlainString": "s", "Nested": { "Inner": "y" } } }""");
+
+        Assert.Equal(
+            "'Retry:Items' is null. Configure it, give RetryOptions.Items a default, or declare it nullable.",
+            Assert.Single(exception.Failures));
+    }
+
+    // ── What it must not do ─────────────────────────────────────────────
+
+    [Fact]
+    public void FullyConfigured_Binds()
+    {
+        var options = Bind<RetryOptions>(FullyConfigured);
+
+        Assert.Equal("checkout", options.Name.Value);
+        Assert.Equal("ops@example.com", options.Contact.Address);
+        Assert.Equal(["a", "b"], options.Items);
+        Assert.Equal("y", options.Nested.Inner);
+    }
+
+    [Fact]
+    public void NullableProperties_AreNotChecked()
+    {
+        var options = Bind<RetryOptions>(FullyConfigured);
+
+        Assert.Null(options.Nickname);
+        Assert.Null(options.OptionalString);
+    }
+
+    [Fact]
+    public void PropertiesWithADeclaredDefault_NeedNoConfiguration() =>
+        Assert.Equal("https://example.test", Bind<RetryOptions>(FullyConfigured).WithDefault);
+
+    /// <summary>A value type has no null state to catch: unconfigured it holds a default the type is happy with, so none of these is ever required.</summary>
+    [Fact]
+    public void ValueTypeProperties_AreNeverRequired()
+    {
+        var options = Bind<ValueTypeOptions>("""{ "Retry": { } }""");
+
+        Assert.Equal(1, options.MaxRetries.Value);
+        Assert.Equal(0, options.Delay.Value);
+        Assert.Equal(0, options.Tier.Value);
+        Assert.False(options.Enabled);
+        Assert.Equal(0, options.Timeout);
+        Assert.Null(options.Score);
+    }
+
+    /// <summary>Presence is the only question asked here; an invalid value is still the converter's failure, thrown while binding.</summary>
+    [Fact]
+    public void PresentButInvalidValue_StillThrowsTheInvariantFailure()
+    {
+        var exception = Assert.Throws<InvalidOperationException>(
+            () => Bind<ValueTypeOptions>("""{ "Retry": { "MaxRetries": -5 } }"""));
+
+        // Assert.Throws is exact-type, so reaching here already rules out a validation failure.
+        Assert.IsType<ArgumentException>(exception.InnerException);
+    }
+
+    // ── Named options ───────────────────────────────────────────────────
+
+    [Fact]
+    public void NamedOptions_ValidateOnlyTheirOwnName()
+    {
+        var services = new ServiceCollection();
+        services.AddOptions<RetryOptions>("configured").BindStrongTypes(Section(FullyConfigured));
+        services.AddOptions<RetryOptions>("incomplete").BindStrongTypes(Section("""{ "Retry": { } }"""));
+
+        var monitor = services.BuildServiceProvider().GetRequiredService<IOptionsMonitor<RetryOptions>>();
+
+        Assert.Equal("checkout", monitor.Get("configured").Name.Value);
+        Assert.Throws<OptionsValidationException>(() => monitor.Get("incomplete"));
+    }
+
+    // ── Nullable reference types disabled ───────────────────────────────
+
+    /// <summary>An options class from an assembly compiled without nullable reference types declares no intent, so nothing is enforced rather than guessed at.</summary>
+    [Fact]
+    public void UnannotatedAssembly_IsNotPoliced()
+    {
+        var options = Bind<UnannotatedOptions>("""{ "Retry": { } }""");
+
+        Assert.Null(options.Name);
+    }
+
+    // ── Depth ───────────────────────────────────────────────────────────
+
+    private sealed class NestedRoot
+    {
+        public Level Child { get; set; } = null!;
+    }
+
+    private sealed class OptionalNestedRoot
+    {
+        public Level? Child { get; set; }
+    }
+
+    private sealed class CollectionRoot
+    {
+        public List<Level> Items { get; set; } = null!;
+    }
+
+    private sealed class DictionaryRoot
+    {
+        public Dictionary<string, Level> Map { get; set; } = null!;
+    }
+
+    private sealed class Level
+    {
+        public NonEmptyString Wrapper { get; set; } = null!;
+        public string Plain { get; set; } = null!;
+        public string? Optional { get; set; }
+        public Positive<int> Number { get; set; }
+    }
+
+    [Fact]
+    public void NestedObject_HasItsOwnPropertiesChecked()
+    {
+        var failures = Failures(BindExpectingFailure<NestedRoot>("""{ "Retry": { "Child": { "Plain": "x" } } }"""));
+
+        Assert.Contains("'Retry:Child:Wrapper' is null", failures, StringComparison.Ordinal);
+        Assert.Contains("Level.Wrapper", failures, StringComparison.Ordinal);
+    }
+
+    /// <summary>Also pins that the walk stops at a wrapper — it is not recursed into — and that a nested value type is still never required.</summary>
+    [Fact]
+    public void NestedObject_FullyConfigured_Passes()
+    {
+        var child = Bind<NestedRoot>("""{ "Retry": { "Child": { "Wrapper": "w", "Plain": "x" } } }""").Child;
+
+        Assert.Equal("w", child.Wrapper.Value);
+        Assert.Null(child.Optional);
+        Assert.Equal(1, child.Number.Value);
+    }
+
+    [Fact]
+    public void ConfiguredOptionalNested_StillHasItsOwnPropertiesChecked() =>
+        Assert.Contains(
+            "'Retry:Child:Wrapper' is null",
+            Failures(BindExpectingFailure<OptionalNestedRoot>("""{ "Retry": { "Child": { "Plain": "x" } } }""")),
+            StringComparison.Ordinal);
+
+    [Fact]
+    public void AbsentOptionalNested_IsNotChecked() =>
+        Assert.Null(Bind<OptionalNestedRoot>("""{ "Retry": { } }""").Child);
+
+    [Fact]
+    public void CollectionElements_HaveTheirPropertiesChecked()
+    {
+        var failures = Failures(BindExpectingFailure<CollectionRoot>(
+            """{ "Retry": { "Items": [ { "Wrapper": "ok", "Plain": "x" }, { "Plain": "y" } ] } }"""));
+
+        Assert.Contains("'Retry:Items:1:Wrapper' is null", failures, StringComparison.Ordinal);
+        Assert.DoesNotContain("Items:0", failures, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void DictionaryValues_HaveTheirPropertiesChecked() =>
+        Assert.Contains(
+            "'Retry:Map:primary:Wrapper' is null",
+            Failures(BindExpectingFailure<DictionaryRoot>("""{ "Retry": { "Map": { "primary": { "Plain": "x" } } } }""")),
+            StringComparison.Ordinal);
+
+    private sealed class CycleRoot
+    {
+        public SelfReferencing Node { get; set; } = null!;
+    }
+
+    /// <summary>Binding cannot build a cycle, but a constructor can hand one to the walk.</summary>
+    private sealed class SelfReferencing
+    {
+        public SelfReferencing() => Self = this;
+
+        public SelfReferencing Self { get; set; }
+        public string Name { get; set; } = null!;
+        public NonEmptyString Wrapper { get; set; } = null!;
+    }
+
+    [Fact]
+    public void SelfReferencingGraph_TerminatesAndReportsOnce() =>
+        Assert.Equal(
+            "'Retry:Node:Wrapper' is null. Configure it, give SelfReferencing.Wrapper a default, or declare it nullable.",
+            Assert.Single(BindExpectingFailure<CycleRoot>("""{ "Retry": { "Node": { "Name": "n" } } }""").Failures));
+
+    // ── Guard rails ─────────────────────────────────────────────────────
+
+    [Fact]
+    public void NullSection_Throws()
+    {
+        var builder = new ServiceCollection().AddOptions<RetryOptions>();
+
+        Assert.Throws<ArgumentNullException>(() => builder.BindStrongTypes(null!));
+    }
+}
diff --git a/src/StrongTypes.Configuration.Tests/StrongTypes.Configuration.Tests.csproj b/src/StrongTypes.Configuration.Tests/StrongTypes.Configuration.Tests.csproj
new file mode 100644
index 00000000..6b16df71
--- /dev/null
+++ b/src/StrongTypes.Configuration.Tests/StrongTypes.Configuration.Tests.csproj
@@ -0,0 +1,26 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+    <OutputType>Exe</OutputType>
+    <LangVersion>14.0</LangVersion>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+    <NoWarn>CS1591</NoWarn>
+    <Nullable>enable</Nullable>
+    <IsPackable>false</IsPackable>
+    <IsTestProject>true</IsTestProject>
+    <TestingPlatformDotnetTestSupport>true</TestingPlatformDotnetTestSupport>
+  </PropertyGroup>
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Extensions.Configuration.Json" Version="10.0.0" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="10.0.0" />
+    <PackageReference Include="Microsoft.Extensions.Options.DataAnnotations" Version="10.0.0" />
+    <PackageReference Include="Microsoft.Testing.Extensions.CodeCoverage" Version="17.14.2" />
+    <PackageReference Include="xunit.v3" Version="3.2.2" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\StrongTypes\StrongTypes.csproj" />
+    <ProjectReference Include="..\StrongTypes.Configuration\StrongTypes.Configuration.csproj" />
+    <ProjectReference Include="..\StrongTypes.Configuration.Tests.NullableDisabled\StrongTypes.Configuration.Tests.NullableDisabled.csproj" />
+  </ItemGroup>
+</Project>
diff --git a/src/StrongTypes.Configuration/NonNullableOptionsValidator.cs b/src/StrongTypes.Configuration/NonNullableOptionsValidator.cs
new file mode 100644
index 00000000..db6118cd
--- /dev/null
+++ b/src/StrongTypes.Configuration/NonNullableOptionsValidator.cs
@@ -0,0 +1,24 @@
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Options;
+
+namespace StrongTypes.Configuration;
+
+/// <summary>Fails validation when a property of <typeparamref name="TOptions"/> declared non-nullable is null once bound, at any depth.</summary>
+internal sealed class NonNullableOptionsValidator<TOptions>(string? name, IConfiguration section) : IValidateOptions<TOptions>
+    where TOptions : class
+{
+    public ValidateOptionsResult Validate(string? optionsName, TOptions options)
+    {
+        // A named registration validates only its own name; an unnamed one covers all.
+        if (name is not null && name != optionsName)
+        {
+            return ValidateOptionsResult.Skip;
+        }
+
+        var failures = NullPropertyWalker.Collect(options, RootPath());
+
+        return failures.Count == 0 ? ValidateOptionsResult.Success : ValidateOptionsResult.Fail(failures);
+    }
+
+    private string RootPath() => section is IConfigurationSection { Path.Length: > 0 } s ? s.Path : "";
+}
diff --git a/src/StrongTypes.Configuration/NullPropertyWalker.cs b/src/StrongTypes.Configuration/NullPropertyWalker.cs
new file mode 100644
index 00000000..d7362740
--- /dev/null
+++ b/src/StrongTypes.Configuration/NullPropertyWalker.cs
@@ -0,0 +1,105 @@
+using System.Collections;
+using System.Collections.Concurrent;
+using System.ComponentModel;
+using System.Reflection;
+
+namespace StrongTypes.Configuration;
+
+/// <summary>Every property a declaration says can never be null but that binding left null, at any depth.</summary>
+internal sealed class NullPropertyWalker
+{
+    private static readonly ConcurrentDictionary<Type, bool> LeafCache = new();
+
+    private readonly NullabilityInfoContext nullability = new();
+    private readonly HashSet<object> visited = new(ReferenceEqualityComparer.Instance);
+    private readonly List<string> failures = [];
+
+    private NullPropertyWalker() { }
+
+    public static IReadOnlyList<string> Collect(object root, string rootPath)
+    {
+        var walker = new NullPropertyWalker();
+        walker.WalkObject(root, rootPath);
+        return walker.failures;
+    }
+
+    private void WalkObject(object instance, string path)
+    {
+        // Visit once: a shared instance would duplicate failures, a cycle would never terminate.
+        if (!visited.Add(instance))
+        {
+            return;
+        }
+
+        foreach (var property in instance.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance))
+        {
+            if (property.GetIndexParameters().Length > 0 || property.GetGetMethod() is null)
+            {
+                continue;
+            }
+
+            var value = property.GetValue(instance);
+            if (value is null)
+            {
+                if (LeftNullAgainstItsDeclaration(property))
+                {
+                    failures.Add(Describe(property, Join(path, property.Name)));
+                }
+                continue;
+            }
+
+            WalkValue(value, Join(path, property.Name));
+        }
+    }
+
+    private void WalkValue(object value, string path)
+    {
+        if (IsLeaf(value.GetType()))
+        {
+            return;
+        }
+
+        if (value is IDictionary dictionary)
+        {
+            foreach (DictionaryEntry entry in dictionary)
+            {
+                if (entry.Value is not null)
+                {
+                    WalkValue(entry.Value, Join(path, entry.Key.ToString() ?? ""));
+                }
+            }
+            return;
+        }
+
+        if (value is IEnumerable items)
+        {
+            var index = 0;
+            foreach (var item in items)
+            {
+                if (item is not null)
+                {
+                    WalkValue(item, Join(path, index.ToString()));
+                }
+                index++;
+            }
+            return;
+        }
+
+        WalkObject(value, path);
+    }
+
+    /// <summary>True only for a settable, non-nullable reference property — the one shape a missing key can leave in a state its declaration forbids.</summary>
+    private bool LeftNullAgainstItsDeclaration(PropertyInfo property) =>
+        !property.PropertyType.IsValueType
+        && property.GetSetMethod() is not null
+        && nullability.Create(property).WriteState == NullabilityState.NotNull;
+
+    /// <summary>A type the binder converts from a string rather than recursing into, so the walk covers exactly the graph the binder built.</summary>
+    private static bool IsLeaf(Type type) =>
+        LeafCache.GetOrAdd(type, static t => TypeDescriptor.GetConverter(t).CanConvertFrom(typeof(string)));
+
+    private static string Join(string path, string name) => path.Length == 0 ? name : $"{path}:{name}";
+
+    private static string Describe(PropertyInfo property, string path) =>
+        $"'{path}' is null. Configure it, give {property.DeclaringType!.Name}.{property.Name} a default, or declare it nullable.";
+}
diff --git a/src/StrongTypes.Configuration/OptionsBuilderExtensions.cs b/src/StrongTypes.Configuration/OptionsBuilderExtensions.cs
new file mode 100644
index 00000000..60d4334f
--- /dev/null
+++ b/src/StrongTypes.Configuration/OptionsBuilderExtensions.cs
@@ -0,0 +1,28 @@
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Options;
+
+namespace StrongTypes.Configuration;
+
+public static class OptionsBuilderExtensions
+{
+    /// <summary>
+    /// Binds <paramref name="section"/> to <typeparamref name="TOptions"/>, then fails validation when a
+    /// non-nullable reference property is left null at any depth. Value types are never required — an
+    /// unconfigured <c>Positive&lt;int&gt;</c> is <c>1</c>. Pair with <c>ValidateOnStart()</c> to fail at
+    /// startup rather than on first read.
+    /// </summary>
+    /// <exception cref="ArgumentNullException"><paramref name="builder"/> or <paramref name="section"/> is <c>null</c>.</exception>
+    public static OptionsBuilder<TOptions> BindStrongTypes<TOptions>(this OptionsBuilder<TOptions> builder, IConfiguration section)
+        where TOptions : class
+    {
+        ArgumentNullException.ThrowIfNull(builder);
+        ArgumentNullException.ThrowIfNull(section);
+
+        builder.Bind(section);
+        builder.Services.AddSingleton<IValidateOptions<TOptions>>(
+            new NonNullableOptionsValidator<TOptions>(builder.Name, section));
+
+        return builder;
+    }
+}
diff --git a/src/StrongTypes.Wpf/StrongTypes.Wpf.csproj b/src/StrongTypes.Configuration/StrongTypes.Configuration.csproj
similarity index 59%
rename from src/StrongTypes.Wpf/StrongTypes.Wpf.csproj
rename to src/StrongTypes.Configuration/StrongTypes.Configuration.csproj
index d5846b15..0c384381 100644
--- a/src/StrongTypes.Wpf/StrongTypes.Wpf.csproj
+++ b/src/StrongTypes.Configuration/StrongTypes.Configuration.csproj
@@ -1,20 +1,18 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <TargetFramework>net10.0-windows</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
     <LangVersion>14.0</LangVersion>
     <Nullable>enable</Nullable>
     <ImplicitUsings>enable</ImplicitUsings>
-    <UseWPF>true</UseWPF>
-    <EnableWindowsTargeting>true</EnableWindowsTargeting>
     <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
     <NoWarn>CS1591</NoWarn>
 
     <Version>0.0.0-dev</Version>
-    <PackageId>Kalicz.StrongTypes.Wpf</PackageId>
+    <PackageId>Kalicz.StrongTypes.Configuration</PackageId>
     <Authors>KaliCZ</Authors>
     <Copyright>Copyright © 2026 KaliCZ</Copyright>
-    <Description>WPF MVVM binding support for Kalicz.StrongTypes. Adds an Application.UseStrongTypes() extension that wires TypeConverters into TypeDescriptor for NonEmptyString, Email, Digit, and every closed instantiation of Positive&lt;T&gt;, NonNegative&lt;T&gt;, Negative&lt;T&gt;, NonPositive&lt;T&gt; — enabling two-way TextBox bindings to strong-typed view-model properties.</Description>
-    <PackageTags>StrongTypes, WPF, MVVM, Binding, TypeConverter, NonEmptyString, Email</PackageTags>
+    <Description>Configuration binding support for Kalicz.StrongTypes. Adds OptionsBuilder&lt;T&gt;.BindStrongTypes(), which binds a section and then fails when a property declared non-nullable is null once bound — what an absent key otherwise leaves silently, because binding succeeds without assigning. Reads intent from nullable reference annotations, so no [Required] attribute per property.</Description>
+    <PackageTags>StrongTypes, Configuration, Options, IOptions, Validation, NonEmptyString</PackageTags>
     <PackageLicenseExpression>MIT</PackageLicenseExpression>
     <PackageRequireLicenseAcceptance>false</PackageRequireLicenseAcceptance>
     <PackageProjectUrl>https://github.com/KaliCZ/StrongTypes</PackageProjectUrl>
@@ -27,6 +25,9 @@
   <ItemGroup>
     <ProjectReference Include="..\StrongTypes\StrongTypes.csproj" />
   </ItemGroup>
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Extensions.Options.ConfigurationExtensions" Version="10.0.0" />
+  </ItemGroup>
   <ItemGroup>
     <None Include="readme.md" Pack="true" PackagePath="\" />
   </ItemGroup>
diff --git a/src/StrongTypes.Configuration/readme.md b/src/StrongTypes.Configuration/readme.md
new file mode 100644
index 00000000..83b0c9a4
--- /dev/null
+++ b/src/StrongTypes.Configuration/readme.md
@@ -0,0 +1,91 @@
+# Kalicz.StrongTypes.Configuration
+
+[![NuGet version](https://img.shields.io/nuget/v/Kalicz.StrongTypes.Configuration?label=nuget)](https://www.nuget.org/packages/Kalicz.StrongTypes.Configuration/) [![Downloads](https://img.shields.io/nuget/dt/Kalicz.StrongTypes.Configuration?label=downloads)](https://www.nuget.org/packages/Kalicz.StrongTypes.Configuration/) [![License](https://img.shields.io/github/license/KaliCZ/StrongTypes)](https://github.com/KaliCZ/StrongTypes/blob/main/license.txt)
+
+Stops an options class binding a non-nullable property to `null`.
+
+```csharp
+builder.Services.AddOptions<RetryOptions>()
+    .BindStrongTypes(builder.Configuration.GetSection("Retry"))
+    .ValidateOnStart();
+```
+
+## The problem
+
+[`Kalicz.StrongTypes`](https://www.nuget.org/packages/Kalicz.StrongTypes/) needs no package to
+bind: every wrapper carries a `TypeConverter`, so values bind and invalid ones throw with the
+invariant's own message. **This package is only about the key that isn't there.**
+
+A wrapper's invariant constrains every value it can hold. It cannot make the binder assign one — the
+binder reaches in through reflection and never calls `Create` — and for an absent key it assigns
+nothing at all. So:
+
+```csharp
+public sealed class RetryOptions
+{
+    public NonEmptyString Name { get; set; } = null!;   // unconfigured -> null
+}
+```
+
+`null` — which the declaration says is impossible. `ValidateOnStart()` does not help:
+binding an absent key *succeeds*, it just doesn't assign, so nothing is raised. C#'s `required`
+doesn't either — it's a compile-time rule and the binder's reflection walks past it. `[Required]`
+does work, but only if you remember it on every property.
+
+## What it does
+
+Fails when a property **declared non-nullable** is null after binding. Your nullable reference
+annotations already say which properties those are, so nothing has to repeat it:
+
+```csharp
+public NonEmptyString Name { get; set; } = null!;          // fails unless configured
+public NonEmptyString? Nickname { get; set; }              // nullable — fine
+public string ApiKey { get; set; } = null!;                // fails unless configured
+public string Endpoint { get; set; } = "https://x.test";   // has a default — never null
+```
+
+```
+OptionsValidationException: 'Retry:Name' is null. Configure it, give RetryOptions.Name a default,
+                            or declare it nullable.
+```
+
+**Every reference property is covered, not only the wrappers** — a `string` declared non-nullable is
+as broken by a missing key as a `NonEmptyString` is. A declared default needs no configuration and
+no annotation: it simply isn't null.
+
+**At every depth**, too: nested options classes, collection elements and dictionary values are walked,
+and the failure names the full path (`'Retry:Endpoints:1:Host'`). The walk stops where the binder
+stops — at any type it has a `TypeConverter` for — so a wrapper is a leaf, not a graph to descend into.
+
+Pair it with `ValidateOnStart()`. On its own the failure is still lazy — it surfaces on the first
+read of `IOptions<T>.Value`, not at startup.
+
+## Value types are not checked, and don't need to be
+
+An unconfigured `Positive<int>` is `1`; an unconfigured `bool` is `false`. Those are defaults, and
+they are values those types are perfectly happy to hold — there is no contradiction to find. Only
+`null` in something that promised never to be null is one, and only a reference can manage it.
+
+So this will not tell you that you forgot to configure `MaxRetries`. If "not configured" has to be
+distinguishable from a configured default, declare it `Positive<int>?` and check for null yourself
+— that is the only way the CLR gives you to say it.
+
+## When you don't need it
+
+- Every reference property on your options classes is nullable or has a default.
+- You already use `[Required]` with `ValidateDataAnnotations()`, which covers the same ground with
+  an attribute per property.
+
+## Why a separate package
+
+So [`Kalicz.StrongTypes`](https://www.nuget.org/packages/Kalicz.StrongTypes/) stays free of
+dependencies. This package pulls in `Microsoft.Extensions.Options.ConfigurationExtensions`; a domain
+model or a library that uses `NonEmptyString` should not inherit the options and configuration stack
+transitively just to hold a value. Apps that bind configuration already have it, and add one
+reference; everyone else keeps a dependency-free core.
+
+## Nullable reference types
+
+Intent is read from the assembly's nullable annotations. An options class in a project with
+`<Nullable>disable</Nullable>` carries none, so nothing on it is enforced — with no intent declared
+there is nothing to enforce.
diff --git a/src/StrongTypes.SourceGenerators/NumericWrapperGenerator.cs b/src/StrongTypes.SourceGenerators/NumericWrapperGenerator.cs
index ff689cc9..68f9cd4a 100644
--- a/src/StrongTypes.SourceGenerators/NumericWrapperGenerator.cs
+++ b/src/StrongTypes.SourceGenerators/NumericWrapperGenerator.cs
@@ -178,7 +178,10 @@ public static string EmitType(Model m)
             sb.Append("    global::System.IComparable<").Append(self).AppendLine(">,");
             sb.Append("    global::System.IComparable<").Append(t).AppendLine(">,");
             sb.AppendLine("    global::System.IComparable,");
-            sb.Append("    global::System.IParsable<").Append(self).AppendLine(">");
+            sb.AppendLine("    global::System.IFormattable,");
+            sb.AppendLine("    global::System.ISpanFormattable,");
+            sb.Append("    global::System.IParsable<").Append(self).AppendLine(">,");
+            sb.Append("    global::System.ISpanParsable<").Append(self).AppendLine(">");
 
             foreach (var c in m.ConstraintClauses)
                 sb.Append("    ").AppendLine(c);
@@ -199,18 +202,13 @@ public static string EmitType(Model m)
             sb.Append("        => Create(").Append(t).AppendLine(".Parse(s, provider));");
             sb.AppendLine();
 
-            sb.Append("    public static bool TryParse(string? s, global::System.IFormatProvider? provider, out ").Append(self).AppendLine(" result)");
-            sb.AppendLine("    {");
-            sb.Append("        if (").Append(t).AppendLine(".TryParse(s, provider, out var underlying) && TryCreate(underlying) is { } parsed)");
-            sb.AppendLine("        {");
-            sb.AppendLine("            result = parsed;");
-            sb.AppendLine("            return true;");
-            sb.AppendLine("        }");
-            sb.AppendLine("        result = default;");
-            sb.AppendLine("        return false;");
-            sb.AppendLine("    }");
+            sb.Append("    public static ").Append(self).AppendLine(" Parse(global::System.ReadOnlySpan<char> s, global::System.IFormatProvider? provider)");
+            sb.Append("        => Create(").Append(t).AppendLine(".Parse(s, provider));");
             sb.AppendLine();
 
+            EmitTryParse(sb, self, t, "string? s");
+            EmitTryParse(sb, self, t, "global::System.ReadOnlySpan<char> s");
+
             sb.AppendLine("    public override int GetHashCode() => Value.GetHashCode();");
             sb.AppendLine();
 
@@ -256,11 +254,30 @@ public static string EmitType(Model m)
             sb.AppendLine();
 
             sb.AppendLine("    public override string ToString() => Value.ToString() ?? string.Empty;");
+            sb.AppendLine("    public string ToString(string? format, global::System.IFormatProvider? provider) => Value.ToString(format, provider);");
+            sb.AppendLine();
+            sb.AppendLine("    public bool TryFormat(global::System.Span<char> destination, out int charsWritten, global::System.ReadOnlySpan<char> format, global::System.IFormatProvider? provider)");
+            sb.AppendLine("        => Value.TryFormat(destination, out charsWritten, format, provider);");
 
             sb.AppendLine("}");
             return sb.ToString();
         }
 
+        private static void EmitTryParse(StringBuilder sb, string self, string underlyingType, string parameter)
+        {
+            sb.Append("    public static bool TryParse(").Append(parameter).Append(", global::System.IFormatProvider? provider, out ").Append(self).AppendLine(" result)");
+            sb.AppendLine("    {");
+            sb.Append("        if (").Append(underlyingType).AppendLine(".TryParse(s, provider, out var underlying) && TryCreate(underlying) is { } parsed)");
+            sb.AppendLine("        {");
+            sb.AppendLine("            result = parsed;");
+            sb.AppendLine("            return true;");
+            sb.AppendLine("        }");
+            sb.AppendLine("        result = default;");
+            sb.AppendLine("        return false;");
+            sb.AppendLine("    }");
+            sb.AppendLine();
+        }
+
         public static string EmitExtensions(Model m)
         {
             var sb = new StringBuilder();
diff --git a/src/StrongTypes.Tests/ComponentModel/ConfigurationBindingTests.cs b/src/StrongTypes.Tests/ComponentModel/ConfigurationBindingTests.cs
new file mode 100644
index 00000000..ffe5f641
--- /dev/null
+++ b/src/StrongTypes.Tests/ComponentModel/ConfigurationBindingTests.cs
@@ -0,0 +1,205 @@
+using System;
+using System.IO;
+using System.Text;
+using FsCheck.Xunit;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Options;
+using Xunit;
+
+namespace StrongTypes.Tests;
+
+/// <summary>
+/// Without a <c>TypeConverter</c>, <c>ConfigurationBinder</c> silently leaves the property at its
+/// default rather than failing — so these assert the bound value, not merely that binding returned.
+/// </summary>
+public class ConfigurationBindingTests
+{
+    public enum BindingPath
+    {
+        ConfigurationGet,
+        Options,
+    }
+
+    public static TheoryData<BindingPath> Paths => new() { BindingPath.ConfigurationGet, BindingPath.Options };
+
+    private sealed class RetryOptions
+    {
+        public NonEmptyString Name { get; set; } = NonEmptyString.Create("initial");
+        public NonEmptyString? Nickname { get; set; }
+        public Positive<int> MaxRetries { get; set; }
+        public Positive<int>? Score { get; set; }
+        public NonNegative<int> InitialDelaySeconds { get; set; }
+        public Email? Contact { get; set; }
+        public Digit Tier { get; set; }
+    }
+
+    private static IConfiguration Config(string settings) =>
+        new ConfigurationBuilder()
+            .AddJsonStream(new MemoryStream(Encoding.UTF8.GetBytes("{\"Retry\":{" + settings + "}}")))
+            .Build();
+
+    private static RetryOptions Bind(BindingPath path, string settings)
+    {
+        var section = Config(settings).GetSection("Retry");
+        if (path is BindingPath.ConfigurationGet)
+            return section.Get<RetryOptions>() ?? new RetryOptions();
+
+        var services = new ServiceCollection();
+        services.AddOptions<RetryOptions>().Bind(section);
+        return services.BuildServiceProvider().GetRequiredService<IOptions<RetryOptions>>().Value;
+    }
+
+    // ── The scenario the converter unlocks ──────────────────────────────
+
+    [Theory]
+    [MemberData(nameof(Paths))]
+    public void EveryStrongTypeBindsFromConfiguration(BindingPath path)
+    {
+        var options = Bind(path, """
+            "Name": "checkout",
+            "Nickname": "co",
+            "MaxRetries": 5,
+            "Score": 99,
+            "InitialDelaySeconds": 0,
+            "Contact": "ops@example.com",
+            "Tier": 7
+            """);
+
+        Assert.Equal("checkout", options.Name.Value);
+        Assert.Equal("co", options.Nickname?.Value);
+        Assert.Equal(5, options.MaxRetries.Value);
+        Assert.Equal(99, options.Score?.Value);
+        Assert.Equal(0, options.InitialDelaySeconds.Value);
+        Assert.Equal("ops@example.com", options.Contact?.Address);
+        Assert.Equal(7, options.Tier.Value);
+    }
+
+    /// <summary><c>default(Positive&lt;int&gt;)</c> is a plausible-looking <c>1</c>, so a dropped config value reads as a real one — hence asserting the bound value differs from the default.</summary>
+    [Property]
+    public void BoundValueComesFromConfiguration_NotTheDefault(int configured)
+    {
+        if (configured <= 0 || configured == default(Positive<int>).Value) return;
+
+        foreach (var path in new[] { BindingPath.ConfigurationGet, BindingPath.Options })
+        {
+            var options = Bind(path, $"\"MaxRetries\": {configured}");
+
+            Assert.Equal(configured, options.MaxRetries.Value);
+            Assert.NotEqual(default(Positive<int>).Value, options.MaxRetries.Value);
+        }
+    }
+
+    // ── Absent vs. explicit null ────────────────────────────────────────
+
+    /// <summary>An absent key leaves the property exactly as the options class constructed it — here a non-null initialiser.</summary>
+    [Theory]
+    [MemberData(nameof(Paths))]
+    public void AbsentKey_LeavesWhateverThePropertyAlreadyHeld(BindingPath path)
+    {
+        var options = Bind(path, "\"Tier\": 7");
+
+        Assert.Equal("initial", options.Name.Value);
+        Assert.Equal(default(Positive<int>).Value, options.MaxRetries.Value);
+        Assert.Null(options.Nickname);
+        Assert.Null(options.Score);
+    }
+
+    /// <summary>An explicit <c>null</c> is not the same as an absent key: it overwrites, so a struct wrapper falls back to <c>default</c> rather than keeping the value the object was constructed with.</summary>
+    [Theory]
+    [MemberData(nameof(Paths))]
+    public void ExplicitNull_OnAStructWrapper_LeavesTheDefault(BindingPath path)
+    {
+        var options = Bind(path, "\"MaxRetries\": null, \"Score\": null");
+
+        Assert.Equal(default(Positive<int>).Value, options.MaxRetries.Value);
+        Assert.Null(options.Score);
+    }
+
+    [Theory]
+    [MemberData(nameof(Paths))]
+    public void ExplicitNull_OnANullableReferenceWrapper_IsNull(BindingPath path) =>
+        Assert.Null(Bind(path, "\"Nickname\": null").Nickname);
+
+    /// <summary>A <c>null</c> in config nulls even a non-nullable reference property, because nullability is erased by the time the binder runs — <c>NonEmptyString</c> is no different from <c>string</c> here.</summary>
+    [Theory]
+    [MemberData(nameof(Paths))]
+    public void ExplicitNull_DefeatsANonNullableReferenceWrapper(BindingPath path) =>
+        Assert.Null(Bind(path, "\"Name\": null").Name);
+
+    // ── Empty string: not uniform, and not obvious ──────────────────────
+
+    /// <summary>Empty is not a legal <see cref="NonEmptyString"/>, and being declared nullable does not make it one — our converter is handed <c>""</c> either way, because a nullable reference is the same runtime type.</summary>
+    [Theory]
+    [InlineData(BindingPath.ConfigurationGet, "\"Name\": \"\"")]
+    [InlineData(BindingPath.ConfigurationGet, "\"Name\": \"  \"")]
+    [InlineData(BindingPath.ConfigurationGet, "\"Nickname\": \"\"")]
+    [InlineData(BindingPath.ConfigurationGet, "\"Nickname\": \"  \"")]
+    [InlineData(BindingPath.Options, "\"Name\": \"\"")]
+    [InlineData(BindingPath.Options, "\"Name\": \"  \"")]
+    [InlineData(BindingPath.Options, "\"Nickname\": \"\"")]
+    [InlineData(BindingPath.Options, "\"Nickname\": \"  \"")]
+    public void EmptyString_OnAReferenceWrapper_Throws_NullableOrNot(BindingPath path, string settings) =>
+        Assert.Throws<InvalidOperationException>(() => Bind(path, settings));
+
+    [Theory]
+    [MemberData(nameof(Paths))]
+    public void EmptyString_OnANonNullableStructWrapper_Throws(BindingPath path) =>
+        Assert.Throws<InvalidOperationException>(() => Bind(path, "\"MaxRetries\": \"\""));
+
+    /// <summary>The one asymmetry: empty binds to <c>null</c> here rather than throwing.</summary>
+    [Theory]
+    [MemberData(nameof(Paths))]
+    public void EmptyString_OnANullableStructWrapper_IsNull(BindingPath path) =>
+        Assert.Null(Bind(path, "\"Score\": \"\"").Score);
+
+    // ── Invalid configuration fails, and says why ───────────────────────
+
+    [Theory]
+    [InlineData(BindingPath.ConfigurationGet, "\"MaxRetries\": -5", "MaxRetries", "-5", "must be positive")]
+    [InlineData(BindingPath.ConfigurationGet, "\"MaxRetries\": 0", "MaxRetries", "0", "must be positive")]
+    [InlineData(BindingPath.ConfigurationGet, "\"Score\": -1", "Score", "-1", "must be positive")]
+    [InlineData(BindingPath.ConfigurationGet, "\"InitialDelaySeconds\": -1", "InitialDelaySeconds", "-1", "must be non-negative")]
+    [InlineData(BindingPath.ConfigurationGet, "\"Contact\": \"not-an-email\"", "Contact", "not-an-email", "valid email")]
+    [InlineData(BindingPath.ConfigurationGet, "\"Tier\": 42", "Tier", "42", "single decimal digit")]
+    [InlineData(BindingPath.Options, "\"MaxRetries\": -5", "MaxRetries", "-5", "must be positive")]
+    [InlineData(BindingPath.Options, "\"MaxRetries\": 0", "MaxRetries", "0", "must be positive")]
+    [InlineData(BindingPath.Options, "\"Score\": -1", "Score", "-1", "must be positive")]
+    [InlineData(BindingPath.Options, "\"InitialDelaySeconds\": -1", "InitialDelaySeconds", "-1", "must be non-negative")]
+    [InlineData(BindingPath.Options, "\"Contact\": \"not-an-email\"", "Contact", "not-an-email", "valid email")]
+    [InlineData(BindingPath.Options, "\"Tier\": 42", "Tier", "42", "single decimal digit")]
+    public void ValueBreakingTheInvariant_ThrowsAndNamesTheReason(
+        BindingPath path, string settings, string key, string value, string expectedReason)
+    {
+        var exception = Assert.Throws<InvalidOperationException>(() => Bind(path, settings));
+
+        Assert.Contains($"Retry:{key}", exception.Message, StringComparison.Ordinal);
+        Assert.Contains(value, exception.Message, StringComparison.Ordinal);
+
+        var inner = Assert.IsType<ArgumentException>(exception.InnerException);
+        Assert.Contains(expectedReason, inner.Message, StringComparison.OrdinalIgnoreCase);
+    }
+
+    [Theory]
+    [InlineData(BindingPath.ConfigurationGet, "\"MaxRetries\": \"not-a-number\"")]
+    [InlineData(BindingPath.ConfigurationGet, "\"Tier\": \"not-a-digit\"")]
+    [InlineData(BindingPath.Options, "\"MaxRetries\": \"not-a-number\"")]
+    [InlineData(BindingPath.Options, "\"Tier\": \"not-a-digit\"")]
+    public void ValueInTheWrongFormat_Throws(BindingPath path, string settings) =>
+        Assert.Throws<InvalidOperationException>(() => Bind(path, settings));
+
+    // ── When the failure surfaces ───────────────────────────────────────
+
+    /// <summary>Binding is lazy: the failure surfaces on first <c>IOptions.Value</c>, not at <c>BuildServiceProvider</c>.</summary>
+    [Fact]
+    public void InvalidValue_DoesNotThrowUntilOptionsAreRead()
+    {
+        var services = new ServiceCollection();
+        services.AddOptions<RetryOptions>().Bind(Config("\"MaxRetries\": -5").GetSection("Retry"));
+
+        var provider = services.BuildServiceProvider();
+        var accessor = provider.GetRequiredService<IOptions<RetryOptions>>();
+
+        Assert.Throws<InvalidOperationException>(() => accessor.Value);
+    }
+}
diff --git a/src/StrongTypes.Tests/ComponentModel/TypeConverterTests.cs b/src/StrongTypes.Tests/ComponentModel/TypeConverterTests.cs
new file mode 100644
index 00000000..4dc2976c
--- /dev/null
+++ b/src/StrongTypes.Tests/ComponentModel/TypeConverterTests.cs
@@ -0,0 +1,114 @@
+using System;
+using System.ComponentModel;
+using System.Globalization;
+using FsCheck.Xunit;
+using Xunit;
+
+namespace StrongTypes.Tests;
+
+public class TypeConverterTests
+{
+    public static TheoryData<Type, string> ConvertibleTypes => new()
+    {
+        { typeof(NonEmptyString), "hello" },
+        { typeof(Email), "ops@example.com" },
+        { typeof(Digit), "7" },
+        { typeof(Positive<int>), "42" },
+        { typeof(NonNegative<int>), "0" },
+        { typeof(Negative<int>), "-42" },
+        { typeof(NonPositive<long>), "0" },
+    };
+
+    /// <summary>Anything reaching a strong type through <see cref="TypeDescriptor"/> — configuration binding, WPF/WinForms bindings, designers — starts here.</summary>
+    [Theory]
+    [MemberData(nameof(ConvertibleTypes))]
+    public void TypeDescriptor_ResolvesAConverterThatAcceptsStrings(Type type, string wire)
+    {
+        var converter = TypeDescriptor.GetConverter(type);
+
+        Assert.True(converter.CanConvertFrom(typeof(string)));
+        Assert.True(converter.CanConvertTo(typeof(string)));
+
+        var converted = converter.ConvertFromInvariantString(wire);
+
+        Assert.NotNull(converted);
+        Assert.IsType(type, converted);
+        Assert.Equal(wire, converter.ConvertToInvariantString(converted));
+    }
+
+    [Theory]
+    [MemberData(nameof(ConvertibleTypes))]
+    public void Converter_RejectsNonStringSources(Type type, string wire)
+    {
+        _ = wire;
+        var converter = TypeDescriptor.GetConverter(type);
+
+        Assert.False(converter.CanConvertFrom(typeof(Guid)));
+        Assert.Throws<NotSupportedException>(() => converter.ConvertFrom(Guid.NewGuid()));
+    }
+
+    /// <summary>A broken invariant surfaces as the wrapper's own <see cref="ArgumentException"/>, not a generic conversion failure — that message is what the caller reports.</summary>
+    [Theory]
+    [InlineData(typeof(Positive<int>), "-5")]
+    [InlineData(typeof(NonNegative<int>), "-1")]
+    [InlineData(typeof(NonEmptyString), "   ")]
+    [InlineData(typeof(Email), "not-an-email")]
+    [InlineData(typeof(Digit), "42")]
+    public void Converter_InvariantBreach_ThrowsArgumentException(Type type, string wire) =>
+        Assert.Throws<ArgumentException>(() => TypeDescriptor.GetConverter(type).ConvertFromInvariantString(wire));
+
+    [Fact]
+    public void Converter_MalformedNumber_ThrowsFormatException() =>
+        Assert.Throws<FormatException>(() => TypeDescriptor.GetConverter(typeof(Positive<int>)).ConvertFromInvariantString("not-a-number"));
+
+    // ── Culture ─────────────────────────────────────────────────────────
+
+    /// <summary>The converter parses in the culture it is handed, so a decimal comma is a decimal point's equal.</summary>
+    [Fact]
+    public void Converter_ParsesInTheSuppliedCulture()
+    {
+        var converter = TypeDescriptor.GetConverter(typeof(Positive<decimal>));
+        var german = CultureInfo.GetCultureInfo("de-DE");
+
+        Assert.Equal(1234.5m, ((Positive<decimal>)converter.ConvertFrom(null, german, "1234,5")!).Value);
+        Assert.Equal(1234.5m, ((Positive<decimal>)converter.ConvertFrom(null, CultureInfo.InvariantCulture, "1234.5")!).Value);
+    }
+
+    /// <summary><c>ConvertTo</c> must format in the same culture <c>ConvertFrom</c> parses in, or the pair does not round-trip.</summary>
+    [Theory]
+    [InlineData("de-DE")]
+    [InlineData("en-US")]
+    [InlineData("")]
+    public void Converter_RoundTripsThroughOneCulture(string cultureName)
+    {
+        var culture = CultureInfo.GetCultureInfo(cultureName);
+        var converter = TypeDescriptor.GetConverter(typeof(Positive<decimal>));
+        var original = Positive<decimal>.Create(1234.5m);
+
+        var text = converter.ConvertTo(null, culture, original, typeof(string));
+        var roundTripped = converter.ConvertFrom(null, culture, text!);
+
+        Assert.Equal(original, roundTripped);
+    }
+
+    [Property]
+    public void Converter_RoundTripsEveryPositiveInt(int value)
+    {
+        if (value <= 0) return;
+
+        var converter = TypeDescriptor.GetConverter(typeof(Positive<int>));
+        var text = converter.ConvertToInvariantString(Positive<int>.Create(value));
+
+        Assert.Equal(Positive<int>.Create(value), converter.ConvertFromInvariantString(text!));
+    }
+
+    // ── StrongTypeConverter's own contract ──────────────────────────────
+
+    [Fact]
+    public void StrongTypeConverter_NonParsableType_Throws() =>
+        Assert.Throws<ArgumentException>(() => new StrongTypeConverter(typeof(object)));
+
+    [Fact]
+    public void StrongTypeConverter_NullType_Throws() =>
+        Assert.Throws<ArgumentNullException>(() => new StrongTypeConverter(null!));
+}
diff --git a/src/StrongTypes.Tests/ComponentModel/UnconfiguredOptionsTests.cs b/src/StrongTypes.Tests/ComponentModel/UnconfiguredOptionsTests.cs
new file mode 100644
index 00000000..8ec398d4
--- /dev/null
+++ b/src/StrongTypes.Tests/ComponentModel/UnconfiguredOptionsTests.cs
@@ -0,0 +1,112 @@
+using System.ComponentModel.DataAnnotations;
+using System.IO;
+using System.Text;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Options;
+using Xunit;
+
+namespace StrongTypes.Tests;
+
+/// <summary>What a strong type holds when its key is simply not in config.</summary>
+public class UnconfiguredOptionsTests
+{
+    private sealed class RetryOptions
+    {
+        public NonEmptyString Name { get; set; } = null!;
+        public Positive<int> MaxRetries { get; set; }
+        public Positive<int>? MaxRetriesOrUnset { get; set; }
+        public Digit Tier { get; set; }
+    }
+
+    private sealed class RequiredRetryOptions
+    {
+        [Required] public NonEmptyString Name { get; set; } = null!;
+        [Required] public Positive<int> MaxRetries { get; set; }
+        [Required] public Positive<int>? MaxRetriesOrUnset { get; set; }
+        public Digit Tier { get; set; }
+    }
+
+    /// <summary>The section exists so the binder produces an instance rather than returning null.</summary>
+    private const string OnlyTierConfigured = "{\"Retry\":{\"Tier\":7}}";
+
+    private static IConfigurationSection Section(string json) =>
+        new ConfigurationBuilder()
+            .AddJsonStream(new MemoryStream(Encoding.UTF8.GetBytes(json)))
+            .Build()
+            .GetSection("Retry");
+
+    private static TOptions Bind<TOptions>(string json, bool validate = false) where TOptions : class
+    {
+        var services = new ServiceCollection();
+        var builder = services.AddOptions<TOptions>().Bind(Section(json));
+        if (validate) builder.ValidateDataAnnotations();
+        return services.BuildServiceProvider().GetRequiredService<IOptions<TOptions>>().Value;
+    }
+
+    /// <summary>A non-nullable reference wrapper is <c>null</c> when unconfigured — nullability is erased before the binder runs, so it behaves exactly as a <see cref="string"/> would.</summary>
+    [Fact]
+    public void UnconfiguredReferenceWrapper_IsNull() =>
+        Assert.Null(Bind<RetryOptions>(OnlyTierConfigured).Name);
+
+    /// <summary>A struct wrapper falls back to <c>default</c>, which satisfies the invariant and so reads as a deliberately configured value.</summary>
+    [Fact]
+    public void UnconfiguredStructWrapper_IsItsDefault()
+    {
+        var options = Bind<RetryOptions>(OnlyTierConfigured);
+
+        Assert.Equal(default(Positive<int>).Value, options.MaxRetries.Value);
+        Assert.Equal(1, options.MaxRetries.Value);
+        Assert.Equal(7, options.Tier.Value);
+    }
+
+    [Fact]
+    public void UnconfiguredNullableStructWrapper_IsNull() =>
+        Assert.Null(Bind<RetryOptions>(OnlyTierConfigured).MaxRetriesOrUnset);
+
+    /// <summary>Binding alone raises nothing for a missing key, whatever the property's nullability says.</summary>
+    [Fact]
+    public void MissingKeys_BindWithoutError()
+    {
+        var options = Bind<RetryOptions>(OnlyTierConfigured);
+
+        Assert.Null(options.Name);
+        Assert.Equal(1, options.MaxRetries.Value);
+    }
+
+    /// <summary>
+    /// <c>[Required]</c> plus <c>ValidateDataAnnotations()</c> catches a missing reference wrapper
+    /// and a missing nullable struct wrapper — both are null — but <b>cannot</b> catch a missing
+    /// non-nullable struct wrapper, whose default is an ordinary value and never null.
+    /// </summary>
+    [Fact]
+    public void Required_CatchesNullsOnly_NotAStructsDefault()
+    {
+        var exception = Assert.Throws<OptionsValidationException>(
+            () => Bind<RequiredRetryOptions>(OnlyTierConfigured, validate: true));
+
+        var failures = string.Join(" | ", exception.Failures);
+
+        Assert.Contains($"'{nameof(RequiredRetryOptions.Name)}'", failures, System.StringComparison.Ordinal);
+        Assert.Contains($"'{nameof(RequiredRetryOptions.MaxRetriesOrUnset)}'", failures, System.StringComparison.Ordinal);
+        Assert.DoesNotContain($"'{nameof(RequiredRetryOptions.MaxRetries)}'", failures, System.StringComparison.Ordinal);
+    }
+
+    /// <summary>Every key present and valid: validation passes, so the failures above are about absence rather than the annotations themselves.</summary>
+    [Fact]
+    public void Required_FullyConfigured_Passes()
+    {
+        var options = Bind<RequiredRetryOptions>(
+            "{\"Retry\":{\"Name\":\"checkout\",\"MaxRetries\":5,\"MaxRetriesOrUnset\":9,\"Tier\":7}}",
+            validate: true);
+
+        Assert.Equal("checkout", options.Name.Value);
+        Assert.Equal(5, options.MaxRetries.Value);
+        Assert.Equal(9, options.MaxRetriesOrUnset?.Value);
+    }
+
+    /// <summary><c>Get&lt;T&gt;</c> on a section with no children at all returns <c>null</c> rather than a defaulted instance.</summary>
+    [Fact]
+    public void EmptySection_GetReturnsNull() =>
+        Assert.Null(Section("{\"Retry\":{}}").Get<RetryOptions>());
+}
diff --git a/src/StrongTypes.Tests/Numbers/NumericFormattingTests.cs b/src/StrongTypes.Tests/Numbers/NumericFormattingTests.cs
new file mode 100644
index 00000000..def69c3c
--- /dev/null
+++ b/src/StrongTypes.Tests/Numbers/NumericFormattingTests.cs
@@ -0,0 +1,150 @@
+using System;
+using System.Globalization;
+using FsCheck.Xunit;
+using Xunit;
+
+namespace StrongTypes.Tests;
+
+/// <summary>Composite formatting silently ignores a specifier on a type that is not <see cref="IFormattable"/> — <c>$"{price:C}"</c> compiles, never throws, and prints the unformatted number — so these pin the specifier and the culture reaching the underlying value.</summary>
+public class NumericFormattingTests
+{
+    private static readonly CultureInfo German = CultureInfo.GetCultureInfo("de-DE");
+    private static readonly CultureInfo American = CultureInfo.GetCultureInfo("en-US");
+
+    // ── IFormattable ────────────────────────────────────────────────────
+
+    [Fact]
+    public void FormatSpecifier_IsHonouredInInterpolation()
+    {
+        var price = Positive<decimal>.Create(1234.5m);
+
+        Assert.Equal("1,234.50", string.Format(American, "{0:N2}", price));
+        Assert.Equal("$1,234.50", string.Format(American, "{0:C}", price));
+        Assert.Equal("1.234,50", string.Format(German, "{0:N2}", price));
+    }
+
+    [Fact]
+    public void FormatProvider_IsHonouredWithoutASpecifier() =>
+        Assert.Equal("1234,5", string.Format(German, "{0}", Positive<decimal>.Create(1234.5m)));
+
+    [Theory]
+    [InlineData("N2", "1,234.50")]
+    [InlineData("C", "$1,234.50")]
+    [InlineData("F0", "1235")]
+    [InlineData("E2", "1.23E+003")]
+    [InlineData(null, "1234.5")]
+    public void ToString_MatchesTheUnderlyingValue(string? format, string expected)
+    {
+        var price = Positive<decimal>.Create(1234.5m);
+
+        Assert.Equal(expected, price.ToString(format, American));
+        Assert.Equal(price.Value.ToString(format, American), price.ToString(format, American));
+    }
+
+    /// <summary>The wrapper must never disagree with the value it wraps, for any format the underlying type accepts.</summary>
+    [Property]
+    public void ToString_NeverDivergesFromTheUnderlyingValue(int value)
+    {
+        if (value <= 0) return;
+
+        var positive = Positive<int>.Create(value);
+        foreach (var format in new[] { "D", "N0", "X", "G", null })
+        {
+            Assert.Equal(value.ToString(format, American), positive.ToString(format, American));
+        }
+    }
+
+    [Fact]
+    public void EveryWrapper_IsFormattable()
+    {
+        Assert.Equal("1,234.50", string.Format(American, "{0:N2}", Positive<decimal>.Create(1234.5m)));
+        Assert.Equal("1,234.50", string.Format(American, "{0:N2}", NonNegative<decimal>.Create(1234.5m)));
+        Assert.Equal("-1,234.50", string.Format(American, "{0:N2}", Negative<decimal>.Create(-1234.5m)));
+        Assert.Equal("-1,234.50", string.Format(American, "{0:N2}", NonPositive<decimal>.Create(-1234.5m)));
+    }
+
+    // ── ISpanFormattable ────────────────────────────────────────────────
+
+    [Fact]
+    public void TryFormat_WritesIntoTheDestination()
+    {
+        Span<char> destination = stackalloc char[32];
+
+        Assert.True(Positive<decimal>.Create(1234.5m).TryFormat(destination, out var written, "N2", American));
+        Assert.Equal("1,234.50", destination[..written].ToString());
+    }
+
+    [Fact]
+    public void TryFormat_DestinationTooShort_ReturnsFalse()
+    {
+        Span<char> destination = stackalloc char[2];
+
+        Assert.False(Positive<decimal>.Create(1234.5m).TryFormat(destination, out var written, "N2", American));
+        Assert.Equal(0, written);
+    }
+
+    // ── ISpanParsable ───────────────────────────────────────────────────
+
+    [Fact]
+    public void Parse_ReadsASliceWithoutMaterialisingIt()
+    {
+        const string line = "sku-1,42,widget";
+
+        Assert.Equal(42, Positive<int>.Parse(line.AsSpan(6, 2), CultureInfo.InvariantCulture).Value);
+    }
+
+    [Property]
+    public void TryParse_Span_MatchesTryParse_String(int value)
+    {
+        var text = value.ToString(CultureInfo.InvariantCulture);
+
+        var fromString = Positive<int>.TryParse(text, CultureInfo.InvariantCulture, out var parsedFromString);
+        var fromSpan = Positive<int>.TryParse(text.AsSpan(), CultureInfo.InvariantCulture, out var parsedFromSpan);
+
+        Assert.Equal(fromString, fromSpan);
+        Assert.Equal(parsedFromString, parsedFromSpan);
+        Assert.Equal(value > 0, fromSpan);
+    }
+
+    [Fact]
+    public void Parse_Span_StillEnforcesTheInvariant() =>
+        Assert.Throws<ArgumentException>(() => Positive<int>.Parse("-5".AsSpan(), CultureInfo.InvariantCulture));
+
+    [Fact]
+    public void TryParse_Span_BreachedInvariant_ReturnsFalse()
+    {
+        Assert.False(Positive<int>.TryParse("-5".AsSpan(), CultureInfo.InvariantCulture, out var result));
+        Assert.Equal(default, result);
+    }
+
+    // ── Generic constraints ─────────────────────────────────────────────
+
+    private static string Render<T>(T value, string format) where T : IFormattable =>
+        value.ToString(format, American);
+
+    private static T Read<T>(ReadOnlySpan<char> text) where T : ISpanParsable<T> =>
+        T.Parse(text, CultureInfo.InvariantCulture);
+
+    private static string RenderIntoBuffer<T>(T value, string format) where T : ISpanFormattable
+    {
+        Span<char> destination = stackalloc char[64];
+        return value.TryFormat(destination, out var written, format, American) ? destination[..written].ToString() : "";
+    }
+
+    [Fact]
+    public void SatisfiesTheIFormattableConstraint() =>
+        Assert.Equal("$1,234.50", Render(Positive<decimal>.Create(1234.5m), "C"));
+
+    [Fact]
+    public void SatisfiesTheISpanFormattableConstraint() =>
+        Assert.Equal("1,234.50", RenderIntoBuffer(Positive<decimal>.Create(1234.5m), "N2"));
+
+    [Fact]
+    public void SatisfiesTheISpanParsableConstraint()
+    {
+        Assert.Equal(42, Read<Positive<int>>("42").Value);
+        Assert.Equal(0, Read<NonNegative<int>>("0").Value);
+        Assert.Equal(-42, Read<Negative<int>>("-42").Value);
+        Assert.Equal(-42, Read<NonPositive<int>>("-42").Value);
+    }
+}
diff --git a/src/StrongTypes.Tests/StrongTypes.Tests.csproj b/src/StrongTypes.Tests/StrongTypes.Tests.csproj
index d2d42542..7ea5f1b5 100644
--- a/src/StrongTypes.Tests/StrongTypes.Tests.csproj
+++ b/src/StrongTypes.Tests/StrongTypes.Tests.csproj
@@ -12,6 +12,11 @@
   </PropertyGroup>
   <ItemGroup>
     <PackageReference Include="FsCheck.Xunit.v3" Version="3.3.2" />
+    <PackageReference Include="Microsoft.Extensions.Configuration" Version="10.0.0" />
+    <PackageReference Include="Microsoft.Extensions.Configuration.Json" Version="10.0.0" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="10.0.0" />
+    <PackageReference Include="Microsoft.Extensions.Options.ConfigurationExtensions" Version="10.0.0" />
+    <PackageReference Include="Microsoft.Extensions.Options.DataAnnotations" Version="10.0.0" />
     <PackageReference Include="Microsoft.Testing.Extensions.CodeCoverage" Version="17.14.2" />
     <PackageReference Include="xunit.v3" Version="3.2.2" />
   </ItemGroup>
diff --git a/src/StrongTypes.Wpf.TestApp/App.xaml.cs b/src/StrongTypes.Wpf.TestApp/App.xaml.cs
index 563fd010..c589f96c 100644
--- a/src/StrongTypes.Wpf.TestApp/App.xaml.cs
+++ b/src/StrongTypes.Wpf.TestApp/App.xaml.cs
@@ -1,10 +1,3 @@
 namespace StrongTypes.Wpf.TestApp;
 
-public partial class App : System.Windows.Application
-{
-    protected override void OnStartup(System.Windows.StartupEventArgs e)
-    {
-        this.UseStrongTypes();
-        base.OnStartup(e);
-    }
-}
+public partial class App : System.Windows.Application;
diff --git a/src/StrongTypes.Wpf.TestApp/PersonViewModel.cs b/src/StrongTypes.Wpf.TestApp/PersonViewModel.cs
index c70c62a0..7b0cdd46 100644
--- a/src/StrongTypes.Wpf.TestApp/PersonViewModel.cs
+++ b/src/StrongTypes.Wpf.TestApp/PersonViewModel.cs
@@ -10,6 +10,10 @@ public sealed class PersonViewModel : INotifyPropertyChanged
     private NonEmptyString _name = NonEmptyString.Create("Alice");
     private Email _email = Email.Create("alice@example.com");
     private Positive<int> _age = Positive<int>.Create(30);
+    private Digit _tier = Digit.Create('7');
+    private Positive<decimal> _salary = Positive<decimal>.Create(1234.5m);
+    private NonEmptyString? _nickname;
+    private Positive<int>? _score;
 
     public NonEmptyString Name
     {
@@ -29,6 +33,30 @@ public Positive<int> Age
         set { _age = value; Raise(); }
     }
 
+    public Digit Tier
+    {
+        get => _tier;
+        set { _tier = value; Raise(); }
+    }
+
+    public Positive<decimal> Salary
+    {
+        get => _salary;
+        set { _salary = value; Raise(); }
+    }
+
+    public NonEmptyString? Nickname
+    {
+        get => _nickname;
+        set { _nickname = value; Raise(); }
+    }
+
+    public Positive<int>? Score
+    {
+        get => _score;
+        set { _score = value; Raise(); }
+    }
+
     public event PropertyChangedEventHandler? PropertyChanged;
 
     private void Raise([CallerMemberName] string? propertyName = null) =>
diff --git a/src/StrongTypes.Wpf.TestApp/StrongTypes.Wpf.TestApp.csproj b/src/StrongTypes.Wpf.TestApp/StrongTypes.Wpf.TestApp.csproj
index 140e72e9..83121a6f 100644
--- a/src/StrongTypes.Wpf.TestApp/StrongTypes.Wpf.TestApp.csproj
+++ b/src/StrongTypes.Wpf.TestApp/StrongTypes.Wpf.TestApp.csproj
@@ -13,6 +13,5 @@
   </PropertyGroup>
   <ItemGroup>
     <ProjectReference Include="..\StrongTypes\StrongTypes.csproj" />
-    <ProjectReference Include="..\StrongTypes.Wpf\StrongTypes.Wpf.csproj" />
   </ItemGroup>
 </Project>
diff --git a/src/StrongTypes.Wpf.Tests/BindingTests.cs b/src/StrongTypes.Wpf.Tests/BindingTests.cs
index 089a7fc0..0e873844 100644
--- a/src/StrongTypes.Wpf.Tests/BindingTests.cs
+++ b/src/StrongTypes.Wpf.Tests/BindingTests.cs
@@ -4,6 +4,7 @@
 using System.Windows.Data;
 using StrongTypes.Wpf.TestApp;
 using Xunit;
+using static StrongTypes.Wpf.Tests.Bindings;
 
 namespace StrongTypes.Wpf.Tests;
 
@@ -64,24 +65,9 @@ public void TwoWay_InvalidInput_DoesNotMutateSourceAndRaisesValidationError()
             textBox.Text = "   ";
 
             Assert.Equal(NonEmptyString.Create("Alice"), vm.Name);
-            Assert.True(System.Windows.Controls.Validation.GetHasError(textBox));
+            Assert.True(Validation.GetHasError(textBox));
         });
     }
-
-    private static Binding OneWay(string path, object source) => new(path)
-    {
-        Source = source,
-        Mode = BindingMode.OneWay,
-    };
-
-    private static Binding TwoWay(string path, object source) => new(path)
-    {
-        Source = source,
-        Mode = BindingMode.TwoWay,
-        UpdateSourceTrigger = UpdateSourceTrigger.PropertyChanged,
-        ValidatesOnExceptions = true,
-        NotifyOnValidationError = true,
-    };
 }
 
 public class EmailBindingTests
@@ -126,24 +112,9 @@ public void TwoWay_InvalidInput_DoesNotMutateSourceAndRaisesValidationError()
             textBox.Text = "not-an-email";
 
             Assert.Equal(Email.Create("alice@example.com"), vm.Email);
-            Assert.True(System.Windows.Controls.Validation.GetHasError(textBox));
+            Assert.True(Validation.GetHasError(textBox));
         });
     }
-
-    private static Binding OneWay(string path, object source) => new(path)
-    {
-        Source = source,
-        Mode = BindingMode.OneWay,
-    };
-
-    private static Binding TwoWay(string path, object source) => new(path)
-    {
-        Source = source,
-        Mode = BindingMode.TwoWay,
-        UpdateSourceTrigger = UpdateSourceTrigger.PropertyChanged,
-        ValidatesOnExceptions = true,
-        NotifyOnValidationError = true,
-    };
 }
 
 public class PositiveIntBindingTests
@@ -188,7 +159,7 @@ public void TwoWay_InvalidInput_DoesNotMutateSourceAndRaisesValidationError()
             textBox.Text = "0";
 
             Assert.Equal(Positive<int>.Create(30), vm.Age);
-            Assert.True(System.Windows.Controls.Validation.GetHasError(textBox));
+            Assert.True(Validation.GetHasError(textBox));
         });
     }
 
@@ -204,22 +175,54 @@ public void TwoWay_NonNumericInput_DoesNotMutateSourceAndRaisesValidationError()
             textBox.Text = "abc";
 
             Assert.Equal(Positive<int>.Create(30), vm.Age);
-            Assert.True(System.Windows.Controls.Validation.GetHasError(textBox));
+            Assert.True(Validation.GetHasError(textBox));
         });
     }
+}
 
-    private static Binding OneWay(string path, object source) => new(path)
+public class DigitBindingTests
+{
+    [Fact]
+    public void OneWay_DisplaysCurrentValue()
     {
-        Source = source,
-        Mode = BindingMode.OneWay,
-    };
+        StaThread.Run(() =>
+        {
+            var vm = new PersonViewModel { Tier = Digit.Create('7') };
+            var textBox = new TextBox();
+            BindingOperations.SetBinding(textBox, TextBox.TextProperty, OneWay(nameof(vm.Tier), vm));
 
-    private static Binding TwoWay(string path, object source) => new(path)
+            Assert.Equal("7", textBox.Text);
+        });
+    }
+
+    [Fact]
+    public void TwoWay_ValidInput_UpdatesSource()
     {
-        Source = source,
-        Mode = BindingMode.TwoWay,
-        UpdateSourceTrigger = UpdateSourceTrigger.PropertyChanged,
-        ValidatesOnExceptions = true,
-        NotifyOnValidationError = true,
-    };
+        StaThread.Run(() =>
+        {
+            var vm = new PersonViewModel { Tier = Digit.Create('7') };
+            var textBox = new TextBox();
+            BindingOperations.SetBinding(textBox, TextBox.TextProperty, TwoWay(nameof(vm.Tier), vm));
+
+            textBox.Text = "3";
+
+            Assert.Equal(Digit.Create('3'), vm.Tier);
+        });
+    }
+
+    [Fact]
+    public void TwoWay_InvalidInput_DoesNotMutateSourceAndRaisesValidationError()
+    {
+        StaThread.Run(() =>
+        {
+            var vm = new PersonViewModel { Tier = Digit.Create('7') };
+            var textBox = new TextBox();
+            BindingOperations.SetBinding(textBox, TextBox.TextProperty, TwoWay(nameof(vm.Tier), vm));
+
+            textBox.Text = "42";
+
+            Assert.Equal(Digit.Create('7'), vm.Tier);
+            Assert.True(Validation.GetHasError(textBox));
+        });
+    }
 }
diff --git a/src/StrongTypes.Wpf.Tests/Bindings.cs b/src/StrongTypes.Wpf.Tests/Bindings.cs
new file mode 100644
index 00000000..70e3dcea
--- /dev/null
+++ b/src/StrongTypes.Wpf.Tests/Bindings.cs
@@ -0,0 +1,25 @@
+#nullable enable
+
+using System.Globalization;
+using System.Windows.Data;
+
+namespace StrongTypes.Wpf.Tests;
+
+internal static class Bindings
+{
+    public static Binding OneWay(string path, object source) => new(path)
+    {
+        Source = source,
+        Mode = BindingMode.OneWay,
+    };
+
+    public static Binding TwoWay(string path, object source, CultureInfo? culture = null) => new(path)
+    {
+        Source = source,
+        Mode = BindingMode.TwoWay,
+        UpdateSourceTrigger = UpdateSourceTrigger.PropertyChanged,
+        ValidatesOnExceptions = true,
+        NotifyOnValidationError = true,
+        ConverterCulture = culture,
+    };
+}
diff --git a/src/StrongTypes.Wpf.Tests/CultureBindingTests.cs b/src/StrongTypes.Wpf.Tests/CultureBindingTests.cs
new file mode 100644
index 00000000..23b0959b
--- /dev/null
+++ b/src/StrongTypes.Wpf.Tests/CultureBindingTests.cs
@@ -0,0 +1,124 @@
+#nullable enable
+
+using System;
+using System.Globalization;
+using System.Windows.Controls;
+using System.Windows.Data;
+using System.Windows.Markup;
+using StrongTypes.Wpf.TestApp;
+using Xunit;
+using static StrongTypes.Wpf.Tests.Bindings;
+
+namespace StrongTypes.Wpf.Tests;
+
+/// <summary>
+/// WPF resolves a binding's culture as <c>ConverterCulture ?? element.Language</c> and never consults
+/// the host thread culture. Each case therefore runs under every host culture in turn, asserting the
+/// host is ignored while the binding culture governs display, write-back, and round-trip.
+/// </summary>
+public class CultureBindingTests
+{
+    private static readonly string[] HostCultures = ["en-US", "de-DE", "cs-CZ", "ja-JP"];
+
+    [Theory]
+    [InlineData("en-US", 1234.5, "1234.5")]
+    [InlineData("de-DE", 1234.5, "1234,5")]
+    [InlineData("cs-CZ", 1234.5, "1234,5")]
+    [InlineData("ja-JP", 1234.5, "1234.5")]
+    public void DisplaysAndRoundTripsInTheBindingCulture(string cultureName, double value, string expectedText)
+    {
+        var binding = CultureInfo.GetCultureInfo(cultureName);
+        var salary = Positive<decimal>.Create((decimal)value);
+        RunUnderEveryHost(host =>
+        {
+            var vm = new PersonViewModel { Salary = salary };
+            var textBox = BoundWithConverterCulture(vm, binding);
+
+            Assert.Equal(expectedText, textBox.Text);
+
+            textBox.Text = textBox.Text;
+
+            Assert.False(Validation.GetHasError(textBox), $"host {host}: committing the displayed text raised an error");
+            Assert.Equal(salary, vm.Salary);
+        });
+    }
+
+    /// <summary>
+    /// Write-back parses in the binding culture. A separator from the wrong culture is silently
+    /// swallowed as digit grouping — <c>"9876,5"</c> under en-US binds to <c>98765</c>, a valid value
+    /// and no error — so the culture must match the input. Text that is no number, or that breaks the
+    /// invariant, raises a validation error and leaves the source unchanged (a <c>null</c> expected).
+    /// </summary>
+    [Theory]
+    [InlineData("en-US", "9876.5", 9876.5)]
+    [InlineData("de-DE", "9876,5", 9876.5)]
+    [InlineData("cs-CZ", "9876,5", 9876.5)]
+    [InlineData("ja-JP", "9876.5", 9876.5)]
+    [InlineData("en-US", "9876,5", 98765.0)]
+    [InlineData("de-DE", "9876.5", 98765.0)]
+    [InlineData("en-US", "not-a-number", null)]
+    [InlineData("de-DE", "not-a-number", null)]
+    [InlineData("en-US", "-5", null)]
+    [InlineData("de-DE", "-5", null)]
+    public void WriteBackParsesInTheBindingCulture(string cultureName, string text, double? expected)
+    {
+        var binding = CultureInfo.GetCultureInfo(cultureName);
+        RunUnderEveryHost(host =>
+        {
+            var original = Positive<decimal>.Create(1m);
+            var vm = new PersonViewModel { Salary = original };
+            var textBox = BoundWithConverterCulture(vm, binding);
+
+            textBox.Text = text;
+
+            if (expected is { } number)
+            {
+                Assert.False(Validation.GetHasError(textBox), $"host {host}: valid input '{text}' raised an error");
+                Assert.Equal(Positive<decimal>.Create((decimal)number), vm.Salary);
+            }
+            else
+            {
+                Assert.True(Validation.GetHasError(textBox), $"host {host}: invalid input '{text}' was accepted");
+                Assert.Equal(original, vm.Salary);
+            }
+        });
+    }
+
+    /// <summary>With no ConverterCulture the binding falls back to the element's Language, still never the host.</summary>
+    [Theory]
+    [InlineData("en-US")]
+    [InlineData("de-DE")]
+    [InlineData("cs-CZ")]
+    [InlineData("ja-JP")]
+    public void NoConverterCulture_usesTheElementLanguageNotTheHost(string languageName)
+    {
+        var language = CultureInfo.GetCultureInfo(languageName);
+        RunUnderEveryHost(host =>
+        {
+            var vm = new PersonViewModel { Salary = Positive<decimal>.Create(1234.5m) };
+            var textBox = new TextBox { Language = XmlLanguage.GetLanguage(languageName) };
+            BindingOperations.SetBinding(textBox, TextBox.TextProperty, TwoWay(nameof(vm.Salary), vm));
+
+            Assert.Equal(1234.5m.ToString(language), textBox.Text);
+        });
+    }
+
+    private static void RunUnderEveryHost(Action<string> body)
+    {
+        foreach (var host in HostCultures)
+        {
+            StaThread.Run(() =>
+            {
+                CultureInfo.CurrentCulture = CultureInfo.GetCultureInfo(host);
+                body(host);
+            });
+        }
+    }
+
+    private static TextBox BoundWithConverterCulture(PersonViewModel vm, CultureInfo converterCulture)
+    {
+        var textBox = new TextBox();
+        BindingOperations.SetBinding(textBox, TextBox.TextProperty, TwoWay(nameof(vm.Salary), vm, converterCulture));
+        return textBox;
+    }
+}
diff --git a/src/StrongTypes.Wpf.Tests/NullableBindingTests.cs b/src/StrongTypes.Wpf.Tests/NullableBindingTests.cs
new file mode 100644
index 00000000..242adfae
--- /dev/null
+++ b/src/StrongTypes.Wpf.Tests/NullableBindingTests.cs
@@ -0,0 +1,133 @@
+#nullable enable
+
+using System.Windows.Controls;
+using System.Windows.Data;
+using StrongTypes.Wpf.TestApp;
+using Xunit;
+using static StrongTypes.Wpf.Tests.Bindings;
+
+namespace StrongTypes.Wpf.Tests;
+
+public class NullableStructBindingTests
+{
+    [Fact]
+    public void OneWay_Null_DisplaysEmpty()
+    {
+        StaThread.Run(() =>
+        {
+            var vm = new PersonViewModel { Score = null };
+            var textBox = new TextBox();
+            BindingOperations.SetBinding(textBox, TextBox.TextProperty, OneWay(nameof(vm.Score), vm));
+
+            Assert.Equal("", textBox.Text);
+        });
+    }
+
+    [Fact]
+    public void OneWay_Value_DisplaysIt()
+    {
+        StaThread.Run(() =>
+        {
+            var vm = new PersonViewModel { Score = Positive<int>.Create(10) };
+            var textBox = new TextBox();
+            BindingOperations.SetBinding(textBox, TextBox.TextProperty, OneWay(nameof(vm.Score), vm));
+
+            Assert.Equal("10", textBox.Text);
+        });
+    }
+
+    [Fact]
+    public void TwoWay_ValidInput_UpdatesSource()
+    {
+        StaThread.Run(() =>
+        {
+            var vm = new PersonViewModel { Score = null };
+            var textBox = new TextBox();
+            BindingOperations.SetBinding(textBox, TextBox.TextProperty, TwoWay(nameof(vm.Score), vm));
+
+            textBox.Text = "10";
+
+            Assert.Equal(Positive<int>.Create(10), vm.Score);
+        });
+    }
+
+    [Fact]
+    public void TwoWay_ClearedInput_RaisesValidationErrorRatherThanNulling()
+    {
+        StaThread.Run(() =>
+        {
+            var vm = new PersonViewModel { Score = Positive<int>.Create(10) };
+            var textBox = new TextBox();
+            BindingOperations.SetBinding(textBox, TextBox.TextProperty, TwoWay(nameof(vm.Score), vm));
+
+            textBox.Text = "";
+
+            Assert.Equal(Positive<int>.Create(10), vm.Score);
+            Assert.True(Validation.GetHasError(textBox));
+        });
+    }
+
+    /// <summary>Nullable does not mean unvalidated: a present value still has to satisfy the invariant.</summary>
+    [Fact]
+    public void TwoWay_InvalidInput_DoesNotMutateSourceAndRaisesValidationError()
+    {
+        StaThread.Run(() =>
+        {
+            var vm = new PersonViewModel { Score = Positive<int>.Create(10) };
+            var textBox = new TextBox();
+            BindingOperations.SetBinding(textBox, TextBox.TextProperty, TwoWay(nameof(vm.Score), vm));
+
+            textBox.Text = "-1";
+
+            Assert.Equal(Positive<int>.Create(10), vm.Score);
+            Assert.True(Validation.GetHasError(textBox));
+        });
+    }
+}
+
+public class NullableReferenceBindingTests
+{
+    [Fact]
+    public void OneWay_Null_DisplaysEmpty()
+    {
+        StaThread.Run(() =>
+        {
+            var vm = new PersonViewModel { Nickname = null };
+            var textBox = new TextBox();
+            BindingOperations.SetBinding(textBox, TextBox.TextProperty, OneWay(nameof(vm.Nickname), vm));
+
+            Assert.Equal("", textBox.Text);
+        });
+    }
+
+    [Fact]
+    public void TwoWay_ValidInput_UpdatesSource()
+    {
+        StaThread.Run(() =>
+        {
+            var vm = new PersonViewModel { Nickname = null };
+            var textBox = new TextBox();
+            BindingOperations.SetBinding(textBox, TextBox.TextProperty, TwoWay(nameof(vm.Nickname), vm));
+
+            textBox.Text = "Ally";
+
+            Assert.Equal(NonEmptyString.Create("Ally"), vm.Nickname);
+        });
+    }
+
+    [Fact]
+    public void TwoWay_InvalidInput_DoesNotMutateSourceAndRaisesValidationError()
+    {
+        StaThread.Run(() =>
+        {
+            var vm = new PersonViewModel { Nickname = NonEmptyString.Create("Ally") };
+            var textBox = new TextBox();
+            BindingOperations.SetBinding(textBox, TextBox.TextProperty, TwoWay(nameof(vm.Nickname), vm));
+
+            textBox.Text = "   ";
+
+            Assert.Equal(NonEmptyString.Create("Ally"), vm.Nickname);
+            Assert.True(Validation.GetHasError(textBox));
+        });
+    }
+}
diff --git a/src/StrongTypes.Wpf.Tests/StaThread.cs b/src/StrongTypes.Wpf.Tests/StaThread.cs
index 3a0dd258..d2dcf914 100644
--- a/src/StrongTypes.Wpf.Tests/StaThread.cs
+++ b/src/StrongTypes.Wpf.Tests/StaThread.cs
@@ -3,6 +3,7 @@
 using System;
 using System.Runtime.ExceptionServices;
 using System.Threading;
+using System.Windows.Threading;
 
 namespace StrongTypes.Wpf.Tests;
 
@@ -19,6 +20,9 @@ public static T Run<T>(Func<T> body)
         {
             try { result = body(); }
             catch (Exception ex) { captured = ExceptionDispatchInfo.Capture(ex); }
+            // Constructing a WPF element spins up a Dispatcher for this thread; without shutdown it
+            // survives the thread and the test host force-exits over the leftover foreground threads.
+            finally { Dispatcher.FromThread(Thread.CurrentThread)?.InvokeShutdown(); }
         });
         thread.SetApartmentState(ApartmentState.STA);
         thread.IsBackground = true;
diff --git a/src/StrongTypes.Wpf.Tests/StrongTypes.Wpf.Tests.csproj b/src/StrongTypes.Wpf.Tests/StrongTypes.Wpf.Tests.csproj
index d7df5d88..a07b607c 100644
--- a/src/StrongTypes.Wpf.Tests/StrongTypes.Wpf.Tests.csproj
+++ b/src/StrongTypes.Wpf.Tests/StrongTypes.Wpf.Tests.csproj
@@ -23,7 +23,6 @@
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\StrongTypes\StrongTypes.csproj" />
-    <ProjectReference Include="..\StrongTypes.Wpf\StrongTypes.Wpf.csproj" />
     <ProjectReference Include="..\StrongTypes.Wpf.TestApp\StrongTypes.Wpf.TestApp.csproj" />
   </ItemGroup>
 </Project>
diff --git a/src/StrongTypes.Wpf.Tests/TestSetup.cs b/src/StrongTypes.Wpf.Tests/TestSetup.cs
index 4da69a85..e0c2db6d 100644
--- a/src/StrongTypes.Wpf.Tests/TestSetup.cs
+++ b/src/StrongTypes.Wpf.Tests/TestSetup.cs
@@ -7,6 +7,7 @@ namespace StrongTypes.Wpf.Tests;
 
 internal static class TestSetup
 {
+    // An Application instance is required for WPF's binding engine to resolve resources.
     [ModuleInitializer]
-    internal static void Init() => StaThread.Run(() => new Application().UseStrongTypes());
+    internal static void Init() => StaThread.Run(() => new Application());
 }
diff --git a/src/StrongTypes.Wpf/ParsableTypeConverter.cs b/src/StrongTypes.Wpf/ParsableTypeConverter.cs
deleted file mode 100644
index 1f7ceda8..00000000
--- a/src/StrongTypes.Wpf/ParsableTypeConverter.cs
+++ /dev/null
@@ -1,24 +0,0 @@
-using System;
-using System.ComponentModel;
-using System.Globalization;
-
-namespace StrongTypes.Wpf;
-
-/// <summary>A <see cref="TypeConverter"/> that converts between <see cref="string"/> and <typeparamref name="T"/> via <see cref="IParsable{T}"/>. Throws the same exception that <c>T.Parse</c> throws when the input cannot be parsed; pair the binding with <c>ValidatesOnExceptions=True</c> to surface that as a WPF <c>ValidationError</c>.</summary>
-/// <typeparam name="T">A strong type that implements <see cref="IParsable{T}"/>.</typeparam>
-public sealed class ParsableTypeConverter<T> : TypeConverter where T : IParsable<T>
-{
-    public override bool CanConvertFrom(ITypeDescriptorContext? context, Type sourceType) =>
-        sourceType == typeof(string) || base.CanConvertFrom(context, sourceType);
-
-    public override bool CanConvertTo(ITypeDescriptorContext? context, Type? destinationType) =>
-        destinationType == typeof(string) || base.CanConvertTo(context, destinationType);
-
-    public override object? ConvertFrom(ITypeDescriptorContext? context, CultureInfo? culture, object value) =>
-        value is string s ? T.Parse(s, culture) : base.ConvertFrom(context, culture, value);
-
-    public override object? ConvertTo(ITypeDescriptorContext? context, CultureInfo? culture, object? value, Type destinationType) =>
-        destinationType == typeof(string) && value is T t
-            ? t.ToString()
-            : base.ConvertTo(context, culture, value, destinationType);
-}
diff --git a/src/StrongTypes.Wpf/Startup.cs b/src/StrongTypes.Wpf/Startup.cs
deleted file mode 100644
index a5e2e597..00000000
--- a/src/StrongTypes.Wpf/Startup.cs
+++ /dev/null
@@ -1,30 +0,0 @@
-using System.ComponentModel;
-using System.Windows;
-
-namespace StrongTypes.Wpf;
-
-public static class ApplicationStartupExtensions
-{
-    private static readonly object _gate = new();
-    private static bool _registered;
-
-    /// <summary>Wires <see cref="ParsableTypeConverter{T}"/> into <see cref="TypeDescriptor"/> for every strong type shipped in <c>Kalicz.StrongTypes</c>, enabling two-way MVVM binding from <c>TextBox.Text</c> to strong-typed view-model properties. Call once from <c>App.OnStartup</c>. Idempotent.</summary>
-    /// <returns><paramref name="application"/>, for fluent chaining.</returns>
-    public static Application UseStrongTypes(this Application application)
-    {
-        if (_registered)
-            return application;
-
-        lock (_gate)
-        {
-            if (_registered)
-                return application;
-
-            var parent = TypeDescriptor.GetProvider(typeof(object));
-            TypeDescriptor.AddProvider(new StrongTypesTypeDescriptionProvider(parent), typeof(object));
-            _registered = true;
-        }
-
-        return application;
-    }
-}
diff --git a/src/StrongTypes.Wpf/StrongTypesTypeDescriptionProvider.cs b/src/StrongTypes.Wpf/StrongTypesTypeDescriptionProvider.cs
deleted file mode 100644
index 5a77ef97..00000000
--- a/src/StrongTypes.Wpf/StrongTypesTypeDescriptionProvider.cs
+++ /dev/null
@@ -1,41 +0,0 @@
-using System;
-using System.ComponentModel;
-
-namespace StrongTypes.Wpf;
-
-internal sealed class StrongTypesTypeDescriptionProvider(TypeDescriptionProvider parent) : TypeDescriptionProvider(parent)
-{
-    public override ICustomTypeDescriptor? GetTypeDescriptor(Type objectType, object? instance)
-    {
-        var inner = base.GetTypeDescriptor(objectType, instance);
-        if (inner is null)
-            return null;
-        var converter = TryCreateConverter(objectType);
-        return converter is null ? inner : new StrongTypeDescriptor(inner, converter);
-    }
-
-    private static TypeConverter? TryCreateConverter(Type type)
-    {
-        if (type == typeof(NonEmptyString))
-            return new ParsableTypeConverter<NonEmptyString>();
-        if (type == typeof(Email))
-            return new ParsableTypeConverter<Email>();
-        if (type == typeof(Digit))
-            return new ParsableTypeConverter<Digit>();
-        if (!type.IsGenericType)
-            return null;
-        var definition = type.GetGenericTypeDefinition();
-        if (definition != typeof(Positive<>)
-            && definition != typeof(NonNegative<>)
-            && definition != typeof(Negative<>)
-            && definition != typeof(NonPositive<>))
-            return null;
-        var converterType = typeof(ParsableTypeConverter<>).MakeGenericType(type);
-        return (TypeConverter)Activator.CreateInstance(converterType)!;
-    }
-}
-
-internal sealed class StrongTypeDescriptor(ICustomTypeDescriptor parent, TypeConverter converter) : CustomTypeDescriptor(parent)
-{
-    public override TypeConverter GetConverter() => converter;
-}
diff --git a/src/StrongTypes.Wpf/readme.md b/src/StrongTypes.Wpf/readme.md
deleted file mode 100644
index db2c6f42..00000000
--- a/src/StrongTypes.Wpf/readme.md
+++ /dev/null
@@ -1,35 +0,0 @@
-# Kalicz.StrongTypes.Wpf
-
-[![NuGet version](https://img.shields.io/nuget/v/Kalicz.StrongTypes.Wpf?label=nuget)](https://www.nuget.org/packages/Kalicz.StrongTypes.Wpf/) [![Downloads](https://img.shields.io/nuget/dt/Kalicz.StrongTypes.Wpf?label=downloads)](https://www.nuget.org/packages/Kalicz.StrongTypes.Wpf/) [![License](https://img.shields.io/github/license/KaliCZ/StrongTypes)](https://github.com/KaliCZ/StrongTypes/blob/main/license.txt)
-
-WPF MVVM binding support for [Kalicz.StrongTypes](https://www.nuget.org/packages/Kalicz.StrongTypes). With this package referenced and `UseStrongTypes()` called once in `App.OnStartup`, two-way binding from a `TextBox.Text` to a strong-typed view-model property just works.
-
-## Why a separate package
-
-WPF's binding pipeline routes `string → T` through `TypeDescriptor.GetConverter(T)` and never consults `IParsable<T>` directly. Without a converter, typing into a `TextBox` bound to a strong-typed property silently fails to update the source. The core `Kalicz.StrongTypes` package deliberately avoids any UI dependency, so the wiring lives here.
-
-## Usage
-
-Call `this.UseStrongTypes()` once in `App.OnStartup`. One call covers every strong type that has a string round-trip — `NonEmptyString`, `Email`, `Digit`, and every closed instantiation of the generic numeric wrappers (`Positive<int>`, `Negative<decimal>`, …) — because the package installs a `TypeDescriptionProvider` that synthesizes an `IParsable<T>`-backed converter on demand the first time WPF asks for it. Composite types with no single-`TextBox` form (the interval types, `Maybe<T>`, `NonEmptyEnumerable<T>`) get no converter — bind their parts (`.Start` / `.End`, etc.) instead.
-
-```csharp
-public partial class App : Application
-{
-    protected override void OnStartup(StartupEventArgs e)
-    {
-        this.UseStrongTypes();
-        base.OnStartup(e);
-    }
-}
-```
-
-After registration, a plain MVVM binding works:
-
-```xml
-<TextBox Text="{Binding Name,
-                        Mode=TwoWay,
-                        UpdateSourceTrigger=PropertyChanged,
-                        ValidatesOnExceptions=True}" />
-```
-
-…where `Name` is a view-model property of type `NonEmptyString`. `ValidatesOnExceptions=True` turns the strong type's `ArgumentException` (thrown by `Create` / `Parse` when validation fails) into a `ValidationError` on the binding, which in turn drives the standard WPF "invalid input" red border.
diff --git a/src/StrongTypes/ComponentModel/ParsableTypeConverter.cs b/src/StrongTypes/ComponentModel/ParsableTypeConverter.cs
new file mode 100644
index 00000000..47f112e0
--- /dev/null
+++ b/src/StrongTypes/ComponentModel/ParsableTypeConverter.cs
@@ -0,0 +1,34 @@
+#nullable enable
+
+using System;
+using System.ComponentModel;
+using System.Globalization;
+
+namespace StrongTypes;
+
+/// <summary>Converts between <see cref="string"/> and <typeparamref name="T"/> via <see cref="IParsable{TSelf}"/>, honouring the culture it is handed.</summary>
+/// <typeparam name="T">A strong type that implements <see cref="IParsable{TSelf}"/>.</typeparam>
+/// <remarks>Invalid input surfaces as whatever <c>T.Parse</c> throws — for a Kalicz.StrongTypes wrapper, the <see cref="ArgumentException"/> naming the broken invariant.</remarks>
+public sealed class ParsableTypeConverter<T> : TypeConverter
+    where T : IParsable<T>
+{
+    public override bool CanConvertFrom(ITypeDescriptorContext? context, Type sourceType) =>
+        sourceType == typeof(string) || base.CanConvertFrom(context, sourceType);
+
+    public override bool CanConvertTo(ITypeDescriptorContext? context, Type? destinationType) =>
+        destinationType == typeof(string) || base.CanConvertTo(context, destinationType);
+
+    /// <exception cref="ArgumentException"><paramref name="value"/> is a string that breaks <typeparamref name="T"/>'s invariant.</exception>
+    /// <exception cref="FormatException"><paramref name="value"/> is a string that is not in <typeparamref name="T"/>'s format.</exception>
+    public override object? ConvertFrom(ITypeDescriptorContext? context, CultureInfo? culture, object value) =>
+        value is string s ? T.Parse(s, culture) : base.ConvertFrom(context, culture, value);
+
+    public override object? ConvertTo(ITypeDescriptorContext? context, CultureInfo? culture, object? value, Type destinationType)
+    {
+        if (destinationType != typeof(string) || value is not T parsed)
+            return base.ConvertTo(context, culture, value, destinationType);
+
+        // Must format in the culture ConvertFrom parses in, or the pair does not round-trip.
+        return parsed is IFormattable formattable ? formattable.ToString(null, culture) : parsed.ToString();
+    }
+}
diff --git a/src/StrongTypes/ComponentModel/StrongTypeConverter.cs b/src/StrongTypes/ComponentModel/StrongTypeConverter.cs
new file mode 100644
index 00000000..877c0e23
--- /dev/null
+++ b/src/StrongTypes/ComponentModel/StrongTypeConverter.cs
@@ -0,0 +1,33 @@
+#nullable enable
+
+using System;
+using System.ComponentModel;
+using System.Globalization;
+
+namespace StrongTypes;
+
+/// <summary>Converts between <see cref="string"/> and a strong type that implements <see cref="IParsable{TSelf}"/>, for generic types that cannot name a closed <see cref="ParsableTypeConverter{T}"/> in an attribute argument.</summary>
+public sealed class StrongTypeConverter : TypeConverter
+{
+    private readonly TypeConverter _inner;
+
+    /// <param name="type">The closed strong type to convert.</param>
+    /// <exception cref="ArgumentException"><paramref name="type"/> does not implement <see cref="IParsable{TSelf}"/>.</exception>
+    public StrongTypeConverter(Type type)
+    {
+        ArgumentNullException.ThrowIfNull(type);
+
+        if (!typeof(IParsable<>).MakeGenericType(type).IsAssignableFrom(type))
+            throw new ArgumentException($"{type} must implement IParsable<{type.Name}> to be converted from a string.", nameof(type));
+
+        _inner = (TypeConverter)Activator.CreateInstance(typeof(ParsableTypeConverter<>).MakeGenericType(type))!;
+    }
+
+    public override bool CanConvertFrom(ITypeDescriptorContext? context, Type sourceType) => _inner.CanConvertFrom(context, sourceType);
+
+    public override bool CanConvertTo(ITypeDescriptorContext? context, Type? destinationType) => _inner.CanConvertTo(context, destinationType);
+
+    public override object? ConvertFrom(ITypeDescriptorContext? context, CultureInfo? culture, object value) => _inner.ConvertFrom(context, culture, value);
+
+    public override object? ConvertTo(ITypeDescriptorContext? context, CultureInfo? culture, object? value, Type destinationType) => _inner.ConvertTo(context, culture, value, destinationType);
+}
diff --git a/src/StrongTypes/Digits/Digit.cs b/src/StrongTypes/Digits/Digit.cs
index e152f976..27ba923f 100644
--- a/src/StrongTypes/Digits/Digit.cs
+++ b/src/StrongTypes/Digits/Digit.cs
@@ -1,4 +1,5 @@
 using System;
+using System.ComponentModel;
 using System.Diagnostics.CodeAnalysis;
 using System.Diagnostics.Contracts;
 
@@ -6,6 +7,7 @@ namespace StrongTypes;
 
 /// <summary>A decimal digit in the range <c>0</c>–<c>9</c>, parsed from a single character.</summary>
 /// <remarks>A character is accepted when <see cref="char.IsDigit(char)"/> returns <c>true</c>, which includes non-ASCII Unicode decimal digits whose numeric value folds into 0–9. <c>default(Digit)</c> represents <c>0</c>.</remarks>
+[TypeConverter(typeof(ParsableTypeConverter<Digit>))]
 public readonly struct Digit :
     IEquatable<Digit>,
     IEquatable<byte>,
diff --git a/src/StrongTypes/Emails/Email.cs b/src/StrongTypes/Emails/Email.cs
index 88b240b7..f7500223 100644
--- a/src/StrongTypes/Emails/Email.cs
+++ b/src/StrongTypes/Emails/Email.cs
@@ -1,4 +1,5 @@
 using System;
+using System.ComponentModel;
 using System.Diagnostics.CodeAnalysis;
 using System.Diagnostics.Contracts;
 using System.Net.Mail;
@@ -9,6 +10,7 @@ namespace StrongTypes;
 /// <summary>An email address validated by <see cref="MailAddress.TryCreate(string?, out MailAddress?)"/> and capped at the RFC 5321 deliverable length of 254 characters.</summary>
 /// <remarks>The <see cref="Value"/> property hands the caller a <see cref="MailAddress"/> directly so it can be passed straight into APIs that take one (mailers, validators). The wire form on JSON, EF Core columns, and route arguments is the underlying address string.</remarks>
 [JsonConverter(typeof(EmailJsonConverter))]
+[TypeConverter(typeof(ParsableTypeConverter<Email>))]
 public sealed class Email :
     IEquatable<Email>,
     IEquatable<MailAddress>,
diff --git a/src/StrongTypes/Numbers/Negative.cs b/src/StrongTypes/Numbers/Negative.cs
index d5266abd..bb428b0f 100644
--- a/src/StrongTypes/Numbers/Negative.cs
+++ b/src/StrongTypes/Numbers/Negative.cs
@@ -1,3 +1,4 @@
+using System.ComponentModel;
 using System.Diagnostics.Contracts;
 using System.Numerics;
 using System.Text.Json.Serialization;
@@ -9,6 +10,7 @@ namespace StrongTypes;
 /// <remarks>Construct via <see cref="TryCreate"/> or <c>Create</c>. <c>default(Negative&lt;T&gt;)</c> wraps <c>-T.One</c> and satisfies the invariant.</remarks>
 [NumericWrapper(InvariantDescription = "negative", GenerateSum = true)]
 [JsonConverter(typeof(NumericStrongTypeJsonConverterFactory))]
+[TypeConverter(typeof(StrongTypeConverter))]
 public readonly partial struct Negative<T>
     where T : INumber<T>
 {
diff --git a/src/StrongTypes/Numbers/NonNegative.cs b/src/StrongTypes/Numbers/NonNegative.cs
index 541392c9..ccc8f192 100644
--- a/src/StrongTypes/Numbers/NonNegative.cs
+++ b/src/StrongTypes/Numbers/NonNegative.cs
@@ -1,3 +1,4 @@
+using System.ComponentModel;
 using System.Diagnostics.Contracts;
 using System.Numerics;
 using System.Text.Json.Serialization;
@@ -9,6 +10,7 @@ namespace StrongTypes;
 /// <remarks>Construct via <see cref="TryCreate"/> or <c>Create</c>. <c>default(NonNegative&lt;T&gt;)</c> wraps <c>T.Zero</c> and satisfies the invariant.</remarks>
 [NumericWrapper(InvariantDescription = "non-negative", GenerateSum = true)]
 [JsonConverter(typeof(NumericStrongTypeJsonConverterFactory))]
+[TypeConverter(typeof(StrongTypeConverter))]
 public readonly partial struct NonNegative<T>
     where T : INumber<T>
 {
diff --git a/src/StrongTypes/Numbers/NonPositive.cs b/src/StrongTypes/Numbers/NonPositive.cs
index 4ca370d2..51a99e10 100644
--- a/src/StrongTypes/Numbers/NonPositive.cs
+++ b/src/StrongTypes/Numbers/NonPositive.cs
@@ -1,3 +1,4 @@
+using System.ComponentModel;
 using System.Diagnostics.Contracts;
 using System.Numerics;
 using System.Text.Json.Serialization;
@@ -9,6 +10,7 @@ namespace StrongTypes;
 /// <remarks>Construct via <see cref="TryCreate"/> or <c>Create</c>. <c>default(NonPositive&lt;T&gt;)</c> wraps <c>T.Zero</c> and satisfies the invariant.</remarks>
 [NumericWrapper(InvariantDescription = "non-positive", GenerateSum = true)]
 [JsonConverter(typeof(NumericStrongTypeJsonConverterFactory))]
+[TypeConverter(typeof(StrongTypeConverter))]
 public readonly partial struct NonPositive<T>
     where T : INumber<T>
 {
diff --git a/src/StrongTypes/Numbers/Positive.cs b/src/StrongTypes/Numbers/Positive.cs
index db4839bb..4e1fad2b 100644
--- a/src/StrongTypes/Numbers/Positive.cs
+++ b/src/StrongTypes/Numbers/Positive.cs
@@ -1,3 +1,4 @@
+using System.ComponentModel;
 using System.Diagnostics.Contracts;
 using System.Numerics;
 using System.Text.Json.Serialization;
@@ -9,6 +10,7 @@ namespace StrongTypes;
 /// <remarks>Construct via <see cref="TryCreate"/> or <c>Create</c>. <c>default(Positive&lt;T&gt;)</c> wraps <c>T.One</c> and satisfies the invariant.</remarks>
 [NumericWrapper(InvariantDescription = "positive", GenerateSum = true)]
 [JsonConverter(typeof(NumericStrongTypeJsonConverterFactory))]
+[TypeConverter(typeof(StrongTypeConverter))]
 public readonly partial struct Positive<T>
     where T : INumber<T>
 {
diff --git a/src/StrongTypes/Strings/NonEmptyString.cs b/src/StrongTypes/Strings/NonEmptyString.cs
index 5207b6b2..39fc29ec 100644
--- a/src/StrongTypes/Strings/NonEmptyString.cs
+++ b/src/StrongTypes/Strings/NonEmptyString.cs
@@ -1,4 +1,5 @@
 using System;
+using System.ComponentModel;
 using System.Diagnostics.CodeAnalysis;
 using System.Diagnostics.Contracts;
 using System.Globalization;
@@ -9,6 +10,7 @@ namespace StrongTypes;
 /// <summary>A string guaranteed to be non-null, non-empty, and not consisting solely of whitespace.</summary>
 /// <remarks>Comparison uses the current culture (it delegates to <see cref="string.CompareTo(string?)"/>). Exposes <c>Count</c> and a char indexer for parity with <see cref="string"/>; <c>Count</c> in particular makes the BCL <c>[MaxLength]</c> attribute work without a custom shim.</remarks>
 [JsonConverter(typeof(NonEmptyStringJsonConverter))]
+[TypeConverter(typeof(ParsableTypeConverter<NonEmptyString>))]
 public sealed class NonEmptyString :
     IEquatable<NonEmptyString>,
     IEquatable<string>,