cybrid_api_id_ruby 0.129.1137 → 0.129.1138

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/doc/release_notes/0_11_0.md

@@ -0,0 +1,74 @@
+# 0.11.0
+
+## Features
+
+### Webmock Adapter
+
+`httpx` can now be integrated with `webmock`, a popular HTTP requests stubbing library.
+
+```ruby
+# minitest
+require "webmock/minitest"
+require "httpx/adapters/webmock"
+
+# in rspec
+require "webmock/rspec"
+require "httpx/adapters/webmock"
+
+# and now you're free for mocking
+WebMock.enable!
+stub_http_request(:get, "https://www.google.com").and_return(status: 200, body: "here's google")
+
+```
+
+Read more about it in the [webmock integration documentation](https://honeyryderchuck.gitlab.io/httpx/wiki/Webmock-Adapter).
+
+### Datadog Adapter
+
+`httpx` ships with integration for [ddtrace, datadog's official tracing client](https://github.com/DataDog/dd-trace-rb). You just need to initialize it the following way:
+
+```ruby
+require "ddtrace"
+require "httpx/adapters/datadog"
+
+Datadog.configure do |c|
+  c.use :httpx
+end
+```
+
+A trace will be emitted for every request, so this should be an interesting visualization if concurrent requests are sent.
+
+Customization options and traces are similar to what [the net-http adapter provides](https://docs.datadoghq.com/tracing/setup_overview/setup/ruby/#nethttp).
+
+Read more about it in the [datadog integration documentation](https://honeyryderchuck.gitlab.io/httpx/wiki/Datadog-Adapter).
+
+## Improvements
+
+### Own multipart request encoder
+
+`httpx` now ships with its own multipart formdata encoder, and does not rely on `http-form_data` anymore:
+
+```ruby
+HTTPX.plugin(:multipart).post(uri, form: {file: File.new("path/to/file")})
+```
+
+Read more about it in the [multipart plugin documentation](https://honeyryderchuck.gitlab.io/httpx/wiki/Multipart-Uploads), including also about why this was made.
+
+### Expect Plugin
+
+The `:expect` plugin now works reliably when the server does not support the `expect: 100-continue` header, i.e. it'll upload the body after a certain timeout. Building onn that, two behaviours are now implemented:
+
+* A cache of domains which did not respond to the `expect` header is now kept, so that subsequent requests can skip the timeout and immediately upload the payload.
+* If the "100 Continue" response arrives **after** the timeout expired and the body has been uploaded, the domain is removed from the cache, and subsequent requests will send the `expect` header.
+
+### SNI/Host options
+
+Some extension of the API was applied in order to support custom TLS negotiation parameters. You can now pass `:hostname` under the `:ssl` options, and this will be used for the SNI part of the TLS negotiation. This is useful in scenarios where a proxy certificate doesn't apply for the host one wants to send the request to:
+
+```ruby
+response = session.get(proxy_ip, headers: { "host" => upstream_hostname }, ssl: { hostname: sni_hostname }
+```
+
+## Bugfixes
+
+A default 5 second timeout is in-place when using the DNS `:system` resolver, as it was found out that. when using the `resolv` library, the DNS query will not be retried otherwise. You can change this setting py passing `resolver_options: { timeouts: ANOTHER_TIMEOUT}`. In the future, this may become another timeout option, however.

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/doc/release_notes/0_11_1.md

@@ -0,0 +1,5 @@
+# 0.11.1
+
+## Bugfixes
+
+Fixed a bug related to the `:compression` plugin trying to process a last empty DATA frame from an HTTP/2 response, after it had been closed.

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/doc/release_notes/0_11_2.md

@@ -0,0 +1,5 @@
+# 0.11.2
+
+## Bugfixes
+
+The `:cookies` plugin wasn't able to parse `Expires` values, as it was using `Time.httpdate` to parse timestamps, which is RFC 2616-compliant, whereas cookies datetime values need to be RFC 6265-compliant.

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/doc/release_notes/0_11_3.md

@@ -0,0 +1,5 @@
+# 0.11.3
+
+## Bugfixes
+
+`EOFError` was being thrown when HTTP/1.1 non-chunked responses which don't contain a "content-length" header. The RFC mandates that the socket should be consumed until the server closes it, so a patch was implemented, to return the available response in such cases.

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/doc/release_notes/0_12_0.md

@@ -0,0 +1,55 @@
+# 0.12.0
+
+## Features
+
+### AWS Sigv4 Authentication Plugin
+
+A new plugin, `:aws_sigv4`, is now shipped with `httpx`. It implements the [AWS Signature Version 4 request signing process](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html), a well documented way of authenticating requests to AWS services, which has since been adopted by other cloud providers, such as Google Cloud Storage.
+
+See how to use it here: https://gitlab.com/os85/httpx/-/wikis/AWS-Sigv4#sessionaws_sigv4_authentication
+
+For convenience, there's a derivative plugin, `:aws_sdk_authentication`, which builds on top of `:aws_sigv4`, and integrates with the `aws-sdk-core` gem, maintained by AWS, to resolve the authentication credentials (p.ex. if you support ephemeral access keys).
+
+See how to use it here: https://gitlab.com/os85/httpx/-/wikis/AWS-Sigv4#sessionaws_sdk_authentication
+
+Other FAQ: https://gitlab.com/os85/httpx/-/wikis/AWS-Sigv4#faqs
+
+### HTTP/2 support for JRuby
+
+`jruby-openssl` doesn't support ALPN protocol negotiation, nor are there plans to implement, which limited the seamless HTTP/2 usage in `httpx`. A new connection adapter was therefore added specifically for JRuby, where ssl/tls connections will be handled using ffi-based openssl bindings, provided you bundle `ffi-compiler` and `concurrent-ruby`, and install a TLS/1.2-compatible `openssl` package.
+
+See how to use it here: https://gitlab.com/os85/httpx/-/wikis/JRuby-Truffleruby-Other-Rubies#http2
+
+## Improvements
+
+
+### truffleruby support
+
+`httpx` supports and tests against `truffleruby` (known to run tests since v20.3, passing all tests since v21).
+
+### Performance
+
+Several optimizations were introduced:
+
+* Reduction in read/write system calls;
+* more usage of `String#byteslice` in parsing (instead of string mutation);
+* Avoid selection on connections with no outstanding requests;
+
+They all contributed to a massive performance improvement, itself reflected in test runs, which need half the time they used to to complete.
+
+### APIs
+
+* `HTTPX::ErrorResponse#to_s` now uses the exception full message, instead of just the backtrace.
+
+## Bugfixes
+
+* HTTP/2 stream protocol errors do not cause the process to hang (instead, error responnses are yielded);
+* Fixed body stream bugs on retries when error causing retry would happen mid-transfer;
+* Fixed `:multipart` plugin body rewind on retries to start the transfer from the beginning;
+* Fixed auto-load of  `:proxy` plugin when `HTTPS_PROXY` or `HTTP_PROXY` is set;
+* Errno::EPIPE errors mid transfer now cause `httpx` to read from the server and get the appropriate HTTP error response;
+* Make sure that all requests have an error responnse if the error happens early;
+* Fixed TCP handshake Errno::INPROGRESS handling inside TLS connnections, which was causing the process to hang in a high handshake contention scenario;
+* Do not call the event loop if there's nothing to listen on (the DoH resolver was being listened on even if there was nothing to be request);
+* Fixed double event registry for DoH resolvers;
+*

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/doc/release_notes/0_13_0.md

@@ -0,0 +1,58 @@
+# 0.13.0
+
+## Features
+
+### Upgrade plugin
+
+A new plugin, `:upgrade`, is now available. This plugin allows one to "hook" on HTTP/1.1's protocol upgrade mechanism (see: https://developer.mozilla.org/en-US/docs/Web/HTTP/Protocol_upgrade_mechanism), which is the mechanism that browsers use to initiate websockets (there is an example of how to use `httpx` to start a websocket client connection [in the tests](https://gitlab.com/os85/httpx/-/blob/master/test/support/requests/plugins/upgrade.rb))
+
+You can read more about the `:upgrade` plugin in the [wiki](https://os85.gitlab.io/httpx/wiki/Connection-Upgrade).
+
+It's the basis of two plugins:
+
+#### `:h2c`
+
+This plugin was been rewritten on top of the `:upgrade` plugin, and handles upgrading a plaintext (non-"https") HTTP/1.1 connection, into an HTTP/2 connection.
+
+https://os85.gitlab.io/httpx/wiki/Connection-Upgrade#h2c
+
+#### `:upgrade/h2`
+
+This plugin handles when a server responds to a request with an `Upgrade: h2` header, does the following requests to the same origin via HTTP/2 prior knowledge (bypassing the necessity for ALPN negotiation, which is the whole point of the feature).
+
+https://os85.gitlab.io/httpx/wiki/Connection-Upgrade#h2
+
+### `:addresses` option
+
+The `:addresses` option is now available. You can use it to pass a list of IPs to connect to:
+
+```ruby
+# will not resolve example.com, and instead connect to one of the IPs passed.
+HTTPX.get("http://example.com", addresses: %w[172.5.3.1 172.5.3.2]))
+```
+
+You should also use it to connect to HTTP servers bound to a UNIX socket, in which case you'll have to provide a path:
+
+```ruby
+HTTPX.get("http://example.com", transport: "unix", addresses: %w[/path/to/usocket]))
+```
+
+The `:transport_options` are therefore deprecated, and will be moved in a major version.
+
+## Improvements
+
+Some internal improvements that allow certain plugins not to "leak" globally, such as the `:compression` plugin, which used to enable compression for all the `httpx` sessions from the same process. It doesn't anymore.
+
+Using exceptionless nonblocking connect calls in the supported rubies.
+
+Removed unneeded APIs around the Options object (`with_` methods, or the defined options list).
+
+## Bugfixes
+
+HTTP/1.1 persistent connections were closing after each request after the max requests was reached. It's fixed, and the new connection will also be persistent.
+
+When passing open IO objects for origins (the `:io` option), `httpx` was still trying to resolve the origin's domain. This not only didn't make sense, it broke if the domain is unresolvable. It has been fixed.
+
+Fixed usage of `:io` option when passed an "authority/io" hash.
+
+Fixing some issues around trying to connnect to the next available IPAddress when the previous one was unreachable or ETIMEDOUT.

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/doc/release_notes/0_13_1.md

@@ -0,0 +1,5 @@
+# 0.13.1
+
+## Bugfixes
+
+Rescue `Errno::EALREADY` on calls to `connect_nonblock(exception: false)` (there are exceptions after all...).

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/doc/release_notes/0_13_2.md

@@ -0,0 +1,9 @@
+# 0.13.2
+
+## Improvements
+
+`UDPSocket#sendmsg_nonblock` is now used in the native resolver.
+
+## Bugfixes
+
+Usage in Windows was buggy, resulting in `Errno::EINVAL` during DNS resolving, when using the native resolver. This was due to a discrepancy between `recvfrom` behaviour in WS Sockets and Linux Sockets. This was fixed by making we the UDP socket never tries to receive before a DNS query has been actually sent.

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/doc/release_notes/0_14_0.md

@@ -0,0 +1,79 @@
+# 0.14.0
+
+## Features
+
+### GRPC plugin
+
+A new plugin, `:grpc`, is now available. This plugin provides a simple DSL to build GRPC services and performing calls using `httpx` under the hood.
+
+Example:
+
+```ruby
+require "httpx"
+
+grpc = HTTPX.plugin(:grpc)
+helloworld_stub = grpc.build_stub("localhost:4545")
+helloworld_svc = helloworld_stub.rpc(:SayHello, HelloRequest, HelloReply)
+result = helloworld_svc.say_hello(HelloRequest.new(name: "Jack")) #=> HelloReply: "Hello Jack"
+```
+
+You can read more about the `:grpc` plugin in the [wiki](https://os85.gitlab.io/httpx/wiki/GRPC).
+
+### :origin
+
+A new `:origin` option is available. You can use it for setting a base URL for subsequent relative paths on that session:
+
+```ruby
+HTTPX.get("/httpbin/get") #=> HTTPX::Error: invalid URI: /httpbin/get
+
+httpbin = HTTPX.with(origin: "https://nghttp2.org")
+httpbin.get("/httpbin/get") #=> #<Response:5420 HTTP/2.0 @status=200 ....
+```
+
+**Note!** The origin is **not** for setting base paths, i.e. if you pass it a relative path, it'll be filtered out in subsequent requests (`HTTPX.with(origin: "https://nghttp2.org/httpbin")` will still use only `"https://nghttp2.org"`).
+
+## Improvements
+
+* setting an unexpected option will now raise an `HTTPX::Error` with an helpful message, instead of a confusing `NoMethodError`:
+
+```ruby
+HTTPX.with(foo: "bar")
+# before
+#=> NoMethodError
+# after
+#=> HTTPX::Error: unknown option: foo
+
+```
+
+* `HTTPX::Options#def_option` (which can be used for setting custom plugin options) can now be passed a full body string (where the argument is `value`), although it still support the block form. This is the recommended approach, as the block form is based on `define_method`, which would make clients unusable inside ractors.
+
+* Added support for `:wait_for_handshake` under the `http2_settings` option (`false` by default). HTTP/2 connections complete the protocol handshake before requests are sent. When this option is `true`, requests get send in the initial payload, before the HTTP/2 connection is fully acknowledged.
+
+*  441716a5ac0f7707211ebe0048f568cf0b759c3f: The `:stream` plugin has been improved to start streaming the real response as methods are called (instead of a completely separate synchronous one, which is definitely not good):
+
+```ruby
+session = HTTPX.plugin(:stream)
+response = session.get(build_uri("/stream/3"), stream: true)
+
+# before
+response.status # this could block indefinitely, if the request truly streams infinitely.
+
+# after
+response.status # sends the request, and starts streaming the response until status is available.
+response.each {|chunk|...} # and now you can start yielding the chunks...
+```
+
+
+## Bugfixes
+
+* fixed usage of the `:multipart` if `pathname` isn't loaded.
+* fixed HTTP/2 trailers.
+* fixed connection merges with the same origin, which was causing them to be duplicated and breaking further usage. (#125)
+* fixed repeated session callbacks on a connection, by ensure they're set only once.
+* fixed calculation of `content-length` for streaming or chunked compressed requests.
+
+
+## Chore
+
+* using ruby base container images in CI instead.
+* using truffleruby official container image.

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/doc/release_notes/0_14_1.md

@@ -0,0 +1,7 @@
+# 0.14.1
+
+
+## Bugfixes
+
+* fixed: HTTP/2-specific headers were being reused on insecure redirects, thereby creating an invalid request (#128);
+* fixed: multipart request parts weren't using explicity set `:content_type`, instead using file mime type or "text/plain";

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/doc/release_notes/0_14_2.md

@@ -0,0 +1,6 @@
+# 0.14.2
+
+
+## Bugfixes
+
+* fixed: multipart request parts weren't using explicity set `:filename`.

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/doc/release_notes/0_14_3.md

@@ -0,0 +1,5 @@
+# 0.14.3
+
+## Bugfixes
+
+* fixed: HTTP/1 "connection: close" header was "leaking" into subsequent redirect follow, including HTTP/2 requests which would fail due to the invalid header.

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/doc/release_notes/0_14_4.md

@@ -0,0 +1,5 @@
+# 0.14.4
+
+## Bugfixes
+
+* The HTTP/1 handler was miscalculating the last request for a given connection, and potentially freezing it.

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/doc/release_notes/0_14_5.md

@@ -0,0 +1,11 @@
+# 0.14.5
+
+## Bugfixes
+
+* After a connection had been initiated, sending multiple concurrent requests (ex: `open_httpx.request(req1, req2, req3)`) could freeze; this happened when the first request would fill the write buffer (like a file upload request), and the subsequent requests would never be buffered afterwards; this was fixed by making pending requests flushing a part of a connection's consumption loop.
+* Fixing v0.14.1's fixed bug again; The HTTP/1 "Connection: close" header was not being set in the last possible request on a connection, due to ann off-by-one error on connection bookkeeping;
+* HTTP/1 connections didn't respect a server-set max nunmber of requests after a reconnect; Fixed by making this accounting part of the reset process;
+
+## Chore
+
+* Added regression test suite, which reproduce reported bugs before the fix (backported all 0.14.x releases here)

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/doc/release_notes/0_15_0.md

@@ -0,0 +1,53 @@
+# 0.15.0
+
+## Features
+
+### HTTP response pattern-matching (ruby 3 only)
+
+You can now apply pattern matching in responses:
+
+```ruby
+case response = HTTPX.get("https://google.com")
+in { status: 200..399, headers: [*, ["x-special-token", token], *], body: }
+  puts "success: #{body.to_s}"
+in { status: 400..499, body: }
+  puts "client error: #{body.to_s}"
+in { status: 500.., body: }
+  puts "server error: #{body.to_s}"
+in { error: error }
+  puts "error: #{error.message}"
+else
+  raise "unexpected: #{response}"
+end
+```
+
+### NTLM Authentication
+
+A new plugin, `:ntml_authentication`, is now available. Like the name suggests, it allows authenticating requests via [NTLM](https://docs.microsoft.com/en-us/windows-server/security/kerberos/ntlm-overview).
+
+```ruby
+ntlm_http = HTTPX.plugin(:ntlm_authentication)
+
+ntlm.ntlm_authentication("user", "password").get("http://protected-area-requiring-ntlm.net")
+# or for a specific domain
+ntlm.ntlm_authentication("user", "password", "Domain\\User").get("http://protected-area-requiring-ntlm.net")
+```
+
+## Improvemennts
+
+A new timeout option, `settings_timeout`, is supported for the HTTP/2 handshake; after the TCP and TLS handshakes are complete, and initiating the HTTP/2 handshake, the client terminates the connection with SETTINGS_TIMEOUT error code, if it doesn't receive the server settings for the amount of seconds set in `settings_timeout` (by default, 10 seconds).
+
+```ruby
+# if you want to change
+HTTPX.with(timeout: {settings_timeout: 5})....
+
+```
+
+IDNA 2008 support is now possibly, by integrating [idnx](https://github.com/HoneyryderChuck/idnx) into your dependencies:
+
+
+```ruby
+# in Gemfile
+gem "httpx"
+gem "idnx"
+```

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/doc/release_notes/0_15_1.md

@@ -0,0 +1,8 @@
+# 0.15.1
+
+## Bugfixes
+
+Fixed HTTP/1 connection accounting on requests:
+
+* when persistent, Connection: close will be set based on the request position on the batch against the allowed requests on the open connection.
+* when not persistent, Connnection: close will be set on the last request of the batch, being the batch a subset based on allowed requests, or the whole of it.

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/doc/release_notes/0_15_2.md

@@ -0,0 +1,9 @@
+# 0.15.2
+
+## Bugfixes
+
+* Fixed cookie management for same-keys: before the fix, cookies with same-key, same-domain and same-path were all being sent in subsequent requests, which violates  RFC 6265 - 5.4 . As of now, only the last valid cookie for a given key/domain/path will be kept, evicting the others.
+
+## Chore
+
+* debug logs were inserting ASCII code string wrappers, even when no color was set. It nonw only sends the plain string.

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/doc/release_notes/0_15_3.md

@@ -0,0 +1,5 @@
+# 0.15.3
+
+## Bugfixes
+
+* Fixed connection management, where selectables could end up with "arrays of IO objects" as elements, instead of just IO objects. This caused bugs when connecting and performing concurrent requests on multiple hosts (#138).

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/doc/release_notes/0_15_4.md

@@ -0,0 +1,5 @@
+# 0.15.4
+
+## Bugfixes
+
+* Fixed `grpc` plugin, where `.marshal` was being called on the encoding protobuf object, instead of the coorrect "marshal method", which is `.encode`.

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/doc/release_notes/0_16_0.md

@@ -0,0 +1,93 @@
+# 0.16.0
+
+## Features
+
+### Response::Body#to_s does not clear the internal buffer
+
+It's well documented that the response body should be treated as a file, and that calling `.to_s` on a response should be done only once, and the user should not expect the same call to return the same response body again, while suggesting that the first call should be cached in a variable in case it's needed:
+
+```ruby
+response = HTTPX.get("https://google.com")
+body = response.body.to_s #=> "<html ...."
+response.body.to_s #=> ""
+
+# thankfully,it's cached in the body var there.
+```
+
+The justification for this behaviour probably had to do with avoiding keeping huge payloads around, but it got a bit lost in git history. It became a feature, not a bug.
+
+However, I got an [issue report](https://gitlab.com/os85/httpx/-/issues/143) that made me change my mind about this behaviour (tl;dr: it broke pattern matching when matching against response bodies more than once).
+
+So now, you can call `.to_s` how many times you want!
+
+```ruby
+response = HTTPX.get("https://google.com")
+body = response.body.to_s #=> "<html ...."
+response.body.to_s #=> "<html ....", still here!
+```
+
+Some optimizations were done around how the body is carried forward, and bodies buffered in files will now get properly garbage collected and not leak descriptors behind when users forget to call `.close`.
+
+### grpc plugin improvements
+
+##### build fully-enabled stub from grpc service
+
+The `:grpc` plugin can now build fully-loaded stubs from existing GRPC generic services.
+
+GRPC stubs could be a bit tedious to write when compared to what the `grpc` gem offers, which is, auto-generation from ruby service stubs from protobuf definitions:
+
+```ruby
+# service generated from the command:
+#
+# > grpc_tools_ruby_protoc -I ../../protos --ruby_out=../lib --grpc_out=../lib ../../protos/route_guide.proto
+#
+require "route_guide_services_pb.rb"
+
+# with httpx, before 0.16
+stub = HTTPX.plugin(:grpc).build_stub("localhost:#{server_port}", service: "RouteGuide")
+                          .rpc(:GetFeature, Point, Feature)
+                          .rpc(:ListFeatures, # ... and so on, all hand stitched
+
+stub.get_feature(# ...
+
+# with httpx 0.16
+stub = HTTPX.plugin(:grpc).build_stub("localhost:#{server_port}", service: RouteGuide)
+# that's it!
+stub.get_feature(# ...
+```
+
+#### no google/protobuf direct dependency
+
+`"google/protobuf"` is no longer assumed when using the plugin, i.e. you can use other protobuf serializers, such as https://github.com/ruby-protobuf/protobuf , which supports `jruby` (unlike the former).
+
+### OptionsMethods for plugins
+
+https://gitlab.com/os85/httpx/-/wikis/Custom-Plugins
+
+You can now define an `OptionsMethods` module under your custom plugin to define your own methods. The tl;dr is, that, given the following module below, a new `:bar` option will be available (and the method will be used to set it):
+
+```ruby
+module CustomPlugin
+  module OptionsMethods
+    def option_bar(x) ; x; end
+  end
+end
+
+HTTPX.plugin(CustomPlugin).with(bar: 2)
+```
+
+### cookies plugin: improved jar management
+
+The behaviour of the cookies jar from the `:cookies` plugin was a bit unpredictable in certain conditions, for instance if a "Cookie" header would be passed directly via `.with(headers: {"Cookie" => "a=1"})` and there'd be a value for it already (in same cases, it'd be fully ignored). This would even get worse, if the session had a jar, and a specific set of cookies would be passed to a request(i.e.: `session_with_cookies.get("http://url.get", headers: {"Cookies" => "..."}`).
+
+The behaviour was fixed, and is now specced under https://gitlab.com/os85/httpx/-/blob/master/test/support/requests/plugins/cookies.rb .
+
+## Bugfixes
+
+* Cookies sorting in the `:cookies` plugin jar was fixed for truffleruby;
+
+## Chore
+
+* errors when setting options nnow raise `TypeError` instead of `HTTPX::Error`.
+* options are now internally frozen by default, which should protect the internals against accidentally updating them;
+* Fixed optimization around options initialization, to prevent needless allocations;

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/doc/release_notes/0_16_1.md

@@ -0,0 +1,5 @@
+# 0.16.1
+
+## Bugfixes
+
+* fixed native resolver hanging when dealing with FQDN end names (#145).

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/doc/release_notes/0_17_0.md

@@ -0,0 +1,49 @@
+# 0.17.0
+
+## Features
+
+### Response mime type decoders (#json, #form)
+
+https://gitlab.com/os85/httpx/-/wikis/Response-Handling#response-decoding
+
+Two new methods, `#json` and `#form`, were added to `HTTPX::Response`. As the name implies, they'll decode the raw payload into ruby objects you can work with.
+
+```ruby
+# after HTTPX.get("https://api.smth/endpoint-returning-json")
+response.json # same as JSON.dump(response.to_s)
+```
+
+Although not yet documented, integrating custom decoders is also possible (i.e. parsing HTML with `nokogiri` or something similar).
+
+## Improvements
+
+### Connection: reduce interest calculations
+
+Due to it being an intensive task, internal interest calculation in connections was reduce to the bare minimum.
+
+### Immutable Options, internal recycling of instances, improves memory usage in the happy path
+
+A lot of effort went into avoiding generating options objects internally whenever necessary. This means, when sending several requests with the same set of options (the most common case in `httpx` usage), internally only one object is passed around. For that, the following improvements were done:
+
+* `Options#merge` returns the same options the the options being merged are a subset of the current set of options (b126938a6547e09b726dd64298fb488891d938e9).
+* `Session#build_request` bypasses instantiation of options if it receives an `Options` object (which happens internally in the happy path, if users don't call `#build_request` directly) (3d549817cb41d4b904102fdc61afe3ecd9170893).
+* Improving internal `Session` APIs to not pass around options, and instead rely on accessing request options.
+* `Options#to_hash` does not build internal garbage arrays anymore (cc02679b804f63798f5d2136a039be1624e96ab6).
+
+### Reduce regexp operations in the HTTP/1 parser
+
+Some code paths in the HTTP/1 parser still using regular expressions were replaced by string operations accomplishing the same.
+
+### HTTP/1 improvements on the complexity of connection accounting calculations
+
+Managing open HTTP/1 connections relies on operations calculating whether there are requests waiting for completion. This relied on traversing all requests for that connectionn (O(n)); it now only checks the completion state of the first and last request of that connection, given that all requests in HTTP/1 are sequential (O(1)); this optimization brings a big improvement to persistent and pipelined requests (65261217b1270913e4bb93717e8b8dcfa775565a).
+
+## Bugfixes
+
+* fixing HTTP/1 protocol uncompliant exposing multiple values for the "Host" header (e435dd0534314508262184fb03d83124d89d2079).
+
+* Custom response finalizer introduced in 0.16.0 has been reverted. It was brought to my attention that `Tempfile` implementation already takes care of the file on GC (and `httpx` was duplicating), and the approach taken in `httpx` was buggy in several ways (not tolerant to forks, never recycled finalizers...) (aa3be21c890f92a41afcc7931f01dd24cc801f7c).
+
+## Chore
+
+RBS Typing improvements based on latest stdlib signatures additions, such as `openssl`, `digest`, `socket` and others.