Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Enforce maximum payload size #279

Open
wants to merge 1 commit into
base: 10-23-Encode_messages_before_storing_in_send_buffer
Choose a base branch
from

Enforce maximum payload size

0908b4d
Select commit
Loading
Failed to load commit list.
Sign in for the full log view
Open

Enforce maximum payload size #279

Enforce maximum payload size
0908b4d
Select commit
Loading
Failed to load commit list.
GitHub Actions / Test Report (macos-latest) succeeded Oct 24, 2024 in 1s

507 passed, 0 failed and 1 skipped

Tests passed successfully

✅ ./test-results.xml

508 tests were completed in 14s with 507 passed, 0 failed and 1 skipped.

Test suite Passed Failed Skipped Time
tests/cancellation.test.ts 64✅ 925ms
tests/cleanup.test.ts 36✅ 2s
tests/context.test.ts 2✅ 62ms
tests/disconnects.test.ts 16✅ 890ms
tests/e2e.test.ts 88✅ 6s
tests/handler.test.ts 10✅ 829ms
tests/invalid-request.test.ts 13✅ 143ms
tests/max-payload-size.test.ts 4✅ 196ms
tests/negative.test.ts 6✅ 54ms
tests/serialize.test.ts 5✅ 13ms
tests/streams.test.ts 25✅ 54ms
tests/typescript-stress.test.ts 17✅ 1⚪ 17ms
codec/codec.test.ts 14✅ 5ms
testUtil/duplex/duplexPair.test.ts 1✅ 3ms
testUtil/observable/observable.test.ts 4✅ 3ms
tracing/tracing.test.ts 9✅ 298ms
transport/events.test.ts 5✅ 4ms
transport/impls/ws/ws.test.ts 5✅ 554ms
transport/message.test.ts 7✅ 3ms
transport/rateLimit.test.ts 8✅ 3ms
transport/sessionStateMachine/stateMachine.test.ts 70✅ 53ms
transport/transforms/messageFraming.test.ts 6✅ 8ms
transport/transport.test.ts 92✅ 10s

✅ tests/cancellation.test.ts

✅ clean handler cancellation ('ws' transport, 'naive' codec) > e2e > rpc
✅ clean handler cancellation ('ws' transport, 'naive' codec) > e2e > stream
✅ clean handler cancellation ('ws' transport, 'naive' codec) > e2e > upload
✅ clean handler cancellation ('ws' transport, 'naive' codec) > e2e > subscribe
✅ clean handler cancellation ('ws' transport, 'binary' codec) > e2e > rpc
✅ clean handler cancellation ('ws' transport, 'binary' codec) > e2e > stream
✅ clean handler cancellation ('ws' transport, 'binary' codec) > e2e > upload
✅ clean handler cancellation ('ws' transport, 'binary' codec) > e2e > subscribe
✅ clean handler cancellation ('mock' transport, 'naive' codec) > e2e > rpc
✅ clean handler cancellation ('mock' transport, 'naive' codec) > e2e > stream
✅ clean handler cancellation ('mock' transport, 'naive' codec) > e2e > upload
✅ clean handler cancellation ('mock' transport, 'naive' codec) > e2e > subscribe
✅ clean handler cancellation ('mock' transport, 'binary' codec) > e2e > rpc
✅ clean handler cancellation ('mock' transport, 'binary' codec) > e2e > stream
✅ clean handler cancellation ('mock' transport, 'binary' codec) > e2e > upload
✅ clean handler cancellation ('mock' transport, 'binary' codec) > e2e > subscribe
✅ client initiated cancellation ('ws' transport, 'naive' codec) > e2e > rpc
✅ client initiated cancellation ('ws' transport, 'naive' codec) > e2e > stream
✅ client initiated cancellation ('ws' transport, 'naive' codec) > e2e > upload
✅ client initiated cancellation ('ws' transport, 'naive' codec) > e2e > subscribe
✅ client initiated cancellation ('ws' transport, 'binary' codec) > e2e > rpc
✅ client initiated cancellation ('ws' transport, 'binary' codec) > e2e > stream
✅ client initiated cancellation ('ws' transport, 'binary' codec) > e2e > upload
✅ client initiated cancellation ('ws' transport, 'binary' codec) > e2e > subscribe
✅ client initiated cancellation ('mock' transport, 'naive' codec) > e2e > rpc
✅ client initiated cancellation ('mock' transport, 'naive' codec) > e2e > stream
✅ client initiated cancellation ('mock' transport, 'naive' codec) > e2e > upload
✅ client initiated cancellation ('mock' transport, 'naive' codec) > e2e > subscribe
✅ client initiated cancellation ('mock' transport, 'binary' codec) > e2e > rpc
✅ client initiated cancellation ('mock' transport, 'binary' codec) > e2e > stream
✅ client initiated cancellation ('mock' transport, 'binary' codec) > e2e > upload
✅ client initiated cancellation ('mock' transport, 'binary' codec) > e2e > subscribe
✅ server explicit cancellation ('ws' transport, 'naive' codec) > e2e > rpc
✅ server explicit cancellation ('ws' transport, 'naive' codec) > e2e > stream
✅ server explicit cancellation ('ws' transport, 'naive' codec) > e2e > upload
✅ server explicit cancellation ('ws' transport, 'naive' codec) > e2e > subscribe
✅ server explicit cancellation ('ws' transport, 'binary' codec) > e2e > rpc
✅ server explicit cancellation ('ws' transport, 'binary' codec) > e2e > stream
✅ server explicit cancellation ('ws' transport, 'binary' codec) > e2e > upload
✅ server explicit cancellation ('ws' transport, 'binary' codec) > e2e > subscribe
✅ server explicit cancellation ('mock' transport, 'naive' codec) > e2e > rpc
✅ server explicit cancellation ('mock' transport, 'naive' codec) > e2e > stream
✅ server explicit cancellation ('mock' transport, 'naive' codec) > e2e > upload
✅ server explicit cancellation ('mock' transport, 'naive' codec) > e2e > subscribe
✅ server explicit cancellation ('mock' transport, 'binary' codec) > e2e > rpc
✅ server explicit cancellation ('mock' transport, 'binary' codec) > e2e > stream
✅ server explicit cancellation ('mock' transport, 'binary' codec) > e2e > upload
✅ server explicit cancellation ('mock' transport, 'binary' codec) > e2e > subscribe
✅ handler uncaught exception error cancellation ('ws' transport, 'naive' codec) > e2e > rpc
✅ handler uncaught exception error cancellation ('ws' transport, 'naive' codec) > e2e > stream
✅ handler uncaught exception error cancellation ('ws' transport, 'naive' codec) > e2e > upload
✅ handler uncaught exception error cancellation ('ws' transport, 'naive' codec) > e2e > subscribe
✅ handler uncaught exception error cancellation ('ws' transport, 'binary' codec) > e2e > rpc
✅ handler uncaught exception error cancellation ('ws' transport, 'binary' codec) > e2e > stream
✅ handler uncaught exception error cancellation ('ws' transport, 'binary' codec) > e2e > upload
✅ handler uncaught exception error cancellation ('ws' transport, 'binary' codec) > e2e > subscribe
✅ handler uncaught exception error cancellation ('mock' transport, 'naive' codec) > e2e > rpc
✅ handler uncaught exception error cancellation ('mock' transport, 'naive' codec) > e2e > stream
✅ handler uncaught exception error cancellation ('mock' transport, 'naive' codec) > e2e > upload
✅ handler uncaught exception error cancellation ('mock' transport, 'naive' codec) > e2e > subscribe
✅ handler uncaught exception error cancellation ('mock' transport, 'binary' codec) > e2e > rpc
✅ handler uncaught exception error cancellation ('mock' transport, 'binary' codec) > e2e > stream
✅ handler uncaught exception error cancellation ('mock' transport, 'binary' codec) > e2e > upload
✅ handler uncaught exception error cancellation ('mock' transport, 'binary' codec) > e2e > subscribe

