natsdotnet/docs/structuregaps.md

Implementation Gaps: Go NATS Server vs .NET Port

Last updated: 2026-02-25

Overview

Metric	Go Server	.NET Port	Ratio
Source lines	~130K (109 files)	~39.1K (215 files)	3.3x
Test methods	2,937 func Test*	5,808 [Fact]/[Theory] (~6,409 with parameterized)	2.0x
Go tests mapped	2,646 / 2,937 (90.1%)	—	—
.NET tests linked to Go	—	2,485 / 5,808 (42.8%)	—
Largest source file	filestore.go (12,593 lines)	NatsServer.cs (1,883 lines)	6.7x

The .NET port has grown significantly from the prior baseline (~27K→~39.1K lines). All 15 original gaps have seen substantial growth. However, many specific features within each subsystem remain unimplemented. This document catalogs the remaining gaps based on a function-by-function comparison.

Gap Severity Legend

• CRITICAL: Core functionality missing, blocks production use
• HIGH: Important feature incomplete, limits capabilities significantly
• MEDIUM: Feature gap exists but workarounds are possible or feature is less commonly used
• LOW: Nice-to-have, minor optimization or edge-case handling

---

Gap 1: FileStore Block Management (CRITICAL)

Go reference: filestore.go — 12,593 lines NET implementation: FileStore.cs (1,633) + MsgBlock.cs (630) + supporting files Current .NET total: ~5,196 lines in Storage/ Gap factor: 2.4x (down from 20.8x)

The .NET FileStore has grown substantially with block-based storage, but the block lifecycle, encryption/compression integration, crash recovery, and integrity checking remain incomplete.

1.1 Block Rotation & Lifecycle (CRITICAL)

Missing Go functions:

• initMsgBlock() (line 1046) — initializes new block with metadata
• recoverMsgBlock() (line 1148) — recovers block from disk with integrity checks
• newMsgBlockForWrite() (line 4485) — creates writable block with locking
• spinUpFlushLoop() + flushLoop() (lines 5783–5842) — background flusher goroutine
• enableForWriting() (line 6622) — opens FD for active block with gating semaphore (dios)
• closeFDs() / closeFDsLocked() (lines 6843–6849) — explicit FD management
• shouldCompactInline() (line 5553) — inline compaction heuristics
• shouldCompactSync() (line 5561) — sync-time compaction heuristics

.NET status: Basic block creation/recovery exists but no automatic rotation on size thresholds, no block sealing, no per-block metadata files, no background flusher.

1.2 Encryption Integration into Block I/O (CRITICAL)

Go encrypts block files on disk using per-block AEAD keys. The .NET AeadEncryptor exists as a standalone utility but is NOT wired into the block write/read path.

Missing Go functions:

• genEncryptionKeys() (line 816) — generates AEAD + stream cipher per block
• recoverAEK() (line 878) — recovers encryption key from metadata
• setupAEK() (line 907) — sets up encryption for the stream
• loadEncryptionForMsgBlock() (line 1078) — loads per-block encryption state
• checkAndLoadEncryption() (line 1068) — verifies encrypted block integrity
• ensureLastChecksumLoaded() (line 1139) — validates block checksum
• convertCipher() (line 1318) — re-encrypts block with new cipher
• convertToEncrypted() (line 1407) — converts plaintext block to encrypted

Impact: Go provides end-to-end encryption of block files on disk. .NET stores block files in plaintext.

1.3 S2 Compression in Block Path (CRITICAL)

Go compresses payloads at the message level during block write and decompresses on read. .NET's S2Codec is standalone only.

Missing Go functions:

• setupWriteCache() (line 4443) — initializes compression-aware write cache
• Block-level compression/decompression during loadMsgs/flushPendingMsgs

Impact: Go block files are compressed (smaller disk footprint). .NET block files are uncompressed.

1.4 Crash Recovery & Index Rebuilding (CRITICAL)

Missing Go functions:

• recoverFullState() (line 1754) — full recovery from blocks with lost-data tracking
• recoverTTLState() (line 2042) — recovers TTL wheel state post-crash
• recoverMsgSchedulingState() (line 2123) — recovers scheduled message delivery post-crash
• recoverMsgs() (line 2263) — scans all blocks and rebuilds message index
• rebuildState() (line 1446) — per-block state reconstruction
• rebuildStateFromBufLocked() (line 1493) — parses raw block buffer to rebuild state
• expireMsgsOnRecover() (line 2401) — enforces MaxAge on recovery
• writeTTLState() (line 10833) — persists TTL state to disk

.NET status: FileStore.RecoverBlocks() exists but is minimal — no TTL wheel recovery, no scheduling recovery, no lost-data tracking, no tombstone cleanup.

1.5 Checksum Validation (HIGH)

Go uses highway hash for per-message checksums and validates integrity on read.

Missing:

