Solhigson.Framework.Core 10.28.0

There is a newer version of this package available.
See the version list below for details.
dotnet add package Solhigson.Framework.Core --version 10.28.0
                    
NuGet\Install-Package Solhigson.Framework.Core -Version 10.28.0
                    
This command is intended to be used within the Package Manager Console in Visual Studio, as it uses the NuGet module's version of Install-Package.
<PackageReference Include="Solhigson.Framework.Core" Version="10.28.0" />
                    
For projects that support PackageReference, copy this XML node into the project file to reference the package.
<PackageVersion Include="Solhigson.Framework.Core" Version="10.28.0" />
                    
Directory.Packages.props
<PackageReference Include="Solhigson.Framework.Core" />
                    
Project file
For projects that support Central Package Management (CPM), copy this XML node into the solution Directory.Packages.props file to version the package.
paket add Solhigson.Framework.Core --version 10.28.0
                    
#r "nuget: Solhigson.Framework.Core, 10.28.0"
                    
#r directive can be used in F# Interactive and Polyglot Notebooks. Copy this into the interactive tool or source code of the script to reference the package.
#:package Solhigson.Framework.Core@10.28.0
                    
#:package directive can be used in C# file-based apps starting in .NET 10 preview 4. Copy this into a .cs file before any lines of code to reference the package.
#addin nuget:?package=Solhigson.Framework.Core&version=10.28.0
                    
Install as a Cake Addin
#tool nuget:?package=Solhigson.Framework.Core&version=10.28.0
                    
Install as a Cake Tool

Utility Library

Product 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. 
Compatible target framework(s)
Included target framework(s) (in package)
Learn more about Target Frameworks and .NET Standard.

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
Loading failed

