create-ailk 0.20.0 → 0.22.0

package/templates/apps/web/app/[locale]/(authed)/account/__tests__/agreements-prompt.test.tsx

@@ -1,281 +1,301 @@
 /**
- * Tests for AgreementsPrompt (#8438 D13) and the carried-agreement cookie
- * `acceptCarriedAgreementsAction` consumes — exercised here because this
- * prompt is its one caller.
+ * Tests for AgreementsInterstitial (#8765 D7, AC-2, AC-4, AC-5) — the
+ * full-page sign-up-agreement ask the account layout renders in place of the
+ * account, and its Server Action `acceptAccountAgreementsAction`.
  */
-import { fireEvent, render, screen, waitFor } from "@testing-library/react";
-
+import { consentStatementText } from "@working-theory/ui/blocks";
+import { CONTACT_FORM_TERMS_STATEMENT } from "@working-theory/validation";
+import {
+  fireEvent,
+  render,
+  screen,
+  waitFor,
+  within,
+} from "@testing-library/react";
+
+const mockPush = jest.fn();
 const mockRefresh = jest.fn();
 jest.mock("next/navigation", () => ({
   __esModule: true,
-  useRouter: () => ({ refresh: mockRefresh }),
+  useRouter: () => ({ push: mockPush, refresh: mockRefresh }),
+  usePathname: () => "/account",
+  useSearchParams: () => new URLSearchParams(""),
 }));
 
