dpvreony/whipstaff

Whipstaff is a comprehensive .NET framework library that provides reusable infrastructure for building enterprise applications across ASP.NET Core, WPF, and MAUI. It standardizes development patterns by offering CQRS-based controller scaffolding, Entity Framework Core utilities, and reactive UI helpers for WPF. The system also includes extensive tooling for command-line interfaces, distributed locking, and testing, alongside integrations for performance monitoring, security, and document generation.

42 changes.

This period focused on establishing the foundational infrastructure for the Whipstaff multi-project .NET solution, including core entity models, logging, and runtime utilities. It expanded the framework with specialized libraries for Entity Framework Core, Oracle, WPF, and ASP.NET Core, introducing CQRS-based controllers and application startup helpers. The work also included comprehensive unit and integration testing alongside example applications to validate the new architecture.

45 changes.

This period focused on significantly expanding the library's capabilities across multiple domains, including WPF interaction flows, Entity Framework utilities, and new packages for Playwright, Couchbase, and PDF handling. It also introduced robust testing infrastructure with fake contexts and command-line helpers, while ensuring backward compatibility through .NET Framework 4.8 shims and strict configuration validation.

39 changes.

This period focused on expanding the library's tooling and integration capabilities, notably introducing .NET CLI tools for Markdown generation and EF Core diagramming. Significant work was done to enhance Mermaid diagram rendering via an in-memory HTTP server and Playwright, while the Mediator library gained extensive support for CQRS auditing, EF Core, and distributed locking via Foundatio. Additional features included WPF culture overrides, ReactiveUI interaction helpers, and Aspire hosting extensions for security and health monitoring.

5 changes.

This period focused on enhancing the command-line interface with file system abstractions to improve testability and introducing a new .NET global tool for YAML template merging. Additionally, the ReactiveUI bootstrap module was updated to support a contract-based registration model, and the WPF sample application was expanded to include a CefSharp browser integration.

New factory classes (ArgumentFactory and OptionFactory) and extension methods (ArgumentResultExtensions) have been added to the CommandLine project to support parsing command-line inputs into abstracted file system types (IDirectoryInfo, IFileInfo, IDriveInfo) via the System.IO.Abstractions library. This allows CLI commands to accept file and directory paths that are decoupled from the concrete OS file system, facilitating easier testing and abstraction.

src/Whipstaff.CommandLine/FileSystemAbstractions · high confidence

The WPF sample application now includes a new feature demonstrating integration with the CefSharp embedded browser. This addition introduces a complete view-model-view structure, including an abstract base window to handle generic typing constraints, a XAML view embedding the ChromiumWebBrowser control, and a view model that exposes the current URL. The implementation uses ReactiveUI for activation and view-to-view-model binding to synchronize the browser's address with the view model's state.

src/Whipstaff.Example.WpfApp/Features/NativeControls · high confidence

The Whipstaff.Mediator.EntityFrameworkCore package now provides a set of abstract and concrete base classes to simplify CQRS command and query handling with Entity Framework Core. This includes AbstractListQueryHandler and AbstractViewQueryHandler for paginated and single-record queries, AbstractInsertUnkeyedEntityIntoInt32IdDbSetCommandHandler and AbstractInsertUnkeyedEntityIntoLongIdDbSetCommandHandler for entity insertion, and FuncFetchFromEntityFrameworkByInt32IdQueryHandler and FuncFetchFromEntityFrameworkByLongIdQueryHandler for flexible, function-based entity fetching.

src/Whipstaff.Mediator.EntityFrameworkCore · high confidence

The Whipstaff.Statiq package now includes a new Mermaid diagram pipeline that processes .mmd source files and renders them as SVG images. This feature utilizes a Playwright-based browser instance to generate diagrams, with the output saved to the configured output path.

src/Whipstaff.Statiq · high confidence

The Whipstaff.Oracle package now includes an OracleDataReaderHelper class that provides a ConsumeDataReader method. This allows users to efficiently bulk copy data from an IDataReader directly into an Oracle database using OracleBulkCopy, simplifying data ingestion workflows.

src/Whipstaff.Oracle · high confidence

Developers can now use ReactiveUI with MahApps Metro controls out of the box. This change introduces ReactiveMetroWindow and ReactiveSimpleChildWindow base classes that implement IViewFor, simplifying view-model binding for main windows and child dialogs. Additionally, MetroWindowExtensions provide helper methods to display standard Ok/Cancel, Ok-only, and Error-only notification dialogs, allowing applications to handle user interactions more consistently.

src/Whipstaff.Wpf.Mahapps · high confidence

The Whipstaff.Syncfusion.Pdf package now provides a SyncFusionPdfDocumentHelper that implements IPdfDocumentHelper, enabling users to apply owner passwords using AES-256 encryption, apply digital signatures with X.509 certificates (including optional long-term validation), and lock PDFs with randomly generated passwords. A readme has been added to document installation and usage, including a notice that a valid Syncfusion license is required to use the underlying library.

src/Whipstaff.Syncfusion.Pdf · high confidence

This change introduces a new interaction flow for displaying the Windows Print Dialog in WPF applications. It adds a \PrintDialogHandler\ that wraps the standard \System.Windows.Controls.PrintDialog\, allowing callers to configure specific options such as page ranges, selected pages, and print queues via a \PrintDialogRequest\ model. The handler returns a \PrintDialogResult\ indicating whether the user proceeded with printing or cancelled the operation, providing a structured way to handle print interactions within the application's interaction patterns.

src/Whipstaff.Wpf/InteractionFlows/PrintDialogInteraction · high confidence

The WPF example application now includes a custom App class that overrides the culture to 'en-GB' and initializes the UI by displaying a MainWindow with a MainViewModel. It uses the Whipstaff.Wpf framework for application lifecycle management and registers sample contract-based model registrations for ReactiveUI, providing a concrete example of how to integrate the library's bootstrapping and dependency injection features in a WPF application.

src/Whipstaff.Example.WpfApp · high confidence

The Whipstaff.EntityFramework library now provides extension methods for Entity Framework Core models that allow you to identify foreign keys configured with cascade delete behavior and remove it. By calling RemoveCascadeDeletionBehaviors on a ModelBuilder or a collection of entity types, all cascade delete relationships are changed to restrict, giving you finer control over referential integrity and preventing accidental deletion of related records.

src/Whipstaff.EntityFramework/CascadeDeletion · high confidence

New extension methods are added to the Whipstaff.ReactiveUI library to simplify handling interaction outputs. \ChainToOutputFuncAsync\ allows an \IInteractionContext\ to execute a function and set its result as the output, while \BindInteractionDirectToOutputFunc\ provides a convenient way to bind a ViewModel's interaction directly to a view using a function that produces the output, reducing boilerplate in view-model bindings.

src/Whipstaff.ReactiveUI/Interactions · high confidence

Users can now easily initialize a MockFileSystem with files embedded in an assembly by calling the new AddAllEmbeddedFilesFromNamespace extension method. This method scans the specified assembly for resources matching a given namespace and adds them to the virtual file system under a specified root path, simplifying the setup of test environments that require pre-loaded file data.

src/Whipstaff.TestableIO.System.IO.Abstractions.TestingHelpers · high confidence