10.28.0: role administration (Solhigson.Framework.Identity). RoleAdministration<TUser, TRole, TContext, TKey> is registered scoped by both AddSolhigsonIdentityManager overloads and answers through the app's IUserAdministrationRules, the registration user administration needs: with none, every call answers NoRules. Every method answers a UserAdministrationResult<T> with its payload in Value, never throws but on the caller's cancellation, reads the database for each call, never a cache, and is counted on role_administration, tagged method and outcome, and logged under RoleAdministration by ids, never a role's name (a create's Done line also names the stored group): an Error is a fault, a Warning an attempt outside reach. ListAsync answers every stored role as a RoleSummary (id, name, group, whether the group is a known one, the holders in every tenant past any query filter, the stored grants, whether the caller holds it, and CanEdit by CanEditRoleAsync's rule), ordered by group then name; GetAsync answers one role by its normalized name. Both, and HeldPermissionsAsync, answer any stored, enabled actor, holder counts in every tenant included, so the app gates who may view the role pages. CreateAsync trims the name and refuses InvalidName (blank, over MaxRoleNameLength, 64, a control or format character, a space other than U+0020 or two in a row, a lone surrogate or U+FFFD, a slash or a backslash, or text not in NFC), GroupNotFound, RoleExists, and GroupOutOfReach, with one Warning, unless the new IUserAdministrationRules.MayCreateRoleAsync answers true: it is given the actor, its roles, the trimmed name and the stored group's own name, and answers false by default, so an app that does not override it creates no role. An app whose rules or role checks work by role name refuses there a privileged name nobody has stored yet, or one a delete has freed. The role is created with no grant. OfferedPermissionsAsync answers the permission manager's offer for a role the caller may edit as OfferedPermission records, ordered by the top ancestor's menu index and name, then depth; Grantable is true when the caller's Grant answer is All, or when it holds the permission as a check with enforcement on sees it, so a grant its role's group does not admit never counts. HeldPermissionsAsync answers every stored grant of a role, whether or not the caller may edit it, as HeldPermission: Class is Offered or, by the permission-group reconciler, OutsideGroup, NoDeclaration, UnknownGroup or Missing, and Grantable holds only on a role the caller may edit. SetPermissionsAsync saves the whole posted set through SetRolePermissionsAsync in one transaction under the execution strategy, refusing InTransaction under an open transaction; Stale when the role's offered grants are not the page's loaded set, or the manager staged other rows than planned; PermissionOutOfReach, with one Warning, when an id to add is not grantable; and RoleOutOfReach, rolled back, when the Grant answer, asked again with the grants as written, no longer lets the caller edit the role. A rule that ranks roles by their grants reads them uncached through the scope's TContext. RemoveGrantsOutsideOfferAsync removes, through the tracker in one save, the grants the reconciler judges outside the role's group, undeclared and no menu root, or naming no stored permission: Revoked names them, and RolePermissionChange.RemovedMissingIds holds the ids of the last kind; with no permission groups registered it answers Unchanged. DeleteAsync deletes a role no user holds in any tenant, answering a RoleDeletion (the summary as it was, RemovedPermissionNames and RemovedMissingIds), or RoleInUse with the holder count; the role's claims go with it by Identity's cascade. It writes the role first, then counts its holders with a read that waits for an assignment in flight: FOR UPDATE on PostgreSQL, at READ COMMITTED, its default; READCOMMITTEDLOCK on SQL Server; the write lock on SQLite. On any other provider it answers Failed. A save, a removal or a delete that is done waits up to two seconds for every instance's cache to be told: CacheConfirmed false means another instance may honour the old grants until its cache recovers. No call ends a session, and a deleted role's name can be created again, which a live session carrying that role claim then matches. UserAdministrationResult<T> now takes any T, with User kept as an alias of Value, and the outcome enum gains InvalidName, GroupNotFound, RoleExists, GroupOutOfReach, PermissionOutOfReach, Stale and RoleInUse, each with its UserAdministrationMessages sentence and counter text. Minor bump: every member is new, UserAdministrationResult<T>'s change is compatible, and MayCreateRoleAsync has a default. 10.27.0: a host names the build it runs, in its logs and at its /api root (Solhigson.Framework.Web, and the package's build targets). The package now carries Solhigson.Framework.Core.targets under build/ and buildTransitive/, so the file reaches every project that references Core, directly or through another package, and it does nothing unless that project sets SolhigsonStampBuildTime to true. A project that sets it gets its UTC build time, to the minute, as the BuildTime AssemblyMetadata, written dd-MM-yyyy HH:mm through the invariant culture whatever the build machine's culture, calendar or time zone, and recompiles whenever the minute has changed, so a host sets the switch in each host project only. The new ServiceRelease reads a host's own assembly: ServiceRelease.Of(assembly), or Of<T>() for the assembly that defines T, a type of the host (never the entry assembly nor Core's own), answers one shared immutable instance per assembly, held no longer than the assembly, and never throws, an assembly whose attributes cannot be read answering as one that carries neither. Commit is the 40-hex-digit commit the SDK writes after the informational version's last +, null when there is none (a SourceRevisionId override that is not a commit, such as a date, or a build that saw no .git); Built is the BuildTime stamp, null when the project did not set the switch; Text is [Built], else the informational version's text after its first + in brackets, else [unknown], the form a version line shows. ServiceRelease.Answer<T>() is a host's /api answer, a successful ResponseInfo<ServiceRelease> with the message Ok, returned through HttpOk(); FailedAnswer<T>() is the failed envelope with the default failed message and code, still carrying the release, so a caller tells a host that is down from one running an old commit, and goes out with a 5xx status, never through HttpOk(), which answers 200 whatever the envelope holds. The release serializes as {"built": ..., "commit": ...}, both written even when null and Text left out, under System.Text.Json and Newtonsoft alike, whatever the caller's naming, null or default-value handling; it has no public constructor, so it is written but not read back: a reader such as a monitor parses it into its own type or a JsonNode. Minor bump: every member is new and no existing behaviour changes, but a consumer's own type named ServiceRelease, brought into a file by a using directive alongside Solhigson.Framework.Web, is ambiguous there (CS0104) until the local copy is renamed or the use qualified or aliased. 10.26.0: an operator saves and resets declared settings by key and removes undeclared rows (Solhigson.Framework.Services, Solhigson.Framework.Infrastructure.ApplicationSettings). SolhigsonConfigurationService gains SaveDeclaredSettingAsync, ResetDeclaredSettingAsync and RemoveUndeclaredRowAsync, each answering the new SettingSaveResult: Outcome, the new enum SettingSaveOutcome (Saved, Unchanged, NotDeclared, NotEditable, ChangedElsewhere, Refused, Failed, NoDefault); Key; Message, which never quotes a value; PreviousShown and NewShown, the mask for a Secret, a row stored sensitive or a Personal value (a removal masks a row stored sensitive or under a secret-looking name, and gives any other raw); and CacheConfirmed. Each judges as ListDeclaredSettingsAsync does, against the configuration passed (pass ConfigurationWrapper.Configuration), so an editor reads the listing's Kind, Editable and Resettable and the calls hold to them: a save of a line not Editable answers NotEditable with its NotEditableReason, and a reset removes a row exactly when the listing's Resettable rule allows. A save (the key matched ignoring case and trailing white space) updates the one matched row or creates one under the key through UpdateApplicationSettingAsync or CreateApplicationSettingAsync and their rules; given the new SettingLoad (HadRow, RowValue) from a write-session listing, it answers ChangedElsewhere when the stored text changed since the load (a row holding the Default counting as none). A save of a Secret or of a row stored sensitive is last-write-wins, and a blank for either keeps the stored value, Refused when none is stored. A reset removes each matched row no read sees, and the row a read finds too when a Default or configuration answers without it; NoDefault when that row is its only one and neither answers. A removal takes only a row the listing names among UndeclaredRows, by exact name. A reset or a removal that would remove a row is Refused while the context holds an unsaved AppSetting edit. After Saved, CacheConfirmed is whether every instance's settings cache was told within two seconds; false, also inside an ambient System.Transactions scope, means other instances may serve the old value until their cache entry expires; null inside a transaction begun on the context, or with no cache provider. A Failed reset or removal whose SaveChanges EF did not wrap in its own transaction or savepoint may have removed its rows: do not commit after it. None checks who may edit or writes an audit row: the caller checks before it calls and writes the audit row from the result. Minor bump: every member is new, and two existing calls change their refusals: UpdateApplicationSettingAsync refuses a row the caller's context holds pending Added or Deleted; and each CreateApplicationSettingAsync and UpdateApplicationSettingAsync refusal that logs a Warning (a declaration's rule, the encryptor rule, the secret-name rule, an unsaved edit) now logs and answers the setting name, and the unsaved settings' names, with control and format characters, line and paragraph separators and lone surrogates removed and cut to 200 characters. 10.25.0: an Autofac host with OTLP log export on starts, the exporter refuses redirects, and the settings listing says what can be edited (Solhigson.Framework.Logging.Export, Solhigson.Framework.Infrastructure, Solhigson.Framework.Infrastructure.ApplicationSettings). OpenTelemetry.Exporter.OpenTelemetryProtocol and OpenTelemetry.Extensions.Hosting are pinned at 1.20.1, up from 1.15.3: from 10.18.0 to 10.24.0 a host built on Autofac with export on, an OTLP endpoint set over http/protobuf and an IHttpClientFactory registered failed at start with Autofac's DependencyResolutionException, and on 1.20.1 it builds and starts; a grpc host was not affected, since the SDK takes the factory's client only for http/protobuf. The exporter's clients refuse a redirect on every path: the SDK's own client, and the OtlpLogExporter, OtlpTraceExporter and OtlpMetricExporter clients a host's IHttpClientFactory gives it, whose primary handler has redirects turned off on that instance (a primary instance shared across clients has them off for every client sharing it; no other client of the host changes). An endpoint answering a redirect is an export failure, written as one SolhigsonLogExportFailed Warning through NLog when it is registered, so set the endpoint to its final address; a batch first exported while the host is disposed, to a redirecting endpoint, is lost with no Warning. A host's primary handler of a type the framework cannot make refuse redirects (one of another type, a DelegatingHandler around one included, or one that has already sent a request) is kept as the host set it, with its certificate checks, client certificates and proxy, and one Warning a process, SolhigsonLogExportRedirectsKept, names the client and the handler's type, never the endpoint or a header. SolhigsonAutofacModule registers ApiTraceMiddleware with PreserveExistingDefaults, so an Autofac host keeps an app's own ApiTraceMiddleware registration. The settings listing (SolhigsonConfigurationService.ListDeclaredSettingsAsync): each DeclaredSettingLine gains Kind, the new public enum SettingValueKind (Text, Switch, Int32, Int64, Decimal, Double, Duration, List), beside the Type text; HasRow and StoredSensitive; RowValue, the value of the row a read finds by the exact key, shown as Value is, also when configuration overrides it; Editable and NotEditableReason (read from configuration only, naming the source; a configuration value is set; several rows match; its row is under a name no read finds; secret and sensitive saves refused under the legacy encryptor); and Resettable and NotResettableReason. No reason quotes a value. A read of a Table setting takes the first row by id among those the database's comparison finds (ConfigurationWrapper), and the listing reports that same row. Minor bump: the package's OpenTelemetry floor rises to 1.20.1, so a consumer that pins any of OpenTelemetry, OpenTelemetry.Api, OpenTelemetry.Api.ProviderBuilderExtensions, OpenTelemetry.Exporter.OpenTelemetryProtocol or OpenTelemetry.Extensions.Hosting lower gets NU1605 at restore and raises those five to 1.20.1 or later; instrumentation packages version apart. Azure Monitor 1.3.0 is untested against 1.20.1. 10.24.0: the menu reads the admin kit needs (Solhigson.Framework.Dto, Solhigson.Framework.Identity). SolhigsonPermissionDto gains Enabled and Id, which the permission manager's menu reads (GetMenuPermissionsForRoleCachedAsync, each overload) fill from the stored permission, so a reader can drop a disabled parent's children and name a permission by its id. PermissionManager.RolesOf(ClaimsPrincipal?) answers the role read the [Permission] gate makes: every ClaimTypes.Role value that is not blank, in claim order, a role claimed twice listed twice, and none for no principal; VerifyPermissionAsync(permission, principal) and GetMenuPermissionsForRoleCachedAsync(principal) now read the roles through it, with the same answers as before. Minor bump: every member is new, and a consumer that serialises SolhigsonPermissionDto sees two more fields, Enabled and Id. 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.