grpc-mojo · differential compliance run

Every layer, checked against the reference implementation

316/316checks passed2026-08-25 23:27 UTC

No self-grading: protobuf binary and JSON behavior is judged by Python protobuf and Google’s official conformance runner, header compression by python-hpack, HTTP/2 by hyper-h2 (which rejects any protocol violation), sockets by CPython, and gRPC behavior by grpcio in both directions. The proto, hpack, h2, and net sections run in each package’s own compliance suite and are aggregated here.

proto 92/92
hpack 5/5
h2 21/21
net 11/11
tls 32/32
grpc 24/24
grpc-tls 16/16
grpc-transport 2/2
grpc-polling 12/12
grpc-polling-tls 5/5
grpc-official 84/84
packaging 6/6
units 2/2
h2_tls 4/4

proto vs Python protobuf and Google's official suite

Randomized binary and proto3 JSON checks compare against Python protobuf. Google's conformance runner executes the supported proto3 binary and JSON groups. Malformed inputs must be accepted or rejected in agreement with those references.

Check	Result
differential decode/re-encode scalars (n=300)	PASS
byte-identical re-encoding scalars (300/300)	PASS
differential decode/re-encode nested (n=150)	PASS
recursion depth limit agrees with protobuf (60 ok, 150 rejected)	PASS
malformed-input agreement with protobuf (6/6)	PASS
proto3 JSON parse differential, flat primitives (n=300)	PASS
proto3 JSON print differential, flat primitives (n=300)	PASS
proto3 JSON parse differential, singular nested messages (n=200)	PASS
proto3 JSON print differential, singular nested messages (n=200)	PASS
proto3 JSON parse differential, repeated primitives and enums (n=200, seed=20260825)	PASS
proto3 JSON print differential, repeated primitives and enums (n=200, seed=20260825)	PASS
proto3 JSON repeated accepted-edge agreement (10/10)	PASS
proto3 JSON repeated rejection agreement (10/10)	PASS
proto3 JSON repeated unknown enum name handling	PASS
proto3 JSON parse differential, repeated messages (n=200, seed=20260825)	PASS
proto3 JSON print differential, repeated messages (n=200, seed=20260825)	PASS
proto3 JSON repeated message accepted-edge agreement (6/6)	PASS
proto3 JSON repeated message rejection agreement (6/6)	PASS
proto3 JSON repeated message unknown field handling	PASS
proto3 JSON parse differential, string-key maps (n=200, seed=20260825)	PASS
proto3 JSON print differential, string-key maps (n=200, seed=20260825)	PASS
proto3 JSON string-key map accepted-edge agreement (8/8)	PASS
proto3 JSON string-key map rejection agreement (8/8)	PASS
proto3 JSON string-key map unknown enum name handling	PASS
proto3 JSON parse differential, integer and boolean map keys (n=200, seed=20260825)	PASS
proto3 JSON print differential, integer and boolean map keys (n=200, seed=20260825)	PASS
proto3 JSON integer and boolean map key accepted-edge agreement (8/8)	PASS
proto3 JSON integer and boolean map key rejection agreement (8/8)	PASS
proto3 JSON parse differential, message-valued maps (n=200, seed=20260825)	PASS
proto3 JSON print differential, message-valued maps (n=200, seed=20260825)	PASS
proto3 JSON message-valued map accepted-edge agreement (6/6)	PASS
proto3 JSON message-valued map rejection agreement (6/6)	PASS
proto3 JSON message-valued map unknown field handling	PASS
proto3 JSON parse differential, oneof fields (n=200, seed=20260825)	PASS
proto3 JSON print differential, oneof fields (n=200, seed=20260825)	PASS
proto3 JSON oneof accepted-edge agreement (10/10)	PASS
proto3 JSON oneof rejection agreement (8/8)	PASS
proto3 JSON oneof unknown enum name handling	PASS
proto3 JSON parse differential, optional fields (n=200, seed=20260825)	PASS
proto3 JSON print differential, optional fields (n=200, seed=20260825)	PASS
proto3 JSON optional accepted-edge agreement (10/10)	PASS
proto3 JSON optional rejection agreement (8/8)	PASS
proto3 JSON optional unknown enum name handling	PASS
proto3 JSON google.protobuf.Empty direct agreement (4/4)	PASS
proto3 JSON google.protobuf.Empty field parse agreement (3/3)	PASS
proto3 JSON google.protobuf.Empty field print agreement (2/2)	PASS
proto3 JSON google.protobuf.Empty rejection agreement (4/4)	PASS
proto3 JSON wrapper direct agreement (6/6)	PASS
proto3 JSON parse differential, wrapper fields (n=200, seed=20260825)	PASS
proto3 JSON print differential, wrapper fields (n=200, seed=20260825)	PASS
proto3 JSON wrapper accepted-edge agreement (12/12)	PASS
proto3 JSON wrapper rejection agreement (10/10)	PASS
proto3 JSON Timestamp direct agreement (10/10)	PASS
proto3 JSON parse differential, Timestamp fields (n=200, seed=20260825)	PASS
proto3 JSON print differential, Timestamp fields (n=200, seed=20260825)	PASS
proto3 JSON Timestamp accepted-edge agreement (15/15)	PASS
proto3 JSON Timestamp rejection agreement (14/14)	PASS
proto3 JSON Duration direct agreement (12/12)	PASS
proto3 JSON parse differential, Duration fields (n=200, seed=20260825)	PASS
proto3 JSON print differential, Duration fields (n=200, seed=20260825)	PASS
proto3 JSON Duration accepted-edge agreement (12/12)	PASS
proto3 JSON Duration rejection agreement (10/10)	PASS
proto3 JSON FieldMask direct agreement (11/11)	PASS
proto3 JSON parse differential, FieldMask fields (n=200, seed=20260825)	PASS
proto3 JSON print differential, FieldMask fields (n=200, seed=20260825)	PASS
proto3 JSON FieldMask accepted-edge agreement (12/12)	PASS
proto3 JSON FieldMask rejection agreement (10/10)	PASS
proto3 JSON parse differential, recursive messages (n=200, seed=20260825)	PASS
proto3 JSON print differential, recursive messages (n=200, seed=20260825)	PASS
proto3 JSON recursive accepted-edge agreement (8/8)	PASS
proto3 JSON recursive rejection and depth-limit agreement (10/10)	PASS
proto3 JSON parse differential, Struct family fields (n=200, seed=20260825)	PASS
proto3 JSON print differential, Struct family fields (n=200, seed=20260825)	PASS
proto3 JSON Struct, Value, and ListValue direct agreement (18/18)	PASS
proto3 JSON Struct family accepted-edge agreement (17/17)	PASS
proto3 JSON Struct family rejection agreement (18/18)	PASS
proto3 JSON parse differential, descriptor message fields (n=200, seed=20260825)	PASS
proto3 JSON print differential, descriptor message fields (n=200, seed=20260825)	PASS
proto3 JSON descriptor message accepted-edge agreement (10/10)	PASS
proto3 JSON descriptor message rejection agreement (10/10)	PASS
proto3 JSON parse differential, Any messages (n=200, seed=20260825)	PASS
proto3 JSON print differential, Any messages (n=200, seed=20260825)	PASS
proto3 JSON Any accepted-edge agreement (12/12)	PASS
proto3 JSON Any rejection agreement (9/9)	PASS
proto3 JSON accepted-edge agreement (20/20)	PASS
proto3 JSON rejection agreement (31/31)	PASS
proto3 JSON parse differential, singular enums (n=200, seed=20260824)	PASS
proto3 JSON print differential, singular enums (n=200, seed=20260824)	PASS
proto3 JSON enum accepted-edge agreement (7/7)	PASS
proto3 JSON enum rejection agreement (6/6)	PASS
proto3 JSON unknown enum name handling	PASS
Google conformance, proto3 binary wire format and JSON (1476 passed, 0 failed; 1303 proto2 cases skipped, declared unsupported)	PASS

