> ## Documentation Index
> Fetch the complete documentation index at: https://docs.westyx.dev/llms.txt
> Use this file to discover all available pages before exploring further.

# .NET SDK - Version history

> What changed in each release of the .NET SDK, and how to migrate across a breaking change.

Every release of the six packages, newest first. All six share one version number. Where a release
broke something, its **Migrating** section shows the change to make. The repository's
[`CHANGELOG.md`](https://gitlab.com/westyx/nexus/sdk/dotnet/-/blob/main/CHANGELOG.md) carries the
same releases in full detail.

## v0.21.1 - 2026-11-19

* **SSE restart after `423 service_locked`:** resets the internal stream cancellation state when the stream exits on `423`, allowing a subsequent `ConnectStream()` call to reconnect after the lockdown is lifted.

## v0.21.0 (2026-11-19)

* **HTTP 423 `service_locked`:** adds `NexusServiceLockedException` and `FallbackReason.ServiceLocked`; stops SSE reconnects immediately and halts background sync retries until an explicit sync succeeds.
* **OpenFeature provider:** suppresses repeated `evaluate-ab` requests while the service is locked down, serving the cached snapshot as `STALE`.
* **Target framework (`net10.0`):** drops `net8.0` (end of support on 2026-11-10); all six packages now target `net10.0` (LTS).
* **Path hardening:** validates fully-qualified canonical paths in `DevCredentialsFile` and `SecretDirectoryCleanup`.

## v0.20.2 - 2026-11-12

* **The OpenFeature provider stops asking a switched-off environment.** While the environment is switched off in the console, a targeted evaluation serves the snapshot as `STALE` and the provider sends no `EvaluateABAsync` request - for any user - for the `AddonSuppression` window, with one warning; any success clears it.

## v0.20.1 - 2026-11-11

* **A successful stream connection starts the failure count and the backoff over.** Drops hours
  apart no longer add up to a fallback, and the reconnect delay no longer climbs to 30 s for the
  life of the process.
* **The first retry after the cooldown waits 1 s.**

## v0.20.0 - 2026-11-11

* **A switched-off environment has its own exception.** `NexusEnvironmentDisabledException` (a `NexusApiException`, HTTP 403 `environment_disabled`) is raised by every call, the WIF token exchange included. The cache keeps serving; the background refresh retries every five minutes and the stream falls back to polling (`FallbackReason.EnvironmentDisabled`) until the environment is switched on. See [Error handling](https://docs.westyx.dev/sdks/dotnet/error-handling.md).
* **`NexusApiException` carries `StatusCode` and `ErrorCode`**, the HTTP status and the server's `error` code, so an unmapped failure such as `410 tenant_deleted` can be told apart without parsing the message.
* **Resources the server leaves out of a sync reach the application**: `client.SyncErrors` lists them, and each is logged as a `Warning` when it first appears (`NexusConfig.LogSyncErrors`, `NexusOptions.LogSyncErrors`). See [API reference](https://docs.westyx.dev/sdks/dotnet/api-reference.md#metadata).
* **A startup summary names the configs, secrets and flags the first sync delivered**, never a value. Without a `LoggerFactory`, `WESTYX_NEXUS_LOG_STARTUP=1` writes it to standard error. See [Logging](https://docs.westyx.dev/sdks/dotnet/logging.md#seeing-what-the-client-loaded).
* **Syncs apply one at a time**, so a slow response can never replace a newer one.
* **CI runs the `net10.0` build on .NET 11.** .NET 8 stays a target. See [Installation](https://docs.westyx.dev/sdks/dotnet/installation.md#requirements).

## v0.19.0 - 2026-10-21

* **`WestyxNexus.OpenFeature` targets the OpenFeature .NET SDK 2.x** (`OpenFeature` 2.0 or later, below 3.0), so it installs next to the current OpenFeature release. A cancelled evaluation stops waiting for a targeted lookup. See [OpenFeature](https://docs.westyx.dev/sdks/dotnet/openfeature.md).
* **`IsStreamConnected` reports the connection itself.** It is `true` from the moment the stream returns `200 OK` until that connection ends, and `false` during every backoff, fallback, rate-limit or quarantine wait - a health check can read it directly. See [API reference](https://docs.westyx.dev/sdks/dotnet/api-reference.md).
* **While the stream is down, the client syncs once per TTL on its own**, so values read through `IConfiguration`, `IOptionsMonitor<T>` or bound secrets keep refreshing until the stream reconnects. With `enableStream: false` (or `EnableStream = false`) the client syncs once per TTL the same way. See [SSE live updates](https://docs.westyx.dev/sdks/dotnet/sse-live-updates.md#reconnection).
* **Every `IStreamObserver` hook has an empty default**, so an observer implements only the hooks it needs. See [Stream observer](https://docs.westyx.dev/sdks/dotnet/stream-observer.md).

### Migrating to v0.19.0

**The OpenFeature provider needs OpenFeature 2.x.** Update the `OpenFeature` package to 2.x, and
call the client's 2.x methods:

```csharp theme={null}
// before
bool enabled = await client.GetBooleanValue("new.checkout", false);

// after
bool enabled = await client.GetBooleanValueAsync("new.checkout", false);
```

The same for `GetStringValueAsync`, `GetDoubleValueAsync`, `GetIntegerValueAsync` and
`GetObjectValueAsync`. Registering the provider with `Api.Instance.SetProviderAsync` is unchanged.
Applications that do not use `WestyxNexus.OpenFeature` need no change.

## v0.18.0 - 2026-09-30

* **The endpoint can come from the environment.** Leave `BaseUrl` unset and the client reads `WESTYX_SERVICE_ENDPOINT` (`NexusConfig.ServiceEndpointEnvironmentVariable`) when it is created - `westyx dev run` sets it for the script's service, so a locally started application needs neither an endpoint nor a key in its code. `AddWestyxNexus` applies the same rule to `NexusOptions.BaseUrl`. A value you set always wins, and an error about the variable's value names the variable. See [Configuration](https://docs.westyx.dev/sdks/dotnet/configuration.md#service-endpoint).
* **`NexusConfig.BaseUrl` is `string?` and no longer `required`.** Every existing initializer still compiles; code that reads the property may see a nullable warning.

## v0.17.0 - 2026-08-29

* **`NexusOptions.LoggerFactory`, `NexusOptions.Observer` and `WifOptions.CredentialSource` are removed**, closing the seven `SYSLIB1100`/`SYSLIB1101` warnings a config-binding-generator consumer got for properties that could never come from configuration. Register the service in the container instead - `services.AddSingleton<IStreamObserver, MyObserver>()` - and `AddWestyxNexus` resolves it from there.

### Migrating to v0.17.0

**Three service-typed options properties move into the container.**

```csharp theme={null}
// before
services.AddWestyxNexus(o =>
{
    o.BaseUrl       = "https://my-slug.westyx.dev";
    o.LoggerFactory = myLoggerFactory;
    o.Observer      = myObserver;
});

// after
services.AddSingleton(myLoggerFactory);
services.AddSingleton<IStreamObserver>(myObserver);
services.AddWestyxNexus(o => o.BaseUrl = "https://my-slug.westyx.dev");
```

Same for `WifOptions.CredentialSource`: `services.AddSingleton<IWifCredentialSource, MySource>()` instead of setting it on the options object. `AddWestyxNexus(NexusConfig)` is unaffected - it still accepts `NexusConfig.LoggerFactory`/`.Observer` and registers them into the container for you.

## v0.16.0 - 2026-08-14

* **A request carrying a credential does not follow a redirect.** Every client the SDK owns refuses redirects. The runtime strips `Authorization` across a cross-origin redirect but forwards custom headers, and `X-Nexus-API-Key` is a custom header - so a redirect is an error rather than a delivery. **If your endpoint could have returned one, rotate the service key.**
* **The secret guards read the backend's `key_type` as well as the key's prefix**, so a legacy public key without the `wxp_` prefix is treated as public.
* **`aws_iam` ships in `WestyxNexus.Wif.Aws`** and is selected as a credential source, so the core no longer depends on `AWSSDK.Core`. See [Workload identity](https://docs.westyx.dev/sdks/dotnet/workload-identity.md#aws-iam-non-eks-aws-compute).
* **[OpenTelemetry](https://docs.westyx.dev/sdks/dotnet/opentelemetry.md) tracing and metrics**, under `NexusDiagnostics.Name` - three spans and three instruments, inert until something subscribes.
* **Every package is trim- and Native-AOT-compatible** and declares `IsAotCompatible`, proven by a harness the pipeline publishes under both `PublishAot` and `PublishTrimmed`. See [Trimming and Native AOT](https://docs.westyx.dev/sdks/dotnet/trimming-and-aot.md).
* **XML documentation, symbol packages and Source Link ship in all six packages** - IntelliSense, and stepping into the SDK from your own debugger.
* **`KeyType` and `Kind` are enums, and `GetSecret` is synchronous.** `GetSecret` reads the in-memory cache and never made a network call.

### Migrating to v0.16.0

**`INexusLogger` and `NexusConfig.Logger` are removed.** Set `NexusConfig.LoggerFactory` to an `ILoggerFactory` instead; on the dependency-injection path the application's own `ILoggerFactory` is used with nothing to set.

**`aws_iam` moves to its own package and becomes a credential source.**

```bash theme={null}
dotnet add package WestyxNexus.Wif.Aws
```

```csharp theme={null}
// before
Wif = new WifConfig { Enabled = true, Provider = WifProvider.AwsIam, AwsRegion = "eu-central-1" }

// after
Wif = new WifConfig { Enabled = true, CredentialSource = AwsIamCredentialSource.Create("eu-central-1") }
```

On the dependency-injection path, call `services.AddWestyxNexusAwsIam("eu-central-1")` and remove `"Provider": "aws_iam"` and `"AwsRegion"` from `appsettings.json`. A configuration that still names `aws_iam` throws at startup, naming the package to add and the call to make. The exchange body, the signed header set and the `X-Nexus-Server-ID` binding are unchanged, and the logs and the `wif.provider` span attribute still read `aws_iam`.

`WifProvider.AwsIam` is gone, which shifts the numeric values of `Gcp`, `Azure` and `Developer`. Only code that casts the enum to or from an integer is affected; use the member names.

**Three API shapes change.**

| Before | After |
| - | - |
| `await client.GetSecretAsync("k")` | `client.GetSecret("k")` |
| `client.KeyType == "pk"` | `client.KeyType == KeyType.Public` |
| `client.Kind == "frontend"` | `client.Kind == ServiceKind.Frontend` |

`GetSecret` reads the in-memory cache and never made a network call, so the `Task` promised asynchrony it could not deliver; it pairs with `GetSecretFilePath`, which was always synchronous. `KeyType.None` is a WIF-only client, and `ServiceKind.Unknown` covers both "not yet synced" and a kind this SDK version does not recognise - so a kind added to the platform cannot make an existing client throw. `client.KindName` carries the string the backend sent.

**`GetAllConfigs` and `GetAllFlags` return the same read-only instance until the next sync**, rather than a fresh copy per call - measured at a thousand keys, a call cost 16.6 µs and 31 KB. Read them again after a sync. A caller that cast the result back to `Dictionary<,>` and mutated it - which affected only that copy - now gets an `InvalidCastException`; copy the map yourself if you need a mutable one.

**A configuration value that cannot be meant is rejected rather than repaired.** A sync `429` now arrives as `NexusRateLimitedException` carrying `RetryAfter`; an unexpected status is `NexusApiException`. Both are `NexusException`, so a `catch (NexusException)` already covers them.

## v0.15.0 - 2026-08-08

* **A credential source can express any credential the protocol accepts.** `IWifCredentialSource` returns either an OIDC token or a signed, server-bound request - the shape `aws_iam` uses - so supplying a workload identity the SDK does not produce natively no longer requires a change to the SDK. See [Workload identity](https://docs.westyx.dev/sdks/dotnet/workload-identity.md#custom-credential-source).
* **`westyx dev setup` credentials are picked up automatically.** The `developer` provider uses the session the Westyx CLI already obtained, directly as the bearer, with no token exchange. It is probed last, so a real cloud identity always wins on a real cloud host. See [Local development](https://docs.westyx.dev/sdks/dotnet/workload-identity.md#local-development-developer-wif).
* **`WifConfig.Provider` is an enum** (`WifProvider`), and a value outside the set is rejected at construction. The WIF types are renamed to `WifConfig` / `WifProvider` / `WifConfig.AwsRegion`.
* **`services.AddWestyxNexus(IConfiguration section)`** registers the client from a configuration section, and an `IWifCredentialSource` in the container is picked up automatically. See [Dependency injection](https://docs.westyx.dev/sdks/dotnet/dependency-injection.md).

### Migrating to v0.15.0

The WIF types are renamed and `Provider` changes type. Both are mechanical, and the compiler names every site.

| Before | After |
| - | - |
| `WIFConfig` | `WifConfig` |
| `WIFProvider.Kubernetes` (a `string` constant) | `WifProvider.Kubernetes` (an enum member) |
| `WIFProvider.AWS` / `AWSIAM` / `GCP` | `WifProvider.Aws` / `AwsIam` / `Gcp` |
| `WIFConfig.AWSRegion` | `WifConfig.AwsRegion` |
| `Provider = "kubernetes"` | `Provider = WifProvider.Kubernetes` |
| `NexusOptions.Wif = new WIFConfig { ... }` | `NexusOptions.Wif = new WifOptions { ... }` (its `Provider` is a `string`) |

`WifConfig.TokenSource` still works and is obsolete for one release:

```csharp theme={null}
// before
Wif = new WifConfig { Enabled = true, TokenSource = ct => Task.FromResult(ReadMyOidcToken()) }

// after
Wif = new WifConfig
{
    Enabled          = true,
    CredentialSource = WifCredentialSource.FromOidcToken(ct => Task.FromResult(ReadMyOidcToken())),
}
```

When both are set, `CredentialSource` wins. `Provider = WifProvider.AwsIam` together with a credential source now throws at client construction: `aws_iam` signs its own request, so the credential source would never be called.

## v0.14.0 - 2026-08-05

* **File-type secrets live in a private per-client directory**, created `0700`, with each file created exclusively at `0600` and the mode applied by the creating call. Nothing else on the machine can enter the directory, which is how .NET gets symlink safety without an `O_NOFOLLOW` equivalent. See [API reference](https://docs.westyx.dev/sdks/dotnet/api-reference.md#file-type-secrets).
* **A throwing `IStreamObserver` callback cannot affect the stream.** Every hook goes through one guarded dispatcher, so a bug in your telemetry callback neither ends the stream nor counts as a transport error.
* **A billing `402` throttles the background refresh to one attempt every five minutes** rather than stopping it, and any success clears it - a `304 Not Modified` included - so settling the invoice restores service without restarting the process.
* **The SSE stream carries a connect deadline and an idle deadline.** `StreamConnectTimeout` (default 10 s) bounds the connect-to-headers phase; `StreamIdleTimeout` (default 90 s) is reset by every line received, keepalives included. See [SSE live updates](https://docs.westyx.dev/sdks/dotnet/sse-live-updates.md).
* **Configuration is validated at construction.** A value that cannot be meant throws `NexusConfigException` naming the option, and for the reconnect schedule the offending index. `null` still selects the default. See [Configuration](https://docs.westyx.dev/sdks/dotnet/configuration.md).
* **An integer inside an OpenFeature structure resolution keeps its exact value**, carried as its decimal text when it does not fit the 32-bit integer slot.

### Migrating to v0.14.0

Two changes can affect existing code.

**Configuration values that were previously coerced are now rejected.** If you pass any of these to mean "use the default", pass `null` instead:

```csharp theme={null}
Ttl = TimeSpan.Zero               // -> Ttl = null
SseReconnectCooldown = []         // -> SseReconnectCooldown = null
SseReconnectCooldown = [0, 5]     // -> entries must be >= 1
```

**A large integer inside a structure resolution is a string.** For a field that may exceed `int.MaxValue`:

```csharp theme={null}
var structure = (await provider.ResolveStructureValue("obj.key", new Value())).Value.AsStructure!;
var id = long.Parse(structure.GetValue("snowflake").AsString!);   // was AsDouble, which lost precision
```

Ordinary integers still resolve as `AsInteger` and fractional numbers as `AsDouble`. A scalar `ResolveIntegerValue` still answers `TYPE_MISMATCH` for a value that does not fit, which is unchanged.

## v0.13.0 - 2026-08-03

* **[`builder.AddWestyxNexus(config)`](https://docs.westyx.dev/sdks/dotnet/package-wiring) wires everything over one client.** One call serves `IConfiguration` and the container from the same client, so config binding, [secrets binding](https://docs.westyx.dev/sdks/dotnet/secrets-binding.md), [feature management](https://docs.westyx.dev/sdks/dotnet/feature-management.md) and an injected `NexusClient` share one cache, one sync loop and one SSE connection.
* **`services.AddWestyxNexus(config)`** accepts a `NexusConfig` directly - the same object the configuration source takes. What `IHttpClientFactory` owns is rejected by name rather than ignored.
* **`NexusOptions.LoggerFactory`** routes SDK diagnostics away from the application's logging pipeline when you want that; null keeps using the application's.
* **The dependency-injection entry points name the call you are missing** when no client is registered.
* **The client created on the builder is disposed with the host.** If you register a client yourself, use `services.AddSingleton(_ => client)` - the container disposes what a factory returns, not an instance handed to `AddSingleton(client)`.

## v0.12.1 - 2026-07-31

* **An OpenFeature boolean resolution reports its `Variant`** - `"true"` or `"false"`, lowercase, the same spelling every SDK in the suite uses.

## v0.12.0 - 2026-07-31

* **Boolean flag evaluation is per-user.** With a targeting key in the `EvaluationContext`, the OpenFeature provider resolves the flag through the AB Testing add-on, applying its rollout percentage and cohort rules to that identity. Without a targeting key it reads the synced snapshot, exactly as before.
* **`NexusClient.FindFlag(key)`** returns the flag's `is_active` state or `null` when the flag is not in the cache at all, which `GetFlag` cannot express.
* **An object or array config resolves to a real OpenFeature structure**, so `AsStructure()` works. Composite values used to arrive as their JSON text.
* Breaking: `EvaluateABAsync`'s `attributes` is `IDictionary<string, string>`; an unknown flag resolves as `FLAG_NOT_FOUND`; successful resolutions report `Static` rather than `Cached`.

### Migrating to v0.12.0

Four changes; only the first is a source edit.

| Before | After |
| - | - |
| `EvaluateABAsync(keys, userId, new Dictionary<string, object> { ["age"] = 30 })` | `EvaluateABAsync(keys, userId, new Dictionary<string, string> { ["age"] = "30" })` |
| An OpenFeature boolean evaluation of an unknown flag returning your default with a success reason | it returns your default with `ErrorType.FlagNotFound` and `Reason.Default` |
| Successful resolutions reporting `Reason.Cached` | they report `Reason.Static`; `Cached` now means a value served from the provider's targeting memo |
| An `EvaluationContext` with a targeting key, previously ignored | it selects a per-user evaluation; omit the targeting key for the previous uniform behaviour |

A non-string attribute value was already rejected by the service with `400`, so nothing that
worked before stops working - the signature now says what the endpoint accepts. Cohort conditions
compare attribute values as strings, so formatting the value at the call site is what lets you
control exactly what the rule is matched against.

## v0.11.0 - 2026-07-14

Acts on an external .NET developer's review. Several items are **breaking**, and every deliberate departure from .NET convention is explained in [Design decisions](https://docs.westyx.dev/sdks/dotnet/design-decisions.md).

**Five packages instead of two** - a console app no longer drags in the configuration pipeline it never uses:

| Package | What it gives you |
| - | - |
| `WestyxNexus` | The client: sync, cache, SSE, WIF. No framework integration. |
| `WestyxNexus.Extensions.DependencyInjection` | [`AddWestyxNexus()`](https://docs.westyx.dev/sdks/dotnet/dependency-injection), `IHttpClientFactory` + `ILoggerFactory` wiring, async startup, [`AddWestyxNexusSecrets<T>()`](https://docs.westyx.dev/sdks/dotnet/secrets-binding) |
| `WestyxNexus.Extensions.Configuration` | `AddWestyx()` - configs through [`IConfiguration`](https://docs.westyx.dev/sdks/dotnet/aspnetcore-configuration) |
| `WestyxNexus.FeatureManagement` | [`Microsoft.FeatureManagement` provider](https://docs.westyx.dev/sdks/dotnet/feature-management) |
| `WestyxNexus.OpenFeature` | [OpenFeature provider](https://docs.westyx.dev/sdks/dotnet/openfeature.md) (unchanged) |

* **BREAKING - `AddWestyx()` moved** to `WestyxNexus.Extensions.Configuration`. Add the package reference; the namespace is unchanged, so no code edit.
* **BREAKING - multi-targeted `net8.0;net10.0`.** .NET 8 goes out of support on **2026-11-10**; .NET 10 is the current LTS (to 2028-11-14).
* **`NexusConfig.LoggerFactory`** takes a standard `ILoggerFactory`; `INexusLogger` is obsolete but still bridged. Log statements are structured, under the categories `Westyx.Nexus.NexusClient`, `Westyx.Nexus.Stream` and `Westyx.Nexus.Wif`.
* **Async startup.** `AddWestyxNexus()` runs the initial sync in an `IHostedService` instead of blocking a thread-pool thread.
* **`NexusConfig.PooledConnectionLifetime`** (default 2 minutes). The framework default is infinite, so an application-lifetime singleton never recycled a connection and never observed a DNS change.
* **`IConfiguration` binding fixed twice** - dotted keys are now section-navigable (`GetSection("database")` used to come back empty and bind nothing), and JSON objects and arrays are flattened instead of stored as one opaque string.
* **[`AddWestyxNexusSecrets<T>()`](https://docs.westyx.dev/sdks/dotnet/secrets-binding)** binds secrets to `IOptions<T>` with live re-bind, without putting them in `IConfiguration`.
* **[`AddWestyxNexusFeatureManagement()`](https://docs.westyx.dev/sdks/dotnet/feature-management)** serves Nexus flags to `IFeatureManager` from the in-memory cache.

**Fixes**

* File-type secrets are written **owner-readable only** (`0600`), applied at creation via `UnixCreateMode` rather than by a chmod afterwards.
* Two clients holding the same secret no longer share one temp file; the first disposed used to delete it out from under the other.
* The post-sync notification is additive, so the configuration provider and the secrets binder both stay live when used together.

### Migrating to v0.11.0

**`AddWestyx()` moved to its own package.** Add `WestyxNexus.Extensions.Configuration`; the namespace is still `Westyx.Nexus`, so no code changes.

**`IConfiguration` keys are section-navigable.** A Nexus key `database.host` is reachable as `database:host` as well as `database.host`, and JSON objects and arrays are flattened into child keys - so `GetSection("database")` and `IOptions<T>` binding work, where before this release they came back empty. A workaround you built keeps working.

## v0.10.0 - 2026-07-05

* Version alignment across the Westyx Nexus SDK suite.

## v0.9.0 - 2026-07-03

* **`aws_iam` WIF provider (AWS IAM Caller Identity)** - authenticates non-EKS AWS compute (**ECS/Fargate, Lambda, plain EC2**) that has IAM credentials but no OIDC token. The SDK SigV4-signs an STS `GetCallerIdentity` request (never sent to AWS) and posts it to `/v1/auth/token-exchange`; Nexus replays it against a pinned STS endpoint to prove your IAM role. The signed `X-Nexus-Server-ID` is your service's own base-URL host - a captured request is valid for that one service only, and there is nothing to configure. Uses `AWSSDK.Core` for the credential/region chain only. See [Workload identity](https://docs.westyx.dev/sdks/dotnet/workload-identity.md#aws-iam-non-eks-aws-compute).
* **Azure Workload Identity (AKS)** - the `Azure` provider now prefers the projected federated token file (`$AZURE_FEDERATED_TOKEN_FILE`) before falling back to IMDS; auto-detection probes the file too.
* **Probe-based auto-detection** - auto-detect now stats the Kubernetes / AWS-IRSA / Azure token files and live-probes the GCP and Azure metadata servers (\~1 s timeout), instead of keying on environment variables absent on real cloud nodes.
* **Security hardening** - `NexusClient.CreateAsync` rejects plain-http `BaseUrl`s (loopback excepted); the Azure IMDS path refuses the generic default audience (must be `api://<client-id>`); expired WIF sessions fail closed; the metadata client disables redirects and the system proxy; metadata/exchange reads are bounded.

## v0.8.0 - 2026-06-16

* **`WestyxNexus.OpenFeature` NuGet sub-package** - install `WestyxNexus.OpenFeature` alongside `WestyxNexus` and register `NexusProvider` as an OpenFeature provider. Feature flags resolve via `ResolveBooleanValue`; configs via `ResolveString/Double/Integer/StructureValue`. All reads are cache-backed. See [OpenFeature integration](https://docs.westyx.dev/sdks/dotnet/openfeature.md).

## v0.7.0 - 2026-06-12

* **ASP.NET Core `IConfiguration` integration** - `builder.Configuration.AddWestyx(nexusConfig)` plugs Nexus into the standard configuration pipeline. All config values are accessible via `IConfiguration`, bindable via `IOptions<T>`, and live-reloaded via `IOptionsMonitor<T>` when SSE is enabled — no restart needed. See [ASP.NET Core configuration](https://docs.westyx.dev/sdks/dotnet/aspnetcore-configuration.md).

## v0.6.0

* **SSE reconnects after a polling fallback.** After the stream falls back to TTL polling, the SDK schedules a reconnect attempt on the `SseReconnectCooldown` schedule instead of staying in polling mode until the client is restarted.

## v0.5.1 - 2026-06-03

* **Requires .NET 8 or later** - target framework widened to `net8.0`. Supports .NET 8, 9, 10, and later.
* **Security improvements** - response bodies are no longer embedded in exception messages; `file`-type secret paths are fully hashed; key names are never stored on the filesystem.
* **Reliable `GetSecretAsync`** - all code paths return a properly awaitable `Task`, consistent with async/await conventions throughout the SDK.
* **Thread-safe WIF session** - concurrent token refresh calls are serialised to prevent redundant token exchanges.
* **CI** - test stage runs on every MR; publish is restricted to `main`-branch tags.

## v0.5.0

* **Write API** - `SetSecretAsync`, `DeleteSecretAsync`, `DeleteSecretVersionAsync` for programmatic secret management. secret keys only; public keys throw `NexusPublicKeyException` immediately without a network call.
* **`NexusRateLimitedException`** - new exception for HTTP 429 on write endpoints.

## v0.4.0 - 2026-05-28

* **Quarantine handling** - `NexusQuarantinedException` on sync when the backend returns `429` with a `{"error":"quarantined"}` body, carrying `Reason` and `ExpiresAt`; `IStreamObserver.OnQuarantined`; background sync is suppressed until `ExpiresAt`, and the stream sleeps until then and reconnects without counting a transport failure.
* All API paths moved from `/api/v1/` to `/v1/`.
* `ConfigEntry.IsPublic` is removed; visibility is decided server-side.

## v0.3.1 - 2026-05-13

* **`Retry-After`-aware SSE 429 handling** - `RunStreamAsync` now `await Task.Delay`-s the indicated duration (clamped `[5 s, 5 min]`) and reconnects automatically when the server returns `429` with a parseable `Retry-After` header (delta-seconds or HTTP-date form). Without `Retry-After`, the legacy terminate-on-429 + TTL polling fallback is preserved.

## v0.3.0

* **AB Testing add-on** - new `EvaluateABAsync(keys, userId, attributes, ct)` for batch per-user flag evaluation. Throws `NexusAbAddonNotAvailableException` on 403.
* **File-type secrets** - secrets now carry a `type` field; `file`-type values are materialised to temp files under `Path.GetTempPath()` and exposed via `GetSecretFilePath(key)`. Temp files are cleaned up by `Dispose()`.

## v0.2.0

* **Workload Identity Federation** - Kubernetes / AWS IRSA / GCP / Azure auto-detected; bearer-JWT auth with automatic refresh.
* **Stream observer hooks** - opt-in `IStreamObserver` for ops dashboards and load-test tooling.
* **Service kind awareness** - `GetSecretAsync` blocked with `NexusServiceKindMismatchException` on `kind=frontend` services.
* **402 Payment Required handling** - `NexusBillingException` thrown, `BillingOverdue` flag set, the background refresh throttled to one attempt every five minutes and the cache served; any success clears it.
* **Split HTTP clients** - a short consumer timeout no longer truncates the SSE stream.

## v0.1.0

* Initial release.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.