dart-lang/http

This system is a comprehensive Dart HTTP and WebSocket library ecosystem that provides cross-platform networking capabilities for Dart and Flutter applications. It offers a unified \package:http\ interface with platform-specific implementations for Android (Cronet and OkHttp), iOS/macOS (Cupertino), and web, alongside a robust HTTP/2 client and server. The system also includes utilities for HTTP parsing, multi-interface server hosting, request profiling, and standardized conformance testing to ensure interoperability across different runtime environments.

31 changes.

This period focused on building a comprehensive HTTP/2 client and server implementation, including low-level framing, HPACK compression, flow control, and multiplexed connection pooling. Simultaneously, the project removed the legacy HTTP client library and its associated tests, while introducing new utilities for HTTP parsing and multi-interface server hosting.

24 changes.

This period focused on standardizing HTTP and WebSocket client APIs through abstract interfaces and platform-specific implementations for iOS, Android, and browsers. It introduced core features like request abortion, retry logic, and chunked encoding while establishing a comprehensive conformance test suite to ensure cross-platform consistency.

18 changes.

This period focused on establishing robust, cross-platform HTTP and WebSocket capabilities through new packages like web\_socket and ok\_http, alongside significant enhancements to http\_profile. The work involved implementing platform-specific native bridges for Android and browsers, introducing comprehensive conformance testing suites, and providing example applications to demonstrate best practices for multi-platform usage.

The example directory now includes a complete Flutter application that demonstrates how to use the \cronet\_http\ plugin. The app initializes a \CronetEngine\ on Android (using memory caching and a custom user agent) and wraps it in a \CronetClient\, while falling back to the standard \IOClient\ on other platforms. It uses the \provider\ package to inject the HTTP client into the widget tree and fetches package statistics from pub.dev to display like counts and download metrics.

_pkgs/cronet\http/example · high confidence

The HPACK encoder and decoder now support Huffman encoding for header values, significantly reducing the size of HTTP/2 header blocks. The implementation includes a static Huffman table and dynamic table management, ensuring compliance with the HPACK specification for efficient header compression.

pkgs/http2/lib/src/hpack · high confidence

New example scripts have been added to demonstrate HTTP/2 usage: \main.dart\ shows how to use the high-level \Http2Client\ to fetch data from the pub.dev API, while \display\_headers.dart\ demonstrates a lower-level approach using \ClientTransportConnection\ to connect via a raw socket, negotiate HTTP/2 via ALPN, and manually parse incoming headers.

pkgs/http2/example · high confidence

A new example file has been added to the package demonstrating how to connect to a WebSocket, wait for the connection to be ready, and handle incoming messages by sending a response and closing the channel.

_pkgs/web\_socket\channel/example · high confidence

The example package now includes a new \web\_socket\_example.dart\ file that demonstrates how to use the \WebSocket.connect\ method to establish a connection to a public WebSocket API (Whitebit) and subscribe to Bitcoin price data. This example serves as a practical reference for users implementing cross-platform WebSocket connections using the library.

_pkgs/web\socket/example · high confidence

A new example file has been added to the http\_parser package demonstrating how to use the formatHttpDate and parseHttpDate functions to convert between DateTime objects and HTTP date strings.

_pkgs/http\parser/example · high confidence

A new example file (main.dart) has been added to the http\_multi\_server package, demonstrating how to bind a single server to both IPv4 and IPv6 loopback addresses using HttpMultiServer.loopback and serve requests with the shelf package.

_pkgs/http\_multi\server/example · high confidence

A new script, generate\_server\_wrappers.dart, has been added to the http\_client\_conformance\_tests package to automatically generate platform-specific server wrapper files (\_server\_vm.dart and \_server\_web.dart) from source definitions. This tool uses the dart\_style library to format the generated code, ensuring consistent output for both VM and Web execution environments used in conformance testing.

_pkgs/http\_client\_conformance\tests/bin · high confidence