hpack vs python-hpack

Sequential header blocks encoded by one implementation and decoded by the other, in both directions, with dynamic-table state carried across blocks. Plus RFC 7541 Appendix C unit vectors (see `units`).

Check	Result
python-hpack encode -> mojo decode (46 blocks, shared dynamic table)	PASS
mojo encode -> python-hpack decode (46 blocks)	PASS
compression ratio sanity (mojo 2821B vs python 2823B, within 25%)	PASS
dynamic table size updates mid-stream (python-hpack -> mojo)	PASS
multibyte UTF-8 header values roundtrip (python -> mojo)	PASS

h2 vs hyper-h2 / hyperframe / h2spec

Frame codec cross-checked byte-for-byte against hyperframe in both directions. Live connections run against hyper-h2, which raises ProtocolError on any protocol violation by the peer. h2spec (the standard RFC 9113/7541 conformance tool) runs its full suite against our server.

Check	Result
parse hyperframe-built frames (all 10 types, 12 cases)	PASS
byte-identical frame serialization vs hyperframe (12 cases)	PASS
incremental decode at every split point (15 plans)	PASS
one-byte chunks preserve 7 hyperframe frames	PASS
coalesced input preserves 7 hyperframe frames	PASS
seeded fragmentation of a 16 KiB hyperframe DATA frame	PASS
incomplete hyperframe suffix is retained without early output	PASS
connection startup accepts hyper-h2 bytes at every split point (76 plans)	PASS
one-byte startup feeds preserve all 75 hyper-h2 bytes	PASS
one-frame dispatch budget preserves hyperframe wire order and hyper-h2 output	PASS
process_frame reassembles hyper-h2 header blocks across one or more CONTINUATION frames	PASS
process_frame preserves HPACK state and bounds live state across 4096 retired hyper-h2 streams	PASS
process_frame queues SETTINGS and PING acknowledgements matching hyper-h2	PASS
process_frame matches hyper-h2 rejection of illegal CONTINUATION sequences	PASS
queued HEADERS and flow-controlled DATA are accepted by hyper-h2	PASS
hyperframe decodes client startup with SETTINGS_ENABLE_PUSH=0	PASS
hyperframe-built ENABLE_PUSH frames obey endpoint role rules	PASS
mojo client vs hyper-h2 server (200KB echo, strict validation)	PASS
mojo client reassembles HEADERS+CONTINUATION (32KB header block) and padded DATA	PASS
hyper-h2 client vs mojo server (50KB echo, strict validation)	PASS
h2spec cleartext full run (146 tests, 146 passed, 0 skipped, 0 failed)	PASS

