create-ailk 0.18.0 → 0.19.0

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

@@ -1,12 +1,16 @@
 /**
  * Tests for the account layout — the base area's SignedInShell frame
- * (#7430, spec 7423 U4 · D13; the U4 half of AC-17).
+ * (#7430, spec 7423 U4 · D13; the U4 half of AC-17; #8231 D1).
  *
  * Covers:
- *   1. The rail: the site logo as the top tile (a link home), Inbox as its
- *      only row, a footer of the avatar and ? only.
+ *   1. The rail: the site logo as the top tile (a link home), then Inbox and
+ *      a Library group holding Artifacts — each selected on its own paths,
+ *      no row on a Settings page — and a footer of the avatar and ? only.
+ *      No Settings row (#8334: Settings lives in the avatar menu, as on the
+ *      Admin).
  *   2. The avatar opens the card menu (name, then Settings and Log out side
- *      by side); Log out signs out and routes home.
+ *      by side); Settings is the one route to /account/general; Log out
+ *      signs out and routes home.
  *   3. ? opens Contact support (→ /account/support) and, only when the site
  *      configures a help URL, Help center.
  *   4. Below md the tab bar reads avatar · Inbox · For you · Help, with no
@@ -55,13 +59,19 @@ jest.mock("../../../../../auth", () => ({
   auth: { api: { getSession: (...args: unknown[]) => mockGetSession(...args) } },
 }));
 
-const mockCheckoutsMe = jest.fn();
 const mockSubscriptionMe = jest.fn();
+// #8231 D7 — the member reads call on every topology; here every one 404s.
+const mockMemberNotFound = jest.fn();
 jest.mock("@working-theory/api-client", () => ({
   __esModule: true,
   waitlistSignups: { me: jest.fn() },
-  flowCheckouts: { me: (...args: unknown[]) => mockCheckoutsMe(...args) },
   subscription: { me: (...args: unknown[]) => mockSubscriptionMe(...args) },
+  member: {
+    pieces: (...args: unknown[]) => mockMemberNotFound(...args),
+    messages: (...args: unknown[]) => mockMemberNotFound(...args),
+    purchases: (...args: unknown[]) => mockMemberNotFound(...args),
+    appointments: (...args: unknown[]) => mockMemberNotFound(...args),
+  },
 }));
 
 const mockSignOut = jest.fn();
@@ -139,8 +149,8 @@ beforeEach(() => {
   mockSearch = "";
   delete process.env.AILK_HELP_CENTER_URL;
   mockGetSession.mockReset().mockResolvedValue(SESSION);
-  mockCheckoutsMe.mockReset().mockResolvedValue({ ok: true, body: [] });
   mockSubscriptionMe.mockReset().mockResolvedValue(NO_SUBSCRIPTION);
+  mockMemberNotFound.mockReset().mockResolvedValue({ ok: false, status: 404, body: null });
   mockSignOut.mockReset().mockResolvedValue({ data: {}, error: null });
   mockPush.mockReset();
   mockRefresh.mockReset();
@@ -167,16 +177,69 @@ describe("the account rail (D13, AC-17)", () => {
     expect(within(rail).getByTestId("account-site-logo")).toHaveAttribute("href", "/fr/");
   });
 
-  it("Inbox is the rail's only row, selected on /account and on an item page", async () => {
-    await renderLayout();
-    const rail = screen.getByTestId("sidebar-desktop");
-    const links = within(rail)
+  /** The rail's rows, in DOM order — every link but the logo. */
+  function railRows(): HTMLElement[] {
+    return within(screen.getByTestId("sidebar-desktop"))
       .getAllByRole("link")
       .filter((link) => link.getAttribute("data-testid") !== "account-site-logo");
-    expect(links).toHaveLength(1);
-    expect(links[0]).toHaveTextContent("Inbox");
-    expect(links[0]).toHaveAttribute("href", "/account");
-    expect(links[0]).toHaveAttribute("aria-current", "page");
+  }
+
+  it("the rows are Inbox, then Artifacts under Library — no Settings row (#8231 D1, #8334)", async () => {
+    await renderLayout();
+    const rows = railRows();
+    expect(rows.map((row) => [row.textContent, row.getAttribute("href")])).toEqual([
+      ["Inbox", "/account"],
+      ["Artifacts", "/account/artifacts"],
+    ]);
+    expect(rows[0]).toHaveAttribute("aria-current", "page");
+    // Artifacts sits in the Library group.
+    const heading = screen.getByTestId("sidebar-group-heading-library");
+    expect(heading).toHaveTextContent("Library");
+    const library = heading.parentElement as HTMLElement;
+    expect(within(library).getByText("Artifacts")).toBeInTheDocument();
+    // #8334 — Settings is nowhere in the rail, at any viewport: not a row, not
+    // a tab. The avatar menu is its one route (the next describe).
+    expect(within(screen.getByTestId("sidebar-desktop")).queryByText("Settings")).not.toBeInTheDocument();
+    expect(within(screen.getByTestId("bottom-tab-bar")).queryByText("Settings")).not.toBeInTheDocument();
+  });
+
+  it.each([
+    ["/account", "Inbox"],
+    ["/account/inbox/purchase/x", "Inbox"],
+    ["/account/artifacts", "Artifacts"],
+    ["/account/artifacts/p1", "Artifacts"],
+  ])("on %s only %s is selected (#8231 D1)", async (path, selected) => {
+    mockPathname = path;
+    await renderLayout();
+    const current = railRows().filter((row) => row.getAttribute("aria-current") === "page");
+    expect(current.map((row) => row.textContent)).toEqual([selected]);
+  });
+
+  it.each([
+    "/account/support",
+    // #8334 — the Settings pages (and the old path that redirects to General)
+    // select no row: Settings has no rail row to select.
+    "/account/general",
+    "/account/billing",
+    "/account/settings",
+    "/fr/account/billing",
+  ])("no row is selected on %s (#8231 D1, #8334)", async (path) => {
+    mockPathname = path;
+    await renderLayout(path.startsWith("/fr/") ? "fr" : "en");
+    const rows = railRows();
+    expect(rows).toHaveLength(2);
+    expect(rows.some((row) => row.hasAttribute("aria-current"))).toBe(false);
+  });
+
+  it("a non-default locale prefixes every row (#8231 D1)", async () => {
+    mockPathname = "/fr/account/artifacts";
+    await renderLayout("fr");
+    const rows = railRows();
+    expect(rows.map((row) => row.getAttribute("href"))).toEqual([
+      "/fr/account",
+      "/fr/account/artifacts",
+    ]);
+    expect(rows[1]).toHaveAttribute("aria-current", "page");
   });
 
   it("an Inbox item page keeps Inbox selected", async () => {
@@ -215,11 +278,28 @@ describe("the avatar menu (D13)", () => {
     const actions = within(menu).getByTestId("account-menu-actions");
     expect(within(actions).getByText("Settings").closest("a")).toHaveAttribute(
       "href",
-      "/account/settings",
+      "/account/general",
     );
     expect(within(actions).getByTestId("account-menu-sign-out")).toHaveTextContent("Log out");
   });
 
+  it("Settings in the menu is the one route to General, locale-prefixed (#8334)", async () => {
+    mockPathname = "/fr/account";
+    await renderLayout("fr");
+    openByPointer(screen.getByTestId("sidebar-nav-user-trigger"));
+    const actions = within(screen.getByTestId("account-menu-content")).getByTestId(
+      "account-menu-actions",
+    );
+    expect(within(actions).getByText("Settings").closest("a")).toHaveAttribute(
+      "href",
+      "/fr/account/general",
+    );
+    // The rail offers no second Settings link.
+    expect(
+      within(screen.getByTestId("sidebar-desktop")).queryByRole("link", { name: "Settings" }),
+    ).not.toBeInTheDocument();
+  });
+
   it("Log out signs out, then routes home and refreshes", async () => {
     await renderLayout();
     openByPointer(screen.getByTestId("sidebar-nav-user-trigger"));
@@ -370,3 +450,22 @@ describe("no session", () => {
     expect(screen.queryByTestId("sidebar-desktop")).not.toBeInTheDocument();
   });
 });
+
+describe("the shell marker (#8337 D4, AC-6)", () => {
+  it("with a session, exactly one [data-ailk-shell=\"account\"] wraps the shell", async () => {
+    await renderLayout();
+    const markers = document.querySelectorAll("[data-ailk-shell]");
+    expect(markers).toHaveLength(1);
+    const marker = markers[0] as HTMLElement;
+    expect(marker.getAttribute("data-ailk-shell")).toBe("account");
+    expect(marker.getAttribute("data-testid")).toBe("account-shell");
+    expect(Array.from(marker.classList)).toEqual(["contents"]);
+    expect(within(marker).getByTestId("dashboard-shell")).toBeInTheDocument();
+  });
+
+  it("with no session, no [data-ailk-shell] exists", async () => {
+    mockGetSession.mockResolvedValue(null);
+    await renderLayout();
+    expect(document.querySelector("[data-ailk-shell]")).not.toBeInTheDocument();
+  });
+});

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

@@ -0,0 +1,305 @@
+/**
+ * Tests for the member New menu (#8233, spec
+ * docs/specs/8233-member-new-menu-the-new-spec.md D1–D4; AC-1, AC-2, AC-6).
+ *
+ * Covers:
+ *   1. New over the Inbox offers exactly Schedule service · Request quote ·
+ *      Send message, in that order, as menu items that are not links; each
+ *      opens a popup over the Inbox titled with its label, and nothing
+ *      navigates (AC-1).
+ *   2. Each row is offered only while its member read answers: a 404, or a
+ *      switched-off request form, leaves it out; every read 404 (a Free
+ *      build) leaves no New button and no error row; a failed read drops
+ *      its row AND shows the Inbox error row (AC-2).
+ *   3. Placement: on the Inbox route the frame's phone top bar holds the
+ *      compact New; elsewhere in /account it holds nothing; outside a frame
+ *      only the desktop New shows, in the h1's header row (AC-6).
+ */
+import { fireEvent, render, screen, waitFor, within } from "@testing-library/react";
+import type { ReactElement } from "react";
+
+// The account suites' next-intl mock: dotted namespaces and dotted keys
+// resolve against en.json, `{name}` placeholders fill from `values`.
+jest.mock("next-intl/server", () => {
+  const msgs: unknown = require("../../../../../messages/en.json");
+  const dig = (obj: unknown, path: string): unknown =>
+    path.split(".").reduce<unknown>(
+      (acc, k) => (acc !== null && typeof acc === "object" ? (acc as Record<string, unknown>)[k] : undefined),
+      obj,
+    );
+  return {
+    __esModule: true,
+    getTranslations: async (arg: string | { namespace?: string; locale?: string }) => {
+      const ns = typeof arg === "string" ? arg : (arg.namespace ?? "");
+      const messages = dig(msgs, ns);
+      return (key: string, values?: Record<string, unknown>): string => {
+        const value = dig(messages, key);
+        if (typeof value !== "string") return `${ns}.${key}`;
+        return value.replace(/\{(\w+)\}/g, (m, name: string) =>
+          values && name in values ? String(values[name]) : m,
+        );
+      };
+    },
+  };
+});
+
+jest.mock("next/headers", () => ({
+  __esModule: true,
+  headers: jest.fn().mockResolvedValue(new Headers()),
+  cookies: jest.fn().mockResolvedValue({ toString: () => "session=abc" }),
+}));
+
+const mockGetSession = jest.fn();
+// eslint-disable-next-line no-restricted-syntax -- #507: mock-internal rewrite pending; auth.ts's lazy Better-Auth singleton has no HTTP/DB boundary a unit test of the session fields can mock without standing up Prisma.
+jest.mock("../../../../../auth", () => ({
+  __esModule: true,
+  auth: { api: { getSession: (...args: unknown[]) => mockGetSession(...args) } },
+}));
+
+const mockSubscriptionMe = jest.fn();
+const mockMemberPieces = jest.fn();
+const mockMemberMessages = jest.fn();
+const mockMemberPurchases = jest.fn();
+const mockMemberAppointments = jest.fn();
+const mockMemberMeetingTypes = jest.fn();
+const mockMemberRequestForm = jest.fn();
+jest.mock("@working-theory/api-client", () => ({
+  __esModule: true,
+  waitlistSignups: { me: jest.fn() },
+  subscription: { me: (...args: unknown[]) => mockSubscriptionMe(...args) },
+  member: {
+    pieces: (...args: unknown[]) => mockMemberPieces(...args),
+    messages: (...args: unknown[]) => mockMemberMessages(...args),
+    purchases: (...args: unknown[]) => mockMemberPurchases(...args),
+    appointments: (...args: unknown[]) => mockMemberAppointments(...args),
+    meetingTypes: (...args: unknown[]) => mockMemberMeetingTypes(...args),
+    requestForm: (...args: unknown[]) => mockMemberRequestForm(...args),
+  },
+}));
+
+jest.mock("better-auth/react", () => ({
+  __esModule: true,
+  createAuthClient: () => ({ signOut: jest.fn() }),
+}));
+
+const mockPush = jest.fn();
+const mockRefresh = jest.fn();
+let mockPathname = "/account";
+jest.mock("next/navigation", () => ({
+  __esModule: true,
+  useRouter: () => ({ push: mockPush, refresh: mockRefresh }),
+  usePathname: () => mockPathname,
+  useSearchParams: () => new URLSearchParams(),
+}));
+
+import { PhoneTabProvider } from "@working-theory/templates/account";
+import { requestQuoteFlowConfig } from "@working-theory/validation";
+
+import AccountLayout from "../layout";
+import { NewMenu } from "../new-menu";
+import Page from "../page";
+
+const SESSION = {
+  user: {
+    id: "user_1",
+    name: "Ada",
+    email: "ada@example.com",
+    emailVerified: true,
+    createdAt: new Date("2026-09-01T00:00:00.000Z"),
+  },
+};
+
+/** The cookie a single site forwards (`forwardedCookieInit()`, no Origin here). */
+const INIT = { headers: { cookie: "session=abc" } };
+
+const notFound = {
+  ok: false,
+  status: 404,
+  body: { ok: false, error: { code: "not_found", message: "Not found" } },
+};
+const failure = (status: number) => ({
+  ok: false,
+  status,
+  body: { ok: false, error: { code: "failed", message: "x" } },
+});
+const ok = <T,>(body: T) => ({ ok: true, body });
+
+const TYPE = { slug: "consult", title: "Consultation", durationMinutes: 30 };
+const FORM = {
+  form: { title: "Request a quote", defaultLocale: "en", steps: requestQuoteFlowConfig.steps },
+};
+
+const LABELS = ["Schedule service", "Request quote", "Send message"];
+
+beforeAll(() => {
+  // Radix menus open on pointerdown; jsdom has no PointerEvent.
+  if (typeof globalThis.PointerEvent === "undefined") {
+    // eslint-disable-next-line no-restricted-syntax -- a MouseEvent stands in for jsdom's missing PointerEvent
+    globalThis.PointerEvent = MouseEvent as unknown as typeof PointerEvent;
+  }
+});
+
+beforeEach(() => {
+  window.localStorage.clear();
+  mockPathname = "/account";
+  mockPush.mockReset();
+  mockRefresh.mockReset();
+  mockGetSession.mockReset().mockResolvedValue(SESSION);
+  mockSubscriptionMe.mockReset().mockResolvedValue(notFound);
+  mockMemberPieces.mockReset().mockResolvedValue(notFound);
+  mockMemberPurchases.mockReset().mockResolvedValue(notFound);
+  mockMemberAppointments.mockReset().mockResolvedValue(notFound);
+  // Every action offered unless a case says otherwise.
+  mockMemberMeetingTypes.mockReset().mockResolvedValue(ok({ items: [TYPE] }));
+  mockMemberRequestForm.mockReset().mockResolvedValue(ok(FORM));
+  mockMemberMessages.mockReset().mockResolvedValue(ok({ items: [] }));
+});
+
+function openByPointer(trigger: HTMLElement): void {
+  fireEvent.pointerDown(trigger, { button: 0, ctrlKey: false, pointerType: "mouse" });
+}
+
+async function renderInbox(): Promise<void> {
+  const element = await Page({ params: Promise.resolve({ locale: "en" }) });
+  render(<PhoneTabProvider tab="inbox">{element}</PhoneTabProvider>);
+}
+
+/** The New menu's rows, as their visible names. */
+function openMenu(trigger = screen.getByTestId("account-new-menu-trigger")): string[] {
+  openByPointer(trigger);
+  const content = screen.getByTestId("account-new-menu-content");
+  return within(content)
+    .getAllByRole("menuitem")
+    .map((item) => item.textContent ?? "");
+}
+
+describe("New offers the three actions, each a popup over the Inbox (AC-1)", () => {
+  it("lists exactly Schedule service · Request quote · Send message, none a link", async () => {
+    await renderInbox();
+    expect(openMenu()).toEqual(LABELS);
+    const content = screen.getByTestId("account-new-menu-content");
+    expect(content.querySelector("a")).toBeNull();
+    expect(within(content).getByTestId("account-new-menu-item-schedule-service")).toBeInTheDocument();
+    expect(within(content).getByTestId("account-new-menu-item-request-quote")).toBeInTheDocument();
+    expect(within(content).getByTestId("account-new-menu-item-send-message")).toBeInTheDocument();
+  });
+
+  it.each(LABELS.map((label, i) => [label, i] as const))(
+    "%s opens a popup titled with its label over the Inbox, and never navigates",
+    async (label, index) => {
+      await renderInbox();
+      openMenu();
+      fireEvent.click(screen.getAllByRole("menuitem")[index]!);
+      const popup = await screen.findByTestId("account-new-popup");
+      expect(within(popup).getByRole("heading", { name: label })).toBeInTheDocument();
+      expect(screen.getByTestId("account-inbox")).toBeInTheDocument();
+      expect(mockPush).not.toHaveBeenCalled();
+      // Close leaves the Inbox as it was, with nothing refreshed.
+      fireEvent.click(within(popup).getByRole("button", { name: "Close" }));
+      await waitFor(() => expect(screen.queryByTestId("account-new-popup")).not.toBeInTheDocument());
+      expect(mockRefresh).not.toHaveBeenCalled();
+    },
+  );
+});
+
+describe("each action is offered only while its read answers (AC-2)", () => {
+  it("meetingTypes 404 → Request quote and Send message only", async () => {
+    mockMemberMeetingTypes.mockResolvedValue(notFound);
+    await renderInbox();
+    expect(openMenu()).toEqual(["Request quote", "Send message"]);
+  });
+
+  it.each([
+    ["{ form: null }", ok({ form: null })],
+    ["404", notFound],
+  ])("requestForm %s → no Request quote", async (_name, answer) => {
+    mockMemberRequestForm.mockResolvedValue(answer);
+    await renderInbox();
+    expect(openMenu()).toEqual(["Schedule service", "Send message"]);
+    expect(screen.queryByTestId("inbox-error")).not.toBeInTheDocument();
+  });
+
+  it("meetingTypes { items: [] } → Schedule service is still offered (its popup says why)", async () => {
+    mockMemberMeetingTypes.mockResolvedValue(ok({ items: [] }));
+    await renderInbox();
+    expect(openMenu()).toEqual(LABELS);
+  });
+
+  it("every member read 404 (a Free build) → no New button and no error row", async () => {
+    mockMemberMeetingTypes.mockResolvedValue(notFound);
+    mockMemberRequestForm.mockResolvedValue(notFound);
+    mockMemberMessages.mockResolvedValue(notFound);
+    await renderInbox();
+    expect(screen.queryByTestId("account-new-menu-trigger")).not.toBeInTheDocument();
+    expect(screen.queryByTestId("account-new-menu-trigger-compact")).not.toBeInTheDocument();
+    expect(screen.queryByTestId("inbox-error")).not.toBeInTheDocument();
+  });
+
+  it("requestForm 500 → no Request quote, and the Inbox error row (D12 parity)", async () => {
+    mockMemberRequestForm.mockResolvedValue(failure(500));
+    await renderInbox();
+    expect(openMenu()).toEqual(["Schedule service", "Send message"]);
+    expect(screen.getByTestId("inbox-error")).toBeInTheDocument();
+  });
+
+  it("each availability read receives the request's init unchanged", async () => {
+    await renderInbox();
+    expect(mockMemberMeetingTypes).toHaveBeenCalledWith(INIT);
+    expect(mockMemberRequestForm).toHaveBeenCalledWith(INIT);
+    expect(mockMemberMessages).toHaveBeenCalledWith(INIT);
+  });
+
+  it("signed out → no New button and no read", async () => {
+    mockGetSession.mockResolvedValue(null);
+    await renderInbox();
+    expect(screen.queryByTestId("account-new-menu-trigger")).not.toBeInTheDocument();
+    expect(mockMemberMeetingTypes).not.toHaveBeenCalled();
+  });
+});
+
+describe("placement — the h1's row from md up, the phone top bar below (AC-6)", () => {
+  const ACTIONS = LABELS.map((label, i) => ({
+    id: ["schedule-service", "request-quote", "send-message"][i]!,
+    label,
+    popup: <p>{label} body</p>,
+  }));
+
+  function InboxChild(): ReactElement {
+    return <NewMenu actions={ACTIONS} labels={{ trigger: "New", close: "Close" }} />;
+  }
+
+  async function renderLayout(): Promise<void> {
+    const element = await AccountLayout({
+      children: <InboxChild />,
+      params: Promise.resolve({ locale: "en" }),
+    });
+    render(element);
+  }
+
+  it("on /account the compact New sits in the top bar's trailing cell and opens the same menu", async () => {
+    await renderLayout();
+    const end = screen.getByTestId("sidebar-topbar-end");
+    const compact = await within(end).findByTestId("account-new-menu-trigger-compact");
+    expect(compact).toHaveAccessibleName("New");
+    expect(openMenu(compact)).toEqual(LABELS);
+  });
+
+  it("on /account/settings the top bar holds no New slot", async () => {
+    mockPathname = "/account/settings";
+    await renderLayout();
+    expect(screen.queryByTestId("account-top-bar-actions")).not.toBeInTheDocument();
+    expect(screen.queryByTestId("account-new-menu-trigger-compact")).not.toBeInTheDocument();
+  });
+
+  it("outside a frame there is no compact New, and New sits in the h1's header row", async () => {
+    await renderInbox();
+    expect(screen.queryByTestId("account-new-menu-trigger-compact")).not.toBeInTheDocument();
+    const heading = screen.getByRole("heading", { level: 1 });
+    expect(heading.parentElement).toContainElement(screen.getByTestId("account-new-menu-trigger"));
+  });
+
+  it("with no action NewMenu renders nothing", () => {
+    const { container } = render(<NewMenu actions={[]} labels={{ trigger: "New", close: "Close" }} />);
+    expect(container).toBeEmptyDOMElement();
+  });
+});

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

@@ -0,0 +1,82 @@
+/**
+ * Tests for account/new-popups.tsx — the New actions with their popups bound
+ * (#8233 D1, D2, D6–D8; spec AC-7's popup half, moved here with the popups:
+ * `lib/account-config.ts` may import nothing under `(authed)`, so the
+ * binding lives in the route).
+ *
+ * Covers:
+ *   1. `newActions` is `accountNewActions` in menu order, each read untouched
+ *      (the same `available` function the config exports).
+ *   2. Each popup's props carry no credential and no email — only the locale
+ *      and strings (SEC-8233-1).
+ */
+
+jest.mock("@working-theory/api-client", () => ({
+  __esModule: true,
+  waitlistSignups: { me: jest.fn() },
+  subscription: { me: jest.fn() },
+  member: {
+    pieces: jest.fn(),
+    messages: jest.fn(),
+    purchases: jest.fn(),
+    appointments: jest.fn(),
+    meetingTypes: jest.fn(),
+    requestForm: jest.fn(),
+  },
+}));
+
+import type {
+  AccountContext,
+  AccountNewAction,
+} from "@working-theory/templates/account";
+import type { ReactElement } from "react";
+
+import { accountNewActions } from "../../../../../lib/account-config";
+import { newActions } from "../new-popups";
+
+const INIT = { headers: { cookie: "session=abc" } };
+
+function ctx(): AccountContext {
+  return {
+    locale: "en",
+    user: { name: "Ada", email: "ada@example.com", emailVerified: true },
+    t: (key) => `t:${key}`,
+    init: INIT,
+  };
+}
+
+function action(id: string): AccountNewAction {
+  const found = newActions.find((a) => a.id === id);
+  if (!found) throw new Error(`no New action ${id}`);
+  return found;
+}
+
+describe("newActions — the config's actions with their popups (#8233 D1, D2)", () => {
+  it("is accountNewActions in menu order, each read the config's own", () => {
+    expect(newActions.map((a) => [a.id, a.label])).toEqual(
+      accountNewActions.map((a) => [a.id, a.label]),
+    );
+    expect(newActions.map((a) => a.id)).toEqual([
+      "schedule-service",
+      "request-quote",
+      "send-message",
+    ]);
+    newActions.forEach((a, i) => {
+      expect(a.available).toBe(accountNewActions[i]!.available);
+    });
+  });
+
+  it.each(["schedule-service", "request-quote", "send-message"])(
+    "%s renders a popup whose props carry no cookie and no email (SEC-8233-1)",
+    (id) => {
+      const popup = action(id).renderPopup(ctx()) as ReactElement<
+        Record<string, unknown>
+      >;
+      const props = JSON.stringify(popup.props);
+      expect(props).not.toContain("session=abc");
+      expect(props).not.toContain("ada@example.com");
+      expect(popup.props).toMatchObject({ locale: "en" });
+      expect(Object.keys(popup.props).sort()).toEqual(["labels", "locale"]);
+    },
+  );
+});