Added a new OpenSSL configuration file and a shell script to the tools directory that automate the generation of self-signed localhost certificates (including RSA keys and X.509 certificates valid for localhost, 127.0.0.1, and ::1). The script regenerates these certificates and automatically embeds the resulting key and certificate content into a Dart source file (test/cert.dart) for use in local testing, replacing manual certificate management.

_pkgs/http\_multi\server/tools · high confidence

The \package:http\ library now supports cancelling in-flight HTTP requests. A new \Abortable\ mixin and \RequestAbortedException\ allow clients to accept an \abortTrigger\ (a \Future\<void\>\); when this future completes, the request is cancelled. If the abort happens before the request is sent, \Client.send\ throws \RequestAbortedException\. If it happens after headers are received or during streaming, the exception is injected into the response stream. This capability is implemented in the \BrowserClient\ (using the browser \AbortController\) and \IOClient\ (using \HttpClientRequest.abort\), and is available for use with \Request\, \MultipartRequest\ (via \AbortableMultipartRequest\), and other base requests.

pkgs/http/lib/src · high confidence

The \pkgs/cronet\_http/example/android\ directory now contains a complete, buildable Android project structure for the cronet\_http example app. This includes the necessary AndroidManifest files (with INTERNET permission and cleartext traffic enabled), a Kotlin MainActivity extending FlutterActivity, standard launch splash screens and themes for light/dark modes, and a Gradle wrapper configured to use Gradle 8.14.3. This scaffolding allows developers to run and test the Cronet-based HTTP client implementation directly on Android devices.

_pkgs/cronet\_http/example/android, pkgs/ok\http/example/android · high confidence

The Android platform-specific implementation for the OkHttp package is introduced, providing the native Kotlin bridge required for Dart integration. This includes an asynchronous input stream reader for non-blocking data processing, a custom SSL key manager to support client certificate authentication, and interceptors to handle HTTP redirects with configurable limits and callbacks. Additionally, WebSocket support is enabled via a listener proxy to work around JNI subclassing limitations and a specific interceptor to manage WebSocket header parsing issues.

_pkgs/ok\http/android · high confidence

The example application for the ok\_http package has been added, providing a Flutter app that demonstrates how to use the plugin. On Android, the app uses OkHttpClient for HTTP requests, while on other platforms it falls back to the standard Dart HttpClient. The app fetches and displays package statistics (likes and 30-day downloads) from pub.dev to illustrate the plugin's usage.

_pkgs/ok\http/example · high confidence

This change introduces the \cronet\_http\ package, an Android Flutter plugin that provides an HTTP client implementation based on the Cronet network stack. It exposes \CronetClient\ and \CronetEngine\ classes, allowing developers to leverage Cronet's features such as HTTP/3 support, configurable caching, and platform-specific proxy handling. The package includes generated JNI bindings via \jnigen\ to interface with the Java Cronet API, and provides specific exception types (\CronetException\, \NetworkException\, \QuicException\) for detailed error reporting. It also supports an embedded Cronet variant for environments without Google Play Services via a \dart-define\ flag.

_pkgs/cronet\http · high confidence

This change introduces the \web\_socket\_conformance\_tests\ package, a library designed to verify that implementations of \package:web\_socket\'s \WebSocket\ interface behave correctly. The package provides a \testAll\ function that runs a suite of conformance tests against a provided WebSocket implementation by starting test servers. It includes a code generator (\generate\_server\_wrappers.dart\) to create platform-specific server wrappers for VM and web environments, along with example usage and configuration files for analysis and formatting.

_pkgs/web\_socket\_conformance\tests · high confidence