net vs CPython sockets

1 MiB echo in both directions between grpc-mojo TCP and CPython sockets, including half-close (shutdown) and clean-EOF semantics.

Check	Result
mojo TCP server echoes 1MiB to python client + EOF semantics	PASS
mojo TCP client 1MiB roundtrip vs python server + EOF check	PASS
resolve() agrees with CPython getaddrinfo for localhost	PASS
mojo UDP exchange vs CPython socket (send, recv, sender addr)	PASS
mojo IPv6 TCP client 100KB roundtrip vs python ::1 server	PASS
mojo unix-socket server echoes 1MiB to CPython AF_UNIX client	PASS
mojo unix-socket client 1MiB roundtrip vs CPython server	PASS
one Poller event loop drains and echoes a burst of 20 CPython clients	PASS
Poller readiness sequence matches CPython selectors	PASS
ReadinessStream TCP partial I/O matches CPython sockets	PASS
ReadinessStream Unix partial I/O matches CPython AF_UNIX	PASS

tls vs CPython ssl

Live TLS connections with CPython on the other end in both roles: version negotiation, ALPN agreement and no-overlap behavior, chain and hostname verification, bulk transfer, and a bad-certificate corpus both implementations must reject.

Check	Result
mojo client vs CPython server: TLSv1.3, ALPN h2, 256KB echo	PASS
Mojo client copies the verified CPython server leaf and typed SANs under TLS 1.3	PASS
Mojo client copies the verified CPython server leaf and typed SANs under TLS 1.2	PASS
Mojo server copies the verified CPython client leaf and typed SANs under TLS 1.3	PASS
Mojo server copies the verified CPython client leaf and typed SANs under TLS 1.2	PASS
Mojo server reports no peer certificate when CPython sends none	PASS
Mojo does not mark a CPython certificate verified when verification is disabled	PASS
nonblocking Mojo client presents a trusted certificate chain to CPython	PASS
CPython rejects a Mojo client without a required certificate	PASS
CPython rejects an untrusted Mojo client certificate	PASS
CPython rejects a Mojo client certificate with server-only usage	PASS
both reject a mismatched client certificate and key before connect	PASS
encrypted client keys are rejected without an interactive prompt	PASS
Mojo server accepts a trusted CPython client certificate chain under TLS 1.3	PASS
Mojo server rejects a CPython client without a required certificate under TLS 1.3	PASS
Mojo server rejects an untrusted CPython client certificate under TLS 1.3	PASS
Mojo server rejects a CPython client certificate with server-only usage under TLS 1.3	PASS
Mojo server accepts a trusted CPython client certificate chain under TLS 1.2	PASS
Mojo server rejects a CPython client without a required certificate under TLS 1.2	PASS
mojo client negotiates TLSv1.2 with a 1.2-capped server	PASS
CPython verifying client vs mojo server: chain, hostname, ALPN, echo	PASS
both reject an untrusted (self-signed) certificate	PASS
both reject a hostname mismatch on a CA-signed certificate	PASS
ALPN no overlap: our server alerts fatally, our client tolerates a server that proceeds without	PASS
nonblocking Mojo handshake matches CPython TLS and ALPN	PASS
partial Mojo TLS writes match CPython	PASS
partial Mojo TLS reads preserve WANT_READ against CPython	PASS
Mojo TLS write preserves WANT_WRITE under CPython backpressure	PASS
clean close_notify returns EOF in Mojo and CPython	PASS
truncated TLS transport is rejected by Mojo and CPython	PASS
fatal session teardown does not contaminate the next nonblocking TLS session	PASS
reset peers with rejected ALPN do not terminate the server	PASS