The Swagger UI integration now supports Content Security Policy (CSP) nonces to allow inline scripts and styles in the Swagger index page. A new extension method, \ApplyNonceToSwaggerIndexStream\, modifies the Swagger UI HTML stream to inject request-specific nonces into \\<script\>\ and \\<style\>\ tags, ensuring compatibility with strict CSP headers provided by the \NetEscapades.AspNetCore.SecurityHeaders\ library. Additionally, new classes (\SwaggerClassMetaDataAttribute\, \SwaggerClassMetaDataDocumentFilter\, \SwaggerClassMetaDataOperationFilter\) were added to support compile-time linking of Swagger metadata, though the operation filter logic is currently a stub.

src/Whipstaff.AspNetCore/Features/Swagger · high confidence

The \src/Whipstaff.EntityFramework/SmokeTest\ directory now contains the core components for running automated smoke tests against Entity Framework Core DbContexts. This includes a \SmokeTestBackgroundWorker\ that executes as a hosted service, an \AbstractDbSetChecker\ base class for defining specific DbSet validation logic, and the associated logging infrastructure (\DbSetCheckerLogMessageActions\ and wrappers) to report test start, completion, and failure events.

src/Whipstaff.EntityFramework/SmokeTest · high confidence

A new OnceTrueLatch class has been introduced in the Whipstaff.Runtime.Bitwise namespace to provide a thread-safe mechanism for setting a flag exactly once. This component allows multiple sources to trigger an update flag without the maintenance overhead of manually managing boolean state, exposing a Value property to check the status and a Set method to trigger the latch.

src/Whipstaff.Runtime/Bitwise · high confidence

The Whipstaff.EntityFramework package now includes a CompiledQueryFactory that provides pre-compiled Entity Framework Core queries for common operations. This allows users to optimize performance by reusing compiled expressions for retrieving records by primary key (int or long) and filtering entities based on row version ranges (ulong).

src/Whipstaff.EntityFramework · high confidence

The application now includes the standard set of Razor view files for the Home and Shared areas, including the main layout (\_Layout.cshtml), error handling (Error.cshtml), privacy page (Privacy.cshtml), and view configuration files (\_ViewImports.cshtml, \_ViewStart.cshtml). This provides the default user interface structure and styling (Bootstrap/jQuery) for the WebMvcApp example.

src/Whipstaff.Example.WebMvcApp/Views · high confidence

The WebMvcApp now includes new controller implementations to demonstrate file download capabilities and basic navigation. ExcelController and PdfController extend AbstractFileDownloadController to handle XLSX and PDF file transfers respectively, utilizing the Mediator pattern for command handling and enforcing specific authorization policies (ViewSpreadSheet and View PDF). Additionally, HomeController was added to serve the main landing page, privacy policy, and error views, implementing authorization checks for the home page access.

src/Whipstaff.Example.WebMvcApp/Controllers · high confidence

The \src/Whipstaff.Testing/Cqrs\ area now includes a set of synthetic CQRS artifacts—specifically \FakeCrudAddCommand\, \FakeCrudDeleteCommand\, \FakeCrudUpdateCommand\, \FakeCrudListQuery\, and \FakeCrudViewQuery\—along with their corresponding factories (\FakeAuditableCommandFactory\, \FakeAuditableQueryFactory\) and response types. These classes implement the \AuditableCommand\ and \AuditableQuery\ base classes from \Whipstaff.AspNetCore\ and are designed to support unit and integration testing of the CQRS pipeline by providing standardized, mockable request and command structures.

src/Whipstaff.Testing/Cqrs · high confidence

A new LogDiagnosticListener has been introduced to capture and log ASP.NET Core middleware lifecycle events. This component listens for diagnostic events (MiddlewareStarting, MiddlewareException, MiddlewareFinished) and uses LoggerMessage.Define to efficiently log the middleware name, request path, and response status code, providing users with detailed visibility into the middleware pipeline execution.

src/Whipstaff.AspNetCore/Features/DiagnosticListener · high confidence

A new \ReflectedDbContextFactory\ class has been added to the \Whipstaff.EntityFramework.Reflection\ namespace to support diagram and documentation generation tools. This utility enables the runtime discovery and instantiation of \DbContext\ instances by reflecting over assemblies to locate either a specific \DbContext\ type or an \IDesignTimeDbContextFactory\ implementation, facilitating support scenarios where standard data access performance is not required.

src/Whipstaff.EntityFramework/Reflection · high confidence

New application startup helpers have been added to configure Mini Profiler for performance monitoring and IP-based rate limiting for request throttling. The Mini Profiler helper registers the profiler services and middleware, while the rate limiting helper configures in-memory storage for IP policies and counters, applying the rate-limiting middleware to the application pipeline.

src/Whipstaff.AspNetCore/Features/StartUp · high confidence

The \Whipstaff.Testing\ library now includes new components to support unit testing and examples: an \AbstractMockableHttpMessageHandler\ to simplify mocking HTTP requests, and a \FakeCrudController\ (along with supporting DTOs, log message actions, and Swagger metadata) that provides a ready-made, fully implemented CRUD API endpoint for use in tests and demonstrations.

src/Whipstaff.Testing · high confidence

The runtime now includes \IncrementOnlyInt\ and \IncrementOnlyLong\ structs in the \Whipstaff.Runtime.Counters\ namespace. These are lightweight, thread-safe wrappers that allow values to be incremented atomically using \Interlocked.Increment\ but cannot be decremented or set to arbitrary values, making them suitable for safe operation counting in concurrent scenarios.

src/Whipstaff.Runtime/Counters · high confidence

This change introduces a set of new helper classes in the APM feature area to streamline the configuration of application performance monitoring and health checks. Specifically, it adds \ApmApplicationStartHelper\ as a central entry point, \ApplicationInsightsApplicationStartHelper\ to register the Service Profiler and a custom \SignalRTelemetryProcessor\ (which prevents SignalR polling requests from skewing performance metrics), and \HealthChecksApplicationStartHelper\ to configure health check endpoints and the associated UI. Stubs for Exceptionless are also included but remain inactive.

src/Whipstaff.AspNetCore/Features/Apm · high confidence

The Swashbuckle integration now automatically documents standard HTTP error responses (4xx and 5xx) in the generated OpenAPI specification. This is achieved by introducing a new \ProblemDetailOperationFilter\ that applies to API operations, along with supporting extension methods to map error status codes to the \ProblemDetails\ schema. Users will see consistent error response definitions in their API documentation without needing to manually annotate each endpoint.

src/Whipstaff.AspNetCore/Swashbuckle · high confidence

Users can now perform batch character replacements on strings using a dictionary, including a built-in helper to convert Microsoft Word smart quotes and dashes into standard ASCII equivalents. This is exposed via the new \BatchStringReplacementHelper\ class and \StringCleansingDictionaryFactories\ in the \StringCleansing\ namespace.

src/Whipstaff.Runtime/StringCleansing · high confidence

The example web application now includes a feature to generate and download Excel spreadsheets. This change introduces a new query handler and request DTO within the Excel feature area, enabling users to request a spreadsheet file that is constructed using OpenXML libraries and returned as a downloadable stream.

src/Whipstaff.Example.WebMvcApp/Features/Excel · high confidence

