fix(read-state): address Thufir review findings on multi-slot splitting

Four findings from pass 1 review:

CRITICAL 1 — publishSplitSlots retry storm: add no-op suppression by
computing the union of all slot contexts and comparing to
lastPublishedContexts before resetting and publishing. Without this,
every debounce cycle in split mode re-published all slots even when
nothing changed.

CRITICAL 2 — split→single transition stale keys: reset
lastPublishedContexts = {} before single-slot publish so stale keys from
a previous split don't cause isIdenticalToLastPublished to return false
forever. Add deleteExtraSlots() which publishes NIP-09 kind:5 delete
events (a-tag) for each extra slot d-tag and clears extraSlotIds from
localStorage. Called at the top of publish() when transitioning from
split to single mode.

IMPORTANT 1 — thread/msg entries silently dropped in split mode:
splitContextsIntoSlots now collects thread/msg entries separately and
adds them to the primary slot (slot 0) after channel key distribution.
trimContextsToBudget is applied to slot 0 to keep it within budget.

IMPORTANT 2 — no tests for multi-slot machinery: extract core split
logic into exported pure function splitContextsIntoBudgetedSlots (takes
channelEntries, threadMsgEntries, clientId, slotIdGenerator, etc.) so
it can be tested without class instantiation. Add 5 unit tests:
- fitsInOneSlot_returnsSingleSlot
- requiresGrowth_allocatesExtraSlot
- exceedsMaxSlots_returnsNull
- includesThreadMsgInPrimarySlot
- threadMsgTrimmedWhenPrimarySlotOverBudget

Also addresses Thufir MINOR on distribute loop elegance: replaced the
clear-and-redistribute-in-place pattern with a clean distribute(count)
closure that allocates fresh slot maps each call.

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/readStateManager.test.mjs

@@ -5,6 +5,7 @@ import {
   applyRemoteContextTimestamp,
   evictDominatedEntries,
   resolveEffectiveTimestamp,
+  splitContextsIntoBudgetedSlots,
   trimContextsToBudget,
 } from "./readStateManager.ts";
 
@@ -401,3 +402,173 @@ test("evictDominatedEntries_channelKeysNeverTouched", () => {
   assert.ok(CHANNEL_ID in contexts, "channel key untouched");
   assert.ok("other-key" in contexts, "non-prefixed key untouched");
 });
