feat(read-state): semantic eviction + multi-slot splitting

The byte-budget trim in #1305 is a reactive backstop — it fires after
the blob is already too large. Two proactive improvements:

1. Semantic eviction (NIP-RS §Eviction): thread: and msg: entries whose
   timestamp is <= the channel frontier are semantically inert. Drop them
   in currentContexts() before the byte-budget check fires, keeping the
   blob small proactively. Only runs when parentResolver is set; skips
   silently when null so we never evict what we can't verify is dominated.

2. Multi-slot splitting: when channel keys alone exceed 32 KB (degenerate
   case: thousands of channels), partition them across multiple kind:30078
   events using the existing slotId mechanism. Each slot gets its own
   d-tag and is published independently. Capped at READ_STATE_MAX_SLOTS=8
   (~5,200 channels). Extra slot IDs are persisted in localStorage.

mergeEvents now unions all own-slot blobs (max-merge) instead of taking
the single highest-created_at blob. fetchOwnBlobBeforePublish fetches all
own slot d-tags in one query. publishOneSlot extracted to avoid
duplication between single-slot and multi-slot paths.

Adds evictDominatedEntries as an exported pure function for testability,
with 6 new unit tests covering: dominated eviction, newer-than-channel
survival, equal-ts eviction, unresolvable parent, missing parent frontier,
and channel-key immunity.

Co-authored-by: Will Pfleger <pfleger.will@gmail.com>
Signed-off-by: Will Pfleger <pfleger.will@gmail.com>

Author: npub1mn7jgtj4w2pd0g0zeuhxsa6jy6p0rewxz4kujt98my82ahfmp72sxjexk7

desktop/src/features/channels/readState/readStateFormat.ts

@@ -16,6 +16,12 @@ export const MAX_CONTEXTS = 10_000;
 // expansion to ~45 KB ciphertext) while keeping the blob well under both caps.
 export const READ_STATE_MAX_PLAINTEXT_BYTES = 32_768;
 
+// Maximum number of slots a client may publish. Each slot is a separate
+// kind:30078 event. Splitting across slots is the fallback when channel keys
+// alone exceed READ_STATE_MAX_PLAINTEXT_BYTES. 8 slots × ~650 channel keys per
+// slot = ~5,200 channels — well beyond any realistic user.
+export const READ_STATE_MAX_SLOTS = 8;
+
 // Context-key prefix for a per-MESSAGE read marker (LP4 v3). One grow-only
 // marker per reply id; the badge predicate reads effective("msg:<id>") live so
 // reading an ancestor never covers a descendant (Issue 2 by construction).
@@ -104,6 +110,10 @@ export function isValidReadStateDTag(
   return slotId.length > 0 && slotId.length <= 64 && isAscii(slotId);
 }
 
