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/dump/useUserDumpFeed.test.tsx

@@ -0,0 +1,134 @@
+import { describe, expect, test } from "vitest";
+import { act, renderHook, waitFor } from "@testing-library/react";
+import { type ReactNode, useState } from "react";
+import { MemoryRouter } from "react-router";
+import { AuthContext } from "../../../contexts/auth/AuthContext.ts";
+import { useUserDumpFeed } from "../../../hooks/dump/useUserDumpFeed.ts";
+import { calls, fail, route } from "../../fetch.ts";
+import { makeDump, makeSession, makeUser, page, wire } from "../../fixtures.ts";
+import { FakeIntersectionObserver } from "../../setup.ts";
+
+describe("useUserDumpFeed", () => {
+  const ann = makeUser({ username: "ann" });
+  function setup(
+    opts: { session?: ReturnType<typeof makeSession> | null } = {},
+  ) {
+    const session = opts.session ?? null;
+    function Wrapper({ children }: { children: ReactNode }) {
+      const [authResponse, setAuthResponse] = useState(session);
+      return (
+        <MemoryRouter>
+          <AuthContext.Provider value={{ authResponse, setAuthResponse }}>
+            {children}
+          </AuthContext.Provider>
+        </MemoryRouter>
+      );
+    }
+    return renderHook(
+      ({ username }: { username?: string }) =>
+        useUserDumpFeed(username, "dumps", "cache-key"),
+      {
+        initialProps: { username: "ann" as string | undefined },
+        wrapper: Wrapper,
+      },
+    );
+  }
+
+  test("loads the profile and the first page", async () => {
+    route("GET /api/users/:u", () => wire(ann));
+    route("GET /api/users/:u/dumps", () => page([makeDump({ id: "a" })], true));
+    const session = makeSession();
+    const { result } = setup({ session });
+    await waitFor(() => expect(result.current.state.status).toBe("loaded"));
+    const s = result.current.state as Extract<
+      typeof result.current.state,
+      { status: "loaded" }
+    >;
+    expect(s.profileUser.username).toBe("ann");
+    expect(s.items[0].createdAt).toBeInstanceOf(Date);
+    expect(s.hasMore).toBe(true);
+    const [req] = calls("GET /api/users/:u/dumps");
+    expect(req.url.searchParams.get("page")).toBe("1");
+    expect(req.headers.get("Authorization")).toBe(`Bearer ${session.token}`);
+  });
+
+  test("an unknown user is an error", async () => {
+    route("GET /api/users/:u", () => fail("User not found", 404));
+    route("GET /api/users/:u/dumps", () => page([]));
+    const { result } = setup();
+    await waitFor(() => expect(result.current.state.status).toBe("error"));
+  });
+
+  test("an offline load says so", async () => {
+    route("GET /api/users/:u", () => new TypeError("Failed to fetch"));
+    route("GET /api/users/:u/dumps", () => page([]));
+    const { result } = setup();
+    await waitFor(() =>
+      expect(result.current.state).toMatchObject({
+        status: "error",
+        error: expect.stringMatching(/Could not connect/),
+      })
+    );
+  });
+
+  test("scrolling to the sentinel loads the next page", async () => {
+    route("GET /api/users/:u", () => wire(ann));
+    route(
+      "GET /api/users/:u/dumps",
+      (req) =>
+        req.url.searchParams.get("page") === "1"
+          ? page([makeDump({ id: "a" })], true)
+          : page([makeDump({ id: "b" })], false),
+    );
+    const { result } = setup();
+    await waitFor(() => expect(result.current.state.status).toBe("loaded"));
+    const sentinel = document.createElement("div");
+    act(() => {
+      result.current.sentinelRef(sentinel);
+    });
+    const obs = FakeIntersectionObserver.instances.at(-1)!;
+    act(() => obs.report(true));
+    await waitFor(() => {
+      const s = result.current.state;
+      expect(s.status === "loaded" && s.items.map((d) => d.id)).toEqual([
+        "a",
+        "b",
+      ]);
+    });
+    const s = result.current.state as Extract<
+      typeof result.current.state,
+      { status: "loaded" }
+    >;
+    expect(s.hasMore).toBe(false);
+    expect(s.page).toBe(2);
+  });
+
+  test("changing user resets to loading", async () => {
+    route(
+      "GET /api/users/:u",
+      (req) => wire(makeUser({ username: req.params.u })),
+    );
+    route("GET /api/users/:u/dumps", () => page([]));
+    const { result, rerender } = setup();
+    await waitFor(() => expect(result.current.state.status).toBe("loaded"));
+    rerender({ username: "bob" });
+    expect(result.current.state.status).toBe("loading");
+    await waitFor(() => expect(result.current.state.status).toBe("loaded"));
+  });
+
+  test("setItems edits the loaded list", async () => {
+    route("GET /api/users/:u", () => wire(ann));
+    route(
+      "GET /api/users/:u/dumps",
+      () => page([makeDump({ id: "a" }), makeDump({ id: "b" })]),
+    );
+    const { result } = setup();
+    await waitFor(() => expect(result.current.state.status).toBe("loaded"));
+    act(() => result.current.setItems((prev) => prev.slice(1)));
+    const s = result.current.state as Extract<
+      typeof result.current.state,
+      { status: "loaded" }
+    >;
+    expect(s.items.map((d) => d.id)).toEqual(["b"]);
+  });
+});