grpc vs grpcio

Behavioral compliance against the reference gRPC implementation in both directions: status-code mapping (all 16 codes), unicode/percent status details, ascii and binary (-bin) metadata in requests, initial response metadata and trailers, deadline (grpc-timeout) propagation, empty and 1 MB messages, sequential calls.

Check	Result
status-code mapping, all 16 codes + unicode/percent details	PASS
request ascii metadata delivered	PASS
request binary metadata (-bin) delivered	PASS
initial response metadata received	PASS
trailing metadata received	PASS
trailing binary metadata decoded	PASS
grpc-timeout propagated to grpcio deadline (2500ms sent)	PASS
1MB unary echo via grpcio server	PASS
empty message echo via grpcio server	PASS
unicode payload echo via grpcio server	PASS
rich error model: grpc-status-details-bin decoded from grpcio	PASS
client deadline enforced vs sleeping server (300ms -> DEADLINE_EXCEEDED)	PASS
grpcio client: 1MB echo through mojo server	PASS
grpcio client: empty message through mojo server	PASS
blocking h2c handler receives no peer certificate	PASS
grpcio deadline decoded by mojo server (3s sent)	PASS
grpcio client metadata (ascii + -bin) visible in mojo handler	PASS
mojo server initial response metadata	PASS
mojo server trailing metadata	PASS
mojo server binary trailing metadata (-bin, unpadded emit)	PASS
mojo handler error -> grpcio UNKNOWN + unicode details	PASS
mojo server rich error (grpc-status-details-bin)	PASS
unknown method -> UNIMPLEMENTED trailers-only	PASS
10 sequential calls on one connection	PASS

grpc over TLS vs grpcio

TLS connections run in both directions with strict certificate verification and h2 ALPN negotiation. Client and server identity checks cover a trusted chain, no client certificate, and an untrusted certificate. Payloads cross the reference boundary through grpcio and grpc-mojo.

