@tribe-nest/forge 3.60.0 → 3.61.0

package/src/ui/headless/_tests/useCommunityModeration.spec.tsx

@@ -0,0 +1,420 @@
+// @vitest-environment jsdom
+import { afterEach, describe, expect, it } from "vitest";
+import { act, renderHook, waitFor } from "@testing-library/react";
+import {
+  communityMuteUntil,
+  describeHoldReason,
+  describeModerationNotification,
+  moderationErrorMessage,
+  restorableLogEntries,
+  useCommunityModeration,
+  useCommunityModeratorActions,
+} from "../community/useCommunityModeration";
+import { useMemberHomeNav } from "../memberHome/useMemberHomeNav";
+import type { CommunityModerationLogEntry } from "../../../data/queries/useCommunityModeration";
+import {
+  COMMUNITY,
+  PROFILE_ID,
+  account,
+  calls,
+  get,
+  installAdapter,
+  post,
+  restoreAdapter,
+  wrapper,
+} from "./communityHarness";
+
+/**
+ * Moderation from the site. The server decides who may moderate; these pin
+ * what the site SENDS (every body names the profile, a mute names the
+ * community), that nothing is asked for until the viewer is known to moderate
+ * this community, and the small readings a renderer depends on: hold reasons
+ * in words, which log entries can still be undone, and which notifications
+ * carry a moderation outcome.
+ */
+
+afterEach(restoreAdapter);
+
+const me = (canModerate: boolean) =>
+  get("/public/community/me", () => ({
+    accountId: "account-1",
+    role: canModerate ? "moderator" : "member",
+    canModerate,
+  }));
+
+const QUEUE = {
+  reports: {
+    data: [
+      {
+        id: "rep-1",
+        entityType: "community_post",
+        entityId: "post-9",
+        reason: "spam",
+        reporterFirstName: "Ada",
+        reporterLastName: "L",
+        contentPreview: "buy now",
+        contentHidden: false,
+        createdAt: "2026-09-01T00:00:00.000Z",
+      },
+    ],
+    total: 1,
+  },
+  pending: {
+    posts: [
+      {
+        id: "post-1",
+        spaceId: "space-1",
+        spaceName: "General",
+        title: "Hello",
+        bodyText: "first post",
+        authorAccountId: "account-2",
+        authorName: "New Fan",
+        moderationReason: "approval_new_member",
+        createdAt: "2026-09-01T00:00:00.000Z",
+      },
+    ],
+    replies: [
+      {
+        id: "reply-1",
+        postId: "post-5",
+        postTitle: "Tour",
+        bodyText: "a reply",
+        authorAccountId: "account-3",
+        authorName: "Other Fan",
+        moderationReason: "keyword:spoiler",
+        createdAt: "2026-09-01T00:00:00.000Z",
+      },
+    ],
+  },
+};
+
+const logEntry = (overrides: Partial<CommunityModerationLogEntry>): CommunityModerationLogEntry => ({
+  id: "log-x",
+  action: "remove",
+  entityType: "community_post",
+  entityId: "post-1",
+  actorAccountId: "account-1",
+  targetAccountId: "account-2",
+  reason: null,
+  createdAt: "2026-09-01T00:00:00.000Z",
+  actorName: "Mod",
+  targetName: "Fan",
+  ...overrides,
+});
+
+describe("describeHoldReason", () => {
+  it("reads the three reasons the server writes", () => {
+    expect(describeHoldReason("approval_new_member")).toEqual({ kind: "new_member" });
+    expect(describeHoldReason("approval_all")).toEqual({ kind: "all_posts" });
+    expect(describeHoldReason("keyword:spoiler alert")).toEqual({ kind: "keyword", word: "spoiler alert" });
+  });
+
+  it("passes an unknown reason through, and nothing for none", () => {
+    expect(describeHoldReason("something_new")).toEqual({ kind: "other", raw: "something_new" });
+    expect(describeHoldReason(null)).toBeNull();
+    expect(describeHoldReason("")).toBeNull();
+  });
+});
+
+describe("communityMuteUntil", () => {
+  it("adds whole days to now", () => {
+    const now = new Date("2026-09-29T12:00:00.000Z");
+    expect(communityMuteUntil(1, now)).toBe("2026-09-30T12:00:00.000Z");
+    expect(communityMuteUntil(7, now)).toBe("2026-10-06T12:00:00.000Z");
+    expect(communityMuteUntil(30, now)).toBe("2026-10-29T12:00:00.000Z");
+  });
+});
+
+describe("moderationErrorMessage", () => {
+  it("returns the server's message, or null", () => {
+    const banned = { response: { status: 403, data: { message: "You can no longer take part in this community." } } };
+    expect(moderationErrorMessage(banned)).toBe("You can no longer take part in this community.");
+    expect(moderationErrorMessage(new Error("network"))).toBeNull();
+    expect(moderationErrorMessage({ response: { data: { message: "  " } } })).toBeNull();
+  });
+});
+
+describe("describeModerationNotification", () => {
+  it("reads an outcome on a post or reply", () => {
+    expect(
+      describeModerationNotification({
+        type: "mod",
+        entityType: "community_post",
+        data: { outcome: "approved", reason: null },
+      }),
+    ).toEqual({ outcome: "approved", subject: "post", reason: null });
+    expect(
+      describeModerationNotification({
+        type: "mod",
+        entityType: "community_reply",
+        data: { outcome: "rejected", reason: " off topic " },
+      }),
+    ).toEqual({ outcome: "rejected", subject: "reply", reason: "off topic" });
+  });
+
+  it("leaves the mute notice (about the community, no data) and other types alone", () => {
+    expect(describeModerationNotification({ type: "mod", entityType: "community", data: null })).toBeNull();
+    expect(describeModerationNotification({ type: "mod", entityType: "community", entityId: "c" } as never)).toBeNull();
+    expect(
+      describeModerationNotification({ type: "reply", entityType: "community_post", data: { outcome: "approved" } }),
+    ).toBeNull();
+    expect(
+      describeModerationNotification({ type: "mod", entityType: "community_post", data: { outcome: "maybe" } }),
+    ).toBeNull();
+  });
+});
+
+describe("restorableLogEntries", () => {
+  it("offers restore on a removal nothing newer has restored", () => {
+    const entries = [
+      logEntry({ id: "log-3", action: "remove", entityId: "post-2" }),
+      logEntry({ id: "log-2", action: "restore", entityId: "post-1" }),
+      logEntry({ id: "log-1", action: "remove", entityId: "post-1" }),
+    ];
+    const restorable = restorableLogEntries(entries);
+    expect([...restorable.keys()]).toEqual(["log-3"]);
+    expect(restorable.get("log-3")).toEqual({ type: "post", id: "post-2" });
+  });
+
+  it("covers a report resolved by hiding, and replies, and only the newest removal of one thing", () => {
+    const entries = [
+      logEntry({ id: "log-3", action: "report_resolved_hidden", entityType: "community_reply", entityId: "reply-1" }),
+      logEntry({ id: "log-2", action: "remove", entityType: "community_reply", entityId: "reply-1" }),
+      logEntry({ id: "log-1", action: "pin", entityId: "post-1" }),
+      logEntry({ id: "log-0", action: "mute", entityType: null, entityId: null }),
+    ];
+    const restorable = restorableLogEntries(entries);
+    expect([...restorable.keys()]).toEqual(["log-3"]);
+    expect(restorable.get("log-3")).toEqual({ type: "reply", id: "reply-1" });
+  });
+});
+
+describe("useCommunityModeration", () => {
+  it("asks for nothing and says so when the viewer does not moderate", async () => {
+    installAdapter([me(false)]);
+    const { result } = renderHook(() => useCommunityModeration(), { wrapper: wrapper({ user: account() }) });
+    await waitFor(() => expect(result.current.isChecking).toBe(false));
+    expect(result.current.canModerate).toBe(false);
+    expect(calls("get", "/public/community-moderation/queue")).toHaveLength(0);
+    expect(calls("get", "/public/community-moderation/log")).toHaveLength(0);
+  });
+
+  it("asks for nothing when signed out", async () => {
+    installAdapter([me(true)]);
+    const { result } = renderHook(() => useCommunityModeration(), { wrapper: wrapper() });
+    expect(result.current.canModerate).toBe(false);
+    expect(calls("get", "/public/community/me")).toHaveLength(0);
+  });
+
+  it("loads the queue and the log for THIS community", async () => {
+    installAdapter([
+      me(true),
+      get("/public/community-moderation/queue", () => QUEUE),
+      get("/public/community-moderation/log", () => ({
+        data: [logEntry({ id: "log-1" })],
+        total: 21,
+        page: 1,
+        pageSize: 20,
+        hasNextPage: true,
+      })),
+    ]);
+    const { result } = renderHook(() => useCommunityModeration(), { wrapper: wrapper({ user: account() }) });
+    await waitFor(() => expect(result.current.reports).toHaveLength(1));
+    expect(result.current.pendingPosts[0].id).toBe("post-1");
+    expect(result.current.pendingReplies[0].id).toBe("reply-1");
+    expect(calls("get", "/public/community-moderation/queue")[0].params).toEqual({
+      profileId: PROFILE_ID,
+      communityId: COMMUNITY.id,
+    });
+
+    await waitFor(() => expect(result.current.log.entries).toHaveLength(1));
+    expect(result.current.log.hasNextPage).toBe(true);
+    expect(result.current.log.restorable.has("log-1")).toBe(true);
+    expect(calls("get", "/public/community-moderation/log")[0].params).toEqual({
+      profileId: PROFILE_ID,
+      communityId: COMMUNITY.id,
+      page: 1,
+      limit: 20,
+    });
+
+    act(() => result.current.log.nextPage());
+    await waitFor(() =>
+      expect(calls("get", "/public/community-moderation/log").some((r) => r.params?.page === 2)).toBe(true),
+    );
+  });
+
+  it("sends each queue action with the profile, and the reason where one is given", async () => {
+    installAdapter([
+      me(true),
+      get("/public/community-moderation/queue", () => QUEUE),
+      get("/public/community-moderation/log", () => ({
+        data: [],
+        total: 0,
+        page: 1,
+        pageSize: 20,
+        hasNextPage: false,
+      })),
+      post("/public/community-moderation/reports/rep-1/resolve", () => ({ success: true })),
+      post("/public/community-moderation/posts/post-1/approve", () => ({ id: "post-1" })),
+      post("/public/community-moderation/posts/post-1/reject", () => ({ success: true })),
+      post("/public/community-moderation/replies/reply-1/reject", () => ({ success: true })),
+    ]);
+    const { result } = renderHook(() => useCommunityModeration(), { wrapper: wrapper({ user: account() }) });
+    await waitFor(() => expect(result.current.reports).toHaveLength(1));
+
+    await act(async () => {
+      expect(await result.current.resolveReport("rep-1", "resolve_and_hide")).toBe(true);
+    });
+    expect(calls("post", "/public/community-moderation/reports/rep-1/resolve")[0].body).toEqual({
+      profileId: PROFILE_ID,
+      action: "resolved",
+      hideContent: true,
+    });
+
+    await act(async () => {
+      await result.current.resolveReport("rep-1", "dismiss");
+    });
+    expect(calls("post", "/public/community-moderation/reports/rep-1/resolve")[1].body).toMatchObject({
+      action: "dismissed",
+      hideContent: false,
+    });
+
+    await act(async () => {
+      await result.current.approvePost({ id: "post-1" });
+      await result.current.rejectPost({ id: "post-1" }, "  off topic  ");
+      await result.current.rejectReply({ id: "reply-1", postId: "post-5" }, "");
+    });
+    expect(calls("post", "/public/community-moderation/posts/post-1/approve")[0].body).toEqual({
+      profileId: PROFILE_ID,
+    });
+    expect(calls("post", "/public/community-moderation/posts/post-1/reject")[0].body).toEqual({
+      profileId: PROFILE_ID,
+      reason: "off topic",
+    });
+    // A blank reason is not sent at all.
+    expect(calls("post", "/public/community-moderation/replies/reply-1/reject")[0].body).toEqual({
+      profileId: PROFILE_ID,
+    });
+  });
+
+  it("keeps the server's refusal on the row it happened to (approving twice is a 409)", async () => {
+    installAdapter([
+      me(true),
+      get("/public/community-moderation/queue", () => QUEUE),
+      get("/public/community-moderation/log", () => ({
+        data: [],
+        total: 0,
+        page: 1,
+        pageSize: 20,
+        hasNextPage: false,
+      })),
+      post("/public/community-moderation/posts/post-1/approve", () => {
+        throw { status: 409, message: "This is not waiting for approval." };
+      }),
+    ]);
+    const { result } = renderHook(() => useCommunityModeration(), { wrapper: wrapper({ user: account() }) });
+    await waitFor(() => expect(result.current.pendingPosts).toHaveLength(1));
+    await act(async () => {
+      expect(await result.current.approvePost({ id: "post-1" })).toBe(false);
+    });
+    expect(result.current.error).toEqual({ id: "post-1", message: "This is not waiting for approval." });
+    expect(result.current.busyId).toBeNull();
+  });
+});
+
+describe("useCommunityModeratorActions", () => {
+  it("is not a moderator until /me says so", async () => {
+    installAdapter([me(false)]);
+    const { result } = renderHook(() => useCommunityModeratorActions(), { wrapper: wrapper({ user: account() }) });
+    await waitFor(() => expect(calls("get", "/public/community/me")).toHaveLength(1));
+    expect(result.current.canModerate).toBe(false);
+  });
+
+  it("pins, removes with a reason, and mutes the author in THIS community", async () => {
+    installAdapter([
+      me(true),
+      post("/public/community-moderation/posts/post-1/pin", () => ({ id: "post-1", isPinned: true })),
+      post("/public/community-moderation/posts/post-1/remove", () => ({ success: true })),
+      post("/public/community-moderation/replies/reply-1/remove", () => ({ success: true })),
+      post("/public/community-moderation/members/account-2/mute", () => ({ success: true })),
+    ]);
+    const { result } = renderHook(() => useCommunityModeratorActions(), { wrapper: wrapper({ user: account() }) });
+    await waitFor(() => expect(result.current.canModerate).toBe(true));
+    expect(result.current.currentAccountId).toBe("account-1");
+
+    const before = Date.now();
+    await act(async () => {
+      await result.current.pinPost({ id: "post-1" });
+      await result.current.removePost({ id: "post-1" }, "spam");
+      await result.current.removeReply({ id: "reply-1", postId: "post-1" });
+      await result.current.muteMember("account-2", 7);
+    });
+    expect(calls("post", "/public/community-moderation/posts/post-1/pin")[0].body).toEqual({ profileId: PROFILE_ID });
+    expect(calls("post", "/public/community-moderation/posts/post-1/remove")[0].body).toEqual({
+      profileId: PROFILE_ID,
+      reason: "spam",
+    });
+    expect(calls("post", "/public/community-moderation/replies/reply-1/remove")[0].body).toEqual({
+      profileId: PROFILE_ID,
+    });
+
+    const mute = calls("post", "/public/community-moderation/members/account-2/mute")[0].body!;
+    expect(mute.profileId).toBe(PROFILE_ID);
+    expect(mute.communityId).toBe(COMMUNITY.id);
+    const until = new Date(mute.mutedUntil as string).getTime();
+    expect(until - before).toBeGreaterThanOrEqual(7 * 24 * 3600 * 1000 - 1000);
+    expect(until - before).toBeLessThan(7 * 24 * 3600 * 1000 + 60_000);
+  });
+
+  it("unmutes with a null time", async () => {
+    installAdapter([me(true), post("/public/community-moderation/members/account-2/mute", () => ({ success: true }))]);
+    const { result } = renderHook(() => useCommunityModeratorActions(), { wrapper: wrapper({ user: account() }) });
+    await waitFor(() => expect(result.current.canModerate).toBe(true));
+    await act(async () => {
+      await result.current.unmuteMember("account-2");
+    });
+    expect(calls("post", "/public/community-moderation/members/account-2/mute")[0].body).toEqual({
+      profileId: PROFILE_ID,
+      communityId: COMMUNITY.id,
+      mutedUntil: null,
+    });
+  });
+
+  it("surfaces a refusal as the server worded it", async () => {
+    installAdapter([
+      me(true),
+      post("/public/community-moderation/posts/post-1/lock", () => {
+        throw { status: 404, message: "Post not found" };
+      }),
+    ]);
+    const { result } = renderHook(() => useCommunityModeratorActions(), { wrapper: wrapper({ user: account() }) });
+    await waitFor(() => expect(result.current.canModerate).toBe(true));
+    await act(async () => {
+      expect(await result.current.lockPost({ id: "post-1" })).toBe(false);
+    });
+    expect(result.current.failed).toBe(true);
+    expect(result.current.error).toBe("Post not found");
+  });
+});
+
+describe("the Moderation tab in the member home nav", () => {
+  it("shows only to a moderator of this community", async () => {
+    installAdapter([me(true)]);
+    const { result } = renderHook(() => useMemberHomeNav({ currentPath: "/i/communities/fan-club/home/moderation" }), {
+      wrapper: wrapper({ user: account() }),
+    });
+    await waitFor(() => expect(result.current.visibleItems.map((i) => i.key)).toContain("moderation"));
+    expect(result.current.activeKey).toBe("moderation");
+    expect(result.current.items.find((i) => i.key === "moderation")?.href).toBe(
+      "/i/communities/fan-club/home/moderation",
+    );
+  });
+
+  it("stays hidden for a member who does not moderate", async () => {
+    installAdapter([me(false)]);
+    const { result } = renderHook(() => useMemberHomeNav({}), { wrapper: wrapper({ user: account() }) });
+    await waitFor(() => expect(calls("get", "/public/community/me")).toHaveLength(1));
+    await waitFor(() => expect(result.current.isReady).toBe(true));
+    expect(result.current.visibleItems.map((i) => i.key)).not.toContain("moderation");
+  });
+});

