dart-frog-dev/dart_frog

Dart Frog is a modern, high-performance web framework for Dart that simplifies building scalable HTTP and WebSocket servers. It provides a comprehensive tooling ecosystem, including a CLI for project scaffolding and a VS Code extension for integrated development, alongside robust code generation and validation to prevent configuration errors. The framework supports advanced features like middleware, authentication, and static file serving, all managed through a consistent, testable architecture.

51 changes.

This period focused on maturing the Dart Frog framework by introducing a comprehensive CLI for project scaffolding, development, and production builds. The work expanded the public API to support form data, WebSockets, and route configuration validation, while adding extensive test coverage and example applications to demonstrate new capabilities.

37 changes.

This period focused on expanding the Dart Frog ecosystem with a new CLI 'new' command, a background daemon for managing development servers, and a VS Code extension for integrated development. The work also introduced authentication middleware, linting rules, and comprehensive test coverage for these new features.

A new entry point for the Dart Frog CLI has been added at packages/dart\_frog\_cli/bin/dart\_frog.dart. This file serves as the executable interface for the command-line tool, initializing the command runner and managing standard output and error streams.

_packages/dart\_frog\cli/bin · high confidence

The Dart Frog CLI now includes a new brick that generates scaffold templates for routes and middleware. The route template provides a basic handler structure with optional path parameters, while the middleware template offers a placeholder for implementing request/response processing. These templates are intended to be used with the dart\_frog\_new command to quickly set up new route or middleware files.

_bricks/dart\_frog\new/\\brick\\_ · high confidence_

A new example file (main.dart) has been added to the dart\_frog\_gen package, demonstrating how to use the buildRouteConfiguration function to generate route configurations from the current directory.

_packages/dart\_frog\gen/example · high confidence

A new example demonstrating a basic Dart Frog route has been added. The example includes a route handler that returns a simple 'Welcome to Dart Frog!' response, providing a starting point for understanding route configuration in the framework.

_examples/hello\world/routes · high confidence

A new Dockerfile has been added to the Dart Frog production server brick, enabling containerized builds. The file defines a multi-stage build process that copies external dependencies and path dependencies, resolves packages, compiles the server to an executable, and finally copies the compiled binary and runtime files into a minimal scratch image for deployment.

