@tribe-nest/forge 3.59.0 → 3.61.0

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

@@ -0,0 +1,195 @@
+// @vitest-environment jsdom
+import { afterEach, describe, expect, it } from "vitest";
+import { act, renderHook, waitFor } from "@testing-library/react";
+import {
+  calendarMonthWindow,
+  calendarMonthStart,
+  callJoinable,
+  groupCalendarItems,
+  nextRsvp,
+  rsvpErrorCode,
+  useCommunityCalendar,
+} from "../communities/useCommunityCalendar";
+import type { CommunityCalendarCall, CommunityCalendarEvent } from "../../../data/queries/useCommunityCalendar";
+import { PROFILE_ID, account, calls, get, installAdapter, restoreAdapter, wrapper, type Route } from "./communityHarness";
+
+/**
+ * The community calendar as the site reads it: one month per request, grouped
+ * by the viewer's own days with what is still ahead on top, and going or not
+ * going on a call (what is SENT, and that the new counts land in the cache).
+ */
+
+afterEach(restoreAdapter);
+
+/** Local wall-clock times, so the day grouping holds in any test time zone. */
+const at = (day: number, hour: number) => new Date(2026, 8, day, hour, 0, 0).toISOString();
+const NOW = new Date(2026, 8, 15, 12, 0, 0);
+
+const call = (overrides: Partial<CommunityCalendarCall> = {}): CommunityCalendarCall => ({
+  kind: "call",
+  id: "11111111-aaaa-4aaa-8aaa-111111111111",
+  title: "Weekly Q&A",
+  description: null,
+  startsAt: at(16, 18),
+  endsAt: at(16, 19),
+  timezone: "Europe/Berlin",
+  participation: "open",
+  role: "attendee",
+  audiences: [],
+  opensAt: at(16, 17),
+  closesAt: at(16, 19),
+  isOpen: false,
+  callPublicId: "pub-1",
+  rsvp: { going: 2, notGoing: 1, mine: null },
+  icsUrl: "https://api.test/calendar/calls/c1.ics",
+  recording: null,
+  ...overrides,
+});
+
+const event = (overrides: Partial<CommunityCalendarEvent> = {}): CommunityCalendarEvent => ({
+  kind: "event",
+  id: "event-1",
+  title: "Album launch",
+  description: null,
+  slug: "album-launch",
+  startsAt: at(16, 20),
+  endsAt: null,
+  timezone: "Europe/Berlin",
+  type: "physical",
+  address: { name: "The Club", city: "Berlin" },
+  cancelled: false,
+  icsUrl: "https://api.test/calendar/events/e1.ics",
+  ...overrides,
+});
+
+const put =
+  (path: string, answer: (req: { body: Record<string, unknown> | null }) => unknown): Route =>
+  (req) =>
+    req.method === "put" && req.url === path ? answer(req) : undefined;
+
+describe("calendar helpers", () => {
+  it("reads one month from its first local midnight to the next", () => {
+    const { from, to } = calendarMonthWindow(calendarMonthStart(NOW));
+    expect(from).toEqual(new Date(2026, 8, 1));
+    expect(to).toEqual(new Date(2026, 9, 1));
+    expect(calendarMonthStart(NOW, -1)).toEqual(new Date(2026, 7, 1));
+    expect(calendarMonthStart(NOW, 4)).toEqual(new Date(2027, 0, 1));
+  });
+
+  it("groups by day, upcoming soonest first, then what already happened, latest first", () => {
+    const items = [
+      event({ id: "e-late", startsAt: at(16, 20) }),
+      call({ id: "c-early", startsAt: at(16, 9), endsAt: at(16, 10) }),
+      call({ id: "c-next-week", startsAt: at(22, 18), endsAt: at(22, 19) }),
+      call({ id: "c-past", startsAt: at(3, 18), endsAt: at(3, 19) }),
+      event({ id: "e-past", startsAt: at(10, 20), endsAt: at(10, 23) }),
+    ];
+    const { upcoming, past } = groupCalendarItems(items, NOW);
+    expect(upcoming.map((day) => [day.key, day.items.map((item) => item.id)])).toEqual([
+      ["2026-09-16", ["c-early", "e-late"]],
+      ["2026-09-22", ["c-next-week"]],
+    ]);
+    expect(past.map((day) => [day.key, day.items.map((item) => item.id)])).toEqual([
+      ["2026-09-10", ["e-past"]],
+      ["2026-09-03", ["c-past"]],
+    ]);
+  });
+
+  it("keeps a call that is on right now with what is ahead", () => {
+    const live = call({ id: "live", startsAt: at(15, 11), endsAt: at(15, 13), isOpen: true });
+    expect(groupCalendarItems([live], NOW).upcoming[0]!.items[0]!.id).toBe("live");
+  });
+
+  it("clears an answer when the same one is pressed again", () => {
+    expect(nextRsvp(null, "going")).toBe("going");
+    expect(nextRsvp("going", "going")).toBeNull();
+    expect(nextRsvp("going", "not_going")).toBe("not_going");
+  });
+
+  it("offers Join only while the room is open and there is one", () => {
+    expect(callJoinable(call({ isOpen: true }))).toBe(true);
+    expect(callJoinable(call({ isOpen: false }))).toBe(false);
+    expect(callJoinable(call({ isOpen: true, callPublicId: null }))).toBe(false);
+  });
+
+  it("reads a refused answer", () => {
+    expect(rsvpErrorCode({ response: { status: 409 } })).toBe("closed");
+    expect(rsvpErrorCode({ response: { status: 404 } })).toBe("not_found");
+    expect(rsvpErrorCode(new Error("network"))).toBe("failed");
+  });
+});
+
+describe("useCommunityCalendar", () => {
+  const PATH = "/public/communities/fan-club/calendar";
+  const RSVP = `/public/communities/fan-club/calendar/calls/${call().id}/rsvp`;
+
+  it("asks for the month shown, and the next one on the arrow", async () => {
+    installAdapter([get(PATH, () => [call(), event()])]);
+    const { result } = renderHook(() => useCommunityCalendar({ now: NOW }), { wrapper: wrapper({ user: account() }) });
+    await waitFor(() => expect(result.current.items).toHaveLength(2));
+    expect(calls("get", PATH)[0]!.params).toEqual({
+      profileId: PROFILE_ID,
+      from: new Date(2026, 8, 1).toISOString(),
+      to: new Date(2026, 9, 1).toISOString(),
+    });
+    act(() => result.current.goToNextMonth());
+    await waitFor(() => expect(calls("get", PATH)).toHaveLength(2));
+    expect(calls("get", PATH)[1]!.params).toMatchObject({
+      from: new Date(2026, 9, 1).toISOString(),
+      to: new Date(2026, 10, 1).toISOString(),
+    });
+    expect(result.current.isCurrentMonth).toBe(false);
+  });
+
+  it("sends going, and puts the new counts in the cache", async () => {
+    installAdapter([
+      get(PATH, () => [call()]),
+      put(RSVP, (req) => ({ going: 3, notGoing: 1, mine: req.body?.response ?? null })),
+    ]);
+    const { result } = renderHook(() => useCommunityCalendar({ now: NOW }), { wrapper: wrapper({ user: account() }) });
+    await waitFor(() => expect(result.current.items).toHaveLength(1));
+    act(() => result.current.answer(result.current.items[0] as CommunityCalendarCall, "going"));
+    await waitFor(() => expect((result.current.items[0] as CommunityCalendarCall).rsvp).toEqual({ going: 3, notGoing: 1, mine: "going" }));
+    expect(calls("put", RSVP)[0]!.body).toEqual({ profileId: PROFILE_ID, response: "going" });
+    // Only the one GET: the answer's own reply is what updates the list.
+    expect(calls("get", PATH)).toHaveLength(1);
+  });
+
+  it("clears the answer when the chosen one is pressed again", async () => {
+    installAdapter([
+      get(PATH, () => [call({ rsvp: { going: 3, notGoing: 1, mine: "going" } })]),
+      put(RSVP, () => ({ going: 2, notGoing: 1, mine: null })),
+    ]);
+    const { result } = renderHook(() => useCommunityCalendar({ now: NOW }), { wrapper: wrapper({ user: account() }) });
+    await waitFor(() => expect(result.current.items).toHaveLength(1));
+    act(() => result.current.answer(result.current.items[0] as CommunityCalendarCall, "going"));
+    await waitFor(() => expect((result.current.items[0] as CommunityCalendarCall).rsvp.mine).toBeNull());
+    expect(calls("put", RSVP)[0]!.body).toEqual({ profileId: PROFILE_ID, response: null });
+  });
+
+  it("keeps a 409 against the call it was for", async () => {
+    installAdapter([
+      get(PATH, () => [call()]),
+      put(RSVP, () => {
+        throw { status: 409, message: "Closed" };
+      }),
+    ]);
+    const { result } = renderHook(() => useCommunityCalendar({ now: NOW }), { wrapper: wrapper({ user: account() }) });
+    await waitFor(() => expect(result.current.items).toHaveLength(1));
+    act(() => result.current.answer(result.current.items[0] as CommunityCalendarCall, "not_going"));
+    await waitFor(() => expect(result.current.rsvpErrorFor(call().id)).toBe("closed"));
+    expect(result.current.rsvpErrorFor("another-call")).toBeNull();
+    expect((result.current.items[0] as CommunityCalendarCall).rsvp).toEqual(call().rsvp);
+  });
+
+  it("is forbidden for a non-member", async () => {
+    installAdapter([
+      get(PATH, () => {
+        throw { status: 403, message: "Forbidden" };
+      }),
+    ]);
+    const { result } = renderHook(() => useCommunityCalendar({ now: NOW }), { wrapper: wrapper({ user: account() }) });
+    await waitFor(() => expect(result.current.forbidden).toBe(true));
+    expect(result.current.isError).toBe(false);
+  });
+});

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