package/src/ui/headless/_tests/useCommunityReads.spec.tsx

@@ -207,21 +207,30 @@ describe("useMemberHomeNav", () => {
       get("/public/community/spaces", () => [{ id: "s-1", name: "Space", tiers: [] }]),
       get("/public/chat/channels", () => [{ id: "c-1", name: "General", type: "public", description: null }]),
       get("/public/post-collections", () => ({ data: [{ id: "col-1" }], total: 1, page: 1, pageSize: 10 })),
-      get("/public/scheduled-calls/mine", () => [{ id: "call-1" }]),
     ]);
     const { result } = renderHook(() => useMemberHomeNav({ currentPath: "/i/communities/fan-club/home/chat" }), { wrapper: wrapper() });
     await waitFor(() => expect(result.current.isReady).toBe(true));
-    await waitFor(() => expect(result.current.visibleItems).toHaveLength(7));
+    await waitFor(() => expect(result.current.visibleItems).toHaveLength(6));
     const hrefs = Object.fromEntries(result.current.items.map((item) => [item.key, item.href]));
     expect(hrefs).toEqual({
       posts: "/i/communities/fan-club/home",
       collections: "/i/communities/fan-club/home/collections",
       spaces: "/i/communities/fan-club/home/spaces",
+      // Built, but hidden: signed out, so not a member.
       calendar: "/i/communities/fan-club/home/calendar",
+      // Built, but hidden: signed out, so not a member.
+      classroom: "/i/communities/fan-club/home/classroom",
       chat: "/i/communities/fan-club/home/chat",
       leaderboard: "/i/communities/fan-club/home/leaderboard",
       notifications: "/i/communities/fan-club/home/notifications",
+      // Built, but hidden: signed out, so not a member.
+      members: "/i/communities/fan-club/home/members",
+      // Built, but hidden: this community has no wiki pages listed.
+      wiki: "/i/communities/fan-club/home/wiki",
+      // Built, but hidden: this viewer does not moderate the community.
+      moderation: "/i/communities/fan-club/home/moderation",
     });
