Skip to content
CAI
Software that uses CAICheck a score

pal-tamas/rask

53.8

Adequate · 8 November 2026

265k

lines of production code

C#

with TypeScript

5

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add Azure Blob Storage backend for file uploads

The storage system now supports Azure Blob Storage as a provider, allowing files to be stored in Azure containers without requiring the Azure SDK. This change introduces configuration options for Azure connection strings (including support for Azurite), implements in-process signing of requests using Shared Keys or SAS tokens, and provides the necessary backend classes to handle file uploads, reads, listings, and deletions against Azure.

src/Rask.Storage · high confidence

Add Rask.Postgres as an opt-in Entity Framework Core provider with production defaults and full-text search

The new Rask.Postgres package provides a drop-in replacement for UseNpgsql that configures production-ready session timeouts (statement, lock, and idle-in-transaction) and enables transient-failure retrying by default. It introduces full-text search support via generated tsvector columns and GIN indexes, including a Unicode tokenizer that handles accent folding, with configuration managed through the Rask:Postgres appsettings section.

src/Rask.Postgres · high confidence

Add a CRUD Todos feature with route-driven dialogs and pluggable persistence

The site now includes a full CRUD screen for managing to-do items, accessible at /todos, /todos/new, and /todos/{id}/edit. The list view displays items with completion toggles and allows adding, editing, and deleting entries via a modal dialog driven by route state. Form validation ensures titles are between 1 and 120 characters. The feature uses a pluggable persistence layer (ITodoStore); by default, it uses an in-memory store for the showcase, but hosts can inject a durable implementation (e.g., SQLite) to persist data across restarts.

src/Rask.Site/Features/Todos · high confidence

Add branding assets and video captions to the site

The site now includes new static assets in the \wwwroot/img\ directory: a WebVTT captions file (\captions.vtt\) providing a video description, an SVG logo mark (\rask-mark.svg\), and an SVG placeholder image (\rask-placeholder.svg\). These additions support the site's visual identity and media presentation.

src/Rask.Site/wwwroot/img · high confidence

Add live Rask.Query demo for parcel management

The site now includes an interactive demo in the query guide that showcases Rask.Query capabilities using a parcel management scenario. This demo features paginated list queries that preserve previous data while loading, dependent queries that pause until a selection is made, function-based searches over local data, and commands that invalidate cached queries upon success, all with visual loading and pending states.

src/Rask.Site/Features/Query · high confidence

Add master-detail order demo with nested sortable tables

A new MasterDetailDemo component has been added to the Orders feature, demonstrating a master-detail data grid where expanding an order row reveals a nested table of line items. Both the outer order grid and the inner item grids support independent column sorting, with the UI state for expanded rows and sort orders managed locally within the component.

src/Rask.Site/Features/Orders · high confidence

Add national flag SVGs to the UI kit

The UI kit now includes a comprehensive set of national flag icons (e.g., Andorra, UAE, Afghanistan) as SVG assets in the \src/Rask.Ui/Flags/\ directory. These assets are available for use within the application's interface, supporting internationalization and location-based UI elements.

src/Rask.Ui · high confidence

Add virtualized table demos with in-memory and async data sources

The site now includes two interactive demos under the /virtualize feature that demonstrate high-performance scrolling for large datasets. The first demo renders 10,000 rows of in-memory data using a virtualization strategy that keeps only the visible window (plus an overscan buffer) in the DOM, utilizing spacer rows to maintain layout stability for a sticky header. The second demo extends this pattern to asynchronous data fetching, simulating a 350ms API call per window with placeholder rendering and proper cancellation support when navigating away. Both demos use a shared sample data model containing index, name, city, and balance fields.

src/Rask.Site/Features/Virtualize · high confidence

Added LogPage record for paginated log queries

A new LogPage record type has been introduced to support paginated access to log entries. This type encapsulates a specific page of results along with metadata such as the total count of matching entries, the current page number, and the page size, allowing users to navigate through large sets of log data efficiently.

Rask.Logging · high confidence

Added PDF refund report demo with download capability

The site now includes a demo feature in the PDF section that displays a diesel refund report for three trucks over a quarter. Users can view the report data directly on the page or download a pre-generated PDF version of the report via a dedicated button. The report includes detailed fuel purchase data per vehicle, formatted with Hungarian locale conventions, and demonstrates how the Rask.Pdf library converts this component structure into a printable document.

src/Rask.Site/Features/Pdf · high confidence

Added SVG feature demonstration components

The site now includes a set of new demo components under the SVG feature area to showcase specific rendering capabilities. These include SvgShapesDemo for basic geometry (rectangles, circles, lines), SvgTextDemo for styled text with spans, SvgGradientDemo for applying gradients to logos, SvgClickableDemo for interactive color selection with pointer events, and SvgAnimateDemo for native SVG animations like radius changes and rotations.

src/Rask.Site/Features/Svg · high confidence

Added demo components for the Tags feature

New demo components have been added to the Tags feature area to showcase various UI elements: TagsFormDemo demonstrates a form with a text input and submit button, TagsMediaDemo displays an image, TagsTableDemo renders a data table, TagsTextDemo shows styled text content, and TagsVoidDemo illustrates a horizontal rule separator.

src/Rask.Site/Features/Tags · high confidence

Added file upload demo component

A new UploadDemo component has been added to the site features, providing a self-contained file-picker interface. Users can select a file via the Ui.Input component, which triggers a handler to display metadata such as name, size, content type, and last modified date in a structured layout.

src/Rask.Site/Features/Upload · high confidence

Added routing demonstration components to the site

The site now includes three new components under the \src/Rask.Site/Features/Routing\ path to serve as a practical example of the routing system: \RoutingAboutPage\ (route \/routing-demo/about\), \RoutingLayoutDemo\ (route \/routing-demo/nested\), and \RoutingNestedProfile\ (route \/routing-demo/nested/profile\). These components demonstrate how to define routed pages with \\[Route\]\ attributes, how to nest pages under a layout using \\[ParentRoute\]\, and how the layout renders dynamic breadcrumbs based on the current route title. All demo pages are marked with \noindex\ meta tags to prevent them from appearing in search engine results.

src/Rask.Site/Features/Routing · high confidence

Application logs are now stored in the app database

The logging system now supports persisting log entries to the application's own database (PostgreSQL or SQL Server) via a new \DbContextLogStore\ implementation, replacing the previous default of a standalone SQLite file. This change introduces a \RaskLog\ table mapped through EF Core, enabling structured log search, retention management, and scope state capture directly within the app's data layer. A bounded, lossy channel ensures logging operations never block the request path, while metrics track dropped entries to alert on incomplete logs.

src/Rask.Logging · high confidence

Automatic registration of FluentValidation validators for forms

Forms and requests now automatically discover and register FluentValidation validators at compile time, eliminating the need for manual assembly scanning or explicit registration calls. This approach ensures validators work correctly in trimmed WebAssembly deployments by using a \[ModuleInitializer\] to register types found during compilation, while also providing clear diagnostics if multiple validators target the same model or if a validator lacks a suitable constructor.

src/Rask.Generators/Validation · high confidence

Built-in DataAnnotations validation and configurable field binding timing

Forms now include DataAnnotations validation out of the box, so attributes like \[Required\] on your model are automatically checked without extra setup. Additionally, bound fields now support configurable binding timing: you can choose to update the model on every keystroke, after a pause (debounce), on blur, or wait for the next action (like a button press), giving you control over when user input is committed.

src/Rask.Core/Forms · high confidence

Built-in Tailwind CLI resolution and C\# source scanning

The build system now includes a dedicated task assembly that automatically downloads and caches the Tailwind CLI binary (pinned to version 4.3.3 with SHA-256 verification) and scans C\# source files for CSS class names. To prevent documentation comments from polluting the generated stylesheet, the build strips C\# comments from source files before scanning them. The resolved class list is then written to an output file so that dependent projects can consume the kit's styles without re-scanning the sources.

src/Rask.Tailwind.Tasks · high confidence

Built-in request validation for dispatched commands

The Rask hosting package now automatically validates dispatched requests before they reach their handlers. It integrates both System.ComponentModel.DataAnnotations attributes and FluentValidation rules, ensuring that validation errors are caught early. On the server, this applies to all requests; on the client (WebAssembly), a pre-check is available to fail fast in the browser before the request is sent, provided the CQRS client is configured to use it.

src/Rask.Hosting.Shared/Batteries · high confidence

Built-in toast notifications with demo component

The application now includes built-in toast notifications that are rendered automatically by the host without requiring explicit injection or mounting. A new demo component, BuiltInToastDemo, illustrates this capability by providing buttons that trigger success, info (with a heading), and error toasts, demonstrating the integrated UI kit's look and feel.

src/Rask.Site/Features/Toasts · high confidence

Compile-time translation catalog generation with plural and placeholder validation

The translation generator now reads JSON catalog files (Resources/{Family}.{culture}.json) and produces compile-checked C\# string members, ensuring that missing keys, mismatched placeholder counts, and incorrect argument types are caught as build errors rather than runtime failures. It supports named placeholders with optional type/format specifiers, validates that mixed positional and named placeholders are not used, and enforces correct plural forms per language using built-in CLDR rules. A reserved 'RaskStrings' family allows the framework's own UI text to be translated, with diagnostics (RASK051/RASK052) flagging malformed catalogs or disagreements with the neutral language catalog.

src/Rask.Generators/Translations · high confidence

Demo of typed element refs with MDN member access

A new demo component in the site features demonstrates how element references are now typed to their MDN interfaces, allowing C\# code to directly access DOM members like focus, getBoundingClientRect, and showModal. The demo also shows how these refs can be passed to scoped TypeScript functions for additional manipulation.

src/Rask.Site/Features/ElementRef · high confidence

DevTools Probe adds per-session telemetry and framework bug reporting

The DevTools Probe now records live session data into per-session feeds, enabling the DevTools panel to display a component tree (with props, context, and nesting), an Errors tab (listing render, handler, lifecycle, page script, and island failures with counts), a Perf tab (timing interactions from handler to patch), and a Renders tab (counting component renders and reasons). It also introduces a "Report framework bug" feature that generates pre-filled GitHub issues for errors identified as framework-level, while ensuring app-specific data like exception messages and props are redacted from reports.

src/Rask.DevTools/Probe · high confidence

DevTools panel client establishes communication bridge for interactive debugging features

The new \panel-client.ts\ script in the DevTools panel provides the client-side logic for several interactive debugging capabilities. It enables hover highlighting of tree rows on the page, supports a 'pick' mode to select nodes, and facilitates the display of error counts and page script errors in the Errors tab. Additionally, it handles performance timing data for page patches and manages the visual flashing of DOM changes and renders, acting as the communication layer between the panel UI and the host page.

src/Rask.DevTools/Resources/panel · high confidence

DevTools panel now supports both Server and WASM hosts with strict access controls

The DevTools panel is now available for inspection on both Server-hosted and WebAssembly (WASM) pages. On Server hosts, the panel is injected via a host script and requires the user to be the session owner, with remote access disabled by default (controllable via the RASK\_DEVTOOLS\_ALLOW\_REMOTE environment variable). On WASM pages, the panel runs in the same tab as the inspected app, leveraging embedded scripts and a dedicated interop layer to communicate with the session feeds without requiring external network access or tokens.

src/Rask.DevTools/Endpoints · high confidence

Enforce \[Authorize\] on component methods and method groups

The framework now checks authorization attributes on component methods (handlers) at runtime, not just on pages. When a method is marked with \[Authorize\], the framework verifies the user's permissions before the method body executes; if the check fails, a HandlerForbiddenException is thrown, preventing the handler from running and allowing the UI to display a refusal toast. This applies to method groups passed to callbacks (e.g., .OnClick), ensuring that guards are applied consistently whether the handler is invoked directly or through generated interceptors.

src/Rask.Core/Authorization · high confidence

Enhanced development and deployment capabilities in the CLI

The CLI now supports more robust local development and secure remote deployments. \rask dev\ can automatically detect and start dev servers for frontend frameworks (React, Vue, Angular, etc.) and islands, with improved hot reload reliability by resolving symlinks. The \rask deploy\ command now includes a new \--dns azure\ option to automatically provision wildcard SSL certificates via Azure DNS, and it performs detailed host probing to verify prerequisites like Docker and SSH configuration before deployment.

Rask.Cli · high confidence

Error boundary demos demonstrate exception handling and recovery

The ErrorBoundary feature page now includes interactive demos showing how the boundary catches exceptions thrown in event handlers and during rendering. These examples illustrate that the boundary isolates failures to the affected subtree, keeps the rest of the page functional, and provides a recover action to restore the healthy state. The demos also confirm that exception details are not exposed in the UI fallback, aligning with the principle that error messages should be user-friendly and not leak internal state.

src/Rask.Site/Features/ErrorBoundary · high confidence

FluentValidation integration for forms and requests

Rask now supports FluentValidation out of the box for form and request validation. By writing an AbstractValidator\<T\>, the framework automatically discovers and registers it at compile time via a source generator, eliminating the need for manual wiring in Program.cs. The integration supports async rules, resolves constructor dependencies from the service scope, and handles per-field validation efficiently. It is included by default in Rask.Server and Rask.Wasm, ensuring WebAssembly apps remain trimmable.

src/Rask.Validation.FluentValidation · high confidence

Flux UI introduces new value types and scope records for enhanced component state management

The Rask.Ui library adds a suite of new internal and public types to support the Flux UI component system, including value models like UiDateRange, UiTimeRange, and UiColorValue, alongside scope records such as UiCardScope, UiCheckboxScope, and UiFieldScope. These additions enable more robust state handling for date pickers, color pickers, and form fields, allowing components to better manage user interactions, validation, and rendering contexts.

Rask.Ui · high confidence

Framework localization and per-session culture support

The framework now supports internationalization, allowing apps to configure supported languages and automatically negotiating the visitor's culture from URL query strings, cookies, or browser preferences. This change introduces a per-session culture system that formats dates, numbers, and UI text in the user's language, while ensuring that framework components and the built-in error/not-found pages render in the correct locale. It also provides a mechanism for apps to supply translations for the framework's own UI strings via a JSON catalog.

src/Rask.Core/Globalization · high confidence

Full-text search support via SQLite FTS5

The Rask.SQLite.EntityFrameworkCore package now supports full-text search queries against SQLite databases using the FTS5 engine. This is implemented via a new query interceptor that translates LINQ expressions for search, highlighting, and snippet generation into efficient SQL joins and subqueries against the underlying full-text index, allowing users to perform ranked text searches and extract context from results directly through Entity Framework Core.