Added a new \ActiveSettings\ class and \SettingsHandler\ in \pkgs/http2/lib/src/settings/settings.dart\ to manage HTTP/2 connection settings. This change introduces support for tracking and modifying settings such as \SETTINGS\_INITIAL\_WINDOW\_SIZE\, \SETTINGS\_MAX\_CONCURRENT\_STREAMS\, and \SETTINGS\_HEADER\_TABLE\_SIZE\, including forwarding header table size changes to the HPack encoder. The \SettingsHandler\ processes incoming \SettingsFrame\s, manages acknowledgments, and exposes a stream for initial window size changes, enabling proper flow control and protocol compliance for HTTP/2 connections.

pkgs/http2/lib/src/settings · high confidence

The \http\_multi\_server\ package is added, providing an \HttpMultiServer\ class that wraps multiple \HttpServer\ instances to serve the same application across multiple network interfaces (such as both IPv4 and IPv6 loopback addresses) via a unified control interface. It introduces static factory methods \loopback\ and \loopbackSecure\ for convenient multi-interface binding, as well as \bind\ and \bindSecure\ utilities that handle special address strings like 'localhost' and 'any' to automatically select appropriate IPv4/IPv6 addresses. The implementation ensures that configuration properties like \serverHeader\, \idleTimeout\, \autoCompress\, and \sessionTimeout\ are propagated to all wrapped servers, and it supports secure HTTPS connections with client certificate request options.

_pkgs/http\_multi\server/lib · high confidence

A new PingHandler class has been added to manage HTTP/2 ping frames, allowing the library to send pings and handle incoming responses via callbacks rather than streams. This implementation ensures protocol compliance by validating stream IDs and handling acknowledgments, while also cleaning up pending operations when the connection terminates.

pkgs/http2/lib/src/ping · high confidence

The \package:web\_socket\ library now provides a unified \WebSocket\ interface that automatically selects the appropriate underlying implementation based on the target platform: it uses the browser's JavaScript WebSocket API when running in a browser (via \dart:js\_interop\) and \dart:io\ WebSocket when running on native platforms. This change introduces \BrowserWebSocket\ and \IOWebSocket\ classes, along with a \FakeWebSocket\ for testing, allowing developers to write platform-agnostic WebSocket code using a single \WebSocket.connect\ entry point. The implementation supports subprotocol negotiation, text and binary data transmission, and proper close code/reason handling, with a stub ensuring a clear error if neither platform library is available.

_pkgs/web\socket/lib/src · high confidence

Adds a new experimental Android plugin that wraps the OkHttp HTTP client and WebSocket API, providing a smaller APK footprint and broader device compatibility than alternatives like \cronet\_http\. The package implements the \package:http\ \BaseClient\ interface to support both synchronous and asynchronous requests with streaming response bodies, includes built-in WebSocket support, and allows configuration of timeouts, client certificates, and redirects via \OkHttpClientConfiguration\.

_pkgs/ok\http · high confidence

The \pkgs/http2/lib/src/frames\ library now exposes a new set of classes for handling HTTP/2 transport frames, including \FrameReader\ for decoding incoming byte streams into \Frame\ objects, \FrameWriter\ for serializing outgoing frames, and \FrameDefragmenter\ for reassembling fragmented headers and push promises. This change adds the foundational types for all HTTP/2 frame types (such as \DataFrame\, \HeadersFrame\, \SettingsFrame\, etc.) and their associated constants, enabling the library to parse and construct raw HTTP/2 protocol data.

pkgs/http2/lib/src/frames · high confidence

This change adds the core implementation files for the \cupertino\_http\ package, providing a new HTTP client and WebSocket support built on top of the iOS Foundation URL Loading System. The \CupertinoClient\ class wraps \NSURLSession\ to handle standard HTTP requests, while the new \CupertinoWebSocket\ class utilizes the \NSURLSessionWebSocketTask\ API to enable WebSocket connections. These components rely on auto-generated FFI bindings (\native\_cupertino\_bindings.dart\) to interface with native Objective-C APIs, allowing Dart applications to use native iOS networking capabilities directly.

_pkgs/cupertino\http/lib/src · high confidence

