schultek/jaspr
35.2
Weak · 13 November 2026
52.9k
lines of production code
Dart
primary language
7
measurements over time
What this system is
Features
Add Bulma UI sample application to Jaspr Pad
The Jaspr Pad sample application now includes a Bulma UI demo that showcases a set of reusable components built on the Bulma CSS framework. This sample introduces components for buttons (including outlined, loading, and icon-label variants), a responsive navbar with dropdown support, a progress bar, and interactive tabs. It also provides the necessary CSS imports for Bulma and Font Awesome, serving as a reference for integrating third-party CSS frameworks with Jaspr.
_apps/jaspr\pad/samples/bulma · high confidence
Add DOM node reader utility for web components
A new \DomNodeReader\ utility component has been added to the \jaspr\_pad\ application to facilitate access to underlying DOM elements in web builds. This component traverses its child elements and invokes a provided callback with the raw DOM node, enabling components to interact directly with the browser's rendering layer when running on the web platform.
_apps/jaspr\pad/lib/components/utils · high confidence
Add Firebase Hosting configuration for the multi-view example
The multi-view example now includes configuration files for deploying to Firebase Hosting. A \.firebaserc\ file targets the 'jaspr-demo' project, and a \firebase.json\ file configures the 'jaspr-flutter-multiview-demo' site to serve static content from the \build/jaspr\ directory. Additionally, a \.gitignore\ file and updated \README.md\ documentation are provided to support local development and build processes.
_examples/flutter\_multi\view · high confidence
Add Firebase-backed data layer for the Dart Quotes app
The \apps/dart\_quotes/lib/data\ directory now includes a new data access layer that integrates Firebase services. This introduces a \Quote\ model class and a \FirebaseService\ singleton that handles data operations with platform-specific logic: server-side code uses the Firebase Admin SDK to load quotes from Firestore, while client-side (web) code uses the standard Firebase SDK for anonymous authentication, real-time quote retrieval, and managing likes. The implementation relies on conditional imports to separate web and server dependencies.
_apps/dart\quotes/lib/data · high confidence
Add Flutter Plugin Interop example application
Introduces a new example application demonstrating how to integrate Flutter plugins (firebase\_auth, firebase\_core, cloud\_firestore, shared\_preferences) with Jaspr. The addition includes the project structure, analysis options, and web styling required to run this demonstration.
_examples/flutter\_plugin\interop · high confidence
Add Flutter counter widget example
A new CounterWidget has been added to the Flutter multi-view example, providing a user interface with increment and decrement buttons to display and modify a count value.
_examples/flutter\_multi\view/lib/widgets · high confidence
Add Flutter interop example with Firebase-backed counter
The example application now includes a counter component that demonstrates platform-specific behavior: on the web, it uses Firebase Authentication, Firestore, and SharedPreferences to maintain a synchronized count across clients, while the virtual machine target provides a simple local-only counter.
_examples/flutter\_plugin\interop/lib/components · high confidence
Add FlutterCon conference site
Introduces a new Jaspr-based web application for the FlutterCon conference, including configuration for Firebase hosting and a data file containing the full session schedule.
apps/fluttercon · high confidence
Add FlutterCon site components
New UI components for the FlutterCon site have been added to the application, including a navigation bar (PagesNav), a session list with time-based grouping (SessionList), individual session cards (SessionCard), a like/favorite button (LikeButton), and reusable tags (Tag). These components provide the visual structure and interactivity for browsing and interacting with conference sessions.
apps/fluttercon/lib/components · high confidence
Add Fluttercon site pages for schedule, sessions, and favorites
The Fluttercon site now includes dedicated pages for viewing the conference schedule, individual session details, and a user's favorite sessions. The Schedule page displays sessions for a specific day with SEO metadata, the Session page provides detailed information about a talk including speakers and description, and the Favorites page allows users to view their saved sessions sorted by start time.
apps/fluttercon/lib/pages · high confidence
Add HTML sample demonstrating Jaspr's DOM API
A new sample application has been added to the Jaspr Pad that demonstrates how to use the \package:jaspr/dom.dart\ library to write HTML-like markup. The sample showcases creating elements like headings, paragraphs, links, and images, handling typed attributes, managing child components, and attaching event listeners such as \onChange\ on a select element.
_apps/jaspr\pad/samples/html · high confidence
Add LLM documentation index and sync tabs script for Jaspr website
The Jaspr website now includes an \llms.txt\ file that provides a curated index of documentation links and concepts to help large language models understand the framework's structure, covering core concepts like components, routing, and rendering modes, as well as advanced topics and API references. Additionally, a new \sync\_tabs.js\ script has been added to the web application to synchronize tab state changes (specifically for rendering modes) in the documentation interface, ensuring consistent UI behavior and local storage persistence.
apps/website/web · high confidence
Add Link Card component to features section
A new LinkCard component has been added to the home page's features section, providing a styled card that displays an icon, title, and description as a clickable link. The component features a gradient border, hover effects, and specific typography styling to enhance the visual presentation of feature links.
_apps/website/lib/pages/home/3\features/components · high confidence
Add RawText component for rendering unescaped HTML
A new \RawText\ component is available that renders its text input as raw HTML rather than escaping it. This allows developers to inject pre-formatted HTML directly into the DOM, but carries a security warning: because the content is not escaped, it is vulnerable to cross-site scripting (XSS) attacks, so user input must be sanitized before use. The component is implemented with separate logic for the web environment (using \HTMLTemplateElement\) and the VM/server environment (using \RawableRenderObject\), ensuring consistent behavior across platforms.
_packages/jaspr/lib/src/dom/raw\text · high confidence
Add Riverpod integration sample to Jaspr Pad
The Jaspr Pad application now includes a new sample demonstrating how to integrate Riverpod for state management within a Jaspr app. This sample provides a complete, runnable example showing how to set up a ProviderScope, define a NotifierProvider for a counter, and use context.watch and context.read to manage and display state in the UI.
_apps/jaspr\pad/samples/riverpod · high confidence
Add Riverpod state management example for count provider
The example application now includes a new \count\_provider.dart\ file demonstrating how to use Riverpod for state management. This provider defines an asynchronous \initialCountProvider\ that generates a random starting number and a \countProvider\ that uses this value as its initial state, illustrating the integration of async data loading with reactive state in the Jaspr-Riverpod example.
_examples/package\riverpod/lib/providers · high confidence
Add basic Jaspr example application
A new example project has been added to the Jaspr package, providing a minimal demonstration of the framework's component model and server-side rendering capabilities. The example includes a simple counter application with increment and decrement buttons, along with standard analysis options for code quality.
packages/jaspr/example · high confidence
Add code syntax highlighting and window components
The website now includes new \CodeBlock\ and \CodeWindow\ components that display source code with syntax highlighting, line numbers, and optional scrolling. The \CodeWindow\ provides a framed or unframed UI with file tabs, while \CodeBlock\ handles the actual rendering using the \highlight\ library. A dedicated theme file maps syntax tokens to specific colors, enabling styled code display on the site.
_apps/website/lib/components/code\window · high confidence
Add custom font and icon definitions for the FlutterCon website
The FlutterCon website now includes a dedicated CSS file that defines the Roboto typeface (regular, bold, italic, and bold italic variants) and the icomoon icon font. This ensures consistent typography and enables the use of specific icon classes, such as heart icons, across the site's interface.
apps/fluttercon/web · high confidence
Add home and quote pages to the Dart Quotes app
The app now includes a home page that displays a list of quotes sorted by likes, fetched asynchronously from Firebase, and a dedicated quote page that shows individual quote details, author information, and a like button, along with navigation between the two views.
_apps/dart\quotes/lib/pages · high confidence
Add multi-view example with deferred Flutter embedding
The multi-view example now includes a Counter component that integrates a Flutter widget via deferred loading. This change introduces an EmbeddedCounter component that uses FlutterEmbedView.deferred to load the CounterWidget asynchronously, featuring a custom PulsingLoader for visual feedback during the load process. The implementation demonstrates how to embed Flutter content within a Jaspr application with lazy loading capabilities.
_examples/flutter\_multi\view/lib/components · high confidence
Add session data model for conference schedule
A new Session model has been introduced in the apps/fluttercon/lib/models directory to represent conference sessions. This model captures essential details such as title, ID, description, start and end times, speakers, room, and categories. It includes helper methods for generating URL-friendly slugs, formatting time and duration, and extracting session formats. The model uses dart\_mappable for serialization and deserialization, enabling easy conversion between JSON and the Session object, which supports the display and management of session data within the FlutterCon application.
apps/fluttercon/lib/models · high confidence
Add session favorites persistence
The app now allows users to save and restore their favorite sessions. A new FavoritesService manages this state, persisting the list of favorited sessions to local storage (using SharedPreferences on the web) so that selections are retained across app restarts.
apps/fluttercon/lib/services · high confidence
Add stub implementations for JS interop and app context
The Jaspr framework now includes stub files in \packages/jaspr/lib/src/stub\ to support non-web platforms. These stubs provide placeholder implementations for JavaScript interop classes (such as \JS\, \JSPromise\, and \JSArray\), unsafe JS utility extensions, and core app context methods like \url\ and \runApp\. On unsupported platforms, these stubs throw \UnimplementedError\ or \UnsupportedError\, ensuring the library compiles and fails gracefully rather than crashing with missing symbol errors.
packages/jaspr/lib/src/stub · high confidence
Add testimonial card component to the home page
A new \TestimonialCard\ component has been added to the home page's testimonials section. This component renders a styled card displaying a quote, the author's name and position, and a profile picture linked to an external URL, utilizing the application's theme constants for styling.
_apps/website/lib/pages/home/4\testimonials/components · high confidence
Add testimonials section to the website home page
A new testimonials section has been added to the home page, displaying quotes from four industry experts (Kevin Moore, Viktor Lidholt, Dinko Marinac, and Temi Ajiboye) in a responsive grid layout that adjusts from three to one column based on screen width.
_apps/website/lib/pages/home/4\testimonials · high confidence
Add weather-api sample application
A new sample application demonstrating a weather lookup feature has been added to the Jaspr Pad samples. It includes a UI with a search bar and a display for current weather conditions (temperature, location, and icon), backed by an API client that fetches data from the WeatherAPI service.
_apps/jaspr\pad/samples/weather-api · high confidence
Add web assets for the flutter\_multi\_view example
The flutter\_multi\_view example now includes the necessary web-side assets to run as a standalone Progressive Web App. This adds a manifest.json defining the app name, theme colors, and icons, a new SVG logo for the interface, and a bootstrap script to initialize the Flutter web runtime.
_examples/flutter\_multi\view/web · high confidence
Add website UI components and analytics integration
The website now includes a set of new UI components: a configurable release banner, a GitHub button that fetches live star and fork counts, a gradient-bordered link button, a logo, a mobile menu toggle, a particle animation effect, and a theme toggle that supports dark mode with local storage persistence. Additionally, a new analytics utility has been added to capture page visits and easter egg interactions using the Lukehog client.
apps/website/lib/components · high confidence
Add website header and footer layout components
The website now includes dedicated layout components for the header and footer. The new Header component provides a responsive navigation bar with links to Docs, Playground, and Sponsor pages, along with a theme toggle, Discord link, and GitHub button, featuring a mobile menu that collapses navigation on smaller screens. The Footer component displays site navigation, community links (Discord, Contribute, Sponsor), legal pages (Imprint, Privacy Policy), and copyright information, with responsive styling that stacks content vertically on mobile devices.
apps/website/lib/components/layout · high confidence
Add website home page with SEO metadata and section components
The website now includes a home page that renders the site title, description, keywords, author, and Open Graph metadata in the document head, and displays the Hero, Meet, DevEx, Features, Testimonials, and Community sections.
apps/website/lib/pages/home · high confidence
Added AWS and GCP deployment infrastructure for the Dart Quotes Server
The \dart\_quotes\_server\ now includes comprehensive infrastructure-as-code and CI/CD configurations for deploying the application to AWS and Google Cloud Platform. This adds GitHub Actions workflows (\deployment-aws.yml\, \deployment-gcp.yml\) for automated deployments, a Dockerfile for containerized builds, and extensive Terraform scripts (\deploy/aws/terraform/\) to provision the necessary AWS resources, including EC2 auto-scaling groups, RDS PostgreSQL databases, ElastiCache Redis, Application Load Balancers, and CloudFront distributions. Configuration files for development, staging, and production environments are also provided to support these deployment targets.
_apps/dart\_quotes\server · high confidence
Added CLI tool to generate mascot logo constants
A new script at packages/jaspr\_cli/tool/logo/generate\_gradient\_logo.dart was added to convert the mascot PNG image into a grid of characters (representing transparent, dark blue, medium blue, and light blue pixels) and save the result as Dart constants in lib/src/helpers/print\_logo\_constants.dart. This tool enables the CLI to display a branded ASCII-style logo by generating the necessary constant data from the source image.
_packages/jaspr\cli/tool/logo · high confidence
Added Lucide icon font support to the website
The website now includes a dedicated CSS file for the Lucide icon font, enabling the use of Lucide icons via CSS classes (e.g., .icon-\*) across the site. This change introduces the font-face definition and associated utility classes, allowing developers to easily integrate Lucide icons into the website's UI.
apps/website/web/font · high confidence
Added Serverpod example server with web UI and API endpoints
The example server now includes a complete backend structure featuring an \ExampleEndpoint\ with a \hello\ method, a serializable \Example\ model, and a \FutureCall\ implementation. Additionally, it introduces a web layer using Jaspr, providing a \RootRoute\ that renders a home page, along with the necessary generated protocol and endpoint dispatch code to support these features.
_examples/backend\_serverpod/example\server/lib/src · high confidence
Added Serverpod example with interactive counter component
The Serverpod example application now includes a new interactive counter component and a home page layout. Users can see the current count and increment it by clicking the 'Increase' button, demonstrating stateful component behavior within the Jaspr framework integrated with Serverpod.
_examples/backend\_serverpod/example\server/lib/components · high confidence
Added animated mode selector component for the Meet page
A new \ModesAnimation\ component has been added to the home Meet section, which displays an animated text cycle highlighting Static Sites, Server Rendered Sites, and Single Page Apps. This component introduces a visual animation effect to the website's landing area to showcase different deployment modes.
_apps/website/lib/pages/home/1\meet/components · high confidence
Added automated deployment script for Dart Quotes
A new \deploy.dart\ tool has been added to the \apps/dart\_quotes/tool\ directory. This script automates the process of building the application's Docker image, tagging it for Google Container Registry, pushing it, and deploying it to Google Cloud Run in the europe-west1 region. This provides a streamlined way to deploy the Dart Quotes application to production.
_apps/dart\_quotes/tool, apps/jaspr\pad/tool · high confidence
Added example component implementations
The examples/backend\_dart\_frog/lib/components directory now includes concrete implementations of a stateful Counter component and a stateless Hello component, providing functional examples of how to build interactive and static UI elements within the Jaspr framework.
_examples/backend\_dart\frog/lib/components · high confidence
Added quote like button with social interaction and visual feedback
The quotes application now includes a like button component that allows users to like and unlike quotes. The button displays the current like count and updates in real-time for web users by streaming data from Firebase. When a user likes a quote, a confetti animation is triggered to provide visual feedback. The component also handles styling for active and inactive states, including hover effects and transitions.
_apps/dart\quotes/lib/components · high confidence
Added theme constants and view transition styles to the multi-view example
The multi-view example now includes a dedicated theme configuration file defining primary, surface, and loader colors, along with card dimensions and border radius. Additionally, a new view transition module has been added to implement CSS view transitions for card animations, handling the visual effects for adding, removing, and reordering cards within the interface.
_examples/flutter\_multi\view/lib/constants · high confidence
Added web platform adapters for syntax highlighting, HTML DOM, and Material Components
The application now includes new adapter files in the \apps/jaspr\_pad/lib/adapters\ directory to bridge Dart with web-specific APIs. These additions provide a \highlightAll\ binding for syntax highlighting via \dart:js\_interop\, re-exports for core HTML DOM elements (such as \window\, \document\, and \Element\) via \dart:html\, and exports for Material Design Components (including \MDCRipple\, \MDCDialog\, \MDCMenu\, \MDCSnackbar\, \MDCTabBar\, and \MDCTextField\) from \package:mdc\_web\. These adapters enable the pad application to interact directly with browser APIs and UI libraries on the web platform.
_apps/jaspr\pad/lib/adapters · high confidence
Generated HTML and SVG DOM components for Jaspr
The Jaspr framework now includes a comprehensive set of generated Dart components for HTML and SVG elements, covering content structures (like article, aside, body), forms (button, form with method and validation options), media (audio, img), interactive widgets (details, dialog), tables, and text links. These components allow developers to render standard HTML tags directly in their views with support for attributes, CSS classes, inline styles, and event listeners. The update also introduces deprecated wrapper functions for text, raw HTML, and fragments, guiding users to migrate to the core Component API.
packages/jaspr/lib/src/dom/html · high confidence
HTML specification generation tool added
A new Dart script, generate\_html.dart, has been added to the tooling package to automatically generate HTML component definitions and specifications from a JSON data source. This tool reads HTML tag and attribute metadata to produce the corresponding Dart code and spec files, streamlining the maintenance of the HTML element library.
packages/jaspr/tool · high confidence
Initial Serverpod example client package
The example\_client directory now contains a complete, generated Serverpod client package. This includes the core client implementation in lib/src/protocol/client.dart, which exposes the 'example' endpoint and its 'hello' method, along with the serializable 'Example' model defined in lib/src/protocol/example.dart. The package is configured with standard Dart analysis options, dartdoc settings, and a .gitignore file to exclude build artifacts and pubspec.lock, providing a ready-to-use client structure for the Serverpod example project.
_examples/backend\_serverpod/example\client · high confidence
Initial release of Jaspr Serverpod integration package
The new \jaspr\_serverpod\ package provides the integration layer between Jaspr and Serverpod, enabling server-side rendering of Jaspr components within a Serverpod web server. It introduces \JasprRoute\ for handling server-side rendering, an \InheritedSession\ widget and \context.session\ extension to access the Serverpod session inside component build methods, and a \JasprConnectivityMonitor\ to sync browser connectivity status with the generated Serverpod client. The package also includes setup documentation and configuration options for development and deployment.
_packages/jaspr\serverpod · high confidence
Initial release of jaspr\_router package
The \jaspr\_router\ package is introduced, providing a client-side and server-side routing solution for Jaspr applications. It supports nested routes, path parameters, lazy-loaded routes for code splitting, and static site generation (SSG) with sitemap support. The package includes a \Link\ component for router-aware navigation, handles server-side redirects via HTTP 302 responses, and respects the \\<base href\>\ configuration for correct path resolution.
_packages/jaspr\_content, packages/jaspr\router · high confidence
Initial website application scaffolding
A new website application has been added to the workspace, providing the foundational structure for a Jaspr-based web project. This includes configuration for Firebase hosting (targeting the 'jaspr-website' site and 'jaspr-demo' project), standard Dart analysis options inherited from the repository, and a README with instructions for running and building the app. This entry covers the specific configuration and scaffolding files for this location.
apps/website · high confidence
Introduce CLI installation and project detection helpers in the VS Code extension
The VS Code extension now includes new helper modules to manage the Jaspr CLI lifecycle and identify relevant projects. The \install\_helper\ ensures the \jaspr\_cli\ is installed and meets the minimum version requirement, prompting the user to run \dart install jaspr\_cli\ if it is missing or outdated. The \project\_helper\ detects folders containing a \pubspec.yaml\ that references Jaspr, enabling the extension to target the correct project context. Additionally, \process\_helper\ provides utilities to run Jaspr commands and stream their output to VS Code output channels, while \object\_helper\ converts LSP ranges to VS Code ranges.
modules/jaspr-code/src/helpers · high confidence
Introduce Dart Quotes app with server-side rendering and client hydration
The \dart\_quotes\ application is added, featuring a dual-entrypoint architecture that separates server-side rendering (SSR) from client-side hydration. The server entrypoint (\main.server.dart\) renders the initial HTML with embedded styles and fonts, while the client entrypoint (\main.client.dart\) hydrates the app using generated options that lazy-load specific components like \QuoteLikeButton\. The app includes routing for a home page and individual quote pages, integrates Firebase for web, and provides interop bindings for a confetti effect.
_apps/dart\quotes/lib · high confidence
Introduce Fluttercon Berlin 2024 site with server/client entrypoints
The \apps/fluttercon/lib\ directory now contains the core application structure for the Fluttercon Berlin 2024 site. This includes \app.dart\, which defines the routing logic for schedule days, session details, and favorites, loading session data from a local \sessions.json\ file. Separate entrypoints (\main.client.dart\ and \main.server.dart\) initialize the Jaspr framework for client-side hydration and server-side rendering respectively, with generated options files configuring client targets and shared styles.
apps/fluttercon/lib · high confidence
Introduce Jaspr Builder package with modular build system
The new \jaspr\_builder\ package provides the core build infrastructure for the Jaspr framework, exposing a comprehensive set of \build\ package builders. This includes dedicated builders for generating client and server options, bundling client modules and entrypoints, handling platform-specific imports and stubs, managing CSS styles (including standalone generation), and supporting codec serialization. This change establishes the foundational build pipeline that processes application components and assets.
_packages/jaspr\builder/lib · high confidence
Introduce Jaspr CLI tooling daemon and structured logging
The Jaspr CLI now includes a background daemon (\jaspr tooling daemon\) that communicates via a JSON-RPC-like protocol over stdin/stdout, enabling external tools (such as the VS Code extension) to interact with the CLI programmatically. This change introduces a new \Daemon\ and \DaemonDomain\ architecture in \packages/jaspr\_cli/lib/src/daemon/\, along with a \DaemonLogger\ that translates CLI logs into structured events for the daemon. The \command\_runner.dart\ has been updated to support this daemon mode, and the \logging.dart\ system has been refactored to support tagged, leveled output compatible with both terminal and daemon consumers. Additionally, the CLI now respects the \PUB\_HOSTED\_URL\ environment variable for pub mirror support and includes a new \html\_spec.dart\ file defining HTML element semantics for the framework.
_packages/jaspr\cli/lib/src · high confidence
Introduce Jaspr Flutter Embed package for embedding Flutter in web apps
The new \jaspr\_flutter\_embed\ package allows developers to embed Flutter widgets directly within Jaspr web applications. It provides a \FlutterEmbedView\ component that handles the lifecycle of a Flutter engine instance, including deferred loading of the Flutter engine and widgets to optimize initial page load times. The implementation supports multi-view embedding, enabling multiple independent Flutter views on a single page, and defaults to the Canvaskit renderer for consistent rendering. Users can configure view constraints (min/max width and height), custom loaders, and styles, with a fallback UI provided while the Flutter engine initializes.
_packages/jaspr\_flutter\embed/lib · high confidence
Introduce client-side hydration for @client components
The client-side rendering engine now supports hydrating server-rendered pages by locating and mounting \@client\ components within the existing DOM. This change introduces a new \ClientApp\ component and a \SlottedChildView\ system that identifies component boundaries using special HTML comment markers (anchors) injected by the server. The \ClientAppBinding\ manages the initialization, while \ClientComponentAnchor\ and \ServerComponentAnchor\ classes handle the asynchronous resolution of client-side builders and the mapping of server-rendered slots. This allows interactive Dart components to take over specific parts of a static server-rendered page without replacing the entire document, preserving the initial HTML structure while enabling client-side interactivity.
packages/jaspr/lib/src/client · high confidence
Introduce foundation package with platform annotations and state synchronization
The Jaspr framework now includes a new \foundation\ library that provides core building blocks for application development. Developers can use the new \@client\ annotation to mark components that should only run on the browser, and the \@Import.onWeb\ or \@Import.onServer\ annotations to handle platform-specific imports with automatic stubbing. The package also introduces a \SyncStateMixin\ that allows stateful components to automatically synchronize their state data from the server to the client during hydration. Additionally, the framework exposes new constants such as \kIsWasm\ and \kGenerateMode\ to detect the compilation target and build mode, alongside standard utility types like \ChangeNotifier\ and \CachingIterable\.
packages/jaspr/lib/src/foundation · high confidence
Introduce jaspr\_test package for component, client, and server testing
The new \jaspr\_test\ package provides testing utilities for the Jaspr framework, built on top of \package:test\. It introduces three distinct testing modes: \testComponents\ for unit-testing components in a simulated environment, \testClient\ for testing DOM interactions in a headless browser, and \testServer\ for verifying server-rendered HTML responses via a virtual HTTP server. The package includes a \find\ API for locating components by tag, text, key, or type, along with matchers like \findsOneComponent\ and \findsNothing\ to assert on the rendered output.
_packages/jaspr\test · high confidence
Introduce new Jaspr CLI tooling and project scaffolding
The \jaspr\_cli\ package now provides a comprehensive set of commands for managing Jaspr projects, including \create\ for scaffolding new apps with configurable rendering modes and routing, \build\ for compiling to static, server, or client targets with options for WebAssembly and source maps, \serve\ and \dev\ for development with hot-reload, and \migrate\ for automated code updates. The CLI also includes \doctor\ for environment diagnostics, \clean\ for build artifact removal, \install-skills\ for AI agent integration, and \update\ for self-upgrades, all built on a shared \BaseCommand\ infrastructure.
_packages/jaspr\cli/lib/src/commands · high confidence
Introduce structured data models for the Jaspr Pad editor
The Jaspr Pad application now includes a comprehensive set of data models in the \lib/models\ directory to support its core features. These new classes define the structure for API interactions (compilation, analysis, formatting, and document hover info), project management (handling Dart, HTML, and CSS files via \ProjectData\), and interactive tutorials (defining steps, configurations, and solutions via \TutorialData\). Additionally, models for GitHub Gist integration (\GistData\) and sample management (\Sample\) have been added, all utilizing the \dart\_mappable\ library for serialization and deserialization.
_apps/jaspr\pad/lib/models · high confidence
Introduce type-safe CSS styling API with class-based properties and nested rules
The \jaspr\ framework now provides a comprehensive, type-safe API for defining CSS styles in Dart. This change introduces a \css()\ utility for creating nested style rules (supporting selectors, \&\ parent references, and at-rules like \@media\, \@font-face\, and \@keyframes\) and a set of strongly-typed property classes (e.g., \Color\, \Border\, \Flex\, \Animation\) that replace raw string values. Users can now compose styles using Dart constructors and extensions (such as \.deg\ for angles) to generate valid CSS, enabling better IDE support and compile-time safety for styling components.
packages/jaspr/lib/src/dom/styles · high confidence
Introduces reusable UI components for the Jaspr Pad editor
The Jaspr Pad application now includes a suite of new UI components located in the elements directory, providing a consistent Material Design look and feel. This update adds a Dialog system for managing modal interactions (such as file deletion or creation), a Button component with icon and state support, a Markdown renderer with syntax highlighting, a Splitter for resizable layouts, a TabBar for navigation, a TextField for input, a Snackbar for notifications, and a Menu component. These components are built using the Jaspr framework and Material Design Components (MDC) adapters, replacing previous ad-hoc implementations with a standardized, reusable set of widgets.
_apps/jaspr\pad/lib/components/elements · high confidence
Jaspr Pad introduces dedicated UI panels for console, documentation, issues, and tutorials
The playground interface now includes a set of new, dedicated components for the right-hand side and footer areas: a Console panel for displaying execution messages, a Documentation panel that renders API hints as markdown with links to Dart library docs, an Issues panel that lists errors and warnings and allows navigation to their source locations, an Output panel for the execution iframe, and a Tutorial panel for guided step-by-step instructions. These panels are integrated into the EditorSplitView, which manages a tabbed interface (UI, Console, Docs, Issues) and automatically switches to the Issues tab when compilation errors occur, providing a more structured and interactive coding experience.
_apps/jaspr\pad/lib/components/playground/panels · high confidence
Jaspr lints plugin migrated to analysis\_server\_plugin with new code assists and rules
The Jaspr lints package has been migrated to use the new analysis\_server\_plugin framework, introducing a comprehensive set of new code assists and lint rules for Jaspr developers. The plugin now provides assists to create and convert components (Stateless, Stateful, Inherited, Async), manage CSS styles (adding styles, converting to nested styles), handle platform-specific imports (converting to web or server imports), and manipulate the component tree (wrapping with HTML elements, extracting components, removing components). Additionally, it enforces best practices through new lint rules: prefer\_html\_components (replacing Component.element with direct HTML tags), prefer\_styles\_getter (using getters for CSS styles for hot-reload support), sort\_children\_last (enforcing argument order in HTML components), styles\_ordering (sorting style arguments), and unsafe\_imports (detecting platform-unsafe imports based on pubspec configuration).
_packages/jaspr\lints/lib · high confidence
JasprPad server-side code analysis, compilation, and project management
The JasprPad application now includes a comprehensive server-side backend located in \apps/jaspr\_pad/lib/server\ that enables real-time code analysis, compilation, and project handling. This backend integrates the Dart Analysis Server to provide live error checking, code formatting, and hover documentation for users editing code in the browser. It features a Google Cloud Storage-backed cache to store and retrieve compilation results, significantly speeding up repeated builds. Additionally, the server supports downloading user projects as zipped archives, loading and serving interactive tutorial steps, and managing sample code directories, creating a fully functional online coding environment.
_apps/jaspr\pad/lib/server · high confidence
New @Import annotation system for platform-specific exports
The builder now supports a new \@Import\ annotation that allows developers to declaratively specify which symbols to export from libraries, with support for platform-specific filtering (web vs. VM). The \analyzing\_builder\ scans for \@Import\ annotations on library imports, resolves the specified symbols, and generates an intermediate \.imports.json\ file. The \imports\_builder\ then processes this JSON to generate platform-specific export files (\\_web.dart\ and \\_vm.dart\) that conditionally export symbols based on the target platform, while the \stubs\_builder\ creates a \\_stubs.dart\ file containing dynamic stubs for any symbols that are not available on the current platform, ensuring type-safe cross-platform usage.
_packages/jaspr\builder/lib/src/imports · high confidence
New CLI helper utilities for configuration, proxying, and branding
The CLI now includes a suite of helper modules to enhance configuration management, development server capabilities, and user interface. Settings are now persisted using the Dart data home directory (migrating from the legacy .jaspr folder) via settings\_helper.dart, and the CLI supports passing environment variables through --dart-define, --dart-define-client, --dart-define-server, and --dart-define-from-file (supporting both JSON and .env formats) via dart\_define\_helpers.dart. The development workflow gains a proxy helper (proxy\_helper.dart) that routes requests between the dev server and Flutter, handles connection retries, and fixes Safari debug errors. Additionally, the CLI now features a daemon helper for background tooling, port availability checks, and a new branded logo with gradient colors printed to the terminal.
_packages/jaspr\cli/lib/src/helpers · high confidence
New Community page with dynamic sponsor display
The website now includes a dedicated Community section on the home page, featuring a card layout that highlights sponsorship opportunities, Discord community access, and enterprise support options. This section dynamically fetches and displays current GitHub sponsors via an external API, showing their avatars and linking to their profiles, while providing clear calls-to-action for users to become sponsors or contact the maintainer for support.
_apps/website/lib/pages/home/5\community · high confidence
New DOM utilities and ViewTransition support
The \packages/jaspr/lib/src/dom\ area now includes several new capabilities: a typed \events\ helper for HTML components that automatically converts input values (such as numbers, dates, or file lists) to the correct Dart types; a \Style\ component for rendering CSS rules via a \\<style\>\ tag; a \DomValidator\ for validating element names and attributes; and a \ViewTransitionMixin\ that enables state updates with view transitions. Additionally, DOM type checks are now cached for improved performance.
packages/jaspr/lib/src/dom · high confidence
New Dart Frog backend example for Jaspr integration
Added a new example application in the \examples/backend\_dart\_frog\ directory that demonstrates how to integrate Jaspr with the Dart Frog backend framework. The example includes a middleware setup (\serveJasprApp\) to serve client-side assets and routes for a static index page, an interactive counter component, and a dynamic 'hello' route, along with the necessary configuration files (\analysis\_options.yaml\, \build.yaml\) and documentation to run the combined server and client environments.
_examples/backend\_dart\frog · high confidence
New DevEx feature highlights on the website
The website's developer experience section now features four new interactive panels—Develop, Run, Integrate, and Analyze—that showcase core Jaspr capabilities. These components demonstrate familiar Flutter concepts like BuildContext and setState, illustrate the integrated CLI tooling for serving and building sites, highlight the ability to import standard Dart and Flutter web plugins via pub.dev, and display built-in linter and code completion features such as quick actions for component conversion.
_apps/website/lib/pages/home/2\devex/items · high confidence
New Document component API for server and client rendering
The \packages/jaspr/lib/src/components/document\ area introduces a new \Document\ component interface with separate client (\document\_client.dart\) and server (\document\_server.dart\) implementations. On the server, \BaseDocument\ constructs the full HTML structure (including \\<html\>\, \\<head\>\, and \\<body\>\) with configurable title, base href, charset, viewport, meta, and styles, while \TemplateDocument\ allows loading external \.template.html\ files. On the client, \HeadDocument\ and \AttachDocument\ enable attaching metadata and attributes to the \\<head\>\ and \\<body\>\ elements dynamically, supporting override logic for duplicate elements like title and base. This change replaces previous ad-hoc document handling with a structured, factory-based API for managing document structure and metadata across server-side pre-rendering and client-side hydration.
packages/jaspr/lib/src/components/document · high confidence
New Flutter embedding example with interactive controls
Added a new example in \examples/flutter\_embedding/lib/components\ that demonstrates embedding Flutter apps within a Jaspr application. The example includes an \App\ component that serves as the entry point, a \FlutterAppContainer\ to host the Flutter widget tree, and a \FlutterTarget\ component that renders the embedded Flutter view with support for visual effects (shadow, mirror, resize, spin) and device mode toggling. Interactive controls (\EffectsControls\ and \InteropControls\) allow users to adjust these effects and switch between demo screens (Counter, TextField, Custom App) via JS interop, while a \RippleLoader\ provides a loading state during initialization. Also in this area: 1 commit (1 fix) fixing examples/flutter\_embedding, examples/flutter\_multi\_view, packages/jaspr\_lints.
_examples/flutter\_embedding/lib/components, examples/flutter\embedding/lib/widgets · low confidence
New Jaspr interactive tutorial added
The JasprPad application now includes a new interactive tutorial that guides users through building web apps with Jaspr. The tutorial covers core concepts including rendering HTML components, creating stateless and stateful components, and handling events with state updates, providing step-by-step exercises and solutions for each chapter.
_apps/jaspr\pad/samples/tutorial · high confidence
New build-time codec system for serializing annotated types
The \jaspr\_builder\ now includes a new build-time codec system that automatically generates serialization and deserialization logic for Dart types annotated with \@encoder\ and \@decoder\. This system consists of a \CodecModuleBuilder\ that scans libraries for these annotations and outputs \.codec.json\ metadata, and a \CodecBundleBuilder\ that aggregates this metadata into a single \codec.bundle.json\ file. The \codecs.dart\ module provides visitors that generate the necessary Dart code to handle encoding and decoding of these types, including support for nested collections and extension types, enabling seamless data transfer without manual boilerplate.
_packages/jaspr\builder/lib/src/codec · high confidence
New client-mode development workflow with dedicated Chrome and client runners
The development server now supports a new client-mode workflow that manages browser and client-side processes separately. This change introduces a \ChromeRunner\ to launch and manage a dedicated Chrome instance with isolated user data, a \ClientRunner\ to handle client-side compilation via the build daemon, and a \ClientManager\ to track client connections and events. The \ClientDomain\ exposes daemon methods for hot reloading, hot restarting, and stopping client applications, while the \DevWorkflow\ orchestrates these components to enable hot reloads for client-side code and CSS generation in client mode.
_packages/jaspr\cli/lib/src/dev · high confidence
New code editor and execution output components for the playground
The playground now includes a new code editor component that integrates CodeMirror with custom options (such as dark theme, specific keybindings, and folding) and an execution output system that manages an iframe sandbox. This system uses a service to send HTML, CSS, and JavaScript to the iframe, handles console output and test results via postMessage, and supports features like RequireJS module loading and Firebase integration, providing a more robust environment for running and debugging code within the app.
_apps/jaspr\pad/lib/components/playground/output · high confidence
New example demonstrating custom Shelf server integration
Added a new backend\_shelf example that shows how to integrate Jaspr with a custom Dart Shelf HTTP server instead of using Jaspr's default built-in server. The example provides separate client and server entrypoints, demonstrating how to mount the Jaspr app as a Shelf handler under a specific route prefix using \serveApp\, and how to manually render individual components to HTML strings using \renderComponent\.
_examples/backend\shelf · high confidence
New hero section for the website homepage
The website now includes a dedicated hero component at the top of the home page, featuring a headline identifying Jaspr as the 'Web Framework for Dart Developers', a descriptive paragraph, and call-to-action buttons for installation and getting started. The layout is styled with flexbox for centering, includes a media query to adjust the minimum height on mobile devices, and utilizes existing theme constants and sub-components like the install command and link buttons.
_apps/website/lib/pages/home/0\hero · high confidence
New interactive DevEx showcase components
The DevEx section of the website now includes two new components: a CounterButton that displays a click count and animates particle effects upon interaction, and a DevexBox that presents feature details with a styled preview area and caption. These components enhance the developer experience showcase by adding interactive and visually structured content blocks.
_apps/website/lib/pages/home/2\devex/components · high confidence
New interactive hero section components for the website
The home page hero section now includes several new interactive UI components: a 'HeroPill' promoting the official Jaspr VSCode extension, an 'InstallCommand' widget that allows users to click-to-copy the installation command to their clipboard, and a 'MeetJasprButton' that features a progressive reveal animation (triggered by mouse movement or touch) which, upon completion, reveals a 'Meet Jasper' Easter egg overlay. The overlay displays a randomized sequence of images and can be dismissed via the Escape key or a click.
_apps/website/lib/pages/home/0\hero/components · high confidence
New multi-view example with view transitions and deferred loading
The flutter\_multi\_view example now demonstrates Jaspr's view transition capabilities and deferred component loading. The app uses separate client and server entrypoints, with the client side leveraging \setStateWithViewTransition\ to animate changes when adding or removing counter widgets. It also implements deferred loading for the main app component to optimize initial load times, and includes a footer with attribution links.
_examples/flutter\_multi\view/lib · high confidence
New provider synchronization and context integration APIs
The \jaspr\_riverpod\ package introduces new capabilities for synchronizing provider state across navigation and integrating Riverpod with the Jaspr framework. Users can now use the \syncWith\ extension on providers (such as \NotifierProvider\, \FutureProvider\, and \StateProvider\) to define state that persists and restores automatically during navigation, utilizing an optional codec for serialization. Additionally, the package adds a \ProviderContext\ extension on \BuildContext\ to provide framework-specific implementations of \watch\, \listen\, and \exists\, ensuring that provider subscriptions are correctly managed within the Jaspr component lifecycle.
_packages/jaspr\riverpod/lib/src/core/jaspr · high confidence
New standalone CSS generation from @css declarations
The Jaspr builder now supports generating standalone CSS output for projects using the @css annotation. This change introduces three new build steps: StylesModuleBuilder extracts style elements from libraries containing @css annotations; StylesBundleBuilder aggregates these modules into a single bundle; and StylesStandaloneBuilder generates a standalone Dart runner that outputs the compiled CSS as JSON. This enables users to extract and use their application's styles independently of the main application runtime, supporting scenarios like server-side rendering or external style injection.
_packages/jaspr\builder/lib/src/styles · high confidence
New sync builder for generating state mixins
A new \SyncMixinsBuilder\ has been added to the \jaspr\_builder\ package to automatically generate Dart mixins for components annotated with \@sync\. This builder scans libraries for \@sync\ annotations on non-static, non-final, public fields within \State\ classes and produces a \.sync.dart\ file containing a mixin that implements \SyncStateMixin\. The generated mixin provides getter/setter accessors and handles state serialization and deserialization using the project's configured codecs, enabling seamless synchronization of component state.
_packages/jaspr\builder/lib/src/sync · high confidence
New utility components for async, state, and notifications
The Jaspr framework adds several new component utilities to \packages/jaspr/lib/src/components\. \async.dart\ introduces \StreamBuilderBase\ and \StreamBuilder\ for building UI from asynchronous stream data, with server-side safety checks. \listenable\_builder.dart\ provides \ListenableBuilder\ and \ValueListenableBuilder\ to rebuild components when a \Listenable\ (such as a \ChangeNotifier\) changes. \basic.dart\ adds \Builder\ and \StatefulBuilder\ for creating inline component trees with their own \BuildContext\ and state. \notification\_listener.dart\ implements \NotificationListener\ for handling bubbling notifications up the component tree. Additionally, \badge.dart\ adds a \JasprBadge\ component for displaying a "Built with Jaspr" badge, and \document.dart\ exports the \Document\ component for client/server environments.
packages/jaspr/lib/src/components · high confidence
New website home page sections for components, modes, and features
The website now includes new home page sections that highlight Jaspr's core capabilities. The 'Meet' section introduces components as fundamental building blocks and showcases the three rendering modes (static, server-rendered, and single-page apps) with an animated text display. The 'Developer Experience' section emphasizes Dart's productivity for web development. The 'Features' section provides an overview of key capabilities including routing, data fetching, SEO, state management, Flutter embedding, custom backends, styling, and testing.
_apps/website/lib/pages/home/1\meet · high confidence
Project initialization and repository structure setup
The repository has been initialized with a new structure, including a root README describing Jaspr as a Dart web framework, a CONTRIBUTING guide for Melos-based development, and a ROADMAP. The project now uses a custom linting plugin (jaspr\_lints) instead of standard lints, and includes configuration for documentation (docs.json), a Docker environment (.dockerignore), and a git submodule for benchmarks. Standard project files like LICENSE, AUTHORS, and .gitignore have also been added.
(repo-wide) · high confidence
Server-side async component support
Introduced server-only async components (AsyncStatelessComponent, AsyncBuilder) that allow build methods to return a Future, enabling asynchronous data fetching during server-side rendering. This new capability is implemented in the async.dart module, which defines the AsyncBuildableElement and its subclasses to handle the async build lifecycle.
packages/jaspr/lib/src/server/components · high confidence
Server-to-client state hydration via HTML comments
The framework now supports hydrating server-rendered state on the client by embedding serialized data into HTML comment markers. The new \sync\_vm.dart\ and \sync\_web.dart\ files implement this by injecting a marker comment containing the JSON-encoded state on the server side, and the client-side logic parses this comment to restore the component's state, enabling seamless state transfer during initial page load.
packages/jaspr/lib/src/foundation/sync · high confidence
Support for platform-specific imports and extension elements
The builder now supports platform-specific imports via the @Import annotation, allowing developers to conditionally include code based on the target platform. Additionally, the import resolution logic has been updated to correctly handle and expose extension elements from imported libraries, ensuring that extension methods and getters are available in the generated code.
_packages/jaspr\builder/lib/src · high confidence
Updated Serverpod example server with Docker, AWS/GCP deployment templates, and Jaspr integration
The example server has been updated to include a Dockerfile for containerized builds (using Dart 3.2.5 and Jaspr), new .gitignore and .gcloudignore files, and comprehensive deployment infrastructure for AWS (Terraform for EC2, RDS, ElastiCache, CloudFront, and CodeDeploy) and GCP (Terraform for GCE and Cloud Run scripts). Configuration files for development, staging, and production environments are now provided, along with a Jaspr-specific analysis options include.
_examples/backend\_serverpod/example\server · high confidence
VS Code extension adds HTML-to-Jaspr conversion and a serve daemon
The Jaspr VS Code extension now automatically converts pasted HTML into Jaspr Dart code via the HtmlPasteProvider, and introduces a JasprServeDaemon that manages the dev server lifecycle through a dedicated terminal and status bar controls. These changes improve the developer workflow by streamlining HTML integration and providing better visibility and control over the running Jaspr application.
modules/jaspr-code, modules/jaspr-code/src/jaspr · high confidence
VS Code extension now supports creating, serving, and debugging Jaspr projects
The VS Code extension has been updated to provide integrated tooling for Jaspr development. Users can now create new projects via the 'jaspr.create' command, choosing from templates like documentation sites, static or server-rendered sites, single-page applications, and embedded Flutter showcases. The extension introduces a 'jaspr.serve' command that launches a dedicated serve daemon for live reloading, and adds a 'jaspr' debug configuration provider to enable debugging of Jaspr applications directly within VS Code. Additionally, code lenses are registered for Dart files to assist with component navigation and serving.
modules/jaspr-code/src · high confidence
Website theme and styling constants introduced
The website now uses a centralized theme configuration defined in \apps/website/lib/constants/theme.dart\. This change establishes a complete design system including light and dark color palettes, typography scales, and responsive breakpoints. It also applies global CSS rules for HTML elements, fonts, and common UI patterns, enabling consistent visual styling across the site.
apps/website/lib/constants · high confidence
Removals
Removal of example application source files
The example application's source code has been removed from the repository. Specifically, the Dart components (app.dart, button.dart), the entry points for server (main.dart) and web (web/main.dart) execution, and the service definition (service.dart) are no longer present. This eliminates the runnable demo that previously showcased the framework's stateful components and data service integration.
example · high confidence
Removal of legacy Dart web framework and server runtime
The library has removed its entire custom web framework implementation, including the core component model (Component, Element, StatefulComponent, StatelessComponent, InheritedComponent), the DOM rendering layer (DomComponent, Text), and the application entry points for both browser and server environments. This deletion eliminates the ability to run Dart web applications using the previous \dart\_web\ export and the associated server-side hot-reload and daemon integration logic.
lib, lib/src · high confidence
Behavioural changes
4 commits (1 fix) modifying packages/jaspr\_cli
A change to existing behaviour in packages/jaspr\_cli — 4 commits (1 fix), 14 files: “Extend CSS hot reload test timeout (\#991)”; “Add --enable-experiment to jaspr build and jaspr serve (\#895)”; “Restore --proxy-port on jaspr serve and jaspr daemon (\#966)”; and 1 more (refs \#991, \#895, \#966, \#980). Also in this area: 4 commits (2 fixes) modifying packages/jaspr\_cli.
_packages/jaspr\cli/test/src/dev · medium confidence · unverified
Add legacy ChangeNotifierProvider for Riverpod 3 compatibility
The package now includes a \ChangeNotifierProvider\ implementation in the \legacy\ directory to support Riverpod 3.1.0+. This addition allows users to continue using the \ChangeNotifier\ pattern for state management within Jaspr components, ensuring backward compatibility with existing codebases that rely on this specific provider type during the migration to Riverpod 3.
_packages/jaspr\riverpod/lib/src/providers · high confidence
Added icon treeshaking tool for website fonts
A new Dart script (\icon\_treeshake.dart\) has been added to the website tooling to optimize font file sizes. This tool identifies specific icon glyphs used on the site (such as moon, sun, check, and copy) and uses the Flutter engine's font-subset utility to generate a smaller, custom font file containing only those characters, thereby reducing the bandwidth required to load website fonts.
apps/website/tool · high confidence
Automated migration tools for Jaspr 0.22.0 API changes
The Jaspr CLI now includes a suite of automated migration scripts to help developers upgrade their projects to version 0.22.0. These tools automatically refactor code to match the new API: the \build\_method\migration\ converts \build()\ methods from using \sync\\/\yield\ to returning single \Component\ instances; the \component\_factory\_migration\ replaces standalone constructors like \Text()\, \DomComponent()\, and \Fragment()\ with static factory methods like \Component.text()\, \Component.element()\, and \Component.fragment()\; the \html\_helper\_migration\ updates helper functions \text()\, \fragment()\, and \raw()\ to their new static or dot-shorthand forms; the \client\_import\_migration\ switches imports from \package:jaspr/browser.dart\ to \package:jaspr/client.dart\ and updates related identifiers; the \dom\_import\_migration\ adds the necessary \package:jaspr/dom.dart\ import when DOM APIs are detected; and the \entrypoint\_migration\ splits the application entry point into separate \main.server.dart\ and \main.client.dart\ files with corresponding options imports.
_packages/jaspr\cli/lib/src/migrations · high confidence
Automated version synchronization and scaffold generation tooling
The CLI now includes new internal tool scripts to automate maintenance tasks. The \generate\_versions.dart\ script automatically extracts current package versions from the monorepo and writes them to \lib/src/version.dart\, while also updating the \jaspr\_version\ metadata in all agent skill definition files to ensure consistency. Additionally, a new \generate\_scaffold.dart\ script streamlines the process of bundling scaffold templates and documentation templates into the CLI's internal resource bundles using Mason.
_packages/jaspr\cli/tool · high confidence
Generated platform-specific Firebase import stubs for Dart Quotes
The Dart Quotes app now includes generated import stubs (\_stubs.dart, \_vm.dart, \_web.dart) created by jaspr\_builder to handle platform-specific dependencies. These files abstract Firebase services (Firestore, Auth, Core) and UI libraries (Confetti), providing stubbed dynamic types for generic environments, real implementations for the VM (using dart\_firebase\_admin), and real implementations for the Web (using cloud\_firestore, firebase\_auth, and firebase\_core).
_apps/dart\quotes/lib/generated · high confidence
Generated stubs for web platform imports
The generated import files for the web platform now provide concrete type definitions and exports for application components (MyApp), Flutter widgets, and Riverpod scopes, replacing the previous dynamic stubs used for other platforms.
_examples/flutter\embedding/lib/generated · high confidence
Generated web platform stubs for code editor and UI components
The Jaspr Pad application now includes generated import stubs that bridge the code editor (CodeMirror) and Material Design Components (MDC) with the web platform. These files provide type-safe exports for essential DOM elements (such as window, document, and input elements) and specific libraries like CodeMirror and mdc\_web, ensuring consistent access to these dependencies across the application's generated code.
_apps/jaspr\pad/lib/generated · medium confidence
Internal library entry point for the Jaspr CLI tool
The \jaspr\_cli\ package now exposes a dedicated library entry point (\jaspr\_cli.dart\) that serves as the internal-only interface for the CLI tool's core logic, separating it from other package components.
_packages/jaspr\cli/lib · high confidence
Introduce Jaspr CLI entry point with consistent async exit handling
The \packages/jaspr\_cli/bin/jaspr.dart\ entry point is now established to initialize the \JasprCommandRunner\ and manage process termination. A key behavioral change is the implementation of \flushThenExit\, which ensures stdout and stderr streams are flushed before the process exits by using the \.wait\ extension on the close futures, replacing any previous inconsistent exit patterns.
_packages/jaspr\cli/bin · high confidence
Introduce server-side render adapters for client/server boundaries and document structure
The server rendering pipeline now uses a set of new adapters in the \server/adapters\ directory to manage how server and client components are rendered and how the final HTML document is structured. \ClientComponentAdapter\ and \ServerComponentAdapter\ wrap component outputs with specific HTML comments (markers) to delineate boundaries, enabling the client to correctly hydrate or identify server-rendered content. \ClientScriptAdapter\ and \GlobalStylesAdapter\ automatically inject the necessary client-side JavaScript and CSS styles into the document \\<head\>\, handling base tag logic for path resolution. \HeadScopeAdapter\ provides a base mechanism for modifying the head section, while \DocumentStructureHelper\ ensures the output is wrapped in a valid \\<html\>\, \\<head\>\, and \\<body\>\ structure, including handling of the doctype and preserving head contents when moving elements to the body.
packages/jaspr/lib/src/server/adapters · high confidence
Introduces new component framework with InheritedModel support
The framework in \packages/jaspr/lib/src/framework\ has been restructured to use a new component hierarchy. This change introduces \InheritedModel\<T\>\, allowing descendant components to depend on specific 'aspects' of an inherited model, enabling more granular rebuilds than the previous \InheritedComponent\. The framework now includes dedicated classes for managing build contexts, dirty element scheduling, and lifecycle states, along with new component types like \DomComponent\ and \Text\ that map directly to DOM elements and text nodes.
packages/jaspr/lib/src/framework · high confidence
Introduction of ProviderScope component for Riverpod integration
The \jaspr\_riverpod\ package now includes a \ProviderScope\ component, which serves as the root container for managing Riverpod provider state within Jaspr applications. This component initializes the \ProviderContainer\, supports provider overrides for testing and dependency injection, and enables nested scopes to isolate provider behavior. It replaces previous implementations, ensuring compatibility with the latest Riverpod version and fixing prior compilation errors.
_packages/jaspr\riverpod/lib/src/core · high confidence
Jaspr Pad styling moved to local SCSS assets
The Jaspr Pad application now uses locally managed SCSS files for its visual presentation, replacing previously external or embedded styles. This change introduces a comprehensive set of design tokens in \colors.scss\ defining distinct light and dark themes for the playground, code editor, and workshop views, alongside layout utilities in \layout.scss\ and \layout\_mixins.scss\ based on Polymer's iron-flex-layout. Shared component styles for flash messages, issue annotations, and busy indicators are consolidated in \shared.scss\, while \material\_shared.scss\ ensures compatibility with Material Components Web.
_apps/jaspr\pad/lib/scss · high confidence
Jaspr Riverpod integration updated to Riverpod 3
The Jaspr Riverpod package has been upgraded to support Riverpod 3, introducing new internal structures and generated provider builders. This change updates the underlying state management layer, meaning existing code using Riverpod providers within Jaspr components may need adjustments to align with Riverpod 3's API changes and internal refactoring.
_packages/jaspr\riverpod/lib/src · high confidence
JasprPad playground UI restructured into dedicated header, footer, and main sections
The JasprPad playground interface has been reorganized into distinct, reusable components: a header containing action buttons (New Pad, Reset, Format, Download, Tutorial) and a samples menu, a footer with links to documentation and community resources, and a main section that conditionally renders the editor, output, and tutorial panels. This change improves the modularity and maintainability of the playground's user interface without altering its core functionality.
_apps/jaspr\pad/lib/components/playground · high confidence
JasprPad provider layer migrated to Riverpod 3 and server-side initialization
The provider layer in \apps/jaspr\_pad/lib/providers\ has been updated to support Riverpod 3, introducing separate client and server entry points (\main.client.dart\, \main.server.dart\) and generated initialization files (\main.server.init.dart\) for mapper setup. The providers themselves now use the Riverpod 3 API (e.g., \NotifierProvider\, \StateProvider\, \FutureProvider.family\) and integrate with the \dart\_mappable\ library for JSON serialization/deserialization of API requests and responses. This change ensures the JasprPad application correctly initializes its dependency injection scope and handles server-side rendering of the playground component while maintaining client-side interactivity for code editing, compilation, and tutorial navigation.
_apps/jaspr\pad/lib/providers · high confidence
JasprPad web assets and UI styling overhaul
The JasprPad web interface has been updated with new document templates, custom SVG icons for UI actions (such as clear console, close, launch, and replace), and comprehensive SCSS stylesheets for the editor, syntax highlighting, and layout. This change introduces a new frame execution script to handle dynamic code execution and CSS injection, while also updating the visual theme and structure of the playground and workshop views.
_apps/jaspr\pad/web · high confidence
Migrate Riverpod example to Jaspr component API and Riverpod 3
The Riverpod example components have been updated to use the Jaspr framework's modern component API, replacing the previous generator-based approach with explicit StatelessComponent classes and direct DOM helpers (e.g., using \button()\ instead of \DomComponent\). The \App\ component now utilizes \ProviderScope\ with sync providers to ensure state consistency between server and client rendering, and the example has been aligned with Riverpod 3 patterns.
_examples/package\riverpod/lib/components · high confidence
New Flutter Web embedding example with updated assets and styling
The \examples/flutter\_embedding/web\ directory now includes a complete set of web assets for the embedding demo, including a new \manifest.json\ for PWA support, updated CSS styling with DM Sans fonts, and regenerated asset manifests (\AssetManifest.json\, \FontManifest.json\) that reflect the inclusion of \cupertino\_icons\ and \MaterialIcons\. A new SkSL shader (\ink\_sparkle.frag\) is added to support sparkle visual effects, and the \flutter\_bootstrap.js\ template is updated to ensure proper initialization.
_examples/flutter\embedding/web · high confidence
New code lenses for component scopes and project serving
The VS Code extension now provides inline code lenses to improve navigation and development workflow. For components, lenses indicate whether a component belongs to the server or client scope, allowing users to peek at the corresponding scope root locations directly from the editor. Additionally, a 'Serve' code lens appears in entry-point files (server or client targets), enabling users to start the development server with a single click.
_modules/jaspr-code/src/code\lenses · high confidence
New project templates with separate server and client entrypoints
The CLI now generates project scaffolds that use distinct entrypoints for server-side pre-rendering (\main.server.dart\) and client-side hydration (\main.client.dart\). This separation allows components annotated with \@client\ to be compiled to JavaScript for the browser while keeping server-only logic isolated, improving build clarity and enabling better control over what runs on each side. The templates also include updated analysis options, theme constants, and routing structures to support this dual-environment setup.
_packages/jaspr\cli/lib/src/bundles · high confidence
Restructure Jaspr library exports and introduce ViewTransition support
The Jaspr library has been restructured to provide distinct entry points for client-side (\client.dart\), server-side (\server.dart\), and DOM-specific (\dom.dart\) APIs, replacing the previous monolithic exports. This change introduces a new \ViewTransition\ API that enables CSS View Transitions on web platforms while providing a no-op fallback for server-side rendering, and adds new components including \Async\, \Badge\, and \Document\ alongside foundational framework updates.
packages/jaspr/lib · high confidence
Restructured package exports into modular entry points
The \jaspr\_riverpod\ package has been reorganized to provide distinct entry points for different feature sets. The main \jaspr\_riverpod.dart\ file now exports core providers, notifiers, and async utilities, while \legacy.dart\ exposes older patterns like \StateNotifier\ and \ChangeNotifierProvider\. New experimental modules have been added: \experimental/mutation.dart\ for mutation handling and \experimental/persist.dart\ for data persistence options. Additionally, \misc.dart\ groups family providers, transformers, and other utility types, allowing users to import only the specific functionality they need rather than the entire library.
_packages/jaspr\riverpod/lib · high confidence
Scaffold now supports Flutter embedding and inline CSS styling
The generated project scaffold has been updated to include a new \EmbeddedCounter\ component that integrates a Flutter widget (\CounterWidget\) into the web application using deferred loading via \FlutterEmbedView\. Additionally, the scaffold components (such as \Counter\ and \Header\) now utilize the \@css\ annotation for defining styles directly within Dart code, replacing previous styling approaches. The scaffold also includes a \Header\ component with routing-aware active state highlighting.
_packages/jaspr\cli/tool/scaffold/\\brick\\/lib/components · high confidence
Scaffold templates now support separate client and server entrypoints
The generated project templates have been restructured to use distinct entrypoints for server-side pre-rendering and client-side hydration. New files such as \base\#main.server.dart\ and \client\#main.client.dart\ (along with their \shelf\ equivalents) allow developers to run initialization logic specific to each environment, while the \app.dart\ component now supports \@client\ annotations and \@css\ style declarations for automatic style extraction. This change also introduces a \ShellRoute\ wrapper for routing layouts and separates global theme styles into \constants/theme.dart\.
_packages/jaspr\cli/tool/scaffold/\\brick\\/lib · high confidence
Separate client and server entrypoints for Dart Frog integration
The example application now uses distinct entrypoints for client-side and server-side execution. A new \main.client.dart\ initializes the client environment using generated \main.client.options.dart\, which defines lazy-loaded client components. On the server side, \utils.server.dart\ provides middleware to wrap the Jaspr app within a Dart Frog handler, utilizing \utils.server.options.dart\ to map server-side components to their client targets. This separation allows the Dart Frog backend to serve the application while keeping client and server initialization logic isolated.
_examples/backend\_dart\frog/lib · high confidence
Separate client and server entrypoints in example apps
The example applications (backend\_serverpod and package\_riverpod) now use distinct entrypoints for client and server execution. The client-side logic is isolated in \main.client.dart\ and \main.client.options.dart\, initializing the Jaspr client environment, while server-side logic is handled by \main.server.dart\ and \main.server.options.dart\, which configure server-specific options and routes. This separation ensures that client-only and server-only code is correctly bundled and executed in their respective environments.
_examples/backend\_serverpod/example\_server/lib, examples/package\riverpod/lib · high confidence
Separate client and server entrypoints with dedicated client module bundling
The client build process now uses distinct entrypoints and module bundlers to isolate client-side components. A new \ClientModuleBuilder\ generates metadata for components annotated with \@client\, including parameter serialization codecs, while a \ClientsBundleBuilder\ aggregates these modules into a single \clients.bundle.json\. Additionally, a \ClientEntrypointBuilder\ generates specific entrypoint files in the \web/\ directory, ensuring client code is built separately from server logic.
_packages/jaspr\builder/lib/src/client · high confidence
Separate client and server options generation
The build system now generates distinct options files for client and server entry points. A new \ClientOptionsBuilder\ creates a client-specific options file (\.client.options.dart\) that handles client-side component loading and Flutter web plugin initialization, while the \ServerOptionsBuilder\ creates a server-specific options file (\.server.options.dart\) that manages server-side component targets, client ID references, and CSS styles. This separation ensures that client and server initialization logic is correctly isolated during the build process.
_packages/jaspr\builder/lib/src/options · high confidence
Server-side rendering now supports request context and response manipulation
Developers can now access the current request URL, HTTP headers, and cookies directly from the build context via the new \AppContext\ extension, and can modify the outgoing HTTP response by setting custom headers, cookies (with full RFC 6265 options like \httpOnly\ and \secure\), and status codes. This change also introduces an \AsyncBuildOwner\ to handle asynchronous initial builds safely, ensuring that HTTP responses are not left pending if a build step throws an error, and refactors the server rendering pipeline to use a new \MarkupRenderObject\ hierarchy with improved HTML formatting and whitespace handling.
packages/jaspr/lib/src/server · high confidence
Split application into separate client and server entrypoints
The Flutter embedding example now uses distinct entrypoints for client-side and server-side execution. The previous single entrypoint has been replaced by \main.client.dart\ and \main.server.dart\, along with their corresponding generated options files (\main.client.options.dart\ and \main.server.options.dart\). This separation allows the client environment to initialize specifically for browser-based rendering using \Jaspr.initializeApp\ and \ClientApp\, while the server environment handles document structure, metadata, and static asset linking via \Document\ and \ServerOptions\.
_examples/flutter\embedding/lib · high confidence
Update embedding example to Riverpod 3
The embedding example's state management has been updated to use Riverpod 3. The main application state is now managed via a \NotifierProvider\ in \app\_state\_provider.dart\, replacing previous patterns, while the effects and rotation state providers in \effects\_provider.dart\ have been migrated to use the Riverpod 3 API (importing \riverpod/legacy.dart\ for compatibility or specific legacy features).
_examples/flutter\embedding/lib/providers · high confidence
Updated CLI scaffold with new logo and Flutter embedding support
The web scaffold template now includes a new SVG logo and supports embedding the application within Flutter. This is achieved by introducing separate client and server entrypoints, adding a \flutter\_bootstrap.js\ script and a \manifest.json\ for PWA capabilities when the Flutter flag is enabled, and updating the \index.html\ to conditionally load these Flutter-specific assets alongside the standard client script and generated CSS.
_packages/jaspr\cli/tool/scaffold/\\brick\\/web · high confidence
Updated Jaspr project templates with new structure and styling
The Jaspr Pad templates for 'jaspr\_basic' and 'jaspr\_export' projects have been updated. The basic template now includes a simple 'Hello World!' entry point and updated analysis options. The export template has been restructured to include a dedicated web entry point, custom CSS styling for centering content, and an HTML template that supports dynamic project titles and HTML injection via placeholders. These changes reflect a move away from the previous Stagehand-based scaffolding to a Jaspr-specific structure.
_apps/jaspr\pad/templates · high confidence
Updated scaffold templates with new page structure and CSS styling
The generated project scaffold now includes updated page components (home and about) that utilize the new @css annotation for defining inline styles, replacing previous styling approaches. The home page template has been refined to include a logo image and a counter component, while the about page provides structured documentation links. These changes reflect the adoption of the new CSS generation feature and updated component patterns in newly created Jaspr projects.
_packages/jaspr\cli/tool/scaffold/\\brick\\/lib/pages · high confidence
Website now uses separate client and server entrypoints
The website application has been refactored to support distinct client and server execution environments. This change introduces separate entrypoints (\main.client.dart\ and \main.server.dart\) along with generated configuration files (\main.client.options.dart\ and \main.server.options.dart\) that handle client-side lazy loading and server-side component targeting. Additionally, new layout files (\home\_layout.dart\ and \imprint\_layout.dart\) define the structure for the home and imprint pages, including specific CSS styles for dark/light mode handling and background effects.
apps/website/lib · high confidence
Fixes
Separate client and server entrypoints for Flutter plugin interop
The example application now uses distinct entrypoints for client and server environments. The client entrypoint initializes the app with specific web plugin registrars (Cloud Firestore, Firebase Auth, Firebase Core, and Shared Preferences) to handle browser-side interactions, while the server entrypoint renders the document structure for server-side rendering. This separation ensures that Flutter web plugins are correctly registered only in the client context, preventing initialization errors during server-side execution.
_examples/flutter\_plugin\interop/lib · high confidence
Test coverage
1 commit adding/updating tests in packages/jaspr/test/server/release\_mode; Added browser tests for dynamic \<head\> updates; Added browser tests for fragment DOM rendering behavior; Added browser tests for server-rendered hydration and reload scenarios; Added builder tests for CSS style sources; Added builder tests for client annotations, entrypoints, and sync mixins; Added client-side tests for basic component rendering and unmounting; Added client-side tests for component lifecycle, reloading, and DOM interactions; Added initial test suite for the extension; Added integration tests for Jaspr CLI commands; Added migration tests for build method, component factories, and entrypoints; Added server-side rendering tests for basic component hierarchy; Added test coverage for Jaspr CLI commands; Added test fakes for build daemon, I/O, and server components; Added test fixtures for platform-specific import generation; Added test utilities for Jaspr Riverpod; Added test utilities for component lifecycle tracking and render object mocking; Added tests for CLI helper utilities; Added tests for CSS annotation and standalone style generation; Added tests for Context provider interaction methods; Added tests for DOM validator and HTML component rendering; Added tests for InheritedComponent dependency notification logic; Added tests for InheritedModel aspect-based dependency tracking; Added tests for Jaspr CLI project configuration validation; Added tests for ObserverComponent lifecycle events; Added tests for RenderObjectElement lifecycle; Added tests for async component rendering; Added tests for basic component rendering and interaction; Added tests for client and server options builders; Added tests for client-side component builder and utility functions; Added tests for codec annotation builders; Added tests for codec source generation; Added tests for component element lifecycle and reordering; Added tests for jaspr\_lint rules; Added tests for provider synchronization on browser and server; Added tests for server-side data preloading; Added tests for server-side head merging behavior; Added tests for server-side rendering without the Jaspr testing library; Added tests for source file name validation and API security; Added tests for the @Import annotation builder; Added tests for the sync state builder.
Dependencies
Jaspr workspace restructured with dependency upgrades and new examples
The project has been reorganized into a Melos monorepo workspace, introducing new apps (dart\_quotes, fluttercon, website) and examples (backend\_dart\_frog, backend\_serverpod, backend\_shelf, flutter\_embedding, flutter\_multi\_view, flutter\_plugin\_interop, package\_riverpod) alongside updated core packages. Key dependency upgrades include jaspr to 0.23.x, jaspr\_builder to 0.23.x, jaspr\_cli to 0.23.x, jaspr\_content to 0.5.x, jaspr\_flutter\_embed to 0.4.x, jaspr\_lints to 0.7.x, jaspr\_riverpod to 0.4.x, jaspr\_router to 0.9.x, and jaspr\_serverpod to 0.6.x. The VS Code extension (jaspr-code) has been added with dependencies on chalk, vscode-uri, and yaml, and dev dependencies on TypeScript and ESLint. Serverpod integration has been updated to version 2.3.0, and Riverpod to 3.x. The old example/pubspec.yaml and pubspec.lock have been removed as part of the restructuring.
(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 33 → 35 (+2.0)
- Rubric changed (rubric-2026.10.5 → rubric-2026.11.3) — scores are not directly comparable.
Lenses
- Code Health 74 → 74 (+0.1)
- Architecture 62 → 61 (-0.1)
- Maturity 51 → 65 (+14.5)
- Readiness 44 → 47 (+2.7)
- Security 14 → 14 (-0.0)
- Domain Modelling 100 → 100 (+0.0)
- Accessibility 45 → 49 (+4.1)
- Performance 61 → 60 (-0.9)
Resolved (17)
- Change coupling: client_tester.dart ↔ component_tester.dart (packages/jaspr_test/lib/src/testers/client_tester.dart)
- Documentation: no installation or build instructions (README.md)
- Duplicated block (10 lines × 2) (packages/jaspr_cli/lib/src/commands/build_command.dart)
- Duplicated block (15 lines × 2) (packages/jaspr_cli/lib/src/dev/dev_workflow.dart)
- Duplicated block (7 lines × 2) (packages/jaspr_builder/lib/src/options/client_options_builder.dart)
- High CVE: [GHSA redacted] (modules/jaspr-code/package-lock.json)
- High CVE: [GHSA redacted] (modules/jaspr-code/package-lock.json)
- High CVE: [GHSA redacted] (modules/jaspr-code/package-lock.json)
- High secret: WD-SECRET-0005 (examples/backend_serverpod/example_server/docker-compose.yaml)
- High secret: WD-SECRET-0005 (examples/mypod/mypod_server/docker-compose.yaml)
- Hotspot: packages/jaspr/lib/src/client/slotted_child_view.dart (packages/jaspr/lib/src/client/slotted_child_view.dart)
- Hotspot: packages/jaspr_builder/lib/src/codec/codecs.dart (packages/jaspr_builder/lib/src/codec/codecs.dart)
- Hotspot: packages/jaspr_cli/lib/src/dev/css_runner.dart (packages/jaspr_cli/lib/src/dev/css_runner.dart)
- Hotspot: packages/jaspr_lints/lib/src/assists/css_assist.dart (packages/jaspr_lints/lib/src/assists/css_assist.dart)
- No ADRs found
- Secret: generic-api-key (apps/jaspr_pad/samples/weather-api/api.dart)
- Secret: generic-api-key (packages/jaspr_pad/samples/weather-api/api.dart)
New (43)
- Documentation: no build, run or usage example (modules/jaspr-code/README.md)
- Duplicated block (18 lines × 2) (packages/jaspr_cli/lib/src/commands/build_command.dart)
- Edited copies of one member (3 members, 12+ corresponding lines) (packages/jaspr_cli/lib/src/dev/client_manager.dart)
- Edited copies of one member (3 members, 13+ corresponding lines) (packages/jaspr_lints/lib/src/rules/prefer_html_components_rule.dart)
- Edited copies of one member (3 members, 3+ corresponding lines) (apps/jaspr_pad/lib/components/dialogs/new_file_dialog.dart)
- Edited copies of one member (3 members, 8+ corresponding lines) (apps/jaspr_pad/lib/providers/logic_provider.dart)
- Edited copies of one member (4 members, 23+ corresponding lines) (apps/jaspr_pad/lib/components/dialogs/delete_file_dialog.dart)
- Edited copy of a member (10 corresponding lines) (packages/jaspr_lints/lib/src/rules/unsafe_imports_rule.dart)
- Edited copy of a member (12 corresponding lines) (apps/jaspr_pad/samples/counter/main.dart)
- Edited copy of a member (13 corresponding lines) (packages/jaspr/lib/src/dom/styles/properties/box.dart)
- Edited copy of a member (13 corresponding lines) (packages/jaspr/lib/src/server/markup_render_object.dart)
- Edited copy of a member (13 corresponding lines) (packages/jaspr_cli/lib/src/commands/dev_command.dart)
- Edited copy of a member (14 corresponding lines) (examples/backend_serverpod/example_server/lib/components/counter.dart)
- Edited copy of a member (14 corresponding lines) (packages/jaspr/lib/src/components/document/document_client.dart)
- Edited copy of a member (15 corresponding lines) (packages/jaspr_content/lib/src/theme/theme.dart)
- Edited copy of a member (16 corresponding lines) (apps/dart_quotes/lib/components/quote_like_button.dart)
- Edited copy of a member (18 corresponding lines) (apps/website/lib/layouts/home_layout.dart)
- Edited copy of a member (18 corresponding lines) (packages/jaspr_cli/lib/src/project.dart)
- Edited copy of a member (18 corresponding lines) (packages/jaspr_lints/lib/src/rules/unsafe_imports_rule.dart)
- Edited copy of a member (26 corresponding lines) (examples/flutter_multi_view/lib/components/counter.dart)
- …and 23 more
Changes since last survey
- 19 commits — 13 feature/other, 6 fixes
By area
- packages/jaspr_cli — 8 commits
- packages/jaspr — 4 commits
- packages/jaspr_router — 4 commits
- packages/jaspr_builder — 2 commits
- packages/jaspr_repo — 1 commit
Notable commits
- fix: Fix/router param names (#957)
- fix: Fix/router redirect query (#956)
- fix: fix pipeline for latest flutter stable version (#984)
- fix: fix(cli): disable echoMode before lineMode so key shortcuts work on Windows (#960)
- fix: fix(cli): keep changed modules for hot reload when builds overlap (#962)
- fix: fix(cli): skip unresponsive clients instead of blocking all following reloads (#980)
- change: Add --enable-experiment to jaspr build and jaspr serve (#895)
- change: Add ServerApp.reassemble() for servers that reload code themselves (#964)
- change: Detect the pub cache on Windows in the CSS runner (#976)
- change: Don't run redirects when preloading a route (#978)
- change: Extend CSS hot reload test timeout (#991)
- change: Increase test timeout for jaspr_builder (#985)
- change: Keep serving when a browser disconnects during reload (#955)
- change: Leave modified and non-primary clicks on Link to the browser (#969)
- change: Remove fragments whose first or last child renders nothing (#968)
- change: Restore --proxy-port on jaspr serve and jaspr daemon (#966)
- change: Treat dart.vm.product builds as release mode (#963)
- change: cleanup analyzer configs (#954)
- change: update skills and add jaspr content skill and best practice rules (#948)
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
Survey your own repository
schultek/jaspr 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 13 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 10471100aa75d31c1bbbd3e85b5e4f6bc79508bb — the exact code this score is about.
- Scored under rubric-2026.11.3 — 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.57+preprod-8ebfb01cf4c0.