Rask.SQLite.EntityFrameworkCore · high confidence

Full-text search, JSON path indexes, and non-overlapping range enforcement for SQLite

The Rask SQLite EF Core provider now supports full-text search via SQLite FTS5, allowing entities to declare searchable text columns that are kept in sync by database triggers; queries can use Search() to retrieve ranked results, along with Highlight() and Snippet() for UI formatting. It also introduces JSON path expression indexes, enabling efficient lookups on values nested inside JSON columns through automatically generated migration DDL. Additionally, the provider enforces non-overlapping range rules on entities using SQLite exclusion triggers, ensuring data integrity at the database level for time-based or logical ranges.

src/Rask.SQLite.EntityFrameworkCore · high confidence

Generated typed API clients for controllers and minimal APIs

The Rask.Api.Generators package now includes an ApiClientGenerator that automatically produces strongly-typed C\# client classes for your application's API endpoints. By analyzing ASP.NET MVC controllers (\[ApiController\]) and Minimal API registrations (MapGet, MapPost, etc.), the generator creates methods that mirror your server actions, handling route parameter substitution, query strings, request bodies, and headers. This eliminates manual URL string construction and runtime 404 errors, as route changes on the server will now cause compile-time errors in the client code. The generator also provides specific diagnostics (RASK067–RASK070) to help you handle endpoints that cannot be fully typed or have ambiguous signatures.

src/Rask.Api.Generators · high confidence

Generated typed DOM APIs from MDN specifications

The build process now automatically generates strongly-typed C\# APIs for HTML elements, CSS properties, ARIA attributes, and DOM events directly from MDN data snapshots. This replaces manual definitions with code generation, providing compile-time safety for element attributes (such as ARIA roles and CSS styles), typed event handlers with specific argument types, and structured access to element references, ensuring the framework stays synchronized with browser specifications.

src/Rask.Dom.Tasks · high confidence

Graceful shutdown with session draining and PWA support

The server host now drains live sessions gracefully on shutdown instead of severing them, ensuring in-flight handlers finish and sockets close with a proper handshake within a configurable budget. It also adds opt-in Progressive Web App support, enabling installable apps with service workers, push notifications, and offline fallbacks via the new \AddRaskPwa\ extension.

src/Rask.Server · high confidence

IDE quick-fixes for Rask diagnostics

The Rask.Generators.CodeFixes package now provides IDE quick-fixes for several Rask diagnostics, allowing developers to automatically correct common issues. These include replacing ASP.NET's \[Route\] attribute with Rask's own route attribute (RASK071), rewriting component construction from 'new Widget()' to the chain entry (RASK014), converting delegate events to Callbacks (RASK096), awaiting or discarding dropped awaitables (RASK093), exposing entity collections as IReadOnlyCollection over a private field (RASK085), adding empty Alt attributes to Img elements (RASK023), adding missing required steps to chains (RASK095), narrowing model state mutations to private (RASK084), removing redundant StateHasChanged() calls (RASK026), and adding 'required' modifiers to factory parameters (RASK001).

src/Rask.Generators.CodeFixes · high confidence

Internal infrastructure for Rask DevTools diagnostics and inspection

This change introduces the internal diagnostic backbone for the Rask DevTools, enabling developers to inspect application state and performance. It defines the \IRaskDevToolsProbe\ interface, which allows the runtime to report render causes, component trees, context usage, and errors to an attached tool with zero overhead when the devtools are inactive. A build-time feature switch (\RaskDevToolsFeature\) ensures this code is completely removed in Release builds, and a loader mechanism allows the separate \Rask.DevTools\ package to attach itself to the host without creating circular dependencies. Additionally, a \PropsDescriber\ is provided to safely format and redact component properties for display in the devtools UI.

src/Rask.Core/Diagnostics/DevTools · high confidence

Introduce Rask.Auth.Client for WebAssembly authentication

Adds the Rask.Auth.Client package, providing the browser-side implementation of Rask's authentication system for WebAssembly apps. This includes BrowserAuth for handling user registration, sign-in (including passkeys via WebAuthn), sign-out, and password management, as well as HttpUserProvider to load the current user from the server's /api/auth/me endpoint before the first render. The package replaces the default anonymous user provider with one that uses same-origin cookies, ensuring no tokens are held in JavaScript and preventing the page from flashing anonymous before signing in.

src/Rask.Auth.Client · high confidence

Introduce Rask.Cache: a database-backed, tenant-isolated cache with a fluent API

Rask now includes a developer-facing cache stored in the application's own database, eliminating the need for external brokers like Redis for basic caching needs. The \Cache\ static class provides a fluent, sentence-like API (e.g., \Cache.Remember(key, load).For(10.Minutes)\) that requires no injection in standard request handlers, while \ICache\ is available for hosted services. The implementation supports absolute and sliding expirations, tenant isolation via key scoping, and a background \CachePurger\ to sweep expired entries. It also implements \IDistributedCache\, allowing it to drop into ASP.NET session state or output caching, and can be configured to use an existing Redis store if preferred.

src/Rask.Cache · high confidence

Introduce Rask.Cqrs.Client for remote CQRS dispatch

Adds the Rask.Cqrs.Client package, enabling WebAssembly and native clients to dispatch CQRS messages to a server via HTTP using the same IDispatcher interface used for in-process calls. Queries are sent as GETs and commands as POSTs, with automatic fallback to POST for long URLs or file attachments. The client supports chunked uploads for large files, configurable timeouts, and custom request configuration for authentication headers. Subscriptions are implemented via Server-Sent Events (SSE), allowing clients to receive real-time events from the server. The package includes source-generated wire codecs for reflection-free serialization, ensuring compatibility with WebAssembly trimming. Configuration is handled via CqrsClientOptions, allowing customization of base address, route prefix, and upload thresholds.

src/Rask.Cqrs.Client · high confidence

Introduce Rask.Outbox for transactional event durability

The new Rask.Outbox package provides a transactional outbox that ensures events are persisted in the same database transaction as the domain change that raised them, guaranteeing they are never lost even if the application crashes. Developers can implement IDurableHandler\<T\> to have events processed durably with automatic retries, while standard IEventHandler\<T\> implementations continue to run in-memory. The package includes a background processor that polls for unprocessed messages, supports configurable retention to purge old records, and exposes OpenTelemetry metrics for monitoring processed, failed, and dead-lettered events. A test fake (Outbox.Fake) is also provided to allow deterministic testing of durable handlers without hitting the database.

src/Rask.Outbox · high confidence

Introduce Rask.Testing for unit-testing components

The new Rask.Testing package allows you to unit-test Rask components without a browser or server. You can render a component or visit a route, drive user actions like clicking buttons or typing into fields, and assert on the resulting markup, navigation state, or framework diagnostics. The package includes utilities for faking time, JS interop, file uploads, and form validation context, enabling comprehensive testing of component behavior and state changes.

src/Rask.Testing · high confidence

Introduce Rask.Web for generated browser API access and testing

Rask.Web provides a generated C\# surface for every browser API shipped by MDN, allowing developers to interact with web features like Clipboard, LocalStorage, and MediaStream using MDN's native names without Async suffixes. The library supports both server-side and WebAssembly hosts, using a JsChain mechanism to execute browser calls in single round trips and offering a keep/dispose pattern for long-lived browser objects. It includes a browser-targets analyzer to warn about unsupported features and a comprehensive WebFake system that enables mocking web objects in unit tests, allowing developers to simulate browser behavior, handle callbacks, and verify calls without a real browser environment.

src/Rask.Web · high confidence

Introduce SQLite-backed distributed cache with explicit lifetime management

Rask now includes a developer-facing, SQLite-backed cache pillar (Rask.Cache) that stores opaque byte values under unique keys. Entries are persisted with explicit expiration logic, supporting absolute deadlines, sliding windows, and fixed durations via a fluent API (e.g., \.For(10.Minutes)\). The cache uses a surrogate primary key for internal storage but relies on unique key lookups for reads, ensuring entries are swept by a purge mechanism when they expire.

Rask.Cache · high confidence

Introduce core abstractions for server-side PDF rendering

Added new interfaces and types in the Printing namespace to support rendering pages as static HTML for PDF generation. This includes IPdfBootstrap and PdfLoader to enable Rask.Pdf to self-register within a RaskApp without creating a hard dependency from the server, IPrintablePages to define how routes and components are rendered for a specific user and culture, and supporting records PrintablePage and PrintableFile to represent the rendered output.

src/Rask.Core/Printing · high confidence

Introduce domain events, subscription queries, UI documentation entries, and validation rules

The site now includes core domain events (CounterIncremented, OrderPlaced, OrderShipped) that fan out to handlers, alongside a subscription query (WatchOrder) allowing users to track specific order shipping events. A new UI documentation system is added via UiDocsEntry to manage page metadata, sidebar grouping, and search engine optimization for the site's component pages. Additionally, validation logic for destination names has been implemented to enforce naming conventions such as length limits and starting characters.

Rask.Site · high confidence

Introduce durable background job queue with scheduling, lanes, and security

The application now supports durable background jobs persisted in the database, enabling reliable execution with retry and dead-lettering. Users can schedule jobs to run at specific times or intervals using a fluent API (e.g., \Jobs.Enqueue(job).In(24.Hours)\ or \.At(midnight)\), and organize work into lanes to control concurrency. Jobs run with the security principal of the enqueuing user, ensuring least-privilege execution. The system also includes metrics for monitoring job health and a fake implementation for testing.

src/Rask.Jobs · high confidence

Introduce durable, single-owner SQLite for browser apps

The new \Rask.SQLite.Browser\ package enables WebAssembly apps to use a real SQLite database that persists across reloads via IndexedDB. It ensures durability by restoring the database from IndexedDB before any service opens it, writing snapshots back on a configurable interval and on page-hide. To prevent data divergence across tabs, it uses a Web Lock to elect exactly one owner tab; non-owner tabs run against an empty, unpersisted database and can use the \BrowserSqliteOwnership\ service to detect this state and prompt the user to reload when the owner closes.

src/Rask.SQLite.Browser · high confidence

Introduce file storage model with tenant ownership and public sharing

The Rask.Storage package now includes a StoredFile entity that tracks uploaded files, including their content type, size, SHA-256 hash, and storage provider details. Files are explicitly owned by a tenant (or the host if no tenant is present), and the model supports marking files as public for link-based access. This change establishes the data structure for file persistence and access control within the storage layer.

Rask.Storage · high confidence

Introduce internal DevTools interface and page tag model

The Rask.Server.DevTools area now exposes an internal IRaskServerDevTools interface and a DevToolsPageTag record to manage how the server hosts and serves developer tools. The interface defines the contract for mapping devtools endpoints, determining which pages should load the host script and panel, controlling access refusal for the devtools panel, and validating session resumption. The DevToolsPageTag record provides the specific URLs for the host script and the framed panel page that a live page will load. This change establishes the foundational server-side logic for injecting and managing the devtools experience within Rask applications.

src/Rask.Server/DevTools · high confidence

Introduces Rask.Cqrs.Server for remote CQRS dispatch

Adds the server-side package for Rask's Command-Query-Responsibility-Segregation (CQRS) system, enabling WebAssembly or native clients to dispatch commands and queries over HTTP. The package registers two primary endpoints (GET for queries, POST for commands) and a server-sent events stream for subscriptions, all under a configurable route prefix. It enforces strict security defaults, requiring authentication by default and validating \[Authorize\] policies on handlers, while also introducing robust chunked upload support with disk-backed session storage and configurable limits to prevent resource exhaustion. Exception details are hidden in non-Development environments to prevent information leakage, returning only a reference ID instead.

src/Rask.Cqrs.Server · high confidence

Introduces Rask.Query for server-side state management and command handling

Adds the Rask.Query package, providing a TanStack Query-style caching layer for server state. This includes a static QueryClient for accessing the session cache from anywhere, queries that automatically follow their inputs (such as route parameters) and refetch when they change, and a Command system that exposes lifecycle states (Idle, Pending, Success, Error) for rendering UI feedback. The package also supports optimistic updates, automatic invalidation via attributes, and live subscriptions to entity changes.

src/Rask.Query · high confidence

Introduces content-addressed scoped CSS/JS with minification, compression, and typed script callbacks

The framework now manages scoped assets via a content-addressed registry that emits files under \/\_rask/a/{hash}.{ext}\ with immutable caching. Scoped CSS is automatically minified to reduce payload size, and served assets are compressed using Brotli or gzip with strong ETags for efficient delivery. Additionally, scoped TypeScript exports are exposed to C\# as typed private methods, and callbacks can be passed between the browser and C\# handlers, enabling tighter integration between component scripts and the runtime.

src/Rask.Core/ScopedAssets · high confidence

Introduces durable transactional email with fluent composition and background delivery

Adds the Rask.Mail battery, enabling apps to queue and send transactional emails without external brokers. Users can compose messages using a fluent \Email\ builder (supporting recipients, subjects, HTML/text bodies, and attachments) and send them via \Mail.Send(email)\, which persists a \QueuedMail\ row to the application database. A background \MailProcessor\ delivers messages with at-least-once semantics, exponential backoff retries, and dead-lettering. Delivery is configured via \MailOptions\ to use SMTP (MailKit), a local \.eml\ pickup directory, or logging (for zero-config development). The package includes a \MailFake\ for testing, OpenTelemetry metrics, and boot-time validation to ensure the database schema is mapped.

src/Rask.Mail · high confidence

Introduces optimistic editing, query matching, and TanStack-compatible caching options

Rask.Query now supports optimistic UI updates via the new OptimisticEdit class, which applies local state changes immediately and allows restoration or invalidation if the operation fails. The library adds QueryMatch to control cache invalidation scope (exact key vs. prefix) and introduces QueryOptions to configure caching behavior with defaults aligned to TanStack Query, including stale time, garbage collection time, retry policies, and a KeepPreviousData flag to maintain UI stability during data transitions.

Rask.Query · high confidence

Introduces typed API client library with automatic code generation

The Rask.Api.Client package now provides a typed client that eliminates manual URL construction by generating C\# client classes directly from server-side API controllers and minimal API endpoints. This ensures that route changes, HTTP verbs, and request/response shapes are validated at compile time, preventing runtime 404 errors. The client includes built-in support for RFC 9457 problem documents, allowing applications to distinguish between transport failures (e.g., timeouts, DNS issues) and server-side errors (e.g., validation failures) via the new ApiException. It also handles complex URL encoding safely, preventing path traversal vulnerabilities from special characters in route parameters, and integrates with dependency injection for scoped client resolution and centralized request configuration.

src/Rask.Api.Client · high confidence

