schultek/jaspr

Jaspr is a Dart web framework that enables server-side rendering with client-side hydration, supporting static, server-rendered, and single-page application modes. It provides a component-based architecture with built-in routing, state management integration via Riverpod, and the ability to embed Flutter widgets within web pages. The system includes a comprehensive CLI for project scaffolding and development, alongside tooling for syntax highlighting, code analysis, and automated deployment to cloud platforms.

44 changes.

The project underwent a major architectural rewrite, replacing the legacy web framework with a new component model, build system, and router while upgrading core dependencies to Riverpod 3. This period also saw the extensive development of JasprPad, an interactive playground application featuring real-time code analysis, syntax highlighting, and comprehensive tutorials to demonstrate the new framework capabilities.

74 changes.

This period focused on establishing a robust server-side rendering and client hydration architecture, introducing dedicated entrypoints, document adapters, and state synchronization via HTML comments. It also delivered a comprehensive CLI overhaul with daemon support, project scaffolding, and automated build tooling, alongside new packages for routing and Flutter embedding.

47 changes.

The project launched a new official website built with Jaspr, featuring a comprehensive design system, interactive UI components, and LLM documentation support. Simultaneously, the framework underwent a major architectural shift to support distinct client and server entrypoints, enabling hybrid rendering and improved hydration of server-side HTML.

6 changes.

This period focused on expanding test coverage for the Jaspr CLI, including command behaviors, lint rules, and security validations, while introducing mock infrastructure for unit testing. Concurrently, dedicated header and footer layout components were added to the project website to improve navigation and responsiveness.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

A new \deploy.dart\ tool has been added to the \apps/dart\_quotes/tool\ directory to streamline the release process. This script automates building the Docker image for the \linux/amd64\ platform, tagging it for Google Container Registry, and deploying the service to Google Cloud Run in the \europe-west1\ region with unauthenticated access enabled.

_apps/dart\_quotes/tool, apps/jaspr\pad/tool · high confidence

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

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

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

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

This change introduces the foundational components for the Jaspr router within the \misc\ directory. It adds an \ErrorScreen\ component to display page-not-found states, a \RouterError\ class for handling routing exceptions, and \InheritedRouter\/\InheritedRouteState\ widgets to expose the current router and route state throughout the widget tree. Additionally, it provides the \GoRouterHelper\ extension on \BuildContext\, enabling convenient navigation methods like \push\, \pushNamed\, \replace\, \replaceNamed\, \back\, and \namedLocation\ for users.

_packages/jaspr\router/lib/src/misc · high confidence

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

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

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

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

The \jaspr\_content\ package is introduced to support building content-driven sites like documentation, blogs, or marketing pages within Jaspr. This initial release provides out-of-the-box tools for loading, parsing, and rendering content from sources such as Markdown files, along with support for frontmatter data and templating. It includes a suite of built-in components for enhancing content, such as \Callout\ (info, warning, error, success), \CodeBlock\ with syntax highlighting and copy functionality, \FileTree\ for directory structures, \GitHubButton\, \Tabs\, and \ZoomableImage\. The package also features pre-defined layouts like \DocsLayout\, a theming system with light and dark mode support, and utilities like \FileIcon\ for visual file representation.

_packages/jaspr\_content, packages/jaspr\test · high confidence

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

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

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

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

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

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

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

The client runtime now supports hydrating server-rendered HTML by locating specific DOM nodes via comment-based anchors. New files in the client package establish a separate entry point (\runApp\), a \ClientAppBinding\ to manage the browser environment (including base path and URL resolution), and a \ClientApp\ component that extracts these anchors from the DOM. The system parses special comment markers to identify where \@client\ components should be mounted, allowing them to attach to existing DOM subtrees rather than replacing them entirely. This enables a hybrid rendering model where static HTML is reused and interactive client components are attached to designated slots within that structure.

packages/jaspr/lib/src/client · high confidence

The \jaspr\_router\ package now provides a full client-side routing system. Users can define hierarchical routes using \Route\ and \ShellRoute\, including \LazyRoute\ and \LazyShellRoute\ which defer JavaScript bundle loading until the route is visited, improving initial page load performance. The router supports named navigation, query parameters, and automatic title management. A new \Link\ component allows for client-side navigation without page reloads, featuring automatic preloading on hover for lazy routes. The router also handles redirects, error states, and integrates with the browser's history API.

_packages/jaspr\router/lib/src · high confidence

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

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

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

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

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