_bricks/dart\_frog\_prod\server/\\brick\\/build/{{\#addDockerfile}}Dockerfile{{ · high confidence

The VS Code extension now provides 'Run' and 'Debug' CodeLens options on route handler functions in Dart Frog projects. Users can now start or debug the development server directly from the editor by clicking the new CodeLens links, which are automatically detected on files within the 'routes' directory.

extensions/vscode/src/code-lens · high confidence

Users can now run \dart\_frog build\ to create a production build of their application. The command supports a \--dart-version\ flag to specify the Dart SDK version for the generated Dockerfile, defaulting to 'stable'.

_packages/dart\_frog\cli/lib/src/commands/build · high confidence

The CLI now includes a \create\ command that scaffolds a new Dart Frog application. Users can generate a new project by running \dart\_frog create\ in their desired output directory, optionally specifying a project name via the \--project-name\ flag. The command validates that the project name is a valid Dart package name and uses a bundled template to generate the initial project structure.

_packages/dart\_frog\cli/lib/src/commands/create · high confidence

Users can now run \dart\_frog daemon\ to start the Dart Frog daemon process. This new command provides a dedicated entry point for managing the background daemon, exposing the \DaemonCommand\ class which handles the daemon's lifecycle and exit code.

_packages/dart\_frog\cli/lib/src/commands/daemon · high confidence

The \dart\_frog new\ command has been added to the CLI, allowing users to generate new routes and middleware. This new command accepts a route path and validates the input, ensuring that route segments are valid Dart identifiers and do not contain empty segments. It also verifies that the project contains a 'routes' directory before proceeding with generation.

_packages/dart\_frog\cli/lib/src/commands/new · high confidence

Added a new example demonstrating bearer authentication with Dart Frog. The example includes a session repository for managing user sessions, a user repository for handling user data, and a hash extension for password hashing. It also includes configuration files (.gitignore, analysis\_options.yaml, pubspec\_overrides.yaml) to support the example's dependencies and linting.

_examples/bearer\authentication · high confidence

A new counter example is introduced in the examples/counter/routes directory. The example demonstrates a middleware that maintains a global request count and provides it via the context, which is then read in the index route to display how many times the route has been accessed.

examples/counter/routes · high confidence

The Dart Frog create brick now includes a new \index.dart\ template file in the routes directory. This file defines the default welcome response for the application's root path, returning a simple 'Welcome to Dart Frog!' message. This change updates the generated project structure to include a functional default route.

_bricks/create\_dart\frog/\\brick\\/routes · high confidence

A new example route was added to the echo application, demonstrating how to return a request parameter as the response body using Dart Frog.

examples/echo/routes · high confidence

The todos example now includes an in-memory implementation of the TodosDataSource interface, allowing users to interact with a local, non-persistent store for testing and demonstration purposes. This new package provides a simple cache of todos in memory, supporting create, read, update, and delete operations without external dependencies.

_examples/todos/packages/in\_memory\_todos\_data\source/lib · high confidence

The kitchen sink example now includes a full set of route handlers and middleware files, demonstrating request handling patterns such as form data processing, header validation, and method restrictions. This provides a comprehensive reference for building and testing Dart Frog applications with various route configurations.

_examples/kitchen\sink/routes · high confidence

The VS Code extension now displays status bar items for Dart Frog projects, allowing users to start and stop the development server directly from the editor. Additionally, a status bar item shows the application's host and port, enabling users to open the running application in a browser with a single click.

extensions/vscode/src/status-bar · high confidence

A new todos example is added to the repository, demonstrating a Dart Frog application with an in-memory data source. The example includes a middleware that registers the data source and a logger, alongside route handlers for creating, reading, updating, and deleting todos via JSON responses.

examples/todos/routes · high confidence

Users can now run \dart\_frog uninstall\ to receive instructions and a link to the official documentation for uninstalling the Dart Frog CLI tool.

_packages/dart\_frog\cli/lib/src/commands/uninstall · high confidence

The basic authentication example now includes full CRUD routes for managing users. A new middleware enforces basic authentication on all user-related endpoints, verifying credentials against a UserRepository. The /users route handles POST requests to create new users, while the /users/\[id\] route supports GET, PATCH, and DELETE operations to retrieve, update, or delete specific users, with access control ensuring users can only modify their own records.

_examples/basic\authentication/routes · high confidence

The web\_socket\_counter example was added, demonstrating a counter application built with Dart Frog using WebSockets. The implementation includes a CounterCubit for state management, a counterProvider middleware, and a WebSocket route that handles increment and decrement messages. The example also includes a .gitignore file, a README with badges, an analysis\_options.yaml file that includes dart\_frog\_lint, and a pubspec\_overrides.yaml for local package paths.

_examples/web\_socket\counter · high confidence

A new example application has been added to the Dart Frog package, providing a minimal 'Hello World' style server entry point that returns a welcome message, serving as a starting point for new users.

_packages/dart\frog/example · high confidence

Introduced a new example demonstrating how to implement basic authentication with Dart Frog. The example includes a user repository that manages an in-memory database of users, handling creation, deletion, and credential verification using SHA-256 hashing. The project is configured with a \.gitignore\ file, a \README.md\ with lint badges, and \analysis\_options.yaml\ that includes the \dart\_frog\_lint\ package for consistent code analysis.

_examples/basic\_authentication, examples/bearer\authentication/routes · high confidence

The \bricks/create\_dart\_frog/hooks\ directory now includes a \post\_gen.dart\ script that automatically runs \dart pub get\ in the newly created project directory and prints helpful next-step instructions to the user. This hook is accompanied by a \.gitignore\ file to exclude build artifacts, an \analysis\_options.yaml\ to standardize code analysis, and a \post\_gen\_test.dart\ file containing unit tests for the hook's behavior.

_bricks/create\_dart\frog/hooks · high confidence

The todos example now includes a new \todos\_data\_source\ package that provides the core data model and interface for managing todo items. The package exports a \Todo\ class containing title, description, ID, and completion status, along with serialization support. It also defines a \TodosDataSource\ abstract class that specifies Create, Read, Update, and Delete operations for todo items.

_examples/todos/packages/todos\_data\source/lib · high confidence

The extension now includes new utility modules for managing Dart Frog CLI versions and resolving project paths. Users will see prompts to install the Dart Frog CLI if it is missing, and the extension can now verify that the installed CLI version is compatible with the extension. Additionally, new functions allow the extension to locate the root of a Dart Frog project from any file path, normalize route paths, and generate unique identifiers for the Dart Frog daemon.

extensions/vscode/src/utils · high confidence

Added shell scripts to the tool directory to automate the release process and bundle generation. The new \release\_ready.sh\ script updates version numbers in \pubspec.yaml\, \brick.yaml\, or \package.json\, regenerates the \CHANGELOG.md\ from git commits, and prepares a release branch. The \generate\_bundles.sh\ script uses \mason\_cli\ to compile Dart Frog bricks into templates for the CLI, ensuring the CLI packages contain the latest brick templates.

tool · high confidence

The VS Code extension now includes formal type definitions and type guards for the 'daemon' and 'dev-server' domains, enabling the extension to send and receive structured messages such as version requests, kill commands, application start/stop/reload requests, and related events (e.g., application starting, exit, logger, and progress events).

extensions/vscode/src/daemon/protocol · high confidence

The dev server template now allows users to provide a custom entrypoint and custom initialization logic. The generated server code conditionally imports and invokes a user-defined 'main.dart' entrypoint and an optional custom init method, enabling advanced startup configurations and dependency injection patterns that were previously unavailable.

_bricks/dart\_frog\_dev\server/\\brick\\_ · high confidence_

The Dart Frog VS Code extension is now available, providing an integrated development experience for Dart Frog projects. Upon activation, the extension checks for the Dart Frog CLI, suggesting installation if missing and warning about version compatibility. It registers a suite of commands for creating new routes and middleware, managing the development server (start, stop, debug), and updating the CLI. Additionally, it adds status bar items for server control and application status, and provides CodeLens for running or debugging route handlers directly from the editor.

extensions/vscode, extensions/vscode/src · high confidence

The VS Code extension now includes a new daemon subsystem that manages Dart Frog applications. This adds a singleton DartFrogDaemon class to spawn and communicate with the Dart Frog daemon process, a DartFrogApplication class to track application metadata (project path, ports, host), and a DartFrogApplicationRegistry to track running applications and their events. This enables the extension to start, monitor, and interact with Dart Frog projects via the daemon protocol.

extensions/vscode/src/daemon · high confidence

The CLI now introduces a dedicated DevServerRunner class to manage the local development server process lifecycle, including code generation, file watching, hot reload, and graceful shutdown. A new ProdServerBuilder class handles building the production server runtime code, ensuring Dart version compatibility and generating the necessary files. Additionally, a RestorableDirectoryGeneratorTarget is added to support file snapshotting and rollback capabilities during code generation.

_packages/dart\_frog\_cli/lib/src/dev\_server\runner · high confidence

Added a new \RouteConfigurationWatcher\ class that monitors a Dart Frog project for changes to its route configuration. This component watches for updates to \main.dart\, \pubspec.yaml\, the \public\ directory, and the \routes\ directory, triggering a regeneration of the route configuration when those files change. This enables the CLI to react to route-related file modifications during development.

_packages/dart\_frog\_cli/lib/src/route\_configuration\watcher · high confidence

Users can now run a local development server using the new \dart\_frog dev\ command. This command starts the dev server and supports customizing the server port (\--port\), the Dart VM service port (\--dart-vm-service-port\), and the hostname (\--hostname\). It also enables hot reload by listening for the 'R' or 'r' key press in the terminal.

_packages/dart\_frog\cli/lib/src/commands/dev · high confidence

The CLI now uses a shared \DartFrogCommand\ base class that standardizes access to the logger, argument results, and working directory, while the \DartFrogCommandRunner\ registers all available commands (build, create, dev, list, new, daemon, uninstall, update, and completion). Additionally, a new \runtime\_compatibility.dart\ module enforces that the installed \dart\_frog\ package version falls within the supported range (\>=1.0.0 \<2.0.0), throwing a clear error if the project's \pubspec.yaml\ is incompatible.

_packages/dart\_frog\cli/lib/src · high confidence

The \dart\_frog\_auth\ package is introduced, providing middleware for HTTP authentication in Dart Frog applications. It supports three authentication strategies: Basic (header), Bearer (header), and Cookie-based authentication. Each strategy allows developers to supply a function that validates credentials or tokens and returns a user object, with the option to apply the middleware to specific routes via a predicate function. The package includes a new \Applies\ typedef for route filtering and extends the \RequestContext\ headers with helper methods to parse Authorization and Cookie headers.

_packages/dart\_frog\auth · high confidence

A new \dart\_frog\_lint\ package has been added to the repository, providing a curated collection of lint rules specifically for Dart Frog applications. Users can now include the package in their projects and enable the recommended set of linter rules via \analysis\_options.yaml\ to enforce consistent code style and catch potential issues early.

_packages/dart\_frog\lint · high confidence

The \dart\_frog\_test\ package is added to provide utilities for testing Dart Frog applications. It includes a \TestRequestContext\ class to mock request contexts and dependency injection, along with a suite of custom matchers for assertions. These matchers allow users to easily verify HTTP status codes (e.g., \isOk\, \isNotFound\), check response bodies (\expectJsonBody\, \expectBody\), and validate HTTP method restrictions (\expectNotAllowedMethods\). An example application is also included to demonstrate how to use these testing tools.

_packages/dart\_frog\test · high confidence

A new \dart\_frog\_web\_socket\ package has been added to the Dart Frog ecosystem, providing a \webSocketHandler\ to manage WebSocket connections within Dart Frog routes. This handler upgrades HTTP requests to WebSocket connections, supporting subprotocol negotiation and configurable origin restrictions. The package includes full test coverage for connection handling, protocol negotiation, and error states, alongside standard project files (README, CHANGELOG, LICENSE, and analysis options).

_packages/dart\_frog\_web\socket · high confidence

The framework now supports parsing form data (both \application/x-www-form-urlencoded\ and \multipart/form-data\) via the new \FormData\ and \UploadedFile\ classes, accessible through \Request.formData()\ and \Response.formData()\. Additionally, the \RequestContext\ now exposes \mountedParams\ to access URL parameters captured by \Router.mount\, and the \Request\ class exposes \connectionInfo\ for HTTP connection details.

_packages/dart\frog/lib/src · high confidence

The dart\_frog\_gen package now exposes a new public API for validating route configurations. Users can access the \validateRouteConfiguration\ function to check route setups, ensuring that generated code adheres to expected structural rules before compilation.

_packages/dart\_frog\gen/lib · high confidence

The Dart Frog CLI now includes a daemon subsystem that runs as a persistent background process to manage and analyze Dart Frog projects. This change introduces the core infrastructure for the daemon, including a JSON-RPC over stdio connection layer, a server implementation that routes requests to specific domains (such as DevServer and RouteConfiguration), and a logger that emits events instead of printing to the console. This enables long-running tasks to be managed more efficiently by the CLI.

_packages/dart\_frog\cli/lib/src/daemon · high confidence

The \dart\_frog create\ command now uses a new bundled template (\create\_dart\_frog\_bundle.dart\) that generates a fresh Dart Frog application. This template includes a \.gitignore\, VS Code extensions, \analysis\_options.yaml\ (using \dart\_frog\_lint\), a \pubspec.yaml\ with Dart 3.11 SDK constraints, and a \routes/index.dart\ file. Crucially, the generated project now includes a \test/routes/index\_test.dart\ file with a test for the default route, and a \post\_gen.dart\ hook that automatically runs \pub get\ and prints helpful startup instructions.

_packages/dart\_frog\cli/lib/src/commands/create/templates · high confidence

The VS Code extension now includes commands to create new projects, routes, and middleware, as well as to install, update, and manage the Dart Frog CLI. Users can also start, stop, and debug development servers directly from the command palette, with the extension handling project resolution, CLI installation checks, and progress feedback.

extensions/vscode/src/commands · high confidence

The \dart\_frog\_cli\ package now includes a new \dart\_frog\_dev\_server\ brick (Mason template) that generates the Dart Frog development server. This brick provides the scaffolding for the dev server, including a \pre\_gen\ hook that validates route configurations, detects route conflicts, and reports rogue routes. The generated server supports custom ports, hosts, middleware, and static file serving. The brick also includes a test suite (\pre\_gen\_test.dart\ and \exit\_overrides\_test.dart\) to verify the hook's behavior.

_packages/dart\_frog\cli/lib/src/commands/dev/templates · high confidence

The dart\_frog package now exposes a broader public API, including Cascade, Pipeline, Request, RequestContext, Response, Router, and Handler types, along with utility functions like requestLogger, serve, createStaticFileHandler, and hotReload. It also provides fromShelfHandler, fromShelfMiddleware, and body parser types (FormData, UploadedFile) to support middleware, static file serving, and form-data handling.

_packages/dart\frog/lib · medium confidence

The Dart Frog CLI has been updated with new templates and hooks for generating routes and middleware. The \dart\_frog\_new\_bundles.dart\ file introduces a new \dartFrogNewBundle\ containing the template files for routes and middleware, along with \pre\_gen.dart\ and \post\_gen.dart\ hooks that handle route configuration validation, path normalization, and file creation. The \exit\_overrides.dart\ file provides a mechanism to override the default \exit\ behavior during hook execution, allowing for better error handling and testing. Additionally, the \pubspec.yaml\ for the \dart\_frog\_new\_hooks\ package has been updated, and new tests have been added to cover the \pre\_gen\ and \post\_gen\ hooks, as well as the \exit\_overrides\ functionality. This change ensures that the CLI can generate new Dart Frog projects with the correct structure and configuration.

_packages/dart\_frog\cli/lib/src/commands/new/templates · high confidence

The \dart\_frog update\ command now supports a \--verify-only\ flag. When this flag is provided, the CLI checks for available updates and displays the latest version number without performing the actual update. This allows users to verify if an update is available before committing to the installation process.

_packages/dart\_frog\cli/lib/src/commands/update · high confidence

The code generation process now includes validation that detects and reports rogue routes (files that do not match their expected path structure) and route conflicts (overlapping or ambiguous dynamic/static route definitions). This helps developers identify configuration errors early in the development cycle.

_packages/dart\_frog\_gen/lib/src/validate\_route\configuration · high confidence

The \dart\_frog\_dev\_server\ hooks have been refactored to use \dart\_frog\_gen\ for route configuration, introducing pre-generation validation that detects and reports route conflicts and rogue routes. The hook logic has been decomposed into multiple files, including a new \pre\_gen.dart\ entry point and a \src/exit\_overrides.dart\ utility for testable exit behavior. Additionally, \.gitignore\ and \analysis\_options.yaml\ files were added to the hooks directory.

_bricks/dart\_frog\_dev\server/hooks · high confidence

The Dart Frog CLI now uses updated hooks to validate route configurations before generation, preventing rogue routes and conflicts. The \pre\_gen\ hook now checks for existing routes and middleware, ensuring that new files do not clash with current project structure. The \post\_gen\ hook handles file renaming to avoid rogue routes. These changes improve the reliability of the \dart\_frog new\ command by catching errors early and ensuring generated code adheres to Dart Frog's routing conventions.

_bricks/dart\_frog\new/hooks · high confidence

The production server build process now properly handles Dart workspaces by copying the workspace root's \pubspec.lock\ to ensure consistent dependency versions. It also detects and bundles external path dependencies into the build directory, and disables workspace resolution during the build to avoid resolution issues. Additionally, the build script now reports route conflicts and rogue routes as errors, and supports custom Dockerfiles and Dart versions.

_bricks/dart\_frog\_prod\server/hooks · high confidence

The daemon's internal structure has been refactored to use a domain-based architecture, introducing new \DaemonDomain\, \DevServerDomain\, and \RouteConfigurationDomain\ classes that extend a shared \DomainBase\. This change organizes daemon logic into distinct, manageable units for managing the daemon lifecycle, starting/stopping dev servers, and watching route configurations, making the daemon's internal behavior more modular and testable.

_packages/dart\_frog\cli/lib/src/daemon/domain · high confidence

The Dart Frog CLI build process now copies the workspace's pubspec.lock file into the build directory to ensure the production build uses the exact same dependency versions as the workspace. This change introduces new logic in the build hooks to detect workspace roots, disable workspace resolution temporarily, and copy the lockfile, ensuring consistent and reproducible production builds in workspace setups.

_packages/dart\_frog\cli/lib/src/commands/build/templates · high confidence

The generated production server entry point (bin/server.dart) has been updated to support a custom entrypoint via the \invokeCustomEntrypoint\ template variable, allowing users to provide their own initialization logic. The server now binds to \InternetAddress.anyIPv6\ to support both IPv4 and IPv6 connections, and includes a startup log message indicating the running address and port.

_bricks/dart\_frog\_prod\server/\\brick\\/build/bin · medium confidence

The route generation logic in \dart\_frog\_gen\ has been refactored to improve how routes are resolved and prioritized. A new \route\_specificity.dart\ module was introduced to determine route priority, ensuring that static routes take precedence over dynamic ones when they have equal specificity. Additionally, the \path\_to\_route.dart\ utility was added to normalize file paths into clean API routes, and the main \buildRouteConfiguration\ function was restructured to better handle nested directories, middleware, and endpoint detection. These changes ensure that route generation is more predictable and correctly handles complex directory structures and dynamic route aliases.

_packages/dart\_frog\gen/lib/src · high confidence

Add e2e test infrastructure helpers for the Dart Frog CLI; Add unit tests for the echo route; Added VSCode integration test runner; Added automated tests for the VS Code extension; Added end-to-end tests for Dart Frog CLI commands; Added end-to-end tests for example apps; Added end-to-end tests for the Dart Frog CLI daemon; Added end-to-end tests for the kitchen sink example; Added route test for the index page; Added tests for Dart Frog New hooks; Added tests for Dart Frog extension utilities; Added tests for PubspecLock parsing and validation; Added tests for VS Code extension commands; Added tests for core Dart Frog components; Added tests for daemon protocol message handling; Added tests for form data parsing; Added tests for production server build hooks; Added tests for route configuration validation; Added tests for status bar items; Added tests for the Dart Frog CLI commands and daemon; Added tests for the Dart Frog dev server pre\_gen hook; Added tests for the Dart Frog production server hooks; Added tests for the Run CodeLens provider; Added tests for the web\_socket\_counter example; Added unit tests for InMemoryTodosDataSource; Added unit tests for dart\_frog\_gen code generation components; Added unit tests for kitchen\_sink example routes and middleware; Added unit tests for the Dart Frog VS Code extension's daemon components; Added unit tests for the Hello World example's index route; Added unit tests for the Todos example application; Added unit tests for the todos data source package.

This update refreshes dependencies across the Dart Frog codebase. The documentation site has been upgraded to Astro 5.18.0 and Starlight 0.37.6, with corresponding updates to dev dependencies like Prettier and Tailwind. All Dart Frog example applications have been updated to use \dart\_frog\ ^1.0.0 and \dart\_frog\_lint\ ^0.1.0, while the \create\_dart\_frog\ brick now targets SDK ^3.11.0. Additionally, the \dart\_frog\_gen\ dependency has been upgraded to ^2.0.0 in the project's internal hooks and bricks.

(dependencies) · high confidence

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

• CAI 58 → 59 (+1.3)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 98 → 94 (-3.4)
• Architecture 86 → 86 (+0.6)
• Maturity 50 → 54 (+3.8)
• Readiness 63 → 64 (+1.0)
• Security 50 → 50 (+0.6)
• Domain Modelling 100 → 100 (+0.0)

• Coverage not included — suite not readable by the collector
• Dependency hygiene not measured — dependency manifest found but not parsed for hygiene
• Further sole-owners (lower concentration)
• High CVE: [GHSA redacted] (extensions/vscode/package-lock.json)
• High CVE: [GHSA redacted] (extensions/vscode/package-lock.json)
• High CVE: [GHSA redacted] (extensions/vscode/package-lock.json)
• High CVE: [GHSA redacted] (extensions/vscode/package-lock.json)
• High CVE: [GHSA redacted] (extensions/vscode/package-lock.json)
• High CVE: [GHSA redacted] (extensions/vscode/package-lock.json)
• High CVE: [GHSA redacted] (extensions/vscode/package-lock.json)
• High vulnerability: [GHSA redacted] (extensions/vscode/package-lock.json)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• …and 20 more

• DevServerRunner.start (cognitive 19) (packages/dart_frog_cli/lib/src/dev_server_runner/dev_server_runner.dart)
• DevServerRunner.start (cyclomatic 19) (packages/dart_frog_cli/lib/src/dev_server_runner/dev_server_runner.dart)
• Documentation: no project overview (README.md)
• Documentation: no usage examples (README.md)
• Duplicated block (22 lines × 3) (bricks/dart_frog_dev_server/hooks/src/exit_overrides.dart)
• Duplicated block (26 lines × 2) (packages/dart_frog_cli/lib/src/daemon/domain/dev_server_domain.dart)
• Duplicated block (7 lines × 2) (packages/dart_frog_cli/lib/src/daemon/domain/dev_server_domain.dart)
• High CVE: [GHSA redacted] (extensions/vscode/package-lock.json)
• High CVE: [GHSA redacted] (extensions/vscode/package-lock.json)
• High CVE: [GHSA redacted] (extensions/vscode/package-lock.json)
• High CVE: [GHSA redacted] (extensions/vscode/package-lock.json)
• High CVE: [GHSA redacted] (extensions/vscode/package-lock.json)
• High CVE: [GHSA redacted] (extensions/vscode/package-lock.json)
• High CVE: [GHSA redacted] (extensions/vscode/package-lock.json)
• High vulnerability: [GHSA redacted] (extensions/vscode/package-lock.json)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• …and 87 more

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

dart-frog-dev/dart_frog 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.