✅ tests/cleanup.test.ts

✅ procedures should clean up after themselves ('ws' transport, 'naive' codec) > closing a transport from the client cleans up connection on the server
✅ procedures should clean up after themselves ('ws' transport, 'naive' codec) > closing a transport from the server cleans up connection on the client
✅ procedures should clean up after themselves ('ws' transport, 'naive' codec) > rpc
✅ procedures should clean up after themselves ('ws' transport, 'naive' codec) > stream
✅ procedures should clean up after themselves ('ws' transport, 'naive' codec) > cancellation after transport close
✅ procedures should clean up after themselves ('ws' transport, 'naive' codec) > subscription
✅ procedures should clean up after themselves ('ws' transport, 'naive' codec) > upload
✅ procedures should clean up after themselves ('ws' transport, 'naive' codec) > shouldn't send messages across stale sessions
✅ procedures should clean up after themselves ('ws' transport, 'binary' codec) > closing a transport from the client cleans up connection on the server
✅ procedures should clean up after themselves ('ws' transport, 'binary' codec) > closing a transport from the server cleans up connection on the client
✅ procedures should clean up after themselves ('ws' transport, 'binary' codec) > rpc
✅ procedures should clean up after themselves ('ws' transport, 'binary' codec) > stream
✅ procedures should clean up after themselves ('ws' transport, 'binary' codec) > cancellation after transport close
✅ procedures should clean up after themselves ('ws' transport, 'binary' codec) > subscription
✅ procedures should clean up after themselves ('ws' transport, 'binary' codec) > upload
✅ procedures should clean up after themselves ('ws' transport, 'binary' codec) > shouldn't send messages across stale sessions
✅ procedures should clean up after themselves ('mock' transport, 'naive' codec) > closing a transport from the client cleans up connection on the server
✅ procedures should clean up after themselves ('mock' transport, 'naive' codec) > closing a transport from the server cleans up connection on the client
✅ procedures should clean up after themselves ('mock' transport, 'naive' codec) > rpc
✅ procedures should clean up after themselves ('mock' transport, 'naive' codec) > stream
✅ procedures should clean up after themselves ('mock' transport, 'naive' codec) > cancellation after transport close
✅ procedures should clean up after themselves ('mock' transport, 'naive' codec) > subscription
✅ procedures should clean up after themselves ('mock' transport, 'naive' codec) > upload
✅ procedures should clean up after themselves ('mock' transport, 'naive' codec) > shouldn't send messages across stale sessions
✅ procedures should clean up after themselves ('mock' transport, 'binary' codec) > closing a transport from the client cleans up connection on the server
✅ procedures should clean up after themselves ('mock' transport, 'binary' codec) > closing a transport from the server cleans up connection on the client
✅ procedures should clean up after themselves ('mock' transport, 'binary' codec) > rpc
✅ procedures should clean up after themselves ('mock' transport, 'binary' codec) > stream
✅ procedures should clean up after themselves ('mock' transport, 'binary' codec) > cancellation after transport close
✅ procedures should clean up after themselves ('mock' transport, 'binary' codec) > subscription
✅ procedures should clean up after themselves ('mock' transport, 'binary' codec) > upload
✅ procedures should clean up after themselves ('mock' transport, 'binary' codec) > shouldn't send messages across stale sessions
✅ request finishing triggers signal onabort > handler aborts 'rpc'
✅ request finishing triggers signal onabort > handler aborts 'subscription'
✅ request finishing triggers signal onabort > handler aborts 'stream'
✅ request finishing triggers signal onabort > handler aborts 'upload'

