@tribe-nest/forge 3.59.0 → 3.61.0

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

@@ -0,0 +1,295 @@
+// @vitest-environment jsdom
+import { afterEach, describe, expect, it } from "vitest";
+import { act, renderHook, waitFor } from "@testing-library/react";
+import { communityJoinOffer, useCommunities, useCommunity } from "../communities/useCommunity";
+import { useCommunityAbout } from "../communities/useCommunityAbout";
+import { useCommunityHome } from "../communities/useCommunityHome";
+import { toMyMembershipEntry, useMyMemberships } from "../communities/useMyMemberships";
+import { useMemberHomeNav } from "../memberHome/useMemberHomeNav";
+import {
+  COMMUNITY,
+  OTHER_COMMUNITY,
+  account,
+  calls,
+  detailRoute,
+  get,
+  installAdapter,
+  meRoute,
+  post,
+  restoreAdapter,
+  tier,
+  viewer,
+  wrapper,
+} from "./communityHarness";
+
+/**
+ * The read side of a community: the list, one community and where the viewer
+ * stands in it, the About page's one action, the home shell (reconciling a
+ * Stripe return, the upgrade opener), the nav under the community home, and
+ * the account page's memberships across communities.
+ */
+
+afterEach(restoreAdapter);
+
+const free = tier({ id: "tier-free", name: "Free" });
+const paid = tier({ id: "tier-paid", priceMonthly: 12 });
+const yearly = tier({ id: "tier-yearly", priceYearly: 60 });
+const apply = tier({ id: "tier-apply", joinMode: "application" });
+
+const member = viewer({
+  state: "member",
+  membership: { id: "m-1", tierId: "tier-paid", tierName: "Paid", status: "active", cancelAtPeriodEnd: false, currentPeriodEnd: null, pendingDowngradeTierId: null },
+  upgradeTiers: [{ id: "tier-gold", name: "Gold", priceMonthly: 30, priceYearly: null }],
+  canInteract: true,
+});
+
+describe("communityJoinOffer (the About page's Join button)", () => {
+  it("Join free when a free tier exists", () => {
+    expect(communityJoinOffer([paid, free])).toMatchObject({ kind: "free", tier: { id: "tier-free" } });
+  });
+  it("otherwise the lowest price, compared per month", () => {
+    expect(communityJoinOffer([paid, yearly])).toMatchObject({ kind: "paid", tier: { id: "tier-yearly" }, amount: 60, cycle: "year" });
+  });
+  it("Apply when every tier is apply-to-join, and nothing with no tiers", () => {
+    expect(communityJoinOffer([apply])).toMatchObject({ kind: "apply" });
+    expect(communityJoinOffer([])).toBeNull();
+  });
+});
+
+describe("useCommunities", () => {
+  it("lists the profile's communities and names the only one", async () => {
+    installAdapter([get("/public/communities", () => [COMMUNITY])]);
+    const { result } = renderHook(() => useCommunities(), { wrapper: wrapper({ community: null }) });
+    await waitFor(() => expect(result.current.communities).toHaveLength(1));
+    expect(result.current.only?.slug).toBe("fan-club");
+    expect(calls("get", "/public/communities")[0].params).toEqual({ profileId: "profile-1" });
+  });
+  it("names none when there are several", async () => {
+    installAdapter([get("/public/communities", () => [COMMUNITY, OTHER_COMMUNITY])]);
+    const { result } = renderHook(() => useCommunities(), { wrapper: wrapper({ community: null }) });
+    await waitFor(() => expect(result.current.communities).toHaveLength(2));
+    expect(result.current.only).toBeNull();
+  });
+});
+
+describe("useCommunity", () => {
+  it("an anonymous visitor: the community, its tiers, and the offer", async () => {
+    installAdapter([detailRoute(() => ({ tiers: [free, paid], viewer: viewer({ state: "anonymous" }) }))]);
+    const { result } = renderHook(() => useCommunity(), { wrapper: wrapper() });
+    await waitFor(() => expect(result.current.tiers).toHaveLength(2));
+    expect(result.current.viewer?.state).toBe("anonymous");
+    expect(result.current.isMember).toBe(false);
+    expect(result.current.joinOffer?.kind).toBe("free");
+    expect(calls("get", /\/me$/)).toHaveLength(0);
+  });
+
+  it("a signed-in member: the viewer comes from /me, with the tier and the upgrade", async () => {
+    installAdapter([meRoute(() => member), detailRoute(() => ({ tiers: [free, paid] }))]);
+    const { result } = renderHook(() => useCommunity(), { wrapper: wrapper({ user: account() }) });
+    await waitFor(() => expect(result.current.isMember).toBe(true));
+    expect(result.current.currentTier?.id).toBe("tier-paid");
+    expect(result.current.hasUpgrade).toBe(true);
+    expect(result.current.canInteract).toBe(true);
+  });
+
+  it("pending: inside, no access, with the date applied", async () => {
+    const pending = viewer({ state: "pending", application: { id: "a-1", tierId: "tier-apply", status: "pending", createdAt: "2026-09-20T00:00:00.000Z" } });
+    installAdapter([meRoute(() => pending), detailRoute(() => ({ tiers: [apply] }))]);
+    const { result } = renderHook(() => useCommunity(), { wrapper: wrapper({ user: account() }) });
+    await waitFor(() => expect(result.current.isPending).toBe(true));
+    expect(result.current.isMember).toBe(false);
+    expect(result.current.pendingSince).toBe("2026-09-20T00:00:00.000Z");
+  });
+
+  it("an unknown community is notFound", async () => {
+    installAdapter([
+      get(/^\/public\/communities\/[^/]+$/, () => {
+        throw { status: 404 };
+      }),
+    ]);
+    const { result } = renderHook(() => useCommunity("nope"), { wrapper: wrapper({ community: null }) });
+    await waitFor(() => expect(result.current.notFound).toBe(true));
+  });
+});
+
+describe("useCommunityAbout", () => {
+  it("Join opens the sheet in place on a visitor, on the tier asked for", async () => {
+    installAdapter([detailRoute(() => ({ tiers: [free, paid] }))]);
+    const { result } = renderHook(() => useCommunityAbout({ tierId: "tier-paid" }), { wrapper: wrapper() });
+    await waitFor(() => expect(result.current.tiers).toHaveLength(2));
+    expect(result.current.action).toBe("join");
+    expect(result.current.sheetOpen).toBe(false);
+    act(() => result.current.primary());
+    expect(result.current.sheetOpen).toBe(true);
+    expect(result.current.sheetTierId).toBe("tier-paid");
+  });
+
+  it("an invite or a shareable link opens the sheet straight away", async () => {
+    installAdapter([detailRoute(() => ({ tiers: [free] }))]);
+    const invite = renderHook(() => useCommunityAbout({ invite: "tok" }), { wrapper: wrapper() });
+    const link = renderHook(() => useCommunityAbout({ join: "link" }), { wrapper: wrapper() });
+    expect(invite.result.current.sheetOpen).toBe(true);
+    expect(link.result.current.sheetOpen).toBe(true);
+  });
+
+  it("a member goes straight inside instead of Join", async () => {
+    installAdapter([meRoute(() => member), detailRoute(() => ({ tiers: [paid] }))]);
+    const navigated: string[] = [];
+    const { result } = renderHook(() => useCommunityAbout({ navigate: (href) => navigated.push(href) }), { wrapper: wrapper({ user: account() }) });
+    await waitFor(() => expect(result.current.action).toBe("enter"));
+    act(() => result.current.primary());
+    expect(navigated).toEqual(["/i/communities/fan-club/home"]);
+    expect(result.current.sheetOpen).toBe(false);
+  });
+});
+
+describe("useCommunityHome", () => {
+  it("reconciles a Stripe return once, for THIS community, inside it", async () => {
+    installAdapter([
+      post("/public/payments/subscriptions/confirm-latest", () => ({ status: "active" })),
+      meRoute(() => member),
+      detailRoute(() => ({ tiers: [paid] })),
+    ]);
+    const { result, rerender } = renderHook(() => useCommunityHome({ confirmSubscription: true }), { wrapper: wrapper({ user: account() }) });
+    await waitFor(() => expect(calls("post", "/public/payments/subscriptions/confirm-latest")).toHaveLength(1));
+    rerender();
+    expect(calls("post", "/public/payments/subscriptions/confirm-latest")).toHaveLength(1);
+    expect(calls("post", "/public/payments/subscriptions/confirm-latest")[0].body).toEqual({
+      profileId: "profile-1",
+      communityId: COMMUNITY.id,
+    });
+    await waitFor(() => expect(result.current.confirming).toBe(false));
+  });
+
+  it("REGRESSION: stops showing Confirming under React StrictMode (dev double mount)", async () => {
+    // The confirm used to report `isPending` from the mutation observer, which
+    // StrictMode's unmount and remount detaches, so the spinner never cleared
+    // although the request answered 200.
+    installAdapter([
+      post("/public/payments/subscriptions/confirm-latest", () => ({ status: "active" })),
+      meRoute(() => member),
+      detailRoute(() => ({ tiers: [paid] })),
+    ]);
+    const { result } = renderHook(() => useCommunityHome({ confirmSubscription: true }), {
+      wrapper: wrapper({ user: account() }),
+      reactStrictMode: true,
+    });
+    await waitFor(() => expect(calls("post", "/public/payments/subscriptions/confirm-latest")).toHaveLength(1));
+    await waitFor(() => expect(result.current.confirming).toBe(false));
+    expect(calls("post", "/public/payments/subscriptions/confirm-latest")).toHaveLength(1);
+  });
+
+  it("the opener every locked item uses opens the one upgrade sheet on the tier", async () => {
+    installAdapter([meRoute(() => member), detailRoute(() => ({ tiers: [paid] }))]);
+    const { result } = renderHook(() => useCommunityHome({ welcome: true }), { wrapper: wrapper({ user: account() }) });
+    await waitFor(() => expect(result.current.isMember).toBe(true));
+    expect(result.current.showUpgrade).toBe(true);
+    expect(result.current.welcomeVisible).toBe(true);
+    act(() => result.current.opener.openUpgrade("tier-gold"));
+    expect(result.current.upgradeOpen).toBe(true);
+    expect(result.current.upgradeTierId).toBe("tier-gold");
+    act(() => result.current.dismissWelcome());
+    expect(result.current.welcomeVisible).toBe(false);
+  });
+
+  it("offers Join, not Upgrade, to a visitor", async () => {
+    installAdapter([detailRoute(() => ({ tiers: [paid], viewer: viewer({ state: "anonymous" }) }))]);
+    const { result } = renderHook(() => useCommunityHome(), { wrapper: wrapper() });
+    await waitFor(() => expect(result.current.showJoin).toBe(true));
+    expect(result.current.showUpgrade).toBe(false);
+    expect(result.current.joinPath).toBe("/i/communities/fan-club");
+  });
+});
+
+describe("useMemberHomeNav", () => {
+  it("builds every tab under the community home, and none leads to the account page", async () => {
+    installAdapter([
+      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 })),
+    ]);
+    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(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");
+  });
+
+  it("an explicit active tab wins over the path", async () => {
+    installAdapter([]);
+    const { result } = renderHook(() => useMemberHomeNav({ activeKey: "spaces", currentPath: "/elsewhere" }), { wrapper: wrapper() });
+    expect(result.current.activeKey).toBe("spaces");
+  });
+});
+
+describe("useMyMemberships", () => {
+  it("one entry per community, each opening its own community home", async () => {
+    installAdapter([
+      // The server's real envelope: `[{ community, membership }]`
+      // (services/membership/selfServe.ts `view`), never a flat row.
+      get("/public/memberships/mine", () => [
+        {
+          community: { id: COMMUNITY.id, name: "Fan Club", slug: "fan-club" },
+          membership: { id: "m-1", communityId: COMMUNITY.id, tierId: "t-1", tierName: "Free", status: "active", amount: null, currency: null },
+        },
+        {
+          community: { id: OTHER_COMMUNITY.id, name: "Producers Circle", slug: "producers" },
+          membership: {
+            id: "m-2",
+            communityId: OTHER_COMMUNITY.id,
+            tierId: "t-9",
+            tierName: "Pro",
+            status: "past_due",
+            currentPeriodEnd: "2026-10-01T00:00:00.000Z",
+            amount: 1500,
+            currency: "USD",
+          },
+        },
+      ]),
+    ]);
+    const { result } = renderHook(() => useMyMemberships(), { wrapper: wrapper({ user: account(), community: null }) });
+    await waitFor(() => expect(result.current.memberships).toHaveLength(2));
+    expect(result.current.memberships.map((m) => m.homePath)).toEqual(["/i/communities/fan-club/home", "/i/communities/producers/home"]);
+    expect(result.current.memberships[1]).toMatchObject({
+      id: "m-2",
+      tierId: "t-9",
+      tierName: "Pro",
+      periodEnd: "2026-10-01T00:00:00.000Z",
+      amount: 1500,
+      currency: "USD",
+    });
+    expect(result.current.memberships[1].access.hasAccess).toBe(true);
+    expect(result.current.memberships[1].access.paymentFailed).toBe(true);
+  });
+
+  it("asks nothing while signed out", async () => {
+    installAdapter([]);
+    renderHook(() => useMyMemberships(), { wrapper: wrapper({ community: null }) });
+    expect(calls("get", "/public/memberships/mine")).toHaveLength(0);
+  });
+
+  it("toMyMembershipEntry reads a trial", () => {
+    const future = new Date(Date.now() + 5 * 86_400_000).toISOString();
+    expect(toMyMembershipEntry({ id: "m", status: "active", trialEndsAt: future, community: { id: "c", name: "C", slug: "c" } }).inTrial).toBe(true);
+  });
+});

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