Added a new extension method to IAssemblyResolveHelper that converts the AppDomain.AssemblyResolve event into a reactive Observable. This allows applications to handle assembly resolution failures using reactive patterns, providing a cleaner integration with the Rx runtime compared to traditional event handlers.

src/Whipstaff.Rx/Runtime · high confidence

The application now actively monitors for Group Policy refresh events on Windows. A new process manager subscribes to system-level user preference changing events and triggers a specific callback when a policy change is detected, allowing the application to react to administrative policy updates in real time.

src/Whipstaff.Windows/GroupPolicyMonitoring · high confidence

The Whipstaff.CsvHelper package now includes extension methods to configure ISO 8601 formatting for date and time values. Users can apply these options to CsvContext, CsvReader, and CsvWriter instances to ensure DateOnly values are parsed and written using the 'yyyy-MM-dd' format, while DateTime values use the standard ISO 8601 'O' (round-trip) format. This simplifies handling standardized date-time strings in CSV operations without manual configuration.

src/Whipstaff.CsvHelper · high confidence

The project has been initialized with core build infrastructure, including Directory.Build.props and Directory.Build.targets to standardize compilation settings, NuGet packaging, and analyzer rules. This setup integrates Gripe.QualityAssurancePack and Gripe.Analyzer (v2.1.3) for code quality enforcement, Nerdbank.GitVersioning (v3.10.94) for versioning, and Microsoft.SourceLink.GitHub (v10.0.401) for source link support. Additionally, a PublicApiGenerator global suppressions file was added to handle style warnings from third-party code inclusion, and the project is configured to target .NET 14.0 with nullable reference types enabled.

src · high confidence

The Whipstaff.Mediator.Foundatio package now provides reusable logic for integrating the Mediator.Abstractions library with the Foundatio framework. This update adds abstract command handlers that support database-then-queue workflows (persisting an entity via Entity Framework Core before enqueuing a message) and simple queue-only command handlers. It also introduces a distributed locking subsystem, including a background process manager for acquiring and renewing locks, configurable lock-loss behaviors (Retry, Complete, Error), and specific implementations for AppFabric, Azure Blob Storage, and Redlock. Additionally, queue processing capabilities are expanded with a recovery strategy interface and enumeration to handle message failures via Abandon, Dead Letter, Retry, Complete, or Requeue actions.

src/Whipstaff.Mediator.Foundatio · high confidence

Added the Whipstaff.WebHooksSite.Client library, providing a Refit-based HTTP client for interacting with the WebHooks.Site API. This enables users to programmatically create and delete webhook tokens, as well as retrieve, filter, and delete incoming webhook requests, supporting features like sorting and pagination for request lists.

src/Whipstaff.WebHooksSite.Client · high confidence

Adds a new example Web API application that serves as a demonstration of the Whipstaff framework. The app is bootstrapped using the Aspire \GetHostApplicationBuilder\ pattern and includes service defaults integration. It configures a minimal ASP.NET Core pipeline with Bearer token authentication, Swagger UI, and an in-memory SQLite database for testing. The setup registers fake Mediator and CRUD controller implementations to showcase basic API routing and authorization policies.

src/Whipstaff.Example.WebApiApp · high confidence

The Mermaid module now includes an in-memory HTTP server (MermaidHttpServerFactory) that serves Mermaid JS assets from embedded resources. This server supports Gzip-compressed static files via a custom EmbeddedGzipFileProvider and EmbeddedResourceGzipFileInfo, automatically handling decompression and setting correct Content-Encoding headers. It exposes an /index.html endpoint that initializes Mermaid and exposes a window.renderMermaid function for rendering diagrams, and prevents external HostingStartup configurations to ensure isolation.

src/Whipstaff.Mermaid/HttpServer · high confidence

Adds the foundational structure for the Whipstaff Example Web MVC App, including the entry point (Program.cs), startup configuration (Startup.cs), and environment settings (appsettings.json). This scaffolding establishes an in-memory SQLite database for testing, configures cookie-based authentication, registers a fake mediator for command/query handling, and sets up basic MVC routing and static file serving, providing a runnable baseline for the example application.

src/Whipstaff.Example.WebMvcApp · high confidence

A new .NET global tool, whipstaff-yamltemplating, is now available to merge a template YAML file with a content YAML file, writing the result to an output path. The tool supports two modes: standard merging, where content values take precedence, and path injection, which allows injecting a template fragment at a specific dot-notation path within the content file. Users can install the tool via \dotnet tool install --global whipstaff-yamltemplating\ and use options like \--template\, \--content\, \--output\, and the optional \--path\ to control the operation.

src/Whipstaff.YamlTemplating.DotNetTool · high confidence

The Whipstaff.Mediator library now provides new interfaces (IAuditableCommand, IAuditableQuery) and corresponding factory interfaces (IAuditableCommandFactory, IAuditableQueryFactory) to support CQRS operations that require auditing via ClaimsPrincipal. Additionally, it introduces a set of registration handler interfaces and a MediatorHelpers class that enables registering command, query, and notification handlers with .NET Core DI using explicit types, avoiding the need for reflection.

src/Whipstaff.Mediator · high confidence

This change adds the foundational interfaces \IPasswordGenerator\ and \IPdfDocumentHelper\ to the core library. The \IPasswordGenerator\ interface defines the contract for generating passwords, while \IPdfDocumentHelper\ establishes the API for PDF manipulation, including applying owner passwords, applying digital signatures with certificate details, and securing documents with read-only restrictions using a random password. These interfaces enable the application to abstract specific PDF library implementations and password generation logic.

src/Whipstaff.Core/PasswordGeneration, src/Whipstaff.Core/Pdf · high confidence

The Whipstaff.Markdig library now includes a new MermaidJS extension that allows users to render Mermaid diagrams directly within Markdown content. This feature introduces a block parser for fenced code blocks tagged with 'mermaid', which utilizes a Playwright browser session to generate the diagrams. The extension supports two output modes: PNG (embedded as base64 images) and SVG (embedded as HTML divs), configurable via the MarkdownJsExtensionSettings.

src/Whipstaff.Markdig · high confidence

Two new .NET command-line tools are now available. The \Whipstaff.CommandLine.MarkdownGen.DotNetTool\ generates Markdown help files from assemblies using System.CommandLine, accepting \--assembly-path\ and \--output-file-path\ arguments. The \Whipstaff.EntityFramework.Diagram.DotNetTool\ creates Entity Framework Core diagrams (DGML) from a DbContext, requiring \--assembly-path\, \--db-context-name\, \--output-file-path\, and \--diagram-type\ arguments. Both tools handle assembly loading and file system operations via dedicated command-line handlers and logging wrappers.

src/Whipstaff.CommandLine.MarkdownGen.DotNetTool, src/Whipstaff.EntityFramework.Diagram.DotNetTool · high confidence

This change introduces two new capabilities in the Windows client. First, it adds logic to check Active Directory account states, exposing a \UserAccountState\ enum and a \UserAccountHelpers\ class that can determine if an account is locked, if the password or account has expired, or if they are approaching expiration based on a configurable threshold. Second, it adds a \SpeechAnnouncements\ class in the SpeechSynthesis namespace that wraps the .NET \SpeechSynthesizer\ to provide text-to-speech announcements and subscribe to various speech events (such as bookmarks, progress, and completion) via reactive observers.

