Solhigson.Framework.Core
10.23.0
See the version list below for details.
dotnet add package Solhigson.Framework.Core --version 10.23.0
NuGet\Install-Package Solhigson.Framework.Core -Version 10.23.0
<PackageReference Include="Solhigson.Framework.Core" Version="10.23.0" />
<PackageVersion Include="Solhigson.Framework.Core" Version="10.23.0" />
<PackageReference Include="Solhigson.Framework.Core" />
paket add Solhigson.Framework.Core --version 10.23.0
#r "nuget: Solhigson.Framework.Core, 10.23.0"
#:package Solhigson.Framework.Core@10.23.0
#addin nuget:?package=Solhigson.Framework.Core&version=10.23.0
#tool nuget:?package=Solhigson.Framework.Core&version=10.23.0
Utility Library
| Product | Versions Compatible and additional computed target framework versions. |
|---|---|
| .NET | net10.0 is compatible. net10.0-android was computed. net10.0-browser was computed. net10.0-ios was computed. net10.0-maccatalyst was computed. net10.0-macos was computed. net10.0-tvos was computed. net10.0-windows was computed. |
-
net10.0
- Autofac.Extensions.DependencyInjection (>= 10.0.0)
- Hangfire.AspNetCore (>= 1.8.22)
- Hangfire.Console (>= 1.4.3)
- Hangfire.Core (>= 1.8.22)
- Hangfire.InMemory (>= 1.0.0)
- Hangfire.PostgreSql (>= 1.20.13)
- Hangfire.SqlServer (>= 1.8.22)
- Mapster (>= 7.4.0)
- Microsoft.AspNetCore.Identity.EntityFrameworkCore (>= 10.0.14)
- Microsoft.Data.SqlClient (>= 6.1.7)
- Microsoft.EntityFrameworkCore (>= 10.0.14)
- Microsoft.EntityFrameworkCore.Sqlite (>= 10.0.14)
- Microsoft.EntityFrameworkCore.SqlServer (>= 10.0.14)
- Microsoft.Extensions.Compliance.Redaction (>= 10.1.0)
- Microsoft.Extensions.Http.Polly (>= 10.0.14)
- Microsoft.Extensions.Identity.Stores (>= 10.0.14)
- Microsoft.Extensions.Telemetry (>= 10.1.0)
- Microsoft.Extensions.Telemetry.Abstractions (>= 10.1.0)
- Microsoft.IO.RecyclableMemoryStream (>= 3.0.1)
- NewId (>= 4.0.1)
- Newtonsoft.Json (>= 13.0.4)
- NLog (>= 6.0.7)
- NLog.Extensions.Logging (>= 6.1.0)
- Npgsql (>= 10.0.3)
- OpenTelemetry.Exporter.OpenTelemetryProtocol (>= 1.15.3)
- OpenTelemetry.Extensions.Hosting (>= 1.15.3)
- Solhigson.Utilities (>= 10.2.0)
- StackExchange.Redis (>= 2.10.1)
- Swashbuckle.AspNetCore.Annotations (>= 10.3.1)
- Swashbuckle.AspNetCore.SwaggerGen (>= 10.3.1)
- Swashbuckle.AspNetCore.SwaggerUI (>= 10.3.1)
- System.Runtime.Caching (>= 10.0.14)
- System.Security.Cryptography.Pkcs (>= 10.0.14)
NuGet packages (1)
Showing the top 1 NuGet packages that depend on Solhigson.Framework.Core:
| Package | Downloads |
|---|---|
|
Solhigson.Admin
Admin screens for Solhigson apps as Razor components, rendered on the server. An app owns its routes; the package ships no page. |
GitHub repositories
This package is not used by any popular GitHub repositories.
| Version | Downloads | Last Updated |
|---|---|---|
| 10.29.0 | 47 | 11/19/2026 |
| 10.28.0 | 47 | 11/18/2026 |
| 10.27.0 | 92 | 11/17/2026 |
| 10.26.0 | 89 | 11/16/2026 |
| 10.25.0 | 89 | 11/16/2026 |
| 10.24.0 | 85 | 11/16/2026 |
| 10.23.0 | 87 | 11/15/2026 |
| 10.22.0 | 92 | 11/15/2026 |
| 10.21.0 | 92 | 11/14/2026 |
| 10.20.0 | 104 | 11/14/2026 |
| 10.19.0 | 93 | 11/12/2026 |
| 10.18.0 | 376 | 11/12/2026 |
| 10.17.0 | 92 | 11/11/2026 |
| 10.16.0 | 177 | 11/11/2026 |
| 10.15.0 | 204 | 11/7/2026 |
| 10.14.0 | 97 | 11/5/2026 |
| 10.13.0 | 99 | 11/4/2026 |
| 10.12.0 | 98 | 11/3/2026 |
| 10.11.0 | 103 | 11/2/2026 |
| 10.10.1 | 964 | 10/28/2026 |
10.23.0: user administration (Solhigson.Framework.Identity). UserAdministration<TUser, TRole, TContext, TKey>, registered scoped by both AddSolhigsonIdentityManager overloads, applies an app's IUserAdministrationRules<TUser, TKey> to who administers whom. Minor bump: every type and member is new, and a host that registers no rules sees no change but two: the two-factor code counters' clearing (a right code at sign-in, TwoFactorManager.DisableAsync and ResetAsync, SolhigsonIdentityManager.UnlockAsync) now guards the reset of the code-attempt count kept in this process as it guards the store's, so a throw there writes the sign-in's "code attempt count not reset" Warning where it escaped before, every other line unchanged; and a refused or thrown write of an account (the name-based unlock's, two-factor's, the wrong-code lockout's) now also puts back the user's owned-type values (TrackedAccount.PutBack), a replaced owned reference or an owned item added or removed still not reverted. Rules: register one IUserAdministrationRules<TUser, TKey> (any lifetime), or every call that reads the rules answers NoRules with one Error (an email change answers EmailChangeOff first while it is off, and a write first refuses a store it cannot rely on). Scope (the users an actor may see, a tenant's say) has no default: an app with one tenant returns the users given. AdministrableRolesAsync answers AdministrableRoles.All or Only(names) for RoleUse.Reach (the roles a target may hold for the actor to reach it) and RoleUse.Grant (the roles the actor may give); ReachesUsersWithNoRole (false), RefuseRoleSet (null), MatchText (a normalized email or user name prefix, or the exact id) and DisplayName (the email) have defaults. AdministrableRolesAsync or Scope answering null, or any rule throwing, answers Failed, so a fault never widens reach. Roles are read from the database for each call, never from claims or a cache, and compared on normalized names: a stored role is in an Only answer when its stored normalized name and its name normalized now are both among the answer's. Result: UserAdministrationResult<TUser> (Outcome, User, Message, Errors, EndSessions, NeedsPasswordLink, Granted, Revoked, Disabled, PreviousEmail); the words a user reads are the app's. No method throws but on the caller's cancellation: a step that throws answers Failed. Reach (CanAdministerAsync(actingUserId, targetUserId)): NoRules; ActorRefused (one Warning) unless the actor is stored and Enabled both as loaded and as stored; NotFound (one Warning) for a target missing, outside Scope, or holding a role outside the Reach answer (no stored role needs ReachesUsersWithNoRole), one answer for all three so an id cannot be probed; else Done with the target. It holds for the rows as read: an app that changes a field Scope reads (a user's tenant) calls it again after its save, inside its transaction, and rolls back on a refusal. The re-check cannot be relied on to stop an actor moving itself: Scope reads the actor's own row, so after the move it passes inside the new tenant whenever the actor's Reach answer covers its own roles; the app refuses a change to a Scope field on the acting user's own row, comparing the loaded rows' keys, never the ids as passed. Enable and disable (SetEnabledAsync): a user store a write cannot rely on (anything but Identity's EF UserStore saving through the context with AutoSaveChanges on) answers Failed with one Error; then reach; NotOwn (one Warning) when the actor's loaded row's key is the loaded target's, never the ids as passed; Unchanged when Enabled as stored is already as asked (a disable so answered still sets EndSessions); a disable sets Enabled false and rotates the security stamp in one save and sets EndSessions; an enable sets NeedsPasswordLink for a user with no password hash. Create (CreateAsync(actingUserId, user, roleNames)), refused in order: the store, NoRules, ActorRefused, InTransaction (a transaction already open on the context, or an ambient one), EmptyRoleSet, RoleNotFound, RoleOutOfReach (a role outside Grant; one Warning), RoleSetRefused (the app's reason as the message), InvalidEmail, EmailInUse (one Warning naming no address; uniqueness is global, checked, not enforced), and unsaved changes of the app's own in the context (Failed, one Error). Then, in the context's execution strategy and one transaction, the user is created with no password and Enabled the negation of NewUserStartsDisabled (true by default, so it starts disabled), given its roles, and read back through the actor's Scope (a row it does not admit is NotFound); Done sets NeedsPasswordLink, for a reset link the app emails. Role change (SetRolesAsync(actingUserId, targetUserId, roleNames), the whole set): the store, reach on the target's current roles (so revoking needs no check of its own), NotOwn, InTransaction, EmptyRoleSet, RoleNotFound, RoleOutOfReach for a role to grant outside Grant, RoleSetRefused, Unchanged for the stored set, then pending changes; in one transaction the roles are added and removed and the stamp rotated, with Enabled set false when RoleChangeDisables is true (the default); Done sets EndSessions, Granted, Revoked, and Disabled only when this call disabled. Email change (ChangeEmailAsync(actingUserId, targetUserId, newEmail)): EmailChangeOff while AllowEmailChange is false (the default), before anything is read; the store, reach and NotOwn; InTransaction; RoleOutOfReach (one Warning) when the target holds any role outside the actor's Grant answer; InvalidEmail; Unchanged for the same address normalized; EmailInUse; pending changes. In one transaction one save sets the address, the user name too where it was the old address, EmailConfirmed false and a new stamp; Done sets EndSessions and PreviousEmail. Identity's email index is not unique, so only a unique index the app adds on NormalizedEmail stops two racing changes or creates storing one address. The transactional writes (create, role change, email change): a write crossing another change to the target answers IdentityFailed with ConcurrencyFailure and one Warning (a role row added past Identity included: role change reads the rows again first in its transaction, email change makes its reach admission again before its save and reads the rows and checks the grant again after it); after its save an email change reads the target back through Scope (NotFound); a create or a role change that wrote any row beyond what was asked answers Failed with one Error naming which. Every refusal or throw rolls back and puts the tracked state back, so a later save of the scope writes none of it; a commit that throws is read back by the concurrency stamp it wrote and answers Done when it landed. For every write a save Identity refuses is IdentityFailed with its codes in Errors and one Warning naming the step and the codes. Ending a lockout (UnlockAsync(actingUserId, targetUserId)): the store, reach and NotOwn (an actor ends its own only through the sign-in's rules); Unchanged when the target is not locked out as stored (lockout off, or no end strictly after now, now read from the injected TimeProvider, the test the list's LockedOut filter uses; under a clock other than the system's it can differ from Identity's IsLockedOutAsync, which the sign-in asks on the system clock); else LockoutEnd and AccessFailedCount are cleared in one save on the row the reach loaded, the stamp kept, and where two-factor is registered the code counters are cleared as the reset clears them; a counter reset that fails leaves it Done with one Warning. SolhigsonIdentityManager.UnlockAsync(userName) stays for a host verb. List (SearchAsync(actingUserId, UserSearch)): the users within reach by the same rule, narrowed by Text (through MatchText, only matches within reach kept), Role, Enabled, LockedOut, TwoFactorEnabled, NotSignedInSince and HasPassword; ordered by normalized user name then id, keyset-paged (UserPage: Rows of UserRow (User, Roles, HasPassword), NextCursor; PageSize 20, clamped to 1 to 100; a cursor that does not decode, or whose user is gone or out of reach, serves the first page); rows untracked, PasswordHash, SecurityStamp and ConcurrencyStamp set null; on SQLite LockedOut needs LockoutEnd mapped through a converter. Audit name lookup (ResolveDisplayNamesAsync(actingUserId, userIds)): UserNameLookup (Names, Failed) for AuditDisplay's resolvedName; the first 200 distinct ids, one query for the users the actor's Scope admits (the role rule does not apply), named by DisplayName; a refusal is no names, a throw no names with Failed true; a caller never passes an id a sign-in caller typed. Role edit (CanEditRoleAsync(actingUserId, roleName)): RoleNotFound (no line), RoleOutOfReach for a role outside Grant and NotOwn when the actor holds the role (one Warning each, naming the role's id, never its name), else Done; the editor calls it inside its write's transaction and again after its save. Grantable roles (GrantableRolesAsync(actingUserId)): the names of the stored roles the Grant answer allows, ordered ordinally, a role with no name or a stale normalized name left out; the writes still check every role. Options (UserAdministrationOptions, through services.Configure): NewUserStartsDisabled true, RoleChangeDisables true, AllowEmailChange false. Signals: lines under the logger name UserAdministration, each with the operation and both ids shaped (a lookup's, the count of ids), never an email, a name or a role's name. Error: NoRules, a user store a write cannot rely on, unsaved changes of the app's, rows written beyond what was asked, or a step that throws (the database, or the app's rules), naming the step and the exception's type, never its message. Warning: ActorRefused, NotFound, NotOwn, IdentityFailed, RoleOutOfReach, EmailInUse, and an unlock whose code counters were not all cleared. Information: each write done. A search, a lookup or a grantable-roles list answered writes no line. Every call adds one to the counter user_administration on the meter Solhigson.Framework.Identity, tagged method (can_administer, set_enabled, unlock, create, set_roles, change_email, search, resolve_display_names, can_edit_role, grantable_roles) and outcome (the outcome as UserAdministrationDiagnostics.Text writes it, or cancelled). 10.22.0: the audit reader, the payload parser, the display labels and the window defaults (Solhigson.Framework.AuditCapture). Minor bump: every type is new and no existing behaviour changes, but a consumer's own type named as one the release adds (listed at the end) is ambiguous (CS0104) in a file that imports both namespaces and uses the name. Reader: IAuditTrailReader<TContext>, registered by SolhigsonAutofacModule (through RegisterSolhigsonDependencies or RegisterSolhigsonDependenciesWithProvider) as the open generic AuditTrailReader<TContext> per lifetime scope, a closed registration (a reader over a read replica's context) winning over it. SearchAsync(AuditTrailSearch) reads one keyset page (AuditTrailPage: Items, NextCursor, HasMore; no total) of AuditTrailListItem rows, Created then Id descending, with no tracking, inside the required window of Created at or after From and before To; Category, Action, EntityType, EntityId, ActorUserId and SourceId each narrow by exact match when set (a null or white-space string sets none); PageSize defaults to 20 and is clamped to 1 to 100; a list row never carries Snapshot, Changes, UserIp or SourceId. GetAsync(id, created) reads one row whole (AuditTrailDetail: the list fields, Snapshot, Changes, UserIp and SourceId, as stored) by both halves of its (Id, Created) key; a miss is a failed result with StatusCode.InvalidRequest and one fixed message, whichever half missed, and is not logged. AuditTrailKey.CreatedKey writes the Created half of a link as UTC round-trip ("O") text ending in Z, and TryParseCreatedKey reads back that form only; the page cursor is base64url of that text and the id, and a cursor that does not parse serves the first page. From, To, GetAsync's created and CreatedKey's argument are read as UTC instants: an unspecified kind is stamped UTC, a local one converted. A To not after From is a failed result with StatusCode.InvalidRequest and no query, and is not logged. The reader makes no access decision and filters no row by caller. Lines under the logger name AuditTrailReader, through the injected ILoggerFactory, else the process-wide factory installed when the line is written (where the factory used throws building the logger, a disposed one say, or there is none, the line goes to NLog's internal logger with no logger name, so an alert on AuditTrailReader misses it): a get, or a search with a valid window, on a context whose model does not map AuditTrail is a failed result and one Warning naming the operation and the context type, with no query; any other failure is a failed result and one Error, a search's naming the context type, the window, the page size, whether a cursor was given, the elapsed milliseconds and the names of the filters set, never their values, and a get's the context type, the created instant and the elapsed milliseconds; a cancellation is rethrown. The consumer's indexes: (EntityType, EntityId, Created) serves EntityType alone or with EntityId, EntityId alone cannot seek it, (ActorUserId, Created) serves ActorUserId, and no index orders by Created, so an unfiltered page, or one filtered only by Category, Action, SourceId or EntityId, reads every row in the window. Payload (AuditPayload): ReadChanges parses AuditTrail.Changes into AuditChanges (AuditChange rows: Field, Old, New) and ReadSnapshot parses AuditTrail.Snapshot into AuditSnapshot (AuditField rows: Name, Value), never throwing and logging nothing: blank is no rows, and text not of the declared shape (not JSON, not valid UTF-16, nested deeper than MaxDepth 64, another root kind, an element or name the shape refuses) is no rows with Raw holding it as stored; a value is text (a string as it is, true and false as those words, a number or a nested value as its raw JSON). Labels (AuditDisplay): CategoryLabel, ActionLabel, IdFragment, Subject and Actor build labels from the values passed alone; no label built from an id shows more than 8 characters of it (IdLength, then an ellipsis), a name has its format, control, line separator and paragraph separator characters and any lone surrogate removed and is cut to 64 characters (NameLength), and Actor always follows a name with the id fragment when there is an id; with no id it is the name alone; on a row keyed by what a sign-in caller typed that name is the caller's text, which can read as System, unattributed or another actor, so a screen marks that row's actor as an attempted identity. Window (AuditTrailWindow.Resolve(fromDay, toDay, scoped, viewerOffset, utcNow)): the UTC From and To from a viewer's days at a fixed east-positive offset, clamped to 14 hours, the clock passed in, never throwing; a toDay at midnight is that whole day; with no dates an unscoped request is the viewer's current day and a scoped one (AuditTrailSearch.IsScoped: EntityType, EntityId or ActorUserId not blank) is all time, from AllTimeFrom (2000-01-01 UTC) to the midnight after utcNow's UTC day; with one side given the missing side is the viewer's today; a To not after From becomes From plus one day, or DateTime.MaxValue where no day is left; one offset serves both ends, so a range crossing a daylight-saving change is off by it at one end. Every text these return is unencoded and may hold what an anonymous caller typed: a screen encodes it on output. A consumer's own type named as one Solhigson.Framework.AuditCapture gains (IAuditTrailReader<TContext>, AuditTrailReader<TContext>, AuditTrailSearch, AuditTrailPage, AuditTrailListItem, AuditTrailDetail, AuditTrailKey, AuditPayload, AuditChanges, AuditChange, AuditSnapshot, AuditField, AuditDisplay, AuditTrailWindow), brought into a file by a using directive alongside that namespace, is ambiguous there (CS0104) until the local copy is deleted or the use qualified or aliased. 10.21.0: the permission manager on a host without MVC and the discovery of routable components. Minor bump: a host with MVC and no Razor component seeds what it seeded before, and sees only discovery's new Information line, for a failed discovery an Error now written for an early failure too, under a new category, and, with permission groups registered, two changed group-check texts. Without MVC (Solhigson.Framework.Identity): PermissionManager's IActionDescriptorCollectionProvider parameter is optional, so a host that registers Razor components and no MVC services (no AddControllers, AddMvc or AddRazorPages) resolves the manager and the framework's PermissionHandler, which its container could not build before, and a [Permission] is checked there. On such a host DiscoverNewPermissionsAsync still seeds every [Permission] on a controller class or action, granting the AllowedRoles a customPermissions entry of the same name gives, but reads no action's route: no action's url is set from its route, IsPrimaryUrl on an action included, a url or click handler customPermissions gave stays, and one Warning counts the menu permissions on actions left with neither. Components: discovery now reads, after the controllers, every routable Razor component of the assembly (a non-abstract IComponent carrying its own Components RouteAttribute, which @page compiles to) and seeds a row for each [Permission] on it, inherited ones included; a name already listed (from customPermissions, a controller or an action) is kept. A [Permission] carries no AllowedRoles and no menu flag (its inherited Roles, if set, adds a role requirement to the check and grants nothing), so a name's AllowedRoles, and whether it is a menu, come only from its customPermissions entry, listed first; with permission groups registered a grant the role's group may not hold is refused at seeding with a Warning under Solhigson.Framework.PermissionGroups, written as the grant is made, after that row, and only by a manager given a logger factory. A menu permission on a component, with neither url nor click handler, takes ~/ plus the component's route template without its leading /, only when the component has exactly one route whose template is not blank and holds no {. IsPrimaryUrl on such a component replaces a url already set, the component winning over an action as it is read later; on a component that claims no url (several routes, or one whose template is blank or holds a {) it fails discovery, with one Error, before any row is written. A row that already exists keeps its stored url: discovery writes a url only when it inserts. With permission groups registered, the start-up group check's walk includes the routable components, each named by its full name. New lines under Solhigson.Framework.Identity.PermissionManager, the Warnings written before any row: on a host without MVC, the Warning above; one Warning per component that claims no url and leaves a menu permission it carries with no url and no click handler; one per routable component carrying neither [Permission] nor [AllowAnonymous]; one per routable component carrying both, whose permissions [AllowAnonymous] leaves unchecked; one per non-abstract component with no route carrying [Permission] that no routable component inherits, which nothing enforces and which seeds no row; and, after the save, one Information line counting the controllers and routable components read and the rows seeded. Changed without opting in: an early failure of discovery (a null assembly, IsPrimaryUrl on a controller class or on a component claiming no url) writes one Error naming its reason under that category, where it wrote none; the outer catch's Error moves from the logger named by PermissionManager's generic type, through the process-wide factory, to that category through the injected ILoggerFactory, falling back to the process-wide factory (ConfigureSolhigsonLogManager) for a manager built without one; a logger that throws on a discovery line or in the start-up group check changes nothing discovery does. Two group-check texts under Solhigson.Framework.PermissionGroups change: a name with no carrier reads "no controller, action or component", and a stopped walk "the walk of the controllers and components stopped at". PermissionAttribute's remarks and its IsPrimaryUrl summary say what discovery reads and where IsPrimaryUrl is valid. No public type is added, and the manager's constructor keeps its parameter types. 10.20.0: two-factor by an authenticator app. Minor bump, opt-in: a host that does not call AddSolhigsonTwoFactor sees no two-factor change, and its sign-in answers as in 10.19.0. Registration (Solhigson.Framework.Identity): identityBuilder.AddSolhigsonTwoFactor(configure), on the IdentityBuilder AddSolhigsonIdentityManager returns, registers TwoFactorManager scoped; replaces Identity's EF UserStore with RootEncryptingUserStore, which stores the authenticator key as a root-encrypted rk1: envelope, so the host also calls AddRootEncryption in the same release, never after it: without the ring every enrolment answers NeedsRootRing, and a stored key's read throws InvalidOperationException, so a right password for an enabled enrolled account throws out of SignInAsync whatever Enabled says and DisableAsync answers Failed; adds AuthenticatorKeysRootStore to the ring census and re-encryption; registers the counter store and TwoFactorOptions (Issuer, required; Enabled and RequiredForGroupsEnabled, Func<IServiceProvider, bool> switches on when unset; RequiredForGroups, role-group names compared ordinally, empty unless set, and empty no account must enrol; CodeCapFailsClosed, false unless set); and turns on the identity manager's second factor for the builder's user type. AddSolhigsonRootEncryptedAuthenticatorKeys registers the store and the census entry alone. A host fails at start when Issuer is blank, IdentityOptions.Lockout.MaxFailedAccessAttempts is below 2 or DefaultLockoutTimeSpan is not above zero. TwoFactorManager answers a TwoFactorResult (Outcome, a TwoFactorOutcome; EndSessions, NotifyHolder and HadPassword for the app's flow and audit; SharedSecret and AuthenticatorUriSecret for an enrolment): BeginEnrolmentAsync, CurrentEnrolmentAsync and CompleteEnrolmentAsync enrol; DisableAsync turns two-factor off only with a live code; ResetAsync(user, actingUserId) is an administrator's removal of another user's factor and password together, a self-reset refused (NotOwn); RequiresEnrolmentAsync answers whether an account in a RequiredForGroups role group must enrol, for the app's gate. Sign-in: SignInAsync answers an enrolled account RequiresTwoFactor with SignInResponse.PendingUserId, and SolhigsonIdentityManager.TwoFactorSignInAsync(code, pendingUserId) is the code step; SignInOutcome gains AuthenticatorUnreadable, TwoFactorTimedOut, TooManyCodeAttempts and CodeCapUnavailable, and SignInResponse gains PendingUserId and NotifyHolder. While Enabled is off an enrolled account signs in on its password alone, with one Warning. Code attempts at sign-in and at a disable share one cap per account, MaxFailedAccessAttempts per DefaultLockoutTimeSpan window, counted before the code is checked; a wrong code counts toward lockout, and the first code lockout of a streak lasts DefaultLockoutTimeSpan and each later one twice the last, up to 24 hours (TwoFactorLockout.EscalatedLockout), a streak living 30 days from its last lockout. A stored key the ring cannot open (not-an-envelope, not-in-ring, malformed, failed-authentication) reads as no key with one Error under Solhigson.Framework.Identity.AuthenticatorKey (AuthenticatorKeyStorage), and the framework's sign-in refuses its account (AuthenticatorUnreadable). Meter Solhigson.Framework.Identity: password_sign_in gains the step tag (password, code) beside outcome, and two_factor counts each TwoFactorManager call but RequiresEnrolmentAsync, tagged method and outcome; TwoFactorManager's lines are under Solhigson.Framework.Identity.TwoFactor (TwoFactorDiagnostics), a disable's wrong-code counting and lockout lines and the counter clearing after a disable or a reset under Solhigson.Framework.Identity. Counter store (Solhigson.Framework.Throttling): ICounterStore (CountAsync, ResetAsync; CounterResult, CounterExpiry) counts per key atomically and answers Unavailable when it cannot; RedisCounterStore, registered once by AddSolhigsonThrottling or AddSolhigsonTwoFactor, needs an IConnectionMultiplexer and a Redis run with maxmemory-policy noeviction, and never falls back to memory; UseInMemoryCounterStore() replaces it with InMemoryCounterStore, per process, for a single host. While the store cannot count, code attempts are counted per process (refused, with CodeCapFailsClosed on) and code lockouts do not escalate, Identity's own lockout standing. A disable or a reset whose lost commit is read back as landed answers Disabled or Reset and leaves the account object detached, so after a Disabled or Reset answer the app reloads the account (UserManager.FindByIdAsync) before writing it again in the request: UserManager.UpdateAsync of the detached object throws EF's InvalidOperationException with Identity's default user validator. Where another request saved the account after the commit, the object keeps this call's concurrency stamp, so UserManager.UpdateAsync without a validator answers ConcurrencyFailure and a context's Update then SaveChangesAsync throws DbUpdateConcurrencyException and writes nothing, and one Warning names the account's id and the method. RequiresEnrolmentAsync never empties its cached entry for an account no longer stored: it answers false and leaves the entry as it was. Changed without opting in: a declared Secret setting's table read is answered from the settings cache, in the process's memory only, until a save, a reset or a delete of any setting made through the framework evicts every cached setting on every instance, while a write made around it is seen when the entry expires (a day by default), and a declared table setting absent with no Default is cached as absent; GetUserDetailsByIdAsync, GetUserDetailsByUsernameAsync and GetUserDetailsByEmailAsync read each role with its group in one cached query, evicted by a saved change to a role or a role group, and no longer write the group onto the role instance the cache holds; password_sign_in carries step password on every host; AddSolhigsonThrottling also registers the Redis ICounterStore, which the identity manager's constructor takes, so a hand-built container that builds the manager registers an IHostEnvironment with an application name, or its own store; the throttle's outage Error names the fault's type, never the driver's message. The identity manager's three public constructors gain optional IOptions<TwoFactorOptions>, ICounterStore and IServiceProvider parameters: source compatible, but an assembly compiled against an earlier Core that constructs the manager, directly or from a derived class, throws MissingMethodException until rebuilt. A consumer's own type named as one Solhigson.Framework.Identity gains (TwoFactorManager, TwoFactorResult, TwoFactorOutcome, TwoFactorDiagnostics, TwoFactorOptions, TwoFactorIdentityBuilderExtensions, TwoFactorLockout, RootEncryptingUserStore, AuthenticatorKeyStorage, AuthenticatorKeysRootStore) or Solhigson.Framework.Throttling gains (ICounterStore, CounterResult, CounterExpiry, RedisCounterStore, InMemoryCounterStore), brought into a file by a using directive alongside that framework namespace, is ambiguous there (CS0104) until the local copy is deleted or the use qualified. A consumer adopting two-factor follows the steps in RELEASING.md. 10.19.0: sign-in hardening and the breached-password check. Minor bump. SolhigsonIdentityManager.SignInAsync (Solhigson.Framework.Identity) does one password-hash verification whatever the account's state, while that state does not change during the call: where Identity answers without hashing it verifies against a fixed hash (SignInFixedHash, a singleton AddSolhigsonIdentityManager registers), the password hasher given null for an unknown name. SignInResponse gains Outcome (SignInOutcome: Succeeded, RequiresTwoFactor, LockedOut, Rejected, Disabled) and LockedByThisAttempt; every call counts on the new meter Solhigson.Framework.Identity (password_sign_in, tagged outcome), and the attempt that locks an account writes a Warning naming its id. UnlockAsync(userName) clears an account's lockout end and failed count in one write and writes an Information line. Tightened without opting in: lockOutOnFailure defaults to true, so a caller that omits it counts failures toward lockout once rebuilt; an account whose Enabled is false is refused even with the right password (Outcome Disabled, User null, no cookie, no second factor asked); a right password whose account cannot be read back is signed out. The three public constructors gain optional SignInFixedHash and ILoggerFactory parameters: source compatible, but an assembly compiled against an earlier Core that constructs the manager, directly or from a derived class, throws MissingMethodException until rebuilt. Breach check, opt-in: identityBuilder.AddSolhigsonBreachedPasswordCheck(configure) registers BreachedPasswordCheck (Breached, Clear or Unchecked), BreachedPasswordValidator for the builder's user type and BreachedPasswordRangeCache; only the first five hex characters of the password's SHA-1 are sent, to api.pwnedpasswords.com, the range is cached an hour by that prefix, and no hash or verdict is stored; a failure answers Unchecked with one Error (the check fails open), and five in a row pause the calls for a minute. A consumer's own type named as one Solhigson.Framework.Identity gains (SignInOutcome, SignInDiagnostics, SignInFixedHash, BreachedPasswordCheck, BreachedPasswordOptions, BreachedPasswordRangeCache, BreachedPasswordResult, BreachedPasswordValidator, BreachedPasswordIdentityBuilderExtensions), brought into a file by a using directive alongside that framework namespace, is ambiguous there (CS0104) until the local copy is deleted or the use qualified. A consumer passes lockOutOnFailure: false only on purpose, reads Outcome where it read User.Enabled after a sign-in, rebuilds an assembly that constructs the manager, and, adopting the breach check, maps its own switch onto BreachedPasswordOptions.Enabled, which is on when unset; the full steps are in RELEASING.md. 10.18.0: the OTLP log export, the API-exchange masker and export, and the Loki readers. Minor bump, every piece opt-in: a host that calls none of AddSolhigsonLogExport, UseSolhigsonLogScope and AddSolhigsonLokiReader sees no logging change but the job runs below. Restore: every consumer now receives OpenTelemetry.Exporter.OpenTelemetryProtocol and OpenTelemetry.Extensions.Hosting 1.15.3 with their transitive packages; one referencing any of them below 1.15.3 raises it to 1.15.3 or later, adopting or not, or restore fails with NU1605, and one restoring in locked mode regenerates its lock files. Export (Solhigson.Framework.Logging.Export): AddSolhigsonLogExport, called after any ClearProviders(), adds the OpenTelemetry logging provider beside NLog; logs export only when Solhigson:Logs:OtlpExportEnabled is true and OTEL_EXPORTER_OTLP_ENDPOINT is set (OtlpExportState). The endpoint is https unless loopback: with any OTEL_EXPORTER_OTLP_*HEADERS key set, an endpoint that is neither turns the export off, but with none set it is not enforced, and a plain-http endpoint carries personal data in clear. Traces and metrics join through SolhigsonLogExportOptions.OpenTelemetry and export only while logs export. Every call ignores inbound trace context, in the DI DistributedContextPropagator and the SDK's process-wide default propagator. While exporting, ScopedPropertiesLogProcessor adds chainId, the ExportedLogProperties, client.address and enduser.id, and replaces the request's raw path in a line by its route template; UseSolhigsonLogScope(), before UseRouting, opens the request's log scope. Nothing else is rewritten or redacted: every template property, the formatted message, and an exception's type, message and stack trace export as written (a URL's query keeps its values), and the path rewrite misses an exception's text, a path after a schemeless host, a byte[] attribute, a multi-dimensional array attribute (which leaves the record's other attributes unrewritten too), a path followed by a percent-encoded / or ., and one preceded by ./ or ../. Every line then goes to an off-host store, so a host audits what its lines write before turning the switch on. Spans keep raw paths. Masker (Solhigson.Framework.Web.Api): ApiTraceMasker under ApiTraceMaskOptions, whose ProtectedFields always hold ProtectedFieldsFloor. API exchanges: with Solhigson:Logs:ApiLogsToLokiEnabled also true, LokiApiTraceSink exports each masked exchange as the service <app>.ApiLogs, carrying enduser_id, counted on the meter Solhigson.Framework.LogExport; the LoggingApiTraceSink line is then not written. Readers (Solhigson.Framework.Logging.Loki): AddSolhigsonLokiReader registers IAppLogReader and IApiLogReader, which read while Solhigson:Logs:LokiReadEnabled is true from Solhigson:Logs:LokiUrl, LokiUser and LokiToken, and check no permission. Changed without opting in: a job a framework Hangfire server runs gets its own root activity (JobRunEnvelopeFilter.ActivitySourceName) and log property scope, its trace id the chain id; with no tracer on that source, an outbound call it makes carries a sampled traceparent. A consumer's own type named as one Solhigson.Framework.Logging.Export gains (ApiLogExportPipeline, LogExportDiagnostics, LogPropertyScopeMiddleware, LokiApiTraceSink, OtlpExportOffReason, OtlpExportState, ScopedPropertiesLogProcessor, SolhigsonLogExportOptions, SolhigsonLogExportServiceCollectionExtensions, SolhigsonLogScopeApplicationBuilderExtensions), Solhigson.Framework.Logging.Loki gains (ApiLogRecord, ApiLogSearchRequest, AppLogNewestRecord, AppLogRecord, AppLogSearchRequest, CursorPagedList, IApiLogReader, IAppLogReader, LokiApiLogReader, LokiAppLogReader, LokiReadClient, SolhigsonLokiReaderOptions, SolhigsonLokiReaderServiceCollectionExtensions) or Solhigson.Framework.Web.Api gains (ApiTraceMasker, ApiTraceMaskOptions), brought into a file by a using directive alongside that framework namespace, is ambiguous there (CS0104) until the local copy is deleted or the use qualified; in a namespace that declares its own type of that name, the local one wins with no error and the framework's is qualified.