Gaoxy v0.13.0

Gaoxy 0.13.0

Native WebSock connections default to persistent connections without frame-size,
message-size, fragment-count, callback-batch-count, inactivity or absolute-lifetime
ceilings. Explicit application limits remain supported. Generic service byte and
state budgets no longer cap retained WebSocket messages or callback state;
transport staging, queues and protocol windows stay finite and reusable.

The WebSock API still delivers complete messages, so memory grows with the
message, application state and pending output. Applications that produce data
independently need their own production policy. Protocol validation and mandatory
control-frame limits remain enforced. Callback execution, bounded writes and
normal close retain separate finite deadlines; an operation deadline does not
cover an entire progressing message or output batch.

Phoenix applications must explicitly configure
websocket: [timeout: :infinity] on their socket declarations to obtain
persistent connections. Authentication, Origin checks, heartbeats and deliberate
application close policies remain under application control. The separately
configured message-level Gaoxy.Proxy.WebSocket bridge retains its own policies.
See the capacity and configuration guide.

The H1/H2/H3 persistence goal uses infinite H1 reads after upgrade, H2 owner idle
suspension while WebSockets exist with restoration after the final WebSocket,
and H3 local idle suspension with keepalive below a finite peer idle period.
Hell 0.1.3 supplies the released public Hell.Handler.set_read_timeout/2 API
required for H2. Focused regressions verify quiet persistence, repeated exact
transfers, HTTP siblings, final-owner idle restoration and preservation of finite
partial-frame and explicit application lifetime deadlines.

HTTP/2 startup now treats a confirmed peer closure as a normal stop when setting
TCP/TLS receive options races with disconnect. Bare and SSL-wrapped failures
require confirmation through the supported socket API; live-peer option failures
retain their original error disposition. See the
issue #17 acceptance record.

The dependency cohort includes Hell 0.1.3, Abyss 0.10.0 and the HTTP/TLS/QUIC
packages at 0.21.17. The direct http_core requirement now has a 0.21.17 floor.
Plug.Crypto advances to 2.2.1. All six Hex distributions and the standalone
application use version 0.13.0.

Historical failures and specialist abnormal, slow-peer, pressure and
sustained-load qualification keep their recorded dispositions. See the
issue #16 qualification.

Gaoxy v0.12.2

Gaoxy 0.12.2

An HTTP/1 peer that disconnects after sending request headers can now close
normally while Gaoxy creates the request exchange. Previously, a failed socket
identity lookup could raise MatchError, including for cancelled uploads with
request_timeout: :infinity.

Expected closed-socket errors stop the connection before application dispatch.
Admission ownership and retained bytes are released when the owner exits;
unexpected transport errors retain their error disposition. Successful request
metadata and finite/infinite request deadlines keep their existing behavior.

The regression coverage includes controlled peer/local identity failures and
synchronized real TCP resets, followed by healthy sibling and new requests.
All six Hex distributions and the standalone application advance together to
0.12.2. Dependency requirements and pins are unchanged.

Gaoxy v0.12.1

Gaoxy 0.12.1

Native HTTP/2 uses the documented first-party HTTP.HTTP2.HPACK codec from
http_core >= 0.21.16 instead of HPAX. The integration preserves decoder state,
header bounds and zero-capacity response encoding.

The HTTP/TLS/QUIC dependency cohort advances together to 0.21.16.
The elixir_quic_http3, http_fetch and http_web_socket package requirements
use ~> 0.21 instead of exact pins. The new direct http_core requirement uses
the same compatibility range with a >= 0.21.16 floor.
The unsupported optional flag is removed from the umbrella gaoxy_http3
dependency; the staged gaoxy_test Hex extension remains optional.

All six Hex distributions and the standalone application advance together to
0.12.1.

Gaoxy v0.12.0

Gaoxy 0.12.0

Native H1/H2 storage handlers can explicitly select
http_limits: %{request_timeout: :infinity}. Upload body reads and ordinary
Plug.Conn.send_file responses then outlive the total request deadline while
retaining finite header, read and write limits, bounded transfer windows,
admission budgets, cancellation and shutdown. The default request timeout
remains 30 seconds. This resolves the storage-transfer policy requested in
#13.

