v3: src/ gets one layout rule and keeps to it — each layer holds one kind of module, and every layer is split into the same domains — the previous pass sorted components into folders but left hooks, helpers and a barrel inside them, kept hooks/, utils/ and contexts/ flat, and still grouped most tests by theme. The rule: components/ holds only components (.tsx), contexts/ holds FooContext.ts + FooProvider.tsx pairs, hooks/ every hook, utils/ every non-React module, pages/ one component per route and nothing else. Each of components/, contexts/, hooks/ and utils/ is split into the same domains — auth, category, chat, comment, dump, editor, feed, form, layout, player, playlist, profile, social, theme, ws — plus shared/ for what belongs to no one domain, so the chat is components/chat, contexts/chat, hooks/chat and utils/chat. components/ui becomes components/shared to match. Out of components/: useApiForm goes to hooks/form, chat's message.ts and time.ts to utils/chat (with chatDraft and chatText, now draft.ts and text.ts), the emoji skin tone to utils/editor, the remembered volume to utils/player; player/icons.tsx is PlayerIcons.tsx. components/form/index.ts is gone: everything is imported from its own file, FormProvider straight from react-hook-form, and expectOk sits beside friendlyFetchError in utils/shared/api.ts (apiError.ts), since pages that have no form used it too. Out of pages/: the index's feed views, tab bar and presence row move to components/feed; HotFeed and NewFeed, identical but for the sort, are one DumpFeed with an order prop, which also takes over MainFeedProps from pages/index/types.ts. App is a named export like everything else. Tests mirror the tree one file per module — test/<layer>/<domain>/<Module>.test.tsx — so the themed files (hooks/misc, data, editor, sync; utils/misc, text, storage, remote, journal; contexts/providers; pages/auth and UserSubpages; layout/Fabs) are split by subject, the setup each piece needs kept and the rest dropped; the floating-button test becomes one test per button, 627 tests now. The README states the rule. No behaviour changes; the catalogues only move their source references.

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

src/test/hooks/playlist/usePlaylistListSync.test.tsx