+export function localExtraSlotIdsKey(pubkey: string): string {
+  return `buzz.nip-rs.extra-slot-ids:${pubkey}`;
+}
+
 export function localIsoToUnixSeconds(value: unknown): number | null {
   if (typeof value !== "string" || value.length === 0) {
     return null;

desktop/src/features/channels/readState/readStateManager.test.mjs

@@ -3,6 +3,7 @@ import test from "node:test";
 
 import {
   applyRemoteContextTimestamp,
+  evictDominatedEntries,
   resolveEffectiveTimestamp,
   trimContextsToBudget,
 } from "./readStateManager.ts";
@@ -300,3 +301,103 @@ test("trimContextsToBudget_channelOnlyBlobExceedsBudget_fitsAfterTrimFalse", ()
   // Channel key must still be present.
   assert.ok("channel:some-channel-id" in contexts);
 });
+
+// ── evictDominatedEntries ─────────────────────────────────────────────────────
+
+const CHANNEL_ID = "channel-abc";
+const THREAD_ID_A = "a".repeat(64);
+const MSG_ID_A = "b".repeat(64);
+
+const threadResolver = (ctx) => {
+  if (ctx.startsWith("thread:") || ctx.startsWith("msg:")) return CHANNEL_ID;
+  return null;
+};
+
+test("evictDominatedEntries_dominatedThreadAndMsg_evictedChannelSurvives", () => {
+  // Channel read at 500; thread read at 300 (dominated); msg read at 200 (dominated).
+  const effectiveState = new Map([
+    [CHANNEL_ID, 500],
+    [`thread:${THREAD_ID_A}`, 300],
+    [`msg:${MSG_ID_A}`, 200],
+  ]);
+  const contexts = {
+    [CHANNEL_ID]: 500,
+    [`thread:${THREAD_ID_A}`]: 300,
+    [`msg:${MSG_ID_A}`]: 200,
+  };
+
+  const count = evictDominatedEntries(contexts, effectiveState, threadResolver);
+
+  assert.equal(count, 2, "both dominated entries evicted");
+  assert.ok(!(`thread:${THREAD_ID_A}` in contexts), "thread entry evicted");
+  assert.ok(!(`msg:${MSG_ID_A}` in contexts), "msg entry evicted");
+  assert.ok(CHANNEL_ID in contexts, "channel key survives");
+});
+
+test("evictDominatedEntries_threadNewerThanChannel_notEvicted", () => {
+  // Thread read at 600 > channel at 500 — thread is NOT dominated.
+  const effectiveState = new Map([
+    [CHANNEL_ID, 500],
+    [`thread:${THREAD_ID_A}`, 600],
+  ]);
+  const contexts = {
+    [CHANNEL_ID]: 500,
+    [`thread:${THREAD_ID_A}`]: 600,
+  };
+
+  const count = evictDominatedEntries(contexts, effectiveState, threadResolver);
+
+  assert.equal(count, 0, "no entries evicted when thread is newer");
+  assert.ok(`thread:${THREAD_ID_A}` in contexts, "thread entry survives");
+});
+
+test("evictDominatedEntries_threadEqualToChannel_evicted", () => {
+  // ts === parentTs is dominated (<=).
+  const effectiveState = new Map([
+    [CHANNEL_ID, 400],
+    [`thread:${THREAD_ID_A}`, 400],
+  ]);
+  const contexts = {
+    [`thread:${THREAD_ID_A}`]: 400,
+  };
+
+  const count = evictDominatedEntries(contexts, effectiveState, threadResolver);
+
+  assert.equal(count, 1);
+  assert.ok(!(`thread:${THREAD_ID_A}` in contexts), "equal-ts entry evicted");
+});
+
+test("evictDominatedEntries_unresolvedParent_notEvicted", () => {
+  // Resolver returns null for this key — must not evict.
+  const effectiveState = new Map([[`thread:${THREAD_ID_A}`, 300]]);
+  const contexts = { [`thread:${THREAD_ID_A}`]: 300 };
+  const nullResolver = () => null;
+
+  const count = evictDominatedEntries(contexts, effectiveState, nullResolver);
+
+  assert.equal(count, 0, "no eviction when parent unresolvable");
+  assert.ok(`thread:${THREAD_ID_A}` in contexts);
+});
+
+test("evictDominatedEntries_parentNotInEffectiveState_notEvicted", () => {
+  // Parent resolves to CHANNEL_ID but CHANNEL_ID has no entry in effectiveState.
+  const effectiveState = new Map([[`thread:${THREAD_ID_A}`, 300]]);
+  const contexts = { [`thread:${THREAD_ID_A}`]: 300 };
+
+  const count = evictDominatedEntries(contexts, effectiveState, threadResolver);
+
+  assert.equal(count, 0, "no eviction when parent has no frontier");
+  assert.ok(`thread:${THREAD_ID_A}` in contexts);
+});
+
+test("evictDominatedEntries_channelKeysNeverTouched", () => {
+  // Channel keys don't start with thread: or msg: — must never be evicted.
+  const effectiveState = new Map([[CHANNEL_ID, 999]]);
+  const contexts = { [CHANNEL_ID]: 999, "other-key": 100 };
+
+  const count = evictDominatedEntries(contexts, effectiveState, threadResolver);
+
+  assert.equal(count, 0);
+  assert.ok(CHANNEL_ID in contexts, "channel key untouched");
+  assert.ok("other-key" in contexts, "non-prefixed key untouched");
+});