Skip to content
CAI
Software that uses CAICheck a score

dart-lang/http

52.9

Adequate · 5 November 2026

20.9k

lines of production code

Dart

primary language

4

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add Android example app scaffolding with Gradle 9.3.1

The \ok\_http\ Android example project now includes a complete Android application structure, providing a ready-to-run environment for testing the library. This includes standard Flutter Android configuration files (AndroidManifest, MainActivity, themes) and updates the Gradle wrapper to version 9.3.1, ensuring compatibility with the latest Android build tools.

_pkgs/ok\http/example/android · high confidence

Add Flutter example app for cronet\_http

A new Flutter example application has been added to demonstrate how to use the cronet\_http plugin. The app initializes a CronetEngine on Android (falling back to the standard IO client on other platforms) and uses it to fetch package details from pub.dev, displaying the results in a simple UI.

_pkgs/cronet\http/example · high confidence

Add HPACK header compression with Huffman encoding and dynamic table support

The HPACK implementation in the HTTP/2 package now includes full support for header compression as required by the HTTP/2 specification. This change introduces a new \HPackContext\ class that manages both static and dynamic header index tables, allowing for efficient header representation. It also adds a dedicated Huffman codec (\huffman.dart\ and \huffman\_table.dart\) to encode and decode header names and values, significantly reducing bandwidth usage. Additionally, the decoder now supports configurable header table sizes and enforces header list size limits to prevent resource exhaustion, ensuring compliance with the HPACK standard.

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

Add HTTP multi-server example

An example application has been added to demonstrate how to use the http\_multi\_server package. The example shows how to create a server that listens on both IPv4 and IPv6 loopback addresses using HttpMultiServer.loopback and serves a simple response via the shelf package.

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

Add HTTP/2 example applications

New example scripts have been added to demonstrate HTTP/2 usage in Dart. The \display\_headers.dart\ example shows how to manually establish a secure socket connection, negotiate HTTP/2 via ALPN, and handle raw stream messages including headers and data. The \main.dart\ example demonstrates a higher-level approach using the \Http2Client\ to perform a standard HTTP GET request against the pub.dev API and parse the JSON response.

pkgs/http2/example · high confidence

Add example demonstrating cross-platform WebSocket connection

The example directory now includes a Dart script that demonstrates using the new \WebSocket.connect\ factory method to establish a connection to a public WebSocket API (Whitebit) for streaming Bitcoin price data. This example illustrates the usage of the cross-platform connection method introduced in the library, showing how to subscribe to candle data and handle incoming text and binary events.

_pkgs/web\socket/example · high confidence

Add ok\_http example application

The \pkgs/ok\_http/example\ directory now contains a complete Flutter application that demonstrates how to use the \ok\_http\ plugin. The app uses the \OkHttpClient\ on Android and falls back to the standard \IOClient\ on other platforms to fetch package statistics from pub.dev, providing users with a concrete reference implementation for integrating the library.

_pkgs/ok\http/example · high confidence

Added HTTP date formatting example

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

Added example demonstrating WebSocketChannel usage

An example file has been added to the package that demonstrates how to connect to a WebSocket server, wait for the connection to be ready, and handle incoming messages by echoing them back and closing the connection.

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

Added server wrapper generation tool for VM and Web targets

A new script, generate\_server\_wrappers.dart, has been added to the http\_client\_conformance\_tests package. This tool automatically generates platform-specific server wrapper files (\_server\_vm.dart and \_server\_web.dart) from source definitions, enabling the conformance tests to run HTTP servers correctly in both VM and Web environments.

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

Added test certificates and generation script for client certificate support

The \pkgs/ok\_http/example/test\_certs\ directory now includes the necessary assets to support client certificate authentication using Java \PrivateKey\s. This addition features a README explaining the certificate files (\server\_chain.p12\, \server\_key.p12\, and \test-combined.p12\) and a new \generate\_test\_combined.sh\ script. The script generates a self-signed client certificate protected with legacy algorithms (SHA-1 MAC and 3DES encryption) to ensure compatibility with older Android versions (e.g., API level 24) that cannot read PKCS \#12 files using modern OpenSSL 3 defaults.

_pkgs/ok\_http/example/test\certs · high confidence

Automated local SSL certificate regeneration for development

Added a new OpenSSL configuration and a shell script to the tools directory that automates the generation of self-signed localhost certificates. This script creates RSA keys and certificates valid for localhost, 127.0.0.1, and ::1, then embeds the resulting key and certificate content into a Dart source file (test/cert.dart) for use in local development and testing environments.

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