The package now provides distinct WebSocket implementations for different runtime environments. A browser-specific implementation is exposed via the \browser\_web\_socket.dart\ entry point, while an IO-based implementation is available through \io\_web\_socket.dart\. A testing utility is also added via \testing.dart\ to expose fake WebSocket implementations for unit testing. These are all re-exported through the main \web\_socket.dart\ library.

_pkgs/web\socket/lib · high confidence

The http\_profile package now exposes its primary functionality through a main entry point file (http\_profile.dart) that re-exports the core implementation from src/http\_profile.dart, establishing the public API surface for consumers of the package.

_pkgs/http\profile/lib · high confidence

A new \tool/ci.sh\ script has been added to automate continuous integration tasks across multiple packages. Generated by \mono\_repo\ v6.7.2, this script iterates through specified packages to run dependency upgrades, formatting checks, and analysis. It supports both Dart and Flutter environments, automatically switching commands based on the presence of a Flutter SDK dependency. The script enables running tests on various platforms including VM, Chrome, Firefox, and Dart2Wasm, ensuring consistent validation across different execution contexts.

tool · high confidence

The library now includes new source files in the \lib/src\ directory that provide foundational HTTP parsing capabilities. This adds an \AuthenticationChallenge\ class for parsing WWW-Authenticate headers, a \ChunkedCodingCodec\ for handling chunked transfer encoding, and an \http\_date\ module for formatting and parsing HTTP dates (including RFC 850 two-digit year handling). It also introduces a \CaseInsensitiveMap\ helper for case-insensitive header parameters and updates the \MediaType\ class to use this map for its parameters, ensuring case-insensitive key access.

_pkgs/http\parser/lib/src · high confidence

The library now exposes a high-level, pooled, multiplexed HTTP/2 client via \Http2Client\ (exported from \client.dart\) for making requests, alongside a \MultiProtocolHttpServer\ that automatically negotiates between HTTP/1.1 and HTTP/2 using ALPN and routes connections to separate callbacks. The core transport layer (\transport.dart\) has been updated with new \ClientSettings\ and \ServerSettings\ classes to configure connection parameters like concurrent stream limits and window sizes, and introduces connection-level hooks such as \onActiveStateChanged\ and \onInitialPeerSettingsReceived\ to monitor connection lifecycle and peer configuration.

pkgs/http2/lib · high confidence

The package introduces a new \MultiHeaders\ class that delegates HTTP header access and modification across multiple \HttpHeaders\ instances, ensuring that operations like setting content type or adding headers are applied to all underlying headers. Additionally, utility functions \supportsIPv6\ and \supportsIPv4\ are added to detect whether the current environment supports binding to IPv6 or IPv4 addresses, enabling the server to work correctly in IPv6-only environments.

_pkgs/http\_multi\server/lib/src · high confidence

The \pkgs/http2\ library now includes \async\_utils.dart\, introducing \BufferedSink\, \BufferedBytesWriter\, and \BufferIndicator\ classes. These utilities provide a mechanism to detect when writing to a stream sink would cause buffering and allow for batched data writes, enabling higher-level components to implement custom buffering and prioritization strategies for HTTP/2 frame transmission.

_pkgs/http2/lib/src/async\utils · high confidence

The flutter\_http\_example package now includes a complete sample application that illustrates how to configure and use the \package:http\ library across different platforms. The app provides platform-specific client implementations: it uses \CronetClient\ on Android, \CupertinoClient\ on iOS/macOS, and \IOClient\ on other native platforms, while falling back to \FetchClient\ for web. The example demonstrates best practices such as sharing a single \Client\ instance via the \provider\ package and using \MockClient\ for testing.

_pkgs/flutter\_http\example · high confidence

The \http2\ package now includes a new \Http2Client\ that multiplexes requests over pooled HTTP/2 connections. It manages connection lifecycles, enforces stream limits, and handles TLS handshakes, providing a high-performance HTTP/2 transport layer for Dart applications.

pkgs/http2/lib/src · high confidence