src/Whipstaff.Windows/ActiveDirectory · high confidence

This update adds new hosting extensions to the Whipstaff.Aspire.Hosting package. Developers can now provision a Zed Attack Proxy (ZAP) container for security testing using AddZedAttackProxyContainer or AddZedAttackProxyContainerAsDaemon, and integrate the HealthChecksUI dashboard to monitor application health via AddHealthChecksUi and WithReference. Additionally, convenience extension methods like WaitForCompletionWithReference and WaitForWithReference are provided to simplify resource dependency management.

src/Whipstaff.Aspire.Hosting · high confidence

This release introduces two new capabilities. First, the Whipstaff.Couchbase package now provides a distributed locking implementation via \CouchbaseLockProvider\ and \CouchbaseLock\, allowing applications to acquire, renew, and release exclusive locks backed by Couchbase mutexes, complete with structured logging for lock lifecycle events. Second, the new Whipstaff.NodaTime package adds a \LocalDateExtensions\ helper that formats \LocalDate\ instances into a standard yyyy-MM-dd string.

src/Whipstaff.Couchbase · high confidence

This release introduces a new set of extension methods in the Whipstaff.EntityFramework library to simplify common Entity Framework Core patterns. Developers can now use \ActOnDbContextAndSaveChangesAsync\ on both \DbContext\ and \IDbContextFactory\ instances to execute an action and persist changes in a single call, automatically handling context disposal for factory-based scenarios. The library also adds \GetOrAddAsync\ and \GetOrAddByIdAsync\ methods to retrieve an existing entity or create and save a new one if it is missing, supporting integer, long, and GUID identifiers. Additionally, \DbSetExtensions\ provide utilities for retrieving maximum IDs or row versions, and filtering rows by ID or row version ranges, while \QueryableExtensions\ adds automatic query tagging with caller information for better tracing. Finally, \ServiceCollectionExtensions\ offers a helper to register a DbContext alongside a model creator in the dependency injection container.

src/Whipstaff.EntityFramework/Extensions · high confidence

The Whipstaff.Healthchecks.EntityFramework package now includes a new \FetchMaxRowVersionFromTableHealthCheck\ component, allowing users to monitor database health by verifying the presence of row version data in specified tables. This generic health check leverages EF Core to fetch the maximum row version for a given entity, reporting a degraded status if no version is found, and is accompanied by updated package documentation.

src/Whipstaff.Healthchecks.EntityFramework · high confidence

Added a suite of classes in the \src/Whipstaff.Testing/EntityFramework\ namespace to simplify testing with Entity Framework Core. This includes \AbstractDbContextFactory\ as a base for creating \DbContext\ instances backed by an in-memory SQLite connection, along with concrete implementations \FakeDbContextFactory\ and \FakeIdentityDbContextFactory\ for standard and Identity-based contexts. The package also introduces \FakeDbContext\ and \FakeIdentityDbContext\ as test-specific context classes that accept a model creator function, and \SqliteFakeDbContextModelCreator\ to handle SQLite-specific model configuration, such as converting \DateTimeOffset\ properties to \long\ and setting default values for \RowVersion\ properties.

src/Whipstaff.Testing/EntityFramework · high confidence

The runtime now includes new helper classes in the \Whipstaff.Runtime.Http\ namespace to simplify HTTP client configuration. Users can create an \HttpClientHandler\ pre-configured with a client X.509 certificate via \HttpClientHandlerFactory\, ensuring the certificate's private key is available before binding. Additionally, \HttpRequestMessageExtensions\ provides convenient methods to add single-value or multi-value header dictionaries to HTTP requests in one step.

src/Whipstaff.Runtime/Http · high confidence

The Whipstaff.Nuget library now includes utilities to search for NuGet packages by author. This introduces an AuthorUsernameAsStringModel for validating author names, a NugetForwardingToNetCoreLogger to bridge NuGet's logging with .NET Core's ILogger, and extension methods on PackageSource, SourceRepository, and PackageSearchResource that expose GetPackagesForAuthorAsync for retrieving package lists or specific metadata for a given author.

src/Whipstaff.Nuget · high confidence

The \Whipstaff.Rx.Observables\ library now includes new extension methods to simplify reactive data manipulation. Developers can split a single observable stream into two to seven separate streams using the new \Split\ methods, which apply different selectors to the upstream data. Additionally, new \AllTrue\ and \AllFalse\ methods allow for easy checking of boolean flags within tuples (supporting 2 to 8 elements), which is particularly useful when working with \CombineLatest\ results, along with a \CountThatAreTrue\ method to count true values in a boolean sequence.

src/Whipstaff.Rx/Observables · high confidence

The Whipstaff.OpenXml package now includes helper classes and extension methods for working with Excel spreadsheets. Users can create workbook documents with multiple worksheets using the SpreadsheetDocumentHelper, which accepts a collection of sheet actors to define sheet content. Additionally, WorksheetPartExtensions provide convenient methods to insert cells into worksheets with various data types (strings, booleans, numbers, and dates) by specifying column names and row indices.

src/Whipstaff.OpenXml · high confidence

Added a new \User32Helpers\ class in the \src/Whipstaff.Windows/PInvoke\ namespace that wraps specific User32.dll native methods. This provides a \FlashWindowEx\ helper to flash a window without changing its active state, and a \SetWindowDisplayAffinity\ helper to control where a window's content can be displayed (e.g., preventing screen capture). These utilities enable applications to implement standard Windows window behaviors and security features via P/Invoke.

src/Whipstaff.Windows/PInvoke · high confidence

The new \Whipstaff.Playwright\ package provides a suite of utilities for browser automation and analysis. It includes a \WebCrawler\ for traversing websites and collecting page data, and \PageExtensions\ that add capabilities such as analyzing undefined CSS classes, checking image alt attributes for accessibility, and exporting pages to MHTML format. The package also features an \InstallationHelper\ to streamline Playwright browser installation, helper models for crawl results, and extension methods to convert Playwright requests and routes into standard .NET \HttpRequestMessage\ objects for easier integration with existing HTTP clients.

src/Whipstaff.Playwright · high confidence

The \src/Whipstaff.ReactiveUI/ReactiveCommands\ area introduces a suite of factory classes to simplify complex command patterns. \CommonExecutionPredicateReactiveCommandFactory\ allows creating 2, 3, or 4 commands that share a common execution predicate (with optional per-command overrides), useful for synchronizing button states based on upstream operations. \MutuallyExclusiveReactiveCommandsFactory\ provides an exclusive lock mechanism to ensure only one command in a set executes at a time, returning a \NobodyIsExecuting\ observable and the created commands. \ReactiveCommandFactory\ adds \CreateFromTaskToProperty\ helpers that automatically map task results to properties and handle exception subscriptions. These are supported by \ReactiveCommandFactoryArgument\ for standardized command configuration and \ReactiveCommandFromTaskWithSubscriptionsResult\ for structured return values.

src/Whipstaff.ReactiveUI/ReactiveCommands · high confidence

Added several new WPF controls to the library: a \GridLayout\ that extends the standard Grid to automatically manage spacing between children via a \ChildMargin\ property; a \SafeAreaOverlayControl\ that renders a visual guide to help identify safe areas within the window client area; an \EInkOverlay\ that applies a grayscale, e-ink-style refresh animation over its content; and supporting base classes \ReactiveContentControl\ and \AbstractNoViewModelReactiveContentControl\ to simplify ReactiveUI view integration.