Check	Result
Mojo polling TLS server: trusted grpcio identity completes a 64 KiB echo	PASS
Mojo polling TLS server: handler receives the verified grpcio client leaf and typed subject alternative names	PASS
Mojo polling TLS server: missing grpcio identity is rejected before handler dispatch	PASS
Mojo polling TLS server: untrusted grpcio identity is rejected before handler dispatch	PASS
Mojo polling TLS server: trusted identity recovers after rejected handshakes	PASS
Mojo TLS client: 64 KiB unary echo via grpcio server	PASS
Mojo TLS client rejects a grpcio certificate hostname mismatch	PASS
Mojo client certificate: trusted identity completes a 64 KiB grpcio echo	PASS
Mojo client certificate: missing identity is rejected before handler dispatch	PASS
Mojo client certificate: untrusted identity is rejected before handler dispatch	PASS
grpcio TLS client: unary echo via Mojo server	PASS
Mojo TLS server: trusted grpcio identity completes a 64 KiB echo	PASS
Mojo TLS server: handler receives the verified grpcio client leaf and typed subject alternative names	PASS
Mojo TLS server: missing grpcio identity is rejected before handler dispatch	PASS
Mojo TLS server: untrusted grpcio identity is rejected before handler dispatch	PASS
Mojo TLS server: trusted identity recovers after rejected handshakes	PASS

GrpcTransport vs CPython sockets and ssl

The readiness wrapper transfers a large payload through CPython TCP and TLS peers with partial reads, partial writes, and would-block handling. TLS retries preserve the direction reported by OpenSSL across same-operation retries.

Check	Result
h2c partial I/O and would-block match CPython sockets	PASS
TLS partial I/O preserves OpenSSL-reported retry direction	PASS

PollingServer with grpcio and hyper-h2 external peers

Independent grpcio processes exercise supported unary behavior, while hyper-h2 drives edge cases and stricter policy grounded in the gRPC HTTP/2 wire grammar. The checks cover configured output limits, fairness, deadlines, rejected-request isolation, connection-cap recovery, half-close ordering, and retired stream ids.

Check	Result
16 grpcio processes complete 25 unary calls each while a partial preface stalls	PASS
1 MiB grpcio unary response completes with a 64 KiB configured output limit	PASS
grpcio observes empty unary, metadata, trailers, and handler UNKNOWN	PASS
polling h2c handler receives no peer certificate	PASS
an expired large response with a stalled reader does not spin the loop	PASS
all four internal gRPC prefix split boundaries complete	PASS
wire grammar rejects compressed, multiple, and truncated unary input	PASS
protocol grammar enforces POST, content type, and registered routes	PASS
idle grpc-timeout wakes the poller before invoking the handler	PASS
readable final bytes beat FIN and truncated FIN skips the handler	PASS
idle and incomplete peers leave a full cap, and 1 KiB emits both statuses	PASS
oversized input recovers with one-frame turns and retired ids stay closed	PASS

PollingServer TLS with grpcio and CPython ssl peers

Independent grpcio processes and CPython ssl exercise non-blocking TLS handshakes, strict h2 ALPN, certificate verification, handshake-cap recovery, large responses, and output backpressure.

Check	Result
8 grpcio TLS processes and a 1 MiB unary call complete beside a stalled handshake	PASS
idle TLS grpc-timeout writes a deadline response without more peer input	PASS
TLS output backpressure does not spin or starve a healthy grpcio call	PASS
ALPN, hostname, and trust failures are isolated from later TLS RPCs	PASS
absolute handshake timeout frees a full connection cap without attacker closes	PASS

Official gRPC interoperability vs grpcio

All 14 canonical interoperability cases run with grpc-mojo in both client and server roles over h2c, verified TLS, and Unix domain sockets. These rows and the published badge come from the same machine-readable result document.