-const mockAcceptCarried = jest.fn();
-// eslint-disable-next-line no-restricted-syntax -- test-seam mock: the Server Action module is a "use server" boundary; the component only passes it through.
-jest.mock("../agreements-actions", () => ({
+const mockSignOut = jest.fn();
+jest.mock("better-auth/react", () => ({
   __esModule: true,
-  acceptCarriedAgreementsAction: (...args: unknown[]) => mockAcceptCarried(...args),
+  createAuthClient: () => ({
+    signOut: (...args: unknown[]) => mockSignOut(...args),
+  }),
 }));
 
-const mockSetConsent = jest.fn();
+const mockAcceptAction = jest.fn();
 // eslint-disable-next-line no-restricted-syntax -- test-seam mock: the Server Action module is a "use server" boundary; the component only passes it through.
-jest.mock("../privacy/actions", () => ({
+jest.mock("../agreements-actions", () => ({
   __esModule: true,
-  setConsentAction: (...args: unknown[]) => mockSetConsent(...args),
+  acceptAccountAgreementsAction: (...args: unknown[]) =>
+    mockAcceptAction(...args),
 }));
 
-import { AgreementsPrompt, type MissingAgreement } from "../agreements-prompt";
+import { consentPoliciesFor } from "../../../../../lib/consent-policies";
+import {
+  AgreementsInterstitial,
+  type AgreementsInterstitialAgreement,
+} from "../agreements-prompt";
 
 const LABELS = {
   titleNew: "Please accept our terms",
   titleUpdated: "We've updated our terms",
+  lead: "To keep using your account, accept the agreements below.",
   accept: "Accept",
+  signOut: "Sign out",
   error: "We couldn't save that. Try again.",
-  policyLink: "Read our privacy policy",
+  signOutFailed: "We couldn't sign you out. Try again.",
 };
 
-const AGREEMENT: MissingAgreement = {
+const AGREEMENT: AgreementsInterstitialAgreement = {
   id: "account_terms",
-  statement: "You agree to our Terms and Privacy Policy.",
-  policyHref: "/terms",
-  version: 1,
-  hadPriorGrant: false,
+  statement: CONTACT_FORM_TERMS_STATEMENT,
+  acceptedVersion: null,
 };
 
+function renderInterstitial(
+  agreements: AgreementsInterstitialAgreement[] = [AGREEMENT],
+  locale = "en",
+  extra: { signOutEndpoint?: string; signInHref?: string } = {},
+): void {
+  render(
+    <AgreementsInterstitial
+      locale={locale}
+      agreements={agreements}
+      labels={LABELS}
+      {...extra}
+    />,
+  );
+}
+
+const fetchMock = jest.fn();
+const ORIGINAL_FETCH = globalThis.fetch;
+
 beforeEach(() => {
+  mockPush.mockReset();
   mockRefresh.mockReset();
-  mockAcceptCarried.mockReset();
-  mockSetConsent.mockReset();
+  mockSignOut.mockReset().mockResolvedValue({ data: {}, error: null });
+  mockAcceptAction.mockReset();
+  fetchMock.mockReset();
+  globalThis.fetch = fetchMock;
 });
 
-describe("AgreementsPrompt — with nothing missing", () => {
-  it("renders nothing and calls nothing", () => {
-    render(<AgreementsPrompt missing={[]} labels={LABELS} />);
-    expect(screen.queryByTestId("account-agreements-prompt")).not.toBeInTheDocument();
-    expect(mockAcceptCarried).not.toHaveBeenCalled();
-  });
+afterAll(() => {
+  globalThis.fetch = ORIGINAL_FETCH;
 });
 
-describe("AgreementsPrompt — the carried-cookie fast path (D13)", () => {
-  it("tries it once on mount, with every missing id", async () => {
-    mockAcceptCarried.mockResolvedValue({ accepted: false });
-    render(<AgreementsPrompt missing={[AGREEMENT]} labels={LABELS} />);
-    await waitFor(() => expect(mockAcceptCarried).toHaveBeenCalledWith(["account_terms"]));
-    expect(mockAcceptCarried).toHaveBeenCalledTimes(1);
+describe("AgreementsInterstitial — the page (D7)", () => {
+  it("renders one h1 — 'Please accept our terms' when nothing was accepted before — and the lead", () => {
+    renderInterstitial();
+    const page = screen.getByTestId("account-agreements-interstitial");
+    const headings = within(page).getAllByRole("heading", { level: 1 });
+    expect(headings).toHaveLength(1);
+    expect(headings[0]).toHaveTextContent("Please accept our terms");
+    expect(page).toHaveTextContent(
+      "To keep using your account, accept the agreements below.",
+    );
   });
 
-  it("on accept, hides and refreshes — the card never shows", async () => {
-    mockAcceptCarried.mockResolvedValue({ accepted: true });
-    render(<AgreementsPrompt missing={[AGREEMENT]} labels={LABELS} />);
-    await waitFor(() => expect(mockRefresh).toHaveBeenCalledTimes(1));
-    expect(screen.queryByTestId("account-agreements-prompt")).not.toBeInTheDocument();
+  it("reads 'We've updated our terms' when any entry has an accepted version (AC-4)", () => {
+    renderInterstitial([{ ...AGREEMENT, acceptedVersion: 1 }]);
+    expect(screen.getByRole("heading", { level: 1 })).toHaveTextContent(
+      "We've updated our terms",
+    );
   });
 
-  it("on a failed check, shows the card with the statement and policy link", async () => {
-    mockAcceptCarried.mockResolvedValue({ accepted: false });
-    render(<AgreementsPrompt missing={[AGREEMENT]} labels={LABELS} />);
-    expect(await screen.findByTestId("account-agreements-prompt")).toBeInTheDocument();
-    expect(screen.getByText("Please accept our terms")).toBeInTheDocument();
-    expect(screen.getByText("You agree to our Terms and Privacy Policy.")).toBeInTheDocument();
-    expect(screen.getByTestId("account-agreements-prompt-account_terms-policy")).toHaveAttribute(
-      "href",
-      "/terms",
+  it("draws no element of the retired Inbox card", () => {
+    renderInterstitial();
+    expect(
+      screen.queryByTestId("account-agreements-prompt"),
+    ).not.toBeInTheDocument();
+    expect(
+      document.querySelector(
+        '[data-testid^="account-agreements-prompt-"][data-testid$="-policy"]',
+      ),
+    ).toBeNull();
+  });
+});
+
+describe("AgreementsInterstitial — the statement renders with its links (AC-5, #8761)", () => {
+  it.each(["en", "fr"])(
+    "%s: the text is the Contact sentence with no markdown, and three labelled links to consentPoliciesFor(locale)",
+    (locale) => {
+      renderInterstitial([AGREEMENT], locale);
+      const statement = screen.getByTestId(
+        "account-agreements-statement-account_terms",
+      );
+      expect(statement.textContent).toBe(
+        consentStatementText(CONTACT_FORM_TERMS_STATEMENT),
+      );
+      expect(statement.textContent).not.toContain("[");
+      expect(statement.textContent).not.toContain("](");
+
+      const policies = consentPoliciesFor(locale);
+      const links = (
+        [
+          ["terms", "Terms"],
+          ["privacy", "Privacy Policy"],
+          ["working_agreement", "Working Agreement"],
+        ] as const
+      ).map(([key, label]) => {
+        const link = within(statement).getByTestId(
+          `consent-policy-link-${key}`,
+        );
+        return [
+          link.textContent,
+          link.getAttribute("href"),
+          label,
+          policies[key],
+        ];
+      });
+      for (const [text, href, label, expected] of links) {
+        expect(text).toBe(label);
+        expect(href).toBe(expected);
+      }
+    },
+  );
+});
+
+describe("AgreementsInterstitial — Accept (AC-2)", () => {
+  it("is a 44px button that calls the action once with every id, then refreshes", async () => {
+    mockAcceptAction.mockResolvedValue({ ok: true });
+    renderInterstitial();
+    const accept = screen.getByTestId("account-agreements-accept");
+    expect(accept).toHaveTextContent("Accept");
+    expect(accept.className).toContain("min-h-(--control-height-big)");
+    fireEvent.click(accept);
+    await waitFor(() => expect(mockRefresh).toHaveBeenCalledTimes(1));
+    expect(mockAcceptAction).toHaveBeenCalledTimes(1);
+    expect(mockAcceptAction).toHaveBeenCalledWith(["account_terms"]);
+    expect(mockAcceptAction.mock.invocationCallOrder[0]).toBeLessThan(
+      mockRefresh.mock.invocationCallOrder[0]!,
     );
   });
 
-  it("shows the 'updated' title when any missing agreement had a prior grant", async () => {
-    mockAcceptCarried.mockResolvedValue({ accepted: false });
-    render(<AgreementsPrompt missing={[{ ...AGREEMENT, hadPriorGrant: true }]} labels={LABELS} />);
-    expect(await screen.findByText("We've updated our terms")).toBeInTheDocument();
+  it("a refused write shows the error line and does not refresh", async () => {
+    mockAcceptAction.mockResolvedValue({ ok: false });
+    renderInterstitial();
+    fireEvent.click(screen.getByTestId("account-agreements-accept"));
+    expect(
+      await screen.findByTestId("account-agreements-error"),
+    ).toHaveTextContent("We couldn't save that. Try again.");
+    expect(mockRefresh).not.toHaveBeenCalled();
+    expect(screen.getByTestId("account-agreements-accept")).not.toBeDisabled();
   });
 
-  it("a rejected check still shows the card, rather than throwing", async () => {
-    mockAcceptCarried.mockRejectedValue(new Error("down"));
-    render(<AgreementsPrompt missing={[AGREEMENT]} labels={LABELS} />);
-    expect(await screen.findByTestId("account-agreements-prompt")).toBeInTheDocument();
+  it("a thrown write shows the error line too", async () => {
+    mockAcceptAction.mockRejectedValue(new Error("down"));
+    renderInterstitial();
+    fireEvent.click(screen.getByTestId("account-agreements-accept"));
+    expect(
+      await screen.findByTestId("account-agreements-error"),
+    ).toBeInTheDocument();
+    expect(mockRefresh).not.toHaveBeenCalled();
   });
 });
 
-describe("AgreementsPrompt — the explicit Accept button", () => {
-  async function showCard(): Promise<void> {
-    mockAcceptCarried.mockResolvedValue({ accepted: false });
-    render(<AgreementsPrompt missing={[AGREEMENT]} labels={LABELS} />);
-    await screen.findByTestId("account-agreements-prompt");
-  }
+describe("AgreementsInterstitial — Sign out (D7, the frame's own logic)", () => {
+  it("is a ghost button; without an endpoint it signs out through Better Auth and goes home", async () => {
+    renderInterstitial();
+    const signOut = screen.getByTestId("account-agreements-sign-out");
+    expect(signOut).toHaveTextContent("Sign out");
+    fireEvent.click(signOut);
+    await waitFor(() => expect(mockPush).toHaveBeenCalledWith("/"));
+    expect(mockSignOut).toHaveBeenCalledTimes(1);
+    expect(mockRefresh).toHaveBeenCalledTimes(1);
+    expect(mockAcceptAction).not.toHaveBeenCalled();
+  });
 
-  it("posts every missing id through setConsentAction, then refreshes", async () => {
-    mockSetConsent.mockResolvedValue({ ok: true, dateLine: "Given Oct 12, 2026" });
-    await showCard();
-    fireEvent.click(screen.getByTestId("account-agreements-prompt-accept"));
-    await waitFor(() => expect(mockSetConsent).toHaveBeenCalledWith("account_terms", true));
-    await waitFor(() => expect(mockRefresh).toHaveBeenCalledTimes(1));
+  it("with a hub endpoint it POSTs it and lands on the sign-in page", async () => {
+    fetchMock.mockResolvedValue({ ok: true });
+    renderInterstitial([AGREEMENT], "fr", {
+      signOutEndpoint: "/api/hub-session/sign-out",
+      signInHref: "/fr/account",
+    });
+    fireEvent.click(screen.getByTestId("account-agreements-sign-out"));
+    await waitFor(() => expect(mockPush).toHaveBeenCalledWith("/fr/account"));
+    expect(fetchMock).toHaveBeenCalledWith("/api/hub-session/sign-out", {
+      method: "POST",
+      credentials: "same-origin",
+    });
+    expect(mockSignOut).not.toHaveBeenCalled();
   });
 
-  it("a failed answer shows the error and keeps the card", async () => {
-    mockSetConsent.mockResolvedValue({ ok: false, message: "nope" });
-    await showCard();
-    fireEvent.click(screen.getByTestId("account-agreements-prompt-accept"));
-    expect(await screen.findByTestId("account-agreements-prompt-error")).toHaveTextContent(
-      "We couldn't save that. Try again.",
-    );
-    expect(screen.getByTestId("account-agreements-prompt")).toBeInTheDocument();
-    expect(mockRefresh).not.toHaveBeenCalled();
+  it("a refused hub sign-out stays and says so", async () => {
+    fetchMock.mockResolvedValue({ ok: false, status: 403 });
+    renderInterstitial([AGREEMENT], "en", {
+      signOutEndpoint: "/api/hub-session/sign-out",
+    });
+    fireEvent.click(screen.getByTestId("account-agreements-sign-out"));
+    expect(
+      await screen.findByTestId("account-sign-out-error"),
+    ).toHaveTextContent("We couldn't sign you out. Try again.");
+    expect(mockPush).not.toHaveBeenCalled();
   });
 });
 
-// ── acceptCarriedAgreementsAction's own cookie checks (D13 C6) ────────────────
-//
-// The real action, loaded past the mock above — exercising the HMAC, the
-// one-hour window and the email-hash binding with real `node:crypto`.
+// ── acceptAccountAgreementsAction — the real module ───────────────────────────
 
-// eslint-disable-next-line no-restricted-syntax -- #507: the topology is a generated constant (#7426 D5), not a runtime input; the seam IS the boundary between a hub and a spoke build, and there is no env or HTTP surface that selects it.
-jest.mock("../../../../../lib/topology.generated", () => ({
+const mockAcceptAccountAgreements = jest.fn();
+jest.mock("@working-theory/api-client", () => ({
   __esModule: true,
-  readSession: jest.fn(),
+  consent: {
+    acceptAccountAgreements: (...args: unknown[]) =>
+      mockAcceptAccountAgreements(...args),
+  },
 }));
 
-const mockMemberSetConsent = jest.fn();
-jest.mock("@working-theory/api-client", () => ({
+jest.mock("next-intl/server", () => ({
   __esModule: true,
-  member: { setConsent: (...args: unknown[]) => mockMemberSetConsent(...args) },
+  getLocale: jest.fn().mockResolvedValue("fr"),
 }));
 
-const mockCookieGet = jest.fn();
-const mockCookieDelete = jest.fn();
 jest.mock("next/headers", () => ({
   __esModule: true,
-  cookies: jest.fn().mockResolvedValue({
-    get: (...args: unknown[]) => mockCookieGet(...args),
-    delete: (...args: unknown[]) => mockCookieDelete(...args),
-    toString: () => "",
-  }),
+  cookies: jest.fn().mockResolvedValue({ toString: () => "session=abc" }),
   headers: jest.fn().mockResolvedValue(new Headers()),
 }));
 
-describe("acceptCarriedAgreementsAction (the real module, D13 C6)", () => {
-  const COOKIE_NAME = "ailk-signup-agreements"; // NODE_ENV !== "production" in jest
-  const EMAIL = "ada@example.com";
-
-  async function remember(email: string, purposeIds: string[]): Promise<string | undefined> {
-    const { rememberSignUpAgreementsAction } = jest.requireActual(
-      "../../../(auth)/sign-up/sign-up.actions",
-    ) as typeof import("../../../(auth)/sign-up/sign-up.actions");
-    await rememberSignUpAgreementsAction(email, purposeIds);
-    expect(mockCookieSet).toHaveBeenCalledTimes(1);
-    return mockCookieSet.mock.calls[0]?.[1] as string | undefined;
-  }
-
-  const mockCookieSet = jest.fn();
-
-  beforeEach(() => {
-    mockCookieGet.mockReset();
-    mockCookieDelete.mockReset();
-    mockCookieSet.mockReset();
-    mockMemberSetConsent.mockReset().mockResolvedValue({ ok: true, body: { purpose: {} } });
-    (jest.requireMock("../../../../../lib/topology.generated") as { readSession: jest.Mock }).readSession.mockReset();
-  });
-
-  // Minting goes through `cookies().set`, which the outer `cookies()` mock
-  // does not define — reassign it per test so `remember()` can capture the
-  // value, without disturbing the delete-tracking mock the "real action"
-  // suite shares.
-  beforeEach(() => {
-    const headersModule = jest.requireMock("next/headers") as {
-      cookies: jest.Mock;
-    };
-    headersModule.cookies.mockResolvedValue({
-      get: (...args: unknown[]) => mockCookieGet(...args),
-      set: (...args: unknown[]) => mockCookieSet(...args),
-      delete: (...args: unknown[]) => mockCookieDelete(...args),
-      toString: () => "",
-    });
-  });
-
-  async function accept(missingPurposeIds: string[]) {
-    const { acceptCarriedAgreementsAction } = jest.requireActual(
+describe("acceptAccountAgreementsAction (the real module, D7)", () => {
+  async function accept(purposeIds: string[]): Promise<{ ok: boolean }> {
+    const { acceptAccountAgreementsAction } = jest.requireActual(
       "../agreements-actions",
     ) as typeof import("../agreements-actions");
-    return acceptCarriedAgreementsAction(missingPurposeIds);
+    return acceptAccountAgreementsAction(purposeIds);
   }
 
-  it("a valid, fresh cookie whose email matches writes every missing purpose with via sign_up, then deletes the cookie", async () => {
-    const value = await remember(EMAIL, ["account_terms"]);
-    mockCookieGet.mockReturnValue({ value });
-    (jest.requireMock("../../../../../lib/topology.generated") as { readSession: jest.Mock }).readSession.mockResolvedValue({
-      user: { email: EMAIL, emailVerified: true },
-    });
-
-    const result = await accept(["account_terms"]);
-    expect(result).toEqual({ accepted: true });
-    expect(mockMemberSetConsent).toHaveBeenCalledWith(
-      { purposeId: "account_terms", granted: true, via: "sign_up" },
-      expect.anything(),
-    );
-    expect(mockCookieDelete).toHaveBeenCalledWith(COOKIE_NAME);
-  });
+  beforeEach(() => mockAcceptAccountAgreements.mockReset());
 
-  it("a flipped character in the cookie fails the HMAC — posts nothing, deletes it, not accepted", async () => {
-    const value = await remember(EMAIL, ["account_terms"]);
-    const tampered = `${value?.slice(0, -1)}${value?.slice(-1) === "0" ? "1" : "0"}`;
-    mockCookieGet.mockReturnValue({ value: tampered });
-
-    const result = await accept(["account_terms"]);
-    expect(result).toEqual({ accepted: false });
-    expect(mockMemberSetConsent).not.toHaveBeenCalled();
-    expect(mockCookieDelete).toHaveBeenCalledWith(COOKIE_NAME);
-  });
-
-  it("another email's hash is refused, even with a verified session", async () => {
-    const value = await remember("someone-else@example.com", ["account_terms"]);
-    mockCookieGet.mockReturnValue({ value });
-    (jest.requireMock("../../../../../lib/topology.generated") as { readSession: jest.Mock }).readSession.mockResolvedValue({
-      user: { email: EMAIL, emailVerified: true },
-    });
-
-    const result = await accept(["account_terms"]);
-    expect(result).toEqual({ accepted: false });
-    expect(mockMemberSetConsent).not.toHaveBeenCalled();
-  });
-
-  it("an unverified session email is refused even when the hash would match", async () => {
-    const value = await remember(EMAIL, ["account_terms"]);
-    mockCookieGet.mockReturnValue({ value });
-    (jest.requireMock("../../../../../lib/topology.generated") as { readSession: jest.Mock }).readSession.mockResolvedValue({
-      user: { email: EMAIL, emailVerified: false },
+  it("posts the ids and the request's locale with the forwarded cookie, and answers ok", async () => {
+    mockAcceptAccountAgreements.mockResolvedValue({
+      ok: true,
+      body: { agreements: [], complete: true },
     });
-
-    const result = await accept(["account_terms"]);
-    expect(result).toEqual({ accepted: false });
+    await expect(accept(["account_terms"])).resolves.toEqual({ ok: true });
+    expect(mockAcceptAccountAgreements).toHaveBeenCalledWith(
+      { purposeIds: ["account_terms"], locale: "fr" },
+      { headers: { cookie: "session=abc" } },
+    );
   });
 
-  it("a cookie that does not cover every missing id is refused", async () => {
-    const value = await remember(EMAIL, ["account_terms"]);
-    mockCookieGet.mockReturnValue({ value });
-    (jest.requireMock("../../../../../lib/topology.generated") as { readSession: jest.Mock }).readSession.mockResolvedValue({
-      user: { email: EMAIL, emailVerified: true },
+  it("a refusal answers ok: false", async () => {
+    mockAcceptAccountAgreements.mockResolvedValue({
+      ok: false,
+      status: 404,
+      body: null,
     });
-
-    const result = await accept(["account_terms", "another_agreement"]);
-    expect(result).toEqual({ accepted: false });
-    expect(mockMemberSetConsent).not.toHaveBeenCalled();
-  });
-
-  it("an issuedAt more than an hour old is refused", async () => {
-    jest.useFakeTimers().setSystemTime(new Date("2026-10-12T00:00:00.000Z"));
-    const value = await remember(EMAIL, ["account_terms"]);
-    jest.setSystemTime(new Date("2026-10-12T01:00:01.000Z"));
-    mockCookieGet.mockReturnValue({ value });
-
-    const result = await accept(["account_terms"]);
-    expect(result).toEqual({ accepted: false });
-    jest.useRealTimers();
+    await expect(accept(["account_terms"])).resolves.toEqual({ ok: false });
   });
 
-  it("no cookie present is refused, with no delete call", async () => {
-    mockCookieGet.mockReturnValue(undefined);
-    const result = await accept(["account_terms"]);
-    expect(result).toEqual({ accepted: false });
-    expect(mockCookieDelete).not.toHaveBeenCalled();
+  it("a thrown post answers ok: false, never a throw", async () => {
+    mockAcceptAccountAgreements.mockRejectedValue(new Error("network"));
+    await expect(accept(["account_terms"])).resolves.toEqual({ ok: false });
   });
 });

package/templates/apps/web/app/[locale]/(authed)/account/__tests__/layout-sign-out.test.tsx

@@ -36,7 +36,12 @@ jest.mock("../../../../../lib/topology.generated", () => ({
 jest.mock("../account-data", () => ({
   __esModule: true,
   accountSession: async () => ({
-    ctx: { user: { name: "Ada", email: "ada@example.com" }, t: {} },
+    ctx: {
+      locale: "en",
+      user: { name: "Ada", email: "ada@example.com" },
+      t: {},
+      init: { headers: {} },
+    },
   }),
   loadForYou: async () => ({ items: [], now: "2026-10-12T00:00:00.000Z" }),
 }));
@@ -52,6 +57,17 @@ jest.mock("../../../../../lib/site-logo", () => ({
   siteLogo: () => null,
 }));
 
+// #8765 D7 — the layout's agreements read: complete, so the frame renders.
+jest.mock("@working-theory/api-client", () => ({
+  __esModule: true,
+  consent: {
+    accountAgreements: async () => ({
+      ok: true,
+      body: { agreements: [], complete: true },
+    }),
+  },
+}));
+
 const mockFrame = jest.fn();
 // eslint-disable-next-line no-restricted-syntax -- #507: test-seam mock; the layout under test composes these account modules and the suite asserts only the sign-out endpoint it forwards
 jest.mock("../account-frame", () => ({