github.com/centrifugal/centrifuge

What's Changed

• Fix flaky TestPresenceTickDefaultIsAllocationFree by @FZambia in #632
• Don't negotiate delta compression with tags filters by @FZambia in #634
• Reject map stream reads past an expired stream by @FZambia in #636
• Scan a payload for UTF-8 validity once per broadcast by @FZambia in #637
• JSON-encode subscribe reply publications for delta subscriptions by @FZambia in #635
• Never block a broadcast on a subscribing client by @FZambia in #640
• Use github.com/centrifugal/fdelta for fossil deltas by @FZambia in #638
• Limit recovery buffers by ClientQueueMaxSize per connection by @FZambia in #641
• Split the single-publication Lua scripts into a function and a caller by @FZambia in #642
• Fail an idempotent publish during a slot migration instead of losing it by @FZambia in #644
• Refuse channels starting with "}" in Redis Cluster; fix idempotent publish with SkipPubSub by @FZambia in #645
• Flush channel batches of all subscribers with one timer per channel by @FZambia in #646

Full Changelog: v0.39.2...v0.39.3

What's Changed

• Reject expired client-side subscription refresh by @FZambia in #627
• Send full data first after a fossil delta recovery with no publications by @FZambia in #629
• Align fossil deltas to UTF-8 character boundaries for JSON clients by @FZambia in #630
• Fix flaky TestRuntimeStability_SlowRefreshHandler by @FZambia in #631

Full Changelog: v0.39.1...v0.39.2

What's Changed

• metrics: add transport_frame_size histogram by @FZambia in #620
• fix client closed or unsubscribed after adding subscription log entry level to be info instead of error by @FZambia in #621
• fix client label metrics and Redis payload parsing: wrong series, runtime panics, per-message allocations by @FZambia in #622
• stress_runtime: cover map subscriptions and shared poll by @FZambia in #623
• send expiration in map subscribe replies, keep client-side refresh across pages by @FZambia in #626

Full Changelog: v0.39.0...v0.39.1

This is one of the largest Centrifuge releases to date — 57 merged PRs since v0.38.0. The headline feature is two new subscription types: Map subscriptions and Shared Poll subscriptions. Alongside them, a deep investigation into Redis Sentinel failover reliability produced fixes both in Centrifuge and upstream in the rueidis driver, and a major round of connection runtime stability and performance work landed as well.

Map subscriptions and Shared Poll subscriptions (experimental)

Centrifuge gets two new subscription types addressing patterns that don't fit well into the existing stream-based model, #565. Both are experimental: the API may still change based on real-world feedback. Today, only centrifuge-js implements client-side support for them — other official SDKs (Go, Swift, Java/Kotlin, Dart) don't have Map/Shared Poll support yet:

• Map subscriptions — a keyed state model where each entry in a channel can be independently created, updated, or removed. Clients get a paginated snapshot on subscribe, then incremental sync events, so they always converge to correct state after a reconnect — a much better fit than presence for cursors, user status, and other cases where presence's snapshot-based protocol runs into scalability limits. Three modes control a channel's sync/recovery/lifecycle behavior, independent of the storage backend: Ephemeral (PUB/SUB only, no recovery stream, entries expire via TTL), Recoverable (stream-backed with offset-based recovery, entries still expire via TTL), and Persistent (stream-backed with offset-based recovery, entries live forever until explicitly removed). Both the new MemoryMapBroker and RedisMapBroker support all three modes — the difference between them is durability: Memory keeps everything in-process, so even Persistent-mode data is gone after a restart, while Redis makes state and recovery survive restarts and work across multiple nodes. Delta compression works per key.
• Shared Poll subscriptions — for the "many clients watching the same objects" pattern (dashboards, live lists, tickers), where Centrifuge polls the backend once per cycle for a channel regardless of client count, and clients track/untrack individual keys. Backend load scales as O(active items) instead of O(active clients) — 10k users watching 100 objects means one backend poll per cycle instead of 10k. Versionless and Versioned delivery modes, plus fast-track publish for immediate updates outside the poll cycle.

Both integrate with the existing channel/Hub/transport model, and centrifuge-js (v5.6.0+) ships type-safe MapSubscription and SharedPollSubscription APIs on the client side.

This repo itself has two new runnable examples that use the library directly, with no Centrifugo layer in between: _examples/map_demo (collaborative cursors, a game lobby, inventory management, a stock ticker, a live scoreboard, and a protocol visualizer, over the in-memory or Redis map broker) and _examples/shared_poll (a feature-flags demo with HMAC-signed per-key track authorization). _examples/map_presence_massive pushes map presence to 100k and 1M synchronized members in a single channel to show where the protocol's limits actually are.