@@ -0,0 +1,120 @@
+// @vitest-environment jsdom
+import { afterEach, describe, expect, it } from "vitest";
+import { renderHook, waitFor } from "@testing-library/react";
+import {
+  classroomCourseHref,
+  classroomCourseState,
+  classroomProgressPercent,
+  classroomUnlockParts,
+  useCommunityClassroom,
+} from "../communities/useCommunityClassroom";
+import type { CommunityClassroomCourse } from "../../../data/queries/useCommunityClassroom";
+import { PROFILE_ID, account, calls, get, installAdapter, restoreAdapter, wrapper } from "./communityHarness";
+
+/**
+ * The classroom tab's reading of the server: what state a card is in, how far
+ * through it the member is, what opens a locked one, where an open one leads,
+ * and what the hook SENDS (the community by slug and the profile, nothing more).
+ */
+
+afterEach(restoreAdapter);
+
+const classroomCourse =(overrides: Partial<CommunityClassroomCourse> = {}): CommunityClassroomCourse => ({
+  courseId: "course-1",
+  title: "Songwriting 101",
+  description: "From idea to demo.",
+  slug: "songwriting-101",
+  coverUrl: null,
+  open: true,
+  progress: { completed: 3, total: 10, completedAt: null, currentLessonId: "lesson-4" },
+  unlockLevel: null,
+  unlockTiers: [],
+  accessId: "acc-1",
+  ...overrides,
+});
+
+describe("classroom helpers", () => {
+  it("reads progress as a percentage, full once completed", () => {
+    expect(classroomProgressPercent({ completed: 3, total: 10, completedAt: null, currentLessonId: null })).toBe(30);
+    expect(classroomProgressPercent({ completed: 0, total: 0, completedAt: null, currentLessonId: null })).toBe(0);
+    expect(
+      classroomProgressPercent({ completed: 2, total: 10, completedAt: "2026-09-01T00:00:00.000Z", currentLessonId: null }),
+    ).toBe(100);
+    expect(classroomProgressPercent(null)).toBe(0);
+  });
+
+  it("names the card's state", () => {
+    expect(classroomCourseState(classroomCourse())).toBe("in_progress");
+    expect(classroomCourseState(classroomCourse({ progress: { completed: 0, total: 5, completedAt: null, currentLessonId: null } }))).toBe(
+      "not_started",
+    );
+    expect(classroomCourseState(classroomCourse({ progress: { completed: 5, total: 5, completedAt: null, currentLessonId: null } }))).toBe(
+      "completed",
+    );
+    expect(classroomCourseState(classroomCourse({ open: false, progress: null }))).toBe("locked");
+  });
+
+  it("says what opens a locked course", () => {
+    expect(classroomUnlockParts(classroomCourse({ open: false, unlockLevel: 4 }))).toEqual({ level: 4, tiers: "" });
+    expect(
+      classroomUnlockParts(
+        classroomCourse({
+          open: false,
+          unlockTiers: [
+            { id: "t-gold", name: "Gold" },
+            { id: "t-vip", name: "VIP" },
+          ],
+        }),
+      ),
+    ).toEqual({ level: null, tiers: "Gold, VIP" });
+  });
+
+  it("opens the course player, and never falls back to the sales page", () => {
+    expect(classroomCourseHref({ open: true, accessId: "acc-9" })).toBe("/i/course-access/acc-9");
+    expect(classroomCourseHref({ open: true, accessId: null })).toBeNull();
+    expect(classroomCourseHref({ open: false, accessId: null })).toBeNull();
+  });
+});
+
+describe("useCommunityClassroom", () => {
+  it("reads the classroom by slug with the profile", async () => {
+    installAdapter([get("/public/communities/fan-club/classroom", () => [classroomCourse()])]);
+    const { result } = renderHook(() => useCommunityClassroom(), { wrapper: wrapper({ user: account() }) });
+    await waitFor(() => expect(result.current.courses).toHaveLength(1));
+    const sent = calls("get", "/public/communities/fan-club/classroom");
+    expect(sent).toHaveLength(1);
+    expect(sent[0]!.params).toEqual({ profileId: PROFILE_ID });
+    expect(result.current.forbidden).toBe(false);
+  });
+
+  it("is forbidden, not broken, for a non-member", async () => {
+    installAdapter([
+      get("/public/communities/fan-club/classroom", () => {
+        throw { status: 403, message: "Forbidden" };
+      }),
+    ]);
+    const { result } = renderHook(() => useCommunityClassroom(), { wrapper: wrapper({ user: account() }) });
+    await waitFor(() => expect(result.current.forbidden).toBe(true));
+    expect(result.current.isError).toBe(false);
+    // A 403 is an answer: asking again changes nothing.
+    expect(calls("get", "/public/communities/fan-club/classroom")).toHaveLength(1);
+  });
+
+  it("asks nothing while signed out", async () => {
+    installAdapter([get("/public/communities/fan-club/classroom", () => [classroomCourse()])]);
+    const { result } = renderHook(() => useCommunityClassroom(), { wrapper: wrapper() });
+    await new Promise((resolve) => setTimeout(resolve, 20));
+    expect(result.current.courses).toEqual([]);
+    expect(calls("get", "/public/communities/fan-club/classroom")).toHaveLength(0);
+  });
+
+  it("offers an upgrade only when a tier includes the course", async () => {
+    installAdapter([get("/public/communities/fan-club/classroom", () => [])]);
+    const { result } = renderHook(() => useCommunityClassroom(), { wrapper: wrapper({ user: account() }) });
+    const tierLocked = classroomCourse({ open: false, progress: null, unlockTiers: [{ id: "t-gold", name: "Gold" }] });
+    const levelLocked = classroomCourse({ open: false, progress: null, unlockLevel: 3 });
+    expect(result.current.canUpgrade(tierLocked)).toBe(true);
+    expect(result.current.canUpgrade(levelLocked)).toBe(false);
+    expect(result.current.unlockHref(tierLocked)).toBe("/i/communities/fan-club?tier=t-gold");
+  });
+});

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