A new \jaspr\_router\ package has been added to the project, providing core routing capabilities for Jaspr applications. The package exports the main router implementation, route definitions, state management, and a \Link\ component for navigation, along with supporting extensions and type definitions.

_packages/jaspr\router/lib · high confidence

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

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

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

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

The CLI now includes dedicated helper modules in the \helpers\ directory to manage configuration and build processes. \settings\_helper.dart\ introduces a new settings directory structure using \dart\_data\_home\, including a migration path from the legacy \.jaspr\ folder, and provides the foundation for the new \analytics.dart\ module which tracks CLI usage via Mixpanel (opt-in). \dart\_define\_helpers.dart\ adds support for \--dart-define\, \--dart-define-client\, \--dart-define-server\, and \--dart-define-from-file\ arguments, allowing environment variables to be passed to the application. \css\_helper.dart\ enables standalone CSS generation from \@css\ declarations. \flutter\_helpers.dart\ and \proxy\_helper.dart\ provide utilities for running and building Flutter web apps and handling proxy requests, including specific fixes for Safari debugging and base path handling.

_packages/jaspr\cli/lib/src/helpers · high confidence

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

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

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

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

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

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.

_examples/flutter\embedding/lib/components · high confidence

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

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

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

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

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

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

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

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

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

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

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

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

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

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

The router now supports server-side rendering and static site generation. On the server, navigation redirects are handled via HTTP 302 responses, and route registration triggers static page generation requests (including metadata like change frequency and priority) through the server app. Browser-side routing remains unchanged, utilizing the standard HTML5 History API for push, replace, and back operations, while server-side history manipulation is explicitly unsupported.

_packages/jaspr\router/lib/src/platform · high confidence

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

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

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

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 · high confidence

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

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

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

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

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

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

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

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

The example projects (backend\_serverpod, flutter\_embedding, and package\_riverpod) have been refactored to support distinct execution environments. Each example now includes separate \main.client.dart\ and \main.server.dart\ files, along with corresponding generated options files (\main.client.options.dart\ and \main.server.options.dart\). This change ensures that client-side initialization (using \Jaspr/client.dart\ and \ClientApp\) is isolated from server-side setup (using \Jaspr/server.dart\, \Serverpod\, or \Document\ rendering), allowing for proper client-server separation in the demo applications.

_examples/backend\_serverpod/example\_server/lib, examples/flutter\_embedding/lib, examples/package\riverpod/lib · high confidence

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

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

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

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

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

The server rendering pipeline now uses a new set of adapter classes to manage HTML output and client-side integration. A DocumentAdapter ensures the final HTML includes a proper structure (DOCTYPE, html, head, body) and injects a base tag if needed. HeadScopeAdapter and its subclasses (GlobalStylesAdapter, ClientScriptAdapter) handle injecting CSS styles and client JavaScript scripts into the document head, automatically adjusting paths based on the presence of a base tag. Additionally, ClientComponentAdapter and its registry introduce markers in the HTML to identify components that require client-side hydration, enabling the framework to sync server-rendered content with the client application.

packages/jaspr/lib/src/server/adapters · high confidence

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

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

The \jaspr\_riverpod\ package has been updated to support the latest Riverpod version (v3). This change introduces a new \ProviderScope\ component that manages the provider container and integrates with Jaspr's state lifecycle, including new \sync\ capabilities for persisting and restoring provider state across navigation or hydration. The core API now exposes \watch\ and \listen\ extensions on \BuildContext\ for declarative and imperative provider access, alongside a \ProviderDependencies\ class to manage subscription lifecycles during component rebuilds and deactivation. Additionally, strict lint rules and wildcard variable usage have been applied to improve code quality and analysis.

_packages/jaspr\riverpod/lib/src/core · high confidence

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

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

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

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

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

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

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

The Jaspr CLI now includes a new internal development workflow located in \packages/jaspr\_cli/lib/src/dev\. This change introduces a \DevProxy\ that integrates with \dwds\ to provide hot-restart capabilities and debugging support for web applications, replacing the previous external dependency on \webdev\. The new codebase includes a \Chrome\ manager to handle browser instances with isolated user data, a \ClientDomain\ to manage app connections and service extensions, and a \ClientWorkflow\ to orchestrate the build daemon and development proxy. This enables the CLI to launch Chrome, connect to the Dart Development Service (DDS), and handle build results and hot restarts internally.