Centrifugo, the server built on top of Centrifuge, showcases both features end to end at the product level, including a PostgreSQL-backed map broker (an application of Centrifuge's MapBroker interface, living in Centrifugo) with transactional publishing from your own database writes. Useful as extra documentation and as a demonstration of what the new primitives make possible:

• Docs:
  • Map subscriptions
  • Shared Poll subscriptions
• Blog:
  • Shared poll subscriptions: O(unique items) polling with low-latency updates
  • Map subscriptions Part 1
  • Map subscriptions Part 2 — the PostgreSQL map broker
• Runnable demos (Centrifugo + centrifuge-js):
  • map_cursors — real-time multi-user cursors over the Redis map broker
  • map_demo — a collection of map subscription scenarios, including a sprint board backed by PostgreSQL transactions
  • shared_poll_demo/votes — live vote results with dynamic per-key tracking
  • shared_poll_demo/drones — a 500-drone geospatial tracker using cell-based spatial partitioning

Redis reliability and failover behavior

This work started from centrifugal/centrifugo#1189: a report that Redis Sentinel pods could go permanently silent after a primary failover under load. WebSocket connections stayed open, publishes kept returning success, and /health stayed green — but nothing was actually being delivered to subscribers. Investigating it turned up several real problems, fixed both in Centrifuge itself and upstream in the rueidis driver it depends on.

Upstream, in rueidis (Centrifuge now pulls v1.0.77, up from v1.0.68 at v0.38.0), five fixes worth knowing about if you run Sentinel:

• redis/rueidis#1015 — after an ordinary failover, the client could close its own live connection and never open a new one. Every command then failed with ErrClosing, without even trying to dial a working node.
• redis/rueidis#1014 — when several goroutines waited on the same topology refresh and that refresh failed, all of them were incorrectly told it had succeeded (nil error), so their retry loops stopped instead of trying again. Combined with #1015 above, this is exactly how an ordinary few-second failover could turn into a permanent outage: the retry loop that should have replaced the closed connection was told everything was fine and gave up.
• redis/rueidis#1017 — when every Sentinel was briefly unreachable, the topology-refresh retry loop kept retrying with no delay between attempts. That used a full CPU core and flooded the surviving Sentinels with connection attempts at the exact moment they were running the election.
• redis/rueidis#1013 — Close() could hang forever on a connection that had silently stalled. In the Sentinel client, Close() was called while holding a lock, so this hang blocked all further topology handling on that client.
• redis/rueidis#1016 — new opt-in TopologyRefreshInterval, giving Sentinel a periodic backup path to notice a failover instead of relying solely on the +switch-master PUB/SUB event. Centrifuge now turns this on internally for every Sentinel-backed RedisShard, with a fixed 5-second interval — no config change needed (#611).

In Centrifuge itself:

• PUB/SUB liveness probes (#594) — a PUB/SUB connection can look perfectly healthy at the TCP level while it's attached to a Redis node that's no longer receiving any traffic (for example, a master that was just demoted by a failover). Subscribers on that connection stop receiving messages, but /health still reports everything is fine — exactly the symptom in #1189. Centrifuge now periodically sends a probe message on each PUB/SUB connection and checks it comes back; if it doesn't, the connection is torn down and rebuilt. This works independently of the rueidis-level fixes above.
• Bounded Redis keepalive (#592) so a silently stalled connection (TCP open, peer frozen or partitioned) is detected and torn down in bounded time instead of hanging.
• Read operations no longer retry forever during a Redis outage (#591) — reads now fail fast like writes already did.
• Sharded PUB/SUB resubscribe no longer risks a cross-slot SSUBSCRIBE panic on Redis Cluster when a PUB/SUB connection reconnects with live subscriptions already in place — fixed as part of the subscription-handling refactor in #565 (reported in #613, thanks to the detailed report).
• Redis Cluster channel keys now use hash tags consistently to avoid cross-slot script errors (#541).
• If you use sharded PUB/SUB on Redis Cluster (NumShardedPubSubPartitions > 0) with many partitions, look at the new opt-in RedisBrokerConfig.UsePrecomputedPartitionTags (#570, reported in #554): the hash tag used to pick a partition's connection was a bare index ({0}, {1}, ...), and CRC16 collisions between those short tags can cause severe load skew on larger clusters — at 16 shards, roughly half the nodes saw zero PUB/SUB traffic. The option switches to a precomputed tag table that spreads evenly; the default is unchanged, so existing deployments aren't affected unless you turn it on.

If you're running Redis Cluster or Sentinel, this release is worth prioritizing.

Connection runtime stability

#590 is the largest single PR in this release — a full audit of the subscribe/unsubscribe/close lifecycle that started as a presence-tick performance pass. Highlights:

• Up to ~500x faster hub metrics. Hub.NumClients and Hub.NumSubscriptions used to be O(n) scans taken under the hub's read lock, so a Prometheus scrape on a large node both burned CPU and contended with the broadcast path. They're now O(shard-count) counters — measured ~137x faster for NumClients and ~495x faster for NumSubscriptions at 5k connections / 20k subscriptions, and the gap widens with node size.
• Presence tick ~34% faster, ~60% less garbage per tick — a pooled snapshot replaces a per-tick copy of the whole channel map, and channels with no periodic work are skipped entirely. Meaningful GC relief at 100k+ connections.
• Subscription-state consistency (the core fix). Under concurrent subscribe/unsubscribe/close on the same channel, the Hub's routing table and a connection's own c.channels could disagree — previously, a stalled or racing subscribe could tear down a subscription that had just succeeded, leak a hub entry, leak presence until TTL expiry, or drift the connections_inflight/subscriptions_inflight metrics. Every reservation is now identity-matched by generation, which closes this entire category of bugs.
• Six data races fixed under -race, including a deadlock between a recovering subscribe's close path and broadcast, and a double-write to Publication.Offset in MemoryBroker.Publish.
• Eight resource leaks fixed, among them a connect-time server-side subscription leak, a goroutine leak in the per-channel batch writer when its timer is cancelled, and keyed/map state left behind after unsubscribe.
• Recovery now correctly applies the server-side tags filter on stream, cache, and map catch-up paths, which it previously skipped in some of those paths.
• Validated by a new self-checking regression harness added alongside, _examples/stress_runtime, which drives real centrifuge-go clients and raw protocol clients against a multi-node memory + Redis cluster through 16 adversarial scenarios and asserts full state convergence afterwards.

Two related fixes from separate PRs: reordering disconnect to close the transport before the synchronous per-channel presence/leave cleanup, so a slow Redis round trip no longer keeps a dead socket open — in one reproduction, peak concurrent sockets during a reconnect storm dropped from ~13 to ~2 (#595); and a closer audit of the recovery and channel-medium code that turned up three more bugs, each with its own regression test: an index-out-of-range in recovery's publication merge when a buffered window contained only filtered publications, a goroutine leak in channelMedium teardown present on any server using queued/delayed medium options, and a join/leave wire-ordering race where a client that disconnected very quickly after subscribing could have its leave event reach observers before its join (#574).

Security

• GHSA-4r3x-2rwr-6w65: the stream command decoder could be driven to allocate unbounded memory from a single frame declaring a huge length, since the configured message size limit wasn't actually reaching the decoder. Fixed by requiring every transport to pass its message size limit down into the decoder (#612, protocol #40/#41). This is a breaking change to the exported HandleReadFrame helper.
• WebSocket decompressed message size limit and outgoing close-code tracking, hardening against decompression bombs (#584).

Other notable changes

• SubscribeOptions.AutoCacheRecover lets the server initiate cache recovery for a subscription even when the client has no way to ask for it itself — needed for server-side subscriptions of unidirectional clients (SSE, HTTP-streaming, unidirectional WebSocket), which only send a token and have no protocol-level way to attach recover: true (#581, #582).
• Client labels — attach a map[string]string to a connection at connect time for Prometheus metric segmentation and targeted Node.{Subscribe,Unsubscribe,Disconnect,Refresh} operations via LabelFilter, scoped across all users of a label value (#539, #577).
• WebsocketConfig.ProcessCommandsOffReadLoop — a WebSocket read loop processes each command inline (handler, broker, broadcast fan-out), so its goroutine stack grows to fit the deepest call it ever makes — around 8KB — and never shrinks back, even once the connection goes idle for the rest of its life. With this option on, each frame is handed to a short-lived goroutine instead, so the deep stack returns to Go's runtime pool and gets reused by other connections. Trades a bit of latency for meaningfully less memory per idle connection at scale (#607). See Tuning Centrifugo PRO for large number of idle WebSocket connections for measured numbers on real workloads: this option alone took idle-connection goroutine stacks from ~12.3KB to ~8.2KB per connection, and combined with four other Centrifugo PRO tuning options, it let the same 16-core node hold 1,000,000 idle WebSocket connections using ~2.3 CPU cores and ~11GB of memory — versus needing well over the machine's RAM at the default configuration.
• Native Prometheus histograms support (#575, example: _examples/native_histograms_otel showing the metrics → OTel bridge pipeline), plus a dedicated map_broker metrics subsystem and clearer broker metric naming (#583).
• Several allocation and throughput improvements in the write/broadcast path: removing a per-drain allocation from broadcast fan-out to every connection (#598), and reduced Prometheus metrics overhead plus fewer allocations on the write-many (batching) path — measured CPU usage under a batching benchmark dropping from ~58% to ~36% across both changes (#530, #535). Building Redis keys (for channels, presence, streams) is also faster and allocates less — up to 36% faster in some cases, with some paths going from two allocations to one (#534).
• Fixed a crash: a delta publication whose JSON encoding fails could dereference a nil pointer and panic the broadcasting goroutine, taking down the whole process since nothing recovers from it (#597). Also fixed a bug where a publication suppressed by version could incorrectly disconnect the client instead of being ignored, matching how MemoryBroker already handled it (#549), and an HTTP/2 WebSocket stream failure caused by a stale write deadline left behind after a frame ping (cf_ws_frame_ping_pong=true only) (#588).
• Node.Shutdown no longer leaves the metrics-aggregator goroutine running after shutdown — a one-goroutine-per-Shutdown leak that only mattered for apps that create and tear down many Node instances in one process, such as tests (ed306c6).
• A client publishing an empty payload used to get disconnected ("channel and data required for publish"); now it's accepted, since an empty payload can be a meaningful signal on its own — whether that's valid is left to the application to decide (#536).
• RedisShardConfig.AuthCredentialsFn lets you supply Redis auth credentials dynamically per connection attempt, instead of a fixed password — needed for managed Redis/Valkey setups that use short-lived, rotating tokens, such as GCP or AWS IAM authentication (#560, thanks to @kf-ajaib).
• Fixed a missing Unlock() on an early-return path in the writer that could deadlock it (#552, thanks to @palkan).
• CI now tests against currently-supported datastore versions instead of stale/EOL ones: Redis drops major 6 and tests the latest two majors (7, 8); Valkey gets its own CI matrix dimension, testing the latest two majors (8, 9) instead of a single fixed version; and the pinned Dragonfly image moves from v1.27.1 to v1.40.1 (#616).

SDK ecosystem

This is a Centrifuge (Go library) changelog, so none of this shipped as part of v0.39.0 itself — but Centrifugal Labs has also been closing capability gaps across the official client SDKs, so a feature isn't limited to whichever platform it launched on first:

• getState on stream subscriptions is now supported by every official SDK — JavaScript, Go, Swift, Java/Kotlin, Dart, Python, and C#. It's an option where the SDK asks your application for its current state and the stream position that state corresponds to, right before subscribing — and again, later, if recovery ever turns out to be impossible, so a subscription is never left running on top of stale state. This replaces a fair amount of manual re-sync code applications used to write by hand for exactly this problem. See App-owned state with stream subscriptions for the full pattern, with a Kafka aggregator and a multi-tenant kitchen-orders example worked through end to end.
• Server-side publication filtering by tags has also reached every official SDK by now. A publication can carry tags, an SDK subscribes with a tag filter, and the server matches publications against it before they ever go over the wire — so a client only pays bandwidth and processing cost for the messages it actually wants, instead of receiving everything on a channel and discarding the rest client-side. See Server-side publication filtering by tags for how it works.

github.com/centrifugal/protocol updated to v0.22.1

centrifuge takes a decoder/encoder from this package for every WebSocket frame, so its perf work lands directly on Centrifuge's hot path. Two rounds of decode/encode optimization, benchmarked on Apple M4 against unmodified code:

#41 also closed a gap where a command's size limit was only checked on some code paths, letting an oversized command slip through at up to roughly 2x the configured limit in a multi-command frame — now enforced consistently and paired with the mandatory-limit change described under Security above. Other changes pulled in along the way (v0.17.0 → v0.22.0): new fields to support Map/Shared Poll subscriptions and server-side tag filtering (#33, #35), and a DeflateFrameCodec.Decompress fix for silent truncation at maxSize=math.MaxInt (#48).

Upgrading from v0.38.0

For the vast majority of setups — using the built-in RedisBroker/MemoryBroker as-is, standard transports — this should be a smooth, drop-in upgrade: bump the dependency, go build, done. Two things require actual code changes, and both are narrow:

• You have a custom Broker implementation. Broker.Publish now returns (PublishResult, error) instead of (StreamPosition, bool, error) — PublishResult carries the suppression info (Suppressed, SuppressReason) that Map/Shared Poll publish semantics need. PublishResult.FromCache was removed. Broker.Subscribe/Unsubscribe now take a variadic ...string instead of a single channel, to support batching. If you only use RedisBroker/MemoryBroker through Node.SetBroker, you're unaffected — Centrifuge calls these methods internally.
• You call the exported HandleReadFrame helper directly (only relevant if you've implemented a custom transport on top of centrifuge.Client). It gained a mandatory messageSizeLimit int64 parameter — see Security above for why.

A few behavioral changes ship without any API change, worth a quick read even though no code changes are needed:

• If you use WebSocket compression and don't set WebsocketConfig.DecompressedMessageSizeLimit explicitly, decompressed messages are now capped at 10x MessageSizeLimit by default (previously unbounded) — set the field explicitly if you legitimately expect higher compression ratios (#584).
• Client.Subscribe/Node.Subscribe can now return ErrorAlreadySubscribed for a channel that's already subscribed (and, new, while a map subscribe is still loading that same channel). If you call it idempotently, treat this error as success (#590).
• On the disconnect path, OnUnsubscribe now fires after the transport is closed rather than before (matching OnDisconnect, which already did) — only matters if a handler assumed it could still write to the disconnecting client from OnUnsubscribe (#590, #595).

Everything else — Map/Shared Poll subscriptions, client labels, native histograms, ProcessCommandsOffReadLoop, the Sentinel/Redis reliability work — is either opt-in or purely internal, so it applies automatically without touching your config.

Looking ahead

Centrifuge was originally built around a single subscription type — stream subscriptions — and SubscribeOptions and the client protocol grew around that one assumption. Now that Map and Shared Poll subscriptions exist too, SubscribeOptions mixes fields and events that only make sense for one subscription type with fields that make sense for another. We're looking into ways to draw a clearer boundary between subscription types and give each one a more explicit, purpose-built set of options, which may also mean some changes to the client protocol down the line. To be clear: this is early exploration, not work in progress — no implementation has started, and we'll share specifics if and when it does.

Full changelog and API diff

See the list of merged PRs for the complete set of changes, including CI and dependency updates not listed above.

gorelease -base v0.38.0 -version v0.39.0
# github.com/centrifugal/centrifuge
## incompatible changes
(*MemoryBroker).Publish: changed from func(string, []byte, PublishOptions) (StreamPosition, bool, error) to func(string, []byte, PublishOptions) (PublishResult, error)
(*MemoryBroker).Subscribe: changed from func(string) error to func(...string) error
(*MemoryBroker).Unsubscribe: changed from func(string) error to func(...string) error
(*RedisBroker).Publish: changed from func(string, []byte, PublishOptions) (StreamPosition, bool, error) to func(string, []byte, PublishOptions) (PublishResult, error)
(*RedisBroker).Subscribe: changed from func(string) error to func(...string) error
(*RedisBroker).Unsubscribe: changed from func(string) error to func(...string) error
Broker.Publish: changed from func(string, []byte, PublishOptions) (StreamPosition, bool, error) to func(string, []byte, PublishOptions) (PublishResult, error)
Broker.Subscribe: changed from func(string) error to func(...string) error
Broker.Unsubscribe: changed from func(string) error to func(...string) error
HandleReadFrame: changed from func(*Client, io.Reader) bool to func(*Client, io.Reader, int64) bool
PublishResult.FromCache: removed
## compatible changes
(*Client).Labels: added
(*Client).OnMapPublish: added
(*Client).OnMapRemove: added
(*Client).OnTrack: added
(*Client).OnUntrack: added
(*Client).Profile: added
(*Hub).BroadcastPublicationDelta: added
(*Node).AddMapBrokerCleanupRemoved: added
(*Node).IncMapBrokerCleanupErrors: added
(*Node).IncTransportOutgoingClose: added
(*Node).MapClear: added
(*Node).MapPublish: added
(*Node).MapRemove: added
(*Node).MapStateRead: added
(*Node).MapStats: added
(*Node).MapStreamRead: added
(*Node).OnSharedPoll: added
(*Node).SetMapBroker: added
(*Node).SetMapBrokerCleanupLag: added
(*Node).SharedPollNotify: added
(*Node).SharedPollPublish: added
Config.Map: added
Config.SharedPoll: added
ConnectEvent.Profile: added
ConnectReply.Labels: added
ConnectReply.Profile: added
ConnectReply.QueueShrinkDelay: added
ConnectReply.WriteWithTimer: added
DisconnectStateInvalidated: added
ErrorConcurrentPagination: added
FilterNode: added
KeyMode: added
KeyModeIfExists: added
KeyModeIfNew: added
KeyModeReplace: added
MakeOrderedCursor: added
MapBroker: added
MapChannelOptions: added
MapClearOptions: added
MapConfig: added
MapCurrentEntry: added
MapMode: added
MapModeEphemeral: added
MapModePersistent: added
MapModeRecoverable: added
MapPhaseLive: added
MapPhaseState: added
MapPhaseStream: added
MapPublishCallback: added
MapPublishEvent: added
MapPublishHandler: added
MapPublishOptions: added
MapPublishReply: added
MapReadStateOptions: added
MapReadStreamOptions: added
MapRemoveCallback: added
MapRemoveEvent: added
MapRemoveHandler: added
MapRemoveOptions: added
MapRemoveReply: added
MapStateResult: added
MapStats: added
MapStatsResult: added
MapStreamResult: added
MapUpdateResult: added
MemoryMapBroker: added
MemoryMapBrokerConfig: added
MetricsConfig.ClientLabels: added
MetricsConfig.EnableNativeHistograms: added
NewMemoryMapBroker: added
NewRedisMapBroker: added
Publication.Epoch: added
Publication.Key: added
Publication.Removed: added
Publication.Score: added
Publication.Version: added
PublishOptions.Epoch: added
PublishOptions.Key: added
PublishOptions.Offset: added
PublishOptions.PrevData: added
PublishOptions.Removed: added
PublishResult.SuppressReason: added
PublishResult.Suppressed: added
RedisAuthCredentials: added
RedisAuthCredentialsContext: added
RedisBrokerConfig.UsePrecomputedPartitionTags: added
RedisMapBroker: added
RedisMapBrokerConfig: added
RedisShardConfig.AuthCredentialsFn: added
ResolveAndValidateMapChannelOptions: added
SharedPollChannelOptions: added
SharedPollConfig: added
SharedPollEvent: added
SharedPollHandler: added
SharedPollItem: added
SharedPollManager: added
SharedPollModeVersioned: added
SharedPollModeVersionless: added
SharedPollNotification: added
SharedPollNotificationItem: added
SharedPollRefreshItem: added
SharedPollResult: added
StreamFilter: added
SubRefreshReply.ServerTagsFilter: added
SubscribeEvent.Type: added
SubscribeOptions.AutoCacheRecover: added
SubscribeOptions.ClientPublishDebounceInterval: added
SubscribeOptions.MapClientPresenceChannel: added
SubscribeOptions.MapRemoveClientOnUnsubscribe: added
SubscribeOptions.MapUserPresenceChannel: added
SubscribeOptions.ServerTagsFilter: added
SubscribeOptions.Type: added
SubscribeReply.Publications: added
SubscriptionType: added
SubscriptionTypeMap: added
SubscriptionTypeMapClients: added
SubscriptionTypeMapUsers: added
SubscriptionTypeSharedPoll: added
SubscriptionTypeStream: added
SuppressReason: added
SuppressReasonIdempotency: added
SuppressReasonKeyExists: added
SuppressReasonKeyNotFound: added
SuppressReasonNone: added
SuppressReasonPositionMismatch: added
SuppressReasonVersion: added
TrackBatch: added
TrackBatchReply: added
TrackCallback: added
TrackEvent: added
TrackHandler: added
TrackItem: added
TrackReply: added
TransportWriteEvent.Key: added
UnsubscribeCodeStateInvalidated: added
UntrackEvent: added
UntrackHandler: added
WebsocketConfig.DecompressedMessageSizeLimit: added
WebsocketConfig.ProcessCommandsOffReadLoop: added
WithAutoCacheRecover: added
WithDisconnectAllUsers: added
WithDisconnectLabelFilter: added
WithKey: added
WithRefreshAllUsers: added
WithRefreshLabelFilter: added
WithSubscribeAllUsers: added
WithSubscribeLabelFilter: added
WithUnsubscribeAllUsers: added
WithUnsubscribeLabelFilter: added

# summary
v0.39.0 is a valid semantic version for this release.