create-ailk 0.18.0 → 0.19.1

package/templates/apps/web/auth.ts

@@ -194,8 +194,12 @@ function buildSocialProviders(): SocialProviders {
  * "up" — and `apps/web/.env.example` has always documented the variable as
  * REQUIRED in production. The change makes the file honest rather than adding
  * a requirement.
+ *
+ * Exported (#8146 D5) so the hub's sign-in continuation seals its ref under the
+ * same resolved secret instead of re-reading the variable: the second consumer
+ * after `betterAuth({ secret })`.
  */
-function resolveSecret(): string {
+export function resolveSecret(): string {
   const configured = process.env.BETTER_AUTH_SECRET;
   if (configured) return configured;
 
@@ -320,6 +324,24 @@ export function createAuth(deps: CreateAuthDeps = {}) {
   const sendResetPassword = makeSendResetPassword({
     prisma,
     send: authEmailTransport,
+    /**
+     * Who is signed in on the reset request (#8431 D4) — the Security tab's
+     * Set password, for a person with no password yet. Read through THIS
+     * instance (assigned below; the callback runs only during a request, by
+     * which time it exists), never a second one, and never by verifying the
+     * cookie by hand. `disableRefresh`: the mail callback runs in the
+     * background after the response, where a refresh's cookie write would
+     * throw and drop the mail. No request (a server-side call carries no
+     * cookie) or no `api` (a test double of `betterAuth`) is no session.
+     */
+    sessionUserId: async (request) => {
+      if (request === undefined || Reflect.get(instance, "api") === undefined) return null;
+      const session = await instance.api.getSession({
+        headers: request.headers,
+        query: { disableRefresh: true },
+      });
+      return session?.user.id ?? null;
+    },
   });
   const sendVerificationEmail = makeSendVerificationEmail({
     send: authEmailTransport,
@@ -415,7 +437,7 @@ export function createAuth(deps: CreateAuthDeps = {}) {
     }
   };
 
-  return betterAuth({
+  const instance = betterAuth({
     database: prismaAdapter(prisma, {
       provider: "postgresql",
     }),
@@ -639,6 +661,7 @@ export function createAuth(deps: CreateAuthDeps = {}) {
         ]
       : [nextCookies()],
   });
+  return instance;
 }
 
 // Lazy singleton: resolved on first access, not at module-load time.

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

@@ -1,31 +1,55 @@
 /**
  * Tests for lib/account-config.ts — the base account area's contributions
- * (#7429, spec 7423 U3 · AC-6; amended by #7448, U5 · D6a/D8a/D9).
+ * (#7429, spec 7423 U3 · AC-6; amended by #7448, U5 · D6a/D8a/D9; by #8231,
+ * spec 8231 D4–D7).
  *
  * Covers:
- *   1. The three contribution arrays are exported; the base area ships no
- *      Settings section (modules add those).
- *   2. The base Inbox kinds are exactly `result` and `purchase` — rows of
- *      the Recents and All tabs; none fills Scheduled (the old Upcoming).
+ *   1. The five contribution arrays are exported; the base area ships no
+ *      Settings section or Billing section (modules add those), and the
+ *      three New actions (#8233 D2).
+ *   2. The Inbox kinds: `result`, `piece` and `message` in `updates` (All
+ *      only), `purchase` in `purchases`, `appointment` in `upcoming`.
  *   3. `email-unverified` and `payment-due` are For-you sources — needs-you
  *      items with an Open action to User settings, never Inbox rows.
- *   4. Each contribution maps its existing read: the session for
- *      `email-unverified`, `waitlistSignups.me` per configured key for
- *      `result`, `flowCheckouts.me` for `purchase`, and `subscription.me`'s
- *      own `actionRequired` for `payment-due`.
+ *   4. Each contribution maps its read: the session for `email-unverified`,
+ *      `waitlistSignups.me` per configured key for `result`,
+ *      `member.purchases` for `purchase` (never `flowCheckouts.me`),
+ *      `member.appointments` for `appointment`, and `subscription.me`'s own
+ *      `actionRequired` for `payment-due`.
  *   5. A 404 — or a 401/403 while the email is unverified — is "nothing for
  *      this caller" (`[]`); any other failed read rejects, a 401/403 for a
  *      verified email included, so the Inbox can show an error row (D12).
+ *   6. The member kinds call on a cookie-session site — no hub-credential
+ *      gate (#8231 D7).
+ *   7. #8233 D1, D2 — each New action is offered while its member read
+ *      answers: a 404 (or a switched-off request form, or an unverified
+ *      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)`.
  */
 
 const mockSignupMe = jest.fn();
 const mockCheckoutsMe = jest.fn();
 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: (...args: unknown[]) => mockSignupMe(...args) },
   flowCheckouts: { me: (...args: unknown[]) => mockCheckoutsMe(...args) },
   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),
+  },
 }));
 
 import type {
@@ -33,12 +57,16 @@ import type {
   AccountForYouSource,
   AccountInboxKind,
 } from "@working-theory/templates/account";
+import { requestQuoteFlowConfig } from "@working-theory/validation";
 
 import {
+  accountBillingSections,
   accountExperimentKeys,
   accountForYouSources,
   accountInboxKinds,
+  accountNewActions,
   accountSettingsSections,
+  type AccountNewRead,
 } from "../account-config";
 
 const INIT = { headers: { cookie: "session=abc" } };
@@ -79,17 +107,39 @@ const SIGNUP = {
   answers: { q3: null },
 };
 
-const CHECKOUT = {
-  id: "flchk_1",
-  flowSlug: "buy",
-  experimentKey: "diag",
-  offerKey: "pro",
-  status: "completed",
+const PURCHASE = {
+  id: "pur_1",
+  offering: "Pro plan",
   amountMinor: 4900,
   currency: "USD",
   period: "month",
-  completedAt: "2026-09-02T10:00:00.000Z",
-  createdAt: "2026-09-02T09:00:00.000Z",
+  purchasedAt: "2026-09-02T10:00:00.000Z",
+};
+
+const APPOINTMENT = {
+  id: "appt_1",
+  title: "Kickoff",
+  startTime: "2026-10-20T15:00:00.000Z",
+  endTime: "2026-10-20T15:30:00.000Z",
+  status: "confirmed" as const,
+};
+
+const PIECE = {
+  id: "piece_1",
+  title: "Brand guide",
+  stage: "in_progress",
+  needsClient: true,
+  createdAt: "2026-09-01T10:00:00.000Z",
+  updatedAt: "2026-09-03T10:00:00.000Z",
+};
+
+const MESSAGE = {
+  id: "intx_1",
+  subject: "Your draft",
+  body: "Attached.",
+  createdAt: "2026-09-04T10:00:00.000Z",
+  file: null,
+  readAt: null,
 };
 
 const ok = <T>(body: T) => ({ ok: true as const, body });
@@ -101,22 +151,30 @@ afterEach(() => {
 });
 
 describe("account-config exports (AC-6)", () => {
-  it("exports the three contribution arrays", () => {
+  it("exports the five contribution arrays", () => {
     expect(Array.isArray(accountInboxKinds)).toBe(true);
     expect(accountSettingsSections).toEqual([]);
     expect(Array.isArray(accountForYouSources)).toBe(true);
   });
 
-  it("ships exactly the base Inbox kinds and the member kinds (#7920), all Recents rows (D6a, D9)", () => {
+  it("ships the three New actions, by message key, and no Billing section (#8233 D2)", () => {
+    expect(accountNewActions.map((a) => [a.id, a.label])).toEqual([
+      ["schedule-service", "new.actions.scheduleService"],
+      ["request-quote", "new.actions.requestQuote"],
+      ["send-message", "new.actions.sendMessage"],
+    ]);
+    expect(accountBillingSections).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"],
-      ["purchase", "updates"],
+      ["purchase", "purchases"],
       ["piece", "updates"],
       ["message", "updates"],
+      ["appointment", "upcoming"],
     ]);
-    // Nothing in the base area fills Scheduled (the old Upcoming), and no
-    // Inbox row asks for a decision — that is the For-you panel's job.
-    expect(accountInboxKinds.some((k) => k.section === "upcoming")).toBe(false);
+    // No Inbox row asks for a decision — that is the For-you panel's job.
     expect(accountInboxKinds.some((k) => k.section === "needs-you")).toBe(false);
   });
 
@@ -152,7 +210,7 @@ describe("email-unverified — a For-you item from the session", () => {
       id: "email-unverified",
       type: { id: "email", label: "t:profile.email", tone: "needs-you" },
       title: "t:profile.unverified",
-      action: { kind: "open", href: "/account/settings#general" },
+      action: { kind: "open", href: "/account/general" },
       dismissible: true,
     });
   });
@@ -191,25 +249,30 @@ describe("result — waitlistSignups.me per accountExperimentKeys", () => {
   });
 });
 
-describe("purchase — flowCheckouts.me", () => {
-  it("is one item per checkout, at its completion time", async () => {
-    mockCheckoutsMe.mockResolvedValue(ok([CHECKOUT]));
+describe("purchase — member.purchases (#8231 D5)", () => {
+  const ITEM = { id: "pur_1", title: "Pro plan", at: PURCHASE.purchasedAt, data: PURCHASE };
+
+  it("sits in the purchases section", () => {
+    expect(kind("purchase").section).toBe("purchases");
+  });
+
+  it("is one item per purchase, at its purchase time, and never reads flowCheckouts.me", async () => {
+    mockMemberPurchases.mockResolvedValue(ok({ items: [PURCHASE] }));
     const items = await kind("purchase").load(ctx());
-    expect(mockCheckoutsMe).toHaveBeenCalledWith(INIT);
-    expect(items).toEqual([
-      { id: "flchk_1", title: "pro", at: CHECKOUT.completedAt, data: CHECKOUT },
-    ]);
+    expect(mockMemberPurchases).toHaveBeenCalledWith(INIT);
+    expect(mockCheckoutsMe).not.toHaveBeenCalled();
+    expect(items).toEqual([ITEM]);
   });
 
   it("is empty on a 404", async () => {
-    mockCheckoutsMe.mockResolvedValue(fail(404));
+    mockMemberPurchases.mockResolvedValue(fail(404));
     await expect(kind("purchase").load(ctx())).resolves.toEqual([]);
   });
 
   it.each([401, 403])(
     "is empty on a %i while the email is unverified",
     async (status) => {
-      mockCheckoutsMe.mockResolvedValue(fail(status));
+      mockMemberPurchases.mockResolvedValue(fail(status));
       await expect(
         kind("purchase").load(ctx({ emailVerified: false })),
       ).resolves.toEqual([]);
@@ -219,33 +282,114 @@ describe("purchase — flowCheckouts.me", () => {
   it.each([401, 403])(
     "rejects on a %i for a verified email",
     async (status) => {
-      mockCheckoutsMe.mockResolvedValue(fail(status));
+      mockMemberPurchases.mockResolvedValue(fail(status));
       await expect(kind("purchase").load(ctx())).rejects.toMatchObject({
         status,
       });
     },
   );
 
-  it("rejects on a failed read", async () => {
-    mockCheckoutsMe.mockResolvedValue(fail(503));
+  it("rejects on a 503", async () => {
+    mockMemberPurchases.mockResolvedValue(fail(503));
     await expect(kind("purchase").load(ctx())).rejects.toThrow();
   });
 
-  it("details the checkout's fields", () => {
-    const item = {
-      id: "flchk_1",
-      title: "pro",
-      at: CHECKOUT.completedAt,
-      data: CHECKOUT,
-    };
-    const detail = kind("purchase").renderDetail(item, ctx());
-    expect(detail.status).toBe("completed");
+  it("details the purchase's fields, with no status", () => {
+    const detail = kind("purchase").renderDetail(ITEM, ctx());
+    expect(detail.status).toBeUndefined();
     expect(detail.fields?.items.map((i) => i.label)).toEqual([
       "t:purchases.offer",
       "t:purchases.amount",
       "t:purchases.period",
       "t:purchases.date",
     ]);
+    expect(detail.fields?.items[0]?.value).toBe("Pro plan");
+  });
+
+  it("shows Not recorded for a null amount or period", () => {
+    const data = { ...PURCHASE, amountMinor: null, currency: null, period: null };
+    const detail = kind("purchase").renderDetail({ ...ITEM, data }, ctx());
+    const values = detail.fields?.items.map((i) => i.value);
+    expect(values?.[1]).toBe("t:purchases.unavailable");
+    expect(values?.[2]).toBe("t:purchases.unavailable");
+  });
+});
+
+describe("appointment — member.appointments (#8231 D6)", () => {
+  const PAST = {
+    ...APPOINTMENT,
+    id: "appt_0",
+    title: null,
+    startTime: "2026-09-10T15:00:00.000Z",
+    endTime: "2026-09-10T15:30:00.000Z",
+  };
+
+  it("sits in the upcoming section, named by its message key", () => {
+    expect(kind("appointment").section).toBe("upcoming");
+    expect(kind("appointment").label).toBe("appointments.heading");
+  });
+
+  it("returns the upcoming items then the past, flagged, at their start time", async () => {
+    mockMemberAppointments.mockResolvedValue(ok({ upcoming: [APPOINTMENT], past: [PAST] }));
+    const items = await kind("appointment").load(ctx());
+    expect(mockMemberAppointments).toHaveBeenCalledWith(INIT);
+    expect(items).toEqual([
+      { id: "appt_1", title: "Kickoff", at: APPOINTMENT.startTime, upcoming: true, data: APPOINTMENT },
+      { id: "appt_0", title: "t:appointments.untitled", at: PAST.startTime, upcoming: false, data: PAST },
+    ]);
+  });
+
+  it("is empty on a 404", async () => {
+    mockMemberAppointments.mockResolvedValue(fail(404));
+    await expect(kind("appointment").load(ctx())).resolves.toEqual([]);
+  });
+
+  it("rejects on a 503", async () => {
+    mockMemberAppointments.mockResolvedValue(fail(503));
+    await expect(kind("appointment").load(ctx())).rejects.toThrow();
+  });
+
+  it("details the status and the start and end", () => {
+    const item = { id: "appt_1", title: "Kickoff", at: APPOINTMENT.startTime, upcoming: true, data: APPOINTMENT };
+    const detail = kind("appointment").renderDetail(item, ctx());
+    expect(detail.status).toBe("t:appointments.statuses.confirmed");
+    expect(detail.fields?.items.map((i) => i.label)).toEqual([
+      "t:appointments.starts",
+      "t:appointments.ends",
+    ]);
+  });
+});
+
+describe("member kinds on a cookie-session site — no gate (#8231 D7)", () => {
+  it("piece reads member.pieces with the cookie init and returns its rows", async () => {
+    mockMemberPieces.mockResolvedValue(ok({ items: [PIECE] }));
+    const items = await kind("piece").load(ctx());
+    expect(mockMemberPieces).toHaveBeenCalledWith(INIT);
+    expect(items.map((i) => i.id)).toEqual(["piece_1"]);
+  });
+
+  it("message reads member.messages with the cookie init and returns its rows", async () => {
+    mockMemberMessages.mockResolvedValue(ok({ items: [MESSAGE] }));
+    const items = await kind("message").load(ctx());
+    expect(mockMemberMessages).toHaveBeenCalledWith(INIT);
+    expect(items.map((i) => i.id)).toEqual(["intx_1"]);
+  });
+
+  it("piece-needs-client reads member.pieces with the cookie init", async () => {
+    mockMemberPieces.mockResolvedValue(ok({ items: [PIECE] }));
+    const items = await source("piece-needs-client").load(ctx());
+    expect(mockMemberPieces).toHaveBeenCalledWith(INIT);
+    expect(items.map((i) => i.id)).toEqual(["piece:piece_1"]);
+  });
+
+  it.each([
+    ["piece", mockMemberPieces],
+    ["message", mockMemberMessages],
+  ] as const)("%s loads [] on a 404 and rejects on a 500", async (id, mock) => {
+    mock.mockResolvedValue(fail(404));
+    await expect(kind(id).load(ctx())).resolves.toEqual([]);
+    mock.mockResolvedValue(fail(500));
+    await expect(kind(id).load(ctx())).rejects.toThrow();
   });
 });
 
@@ -266,7 +410,7 @@ describe("payment-due — a For-you item from subscription.me's actionRequired",
       id: "payment-due",
       type: { id: "payment", label: "t:subscription.action", tone: "needs-you" },
       title: "t:subscription.headline",
-      action: { kind: "open", href: "/account/settings#billing" },
+      action: { kind: "open", href: "/account/billing" },
       dismissible: true,
     });
   });
@@ -286,3 +430,71 @@ describe("payment-due — a For-you item from subscription.me's actionRequired",
     await expect(source("payment-due").load(ctx())).rejects.toThrow();
   });
 });
+
+// ── #8233 — the New actions ──────────────────────────────────────────────────
+
+describe("New actions — offered while their member read answers (#8233 D1, D2)", () => {
+  function action(id: string): AccountNewRead {
+    const found = accountNewActions.find((a) => a.id === id);
+    if (!found) throw new Error(`no New action ${id}`);
+    return found;
+  }
+
+  const TYPE = { slug: "consult", title: "Consultation", durationMinutes: 30 };
+  const FORM = {
+    form: {
+      title: "Request a quote",
+      defaultLocale: "en",
+      steps: requestQuoteFlowConfig.steps,
+    },
+  };
+  const failure = (status: number) => ({
+    ok: false as const,
+    status,
+    body: { ok: false, error: { code: "failed", message: "x" } },
+  });
+
+  it.each([
+    ["{ items: [] }", true, ok({ items: [] })],
+    ["one type", true, ok({ items: [TYPE] })],
+    ["404", false, fail(404)],
+  ])("schedule-service: meetingTypes %s → %s", async (_name, offered, answer) => {
+    mockMemberMeetingTypes.mockResolvedValue(answer);
+    await expect(action("schedule-service").available(ctx())).resolves.toBe(offered);
+    expect(mockMemberMeetingTypes).toHaveBeenCalledWith(INIT);
+  });
+
+  it.each([
+    ["a form", true, ok(FORM)],
+    ["{ form: null }", false, ok({ form: null })],
+    ["404", false, fail(404)],
+  ])("request-quote: requestForm %s → %s", async (_name, offered, answer) => {
+    mockMemberRequestForm.mockResolvedValue(answer);
+    await expect(action("request-quote").available(ctx())).resolves.toBe(offered);
+    expect(mockMemberRequestForm).toHaveBeenCalledWith(INIT);
+  });
+
+  it("send-message: a messages 200 → true, read with ctx.init", async () => {
+    mockMemberMessages.mockResolvedValue(ok({ items: [] }));
+    await expect(action("send-message").available(ctx())).resolves.toBe(true);
+    expect(mockMemberMessages).toHaveBeenCalledWith(INIT);
+  });
+
+  it("send-message: 404 → false; 403 while the email is unverified → false", async () => {
+    mockMemberMessages.mockResolvedValue(fail(404));
+    await expect(action("send-message").available(ctx())).resolves.toBe(false);
+    mockMemberMessages.mockResolvedValue(fail(403));
+    await expect(action("send-message").available(ctx({ emailVerified: false }))).resolves.toBe(
+      false,
+    );
+  });
+
+  it.each([
+    ["schedule-service", 503, mockMemberMeetingTypes],
+    ["request-quote", 500, mockMemberRequestForm],
+    ["send-message", 503, mockMemberMessages],
+  ] as const)("%s rejects on a %i — a failed read is never reported as absent", async (id, status, mock) => {
+    mock.mockResolvedValue(failure(status));
+    await expect(action(id).available(ctx())).rejects.toMatchObject({ status });
+  });
+});

package/templates/apps/web/lib/__tests__/auth-email.test.ts

@@ -152,6 +152,90 @@ describe("sendResetPassword (§ D14 — the credential-account check)", () => {
   });
 });
 
+describe("sendResetPassword — the signed-in carve-out (#8431 D4)", () => {
+  const USER = { id: "user_1", email: "person@example.com" };
+  const RESET_URL = "https://site.example/api/auth/reset-password/tok";
+  const REQUEST = { headers: new Headers({ cookie: "session=abc" }) } as Request;
+
+  it("sends ONE password-reset to the account's own address when the session is that person's", async () => {
+    const send = jest.fn().mockResolvedValue({ ok: true, body: { ok: true } });
+    const { lines, log } = makeLog();
+    const sessionUserId = jest.fn().mockResolvedValue("user_1");
+    const cb = makeSendResetPassword({ prisma: makePrisma(false), send, log, sessionUserId });
+
+    await cb({ user: USER, url: RESET_URL }, REQUEST);
+
+    expect(sessionUserId).toHaveBeenCalledWith(REQUEST);
+    expect(send).toHaveBeenCalledTimes(1);
+    const [rawBody] = send.mock.calls[0] as [string];
+    expect(JSON.parse(rawBody)).toEqual({
+      kind: "password-reset",
+      userId: "user_1",
+      to: "person@example.com",
+      url: RESET_URL,
+      expiresInMinutes: 60,
+    });
+    expect(lines.some((l) => l.fields.reason === "self_service_set")).toBe(true);
+    expect(JSON.stringify(lines)).not.toContain("person@example.com");
+  });
+
+  it.each<[string, () => Promise<string | null>]>([
+    ["another person's id", () => Promise.resolve("user_2")],
+    ["null (no session)", () => Promise.resolve(null)],
+    ["a rejection", () => Promise.reject(new Error("db down"))],
+  ])("sends NOTHING and logs no address when the session lookup answers %s", async (_label, impl) => {
+    const send = jest.fn();
+    const { lines, log } = makeLog();
+    const cb = makeSendResetPassword({ prisma: makePrisma(false), send, log, sessionUserId: jest.fn(impl) });
+
+    await expect(cb({ user: USER, url: RESET_URL }, REQUEST)).resolves.toBeUndefined();
+
+    expect(send).not.toHaveBeenCalled();
+    expect(lines.some((l) => l.fields.reason === "no_credential_account")).toBe(true);
+    expect(JSON.stringify(lines)).not.toContain("person@example.com");
+  });
+
+  it("logs the failed lookup's kind only", async () => {
+    const { lines, log } = makeLog();
+    const cb = makeSendResetPassword({
+      prisma: makePrisma(false),
+      send: jest.fn(),
+      log,
+      sessionUserId: jest.fn().mockRejectedValue(new Error("person@example.com broke")),
+    });
+    await cb({ user: USER, url: RESET_URL }, REQUEST);
+    expect(lines).toEqual([
+      {
+        level: "warn",
+        fields: {
+          userId: "user_1",
+          kind: "password-reset",
+          reason: "no_credential_account",
+          errorKind: "session_lookup_failed",
+        },
+      },
+    ]);
+  });
+
+  it("with no sessionUserId it sends nothing, as before", async () => {
+    const send = jest.fn();
+    const { log } = makeLog();
+    const cb = makeSendResetPassword({ prisma: makePrisma(false), send, log });
+    await cb({ user: USER, url: RESET_URL }, REQUEST);
+    expect(send).not.toHaveBeenCalled();
+  });
+
+  it("a person WITH a password never needs the session lookup", async () => {
+    const send = jest.fn().mockResolvedValue({ ok: true, body: { ok: true } });
+    const { log } = makeLog();
+    const sessionUserId = jest.fn();
+    const cb = makeSendResetPassword({ prisma: makePrisma(true), send, log, sessionUserId });
+    await cb({ user: USER, url: RESET_URL });
+    expect(sessionUserId).not.toHaveBeenCalled();
+    expect(send).toHaveBeenCalledTimes(1);
+  });
+});
+
 describe("the § D12 PII boundary", () => {
   it("never logs the address, the token or the assembled link", async () => {
     const send = jest.fn().mockResolvedValue({ ok: true, body: { ok: true } });