The \ok\_http\ library now supports WebSocket connections via the new \OkHttpWebSocket\ class, allowing users to establish \ws\/\wss\ connections and handle text, binary, and close events. Additionally, the \OkHttpClientConfiguration\ class has been expanded to support TLS client authentication, enabling users to configure private keys and certificate chains for mutual TLS. The plugin also introduces helper functions to load private keys from Android Keystore aliases or PKCS12 archives, and exposes a mechanism to select private key aliases via the system UI.

_pkgs/ok\http/lib/src · high confidence

This change introduces the initial structure and configuration files for the http\_multi\_server package within the monorepo. It adds the .gitignore file to exclude build artifacts and tool directories, a .test\_config file to specify VM platform testing, and an analysis\_options.yaml file that enforces strict-casts and includes the dart\_flutter\_team\_lints rule set. Additionally, it includes the LICENSE, README, and CHANGELOG files to document the package's usage, licensing, and version history.

_pkgs/http\_multi\server · high confidence

The \lib/src\ directory has been completely emptied as the legacy HTTP client implementation files—including \base\_client.dart\, \client.dart\, \request.dart\, \response.dart\, \streamed\_request.dart\, \streamed\_response.dart\, and \utils.dart\—have been deleted. This change removes the internal source code for the HTTP client, request, and response classes, along with their associated utility functions, effectively stripping the library of its core HTTP functionality in this location.

lib/src · high confidence

The \http\_profile\ package's internal implementation has been refactored by splitting the profiling logic into separate files (\http\_client\_request\_profile.dart\, \http\_profile\_request\_data.dart\, \http\_profile\_response\_data.dart\, and \utils.dart\). This change organizes the classes that record HTTP request and response details—such as headers, body bytes, connection info, and redirects—into a more modular structure while preserving the existing public API for debugging and profiling tools.

_pkgs/http\profile/lib/src · high confidence

The http2 package introduces stricter protocol compliance and a new pooled client. It now rejects incoming streams if they exceed the locally advertised \SETTINGS\_MAX\_CONCURRENT\_STREAMS\ limit and treats incoming server push streams as a protocol error when push is disabled. Additionally, it gracefully handles headers received on streams that the client has already canceled. A new \Http2Client\ is also available in \package:http2/client.dart\, providing a pooled, multiplexed HTTP/2 client for \package:http\ that reuses connections across requests.

pkgs/http2 · high confidence

The HTTP/2 implementation now uses a dedicated StreamHandler class to manage individual stream lifecycles, including state tracking (Idle, Open, Closed, etc.), flow control, and message queuing. This change centralizes the handling of stream-specific frames (such as RST\_STREAM and GOAWAY) and enforces settings like max concurrent streams, providing a more robust and structured approach to stream management compared to the previous flat implementation.

pkgs/http2/lib/src/streams · high confidence

The library now exposes an abstract \WebSocketChannel\ interface that defines the contract for WebSocket communication, including properties for the negotiated subprotocol, close code, and close reason. A key behavioral addition is the \ready\ future, which allows users to await connection establishment before sending data, replacing previous implicit readiness assumptions. The \WebSocketSink\ interface is also formalized to support explicit close codes and reasons. This change shifts the API from concrete implementation details to a structured interface, with the \connect\ factory method delegating to an adapter implementation.

_pkgs/web\_socket\channel/lib/src · high confidence

The package now exposes a unified \cupertino\_http.dart\ library file that consolidates exports for \CupertinoClient\, \NSErrorClientException\, and the WebSocket implementation. This change simplifies imports for users, who can now access the full API surface by importing a single file rather than navigating multiple internal source paths.

_pkgs/cupertino\http/lib · high confidence

