test: localStorage-backed state modules (+38)

Via subagent, no bugs:
- state/utils/atomWithLocalStorage (9): get/set helpers + atom write-through.
- state/scheduledMessages (6): Map<->Record round-trip, persistence, mount-gated
  hydration (atomWithStorage w/o getOnInit — modeled with a subscription).
- state/spaceRooms (9): Set dedupe + no-write-when-unchanged + serialization.
- state/navToActivePath (8): per-user Map<->Object serialization.
- state/callPreferences (6): the privacy rule forcing video=false on load+persist.

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

src/app/state/utils/atomWithLocalStorage.test.ts

@@ -0,0 +1,109 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { createStore } from 'jotai';
+import {
+  getLocalStorageItem,
+  setLocalStorageItem,
+  atomWithLocalStorage,
+} from './atomWithLocalStorage';
+
+// These helpers read/write the real `localStorage` global, which node lacks, so
+// we install a small in-memory mock before each case. `atomWithLocalStorage`
+// also registers a `window` storage listener via `onMount`; we only drive the
+// pure read/write path through a jotai store (no onMount), so `window` is not
+// required here.
+const installStorage = (): Map<string, string> => {
+  const map = new Map<string, string>();
+  (globalThis as { localStorage?: unknown }).localStorage = {
+    getItem: (k: string) => (map.has(k) ? map.get(k)! : null),
+    setItem: (k: string, v: string) => {
+      map.set(k, v);
+    },
+    removeItem: (k: string) => {
+      map.delete(k);
+    },
+  };
+  return map;
+};
+
+test('getLocalStorageItem returns the default when the key is absent', () => {
+  installStorage();
+  assert.deepEqual(getLocalStorageItem('missing', { a: 1 }), { a: 1 });
+  assert.equal(getLocalStorageItem('missing', 7), 7);
+});
+
+test('getLocalStorageItem maps the literal string "undefined" to undefined', () => {
+  const store = installStorage();
+  store.set('k', 'undefined');
+  assert.equal(getLocalStorageItem('k', 'fallback'), undefined);
+});
+
+test('getLocalStorageItem parses stored JSON', () => {
+  const store = installStorage();
+  store.set('k', JSON.stringify({ nested: [1, 2, 3] }));
+  assert.deepEqual(getLocalStorageItem('k', null), { nested: [1, 2, 3] });
+});
+
+test('getLocalStorageItem returns the default on malformed JSON', () => {
+  const store = installStorage();
+  store.set('k', '{ not valid json');
+  assert.equal(getLocalStorageItem('k', 'fallback'), 'fallback');
+});
+
+test('setLocalStorageItem writes the JSON-serialized value', () => {
+  const store = installStorage();
+  setLocalStorageItem('k', { hello: 'world' });
+  assert.equal(store.get('k'), JSON.stringify({ hello: 'world' }));
+});
+
+test('round-trips a value through set + get', () => {
+  installStorage();
+  setLocalStorageItem('k', [1, 'two', { three: true }]);
+  assert.deepEqual(getLocalStorageItem('k', null), [1, 'two', { three: true }]);
+});
+
+test('atomWithLocalStorage seeds the atom from getItem on creation', () => {
+  installStorage();
+  const seeded = atomWithLocalStorage<number>(
+    'k',
+    () => 42,
+    () => undefined,
+  );
+  const store = createStore();
+  assert.equal(store.get(seeded), 42);
+});
+
+test('atomWithLocalStorage write-through updates BOTH the atom and storage', () => {
+  installStorage();
+  const writes: Array<[string, number]> = [];
+  const theAtom = atomWithLocalStorage<number>(
+    'k',
+    () => 0,
+    (key, value) => {
+      writes.push([key, value]);
+    },
+  );
+
+  const store = createStore();
+  store.set(theAtom, 5);
+
+  // Atom value reflects the write...
+  assert.equal(store.get(theAtom), 5);
+  // ...and setItem was invoked with the key + new value.
+  assert.deepEqual(writes, [['k', 5]]);
+});
+
+test('atomWithLocalStorage persists through the real setLocalStorageItem helper', () => {
+  const backing = installStorage();
+  const theAtom = atomWithLocalStorage<{ count: number }>(
+    'k',
+    (key) => getLocalStorageItem(key, { count: 0 }),
+    (key, value) => setLocalStorageItem(key, value),
+  );
+
+  const store = createStore();
+  store.set(theAtom, { count: 9 });
+
+  assert.equal(backing.get('k'), JSON.stringify({ count: 9 }));
+  assert.deepEqual(store.get(theAtom), { count: 9 });
+});