DP13: extract shared account-data list-store engine

useBookmarks / useReminders / useUserNotes were near-verbatim copies of a
concurrency-critical engine (module-scoped singleton, per-client
subscribe/teardown, a serialized write-queue that prevents lost-update
clobbering, a listener Set, and the account-data subscription).

Extract it into createAccountDataListStore<T, C>({ eventType, read, write }) in
src/app/hooks/createAccountDataListStore.ts. The write-serialization semantics
are preserved identically (still the lost-update fix). The differing payload
shapes are parameterized via read/write: bookmarks/reminders wrap a list
({bookmarks}/{reminders}); notes is a flat Record passed through unchanged.

The three hooks become thin wrappers with their exact public APIs unchanged
(same exported names, signatures, return shapes, and mutators), so no call site
changes. The DP16 setAccountData helper is used inside the queue.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

src/app/hooks/useUserNotes.ts

@@ -1,111 +1,37 @@
-import { useCallback, useEffect, useState } from 'react';
-import { ClientEvent, ClientEventHandlerMap, MatrixClient } from 'matrix-js-sdk';
+import { useCallback } from 'react';
 import { useMatrixClient } from './useMatrixClient';
-import { getAccountData, setAccountData } from '../utils/accountData';
+import { createAccountDataListStore } from './createAccountDataListStore';
 
 const NOTES_KEY = 'io.lotus.user_notes';
 export const USER_NOTE_MAX_LENGTH = 500;
 
 type UserNotesContent = Record<string, string>;
 
-function readNotes(mx: MatrixClient): UserNotesContent {
-  return getAccountData<UserNotesContent>(mx, NOTES_KEY) ?? {};
-}
-
-// Module-scoped serialization state.
+// Shared, concurrency-safe store. See createAccountDataListStore for why the
+// snapshot + write queue must be module-scoped (writes are serialized to avoid
+// lost updates, since setAccountData replaces the whole content with no merge).
 //
-// useUserNotes() can be mounted by many components at once, so a per-instance
-// latest/queue would only serialize writes within one instance. Notes for
-// different users saved from different instances (before the server echo lands)
-// would each compute from a stale snapshot and clobber each other, since
-// setAccountData replaces the whole record with no server merge. We therefore
-// keep a single shared latest record + write queue, keyed off the active client.
-type UserNotesModuleState = {
-  mx: MatrixClient;
-  latest: UserNotesContent;
-  writeQueue: Promise<unknown>;
-  listeners: Set<(record: UserNotesContent) => void>;
-  onAccountData: ClientEventHandlerMap[ClientEvent.AccountData];
-};
-
-let moduleState: UserNotesModuleState | null = null;
-
-// Lazily initialize the shared state for the given client. On a client change
-// (login/logout swaps the MatrixClient) we tear down the old subscription and
-// re-initialize against the new client so we never leak or double-subscribe.
-function ensureModuleState(mx: MatrixClient): UserNotesModuleState {
-  if (moduleState && moduleState.mx === mx) {
-    return moduleState;
-  }
-
-  if (moduleState) {
-    moduleState.mx.removeListener(ClientEvent.AccountData, moduleState.onAccountData);
-  }
-
-  const state: UserNotesModuleState = {
-    mx,
-    latest: readNotes(mx),
-    writeQueue: Promise.resolve(),
-    listeners: new Set(),
-    // Reassigned below once `state` is captured.
-    onAccountData: () => undefined,
-  };
-
-  state.onAccountData = (evt) => {
-    if (evt.getType() === NOTES_KEY) {
-      const record = evt.getContent<UserNotesContent>() ?? {};
-      state.latest = record;
-      state.listeners.forEach((listener) => listener(record));
-    }
-  };
-
-  mx.on(ClientEvent.AccountData, state.onAccountData);
-  moduleState = state;
-  return state;
-}
-
-function enqueueNotesWrite(
-  mx: MatrixClient,
-  compute: (current: UserNotesContent) => UserNotesContent,
-): Promise<void> {
-  const state = ensureModuleState(mx);
-  const run = state.writeQueue.then(async () => {
-    const next = compute(state.latest);
-    state.latest = next;
-    state.listeners.forEach((listener) => listener(next));
-    await setAccountData(mx, NOTES_KEY, next);
-  });
-  // Keep the chain alive even if one write rejects, but propagate the
-  // rejection to this caller so it can react (e.g. retry).
-  state.writeQueue = run.catch(() => undefined);
-  return run;
-}
+// Notes are a flat Record<userId, note> rather than a wrapped list, so `read`
+// and `write` pass the content through unchanged.
+const notesStore = createAccountDataListStore<UserNotesContent, UserNotesContent>({
+  eventType: NOTES_KEY,
+  read: (content) => content ?? {},
+  write: (notes) => notes,
+});
 
 export function useUserNotes(): {
   getNote: (userId: string) => string;
   setNote: (userId: string, note: string) => Promise<void>;
 } {
   const mx = useMatrixClient();
-  const [notes, setNotes] = useState<UserNotesContent>(() => ensureModuleState(mx).latest);
-
-  // Subscribe to the shared module state. A single AccountData listener is
-  // installed per client (in ensureModuleState); each hook instance only
-  // registers a local setter and unregisters it on unmount / client change.
-  useEffect(() => {
-    const state = ensureModuleState(mx);
-    setNotes(state.latest);
-    state.listeners.add(setNotes);
-    return () => {
-      state.listeners.delete(setNotes);
-    };
-  }, [mx]);
+  const notes = notesStore.useValue(mx);
 
   const getNote = useCallback((userId: string) => notes[userId] ?? '', [notes]);
 
   const setNote = useCallback(
     (userId: string, note: string) => {
       const trimmed = note.trim().slice(0, USER_NOTE_MAX_LENGTH);
-      return enqueueNotesWrite(mx, (current) => {
+      return notesStore.enqueueWrite(mx, (current) => {
         const updated = { ...current };
         if (trimmed) {
           updated[userId] = trimmed;