✅ tests/context.test.ts

✅ should handle incompatabilities > should pass extended context to procedure
✅ should handle incompatabilities > should pass extended context to initializeState

✅ tests/disconnects.test.ts

✅ procedures should handle unexpected disconnects ('ws' transport, 'naive' codec) > rpc
✅ procedures should handle unexpected disconnects ('ws' transport, 'naive' codec) > stream
✅ procedures should handle unexpected disconnects ('ws' transport, 'naive' codec) > subscription
✅ procedures should handle unexpected disconnects ('ws' transport, 'naive' codec) > upload
✅ procedures should handle unexpected disconnects ('ws' transport, 'binary' codec) > rpc
✅ procedures should handle unexpected disconnects ('ws' transport, 'binary' codec) > stream
✅ procedures should handle unexpected disconnects ('ws' transport, 'binary' codec) > subscription
✅ procedures should handle unexpected disconnects ('ws' transport, 'binary' codec) > upload
✅ procedures should handle unexpected disconnects ('mock' transport, 'naive' codec) > rpc
✅ procedures should handle unexpected disconnects ('mock' transport, 'naive' codec) > stream
✅ procedures should handle unexpected disconnects ('mock' transport, 'naive' codec) > subscription
✅ procedures should handle unexpected disconnects ('mock' transport, 'naive' codec) > upload
✅ procedures should handle unexpected disconnects ('mock' transport, 'binary' codec) > rpc
✅ procedures should handle unexpected disconnects ('mock' transport, 'binary' codec) > stream
✅ procedures should handle unexpected disconnects ('mock' transport, 'binary' codec) > subscription
✅ procedures should handle unexpected disconnects ('mock' transport, 'binary' codec) > upload

✅ tests/e2e.test.ts