HTTP client library refactored with new base classes and request abortion support

The \pkgs/http/lib/src\ implementation has been restructured to introduce \BaseClient\ and \BaseResponse\ as foundational abstractions, providing default implementations for convenience methods like \get\, \post\, and \read\. A new \Abortable\ mixin and \RequestAbortedException\ have been added, allowing HTTP requests to be cancelled via an \abortTrigger\ in both \IOClient\ and \BrowserClient\. The \BrowserClient\ now uses \package:web\ for its underlying \fetch\ implementation, and \BaseResponse\ gains a \headersSplitValues\ extension to parse comma-separated headers into lists, alongside a \BaseResponseWithUrl\ interface to expose the final response URI.

pkgs/http/lib/src · high confidence

Initial Android example app scaffolding for cronet\_http

The cronet\_http example application now includes a complete Android project structure, providing users with a ready-to-run template. This includes the necessary AndroidManifest.xml files with internet permissions, a Kotlin MainActivity extending FlutterActivity, standard launch splash screens, and Gradle wrapper configuration (Gradle 8.14.3) to facilitate building and testing the Cronet-based HTTP client on Android devices.

_pkgs/cronet\http/example/android · high confidence

Initial Android implementation for OkHttp package

The Android native layer for the OkHttp package is introduced, providing the Kotlin bridge code required to integrate OkHttp with Dart via jnigen. This includes an asynchronous input stream reader for non-blocking response body handling, a custom X.509 key manager to support client certificate authentication, and interceptors that enable configurable HTTP redirect handling and WebSocket connectivity. A ProGuard configuration is also added to ensure the necessary OkHttp and custom classes are preserved in release builds.

_pkgs/ok\http/android · high confidence

Initial release of cronet\_http with Cronet integration and JNI bindings

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

Initial release of web\_socket\_conformance\_tests package

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

Introduce HTTP/2 settings handling and stream window size change notifications

The HTTP/2 implementation now includes a dedicated \SettingsHandler\ and \ActiveSettings\ class to manage connection-level parameters such as header table size, push enablement, concurrent streams, initial window size, frame size, and header list size. This change adds support for handling remote SETTINGS frames, acknowledging them, and sending local setting changes. Crucially, it introduces a new \onInitialWindowSizeChange\ stream that notifies users when the remote peer updates the initial stream-level flow control window size, allowing applications to react to dynamic flow control adjustments.

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

Introduce HttpMultiServer for binding to multiple network interfaces

The http\_multi\_server package now provides an HttpMultiServer class that wraps multiple HttpServer instances, allowing applications to serve the same content on multiple network interfaces (such as both IPv4 and IPv6 loopback addresses) through a unified API. This release adds static convenience methods including loopback, loopbackSecure, bind, and bindSecure to simplify binding to common addresses like 'localhost' or 'any', while also supporting secure HTTPS connections via SecurityContext.

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

Introduce PingHandler for HTTP/2 ping management

A new PingHandler class has been added to the HTTP/2 library to manage connection keep-alive pings. This component handles sending ping frames and tracking their responses via Completers, while also processing incoming ping frames from the remote end by either forwarding opaque data to a provided sink (if listeners are present) or automatically sending ACKs. It ensures protocol compliance by validating stream IDs and handling termination states to clean up pending ping operations.

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

Introduce cross-platform WebSocket API with browser and IO implementations

This change adds a new \package:web\_socket\ implementation that provides a unified \WebSocket\ interface across Dart platforms. It introduces platform-specific connectors: \BrowserWebSocket\ for web targets (using \dart:js\_interop\) and \IOWebSocket\ for native targets (using \dart:io\), selected automatically via conditional imports. The API supports subprotocol negotiation, sends text and binary data, and handles connection closure with standard codes. A \FakeWebSocket\ implementation is also included to facilitate testing by allowing the creation of paired mock sockets.

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

