From 82811239e9ff377d383c5bb2e721d6315add94d1 Mon Sep 17 00:00:00 2001
From: pilot <pilot@vulturelabs.io>
Date: Thu, 1 Oct 2026 22:24:33 +0300
Subject: [PATCH 1/5] rendezvous: cache the trust-pairs snapshot encoding
 (revision + TTL)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

flushSave re-encoded the entire trust-pair list (millions of "min:max"
strings at fleet scale) on every save, single-threaded — the dominant cost
of snapshot encoding. The set is near-static in practice, so cache its JSON
array and reuse it.

- trust: trustPairSet gains a revision counter, bumped only on real
  add/remove; trust.Store.Revision() exposes it.
- server: trustPairsEncodeCache memoizes the JSON array keyed by revision,
  with a 10-minute TTL safety net so a missed invalidation can't wedge a
  stale list. Empty list still returns nil so omitempty drops the field.
- Snapshot.TrustPairs becomes json.RawMessage (emitted verbatim); load and
  replication decode it back to []string.

Output is byte-identical to encoding the slice directly (tested), so the
snapshot checksum and recovery semantics are unchanged. No behavioural
change: the 5s save cadence and full-state snapshot are untouched.

Tests: byte-equality vs encoding/json, revision invalidation, TTL expiry,
empty->nil, and pairset revision semantics. Full module suite green.
---
 replication.go               |  18 +++++--
 server.go                    |   5 ++
 server_persist.go            |  73 ++++++++++++++++++++++---
 trust/pairset.go             |  24 +++++++--
 trust/trust.go               |  13 +++--
 trust/zz_pairset_rev_test.go |  32 +++++++++++
 wal/snapshot.go              |  16 +++---
 zz_trust_pairs_cache_test.go | 100 +++++++++++++++++++++++++++++++++++
 8 files changed, 259 insertions(+), 22 deletions(-)
 create mode 100644 trust/zz_pairset_rev_test.go
 create mode 100644 zz_trust_pairs_cache_test.go

diff --git a/replication.go b/replication.go
index fe705cf..419036c 100644
--- a/replication.go
+++ b/replication.go
@@ -155,8 +155,12 @@ func (s *Server) snapshotJSON() []byte {
 		snap.Networks[fmt.Sprintf("%d", id)] = sn
 	}
 
-	// Include trust pairs via the trust sub-package (R2.1).
-	snap.TrustPairs = s.trust.Pairs()
+	// Include trust pairs via the trust sub-package (R2.1), served from the
+	// same revision-keyed cache flushSave uses so replication doesn't pay the
+	// full re-encode either.
+	if tp, err := s.trustPairsCache.encode(s.trust.Revision(), s.trust.Pairs, trustPairsEncodeCacheTTL); err == nil {
+		snap.TrustPairs = tp
+	}
 
 	// Include handshake inboxes via the trust sub-package (R2.1).
 	inbox, responses := s.trust.InboxSnapshot()