+    expect(result.current.visibleItems.map((item) => item.key)).not.toContain("moderation");
     expect(result.current.activeKey).toBe("chat");
     expect(JSON.stringify(result.current.items)).not.toContain("/i/account");
   });

package/src/ui/headless/_tests/useCommunityWiki.spec.tsx

@@ -0,0 +1,224 @@
+// @vitest-environment jsdom
+import { afterEach, describe, expect, it } from "vitest";
+import { renderHook, waitFor } from "@testing-library/react";
+import {
+  defaultWikiPageSlug,
+  extractWikiToc,
+  parseWikiContent,
+  shapeWikiList,
+  useCommunityWiki,
+  useCommunityWikiPage,
+  wikiHeadingSlug,
+} from "../communities/useCommunityWiki";
+import { useMemberHomeNav } from "../memberHome/useMemberHomeNav";
+import type { CommunityWikiPageSummary } from "../../../data/queries/useCommunityWiki";
+import { PROFILE_ID, account, calls, get, installAdapter, restoreAdapter, wrapper } from "./communityHarness";
+
+/**
+ * The community wiki as the site reads it. These pin the list shaping (what is
+ * readable, what is locked, what the About page shows), which page the Wiki tab
+ * opens on, the table of contents a page grows from its headings, and what the
+ * hooks SEND: the community named by slug, the profile, and nothing more.
+ */
+
+afterEach(restoreAdapter);
+
+const summary = (overrides: Partial<CommunityWikiPageSummary>): CommunityWikiPageSummary => ({
+  id: "page-x",
+  title: "Page",
+  slug: "page",
+  isPublic: false,
+  locked: false,
+  unlockTiers: [],
+  updatedAt: "2026-09-01T00:00:00.000Z",
+  ...overrides,
+});
+
+const PAGES = [
+  summary({
+    id: "p1",
+    slug: "vip-lounge",
+    title: "VIP lounge",
+    locked: true,
+    unlockTiers: [{ id: "tier-gold", name: "Gold" }],
+  }),
+  summary({ id: "p2", slug: "start-here", title: "Start here" }),
+  summary({ id: "p3", slug: "community-guidelines", title: "Community guidelines", isPublic: true }),
+];
+
+const text = (value: string) => ({ type: "text", version: 1, text: value });
+const heading = (tag: string, value: string) => ({ type: "heading", version: 1, tag, children: [text(value)] });
+const paragraph = (value: string) => ({ type: "paragraph", version: 1, children: [text(value)] });
+const doc = (...children: unknown[]) => ({ root: { type: "root", version: 1, children } });
+
+describe("shapeWikiList", () => {
+  it("splits readable from locked, keeping the wiki's order", () => {
+    const shaped = shapeWikiList(PAGES);
+    expect(shaped.all.map((p) => p.slug)).toEqual(["vip-lounge", "start-here", "community-guidelines"]);
+    expect(shaped.readable.map((p) => p.slug)).toEqual(["start-here", "community-guidelines"]);
+    expect(shaped.locked.map((p) => p.slug)).toEqual(["vip-lounge"]);
+  });
+
+  it("keeps only public pages for the About page", () => {
+    expect(shapeWikiList(PAGES, { publicOnly: true }).all.map((p) => p.slug)).toEqual(["community-guidelines"]);
+  });
+
+  it("treats a missing or malformed list as empty", () => {
+    expect(shapeWikiList(undefined).all).toEqual([]);
+    expect(shapeWikiList({} as never).all).toEqual([]);
+  });
+});
+
+describe("defaultWikiPageSlug", () => {
+  it("opens the first page the viewer can read, skipping locked ones", () => {
+    expect(defaultWikiPageSlug(PAGES)).toBe("start-here");
+  });
+
+  it("is null when every page is locked, or there are none", () => {
+    expect(defaultWikiPageSlug([PAGES[0]])).toBeNull();
+    expect(defaultWikiPageSlug([])).toBeNull();
+    expect(defaultWikiPageSlug(undefined)).toBeNull();
+  });
+});
+
+describe("parseWikiContent", () => {
+  it("accepts the editor state as an object or as a JSON string", () => {
+    const state = doc(paragraph("hi"));
+    expect(parseWikiContent(state)?.root.type).toBe("root");
+    expect(parseWikiContent(JSON.stringify(state))?.root.type).toBe("root");
+  });
+
+  it("returns null for anything that is not an editor state", () => {
+    expect(parseWikiContent(null)).toBeNull();
+    expect(parseWikiContent("not json")).toBeNull();
+    expect(parseWikiContent(42)).toBeNull();
+  });
+});
+
+describe("extractWikiToc", () => {
+  it("lists the top-level headings in order, with their level", () => {
+    const toc = extractWikiToc(doc(heading("h2", "Getting started"), paragraph("..."), heading("h3", "Your profile")));
+    expect(toc).toEqual([
+      { id: "getting-started", text: "Getting started", level: 2 },
+      { id: "your-profile", text: "Your profile", level: 3 },
+    ]);
+  });
+
+  it("gives repeated titles unique anchors, and skips empty headings", () => {
+    const toc = extractWikiToc(doc(heading("h2", "FAQ"), heading("h2", "  "), heading("h2", "FAQ")));
+    expect(toc.map((e) => e.id)).toEqual(["faq", "faq-2"]);
+  });
+
+  it("reads headings made of several text runs, and a string state", () => {
+    const multi = {
+      type: "heading",
+      version: 1,
+      tag: "h1",
+      children: [text("Hello "), { type: "link", version: 1, children: [text("world")] }],
+    };
+    expect(extractWikiToc(JSON.stringify(doc(multi)))).toEqual([{ id: "hello-world", text: "Hello world", level: 1 }]);
+  });
+
+  it("is empty for a page with no headings (the seeded pages are plain paragraphs)", () => {
+    expect(extractWikiToc(doc(paragraph("Welcome")))).toEqual([]);
+  });
+});
+
+describe("wikiHeadingSlug", () => {
+  it("makes a URL-safe anchor, keeping letters beyond ASCII", () => {
+    expect(wikiHeadingSlug("Membership & billing!")).toBe("membership-billing");
+    expect(wikiHeadingSlug("Über uns")).toBe("uber-uns");
+    expect(wikiHeadingSlug("???")).toBe("section");
+  });
+});
+
+describe("useCommunityWiki", () => {
+  it("asks for this community's wiki by slug, and shapes it", async () => {
+    installAdapter([get("/public/communities/fan-club/wiki", () => PAGES)]);
+    const { result } = renderHook(() => useCommunityWiki(), { wrapper: wrapper({ user: account() }) });
+    await waitFor(() => expect(result.current.pages).toHaveLength(3));
+    expect(result.current.defaultSlug).toBe("start-here");
+    expect(result.current.lockedPages[0].slug).toBe("vip-lounge");
+    expect(calls("get", "/public/communities/fan-club/wiki")[0].params).toEqual({ profileId: PROFILE_ID });
+    // No community home around it, so the upgrade leads to the About page with the tier chosen.
+    expect(result.current.unlock).toBeNull();
+    expect(result.current.unlockHref(PAGES[0])).toBe("/i/communities/fan-club?tier=tier-gold");
+  });
+
+  it("shows only public pages with publicOnly, signed out too", async () => {
+    installAdapter([get("/public/communities/fan-club/wiki", () => PAGES)]);
+    const { result } = renderHook(() => useCommunityWiki({ publicOnly: true }), { wrapper: wrapper() });
+    await waitFor(() => expect(result.current.pages).toHaveLength(1));
+    expect(result.current.readablePages[0].slug).toBe("community-guidelines");
+  });
+});
+
+describe("useCommunityWikiPage", () => {
+  it("loads one page with its table of contents", async () => {
+    installAdapter([
+      get("/public/communities/fan-club/wiki/start-here", () => ({
+        id: "p2",
+        title: "Start here",
+        slug: "start-here",
+        isPublic: false,
+        content: doc(heading("h2", "Welcome"), paragraph("..."), heading("h2", "Where to go next")),
+        updatedAt: "2026-09-01T00:00:00.000Z",
+      })),
+    ]);
+    const { result } = renderHook(() => useCommunityWikiPage("start-here"), { wrapper: wrapper({ user: account() }) });
+    await waitFor(() => expect(result.current.page?.title).toBe("Start here"));
+    expect(result.current.showToc).toBe(true);
+    expect(result.current.headingIds).toEqual(["welcome", "where-to-go-next"]);
+    expect(calls("get", "/public/communities/fan-club/wiki/start-here")[0].params).toEqual({ profileId: PROFILE_ID });
+  });
+
+  it("hides the table of contents under two headings", async () => {
+    installAdapter([
+      get("/public/communities/fan-club/wiki/faq", () => ({
+        id: "p4",
+        title: "FAQ",
+        slug: "faq",
+        isPublic: false,
+        content: doc(heading("h2", "Only one"), paragraph("...")),
+        updatedAt: "2026-09-01T00:00:00.000Z",
+      })),
+    ]);
+    const { result } = renderHook(() => useCommunityWikiPage("faq"), { wrapper: wrapper({ user: account() }) });
+    await waitFor(() => expect(result.current.page).not.toBeNull());
+    expect(result.current.toc).toHaveLength(1);
+    expect(result.current.showToc).toBe(false);
+  });
+
+  it("reports a page the viewer may not read as not found, without retrying", async () => {
+    installAdapter([
+      get("/public/communities/fan-club/wiki/vip-lounge", () => {
+        throw { status: 404, message: "Not found" };
+      }),
+    ]);
+    const { result } = renderHook(() => useCommunityWikiPage("vip-lounge"), { wrapper: wrapper({ user: account() }) });
+    await waitFor(() => expect(result.current.notFound).toBe(true));
+    expect(result.current.isError).toBe(false);
+    expect(calls("get", "/public/communities/fan-club/wiki/vip-lounge")).toHaveLength(1);
+  });
+});
+
+describe("the Wiki tab in the member home nav", () => {
+  it("shows once the community has a page this viewer may see", async () => {
+    installAdapter([get("/public/communities/fan-club/wiki", () => PAGES)]);
+    const { result } = renderHook(
+      () => useMemberHomeNav({ currentPath: "/i/communities/fan-club/home/wiki/start-here" }),
+      {
+        wrapper: wrapper({ user: account() }),
+      },
+    );
+    await waitFor(() => expect(result.current.visibleItems.map((i) => i.key)).toContain("wiki"));
+    expect(result.current.activeKey).toBe("wiki");
+  });
+
+  it("stays hidden with no pages", async () => {
+    installAdapter([get("/public/communities/fan-club/wiki", () => [])]);
+    const { result } = renderHook(() => useMemberHomeNav({}), { wrapper: wrapper({ user: account() }) });
+    await waitFor(() => expect(result.current.isReady).toBe(true));
+    expect(result.current.visibleItems.map((i) => i.key)).not.toContain("wiki");
+  });
+});