The HTTP/2 library now uses dedicated classes to manage data flow and message ordering. \ConnectionMessageQueueOut\ and \StreamMessageQueueOut\ buffer outgoing messages, ensuring data is only sent when the connection and stream flow control windows allow, and automatically fragmenting large data frames to fit within available window space. \ConnectionMessageQueueIn\ and \StreamMessageQueueIn\ handle incoming frames, multiplexing them to the correct streams and buffering if the application is not consuming data fast enough. New \Window\ and \WindowHandler\ classes track flow control state, enforcing limits and sending \WINDOW\_UPDATE\ frames when data is processed, while \queue\_messages.dart\ defines the message types used internally.

pkgs/http2/lib/src/flowcontrol · high confidence

The http\_parser library has been restructured to export a new set of core classes, including AuthenticationChallenge, CaseInsensitiveMap, and chunked transfer coding support, while removing the deprecated DataUri API. This change updates the public surface area of the library, requiring consumers to adjust imports to the new module structure.

_pkgs/http\parser/lib · high confidence

The library has been refactored to use the latest \package:web\ for browser-based WebSocket communication, replacing the previous HTML implementation with \HtmlWebSocketChannel\ which exposes the underlying \WebSocket\ via \innerWebSocket\ and supports configurable binary types (\Blob\ or \Uint8List\). A new \AdapterWebSocketChannel\ class serves as a shared base for platform implementations, and \IOWebSocketChannel\ now extends this adapter for Dart VM/IO environments, supporting custom HTTP clients and connection timeouts. A new \status.dart\ library exports standard WebSocket close codes (e.g., \normalClosure\, \goingAway\) for convenient import.

_pkgs/web\_socket\channel/lib · high confidence

The \pkgs/http\_parser\ library now includes a dedicated implementation for HTTP chunked transfer encoding, introducing \ChunkedCodingEncoder\ and \ChunkedCodingDecoder\ classes along with a \charcodes.dart\ helper file. This change replaces the previous dependency on the \package:charcode\ library with local constant definitions for ASCII characters, providing a self-contained solution for encoding and decoding chunked data streams.

_pkgs/http\_parser/lib/src/chunked\coding · high confidence

The \lib/http.dart\ file has been deleted, removing the convenience top-level functions (such as \get\, \post\, \put\, \delete\, \read\, and \readBytes\) that previously allowed making HTTP requests without explicitly managing a \Client\ instance. Users must now instantiate and manage an \http.Client\ directly for all HTTP operations, ensuring proper resource handling and enabling more fine-grained control over persistent connections and request configuration.

lib · high confidence

The \pkgs/http/lib\ package has been reorganized to provide dedicated entry-point files for different usage contexts: \http.dart\ now serves as the main API surface (exporting core classes and top-level convenience functions), \browser\_client.dart\ exposes the browser-specific client, \io\_client.dart\ exposes the IO-specific client and response type, \retry.dart\ introduces a new \RetryClient\ wrapper that automatically retries failing HTTP requests with configurable delays and conditions, and \testing.dart\ provides the \MockClient\ for unit testing. This structure allows users to import only the components they need, such as the retry logic or testing utilities, without pulling in unnecessary platform-specific implementations.

pkgs/http/lib · high confidence

The example code in the HTTP package has been updated to demonstrate usage of public APIs. The main example now fetches package statistics (likes and 30-day downloads) from the pub.dev API, and a new retry example demonstrates how to use the RetryClient wrapper for automatic request retries.

pkgs/http/example · high confidence

This release of the iOS/macOS HTTP library addresses potential memory leaks in \URLRequest.fromUrl\ and \MutableURLRequest.fromUrl\ by correcting autorelease pool usage, and eagerly releases request body data in \CupertinoClient\. It also upgrades \package:ffigen\ to version 22.0.0 and updates the example to fetch and display package scores from pub.dev.

_pkgs/cupertino\http · high confidence