@@ -476,8 +480,14 @@ func (s *Server) applySnapshot(data []byte) error {
 
 	// --- Phase 3: side state under their own locks ---
 
-	// Trust pairs and handshake state are owned by s.trust (R2.1).
-	s.trust.RestorePairs(snap.TrustPairs)
+	// Trust pairs and handshake state are owned by s.trust (R2.1). TrustPairs
+	// arrives as a pre-encoded JSON array (RawMessage).
+	if len(snap.TrustPairs) > 0 {
+		var pairs []string
+		if err := json.Unmarshal(snap.TrustPairs, &pairs); err == nil {
+			s.trust.RestorePairs(pairs)
+		}
+	}
 	s.trust.RestoreInbox(newHandshakeInbox, newHandshakeResponses)
 
 	if len(snap.AuditLog) > 0 {
diff --git a/server.go b/server.go
index 7be9bcc..652253a 100644
--- a/server.go
+++ b/server.go
@@ -97,6 +97,11 @@ type Server struct {
 	lastSnapshotRLockMs atomic.Int64 // s.mu.RLock hold time in phase 1
 	maxSnapshotDurMs    atomic.Int64 // worst-ever save duration
 
+	// trustPairsCache memoizes the JSON encoding of the trust-pair list
+	// across saves (see server_persist.go). The set is near-static at fleet
+	// scale, so this avoids re-encoding millions of strings every save.
+	trustPairsCache trustPairsEncodeCache
+
 	// buildInfo carries the build-time identity surfaced on
 	// /api/public-stats for code-verification (version, git commit, ISO
 	// build time, SHA256 of /proc/self/exe, Go runtime version). Set
diff --git a/server_persist.go b/server_persist.go
index 634785c..5f31f97 100644
--- a/server_persist.go
+++ b/server_persist.go
@@ -14,6 +14,7 @@ import (
 	"os"
 	"path/filepath"
 	"runtime/debug"
+	"sync"
 	"sync/atomic"
 	"time"
 
@@ -69,6 +70,56 @@ func shouldScavenge(dataLen int, nowMs int64) bool {
 	return nowMs-last >= scavengeIntervalMs && lastScavengeMs.CompareAndSwap(last, nowMs)
 }
 
+// trustPairsEncodeCacheTTL bounds how long a cached trust-pairs encoding is
+// served without re-encoding, independent of the revision. The revision
+// invalidation is exact; this is a belt-and-braces safety net so a missed
+// mutation can't wedge a stale list indefinitely.
+const trustPairsEncodeCacheTTL = 10 * time.Minute
+
+// trustPairsEncodeCache memoizes the JSON array of trust-pair keys. The set
+// (millions of entries at fleet scale) is near-static, so reusing the bytes
+// across saves removes the dominant cost of snapshot encoding while
+// producing output byte-identical to encoding the slice directly.
+type trustPairsEncodeCache struct {
+	mu  sync.Mutex
+	rev uint64
+	at  time.Time
+	b   json.RawMessage
+}
+
+// encode returns the JSON array for pairs, reusing the cached bytes while
+// rev is unchanged and the TTL hasn't elapsed. pairs is only invoked on a
+// cache miss. An empty list returns nil so the omitempty tag still drops the
+// field, matching the previous []string behaviour.
+func (c *trustPairsEncodeCache) encode(rev uint64, pairs func() []string, ttl time.Duration) (json.RawMessage, error) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	if c.b != nil && c.rev == rev && time.Since(c.at) < ttl {
+		return c.b, nil
+	}
+	p := pairs()
+	if len(p) == 0 {
+		c.b = nil
+		c.rev = rev
+		c.at = time.Now()
+		return nil, nil
+	}
+	var buf bytes.Buffer
+	enc := json.NewEncoder(&buf)
+	enc.SetEscapeHTML(false)
+	if err := enc.Encode(p); err != nil {
+		return nil, err
+	}
+	b := buf.Bytes()
+	if len(b) > 0 && b[len(b)-1] == '\n' {
+		b = b[:len(b)-1]
+	}
+	c.b = append(c.b[:0], b...)
+	c.rev = rev
+	c.at = time.Now()
+	return c.b, nil
+}
+
 // atomicWriteStream writes path atomically via a temp file + rename, but
 // streams the content: fn receives the open *os.File and may write
 // incrementally (and Seek/WriteAt to backfill a trailer) instead of the
@@ -307,8 +358,9 @@ func (s *Server) flushSave() (retErr error) {
 		}
 	}
 
-	// Copy trust pairs and handshake inboxes from the trust sub-package.
-	trustPairs := s.trust.Pairs()
+	// Handshake inboxes are copied here; the trust-pair list is encoded in
+	// Phase 2 through the revision-keyed cache (it is near-static and by far
+	// the most expensive part to serialize).
 	handshakeInbox, handshakeResponses := s.trust.InboxSnapshot()
 	var inviteInbox map[uint32][]*NetworkInvite
 	if len(s.inviteInbox) > 0 {
@@ -457,7 +509,11 @@ func (s *Server) flushSave() (retErr error) {
 	}
 
 	snap.PubKeyIdx = pubKeyIdx
-	snap.TrustPairs = trustPairs
+	tp, tpErr := s.trustPairsCache.encode(s.trust.Revision(), s.trust.Pairs, trustPairsEncodeCacheTTL)
+	if tpErr != nil {
+		return fmt.Errorf("encode trust pairs: %w", tpErr)
+	}
+	snap.TrustPairs = tp
 
 	// Handshake inboxes
 	if len(handshakeInbox) > 0 {
@@ -893,10 +949,15 @@ func (s *Server) load() error {
 		s.networks[n.ID] = net
 	}
 
-	// Restore trust pairs (delegated to the trust sub-package).
-	s.trust.RestorePairs(snap.TrustPairs)
+	// Restore trust pairs (delegated to the trust sub-package). TrustPairs is
+	// a pre-encoded JSON array (RawMessage) so flushSave can cache it.
 	if len(snap.TrustPairs) > 0 {
-		slog.Info("loaded trust pairs", "count", len(snap.TrustPairs))
+		var pairs []string
+		if err := json.Unmarshal(snap.TrustPairs, &pairs); err != nil {
+			return fmt.Errorf("decode trust_pairs: %w", err)
+		}
+		s.trust.RestorePairs(pairs)
+		slog.Info("loaded trust pairs", "count", len(pairs))
 	}
 
 	// Restore persisted pubKeyIdx (entries for reaped nodes that aren't in snap.Nodes)
diff --git a/trust/pairset.go b/trust/pairset.go
index 66c3b0d..c637f8e 100644
--- a/trust/pairset.go
+++ b/trust/pairset.go
@@ -2,7 +2,10 @@
 
 package trust
 
-import "sync"
+import (
+	"sync"
+	"sync/atomic"
+)
 
 // trustPairShards is the shard count for the trust-pair set. A power of two
 // so the index is a mask. Sized well above the registry's request
@@ -27,8 +30,15 @@ type trustPairSet struct {
 		mu sync.RWMutex
 		m  map[string]bool
 	}
+	// rev ticks on every mutation that actually changes the set (new add or
+	// real remove). Consumers can use it as a cache key: an unchanged rev
+	// means the serialized pair list is unchanged.
+	rev atomic.Uint64
 }
 
+// revision returns the set's mutation counter.
+func (s *trustPairSet) revision() uint64 { return s.rev.Load() }
+
 func newTrustPairSet() *trustPairSet {
 	s := &trustPairSet{}
 	for i := range s.shards {
@@ -47,7 +57,10 @@ func (s *trustPairSet) has(key string) bool {
 func (s *trustPairSet) add(key string) {
 	sh := &s.shards[trustShardIdx(key)]
 	sh.mu.Lock()
-	sh.m[key] = true
+	if !sh.m[key] {
+		sh.m[key] = true
+		s.rev.Add(1)
+	}
 	sh.mu.Unlock()
 }
 
@@ -60,6 +73,7 @@ func (s *trustPairSet) remove(key string) bool {
 		return false
 	}
 	delete(sh.m, key)
+	s.rev.Add(1)
 	return true
 }
 
@@ -89,5 +103,9 @@ func (s *trustPairSet) keys() []string {
 
 // addUnlocked inserts without locking — for startup restore before serving.
 func (s *trustPairSet) addUnlocked(key string) {
-	s.shards[trustShardIdx(key)].m[key] = true
+	m := s.shards[trustShardIdx(key)].m
+	if !m[key] {
+		m[key] = true
+		s.rev.Add(1)
+	}
 }
diff --git a/trust/trust.go b/trust/trust.go
index 77e8518..cd6bc05 100644
--- a/trust/trust.go
+++ b/trust/trust.go
@@ -14,8 +14,8 @@ import (
 	"log/slog"
 	"time"
 
-	"github.com/pilot-protocol/common/protocol"
 	"github.com/pilot-protocol/common/crypto"
+	"github.com/pilot-protocol/common/protocol"
 )
 
 // maxHandshakeInbox limits the number of pending handshake requests per node.
@@ -92,8 +92,8 @@ type Store struct {
 // NewStore creates an empty, ready-to-use Store.
 func NewStore(nodes NodeView, cb Callbacks) *Store {
 	return &Store{
-		nodes:              nodes,
-		cb:                 cb,
+		nodes:      nodes,
+		cb:         cb,
 		trustPairs: newTrustPairSet(),
 		handshakes: newHandshakeState(),
 	}
@@ -106,6 +106,13 @@ func (st *Store) Count() int {
 	return st.trustPairs.count()
 }
 
+// Revision returns a counter that increments whenever the trust-pair set
+// actually changes (a new pair is added or one is removed). It is a cheap
+// cache key for consumers that serialize Pairs(): same revision ⇒ same set.
+func (st *Store) Revision() uint64 {
+	return st.trustPairs.revision()
+}
+
 // IsTrusted reports whether nodes a and b have an established trust pair.
 // The relation is symmetric: IsTrusted(a, b) == IsTrusted(b, a).
 func (st *Store) IsTrusted(a, b uint32) bool {
diff --git a/trust/zz_pairset_rev_test.go b/trust/zz_pairset_rev_test.go
new file mode 100644
index 0000000..545efdc
--- /dev/null
+++ b/trust/zz_pairset_rev_test.go
@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+package trust
+
+import "testing"
+
+func TestTrustPairSet_Revision(t *testing.T) {
+	s := newTrustPairSet()
+	if s.revision() != 0 {
+		t.Fatalf("initial revision = %d, want 0", s.revision())
+	}
+	s.add("1:2")
+	if s.revision() != 1 {
+		t.Fatalf("add new key: revision = %d, want 1", s.revision())
+	}
+	s.add("1:2") // duplicate
+	if s.revision() != 1 {
+		t.Fatalf("duplicate add must not bump revision, got %d", s.revision())
+	}
+	if !s.remove("1:2") {
+		t.Fatal("remove present key should return true")
+	}
+	if s.revision() != 2 {
+		t.Fatalf("remove: revision = %d, want 2", s.revision())
+	}
+	if s.remove("1:2") {
+		t.Fatal("remove absent key should return false")
+	}
+	if s.revision() != 2 {
+		t.Fatalf("failed remove must not bump revision, got %d", s.revision())
+	}
+}
diff --git a/wal/snapshot.go b/wal/snapshot.go
index 443940f..97941bf 100644
--- a/wal/snapshot.go
+++ b/wal/snapshot.go
@@ -83,12 +83,16 @@ type SnapshotNet struct {
 // and read by load. Version 0 is the legacy (pre-checksum) format; version 1
 // includes the Checksum field for integrity verification.
 type Snapshot struct {
-	Version            int                                         `json:"version"`
-	NextNode           uint32                                      `json:"next_node"`
-	NextNet            uint16                                      `json:"next_net"`
-	Nodes              map[string]*SnapshotNode                    `json:"nodes"`
-	Networks           map[string]*SnapshotNet                     `json:"networks"`
-	TrustPairs         []string                                    `json:"trust_pairs,omitempty"`
+	Version  int                      `json:"version"`
+	NextNode uint32                   `json:"next_node"`
+	NextNet  uint16                   `json:"next_net"`
+	Nodes    map[string]*SnapshotNode `json:"nodes"`
+	Networks map[string]*SnapshotNet  `json:"networks"`
+	// TrustPairs carries the pre-encoded JSON array of "min:max" pair keys as
+	// a RawMessage so flushSave can serve it from a revision-keyed cache
+	// (the set is near-static at fleet scale) instead of re-encoding ~8.3M
+	// strings every save. encoding/json emits RawMessage verbatim.
+	TrustPairs         json.RawMessage                             `json:"trust_pairs,omitempty"`
 	PubKeyIdx          map[string]uint32                           `json:"pub_key_idx,omitempty"`
 	HandshakeInbox     map[string][]*trustpkg.HandshakeRelayMsg    `json:"handshake_inbox,omitempty"`
 	HandshakeResponses map[string][]*trustpkg.HandshakeResponseMsg `json:"handshake_responses,omitempty"`
diff --git a/zz_trust_pairs_cache_test.go b/zz_trust_pairs_cache_test.go
new file mode 100644
index 0000000..fd961df
--- /dev/null
+++ b/zz_trust_pairs_cache_test.go
@@ -0,0 +1,100 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+package server
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"sync/atomic"
+	"testing"
+	"time"
+)
+
+func stdEncodeStrings(t *testing.T, s []string) []byte {
+	t.Helper()
+	var buf bytes.Buffer
+	e := json.NewEncoder(&buf)
+	e.SetEscapeHTML(false)
+	if err := e.Encode(s); err != nil {
+		t.Fatalf("encode: %v", err)
+	}
+	b := buf.Bytes()
+	if len(b) > 0 && b[len(b)-1] == '\n' {
+		b = b[:len(b)-1]
+	}
+	return b
+}
+
+// The cached bytes must be byte-identical to encoding the slice directly —
+// load() re-encodes to verify the checksum.
+func TestTrustPairsCache_ByteIdentical(t *testing.T) {
+	var c trustPairsEncodeCache
+	pairs := []string{`1:2`, `x"y`, `a<b>&c`, "unicode-雪", `back\slash`, ""}
+	for i := 0; i < 50000; i++ {
+		pairs = append(pairs, fmt.Sprintf("%d:%d", i, i*3))
+	}
+	got, err := c.encode(1, func() []string { return pairs }, time.Minute)
+	if err != nil {
+		t.Fatal(err)
+	}
+	want := stdEncodeStrings(t, pairs)
+	if !bytes.Equal(got, want) {
+		t.Fatalf("cache encode differs from standard encoding")
+	}
+}
+
+func TestTrustPairsCache_ReuseAndInvalidate(t *testing.T) {
+	var c trustPairsEncodeCache
+	var calls atomic.Int64
+	pairs := []string{"1:2", "3:4"}
+	fn := func() []string { calls.Add(1); return pairs }
+
+	b1, _ := c.encode(7, fn, time.Minute)
+	if calls.Load() != 1 {
+		t.Fatalf("first call should encode, calls=%d", calls.Load())
+	}
+	b2, _ := c.encode(7, fn, time.Minute)
+	if calls.Load() != 1 {
+		t.Fatalf("same revision must reuse cache, calls=%d", calls.Load())
+	}
+	if !bytes.Equal(b1, b2) {
+		t.Fatalf("cached bytes changed on reuse")
+	}
+
+	// Revision change forces a re-encode, and the result is identical for
+	// identical data.
+	b3, _ := c.encode(8, fn, time.Minute)
+	if calls.Load() != 2 {
+		t.Fatalf("revision change must re-encode, calls=%d", calls.Load())
+	}
+	if !bytes.Equal(b1, b3) {
+		t.Fatalf("same data encoded differently across revisions")
+	}
+
+	// TTL expiry forces a re-encode even with an unchanged revision.
+	if _, err := c.encode(9, fn, time.Nanosecond); err != nil {
+		t.Fatal(err)
+	}
+	time.Sleep(2 * time.Millisecond)
+	_, _ = c.encode(9, fn, time.Nanosecond)
+	if calls.Load() != 4 {
+		t.Fatalf("TTL expiry must re-encode, calls=%d", calls.Load())
+	}
+}
+
+func TestTrustPairsCache_EmptyReturnsNil(t *testing.T) {
+	var c trustPairsEncodeCache
+	b, err := c.encode(1, func() []string { return nil }, time.Minute)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if b != nil {
+		t.Fatalf("empty pairs must return nil (omitempty), got %q", b)
+	}
+	// And a subsequent non-empty set must not be masked by the nil cache.
+	b2, _ := c.encode(2, func() []string { return []string{"1:2"} }, time.Minute)
+	if string(b2) != `["1:2"]` {
+		t.Fatalf("got %q, want [\"1:2\"]", b2)
+	}
+}

From f52cb1c9fb4836a99b0ba3026c9bebb2d51e2d1b Mon Sep 17 00:00:00 2001
From: pilot <pilot@vulturelabs.io>
Date: Thu, 1 Oct 2026 22:25:25 +0300
Subject: [PATCH 2/5] rendezvous: benchmark trust-pairs encode cache (re-encode
 vs cached)

200k nodes + 5M trust pairs: ~315ms -> ~203ms per snapshot encode
(~35% faster), with ~344MB less allocated per save.
---
 wal/zz_snapshot_bench_test.go | 83 +++++++++++++++++++++++++++++++++++
 1 file changed, 83 insertions(+)
 create mode 100644 wal/zz_snapshot_bench_test.go

diff --git a/wal/zz_snapshot_bench_test.go b/wal/zz_snapshot_bench_test.go
new file mode 100644
index 0000000..01714a8
--- /dev/null
+++ b/wal/zz_snapshot_bench_test.go
@@ -0,0 +1,83 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+package wal
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"strconv"
+	"testing"
+)
+
+func benchEncodePairs(n int) []string {
+	p := make([]string, 0, n)
+	for i := 0; i < n; i++ {
+		p = append(p, strconv.Itoa(i)+":"+strconv.Itoa(i*3))
+	}
+	return p
+}
+
+func benchRawPairs(p []string) json.RawMessage {
+	var buf bytes.Buffer
+	e := json.NewEncoder(&buf)
+	e.SetEscapeHTML(false)
+	_ = e.Encode(p)
+	b := buf.Bytes()
+	if len(b) > 0 && b[len(b)-1] == '\n' {
+		b = b[:len(b)-1]
+	}
+	return append(json.RawMessage(nil), b...)
+}
+
+func benchSnapshot(nodes int) *Snapshot {
+	m := make(map[string]*SnapshotNode, nodes)
+	for i := 0; i < nodes; i++ {
+		m[strconv.Itoa(i)] = &SnapshotNode{
+			ID:        uint32(i),
+			PublicKey: "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8=",
+			RealAddr:  "10.0.0.1:1234",
+			Networks:  []uint16{0, 3},
+			LastSeen:  "2026-10-01T12:00:00Z",
+			Hostname:  fmt.Sprintf("host-%d", i),
+			Version:   "v1.2.3",
+		}
+	}
+	return &Snapshot{Version: 1, NextNode: uint32(nodes), NextNet: 1,
+		Nodes: m, Networks: map[string]*SnapshotNet{}}
+}
+
+func benchEncodeSnap(s *Snapshot) error {
+	var buf bytes.Buffer
+	e := json.NewEncoder(&buf)
+	e.SetEscapeHTML(false)
+	return e.Encode(s)
+}
+
+// Re-encodes the trust list every save (old behaviour).
+func BenchmarkSnapshotEncode_TrustReEncode(b *testing.B) {
+	pairs := benchEncodePairs(5_000_000)
+	snap := benchSnapshot(200_000)
+	b.ReportAllocs()
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		snap.TrustPairs = benchRawPairs(pairs)
+		if err := benchEncodeSnap(snap); err != nil {
+			b.Fatal(err)
+		}
+	}
+}
+
+// Reuses the cached trust-list bytes (new behaviour).
+func BenchmarkSnapshotEncode_TrustCached(b *testing.B) {
+	pairs := benchEncodePairs(5_000_000)
+	snap := benchSnapshot(200_000)
+	snap.TrustPairs = benchRawPairs(pairs)
+	b.ReportAllocs()
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		if err := benchEncodeSnap(snap); err != nil {
+			b.Fatal(err)
+		}
+	}
+}

From b9aa913145eb752e589689df2fdacfaa59a8e86b Mon Sep 17 00:00:00 2001
From: pilot <pilot@vulturelabs.io>
Date: Fri, 2 Oct 2026 00:55:01 +0300
Subject: [PATCH 3/5] rendezvous: hand-written snapshot encoder
 (reflection-free, byte-identical)

flushSave encoded the snapshot with encoding/json, which reflects over the
whole 200k-node graph every save and allocates heavily (the dominant cost
plus a GC storm at fleet scale).

wal.AppendSnapshot is a hand-written top-level encoder:
- Nodes and PubKeyIdx are encoded directly (map keys sorted, field order and
  omitempty mirrored) with a fast string escaper (falling back to
  encoding/json only for non-ASCII/control/quote/backslash strings).
- TrustPairs is emitted verbatim from its cached RawMessage.
- Small/rare fields delegate to encoding/json per value so their bytes are
  exactly right.

flushSave now encodes into a reused buffer via AppendSnapshot, hashes, and
writes body + checksum trailer atomically. Output is byte-identical to
encoding/json (differential test + native fuzzing), so the snapshot
checksum and load() recovery are unchanged.

Bench (200k nodes): ~113ms -> ~64ms, 325MB -> 13MB allocated. Full
cache-heavy case ~2.8x. Fuzzed: FuzzAppendJSONString,
FuzzSnapshotNodes_MarshalParity, FuzzAppendSnapshot_MarshalParity (~31M
execs, zero mismatches).
---
 server.go                     |   6 +
 server_persist.go             |  89 ++++----------
 wal/snapshot.go               |  10 +-
 wal/snapshot_fast.go          | 185 ++++++++++++++++++++++++++++
 wal/snapshot_nodes.go         | 224 ++++++++++++++++++++++++++++++++++
 wal/zz_fuzz_test.go           | 111 +++++++++++++++++
 wal/zz_snapshot_fast_test.go  | 120 ++++++++++++++++++
 wal/zz_snapshot_nodes_test.go | 100 +++++++++++++++
 zz_save_memory_test.go        |  47 +------
 9 files changed, 773 insertions(+), 119 deletions(-)
 create mode 100644 wal/snapshot_fast.go
 create mode 100644 wal/snapshot_nodes.go
 create mode 100644 wal/zz_fuzz_test.go
 create mode 100644 wal/zz_snapshot_fast_test.go
 create mode 100644 wal/zz_snapshot_nodes_test.go

diff --git a/server.go b/server.go
index 652253a..6b63d0d 100644
--- a/server.go
+++ b/server.go
@@ -102,6 +102,12 @@ type Server struct {
 	// scale, so this avoids re-encoding millions of strings every save.
 	trustPairsCache trustPairsEncodeCache
 
+	// snapshotBuf is the reused buffer for the hand-written snapshot encoder
+	// (wal.AppendSnapshot). snapshotEncodeMu guards it against concurrent
+	// flushSave callers (saveLoop and a rare replication-triggered flush).
+	snapshotEncodeMu sync.Mutex
+	snapshotBuf      []byte
+
 	// buildInfo carries the build-time identity surfaced on
 	// /api/public-stats for code-verification (version, git commit, ISO
 	// build time, SHA256 of /proc/self/exe, Go runtime version). Set
diff --git a/server_persist.go b/server_persist.go
index 5f31f97..8577d0e 100644
--- a/server_persist.go
+++ b/server_persist.go
@@ -22,6 +22,7 @@ import (
 	"github.com/pilot-protocol/common/urlvalidate"
 	dashpkg "github.com/pilot-protocol/rendezvous/dashboard"
 	trustpkg "github.com/pilot-protocol/rendezvous/trust"
+	walpkg "github.com/pilot-protocol/rendezvous/wal"
 )
 
 const (
@@ -31,37 +32,6 @@ const (
 
 var lastScavengeMs atomic.Int64
 
-// trimTrailingNewlineWriter forwards every byte it is given except the final
-// one. json.Encoder.Encode terminates its output with '\n', but the snapshot
-// checksum is defined over the encoded value WITHOUT that newline (load()
-// strips it before recomputing too). Holding back the last byte yields a file
-// and hash of `{...}` while writing straight to disk — no full-size buffer.
-type trimTrailingNewlineWriter struct {
-	w       io.Writer
-	held    byte
-	hasHeld bool
-}
-
-func (t *trimTrailingNewlineWriter) Write(p []byte) (int, error) {
-	if len(p) == 0 {
-		return 0, nil
-	}
-	if t.hasHeld {
-		if _, err := t.w.Write([]byte{t.held}); err != nil {
-			return 0, err
-		}
-		t.hasHeld = false
-	}
-	if len(p) > 1 {
-		if _, err := t.w.Write(p[:len(p)-1]); err != nil {
-			return 0, err
-		}
-	}
-	t.held = p[len(p)-1]
-	t.hasHeld = true
-	return len(p), nil
-}
-
 func shouldScavenge(dataLen int, nowMs int64) bool {
 	if dataLen < scavengeMinSnapshot {
 		return false
@@ -607,52 +577,35 @@ func (s *Server) flushSave() (retErr error) {
 	}
 	s.auditMu.Unlock()
 
-	// Stream-encode straight to the temp file: no full-size in-memory buffer
-	// and no second copy through AtomicWrite. The body is hashed as it is
-	// written, then the checksum is backfilled as a trailing JSON member.
-	//
-	// At 170k+ nodes the old path materialized a ~50-100 MB pooled buffer and
-	// was the dominant heap allocator (~1 GB live, GC STW pauses causing UDP
-	// drops). Streaming writes the same bytes directly to disk instead.
-	//
-	// Checksum invariant: load() re-encodes the struct with Checksum omitted
-	// and hashes those bytes (newline stripped). So the hash here must cover
-	// exactly the encoder output minus its trailing '\n' — which
-	// trimTrailingNewlineWriter guarantees by withholding the final byte.
+	// Encode with the hand-written, reflection-free encoder (wal.AppendSnapshot)
+	// into a buffer reused across saves. It is byte-identical to encoding/json
+	// (differential-tested), so the checksum and load() parity are unchanged,
+	// but it skips the reflection + per-node allocation that dominated saves at
+	// fleet scale. The body is hashed, then the checksum is written as a
+	// trailing JSON member by replacing the final '}'.
 	snap.Checksum = ""
 	var written int64
 	if s.storePath != "" {
+		s.snapshotEncodeMu.Lock()
+		body := walpkg.AppendSnapshot(s.snapshotBuf[:0], &snap)
+		s.snapshotBuf = body
+		if len(body) == 0 || body[len(body)-1] != '}' {
+			s.snapshotEncodeMu.Unlock()
+			return fmt.Errorf("encode snapshot: unexpected JSON format (expected trailing '}')")
+		}
+		sum := sha256.Sum256(body)
+		trailer := `,"checksum":"` + hex.EncodeToString(sum[:]) + `"}`
 		err := atomicWriteStream(s.storePath, func(f *os.File) error {
-			h := sha256.New()
-			enc := json.NewEncoder(&trimTrailingNewlineWriter{w: io.MultiWriter(f, h)})
-			enc.SetEscapeHTML(false)
-			if err := enc.Encode(snap); err != nil {
-				return fmt.Errorf("encode snapshot: %w", err)
-			}
-			// The encoded object ends with '}' (the trailing newline was
-			// withheld). Replace that '}' with the checksum trailer so the
-			// on-disk file is `{...` + `,"checksum":"<hex>"}`.
-			end, err := f.Seek(0, io.SeekEnd)
-			if err != nil {
-				return fmt.Errorf("seek snapshot temp: %w", err)
-			}
-			var last [1]byte
-			if end == 0 {
-				return fmt.Errorf("encode snapshot: empty output")
-			}
-			if _, err := f.ReadAt(last[:], end-1); err != nil {
-				return fmt.Errorf("read snapshot tail: %w", err)
-			}
-			if last[0] != '}' {
-				return fmt.Errorf("encode snapshot: unexpected JSON format (expected trailing '}')")
+			if _, err := f.Write(body[:len(body)-1]); err != nil {
+				return fmt.Errorf("write snapshot body: %w", err)
 			}
-			trailer := `,"checksum":"` + hex.EncodeToString(h.Sum(nil)) + `"}`
-			if _, err := f.WriteAt([]byte(trailer), end-1); err != nil {
+			if _, err := io.WriteString(f, trailer); err != nil {
 				return fmt.Errorf("write checksum trailer: %w", err)
 			}
-			written = end - 1 + int64(len(trailer))
+			written = int64(len(body) - 1 + len(trailer))
 			return nil
 		})
+		s.snapshotEncodeMu.Unlock()
 		if err != nil {
 			slog.Error("registry save error", "err", err)
 			return fmt.Errorf("write snapshot: %w", err)
diff --git a/wal/snapshot.go b/wal/snapshot.go
index 97941bf..acc1934 100644
--- a/wal/snapshot.go
+++ b/wal/snapshot.go
@@ -83,11 +83,11 @@ type SnapshotNet struct {
 // and read by load. Version 0 is the legacy (pre-checksum) format; version 1
 // includes the Checksum field for integrity verification.
 type Snapshot struct {
-	Version  int                      `json:"version"`
-	NextNode uint32                   `json:"next_node"`
-	NextNet  uint16                   `json:"next_net"`
-	Nodes    map[string]*SnapshotNode `json:"nodes"`
-	Networks map[string]*SnapshotNet  `json:"networks"`
+	Version  int                     `json:"version"`
+	NextNode uint32                  `json:"next_node"`
+	NextNet  uint16                  `json:"next_net"`
+	Nodes    SnapshotNodes           `json:"nodes"`
+	Networks map[string]*SnapshotNet `json:"networks"`
 	// TrustPairs carries the pre-encoded JSON array of "min:max" pair keys as
 	// a RawMessage so flushSave can serve it from a revision-keyed cache
 	// (the set is near-static at fleet scale) instead of re-encoding ~8.3M
diff --git a/wal/snapshot_fast.go b/wal/snapshot_fast.go
new file mode 100644
index 0000000..0486c8e
--- /dev/null
+++ b/wal/snapshot_fast.go
@@ -0,0 +1,185 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+package wal
+
+import (
+	"bytes"
+	"encoding/json"
+	"sort"
+	"strconv"
+)
+
+// AppendSnapshot appends the JSON encoding of s to dst, without the
+// reflection-based encoding/json overhead on the hot collections. The output
+// is byte-identical to json.Encoder(SetEscapeHTML(false)) over the same
+// struct (differential-tested), which load() depends on when it re-encodes to
+// verify the checksum.
+//
+// Hot fields (Nodes, PubKeyIdx) are hand-encoded; TrustPairs is emitted
+// verbatim from its pre-encoded RawMessage (cached); the remaining small/rare
+// fields fall back to encoding/json per value so their bytes are exactly
+// right.
+func AppendSnapshot(dst []byte, s *Snapshot) []byte {
+	dst = append(dst, '{')
+	first := true
+	key := func(name string) {
+		if !first {
+			dst = append(dst, ',')
+		}
+		first = false
+		dst = append(dst, '"')
+		dst = append(dst, name...)
+		dst = append(dst, '"', ':')
+	}
+
+	key("version")
+	dst = strconv.AppendInt(dst, int64(s.Version), 10)
+	key("next_node")
+	dst = strconv.AppendUint(dst, uint64(s.NextNode), 10)
+	key("next_net")
+	dst = strconv.AppendUint(dst, uint64(s.NextNet), 10)
+	key("nodes")
+	dst = s.Nodes.appendTo(dst)
+	key("networks")
+	dst = appendStdValue(dst, s.Networks)
+
+	if len(s.TrustPairs) > 0 {
+		key("trust_pairs")
+		dst = append(dst, s.TrustPairs...)
+	}
+	if len(s.PubKeyIdx) > 0 {
+		key("pub_key_idx")
+		dst = appendPubKeyIdx(dst, s.PubKeyIdx)
+	}
+	if len(s.HandshakeInbox) > 0 {
+		key("handshake_inbox")
+		dst = appendStdValue(dst, s.HandshakeInbox)
+	}
+	if len(s.HandshakeResponses) > 0 {
+		key("handshake_responses")
+		dst = appendStdValue(dst, s.HandshakeResponses)
+	}
+	if len(s.InviteInbox) > 0 {
+		key("invite_inbox")
+		dst = appendStdValue(dst, s.InviteInbox)
+	}
+	if s.TotalRequests != 0 {
+		key("total_requests")
+		dst = strconv.AppendInt(dst, s.TotalRequests, 10)
+	}
+	if s.TotalNodes != 0 {
+		key("total_nodes")
+		dst = strconv.AppendInt(dst, int64(s.TotalNodes), 10)
+	}
+	if s.OnlineNodes != 0 {
+		key("online_nodes")
+		dst = strconv.AppendInt(dst, int64(s.OnlineNodes), 10)
+	}
+	if s.TrustLinks != 0 {
+		key("trust_links")
+		dst = strconv.AppendInt(dst, int64(s.TrustLinks), 10)
+	}
+	if s.UniqueTags != 0 {
+		key("unique_tags")
+		dst = strconv.AppendInt(dst, int64(s.UniqueTags), 10)
+	}
+	if s.TaskExecutors != 0 {
+		key("task_executors")
+		dst = strconv.AppendInt(dst, int64(s.TaskExecutors), 10)
+	}
+	if s.StartTime != "" {
+		key("start_time")
+		dst = appendJSONString(dst, s.StartTime)
+	}
+	if len(s.RestartEvents) > 0 {
+		key("restart_events")
+		dst = appendStdValue(dst, s.RestartEvents)
+	}
+	if len(s.DowntimeIntervals) > 0 {
+		key("downtime_intervals")
+		dst = appendStdValue(dst, s.DowntimeIntervals)
+	}
+	if s.LastHeartbeat != 0 {
+		key("last_heartbeat")
+		dst = strconv.AppendInt(dst, s.LastHeartbeat, 10)
+	}
+	if len(s.ProbeStates) > 0 {
+		key("probe_states")
+		dst = appendStdValue(dst, s.ProbeStates)
+	}
+	if len(s.HourlyHistory) > 0 {
+		key("hourly_history")
+		dst = appendStdValue(dst, s.HourlyHistory)
+	}
+	if len(s.DailyHistory) > 0 {
+		key("daily_history")
+		dst = appendStdValue(dst, s.DailyHistory)
+	}
+	if len(s.NetHourlyHistory) > 0 {
+		key("net_hourly_history")
+		dst = appendStdValue(dst, s.NetHourlyHistory)
+	}
+	if len(s.NetDailyHistory) > 0 {
+		key("net_daily_history")
+		dst = appendStdValue(dst, s.NetDailyHistory)
+	}
+	if len(s.AuditLog) > 0 {
+		key("audit_log")
+		dst = appendStdValue(dst, s.AuditLog)
+	}
+	if s.IDPConfig != nil {
+		key("idp_config")
+		dst = appendStdValue(dst, s.IDPConfig)
+	}
+	if s.AuditExportCfg != nil {
+		key("audit_export_config")
+		dst = appendStdValue(dst, s.AuditExportCfg)
+	}
+	if len(s.RBACPreAssign) > 0 {
+		key("rbac_pre_assign")
+		dst = appendStdValue(dst, s.RBACPreAssign)
+	}
+	if s.Term != 0 {
+		key("term")
+		dst = strconv.AppendUint(dst, s.Term, 10)
+	}
+	if s.Checksum != "" {
+		key("checksum")
+		dst = appendJSONString(dst, s.Checksum)
+	}
+	return append(dst, '}')
+}
+
+// appendPubKeyIdx writes a map[string]uint32 the way encoding/json does
+// (ascending keys, decimal values).
+func appendPubKeyIdx(dst []byte, m map[string]uint32) []byte {
+	keys := make([]string, 0, len(m))
+	for k := range m {
+		keys = append(keys, k)
+	}
+	sort.Strings(keys)
+	dst = append(dst, '{')
+	for i, k := range keys {
+		if i > 0 {
+			dst = append(dst, ',')
+		}
+		dst = appendJSONString(dst, k)
+		dst = append(dst, ':')
+		dst = strconv.AppendUint(dst, uint64(m[k]), 10)
+	}
+	return append(dst, '}')
+}
+
+// appendStdValue appends v's standard encoding, with the snapshot encoder's
+// settings (HTML escaping off), so the bytes match encoding/json exactly.
+func appendStdValue(dst []byte, v interface{}) []byte {
+	var buf bytes.Buffer
+	e := json.NewEncoder(&buf)
+	e.SetEscapeHTML(false)
+	_ = e.Encode(v)
+	b := buf.Bytes()
+	if len(b) > 0 && b[len(b)-1] == '\n' {
+		b = b[:len(b)-1]
+	}
+	return append(dst, b...)
+}
diff --git a/wal/snapshot_nodes.go b/wal/snapshot_nodes.go
new file mode 100644
index 0000000..9fb3abf
--- /dev/null
+++ b/wal/snapshot_nodes.go
@@ -0,0 +1,224 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+package wal
+
+import (
+	"bytes"
+	"encoding/json"
+	"sort"
+	"strconv"
+)
+
+// SnapshotNodes is the node map field of Snapshot. It's a named type so it can
+// implement a hand-written MarshalJSON: encoding/json's reflection-based map
+// encoder is the single most expensive part of a fleet-scale snapshot
+// (~200k entries), and it allocates heavily (driving GC on the registry box).
+//
+// The output is byte-identical to encoding/json (differential-tested): same
+// key ordering (ascending), same field order/omitempty per node, same string
+// escaping (HTML escaping disabled, matching the snapshot encoder). load()
+// re-encodes to verify the checksum, so byte-equality is required.
+type SnapshotNodes map[string]*SnapshotNode
+
+// MarshalJSON is reflection-free and, on the hot path, allocation-free beyond
+// the single result buffer.
+func (m SnapshotNodes) MarshalJSON() ([]byte, error) {
+	return m.appendTo(nil), nil
+}
+
+// appendTo appends the encoding/json-compatible object encoding of m to dst.
+func (m SnapshotNodes) appendTo(dst []byte) []byte {
+	if m == nil {
+		return append(dst, "null"...)
+	}
+	keys := make([]string, 0, len(m))
+	for k := range m {
+		keys = append(keys, k)
+	}
+	sort.Strings(keys) // encoding/json emits map keys in ascending order
+	dst = append(dst, '{')
+	for i, k := range keys {
+		if i > 0 {
+			dst = append(dst, ',')
+		}
+		dst = appendJSONString(dst, k)
+		dst = append(dst, ':')
+		dst = appendSnapshotNode(dst, m[k])
+	}
+	return append(dst, '}')
+}
+
+// appendJSONString appends s as a JSON string. Fast path for printable ASCII
+// with no quote/backslash (base64 keys, addresses, hostnames, RFC3339,
+// "min:max"); anything else (control chars, non-ASCII, invalid UTF-8) falls
+// back to encoding/json with SetEscapeHTML(false) so bytes match exactly.
+func appendJSONString(dst []byte, s string) []byte {
+	safe := true
+	for i := 0; i < len(s); i++ {
+		c := s[i]
+		if c < 0x20 || c == '"' || c == '\\' || c >= 0x80 {
+			safe = false
+			break
+		}
+	}
+	if safe {
+		dst = append(dst, '"')
+		dst = append(dst, s...)
+		return append(dst, '"')
+	}
+	var buf bytes.Buffer
+	e := json.NewEncoder(&buf)
+	e.SetEscapeHTML(false)
+	_ = e.Encode(s)
+	b := buf.Bytes()
+	if len(b) > 0 && b[len(b)-1] == '\n' {
+		b = b[:len(b)-1]
+	}
+	return append(dst, b...)
+}
+
+func appendU16Slice(dst []byte, s []uint16) []byte {
+	if s == nil {
+		return append(dst, "null"...)
+	}
+	dst = append(dst, '[')
+	for i, v := range s {
+		if i > 0 {
+			dst = append(dst, ',')
+		}
+		dst = strconv.AppendUint(dst, uint64(v), 10)
+	}
+	return append(dst, ']')
+}
+
+func appendStringSlice(dst []byte, s []string) []byte {
+	if s == nil {
+		return append(dst, "null"...)
+	}
+	dst = append(dst, '[')
+	for i, v := range s {
+		if i > 0 {
+			dst = append(dst, ',')
+		}
+		dst = appendJSONString(dst, v)
+	}
+	return append(dst, ']')
+}
+
+// appendSnapshotNode mirrors SnapshotNode's struct-tag field order and
+// omitempty rules exactly.
+func appendSnapshotNode(dst []byte, n *SnapshotNode) []byte {
+	if n == nil {
+		return append(dst, "null"...)
+	}
+	dst = append(dst, '{')
+	first := true
+	key := func(name string) {
+		if !first {
+			dst = append(dst, ',')
+		}
+		first = false
+		dst = append(dst, '"')
+		dst = append(dst, name...)
+		dst = append(dst, '"', ':')
+	}
+	key("id")
+	dst = strconv.AppendUint(dst, uint64(n.ID), 10)
+	if n.Owner != "" {
+		key("owner")
+		dst = appendJSONString(dst, n.Owner)
+	}
+	key("public_key")
+	dst = appendJSONString(dst, n.PublicKey)
+	if n.RealAddr != "" {
+		key("real_addr")
+		dst = appendJSONString(dst, n.RealAddr)
+	}
+	key("networks")
+	dst = appendU16Slice(dst, n.Networks)
+	if n.Public {
+		key("public")
+		dst = append(dst, "true"...)
+	}
+	if n.LastSeen != "" {
+		key("last_seen")
+		dst = appendJSONString(dst, n.LastSeen)
+	}
+	if n.Hostname != "" {
+		key("hostname")
+		dst = appendJSONString(dst, n.Hostname)
+	}
+	if len(n.Tags) > 0 {
+		key("tags")
+		dst = appendStringSlice(dst, n.Tags)
+	}
+	if n.TaskExec {
+		key("task_exec")
+		dst = append(dst, "true"...)
+	}
+	if len(n.LANAddrs) > 0 {
+		key("lan_addrs")
+		dst = appendStringSlice(dst, n.LANAddrs)
+	}
+	if n.KeyCreated != "" {
+		key("key_created")
+		dst = appendJSONString(dst, n.KeyCreated)
+	}
+	if n.KeyRotated != "" {
+		key("key_rotated")
+		dst = appendJSONString(dst, n.KeyRotated)
+	}
+	if n.KeyRotCount != 0 {
+		key("key_rot_count")
+		dst = strconv.AppendInt(dst, int64(n.KeyRotCount), 10)
+	}
+	if n.KeyExpires != "" {
+		key("key_expires")
+		dst = appendJSONString(dst, n.KeyExpires)
+	}
+	if n.ExternalID != "" {
+		key("external_id")
+		dst = appendJSONString(dst, n.ExternalID)
+	}
+	if n.Version != "" {
+		key("version")
+		dst = appendJSONString(dst, n.Version)
+	}
+	if n.RelayOnly {
+		key("relay_only")
+		dst = append(dst, "true"...)
+	}
+	if n.Badge != "" {
+		key("badge")
+		dst = appendJSONString(dst, n.Badge)
+	}
+	if n.BadgeSig != "" {
+		key("badge_sig")
+		dst = appendJSONString(dst, n.BadgeSig)
+	}
+	if n.VerificationProvider != "" {
+		key("verification_provider")
+		dst = appendJSONString(dst, n.VerificationProvider)
+	}
+	if n.VerifiedAt != "" {
+		key("verified_at")
+		dst = appendJSONString(dst, n.VerifiedAt)
+	}
+	if n.RecoveryCommitment != "" {
+		key("recovery_commitment")
+		dst = appendJSONString(dst, n.RecoveryCommitment)
+	}
+	if n.RecoveryProvider != "" {
+		key("recovery_provider")
+		dst = appendJSONString(dst, n.RecoveryProvider)
+	}
+	if n.RecoveryConsumedNonce != "" {
+		key("recovery_consumed_nonce")
+		dst = appendJSONString(dst, n.RecoveryConsumedNonce)
+	}
+	if n.RecoveryConsumedExp != "" {
+		key("recovery_consumed_exp")
+		dst = appendJSONString(dst, n.RecoveryConsumedExp)
+	}
+	return append(dst, '}')
+}
diff --git a/wal/zz_fuzz_test.go b/wal/zz_fuzz_test.go
new file mode 100644
index 0000000..4816370
--- /dev/null
+++ b/wal/zz_fuzz_test.go
@@ -0,0 +1,111 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+package wal
+
+import (
+	"bytes"
+	"encoding/json"
+	"strings"
+	"testing"
+)
+
+// Native fuzz targets asserting byte-parity with encoding/json(SetEscapeHTML=false).
+// Run: go test ./wal/ -run '^$' -fuzz=FuzzAppendJSONString -fuzztime=60s (etc.)
+
+func FuzzAppendJSONString(f *testing.F) {
+	for _, s := range []string{
+		"", "hello", `q"b`, `back\slash`, "a<b>&c", "x\u2028y\u2029z",
+		"unicode-雪", "\x00\x01\x1f", "tab\tnewline\n", "\x7f", "\xff\xfe-invalid",
+	} {
+		f.Add(s)
+	}
+	f.Fuzz(func(t *testing.T, s string) {
+		got := appendJSONString(nil, s)
+		var buf bytes.Buffer
+		e := json.NewEncoder(&buf)
+		e.SetEscapeHTML(false)
+		if err := e.Encode(s); err != nil {
+			t.Fatalf("std encode: %v", err)
+		}
+		want := buf.Bytes()
+		if len(want) > 0 && want[len(want)-1] == '\n' {
+			want = want[:len(want)-1]
+		}
+		if !bytes.Equal(got, want) {
+			t.Fatalf("escaping mismatch for %q:\n got=%q\nwant=%q", s, got, want)
+		}
+		if !json.Valid(got) {
+			t.Fatalf("invalid JSON for %q: %q", s, got)
+		}
+	})
+}
+
+func FuzzSnapshotNodes_MarshalParity(f *testing.F) {
+	f.Add("1", "own", "pub", "10.0.0.1:1", "host", "a,b", "/lan", "v1", "badge", uint32(1), 2, true, true, true)
+	f.Fuzz(func(t *testing.T, key, owner, pub, addr, host, tags, lan, version, badge string, id uint32, rot int, public, relay, task bool) {
+		var tagList, lanList []string
+		if tags != "" {
+			tagList = strings.Split(tags, ",")
+		}
+		if lan != "" {
+			lanList = strings.Split(lan, ",")
+		}
+		m := SnapshotNodes{
+			key: {ID: id, Owner: owner, PublicKey: pub, RealAddr: addr, Hostname: host,
+				Tags: tagList, LANAddrs: lanList, Version: version, Badge: badge,
+				KeyRotCount: rot, Public: public, RelayOnly: relay, TaskExec: task},
+		}
+		if key2 := key + "2"; key2 != key {
+			m[key2] = &SnapshotNode{}
+		}
+		got := m.appendTo(nil)
+		want := encRaw(t, map[string]*SnapshotNode(m))
+		if !bytes.Equal(got, want) {
+			n := min(len(got), len(want))
+			i := 0
+			for i < n && got[i] == want[i] {
+				i++
+			}
+			lo := max(0, i-30)
+			t.Fatalf("mismatch at %d for key=%q:\n got=%q\nwant=%q", i, key, got[lo:min(i+30, len(got))], want[lo:min(i+30, len(want))])
+		}
+	})
+}
+
+func FuzzAppendSnapshot_MarshalParity(f *testing.F) {
+	f.Add("own", "pub", "host", "2026-01-01T00:00:00Z", "start", uint32(1), int64(5), uint64(2), true)
+	f.Fuzz(func(t *testing.T, owner, pub, host, lastseen, start string, id uint32, hb int64, term uint64, omit bool) {
+		s := &Snapshot{
+			Version:    1,
+			NextNode:   id,
+			NextNet:    2,
+			Nodes:      SnapshotNodes{"1": {ID: id, Owner: owner, PublicKey: pub, Hostname: host, LastSeen: lastseen, Networks: []uint16{0}, Tags: []string{owner, pub}}},
+			Networks:   map[string]*SnapshotNet{},
+			TrustPairs: json.RawMessage(`["1:2"]`),
+			PubKeyIdx:  map[string]uint32{pub: id},
+			StartTime:  start, LastHeartbeat: hb, Term: term,
+			TotalNodes: 1, OnlineNodes: 1, TrustLinks: 2,
+		}
+		if omit {
+			s.TrustPairs = nil
+			s.PubKeyIdx = nil
+			s.StartTime = ""
+			s.Term = 0
+			s.TotalNodes, s.OnlineNodes, s.TrustLinks = 0, 0, 0
+		}
+		got := AppendSnapshot(nil, s)
+		want := stdEncodeSnapshot(t, s)
+		if !bytes.Equal(got, want) {
+			n := min(len(got), len(want))
+			i := 0
+			for i < n && got[i] == want[i] {
+				i++
+			}
+			lo := max(0, i-30)
+			t.Fatalf("mismatch at %d:\n got=%q\nwant=%q", i, got[lo:min(i+30, len(got))], want[lo:min(i+30, len(want))])
+		}
+		if !json.Valid(got) {
+			t.Fatalf("invalid JSON: %q", got)
+		}
+	})
+}
diff --git a/wal/zz_snapshot_fast_test.go b/wal/zz_snapshot_fast_test.go
new file mode 100644
index 0000000..6e215bb
--- /dev/null
+++ b/wal/zz_snapshot_fast_test.go
@@ -0,0 +1,120 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+package wal
+
+import (
+	"bytes"
+	"encoding/json"
+	"testing"
+
+	wire "github.com/pilot-protocol/common/registry/wire"
+	auditpkg "github.com/pilot-protocol/rendezvous/audit"
+	dashpkg "github.com/pilot-protocol/rendezvous/dashboard"
+	membpkg "github.com/pilot-protocol/rendezvous/membership"
+	trustpkg "github.com/pilot-protocol/rendezvous/trust"
+)
+
+func richSnapshot() *Snapshot {
+	return &Snapshot{
+		Version:  1,
+		NextNode: 42,
+		NextNet:  3,
+		Nodes: SnapshotNodes{
+			"1": {ID: 1, Owner: "o1", PublicKey: "k1", RealAddr: "10.0.0.1:1", Networks: []uint16{0, 3}, LastSeen: "2026-10-01T12:00:00Z", Hostname: "h1", Tags: []string{"a"}, Version: "v1"},
+			"2": {ID: 2, PublicKey: `q"b\c`, Networks: []uint16{}, Badge: "b", KeyRotCount: 2, RelayOnly: true},
+		},
+		Networks: map[string]*SnapshotNet{
+			"0": {ID: 0, Name: "n0", JoinRule: "open", Members: []uint32{1, 2},
+				MemberRoles: map[string]string{"1": "owner"}, MemberTags: map[string][]string{"1": {"x"}},
+				Policy: &membpkg.NetworkPolicy{MaxMembers: 5, AllowedPorts: []uint16{80}}, Rules: &wire.NetworkRules{},
+				ExprPolicy: json.RawMessage(`{"a":1}`), Created: "2026-01-01T00:00:00Z"},
+		},
+		TrustPairs: json.RawMessage(`["1:2","3:4"]`),
+		PubKeyIdx:  map[string]uint32{"k1": 1, "k2": 2},
+		HandshakeInbox: map[string][]*trustpkg.HandshakeRelayMsg{
+			"1": {{}},
+		},
+		HandshakeResponses: map[string][]*trustpkg.HandshakeResponseMsg{
+			"1": {{}},
+		},
+		InviteInbox: map[string][]*membpkg.NetworkInvite{
+			"1": {{}},
+		},
+		TotalRequests:     99,
+		TotalNodes:        2,
+		OnlineNodes:       1,
+		TrustLinks:        2,
+		UniqueTags:        1,
+		TaskExecutors:     1,
+		StartTime:         "2026-01-01T00:00:00Z",
+		RestartEvents:     []int64{1, 2},
+		DowntimeIntervals: [][2]int64{{1, 2}},
+		LastHeartbeat:     123,
+		ProbeStates:       map[string]*dashpkg.ProbeState{"p": {}},
+		HourlyHistory:     []dashpkg.StatsSample{{}},
+		DailyHistory:      []dashpkg.StatsSample{{}},
+		NetHourlyHistory:  map[string][]dashpkg.NetworkSampleEntry{"0": {{}}},
+		NetDailyHistory:   map[string][]dashpkg.NetworkSampleEntry{"0": {{}}},
+		AuditLog:          []auditpkg.Entry{{}},
+		IDPConfig:         &wire.BlueprintIdentityProvider{},
+		AuditExportCfg:    &wire.BlueprintAuditExport{},
+		RBACPreAssign:     map[string][]wire.BlueprintRole{"0": {{}}},
+		Term:              7,
+	}
+}
+
+func stdEncodeSnapshot(t testing.TB, s *Snapshot) []byte {
+	t.Helper()
+	var buf bytes.Buffer
+	e := json.NewEncoder(&buf)
+	e.SetEscapeHTML(false)
+	if err := e.Encode(s); err != nil {
+		t.Fatalf("encode: %v", err)
+	}
+	b := buf.Bytes()
+	if len(b) > 0 && b[len(b)-1] == '\n' {
+		b = b[:len(b)-1]
+	}
+	return b
+}
+
+func TestAppendSnapshot_ByteIdenticalFull(t *testing.T) {
+	for _, s := range []*Snapshot{richSnapshot(), {}} {
+		got := AppendSnapshot(nil, s)
+		want := stdEncodeSnapshot(t, s)
+		if !bytes.Equal(got, want) {
+			n := min(len(got), len(want))
+			i := 0
+			for i < n && got[i] == want[i] {
+				i++
+			}
+			lo := max(0, i-40)
+			t.Fatalf("mismatch at %d:\n got=%q\nwant=%q", i, got[lo:min(i+40, len(got))], want[lo:min(i+40, len(want))])
+		}
+	}
+}
+
+func BenchmarkAppendSnapshot_Std(b *testing.B) {
+	s := &Snapshot{Version: 1, NextNode: 200000, NextNet: 1,
+		Nodes: sampleNodes(200_000), Networks: map[string]*SnapshotNet{},
+		TrustPairs: json.RawMessage(`["1:2"]`),
+		PubKeyIdx:  map[string]uint32{"a": 1}, TotalNodes: 200000}
+	b.ReportAllocs()
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_ = stdEncodeSnapshot(b, s)
+	}
+}
+
+func BenchmarkAppendSnapshot_Fast(b *testing.B) {
+	s := &Snapshot{Version: 1, NextNode: 200000, NextNet: 1,
+		Nodes: sampleNodes(200_000), Networks: map[string]*SnapshotNet{},
+		TrustPairs: json.RawMessage(`["1:2"]`),
+		PubKeyIdx:  map[string]uint32{"a": 1}, TotalNodes: 200000}
+	buf := make([]byte, 0, 32<<20)
+	b.ReportAllocs()
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		buf = AppendSnapshot(buf[:0], s)
+	}
+}
diff --git a/wal/zz_snapshot_nodes_test.go b/wal/zz_snapshot_nodes_test.go
new file mode 100644
index 0000000..06245d2
--- /dev/null
+++ b/wal/zz_snapshot_nodes_test.go
@@ -0,0 +1,100 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+package wal
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"strconv"
+	"testing"
+)
+
+type wrapFast struct {
+	N SnapshotNodes `json:"n"`
+}
+type wrapStd struct {
+	N map[string]*SnapshotNode `json:"n"`
+}
+
+func encRaw(t testing.TB, v interface{}) []byte {
+	t.Helper()
+	var buf bytes.Buffer
+	e := json.NewEncoder(&buf)
+	e.SetEscapeHTML(false)
+	if err := e.Encode(v); err != nil {
+		t.Fatalf("encode: %v", err)
+	}
+	b := buf.Bytes()
+	if len(b) > 0 && b[len(b)-1] == '\n' {
+		b = b[:len(b)-1]
+	}
+	return b
+}
+
+func sampleNodes(n int) SnapshotNodes {
+	m := make(SnapshotNodes, n)
+	for i := 0; i < n; i++ {
+		m[strconv.Itoa(i)] = &SnapshotNode{
+			ID:        uint32(i),
+			Owner:     fmt.Sprintf("owner-%d", i),
+			PublicKey: "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8=",
+			RealAddr:  "10.0.0.1:1234",
+			Networks:  []uint16{0, 3},
+			LastSeen:  "2026-10-01T12:00:00Z",
+			Hostname:  fmt.Sprintf("host-%d", i),
+			Version:   "v1.2.3",
+		}
+	}
+	return m
+}
+
+// The hand-written encoder must be byte-identical to encoding/json — load()
+// re-encodes the struct to verify the snapshot checksum.
+func TestSnapshotNodes_MarshalByteIdentical(t *testing.T) {
+	m := sampleNodes(8000)
+	m["zz"] = &SnapshotNode{ID: 1, PublicKey: `q"b\c`, Hostname: "a<b>&c", LastSeen: "x\u2028y", Tags: []string{"t\t1", "unicode-雪", ""}}
+	m["nilnode"] = nil
+	m["empty"] = &SnapshotNode{ID: 2, PublicKey: "", Networks: []uint16{}}
+
+	got := encRaw(t, wrapFast{N: m})
+	want := encRaw(t, wrapStd{N: map[string]*SnapshotNode(m)})
+	if !bytes.Equal(got, want) {
+		n := min(len(got), len(want))
+		i := 0
+		for i < n && got[i] == want[i] {
+			i++
+		}
+		lo := max(0, i-30)
+		t.Fatalf("mismatch at byte %d:\n got=%q\nwant=%q", i, got[lo:min(i+30, len(got))], want[lo:min(i+30, len(want))])
+	}
+}
+
+func TestSnapshotNodes_NilAndEmpty(t *testing.T) {
+	if got := encRaw(t, wrapFast{N: nil}); string(got) != `{"n":null}` {
+		t.Fatalf("nil = %s, want {\"n\":null}", got)
+	}
+	if got := encRaw(t, wrapFast{N: SnapshotNodes{}}); string(got) != `{"n":{}}` {
+		t.Fatalf("empty = %s, want {\"n\":{}}", got)
+	}
+}
+
+func BenchmarkSnapshotNodes_Std(b *testing.B) {
+	m := sampleNodes(200_000)
+	// wrap in a plain map to force the std encoder
+	plain := map[string]*SnapshotNode(m)
+	b.ReportAllocs()
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_ = encRaw(b, wrapStd{N: plain})
+	}
+}
+
+func BenchmarkSnapshotNodes_Fast(b *testing.B) {
+	m := sampleNodes(200_000)
+	b.ReportAllocs()
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_ = encRaw(b, wrapFast{N: m})
+	}
+}
diff --git a/zz_save_memory_test.go b/zz_save_memory_test.go
index 70a467c..c66f06c 100644
--- a/zz_save_memory_test.go
+++ b/zz_save_memory_test.go
@@ -2,52 +2,7 @@
 
 package server
 
-import (
-	"bytes"
-	"testing"
-)
-
-// The snapshot encode path streams JSON straight to disk (no pooled buffer).
-// trimTrailingNewlineWriter withholds the encoder's trailing '\n' so the
-// checksum covers `{...}` exactly as load() recomputes it.
-
-func TestTrimTrailingNewlineWriterDropsFinalByte(t *testing.T) {
-	t.Parallel()
-	var buf bytes.Buffer
-	w := &trimTrailingNewlineWriter{w: &buf}
-	if _, err := w.Write([]byte(`{"a":1}` + "\n")); err != nil {
-		t.Fatalf("write: %v", err)
-	}
-	if got, want := buf.String(), `{"a":1}`; got != want {
-		t.Fatalf("body = %q, want %q (trailing newline must be withheld)", got, want)
-	}
-}
-
-func TestTrimTrailingNewlineWriterAcrossChunks(t *testing.T) {
-	t.Parallel()
-	var buf bytes.Buffer
-	w := &trimTrailingNewlineWriter{w: &buf}
-	for _, chunk := range []string{`{"a"`, `:1}`, "\n"} {
-		if _, err := w.Write([]byte(chunk)); err != nil {
-			t.Fatalf("write %q: %v", chunk, err)
-		}
-	}
-	if got, want := buf.String(), `{"a":1}`; got != want {
-		t.Fatalf("body = %q, want %q (streaming across chunks)", got, want)
-	}
-}
-
-func TestTrimTrailingNewlineWriterEmptyWrite(t *testing.T) {
-	t.Parallel()
-	var buf bytes.Buffer
-	w := &trimTrailingNewlineWriter{w: &buf}
-	if n, err := w.Write(nil); n != 0 || err != nil {
-		t.Fatalf("empty write = (%d, %v), want (0, nil)", n, err)
-	}
-	if buf.Len() != 0 {
-		t.Fatalf("buffer = %q, want empty", buf.String())
-	}
-}
+import "testing"
 
 func TestShouldScavengeGate(t *testing.T) {
 	lastScavengeMs.Store(0)

From a072731bc41175a4893f046bc7556a52cc4a77fe Mon Sep 17 00:00:00 2001
From: pilot <pilot@vulturelabs.io>
Date: Fri, 2 Oct 2026 00:56:55 +0300
Subject: [PATCH 4/5] rendezvous: drop parallel node encoding (memory-bound, no
 gain)

Chunking the node-map encode across goroutines measured no faster than
serial (the encoder is memory-bandwidth-bound) while allocating ~18x more
(172MB vs 9.4MB per 200k-node encode). Keep the serial hand-written encoder:
2.25x faster than encoding/json including the key sort, with ~6x less
allocation.
---
 wal/snapshot_nodes.go         | 3 +++
 wal/zz_snapshot_nodes_test.go | 9 ++++-----
 2 files changed, 7 insertions(+), 5 deletions(-)

diff --git a/wal/snapshot_nodes.go b/wal/snapshot_nodes.go
index 9fb3abf..edb7039 100644
--- a/wal/snapshot_nodes.go
+++ b/wal/snapshot_nodes.go
@@ -27,6 +27,9 @@ func (m SnapshotNodes) MarshalJSON() ([]byte, error) {
 }
 
 // appendTo appends the encoding/json-compatible object encoding of m to dst.
+// Serial by design: the encoder is memory-bandwidth-bound, so chunking across
+// goroutines measured no faster while allocating ~18x more, and the reused
+// dst keeps this allocation-free beyond dst's own growth.
 func (m SnapshotNodes) appendTo(dst []byte) []byte {
 	if m == nil {
 		return append(dst, "null"...)
diff --git a/wal/zz_snapshot_nodes_test.go b/wal/zz_snapshot_nodes_test.go
index 06245d2..053b646 100644
--- a/wal/zz_snapshot_nodes_test.go
+++ b/wal/zz_snapshot_nodes_test.go
@@ -80,21 +80,20 @@ func TestSnapshotNodes_NilAndEmpty(t *testing.T) {
 }
 
 func BenchmarkSnapshotNodes_Std(b *testing.B) {
-	m := sampleNodes(200_000)
-	// wrap in a plain map to force the std encoder
-	plain := map[string]*SnapshotNode(m)
+	m := map[string]*SnapshotNode(sampleNodes(200_000))
 	b.ReportAllocs()
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		_ = encRaw(b, wrapStd{N: plain})
+		_ = encRaw(b, m)
 	}
 }
 
 func BenchmarkSnapshotNodes_Fast(b *testing.B) {
 	m := sampleNodes(200_000)
+	buf := make([]byte, 0, 32<<20)
 	b.ReportAllocs()
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		_ = encRaw(b, wrapFast{N: m})
+		buf = m.appendTo(buf[:0])
 	}
 }

From 7e7d78d8fafa24d4e94e334c6d6f658525fe0c3f Mon Sep 17 00:00:00 2001
From: pilot <pilot@vulturelabs.io>
Date: Fri, 2 Oct 2026 01:05:18 +0300
Subject: [PATCH 5/5] rendezvous: harden snapshot encoder against funky
 strings/hostnames
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Add an explicit differential test stuffing every string field (and map keys)
with adversarial values — quotes, backslashes, HTML, control chars,
U+2028/2029, unicode, emoji, invalid UTF-8, very long, whitespace — plus
fuzz seeds for the same. Byte-parity with encoding/json holds; output is
always valid JSON.
---
 wal/zz_fuzz_test.go           |  7 ++++++
 wal/zz_snapshot_nodes_test.go | 44 +++++++++++++++++++++++++++++++++++
 2 files changed, 51 insertions(+)

diff --git a/wal/zz_fuzz_test.go b/wal/zz_fuzz_test.go
index 4816370..0b94236 100644
--- a/wal/zz_fuzz_test.go
+++ b/wal/zz_fuzz_test.go
@@ -42,6 +42,11 @@ func FuzzAppendJSONString(f *testing.F) {
 
 func FuzzSnapshotNodes_MarshalParity(f *testing.F) {
 	f.Add("1", "own", "pub", "10.0.0.1:1", "host", "a,b", "/lan", "v1", "badge", uint32(1), 2, true, true, true)
+	// funky hostname / strings seeds
+	f.Add(`a"b`, "own", "pub", "10.0.0.1:1", `a\b`, "a,b", "/lan", "v1", "b", uint32(2), 0, false, false, false)
+	f.Add("x\u2028y", "own", "pub", "10.0.0.1:1", "héllo.😀", "a,b", "/lan", "v1", "b", uint32(3), 0, false, false, false)
+	f.Add("<h>&'", "own", "pub", "10.0.0.1:1", "\x00\x1f\x7f", "a,b", "/lan", "v1", "b", uint32(4), 0, false, false, false)
+	f.Add("日本.рф", "own", "pub", "10.0.0.1:1", "USER@Host:/x?y", "a,b", "/lan", "v1", "b", uint32(5), 0, false, false, false)
 	f.Fuzz(func(t *testing.T, key, owner, pub, addr, host, tags, lan, version, badge string, id uint32, rot int, public, relay, task bool) {
 		var tagList, lanList []string
 		if tags != "" {
@@ -74,6 +79,8 @@ func FuzzSnapshotNodes_MarshalParity(f *testing.F) {
 
 func FuzzAppendSnapshot_MarshalParity(f *testing.F) {
 	f.Add("own", "pub", "host", "2026-01-01T00:00:00Z", "start", uint32(1), int64(5), uint64(2), true)
+	f.Add(`a"b`, "pub", `h\st`, "x\u2028y", "héllo.😀", uint32(2), int64(0), uint64(0), false)
+	f.Add("\x00\x1f", "pub", "日本.рф", "t\tb", "<h>&'", uint32(3), int64(-1), uint64(7), false)
 	f.Fuzz(func(t *testing.T, owner, pub, host, lastseen, start string, id uint32, hb int64, term uint64, omit bool) {
 		s := &Snapshot{
 			Version:    1,
diff --git a/wal/zz_snapshot_nodes_test.go b/wal/zz_snapshot_nodes_test.go
index 053b646..181c634 100644
--- a/wal/zz_snapshot_nodes_test.go
+++ b/wal/zz_snapshot_nodes_test.go
@@ -7,6 +7,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"strconv"
+	"strings"
 	"testing"
 )
 
@@ -70,6 +71,49 @@ func TestSnapshotNodes_MarshalByteIdentical(t *testing.T) {
 	}
 }
 
+// Every string field is stuffed with adversarial values (HTML, quotes,
+// backslashes, control chars, U+2028/2029, unicode, emoji, invalid UTF-8,
+// very long, whitespace) — the hand-written encoder must match encoding/json
+// byte-for-byte. This is the "funky hostname" guard.
+func TestSnapshotNodes_FunkyStrings(t *testing.T) {
+	funky := []string{
+		"", " ", "  lead/trail  ",
+		`a"b`, `a\b`, `a\\b`, "a<b>&c",
+		"x\u2028y", "x\u2029y", "t\tb", "n\nl", "r\rb",
+		"\x00\x01\x1f", "\x7f", "\xff\xfe-invalid", "héllo.wörld", "😀-emoji",
+		"日本.example", "МОСКВА.рф", "USER@Host", "a:b/c%d?e=f",
+		strings.Repeat("long", 200),
+	}
+	m := SnapshotNodes{}
+	for i, s := range funky {
+		m[strconv.Itoa(i)] = &SnapshotNode{
+			ID: uint32(i), Owner: s, PublicKey: s, RealAddr: s, Hostname: s,
+			Tags: []string{s, "t"}, LANAddrs: []string{s}, Version: s, Badge: s,
+			BadgeSig: s, VerificationProvider: s, ExternalID: s, LastSeen: s,
+			KeyCreated: s, RecoveryCommitment: s,
+		}
+	}
+	// funky *map keys* too (hostname-index-ish keys)
+	for i, s := range funky {
+		m["k"+s+strconv.Itoa(i)] = &SnapshotNode{ID: 1, PublicKey: "p", Networks: []uint16{0}}
+	}
+
+	got := m.appendTo(nil)
+	want := encRaw(t, map[string]*SnapshotNode(m))
+	if !bytes.Equal(got, want) {
+		n := min(len(got), len(want))
+		i := 0
+		for i < n && got[i] == want[i] {
+			i++
+		}
+		lo := max(0, i-30)
+		t.Fatalf("funky-string mismatch at %d:\n got=%q\nwant=%q", i, got[lo:min(i+30, len(got))], want[lo:min(i+30, len(want))])
+	}
+	if !json.Valid(got) {
+		t.Fatal("hand-written encoder produced invalid JSON")
+	}
+}
+
 func TestSnapshotNodes_NilAndEmpty(t *testing.T) {
 	if got := encRaw(t, wrapFast{N: nil}); string(got) != `{"n":null}` {
 		t.Fatalf("nil = %s, want {\"n\":null}", got)