✅ client <-> server integration test ('ws' transport, 'naive' codec) > rpc
✅ client <-> server integration test ('ws' transport, 'naive' codec) > fallible rpc
✅ client <-> server integration test ('ws' transport, 'naive' codec) > rpc with binary (uint8array)
✅ client <-> server integration test ('ws' transport, 'naive' codec) > stream
✅ client <-> server integration test ('ws' transport, 'naive' codec) > stream empty
✅ client <-> server integration test ('ws' transport, 'naive' codec) > stream idempotent close
✅ client <-> server integration test ('ws' transport, 'naive' codec) > stream with init message
✅ client <-> server integration test ('ws' transport, 'naive' codec) > fallible stream
✅ client <-> server integration test ('ws' transport, 'naive' codec) > subscription
✅ client <-> server integration test ('ws' transport, 'naive' codec) > subscription idempotent close
✅ client <-> server integration test ('ws' transport, 'naive' codec) > upload
✅ client <-> server integration test ('ws' transport, 'naive' codec) > upload empty
✅ client <-> server integration test ('ws' transport, 'naive' codec) > upload with init message
✅ client <-> server integration test ('ws' transport, 'naive' codec) > message order is preserved in the face of disconnects
✅ client <-> server integration test ('ws' transport, 'naive' codec) > concurrent rpcs
✅ client <-> server integration test ('ws' transport, 'naive' codec) > concurrent streams
✅ client <-> server integration test ('ws' transport, 'naive' codec) > eagerlyConnect should actually eagerly connect
✅ client <-> server integration test ('ws' transport, 'naive' codec) > client reconnects even after session grace
✅ client <-> server integration test ('ws' transport, 'naive' codec) > client doesn't reconnect after session grace if connectOnInvoke is false
✅ client <-> server integration test ('ws' transport, 'naive' codec) > calls service dispose methods on cleanup
✅ client <-> server integration test ('ws' transport, 'naive' codec) > works with non-object schemas
✅ client <-> server integration test ('ws' transport, 'naive' codec) > procedure can use metadata
✅ client <-> server integration test ('ws' transport, 'binary' codec) > rpc
✅ client <-> server integration test ('ws' transport, 'binary' codec) > fallible rpc
✅ client <-> server integration test ('ws' transport, 'binary' codec) > rpc with binary (uint8array)
✅ client <-> server integration test ('ws' transport, 'binary' codec) > stream
✅ client <-> server integration test ('ws' transport, 'binary' codec) > stream empty
✅ client <-> server integration test ('ws' transport, 'binary' codec) > stream idempotent close
✅ client <-> server integration test ('ws' transport, 'binary' codec) > stream with init message
✅ client <-> server integration test ('ws' transport, 'binary' codec) > fallible stream
✅ client <-> server integration test ('ws' transport, 'binary' codec) > subscription
✅ client <-> server integration test ('ws' transport, 'binary' codec) > subscription idempotent close
✅ client <-> server integration test ('ws' transport, 'binary' codec) > upload
✅ client <-> server integration test ('ws' transport, 'binary' codec) > upload empty
✅ client <-> server integration test ('ws' transport, 'binary' codec) > upload with init message
✅ client <-> server integration test ('ws' transport, 'binary' codec) > message order is preserved in the face of disconnects
✅ client <-> server integration test ('ws' transport, 'binary' codec) > concurrent rpcs
✅ client <-> server integration test ('ws' transport, 'binary' codec) > concurrent streams
✅ client <-> server integration test ('ws' transport, 'binary' codec) > eagerlyConnect should actually eagerly connect
✅ client <-> server integration test ('ws' transport, 'binary' codec) > client reconnects even after session grace
✅ client <-> server integration test ('ws' transport, 'binary' codec) > client doesn't reconnect after session grace if connectOnInvoke is false
✅ client <-> server integration test ('ws' transport, 'binary' codec) > calls service dispose methods on cleanup
✅ client <-> server integration test ('ws' transport, 'binary' codec) > works with non-object schemas
✅ client <-> server integration test ('ws' transport, 'binary' codec) > procedure can use metadata
✅ client <-> server integration test ('mock' transport, 'naive' codec) > rpc
✅ client <-> server integration test ('mock' transport, 'naive' codec) > fallible rpc
✅ client <-> server integration test ('mock' transport, 'naive' codec) > rpc with binary (uint8array)
✅ client <-> server integration test ('mock' transport, 'naive' codec) > stream
✅ client <-> server integration test ('mock' transport, 'naive' codec) > stream empty
✅ client <-> server integration test ('mock' transport, 'naive' codec) > stream idempotent close
✅ client <-> server integration test ('mock' transport, 'naive' codec) > stream with init message
✅ client <-> server integration test ('mock' transport, 'naive' codec) > fallible stream
✅ client <-> server integration test ('mock' transport, 'naive' codec) > subscription
✅ client <-> server integration test ('mock' transport, 'naive' codec) > subscription idempotent close
✅ client <-> server integration test ('mock' transport, 'naive' codec) > upload
✅ client <-> server integration test ('mock' transport, 'naive' codec) > upload empty
✅ client <-> server integration test ('mock' transport, 'naive' codec) > upload with init message
✅ client <-> server integration test ('mock' transport, 'naive' codec) > message order is preserved in the face of disconnects
✅ client <-> server integration test ('mock' transport, 'naive' codec) > concurrent rpcs
✅ client <-> server integration test ('mock' transport, 'naive' codec) > concurrent streams
✅ client <-> server integration test ('mock' transport, 'naive' codec) > eagerlyConnect should actually eagerly connect
✅ client <-> server integration test ('mock' transport, 'naive' codec) > client reconnects even after session grace
✅ client <-> server integration test ('mock' transport, 'naive' codec) > client doesn't reconnect after session grace if connectOnInvoke is false
✅ client <-> server integration test ('mock' transport, 'naive' codec) > calls service dispose methods on cleanup
✅ client <-> server integration test ('mock' transport, 'naive' codec) > works with non-object schemas
✅ client <-> server integration test ('mock' transport, 'naive' codec) > procedure can use metadata
✅ client <-> server integration test ('mock' transport, 'binary' codec) > rpc
✅ client <-> server integration test ('mock' transport, 'binary' codec) > fallible rpc
✅ client <-> server integration test ('mock' transport, 'binary' codec) > rpc with binary (uint8array)
✅ client <-> server integration test ('mock' transport, 'binary' codec) > stream
✅ client <-> server integration test ('mock' transport, 'binary' codec) > stream empty
✅ client <-> server integration test ('mock' transport, 'binary' codec) > stream idempotent close
✅ client <-> server integration test ('mock' transport, 'binary' codec) > stream with init message
✅ client <-> server integration test ('mock' transport, 'binary' codec) > fallible stream
✅ client <-> server integration test ('mock' transport, 'binary' codec) > subscription
✅ client <-> server integration test ('mock' transport, 'binary' codec) > subscription idempotent close
✅ client <-> server integration test ('mock' transport, 'binary' codec) > upload
✅ client <-> server integration test ('mock' transport, 'binary' codec) > upload empty
✅ client <-> server integration test ('mock' transport, 'binary' codec) > upload with init message
✅ client <-> server integration test ('mock' transport, 'binary' codec) > message order is preserved in the face of disconnects
✅ client <-> server integration test ('mock' transport, 'binary' codec) > concurrent rpcs
✅ client <-> server integration test ('mock' transport, 'binary' codec) > concurrent streams
✅ client <-> server integration test ('mock' transport, 'binary' codec) > eagerlyConnect should actually eagerly connect
✅ client <-> server integration test ('mock' transport, 'binary' codec) > client reconnects even after session grace
✅ client <-> server integration test ('mock' transport, 'binary' codec) > client doesn't reconnect after session grace if connectOnInvoke is false
✅ client <-> server integration test ('mock' transport, 'binary' codec) > calls service dispose methods on cleanup
✅ client <-> server integration test ('mock' transport, 'binary' codec) > works with non-object schemas
✅ client <-> server integration test ('mock' transport, 'binary' codec) > procedure can use metadata

✅ tests/handler.test.ts

✅ server-side test > rpc basic
✅ server-side test > fallible rpc
✅ server-side test > stream basic
✅ server-side test > stream empty
✅ server-side test > stream with initialization
✅ server-side test > fallible stream
✅ server-side test > subscriptions
✅ server-side test > uploads
✅ server-side test > uploads empty
✅ server-side test > uploads with initialization

✅ tests/invalid-request.test.ts

✅ cancels invalid request > missing StreamOpenBit
✅ cancels invalid request > missing serviceName
✅ cancels invalid request > missing procedureName
✅ cancels invalid request > service does not exist
✅ cancels invalid request > procedure does not exist
✅ cancels invalid request > bad init message
✅ cancels invalid request > bad request message
✅ cancels invalid request > data message for non-stream procedure
✅ cancels invalid request > request after close
✅ cancels invalid request > e2e
✅ cancels invalid request > tombstones invalid request > responds to multiple invalid requests for the same stream only once
✅ cancels invalid request > tombstones invalid request > starts responding to same stream after tombstones are evicted
✅ cancels invalid request > tombstones invalid request > separate sessions don't evict tombstones

✅ tests/max-payload-size.test.ts

✅ client exceeded max payload size > rpc init exceeds max payload size
✅ client exceeded max payload size > stream message exceeds max payload size
✅ server exceeded max payload size > rpc response exceeds max payload size
✅ server exceeded max payload size > stream message exceeds max payload size

✅ tests/negative.test.ts

