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

@@ -0,0 +1,91 @@
+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, Playlist } from "../../../model.ts";
+import { useDumpListSync } from "../../../hooks/dump/useDumpListSync.ts";
+import { usePositionAwareSync } from "../../../hooks/feed/usePositionAwareSync.ts";
+import { makeDump, 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("usePositionAwareSync", () => {
+  test("a dump that goes private and back returns to its old place", () => {
+    const ws = liveWS();
+    const initial = ["a", "b", "c"].map((id) => makeDump({ id, userId: "me" }));
+    // Wire the pair exactly as UserPublicProfile does.
+    const both = renderHook(() => {
+      const { items, setItems } = useList(initial);
+      const [event, setEvent] = useState<Dump | null>(null);
+      usePositionAwareSync(
+        items,
+        setItems,
+        event,
+        (d) => d.isPrivate,
+        (d) => !d.isPrivate,
+      );
+      useDumpListSync(setItems, { ownerId: "me", skipReinsert: true });
+      return { items, setEvent };
+    }, { wrapper: ws.Wrapper });
+
+    const b = initial[1];
+    act(() => both.result.current.setEvent({ ...b, isPrivate: true }));
+    ws.emit({ lastDumpEvent: { ...b, isPrivate: true } });
+    expect(ids(both.result.current.items)).toEqual(["a", "c"]);
+
+    act(() => both.result.current.setEvent({ ...b, isPrivate: false }));
+    ws.emit({ lastDumpEvent: { ...b, isPrivate: false } });
+    expect(ids(both.result.current.items)).toEqual(["a", "b", "c"]);
+  });
+
+  test("a position is only used once, and clamps to the list end", () => {
+    const initial = ["a", "b", "c"].map((id) => makePlaylist({ id }));
+    const hook = renderHook(() => {
+      const { items, setItems } = useList(initial);
+      const [event, setEvent] = useState<Playlist | null>(null);
+      usePositionAwareSync(
+        items,
+        setItems,
+        event,
+        (p) => !p.isPublic,
+        (p) => p.isPublic,
+      );
+      return { items, setItems, setEvent };
+    });
+    const c = initial[2];
+    act(() => hook.result.current.setEvent({ ...c, isPublic: false }));
+    act(() => hook.result.current.setItems((prev) => prev.slice(0, 1)));
+    act(() => hook.result.current.setEvent({ ...c, isPublic: true }));
+    expect(ids(hook.result.current.items)).toEqual(["a", "c"]);
+    // Nothing saved any more: a second public event is left alone.
+    act(() => hook.result.current.setItems((prev) => prev.slice(0, 1)));
+    act(() =>
+      hook.result.current.setEvent({ ...c, isPublic: true, title: "x" })
+    );
+    expect(ids(hook.result.current.items)).toEqual(["a"]);
+  });
+});