• msgBlock.lchk[8]byte — last checksum buffer
• msgBlock.hh *highwayhash.Digest64 — highway hasher
• msgBlock.lastChecksum() (line 2204) — returns last computed checksum
• Message checksum validation during msgFromBufEx() (line ~8180)

.NET status: MessageRecord has no checksum field. No integrity checks on read.

1.6 Atomic File Overwrites (HIGH)

Go uses temp file + rename for crash-safe state updates.

Missing:

• _writeFullState() (line 10599) — atomic state serialization with temp file + rename
• State file write protection with mutual exclusion (wfsmu/wfsrun)

.NET status: Writes directly without atomic guarantees.

1.7 Tombstone & Deletion Tracking (HIGH)

Missing:

• removeMsg() (line 5267) — removes message with optional secure erase
• removeMsgFromBlock() (line 5307) — removes from specific block
• eraseMsg() (line 5890) — overwrites deleted message with random data (secure erase)
• Sparse avl.SequenceSet for deletion tracking (Go uses AVL; .NET uses HashSet<ulong>)
• Tombstone record persistence (deleted messages lost on crash in .NET)

1.8 Multi-Block Write Cache (MEDIUM)

Missing Go functions:

• setupWriteCache() (line 4443) — sets up write cache
• finishedWithCache() (line 4477) — marks cache complete
• expireCache() / expireCacheLocked() (line 6148+) — expires idle cache
• resetCacheExpireTimer() / startCacheExpireTimer() — manages cache timeout
• Elastic reference machinery (line 6704, ecache.Strengthen() / WeakenAfter())
• flushPendingMsgs() / flushPendingMsgsLocked() (line 7560+) — background flush

.NET status: Synchronous flush on rotation; no background flusher, no cache expiration.

1.9 Missing IStreamStore Interface Methods (CRITICAL)

Method	Go Equivalent	.NET Status
StoreRawMsg	filestore.go:4759	Missing
LoadNextMsgMulti	filestore.go:8426	Missing
LoadPrevMsg	filestore.go:8580	Missing
LoadPrevMsgMulti	filestore.go:8634	Missing
NumPendingMulti	filestore.go:4051	Missing
SyncDeleted	—	Missing
EncodedStreamState	filestore.go:10599	Missing
Utilization	filestore.go:8758	Missing
FlushAllPending	—	Missing
RegisterStorageUpdates	filestore.go:4412	Missing
RegisterStorageRemoveMsg	filestore.go:4424	Missing
RegisterProcessJetStreamMsg	filestore.go:4431	Missing
ResetState	filestore.go:8788	Missing
UpdateConfig	filestore.go:655	Stubbed
Delete(bool)	—	Incomplete
Stop()	—	Incomplete

1.10 Query/Filter Operations (MEDIUM)

Go uses trie-based subject indexing (SubjectTree[T]) for O(log n) lookups. .NET uses linear LINQ scans.

Missing:

• FilteredState() (line 3191) — optimized filtered state with caching
• checkSkipFirstBlock() family (lines 3241–3287)
• numFiltered*() family (lines 3308–3413)
• LoadMsg() (line 8308) — block-aware message loading

---

Gap 2: JetStream Cluster Coordination (CRITICAL)

Go reference: jetstream_cluster.go — 10,887 lines NET implementation: JetStreamMetaGroup.cs (454) + StreamReplicaGroup.cs (300) + supporting files Current .NET total: ~2,787 lines in Cluster/ + Raft/ Gap factor: ~3.9x Missing functions: ~84

The .NET implementation provides a skeleton suitable for unit testing but lacks the real cluster coordination machinery. The Go implementation is deeply integrated with RAFT, NATS subscriptions for inter-node communication, and background monitoring goroutines.

2.1 Cluster Monitoring Loop (CRITICAL)

The main orchestration loop that drives cluster state transitions.

Missing Go functions:

• monitorCluster() (lines 1455–1825, 370 lines) — processes metadata changes from RAFT ApplyQ
• checkForOrphans() (lines 1378–1432) — identifies unmatched streams/consumers after recovery
• getOrphans() (lines 1433–1454) — scans all accounts for orphaned assets
• checkClusterSize() (lines 1828–1869) — detects mixed-mode clusters, adjusts bootstrap size
• isStreamCurrent(), isStreamHealthy(), isConsumerHealthy() (lines 582–679)
• subjectsOverlap() (lines 751–767) — prevents subject collisions
• Recovery state machine (recoveryUpdates struct, lines 1332–1366)

2.2 Stream & Consumer Assignment Processing (CRITICAL)

Missing Go functions:

• processStreamAssignment() (lines 4541–4647, 107 lines)
• processUpdateStreamAssignment() (lines 4650–4768)
• processStreamRemoval() (lines 5216–5265)
• processConsumerAssignment() (lines 5363–5542, 180 lines)
• processConsumerRemoval() (lines 5543–5599)
• processClusterCreateStream() (lines 4944–5215, 272 lines)
• processClusterDeleteStream() (lines 5266–5362, 97 lines)
• processClusterCreateConsumer() (lines 5600–5855, 256 lines)
• processClusterDeleteConsumer() (lines 5856–5925)
• processClusterUpdateStream() (lines 4798–4943, 146 lines)

2.3 Inflight Request Deduplication (HIGH)

Missing:

• trackInflightStreamProposal() (lines 1193–1210)
• removeInflightStreamProposal() (lines 1214–1230)
• trackInflightConsumerProposal() (lines 1234–1257)
• removeInflightConsumerProposal() (lines 1260–1278)
• Full inflight tracking with ops count, deleted flag, and assignment capture

2.4 Peer Management & Stream Moves (HIGH)

Missing:

• processAddPeer() (lines 2290–2340)
• processRemovePeer() (lines 2342–2393)
• removePeerFromStream() / removePeerFromStreamLocked() (lines 2396–2439)
• remapStreamAssignment() (lines 7077–7111)
• Stream move operations in jsClusteredStreamUpdateRequest() (lines 7757+)

2.5 Leadership Transition (HIGH)

Missing:

• processLeaderChange() (lines 7001–7074) — meta-level leader change
• processStreamLeaderChange() (lines 4262–4458, 197 lines) — stream-level
• processConsumerLeaderChange() (lines 6622–6793, 172 lines) — consumer-level
• Step-down mechanisms: JetStreamStepdownStream(), JetStreamStepdownConsumer()

2.6 Snapshot & State Recovery (HIGH)

Missing:

• metaSnapshot() (line 1890) — triggers meta snapshot
• encodeMetaSnapshot() (lines 2075–2145) — binary+S2 compression
• decodeMetaSnapshot() (lines 2031–2074) — reverse of encode
• applyMetaSnapshot() (lines 1897–2030, 134 lines) — computes deltas and applies
• collectStreamAndConsumerChanges() (lines 2146–2240)
• Per-stream monitorStream() (lines 2895–3700, 800+ lines)
• Per-consumer monitorConsumer() (lines 6081–6350, 270+ lines)

2.7 Entry Application Pipeline (HIGH)

Missing:

• applyMetaEntries() (lines 2474–2609, 136 lines) — handles all entry types
• applyStreamEntries() (lines 3645–4067, 423 lines) — per-stream entries
• applyStreamMsgOp() (lines 4068–4261, 194 lines) — per-message ops
• applyConsumerEntries() (lines 6351–6621, 271 lines) — per-consumer entries

2.8 Topology-Aware Placement (MEDIUM)

