malice

public

Star0

Fork 0

Watch0

100 commits 2 branches 0 tags 0 releases4.4 MiB

Commit `a802a95814e6`

tarball

atagen <boss@atagen.co>2026-10-26 03:48 UTC

8 files changed+405-35

web: reuse unchanged timeline items and coalesce worker bursts

Each timeline change resent and reparsed the whole room into new objects, so a single reaction or receipt rerendered every row. Unchanged items, rooms and thread lists now keep their identity, and full-state worker events are coalesced per key and macrotask while deltas keep their order.

Modified file: web/src/lib/arrivals.ts+14 additions−3 deletions@@ -2,6 +2,16 @@ import type { TimelineItem } from './types';
 
 export const FEDERATION_LAG_MS = 60 * 1000;
 
+const decorated = new WeakMap<TimelineItem, { lag: number; item: TimelineItem }>();
+
+function withLag(item: TimelineItem & { kind: 'event' }, lag: number): TimelineItem {
+  const hit = decorated.get(item);
+  if (hit && hit.lag === lag) return hit.item;
+  const next: TimelineItem = { ...item, event: { ...item.event, delivery_lag_ms: lag } };
+  decorated.set(item, { lag, item: next });
+  return next;
+}
+
 /**
  * Carries delivery lag forward from the previous list and measures it for events appended
  * after the last one already known. `since` is when the room last became able to receive
@@ -16,15 +26,16 @@ export function observeArrivals(previous: TimelineItem[], items: TimelineItem[],
     if (item.kind === 'event' && lags.has(item.event.item_id)) lastKnown = index;
   });
   if (lastKnown === -1) return null;
-  return items.map((item, index) => {
+  const next = items.map((item, index) => {
     if (item.kind !== 'event') return item;
     const event = item.event;
     if (lags.has(event.item_id)) {
       const carried = lags.get(event.item_id);
-      return carried === undefined ? item : { ...item, event: { ...event, delivery_lag_ms: carried } };
+      return carried === undefined ? item : withLag(item, carried);
     }
     if (index < lastKnown || event.own) return item;
     const lag = now - Math.max(event.timestamp_ms, since);
-    return lag < FEDERATION_LAG_MS ? item : { ...item, event: { ...event, delivery_lag_ms: lag } };
+    return lag < FEDERATION_LAG_MS ? item : withLag(item, lag);
   });
+  return previous.length === next.length && next.every((item, index) => item === previous[index]) ? previous : next;
 }

Added file: web/src/lib/sharing.ts+63 additions@@ -0,0 +1,63 @@
+interface Entry<T> {
+  signature: string;
+  item: T;
+}
+
+export interface ShareCache<T> {
+  byKey: Map<string, Entry<T>>;
+  list: T[];
+}
+
+export function newShareCache<T>(): ShareCache<T> {
+  return { byKey: new Map(), list: [] };
+}
+
+function signature(text: string): string {
+  let a = 0x811c9dc5;
+  let b = 0x9747b28c;
+  for (let i = 0; i < text.length; i += 1) {
+    const c = text.charCodeAt(i);
+    a = Math.imul(a ^ c, 0x01000193);
+    b = Math.imul(b + c, 0x85ebca6b) ^ (b >>> 13);
+  }
+  return `${text.length}.${(a >>> 0).toString(36)}.${(b >>> 0).toString(36)}`;
+}
+
+/**
+ * Parses `raw` while reusing the objects from the previous call whose serialised form is unchanged.
+ * Entries are matched by `identify` and compared by a hash of their JSON, so only the latest list is retained.
+ * Returns the previous array itself when every element was reused and the length matches.
+ */
+export function parseShared<T>(
+  cache: ShareCache<T>,
+  raw: unknown,
+  parse: (entry: unknown) => T | null,
+  identify: (entry: unknown) => string | null = () => null
+): T[] {
+  if (!Array.isArray(raw)) {
+    cache.byKey = new Map();
+    cache.list = cache.list.length ? [] : cache.list;
+    return cache.list;
+  }
+  const byKey = new Map<string, Entry<T>>();
+  const out: T[] = [];
+  for (const entry of raw) {
+    const sig = signature(JSON.stringify(entry));
+    const base = identify(entry) ?? `~${sig}`;
+    let key = base;
+    for (let n = 1; byKey.has(key); n += 1) key = `${base}#${n}`;
+    const previous = cache.byKey.get(key);
+    const item = previous && previous.signature === sig ? previous.item : parse(entry);
+    if (item === null) continue;
+    byKey.set(key, { signature: sig, item });
+    out.push(item);
+  }
+  cache.byKey = byKey;
+  if (out.length === cache.list.length && out.every((item, index) => item === cache.list[index])) return cache.list;
+  cache.list = out;
+  return out;
+}
+
+export function sameList<T>(a: readonly T[], b: readonly T[]): boolean {
+  return a === b || (a.length === b.length && a.every((item, index) => item === b[index]));
+}