✅ should handle incompatabilities > cannot get a bound send function on a closed transport
✅ should handle incompatabilities > retrying single connection attempt should hit retry limit reached
✅ should handle incompatabilities > calling connect consecutively should reuse the same connection
✅ should handle incompatabilities > incorrect client handshake
✅ should handle incompatabilities > seq number in the future should close connection
✅ should handle incompatabilities > mismatched protocol version

✅ tests/serialize.test.ts

✅ serialize server to jsonschema > serialize entire service schema
✅ serialize service to jsonschema > serialize basic service
✅ serialize service to jsonschema > serialize service with binary
✅ serialize service to jsonschema > serialize service with errors
✅ serialize service to jsonschema > serialize backwards compatible with v1

✅ tests/streams.test.ts

✅ Readable unit > should close the readable
✅ Readable unit > should synchronously lock the stream when Symbol.asyncIterable is called
✅ Readable unit > should synchronously lock the stream when collect() is called
✅ Readable unit > should synchronously lock the stream when break() is called
✅ Readable unit > should iterate over the values pushed to the stream
✅ Readable unit > should iterate over the values push to the stream after close
✅ Readable unit > should handle eager iterations gracefully
✅ Readable unit > should not resolve iterator until value is pushed or stream is closed
✅ Readable unit > should return an array of the stream values when collect is called after close
✅ Readable unit > should not resolve collect until the stream is closed
✅ Readable unit > should throw when pushing to a closed stream
✅ Readable unit > should throw when closing multiple times
✅ Readable unit > should support for-await-of
✅ Readable unit > should support for-await-of with break
✅ Readable unit > should emit error results as part of iteration
✅ Readable unit > break > should signal the next stream iteration
✅ Readable unit > break > should signal the pending stream iteration
✅ Readable unit > break > should signal the next stream iteration wtih a queued up value
✅ Readable unit > break > should signal the next stream iteration with a queued up value after stream is closed
✅ Readable unit > break > should not signal the next stream iteration with an empty queue after stream is closed
✅ Readable unit > break > should end iteration if draining mid-stream
✅ Writable unit > should write
✅ Writable unit > should close the writable
✅ Writable unit > should allow calling close multiple times
✅ Writable unit > should throw when writing after close

✅ tests/typescript-stress.test.ts

✅ ensure typescript doesn't give up trying to infer the types for large services > service with many procedures hits typescript limit
✅ ensure typescript doesn't give up trying to infer the types for large services > server client should support many services with many procedures
✅ ResponseData<> type > it unwraps rpc response data correctly
✅ ResponseData<> type > it unwraps stream response data correctly
✅ ResponseData<> type > it unwraps subscription response data correctly
✅ ResponseData<> type > it unwraps upload response data correctly
✅ ResultUwrap types > it unwraps Ok correctly
✅ ResultUwrap types > it unwraps Err correctly
✅ Handshake > custom handhshake types should work
✅ Procedure error schema > allowed > object
✅ Procedure error schema > allowed > union of object
✅ Procedure error schema > allowed > union of union
✅ Procedure error schema > allowed > union of object and union
✅ Procedure error schema > allowed > deeeeep nesting
✅ Procedure error schema > allowed > mixed bag, union of object, unions, "union of unions", and "union of union and object" (I think)
✅ Procedure error schema > fails > fails when object has an invalid error shape
✅ Procedure error schema > fails > fails on nested union without helper
⚪ Readable types > should maintain result types

✅ codec/codec.test.ts

✅ codec -- 'naive' > empty object
✅ codec -- 'naive' > simple test
✅ codec -- 'naive' > encodes null properly
✅ codec -- 'naive' > skips optional fields
✅ codec -- 'naive' > deeply nested test
✅ codec -- 'naive' > buffer test
✅ codec -- 'naive' > invalid json returns null
✅ codec -- 'binary' > empty object
✅ codec -- 'binary' > simple test
✅ codec -- 'binary' > encodes null properly
✅ codec -- 'binary' > skips optional fields
✅ codec -- 'binary' > deeply nested test
✅ codec -- 'binary' > buffer test
✅ codec -- 'binary' > invalid json returns null

✅ testUtil/duplex/duplexPair.test.ts

✅ duplexPair > should create a pair of duplex streams

✅ testUtil/observable/observable.test.ts

✅ Observable > should set initial value correctly
✅ Observable > should update value correctly
✅ Observable > should notify listeners when value changes
✅ Observable > should unsubscribe from notifications

✅ tracing/tracing.test.ts

✅ Basic tracing tests > createSessionTelemetryInfo
✅ Integrated tracing tests ('ws' transport, 'naive' codec) > Traces sessions and connections across network boundary
✅ Integrated tracing tests ('ws' transport, 'naive' codec) > implicit telemetry gets picked up from handlers
✅ Integrated tracing tests ('ws' transport, 'binary' codec) > Traces sessions and connections across network boundary
✅ Integrated tracing tests ('ws' transport, 'binary' codec) > implicit telemetry gets picked up from handlers
✅ Integrated tracing tests ('mock' transport, 'naive' codec) > Traces sessions and connections across network boundary
✅ Integrated tracing tests ('mock' transport, 'naive' codec) > implicit telemetry gets picked up from handlers
✅ Integrated tracing tests ('mock' transport, 'binary' codec) > Traces sessions and connections across network boundary
✅ Integrated tracing tests ('mock' transport, 'binary' codec) > implicit telemetry gets picked up from handlers

✅ transport/events.test.ts

✅ EventDispatcher > notifies all handlers in order they were registered
✅ EventDispatcher > does not notify removed handlers
✅ EventDispatcher > does not notify handlers added while notifying another handler
✅ EventDispatcher > does notify handlers removed while notifying another handler
✅ EventDispatcher > removes all listeners

✅ transport/impls/ws/ws.test.ts