src/Whipstaff.Wpf/Controls · high confidence

The application now includes dedicated interaction flows for Windows Open and Save file dialogs. This change introduces request and result DTOs (OpenFileDialogRequest/Result and SaveFileDialogRequest/Result) along with a shared abstract base for common dialog settings. Handlers in the OpenFileDialogInteraction and SaveFileDialogInteraction folders wrap the standard Microsoft.Win32 dialogs, allowing callers to configure options like filters, initial directories, and multi-select, and receive structured results indicating whether the user proceeded or cancelled.

src/Whipstaff.Wpf/InteractionFlows/OpenFileDialogInteraction · high confidence

This update adds new extension methods and interfaces to the WPF UI layer to support advanced window management and clipboard interactions. Developers can now bind a window's display affinity (controlling where its content is rendered, such as preventing screen capture) by implementing the new IWindowDisplayAffinity interface and using the BindSetWindowDisplayAffinityInteraction extension. Additionally, new SubscribeKeyboardCopyAsText and SubscribeKeyboardCopyAsFormattedText methods allow windows to easily handle standard copy keyboard shortcuts (Ctrl+C, Insert) to place text onto the clipboard, which is particularly useful for error dialogs or log viewers.

src/Whipstaff.Wpf/UiElements · high confidence

This change introduces a new set of WPF-specific interaction flows and utilities within the \InteractionFlows\ namespace. It adds support for opening file and folder dialogs via \Interactions\ and \InteractionRegistrations\, including specific handlers for folder selection. Additionally, it provides \ReactiveCommandFactory\ for shell execution commands (such as opening log folders) and defines interaction request models (\ErrorOnly\, \OkOnly\, \OkCancel\) to standardize user prompts. A \SolidColorBrushFactory\ is also added to assist with view model-to-view color conversions.

src/Whipstaff.Wpf/InteractionFlows · high confidence

Added extension methods to the WPF library to enhance window management and color handling. Users can now flash a WPF window to draw attention without changing its active state, and set display affinity flags (such as preventing screen capture) on top-level windows via Win32 interop. Additionally, a utility method is provided to determine if a Windows UI color is considered light, useful for dynamic theme or contrast calculations.

src/Whipstaff.Wpf/Extensions · high confidence

Added extension methods for X.509 certificate management in the cryptography runtime. Users can now verify that a certificate has a private key via \X509Certificate2Extensions.EnsurePrivateKey\, and query certificate stores for expired or expiring certificates using \X509StoreExtensions.GetExpiredCertificateCollection\ and \GetExpiringCertificateCollection\. A generic selector method \GetCertificateCollectionViaSelector\ is also provided for custom filtering logic.

src/Whipstaff.Runtime/Cryptography · high confidence

The application now includes a new XML Viewer feature, implemented in the MainWindow feature area. This new window allows users to input an ID and fetch XML data, displaying the result in a read-only text box. The implementation integrates Windows Win32 window display affinity flags (via IWindowDisplayAffinity) to control window behavior and includes an EInkOverlay control, preparing the UI for E-Ink emulator support.

src/Whipstaff.Example.WpfApp/Features/MainWindow · high confidence

This change introduces a new application startup layer for the ASP.NET Core web app core. It adds a \WebApplicationFactory\ helper that bootstraps the application using a strongly-typed \IWhipstaffWebAppStartup\ interface, allowing developers to configure Aspire service defaults, logging, services, and the web application pipeline in a structured way. The package also provides extension methods for endpoint routing, including a \DoCrudMapControllerRoute\ helper to automatically map standard CRUD HTTP verbs to controller actions, and defines configuration interfaces (\IConfigureApplication\, \IConfigureService\) and an \MvcServiceMode\ enum to control MVC service registration.

src/Whipstaff.AspNetCore/Features/ApplicationStartup · high confidence

The Whipstaff.CommandLine library now provides a suite of helpers for building and validating command-line interfaces. It introduces an AbstractCommandLineHandler to centralize exception logging and reduce call-stack noise, alongside extension methods for System.CommandLine that allow developers to easily enforce mutually exclusive options and validate file arguments against specific extensions or existence checks. Additionally, a MarkdownDocumentationGenerator is included to automatically produce documentation tables for command arguments and options.

src/Whipstaff.CommandLine · high confidence

The Whipstaff.ReactiveUI.Bootstrap module now introduces a new contract-based registration system, adding interfaces like IContractBasedRegistration and concrete implementations for registering view models and views as constants, singletons, or transient instances. This change aligns the library with ReactiveUI v23's builder pattern, allowing developers to configure dependency injection and view-model wiring through a more structured, extensible API.

src/Whipstaff.ReactiveUI/Bootstrap · high confidence

Added \ControllerBaseExtensions\ providing \GetAddActionAsync\ and \GetDeleteActionAsync\ helper methods. These extensions standardize the implementation of CQRS-based API endpoints by handling authorization checks (both method-level and resource-level for deletes), model state validation, logging, and mediator command dispatch, allowing controllers to delegate common boilerplate logic to these reusable utilities.

src/Whipstaff.AspNetCore/Extensions · high confidence

A new \HostRunner\ class has been added to the \Whipstaff.CommandLine.Hosting\ namespace, providing two static methods to execute command-line jobs with integrated dependency injection. \RunJobWithFullDependencyInjectionAsync\ allows callers to register additional services via a callback before building a service provider and resolving the command handler, while \RunSimpleCliJobAsync\ supports simpler scenarios by accepting a factory function to create the handler with injected \IFileSystem\ and \ILogger\ dependencies. Both methods handle logging setup (defaulting to Information level with console output) and error handling, returning an integer exit code.

src/Whipstaff.CommandLine/Hosting · high confidence

The core entity model now includes a set of new interfaces to standardize how entities expose their identifiers and metadata. This adds generic and specific ID interfaces (IId, IGuidId, IIntId, ILongId) and user ID variants (IUserId, IGuidUserId, IIntUserId, ILongUserId) to support different identifier types. It also introduces metadata interfaces for creation and modification tracking (ICreateable, IModifiable), descriptive fields (IDescribable, INameable, ITitle), and a concurrency row version (ILongRowVersion). Additionally, type-safe wrapper interfaces (IEntityAsType and its specific variants like IEntityAsInt, IEntityAsString) are added to encapsulate built-in types, and specific interfaces for GB post codes (IGbPostCode, IGbPostCodeAsString) are provided.

src/Whipstaff.Core/Entities · high confidence

The FileTransfer area now includes an abstract base controller (AbstractFileDownloadController) and a supporting data model (FileNameAndStreamModel). The controller provides a standardized way to serve files with specific MIME types, handling authorization, logging, and returning the file stream as an HTTP response. The model encapsulates the file name and stream for in-memory file manipulation. This change introduces new infrastructure for file downloads rather than modifying existing behavior.

src/Whipstaff.AspNetCore/FileTransfer · high confidence

