pal-tamas/rask

Rask is a .NET web framework that enables server-side rendering of interactive UIs using C\# components, while supporting integration with major frontend frameworks like React, Vue, and Angular via 'islands'. It provides a comprehensive, database-backed infrastructure for authentication, data access, background jobs, and caching, eliminating the need for external services. The system features a robust CLI for scaffolding and development, along with built-in tools for local HTTPS, hot reloading, and developer diagnostics.

The new Rask.Postgres package provides an opt-in Entity Framework Core provider for PostgreSQL, serving as a drop-in replacement for UseNpgsql. It automatically configures production-grade session defaults—including statement, lock, and idle-in-transaction timeouts—and enables Npgsql's transient-failure retry strategy. These settings are bound from the Rask:Postgres configuration section, allowing users to easily scale beyond SQLite's single-file limitations to managed databases or read replicas.

src/Rask.Postgres · high confidence

The new Rask.SqlServer package provides an opt-in Entity Framework Core provider that replaces the standard UseSqlServer with production-hardened defaults. It automatically applies SET XACT\_ABORT ON and a configurable LOCK\_TIMEOUT on every connection open to prevent lock-holding bugs, enforces a client-side command timeout (default 30s) since SQL Server lacks a server-side equivalent, and enables transient-failure retrying. It also includes a specific convention to cap the Rask.Cache key length at 450 characters to comply with SQL Server's 900-byte index key limit, preventing silent insert failures for cache entries.

src/Rask.SqlServer · high confidence

The site now includes two new interactive demo pages. The Cancellation demo allows users to mount and unmount a probe component to observe how asynchronous operations are cancelled via lifetime tokens, with outcomes logged in a list. The CQRS demo demonstrates a counter application using the Rask.Cqrs library, showcasing queries, commands with results, notifications, and pipeline behaviors, with state and dispatch logs displayed in the UI.

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

The site's static image directory now includes a WebVTT caption file for video content, a branded SVG logo (rask-mark.svg), and a placeholder SVG graphic (rask-placeholder.svg). These additions provide the necessary visual assets and accessibility captions for the site's media and branding elements.

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

The Rask.Site project now includes a set of new demo components under src/Rask.Site/Features that illustrate core framework capabilities. These include Primitives demos for text, fragments, doctype, and raw HTML; Routing demos for nested layouts and page navigation with SEO considerations; Scoped CSS demos showing component-specific styling isolation; and SVG demos covering clickable swatches, gradients, shapes, and text. These files serve as interactive examples and documentation for the site's feature showcase.

(repo-wide) · high confidence

This change introduces a set of new demonstration components within the site's feature directory to showcase the framework's capabilities. In the Navigator area, \NavigatorDemo\ and \NavigatorQueryDemo\ illustrate how to use the scoped \Navigator\ service to mutate the route path and query parameters declaratively without JavaScript. In the Props area, several new demos (\PropsAriaDemo\, \PropsAttributeOrderDemo\, \PropsAttributesDemo\, \PropsCommandDemo\, \PropsDataDemo\, and \PropsIdClassStyleDemo\) demonstrate specific UI element properties, including ARIA attribute handling, custom data attributes, command-based dialog interactions, and standard HTML attribute ordering.

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

A new DownloadDemo component has been added to the site's download feature area, providing a user-facing interface to generate and download text reports. The component renders a primary button labeled "Download report" which, when clicked, increments a counter and triggers a file download of a generated text file named "report.txt" containing the generation timestamp and count. A status message below the button displays the total number of times the report has been generated.

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

New demo components have been added to the site to showcase the framework's UI library and event system. The ElementRef feature is demonstrated with a component that passes DOM elements to JavaScript for measurement and focuses inputs programmatically. The Events feature includes demos for pointer tracking (mouse move, enter, leave, wheel), double-clicks, context menus, focus/blur, keyboard input, and clipboard paste events. Additionally, form handling is demonstrated with a submit example, while input and select components show reactive value binding and change events.

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

The logging system now supports storing the application log in the app's own PostgreSQL or SQL Server database, in addition to the existing SQLite file store. This is enabled by calling \AddRaskLogging\<AppDbContext\>()\ and mapping the \RaskLog\ table via \modelBuilder.AddRaskLogging()\. The implementation uses a dedicated EF Core context per write to ensure log entries survive application transaction rollbacks, and captures the \ILogger\ scope state (e.g., request IDs) as JSON for structured querying. To prevent the store from capturing its own SQL execution logs, it uses an async-local marker to exclude its internal operations from the capture flow.

src/Rask.Logging · high confidence

The new Blazor source generator in Rask.Generators automatically reads the \[Parameter\] properties from a hosted Blazor component and generates the corresponding chain steps and parameter writer for the island. This eliminates the need to manually redeclare parameters, ensuring the island's interface stays in sync with the hosted component. The generator also enforces that islands are partial classes, ensures unique island names in rendered markup, and handles edge cases like generic container names to prevent generator crashes.

src/Rask.Generators/Blazor · high confidence

Rask now provides a dedicated client library for WebAssembly hosts, enabling browser-based applications to register, sign in, sign out, and manage passkeys using the same \IAuth\ and \IUserProvider\ interfaces used by server-rendered components. This implementation replaces the previous anonymous default user provider with an HTTP-based provider that reads the current user from the app's own \/api/auth/me\ endpoint, ensuring the authentication cookie is handled via same-origin requests without exposing tokens to JavaScript. The package also includes source-generated JSON serializers to support trimmed WebAssembly publishes and registers the necessary services via \AddRaskAuthClient()\.

src/Rask.Auth.Client · high confidence

A new MSBuild task in the Rask.Spa.Tasks project now extracts TypeScript source code embedded as constants in compiled assemblies and writes it to the front-end source tree. This ensures the client-side bundler compiles the same CQRS contracts and message types as the server, preventing runtime mismatches and keeping the front-end type definitions in sync with the back-end.

src/Rask.Spa.Tasks · high confidence

Rask now includes a complete HTTP API layer out of the box. The new Rask.Api package provides \AddRaskApi\ and \MapRaskApi\ to host standard ASP.NET Core MVC controllers and minimal API endpoints, featuring a configurable prefix (defaulting to \/api\) and a guard that returns a proper 404 Problem Document for unmatched API routes instead of falling through to the app's catch-all. Validation is built-in for both forms and HTTP requests, running DataAnnotations and FluentValidation asynchronously to ensure consistent error handling. Additionally, the framework now supports multi-tenant applications by automatically injecting the signed-in user's tenant into the request context, allowing data reads to be scoped to the user's tenant without manual configuration.

src/Rask · high confidence

The site now features a single \PwaPage\ that serves as a unified showcase for all PWA and device-capability demos, replacing the previous structure of thirteen separate pages. This page includes a generated navigation rail and hosts dedicated demo components for each capability, including \BluetoothDemo\, \EyeDropperDemo\, \FullscreenDemo\, \HidDemo\, \IdleDetectorDemo\, \InstallPromptDemo\, \JsRuntimeDemo\, \MediaDevicesDemo\, \OrientationDemo\, \PictureInPictureDemo\, \PwaDemo\, \SerialDemo\, and \UploadDemo\. The \PwaPage\ maintains backward compatibility by routing all former individual URLs (e.g., \/docs/wake-lock\, \/bluetooth\) to this new consolidated view. Each demo component demonstrates the corresponding typed C\# wrapper over browser APIs (such as Web Bluetooth, Web HID, Wake Lock, and Media Capture) in a live WebAssembly environment, ensuring that users can interact with these features directly in the browser.

src/Rask.Site/Features · high confidence

FluentValidation is now a built-in validation provider for Rask forms and requests. Developers can define validators using standard FluentValidation types (e.g., \AbstractValidator\<T\>\), and the framework automatically discovers and registers them at build time via a source generator. This eliminates the need for manual registration or custom component markup; forms and requests will automatically use these validators for both synchronous and asynchronous validation rules, including client-side field validation and server-side model validation.

src/Rask.Validation.FluentValidation · high confidence