@@ -0,0 +1,80 @@
+// @vitest-environment jsdom
+import { afterEach, describe, expect, it } from "vitest";
+import { render, screen, waitFor } from "@testing-library/react";
+import { CommunityGate, communityGateAllows } from "../communities/CommunityGate";
+import { account, detailRoute, installAdapter, meRoute, restoreAdapter, viewer, wrapper } from "./communityHarness";
+
+/**
+ * `CommunityGate` replaces `MembershipGate`. With no tiers it means "an active
+ * member of THIS community": a membership in another community of the same
+ * creator unlocks nothing here.
+ */
+
+afterEach(restoreAdapter);
+
+const memberOn = (tierId: string, state: "member" | "past_due" | "cancelled" = "member") =>
+  viewer({
+    state,
+    membership: { id: "m-1", tierId, tierName: tierId, status: "active", cancelAtPeriodEnd: false, currentPeriodEnd: null, pendingDowngradeTierId: null },
+  });
+
+describe("communityGateAllows", () => {
+  it("any active member of this community, when no tiers are named", () => {
+    expect(communityGateAllows(memberOn("tier-a"))).toBe(true);
+    expect(communityGateAllows(memberOn("tier-a", "past_due"))).toBe(true);
+  });
+  it("nobody else: none, pending, cancelled, anonymous, or no viewer at all", () => {
+    for (const state of ["none", "pending", "cancelled", "anonymous"] as const) {
+      expect(communityGateAllows(viewer({ state }))).toBe(false);
+    }
+    expect(communityGateAllows(undefined)).toBe(false);
+  });
+  it("only the named tiers when tiers are named", () => {
+    expect(communityGateAllows(memberOn("tier-a"), ["tier-a", "tier-b"])).toBe(true);
+    expect(communityGateAllows(memberOn("tier-c"), ["tier-a", "tier-b"])).toBe(false);
+  });
+});
+
+function renderGate(me: () => ReturnType<typeof viewer>, tiers?: string[]) {
+  installAdapter([meRoute(me), detailRoute(() => ({ viewer: me() }))]);
+  const Wrapper = wrapper({ user: account() });
+  render(
+    <Wrapper>
+      <CommunityGate tiers={tiers} fallback={(state) => <p data-testid="locked">{state.viewerState}</p>}>
+        <p data-testid="unlocked">secret</p>
+      </CommunityGate>
+    </Wrapper>,
+  );
+}
+
+describe("<CommunityGate>", () => {
+  it("shows the content to a member of this community", async () => {
+    renderGate(() => memberOn("tier-a"));
+    expect(await screen.findByTestId("unlocked")).toBeTruthy();
+  });
+
+  it("locks out a fan whose membership is in ANOTHER community (the server answers none here)", async () => {
+    renderGate(() => viewer({ state: "none" }));
+    expect((await screen.findByTestId("locked")).textContent).toBe("none");
+    expect(screen.queryByTestId("unlocked")).toBeNull();
+  });
+
+  it("locks out a member on a tier the gate does not name", async () => {
+    renderGate(() => memberOn("tier-c"), ["tier-a"]);
+    await waitFor(() => expect(screen.getByTestId("locked").textContent).toBe("member"));
+  });
+
+  it("refuses to render outside a provider", () => {
+    installAdapter([]);
+    const Wrapper = wrapper({ community: null });
+    expect(() =>
+      render(
+        <Wrapper>
+          <CommunityGate>
+            <p>secret</p>
+          </CommunityGate>
+        </Wrapper>,
+      ),
+    ).toThrow(/CommunityProvider/);
+  });
+});