The \Whipstaff.AspNetCore\ package now includes abstract base controllers to simplify building CQRS-based APIs and MVC applications. \AbstractCrudApiController\ provides a generic foundation for full CRUD operations (List, View, Add, Update, Delete) with built-in authorization and logging, while \AbstractQueryOnlyApiController\ and \AbstractQueryOnlyMvcController\ offer specialized bases for read-only scenarios. These classes rely on the \Whipstaff.Mediator\ library to handle message dispatching, allowing developers to inherit from them to quickly scaffold typed controllers without repeating boilerplate code.

src/Whipstaff.AspNetCore · high confidence

The Whipstaff.EntityFramework.Relational package now includes a new ModelBuilderHelpers class that provides utilities to automatically convert DateTimeOffset properties to long (Unix time milliseconds) when using SQLite. This allows developers to retain DateTimeOffset precision in their models while using SQLite for testing, working around SQLite's lack of native DateTimeOffset support by storing values as integers instead.

src/Whipstaff.Entityframework.Relational · high confidence

A new interface, IWrapLogMessageActionUnhandledException, has been added to the logging subsystem to define a contract for handling unhandled exceptions. This interface introduces an UnhandledException method, allowing the application to standardize how critical errors are captured and processed within the message action wrapper layer.

src/Whipstaff.Core/Logging/MessageActionWrappers · high confidence

The \src/Whipstaff.Runtime/JobSequencing\ directory now includes a set of base classes and functional helpers to simplify asynchronous iteration over collections. \AbstractActOnCollectionHelper\ provides an abstract base for defining actions on collections, with specialized implementations \AbstractAbstractActOnDataReader\ and \AbstractAbstractActOnEnumerable\ for \IDataReader\ and generic \IEnumerable\<T\>\ respectively. Concrete functional wrappers (\FuncAbstractAbstractActOnDataReader\ and \FuncAbstractAbstractActOnEnumerable\<T\>\) allow users to pass \Func\ delegates to handle individual items or empty collections, while \JobSequenceByRange\ offers static factory methods to generate start/end index sequences for byte, short, int, and long types.

src/Whipstaff.Runtime/JobSequencing · high confidence

Added a new ASP.NET Core middleware that validates the presence and correctness of X-Forwarded-For, X-Forwarded-Host, and X-Forwarded-Proto headers on incoming requests. If these headers are missing or if X-Forwarded-Proto is not set to 'https', the middleware returns a specific HTTP error (597–599) with the message 'Load Balancer Configuration Issue.' This ensures that requests are properly routed through a load balancer and that the connection protocol is secure before reaching the application.

src/Whipstaff.AspNetCore/Features/RequireForwardedForHeader · high confidence

A new ASP.NET Core middleware has been introduced that automatically appends the server's hostname (or a custom token) and the application version to every HTTP response via the X-HOSTNAME and X-APPVERSION headers. This feature aids in diagnostics, support, and testing by making server identity and versioning visible to clients, with the option to hide the actual machine name by providing a custom hostname value.

src/Whipstaff.AspNetCore/Features/AddServerDetailsToResponseHeader · high confidence

The library now includes an IModelCreator interface to allow custom model configuration for database contexts, and a RowVersionSaveChangesInterceptor that automatically sets row version timestamps on entities implementing ILongRowVersion during save operations, enabling concurrency token support for providers like SQLite.

src/Whipstaff.EntityFramework/ModelCreation, src/Whipstaff.EntityFramework/RowVersionSaving · high confidence

Developers can now wrap a BehaviorSubject in a read-only interface (IReadOnlyObservable) to expose its current value and subscription capabilities while preventing external code from pushing new values, errors, or completion signals. This is achieved via a new extension method ToReadOnlyObservable and the accompanying ReadOnlyBehaviorObservable class, which hides the subject's mutation methods.

src/Whipstaff.Rx/ReadOnlyObservables · high confidence

The Whipstaff.Runtime package now includes a comprehensive set of new exception classes in the Whipstaff.Runtime.Exceptions namespace to provide more specific error handling. These include NumberTooHigh and NumberTooLow exceptions for various CLR types (char, DateTime, decimal, double, single, int16, int32, int64, and uint8), as well as StringTooLong, StringTooShort, FailedToGetResourceStream, and UnexpectedFileFormat exceptions. This allows applications to catch and handle specific validation and resource-loading failures more precisely than using generic exceptions.

src/Whipstaff.Runtime/Exceptions · high confidence

This release adds a suite of new extension methods and helper classes to the runtime library to simplify common development tasks. Developers can now load strings or byte arrays directly from embedded assembly resources, check if characters or strings are hexadecimal, and filter dictionary keys using predicates. String manipulation is enhanced with methods to replace characters using dictionaries (including support for multi-character replacements and removal) and to replace Microsoft Word smart quotes with ASCII equivalents. Additional utilities include a helper to conditionally add items to lists if a specific type is not already present, a method to convert streams to byte arrays, and helpers to determine if types have parameterless constructors or are closed classes. The release also introduces temporary file management utilities for executing actions with temporary files and math helpers to find the item with the maximum value among multiple arguments.

src/Whipstaff.Runtime/Extensions · high confidence

The \src/Whipstaff.Core/Logging\ area now includes a comprehensive set of new types to support structured, high-performance logging and safer async execution. \TaskHelpers\ provides \DefaultIfExceptionAsync\ extension methods that catch exceptions in async delegates and return a default value while logging a warning. The logging framework is enhanced with \LogExtensions\ for convenient trace, warning, error, and information logging (including lazy evaluation via \Func\<string\>\), \LoggerMessageFactory\ for generating pre-compiled \LoggerMessage\ delegates to reduce runtime allocation, and \LogValuesFormatter\/\ValueStringBuilder\ for efficient format string handling. Additionally, \AbstractLogMessageActionsWrapper\ and related interfaces (\ILogMessageActions\, \ILogMessageActionsWrapper\) provide a pattern for tightly coupling log message actions with loggers, while \EventIdFactory\ and \WhipstaffEventIdFactory\ centralize the creation of typed event IDs for consistent log categorization.

src/Whipstaff.Core/Logging · high confidence

Added new fake Entity Framework DbSet classes (AbstractDbSet, FakeAddAuditDbSet, FakeAddPostProcessAuditDbSet, FakeAddPreProcessAuditDbSet, and FakeLongIdTableDbSet) to the testing library. These entities implement the ILongRowVersion interface, utilizing a ulong type for the RowVersion property to support optimistic concurrency testing scenarios.

src/Whipstaff.Testing/EntityFramework/DbSets · high confidence

Added a set of helper classes and records in the \Whipstaff.Testing.CommandLine\ namespace to facilitate unit testing of command-line interfaces. This includes \FakeCommandAndBinderFactory\, \FakeCommandLineArgModel\, \FakeCommandLineArgModelBinder\, and \FakeCommandLineHandler\ to simulate command execution and argument binding, along with \FakeCommandLineHandlerLogMessageActionsWrapper\ for logging simulation and \XUnitTestHelpers\ to configure test console output and error streams.

src/Whipstaff.Testing/CommandLine · high confidence