The framework now supports per-session culture negotiation and rendering. Users can configure supported languages via \RaskCultureOptions\, after which the framework negotiates the visitor's culture from the URL query string, a persistent cookie, or client preferences, falling back to a default. The framework's own UI text (e.g., date pickers, error pages) is now translatable via a JSON catalog, and the \IRaskCulture\ service allows components to switch languages at runtime, triggering a re-render. Culture is persisted in a cookie (defaulting to ASP.NET's \.AspNetCore.Culture\ format) to survive page reloads, and the system handles right-to-left layouts and HTML \lang\/\dir\ attributes automatically.

src/Rask.Core/Globalization · high confidence

The \Rask.SQLite.EntityFrameworkCore\ provider now supports full-text search using SQLite's FTS5 engine. When an entity declares a full-text index via \HasFullTextSearch\, the provider automatically generates the necessary FTS5 virtual table and triggers to keep the index synchronized with the main table during inserts, updates, and deletes. Queries can use the \Search\ method to find matches, which are ranked by relevance, and the \FullText.Highlight\ and \FullText.Snippet\ methods to display context around the matched terms. The implementation handles both simple integer primary keys and more complex key types by using a key map table when necessary, and ensures the index is correctly rebuilt during migrations if the underlying table structure changes.

src/Rask.SQLite.EntityFrameworkCore · high confidence

A new source generator in the API layer now produces a strongly-typed client for every ASP.NET \[ApiController\] and minimal API endpoint. By reading the server's route templates, HTTP verbs, and parameter types at compile time, the generator creates C\# methods that replace manual URL string construction with type-safe calls, ensuring that route changes on the server are caught as compile-time errors rather than runtime 404s.

src/Rask.Api.Generators · high confidence

The documentation site now exposes its guides to external discovery through structured metadata and AI-friendly formats. Each guide page includes optimized search titles and meta descriptions to improve search engine visibility, while the site generates an llms.txt index, a full-text llms-full.txt file, and individual Markdown twins for every guide to support AI assistants. Additionally, accurate last-modified dates are embedded at build time using git history, ensuring crawlers and AI tools receive correct freshness signals rather than generic build timestamps.

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

The HTTP feature area now includes two demo components: HttpFetchDemo demonstrates a robust HTTP fetch pattern that handles transient failures, timeouts, and cancellation by retrying up to three times with a 5-second per-attempt deadline and using an injected TimeProvider for testability; HttpRegisterDemo illustrates how to configure an HttpClient to resolve relative URLs against the application's own origin, ensuring self-contained and offline-safe fetches.

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

You can now embed existing Blazor components (such as those from MudBlazor or Radzen) as static islands within a Rask page. The new \BlazorComponent\<T\>\ base class and \AddRaskBlazor\ service registration render the hosted component server-side and inject its HTML, preserving event handlers via Rask's delegated listener contract so clicks work without a Blazor circuit. Parameters are passed as live C\# objects (not serialized JSON), and the \BlazorParameterAttribute\ allows renaming properties to avoid collisions with common names like \Class\ or \Style\. The implementation handles trimmer safety for WebAssembly, ensures \\[Inject\]\ services are resolved via Blazor's activator, and provides a \NavigationManager\ stub so component libraries initialize correctly.

src/Rask.Blazor · high confidence

The Rask.Generators.CodeFixes package now ships with IDE quick-fixes for several Rask diagnostics, allowing developers to automatically correct common issues directly from the editor. These include adding a 'required' modifier for factory parameters (RASK001), adding an empty Alt attribute for decorative images (RASK023), removing redundant StateHasChanged calls (RASK026), rewriting component construction to use the chain pattern (RASK014), exposing entity collections as read-only (RASK085), narrowing model state to private (RASK084), and replacing ASP.NET's \[Route\] attribute with Rask's own (RASK071).

src/Rask.Generators.CodeFixes · high confidence

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

A new Rask.DevTools package provides a developer panel for inspecting live WASM pages served from the local machine. The panel mounts as a dockable drawer with a corner pill, offering tabs to view the component tree (with props, context, and highlighting), wire traffic, render counts, performance timing, and a consolidated error log. It is restricted to local development origins and requires the Rask.Ui kit to render.

src/Rask.DevTools · high confidence

Adds the Rask.Cache package, providing a typed ICache convenience layer and an IDistributedCache implementation backed by the application's own database (via a CacheEntry table) rather than an external broker like Redis. This allows apps to use standard ASP.NET caching features (session state, output caching) with a zero-infrastructure default, while supporting tenant isolation via scoped keys, absolute and sliding expirations, and a background purge service for expired entries. The implementation includes EF Core mapping helpers, a model check to ensure the cache table is mapped at boot, and options for configuring purge intervals and default sliding expirations.

src/Rask.Cache · high confidence

This change introduces the Rask.Query package, providing a TanStack Query-inspired API for managing server state and mutations within Rask components. It adds a scoped IQueryClient that enables declarative data fetching with automatic deduplication, background refetching, and cache invalidation via hierarchical QueryKeys. The package also introduces a Command system that wraps mutations, offering built-in optimistic update support (with automatic rollback on failure) and a renderable state machine (Idle, Pending, Success, Error) so components can display loading indicators and disable buttons during dispatch without handling exceptions manually.

src/Rask.Query · high confidence

The new Rask.Testing package allows you to render Rask components to HTML, invoke their event handlers, and assert on the resulting markup, all without a browser, server, or WebSocket. It provides a \RaskTest\ entry point to render components or full documents, a \RenderedComponent\ handle to query the DOM via a lightweight CSS-selector subset, and utilities to drive interactions like clicks, inputs, and file uploads. The package also includes fakes for dependencies such as \TestJSRuntime\, \TestFileBackend\, and \TestDownloadSink\, as well as \CapturingDiagnostics\ to assert on framework-level faults that are normally swallowed.

src/Rask.Testing · high confidence

A new \Rask.Signaling\ package provides the WebRTC signaling relay that allows peers to exchange offers, answers, and ICE candidates before establishing direct connections. The relay is hosted via \AddRaskSignaling\ and \MapRaskSignaling\ extensions, requiring WebSocket support in the ASP.NET pipeline. It enforces security by minting peer IDs server-side, restricting message delivery to the sender's room, and requiring authentication by default. Configuration is available through \RaskSignalingOptions\, allowing customization of rate limits, payload sizes, and room capacities, with an \AuthorizeRoom\ hook for application-specific access control.

src/Rask.Signaling · high confidence

The framework now manages scoped CSS and JavaScript assets using content-addressed URLs (/\_rask/a/{hash}.{ext}) to enable immutable caching and efficient hot-reload swaps. This change introduces a built-in, dependency-free CSS minifier that safely reduces bundle size by stripping comments and whitespace, and adds server-side Brotli and gzip compression for scoped assets to improve network performance. The new registry system ensures byte-stable URLs and supports concurrent access for high-performance rendering.

src/Rask.Core/ScopedAssets · high confidence

The Rask.Jobs package now provides a built-in background job system that persists work items in the app's own database (SQLite, PostgreSQL, SQL Server, or Redis) rather than relying on an external message broker. Developers can enqueue immediate or delayed jobs via the IJob interface, and the system handles at-least-once execution with exponential backoff retries, dead-lettering for exhausted jobs, and graceful shutdown handling. The feature also supports interval-recurring jobs with durable state tracking to prevent double-execution on restart, and exposes OpenTelemetry-compatible metrics for monitoring job processing.

src/Rask.Jobs · high confidence

Adds the Rask.Mail package, providing a fluent Email builder and IMail interface to queue transactional emails into the application's database for background delivery. The system supports SMTP transport via MailKit, a local .eml pickup directory for development, and a logging fallback, with configurable exponential backoff retries, dead-lettering, and graceful shutdown handling to ensure at-least-once delivery.

src/Rask.Mail · high confidence

The new \Rask.SQLite.Browser\ package enables WebAssembly apps to use a real SQLite database that persists across page reloads by storing snapshots in IndexedDB. It ensures durability by restoring the database from IndexedDB before any service opens it and writing it back on a configurable interval and on page hide. To prevent data corruption from multiple tabs, it uses Web Locks to elect exactly one owner tab; non-owner tabs receive an empty, non-persisted database and can use \BrowserSqliteOwnership\ to detect this state and prompt the user to reload when the owner closes. The package also attempts to request persistent storage from the browser to prevent IndexedDB eviction under storage pressure.

src/Rask.SQLite.Browser · high confidence

The new Rask.Api.Client package allows applications to call their own API controllers and minimal API endpoints from C\# without hardcoding URLs. A source generator reads the server's route definitions, HTTP verbs, parameters, and response types to emit strongly-typed client classes, ensuring that route changes on the server cause compile-time errors rather than runtime 404s. The library includes a DI registration extension (\AddRaskApiClient\) that manages a shared \HttpClient\ and scoped client instances, along with robust error handling via \ApiException\ that distinguishes between transport failures (e.g., timeouts, DNS issues) and server-side HTTP errors, including support for RFC 9457 problem documents.

src/Rask.Api.Client · high confidence

This change adds the \src/Rask.Auth.Api\ package, providing a complete accounts battery for ASP.NET hosts that do not render Rask components (such as SPAs or meta-frameworks). It replaces ASP.NET Core Identity with a custom implementation that supports email/password registration, passkey (WebAuthn) sign-in, and tenant-aware authentication. The service includes its own database model mapping, session management with caching, and email delivery for account confirmations and password resets, while deliberately avoiding dependencies on the Rask Core renderer to remain lightweight.

src/Rask.Auth.Api · high confidence

The new Rask.Cqrs package provides a compile-time wired CQRS/mediator implementation that eliminates runtime reflection and assembly scanning. Handlers for queries, commands, and notifications are discovered and registered via a source generator, exposing a single \IDispatcher\ interface for dispatching requests and publishing events. The system supports configurable pipeline behaviors for cross-cutting concerns, allows remote dispatch to other processes via \IRemoteDispatch\, and includes a \LocalOnlyAttribute\ to restrict specific messages to in-process handling only.

src/Rask.Cqrs · high confidence

The new Rask.SQLite.Litestream package provides a managed background service that continuously streams the SQLite write-ahead log to a configured replica (S3, GCS, Azure Blob, or local file) and automatically restores the database from that replica on startup when the local file is missing. It also introduces an opt-in restore-verification pass that proves the backup is restorable by writing a sentinel, waiting for replication, and restoring to a throwaway path, ensuring that replication health actually reflects recoverability.

src/Rask.SQLite.Litestream · high confidence

Added a comprehensive set of demo components under src/Rask.Site/Features/Elements that showcase the framework's support for native HTML elements. These new pages demonstrate form controls (input, select, textarea, datalist, progress, meter), grouping and list structures (div, pre, blockquote, ol/ul/dl, figure), interactive elements (details, dialog, menu), media and embedded content (img, picture, canvas, iframe, audio, video), metadata and document structure (html, head, body, template, slot), sectioning landmarks (article, nav, main, aside, footer), tables (UiTable with colgroup/thead/tbody), and text-level inline elements (strong, em, code, kbd, ruby, bdi, etc.).

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

A new browser-side runtime (rask-external.js) is introduced to handle the hydration and lifecycle of Rask islands. It locates host elements rendered by the server, loads the corresponding island chunks via a manifest, and mounts them using a framework-agnostic adapter interface. The runtime manages stable identity for event handlers to prevent unnecessary re-renders, handles hot module replacement during development, and ensures styles injected by island libraries are preserved during hydration.

src/Rask.External/wwwroot · high confidence

The new Rask.Data package provides a model-first data access layer built on EF Core, introducing several key capabilities. It defines aggregates and entities with automatic child loading, auditing (CreatedAt/UpdatedAt), soft delete, and optimistic concurrency (Version). A new BulkInsertAsync extension allows efficient batch inserts with configurable batching and transaction options, including a fast path that bypasses the change tracker. The package also includes interceptors for auditing and domain events, and supports tenant-scoped data with automatic tenant stamping and key synchronization.

src/Rask.Data · high confidence

The new \Rask.Wire\ package introduces the shared wire contracts for the application's authentication system and file transfers, ensuring both server and client sides agree on the API shape without cross-referencing heavy dependencies. It defines the \/api/auth\ endpoint routes (register, login, logout, passkey operations, etc.), request/response models (such as \RegisterRequest\, \LoginRequest\, \BearerSession\, and \CurrentUser\), and error codes (\AuthError\) for authentication flows. Additionally, it provides transport-agnostic types for file handling: \RemoteFile\ for uploads and \FileDownload\ for downloads, along with \WireJson\, a reflection-free JSON reader/writer used by generated codecs to parse these contracts efficiently.

src/Rask.Wire · high confidence

The \src/Rask.Core/Components/Svg\ directory now contains a comprehensive set of strongly-typed components for generating SVG markup, including shapes (Circle, Ellipse, Line, Polygon, Polyline, Rect), structural containers (Defs, Desc, G, ForeignObject, Image, Marker, Mask, Pattern, Stop), and filter primitives (FeBlend, FeColorMatrix, FeComposite, FeDropShadow, FeFlood, FeGaussianBlur, FeMerge, FeMergeNode, FeOffset, Filter). These components inherit from a new \SvgElement\ base class that provides common presentation attributes (fill, stroke, opacity, transform) and event handling, allowing users to compose complex, resolution-independent graphics with full attribute coverage as documented by MDN.

src/Rask.Core/Components/Svg · high confidence

The site now includes a full CRUD (Create, Read, Update, Delete) to-do list screen at /todos. Users can add, edit, complete, and delete items via a route-driven dialog (accessible at /todos/new and /todos/{id}/edit) that supports browser back-navigation. The implementation introduces an ITodoStore abstraction, defaulting to a seeded in-memory store for the showcase but allowing hosts to inject durable backends (e.g., SQLite) for persistence across restarts. The UI uses native Rask components (UiButton, Input) and CSS for styling, replacing previous Bootstrap-based form controls.

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

The UiKit area now includes a set of new showcase pages (UiKitActionsPage, UiKitDataDisplayPage, UiKitDataGridPage, UiKitDataInputPage, UiKitFeedbackPage) and their corresponding demo components (UiKitActionsDemo, UiKitDataDisplayDemo, UiKitDataGridDemo, UiKitDataInputDemo, UiKitFeedbackDemo). These pages serve as live, interactive documentation for the UI kit, demonstrating components such as buttons, dropdowns, modals, data grids, form inputs, and feedback elements. The demos illustrate key behaviors like controlled state management, keyboard navigation, and responsive layouts, providing users with concrete examples of how to use the kit's components in their applications.

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

This update introduces several new static analysis rules to the Rask generator to catch common configuration and usage errors at compile time. RASK071 now reports an error when an ASP.NET or Blazor \\[Route\]\ attribute is mistakenly applied to a Rask component, preventing silent 404s caused by the router ignoring the wrong attribute. RASK024 warns if \UseAuthentication()\ is placed after \UseRask()\, ensuring the user principal is available during the initial render. Additionally, RASK045 flags components built via the chain that are subsequently assigned to properties, RASK044 detects duplicate property setters within a single chain, and RASK014 enforces that components are instantiated via the builder chain rather than \new\. Other new rules include RASK037 for detecting \using\ aliases hidden by builder entries, RASK043 for missing factory imports in non-component contexts, and RASK060 for duplicate \AddRask\ calls on the same service collection.

src/Rask.Generators/Analyzers · high confidence

The authentication layer now exposes a comprehensive \IAuth\ interface for account registration, sign-in, sign-out, password reset, and passkey management (add, sign-in, remove), alongside \IAuthSignIn\ for low-level principal handling and \ISessionRevalidator\ to check live session validity. Additionally, \ClaimsPrincipalExtensions\ provides helper methods to extract user and session IDs, while \IUserProvider\ now includes an \IsLoading\ property to indicate when the user principal is being established, helping to prevent UI flashes during authentication transitions.

src/Rask.Core/Authentication · high confidence

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

The site now includes a comprehensive set of interactive demo components that showcase the framework's browser integration capabilities. The Binding section demonstrates data binding patterns, including synchronous and asynchronous \AfterBind\ handlers, multi-field binding, nullable types, and manual input handling. The Browser section adds demos for native device and platform APIs, including Battery status, BroadcastChannel messaging, Clipboard read/write, Cookie management, Crypto (UUID, hashing), Device Sensors (orientation and motion), File System Access, Gamepad polling, Geolocation (one-shot and watch), Gesture Bridge (fullscreen, eyedropper, install, media capture, PiP), IndexedDB, IntersectionObserver, and Media Queries. Each demo illustrates the specific API usage, state management, and lifecycle patterns (such as \IAsyncDisposable\ for cleanup) required to interact with the browser environment from C\#.

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

The framework now exposes typed interfaces for several browser capabilities, allowing applications to access device and platform features consistently across both Server and WASM transports. This includes IBrowserStorage for local and session storage, IBattery for monitoring charge levels, IDeviceMotion and IDeviceOrientation for sensor data, IFileSystemAccess for direct file system operations, and additional APIs for clipboard, cookies, crypto, gamepads, and broadcast channels. These interfaces are injected via component constructors and handle the underlying JavaScript interop automatically.

src/Rask.Core/Browser · high confidence

The builder surface is now accessed via the new RaskMarkup base class and RaskMarkupAttribute, allowing markup entry points (like Div, Span) to be used in components, test classes, and static classes without requiring a base slot. Additionally, new prop carrier structs—Callback, Fn, and Validator—replace direct delegate properties to enable fluent chain syntax while supporting sync/async handlers, template functions, and validation rules respectively.

src/Rask.Core/Builder · high confidence

The generators package now includes new static analyzers (RASK084, RASK085) that enforce strict immutability and encapsulation on entities and aggregates by flagging public setters, public init accessors, and mutable collections of entities, as well as new source generators that automatically produce reflection-free wire codecs for CQRS messages, a dispatch table for command/query handlers, and form-bound model classes with corresponding Create, Update, and Delete methods for aggregates.

src/Rask.Batteries.Generators · high confidence

The framework introduces the Authorize component for declarative access control, allowing developers to gate content based on roles or ASP.NET authorization policies while exposing the current user principal to authorized slots. Additionally, a Context component is added to provide ambient value propagation across descendant subtrees, enabling features like theme or locale sharing without manual prop threading.

src/Rask.Core/Components · high confidence

Added four new demo components in the site's FormControls feature to showcase the updated UI library: FormControlsInputDemo, FormControlsSelectDemo, and FormControlsTextareaDemo demonstrate both controlled (Value + OnChange) and bound (two-way) patterns for text inputs, selects, and textareas, while FormSubmitStateDemo illustrates how to use a children function to react to the form's submitting state for busy affordances like disabled inputs and loading button text.

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

The core messaging layer now includes a \BroadcastHub\ that allows components to subscribe to named topics and receive messages across all active sessions, with delivery grouped per session to ensure a single render cycle per page. Additionally, a scoped \IToaster\ service has been introduced to manage transient, consumed-once user notifications (toasts) that survive client-side navigations, replacing the previous flash-message pattern.

src/Rask.Core/Messaging · high confidence

This change introduces the foundational components for the live rendering engine, including the \FrameDiffer\ for generating minimal DOM edit operations, \HeadAssetRegistry\ for managing and deduplicating head tags, and a comprehensive set of typed event argument records (such as \ClipboardEventArgs\, \FormData\, and various mouse/keyboard events) along with their JSON payload readers. It also adds lifecycle management for component disposal, a synchronization context for handler execution, and interfaces for persistent state and prerendering, establishing the core mechanics for interactive, server-driven UI updates.

src/Rask.Core/Live · high confidence

The repository now includes a suite of local shell scripts to run end-to-end tests and maintenance tasks that were previously automated in CI or run manually. \scripts/run-devtools-e2e-local.sh\ drives the DevTools panel in a real Chromium browser to verify the pill, Wire, Tree, Renders, Perf, and Errors tabs. \scripts/run-benchmarks-local.sh\ and \scripts/run-bulk-insert-benchmarks-local.sh\ enforce payload-size baselines and measure database performance with simulated network latency. \scripts/refresh-templates.sh\ allows developers to re-import upstream frontend framework templates (React, Vue, Svelte, etc.) into the committed tree. Additionally, \scripts/capture-devtools-screenshots.mjs\ and its shell wrapper automate the generation of documentation screenshots, while \scripts/run-all-gates.sh\ provides a single entry point to execute the full suite of local quality gates.

scripts · high confidence

The operator dashboard is now a standalone application mounted at /\_rask, replacing the previous in-app pages. This new console includes dedicated pages for Cache (viewing and flushing entries), Logs (live tail and history with filters), and Storage (read-only file inventory), alongside the existing Queue and Overview panels. The dashboard shell enforces access control via a single \[Authorize\] attribute on the layout, inlines the daisyUI stylesheet for consistent styling, and uses a polling-based panel architecture to keep data fresh without competing with application processors.

src/Rask.Dashboard/Pages · high confidence

A built-in operator dashboard is now available at the \/\_rask\ route, providing a read-only view and safe management controls for the application's batteries (jobs, outbox, mail, cache, and storage) directly from the database. The dashboard features a bounded in-memory log tail to surface runtime failures, a fixed daisyUI light theme to ensure consistent contrast, and a fail-closed security model that denies access by default outside of Development unless a specific \RaskDashboard\ authorization policy is defined.

src/Rask.Dashboard · high confidence

A new TypeScript-based extractor has been added to the Rask build pipeline to automatically generate props snapshots for external component libraries. This tool reads TypeScript declarations from installed npm packages and outputs a structured JSON snapshot used to generate C\# code for package islands. The implementation supports multiple frameworks including Vue, Svelte, Lit, and Angular, handling framework-specific details such as input aliases, event bindings, and inheritance of framework-owned types to ensure accurate and stable prop definitions.

src/Rask.External/extractor · high confidence

The routing subsystem has been rebuilt to introduce several key capabilities and safeguards. A new \LocalUrl\ class provides an open-redirect guard for all redirect paths (server post-sign-in, client route-guard challenges, and WASM login/logout flows), rejecting non-local URLs and control characters to prevent security vulnerabilities. The system now supports mounting multiple Rask applications under a single host via \RaskMountedApp\, allowing separate route tables and documents for different parts of the application (e.g., an operator console). Navigation is handled by a new \Navigator\ class, which enforces that navigation only occurs within event handlers to maintain consistency. Additionally, query string handling is improved with dedicated \QueryCollection\ and \QueryString\ classes, and route resolution is optimized with caching in \RouteRegistry\ and \RouteResolver\ to support hot reloads and mounted apps efficiently.

src/Rask.Core/Routing · high confidence

A new unified TypeScript module layer has been introduced under src/Rask.Core/Resources/browser, providing a consistent set of browser API wrappers (including auth, geolocation, battery, file system, and device sensors) that can be consumed by both the framework's internal clients and external front ends. This layer standardizes how browser capabilities are accessed, ensuring that TypeScript front ends and the framework's C\# clients interact with a single, coherent API contract rather than disparate implementations.

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

The WASM-hosted template now includes a shared \AppDbContext\ and \User\ entity. The context is configured to automatically map aggregates and apply Rask conventions (audit stamps, soft-delete, concurrency tokens), while conditionally integrating optional modules like outbox, jobs, mail, cache, and storage. The \User\ entity extends \Authenticatable\ to provide standard sign-in capabilities and includes a \DisplayName\ field, serving as the base user model for the application.

src/Rask.Templates/wasm-hosted/Features/Shared · high confidence

This change introduces a suite of new components in the shared hosting layer to improve the developer experience and production reliability. For local development, it adds automatic hostname management (using the reserved .test TLD), safe /etc/hosts and macOS pf firewall modifications, and logic to launch and manage frontend dev servers when an app is started via an editor's debugger (F5). For production, it adds a middleware to serve pre-compressed static assets (Brotli/Gzip) to reduce bandwidth and CPU usage, and a data protection setup that persists encryption keys to a durable volume in containers to prevent user session loss across deployments. It also standardizes configuration binding and sets safer concurrent shutdown defaults for hosted services.

src/Rask.Hosting.Shared · high confidence

The site now includes a suite of new demonstration components under the \Features\ namespace to showcase framework capabilities. Asset loading demos (\BasicScopedCss\, \JsOnlyDemo\, \LazyMount\, \TwinA\, \TwinB\) illustrate scoped CSS emission, lazy loading, and content-addressed caching. Callback and component demos (\CallbackRatingDemo\, \RatingStars\, \WeatherCard\, \Greeting\, \SkipFactoryCounter\) demonstrate state management, dependency injection, and factory generation. Additionally, a dedicated \NotFoundPage\ handles 404 errors with its own layout and SEO metadata.

(repo-wide) · high confidence

The site now includes interactive demos demonstrating keyed list reconciliation (KeyedListsReorderDemo) and various nested form patterns, including sub-object binding, collection binding via foreach and indexer, and integration with FluentValidation. These examples showcase the updated UI component library (UiButton, UiInput, UiTable, etc.) and the framework's ability to maintain input state during list reordering and handle complex nested validation scenarios.

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

The site now includes interactive demonstration components for three core framework capabilities. In the Context feature, a theme toggle demo illustrates how a value provided high in the component tree can be consumed by deeply nested components without prop drilling, while an intermediate component remains render-cached. The ErrorBoundary feature adds demos showing how exceptions thrown in event handlers or during rendering are caught and replaced with a fallback UI that offers a recovery action, including support for nested boundaries where inner errors do not unmount outer healthy regions. The Users feature introduces two authorization demos: an imperative gate that manually subscribes to user state changes to render content based on identity and roles, and a declarative Authorize component that automatically manages subscriptions and provides distinct slots for authorized, not authorized, and authorizing states.

src/Rask.Site/Features/Context, src/Rask.Site/Features/ErrorBoundary, src/Rask.Site/Features/Users · high confidence

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

The \add-html-tag\ skill has been added to the developer workflow, providing a standardized method for introducing new HTML elements (such as \\<dialog\>\, \\<video\>\, etc.) into the Rask framework. It includes a \SKILL.md\ guide and C\# templates that generate the component class (deriving from \Element\ or specific DOM-interface bases like \HtmlMediaElement\) and corresponding xUnit tests. The generated code ensures correct attribute ordering (id, class, style, data-\*, then tag-specific) and handles void/self-closing elements, with the factory code produced automatically by the Roslyn generator.

.claude/skills/add-html-tag · high confidence

The template system now supports frontend islands for Angular, Blazor, Lit, Preact, React, Solid, Svelte, and Vue, each defined by an \island.json\ manifest specifying its runtime and dependencies. Blazor islands are implemented as server-rendered components that reuse the page's existing WebSocket for interactivity without requiring a full Blazor circuit. Additionally, VS Code launch and task configurations have been added to support F5 debugging for both standard server apps and WebAssembly-hosted apps, enabling breakpoints in C\# and scoped TypeScript within the browser.

src/Rask.Templates · high confidence

The site now includes a comprehensive set of demo pages under src/Rask.Site/Features/Validation that showcase the framework's validation capabilities. These pages demonstrate various validation strategies, including inline field and form-level validation, custom DataAnnotations attributes, FluentValidation integration, and async validators with live checking indicators. The demos also cover advanced scenarios such as cross-field validation, first-error-wins gating, programmatic validation control, and nested object validation with live totals.

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

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

The new Rask.Auth package replaces ASP.NET Core Identity with a unified accounts system that works across server, WebAssembly, and island hosts. It provides register, sign-in, sign-out, email confirmation, and password reset capabilities, including native passkey authentication verified on the BCL. The package includes default transactional email templates (confirmation and password reset) rendered as Rask components, ensuring consistent styling and accessibility, while allowing apps to override them. The first registered account is automatically assigned the admin role, and the system uses PBKDF2 or bcrypt for password hashing with session management that survives across different hosting environments.

src/Rask.Auth · high confidence

The Rask.Ui package now provides a comprehensive set of typed C\# components wrapping the daisyUI design system, including actions (UiButton, UiModal), data display (UiAccordion, UiDataGrid, UiTree), navigation (UiMegamenu, UiTabs), feedback (UiToast, UiTooltip), and data input controls (UiInput, UiSelect, UiCalendar). The kit ships with its own precompiled stylesheet, eliminating the need for npm or Tailwind configuration in the consuming application, and enforces a scoped theme via the \[data-rask-ui\] attribute to prevent style leakage. It supports 35 daisyUI themes, mobile-first layouts with 44px touch targets, and native browser interactions (such as \<dialog\> popovers) without requiring JavaScript.

src/Rask.Ui · high confidence

The Rask.Cqrs.Client package now enables WASM or native clients to dispatch commands, queries, and notifications to a remote server via HTTP. Clients register the transport using AddRaskCqrsClient, which configures the server address, route prefix, and request hooks (such as attaching bearer tokens for cross-origin scenarios). The client respects a per-request timeout and handles large file attachments by uploading them in chunks before sending the message, preventing memory spikes in the browser. File downloads returned by handlers are saved to disk through a Navigator extension that streams the response without buffering it into memory.

src/Rask.Cqrs.Client · high confidence

The Rask CLI templates (analog, angular, lit, nextjs, nuxt, preact, react, server, solid, solidstart, svelte, sveltekit, tanstack-start, vue, and wasm) now include server-side CQRS handlers for a 'Hello' feature (providing a greeting and visit counter) and a 'Push' feature (managing web push subscriptions via in-memory stores). These additions allow generated applications to immediately support basic user interaction and push notification capabilities without requiring manual backend implementation.

(repo-wide) · high confidence

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.

src/Rask.Cli/Scaffolding · high confidence

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

The new UseRaskSpa middleware in Rask.Spa.Hosting serves built single-page apps (including Rask WebAssembly bundles) from an ASP.NET host, handling static file delivery, precompressed assets, and client-side route fallbacks. It automatically detects WebAssembly clients, serves their build output during development for hot reload, and provides a debug proxy for browser-based C\# debugging. The package also registers response compression and data protection, and launches the bundler's dev server automatically when launched from an editor.

src/Rask.Spa.Hosting · high confidence

The new \Rask.WebPush\ package provides a server-side library for sending Web Push notifications. It handles VAPID authentication (RFC 8292) and end-to-end payload encryption using \aes128gcm\ (RFC 8291) with zero external dependencies. Developers can register the sender via \AddRaskWebPush()\, configure VAPID keys and a contact subject in the \Rask:WebPush\ section, and use \IWebPush.SendAsync()\ to deliver messages to browser subscriptions. The sender returns a \WebPushResult\ that classifies outcomes (Success, Expired, TransientFailure, PermanentFailure) to help manage subscription lifecycles.

src/Rask.WebPush · high confidence

The server host now includes a dedicated authentication subsystem with an in-memory ticket store for sign-in/out flows and a session-scoped user provider that triggers UI re-renders on identity changes. Comprehensive observability is added via OpenTelemetry-aligned metrics (session lifecycle, handler performance, frame rejection) and health checks that monitor live-session capacity and graceful shutdown readiness. File handling is supported through session-scoped upload and download stores with configurable size and quota limits, while a background dev server enables island hot-reloading during development.

src/Rask.Server · high confidence

This change introduces the server component for Rask's remote CQRS dispatch, allowing WASM or native clients to communicate with the server via HTTP. It registers the \MapRaskCqrs\ endpoint extension, which exposes GET and POST routes for queries and commands, along with a dedicated chunked-upload endpoint for large file transfers. The server enforces strict limits on request size, upload chunks, and file counts, and requires authenticated users by default to ensure secure, controlled access to the CQRS handlers.

src/Rask.Cqrs.Server · high confidence

The CLI now supports shell completion for Bash, Zsh, and Fish, automatically generated from the live command schema so that new commands and options are always reflected in tab-completion. Additionally, a new \rask db\ command has been introduced to manage EF Core migrations (add, remove, list, update, drop) and to back up or restore the database, including handling uploaded files and supporting remote operations on deployed containers via Docker.

src/Rask.Cli/Commands · high confidence

Rask now supports rendering interactive islands using seven major frontend frameworks: Angular, Vue, Svelte, Lit, Preact, Solid, and React. This change introduces a new \Rask.External\ package containing base classes (e.g., \AngularComponent\, \VueComponent\) that allow C\# components to be rendered by their respective frontend runtimes. The implementation includes runtime-specific adapters, hydration strategies (Load, Idle, Visible, None), and type-safe child handling to ensure islands only accept children compatible with their specific framework. This enables developers to integrate existing frontend components into Rask pages while maintaining server-side rendering and live updates.

src/Rask.External · high confidence

Rask.Storage now supports storing uploaded files in Azure Blob Storage and S3-compatible object stores, in addition to the existing local disk backend. This is achieved through a new pluggable backend architecture (IBlobBackend) that implements storage operations without relying on external cloud SDKs, using custom HTTP signing (Azure Shared Key and AWS SigV4) instead. Users can configure the storage provider via connection strings and credentials, allowing files to be persisted to cloud object storage or local directories.

src/Rask.Storage · high confidence

The Rask generator now supports a broader set of frontend runtimes for component islands. In addition to the existing React and Lit support, developers can now use Vue, Svelte, Preact, Solid, and Angular components as islands. The generator automatically detects the runtime based on the base class (e.g., \VueComponent\, \SvelteComponent\) and generates the necessary props writers and module bindings. This allows islands to take children of their own runtime and integrate seamlessly with the Rask build system.

src/Rask.Generators/External · high confidence

Rask islands can now be built with React, Vue, Svelte, Preact, Solid, Lit, or Angular, and can accept children from the host. This is enabled by new client-side adapters that handle mounting, updating, and unmounting for each framework, along with a shared adapter contract and Svelte-specific host components to render nested island trees.

src/Rask.External/client · high confidence

The \rask new --islands\ command now scaffolds front-end components for Angular, Lit, Preact, React, Solid, Svelte, and Vue. This change adds paired C\# host classes and front-end source files (e.g., \AngularCounter.cs\ with \AngularCounter.ts\) for each framework, establishing the contract for Rask islands where C\# declares props and the front-end implements the component logic.

(repo-wide) · high confidence

The new Rask.Outbox package ensures domain events are never lost by writing them to an OutboxMessage table in the same database transaction as the entity change that raised them. A background OutboxProcessor then polls this table and publishes the events via Rask.Cqrs with at-least-once semantics, including retries and dead-letter handling. Published messages are automatically purged after a configurable retention period (default 7 days) to prevent table bloat, while metrics are exposed for monitoring processed, failed, and dead-lettered events.

src/Rask.Outbox · high confidence

The WASM host now exposes typed wrappers for several browser APIs that require transient user activation or live document access—Background Sync, Web Bluetooth, WebHID, EyeDropper, Fullscreen, Idle Detection, PWA Install Prompt, Media Capture, Picture-in-Picture, and Screen Orientation—enabling features like offline sync, hardware device communication, and immersive media directly from C\#. Additionally, the WASM authentication flow now includes a dedicated sign-out implementation that posts to a configurable server logout endpoint to clear cookies, refreshes the user provider, and navigates to a sanitized return URL without a full page reload.

src/Rask.Wasm · high confidence

A new 'Islands on WebAssembly' page has been added to the site, showcasing byte-identical front-end components from Vue, React, Svelte, Solid, and Lit running client-side. The demo illustrates how these islands communicate with C\# via direct runtime calls rather than WebSockets, and highlights specific capabilities such as nested package islands (using an npm React color picker) and state reconciliation without remounting.

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

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

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

The \Rask.Core/Forms\ directory has removed the legacy validation implementation, including the \DataAnnotationsValidator\, \EditContext\, \EditContextScope\, \ExpressionAccessor\, \FieldIdentifier\, and \IFieldValidator\ types. This change eliminates the previous manual validation context and expression-based accessor system, indicating a shift to a new validation architecture (likely the \IAsyncFieldValidator\ and inline callbacks mentioned in commit history) that users must now adopt.

Rask.Core/Forms · high confidence

The Rask.Server module has removed the \LiveSession\, \LiveSessionStore\, and \RaskEndpointExtensions\ classes, which previously handled WebSocket connections, session lifecycle, and endpoint registration for live rendering. This change eliminates the legacy server-side session management infrastructure, indicating a migration to a different mechanism for handling real-time updates or server interactions.

Rask.Server · high confidence

The legacy \Rask.Server/Resources/rask.js\ file, which previously handled WebSocket connections, DOM morphing, scoped CSS injection, and client-side navigation events, has been deleted. This removes the standalone JavaScript client logic that managed real-time updates and UI synchronization for the Rask framework.

Rask.Server/Resources · high confidence

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

The Rask framework has removed the \IAuthSignIn\ interface from the Authentication module and the \RaskAuthorizationOptions\ class from the Authorization module. This eliminates the previous sign-in/sign-out contract and the configuration options for challenge and forbidden paths, indicating a shift in how authentication flows and authorization settings are managed within the core library.

Rask.Core/Authentication, Rask.Core/Authorization · high confidence

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

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

The entire \Rask.Core.Routing\ namespace has been removed, eliminating the previous routing implementation. This includes the deletion of the \Navigator\ class (which handled programmatic navigation and query manipulation), the \IQueryCollection\ and \QueryCollection\ types (used for managing URL query parameters), and the core routing engine components such as \Router\, \Outlet\, \RouteRegistry\, \RouteFlattener\, and \RouteMatcher\. Users relying on these specific classes for navigation or route definition will need to adopt the framework's updated routing mechanisms.

Rask.Core/Routing · high confidence

The Rask CLI has been refactored to use Spectre.Console, introducing a modernized terminal interface with semantic color styling, animated progress indicators for long-running operations, and a structured help system that renders command options and aliases directly from the argument schema. A new custom argument parser ensures consistent validation, supports multi-value options and passthrough arguments, and provides clear error messages with suggestions for unknown commands. The tool now includes a new \doctor\ command to probe dependencies, validates the \--domain\ flag for security, and ensures the EF Core tools are installed and up-to-date before use.

src/Rask.Cli · high confidence

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

The translation system now generates strongly-typed C\# code from JSON catalogs at compile time, ensuring that missing keys or mismatched placeholders result in build errors rather than runtime failures. This update introduces support for real plural grammar (using CLDR rules for languages like French, Russian, and Arabic) and allows the framework's own UI text to be translated via a reserved catalog, replacing the previous static label approach.

src/Rask.Generators/Translations · high confidence

The core rendering engine has been refactored to significantly reduce allocation overhead and simplify event handling. A new \AttrBag\ type replaces dictionary-based storage for \data-\\ and \aria-\\ attributes, eliminating enumerator allocations on the render hot path. Callback properties on components are now automatically wrapped via \AutoCallback\ to ensure the parent component re-renders when invoked, removing the need for manual state-change triggers. Additionally, a unified \GlobalEventHandlers\ surface consolidates all DOM events into a single storage mechanism, and keyed child reconciliation now correctly identifies children by their stable \Key\ property rather than their position in the sibling list.

src/Rask.Core · high confidence

The demo component in the FloatingLabels feature now uses the new default behavior where kit text fields (UiInput, UiSelect, UiTextarea) automatically float their labels when empty, eliminating the need for a separate UiFloatingLabel wrapper. This change simplifies form markup by making the label floating behavior the standard for all bound input fields, while still supporting standard DataAnnotations validation and explicit ID assignment.

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

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

Form binding and validation are now built into Rask.Core.Forms, removing the need for opt-in components. DataAnnotations validation is automatically registered by the Form, so attributes like \[Required\] on a model just work without extra setup. The binding system has been refactored with a new BindingConsumerRegistry to ensure that two-way writes correctly re-render the authoring component, even when controls are wrapped. Additionally, ExpressionAccessor now strips every Convert in bind expressions, fixing issues where lifted binds over casts failed to parse, and Input controls now default to step="any" for fractional types to prevent browser constraint validation from blocking submission.

src/Rask.Core/Forms · high confidence

The source generators in this location have been restructured: the monolithic ComponentFactoryGenerator is now split into focused partials (e.g., ComponentFactoryGenerator.PackageIslands.cs) to handle package-island props, while dedicated generators (ComponentScopedCssGenerator, ComponentScopedJsGenerator) now pair sibling .css and .ts files with their components. Scoped JavaScript is no longer supported; .js siblings trigger RASK055 and must be renamed to .ts. A new AssetPairing utility normalizes directory paths (collapsing macOS /private aliases) to ensure consistent file pairing. Additionally, a lightweight, hand-written JSON parser (JsonLite/JsonScanner) replaces System.Text.Json to avoid dependency conflicts in the analyzer host.

src/Rask.Generators · high confidence

The meta-framework hosting lane now prevents 502 errors during deployments and startup by introducing a dedicated drain mechanism and a readiness gate. The new MetaDrain component ensures that in-flight requests are allowed to complete before the Node process is terminated, while the NodeReadiness service blocks forwarding until the front end is actually listening, returning 503 Service Unavailable with a Retry-After header during these transient states. A new RaskMetaHealthCheck provides distinct status reports for 'starting' and 'draining' phases, enabling orchestrators to make accurate routing decisions based on the true state of the front end.

src/Rask.Meta.Hosting · high confidence

The build system now more accurately identifies external component islands and validates their configuration. It distinguishes between scoped TypeScript files and actual island modules to prevent file conflicts, and introduces a snapshot verification step that errors if a package island's props are missing or warns if the committed snapshot version mismatches the lockfile. Additionally, support for multiple front-end runtimes (React, Vue, Svelte, Lit, Preact, Solid, Angular) is standardized via a unified runtime table, ensuring correct adapter selection and entry module generation for each.

src/Rask.External.Tasks · high confidence

The template now generates a complete server-side application structure in the Shared feature area, replacing previous boilerplate. This includes an App component that configures the global HTML shell, injects the UI kit's stylesheet, and manages head assets like the page title. A new AppDbContext is provided, extending RaskDbContext to automatically map aggregates and apply conventions (audit stamps, soft deletes) while conditionally registering modules for outbox, jobs, mail, cache, storage, and Rask's own auth system. An error page is added at /error to display a user-friendly message and trace ID without exposing stack traces. Finally, a User entity is defined inheriting from Authenticatable, providing a base for custom user properties like DisplayName while leveraging Rask's built-in authentication and authorization mechanisms instead of ASP.NET Core Identity.

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

Rask now resolves and caches esbuild, tsgo, and the TypeScript compiler library directly from the npm registry, eliminating the need for a local npm installation or Node.js for standard builds. The new build tasks download pre-built native binaries (or the JS library for type introspection), verify their integrity via SHA-512 checksums, and cache them in a per-user directory, ensuring reproducible builds across different environments without relying on the project's node\_modules.

src/Rask.TypeScript.Tasks · high confidence

The Rask.Core package now includes build targets that automatically register scoped CSS and TypeScript files as additional build inputs, enabling the framework to pair component classes with their local styles and scripts. This integration pins specific versions of the TypeScript compiler (tsgo) and bundler (esbuild) to ensure consistent output, and configures the build to strip comments from scoped JavaScript in Release mode to reduce payload size while preserving source maps in Debug mode for better developer experience.

src/Rask.Core/build · high confidence

The documentation site has been rebuilt with a new layout featuring a sticky 'On this page' navigation rail, a chapters table of contents, and a version/source banner. Code samples are now interactive, displaying live results alongside the source code with syntax highlighting and a copy-to-clipboard feature. Relative links within guides are now correctly resolved to their intended destinations, fixing previous 404 errors. The site also includes a new guides index page with grouped cards and improved styling for code blocks and navigation elements.

src/Rask.Site/Shared · high confidence

The home page has been rewritten to deliver a fully static, JavaScript-free experience for the initial render, ensuring that crawlers and users see all content immediately without relying on client-side scripts for visibility. The hero section now features a responsive layout that prevents horizontal scrolling issues on mobile devices and includes a live, stateful counter component that demonstrates the framework's efficient diffing capabilities (shipping only \~41 bytes per click) once the WebAssembly bundle loads. Additionally, an interactive install tab component allows users to toggle between Server and WASM installation commands without JavaScript, using server-side state management to render the correct terminal output.

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

The core rendering model in Rask.Core has been refactored to migrate Component subclasses to a new Element base class with support for HTML attributes. This change removes the legacy Child struct, Text, Raw, and HtmlSerializer classes, replacing them with a more direct element-based tree structure. The Tags factory methods now generate Element instances directly, and the rendering pipeline has been updated to work with the new Element hierarchy.

Rask.Core · high confidence

The Rask.Core/Live module has undergone a significant internal refactor to streamline the rendering pipeline and lifecycle management. Several legacy internal classes have been removed, including ComponentLifecycle, FormData, HandlerSyncContext, LifecycleSyncContext, IRenderHandle, and LivePayload, indicating a consolidation of how component disposal, form data parsing, synchronization contexts, and payload construction are handled. Additionally, LiveRenderContext has been modified to remove the ScopedCssRegistry dependency from its scope management logic, suggesting a migration toward a new scoped CSS/JS asset system. These changes represent a structural cleanup and optimization of the core Live rendering engine rather than a change in user-facing features.

Rask.Core/Live · medium confidence

The local CI gate system has been refactored to use a shared library of scripts in scripts/lib, replacing inline logic with modular components. This introduces precise build-failure classification (distinguishing code errors from machine/workload issues), a slot-based machine lane system to prevent resource contention between worktrees, and improved E2E gate admission controls. Additionally, Playwright browser installation now works without PowerShell, and attribution trailers are now checked by hooks.

scripts/lib · high confidence

The framework now ensures that hot reload updates apply in a strict, deterministic order: scoped CSS and JavaScript assets are refreshed and staged before route and command registries are updated, and session re-renders only occur after all other phases complete. This prevents visual glitches where a page repaints with stale bundle hashes or missing styles. Additionally, the 'hot reload applied' notification is now only shown if the page actually repaints, preventing misleading feedback when an edit does not result in a visible change.

src/Rask.Core/HotReload · high confidence

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

The legacy \ScopedCssRegistry\ and \ScopedCssHotReloadHandler\ classes have been removed from the \Rask.Core.ScopedCss\ namespace. This eliminates the previous mechanism for registering component-scoped CSS, managing scope IDs, and handling hot-reload invalidation events, indicating a shift in how scoped styles are processed and delivered within the framework.

Rask.Core/ScopedCss · high confidence

The local in-memory authentication ticket store (AuthTicketStore) and the WASM-side sign-in implementation (WasmAuthSignIn) have been removed. This eliminates the server-side mechanism for issuing and redeeming short-lived authentication tickets and removes the client-side capability to perform principal-based sign-ins directly in the browser, enforcing that sign-in logic must be handled by posting credentials to a server endpoint instead.

Rask.Server/Authentication, Rask.Wasm/Authentication · high confidence

The static HTML component classes (such as A, Button, Form, and Div) in Rask.Core/Components have been removed. This change aligns with the migration of Component subclasses to Element and the introduction of generated factories, shifting the framework from hand-written component definitions to a code-generation approach for building HTML elements.

Rask.Core/Components · high confidence

The standalone Rask WASM entry point has been refactored by deleting the previous \index.html\, \main.js\, and \rask.wasm.js\ files. This removes the legacy client-side JavaScript bootstrap logic, including the manual .NET runtime initialization, the custom DOM morphing engine, and the direct event dispatching (click, input, change) that previously ran in the browser. These changes consolidate the WASM hosting model, likely shifting responsibility for these concerns to a new unified interop layer or hosting infrastructure.

Rask.Wasm/Browser · high confidence

The Auth feature now includes a complete set of compiled Razor components for user identity management, replacing the previous non-compiling scaffold. This adds functional pages for signing in, registering (including a first-run claim flow), confirming email addresses, resetting passwords, and signing out. A key behavioral addition is support for passkey-based authentication on the login and device management pages, allowing users to sign in or manage their devices without a password. The sign-in page specifically detects browser passkey support and offers a dedicated passkey sign-in button when available.

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

The Rask showcase site has been redesigned to use Tailwind's typography plugin for guide content and to follow the operating system's light/dark theme preference. To eliminate the layout flicker that occurred during page navigation, fonts (Inter, Space Grotesk, JetBrains Mono) are now self-hosted from the site's own origin instead of loading from Google Fonts. The visual identity has shifted to a violet palette with improved accessibility, and the legacy Bootstrap styling has been removed in favor of Tailwind and daisyUI utilities.

src/Rask.Site/wwwroot · high confidence

The site's stylesheet has been rewritten to use Tailwind's typography plugin for guides and defines a comprehensive UI palette that adapts to the operating system's light or dark mode. This change ensures that all color combinations, including those for status indicators and surfaces, meet readability standards across different themes, replacing the previous dark-first design with a unified, theme-aware approach.

src/Rask.Site/Styles · high confidence

The site's lifecycle and virtualization demos have been refactored to ensure their HTML structure remains stable during rendering, preventing layout shifts and ensuring consistent test snapshots. The lifecycle demos now use fixed-table layouts where hook statuses are displayed as text within existing rows rather than appending new DOM nodes, and the cycle demo correctly handles unmount-time state changes in WebAssembly. The virtualization demos now use spacer rows inside the table body to maintain a constant container height, which keeps sticky headers fixed during scrolling, and the provider demo pre-renders placeholders to avoid dynamic tag insertion while fetching data.

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

The authorization guard now defines explicit constants for client-side redirect targets: /login for challenges and /forbidden for forbidden access. These paths are shared between the server-side endpoint extensions and the WebAssembly live session guard to prevent drift, ensuring that in-app navigation to protected routes uses consistent URLs while the initial HTTP challenge still relies on the configured auth scheme's LoginPath and AccessDeniedPath. Additionally, minor code style fixes were applied to attribute retrieval and method calls.

src/Rask.Core/Authorization · high confidence

The framework now routes internal faults (such as lifecycle hook failures, dispose errors, and duplicate keys) through a new diagnostic seam that includes severity levels (info, warning, error) and subsystem categories. This changes the default error output format from a bare message to a structured string like '\[Rask:Category\] level: message', making it easier for users to identify the source and importance of issues without needing to configure external logging.

src/Rask.Core/Diagnostics · high confidence

The Rask.Tailwind.Tasks package now bundles the logic to automatically resolve and download the Tailwind CSS CLI binary at build time, eliminating the need for external setup. It prefers a standalone binary for speed and offline reliability, falling back to npm only when a standalone asset is unavailable for the platform. Downloads are pinned to a specific version, verified via SHA-256 checksums, and cached per-user to avoid repeated fetches. The implementation includes safeguards against race conditions and truncated files by staging downloads uniquely and validating file sizes against receipts.

src/Rask.Tailwind.Tasks · high confidence

The framework runtime has been consolidated into a single TypeScript codebase shared by both the Server and WASM clients, replacing the previous text-splicing approach with proper ES module imports. This change introduces a dedicated browser layer for interop helpers (WebRTC, file uploads, gestures) and a new DOM path resolution module that fixes hydration styling issues by correctly ignoring formatting whitespace in \<html\> and \<head\> elements. Additionally, the event system now uses a centralized delegation model with rAF-coalesced input handling, and the diff codec interpreter has been updated to support atomic DOM moves and better form property synchronization.

src/Rask.Core/Resources · high confidence

The shared generator codebase has been restructured to support a new data model where aggregates and entities replace the previous generic Model, introducing read-only 'read faces' for querying while restricting writes to aggregate roots. This change includes a new registry generator base that unifies job and outbox registration, fixes runtime key mismatches by using metadata names instead of C\# display syntax, and consolidates diagnostics under a single category with improved help links. Additionally, shared TypeScript emission and model shape definitions ensure consistent wire formats between C\# and client-side code.

src/Rask.Generators.Shared · high confidence

The WASM-specific JS interop layer has been consolidated to align with the Server hosting model, removing the dedicated \JSInterop\, \PayloadExtractor\, \RouteSeeder\, and \WasmHostBuilder\ classes in favor of a unified \IJSRuntime\ approach. This change eliminates the previous manual JSON payload extraction and separate hosting entry point, simplifying the client-side runtime and ensuring consistent behavior across Server and WASM execution environments.

Rask.Wasm · high confidence

The shared scaffolding templates for all frontend frameworks (Angular, React, Vue, Svelte, etc.) now include a new \AppDbContext\ and \User\ class. The \AppDbContext\ inherits from \RaskDbContext\ instead of the standard EF Core \DbContext\, enabling automatic mapping of aggregates, strongly-typed IDs, and integration with Rask's built-in batteries (Outbox, Jobs, Mail, Cache, Storage) and authentication. The \User\ class now inherits from Rask's \Authenticatable\ aggregate, replacing previous identity implementations and allowing users to register, sign in, and manage roles through Rask's \IAuth\ service.

(repo-wide) · high confidence

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

The application now fails to start if an enabled battery's database tables are not mapped in the DbContext, providing a clear error message at boot rather than crashing on the first request. Additionally, background polling services (pollers) no longer clutter the console with their SQL queries; their logs are now set to Debug level, keeping the Information log clean for application-specific queries while still allowing developers to inspect battery activity if needed.

src/Rask.Batteries.Shared · high confidence

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

The Rask.Site showcase has been reorganized to consolidate PWA and device-capability demos into a single page, simplifying navigation. Font loading has been optimized by preloading local WOFF2 files instead of using a non-blocking CDN pattern, eliminating the document reflow and visual flicker that occurred during hydration and navigation. The site now respects the operating system's color scheme preference, ensuring all palettes remain readable, and documentation links are resolved correctly using Uri-based logic to handle path bases properly.

src/Rask.Site · high confidence

Added skill to drive and smoke-test the Rask CLI; Added test fixtures for Angular and Lit component extraction; Added test fixtures for Angular and Lit type definitions; Added test fixtures for Vue and Svelte component type extraction; Added tests for ComponentFactoryGenerator behavior and WASM compatibility; Added tests for the generated API client against real controllers and minimal APIs; Added tests for the repository's gate scripts and documentation consistency; 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.

The project now uses Central Package Management (Directory.Packages.props) to pin all NuGet versions, including upgrading the Microsoft platform stack to 10.0.12 and BenchmarkDotNet to 0.15.8. Crucially, SQLitePCLRaw is moved to the 3.x family (3.0.5) to patch [CVE redacted], a memory corruption vulnerability in the previous 2.1.11 bundle, by replacing the vulnerable native library with a patched version that includes SQLite 3.53.4.

(dependencies) · high confidence

The project's build configuration has been updated to target .NET 10.0.10 and Microsoft.NET.Test.Sdk 18.8.1. This ensures the framework and test infrastructure align with the latest platform releases.

(repo-wide) · high confidence

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

• First survey — no prior run to compare against. CAI 51.

• Code Health 76
• Architecture 80
• Maturity 66
• Readiness 31
• Security 63
• Domain Modelling 97
• Accessibility 71
• Performance 76

• 300 commits — 226 feature/other, 74 fixes

• (repo) — 152 commits
• (root) — 31 commits
• src/Rask.Ui — 21 commits
• src/Rask.Data — 11 commits
• src/Rask.DevTools — 11 commits
• src/Rask.Site — 9 commits
• src/Rask.Cli — 7 commits
• src/Rask.Core — 6 commits
• src/Rask.Templates — 6 commits
• src/Rask.Server — 5 commits
• tests/Rask.Server.Tests — 5 commits
• .claude/skills — 4 commits
• src/Rask — 3 commits
• tests/Rask.DevTools.E2E.Tests — 3 commits
• docs/tutorial — 2 commits
• src/Rask.Auth.Api — 2 commits
• src/Rask.Query — 2 commits
• src/Rask.SQLite.EntityFrameworkCore — 2 commits
• src/Rask.Storage — 2 commits
• tests/Rask.Benchmarks — 2 commits

• fix: chore: bring main into the wave-1 fixes
• fix: chore: merge origin/main a third time before landing the prerender scoped-CSS fix
• fix: chore: merge origin/main again before landing the prerender scoped-CSS fix
• fix: chore: merge origin/main before landing the CLI next-steps and docs fixes
• fix: chore: merge origin/main before landing the prerender scoped-CSS fix
• fix: chore: merge origin/main before landing the session scoping fix
• fix: chore: merge origin/main before landing the soft-delete, kit link and SWA fixes
• fix: chore: merge origin/main before landing the storage and configuration fix
• fix: chore: merge origin/main before landing the wasm diff-path fix
• fix: chore: merge origin/main before landing the websocket admission fix
• fix: chore: merge origin/main before landing the websocket admission fix
• fix: chore: merge origin/main before landing the websocket admission fix
• fix: chore: merge origin/main before landing the websocket admission fix
• fix: chore: merge origin/main into fix-all-issues to land #1061
• fix: chore: merge origin/main into fix-all-issues to land #1061 after devtools E2E
• fix: chore: merge origin/main into fix-all-issues to land #1063
• fix: chore: merge origin/main into fix-all-issues to land #1073
• fix: chore: merge origin/main into fix-all-issues to land #1077
• fix: chore: merge origin/main into fix-all-issues to land #1101
• fix: chore: merge origin/main into fix-all-issues to land #1108
• …and 280 more

• 3 HTTP endpoints (baseline)

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

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.