Modified file: web/src/lib/store.ts+53 additions−12 deletions@@ -1,10 +1,13 @@
 import { get, writable } from 'svelte/store';
+import type { Writable } from 'svelte/store';
 import { parseMentionsPage, parseMentionsUpdate } from './mentions-model';
 import type { MentionsPage } from './mentions-model';
 import { getSession, subscribeEvents } from './api';
 import type { SoftLogout } from './api';
 import { isRecord } from './guards';
 import { observeArrivals } from './arrivals';
+import { newShareCache, parseShared, sameList } from './sharing';
+import type { ShareCache } from './sharing';
 import { loadKeywords, resetKeywords } from './keywords';
 import { resetLinkPreviews } from './link-previews';
 import { resetQuickReactions } from './quick-reactions';
@@ -17,8 +20,9 @@ import {
   parseRecentHistoryMap,
   parseThreadListEntries,
   parseRecentHistoryState,
-  parseRoomList,
-  parseTimelineList,
+  parseRoomSummary,
+  identifyTimelineItem,
+  parseTimelineItem,
   parseVerificationState
 } from './types';
 import type {
@@ -103,7 +107,28 @@ export function dismissBanner(id: number): void {
   banners.update((list) => list.filter((b) => b.id !== id));
 }
 
+const timelineCaches = new Map<string, ShareCache<TimelineItem>>();
+const pinnedCaches = new Map<string, ShareCache<TimelineItem>>();
+const threadCaches = new Map<string, ShareCache<TimelineItem>>();
+const roomsCache = newShareCache<RoomSummary>();
+
+function parseCached(caches: Map<string, ShareCache<TimelineItem>>, key: string, raw: unknown): TimelineItem[] {
+  let cache = caches.get(key);
+  if (!cache) caches.set(key, (cache = newShareCache()));
+  return parseShared(cache, raw, parseTimelineItem, identifyTimelineItem);
+}
+
+function setKeyed<T extends unknown[]>(store: Writable<Record<string, T>>, key: string, value: T): void {
+  const all = get(store);
+  if (all[key] !== value) store.set({ ...all, [key]: value });
+}
+
 export function resetClientState(): void {
+  timelineCaches.clear();
+  pinnedCaches.clear();
+  threadCaches.clear();
+  roomsCache.byKey = new Map();
+  roomsCache.list = [];
   mentionsSnapshot.set(null);
   rooms.set([]);
   timelines.set({});
@@ -168,12 +193,17 @@ function withArrivals(roomId: string, previous: TimelineItem[], items: TimelineI
 
 function applyTimelinePayload(roomId: string, payload: Record<string, unknown>): void {
   if (!Array.isArray(payload['items'])) return;
-  const items = parseTimelineList(payload['items']);
-  timelines.update((all) => ({ ...all, [roomId]: withArrivals(roomId, all[roomId] ?? [], items) }));
+  const items = parseCached(timelineCaches, roomId, payload['items']);
+  setKeyed(timelines, roomId, withArrivals(roomId, get(timelines)[roomId] ?? [], items));
+}
+
+function identifyRoom(raw: unknown): string | null {
+  return isRecord(raw) && typeof raw['room_id'] === 'string' ? raw['room_id'] : null;
 }
 
 function setRooms(raw: unknown): void {
-  rooms.set(parseRoomList(raw));
+  const next = parseShared(roomsCache, raw, parseRoomSummary, identifyRoom);
+  if (!sameList(get(rooms), next)) rooms.set(next);
 }
 
 function handlePayload(text: string): void {
@@ -196,7 +226,7 @@ function handlePayload(text: string): void {
       timelines.update((all) => {
         const next = { ...all };
         for (const [roomId, list] of Object.entries(rawTimelines)) {
-          next[roomId] = withArrivals(roomId, all[roomId] ?? [], parseTimelineList(list));
+          next[roomId] = withArrivals(roomId, all[roomId] ?? [], parseCached(timelineCaches, roomId, list));
         }
         return next;
       });
@@ -205,7 +235,8 @@ function handlePayload(text: string): void {
       const next: Record<string, TimelineItem[]> = {};
       for (const entry of data['threads']) {
         if (!isRecord(entry) || typeof entry['room_id'] !== 'string' || typeof entry['root_event_id'] !== 'string') continue;
-        next[threadKey(entry['room_id'], entry['root_event_id'])] = parseTimelineList(entry['items']);
+        const key = threadKey(entry['room_id'], entry['root_event_id']);
+        next[key] = parseCached(threadCaches, key, entry['items']);
       }
       threadTimelines.set(next);
     }
@@ -213,7 +244,7 @@ function handlePayload(text: string): void {
     const rawPinned = data['pinned'];
     if (isRecord(rawPinned)) {
       const next: Record<string, TimelineItem[]> = {};
-      for (const [roomId, list] of Object.entries(rawPinned)) next[roomId] = parseTimelineList(list);
+      for (const [roomId, list] of Object.entries(rawPinned)) next[roomId] = parseCached(pinnedCaches, roomId, list);
       pinnedTimelines.set(next);
     }
     const snapshotEncryption = parseEncryptionState(data['encryption']);
@@ -251,11 +282,20 @@ function handlePayload(text: string): void {
     if (typeof roomId === 'string') applyTimelinePayload(roomId, data);
     return;
   }
+  if (kind === 'timeline_closed') {
+    const roomId = data['room_id'];
+    if (typeof roomId !== 'string') return;
+    timelineCaches.delete(roomId);
+    timelines.update((all) => {
+      const { [roomId]: _closed, ...rest } = all;
+      return rest;
+    });
+    return;
+  }
   if (kind === 'pinned') {
     const roomId = data['room_id'];
     if (typeof roomId === 'string' && Array.isArray(data['items'])) {
-      const items = parseTimelineList(data['items']);
-      pinnedTimelines.update((all) => ({ ...all, [roomId]: items }));
+      setKeyed(pinnedTimelines, roomId, parseCached(pinnedCaches, roomId, data['items']));
     }
     return;
   }
@@ -278,9 +318,9 @@ function handlePayload(text: string): void {
     if (typeof roomId !== 'string' || typeof root !== 'string') return;
     const key = threadKey(roomId, root);
     if (kind === 'thread') {
-      const items = parseTimelineList(data['items']);
-      threadTimelines.update((all) => ({ ...all, [key]: items }));
+      setKeyed(threadTimelines, key, parseCached(threadCaches, key, data['items']));
     } else {
+      threadCaches.delete(key);
       threadTimelines.update((all) => {
         const { [key]: _closed, ...rest } = all;
         return rest;
@@ -291,6 +331,7 @@ function handlePayload(text: string): void {
   if (kind === 'pinned_closed') {
     const roomId = data['room_id'];
     if (typeof roomId === 'string') {
+      pinnedCaches.delete(roomId);
       pinnedTimelineVersions.update((all) => ({ ...all, [roomId]: (all[roomId] ?? 0) + 1 }));
       pinnedTimelines.update((all) => {
         const { [roomId]: _closed, ...rest } = all;

Modified file: web/src/lib/threads.ts+52 additions−11 deletions@@ -1,8 +1,9 @@
-import { derived, get, writable } from 'svelte/store';
+import { derived, get, readable, writable } from 'svelte/store';
 import { closeThreadList, getAccountData, openThreadList, paginateThreadList, runCommand, setAccountData } from './api';
 import { pushBanner, rooms, sessionUser, threadLists, timelines } from './store';
 import { roomThreads } from './thread-index';
 import type { ThreadEntry } from './thread-index';
+import type { ThreadListEntry, ThreadUnread, TimelineItem } from './types';
 
 const PINNED_TYPE = 'dev.malice.pinned_threads';
 
@@ -15,16 +16,56 @@ export interface OpenThread {
 export const openThread = writable<OpenThread | null>(null);
 export const pinnedThreads = writable<Record<string, string[]>>({});
 
-export const threadsByRoom = derived([timelines, pinnedThreads, threadLists, rooms], ([$timelines, $pinned, $lists, $rooms]) => {
-  const unreads = new Map($rooms.map((room) => [room.room_id, room.thread_unreads]));
-  const out: Record<string, ThreadEntry[]> = {};
-  const ids = [...Object.keys($timelines), ...Object.keys($pinned), ...Object.keys($lists), ...unreads.keys()];
-  for (const roomId of new Set(ids)) {
-    const list = roomThreads(roomId, $timelines[roomId] ?? [], $pinned[roomId] ?? [], $lists[roomId]?.entries ?? [], unreads.get(roomId) ?? {});
-    if (list.length) out[roomId] = list;
-  }
-  return out;
-});
+const NO_TIMELINE: TimelineItem[] = [];
+const NO_PINS: string[] = [];
+const NO_ENTRIES: ThreadListEntry[] = [];
+const NO_UNREADS: Record<string, ThreadUnread> = {};
+
+interface RoomThreadsCache {
+  timeline: TimelineItem[];
+  pins: string[];
+  entries: ThreadListEntry[];
+  unreads: Record<string, ThreadUnread>;
+  list: ThreadEntry[];
+}
+
+function createThreadsByRoom() {
+  let cache = new Map<string, RoomThreadsCache>();
+  let last: Record<string, ThreadEntry[]> = {};
+  const computed = derived([timelines, pinnedThreads, threadLists, rooms], ([$timelines, $pinned, $lists, $rooms]) => {
+    const unreads = new Map($rooms.map((room) => [room.room_id, room.thread_unreads]));
+    const next = new Map<string, RoomThreadsCache>();
+    const out: Record<string, ThreadEntry[]> = {};
+    const ids = [...Object.keys($timelines), ...Object.keys($pinned), ...Object.keys($lists), ...unreads.keys()];
+    for (const roomId of new Set(ids)) {
+      const timeline = $timelines[roomId] ?? NO_TIMELINE;
+      const pins = $pinned[roomId] ?? NO_PINS;
+      const entries = $lists[roomId]?.entries ?? NO_ENTRIES;
+      const roomUnreads = unreads.get(roomId) ?? NO_UNREADS;
+      const hit = cache.get(roomId);
+      const reuse = hit && hit.timeline === timeline && hit.pins === pins && hit.entries === entries && hit.unreads === roomUnreads;
+      const entry = reuse ? hit : { timeline, pins, entries, unreads: roomUnreads, list: roomThreads(roomId, timeline, pins, entries, roomUnreads) };
+      next.set(roomId, entry);
+      if (entry.list.length) out[roomId] = entry.list;
+    }
+    const keys = Object.keys(out);
+    const unchanged = keys.length === Object.keys(last).length && keys.every((roomId) => out[roomId] === last[roomId]);
+    cache = next;
+    if (unchanged) return last;
+    last = out;
+    return out;
+  });
+  return readable(last, (set) => {
+    let sent: Record<string, ThreadEntry[]> | null = null;
+    return computed.subscribe((value) => {
+      if (value === sent) return;
+      sent = value;
+      set(value);
+    });
+  });
+}
+
+export const threadsByRoom = createThreadsByRoom();
 
 const THREAD_PAGE = 20;
 const openLists = new Set<string>();

Added file: web/src/worker/coalesce.ts+52 additions@@ -0,0 +1,52 @@
+const STRING = '"(?:[^"\\\\]|\\\\.)*"';
+const REPLACEMENT = new RegExp(`^\\{"type":"(rooms|timeline|pinned|thread|thread_list)"(?:,"room_id":(${STRING}))?(?:,"root_event_id":(${STRING}))?`);
+
+/** Serialised key for events that replace the full state of one room, thread or list, or null for anything else. */
+export function replacementKey(event: string): string | null {
+  const match = REPLACEMENT.exec(event);
+  if (!match) return null;
+  const [, type, room, root] = match;
+  if (type === 'rooms') return type;
+  if (room === undefined) return null;
+  if (type === 'thread') return root === undefined ? null : `${type}:${room}:${root}`;
+  return `${type}:${room}`;
+}
+
+/**
+ * Buffers full-state events so a burst delivers only the latest per key. Anything else flushes
+ * the buffer first, so deltas and lifecycle events keep their order relative to the buffered ones.
+ */
+export class EventCoalescer {
+  private pending = new Map<string, { account: string; event: string }>();
+  private scheduled = false;
+
+  constructor(
+    private deliver: (account: string, event: string) => void,
+    private schedule: (flush: () => void) => void = (flush) => void setTimeout(flush, 0)
+  ) {}
+
+  push(account: string, event: string): void {
+    const key = replacementKey(event);
+    if (key === null) {
+      this.flush();
+      this.deliver(account, event);
+      return;
+    }
+    const slot = `${account}\n${key}`;
+    this.pending.delete(slot);
+    this.pending.set(slot, { account, event });
+    if (this.scheduled) return;
+    this.scheduled = true;
+    this.schedule(() => {
+      this.scheduled = false;
+      this.flush();
+    });
+  }
+
+  flush(): void {
+    if (this.pending.size === 0) return;
+    const batch = [...this.pending.values()];
+    this.pending.clear();
+    for (const { account, event } of batch) this.deliver(account, event);
+  }
+}

Modified file: web/src/worker/worker.ts+20 additions−9 deletions@@ -1,5 +1,6 @@
 import init, { Host } from './pkg/malice_worker.js';
 import { isRecord } from '../lib/guards';
+import { EventCoalescer } from './coalesce';
 import {
   createAccount,
   deleteAccount,
@@ -48,6 +49,8 @@ function broadcastEvent(account: string, event: string): void {
   for (const port of subscriptions.get(account) ?? []) postTo(port, { kind: 'event', account, event });
 }
 
+const coalescer = new EventCoalescer(broadcastEvent);
+
 function toWireError(error: unknown): WireError {
   if (isRecord(error) && typeof error['kind'] === 'string') {
     return { kind: error['kind'], message: typeof error['message'] === 'string' ? error['message'] : 'unknown error' };
@@ -76,21 +79,24 @@ function onSessionEnded(account: string, retain: unknown): void {
   } else if (identity) {
     softAccounts.set(account, identity);
   }
+  coalescer.flush();
   broadcastEvent(account, JSON.stringify({ type: 'session_ended', retain }));
 }
 
+const SESSION_ENDED_PREFIX = '{"type":"session_ended"';
+
 function onHostEvent(account: string, eventJson: string): void {
-  let parsed: unknown;
-  try {
-    parsed = JSON.parse(eventJson);
-  } catch {
-    return;
-  }
-  if (isRecord(parsed) && parsed['type'] === 'session_ended') {
-    onSessionEnded(account, parsed['retain']);
+  if (eventJson.startsWith(SESSION_ENDED_PREFIX)) {
+    let retain: unknown;
+    try {
+      retain = (JSON.parse(eventJson) as { retain?: unknown }).retain;
+    } catch {
+      return;
+    }
+    onSessionEnded(account, retain);
     return;
   }
-  broadcastEvent(account, eventJson);
+  coalescer.push(account, eventJson);
 }
 
 function onHostFatal(message: string): void {
@@ -183,6 +189,7 @@ async function handleCall(account: string, request: unknown, bytes?: ArrayBuffer
 }
 
 function handleSubscribe(port: PortLike, account: string): void {
+  coalescer.flush();
   let set = subscriptions.get(account);
   if (!set) {
     set = new Set();
@@ -196,10 +203,12 @@ function handleSubscribe(port: PortLike, account: string): void {
 }
 
 function handleUnsubscribe(port: PortLike, account: string): void {
+  coalescer.flush();
   subscriptions.get(account)?.delete(port);
 }
 
 function dropPort(port: PortLike): void {
+  coalescer.flush();
   ports.delete(port);
   for (const set of subscriptions.values()) set.delete(port);
 }
@@ -210,9 +219,11 @@ async function dispatch(port: PortLike, data: unknown): Promise<void> {
   const kind = data['kind'];
   const id = data['id'];
   const reply = (ok: unknown) => {
+    coalescer.flush();
     if (typeof id === 'number') postTo(port, { kind: 'reply', id, ok });
   };
   const fail = (error: unknown) => {
+    coalescer.flush();
     if (typeof id === 'number') postTo(port, { kind: 'reply', id, error: toWireError(error) });
   };
 

Added file: web/test/coalesce.test.ts+71 additions@@ -0,0 +1,71 @@
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { EventCoalescer, replacementKey } from '../src/worker/coalesce.ts';
+
+function setup() {
+  const delivered: string[] = [];
+  const queue: Array<() => void> = [];
+  const coalescer = new EventCoalescer(
+    (account, event) => delivered.push(`${account}|${event}`),
+    (flush) => queue.push(flush)
+  );
+  return { delivered, coalescer, run: () => queue.splice(0).forEach((flush) => flush()), queue };
+}
+
+const timeline = (room: string, n: number) => `{"type":"timeline","room_id":"${room}","items":[${n}]}`;
+
+test('keys cover full-state events only', () => {
+  assert.equal(replacementKey(timeline('!a', 1)), 'timeline:"!a"');
+  assert.equal(replacementKey('{"type":"rooms","rooms":[]}'), 'rooms');
+  assert.equal(replacementKey('{"type":"thread","room_id":"!a","root_event_id":"$r","items":[]}'), 'thread:"!a":"$r"');
+  assert.equal(replacementKey('{"type":"thread_list","room_id":"!a","entries":[]}'), 'thread_list:"!a"');
+  assert.equal(replacementKey('{"type":"pinned","room_id":"!a","items":[]}'), 'pinned:"!a"');
+  assert.equal(replacementKey('{"type":"thread_closed","room_id":"!a","root_event_id":"$r"}'), null);
+  assert.equal(replacementKey('{"type":"thread_list_history","room_id":"!a","state":"Idle"}'), null);
+  assert.equal(replacementKey('{"type":"timeline_closed","room_id":"!a"}'), null);
+  assert.equal(replacementKey('{"type":"snapshot"}'), null);
+  assert.equal(replacementKey('{"type":"connection","state":"online"}'), null);
+});
+
+test('a burst for one key delivers only the latest, once, on the scheduled flush', () => {
+  const { delivered, coalescer, run, queue } = setup();
+  coalescer.push('acc', timeline('!a', 1));
+  coalescer.push('acc', timeline('!a', 2));
+  coalescer.push('acc', timeline('!a', 3));
+  assert.equal(queue.length, 1);
+  assert.deepEqual(delivered, []);
+  run();
+  assert.deepEqual(delivered, [`acc|${timeline('!a', 3)}`]);
+});
+
+test('other events flush pending ones first and keep their order', () => {
+  const { delivered, coalescer, run } = setup();
+  coalescer.push('acc', timeline('!a', 1));
+  coalescer.push('acc', timeline('!b', 1));
+  coalescer.push('acc', '{"type":"timeline_closed","room_id":"!a"}');
+  coalescer.push('acc', timeline('!a', 2));
+  run();
+  assert.deepEqual(delivered, [
+    `acc|${timeline('!a', 1)}`,
+    `acc|${timeline('!b', 1)}`,
+    'acc|{"type":"timeline_closed","room_id":"!a"}',
+    `acc|${timeline('!a', 2)}`
+  ]);
+});
+
+test('different keys and accounts are kept apart', () => {
+  const { delivered, coalescer, run } = setup();
+  coalescer.push('x', timeline('!a', 1));
+  coalescer.push('y', timeline('!a', 2));
+  coalescer.push('x', timeline('!a', 3));
+  run();
+  assert.deepEqual(delivered, [`y|${timeline('!a', 2)}`, `x|${timeline('!a', 3)}`]);
+});
+
+test('a flush with nothing pending after an explicit flush delivers nothing twice', () => {
+  const { delivered, coalescer, run } = setup();
+  coalescer.push('acc', timeline('!a', 1));
+  coalescer.flush();
+  run();
+  assert.equal(delivered.length, 1);
+});

Added file: web/test/sharing.test.ts+80 additions@@ -0,0 +1,80 @@
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { newShareCache, parseShared } from '../src/lib/sharing.ts';
+import { observeArrivals } from '../src/lib/arrivals.ts';
+import type { TimelineEvent, TimelineItem } from '../src/lib/types.ts';
+
+interface Row {
+  id: string;
+  count: number;
+}
+
+function parse(entry: unknown): Row | null {
+  const raw = entry as Record<string, unknown>;
+  return typeof raw['id'] === 'string' ? { id: raw['id'], count: Number(raw['count']) } : null;
+}
+
+test('unchanged entries keep their object and unchanged lists keep their array', () => {
+  const cache = newShareCache<Row>();
+  const first = parseShared(cache, [{ id: 'a', count: 1 }, { id: 'b', count: 1 }], parse);
+  const second = parseShared(cache, [{ id: 'a', count: 1 }, { id: 'b', count: 1 }], parse);
+  assert.equal(second, first);
+});
+
+test('a changed entry gets a new object while its neighbours keep theirs', () => {
+  const cache = newShareCache<Row>();
+  const first = parseShared(cache, [{ id: 'a', count: 1 }, { id: 'b', count: 1 }], parse);
+  const second = parseShared(cache, [{ id: 'a', count: 1 }, { id: 'b', count: 2 }], parse);
+  assert.notEqual(second, first);
+  assert.equal(second[0], first[0]);
+  assert.notEqual(second[1], first[1]);
+  assert.equal(second[1].count, 2);
+});
+
+test('appended and removed entries change the array', () => {
+  const cache = newShareCache<Row>();
+  const first = parseShared(cache, [{ id: 'a', count: 1 }], parse);
+  const grown = parseShared(cache, [{ id: 'a', count: 1 }, { id: 'b', count: 1 }], parse);
+  assert.notEqual(grown, first);
+  assert.equal(grown[0], first[0]);
+  const shrunk = parseShared(cache, [{ id: 'b', count: 1 }], parse);
+  assert.equal(shrunk[0], grown[1]);
+});
+
+test('unparsable entries are skipped and non-arrays yield an empty list', () => {
+  const cache = newShareCache<Row>();
+  assert.equal(parseShared(cache, [{ id: 'a', count: 1 }, { nope: true }], parse).length, 1);
+  assert.deepEqual(parseShared(cache, 'x', parse), []);
+});
+
+function event(id: string, timestamp_ms: number): TimelineItem {
+  return { kind: 'event', event: { item_id: id, timestamp_ms, own: false } as TimelineEvent };
+}
+
+test('arrivals keeps array and lagged item identity across identical updates', () => {
+  const MINUTE = 60 * 1000;
+  const known = event('a', 90 * MINUTE);
+  const late = event('late', 80 * MINUTE);
+  const first = observeArrivals([known], [known, late], 0, 100 * MINUTE);
+  assert.ok(first);
+  const second = observeArrivals(first, [known, late], 0, 101 * MINUTE);
+  assert.equal(second, first);
+});
+
+test('identified entries are matched by identity and evicted when absent', () => {
+  const cache = newShareCache<Row>();
+  const identify = (entry: unknown) => (entry as Row).id;
+  const first = parseShared(cache, [{ id: 'a', count: 1 }, { id: 'b', count: 1 }], parse, identify);
+  const second = parseShared(cache, [{ id: 'b', count: 1 }, { id: 'c', count: 1 }], parse, identify);
+  assert.equal(second[0], first[1]);
+  assert.deepEqual([...cache.byKey.keys()], ['b', 'c']);
+});
+
+test('a changed identified entry is reparsed under the same key', () => {
+  const cache = newShareCache<Row>();
+  const identify = (entry: unknown) => (entry as Row).id;
+  const first = parseShared(cache, [{ id: 'a', count: 1 }], parse, identify);
+  const second = parseShared(cache, [{ id: 'a', count: 2 }], parse, identify);
+  assert.notEqual(second[0], first[0]);
+  assert.equal(second[0].count, 2);
+});

malice

Commit a802a95814e6

Commit `a802a95814e6`