Missing from PlacementEngine (currently 80 lines vs Go's 312 lines for selectPeerGroup()):

• Unique tag enforcement (JetStreamUniqueTag)
• HA asset limits per peer
• Dynamic available storage calculation
• Tag inclusion/exclusion with prefix handling
• Weighted node selection based on availability
• Mixed-mode detection
• tieredStreamAndReservationCount() (lines 7524–7546)
• createGroupForConsumer() (lines 8783–8923, 141 lines)
• jsClusteredStreamLimitsCheck() (lines 7599–7618)

2.9 RAFT Group Creation & Lifecycle (MEDIUM)

Missing:

• createRaftGroup() (lines 2659–2789, 131 lines)
• raftGroup.isMember() (lines 2611–2621)
• raftGroup.setPreferred() (lines 2623–2656)

2.10 Assignment Encoding/Decoding (MEDIUM)

Missing (no serialization for RAFT persistence):

• encodeAddStreamAssignment(), encodeUpdateStreamAssignment(), encodeDeleteStreamAssignment()
• decodeStreamAssignment(), decodeStreamAssignmentConfig()
• encodeAddConsumerAssignment(), encodeDeleteConsumerAssignment()
• encodeAddConsumerAssignmentCompressed(), decodeConsumerAssignment()
• decodeConsumerAssignmentCompressed(), decodeConsumerAssignmentConfig()

2.11 Unsupported Asset Handling (LOW)

Missing:

• unsupportedStreamAssignment type (lines 186–247) — graceful handling of version-incompatible streams
• unsupportedConsumerAssignment type (lines 268–330)

2.12 Clustered API Handlers (MEDIUM)

Missing:

• jsClusteredStreamRequest() (lines 7620–7701, 82 lines)
• jsClusteredStreamUpdateRequest() (lines 7757–8265, 509 lines)
• System-level subscriptions for result processing, peer removal, leadership step-down

---

Gap 3: Consumer Delivery Engines (HIGH)

Go reference: consumer.go — 6,715 lines, 209 functions NET implementation: PushConsumerEngine.cs (264) + PullConsumerEngine.cs (411) + AckProcessor.cs (225) + PriorityGroupManager.cs (102) + RedeliveryTracker.cs (92) + ConsumerManager.cs (198) Current .NET total: ~1,292 lines Gap factor: 5.2x

3.1 Core Message Delivery Loop (CRITICAL)

Missing: loopAndGatherMsgs() (Go lines ~1400–1700) — the main consumer dispatch loop that:

• Polls stream store for new messages matching filter
• Applies redelivery logic
• Handles num_pending calculations
• Manages delivery interest tracking
• Responds to stream updates

3.2 Pull Request Pipeline (CRITICAL)

Missing: processNextMsgRequest() (Go lines ~4276–4450) — full pull request handler with:

• Waiting request queue management (waiting list with priority)
• Max bytes accumulation and flow control
• Request expiry handling
• Batch size enforcement
• Pin ID assignment from priority groups

3.3 Inbound Ack/NAK Processing Loop (HIGH)

Missing: processInboundAcks() (Go line ~4854) — background goroutine that:

• Reads from ack subject subscription
• Parses +ACK, -NAK, +TERM, +WPI frames
• Dispatches to appropriate handlers
• Manages ack deadlines and redelivery scheduling

3.4 Redelivery Scheduler (HIGH)

Missing: Redelivery queue (rdq) as a min-heap/priority queue. RedeliveryTracker only tracks deadlines, doesn't:

• Order redeliveries by deadline
• Batch redelivery dispatches efficiently
• Support per-sequence redelivery state
• Handle redelivery rate limiting

3.5 Idle Heartbeat & Flow Control (HIGH)

Missing:

• sendIdleHeartbeat() (Go line ~5222) — heartbeat with pending counts and stall headers
• sendFlowControl() (Go line ~5495) — dedicated flow control handler
• Flow control reply generation with pending counts

3.6 Priority Group Pinning (HIGH)

PriorityGroupManager exists (102 lines) but missing:

• Pin ID (NUID) generation and assignment (setPinnedTimer, assignNewPinId, unassignPinId)
• Pin timeout timers (pinnedTtl)
• Nats-Pin-Id header response
• Advisory messages on pin/unpin events
• Priority group state persistence

3.7 Pause/Resume State Management (HIGH)

Missing:

• PauseUntil deadline tracking
• Pause expiry timer
• Pause advisory generation ($JS.EVENT.ADVISORY.CONSUMER.PAUSED)
• Resume/unpause event generation
• Pause state in consumer info response

3.8 Delivery Interest Tracking (HIGH)

Missing: Dynamic delivery interest monitoring:

• Subject interest change tracking
• Gateway interest checks
• Subscribe/unsubscribe tracking for delivery subject
• Interest-driven consumer cleanup (deleteNotActive)

3.9 Max Deliveries Enforcement (MEDIUM)

AckProcessor checks basic threshold but missing:

• Advisory event generation on exceeding max delivers
• Per-delivery-count policy selection
• NotifyDeliveryExceeded advisory

3.10 Filter Subject Skip Tracking (MEDIUM)

Missing: Efficient filter matching with compiled regex, skip list tracking, UpdateSkipped state updates.

3.11 Sample/Observe Mode (MEDIUM)

Missing: Sample frequency parsing ("1%"), stochastic sampling, latency measurement, latency advisory generation.

3.12 Reset to Sequence (MEDIUM)

Missing: processResetReq() (Go line ~4241) — consumer state reset to specific sequence.

3.13 Rate Limiting (MEDIUM)

PushConsumerEngine has basic rate limiting but missing accurate token bucket, dynamic updates, per-message delay calculation.

3.14 Cluster-Aware Pending Requests (LOW)

Missing: Pull request proposals to RAFT, cluster-wide pending request tracking.

---

Gap 4: Stream Mirrors, Sources & Lifecycle (HIGH)

Go reference: stream.go — 8,072 lines, 193 functions NET implementation: StreamManager.cs (644) + MirrorCoordinator.cs (364) + SourceCoordinator.cs (470) Current .NET total: ~1,478 lines Gap factor: 5.5x

4.1 Mirror Consumer Setup & Retry (HIGH)

MirrorCoordinator (364 lines) exists but missing:

• Complete mirror consumer API request generation
• Consumer configuration with proper defaults
• Subject transforms for mirror
• Filter subject application
• OptStartSeq/OptStartTime handling
• Mirror error state tracking (setMirrorErr)
• Scheduled retry with exponential backoff
• Mirror health checking

4.2 Mirror Message Processing (HIGH)

Missing from MirrorCoordinator:

• Gap detection in mirror stream (deleted/expired messages)
• Sequence alignment (sseq/dseq tracking)
• Mirror-specific handling for out-of-order arrival
• Mirror error advisory generation

4.3 Source Consumer Setup (HIGH)

SourceCoordinator (470 lines) exists but missing:

• Complete source consumer API request generation
• Subject filter configuration
• Subject transform setup
• Account isolation verification
• Flow control configuration
• Starting sequence selection logic

4.4 Deduplication Window Management (HIGH)

SourceCoordinator has _dedupWindow but missing:

• Time-based window pruning
• Memory-efficient cleanup
• Statistics reporting (DeduplicatedCount)
• Nats-Msg-Id header extraction integration

4.5 Purge with Subject Filtering (HIGH)

Missing:

• Subject-specific purge (preq.Subject)
• Sequence range purge (preq.Sequence)
• Keep-N functionality (preq.Keep)
• Consumer purge cascading based on filter overlap

4.6 Interest Retention Enforcement (HIGH)

Missing:

• Interest-based message cleanup (checkInterestState/noInterest)
• Per-consumer interest tracking
• noInterestWithSubject for filtered consumers
• Orphan message cleanup

4.7 Stream Snapshot & Restore (MEDIUM)

StreamSnapshotService is a 10-line stub. Missing:

• Snapshot deadline enforcement
• Consumer inclusion/exclusion
• TAR + S2 compression/decompression
• Snapshot validation
• Partial restore recovery

4.8 Stream Config Update Validation (MEDIUM)

Missing:

• Subjects overlap checking
• Mirror/source config validation
• Subjects modification handling
• Template update propagation
• Discard policy enforcement

4.9 Source Retry & Health (MEDIUM)

Missing:

• retrySourceConsumerAtSeq() — retry with exponential backoff
• cancelSourceConsumer() — source consumer cleanup
• retryDisconnectedSyncConsumers() — periodic health check
• setupSourceConsumers() — bulk initialization
• stopSourceConsumers() — coordinated shutdown

4.10 Source/Mirror Info Reporting (LOW)

Missing: Source/mirror lag, error state, consumer info for monitoring responses.

---

Gap 5: Client Protocol Handling (HIGH)

Go reference: client.go — 6,716 lines, 162+ functions NET implementation: NatsClient.cs (924 lines) Gap factor: 7.3x

5.1 Flush Coalescing (HIGH)

Missing: Flush signal pending counter (fsp), maxFlushPending=10, pcd map of pending clients for broadcast-style flush signaling. Go allows multiple producers to queue data, then ONE flush signals the writeLoop. .NET uses independent channels per client.

5.2 Stall Gate Backpressure (HIGH)

Missing: c.out.stc channel that blocks producers when client is 75% full. No producer rate limiting in .NET.

5.3 Write Timeout with Partial Flush Recovery (HIGH)

Missing:

• Partial flush recovery logic (written > 0 → retry vs close)
• WriteTimeoutPolicy enum (Close, TcpFlush)
• Different handling per client kind (routes can recover, clients cannot)
• .NET immediately closes on timeout; Go allows ROUTER/GATEWAY/LEAF to continue

5.4 Per-Account Subscription Result Cache (HIGH)

Missing: readCache struct with per-account results cache, route targets, statistical counters. Go caches Sublist match results per account on route/gateway inbound path (maxPerAccountCacheSize=8192).

5.5 Slow Consumer Stall Gate (MEDIUM)

Missing: Full stall gate mechanics — Go creates a channel blocking producers at 75% threshold, per-kind slow consumer statistics (route, gateway, leaf), account-level slow consumer tracking.

5.6 Dynamic Write Buffer Pooling (MEDIUM)

OutboundBufferPool exists but missing flush coalescing integration, pcd broadcast optimization.

5.7 Per-Client Trace Level (MEDIUM)

SetTraceMode() exists but missing message delivery tracing (traceMsgDelivery) for routed messages, per-client echo support.

5.8 Subscribe Permission Caching (MEDIUM)

PermissionLruCache caches PUB permissions but NOT SUB. Go caches per-account results with genid-based invalidation.

5.9 Internal Client Kinds (LOW)

ClientKind enum supports CLIENT, ROUTER, GATEWAY, LEAF but missing SYSTEM, JETSTREAM, ACCOUNT kinds and isInternalClient() predicate.

5.10 Adaptive Read Buffer Short-Read Counter (LOW)

AdaptiveReadBuffer implements 2x grow/shrink but missing Go's srs (short reads) counter for more precise shrink decisions.

---

Gap 6: MQTT Protocol (HIGH)

Go reference: mqtt.go — 5,882 lines NET implementation: Mqtt/ — 1,238 lines (8 files) Gap factor: 4.7x

6.1 JetStream-Backed Session Persistence (CRITICAL)

Missing: Go creates dedicated JetStream streams for:

• $MQTT_msgs — message persistence
• $MQTT_rmsgs — retained messages
• $MQTT_sess — session state
• $MQTT_qos2in — QoS 2 incoming tracking
• $MQTT_out — QoS 1/2 outgoing

.NET MQTT is entirely in-memory. Sessions are lost on restart.

6.2 Will Message Delivery (HIGH)

MqttSessionStore stores will metadata (WillTopic, WillPayload, WillQoS, WillRetain) but does NOT publish the will message on abnormal client disconnection.

6.3 QoS 1/2 Tracking (HIGH)

MqttQoS2StateMachine exists for QoS 2 state transitions but missing:

• JetStream-backed QoS 1 acknowledgment tracking
• Durable redelivery of unacked QoS 1/2 messages
• PUBREL delivery stream for QoS 2 phase 2

6.4 MaxAckPending Enforcement (HIGH)

Missing: No backpressure mechanism for QoS 1 accumulation, no per-subscription limits, no config reload hook.

6.5 Retained Message Delivery on Subscribe (MEDIUM)

MqttRetainedStore exists but not JetStream-backed and not integrated with subscription handling — retained messages aren't delivered on SUBSCRIBE.

6.6 Session Flapper Detection (LOW)

Partially implemented in MqttSessionStore (basic structure present) but integration unclear.

---

Gap 7: JetStream API Layer (MEDIUM)

Go reference: jetstream_api.go (5,165) + jetstream.go (2,866) = 8,031 lines NET implementation: ~1,374 lines across 11 handler files Gap factor: 5.8x

7.1 Leader Forwarding (HIGH)

API requests arriving at non-leader nodes must be forwarded to the current leader. Not implemented.

7.2 Clustered API Handlers (HIGH)

Missing:

• jsClusteredStreamRequest() — stream create in clustered mode
• jsClusteredStreamUpdateRequest() — update/delete/move/scale (509 lines in Go)
• Cluster-aware consumer create/delete handlers

7.3 API Rate Limiting & Deduplication (MEDIUM)

No request deduplication or rate limiting.

7.4 Snapshot & Restore API (MEDIUM)

No snapshot/restore API endpoints.

7.5 Consumer Pause/Resume API (MEDIUM)

No consumer pause/resume API endpoint.

7.6 Advisory Event Publication (LOW)

No advisory events for API operations.

---

Gap 8: RAFT Consensus (CRITICAL for clustering)

Go reference: raft.go — 5,037 lines NET implementation: Raft/ — 1,838 lines (17 files) Gap factor: 2.7x

8.1 Persistent Log Storage (CRITICAL)

.NET RAFT uses in-memory log only. RAFT state is not persisted across restarts.

8.2 Joint Consensus for Membership Changes (CRITICAL)

Current single-membership-change approach is unsafe for multi-node clusters. Go implements safe addition/removal per Section 4 of the RAFT paper.

8.3 InstallSnapshot Streaming (HIGH)

RaftSnapshot is fully loaded into memory. Go streams snapshots in chunks with progress tracking.

8.4 Leadership Transfer (MEDIUM)

No graceful leader step-down mechanism for maintenance operations.

8.5 Log Compaction (MEDIUM)

Basic compaction exists but no configurable retention policies.

8.6 Quorum Check Before Proposing (MEDIUM)

May propose entries when quorum is unreachable.

8.7 Read-Only Query Optimization (LOW)

All queries append log entries; no ReadIndex optimization for read-only commands.

8.8 Election Timeout Jitter (LOW)

May not have sufficient randomized jitter to prevent split votes.

---

Gap 9: Account Management & Multi-Tenancy (MEDIUM)

Go reference: accounts.go — 4,774 lines, 172+ functions NET implementation: Account.cs (280) + auth files Current .NET total: ~1,266 lines Gap factor: 3.8x

9.1 Service Export Latency Tracking (MEDIUM)

Missing: TrackServiceExport(), UnTrackServiceExport(), latency sampling, p50/p90/p99 tracking, sendLatencyResult(), sendBadRequestTrackingLatency(), sendReplyInterestLostTrackLatency().

9.2 Service Export Response Threshold (MEDIUM)

Missing: ServiceExportResponseThreshold(), SetServiceExportResponseThreshold() for SLA limits.

9.3 Stream Import Cycle Detection (MEDIUM)

Only service import cycles detected. Missing: streamImportFormsCycle(), checkStreamImportsForCycles().

9.4 Wildcard Service Exports (MEDIUM)

Missing: getWildcardServiceExport() — cannot define wildcard exports like svc.*.

9.5 Account Expiration & TTL (MEDIUM)

Missing: IsExpired(), expiredTimeout(), setExpirationTimer() — expired accounts won't auto-cleanup.

9.6 Account Claim Hot-Reload (MEDIUM)

Missing: UpdateAccountClaims(), updateAccountClaimsWithRefresh() — account changes may require restart.

9.7 Service/Stream Activation Expiration (LOW)

Missing: JWT activation claim expiry enforcement.

9.8 User NKey Revocation (LOW)

Missing: checkUserRevoked() — cannot revoke individual users without re-deploying.

9.9 Response Service Import (LOW)

Missing: Reverse response mapping for cross-account request-reply (addReverseRespMapEntry, checkForReverseEntries).

9.10 Service Import Shadowing Detection (LOW)

Missing: serviceImportShadowed().

---

Gap 10: Monitoring & Events (MEDIUM)

Go reference: monitor.go (4,240) + events.go (3,334) + msgtrace.go (799) = 8,373 lines NET implementation: Monitoring/ (1,698) + Events/ (960) + MessageTraceContext.cs = ~2,658 lines Gap factor: 3.1x

10.1 Closed Connections Ring Buffer (HIGH)

Missing: Ring buffer for recently closed connections with disconnect reasons. /connz?state=closed returns empty.

10.2 Account-Scoped Filtering (MEDIUM)

Missing: /connz?acc=ACCOUNT filtering.

10.3 Sort Options (MEDIUM)

Missing: ConnzOptions.SortBy (by bytes, msgs, uptime, etc.).

10.4 Message Trace Propagation (MEDIUM)

MessageTraceContext exists but trace data not propagated across servers in events.

10.5 Auth Error Events (MEDIUM)

Missing: sendAuthErrorEvent(), sendAccountAuthErrorEvent() — cannot monitor auth failures.

10.6 Full System Event Payloads (MEDIUM)

Event types defined but payloads may be incomplete (server info, client info fields).

10.7 Closed Connection Reason Tracking (MEDIUM)

ClosedClient.Reason exists but not populated consistently.

10.8 Remote Server Events (LOW)

Missing: remoteServerShutdown(), remoteServerUpdate(), leafNodeConnected() — limited cluster member visibility.

10.9 Event Compression (LOW)

Missing: getAcceptEncoding() — system events consume more bandwidth.

10.10 OCSP Peer Events (LOW)

Missing: sendOCSPPeerRejectEvent(), sendOCSPPeerChainlinkInvalidEvent().

---

Gap 11: Gateway Bridging (MEDIUM)

Go reference: gateway.go — 3,426 lines NET implementation: GatewayManager.cs (225) + GatewayConnection.cs (259) + GatewayInterestTracker.cs (190) + ReplyMapper.cs (174) Current .NET total: ~848 lines Gap factor: 4.0x

11.1 Implicit Gateway Discovery (HIGH)

Missing: processImplicitGateway(), gossipGatewaysToInboundGateway(), forwardNewGatewayToLocalCluster(). All gateways must be explicitly configured.

11.2 Gateway Reconnection with Backoff (MEDIUM)

Missing: solicitGateways(), reconnectGateway(), solicitGateway() with structured delay/jitter.

11.3 Account-Specific Gateway Routes (MEDIUM)

Missing: sendAccountSubsToGateway() — routes all subscriptions without per-account isolation.

11.4 Queue Group Propagation (MEDIUM)

Missing: sendQueueSubsToGateway() — queue-based load balancing may not work across gateways.

11.5 Reply Subject Mapping Cache (MEDIUM)

Missing: trackGWReply(), startGWReplyMapExpiration() — dynamic reply tracking with TTL. Basic _GR_ prefix exists but no caching.

11.6 Gateway Command Protocol (LOW)

Missing: gatewayCmdGossip, gatewayCmdAllSubsStart, gatewayCmdAllSubsComplete — no bulk subscription synchronization.

11.7 Connection Registration (LOW)

Missing: registerInboundGatewayConnection(), registerOutboundGatewayConnection(), getRemoteGateway() — minimal gateway registry.

---

Gap 12: Leaf Node Connections (MEDIUM)

Go reference: leafnode.go — 3,470 lines NET implementation: LeafNodeManager.cs (328) + LeafConnection.cs (284) + LeafHubSpokeMapper.cs (121) + LeafLoopDetector.cs (35) Current .NET total: ~768 lines Gap factor: 4.5x

12.1 TLS Certificate Hot-Reload (MEDIUM)

Missing: updateRemoteLeafNodesTLSConfig() — TLS cert changes require server restart.

12.2 Permission & Account Syncing (MEDIUM)

Missing: sendPermsAndAccountInfo(), initLeafNodeSmapAndSendSubs() — permission changes on hub may not propagate.

12.3 Leaf Connection State Validation (MEDIUM)

Missing: remoteLeafNodeStillValid() — no validation of remote config on reconnect.

12.4 JetStream Migration Checks (LOW)

Missing: checkJetStreamMigrate() — cannot safely migrate leaf JetStream domains.

12.5 Leaf Node WebSocket Support (LOW)

Missing: Go accepts WebSocket connections for leaf nodes.

12.6 Leaf Cluster Registration (LOW)

Missing: registerLeafNodeCluster(), hasLeafNodeCluster() — cannot query leaf topology.

12.7 Connection Disable Flag (LOW)

Missing: isLeafConnectDisabled() — cannot selectively disable leaf solicitation.

---

Gap 13: Route Clustering (MEDIUM)

Go reference: route.go — 3,314 lines NET implementation: RouteManager.cs (324) + RouteConnection.cs (296) + RouteCompressionCodec.cs (135) Current .NET total: ~755 lines Gap factor: 4.4x

13.1 Implicit Route Discovery (HIGH)

Missing: processImplicitRoute(), forwardNewRouteInfoToKnownServers(). Routes must be explicitly configured.

13.2 Account-Specific Dedicated Routes (MEDIUM)

Missing: Per-account route pinning for traffic isolation.

13.3 Route Pool Size Negotiation (MEDIUM)

Missing: Handling heterogeneous clusters with different pool sizes.

13.4 Route Hash Storage (LOW)

Missing: storeRouteByHash(), getRouteByHash() for efficient route lookup.

13.5 Cluster Split Handling (LOW)

Missing: removeAllRoutesExcept(), removeRoute() — no partition handling.

13.6 No-Pool Route Fallback (LOW)

Missing: Interoperability with older servers without pool support.

---

Gap 14: Configuration & Hot Reload (MEDIUM)

Go reference: opts.go (6,435) + reload.go (2,653) = 9,088 lines NET implementation: ConfigProcessor.cs (1,438) + NatsConfLexer.cs (1,503) + NatsConfParser.cs (421) + ConfigReloader.cs (526) Current .NET total: ~3,888 lines Gap factor: 2.3x

14.1 SIGHUP Signal Handling (HIGH)

Missing: Unix signal handler for config reload without restart.

14.2 Auth Change Propagation (MEDIUM)

Missing: When users/nkeys change, propagate to existing connections.

14.3 TLS Certificate Reload (MEDIUM)

Missing: Reload certificates for new connections without restart.

14.4 Cluster Config Hot Reload (MEDIUM)

Missing: Add/remove route URLs, gateway URLs, leaf node URLs at runtime.

14.5 Logging Level Changes (LOW)

Missing: Debug/trace/logtime changes at runtime.

14.6 JetStream Config Changes (LOW)

Missing: JetStream option reload.

---

Gap 15: WebSocket Support (LOW)

Go reference: websocket.go — 1,550 lines NET implementation: WebSocket/ — 1,453 lines (7 files) Gap factor: 1.1x

WebSocket support is the most complete subsystem. Compression negotiation (permessage-deflate), JWT auth through WebSocket, and origin checking are all implemented.

15.1 WebSocket-Specific TLS (LOW)

Minor TLS configuration differences.

---

Priority Summary

Tier 1: Production Blockers (CRITICAL)

1. FileStore encryption/compression/recovery (Gap 1) — blocks data security and durability
2. FileStore missing interface methods (Gap 1.9) — blocks API completeness
3. RAFT persistent log (Gap 8.1) — blocks cluster persistence
4. RAFT joint consensus (Gap 8.2) — blocks safe membership changes
5. JetStream cluster monitoring loop (Gap 2.1) — blocks distributed JetStream

Tier 2: Capability Limiters (HIGH)

6. Consumer delivery loop (Gap 3.1) — core consumer functionality
7. Consumer pull request pipeline (Gap 3.2) — pull consumer correctness
8. Consumer ack/redelivery (Gaps 3.3–3.4) — consumer reliability
9. Stream mirror/source retry (Gaps 4.1–4.3) — replication reliability
10. Stream purge with filtering (Gap 4.5) — operational requirement
11. Client flush coalescing (Gap 5.1) — performance
12. Client stall gate (Gap 5.2) — backpressure
13. MQTT JetStream persistence (Gap 6.1) — MQTT durability
14. SIGHUP config reload (Gap 14.1) — operational requirement
15. Implicit route/gateway discovery (Gaps 11.1, 13.1) — cluster usability

Tier 3: Important Features (MEDIUM)

16–40: Account management, monitoring, gateway details, leaf node features, consumer advanced features, etc.

Tier 4: Nice-to-Have (LOW)

41+: Internal client kinds, election jitter, event compression, etc.

---

Test Coverage Gap Summary

All 2,937 Go tests have been categorized:

• 2,646 mapped (90.1%) — have corresponding .NET tests
• 272 not_applicable (9.3%) — platform-specific or irrelevant
• 19 skipped (0.6%) — intentionally deferred
• 0 unmapped — none remaining

The .NET test suite has 5,808 test methods (expanding to ~6,409 with parameterized [Theory] test cases). Of these, 2,485 (42.8%) are linked back to Go test counterparts via the test_mappings table (57,289 mapping rows). The remaining 3,323 .NET tests are original — covering areas like unit tests for .NET-specific implementations, additional edge cases, and subsystems that don't have 1:1 Go equivalents.

Many tests validate API contracts against stubs/mocks rather than testing actual distributed behavior. The gap is in test depth, not test count.