_packages/jaspr\cli/lib/src/dev · high confidence

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Added browser-based routing tests for Jaspr Router; Added builder tests for CSS style sources; Added builder tests for client annotations, entrypoints, and sync mixins; Added client-side browser tests for Jaspr components; 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 server-side routing and redirect tests for Jaspr Router; Added test fakes for build daemon, I/O, and server components; Added test fixtures for platform-specific import generation; Added test utilities for component lifecycle tracking and render object mocking; Added test utilities for jaspr\_router; Added tests for CLI dart-define parsing and settings directory migration; 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 commands; Added tests for Jaspr CLI project configuration validation; Added tests for Jaspr lint rules; 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 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; Added unit tests for jaspr\_router routing behaviors.

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 watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 45 → 55 (+9.8)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 90 → 87 (-3.0)
• Architecture 91 → 61 (-30.3)
• Maturity 58 → 60 (+1.6)
• Readiness 55 → 56 (+1.5)
• Security 27 → 50 (+23.6)
• Domain Modelling 100 → 100 (+0.0)
• Accessibility 54 → 54 (+0.0)

• Coverage not included — suite not readable by the collector
• Critical IaC: AWS-0104 (apps/dart_quotes_server/deploy/aws/terraform/instances.tf)
• Dependency hygiene not measured — dependency manifest found but not parsed for hygiene
• Further sole-owners (lower concentration)
• 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 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 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 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 CVE: [GHSA redacted] (modules/jaspr-code/package-lock.json)
• High IaC: AWS-0080 (apps/dart_quotes_server/deploy/aws/terraform/database.tf)
• High IaC: AWS-0086 (apps/dart_quotes_server/deploy/aws/terraform/storage.tf)
• High IaC: AWS-0087 (apps/dart_quotes_server/deploy/aws/terraform/storage.tf)
• …and 36 more

• AttachAdapter.apply (cognitive 35) (packages/jaspr/lib/src/components/document/document_server.dart)
• AttachAdapter.apply (cyclomatic 21) (packages/jaspr/lib/src/components/document/document_server.dart)
• AttachAdapter.update (cognitive 48) (packages/jaspr/lib/src/components/document/document_client.dart)
• AttachAdapter.update (cyclomatic 24) (packages/jaspr/lib/src/components/document/document_client.dart)
• BuildCommand._buildWeb (cognitive 32) (packages/jaspr_cli/lib/src/commands/build_command.dart)
• BuildCommand._buildWeb (cyclomatic 24) (packages/jaspr_cli/lib/src/commands/build_command.dart)
• BuildCommand.runCommand (cognitive 124) (packages/jaspr_cli/lib/src/commands/build_command.dart)
• BuildCommand.runCommand (cyclomatic 56) (packages/jaspr_cli/lib/src/commands/build_command.dart)
• BuildMethodMigration._migrateFunctionBody (cognitive 87) (packages/jaspr_cli/lib/src/migrations/build_method_migration.dart)
• BuildMethodMigration._migrateFunctionBody (cyclomatic 39) (packages/jaspr_cli/lib/src/migrations/build_method_migration.dart)
• BuildMethodMigration.runForUnit (cognitive 18) (packages/jaspr_cli/lib/src/migrations/build_method_migration.dart)
• BuildOwner.performBuild (cognitive 23) (packages/jaspr/lib/src/framework/build_owner.dart)
• ButtonState.build (cognitive 21) (apps/jaspr_pad/lib/components/elements/button.dart)
• ButtonState.build (cyclomatic 21) (apps/jaspr_pad/lib/components/elements/button.dart)
• Change coupling: analyzing_builder.dart ↔ styles_module_builder.dart (packages/jaspr_builder/lib/src/imports/analyzing_builder.dart)
• Change coupling: base_command.dart ↔ serve_command.dart (packages/jaspr_cli/lib/src/commands/base_command.dart)
• Change coupling: build_command.dart ↔ dev_command.dart (packages/jaspr_cli/lib/src/commands/build_command.dart)
• Change coupling: client_tester.dart ↔ component_tester.dart (packages/jaspr_test/lib/src/testers/client_tester.dart)
• Change coupling: dom_render_object.dart ↔ components_binding.dart (packages/jaspr/lib/src/client/dom_render_object.dart)
• Change coupling: dom_render_object.dart ↔ html.dart (packages/jaspr/lib/src/client/dom_render_object.dart)
• …and 289 more

• 4 commits — 4 feature/other, 0 fixes

• packages/jaspr — 4 commits

• change: Bump package versions
• change: Fail the render instead of hanging when an initial build step throws (#868)
• change: Work around a VM fault when hashing closures in TaskChain (#867)
• change: update changelog

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

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.