Introduction of AuthResult type for sign-in outcomes

A new AuthResult record has been added to the Rask.Wire library to represent the outcome of register or sign-in attempts. This type exposes a Succeeded boolean, an AuthError code for failures, and an optional human-readable Message field to provide specific details such as password-policy violations, allowing consumers to programmatically distinguish between success and various failure modes.

Rask.Wire · high confidence

Introduction of Rask.Auth.Api accounts battery

The application now includes a dedicated authentication service (Rask.Auth.Api) that manages user accounts, sessions, and security flows. This battery provides built-in endpoints for registration, sign-in, password reset, and email confirmation, replacing the previous reliance on ASP.NET Core Identity. It introduces support for passkey authentication, enforces email confirmation gates, and implements a per-address throttling mechanism to prevent brute-force attacks. The system also handles tenant-aware user principals and manages session lifecycles via cookies and bearer tokens.

src/Rask.Auth.Api · high confidence

Introduction of durable transactional email queuing

The Rask.Mail package now includes a persistent email queue system, represented by the new QueuedMail entity, which stores rendered HTML and text bodies along with recipient lists and attachments as JSON. This change enables reliable, background delivery of transactional emails by tracking send status, handling retries with exponential backoff via a ClaimToken-based lease mechanism, and ensuring tenant isolation by recording the originating tenant and user context for each message.

Rask.Mail · high confidence

Introduction of durable, lane-isolated background job processing

The Rask.Jobs library now provides a persistent background job system backed by the application's database (SQLite, PostgreSQL, SQL Server, or Redis). Jobs are persisted with their execution context (user and tenant) and run with the same permissions as the enqueuing user. The system supports lane-based concurrency, ensuring jobs in the same lane execute sequentially while different lanes run in parallel, and includes deduplication logic to prevent duplicate work from queuing while a similar job is already waiting. Recurring jobs are also supported with durable state tracking to prevent double-enqueueing on restart.

Rask.Jobs · high confidence

Landing page rebuilt with Flux components and a zero-JS hero demo

The home page now uses the new Flux UI kit (Ui.Icon, Ui.Tabs, Ui.Card, Ui.Badge) and renders without JavaScript. The hero section features a new interactive LiveCounter demo that proves the framework's state management and minimal diffing, alongside a HeroCode component that displays syntax-highlighted C\# snippets in a tabbed window. An InstallTabs component provides a single, copyable command to install the CLI for both server and WASM templates.

src/Rask.Site/Features/Home · high confidence

Managed Litestream backup and restore-verification for SQLite

The new Rask.SQLite.Litestream package provides a managed background service that continuously replicates the SQLite WAL to a configured remote replica (S3, GCS, Azure Blob, or file storage) and automatically restores the database from that replica on startup if the local file is missing. It includes a configurable, opt-in restore-verification pass that proves the backup is actually restorable by writing a sentinel, waiting for replication, and restoring to a temporary location, ensuring operators can detect broken replicas (e.g., wrong credentials or prefixes) that would otherwise appear healthy.

src/Rask.SQLite.Litestream · high confidence

New CQRS-based counter demo with event-driven logging

The site now includes a new Counter demo in the CQRS feature slice that uses the Rask.Cqrs pipeline (queries, commands, and events) instead of direct state mutation. Clicking Increment sends a command, which updates the count, publishes a CounterIncremented event, and triggers a pipeline behavior that logs every dispatch; the handler then appends a notification to the log. The UI component loads the initial state on mount, re-reads it after the command, and renders the count and a table of recent log entries.

src/Rask.Site/Features/Cqrs · high confidence

New Elements demo components showcase Rask's HTML element API

The site now includes a comprehensive set of demo components under src/Rask.Site/Features/Elements that illustrate the usage of Rask's generated HTML elements. These new files—ElementsFormsDemo, ElementsGroupingDemo, ElementsInteractiveDemo, ElementsMediaDemo, ElementsMetadataDemo, ElementsSectionsDemo, ElementsTablesDemo, and ElementsTextDemo—demonstrate how to render form controls, grouping content, interactive elements, media, metadata, sections, tables, and text-level elements using the framework's fluent API.

src/Rask.Site/Features/Elements · high confidence

New HTML selector utility for testing

The Rask.Testing library now includes an HtmlSelector class that allows tests to locate HTML elements using a specific subset of CSS selectors. This utility supports tag names, IDs, classes, attribute matches (presence, equality, start/end/contains), and descendant/child combinators, along with a :has-text filter. It is designed to be strict, throwing errors for unsupported selector syntax to prevent silent failures in tests.

Rask.Testing · high confidence

New HTTP demo components with resilient fetch and retry logic

Added three new components in the site's HTTP feature area to demonstrate HttpClient usage. HttpFetchDemo performs an asynchronous JSON fetch with a 5-second per-attempt timeout, up to three transient retries using an injected TimeProvider for clock-based delays, and proper cancellation on unmount or navigation. HttpJsonContext provides the System.Text.Json serialization context for the demo's Post record. HttpRegisterDemo illustrates the recommended HttpClient registration pattern, showing how to configure a client with a base address relative to the app's own origin to ensure self-contained, offline-safe relative fetches.

src/Rask.Site/Features/Http · high confidence

New Note data demo with browser-based persistence

A new demo application is available at /demos/data/ that demonstrates data persistence using a browser-based database. This demo introduces a Note aggregate, defined in Note.cs, which stores a title and body. The implementation leverages the Rask.Data framework, utilizing traits such as Versioned and Deletable, and relies on generated model classes for form handling and querying.

Rask.Site.DataDemo · high confidence

New Outbox package for durable event publishing

The new Rask.Outbox package introduces a persisted domain event model that ensures events are written in the same transaction as the originating change and subsequently drained by a background processor. This mechanism allows handlers to choose durability, with each durable handler receiving its own row for independent retry, dead-lettering, and counting. The system tracks the user and tenant context at enqueue time, re-entering them during processing, and uses a claim-based lease mechanism to handle concurrent processing and failure recovery.

Rask.Outbox · high confidence

New Props feature demos added to the site

Added a set of new demo components in the Props feature area (PropsAriaDemo, PropsAttributeOrderDemo, PropsAttributesDemo, PropsCommandDemo, PropsDataDemo, and PropsIdClassStyleDemo) that showcase the usage of typed ARIA roles and attributes, attribute ordering, command-based interactions, data attributes, and standard HTML attributes (id, class, style) within the UI framework.

src/Rask.Site/Features/Props · high confidence

New Rask DevTools host script with interactive page overlays

A new host script is injected into inspected pages to power the Rask DevTools panel. It installs a corner pill and a dockable drawer (bottom or right) to open the panel, and provides interactive overlays: hovering a tree row highlights the corresponding nodes on the page, and a picker mode lets users click to select elements. It also visualizes performance by flashing component renders (amber) and DOM changes (teal) when enabled, and tracks page errors (uncaught exceptions, unhandled promise rejections, and island failures) to display a count on the pill and add an "Open in DevTools" button to the runtime's error overlay.

src/Rask.DevTools/Resources/host · high confidence

New Rask DevTools panel with debugging and performance tabs

A new DevTools panel is now available for inspecting Rask applications, providing several diagnostic tabs. The Errors tab lists component faults, framework warnings, and page-level script errors or island failures, with an option to generate pre-filled bug reports for framework issues. The Renders tab tracks which components actually executed their render logic, showing counts and reasons, and can highlight rendered components and DOM changes on the page. The Perf tab measures interaction times, breaking down the duration of handlers, renders, diffs, and patch application, while also identifying the slowest components. The Tree tab displays the component hierarchy, props, context usage, and allows highlighting components on the page. The Wire tab shows network traffic, and the panel includes a flash emitter to visualize renders and DOM changes. The panel is secured to only render within its own shell and supports both server-side and WASM-hosted inspection sessions.

src/Rask.DevTools/Panel · high confidence

New Rask DevTools panel with error tracking, performance timing, and DOM interaction aids

A new development-only DevTools panel is now available for pages served in Development mode, providing real-time visibility into application behavior. The panel includes an Errors tab that lists and counts page script errors, rejected promises, and island failures, and a Perf tab that times each interaction from the handler to the page's patch. Developers can visually inspect the page using a corner pill and dockable drawer, with features to highlight tree rows on the page, pick specific nodes, and flash DOM changes and renders in two colors to aid debugging.

src/Rask.DevTools/Resources · high confidence

New Rask.Auth package provides account management with passkey support

The new Rask.Auth package introduces a complete account system for Rask applications, replacing ASP.NET Core Identity. It supports registration, sign-in, sign-out, email confirmation, and password reset. A key feature is the ability to sign in with passkeys, which are verified on the BCL. The package includes default email templates for account lifecycle events and handles session management, including revalidation of live sessions. It is designed to be host-neutral, working with both server-side and WebAssembly hosts.

src/Rask.Auth · high confidence

New Rask.Data package with model-first aggregates, ambient transactions, and bulk insert

The new Rask.Data package introduces a model-first data layer where aggregates (Entity\<TId\>) manage their own persistence via Find, Save, and Delete methods, eliminating the need for generated model writes. It enforces tenant isolation by refusing to save rows in a different tenant than the one they were loaded in, and introduces an ambient transaction system (Db.Transaction) that joins DbContexts to a shared connection and transaction scope. The package also includes a high-performance BulkInsert extension for efficient data loading, configurable via batch size and transaction options, and supports full-text search, unique constraint violation messages, and soft-delete as an opt-in feature.

src/Rask.Data · high confidence

New Rask.Spa.Hosting package for serving single-page apps

The Rask.Spa.Hosting package now provides an ASP.NET Core host for single-page applications, allowing you to serve build output from any front-end bundler (React, Vue, Angular, Svelte, etc.) or a Rask WebAssembly app. It handles correct MIME types, cache headers for content-hashed assets, precompressed files, and a SPA fallback for client-side routing. The package also supports running the front-end's dev server automatically during development sessions and includes a debug proxy for WebAssembly C\# debugging.

src/Rask.Spa.Hosting · high confidence

New Roslyn analyzers enforce domain model invariants

Added new static analysis rules (RASK084, RASK085, RASK107) to the Rask generator battery that enforce strict encapsulation for entities, aggregates, and value objects. The new \ModelStateMutationAnalyzer\ flags public setters or mutable fields on model types to ensure state changes only occur through constructors or methods, while \EntityCollectionExposureAnalyzer\ warns when entities expose mutable collections of other entities instead of read-only interfaces. Additionally, \EntityCreationAnalyzer\ prevents aggregates and child entities from being instantiated with \new\ outside their designated factories or parent types, ensuring invariants are maintained at creation time.

src/Rask.Batteries.Generators/Analyzers · high confidence

New TypeScript browser API layer and authentication module

The \src/Rask.Core/Resources/browser\ directory now contains a comprehensive TypeScript layer providing direct wrappers for native browser APIs, including authentication (\auth\), IndexedDB (\indexedDb\), WebRTC/media (\mediaDevices\), WebAuthn/passkeys (\webAuthn\), and various UI features like fullscreen, picture-in-picture, screen orientation, and EyeDropper. This layer introduces a new \auth\ module that implements Rask's own account system (register, login, logout, password reset, email confirmation) via \/api/auth\ endpoints, replacing previous ASP.NET Core Identity patterns, and adds support for passkey-based sign-in. A \globals.ts\ file exposes these capabilities to C\# via \window.\_\rask\\ namespaces for WASM/Server interop, while \index.ts\ provides standard ES module exports for frontend bundlers.

src/Rask.Core/Resources/browser · high confidence

New WebRTC signaling relay package

A new \Rask.Signaling\ package provides a WebSocket-based relay for WebRTC peer-to-peer connections, allowing two peers to exchange offers, answers, and ICE candidates. The relay is opt-in via \AddRaskSignaling\ and \MapRaskSignaling\, requiring explicit WebSocket middleware configuration in non-standard hosts. It enforces strict security defaults: authentication is required by default, peer IDs are server-minted to prevent impersonation, and cross-origin WebSocket hijacking is blocked by validating the \Origin\ header against \AllowedOrigins\. The relay operates in-memory with configurable limits on message size, payload size, message rate, room count, and peers per room, ensuring it remains a lightweight, secure channel for untrusted peers.

src/Rask.Signaling · high confidence

New analyzers for route attributes, auth ordering, and browser targets

The analyzer package introduces several new diagnostics to catch common configuration and usage errors. RASK071 flags Rask components that incorrectly use ASP.NET's \[Route\] attribute, which would otherwise cause silent 404s because Rask's router ignores it. RASK024 warns if authentication middleware is initialized after MapRask, ensuring the user principal is available during the initial render. RASK098 and RASK099 analyze browser compatibility based on the app's \<RaskBrowserTargets\> configuration, warning when generated web API members are missing from specified browser versions or when the target configuration itself is malformed. Additional analyzers include RASK037 (detecting using aliases hidden by chain entries), RASK045 (preventing post-chain property assignments), RASK014 (enforcing chain-based component construction), and RASK096 (requiring Callback\<T\> for events instead of delegates).

src/Rask.Generators/Analyzers · high confidence

New asset-loading demo components for scoped CSS and JS

The site now includes a new set of demo components in the AssetLoading feature area to illustrate how the framework handles scoped assets. BasicScopedCss and TwinA/TwinB demonstrate that sibling CSS files are hashed and emitted as immutable \<link\> tags in the page head, with TwinA and TwinB showing that distinct components receive distinct content-addressed URLs. LazyMount and LazyChild demonstrate on-demand loading, where CSS is fetched only when the component mounts and subsequent mounts utilize the browser cache. JsOnlyDemo serves as a regression case ensuring that components with only JavaScript (no CSS) correctly emit their scoped \<script\> tags. Finally, ScriptCallsDemo shows how scoped TypeScript functions and classes are exposed as typed C\# methods, allowing C\# code to call into JavaScript for viewport size and countdown logic.

src/Rask.Site/Features/AssetLoading · high confidence

New brand assets and social sharing card

Added the source HTML for the Open Graph social card (og-card.html) used to generate the 1200×630 preview image for link unfurls on platforms like Slack, X, and LinkedIn, along with new SVG files for the Rask logo (light and dark variants) and the application icon.

assets · high confidence

New browser-based Notes demo with full-text search and offline persistence

A new standalone WebAssembly application (src/Rask.Site.DataDemo) is introduced, serving as a full-stack demo for the Rask data stack. It runs a SQLite database entirely within the browser tab using IndexedDB for persistence, allowing users to create, list, and search notes with full-text highlighting. The demo features a reactive UI where saving a note automatically refreshes the list, and it is served at /demos/data/ to avoid impacting the main site's bundle size.

