create-ailk 0.25.1 → 0.26.0

package/templates/apps/web/app/[locale]/(authed)/account/billing/page.tsx

@@ -19,7 +19,8 @@
  *
  * After any of the three, one plain line when some of the member's billing
  * is on a Stripe account this spoke's key cannot read (#8217 D12), then
- * each section a module contributes (`accountBillingSections`, #8231 D4).
+ * each section a module contributes (`accountBillingSections`, #8231 D4),
+ * then each section the site adds (`siteBillingSections`, #9401 D7).
  */
 
 import { AccountSettingsFrame, AccountSettingsPane, CurrentPlanCard } from "@working-theory/templates/account";
@@ -29,6 +30,7 @@ import { getTranslations } from "next-intl/server";
 import type { ReactElement } from "react";
 
 import { accountBillingSections } from "../../../../../lib/account-config";
+import { siteBillingSections } from "../../../../../lib/site-contributions";
 import { accountSession } from "../account-data";
 import { openBillingPortal } from "../actions";
 import { type BillingState, loadBilling } from "../billing-source";
@@ -161,7 +163,7 @@ export default async function AccountBillingPage({ params }: Props): Promise<Rea
           </div>
         ) : null}
 
-        {accountBillingSections.map((section) => (
+        {[...accountBillingSections, ...siteBillingSections].map((section) => (
           <SettingsSection key={section.id} id={section.id} title={ctx.t(section.title)}>
             {section.render(ctx)}
           </SettingsSection>

package/templates/apps/web/app/[locale]/(authed)/sign-in-gate.tsx

@@ -20,18 +20,23 @@
  * current pathname (via `usePathname()`) so a successful social sign-in
  * lands back on the exact dashboard page the visitor requested.
  *
- * Email sign-in link (#7435 § D9): when the layout passes `emailLink`, the
- * gate renders `/sign-in`'s own `SignInCard` — the same providers plus "Email
- * me a sign-in link" — in place of `AuthPanel`, whose email + password form
- * has no submit wiring and would otherwise sit inert beside the new field.
- * Without the prop every render is what it was before.
+ * Email sign-in link (#7435 § D9): when the layout passes `card` with
+ * `emailLink`, the gate renders `/sign-in`'s own `SignInCard` — the same
+ * providers plus "Send me a magic link" — in place of `AuthPanel`, whose
+ * email + password form has no submit wiring and would otherwise sit inert
+ * beside the new field. Without the prop every render is what it was before.
+ *
+ * The one card (#9662): on the member `/account` gate the layout passes
+ * `card` whenever a method is on, with the site's mark, the "Don't have an
+ * account? Sign up" line and the Terms + Privacy acknowledgement, so the gate
+ * renders the same card `/sign-in` does.
  */
 
 import { EmptyState, Link } from "@working-theory/ui/primitives";
 import { AuthPanel, type AuthPanelProvider } from "@working-theory/ui/sections";
 import { createAuthClient } from "better-auth/react";
 import { usePathname } from "next/navigation";
-import type { ReactElement } from "react";
+import type { ReactElement, ReactNode } from "react";
 
 import { SignInCard } from "../(auth)/sign-in/sign-in-card";
 import type { SignInCardText } from "../(auth)/sign-in/sign-in-text";
@@ -52,17 +57,25 @@ export interface SignInGateProps {
   /** The active social providers, resolved server-side by the layout (#7419). */
   providers: AuthPanelProvider[];
   /**
-   * Present iff the email sign-in link is on (#7435) — the sign-in card's
-   * copy, resolved server-side by the layout.
+   * Renders `SignInCard` in place of `AuthPanel` — present when the email
+   * sign-in link is on (#7435) or on the member gate (#9662). The card's copy,
+   * mark, prospect line and footnote are resolved server-side by the layout.
    */
-  emailLink?: { text: SignInCardText };
+  card?: {
+    text: SignInCardText;
+    /** Offer "Send me a magic link" — the email sign-in link is on. */
+    emailLink: boolean;
+    logo?: ReactNode;
+    prospect?: { prompt: string; linkLabel: string; href: string };
+    footnote?: ReactNode;
+  };
 }
 
 export function SignInGate({
   labels,
   signInPath,
   providers,
-  emailLink,
+  card,
 }: SignInGateProps): ReactElement {
   const pathname = usePathname();
   const signInHref = `${signInPath}?next=${encodeURIComponent(pathname)}`;
@@ -79,25 +92,35 @@ export function SignInGate({
     </Link>
   );
 
-  if (emailLink) {
-    const { text } = emailLink;
+  if (card) {
+    const { text } = card;
     return (
       <div
         className="flex min-h-screen flex-col items-center justify-center gap-4 py-section"
         data-testid="sign-in-gate"
       >
-        <SignInCard
-          providers={providers}
-          method="sso"
-          next={pathname}
-          labels={text.labels}
-          notConfiguredSubhead={text.notConfiguredSubhead}
-          errorLabels={text.errorLabels}
-          emailLink
-          errorCallbackURL={signInHref}
-          signInHref={signInHref}
-          emailLinkLabels={text.emailLinkLabels}
-        />
+        {/* AuthShell's 400px column: the cap sits on the wrapper, never on the card (AuthShell.tsx). */}
+        <div className="w-full max-w-100">
+          <SignInCard
+            providers={providers}
+            method="sso"
+            next={pathname}
+            labels={text.labels}
+            notConfiguredSubhead={text.notConfiguredSubhead}
+            errorLabels={text.errorLabels}
+            emailLink={card.emailLink}
+            errorCallbackURL={signInHref}
+            signInHref={signInHref}
+            emailLinkLabels={text.emailLinkLabels}
+            {...(card.logo !== undefined ? { logo: card.logo } : {})}
+            {...(card.prospect !== undefined
+              ? { prospect: card.prospect }
+              : {})}
+            {...(card.footnote !== undefined
+              ? { footnote: card.footnote }
+              : {})}
+          />
+        </div>
         {signInLink}
       </div>
     );

package/templates/apps/web/app/[locale]/(authed)/signed-out-gate.generated.tsx

@@ -11,9 +11,11 @@ import { readLocales } from "@working-theory/web-i18n";
 import { getTranslations } from "next-intl/server";
 import type { ReactElement } from "react";
 
+import { legalFootnote } from "../(auth)/legal-footnote";
 import { resolveSignInCardText } from "../(auth)/sign-in/sign-in-text";
 import { getActiveProviderIds } from "../../../lib/auth-env";
 import { isAccountPath } from "../../../lib/auth-routes";
+import { siteLogo } from "../../../lib/site-logo";
 
 import { SignInGate } from "./sign-in-gate";
 
@@ -39,9 +41,7 @@ export async function SignedOutGate({
     namespace: isAccount ? "account.gate" : "waitlistDashboard.gate",
   });
   const active = getActiveProviderIds();
-  const emailLink = active.includes("magic-link")
-    ? { text: await resolveSignInCardText(locale) }
-    : undefined;
+  const emailLink = active.includes("magic-link");
   const providers = active.filter((id): id is AuthPanelProvider =>
     (SUPPORTED_PROVIDERS as readonly string[]).includes(id),
   );
@@ -75,6 +75,25 @@ export async function SignedOutGate({
     );
   }
 
+  // The sign-in card: with the email link on, and on the member gate, which
+  // also wears the one card's frame — the mark, the toggle line to /sign-up
+  // and the Terms + Privacy acknowledgement (#9662).
+  const text =
+    emailLink || isAccount ? await resolveSignInCardText(locale) : undefined;
+  const card = text
+    ? {
+        text,
+        emailLink,
+        ...(isAccount
+          ? {
+              logo: siteLogo(),
+              prospect: { ...text.prospect, href: localeHref(locale, "/sign-up") },
+              footnote: legalFootnote(locale, text.acknowledgement),
+            }
+          : {}),
+      }
+    : undefined;
+
   return (
     <SignInGate
       labels={{
@@ -84,7 +103,7 @@ export async function SignedOutGate({
       }}
       signInPath={signInPath}
       providers={providers}
-      {...(emailLink ? { emailLink } : {})}
+      {...(card ? { card } : {})}
     />
   );
 }

package/templates/apps/web/app/[locale]/layout.tsx

@@ -952,7 +952,9 @@ export default async function LocaleLayout({
            * cookie read — same #5557 hydration-safety property, no gate
            * needed. This also means the banner never blocks the page: it
            * reserves its own space (D1) and carries a close-without-choosing
-           * control (D2) instead of a hard server-side hide.
+           * control (D2) instead of a hard server-side hide. The standard
+           * chrome's compact card has no close control (#9656 D5): it is a
+           * non-modal corner card and Decline All is one tap.
            */}
           {isAccountRoute ? null : (
             <ConsentBanner
@@ -961,18 +963,36 @@ export default async function LocaleLayout({
               consentCookieName={CONSENT_COOKIE_NAME}
               consentDecided={consentDecided}
               title={tConsent("title")}
-              message={
-                <>
-                  {consentBannerStatement}{" "}
-                  <Link
-                    href={localeHref(locale, "/privacy")}
-                    variant="unstyled"
-                    className="font-semibold text-current underline underline-offset-4"
-                  >
-                    {tConsent("policyLinkLabel")}
-                  </Link>
-                </>
-              }
+              // #9656 D7 — the standard chrome mounts the compact floating
+              // card on every width, its Privacy Policy link on the button
+              // row; the minimal chrome keeps its hairline band (#7742 D5),
+              // the statement with the link inline.
+              {...(isMinimalChrome
+                ? {
+                    message: (
+                      <>
+                        {consentBannerStatement}{" "}
+                        <Link
+                          href={localeHref(locale, "/privacy")}
+                          variant="unstyled"
+                          className="font-semibold text-current underline underline-offset-4"
+                        >
+                          {tConsent("policyLinkLabel")}
+                        </Link>
+                      </>
+                    ),
+                  }
+                : {
+                    message: consentBannerStatement,
+                    presentation: "floating" as const,
+                    corner: "bottom-left" as const,
+                    consentAppearance: "compact" as const,
+                    mobileConsent: "inherit" as const,
+                    consentPolicyLink: {
+                      label: tConsent("policyLinkLabel"),
+                      href: "/privacy",
+                    },
+                  })}
               dismissible={false}
               dismissLabel={tConsent("dismissLabel")}
               acceptLabel={tConsent("acceptLabel")}

package/templates/apps/web/app/[locale]/meet/confirmed/BookingHandOff.tsx

@@ -0,0 +1,128 @@
+// oss: false
+"use client"; // Reads sessionStorage (a browser API) once on mount — a server page cannot.
+
+/**
+ * BookingHandOff — `/meet/confirmed`'s booked time and Slack next step
+ * (#9853 D10). The booker writes one `sessionStorage` item before it
+ * navigates here (`BOOKING_CONFIRMATION_STORAGE_KEY`); this reads it once and
+ * removes it, the `/thanks` page's `AccountInviteLink` pattern, so the page's
+ * address carries nothing about the booking and a later visit shows nothing.
+ *
+ * It renders only an item written for this page (`to`'s path, without its
+ * query or hash, is `/meet/confirmed` or `/<locale>/meet/confirmed`) in the last ten
+ * minutes. The time is formatted in the zone Cal.com recorded, with the zone
+ * named, so the page and the Slack welcome name the same one; a zone `Intl`
+ * does not know renders nothing. Every string is a prop the server page read
+ * from the `schedule` namespace.
+ */
+import { Container, Heading, Text } from "@working-theory/ui";
+import {
+  BOOKING_CONFIRMATION_STORAGE_KEY,
+  BookingConfirmationHandOffSchema,
+} from "@working-theory/validation";
+import type { ReactElement } from "react";
+import { useEffect, useState } from "react";
+
+/** A reserved name that never resolves: only used to read the path of `to`. */
+const PLACEHOLDER_ORIGIN = "https://placeholder.invalid";
+const CONFIRMED_PATH = "/meet/confirmed";
+const MAX_AGE_MS = 10 * 60_000;
+
+interface Props {
+  locale: string;
+  /** `schedule.confirmed.bookedTimeHeading`. */
+  bookedTimeHeading: string;
+  /** `schedule.confirmed.slackHeadline`. */
+  slackHeadline: string;
+  /** `schedule.confirmed.slackBody`. */
+  slackBody: string;
+}
+
+interface Shown {
+  time: string;
+  slackOptIn: boolean;
+}
+
+/** Whether `to` names this page, with or without this page's `/<locale>`. */
+function namesThisPage(to: string, locale: string): boolean {
+  let url: URL;
+  try {
+    url = new URL(to, PLACEHOLDER_ORIGIN);
+  } catch {
+    return false;
+  }
+  if (url.origin !== PLACEHOLDER_ORIGIN) return false;
+  return (
+    url.pathname === CONFIRMED_PATH ||
+    url.pathname === `/${locale}${CONFIRMED_PATH}`
+  );
+}
+
+/** Read the hand-off once, remove it, and answer what to show (or `null`). */
+function takeHandOff(locale: string): Shown | null {
+  try {
+    const stored = window.sessionStorage.getItem(
+      BOOKING_CONFIRMATION_STORAGE_KEY,
+    );
+    if (stored === null) return null;
+    window.sessionStorage.removeItem(BOOKING_CONFIRMATION_STORAGE_KEY);
+    const parsed = BookingConfirmationHandOffSchema.safeParse(
+      JSON.parse(stored),
+    );
+    if (!parsed.success) return null;
+    const { to, savedAt, start, timeZone, slackOptIn } = parsed.data;
+    const age = Date.now() - savedAt;
+    if (!namesThisPage(to, locale) || age < 0 || age >= MAX_AGE_MS) return null;
+    const time = new Intl.DateTimeFormat(locale, {
+      weekday: "long",
+      month: "long",
+      day: "numeric",
+      hour: "numeric",
+      minute: "2-digit",
+      timeZone,
+      timeZoneName: "longGeneric",
+    }).format(new Date(start));
+    return { time, slackOptIn };
+  } catch {
+    // Unparseable JSON, refused storage, or a zone `Intl` does not know.
+    return null;
+  }
+}
+
+export function BookingHandOff({
+  locale,
+  bookedTimeHeading,
+  slackHeadline,
+  slackBody,
+}: Props): ReactElement | null {
+  const [shown, setShown] = useState<Shown | null>(null);
+
+  useEffect(() => {
+    // Only ever sets: React's development double-mount runs this twice, and
+    // the second run finds the item already removed.
+    const found = takeHandOff(locale);
+    if (found !== null) setShown(found);
+  }, [locale]);
+
+  if (shown === null) return null;
+  return (
+    <Container className="pt-block-loose">
+      <div role="status" data-testid="booking-hand-off">
+        <Heading level={2} visual={4}>
+          {bookedTimeHeading}
+        </Heading>
+        <Text className="mt-2">{shown.time}</Text>
+        {shown.slackOptIn && (
+          <>
+            <Heading level={2} visual={4} className="mt-block-tight">
+              {slackHeadline}
+            </Heading>
+            <Text tone="muted" className="mt-2">
+              {slackBody}
+            </Text>
+          </>
+        )}
+      </div>
+    </Container>
+  );
+}

package/templates/apps/web/app/[locale]/meet/confirmed/__tests__/BookingHandOff.test.tsx

@@ -0,0 +1,126 @@
+// oss: false
+/**
+ * Tests for `/meet/confirmed`'s booking hand-off (#9853 D9, D10; AC-7).
+ *
+ * The booker hands this page the booked time, its zone and the Slack opt-in
+ * through one `sessionStorage` item, never the address. The component reads
+ * it once and removes it, and shows it only when it was written for this page
+ * in the last ten minutes, formatted in the zone Cal.com recorded — the
+ * prospect's, not the viewer's. Anything else renders nothing.
+ */
+import React from "react";
+import { act, render, screen } from "@testing-library/react";
+
+import { BookingHandOff } from "../BookingHandOff";
+
+const STORAGE_KEY = "ailk:booking-confirmation";
+const PROPS = {
+  locale: "en",
+  bookedTimeHeading: "copy:confirmed.bookedTimeHeading",
+  slackHeadline: "copy:confirmed.slackHeadline",
+  slackBody: "copy:confirmed.slackBody",
+};
+
+function handOff(overrides: Record<string, unknown> = {}) {
+  return {
+    to: "/meet/confirmed",
+    savedAt: Date.now(),
+    start: "2026-10-30T20:00:00.000Z",
+    timeZone: "America/Denver",
+    slackOptIn: true,
+    ...overrides,
+  };
+}
+
+function store(value: unknown): void {
+  window.sessionStorage.setItem(
+    STORAGE_KEY,
+    typeof value === "string" ? value : JSON.stringify(value),
+  );
+}
+
+async function renderHandOff() {
+  let utils!: ReturnType<typeof render>;
+  await act(async () => {
+    utils = render(<BookingHandOff {...PROPS} />);
+  });
+  return utils;
+}
+
+beforeEach(() => {
+  window.sessionStorage.clear();
+  window.history.replaceState(null, "", "/en/meet/confirmed");
+});
+
+describe("<BookingHandOff/> (#9853 AC-7)", () => {
+  it("shows the booked time in the prospect's zone, named, and the Slack step; then forgets it", async () => {
+    store(handOff());
+    const { container } = await renderHandOff();
+
+    expect(screen.getByText(PROPS.bookedTimeHeading)).toBeInTheDocument();
+    expect(container.textContent).toContain("2:00");
+    expect(container.textContent).toContain("Mountain Time");
+    expect(screen.getByText(PROPS.slackHeadline)).toBeInTheDocument();
+    expect(screen.getByText(PROPS.slackBody)).toBeInTheDocument();
+    expect(screen.getByRole("status")).toBeInTheDocument();
+    expect(window.sessionStorage.getItem(STORAGE_KEY)).toBeNull();
+  });
+
+  it("accepts a destination written with a locale prefix, a query or a hash", async () => {
+    store(handOff({ to: "/en/meet/confirmed?x=1#top" }));
+    const { container } = await renderHandOff();
+    expect(container.textContent).toContain("Mountain Time");
+  });
+
+  it("shows no Slack text when the box was not ticked", async () => {
+    store(handOff({ slackOptIn: false }));
+    const { container } = await renderHandOff();
+    expect(container.textContent).toContain("Mountain Time");
+    expect(screen.queryByText(PROPS.slackHeadline)).toBeNull();
+    expect(screen.queryByText(PROPS.slackBody)).toBeNull();
+  });
+
+  it.each<[string, () => void]>([
+    ["no item", () => undefined],
+    ["an unparseable item", () => store("{not json")],
+    [
+      "an item with an extra email key",
+      () => store(handOff({ email: "ada@example.com" })),
+    ],
+    [
+      "an item for another page",
+      () => store(handOff({ to: "/before-your-call" })),
+    ],
+    [
+      "an item eleven minutes old",
+      () => store(handOff({ savedAt: Date.now() - 11 * 60_000 })),
+    ],
+    [
+      "a zone Intl does not know",
+      () => store(handOff({ timeZone: "Mars/Olympus" })),
+    ],
+  ])("renders nothing, and removes the item, for %s", async (_label, seed) => {
+    seed();
+    const { container } = await renderHandOff();
+    expect(container).toBeEmptyDOMElement();
+    expect(window.sessionStorage.getItem(STORAGE_KEY)).toBeNull();
+  });
+
+  it("shows nothing on a later visit", async () => {
+    store(handOff());
+    const first = await renderHandOff();
+    first.unmount();
+    const { container } = await renderHandOff();
+    expect(container).toBeEmptyDOMElement();
+  });
+
+  it.each([
+    "/fr/meet/confirmed",
+    "/anything/meet/confirmed",
+    "//evil.example/meet/confirmed",
+  ])("renders nothing for a destination of %s", async (to) => {
+    store(handOff({ to }));
+    const { container } = await renderHandOff();
+    expect(container).toBeEmptyDOMElement();
+  });
+});

package/templates/apps/web/auth.ts

@@ -459,7 +459,9 @@ export function createAuth(deps: CreateAuthDeps = {}) {
     /**
      * The sign-up grants (#8765 D4): the user hook decides whether the new
      * user carries agreements, the account hook writes them on the captured
-     * transaction client. No other database hook is installed.
+     * transaction client. A magic-link sign-up creates no Account, so the
+     * session hook writes its grants, in their own transaction, before the
+     * session exists (#9667 D5). No other database hook is installed.
      */
     databaseHooks: signUpAgreementHooks(),
     secret: resolveSecret(),
@@ -671,9 +673,11 @@ export function createAuth(deps: CreateAuthDeps = {}) {
     /**
      * `magicLink` only when its predicate holds (#7435 § D2): absent, its
      * `/sign-in/magic-link` and `/magic-link/verify` endpoints do not exist.
-     * Sign-in only — the callback mails existing users and nobody else, and
-     * `disableSignUp` refuses to create one even for a live token
-     * (lib/auth-email.ts).
+     * Sign-in only while sign-up is closed — the callback mails existing users
+     * and nobody else, and `disableSignUp` refuses to create one even for a
+     * live token (lib/auth-email.ts). While `isSignUpOpen()` a request
+     * carrying the agreements is a sign-up: its token is bound to them, and
+     * the verify creates the account only for a token so bound (#9667).
      *
      * `signUpAgreementsPlugin` always (#8765 D3): while sign-up is open,
      * `/sign-up/email` without every sign-up agreement is refused before the

package/templates/apps/web/i18n/request.ts

@@ -4,6 +4,14 @@
 // English when no catalog exists (e.g. a locale is enabled in project.yaml
 // but its messages/<locale>.json has not been translated yet).
 //
+// The site's own strings (#9401 D8) live in messages/site/<locale>.json, an
+// overlay the template ships as `{}` and never changes, so `create-ailk
+// update` keeps a site's edit of it. It falls back to the English overlay,
+// then to nothing, and merges add-only: a key the template catalog already
+// has keeps the template's value. The merge builds new objects, descends only
+// into plain objects, takes only string leaves and skips prototype keys, so
+// it can neither mutate the imported catalog nor pollute `Object.prototype`.
+//
 // Spec: docs/internal/specs/i18n-phase1-s2-next-intl-foundation-spec.md
 
 import type { AbstractIntlMessages } from "next-intl";
@@ -11,6 +19,42 @@ import { getRequestConfig } from "next-intl/server";
 
 const DEFAULT_LOCALE = "en";
 
+const UNSAFE_KEYS: ReadonlySet<string> = new Set([
+  "__proto__",
+  "constructor",
+  "prototype",
+]);
+
+type Catalog = Record<string, unknown>;
+
+function isCatalog(value: unknown): value is Catalog {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+/** `base` with every key of `overlay` it lacks added — new objects, never a mutation. */
+function mergeAddOnly(base: Catalog, overlay: Catalog): Catalog {
+  const out: Catalog = { ...base };
+  for (const [key, value] of Object.entries(overlay)) {
+    if (UNSAFE_KEYS.has(key)) continue;
+    const has = Object.prototype.hasOwnProperty.call(base, key);
+    if (typeof value === "string") {
+      if (!has) out[key] = value;
+    } else if (isCatalog(value)) {
+      if (!has) out[key] = mergeAddOnly({}, value);
+      else if (isCatalog(base[key])) out[key] = mergeAddOnly(base[key], value);
+    }
+  }
+  return out;
+}
+
+async function loadSiteOverlay(locale: string): Promise<Catalog> {
+  const mod =
+    (await import(`../messages/site/${locale}.json`).catch(() => null)) ??
+    (await import(`../messages/site/${DEFAULT_LOCALE}.json`).catch(() => null));
+  const overlay: unknown = mod ? (mod.default ?? mod) : null;
+  return isCatalog(overlay) ? overlay : {};
+}
+
 export default getRequestConfig(async ({ requestLocale }) => {
   // requestLocale is the modern API (next-intl >= 3.22). It resolves the
   // active locale from the request, validated by middleware.
@@ -32,5 +76,9 @@ export default getRequestConfig(async ({ requestLocale }) => {
     messages = (fallback.default ?? fallback) as AbstractIntlMessages;
   }
 
-  return { locale, messages };
+  const overlay = await loadSiteOverlay(locale);
+  return {
+    locale,
+    messages: mergeAddOnly(messages, overlay) as AbstractIntlMessages,
+  };
 });

package/templates/apps/web/lib/__tests__/account-config.test.ts

@@ -26,6 +26,8 @@
  *      401/403) is `false`, any other failure rejects. The popups are bound
  *      in the route (`account/new-popups.tsx`, tested beside it): this file
  *      imports nothing under `(authed)`.
+ *   8. #9401 AC-11 — the template's `site-contributions.ts` stub ships no
+ *      Billing section either; a site fills it.
  */
 
 const mockSignupMe = jest.fn();
@@ -68,6 +70,7 @@ import {
   accountSettingsSections,
   type AccountNewRead,
 } from "../account-config";
+import { siteBillingSections } from "../site-contributions";
 
 const INIT = { headers: { cookie: "session=abc" } };
 
@@ -166,6 +169,10 @@ describe("account-config exports (AC-6)", () => {
     expect(accountBillingSections).toEqual([]);
   });
 
+  it("ships no site Billing section either: the stub is the site's to fill (#9401 AC-11, D7)", () => {
+    expect(siteBillingSections).toEqual([]);
+  });
+
   it("ships the base kinds and the member kinds in their sections (#8231 D4–D6)", () => {
     expect(accountInboxKinds.map((k) => [k.kind, k.section])).toEqual([
       ["result", "updates"],