Introduce experimental \`package:ok\_http\` for Android

Adds a new Android-specific Flutter plugin that wraps the OkHttp HTTP client and WebSocket API, providing a smaller disk 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 WebSocket support via \package:web\_socket\, and allows configuration of timeouts, redirects, and client certificates through \OkHttpClientConfiguration\.

_pkgs/ok\http · high confidence

Introduce native iOS HTTP client and WebSocket support

The \cupertino\_http\ package now provides a native implementation of the HTTP client and WebSocket interfaces using the Foundation URL Loading System on iOS. Users can create HTTP requests via \CupertinoClient\ and establish WebSocket connections via \CupertinoWebSocket\, which exposes the \NSURLSessionWebSocketTask\ API. This change adds new exception types like \NSErrorClientException\ for better error reporting and includes generated FFI bindings to interact with Objective-C APIs directly.

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

Introduce new HTTP/2 framing layer with FrameReader and FrameWriter

The \pkgs/http2/lib/src/frames\ directory now contains a new, modular framing implementation for HTTP/2. This includes \FrameReader\ to decode incoming byte streams into typed \Frame\ objects, \FrameWriter\ to encode outgoing frames (such as DATA, HEADERS, and SETTINGS) into bytes, and \FrameDefragmenter\ to reassemble fragmented header blocks from HEADERS and PUSH\_PROMISE frames. The \frame\_types.dart\ file defines the core data structures for all HTTP/2 frame types (e.g., \DataFrame\, \HeadersFrame\, \SettingsFrame\) and constants, providing the foundation for the connection's transport layer.

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

Introduce platform-specific WebSocket implementations

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

Introduce pooled HTTP/2 client and multiprotocol server

The library now exposes a pooled, multiplexed HTTP/2 client via \Http2Client\ (exported from \client.dart\) for users who want to reuse connections across multiple requests. On the server side, \MultiProtocolHttpServer\ is added to handle both HTTP/1.1 and HTTP/2 clients on the same port, automatically negotiating the protocol via ALPN and routing requests to separate callbacks. The core transport layer (\transport.dart\) is updated with new \ClientSettings\ and \ServerSettings\ classes that allow configuring connection limits, header sizes, and flow control, along with callbacks for connection state changes and peer settings.

pkgs/http2/lib · high confidence

Introduce pooled Http2Client and enforce HTTP/2 protocol limits

The \pkgs/http2\ package now includes \Http2Client\ (in \package:http2/client.dart\), a pooled, multiplexed client that reuses HTTP/2 connections for multiple requests, offering a drop-in replacement for \package:http\'s \Client\ to improve performance on concurrent workloads. Additionally, the library now strictly enforces peer-initiated stream limits by rejecting requests that exceed \SETTINGS\_MAX\_CONCURRENT\_STREAMS\ and treating incoming server push streams as protocol errors when push is disabled, while also exposing the peer's max concurrent streams setting via \ClientTransportConnection.peerMaxConcurrentStreams\.

pkgs/http2 · high confidence

Introduce pooled, multiplexed HTTP/2 client

A new \Http2Client\ is available that multiplexes requests over pooled HTTP/2 connections, dialing additional connections when a connection reaches its concurrent-stream limit rather than queuing. It enforces the server's \SETTINGS\_MAX\_CONCURRENT\_STREAMS\ limit, rejects requests that would exceed it, and waits for the peer's initial SETTINGS frame before allowing multiplexing (abandoning the connection if the frame does not arrive within the configured timeout). The client supports configuring the maximum streams per connection, the number of idle connections to retain, and TLS options such as \onBadCertificate\ and \SecurityContext\.

pkgs/http2/lib/src · high confidence

Introduction of http\_profile package entry point

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

New CI automation script for multi-package testing

A new \tool/ci.sh\ script has been added to automate continuous integration tasks across multiple packages. This script dynamically detects whether a package is a Flutter or Dart project and runs the appropriate commands (\flutter\ or \dart\). It supports various tasks including analysis, formatting, and testing on different platforms (VM, Chrome, Firefox, and Dart2WASM), allowing for consistent and randomized test execution in the CI environment.

tool · high confidence

New async buffering utilities for HTTP/2 streams

Added a new \async\_utils.dart\ module containing \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 more efficient and prioritized data handling in HTTP/2 frame processing.

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

New flutter\_http\_example sample app

A new Flutter sample application has been added to demonstrate how to configure and use the \package:http\ library across multiple platforms. The app provides platform-specific HTTP client implementations—using \CronetClient\ on Android, \CupertinoClient\ on iOS/macOS, and \FetchClient\ on the web—while sharing a single client instance via the \provider\ package. It also illustrates how to use \http\_image\_provider\ for image loading and how to write tests using \MockClient\.

_pkgs/flutter\_http\example · high confidence

New internal parsing utilities and HTTP component models

This change introduces several new internal source files to support HTTP parsing: \AuthenticationChallenge\ for parsing WWW-Authenticate headers, \MediaType\ for handling Content-Type/Accept headers with case-insensitive parameters, \ChunkedCodingCodec\ for chunked transfer encoding, \HttpDate\ for parsing and formatting HTTP dates (including RFC 850 two-digit year handling), \CaseInsensitiveMap\ for case-insensitive key storage, and supporting utilities (\scan.dart\, \utils.dart\) for token/quoted-string parsing and exception wrapping. These components are internal implementation details and do not expose new public APIs.

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

New internal utilities for IPv6 support and multi-header delegation

This change introduces two new internal source files to the package. The \utils.dart\ file adds runtime detection for IPv4 and IPv6 socket support, enabling the library to operate correctly in IPv6-only environments. The \multi\_headers.dart\ file implements a \MultiHeaders\ class that delegates HTTP header operations across multiple \HttpHeaders\ instances, ensuring consistent header handling when the server manages multiple connections or protocols.

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

OkHttp client now supports WebSocket connections and configurable timeouts

The \ok\_http\ package on Android now exposes WebSocket connectivity via the new \OkHttpWebSocket\ class, allowing applications to establish persistent connections using the \ws\ or \wss\ schemes. Additionally, the \OkHttpClient\ is now configurable with specific timeouts for connection, reading, writing, and overall call duration through \OkHttpClientConfiguration\, giving users finer control over network behavior and error handling.

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

http\_multi\_server package initialization and configuration

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

Removals

Removal of legacy HTTP client implementation files

The \lib/src\ directory has been cleaned up by removing several files that contained the legacy HTTP client implementation, including \base\_client.dart\, \base\_response.dart\, \client.dart\, \request.dart\, \response.dart\, \streamed\_request.dart\, \streamed\_response.dart\, and \utils.dart\. These files, which previously provided the core HTTP client classes and utility functions, are no longer present in this location, indicating a significant restructuring or removal of the internal HTTP client codebase.

lib/src · high confidence

Behavioural changes

HTTP profiling data structures refactored into modular source files

The \http\_profile\ package's internal implementation has been split from a single file into multiple dedicated source files (\http\_client\_request\_profile.dart\, \http\_profile\_request\_data.dart\, \http\_profile\_response\_data.dart\, and \utils.dart\). This refactoring introduces specific data classes for request and response details, including \HttpProfileProxyData\ for proxy configuration and \HttpProfileRedirectData\ for tracking redirects. The change also adds \eq\, \toString\, and \hash\ methods to \HttpProfileRedirectData\ to support value-based comparisons and debugging output, while ensuring that errors added to request and response body sinks are silently ignored to prevent profiling interruptions.

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

Introduce StreamHandler for HTTP/2 stream state management

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 peer settings like maximum concurrent streams, providing a more robust and structured approach to stream management compared to the previous flat connection-level handling.

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

Introduce abstract WebSocketChannel interface and connection readiness

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

Introduce single top-level entry point for cupertino\_http

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

Introduces structured HTTP/2 flow control and message queuing

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

Library restructure and API updates

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

Migrate to package:web and introduce new platform-specific WebSocket implementations

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

New chunked transfer coding implementation

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

Removal of legacy top-level HTTP functions

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

Restructured library entry points and added retry client

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

Update example to use pub.dev API and explicit client usage

The example code in pkgs/http/example has been updated to demonstrate using an explicit http.Client instance rather than the top-level convenience functions, and now queries the pub.dev API for package statistics (likes and 30-day downloads) instead of the Google Books API. This change also includes adding the required copyright header and ensuring the client is properly closed after use.

pkgs/http/example · high confidence

Fixes

cupertino\_http 3.1.1-wip: memory leak fixes and ffigen upgrade

This release updates the native bindings generator to ffigen 22.0.0 and fixes potential memory leaks in \URLRequest.fromUrl\ and \MutableURLRequest.fromUrl\ caused by objects being added to the autorelease pool. It also eagerly releases request body data in \CupertinoClient\ to free resources sooner.

_pkgs/cupertino\http · high confidence

Test coverage

Added HPack decoder and Huffman codec tests; Added HTTP client conformance test suite; Added IO-specific HTTP client tests; Added browser conformance tests and updated HTML test utilities; Added conformance test suite for WebSocket implementations; Added example conformance test for custom HTTP clients; Added integration tests for cronet\_http; Added integration tests for ok\_http client capabilities; Added test coverage for HTTP parser components; 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 test suite for the pooled HTTP/2 client; Added tests for HTTP/2 connection preface handling; 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; Added unit tests for HTTP/2 framing components; Expanded HTTP client conformance test coverage; Expanded WebSocket conformance test coverage; Expanded test coverage for HTTP client behavior and utilities; Removed legacy unittest-based HTTP client tests.

Dependencies

Updated Android build configurations and Dart SDK constraints for HTTP client plugins

The \cronet\_http\, \cupertino\_http\, \ok\_http\, and \flutter\_http\_example\ packages have updated their Android Gradle build files to use newer plugin and Kotlin versions (e.g., Kotlin 2.1.0/2.2.20, AGP 8.1.0/8.6.0/9.1.0) and set \compileSdkVersion\ to 35 for \cronet\_http\. Additionally, the Dart SDK constraints for these packages and their dependencies (such as \http\, \http2\, \web\_socket\, and \web\_socket\_channel\) have been raised to require Dart 3.4.0 or higher, ensuring compatibility with the latest language features and tooling.

(dependencies) · high confidence

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

How this codebase got here

Score

  • CAI 50 → 53 (+2.4)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.2) — scores are not directly comparable.

Lenses

  • Code Health 92 → 92 (+0.1)
  • Architecture 95 → 95 (+0.2)
  • Maturity 59 → 75 (+15.6)
  • Readiness 61 → 61 (+0.0)
  • Security 32 → 32 (+0.0)
  • Performance 79 → 79 (+0.0)

Resolved (3)

  • Change coupling: decoder.dart ↔ media_type.dart (pkgs/http_parser/lib/src/chunked_coding/decoder.dart)
  • Off-boarding risk: anonymized user #1
  • TodoComment (pkgs/http2/lib/src/streams/stream_handler.dart)

New (6)

  • Connection._handleFrameImpl (cyclomatic 16) (pkgs/http2/lib/src/connection.dart)
  • Hotspot: pkgs/cupertino_http/lib/src/cupertino_client.dart (pkgs/cupertino_http/lib/src/cupertino_client.dart)
  • Off-boarding risk: anonymized user #2
  • Off-boarding risk: anonymized user #1
  • Repeated repair: pkgs/http2/lib/src/flowcontrol/connection_queues.dart (pkgs/http2/lib/src/flowcontrol/connection_queues.dart)
  • Repeated repair: pkgs/http2/lib/src/sync_errors.dart (pkgs/http2/lib/src/sync_errors.dart)

Changes since last survey

  • 19 commits — 9 feature/other, 10 fixes

By area

  • pkgs/http2 — 9 commits
  • pkgs/cupertino_http — 3 commits
  • pkgs/http — 3 commits
  • .github/workflows — 2 commits
  • pkgs/cronet_http — 2 commits

Notable commits

  • fix: fix(cronet): avoid cronet namespace duplication (#2034)
  • fix: fix(http2): Http2Client applies response-body backpressure to the HTTP/2 stream and uses 4 MiB / 16 MiB receive windows (#2029)
  • fix: fix(http2): accept larger headers (#2041)
  • fix: fix(http2): do not head-of-line block HEADERS, RST_STREAM and GOAWAY behind window-exhausted DATA (#2013)
  • fix: fix(http2): ignore PRIORITY and unknown frames on streams and reject non-zero stream control frames (#2006)
  • fix: fix(http2): keep flow-controlled end-stream DATA alive until it is flushed (#1998) (#2007)
  • fix: fix(http2): make StreamException a StreamTransportException and forward ALPN errors to onError (#2009)
  • fix: fix(http2): never write RST_STREAM ahead of the stream's still-queued HEADERS (#2008)
  • fix: fix(http2): preserve the complete response on RST_STREAM(NO_ERROR) (#2012)
  • fix: fix(http2): replenish connection receive window when stream closes with unconsumed data (#2005)
  • change: Tighten pull_request_label workflow permissions (#2035)
  • change: [http] Don't throw in RetryClient when when has read the response stream (#2040)
  • change: chore(cronet_http): ready 1.10.1 (#2039)
  • change: chore(cupertino_http): check ffigen generation (#2044)
  • change: chore(cupertino_http): ready 3.1.1 release (#2056)
  • change: chore(deps): bump the github-actions group with 8 updates (#2052)
  • change: chore(http): run Firefox tests with -headless instead of xvfb-run (#2033)
  • change: doc: use timeout as an abort example (#2062)
  • change: feat(cupertino_http): support custom trust eval (#2038)

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

Survey your own repository

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.

About this page

  • The score is its most recent published measurement, taken on 5 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit 65821773f84a08a2ea48c60eccf5081074a16985 — the exact code this score is about.
  • Scored under rubric-2026.11.2 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.2+preprod-5c4e66d9318b.