src/Rask.Site.DataDemo · high confidence

New browser-based notes demo with OS-following dark mode

A new full-stack demo application for managing notes is now available, served at /demos/data/. The demo's entry page (index.html) implements a dark mode that automatically follows the user's operating system preference (prefers-color-scheme) without storing a persistent theme choice, ensuring the demo's appearance matches the surrounding documentation or guide context. It uses the Rask UI kit's scoped styles and handles theme application across client-side morphs.

src/Rask.Site.DataDemo/wwwroot · high confidence

New browser-based notes demo with local SQLite database

A new interactive demo is available at /demos/data/ that allows users to create, write, and search notes using a SQLite database stored entirely in the browser. This feature is implemented as a separate application embedded via a lazy-loaded iframe to minimize the main site's bundle size, with an option to open the demo in full-screen mode for a dedicated experience.

src/Rask.Site/Features/Data · high confidence

New browser-layer interop and UI hooks in Rask.Core/Resources

The framework introduces a suite of TypeScript modules in \src/Rask.Core/Resources\ that shift significant UI and runtime logic to the browser. \rask-api.ts\ provides a shared Web-API interop layer for both client runtimes, enabling typed element references and MDN-based global access. Several UI components are now kept in the browser to reduce server round-trips: \rask-calendar.ts\ and \rask-color.ts\ manage their own state and drawing, while \rask-carousel.ts\ handles scroll-snap and slide navigation locally. Input handling is improved via \rask-bound.ts\ for managing complex bound fields (like date segments) and \rask-autofocus.ts\ for correctly focusing elements after in-place page morphs. Additional hooks include \rask-batch.ts\ for batching handler events into single frames, \rask-clicks.ts\ for unified click delegation, and \rask-ask.ts\ for in-page confirmation dialogs.

src/Rask.Core/Resources · high confidence

New build integration for scoped CSS, TypeScript, and devtools

The Rask.Core package now includes MSBuild targets and props that automatically register scoped CSS and TypeScript files, enforce TypeScript toolchain versions (tsgo 7.0.2, esbuild 0.28.2), and enable devtools support. In Release builds, comments are stripped from scoped TypeScript output to reduce bundle size, while source maps are included in Debug builds for debugging. The integration also sets up interceptors for authorization checks on component methods and provides TypeScript declaration files for the runtime interop layer.

src/Rask.Core/build · high confidence

New callback-based rating demo using Ui.Button and Callback\<T\>

A new demo component (CallbackRatingDemo) and its child (RatingStars) have been added to the site to showcase the new Callback\<T\> event pattern. The demo allows users to click stars to set a rating, demonstrating how a child component can emit events via a non-nullable Callback\<int\> prop without requiring manual state management or StateHasChanged calls. The implementation uses the new Ui.Button component for the stars and applies theme-aware tokens (text-ui-warn-ink, text-ui-muted) instead of hardcoded hex colors.

src/Rask.Site/Features/Callback · high confidence

New component demos and factory-based component patterns

Added demo components in the site features area to showcase the new source-generator-driven component API. Greeting and WeatherCard demonstrate the fluent chain-step pattern (e.g., Greeting.Name(...).Title(...)) where public settable properties become required or optional chain steps, with WeatherCard also showing dependency injection via constructor for HttpClient. ComponentsDiDemo and ComponentsGreetingDemo illustrate how the generated factories are resolved and used at call sites. SkipFactoryCounter demonstrates the \[SkipFactory\] attribute to exclude properties from the generated chain while preserving state across renders. WeatherJsonContext provides the System.Text.Json serialization context for WeatherCard's data model.

src/Rask.Site/Features/Components · high confidence

New core components for authentication, context, and error handling

This update introduces several foundational components to the framework's core. The Authorize component provides declarative access control with slots for authorized, unauthorized, and authorizing states, supporting role-based and policy-based checks. Context and ContextStack enable ambient value propagation through the component tree, allowing descendants to consume values provided by ancestors without explicit prop threading. Error handling is improved with ErrorBoundary, which catches rendering faults and displays a customizable fallback, and DefaultErrorPage, which shows detailed exception information in development and a safe reference in production. Additionally, DefaultNotFoundPage handles 404s with localized messages, and ForbiddenPage displays permission denied messages within the app layout.

src/Rask.Core/Components · high confidence

New declarative and imperative authorization demos in the Users feature

The Users feature area now includes two new demo components: AuthorizeDemo, which demonstrates declarative role-based access control using the Authorize component with nested slots for admin, signed-in, and anonymous states, and UserGateDemo, which shows imperative authentication gating by injecting IUserProvider and manually handling state changes. Both demos utilize the new Ui.Button and Ui.Callout components for consistent UI styling and allow users to toggle between signed-in (as user or admin) and signed-out states to observe the different access levels.

src/Rask.Site/Features/Users · high confidence

New download demo and standalone 404 page

The site now includes a DownloadDemo component that allows users to generate and download text-based reports via a button, and a dedicated NotFoundPage that handles all unregistered URLs with a proper 404 response, including its own layout and noindex meta tag to prevent search engine indexing of error pages.

src/Rask.Site/Features/Download · high confidence

New event-handling demos for UI components

Added demo components in the Events feature area that showcase the framework's event system. These include examples for click tracking, comprehensive global event handlers (mouse movement, wheel, double-click, context menu, focus/blur, keyboard input, and clipboard paste), form submission with raw FormData, input binding, and selection changes using the new Ui.Select component.

src/Rask.Site/Features/Events · high confidence

New floating-label form demo with validation

A new demo component in the site showcases labelled text fields that float their labels by default, using the Ui.Input and Ui.Select components. The demo includes an account creation form with server-side validation via DataAnnotations attributes (Required, EmailAddress, Range, StringLength) and displays validation messages directly on the bound fields. Upon successful submission, a success callout is shown to confirm the action.

src/Rask.Site/Features/FloatingLabels · high confidence

New form control demos for input, select, textarea, and confirmation behaviors

The site now includes dedicated demo components for key form controls, demonstrating both controlled and bound (two-way) patterns for Ui.Input, Ui.Select, and Ui.Textarea, including the new .Live() mode for real-time binding updates. Additionally, new demos illustrate form submission state handling via a submit-state function and the new .Confirm and .ConfirmLeave APIs for preventing accidental navigation or submission when unsaved changes are present.

src/Rask.Site/Features/FormControls · high confidence

New in-page developer tools for inspecting wire traffic and components

The new Rask.DevTools package provides an in-page panel for developers to inspect live wire traffic, component trees, and performance metrics. The panel is accessible via a pill in the bottom-left corner or Ctrl+Shift+D, but is restricted to local development environments (loopback origins) and requires the Rask.Ui package to render. It is automatically mounted on WASM pages served from the local machine and integrates with the ASP.NET host to record and display session data without affecting production builds.

src/Rask.DevTools · high confidence

New live-rendering core infrastructure and lifecycle management

This change introduces the foundational components for the framework's live-rendering engine, including the \HeadAssetRegistry\ for managing and deduplicating head tags, a new component lifecycle system with \OnMount\, \OnUpdated\, and \OnUnmount\ hooks, and a robust ambient service scope model (\AmbientServices\, \EventServices\) that ensures scoped services are correctly isolated per event. It also adds the \EditOp\ and \EditOpKind\ structures that define the diff operations sent to the client, along with \FrameDiffer\ logic for handling structural changes like child runs and permutations, and \CallbackOwnerScope\ to manage callback lifetimes relative to their owning components.

src/Rask.Core/Live · high confidence

New navigation and query parameter demos in the Go feature

The Go feature now includes interactive demo components that illustrate how to handle navigation and query parameters. GoDemo demonstrates basic path navigation via Go.To and query updates via Go.With using a select listbox. GoQueryDemo provides a live example of manipulating the current URL's query string using Go.With and Go.Without, displaying the resulting path and query state in real-time.

src/Rask.Site/Features/Go · high confidence

New nested form and localization demo components

Added a suite of demonstration components in the site's Features folder to showcase nested form handling and localization. This includes \NestedFluentValidationDemo\, \NestedListForeachDemo\, \NestedListIndexerDemo\, and \NestedSubObjectDemo\, which illustrate binding strategies for sub-objects, dynamic lists with keyed diffing, and FluentValidation integration. Supporting data models (e.g., \AddressModel\, \CheckoutModel\, \LineItem\) and validators are included to power these interactive examples. Additionally, \CultureFormatsDemo\ was added to display how date, currency, and percentage values are formatted across different cultures.

src/Rask.Site/Features/NestedForms · high confidence

New operator dashboard console at /\_rask

A new, mobile-first operator dashboard is now available at the /\_rask route, providing a dedicated interface for monitoring and managing application batteries. The console includes an Overview page for high-level queue health, detailed Queue pages with filtering and pagination, a Cache page for inspecting and flushing cache entries, a Logs page with live tailing and history search, and a Storage page for viewing stored files. The dashboard is styled with the Rask UI kit and daisyUI, enforces access control via the layout, and is served as a separate application to ensure operators do not share render sessions with end users.

src/Rask.Dashboard/Pages · high confidence

New operator dashboard panels for queues, cache, storage, and system health

The dashboard now includes dedicated panels for monitoring and managing background jobs, mail, and outbox queues, as well as viewing cache usage, stored files, and system-level database and backup status. Operators can inspect queue states (due, delayed, failed, processed), retry or purge items, browse cache entries, and review storage statistics and backup replication/verification health directly from the UI.

src/Rask.Dashboard/Panels · high confidence

New primitives for ambient context, typed CSS units, and shared API contracts

The Rask.Wire package now provides core primitives that shape how the application manages state and data. An ambient context system (Ambient, Current) allows handlers, renders, and jobs to access services and cancellation tokens without explicit injection, while also supporting testable time freezing via Clock.Fake. For styling, typed Length and Percentage structs with unit literals (e.g., 12.Px) replace raw strings. The package also defines the shared wire contracts for authentication (AuthApi, AuthError, BearerSession) and file transfers (RemoteFile, FileDownload), ensuring a consistent interface between server and client-side generated code.

src/Rask.Wire · high confidence

New routing primitives and download support

The routing layer now includes a new IDownloadSink interface and PendingDownload record to support file downloads, alongside a LocalUrl helper that sanitizes redirect paths to prevent open-redirect vulnerabilities. Navigation is handled by a new Navigator class with NavigateTo and NavigateOut methods, while query handling is abstracted via IQueryCollection and QueryCollection interfaces. Route binding is managed by PageBinder, which supports \[RouteParam\] and \[QueryParam\] attributes, and boolean route/query values can now be parsed from '1' and '0' in addition to 'true'/'false'. The routing system also introduces MountOnlyRoutesAttribute to restrict route registration to specific mounted apps, and NotFoundAttribute to mark custom not-found pages.

src/Rask.Core/Routing · high confidence

New scaffolded home page with conditional UI islands

The generated application now includes a new home page (HomePage.cs) for both server and WASM targets. This page features a responsive layout with a navbar, hero section, and footer. It conditionally renders specific UI islands (React, Preact, Vue, Svelte, Solid, Lit, Angular, Blazor) based on the selected template configuration, providing a 'Hello, Rask!' welcome message and quick-start instructions for development and documentation.

src/Rask.Templates/wasm/Features/Home · high confidence

New site demos for component lifecycle and disposal patterns

The site now includes interactive demos in the Disposal and Cancellation features that illustrate how the framework handles component lifecycles. Users can mount and unmount probes to observe synchronous disposal (IDisposable), asynchronous disposal (IAsyncDisposable), and lifecycle hook-based cleanup (OnMount/OnUnmount). These demos also demonstrate cooperative cancellation via lifetime tokens, showing how long-running tasks are aborted when a component is removed from the tree, with all outcomes logged in real-time tables.

src/Rask.Site/Features/Disposal · high confidence

New skill to drive the Rask site and operator console with Playwright

Adds the \run-rask\ skill, providing a suite of C\# Playwright drivers and diagnostic probes to automate the testing and verification of the Rask framework's showcase site and its built-in operator console. The skill includes \driver.cs\ to launch the WASM-based site and capture screenshots of key pages, and \dashboard-driver.cs\ to scaffold a throwaway app, authenticate against the console, and verify its layout at both desktop and mobile widths. It also ships specialized probes (\frameprobe\, \hydrateprobe\, \growprobe\, \navprobe\, etc.) to detect hydration flickers, layout overflows, and theme correctness, ensuring UI changes are visually validated in a real browser environment.

.claude/skills/run-rask · high confidence

New source generators for CQRS dispatch, data models, and EF Core mapping

The Rask.Batteries.Generators package now includes three new Roslyn source generators that automate infrastructure code. CqrsDispatchGenerator creates a reflection-free dispatch table for CQRS handlers and events, registering them in a registry at startup to support trimming. ModelInputGenerator produces form-bound model classes and write methods (Create, Update, Delete) for aggregates, using UnsafeAccessor to bypass private setters without reflection. ModelRegistryGenerator builds the EF Core model configuration for entities and value objects, eliminating the need for manual DbContext or DbSet declarations. These generators replace manual boilerplate with compile-time generated code.

Rask.Batteries.Generators · high confidence

New source generators for authentication, composite keys, and CQRS codecs

The generator assembly now includes new source generators: AuthUserGenerator automatically detects the application's user type (deriving from Authenticatable) and registers it at compile time, eliminating the need to manually specify the type for authentication setup; CompositeKeyGenerator supports entities keyed by multiple columns by generating the necessary partial class members and validation; CqrsCodecGenerator produces reflection-free wire codecs for remote CQRS messages, including TypeScript bindings for front-end clients, and enforces compile-time authorization checks on handlers and events. Additionally, JobRegistryGenerator registers background jobs for serialization without runtime reflection, and ModelInputGenerator has been refactored into partial files to improve maintainability while continuing to generate form models and validation rules for aggregates.

src/Rask.Batteries.Generators · high confidence

New typed browser APIs for WebRTC, WebAuthn, IndexedDB, and View Transitions

The framework now exposes typed interfaces for several browser capabilities, allowing apps to use WebRTC for peer-to-peer data and media, WebAuthn (passkeys) for authentication, IndexedDB for large-scale offline key/value storage, and the View Transition API for animated DOM updates. These APIs are registered via a central DI helper (RaskBrowserApis) that supports fallback implementations, ensuring they work across both Server and WASM hosts where the underlying JavaScript interop is available.

src/Rask.Core/Browser · high confidence

OpenTelemetry-aligned observability and live-session health checks