Check	Result
grpc-mojo client vs grpcio server (h2c): empty_unary	PASS
grpc-mojo client vs grpcio server (h2c): large_unary	PASS
grpc-mojo client vs grpcio server (h2c): client_streaming	PASS
grpc-mojo client vs grpcio server (h2c): server_streaming	PASS
grpc-mojo client vs grpcio server (h2c): ping_pong	PASS
grpc-mojo client vs grpcio server (h2c): empty_stream	PASS
grpc-mojo client vs grpcio server (h2c): custom_metadata	PASS
grpc-mojo client vs grpcio server (h2c): status_code_and_message	PASS
grpc-mojo client vs grpcio server (h2c): special_status_message	PASS
grpc-mojo client vs grpcio server (h2c): unimplemented_method	PASS
grpc-mojo client vs grpcio server (h2c): timeout_on_sleeping_server	PASS
grpc-mojo client vs grpcio server (h2c): cancel_after_begin	PASS
grpc-mojo client vs grpcio server (h2c): client_compressed_unary	PASS
grpc-mojo client vs grpcio server (h2c): server_compressed_unary	PASS
grpc-mojo client vs grpcio server (TLS): empty_unary	PASS
grpc-mojo client vs grpcio server (TLS): large_unary	PASS
grpc-mojo client vs grpcio server (TLS): client_streaming	PASS
grpc-mojo client vs grpcio server (TLS): server_streaming	PASS
grpc-mojo client vs grpcio server (TLS): ping_pong	PASS
grpc-mojo client vs grpcio server (TLS): empty_stream	PASS
grpc-mojo client vs grpcio server (TLS): custom_metadata	PASS
grpc-mojo client vs grpcio server (TLS): status_code_and_message	PASS
grpc-mojo client vs grpcio server (TLS): special_status_message	PASS
grpc-mojo client vs grpcio server (TLS): unimplemented_method	PASS
grpc-mojo client vs grpcio server (TLS): timeout_on_sleeping_server	PASS
grpc-mojo client vs grpcio server (TLS): cancel_after_begin	PASS
grpc-mojo client vs grpcio server (TLS): client_compressed_unary	PASS
grpc-mojo client vs grpcio server (TLS): server_compressed_unary	PASS
grpc-mojo client vs grpcio server (Unix): empty_unary	PASS
grpc-mojo client vs grpcio server (Unix): large_unary	PASS
grpc-mojo client vs grpcio server (Unix): client_streaming	PASS
grpc-mojo client vs grpcio server (Unix): server_streaming	PASS
grpc-mojo client vs grpcio server (Unix): ping_pong	PASS
grpc-mojo client vs grpcio server (Unix): empty_stream	PASS
grpc-mojo client vs grpcio server (Unix): custom_metadata	PASS
grpc-mojo client vs grpcio server (Unix): status_code_and_message	PASS
grpc-mojo client vs grpcio server (Unix): special_status_message	PASS
grpc-mojo client vs grpcio server (Unix): unimplemented_method	PASS
grpc-mojo client vs grpcio server (Unix): timeout_on_sleeping_server	PASS
grpc-mojo client vs grpcio server (Unix): cancel_after_begin	PASS
grpc-mojo client vs grpcio server (Unix): client_compressed_unary	PASS
grpc-mojo client vs grpcio server (Unix): server_compressed_unary	PASS
grpcio client vs grpc-mojo server (h2c): empty_unary	PASS
grpcio client vs grpc-mojo server (h2c): large_unary	PASS
grpcio client vs grpc-mojo server (h2c): client_streaming	PASS
grpcio client vs grpc-mojo server (h2c): server_streaming	PASS
grpcio client vs grpc-mojo server (h2c): ping_pong	PASS
grpcio client vs grpc-mojo server (h2c): empty_stream	PASS
grpcio client vs grpc-mojo server (h2c): custom_metadata	PASS
grpcio client vs grpc-mojo server (h2c): status_code_and_message	PASS
grpcio client vs grpc-mojo server (h2c): special_status_message	PASS
grpcio client vs grpc-mojo server (h2c): unimplemented_method	PASS
grpcio client vs grpc-mojo server (h2c): timeout_on_sleeping_server	PASS
grpcio client vs grpc-mojo server (h2c): cancel_after_begin	PASS
grpcio client vs grpc-mojo server (h2c): client_compressed_unary	PASS
grpcio client vs grpc-mojo server (h2c): server_compressed_unary	PASS
grpcio client vs grpc-mojo server (TLS): empty_unary	PASS
grpcio client vs grpc-mojo server (TLS): large_unary	PASS
grpcio client vs grpc-mojo server (TLS): client_streaming	PASS
grpcio client vs grpc-mojo server (TLS): server_streaming	PASS
grpcio client vs grpc-mojo server (TLS): ping_pong	PASS
grpcio client vs grpc-mojo server (TLS): empty_stream	PASS
grpcio client vs grpc-mojo server (TLS): custom_metadata	PASS
grpcio client vs grpc-mojo server (TLS): status_code_and_message	PASS
grpcio client vs grpc-mojo server (TLS): special_status_message	PASS
grpcio client vs grpc-mojo server (TLS): unimplemented_method	PASS
grpcio client vs grpc-mojo server (TLS): timeout_on_sleeping_server	PASS
grpcio client vs grpc-mojo server (TLS): cancel_after_begin	PASS
grpcio client vs grpc-mojo server (TLS): client_compressed_unary	PASS
grpcio client vs grpc-mojo server (TLS): server_compressed_unary	PASS
grpcio client vs grpc-mojo server (Unix): empty_unary	PASS
grpcio client vs grpc-mojo server (Unix): large_unary	PASS
grpcio client vs grpc-mojo server (Unix): client_streaming	PASS
grpcio client vs grpc-mojo server (Unix): server_streaming	PASS
grpcio client vs grpc-mojo server (Unix): ping_pong	PASS
grpcio client vs grpc-mojo server (Unix): empty_stream	PASS
grpcio client vs grpc-mojo server (Unix): custom_metadata	PASS
grpcio client vs grpc-mojo server (Unix): status_code_and_message	PASS
grpcio client vs grpc-mojo server (Unix): special_status_message	PASS
grpcio client vs grpc-mojo server (Unix): unimplemented_method	PASS
grpcio client vs grpc-mojo server (Unix): timeout_on_sleeping_server	PASS
grpcio client vs grpc-mojo server (Unix): cancel_after_begin	PASS
grpcio client vs grpc-mojo server (Unix): client_compressed_unary	PASS
grpcio client vs grpc-mojo server (Unix): server_compressed_unary	PASS