The repository has been initialized with the Whipstaff multi-project .NET solution, including a comprehensive README detailing the project layout, build instructions, and available libraries (ASP.NET Core, WPF, MAUI, Blazor, etc.). The setup includes essential configuration files such as global.json (targeting .NET SDK 10.0.401), version.json (version 9.2), .editorconfig (C\# coding standards), .gitattributes, and nuget.config. Additionally, standard repository governance files like LICENSE (MIT), CODE\_OF\_CONDUCT.md, CONTRIBUTING.md, and citation.cff have been added.

(repo-wide) · high confidence

The runtime now includes a host override mechanism that allows HTTP client requests to be redirected to different hosts at runtime without modifying the application's system-wide hosts file. This is implemented via the new \HostOverridableHttpClientHandler\, which intercepts outgoing HTTP requests and rewrites the target hostname based on a provided \IHostOverride\ implementation. The \InMemoryHostOverride\ class provides a default in-memory mapping store for these overrides, enabling scenarios where services need to route traffic internally or to local endpoints without external network calls.

src/Whipstaff.Runtime/HostOverride · high confidence

The WPF application now includes a dedicated Jump List helper that manages Windows taskbar jump lists with full observability. This change introduces a helper class that subscribes to user-initiated events, such as items being removed or rejected, and wraps standard jump list operations (adding recent paths/tasks, clearing the list) with structured logging. Users will benefit from improved traceability of jump list interactions and robust handling of user modifications to the application's pinned or recent items.

src/Whipstaff.Wpf/JumpLists · high confidence

The logging feature now provides \ICrudControllerLogMessageActions\ and \IQueryOnlyControllerLogMessageActions\ interfaces to define log message actions for API events. These interfaces allow developers to move log message instantiation outside of controllers, adhering to performance recommendations by ensuring the define call is executed only once. The CRUD interface covers Add, Delete, and Update events, while the Query-only interface covers List and View events.

src/Whipstaff.AspNetCore/Features/Logging · high confidence

The SecurityCenter module now exposes enumerations for Windows Security Center provider types (such as Firewall, Antivirus, and AntiSpyware) and their health states. It provides helper methods to query the current health status of these providers via the Windows API and offers reactive observables that periodically poll and emit health updates, enabling applications to monitor the status of system security components.

src/Whipstaff.Windows/SecurityCenter · high confidence

Added shim implementations for C\# 10+ features (CallerArgumentExpressionAttribute, IsExternalInit) and ArgumentNullException.ThrowIfNull to enable modern language constructs on .NET Framework 4.8. These additions allow the shared codebase to use advanced parameter validation and record syntax while maintaining backward compatibility with older target frameworks.

_src/\shared · high confidence

The Playwright integration for Mermaid diagram rendering has been restructured to improve performance and reliability. The new implementation utilizes an in-memory HTTP server to serve diagram content, allowing the renderer to interact with the browser via API calls rather than relying on page load and DOM manipulation. This change introduces a new \PlaywrightRenderer\ and \PlaywrightRendererBrowserInstance\ architecture that manages browser sessions more efficiently, reducing initialization overhead and fixing issues with detached SVGs during screenshot capture on Linux Chrome.

src/Whipstaff.Mermaid/Playwright · high confidence

The Whipstaff.Core library now provides extension methods to register configuration options that fail fast on unknown configuration keys. By setting \ErrorOnUnknownConfiguration = true\ during binding, any configuration property not present in the source will cause the application to fail at startup rather than silently ignoring the mismatch. This ensures that configuration sections are strictly validated against their expected schema, reducing the risk of misconfiguration errors going unnoticed.

src/Whipstaff.Core/Configuration, src/Whipstaff.Testing/Configuration · high confidence

This change introduces a new culture initialization mechanism for WPF applications within the Whipstaff framework. Developers can now explicitly set the application's culture (affecting date, number formatting, and resource lookups) by overriding the \GetCultureName\ method in \AbstractWpfApplication\. The framework applies this culture early in the startup process via \CultureHelpers\, ensuring consistent localization before WPF components initialize. This is a behavioral change that allows for deterministic culture handling in WPF apps, separate from the system default.

src/Whipstaff.Wpf · high confidence

A new in-memory fake implementation of IFeatureUsageTrackingSession has been added to the testing library. This allows tests to simulate feature usage tracking without requiring a real backend or complex setup, supporting the fix for threading issues in APM tests.

src/Whipstaff.Testing/Splat · high confidence

The WPF application host core now exposes assembly resolution failure handling through a new \IAssemblyResolveHelper\ interface and a \NullAssemblyResolveHelper\ implementation. This allows the application to properly handle \AppDomain.AssemblyResolve\ events, preventing crashes when assemblies cannot be found, while providing a no-op implementation for scenarios where custom resolution logic is not needed.

src/Whipstaff.Runtime/AppDomains · high confidence

Added argument null exception test sources for runtime extensions; Added integration tests for web application startup and crawling; Added test sources for CsvHelper extension argument validation; Added test sources for strict configuration binding argument validation; Added unit tests and test infrastructure for Oracle, WPF, and mocking; Added unit tests for ArgumentFactory and OptionFactory null-argument handling; Added unit tests for AssemblyResolverExtensions.ToObservable argument validation; Added unit tests for CascadeDeletionExtensions; Added unit tests for CommandLineJobLogMessageActions; Added unit tests for CsvHelper ISO 8601 date conversion extensions; Added unit tests for Entity Framework Core Mediator query handler; Added unit tests for Entity Framework extension methods; Added unit tests for Entity Framework health check; Added unit tests for FuncDefaultIfExceptionExtensions; Added unit tests for IncrementOnlyInt and IncrementOnlyLong counters; Added unit tests for MarkdownGen DotNetTool command-line components; Added unit tests for MediatR helper registration; Added unit tests for MediatR request handlers and compiled query factories; Added unit tests for Mermaid JS rendering; Added unit tests for MockFileSystemExtensions; Added unit tests for Playwright Mermaid renderer components; Added unit tests for Playwright helper components; Added unit tests for ReactiveUI command factories; Added unit tests for ReactiveUI interaction extensions; Added unit tests for RequireForwardedForHeaderMiddleware; Added unit tests for Rx observable extensions and splitting helpers; Added unit tests for SQLite DateTimeOffset ordering; Added unit tests for TemporaryFileHelpers argument validation; Added unit tests for TypeDescriptorHelpers; Added unit tests for application startup validation; Added unit tests for command-line argument validation and reflection helpers; Added unit tests for logging extensions and message factory; Added unit tests for runtime extension methods and string cleansing helpers; Added unit tests for spreadsheet document helper and NodaTime date extensions; Added unit tests for strict configuration binding; Added unit tests for the CRUD controller; Added unit tests for the CommandLine module.

This release updates dependencies across 114 manifests, including major version bumps for Syncfusion (e.g., 34.2.8), MudBlazor (9.10.0), and Splat (v21), alongside numerous patch and minor updates for packages such as Mermaid, Audit.NET, and Microsoft.Data.SqlClient.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 53 → 52 (-1.0)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 68 → 63 (-5.5)
• Architecture 99 → 99 (+0.1)
• Maturity 69 → 68 (-1.1)
• Readiness 57 → 56 (-1.1)
• Security 39 → 39 (+0.1)
• Accessibility 80 → 80 (+0.0)
• Performance 81 → 81 (+0.0)

• BarePragmaDisable (src/Whipstaff.Mermaid/Playwright/PlaywrightRendererBrowserInstance.cs)
• BarePragmaDisable (src/Whipstaff.ReactiveUI/ReactiveCommands/ReactiveCommandFactory.cs)
• BarePragmaDisable (src/Whipstaff.UnitTests/Controllers/CrudControllerTests.cs)
• BarePragmaDisable (src/Whipstaff.UnitTests/Controllers/CrudControllerTests.cs)
• Bounded contexts not declared
• Build status unknown
• Duplicated block (11 lines × 2) (src/Whipstaff.Example.WebApiApp/Startup.cs)
• Duplicated block (30 lines × 2) (src/Whipstaff.Runtime/Maths/MathHelpers.cs)
• Duplicated block (30 lines × 2) (src/Whipstaff.Runtime/Maths/MathHelpers.cs)
• Duplicated block (8 lines × 2) (src/Whipstaff.Runtime/Maths/MathHelpers.cs)
• Duplicated block (8 lines × 2) (src/Whipstaff.Runtime/Maths/MathHelpers.cs)
• Duplicated block (9 lines × 5) (src/Whipstaff.Core/Logging/LoggerMessageFactory.cs)
• Inconsistent naming and return types for list retrieval operations. Some methods return ActionResult<T> (API style) while others return IActionResult (MVC/General style). Additionally, the naming convention varies between GetList, GetApiList, and GetListActionFlexible, creating confusion about which method to use in different contexts.
• Inconsistent naming and return types for view/retrieval operations. Similar to list operations, there is a mix of GetView, GetViewAction, and GetApiViewAction. Return types alternate between ActionResult<T> and IActionResult.
• Inconsistent naming for create/add operations. The abstract controller uses AddAsync while the extension methods use GetAddActionAsync and GetApiAddActionAsync. This creates a disconnect between the controller's internal methods and the extension helpers.
• Inconsistent naming for delete operations. The abstract controller uses DeleteAsync while the extension method uses GetDeleteActionAsync. This inconsistency extends to the broader pattern where 'Action' is appended in extensions but not in the controller base class.
• Inconsistent naming for update operations. The abstract controller uses UpdateAsync while the extension method uses GetUpdateActionAsync. This breaks the pattern established by the other CRUD operations.
• LLM evaluation failed
• Medium: security finding (details withheld)
• Off-boarding risk: anonymized user #1
• …and 3 more

• BarePragmaDisable (src/Whipstaff.Mermaid/Playwright/PlaywrightRendererPageInstance.cs)
• BarePragmaDisable (src/Whipstaff.Mermaid/Playwright/PlaywrightRendererPageInstance.cs)
• BarePragmaDisable (src/Whipstaff.Rx/Observables/ObservableExtensions.Split.cs)
• BarePragmaDisable (src/Whipstaff.Rx/Observables/ObservableExtensions.cs)
• BarePragmaDisable (src/Whipstaff.UnitTests/Controllers/CrudControllerTests.cs)
• CoverageExclusion (src/Whipstaff.Core/Logging/LogValuesFormatter.cs)
• CoverageExclusion (src/Whipstaff.Core/Logging/SR.cs)
• CoverageExclusion (src/Whipstaff.Core/Logging/ValueStringBuilder.cs)
• CoverageExclusion (src/Whipstaff.Testing/Cqrs/FakeCrudAddCommand.cs)
• CoverageExclusion (src/Whipstaff.Testing/Cqrs/FakeCrudDeleteCommand.cs)
• CoverageExclusion (src/Whipstaff.Testing/Cqrs/FakeCrudListQuery.cs)
• CoverageExclusion (src/Whipstaff.Testing/Cqrs/FakeCrudUpdateCommand.cs)
• CoverageExclusion (src/Whipstaff.Testing/Cqrs/FakeCrudViewQuery.cs)
• CoverageExclusion (src/Whipstaff.Testing/FakeCrudController.cs)
• CoverageExclusion (src/Whipstaff.Testing/FakeCrudControllerSwaggerMetaData.cs)
• CoverageExclusion (src/Whipstaff.Testing/FakeCrudListRequest.cs)
• CoverageExclusion (src/Whipstaff.Testing/GlobalSuppressions.cs)
• CoverageExclusion (src/_shared/CompilerServices/CallerArgumentExpressionAttribute.cs)
• CoverageExclusion (src/_shared/CompilerServices/IsExternalInit.cs)
• DeadPreprocessorBranch (src/Whipstaff.AspNetCore/AbstractWebAppStartup.cs)
• …and 139 more

• 73 commits — 68 feature/other, 5 fixes

• src/Directory.Build.props — 11 commits
• src/Whipstaff.Blazor.Syncfusion.BarcodeGenerator — 7 commits
• src/Whipstaff.AspNetCore — 6 commits
• src/Whipstaff.Mermaid — 6 commits
• src/Whipstaff.Example.AspireServiceDefaults — 4 commits
• src/Whipstaff.Aspire.Hosting — 3 commits
• src/Whipstaff.Blazor.MudBlazor — 3 commits
• src/Whipstaff.WebHooksSite.Client — 3 commits
• (root) — 2 commits
• .github/workflows — 2 commits
• src/Whipstaff.Avalonia — 2 commits
• src/Whipstaff.CommandLine — 2 commits
• src/Whipstaff.Maui.AspNetCore.WebView — 2 commits
• src/Whipstaff.WinUI — 2 commits
• src/Whipstaff.Windows — 2 commits
• src/Whipstaff.Wpf.CefSharp — 2 commits
• src/Whipstaff.Blazor — 1 commit
• src/Whipstaff.Blazor.Syncfusion.DataVizCommon — 1 commit
• src/Whipstaff.Couchbase — 1 commit
• src/Whipstaff.Example.WebMvcApp — 1 commit

• fix: fix(deps): update dependency highlight.js to v11.12.0 (#3014)
• fix: fix(deps): update dependency mermaid to v11.16.1 (#3005)
• fix: fix(deps): update dependency mermaid to v11.17.0 (#3034)
• fix: fix(deps): update dependency mermaid to v11.17.1 (#3041)
• fix: fix(deps): update dependency mermaid to v11.17.2 (#3044)
• change: Add Microsoft.Testing.Extensions.GitHubActionsReport package
• change: Feature: signalr rx client (#3009)
• change: build(deps): bump dompurify in Whipstaff.Mermaid (#3011)
• change: chore(deps): update all aspire to 13.5.0 (#3032)
• change: chore(deps): update all aspire to 13.5.2 (#3037)
• change: chore(deps): update all aspire to 13.5.3 (#3045)
• change: chore(deps): update all audit.net dependencies to 32.3.0 (#3030)
• change: chore(deps): update all audit.net dependencies to 32.3.1 (#3033)
• change: chore(deps): update all audit.net dependencies to v33 (#3078)
• change: chore(deps): update all gripe to 2.0.138 (#3001)
• change: chore(deps): update all gripe to 2.0.148 (#3025)
• change: chore(deps): update all microsoft dependencies (#3015)
• change: chore(deps): update all microsoft dependencies (#3028)
• change: chore(deps): update all microsoft dependencies to 10.0.101 (#3060)
• change: chore(deps): update all microsoft dependencies to 10.0.12 (#3064)
• …and 53 more

• Unchanged — 5 HTTP endpoints

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

dpvreony/whipstaff was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.