package/src/ui/headless/_tests/communityHarness.tsx

@@ -0,0 +1,212 @@
+import { useState, type ReactNode } from "react";
+import axios, { type AxiosAdapter, type InternalAxiosRequestConfig } from "axios";
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import { ForgeClientProvider } from "../../../provider/ForgeProvider";
+import { PublicAuthContext } from "../../../contexts/PublicAuthContext";
+import { CommunityProvider } from "../../../contexts/CommunityContext";
+import type {
+  CommunityDetail,
+  CommunityViewerState,
+  PublicCommunity,
+  PublicTier,
+} from "../../../data/queries/useCommunities";
+
+/**
+ * A real provider tree for the community hook specs: the real data hooks over
+ * a stub axios adapter, so a spec asserts what is SENT, and an auth context
+ * whose sign-up, code and sign-in steps really sign the fan in (the join sheet
+ * reacts to that exactly as it does on a site).
+ */
+
+export const PROFILE_ID = "profile-1";
+
+export const COMMUNITY: PublicCommunity = {
+  id: "11111111-1111-4111-8111-111111111111",
+  name: "Fan Club",
+  slug: "fan-club",
+  description: "Where the fans are.",
+  coverUrl: null,
+  logoUrl: null,
+  category: "Music",
+  tags: [],
+  memberCount: 42,
+};
+
+export const OTHER_COMMUNITY: PublicCommunity = {
+  ...COMMUNITY,
+  id: "22222222-2222-4222-8222-222222222222",
+  name: "Producers Circle",
+  slug: "producers",
+};
+
+export const tier = (overrides: Partial<PublicTier> = {}): PublicTier => ({
+  id: "tier-free",
+  name: "Free",
+  description: "",
+  payWhatYouWant: false,
+  benefits: [],
+  communityId: COMMUNITY.id,
+  ...overrides,
+});
+
+export const viewer = (overrides: Partial<CommunityViewerState> = {}): CommunityViewerState => ({
+  state: "none",
+  membership: null,
+  application: null,
+  upgradeTiers: [],
+  canInteract: false,
+  ...overrides,
+});
+
+export const account = (email = "fan@example.com") => ({
+  id: "account-1",
+  email,
+  firstName: "Fan",
+  lastName: "Person",
+  kind: "fan",
+  status: "active",
+  createdAt: "2026-01-01T00:00:00.000Z",
+  updatedAt: "2026-01-01T00:00:00.000Z",
+});
+
+export interface Sent {
+  method: string;
+  url: string;
+  params: Record<string, unknown> | undefined;
+  body: Record<string, unknown> | null;
+}
+
+export type Route = (req: Sent) => unknown | undefined;
+
+let realAdapter: AxiosAdapter | undefined;
+export let sent: Sent[] = [];
+
+/**
+ * Answer requests from `routes` in order; the first that returns something
+ * other than `undefined` wins. A thrown `{ status }` becomes that HTTP error.
+ */
+export function installAdapter(routes: Route[]) {
+  sent = [];
+  realAdapter ??= axios.defaults.adapter as AxiosAdapter | undefined;
+  axios.defaults.adapter = (async (config: InternalAxiosRequestConfig) => {
+    const req: Sent = {
+      method: (config.method ?? "get").toLowerCase(),
+      url: config.url ?? "",
+      params: config.params as Record<string, unknown> | undefined,
+      body: config.data ? (JSON.parse(config.data as string) as Record<string, unknown>) : null,
+    };
+    sent.push(req);
+    for (const route of routes) {
+      let data: unknown;
+      try {
+        data = route(req);
+      } catch (e) {
+        const status = (e as { status?: number }).status ?? 500;
+        const error = Object.assign(new Error(`HTTP ${status}`), {
+          response: { status, data: { message: (e as { message?: string }).message } },
+          config,
+          isAxiosError: true,
+        });
+        throw error;
+      }
+      if (data !== undefined) return { data, status: 200, statusText: "OK", headers: {}, config } as never;
+    }
+    return { data: {}, status: 200, statusText: "OK", headers: {}, config } as never;
+  }) as AxiosAdapter;
+}
+
+export function restoreAdapter() {
+  if (realAdapter) axios.defaults.adapter = realAdapter;
+}
+
+/** The community read, answered for `/public/communities/:slug` (with or without a token). */
+export const detailRoute =
+  (detail: (req: Sent) => Partial<CommunityDetail>): Route =>
+  (req) => {
+    if (req.method !== "get") return undefined;
+    const match = /^\/public\/communities\/([^/]+)$/.exec(req.url);
+    if (!match) return undefined;
+    return { community: COMMUNITY, tiers: [], viewer: viewer(), invite: null, ...detail(req) };
+  };
+
+export const meRoute =
+  (state: () => CommunityViewerState): Route =>
+  (req) =>
+    req.method === "get" && /^\/public\/communities\/[^/]+\/me$/.test(req.url) ? state() : undefined;
+
+export const post = (path: string, answer: (req: Sent) => unknown): Route => (req) =>
+  req.method === "post" && req.url === path ? answer(req) : undefined;
+
+export const get = (path: string | RegExp, answer: (req: Sent) => unknown): Route => (req) =>
+  req.method === "get" && (typeof path === "string" ? req.url === path : path.test(req.url)) ? answer(req) : undefined;
+
+export interface AuthControls {
+  logout?: () => void;
+  /** Sees every session the email-first flow hands to `adoptSession`. */
+  adopted?: (session: unknown) => void;
+}
+
+/**
+ * A stateful auth context: `register` succeeds and asks for a code,
+ * `verifyRegistration` signs the fan in, `adoptSession` (the email-first flow)
+ * signs in whoever the session names, `validateLoginCredentials` +
+ * `verifyLoginCode` do the same for sign-in, `logout` signs out.
+ */
+function TestAuth({ initialUser, children, controls }: { initialUser: unknown; children: ReactNode; controls?: AuthControls }) {
+  const [user, setUser] = useState<ReturnType<typeof account> | null>(initialUser as ReturnType<typeof account> | null);
+  const value = {
+    user,
+    isAuthenticated: !!user,
+    isInitialized: true,
+    currencies: null,
+    userSelectedCurrency: "USD",
+    register: async () => ({}),
+    verifyRegistration: async (data: { email: string }) => {
+      setUser(account(data.email));
+      return {};
+    },
+    validateLoginCredentials: async () => ({}),
+    verifyLoginCode: async (email: string) => {
+      setUser(account(email));
+      return {};
+    },
+    resendLoginCode: async () => {},
+    adoptSession: (session: { account: ReturnType<typeof account> }) => {
+      controls?.adopted?.(session);
+      setUser(session.account);
+    },
+    logout: async () => {
+      controls?.logout?.();
+      setUser(null);
+    },
+    refetchUser: async () => {},
+  };
+  return <PublicAuthContext.Provider value={value as never}>{children}</PublicAuthContext.Provider>;
+}
+
+/** A `renderHook` wrapper: client, auth, and (unless `community: null`) a community provider. */
+export function wrapper(opts: { user?: unknown; community?: PublicCommunity | null; controls?: AuthControls } = {}) {
+  const client = new QueryClient({ defaultOptions: { queries: { retry: false }, mutations: { retry: false } } });
+  const community = opts.community === undefined ? COMMUNITY : opts.community;
+  return function Wrapper({ children }: { children: ReactNode }) {
+    return (
+      <QueryClientProvider client={client}>
+        <ForgeClientProvider apiUrl="http://api.test" profileId={PROFILE_ID}>
+          <TestAuth initialUser={opts.user ?? null} controls={opts.controls}>
+            {community ? (
+              <CommunityProvider community={community.slug} initialData={community}>
+                {children}
+              </CommunityProvider>
+            ) : (
+              children
+            )}
+          </TestAuth>
+        </ForgeClientProvider>
+      </QueryClientProvider>
+    );
+  };
+}
+
+/** Requests to `path` (exact) with `method`. */
+export const calls = (method: string, path: string | RegExp) =>
+  sent.filter((req) => req.method === method && (typeof path === "string" ? req.url === path : path.test(req.url)));