Added HPack decoder and Huffman codec tests; Added HTTP client conformance test suite; Added IO-specific HTTP client tests; Added browser-specific conformance and unit tests for BrowserClient; Added conformance test suite for WebSocket implementations; Added example conformance test for custom HTTP clients; Added integration tests for cronet\_http; Added test coverage for HTTP parser components; Added test coverage for HTTP/2 client pooling, conformance, and transport behavior; Added test coverage for the new package:web\_socket library; Added test for client connection closure when stream IDs are exhausted; Added test suite for HTTP/2 stream behavior and server push; Added test suite for HttpMultiServer functionality; Added tests for HTTP/2 connection preface handling; Added tests for HTTP/2 framing components; Added tests for HTTP/2 settings frame handling; Added tests for http\_profile profiling data structures and behaviors; Added tests for the HTTP/2 PingHandler; Added tests for the new WebSocket adapter and platform-specific implementations; Added unit tests for HTTP/2 flow control queues and window handlers; Expanded HTTP client conformance test coverage; Expanded WebSocket conformance test coverage for connection lifecycle and protocol handling; Expanded test coverage for HTTP client features; Integration test coverage for ok\_http client features; Removed legacy unittest-based HTTP client tests.

The Android build configuration for the \cronet\_http\ and \ok\_http\ plugins, along with their example applications, has been updated to use newer versions of the Android Gradle Plugin (AGP) and Kotlin. Specifically, \cronet\_http\ now targets AGP 8.1.0 and Kotlin 2.1.0 with a minimum SDK of 24, while \ok\_http\ targets AGP 9.1.0 and Kotlin 2.4.0 with a minimum SDK of 24. The \flutter\_http\_example\ app has also been updated to use AGP 8.6.0 and Kotlin 2.1.0. These changes ensure compatibility with the latest Android development tools and SDKs.

(dependencies) · high confidence

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

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

• Code Health 89
• Architecture 91
• Maturity 68
• Readiness 77
• Security 61
• Domain Modelling 100

• 300 commits — 249 feature/other, 51 fixes

• pkgs/cupertino_http — 53 commits
• pkgs/cronet_http — 46 commits
• .github/workflows — 41 commits
• pkgs/http — 31 commits
• pkgs/ok_http — 23 commits
• (repo) — 16 commits
• pkgs/http2 — 16 commits
• pkgs/web_socket_channel — 16 commits
• pkgs/http_parser — 13 commits
• pkgs/http_client_conformance_tests — 12 commits
• pkgs/http_multi_server — 10 commits
• pkgs/web_socket — 6 commits
• (root) — 5 commits
• pkgs/flutter_http_example — 3 commits
• .github/ISSUE_TEMPLATE — 2 commits
• pkgs/http_profile — 2 commits
• pkgs/web_socket_conformance_tests — 2 commits
• .gemini/config.yaml — 1 commit
• .github/labeler.yml — 1 commit
• pkgs/java_http — 1 commit

• fix: Add issue template and other fixes
• fix: Add issue template and other fixes
• fix: Add issue template and other fixes
• fix: Add issue template and other fixes
• fix: Bump and fix lints (dart-lang/web_socket_channel#366)
• fix: Fix "unintended_html_in_doc_comment" analysis errors (#1291)
• fix: Fix CI
• fix: Fix Default Encoding for application/json Content-Type in HTTP Responses (#1422)
• fix: Fix RFC 850 two-digit year parsing (#1951)
• fix: Fix Connection reset by peer in protocol error tests (#1786)
• fix: Fix fetch response stream cancellation (#1822)
• fix: Fix a bug where ConnectionException.toString didn't stringify NSError (#1785)
• fix: Fix a bug where cupertino_http did not work on iOS<17. (#1399)
• fix: Fix a bug where the HttpClient response stream was cancelled after completed (#1792)
• fix: Fix a potential exponential backtracking issue when parsing quoted headers (#1434)
• fix: Fix browser clients in workers (#1715)
• fix: Fix health workflow
• fix: Fix incorrect response processing (#1448)
• fix: Fix publishing workflow
• fix: Fix tags
• …and 280 more

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

dart-lang/http 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.