@@ -0,0 +1,157 @@
+// @vitest-environment jsdom
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { act, renderHook, waitFor } from "@testing-library/react";
+import { useCommunityUpgrade } from "../communities/useCommunityUpgrade";
+import { account, calls, detailRoute, get, installAdapter, meRoute, post, restoreAdapter, tier, viewer, type Route } from "./communityHarness";
+import { wrapper } from "./communityHarness";
+
+const paystack = vi.hoisted(() => ({ open: vi.fn(async () => "opened" as const) }));
+vi.mock("../../../utils/paystackCheckout", async (importOriginal) => ({
+  ...(await importOriginal<typeof import("../../../utils/paystackCheckout")>()),
+  openPaystackCheckout: paystack.open,
+}));
+
+/**
+ * The upgrade sheet, on both providers. Only tiers ABOVE the current one are
+ * offered; on Stripe a `changed` answer is done with nothing to pay; a bank
+ * challenge or a Paystack upgrade (cancel and recreate, card again) is a
+ * payment step, and the sheet knows `requiresCard` BEFORE the fan confirms.
+ */
+
+const HOME = "/i/communities/fan-club/home";
+let onUpgraded: ReturnType<typeof vi.fn>;
+beforeEach(() => {
+  onUpgraded = vi.fn();
+  paystack.open.mockClear();
+});
+afterEach(restoreAdapter);
+
+const basic = tier({ id: "tier-basic", name: "Basic", priceMonthly: 5 });
+const gold = tier({ id: "tier-gold", name: "Gold", priceMonthly: 20, benefits: [{ id: "b1", title: "Live calls" }] as never });
+const platinum = tier({ id: "tier-plat", name: "Platinum", priceMonthly: 50 });
+
+const member = () =>
+  viewer({
+    state: "member",
+    membership: {
+      id: "m-1",
+      tierId: "tier-basic",
+      tierName: "Basic",
+      status: "active",
+      cancelAtPeriodEnd: false,
+      currentPeriodEnd: "2026-10-27T00:00:00.000Z",
+      pendingDowngradeTierId: null,
+    },
+    upgradeTiers: [
+      { id: "tier-gold", name: "Gold", priceMonthly: 20, priceYearly: null },
+      { id: "tier-plat", name: "Platinum", priceMonthly: 50, priceYearly: null },
+    ],
+  });
+
+const base = (extra: Route[] = [], preview = { amount: 15, currency: "USD", interval: "month", requiresCard: false, prorated: true }): Route[] => [
+  ...extra,
+  get("/public/communities/fan-club/upgrade-preview", () => preview),
+  meRoute(member),
+  detailRoute(() => ({ tiers: [basic, gold, platinum] })),
+];
+
+describe("useCommunityUpgrade", () => {
+  it("offers only the tiers above the current one, enriched with the tier's benefits", async () => {
+    installAdapter(base());
+    const { result } = renderHook(() => useCommunityUpgrade({ onUpgraded }), { wrapper: wrapper({ user: account() }) });
+    await waitFor(() => expect(result.current.options).toHaveLength(2));
+    expect(result.current.options.map((option) => option.id)).toEqual(["tier-gold", "tier-plat"]);
+    expect(result.current.options[0].tier?.benefits?.[0]?.title).toBe("Live calls");
+    expect(result.current.step).toBe("choose");
+    expect(result.current.currentTierName).toBe("Basic");
+  });
+
+  it("Stripe: previews the prorated charge, then one tap moves the plan and lands on the home", async () => {
+    installAdapter(base([post("/public/communities/fan-club/upgrade", () => ({ status: "changed", membership: null }))]));
+    const { result } = renderHook(() => useCommunityUpgrade({ onUpgraded }), { wrapper: wrapper({ user: account() }) });
+    await waitFor(() => expect(result.current.options).toHaveLength(2));
+    act(() => result.current.select("tier-gold"));
+    expect(result.current.step).toBe("confirm");
+    await waitFor(() => expect(result.current.preview?.amount).toBe(15));
+    expect(result.current.prorated).toBe(true);
+    expect(result.current.requiresCard).toBe(false);
+    expect(calls("get", "/public/communities/fan-club/upgrade-preview")[0].params).toMatchObject({ membershipTierId: "tier-gold" });
+
+    await act(async () => {
+      await result.current.upgrade();
+    });
+    expect(calls("post", "/public/communities/fan-club/upgrade")[0].body).toEqual({
+      profileId: "profile-1",
+      membershipTierId: "tier-gold",
+      returnUrl: `${window.location.origin}${HOME}?confirmSubscription=1`,
+    });
+    expect(result.current.step).toBe("done");
+    expect(onUpgraded).toHaveBeenCalledWith({ requiresConfirmation: false, path: HOME });
+  });
+
+  it("Stripe: a bank challenge is a payment step, and success lands on the home to reconcile", async () => {
+    installAdapter(
+      base([post("/public/communities/fan-club/upgrade", () => ({ status: "requires_payment", clientSecret: "pi_up_secret", membership: null }))]),
+    );
+    const { result } = renderHook(() => useCommunityUpgrade({ onUpgraded, initialTierId: "tier-plat" }), { wrapper: wrapper({ user: account() }) });
+    await waitFor(() => expect(result.current.selected?.id).toBe("tier-plat"));
+    await act(async () => {
+      await result.current.upgrade();
+    });
+    expect(result.current.step).toBe("payment");
+    expect(result.current.clientSecret).toBe("pi_up_secret");
+    expect(result.current.isPaystack).toBe(false);
+    act(() => result.current.onPaymentSucceeded());
+    expect(onUpgraded).toHaveBeenCalledWith({ requiresConfirmation: true, path: `${HOME}?confirmSubscription=1` });
+  });
+
+  it("Paystack: requiresCard is known before confirming, and the upgrade opens the new checkout", async () => {
+    installAdapter(
+      base(
+        [
+          post("/public/communities/fan-club/upgrade", () => ({
+            status: "requires_payment",
+            accessCode: "ac_up",
+            checkoutUrl: "https://paystack.test/ac_up",
+            membership: null,
+          })),
+        ],
+        { amount: 20, currency: "NGN", interval: "month", requiresCard: true, prorated: false },
+      ),
+    );
+    const { result } = renderHook(() => useCommunityUpgrade({ onUpgraded }), { wrapper: wrapper({ user: account() }) });
+    await waitFor(() => expect(result.current.options).toHaveLength(2));
+    act(() => result.current.select("tier-gold"));
+    await waitFor(() => expect(result.current.requiresCard).toBe(true));
+    expect(result.current.prorated).toBe(false);
+
+    await act(async () => {
+      await result.current.upgrade();
+    });
+    expect(result.current.step).toBe("payment");
+    expect(result.current.isPaystack).toBe(true);
+    expect(paystack.open).toHaveBeenCalledWith(
+      expect.objectContaining({ accessCode: "ac_up", returnUrl: `${window.location.origin}${HOME}?confirmSubscription=1` }),
+      expect.anything(),
+    );
+    expect(onUpgraded).not.toHaveBeenCalled();
+  });
+
+  it("a refusal is shown and nothing lands", async () => {
+    installAdapter(
+      base([
+        post("/public/communities/fan-club/upgrade", () => {
+          throw { status: 400, message: "That tier is not above yours." };
+        }),
+      ]),
+    );
+    const { result } = renderHook(() => useCommunityUpgrade({ onUpgraded, initialTierId: "tier-gold" }), { wrapper: wrapper({ user: account() }) });
+    await waitFor(() => expect(result.current.options).toHaveLength(2));
+    await act(async () => {
+      await result.current.upgrade();
+    });
+    expect(result.current.error).toBe("That tier is not above yours.");
+    expect(result.current.step).toBe("confirm");
+    expect(onUpgraded).not.toHaveBeenCalled();
+  });
+});

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");
+  });
+});