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

@@ -0,0 +1,110 @@
+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 { Dump } from "../../../model.ts";
+import { useDumpListSync } from "../../../hooks/dump/useDumpListSync.ts";
+import { makeDump } 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("useDumpListSync", () => {
+  function setup(
+    initial: Dump[],
+    opts?: Parameters<typeof useDumpListSync>[1],
+  ) {
+    const ws = liveWS();
+    const hook = renderHook(() => {
+      const list = useList(initial);
+      useDumpListSync(list.setItems, opts);
+      return list;
+    }, { wrapper: ws.Wrapper });
+    return { ...ws, hook };
+  }
+
+  test("drops deleted dumps", () => {
+    const { hook, emit } = setup([
+      makeDump({ id: "a" }),
+      makeDump({ id: "b" }),
+    ]);
+    emit({ deletedDumpIds: new Set(["a"]) });
+    expect(ids(hook.result.current.items)).toEqual(["b"]);
+  });
+
+  test("updates a dump in place", () => {
+    const { hook, emit } = setup([makeDump({ id: "a", title: "old" })]);
+    emit({ lastDumpEvent: makeDump({ id: "a", title: "new" }) });
+    expect(hook.result.current.items[0].title).toBe("new");
+  });
+
+  test("a dump gone private leaves others' lists but not the owner's", () => {
+    const a = makeDump({ id: "a" });
+    const viewer = setup([a]);
+    viewer.emit({ lastDumpEvent: { ...a, isPrivate: true } });
+    expect(viewer.hook.result.current.items).toEqual([]);
+
+    const owner = setup([a], { isOwner: true });
+    owner.emit({ lastDumpEvent: { ...a, isPrivate: true } });
+    expect(owner.hook.result.current.items[0].isPrivate).toBe(true);
+  });
+
+  test("re-inserts only the owner's dumps, and only when asked", () => {
+    const mine = makeDump({ id: "m", userId: "me" });
+    const theirs = makeDump({ id: "t", userId: "them" });
+
+    const none = setup([]);
+    none.emit({ lastDumpEvent: mine });
+    expect(none.hook.result.current.items).toEqual([]);
+
+    const owned = setup([], { ownerId: "me" });
+    owned.emit({ lastDumpEvent: theirs });
+    expect(owned.hook.result.current.items).toEqual([]);
+    owned.emit({ lastDumpEvent: mine });
+    expect(ids(owned.hook.result.current.items)).toEqual(["m"]);
+
+    const skip = setup([], { ownerId: "me", skipReinsert: true });
+    skip.emit({ lastDumpEvent: mine });
+    expect(skip.hook.result.current.items).toEqual([]);
+
+    const privateOne = setup([], { ownerId: "me" });
+    privateOne.emit({ lastDumpEvent: { ...mine, isPrivate: true } });
+    expect(privateOne.hook.result.current.items).toEqual([]);
+  });
+
+  test("comment events move the count, never below zero; edits don't", () => {
+    const { hook, emit } = setup([makeDump({ id: "a", commentCount: 0 })]);
+    emit({ lastCommentEvent: { type: "created", dumpId: "a" } });
+    expect(hook.result.current.items[0].commentCount).toBe(1);
+    emit({ lastCommentEvent: { type: "updated", dumpId: "a" } });
+    expect(hook.result.current.items[0].commentCount).toBe(1);
+    emit({ lastCommentEvent: { type: "deleted", dumpId: "a" } });
+    emit({ lastCommentEvent: { type: "deleted", dumpId: "a" } });
+    expect(hook.result.current.items[0].commentCount).toBe(0);
+    emit({ lastCommentEvent: { type: "created", dumpId: "zzz" } });
+    expect(hook.result.current.items).toHaveLength(1);
+  });
+});