The Rask server now provides structured diagnostics aligned with OpenTelemetry standards. Users can subscribe to server metrics (via the 'Rask.Server' meter) and traces (via the 'Rask.Server' activity source) to monitor session lifecycle, handler performance, and resource usage. Additionally, a new health-check extension registers two distinct probes: a 'live' check that reports session capacity and memory load (degrading or failing as limits are approached), and a 'ready' check that immediately reports unhealthy during graceful shutdowns to assist load balancers in routing.

src/Rask.Server/Diagnostics · high confidence

Operator dashboard mounts at /\_rask with fail-closed security

The new operator dashboard is now available at the /\_rask path, providing a unified view of background jobs, outbox, mail, cache, and logs. Access is strictly controlled: if you do not define the RaskDashboard authorization policy, the dashboard denies all access in non-Development environments (logging a warning if you attempt to enable anonymous access) and remains open only in Development. You can register the dashboard via AddRaskDashboard, which automatically mounts the console as a separate application to prevent style or route conflicts with your host.

src/Rask.Dashboard · high confidence

Production-ready SQLite with hardened pragmas and non-blocking concurrent writes

The Rask.SQLite package now provides a production-hardened SQLite implementation that applies tuned pragmas (WAL journaling, NORMAL synchronous, foreign keys, memory-mapped I/O, and cell size checks) on every connection open to ensure correctness and performance. It introduces a new \ISqlite\ factory and \InImmediateTransactionAsync\ helper that uses \BEGIN IMMEDIATE\ transactions with a non-blocking, fair-interval busy retry to handle concurrent writes without blocking threads or causing deadlocks. Additionally, it fixes a critical locale-dependent crash in decimal ordering by registering a culture-invariant, non-throwing collation that safely handles non-numeric text, and hardens the connection against schema-based code execution by disabling trusted schema.

src/Rask.SQLite · high confidence

Rask.Core framework initial commit

This entry marks the initial commit of the Rask.Core framework, introducing the foundational components for a web application framework. The diff establishes the core architecture, including the base Component class with its lifecycle hooks (OnInitialized, OnParametersSet, OnAfterRender), a routing system with Route and RouteUrl types, and a comprehensive set of HTML element components (A, Button, Input, etc.). It also introduces form binding capabilities via ExpressionAccessor, drag-and-drop primitives, and development-time error overlays. This commit serves as the baseline for the framework's subsequent evolution.

Rask.Core · high confidence

Redesigned documentation site with live demos and improved navigation

The documentation site has been rebuilt to feature a new layout with a top bar, sidebar, and guide chrome that includes a version banner, table of contents, and a sticky 'On this page' rail. Users can now interact with live code samples via the new CodeSample component, which supports syntax highlighting, multiple file tabs, and a copy-to-clipboard button. The site also introduces a dark mode toggle in the header, a demo registry for embedding interactive examples directly into guides, and improved link resolution for relative doc links. Additionally, a new Bash language highlighter has been added to support shell code blocks in the documentation.

src/Rask.Site/Shared · high confidence

Scaffolded apps now include shared UI, error handling, and user model components

The shared feature area now provides three new template components for generated applications: App.cs manages the application shell by injecting the page title into the browser tab; ErrorPage.cs offers a secure, user-friendly error display that shows only a trace ID rather than stack traces; and User.cs defines the application's user entity, extending the built-in Authenticatable base class to support display names and role-based access.

src/Rask.Templates/server/Features/Shared · high confidence

Scaffolding infrastructure and configuration handling

The CLI scaffolding system now includes dedicated components for managing project configuration and deployment state. A new AppSettingsReader allows commands to inspect appsettings files (including JSONC comments) to read string settings without running the app. DeployConfig persists deployment settings (host, domain, port, env-file path, health check configuration) to .rask/deploy.json, explicitly storing only environment variable names (not values) to prevent silent secret loss on redeploy. DotnetTarget manages .NET version scaffolding (net10.0 default, net11.0 preview), rewriting framework references in csproj, Dockerfiles, and global.json. IslandAssembly composes frontend island runtimes (React, Vue, Svelte, etc.) into host projects, handling package.json and tsconfig.json generation. MetaTemplate defines scaffolding behavior for six meta frameworks (Next, Nuxt, SvelteKit, etc.), including dev server proxying and Tailwind integration. GitHubActionsWorkflow generates deploy workflows for CI/CD. IFileSystem abstracts file operations for testability, with WriteSecretText ensuring owner-only permissions for sensitive files. Identifiers validates C\# namespaces, type names, and route paths. OwnerOnly restricts file permissions to owner-only on Unix systems. PackageFeed checks NuGet package existence before scaffolding to provide clearer error messages. Also in this area: Dashboard UI kit adopts nested namespace and static logging.

src/Rask.Cli/Scaffolding · high confidence

Serve rask dev on https://\<name\>.test with a trusted local CA