✅ sending and receiving across websockets works > basic send/receive
✅ sending and receiving across websockets works > sending respects to/from fields
✅ sending and receiving across websockets works > hanging ws connection with no handshake is cleaned up after grace
✅ sending and receiving across websockets works > ws connection is recreated after unclean disconnect
✅ sending and receiving across websockets works > ws connection always calls the close callback

✅ transport/message.test.ts

✅ message helpers > ack
✅ message helpers > streamOpen
✅ message helpers > streamClose
✅ message helpers > handshakeRequestMessage
✅ message helpers > handshakeResponseMessage
✅ message helpers > default message has no control flags set
✅ message helpers > combining control flags works

✅ transport/rateLimit.test.ts

✅ LeakyBucketRateLimit > should return 0 backoff time for new user
✅ LeakyBucketRateLimit > should return 0 budget consumed for new user
✅ LeakyBucketRateLimit > should consume budget correctly
✅ LeakyBucketRateLimit > keeps growing until startRestoringBudget
✅ LeakyBucketRateLimit > stops restoring budget when we consume budget again
✅ LeakyBucketRateLimit > respects maximum backoff time
✅ LeakyBucketRateLimit > backoff increases
✅ LeakyBucketRateLimit > reports remaining budget correctly

✅ transport/sessionStateMachine/stateMachine.test.ts

✅ session state machine > initial state > no connection
✅ session state machine > initial state > connecting
✅ session state machine > initial state > handshaking
✅ session state machine > initial state > connected
✅ session state machine > initial state > pending identification
✅ session state machine > state transitions > no connection -> backing off
✅ session state machine > state transitions > backing off -> connecting
✅ session state machine > state transitions > connecting -> handshaking
✅ session state machine > state transitions > handshaking -> connected
✅ session state machine > state transitions > waiting (no existing session) -> connected
✅ session state machine > state transitions > waiting (existing session) -> connected
✅ session state machine > state transitions > backing off -> no connection
✅ session state machine > state transitions > connecting (conn failed) -> no connection
✅ session state machine > state transitions > connecting (conn ok) -> no connection
✅ session state machine > state transitions > handshaking -> no connection
✅ session state machine > state transitions > connected -> no connection
✅ session state machine > state transitions preserve buffer, seq, ack > no connection -> backing off
✅ session state machine > state transitions preserve buffer, seq, ack > backing off -> connecting
✅ session state machine > state transitions preserve buffer, seq, ack > connecting -> handshaking
✅ session state machine > state transitions preserve buffer, seq, ack > handshaking -> connected
✅ session state machine > state transitions preserve buffer, seq, ack > backing off -> no connection
✅ session state machine > state transitions preserve buffer, seq, ack > connecting -> no connection
✅ session state machine > state transitions preserve buffer, seq, ack > handshaking -> no connection
✅ session state machine > state transitions preserve buffer, seq, ack > connected -> no connection
✅ session state machine > state transitions deal with session grace period appropriately > no connection -> backing off: partially consumed grace period
✅ session state machine > state transitions deal with session grace period appropriately > no connection -> backing off -> connecting: partially consumed grace period
✅ session state machine > state transitions deal with session grace period appropriately > no connection -> backing off -> connecting -> handshaking: partially consumed grace period
✅ session state machine > state transitions deal with session grace period appropriately > no connection -> backing off -> connecting -> handshaking -> connected: partially consumed grace period
✅ session state machine > state transitions deal with session grace period appropriately > backing off -> no connection: partially consumed grace period
✅ session state machine > state transitions deal with session grace period appropriately > connecting -> no connection: partially consumed grace period
✅ session state machine > state transitions deal with session grace period appropriately > handshaking -> no connection: partially consumed grace period
✅ session state machine > state transitions deal with session grace period appropriately > handshaking -> connected: connected should clear grace timer
✅ session state machine > stale handles post-transition > no connection -> backing off: stale handle
✅ session state machine > stale handles post-transition > backing off -> connecting: stale handle
✅ session state machine > stale handles post-transition > connecting -> handshaking: stale handle
✅ session state machine > stale handles post-transition > handshaking -> connected: stale handle
✅ session state machine > stale handles post-transition > waiting -> connected: stale handle
✅ session state machine > stale handles post-transition > backing off -> no connection: stale handle
✅ session state machine > stale handles post-transition > connecting -> no connection: stale handle
✅ session state machine > stale handles post-transition > handshaking -> no connection: stale handle
✅ session state machine > stale handles post-transition > connected -> no connection: stale handle
✅ session state machine > close cleanup > no connection
✅ session state machine > close cleanup > backing off
✅ session state machine > close cleanup > connecting
✅ session state machine > close cleanup > connecting finish after close
✅ session state machine > close cleanup > handshaking
✅ session state machine > close cleanup > connected
✅ session state machine > close cleanup > pending identification
✅ session state machine > event listeners > no connection event listeners: onSessionGracePeriodElapsed
✅ session state machine > event listeners > backing off event listeners: onBackoffFinished
✅ session state machine > event listeners > backing off event listeners: onSessionGracePeriodElapsed
✅ session state machine > event listeners > connecting event listeners: connectionEstablished
✅ session state machine > event listeners > connecting event listeners: connectionFailed
✅ session state machine > event listeners > connecting event listeners: connectionTimeout
✅ session state machine > event listeners > connecting event listeners: sessionGracePeriodElapsed
✅ session state machine > event listeners > handshaking event listeners: connectionErrored
✅ session state machine > event listeners > handshaking event listeners: connectionClosed
✅ session state machine > event listeners > handshaking event listeners: onHandshakeData
✅ session state machine > event listeners > handshaking event listeners: handshakeTimeout
✅ session state machine > event listeners > handshaking event listeners: sessionGracePeriodElapsed
✅ session state machine > event listeners > pending identification event listeners: connectionErrored
✅ session state machine > event listeners > pending identification event listeners: connectionClosed
✅ session state machine > event listeners > pending identification event listeners: onHandshakeData
✅ session state machine > event listeners > pending identification event listeners: handshakeTimeout
✅ session state machine > event listeners > connected event listeners: connectionErrored
✅ session state machine > event listeners > connected event listeners: connectionClosed
✅ session state machine > event listeners > connected event listeners: onMessageData
✅ session state machine > heartbeats > active heartbeating works and is cleared on state transition
✅ session state machine > heartbeats > passive heartbeating echoes back acks
✅ session state machine > heartbeats > does not dispatch acks

