@tribe-nest/forge 3.60.0 → 3.63.0

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

@@ -0,0 +1,389 @@
+// @vitest-environment jsdom
+import { afterEach, describe, expect, it } from "vitest";
+import { act, renderHook, waitFor } from "@testing-library/react";
+import {
+  buildPollPayload,
+  emptyPollDraft,
+  pollHiddenReason,
+  pollOptionPercent,
+  pollVoteErrorCode,
+  sameAnswer,
+  useCommunityPoll,
+  useCommunityPollDraft,
+  validatePollDraft,
+  type CommunityPollDraft,
+} from "../community/communityPoll";
+import { useCommunitySpaceFeed } from "../community/useCommunitySpaceFeed";
+import { wikiUnlockParts } from "../communities/useCommunityWiki";
+import { useCommunitySpacePosts, type CommunityPollView, type CommunityPost } from "../../../data/queries/useCommunity";
+import { COMMUNITY, calls, get, installAdapter, post, restoreAdapter, wrapper } from "./communityHarness";
+
+/**
+ * Polls on community posts and the level locks, headless: the composer's
+ * checks (the server's limits, so a draft that passes is not refused for its
+ * shape), the body the draft becomes, the vote request and the caches it
+ * patches, and a level-locked space that is never asked for.
+ */
+
+afterEach(restoreAdapter);
+
+const NOW = new Date("2026-09-30T12:00:00Z").getTime();
+
+const draft = (overrides: Partial<CommunityPollDraft> = {}): CommunityPollDraft => ({
+  ...emptyPollDraft(),
+  question: "Which day works?",
+  options: ["Monday", "Tuesday"],
+  ...overrides,
+});
+
+describe("validatePollDraft (the composer's checks)", () => {
+  it("passes a complete draft", () => {
+    const errors = validatePollDraft(draft(), NOW);
+    expect(errors.valid).toBe(true);
+    expect(errors).toMatchObject({ question: null, options: [null, null], optionsList: null, closesAt: null });
+  });
+
+  it("needs a question, and at most 200 characters of it", () => {
+    expect(validatePollDraft(draft({ question: "   " }), NOW)).toMatchObject({ question: "question_required", valid: false });
+    expect(validatePollDraft(draft({ question: "x".repeat(201) }), NOW).question).toBe("question_too_long");
+    expect(validatePollDraft(draft({ question: "x".repeat(200) }), NOW).question).toBeNull();
+  });
+
+  it("needs 2 to 10 options", () => {
+    expect(validatePollDraft(draft({ options: ["Only"] }), NOW)).toMatchObject({ optionsList: "options_too_few", valid: false });
+    const eleven = Array.from({ length: 11 }, (_, i) => `Option ${i}`);
+    expect(validatePollDraft(draft({ options: eleven }), NOW).optionsList).toBe("options_too_many");
+    const ten = eleven.slice(0, 10);
+    expect(validatePollDraft(draft({ options: ten }), NOW).valid).toBe(true);
+  });
+
+  it("marks each empty, overlong or repeated option where it is", () => {
+    const errors = validatePollDraft(draft({ options: ["Yes", " ", "x".repeat(121), " yes ", "x".repeat(120)] }), NOW);
+    expect(errors.options).toEqual([null, "option_empty", "option_too_long", "option_duplicate", null]);
+    expect(errors.valid).toBe(false);
+  });
+
+  it("wants a close time in the future, or none", () => {
+    expect(validatePollDraft(draft({ closesAt: "2026-09-29T10:00" }), NOW).closesAt).toBe("closes_in_past");
+    expect(validatePollDraft(draft({ closesAt: "not a date" }), NOW).closesAt).toBe("closes_invalid");
+    expect(validatePollDraft(draft({ closesAt: "2026-10-02T10:00" }), NOW).closesAt).toBeNull();
+  });
+
+  it("needs a close time when the results wait for the close", () => {
+    expect(validatePollDraft(draft({ resultsVisibility: "after_close" }), NOW).closesAt).toBe("closes_required");
+    expect(
+      validatePollDraft(draft({ resultsVisibility: "after_close", closesAt: "2026-10-02T10:00" }), NOW).valid,
+    ).toBe(true);
+  });
+});
+
+describe("buildPollPayload (what the create-post call carries)", () => {
+  it("sends the trimmed question as the title and the poll beside it", () => {
+    const payload = buildPollPayload(
+      draft({
+        question: "  Which day works?  ",
+        options: [" Monday ", "Tuesday "],
+        multipleChoice: true,
+        closesAt: "2026-10-02T10:00",
+        resultsVisibility: "always",
+      }),
+    );
+    expect(payload).toEqual({
+      title: "Which day works?",
+      poll: {
+        options: ["Monday", "Tuesday"],
+        multipleChoice: true,
+        closesAt: new Date("2026-10-02T10:00").toISOString(),
+        resultsVisibility: "always",
+      },
+    });
+  });
+
+  it("no close time is null, and the default visibility is after_vote", () => {
+    expect(buildPollPayload(draft()).poll).toEqual({
+      options: ["Monday", "Tuesday"],
+      multipleChoice: false,
+      closesAt: null,
+      resultsVisibility: "after_vote",
+    });
+  });
+});
+
+describe("useCommunityPollDraft", () => {
+  it("keeps between 2 and 10 options", () => {
+    const { result } = renderHook(() => useCommunityPollDraft());
+    expect(result.current.draft.options).toHaveLength(2);
+    expect(result.current.canRemoveOption).toBe(false);
+    act(() => result.current.removeOption(0));
+    expect(result.current.draft.options).toHaveLength(2);
+    for (let i = 0; i < 12; i++) act(() => result.current.addOption());
+    expect(result.current.draft.options).toHaveLength(10);
+    expect(result.current.canAddOption).toBe(false);
+    act(() => result.current.removeOption(3));
+    expect(result.current.draft.options).toHaveLength(9);
+  });
+
+  it("shows errors only once a submit was tried", () => {
+    const { result } = renderHook(() => useCommunityPollDraft());
+    expect(result.current.showErrors).toBe(false);
+    let ok = true;
+    act(() => {
+      ok = result.current.attempt();
+    });
+    expect(ok).toBe(false);
+    expect(result.current.showErrors).toBe(true);
+    expect(result.current.errors.question).toBe("question_required");
+  });
+});
+
+describe("reading a poll", () => {
+  const poll = (overrides: Partial<CommunityPollView> = {}): CommunityPollView => ({
+    id: "poll-1",
+    multipleChoice: false,
+    closesAt: null,
+    closed: false,
+    resultsVisibility: "after_vote",
+    resultsVisible: false,
+    totalVoters: null,
+    myVotes: [],
+    options: [],
+    ...overrides,
+  });
+
+  it("percentages are of the voters, and hidden counts stay hidden", () => {
+    expect(pollOptionPercent(1, 3)).toBe(33);
+    expect(pollOptionPercent(0, 0)).toBe(0);
+    expect(pollOptionPercent(null, null)).toBeNull();
+  });
+
+  it("says why the counts are hidden", () => {
+    expect(pollHiddenReason(poll())).toBe("after_vote");
+    expect(pollHiddenReason(poll({ resultsVisibility: "after_close" }))).toBe("after_close");
+    expect(pollHiddenReason(poll({ resultsVisible: true }))).toBeNull();
+  });
+
+  it("names a failed vote by its status", () => {
+    const err = (status: number) => ({ response: { status } });
+    expect(pollVoteErrorCode(err(409))).toBe("closed");
+    expect(pollVoteErrorCode(err(400))).toBe("invalid");
+    expect(pollVoteErrorCode(err(403))).toBe("forbidden");
+    expect(pollVoteErrorCode(new Error("network"))).toBe("generic");
+  });
+
+  it("an answer is the same answer in any order", () => {
+    expect(sameAnswer(["a", "b"], ["b", "a"])).toBe(true);
+    expect(sameAnswer(["a"], ["a", "b"])).toBe(false);
+  });
+});
+
+// ── Voting, against the real data hooks ──────────────────────────────────────
+
+const OPTION_A = "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa";
+const OPTION_B = "bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb";
+
+const openPoll = (overrides: Partial<CommunityPollView> = {}): CommunityPollView => ({
+  id: "poll-1",
+  multipleChoice: false,
+  closesAt: null,
+  closed: false,
+  resultsVisibility: "after_vote",
+  resultsVisible: false,
+  totalVoters: null,
+  myVotes: [],
+  options: [
+    { id: OPTION_A, label: "Monday", position: 0, votes: null },
+    { id: OPTION_B, label: "Tuesday", position: 1, votes: null },
+  ],
+  ...overrides,
+});
+
+const feedPost = (poll: CommunityPollView): CommunityPost => ({
+  id: "post-1",
+  profileId: "profile-1",
+  spaceId: "space-1",
+  authorAccountId: "acct-2",
+  title: "Which day works?",
+  body: null,
+  bodyText: "",
+  isPinned: false,
+  isLocked: false,
+  replyCount: 0,
+  reactionCount: 0,
+  lastActivityAt: null,
+  createdAt: "2026-09-30T10:00:00.000Z",
+  author: null,
+  media: [],
+  reactions: [],
+  poll,
+});
+
+const page = (posts: CommunityPost[]) => ({
+  data: posts,
+  total: posts.length,
+  page: 1,
+  pageSize: 20,
+  hasNextPage: false,
+  nextPage: null,
+});
+
+/** The feed and a poll on its first post, sharing one query client. */
+function useFeedAndPoll() {
+  const feed = useCommunitySpacePosts("space-1");
+  const first = feed.data?.pages[0]?.data[0];
+  const poll = useCommunityPoll(first ?? { id: "post-1", spaceId: "space-1", poll: null });
+  return { feed, first, poll };
+}
+
+describe("useCommunityPoll voting", () => {
+  it("sends the member's whole answer and puts the answer the server gives into the feed", async () => {
+    const answered = openPoll({
+      resultsVisible: true,
+      totalVoters: 4,
+      myVotes: [OPTION_B],
+      options: [
+        { id: OPTION_A, label: "Monday", position: 0, votes: 1 },
+        { id: OPTION_B, label: "Tuesday", position: 1, votes: 3 },
+      ],
+    });
+    installAdapter([
+      get("/public/community/spaces/space-1/posts", () => page([feedPost(openPoll())])),
+      post("/public/community/posts/post-1/poll/vote", () => answered),
+    ]);
+    const { result } = renderHook(() => useFeedAndPoll(), { wrapper: wrapper() });
+    await waitFor(() => expect(result.current.first?.poll?.id).toBe("poll-1"));
+    expect(result.current.poll.choosing).toBe(true);
+
+    // Single choice: picking another option replaces the first.
+    act(() => result.current.poll.toggle(OPTION_A));
+    act(() => result.current.poll.toggle(OPTION_B));
+    expect(result.current.poll.selection).toEqual([OPTION_B]);
+    await act(async () => {
+      await result.current.poll.submit();
+    });
+
+    expect(calls("post", "/public/community/posts/post-1/poll/vote").map((c) => c.body)).toEqual([
+      { profileId: "profile-1", communityId: COMMUNITY.id, optionIds: [OPTION_B] },
+    ]);
+    // The feed cache now holds the server's answer: counts shown, the vote on record.
+    await waitFor(() => expect(result.current.first?.poll).toEqual(answered));
+    expect(result.current.poll.hasVoted).toBe(true);
+    expect(result.current.poll.choosing).toBe(false);
+  });
+
+  it("withdrawing sends an empty answer", async () => {
+    installAdapter([
+      get("/public/community/spaces/space-1/posts", () =>
+        page([feedPost(openPoll({ myVotes: [OPTION_A], resultsVisible: true, totalVoters: 1 }))]),
+      ),
+      post("/public/community/posts/post-1/poll/vote", () => openPoll()),
+    ]);
+    const { result } = renderHook(() => useFeedAndPoll(), { wrapper: wrapper() });
+    await waitFor(() => expect(result.current.poll.hasVoted).toBe(true));
+    await act(async () => {
+      await result.current.poll.withdraw();
+    });
+    expect(calls("post", "/public/community/posts/post-1/poll/vote")[0].body).toMatchObject({ optionIds: [] });
+    await waitFor(() => expect(result.current.first?.poll?.myVotes).toEqual([]));
+  });
+
+  it("a multiple-choice poll collects several options", async () => {
+    installAdapter([
+      get("/public/community/spaces/space-1/posts", () => page([feedPost(openPoll({ multipleChoice: true }))])),
+    ]);
+    const { result } = renderHook(() => useFeedAndPoll(), { wrapper: wrapper() });
+    await waitFor(() => expect(result.current.poll.poll?.multipleChoice).toBe(true));
+    act(() => result.current.poll.toggle(OPTION_A));
+    act(() => result.current.poll.toggle(OPTION_B));
+    expect(result.current.poll.selection).toEqual([OPTION_A, OPTION_B]);
+    act(() => result.current.poll.toggle(OPTION_A));
+    expect(result.current.poll.selection).toEqual([OPTION_B]);
+  });
+
+  it("a 409 reads as closed, and the feed keeps the old poll", async () => {
+    installAdapter([
+      get("/public/community/spaces/space-1/posts", () => page([feedPost(openPoll())])),
+      post("/public/community/posts/post-1/poll/vote", () => {
+        throw { status: 409, message: "This poll has closed." };
+      }),
+    ]);
+    const { result } = renderHook(() => useFeedAndPoll(), { wrapper: wrapper() });
+    await waitFor(() => expect(result.current.poll.poll).not.toBeNull());
+    act(() => result.current.poll.toggle(OPTION_A));
+    await act(async () => {
+      await result.current.poll.submit();
+    });
+    expect(result.current.poll.error).toBe("closed");
+    expect(result.current.first?.poll?.myVotes).toEqual([]);
+  });
+
+  it("a closed poll takes no vote", async () => {
+    installAdapter([
+      get("/public/community/spaces/space-1/posts", () => page([feedPost(openPoll({ closed: true }))])),
+    ]);
+    const { result } = renderHook(() => useFeedAndPoll(), { wrapper: wrapper() });
+    await waitFor(() => expect(result.current.poll.closed).toBe(true));
+    expect(result.current.poll.canVote).toBe(false);
+    expect(result.current.poll.choosing).toBe(false);
+    act(() => result.current.poll.toggle(OPTION_A));
+    expect(result.current.poll.selection).toEqual([]);
+  });
+});
+
+// ── Level locks ──────────────────────────────────────────────────────────────
+
+const space = (overrides: Record<string, unknown> = {}) => ({
+  id: "space-1",
+  profileId: "profile-1",
+  name: "Inner circle",
+  slug: "inner-circle",
+  description: null,
+  type: "feed",
+  courseId: null,
+  order: 0,
+  archivedAt: null,
+  createdAt: "2026-09-01T00:00:00.000Z",
+  tiers: [],
+  postCount: 3,
+  memberCount: 2,
+  isJoined: false,
+  minLevel: 1,
+  levelLocked: false,
+  ...overrides,
+});
+
+describe("useCommunitySpaceFeed and a level-locked space", () => {
+  it("is resolved from the list but its posts are never asked for", async () => {
+    installAdapter([get("/public/community/spaces", () => [space({ minLevel: 3, levelLocked: true })])]);
+    const { result } = renderHook(() => useCommunitySpaceFeed("inner-circle"), { wrapper: wrapper() });
+    await waitFor(() => expect(result.current.space?.id).toBe("space-1"));
+    expect(result.current.levelLocked).toBe(true);
+    expect(result.current.minLevel).toBe(3);
+    expect(calls("get", /\/posts$/)).toHaveLength(0);
+  });
+
+  it("an open space loads its posts", async () => {
+    installAdapter([
+      get("/public/community/spaces", () => [space()]),
+      get("/public/community/spaces/space-1/posts", () => page([])),
+    ]);
+    const { result } = renderHook(() => useCommunitySpaceFeed("space-1"), { wrapper: wrapper() });
+    await waitFor(() => expect(calls("get", "/public/community/spaces/space-1/posts")).toHaveLength(1));
+    expect(result.current.levelLocked).toBe(false);
+  });
+});
+
+describe("wikiUnlockParts", () => {
+  it("names the level, the tiers, or both", () => {
+    expect(wikiUnlockParts({ unlockLevel: 4, unlockTiers: [] })).toEqual({ level: 4, tiers: "" });
+    expect(wikiUnlockParts({ unlockLevel: 4, unlockTiers: [{ id: "t", name: "Gold" }] })).toEqual({
+      level: 4,
+      tiers: "Gold",
+    });
+    expect(wikiUnlockParts({ unlockLevel: null, unlockTiers: [{ id: "t", name: "Gold" }] })).toEqual({
+      level: null,
+      tiers: "Gold",
+    });
+    // An older server sends no unlockLevel at all.
+    expect(wikiUnlockParts({ unlockTiers: [] })).toEqual({ level: null, tiers: "" });
+  });
+});