@@ -0,0 +1,165 @@
+import { describe, expect, test } from "vitest";
+import { act, renderHook } from "@testing-library/react";
+import { type ReactNode, useState } from "react";
+import {
+  defaultWSValue,
+  WSContext,
+  type WSContextValue,
+} from "../../../contexts/ws/WSContext.ts";
+import type { Playlist } from "../../../model.ts";
+import { usePlaylistListSync } from "../../../hooks/playlist/usePlaylistListSync.ts";
+import { makePlaylist } from "../../fixtures.ts";
+
+/** A WS context whose value a test can push new events into. */
+function liveWS() {
+  let push: (patch: Partial<WSContextValue>) => void = () => {};
+  const base = defaultWSValue;
+  function Wrapper({ children }: { children: ReactNode }) {
+    const [value, setValue] = useState(base);
+    push = (patch) => setValue((v) => ({ ...v, ...patch }));
+    return <WSContext.Provider value={value}>{children}</WSContext.Provider>;
+  }
+  return {
+    Wrapper,
+    emit: (patch: Partial<WSContextValue>) => act(() => push(patch)),
+  };
+}
+
+function useList<T>(initial: T[]) {
+  const [items, setItems] = useState(initial);
+  return { items, setItems };
+}
+
+const ids = (xs: { id: string }[]) => xs.map((x) => x.id);
+
+describe("usePlaylistListSync", () => {
+  function setup(
+    initial: Playlist[],
+    opts?: Parameters<typeof usePlaylistListSync>[1],
+  ) {
+    const ws = liveWS();
+    const hook = renderHook(() => {
+      const list = useList(initial);
+      usePlaylistListSync(list.setItems, opts);
+      return list;
+    }, { wrapper: ws.Wrapper });
+    return { ...ws, hook };
+  }
+
+  test("prepends a created playlist once", () => {
+    const { hook, emit } = setup([makePlaylist({ id: "a" })]);
+    const p = makePlaylist({ id: "b" });
+    emit({
+      lastPlaylistEvent: { type: "created", playlistId: "b", playlist: p },
+    });
+    emit({
+      lastPlaylistEvent: {
+        type: "created",
+        playlistId: "b",
+        playlist: { ...p },
+      },
+    });
+    expect(ids(hook.result.current.items)).toEqual(["b", "a"]);
+  });
+
+  test("created: filtered by owner, privacy and noNewEntries", () => {
+    const p = makePlaylist({ id: "p", userId: "them" });
+    const byOwner = setup([], { ownerId: "me" });
+    byOwner.emit({
+      lastPlaylistEvent: { type: "created", playlistId: "p", playlist: p },
+    });
+    expect(byOwner.hook.result.current.items).toEqual([]);
+
+    const priv = setup([]);
+    priv.emit({
+      lastPlaylistEvent: {
+        type: "created",
+        playlistId: "p",
+        playlist: { ...p, isPublic: false },
+      },
+    });
+    expect(priv.hook.result.current.items).toEqual([]);
+
+    const followed = setup([], { noNewEntries: true });
+    followed.emit({
+      lastPlaylistEvent: { type: "created", playlistId: "p", playlist: p },
+    });
+    expect(followed.hook.result.current.items).toEqual([]);
+  });
+
+  test("updated: in place, removed when private, re-added when public", () => {
+    const p = makePlaylist({ id: "p", title: "one" });
+    const { hook, emit } = setup([p]);
+    emit({
+      lastPlaylistEvent: {
+        type: "updated",
+        playlistId: "p",
+        playlist: { ...p, title: "two" },
+      },
+    });
+    expect(hook.result.current.items[0].title).toBe("two");
+    emit({
+      lastPlaylistEvent: {
+        type: "updated",
+        playlistId: "p",
+        playlist: { ...p, isPublic: false },
+      },
+    });
+    expect(hook.result.current.items).toEqual([]);
+    emit({
+      lastPlaylistEvent: {
+        type: "updated",
+        playlistId: "p",
+        playlist: { ...p, title: "back" },
+      },
+    });
+    expect(hook.result.current.items[0].title).toBe("back");
+  });
+
+  test("updated and not in the list: skipReinsert and noNewEntries hold it back", () => {
+    const p = makePlaylist({ id: "p" });
+    for (const opts of [{ skipReinsert: true }, { noNewEntries: true }]) {
+      const { hook, emit } = setup([], opts);
+      emit({
+        lastPlaylistEvent: { type: "updated", playlistId: "p", playlist: p },
+      });
+      expect(hook.result.current.items).toEqual([]);
+    }
+  });
+
+  test("deleted and deletedPlaylistIds both remove", () => {
+    const { hook, emit } = setup([
+      makePlaylist({ id: "a" }),
+      makePlaylist({ id: "b" }),
+      makePlaylist({ id: "c" }),
+    ]);
+    emit({ lastPlaylistEvent: { type: "deleted", playlistId: "a" } });
+    emit({ deletedPlaylistIds: new Set(["b"]) });
+    expect(ids(hook.result.current.items)).toEqual(["c"]);
+  });
+
+  test("dumps_updated sets the count", () => {
+    const { hook, emit } = setup([makePlaylist({ id: "a", dumpCount: 1 })]);
+    emit({
+      lastPlaylistEvent: {
+        type: "dumps_updated",
+        playlistId: "a",
+        dumpIds: ["x", "y", "z"],
+      },
+    });
+    expect(hook.result.current.items[0].dumpCount).toBe(3);
+  });
+
+  test("dumps_updated counts the members this viewer can't see too", () => {
+    const { hook, emit } = setup([makePlaylist({ id: "a", dumpCount: 3 })]);
+    emit({
+      lastPlaylistEvent: {
+        type: "dumps_updated",
+        playlistId: "a",
+        dumpIds: ["x", "y"],
+        dumpCount: 4,
+      },
+    });
+    expect(hook.result.current.items[0].dumpCount).toBe(4);
+  });
+});