✅ transport/transforms/messageFraming.test.ts

✅ MessageFramer > basic transform
✅ MessageFramer > handles partial messages across chunks
✅ MessageFramer > multiple messages in a single chunk
✅ MessageFramer > max buffer size exceeded
✅ MessageFramer > incomplete message at stream end
✅ MessageFramer > consistent byte length calculation with emojis and unicode

✅ transport/transport.test.ts

✅ transport connection behaviour tests ('ws' transport, 'naive' codec) > connection is recreated after clean client disconnect
✅ transport connection behaviour tests ('ws' transport, 'naive' codec) > misbehaving clients get their sessions recreated after reconnect
✅ transport connection behaviour tests ('ws' transport, 'naive' codec) > idle transport cleans up nicely
✅ transport connection behaviour tests ('ws' transport, 'naive' codec) > idle transport stays alive
✅ transport connection behaviour tests ('ws' transport, 'naive' codec) > heartbeats should not interrupt normal operation
✅ transport connection behaviour tests ('ws' transport, 'naive' codec) > sending right after session event should not cause invalid handshake
✅ transport connection behaviour tests ('ws' transport, 'naive' codec) > seq numbers should be persisted across transparent reconnects
✅ transport connection behaviour tests ('ws' transport, 'naive' codec) > both client and server transport get connect/disconnect notifs
✅ transport connection behaviour tests ('ws' transport, 'naive' codec) > transport connection is not recreated after destroy
✅ transport connection behaviour tests ('ws' transport, 'naive' codec) > multiple connections works
✅ transport connection behaviour tests ('ws' transport, 'binary' codec) > connection is recreated after clean client disconnect
✅ transport connection behaviour tests ('ws' transport, 'binary' codec) > misbehaving clients get their sessions recreated after reconnect
✅ transport connection behaviour tests ('ws' transport, 'binary' codec) > idle transport cleans up nicely
✅ transport connection behaviour tests ('ws' transport, 'binary' codec) > idle transport stays alive
✅ transport connection behaviour tests ('ws' transport, 'binary' codec) > heartbeats should not interrupt normal operation
✅ transport connection behaviour tests ('ws' transport, 'binary' codec) > sending right after session event should not cause invalid handshake
✅ transport connection behaviour tests ('ws' transport, 'binary' codec) > seq numbers should be persisted across transparent reconnects
✅ transport connection behaviour tests ('ws' transport, 'binary' codec) > both client and server transport get connect/disconnect notifs
✅ transport connection behaviour tests ('ws' transport, 'binary' codec) > transport connection is not recreated after destroy
✅ transport connection behaviour tests ('ws' transport, 'binary' codec) > multiple connections works
✅ transport connection behaviour tests ('mock' transport, 'naive' codec) > connection is recreated after clean client disconnect
✅ transport connection behaviour tests ('mock' transport, 'naive' codec) > misbehaving clients get their sessions recreated after reconnect
✅ transport connection behaviour tests ('mock' transport, 'naive' codec) > idle transport cleans up nicely
✅ transport connection behaviour tests ('mock' transport, 'naive' codec) > idle transport stays alive
✅ transport connection behaviour tests ('mock' transport, 'naive' codec) > heartbeats should not interrupt normal operation
✅ transport connection behaviour tests ('mock' transport, 'naive' codec) > sending right after session event should not cause invalid handshake
✅ transport connection behaviour tests ('mock' transport, 'naive' codec) > seq numbers should be persisted across transparent reconnects
✅ transport connection behaviour tests ('mock' transport, 'naive' codec) > both client and server transport get connect/disconnect notifs
✅ transport connection behaviour tests ('mock' transport, 'naive' codec) > transport connection is not recreated after destroy
✅ transport connection behaviour tests ('mock' transport, 'naive' codec) > multiple connections works
✅ transport connection behaviour tests ('mock' transport, 'binary' codec) > connection is recreated after clean client disconnect
✅ transport connection behaviour tests ('mock' transport, 'binary' codec) > misbehaving clients get their sessions recreated after reconnect
✅ transport connection behaviour tests ('mock' transport, 'binary' codec) > idle transport cleans up nicely
✅ transport connection behaviour tests ('mock' transport, 'binary' codec) > idle transport stays alive
✅ transport connection behaviour tests ('mock' transport, 'binary' codec) > heartbeats should not interrupt normal operation
✅ transport connection behaviour tests ('mock' transport, 'binary' codec) > sending right after session event should not cause invalid handshake
✅ transport connection behaviour tests ('mock' transport, 'binary' codec) > seq numbers should be persisted across transparent reconnects
✅ transport connection behaviour tests ('mock' transport, 'binary' codec) > both client and server transport get connect/disconnect notifs
✅ transport connection behaviour tests ('mock' transport, 'binary' codec) > transport connection is not recreated after destroy
✅ transport connection behaviour tests ('mock' transport, 'binary' codec) > multiple connections works
✅ transport disabling transparent reconnect ('ws' transport, 'naive' codec) > reconnecting with grace period of 0 should result in hard reconnect
✅ transport disabling transparent reconnect ('ws' transport, 'binary' codec) > reconnecting with grace period of 0 should result in hard reconnect
✅ transport disabling transparent reconnect ('mock' transport, 'naive' codec) > reconnecting with grace period of 0 should result in hard reconnect
✅ transport disabling transparent reconnect ('mock' transport, 'binary' codec) > reconnecting with grace period of 0 should result in hard reconnect
✅ transport handshake grace period tests ('ws' transport, 'naive' codec) > handshake grace period of 0 should lead to closed connections
✅ transport handshake grace period tests ('ws' transport, 'binary' codec) > handshake grace period of 0 should lead to closed connections
✅ transport handshake grace period tests ('mock' transport, 'naive' codec) > handshake grace period of 0 should lead to closed connections
✅ transport handshake grace period tests ('mock' transport, 'binary' codec) > handshake grace period of 0 should lead to closed connections
✅ transport connection edge cases ('ws' transport, 'naive' codec) > reconnecting before grace period ends should leave session intact
✅ transport connection edge cases ('ws' transport, 'naive' codec) > client transport calling .hardDisconnect() immediately kills the session and updates bookkeeping
✅ transport connection edge cases ('ws' transport, 'naive' codec) > session grace elapses during long reconnect loop
✅ transport connection edge cases ('ws' transport, 'naive' codec) > messages should not be resent when the client loses all state and reconnects to the server
✅ transport connection edge cases ('ws' transport, 'naive' codec) > messages should not be resent when client reconnects to a different instance of the server
✅ transport connection edge cases ('ws' transport, 'naive' codec) > recovers from phantom disconnects
✅ transport connection edge cases ('ws' transport, 'binary' codec) > reconnecting before grace period ends should leave session intact
✅ transport connection edge cases ('ws' transport, 'binary' codec) > client transport calling .hardDisconnect() immediately kills the session and updates bookkeeping
✅ transport connection edge cases ('ws' transport, 'binary' codec) > session grace elapses during long reconnect loop
✅ transport connection edge cases ('ws' transport, 'binary' codec) > messages should not be resent when the client loses all state and reconnects to the server
✅ transport connection edge cases ('ws' transport, 'binary' codec) > messages should not be resent when client reconnects to a different instance of the server
✅ transport connection edge cases ('ws' transport, 'binary' codec) > recovers from phantom disconnects
✅ transport connection edge cases ('mock' transport, 'naive' codec) > reconnecting before grace period ends should leave session intact
✅ transport connection edge cases ('mock' transport, 'naive' codec) > client transport calling .hardDisconnect() immediately kills the session and updates bookkeeping
✅ transport connection edge cases ('mock' transport, 'naive' codec) > session grace elapses during long reconnect loop
✅ transport connection edge cases ('mock' transport, 'naive' codec) > messages should not be resent when the client loses all state and reconnects to the server
✅ transport connection edge cases ('mock' transport, 'naive' codec) > messages should not be resent when client reconnects to a different instance of the server
✅ transport connection edge cases ('mock' transport, 'naive' codec) > recovers from phantom disconnects
✅ transport connection edge cases ('mock' transport, 'binary' codec) > reconnecting before grace period ends should leave session intact
✅ transport connection edge cases ('mock' transport, 'binary' codec) > client transport calling .hardDisconnect() immediately kills the session and updates bookkeeping
✅ transport connection edge cases ('mock' transport, 'binary' codec) > session grace elapses during long reconnect loop
✅ transport connection edge cases ('mock' transport, 'binary' codec) > messages should not be resent when the client loses all state and reconnects to the server
✅ transport connection edge cases ('mock' transport, 'binary' codec) > messages should not be resent when client reconnects to a different instance of the server
✅ transport connection edge cases ('mock' transport, 'binary' codec) > recovers from phantom disconnects
✅ transport handshake tests ('ws' transport, 'naive' codec) > handshakes and stores parsed metadata in session
✅ transport handshake tests ('ws' transport, 'naive' codec) > client checks request schema on construction
✅ transport handshake tests ('ws' transport, 'naive' codec) > server checks request schema on receive
✅ transport handshake tests ('ws' transport, 'naive' codec) > server gets previous parsed metadata on reconnect
✅ transport handshake tests ('ws' transport, 'naive' codec) > parse can reject connection
✅ transport handshake tests ('ws' transport, 'binary' codec) > handshakes and stores parsed metadata in session
✅ transport handshake tests ('ws' transport, 'binary' codec) > client checks request schema on construction
✅ transport handshake tests ('ws' transport, 'binary' codec) > server checks request schema on receive
✅ transport handshake tests ('ws' transport, 'binary' codec) > server gets previous parsed metadata on reconnect
✅ transport handshake tests ('ws' transport, 'binary' codec) > parse can reject connection
✅ transport handshake tests ('mock' transport, 'naive' codec) > handshakes and stores parsed metadata in session
✅ transport handshake tests ('mock' transport, 'naive' codec) > client checks request schema on construction
✅ transport handshake tests ('mock' transport, 'naive' codec) > server checks request schema on receive
✅ transport handshake tests ('mock' transport, 'naive' codec) > server gets previous parsed metadata on reconnect
✅ transport handshake tests ('mock' transport, 'naive' codec) > parse can reject connection
✅ transport handshake tests ('mock' transport, 'binary' codec) > handshakes and stores parsed metadata in session
✅ transport handshake tests ('mock' transport, 'binary' codec) > client checks request schema on construction
✅ transport handshake tests ('mock' transport, 'binary' codec) > server checks request schema on receive
✅ transport handshake tests ('mock' transport, 'binary' codec) > server gets previous parsed metadata on reconnect
✅ transport handshake tests ('mock' transport, 'binary' codec) > parse can reject connection