The \rask dev\ command now serves the application on a \.test\ hostname (e.g., \https://appname.test\) using HTTPS, eliminating the need for manual certificate configuration. It automatically generates a local Certificate Authority and issues short-lived server certificates for the project, handling platform-specific setup for host resolution, port binding, and trust store integration on Windows, macOS, and Linux. The setup requires a one-time privilege elevation to configure the environment, after which subsequent runs are password-free. Additionally, a dedicated status server on localhost reports build health to distinguish between build failures and normal restarts.

src/Rask.Cli/Dev · high confidence

Server host now serves a dedicated sign-in page for unauthenticated users

The Rask.Server host now provides a built-in sign-in page (HostSignInPage) that is served outside the application's own routes when a user is unauthenticated. This page is automatically discovered from the ASP.NET Core cookie authentication scheme's LoginPath, or falls back to a configurable path in RaskServerOptions, ensuring that sign-in challenges are handled correctly without leaking session data or guessing routes.

Rask.Server · high confidence

Server-side JS interop now works via WebSocket for third-party libraries

Users can now use Blazor-style libraries that depend on IJSRuntime (such as ProtectedSessionStorage or Blazored.LocalStorage) within Rask server-side sessions. The new RaskJSRuntime implementation bridges the gap by queuing JavaScript invocations onto the live session's pending list and shipping them over the WebSocket transport, ensuring that interop calls are executed after the DOM patch and results are returned correctly to the client.

src/Rask.Server/JSInterop · high confidence

Server-side Web Push support with VAPID authentication and subscriber management

Rask now includes a server-side Web Push sender that allows applications to deliver notifications to browsers. This feature introduces a \PushSubscriber\ entity to store browser subscription details (endpoint, keys, expiration) in the application's database, enabling targeted messaging by user ID. It utilizes VAPID keys (generated via the CLI or code) to authenticate with push services according to RFC 8292, and supports sending encrypted messages via \Push.Send\ using the \WebPushMessage\ model, which handles standard notification fields (title, body, URL) or raw JSON payloads for custom service workers.

Rask.WebPush · high confidence

Server-side Web Push with VAPID and end-to-end encryption

The Rask.WebPush package introduces a server-side Web Push sender that manages browser subscriptions in the application database and delivers notifications using VAPID (RFC 8292) and AES-128-GCM encryption (RFC 8291). Subscribers are stored in a dedicated table, and broadcasts reach all subscribers or specific users via a fluent API (\Push.Send(message).To(userId)\). The implementation includes security hardening by validating that push endpoints resolve to public addresses (blocking localhost and private networks) and automatically removing malformed subscriptions that would otherwise block broadcasts. It also provides a fake implementation for testing and exposes configuration options for VAPID keys, contact subjects, and anonymous subscriber limits.

src/Rask.WebPush · high confidence

Server-side page rendering for printing

The printing subsystem now supports rendering arbitrary application pages on the server for output as PDFs. A new \ServerPrintablePages\ implementation allows the system to take a route URL and a user context, perform authorization, and render the page into HTML within an isolated session, ensuring that printed content respects access controls and includes the application's shell (stylesheets, fonts). This capability enables users to generate printable documents for any page they have permission to view, rather than relying solely on pre-defined print templates.

src/Rask.Server/Printing · high confidence

Shared hosting infrastructure for SPA serving, configuration, and resilience

This change introduces a set of shared components in src/Rask.Hosting.Shared that standardize how Rask hosts serve static assets, manage configuration, and handle deployment resilience. It adds PrecompressedFileMiddleware and ContentEncodingNegotiation to correctly serve precompressed (.br/.gz) static files while respecting client Accept-Encoding quality values, and StaticSpaFiles to map SPA catch-all routes that only allow GET/HEAD. It introduces RaskOptionsRegistration to bind settings from Rask:\<Area\> configuration sections with a strict priority order (defaults, config, code, validation) and RaskDataProtectionSetup to persist ASP.NET Data Protection keys to durable storage (e.g., /data/keys) in containerized deployments, preventing silent user sign-outs on redeploy. Additionally, it adds RaskShutdownDefaults to configure concurrent service shutdown and appropriate timeout budgets, SameOrigin to restrict WebSocket upgrades to the same origin, ClientNetwork to normalize IPv6 addresses for throttling, and ErrorReferenceId to generate safe, random error reference codes for logging.

src/Rask.Hosting.Shared · high confidence

Structured documentation system with AI-ready exports

The site now features a centralized guide catalog that organizes documentation into logical groups (Start here, Tutorial, Data, Auth, etc.) and serves them via a dedicated index page with installation instructions. This system introduces structured metadata for every guide, including specific search titles and meta descriptions to improve SEO and search relevance. It also integrates build-time git history to display accurate 'last modified' dates on each guide page, which are used for article metadata and sitemap updates. Additionally, the system automatically generates LLM-friendly text exports (llms.txt and per-guide Markdown twins) to make the documentation easily consumable by AI assistants.

src/Rask.Site/Features/Guides · high confidence

Subscription demo for real-time order tracking

Added a new subscription feature demo in the Rask.Site application that showcases real-time event handling. The demo includes an OrderBoard component that automatically refreshes to display the last five placed orders, a SubscriptionDemo component that allows users to place and ship orders while tracking their status, and a WatchingOrders policy class that currently permits all users to watch orders. This implementation demonstrates the new subscription-based architecture where UI components subscribe to events like OrderPlaced and OrderShipped to update their state reactively.

src/Rask.Site/Features/Subscriptions · high confidence

Typed private methods for scoped TypeScript exports

Components can now call their own scoped TypeScript functions and classes using strongly-typed C\# private methods (e.g., \await Width(\_box)\) instead of manual \IJSRuntime\ invocations. The new \ScopedScriptCallsGenerator\ reads TypeScript declaration files generated by tsgo and produces C\# members for exported functions, classes (as nested proxies with \New{Class}\ methods), and interfaces (as nested records), handling type mapping for tuples, callbacks, and data shapes while reporting unsupported exports via diagnostic RASK094.

src/Rask.Generators/ScopedScripts · high confidence

Typed, bound form controls with live validation and unsaved-change guards

The DOM layer now provides strongly-typed, generic form components (HTMLFormElement, HTMLInputElement, HTMLSelectElement, HTMLTextAreaElement) that bind directly to model properties via expressions. Bound controls automatically parse values, run validation (including DataAnnotations and custom validators), and update the model either on every keystroke (Live), on blur, or with a configurable debounce. The form element itself tracks submission state, exposes OnSubmit/OnInvalidSubmit callbacks, and supports a ConfirmLeave prompt to warn users if they attempt to navigate away with unsaved changes. Additionally, HTMLMetaElement now supports an explicit Property attribute for Open Graph/RDFa metadata, and SVGElement exposes common presentation attributes like fill and stroke as direct properties.

src/Rask.Core/Dom · high confidence

Validation feature demos added to the site

The site now includes a comprehensive set of demonstration components in the Validation feature area, showcasing the framework's form validation capabilities. These demos cover inline and programmatic validation, asynchronous field checks with live status indicators, custom DataAnnotations attributes (including cross-field matching and service resolution), FluentValidation integration, and complex scenarios like nested object validation and live-derived totals. The additions also demonstrate error handling behaviors, such as first-error-wins gating, form-level summaries, and graceful degradation when save operations fail or throw exceptions.

src/Rask.Site/Features/Validation · high confidence

Removals

Removal of authentication and hosting configuration from the WASM example

The Rask.Example.Wasm project has removed its built-in authentication flow and specific hosting configuration. The HttpUserProvider, LoginPage, and Program.cs files that handled user identity, login UI, and service registration have been deleted, along with the runtimeconfig.template.json. This indicates the example app no longer demonstrates or requires local authentication logic or custom WASM host properties in this location.

Rask.Example.Wasm · high confidence

Removal of example authentication and server setup

The example application no longer includes the login page or the server configuration required to run it. The \LoginPage.cs\ component, which handled user sign-in with hardcoded credentials, has been removed, along with the \Program.cs\ file that configured cookie authentication and authorization. Users will no longer see or be able to access the sign-in functionality in this example.

Rask.Example.Server · high confidence

Removal of legacy UseRask SPA hosting extension

The \UseRask\ extension method and its associated \WasmAppBundle\ resolution logic have been removed from \Rask.Wasm.Hosting\. This eliminates the previous implementation that served the WASM AppBundle via \UseDefaultFiles\ and \UseStaticFiles\ with a fallback to \index.html\, along with the assembly metadata-based bundle path resolution. Users relying on this specific hosting pattern must migrate to the updated hosting model provided by the framework.

Rask.Wasm.Hosting · high confidence

Removal of legacy example components and services

The Rask.Example.Components area has removed its previous set of demonstration files, including the main App layout, routing components (HomePage, Counter, Weather), authentication helpers (UserBadge, LoginModel), and weather data services (HttpWeatherForecastService, LocalWeatherForecastService). This cleanup clears the way for the new multi-page feature showcase structure mentioned in the commit history.

Rask.Example.Components · high confidence

Removal of source generators and polyfills

The \Rask.Generators\ package has been removed, eliminating the \ComponentFactoryGenerator\ and \RoutesGenerator\ that previously generated factory classes and route-handling code at compile time. Additionally, the \IsExternalInit\ polyfill used for netstandard2.0 compatibility has been deleted, indicating a shift in supported runtime or build environment requirements.

Rask.Generators · high confidence

Security

Authorization is enforced for all in-process CQRS dispatches

The Rask.Cqrs package now applies \[Authorize\] checks to commands and queries dispatched in-process, not just those arriving over HTTP. An AuthorizationBehavior pipeline behavior intercepts every request and throws a ForbiddenException if the current user does not meet the handler's authorization requirements, preventing unauthorized users from bypassing security by calling the dispatcher directly from application code.

src/Rask.Cqrs · high confidence

Behavioural changes

1 commit (0 fixes) modifying src/Rask.Hosting.Shared/Tenants

A change to existing behaviour in src/Rask.Hosting.Shared/Tenants — 1 commit, 1 file: “feat(auth): a tenant choice for apps with their own sign-in, MapRaskTenantChoice”.

src/Rask.Hosting.Shared/Tenants · medium confidence · unverified

11 commits (1 fix) modifying scripts/flux

A change to existing behaviour in scripts/flux — 11 commits (1 fix), 1 file: “fix(ui): an open date picker rests the focus on nothing, as Flux; parity-focus.mjs holds the look”; “build(flux): parity-all and the refresh test run the .NET harness alone”; “chore(flux): hold the tooltip and the toast to Flux on a phone too, finger by finger”; and 8 more.

scripts/flux · medium confidence · unverified

11 commits (5 fixes) modifying src/Rask.TypeScript.Tasks

A change to existing behaviour in src/Rask.TypeScript.Tasks — 11 commits (5 fixs), 8 files: “refactor!: remove every island from the framework”; “feat!: build src/ analyzer-clean under Meziantou, Roslynator, Sonar and banned APIs”; “fix(build): compile scoped TypeScript in design-time builds with a cached tsgo”; and 8 more (refs \#1182, \#871).

src/Rask.TypeScript.Tasks · medium confidence · unverified

124 commits (27 fixes) modifying src/Rask.Cli/Commands

A change to existing behaviour in src/Rask.Cli/Commands — 124 commits (27 fixs), 47 files: “feat(cli): scaffold a localized app with rask new --culture (\#837)”; “feat(cli): rask db backup and restore, for the local and the deployed database (\#543)”; “feat(dashboard)!: move the operator dashboard to /\_rask and run it on wasm-hosted”; and 120 more (refs \#837, \#543, \#995, \#532, \#513, …).

src/Rask.Cli/Commands · medium confidence · unverified

131 commits (33 fixes) modifying scripts

A change to existing behaviour in scripts — 131 commits (33 fixs), 25 files: “ci: restore the workload cache into a runner-owned SDK, pin the runner image, and bring the docs in line”; “feat(objectstore): add Rask.ObjectStore, an S3 and Azure Blob client with no cloud SDK (\#653)”; “ci: run the benchmark gates on every push, with an allocation budget for a live update”; and 128 more (refs \#653, \#769, \#783, \#585, \#940, …).

scripts · medium confidence · unverified

15 commits (0 fixes) modifying src/Rask.Site/Features/DragDrop

A change to existing behaviour in src/Rask.Site/Features/DragDrop — 15 commits, 4 files: “feat(ui)!: reach the kit through one class — Ui.Button, Ui.Tone — in the Rask namespace”; “refactor(site): draw the demo logs, lists, terminal and counter with Flux components”; “feat(ui): UiButton, UiBadge and UiAlert are their elements; content is children”; and 12 more.

src/Rask.Site/Features/DragDrop · medium confidence · unverified

17 commits (0 fixes) modifying src/Rask.Site/Features/KeyedLists

A change to existing behaviour in src/Rask.Site/Features/KeyedLists — 17 commits, 1 file: “feat(ui)!: reach the kit through one class — Ui.Button, Ui.Tone — in the Rask namespace”; “refactor(site): draw the demo logs, lists, terminal and counter with Flux components”; “feat(ui): UiButton, UiBadge and UiAlert are their elements; content is children”; and 14 more (refs \#1243).

src/Rask.Site/Features/KeyedLists · medium confidence · unverified

19 commits (1 fix) modifying src/Rask.Site/Features/Cancellation

A change to existing behaviour in src/Rask.Site/Features/Cancellation — 19 commits (1 fix), 2 files: “feat(ui)!: reach the kit through one class — Ui.Button, Ui.Tone — in the Rask namespace”; “refactor(site): draw the demo logs, lists, terminal and counter with Flux components”; “feat(ui): UiButton, UiBadge and UiAlert are their elements; content is children”; and 16 more.

src/Rask.Site/Features/Cancellation · medium confidence · unverified

1985 commits (620 fixes) modifying (repo-wide)

A change to existing behaviour in (repo-wide) — 1985 commits (620 fixs), 19 files: “feat(sqlite): fold a replica's own objects into one so a shared bucket stops growing”; “feat(cli): scaffold a localized app with rask new --culture (\#837)”; “docs(site): give each actions page a Behaviour section with the rules ui-kit.md had”; and 1971 more (refs \#837, \#644, \#99, \#380, \#462, …).

(repo-wide) · low confidence · unverified

2 commits (0 fixes) modifying scripts/tools

A change to existing behaviour in scripts/tools — 2 commits, 18 files: “build: add RaskRename, a one-pass symbol rename over the solution”; “build(ui): bundle the editor and phone engines with a .NET tool, no npm or Node”.

scripts/tools · medium confidence · unverified

2 commits (0 fixes) modifying src/Rask.Hosting.Shared/Dev

A change to existing behaviour in src/Rask.Hosting.Shared/Dev — 2 commits, 4 files: “feat(dev): an app F5 launched starts its own dev servers and serves on .test”; “feat!: build src/ analyzer-clean under Meziantou, Roslynator, Sonar and banned APIs”.

src/Rask.Hosting.Shared/Dev · medium confidence · unverified

2 commits (0 fixes) modifying src/Rask.Xlsx

A change to existing behaviour in src/Rask.Xlsx — 2 commits, 13 files: “feat(xlsx): Rask.Xlsx, an Excel workbook from headings and rows with no dependency”; “refactor(xlsx): value wrappers are plain structs and a sheet a class, 87 recorded members to 35”.

src/Rask.Xlsx · medium confidence · unverified

2 commits (1 fix) modifying src/Rask.Generators/Authorization

A change to existing behaviour in src/Rask.Generators/Authorization — 2 commits (1 fix), 6 files: “feat(auth): check \[Authorize\] on a component method wherever it is called”; “fix(generators): name another generator's type as its declaration does in \[Authorize\] interceptors”.

src/Rask.Generators/Authorization · medium confidence · unverified

20 commits (6 fixes) modifying src/Rask.Pdf

A change to existing behaviour in src/Rask.Pdf — 20 commits (6 fixs), 27 files: “perf(pdf): hold a printed page out of rendering until it loads, then lay it out once”; “feat(pdf): a RaskApp finds Rask.Pdf by itself, and Pdf.From works in an endpoint”; “fix(pdf): a hand-wired AddRask() host prints once Rask.Pdf is referenced”; and 17 more.

src/Rask.Pdf · medium confidence · unverified

22 commits (4 fixes) modifying scripts/upstream

A change to existing behaviour in scripts/upstream — 22 commits (4 fixs), 14 files: “ci(upstream): one registry of followers, and a gate that every generator is on it”; “ci: main runs once — full.yml daily, publishing follows main's ci push run”; “ci: the gates install the Node the repo states in .node-version, which the node-lts follower moves”; and 19 more (refs \#1189).

scripts/upstream · medium confidence · unverified

3 commits (0 fixes) modifying src/Rask.DevTools/Server

A change to existing behaviour in src/Rask.DevTools/Server — 3 commits, 5 files: “refactor!: remove every island from the framework”; “feat(dev): an app F5 launched starts its own dev servers and serves on .test”; “feat!: build src/ analyzer-clean under Meziantou, Roslynator, Sonar and banned APIs”.

src/Rask.DevTools/Server · medium confidence · unverified

4 commits (1 fix) modifying python

A change to existing behaviour in python — 4 commits (1 fix), 1 file: “ci(release): packages are pushed dependencies first and the set is verified before success”; “fix(ci): give every nightly commit its own version and refuse a version from two commits”; “ci: push a nightly in one wave instead of eight gated levels”; and 1 more.

python · medium confidence · unverified

4 commits (1 fix) modifying scripts/flux/Flux

A change to existing behaviour in scripts/flux/Flux — 4 commits (1 fix), 57 files: “fix(flux): parity finds its page by place, so command-open runs with --prepare command-open”; “build(flux): port the open-state parity checks to the C\# harness”; “build(flux): port the component parity checks to the C\# harness, no Node”; and 1 more.

scripts/flux/Flux · medium confidence · unverified

43 commits (2 fixes) modifying src/Rask.Site/Features/UiKit

A change to existing behaviour in src/Rask.Site/Features/UiKit — 43 commits (2 fixs), 8 files: “feat(ui)!: Ui.Dropdown, Ui.Menu and Ui.Context are Flux's”; “feat(ui)!: Ui.Table is Flux's table, with its columns, rows and cells”; “feat(ui)!: Ui.Header and Ui.Sidebar are Flux's layouts”; and 40 more.

src/Rask.Site/Features/UiKit · medium confidence · unverified

45 commits (6 fixes) modifying src/Rask.Server/App

A change to existing behaviour in src/Rask.Server/App — 45 commits (6 fixs), 30 files: “refactor!: remove every island from the framework”; “feat(pdf): a RaskApp finds Rask.Pdf by itself, and Pdf.From works in an endpoint”; “fix(pdf): a hand-wired AddRask() host prints once Rask.Pdf is referenced”; and 42 more (refs \#1216).

src/Rask.Server/App · medium confidence · unverified

48 commits (8 fixes) modifying scripts/lib

A change to existing behaviour in scripts/lib — 48 commits (8 fixs), 27 files: “ci: restore the workload cache into a runner-owned SDK, pin the runner image, and bring the docs in line”; “test(devtools): add a browser E2E gate that drives the real panel against a live Server page”; “fix(ci): give every nightly commit its own version and refuse a version from two commits”; and 45 more (refs \#728, \#847, \#924, \#969, \#925, …).

scripts/lib · medium confidence · unverified

5 commits (1 fix) modifying src/Rask.Core/Http

A change to existing behaviour in src/Rask.Core/Http — 5 commits (1 fix), 1 file: “feat(core)!: navigate with Go and hand over files with Download”; “refactor(core)!: lifecycle hooks keep their On — OnMount, OnUpdated, OnFirstRender, OnRendered, OnUnmount”; “fix(cli): point the retired language flags at Rask:Cultures; refresh stale comments”; and 2 more (refs \#865).

src/Rask.Core/Http · medium confidence · unverified

57 commits (12 fixes) modifying src/Rask.Templates

A change to existing behaviour in src/Rask.Templates — 57 commits (12 fixs), 61 files: “test(templates): build every template, not the four that had a gate”; “feat(cli): F5 in VS Code runs the app as a dev session under the debugger”; “feat(storage)!: Files.Save(…).Public(), Files.Share(id).For(15.Minutes)”; and 54 more.

src/Rask.Templates · medium confidence · unverified

63 commits (11 fixes) modifying src/Rask.Site/Features/UiDocs

A change to existing behaviour in src/Rask.Site/Features/UiDocs — 63 commits (11 fixs), 656 files: “docs(site): give each actions page a Behaviour section with the rules ui-kit.md had”; “feat(ui): add Flux's scrollable on the navbar and label on its items”; “feat(ui): the page header is always the h1 and keeps no room, Ui.Empty takes its cell's ink”; and 60 more.

src/Rask.Site/Features/UiDocs · medium confidence · unverified

7 commits (1 fix) modifying src/Rask.Site/wwwroot

A change to existing behaviour in src/Rask.Site/wwwroot — 7 commits (1 fix), 3 files: “test(ui): the showcase holds the native feel on a desktop and a phone, and parity departs for it”; “refactor(site): typeset the guides with Tailwind's typography plugin”; “fix(site)!: follow the OS theme, and make every palette readable”; and 4 more.

src/Rask.Site/wwwroot · medium confidence · unverified

7 commits (1 fix) modifying src/Rask.Templates/server/Features/Home

A change to existing behaviour in src/Rask.Templates/server/Features/Home — 7 commits (1 fix), 1 file: “feat(cli): scaffolded pages reach routing, forms, browser, live and auth with no using”; “feat(cli)!: rask new writes only the server, wasm and wasm-hosted templates”; “docs: say only true things in the short words, and end runtime errors in a fix”; and 4 more.

src/Rask.Templates/server/Features/Home · medium confidence · unverified

9 commits (0 fixes) modifying scripts/mdn

A change to existing behaviour in scripts/mdn — 9 commits, 7 files: “ci(upstream): one registry of followers, and a gate that every generator is on it”; “build(mdn): snapshot the element surface from the latest MDN data”; “feat(core): typed ARIA roles and attributes generated from the WAI-ARIA spec”; and 6 more.

scripts/mdn · medium confidence · unverified

9 commits (3 fixes) modifying src/Rask.SqlServer

A change to existing behaviour in src/Rask.SqlServer — 9 commits (3 fixs), 11 files: “fix(sqlserver): every open puts the session back to read committed in the settings batch”; “feat(sqlserver): Rask:SqlServer:SplitQueries turns split queries on for every context”; “feat!: build src/ analyzer-clean under Meziantou, Roslynator, Sonar and banned APIs”; and 6 more (refs \#734, \#574).

src/Rask.SqlServer · medium confidence · unverified

Authentication API simplification and session revalidation

The authentication surface has been streamlined: methods previously suffixed with 'Async' (such as EnsureLoaded, Refresh, and SignIn) are now synchronous in name, and the SignIn method now supports a 'persistent' flag for 'remember me' sessions. A new ISessionRevalidator interface allows the system to verify live session validity on every event, ensuring that sessions ended elsewhere or with expired tokens are immediately invalidated. Additionally, the framework now provides extension methods to extract the user ID and session ID from a ClaimsPrincipal, and introduces a new IAuth interface to centralize account management including registration, sign-in, sign-out, and passkey support.

src/Rask.Core/Authentication · high confidence

Automatic query refresh after data mutations in WebAssembly apps

The Rask Data library now automatically invalidates and refetches cached queries for affected entity types whenever a save operation (Create, Update, or Delete) occurs. This is achieved by registering a \QueryDataChanges\ handler that listens for write events and triggers cache invalidation via \QueryClient.Invalidate\, ensuring the UI reflects the latest server state without requiring manual cache management or explicit app code to handle post-write refreshes.

src/Rask.Data/Browser · high confidence

Browser API demos now use Rask.Web and Flux UI components

The site's browser feature demos (Battery, BroadcastChannel, Clipboard, Cookies, Crypto, DeviceSensors, FileSystemAccess, Gamepad, Geolocation, GestureBridge, IndexedDb, IntersectionObserver, MediaQuery, MediaSession, MutationObserver, NavigatorInfo, NetworkInfo, and Notifications) have been rewritten to use the new Rask.Web API wrappers and the Flux-based UI kit. Users will see these demos rendered with the new Ui.Card, Ui.Button, Ui.Input, and Ui.Textarea components, and the underlying browser interactions now rely on direct MDN API access via Rask.Web types instead of previous wrapper abstractions.

src/Rask.Site/Features/Browser · high confidence

CLI output and help system overhauled for reliability and consistency

The CLI's user-facing output has been completely rewritten to ensure that piped output, CI logs, and captured test results remain byte-for-byte identical to terminal output, with no accidental word-wrapping or color injection. This is achieved by introducing a custom argument parser and a Spectre.Console-based rendering layer that explicitly disables ANSI capabilities when output is redirected, while also providing structured JSON reports for commands like \deploy status\, \doctor\, and \dev --dry-run\. The help system now dynamically reflects the command schema, and the tool includes a new \doctor\ command to diagnose environment issues and a \branding\ module that safely renders the logo only on capable terminals.

src/Rask.Cli · high confidence

Centralized template catalog for rask new scaffolding

The CLI now uses a single \TemplateCatalog\ to define all available project templates (Server, WASM, WASM-hosted, TypeScript SPAs, and Meta frameworks) and their supported feature flags. This centralizes the source of truth for what \rask new\ can generate, ensuring consistency between the command-line parser, the scaffolding logic, and tests. The catalog explicitly documents which templates support localization, database batteries, and other options, and clarifies why certain flags (like \ops\ or \pwa\) are restricted to specific template types based on runtime dependencies and client-side requirements.

src/Rask.Cli/Templates · high confidence

Component factory generator refactored into partial files with new asset pairing and diagnostics

The ComponentFactoryGenerator has been restructured into multiple partial files (ChainStates, ComponentModel, Diagnostics, DocComments, Entries, EntryHosts) to improve maintainability. A new AssetPairing utility normalizes file paths to correctly pair sibling scoped CSS/JS files with components, resolving macOS path aliasing issues. The generator now emits a state-machine-based chain API where required properties are enforced as sequential steps, and diagnostics (RASK001, RASK002, RASK036, RASK040, RASK041) provide clearer error messages for missing required properties, constructor conflicts, and entry collisions.

src/Rask.Generators · high confidence

Consolidated PWA and device-capability demos into a single page

The site now presents thirteen previously separate device and PWA demos (including Bluetooth, HID, Web Serial, Fullscreen, and Push) as sections within a single \PwaPage\. This page features a dynamic navigation rail generated from the demo list and preserves all original URLs via route aliases to prevent 404s for existing bookmarks. The individual demo components (e.g., \BluetoothDemo\, \HidDemo\) have been moved into this unified layout, replacing the old sidebar structure.

src/Rask.Site/Features · high confidence

Core framework refactoring and performance optimizations

This update introduces significant internal refactoring to the Rask.Core library, including the introduction of \AppCapture\ for testing entry points, \AttrBag\ for optimized attribute storage, and \AutoCallback\ to automatically manage parent re-renders for delegate props. It also adds \Auth\ and \AuthorizeSteps\ for authentication flows, \Battery\ for configurable feature toggles, and \ChildText\ for invariant culture rendering. Performance improvements include optimized child handling in \Component.Children.cs\ using pooled arrays and reduced allocations in \Component.AriaAttributes.cs\. These changes enhance the framework's internal stability, testing capabilities, and runtime efficiency.

src/Rask.Core · medium confidence

Dashboard console now uses scoped daisyUI theme via Tailwind

The dashboard console's styling has been rebuilt to use the internal Rask.Ui component kit powered by daisyUI. A new stylesheet (dashboard.css) is introduced to import Tailwind's theme and utilities along with the scoped kit, ensuring the theme (light/dark) is contained within the console and does not leak into the rest of the application. This replaces previous styling approaches with a mobile-first, utility-based design system managed by the project's own Tailwind build.

src/Rask.Dashboard/Styles · high confidence

Editor F5 launches now serve on a .test domain with automatic HTTPS

When launching via F5 in the editor, the application now automatically configures and serves itself on a local \<code\>.test\</code\> hostname (e.g., \<code\>https://&lt;name&gt;.test\</code\>) using a development certificate and key, rather than relying solely on standard localhost addresses. This behavior is active only when the environment is detected as a development session and prerequisites like the hosts file entry and certificate files are present; it is explicitly skipped for projects using islands to avoid HTTPS/HTTP mixed-content issues with the Vite dev server.

Rask.DevTools · high confidence

Enforced local development gates for formatting, unit tests, and commit conventions

Developers now have local Git hooks installed that enforce coding standards and test coverage before changes leave the machine. The pre-commit hook runs \dotnet format\ and the unit test suite scoped to affected projects, ensuring code is formatted and tests pass before a commit is created. The pre-push hook re-runs the unit gate with a strict one-minute budget to prevent pushing broken code, while also verifying that no commits contain prohibited attribution trailers (like Co-authored-by) which are banned to maintain a single-contributor history. The commit-msg hook enforces Conventional Commits syntax. These gates replace previous CI-only checks, shifting the responsibility for fast feedback to the developer's local environment.

.githooks · high confidence

Fail boot if enabled battery tables are missing from the EF Core model

The application now fails to start if an enabled battery's entity types are not mapped in the DbContext model. Previously, missing mappings caused runtime failures on the first request that touched the unmapped battery; the new startup check detects this immediately and provides a clear error message with the exact code fix required.

src/Rask.Batteries.Shared · high confidence

Improved session resilience with credential monitoring and HTTP fallback

The server runtime now includes a client-side credential watcher that periodically verifies the browser's authentication cookie against the server, automatically reconnecting the live session if the user signs in or out in another tab. Additionally, if a WebSocket connection fails to open, the client automatically falls back to a long-polling HTTP transport (using Server-Sent Events and POST requests) to maintain the live session, ensuring continuous connectivity without requiring manual configuration.

src/Rask.Server/Resources · high confidence

Lifecycle demo components now use fixed-table hook status instead of dynamic logs

The Lifecycle feature demos (LifecycleCycleDemo, LifecycleCycleProbe, LifecycleProbe) have been refactored to present hook execution status in a stable, fixed-table layout rather than appending dynamic log entries. This ensures the markup structure remains constant regardless of render timing, fixing issues where demo snapshots failed due to changing DOM shapes and improving the clarity of the lifecycle guide by showing all hook statuses upfront.

src/Rask.Site/Features/Lifecycle · high confidence

Migrate scoped CSS/JS to per-component content-addressed assets

The WASM client runtime and build pipeline have been refactored to replace the previous global scoped-style injection and monolithic JavaScript bootstrap with a content-addressed asset model. The old \index.html\ shell, \main.js\ bootstrapper, and \rask.wasm.js\ event-dispatch module have been removed in favor of a new \PublishedAssetRepair\ pass that runs post-publish to regenerate compressed siblings (\.br\, \.gz\) and repair endpoint manifests, ensuring prerendered pages are served correctly alongside their assets. This change eliminates the need for manual \wwwroot\ boilerplate by baking scoped assets directly into the published output, fixing issues where precompressed siblings served stale shells instead of prerendered content.

Rask.Wasm · high confidence

New binding behavior demos for the Rask UI kit

The site now includes a set of demonstration components in the Binding feature area that showcase the framework's data-binding capabilities. These demos illustrate live two-way binding for various input types (text, textarea, select, checkbox, date picker), handling of nullable and non-nullable types, clearing default values, manual input handling, and asynchronous post-binding logic for dependent fields.

src/Rask.Site/Features/Binding · high confidence

New toast notification system with structured messaging and error handling

The application now uses a dedicated toast notification system for transient user messages, replacing the previous flash-message pattern. This change introduces a scoped \IToaster\ service that queues messages (Info, Success, Warning, Error) and allows them to survive client-side navigations. Users will see structured toasts that can include headings, action buttons, and links, with automatic dismissal or manual dismissal options. The system also handles error reporting: handler failures and authorization refusals now display specific error toasts to users while preserving the current page state. In development mode, error toasts include exception details for debugging, while production mode shows generic user-friendly messages. The messaging layer also supports field-level validation failures, consolidating multiple validation errors into single, readable toast notifications.

src/Rask.Core/Messaging · high confidence

Optimized asset serving and page compression in the HTTP pipeline

The server now serves the client runtime and the app's stylesheet as hashed, compressed assets with long-term browser caching, and compresses the HTML page document on-the-fly. Additionally, the initial response now injects localized connection text for the offline overlay and includes a script tag for on-demand behavior hooks, while enforcing strict no-store caching on page responses to protect session IDs.

src/Rask.Server/Http · high confidence

PDF footers now display page numbers in the user's language

The PDF generation now includes localized page numbers in the footer, determined by the current UI culture of the user. This change introduces a new \PrintCaller\ record in the \Rask.Pdf\ project to encapsulate the user's identity, culture, and the generated HTML for page numbers, ensuring that the printed output respects the caller's language settings.

Rask.Pdf · high confidence

Rask replaces ASP.NET Core Identity with a custom authentication system

The Rask.Auth.Api module introduces a new, self-contained authentication stack that replaces ASP.NET Core Identity. This change introduces a custom \Authenticatable\ user aggregate that manages credentials, roles, and tenant context directly, issuing a \ClaimsPrincipal\ that includes the user's tenant ID and custom claims. Session management is now handled by a dedicated \AuthSessions\ service that reads the session row from the database on every resume and revalidation, ensuring that session endings, role changes, or user deletions take immediate effect across all devices without relying on per-process caching. The system also adds support for passkey (WebAuthn) sign-ins via a new \Passkey\ aggregate and enforces stricter security by requiring non-nullable form fields and using compiled LINQ queries for efficient session lookups.

Rask.Auth.Api · high confidence

Rask.Data introduces a trait-based entity model with new search and constraint capabilities

The Rask.Data library has been refactored to use a new trait-based architecture where entities and aggregates declare their behavior (such as timestamps, versioning, soft deletion, and tenant isolation) via type arguments rather than base class inheritance. This change introduces new base classes (Aggregate and Entity) and trait interfaces that allow developers to compose entity features flexibly. Additionally, the library now supports full-text search on PostgreSQL and SQLite, JSON path indexing, and non-overlapping range constraints enforced by database triggers, providing more robust data integrity and search capabilities out of the box.

Rask.Data · high confidence

Rask.Site restructured as a WASM-first showcase with self-hosted fonts and unified theming

The site is now a browser-WASM application that self-hosts and preloads Latin font subsets to eliminate layout shifts during hydration, and applies dark mode via a single \dark\ attribute on the root element. It registers example services (DI, CQRS, query caching) for live demos, generates guide history dates at build time, and exposes an AI-friendly \/llms.txt\ face during publishing.

src/Rask.Site · high confidence

Refactored builder runtime to support chained class joining and deferred change tracking

The builder runtime in \src/Rask.Core/Builder\ has been restructured to support a new chaining model where multiple \.Class(...)\ calls accumulate rather than replace each other, and to optimize change detection for these joined values. New files introduce \ClassWatchEntry\ and \SettleClasses\ to defer class-change reporting until the end of a render pass, preventing false positives when intermediate chain steps differ from the previous render's final state. The \JoinClasses\ and \JoinClass\ methods now handle the logic for merging class parts, trimming whitespace, and managing pending bits to ensure that only the final accumulated class list triggers a component update. Additionally, \CopyClass\ ensures that class state is correctly transferred when a \Key\ step reuses an existing component instance.

src/Rask.Core/Builder · high confidence

Refactored server-side page rendering into a cancellable, session-based pipeline

The server's GET page render logic has been extracted from the HTTP handler into a dedicated, cancellable \PageRender\ service. This change introduces a structured rendering pipeline where page input (path, user, culture) is prepared before the initial render, and the resulting HTML is shaped into a response by \PageDocument\ (injecting session IDs, dev attributes, and devtools scripts). The new model supports explicit handling of redirects during render (including safe sanitization for external exits) and precise HTTP status code determination based on faults, declared status, not-found mounting, and authorization guards.

src/Rask.Server/Prerender · high confidence

Reliable hot reload with ordered asset refresh and accurate status reporting

The hot reload mechanism now uses a single, ordered pipeline to ensure scoped CSS and JavaScript assets are fully refreshed before routes and session re-renders occur, preventing visual glitches from partial updates. Additionally, the system only signals that a hot reload has been applied when a page actually repaints, fixing a bug where the UI incorrectly announced success for edits that did not result in visible changes.

src/Rask.Core/HotReload · high confidence

Removal of authentication and weather API endpoints from the WASM host

The Rask.Example.Wasm.Host project has been refactored to remove its previous role as a standalone authentication and API server. The AuthEndpoints.cs file, which handled user login, logout, and profile retrieval using cookie-based authentication, has been deleted. Consequently, Program.cs no longer configures authentication services, maps auth or weather forecast API routes, or registers the LocalWeatherForecastService. The launch settings for the host project have also been removed, indicating a shift in how this example is structured or hosted.

Rask.Example.Wasm.Host · high confidence

Replace ASP.NET Core Identity with custom session-based authentication

The application has replaced ASP.NET Core Identity with a custom authentication system. This change introduces a new \SessionUserProvider\ that tracks the current user for live sessions and raises events to trigger UI re-renders when the user state changes. It also adds an \AuthTicket\ and \AuthTicketStore\ mechanism to manage short-lived, one-time redeemable tokens for sign-in and sign-out actions, ensuring that session identity is handled independently of the framework's built-in identity providers.

src/Rask.Server/Authentication · high confidence

Server-side file upload/download with resource-exhaustion limits

The server now manages file uploads and downloads via session-scoped temporary stores that enforce strict resource limits to prevent exhaustion attacks. Uploads are capped by a maximum single-file size (default 50 MB), a maximum number of files per request (default 16), and an optional cumulative per-session byte quota (default 256 MB) that rejects excess staging with a 413 status. Downloads are similarly staged in temporary files or memory, with automatic cleanup on session end or after consumption. These changes introduce new internal components (RaskUploadOptions, SessionUploadStore, SessionDownloadStore, and related backend/sink classes) to handle file I/O safely within the server's file handling subsystem.

src/Rask.Server/Files · high confidence

Structured diagnostic reporting with error references

The framework now routes internal faults through a new diagnostic seam (RaskDiagnostics) that produces structured events instead of raw Console.Error output. For users, this means unhandled exceptions are no longer silently swallowed or exposed in production; instead, a unique error reference is generated and displayed, allowing users to report issues while keeping sensitive stack traces hidden. Additionally, prerendering failures are logged as informational messages rather than failing the build, and duplicate key warnings are deduplicated to prevent log spam.

src/Rask.Core/Diagnostics · high confidence

Unified shape definitions for Rask generators and analyzers

The \src/Rask.Generators.Shared\ library now provides a single, shared source of truth for the structural definitions used by Rask's data generators and analyzers. This change consolidates the logic for identifying entities, aggregates, and value objects (\AggregateShape\), defining composite keys (\CompositeKeyShape\), and describing the shape of generated models (\GeneratedModelShape\), read faces (\ReadModelShape\), and their members. By centralizing these definitions, the generators and analyzers no longer risk drifting from each other, ensuring that the generated code (models, read faces, diagnostics) remains consistent with the rules used to validate the source entities.

src/Rask.Generators.Shared · high confidence

Unified stylesheet and dark-mode-aware typography for guides

The site now uses a single compiled stylesheet (app.css) that integrates the Rask UI kit and Tailwind utilities, ensuring consistent layering and dark-mode support via the kit's theme tokens. Documentation guides benefit from Tailwind's typography plugin, which is configured to use the site's UI palette for text, links, and backgrounds, ensuring readability in both light and dark modes. Additionally, prose elements like tables, inline code, and blockquotes are styled to match the brand's design system, with specific adjustments for scroll behavior and overflow handling.

src/Rask.Site/Styles · high confidence

WASM host now reports boot failures and forwards framework diagnostics to the browser console

Developers will now see explicit error messages in the browser UI if the WebAssembly app fails to start, replacing the previous behavior where a boot failure left the user with an infinite spinner. Additionally, framework diagnostics and warnings are now forwarded to the browser console via a new logging provider, ensuring that issues like navigation faults or malformed frames are visible during development rather than being silently discarded.

src/Rask.Wasm · high confidence

Fixes

7 commits (4 fixes) fixing src/Rask.Server/Transport

A fix in src/Rask.Server/Transport — 7 commits (4 fixs), 8 files: “feat!: build src/ analyzer-clean under Meziantou, Roslynator, Sonar and banned APIs”; “feat(server): log the live-session lifecycle on Rask.Live”; “fix(live): log the close reason, repaint only replaced assets, never hold frames on a failed reopen”; and 4 more.

src/Rask.Server/Transport · medium confidence · unverified

Fix for silent empty bundles caused by MSBuild node reuse

Resolves an issue where publishing a WebAssembly app could result in a broken bundle with missing scoped CSS/JS files (404s) without any build errors. This was caused by MSBuild node reuse loading assemblies incorrectly, preventing the asset registry from being read. The new \BakeScopedAssetsTask\ detects this specific race condition and now fails the build with a clear error message, instructing users to re-run with \-nodeReuse:false\ or from a fresh process.

src/Rask.Wasm.Tasks · high confidence

Fixes parsing of nested error objects in API problem documents

The Rask API client now correctly handles RFC 9457 problem documents that contain nested objects, specifically the 'errors' field used for field-level validation. Previously, the client's manual JSON parsing would fail or drop data when encountering nested structures; this update ensures that validation errors are properly extracted and exposed to the user instead of being silently ignored.

Rask.Api.Client · high confidence

Hot-reload now replaces generated registries instead of merging them

The CqrsRegistry in Rask.Cqrs now uses a replace-based strategy for assembly-generated dispatch tables, ensuring that during hot-reload, the new code completely swaps the old handlers rather than appending to them. This prevents stale or duplicate handlers from persisting in memory after a code change, fixing an issue where updated logic might not take effect immediately or correctly.

Rask.Cqrs · high confidence

Invariant CSS scope hash generation

The CSS scoping logic in Rask.Core now generates deterministic scope identifiers regardless of the system's regional settings. By explicitly using \CultureInfo.InvariantCulture\ when formatting hash bytes, the tool prevents potential mismatches in scope classes that could occur on systems with different number formatting conventions, ensuring consistent styling across different environments.

src/Rask.Core/ScopedCss · high confidence

Scaffolded authentication pages now compile and handle email confirmation correctly

The scaffolded sign-in pages in the Auth feature now compile successfully in a real application. This includes a fix for the email confirmation flow: when a user attempts to sign in with an email address that has not yet been confirmed (and email confirmation is required), the system now treats the attempt as a request to re-send the confirmation link rather than failing with a generic error. The scaffolded pages (Login, Register, ForgotPassword, ResetPassword, ConfirmEmail, Logout, and Devices) are now fully functional with proper error messaging and passkey support.

src/Rask.Templates/server/Features/Auth · high confidence

Test coverage

100 commits adding/updating tests in scripts/tests; 1959 commits adding/updating tests in tests; 9 commits adding/updating tests in tests/Rask.Site.Tests; Added comprehensive server-side integration tests for API validation, live sessions, and data handling; Added initial test coverage for the Home page in server and WASM templates; Added skill to drive and smoke-test the Rask CLI; Added tests for ComponentFactoryGenerator behavior and WASM compatibility; Removed StubApp test infrastructure component; Removed WebSocket integration tests; Removed component unit tests for HTML elements and validation helpers; Removed legacy E2E smoke tests for Server and Wasm examples; Removed legacy E2E test infrastructure fixtures; Removed legacy Forms test suite; Removed legacy ScopedCssRegistry tests; Removed legacy test files for LivePayload and StubComponent; Removed lifecycle and rendering tests; Removed obsolete test coverage for legacy Component types; Removed obsolete test files for hosting and session components; Removed obsolete test infrastructure and authentication tests; Removed tests for legacy endpoint functionality.

Dependencies

Centralized dependency management and security patches for SQLite and cryptographic libraries

The project now uses Central Package Management (Directory.Packages.props) to pin all dependency versions, ensuring consistency across the solution. This update explicitly upgrades SQLitePCLRaw to the 3.x family to mitigate [CVE redacted] (memory corruption in SQLite 3.49.1) by bundling the patched SQLite 3.53.4, and raises System.Security.Cryptography.Pkcs to 10.0.13 to address [CVE redacted] and [CVE redacted]. Additionally, the test framework is upgraded to xUnit v3, and various Microsoft .NET platform packages are pinned to version 10.0.13.

(dependencies) · high confidence

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

How this codebase got here

Score

  • CAI 43 → 54 (+11.0)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.2) — scores are not directly comparable.

Lenses

  • Code Health 66 → 59 (-6.5)
  • Architecture 71 → 68 (-3.3)
  • Maturity 42 → 69 (+27.4)
  • Readiness 34 → 47 (+12.8)
  • Security 66 → 65 (-0.7)
  • Domain Modelling 78 → 78 (+0.1)
  • Accessibility 45 → 54 (+9.5)
  • Performance 76 → 77 (+1.6)

Resolved (305)

  • AnalyzerSeverityNone repeated across 10 files (src/Rask.Templates/wasm/.editorconfig)
  • ClassTooLong: Ui (src/Rask.Ui/Ui.ThemeName.cs)
  • Coverage not measured — JavaScript/TypeScript suite
  • Cross-context type PushSubscriber (Rask.WebPush → Rask.Server) (src/Rask.Server/BrowserPushSubscriptions.cs)
  • Cross-context type StorageProvider (Rask.Storage → Rask.Dashboard) (src/Rask.Dashboard/Panels/ProviderUsage.cs)
  • Cross-context type StorageProvider (Rask.Storage → Rask.Dashboard) (src/Rask.Dashboard/Panels/StorageStats.cs)
  • Cross-context type StorageProvider (Rask.Storage → Rask.Dashboard) (src/Rask.Dashboard/Panels/StoredFileRow.cs)
  • DevToolsPageErrorReceiver.Record (cyclomatic 18) (src/Rask.DevTools/Panel/DevToolsPageErrorReceiver.cs)
  • DevToolsTreeSnapshotter.BadgeOf (cyclomatic 18) (src/Rask.DevTools/Probe/DevToolsTreeSnapshotter.cs)
  • Duplicated block (10 lines × 2) (src/Rask.External.Tasks/ExternalIslandMetadata.cs)
  • Duplicated block (10–11 lines × 2) (src/Rask.Ui/UiNavmenu.cs)
  • Duplicated block (12 lines × 2) (src/Rask.Core/Dom/HTMLInputElement.cs)
  • Duplicated block (12 lines × 2) (src/Rask.Generators/External/ExternalGenerator.cs)
  • Duplicated block (14 lines × 2) (src/Rask.External.Tasks/ExternalBuildPlan.cs)
  • Duplicated block (15–24 lines × 2) (src/Rask.Ui/UiCalendarControl.cs)
  • Duplicated block (17 lines × 7) (src/Rask.Templates/angular/Features/Hello/HelloHandlers.cs)
  • Duplicated block (17–18 lines × 2) (src/Rask.Cli/Dev/DevBuildWatcher.cs)
  • Duplicated block (20 lines × 2) (src/Rask.External.Tasks/ExternalPackageSpecifier.cs)
  • Duplicated block (22 lines × 5) (src/Rask.Ui/UiComposer.cs)
  • Duplicated block (22–23 lines × 2) (src/Rask.Ui/UiBadge.cs)
  • …and 285 more

New (338)

  • (anonymous) (cognitive 45) (src/Rask.Pdf/PrintTables.js)
  • (anonymous) (cyclomatic 36) (src/Rask.Pdf/PrintTables.js)
  • AnalyzerSeverityNone (src/Rask.Templates/server/.editorconfig)
  • AnalyzerSeverityNone (src/Rask.Templates/wasm-hosted/.editorconfig)
  • AnalyzerSeverityNone (src/Rask.Templates/wasm/.editorconfig)
  • ClassTooLong: AccountService (src/Rask.Auth.Api/AccountService.cs)
  • ClassTooLong: CqrsCodecGenerator (src/Rask.Batteries.Generators/CqrsCodecGenerator.cs)
  • ClassTooLong: ParityMenu (scripts/flux/Flux/Commands/ParityMenu.cs)
  • ClassTooLong: ReadModelGenerator (src/Rask.Batteries.Generators/ReadModelGenerator.cs)
  • ClassTooLong: Ui (src/Rask.Ui/Ui.DateRangePreset.cs)
  • ClassTooLong: UiDocsCatalog (src/Rask.Site/Features/UiDocs/UiDocsCatalog.cs)
  • ClearPlacement.Judge (cognitive 25) (scripts/flux/Flux/Commands/ClearPlacement.cs)
  • ClearPlacement.Judge (cyclomatic 17) (scripts/flux/Flux/Commands/ClearPlacement.cs)
  • ClearPlacement.Run (cognitive 40) (scripts/flux/Flux/Commands/ClearPlacement.cs)
  • ClearPlacement.Run (cyclomatic 18) (scripts/flux/Flux/Commands/ClearPlacement.cs)
  • ConstraintNameConvention.ProcessModelFinalizing (cognitive 21) (src/Rask.Data/ConstraintNameConvention.cs)
  • DateFlip.Run (cognitive 28) (scripts/flux/Flux/Commands/DateFlip.cs)
  • Duplicated block (10–11 lines × 2) (src/Rask.Ui/UiNavmenu.cs)
  • Duplicated block (12 lines × 5) (src/Rask.Site/Features/UiDocs/Examples/HeaderInsetExample.cs)
  • Duplicated block (13 lines × 2) (scripts/flux/Flux/Commands/ParityMenu.cs)
  • …and 318 more

Changes since last survey

  • 300 commits — 246 feature/other, 54 fixes

By area

  • (repo) — 105 commits
  • (root) — 32 commits
  • src/Rask.Core — 20 commits
  • scripts/flux — 15 commits
  • src/Rask.Ui — 14 commits
  • src/Rask.Site — 12 commits
  • src/Rask.Server — 9 commits
  • .github/workflows — 8 commits
  • src/Rask.Cli — 8 commits
  • tests/Rask.Ui.Tests — 8 commits
  • tests/Rask.Site.E2E.Tests — 7 commits
  • .claude/skills — 5 commits
  • scripts/lib — 5 commits
  • tests/Rask.Server.E2E.Tests — 5 commits
  • src/Rask.Data — 4 commits
  • src/Rask.Auth.Api — 3 commits
  • src/Rask.Templates — 3 commits
  • tests/Rask.Core.Tests — 3 commits
  • docs/testing.md — 2 commits
  • tests/Rask.Benchmarks — 2 commits

Notable commits

  • fix: Merge remote-tracking branch 'origin/main' into fix/render-outside-handler-scope
  • fix: Merge remote-tracking branch 'origin/main' into fix/render-outside-handler-scope
  • fix: chore: bring main into fix/choice-only-drawn-values
  • fix: chore: bring main into fix/disabled-elements-typed-limits
  • fix: fix(blazor): a disabled control inside a hosted component takes no event
  • fix: fix(blazor): a hosted EditForm submits, and an oninput bind on a checkbox gets a bool
  • fix: fix(ci): the WASM E2E gate names its project's .csproj literally, as the coverage test reads it
  • fix: fix(cli): a refused docker-socket forward is named in ssh's own words and given up at once
  • fix: fix(cli): pin the scaffold's EF Core design package to the EF version Rask is built against
  • fix: fix(cli): point the retired language flags at Rask:Cultures; refresh stale comments
  • fix: fix(cli): the deploy lab's sshd forwards, and a tunnel that falls back says why
  • fix: fix(core): Format.Moment writes a 24-hour hour in two digits, so moments line up
  • fix: fix(core): a swipe leaves an open popover, dropdown or menu open; a tap outside still closes it
  • fix: fix(core): file a chain into the tree only from the walk on this thread, not after an await
  • fix: fix(core): scope an unkeyed component in a keyed row by that row's key
  • fix: fix(data): run a read face nested in another's query instead of overflowing the stack
  • fix: fix(flux): parity finds its page by place, so command-open runs with --prepare command-open
  • fix: fix(forms): a bound select takes only a value one of its options offered
  • fix: fix(forms): a disabled bound control and a Ui.Tabs take only what the reader could send
  • fix: fix(forms): a disabled control takes no event, and a picker says why it refused a typed limit
  • …and 280 more

Architecture

  • Containers 0 added · 0 removed · contexts 1 added · 1 removed · edges 2 added · 0 removed

Added bounded contexts (1)

  • scripts

Removed bounded contexts (1)

  • Rask.Generators

Added dependency edges (2)

  • Rask.Server → Rask.Wire
  • Rask.Testing → Rask.Wire

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

Survey your own repository

pal-tamas/rask 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.

About this page

  • The score is its most recent published measurement, taken on 8 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit 00d5ba0b1814d64b090bd95c14d7168e17a533dc — the exact code this score is about.
  • Scored under rubric-2026.11.2 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.3+preprod-45ab2cab63de.