package/src/ui/headless/_tests/memberHomeBar.spec.ts

@@ -0,0 +1,84 @@
+import { describe, expect, it } from "vitest";
+import { buildMemberHomeBar } from "../memberHome/memberHomeBar";
+import type { MemberHomeNavKey } from "../memberHome/useMemberHomeNav";
+
+/**
+ * The phone's bottom bar: four slots in a fixed priority (Feed, Spaces, Chat,
+ * Alerts), filled from the fallback order when one of those is not shown, then
+ * "More" with everything else, grouped. Every shown item is in exactly one
+ * place.
+ */
+
+const items = (...keys: MemberHomeNavKey[]) => keys.map((key) => ({ key }));
+const keys = (list: Array<{ key: MemberHomeNavKey }>) => list.map((i) => i.key);
+const ALL: MemberHomeNavKey[] = [
+  "posts",
+  "collections",
+  "spaces",
+  "calendar",
+  "classroom",
+  "chat",
+  "leaderboard",
+  "notifications",
+  "members",
+  "wiki",
+  "moderation",
+];
+
+describe("buildMemberHomeBar", () => {
+  it("everything shown: Feed, Spaces, Chat, Alerts in the bar; the rest grouped under More", () => {
+    const model = buildMemberHomeBar({ visibleItems: items(...ALL), activeKey: "posts" });
+    expect(keys(model.bar)).toEqual(["posts", "spaces", "chat", "notifications"]);
+    expect(model.more.map((g) => g.group)).toEqual(["community", "you"]);
+    expect(keys(model.more[0]!.items)).toEqual(["collections", "calendar", "classroom", "wiki", "members", "leaderboard"]);
+    expect(keys(model.more[1]!.items)).toEqual(["moderation"]);
+    expect(model.moreActive).toBe(false);
+  });
+
+  it("no chat: the next item in the fallback order (calendar) takes its slot", () => {
+    const visible = items("posts", "spaces", "calendar", "classroom", "notifications", "members");
+    const model = buildMemberHomeBar({ visibleItems: visible, activeKey: null });
+    expect(keys(model.bar)).toEqual(["posts", "spaces", "notifications", "calendar"]);
+    expect(keys(model.more[0]!.items)).toEqual(["classroom", "members"]);
+  });
+
+  it("no spaces (so no alerts either): calendar, classroom fill in, in that order", () => {
+    const model = buildMemberHomeBar({ visibleItems: items("posts", "chat", "calendar", "classroom", "members", "wiki"), activeKey: null });
+    expect(keys(model.bar)).toEqual(["posts", "chat", "calendar", "classroom"]);
+    expect(keys(model.more[0]!.items)).toEqual(["wiki", "members"]);
+  });
+
+  it("the fallback reaches collections, leaderboard and moderation only when nothing ahead is shown", () => {
+    const model = buildMemberHomeBar({ visibleItems: items("posts", "collections", "moderation"), activeKey: null });
+    expect(keys(model.bar)).toEqual(["posts", "collections", "moderation"]);
+    expect(model.more).toEqual([]);
+  });
+
+  it("the active page under More highlights More, not a bar item", () => {
+    const model = buildMemberHomeBar({ visibleItems: items(...ALL), activeKey: "wiki" });
+    expect(model.moreActive).toBe(true);
+    expect(buildMemberHomeBar({ visibleItems: items(...ALL), activeKey: "chat" }).moreActive).toBe(false);
+    expect(buildMemberHomeBar({ visibleItems: items(...ALL), activeKey: "moderation" }).moreActive).toBe(true);
+  });
+
+  it("an active key that is not shown highlights nothing", () => {
+    const model = buildMemberHomeBar({ visibleItems: items("posts", "spaces"), activeKey: "wiki" });
+    expect(model.moreActive).toBe(false);
+  });
+
+  it("every shown item is in exactly one place, and nothing hidden appears", () => {
+    for (let n = 1; n <= ALL.length; n++) {
+      const visible = items(...ALL.slice(0, n));
+      const model = buildMemberHomeBar({ visibleItems: visible, activeKey: null });
+      const placed = [...keys(model.bar), ...model.more.flatMap((g) => keys(g.items))];
+      expect(placed.sort()).toEqual(keys(visible).sort());
+      expect(model.bar.length).toBeLessThanOrEqual(4);
+    }
+  });
+
+  it("keeps the caller's item objects, so hrefs and active flags pass through", () => {
+    const posts = { key: "posts" as const, href: "/i/communities/x/home", active: true };
+    const model = buildMemberHomeBar({ visibleItems: [posts], activeKey: "posts" });
+    expect(model.bar[0]).toBe(posts);
+  });
+});