+
+// ── splitContextsIntoBudgetedSlots ────────────────────────────────────────────
+
+// Build a channel key that is ~70 bytes in the JSON blob:
+// `"channel-<64-hex>":1` ≈ 70 bytes including quotes, colon, comma.
+const makeChannelKey = (n) => `channel-${n.toString().padStart(64, "0")}`;
+const makeThreadKey = (n) => `thread:${n.toString().padStart(64, "0")}`;
+const makeMsgKey = (n) => `msg:${n.toString().padStart(64, "0")}`;
+
+// Compute the byte size of a single-slot blob with the given contexts.
+const blobSize = (clientId, contexts) => {
+  const encoder = new TextEncoder();
+  return encoder.encode(JSON.stringify({ v: 1, client_id: clientId, contexts }))
+    .length;
+};
+
+let slotCounter = 0;
+const deterministicSlotId = () =>
+  `slot-${(++slotCounter).toString().padStart(4, "0")}`;
+
+test("splitContextsIntoBudgetedSlots_fitsInOneSlot_returnsSingleSlot", () => {
+  // 3 channel keys — easily fits in one slot with a generous budget.
+  const channelEntries = [
+    [makeChannelKey(1), 100],
+    [makeChannelKey(2), 200],
+    [makeChannelKey(3), 300],
+  ];
+  const result = splitContextsIntoBudgetedSlots({
+    channelEntries,
+    threadMsgEntries: [],
+    clientId: CLIENT_ID,
+    initialSlotCount: 1,
+    maxSlots: 8,
+    maxBytes: 1_000_000,
+    slotIdGenerator: deterministicSlotId,
+  });
+
+  assert.ok(result !== null, "should succeed");
+  assert.equal(result.slots.length, 1, "single slot");
+  assert.equal(result.extraSlotIds.length, 0, "no extra slots allocated");
+  // All channel keys present in slot 0.
+  for (const [key] of channelEntries) {
+    assert.ok(key in result.slots[0], `${key} should be in slot 0`);
+  }
+});
+
+test("splitContextsIntoBudgetedSlots_requiresGrowth_allocatesExtraSlot", () => {
+  // Build enough channel keys that a single slot overflows a tight budget
+  // but two slots fit.
+  const channelEntries = [];
+  for (let i = 0; i < 20; i++) {
+    channelEntries.push([makeChannelKey(i), i + 1]);
+  }
+  const encoder = new TextEncoder();
+  // Budget that fits ~10 channel keys but not 20.
+  const tenKeyContexts = Object.fromEntries(channelEntries.slice(0, 10));
+  const tenKeySize = encoder.encode(
+    JSON.stringify({ v: 1, client_id: CLIENT_ID, contexts: tenKeyContexts }),
+  ).length;
+  const budget = tenKeySize + 50; // fits 10 but not 20
+
+  const result = splitContextsIntoBudgetedSlots({
+    channelEntries,
+    threadMsgEntries: [],
+    clientId: CLIENT_ID,
+    initialSlotCount: 1,
+    maxSlots: 8,
+    maxBytes: budget,
+    slotIdGenerator: deterministicSlotId,
+  });
+
+  assert.ok(result !== null, "should succeed with 2 slots");
+  assert.equal(result.slots.length, 2, "two slots");
+  assert.equal(result.extraSlotIds.length, 1, "one extra slot allocated");
+  // All 20 keys present across both slots.
+  const allKeys = new Set([
+    ...Object.keys(result.slots[0]),
+    ...Object.keys(result.slots[1]),
+  ]);
+  for (const [key] of channelEntries) {
+    assert.ok(allKeys.has(key), `${key} should appear in some slot`);
+  }
+  // Each slot fits within budget.
+  for (const slotContexts of result.slots) {
+    const size = encoder.encode(
+      JSON.stringify({ v: 1, client_id: CLIENT_ID, contexts: slotContexts }),
+    ).length;
+    assert.ok(size <= budget, `slot size ${size} exceeds budget ${budget}`);
+  }
+});
+
+test("splitContextsIntoBudgetedSlots_exceedsMaxSlots_returnsNull", () => {
+  // Build enough channel keys that even maxSlots=2 can't fit them with a
+  // very tight budget (1 byte — nothing can fit).
+  const channelEntries = [[makeChannelKey(1), 1]];
+  const result = splitContextsIntoBudgetedSlots({
+    channelEntries,
+    threadMsgEntries: [],
+    clientId: CLIENT_ID,
+    initialSlotCount: 1,
+    maxSlots: 2,
+    maxBytes: 1, // impossibly small
+    slotIdGenerator: deterministicSlotId,
+  });
+
+  assert.equal(result, null, "should return null when max slots exceeded");
+});
+
+test("splitContextsIntoBudgetedSlots_includesThreadMsgInPrimarySlot", () => {
+  // Channel key in slot 0; thread and msg entries should also land in slot 0.
+  const channelEntries = [[makeChannelKey(1), 100]];
+  const threadMsgEntries = [
+    [makeThreadKey(1), 200],
+    [makeMsgKey(1), 300],
+  ];
+
+  const result = splitContextsIntoBudgetedSlots({
+    channelEntries,
+    threadMsgEntries,
+    clientId: CLIENT_ID,
+    initialSlotCount: 1,
+    maxSlots: 8,
+    maxBytes: 1_000_000,
+    slotIdGenerator: deterministicSlotId,
+  });
+
+  assert.ok(result !== null, "should succeed");
+  assert.equal(result.slots.length, 1);
+  // Channel key in slot 0.
+  assert.ok(makeChannelKey(1) in result.slots[0], "channel key in slot 0");
+  // Thread and msg entries in slot 0.
+  assert.ok(makeThreadKey(1) in result.slots[0], "thread key in slot 0");
+  assert.ok(makeMsgKey(1) in result.slots[0], "msg key in slot 0");
+});
+
+test("splitContextsIntoBudgetedSlots_threadMsgTrimmedWhenPrimarySlotOverBudget", () => {
+  // Channel key fills the primary slot to near-budget. Thread/msg entries
+  // added to slot 0 would overflow — trimContextsToBudget must evict them.
+  const channelEntries = [[makeChannelKey(1), 100]];
+  // Compute the size of a blob with just the channel key.
+  const channelOnlyContexts = { [makeChannelKey(1)]: 100 };
+  const channelOnlySize = blobSize(CLIENT_ID, channelOnlyContexts);
+  // Budget = channel-only size + 5 bytes: fits the channel key but not
+  // an additional thread/msg entry (~70+ bytes each).
+  const budget = channelOnlySize + 5;
+
+  const threadMsgEntries = [[makeThreadKey(1), 200]];
+
+  const result = splitContextsIntoBudgetedSlots({
+    channelEntries,
+    threadMsgEntries,
+    clientId: CLIENT_ID,
+    initialSlotCount: 1,
+    maxSlots: 8,
+    maxBytes: budget,
+    slotIdGenerator: deterministicSlotId,
+  });
+
+  assert.ok(result !== null, "should succeed");
+  // Channel key must survive (never evicted by trimContextsToBudget).
+  assert.ok(makeChannelKey(1) in result.slots[0], "channel key survives");
+  // Thread entry must be evicted (doesn't fit within budget).
+  assert.ok(
+    !(makeThreadKey(1) in result.slots[0]),
+    "thread key evicted to fit budget",
+  );
+  // Slot 0 must fit within budget.
+  const size = blobSize(CLIENT_ID, result.slots[0]);
+  assert.ok(size <= budget, `slot 0 size ${size} exceeds budget ${budget}`);
+});