This opt-in supports ordinary native/Plug targets, including Endpoint-owned
Phoenix and ListenerSet, on H1/H2. H3 and Generation targets, including managed
gateway targets, reject it with :unsupported_request_timeout, whether direct
or wrapped. Trusted application code without I/O can run
indefinitely under the opt-in and must enforce its own execution/idle policy.
stream_timeout retains its response-only role; :request means the configured
request lifetime, which is infinite when explicitly selected on a supported
listener. See the request lifetime guide.

Two compatibility fixes accompany the new option:

• HEAD preserves validated application Content-Length metadata while omitting
  the body. Without a supplied length it infers the representation length from
  the body. Existing 204/205/304 rules, malformed/duplicate length rejection and
  GET framing remain unchanged
  (#12).
• Phoenix's exact {:shutdown, :disconnected} WebSock stop reason closes with
  1000 and normal termination. Restart remains 1012, arbitrary stop errors
  remain 1011, and explicit close codes remain authoritative
  (#14).

All six Hex distributions and the standalone application advance together to
0.12.0. Use the Gaoxy WebSockAdapter distribution under Phoenix's existing
:websock_adapter dependency key with hex: :gaoxy_websock_adapter and
override: true. Dependency pins and vendor provenance remain unchanged.
This release adds no deployment or specialist pressure/load qualification.

Gaoxy v0.11.1

Gaoxy 0.11.1

Fix HTTP/1 peer-close polling at the inclusive max_buffer_bytes boundary
(#11). A full buffer remains
usable for the next keep-alive request. Polling can still observe pending input
or peer closure; an actual excess byte produces :buffer_limit without growing
the retained input buffer beyond its limit.

Callers must retain the returned Plug.Conn after every poll and abort it on
errors. The excess observation consumes one byte, so :buffer_limit is terminal.
No extra application buffer margin is required. Finite I/O, request and shutdown limits,
service resource accounting and HTTP/2 stream isolation remain in force.

All six Hex distributions and the standalone application advance to 0.11.1.
Dependency versions and vendored upstream provenance are unchanged. This patch
adds no deployment or specialist load/pressure qualification.

Gaoxy v0.11.0

Gaoxy 0.11.0

Gaoxy adds validated backend service tuning for applications migrating from
Bandit's thousand_island_options. Configure TCP/TLS with hell_options and
UDP/QUIC with abyss_options. These entries work through embedded services,
native HTTP/HTTP3, ListenerSet and Phoenix's per-listener configuration. The
old Thousand Island option name is not an alias.

TCP/TLS supports acceptor count, backlog and ordinary socket tuning. Acceptor
connection quotas divide the existing service-wide limits.max_active ceiling;
division remainders are unused. HTTP rejects receive-buffer fields owned by its
protocol limits/profile. UDP supports a shared receive/send buffer size and
IPv4 TOS/TTL. QUIC supports bounded event batches and polling intervals.

The options are checked before binding or endpoint initialization, with explicit
errors for duplicates, unsupported fields, backend mismatches and ownership
overrides. QUIC polling aliases normalize into the canonical service field and
reject conflicting values. Binding, credentials, handlers, resource budgets and
lifecycle remain under Gaoxy control. Omitted options preserve existing defaults.

Real-socket tests cover effective tuning and traffic through direct,
ListenerSet and Phoenix paths, including independent aioquic requests. The
mandatory ordinary composition gate adds all 19 backend-options tests, bringing
the complete repair/compatibility gate from 334 to 353 required cases without
excluding prior cases. Existing Gaoxy.Test functionality and dependency pins
remain unchanged. All six Hex distributions advance together to 0.11.0; the
standalone application uses the same version.

QUIC UDP socket tuning, separate UDP receive/send buffers, arbitrary backend
options and standalone JSON configuration additions are outside this release.
Kernel buffer rounding/clamping and OS socket-option support still apply.

The feature acceptance record preserves
the original verification results and limitations: browser automation was
unavailable, broader core verification observed baseline cancellation-test
instability, and a newer local formatter flagged unchanged files. Release
preparation uses canonical Elixir 1.18.5 and OpenSSL 3. Hosted CI, release
artifacts, publication and browser acceptance require their own recorded
results; this document does not claim they have run. Deployment and specialist
pressure/soak qualification remain separate.

See the configuration support matrix,
Bandit migration guide,
design and implementation plan.

Gaoxy v0.10.0

Gaoxy 0.10.0

Gaoxy.Test adds independently consumable HTTP test fixtures with atomic request
expectations, ordinary Plug handlers, bounded journals and automatic per-test
ExUnit verification. Install {:gaoxy_test, "~> 0.10.0", only: :test}. Manual
mode works without starting ExUnit.

Profiles cover H1, trusted HTTPS, h2c and TLS H2, plus optional H3 with an explicit
aligned gaoxy_http3 dependency. Finite streaming/SSE, established persistent SSE
and H1 WebSocket helpers expose event-driven observations. Extended-CONNECT
WebSockets and Bypass-style down/up are outside this helper's scope.

Callback assertions retain their original stacktraces. Verification survives the
ExUnit teardown boundary; bounded finalization records pending callbacks, session
failures and cleanup uncertainty. A narrow core ownership repair retains handlers
created during listener suspension so a pending TLS handshake cannot escape
forced cleanup.

The ordinary consumer excludes H3/QUIC/ExSSL, proxy and client dependencies. Test
infrastructure stays outside production releases. Isolated extracted-tarball
consumers cover ordinary use, explicit H3, and published HTTPFetch 0.21.14. The
release workflow includes all six aligned Hex distributions and a fresh Hex-only
consumer after publication.

The integrated source preserves 0.9.0's Phoenix migration, stream lifetime,
WebSocket limits and client-certificate work. Raw negative peers and independent
interoperability suites remain intact. Specialist pressure/soak qualification and
deployment remain outside this release.

See the package guide,
design, and
acceptance record for precise capabilities,
commands, source identities, historical failures and publication status. A target
version in source is not evidence of publication.

Gaoxy v0.9.0

Gaoxy 0.9.0

Long-lived SSE responses can explicitly opt out of the ordinary absolute
request deadline. Select http_limits.stream_timeout: :infinity on a listener
or Gaoxy.HTTP.put_stream_timeout(conn, :infinity) for a route before starting
its chunked response. The default remains :request; positive finite stream
lifetimes are also supported. HTTP/1 and HTTP/2 retain finite header, body-read
and individual-write deadlines, admission accounting, cancellation and bounded
shutdown. HTTP/2 streaming remains local to its stream. HTTP/3 does not support
the opt-in. See streaming responses.
Fixes #3 and
#7.

OTP TLS and Phoenix HTTPS listeners accept verify, cacertfile, and
fail_if_no_peer_cert. An enrollment listener can allow clients without a
certificate while verifying any certificate supplied; a required-certificate
listener rejects absence. Trusted DER peer certificates reach HTTP and Phoenix
WebSocket peer data, and forwarded HTTP headers cannot supply TLS identity.
Invalid verification combinations fail explicitly. See
client certificates.
Fixes #5.

WebSocket message capacity now follows the selected max_frame_size when
max_message_size is omitted. Phoenix's accepted frame-size option therefore
supports messages above 256 KiB. Explicit direct-WebSock message limits,
aggregate fragmented-message limits, and the service admission budget remain
authoritative. See WebSocket limits.
Fixes #6 and
#9.

Phoenix-owned WebSocket options log and code_reloader are accepted after
Phoenix applies their policies. Wire-engine settings retain strict validation.
Fixes #8.

The HTTP supervision child preserves the validated instance shutdown budget,
including configured drain time and cleanup headroom.
Fixes #10.

The five Hex distributions and standalone application use coordinated 0.9.0
metadata. Existing dependency pins and vendored adapter source provenance are
retained. The final acceptance record
separates implementation tests, release qualification and publication evidence.

Gaoxy v0.8.0

Gaoxy 0.8.0

One Phoenix Endpoint can now own HTTP/1.1, HTTP/2 and optional HTTP/3 through
Gaoxy.PhoenixAdapter. Configure explicit http3: credentials and binding
beside http: and https:; one ListenerSet initializes the Endpoint once and
owns one core instance. Actual transport addresses, recovery state and
capabilities are inspectable. Native H2/H3 WebSocket CONNECT keeps exact socket
paths, LiveView, Channels and development code reload.

Gaoxy.Proxy.Gateway embeds the managed gateway without gaoxy_server.
Applications declare logical listener sets, share one route generation across
their H1/H2/H3 listeners, reload with an expected accepted revision, inspect
bounded operation receipts, and stop the complete runtime. Stable stores retain
accepted routes and immutable upstream trust through runtime-owner recovery.
Different gateways can reuse logical IDs independently. Standalone JSON v1,
environment/readiness output and file-based reload delegate to the same runtime.

Gaoxy.HTTP.ListenerSet supplies pure declarations and optional providers.
Supported deferred core activation preserves the complete planned resource and
shutdown budgets, owns late startup/rollback and replaces private Instance
startup. Optional readiness-aware Alt-Svc discovery runs before response-header
budget checks for secure H1/H2 native, Plug and proxy final responses, including
streaming. Discovery remains disabled by default.

Existing single-service builders, HTTP defaults and mixed cleartext
H1/prior-knowledge H2 remain supported. H3 requires gaoxy_http3; HTTP and Proxy
do not acquire a reverse dependency. Independent port-zero bindings remain
independent. Unsupported H3 bind/TLS capabilities still fail explicitly. Reload
changes routes, not listener bindings or certificates; complete root/VM loss
returns to the host's startup configuration.

The five Hex distributions and standalone application use coordinated 0.8.0
metadata. See Phoenix configuration,
embedded Gateway APIs,
ListenerSets, and the
acceptance record for
commands, evidence, known baseline failures and publication status. Specialist
pressure/soak qualification and deployment remain outside this release.

Gaoxy v0.7.0

Gaoxy 0.7.0

Native HTTP/1.1 and cleartext HTTP/2 prior knowledge can now share one TCP
listener. Embedded endpoints, Plug, standalone routes and Phoenix HTTP options
all use the same connection-level selection:

transport: :tcp,
protocols: [:http2, :http1],
h2c: :prior_knowledge

Standalone JSON uses "protocols": ["http2", "http1"] and
"h2c": "prior_knowledge". Plain TCP defaults to H1-only and TLS retains
existing ALPN behavior. This enables prior knowledge; HTTP/1.1 Upgrade is not
implemented by this change.

Detection compares the complete 24-byte H2 preface and preserves fragmented,
coalesced, body and pipelined bytes. It retains at most 23 undecided bytes,
reuses one owner admission lease, and fixes first-request/startup deadlines at
the original first byte. Protocol selection never falls back after a parser
error. An absolute startup deadline also prevents a queued timeout from losing
to a late SETTINGS acknowledgment.

The coordinated five Hex distributions and standalone application retain the
existing dependency cohort and publication process. The release smoke now
tests explicit H1 and independent H2 clients simultaneously on the mixed port,
alongside the existing dedicated proxy and transport checks.

Published from 14287f30b83ccec207ffc944867413043cb8f360 through
release workflow 39555029237.
Main CI passed all ten unit, static and foundation jobs on that exact source.
All five Hex packages, seven GitHub assets and six checksum entries were
verified publicly. Clean public consumers passed 10 tests, and the downloaded
standalone passed core (3 transports), gateway (7 exchanges, including 5 mixed)
and H3 compatibility (3 checks). Local downloaded execution on NixOS used the
existing host libraries through an explicit loader path.

The acceptance record
contains commands, exact counts, source identities, immutable publication
receipts and independent review. It also preserves an unrelated existing H1
upload failure with a 4096-byte service budget, reproduced on the baseline;
that body-copy reservation case is
unchanged. Specialist exceptional/pressure/soak qualification and deployment
remain outside this release.