package/src/ui/headless/_tests/siteAppBar.spec.ts

@@ -0,0 +1,83 @@
+import { describe, expect, it } from "vitest";
+import { APP_BAR_HREFS, buildAppBar, isAppBarItemActive, normaliseBarItems } from "../siteApp/appBar";
+import { SITE_APP_BAR_KEYS } from "../../../data/queries/useSiteApp";
+
+/**
+ * The site app's bottom bar model: Home first, the creator's items (at most
+ * three) after it, More last, and every other destination behind More.
+ */
+
+const keys = (items: Array<{ key: string }>) => items.map((item) => item.key);
+
+describe("buildAppBar", () => {
+  it("puts Home first, then the configured items in their order, and the rest behind More", () => {
+    const model = buildAppBar({ barItems: ["shop", "events"], homeHref: "/i/app" });
+    expect(keys(model.bar)).toEqual(["home", "shop", "events"]);
+    // The sheet keeps the canonical order, not the configured one.
+    expect(keys(model.more)).toEqual(["communities", "portal", "inbox", "courses"]);
+  });
+
+  it("uses the contract's default bar when nothing is configured", () => {
+    for (const barItems of [undefined, null, []]) {
+      const model = buildAppBar({ barItems, homeHref: "/i/app" });
+      expect(keys(model.bar)).toEqual(["home", "communities", "portal", "inbox"]);
+      expect(keys(model.more)).toEqual(["events", "courses", "shop"]);
+    }
+  });
+
+  it("drops unknown keys and repeats and holds at most three items", () => {
+    const model = buildAppBar({
+      barItems: ["inbox", "nope", "inbox", "courses", "home", "shop", "events"],
+      homeHref: "/i/app",
+    });
+    expect(keys(model.bar)).toEqual(["home", "inbox", "courses", "shop"]);
+    expect(normaliseBarItems(["events", "events", "bogus"])).toEqual(["events"]);
+  });
+
+  it("lists every destination exactly once, in the bar or in More", () => {
+    for (const barItems of [["communities"], ["portal", "inbox", "events"], ["shop", "courses", "communities"]]) {
+      const model = buildAppBar({ barItems, homeHref: "/i/app" });
+      const all = [...keys(model.bar), ...keys(model.more)];
+      expect(all.sort()).toEqual(["home", ...SITE_APP_BAR_KEYS].sort());
+    }
+  });
+
+  it("links each destination to its page, and Home to the Home it is given", () => {
+    const model = buildAppBar({ barItems: ["inbox"], homeHref: "/members" });
+    expect(model.bar[0]).toMatchObject({ key: "home", href: "/members" });
+    expect(model.bar[1]).toMatchObject({ key: "inbox", href: "/i/account/notifications" });
+    expect(APP_BAR_HREFS).toEqual({
+      communities: "/i/communities",
+      portal: "/i/account",
+      inbox: "/i/account/notifications",
+      events: "/i/events",
+      courses: "/i/courses",
+      shop: "/i/store",
+    });
+  });
+
+  it("highlights the page being shown, and More when that page lives in the sheet", () => {
+    const onEvents = buildAppBar({ barItems: ["events"], homeHref: "/i/app", currentPath: "/i/events/summit" });
+    expect(onEvents.bar.find((item) => item.key === "events")?.active).toBe(true);
+    expect(onEvents.moreActive).toBe(false);
+
+    const inSheet = buildAppBar({ barItems: ["communities"], homeHref: "/i/app", currentPath: "/i/store/tee?x=1" });
+    expect(inSheet.more.find((item) => item.key === "shop")?.active).toBe(true);
+    expect(inSheet.moreActive).toBe(true);
+
+    const home = buildAppBar({ barItems: [], homeHref: "/i/app", currentPath: "/i/app/" });
+    expect(home.bar[0]!.active).toBe(true);
+  });
+
+  it("does not let the portal claim the inbox, which lives under it", () => {
+    expect(isAppBarItemActive("portal", "/i/account", "/i/account/notifications")).toBe(false);
+    expect(isAppBarItemActive("inbox", "/i/account/notifications", "/i/account/notifications")).toBe(true);
+    expect(isAppBarItemActive("portal", "/i/account", "/i/account/invoices")).toBe(true);
+  });
+
+  it("matches Home exactly, so a custom Home at the root does not light up on every page", () => {
+    expect(isAppBarItemActive("home", "/", "/i/events")).toBe(false);
+    expect(isAppBarItemActive("home", "/", "/")).toBe(true);
+    expect(isAppBarItemActive("events", "/i/events", "/i/eventsx")).toBe(false);
+  });
+});

package/src/ui/headless/_tests/siteAppHarness.ts

@@ -0,0 +1,19 @@
+import type { SiteApp } from "../../../data/queries/useSiteApp";
+
+/** The public site app settings (`GET /public/websites/app`), as the contract shapes them. */
+export const siteApp = (patch: Partial<SiteApp> = {}): SiteApp => ({
+  websiteId: "website-1",
+  profileId: "profile-1",
+  appName: "Northlight",
+  shortName: "Northlight",
+  iconUrl: null,
+  themeColor: null,
+  backgroundColor: null,
+  startUrl: "/i/app",
+  homeSections: [{ type: "builtin", key: "portal", visible: true }],
+  barItems: ["communities", "portal", "inbox"],
+  installPrompt: true,
+  pushPrompt: true,
+  activeVersionId: null,
+  ...patch,
+});