Extraction isolation

Each package is staged into a scratch directory with only its declared dependencies (docs/ARCHITECTURE.md), then compiled and executed there. A package that reaches outside its dependency set fails this check. This is the mechanical proof behind independent open-sourcing.

Check	Result
`net` builds and runs staged with stdlib only	PASS
`hpack` builds and runs staged with stdlib only	PASS
`proto` builds and runs staged with stdlib only	PASS
`tls` builds and runs staged with net	PASS
`h2` builds and runs staged with hpack + net + tls	PASS
`grpc` builds and runs staged with h2 + hpack + net + proto + tls	PASS

Spec-vector unit suites

The repo's unit tests are themselves reference-anchored: protobuf goldens generated by Python protobuf, all RFC 7541 Appendix C vectors, and the grpcio interop suite.

Check	Result
unit test files (30/30 test files passed)	PASS
interop suite (interop: 7 passed, 0 failed)	PASS

h2_tls

Check	Result
mojo client vs CPython ssl + hyper-h2 server (80KB echo, ALPN h2)	PASS
CPython ssl + hyper-h2 client vs mojo server (verified TLS, ALPN h2)	PASS
both HTTP/2 roles reject TLS connections without negotiated h2 ALPN	PASS
h2spec TLS full run (146 tests, 146 passed, 0 skipped, 0 failed)	PASS

Environment

mojo	Mojo 1.0.0 (ed45d567)
python	3.14.6
protobuf (reference for proto)	7.35.1
grpcio (reference for grpc)	1.83.0
hpack (reference for hpack)	4.2.0
h2/hyper-h2 (reference for h2)	4.4.1
hyperframe (reference for h2 frames)	6.1.0
platform	Darwin 27.0.0 arm64

Known gaps (tracked, not silent)

Compression: mojo-zlib exists, but grpc-encoding gzip integration remains pending (PRIMITIVES.md #4). Published mojo-zlib depends on nightly Mojo, not 1.0. Compressed messages are rejected, never mis-decoded.
Concurrency: PollingServer overlaps bounded h2c or TLS connection I/O; handlers remain serialized. Streaming handlers run to completion on the poll thread (PRIMITIVES.md #7).
Control plane: Keepalive PINGs on the blocking Server wait on Mojo threads or a public async runtime. PollingServer.request_stop() sends GOAWAY and drains on the event-loop thread. Configurable HTTP/2 initial_window_size already ships.
hpack value encoding: header values are UTF-8 Strings; arbitrary octets are out of scope for now (gRPC uses base64 -bin metadata).

Generated by test/compliance/run_compliance.py · rerun with pixi run compliance · canonical copy: docs/COMPLIANCE.md