create-ailk 0.26.0 → 0.28.0

package/templates/apps/web/lib/__tests__/pricing-page.test.ts

@@ -0,0 +1,142 @@
+/**
+ * The shared Pricing render (#10044 D5, AC-4): which offering pages `/pricing`
+ * lists, the card it lists each with, and `plans: []` reading no Stripe data.
+ */
+import {
+  PageSectionsSchema,
+  type PageSection,
+} from "@working-theory/validation";
+
+import {
+  offeringPricingPages,
+  pagePlans,
+  PRICING_HUB_SLUG,
+  pricingPageCard,
+  pricingSections,
+} from "../pricing-page";
+import type { DetailPage } from "../route-family";
+
+const fetchMock: jest.Mock = jest.fn(async () => ({
+  ok: true,
+  status: 200,
+  json: async () => ({ ok: true, data: { status: "unconnected" } }),
+}));
+
+beforeEach(() => {
+  global.fetch = fetchMock;
+  fetchMock.mockClear();
+});
+
+function page(slug: string, frontmatter: Record<string, unknown>): DetailPage {
+  return { slug, frontmatter: { type: "Pricing", slug, ...frontmatter } };
+}
+
+describe("offeringPricingPages (#10044 AC-4)", () => {
+  it("keeps a page whose frontmatter slug is its file slug, drops the hub and a mismatched slug, in input order", () => {
+    const pages = [
+      page("a", { title: "A" }),
+      page("b", { title: "B" }),
+      page(PRICING_HUB_SLUG, { title: "Pricing" }),
+      { slug: "x", frontmatter: { type: "Pricing", slug: "pricing" } },
+      { slug: "y", frontmatter: { type: "Pricing", slug: "other" } },
+    ];
+    expect(offeringPricingPages(pages).map((p) => p.slug)).toEqual(["a", "b"]);
+  });
+});
+
+describe("pricingPageCard (#10044 AC-4)", () => {
+  const labels = { viewPricing: "See pricing" };
+
+  it("carries the title, the summary over the description, and a link to /pricing/<slug>", () => {
+    expect(
+      pricingPageCard(
+        page("a", { title: "A", summary: "Short", description: "Long" }),
+        labels,
+      ),
+    ).toEqual({
+      title: "A",
+      description: "Short",
+      link: { label: "See pricing", href: "/pricing/a" },
+    });
+  });
+
+  it("falls back to the description without a summary", () => {
+    expect(
+      pricingPageCard(page("b", { title: "B", description: "Long" }), labels)
+        .description,
+    ).toBe("Long");
+  });
+
+  it("builds a pricing-pages section that parses PageSectionsSchema", () => {
+    const section = {
+      type: "items",
+      id: "pricing-pages",
+      data: {
+        headline: "Pricing by offering",
+        variant: "tile",
+        tileHover: "outline",
+        items: [
+          pricingPageCard(
+            page("a", { title: "A", summary: "S", description: "D" }),
+            labels,
+          ),
+          pricingPageCard(page("b", { title: "B", description: "D" }), labels),
+        ],
+      },
+    };
+    expect(PageSectionsSchema.safeParse([section]).success).toBe(true);
+  });
+});
+
+describe("pagePlans (#10044 D1)", () => {
+  it("reads the page's plans, or undefined when it names none", () => {
+    expect(pagePlans({ plans: ["a", "b"] })).toEqual(["a", "b"]);
+    expect(pagePlans({ plans: [] })).toEqual([]);
+    expect(pagePlans({})).toBeUndefined();
+    expect(pagePlans(null)).toBeUndefined();
+  });
+});
+
+describe("pricingSections (#10044 AC-4)", () => {
+  const declared: PageSection[] = PageSectionsSchema.parse([
+    {
+      id: "plans",
+      type: "pricing",
+      data: {
+        variant: "three-tiers-with-toggle",
+        billingToggle: false,
+        plans: [
+          {
+            key: "basic",
+            name: "Basic",
+            price: { monthly: "$29" },
+            features: [],
+            cta: { label: "Choose Basic", href: "/checkout/basic" },
+          },
+        ],
+      },
+    },
+  ]);
+
+  it("makes no shown-offerings read for `plans: []` and returns the declared sections", async () => {
+    const sections = await pricingSections(declared, {
+      plans: [],
+      plan: undefined,
+      locale: "en",
+    });
+    expect(fetchMock).not.toHaveBeenCalled();
+    expect(sections).toBe(declared);
+  });
+
+  it("moves `?plan=` onto the written sections for `plans: []`", async () => {
+    const sections = await pricingSections(declared, {
+      plans: [],
+      plan: "basic",
+      locale: "en",
+    });
+    expect(fetchMock).not.toHaveBeenCalled();
+    expect((sections[0]!.data as { recommended?: string }).recommended).toBe(
+      "basic",
+    );
+  });
+});

package/templates/apps/web/lib/__tests__/relay.test.ts

@@ -10,10 +10,18 @@
 //
 // Spec: docs/specs/7644-the-browser-talks-only-to-spec.md §5.1 AC-1 to AC-4.
 
-import { handleRelay, RELAY_ROUTES } from "../relay";
+import { ensureConsentVisitor } from "../consent-visitor";
+import { BOT_CHECKED_ROUTES, handleRelay, RELAY_ROUTES } from "../relay";
 import { __resetRelayRateLimit, __relayRateLimitBucketCount } from "../relay";
 import { TOPOLOGY } from "../topology.generated";
 
+// #9889 — the booking bot check's verdict. `checkBotId` reads Vercel's
+// request context, which jest has none of, so every case decides it here.
+const checkBotIdMock = jest.fn();
+jest.mock("botid/server", () => ({
+  checkBotId: (...args: unknown[]) => checkBotIdMock(...args),
+}));
+
 const HUB = "https://hub.example";
 const SITE = "https://spoke.example";
 const K1 = "K1";
@@ -27,6 +35,9 @@ const ENV_KEYS = [
   "NEXT_PUBLIC_API_URL",
   "AILK_SPOKE_KEY",
   "AILK_VISITOR_FORWARD_KEY",
+  "VERCEL",
+  "AILK_BOOKING_BOT_CHECK",
+  "AILK_BOT_CHECK",
 ] as const;
 const priorEnv = new Map<string, string | undefined>(
   ENV_KEYS.map((name) => [name, process.env[name]]),
@@ -460,14 +471,84 @@ describe("the banner's visitor id (#8438 D12)", () => {
   const VALID_ID = "11111111-2222-4333-8444-555555555555";
   const LEAD_PATHS = ["/v1/leads/submit", "/v1/leads/subscribe", "/v1/leads/callback"];
 
+  /** A cookie value the site signed (#8556), and the UUID it carries. */
+  function signedCookie(): { id: string; value: string } {
+    const set = jest.fn();
+    const id = ensureConsentVisitor({ get: () => undefined, set });
+    return { id, value: set.mock.calls[0][1] as string };
+  }
+
   it.each(LEAD_PATHS)(
-    "%s carries x-ailk-consent-visitor from the request's own ailk-vid cookie",
+    "%s carries x-ailk-consent-visitor from the request's own signed ailk-vid cookie",
     async (path) => {
-      await handleRelay(relayRequest(path, { headers: { cookie: `ailk-vid=${VALID_ID}` } }));
-      expect(sent().headers.get("x-ailk-consent-visitor")).toBe(VALID_ID);
+      const { id, value } = signedCookie();
+      await handleRelay(relayRequest(path, { headers: { cookie: `ailk-vid=${value}` } }));
+      expect(sent().headers.get("x-ailk-consent-visitor")).toBe(id);
     },
   );
 
+  // #8556: a well-formed id the browser chose is not one this site minted.
+  it("sends no header when the cookie is a bare UUID the site did not sign", async () => {
+    await handleRelay(relayRequest("/v1/leads/submit", { headers: { cookie: `ailk-vid=${VALID_ID}` } }));
+    expect(sent().headers.get("x-ailk-consent-visitor")).toBeNull();
+  });
+
+  it("sends no header when the cookie's signature has been changed", async () => {
+    const { value } = signedCookie();
+    const at = value.indexOf(".") + 1;
+    const changed = `${value.slice(0, at)}${value[at] === "A" ? "B" : "A"}${value.slice(at + 1)}`;
+    await handleRelay(relayRequest("/v1/leads/submit", { headers: { cookie: `ailk-vid=${changed}` } }));
+    expect(sent().headers.get("x-ailk-consent-visitor")).toBeNull();
+  });
+
+  /** Run `fn` as a production process with exactly `vars` among the signing secrets. */
+  async function inProduction(vars: Record<string, string>, fn: () => Promise<void>): Promise<void> {
+    const keys = ["NODE_ENV", "NEXT_PHASE", "BETTER_AUTH_SECRET", "AILK_HUB_SESSION_SECRET", "AILK_SPOKE_KEY"];
+    const saved = new Map(keys.map((key) => [key, process.env[key]]));
+    for (const key of keys) delete process.env[key];
+    Object.assign(process.env, { NODE_ENV: "production" }, vars);
+    try {
+      await fn();
+    } finally {
+      for (const [key, value] of saved) {
+        if (value === undefined) delete process.env[key];
+        else process.env[key] = value;
+      }
+    }
+  }
+
+  it("sends no header, and still relays, when the site has no usable secret", async () => {
+    const { value } = signedCookie();
+    await inProduction({}, async () => {
+      const res = await handleRelay(relayRequest("/v1/leads/submit", { headers: { cookie: `ailk-vid=${value}` } }));
+      expect(res.status).toBe(201);
+    });
+    expect(sent().headers.get("x-ailk-consent-visitor")).toBeNull();
+  });
+
+  // #8556 option (b): a production spoke has no BETTER_AUTH_SECRET by design.
+  // A minted spoke key is `ailk_spk_` plus 43 characters; the signer skips one under 32.
+  const SPOKE_KEY = `ailk_spk_${"k".repeat(43)}`;
+
+  it("a production spoke holding only AILK_SPOKE_KEY forwards the id it signed", async () => {
+    await inProduction({ AILK_SPOKE_KEY: SPOKE_KEY }, async () => {
+      const { id, value } = signedCookie();
+      await handleRelay(relayRequest("/v1/leads/submit", { headers: { cookie: `ailk-vid=${value}` } }));
+      expect(sent().headers.get("x-ailk-consent-visitor")).toBe(id);
+    });
+  });
+
+  it("a production spoke sends no header for an id another spoke key signed", async () => {
+    let value = "";
+    await inProduction({ AILK_SPOKE_KEY: `ailk_spk_${"o".repeat(43)}` }, async () => {
+      value = signedCookie().value;
+    });
+    await inProduction({ AILK_SPOKE_KEY: SPOKE_KEY }, async () => {
+      await handleRelay(relayRequest("/v1/leads/submit", { headers: { cookie: `ailk-vid=${value}` } }));
+    });
+    expect(sent().headers.get("x-ailk-consent-visitor")).toBeNull();
+  });
+
   it("sends no header when the request carries no ailk-vid cookie", async () => {
     await handleRelay(relayRequest("/v1/leads/submit"));
     expect(sent().headers.get("x-ailk-consent-visitor")).toBeNull();
@@ -885,3 +966,402 @@ describe("the per-visitor rate limit (#7707)", () => {
     );
   });
 });
+
+// The booking bot check (#9889, spec
+// docs/specs/9889-the-booking-bot-check-vercel-spec.md §5.1 AC-1 to AC-5).
+describe("the booking bot check (#9889)", () => {
+  const BOOK = "/v1/schedule/book";
+  const BOT = {
+    isHuman: false,
+    isBot: true,
+    isVerifiedBot: false,
+    bypassed: false,
+  };
+  const HUMAN = {
+    isHuman: true,
+    isBot: false,
+    isVerifiedBot: false,
+    bypassed: false,
+  };
+
+  let warnSpy: jest.SpyInstance;
+
+  beforeEach(() => {
+    checkBotIdMock.mockReset();
+    process.env.VERCEL = "1";
+    warnSpy = jest.spyOn(console, "warn").mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    warnSpy.mockRestore();
+  });
+
+  describe("AC-1 — a bot verdict is refused before the hub is called", () => {
+    it.each([
+      ["a bot", BOT],
+      ["a verified bot", { ...BOT, isVerifiedBot: true }],
+    ])("%s answers 403 bot_detected", async (_label, verdict) => {
+      checkBotIdMock.mockResolvedValue(verdict);
+      const res = await handleRelay(relayRequest(BOOK));
+      expect(res.status).toBe(403);
+      expect(await errorCode(res)).toBe("bot_detected");
+      expect(res.headers.get("cache-control")).toBe("no-store");
+      expect(fetchMock).not.toHaveBeenCalled();
+      expect(checkBotIdMock).toHaveBeenCalledTimes(1);
+      expect(checkBotIdMock.mock.calls[0]).toEqual([]);
+      expect(warnSpy).toHaveBeenCalledTimes(1);
+      expect(warnSpy).toHaveBeenCalledWith("[relay] bot refused", {
+        path: BOOK,
+        outcome: "bot-detected",
+      });
+    });
+  });
+
+  describe("AC-2 — a human verdict forwards exactly as with the check off", () => {
+    it("the same URL, method, body and headers, and no BotID header", async () => {
+      checkBotIdMock.mockResolvedValue(HUMAN);
+      const botIdHeaders = {
+        "x-is-human": "{}",
+        "x-path": BOOK,
+        "x-method": "POST",
+      };
+
+      delete process.env.VERCEL;
+      expect((await handleRelay(relayRequest(BOOK, { headers: botIdHeaders }))).status).toBe(201);
+      process.env.VERCEL = "1";
+      expect((await handleRelay(relayRequest(BOOK, { headers: botIdHeaders }))).status).toBe(201);
+
+      expect(checkBotIdMock).toHaveBeenCalledTimes(1);
+      expect(fetchMock).toHaveBeenCalledTimes(2);
+      const [off, on] = fetchMock.mock.calls.map(([url, init]) => ({
+        url,
+        method: init.method,
+        body: init.body,
+        headers: [...new Headers(init.headers).entries()],
+      }));
+      expect(on).toEqual(off);
+      const names = (on?.headers ?? []).map(([name]) => name);
+      for (const name of Object.keys(botIdHeaders)) {
+        expect(names).not.toContain(name);
+      }
+    });
+  });
+
+  describe("AC-3 — a check that cannot decide fails closed", () => {
+    function expectUnavailable(error: string): void {
+      expect(fetchMock).not.toHaveBeenCalled();
+      expect(errorSpy).toHaveBeenCalledTimes(1);
+      expect(errorSpy).toHaveBeenCalledWith("[relay] bot check failed", {
+        path: BOOK,
+        outcome: "bot-check-failed",
+        error,
+      });
+    }
+
+    it("a throw answers 503 and logs the error's name, never its message", async () => {
+      checkBotIdMock.mockRejectedValue(new Error("token abc"));
+      const res = await handleRelay(relayRequest(BOOK));
+      expect(res.status).toBe(503);
+      expect(await errorCode(res)).toBe("bot_check_unavailable");
+      expectUnavailable("Error");
+      expect(JSON.stringify(errorSpy.mock.calls)).not.toContain("token abc");
+    });
+
+    it.each([
+      ["an empty verdict", {}],
+      [
+        "Vercel's error answer",
+        {
+          isHuman: undefined,
+          isBot: undefined,
+          isVerifiedBot: undefined,
+          bypassed: undefined,
+        },
+      ],
+      ["a non-boolean isBot", { ...HUMAN, isBot: "false" }],
+    ])("%s answers 503 InvalidVerdictError", async (_label, verdict) => {
+      checkBotIdMock.mockResolvedValue(verdict);
+      const res = await handleRelay(relayRequest(BOOK));
+      expect(res.status).toBe(503);
+      expect(await errorCode(res)).toBe("bot_check_unavailable");
+      expectUnavailable("InvalidVerdictError");
+    });
+
+    describe("with fake timers", () => {
+      beforeEach(() => {
+        jest.useFakeTimers({
+          doNotFake: ["nextTick", "queueMicrotask", "setImmediate"],
+        });
+      });
+      afterEach(() => {
+        jest.useRealTimers();
+      });
+
+      it("no verdict within 5 000 ms answers 503 TimeoutError", async () => {
+        checkBotIdMock.mockReturnValue(new Promise(() => {}));
+        const pending = handleRelay(relayRequest(BOOK));
+        await jest.advanceTimersByTimeAsync(5_000);
+        const res = await pending;
+        expect(res.status).toBe(503);
+        expect(await errorCode(res)).toBe("bot_check_unavailable");
+        expectUnavailable("TimeoutError");
+      });
+
+      it("a check that settles in time leaves no timer pending", async () => {
+        checkBotIdMock.mockResolvedValue(BOT);
+        const res = await handleRelay(relayRequest(BOOK));
+        expect(res.status).toBe(403);
+        expect(jest.getTimerCount()).toBe(0);
+      });
+    });
+  });
+
+  describe("AC-4 — the switch", () => {
+    it.each([
+      ["VERCEL=1, AILK_BOOKING_BOT_CHECK=off", "1", "off"],
+      ['VERCEL=1, AILK_BOOKING_BOT_CHECK=" OFF "', "1", " OFF "],
+      ["VERCEL unset, switch unset", undefined, undefined],
+    ])("%s forwards with no BotID call", async (_label, vercel, check) => {
+      checkBotIdMock.mockResolvedValue(BOT);
+      if (vercel === undefined) delete process.env.VERCEL;
+      else process.env.VERCEL = vercel;
+      if (check === undefined) delete process.env.AILK_BOOKING_BOT_CHECK;
+      else process.env.AILK_BOOKING_BOT_CHECK = check;
+      const res = await handleRelay(relayRequest(BOOK));
+      expect(res.status).toBe(201);
+      expect(fetchMock).toHaveBeenCalledTimes(1);
+      expect(checkBotIdMock).not.toHaveBeenCalled();
+    });
+
+    it.each(["on", "0"])(
+      "VERCEL=1, AILK_BOOKING_BOT_CHECK=%s keeps the check on",
+      async (check) => {
+        checkBotIdMock.mockResolvedValue(BOT);
+        process.env.AILK_BOOKING_BOT_CHECK = check;
+        const res = await handleRelay(relayRequest(BOOK));
+        expect(res.status).toBe(403);
+        expect(await errorCode(res)).toBe("bot_detected");
+        expect(fetchMock).not.toHaveBeenCalled();
+      },
+    );
+
+    describe("in production, off Vercel", () => {
+      const env = process.env as Record<string, string | undefined>;
+      const priorNodeEnv = env.NODE_ENV;
+      beforeEach(() => {
+        env.NODE_ENV = "production";
+        delete process.env.VERCEL;
+      });
+      afterEach(() => {
+        env.NODE_ENV = priorNodeEnv;
+      });
+
+      async function twoBookings(): Promise<void> {
+        await jest.isolateModulesAsync(async () => {
+          const fresh = await import("../relay");
+          for (let i = 0; i < 2; i++) {
+            const res = await fresh.handleRelay(relayRequest(BOOK));
+            expect(res.status).toBe(201);
+          }
+        });
+      }
+
+      it("warns once per process that the check is not running", async () => {
+        await twoBookings();
+        expect(checkBotIdMock).not.toHaveBeenCalled();
+        expect(warnSpy).toHaveBeenCalledTimes(1);
+        expect(warnSpy).toHaveBeenCalledWith(
+          "[relay] booking bot check inactive",
+          { outcome: "not-on-vercel" },
+        );
+      });
+
+      it("with the switch off, warns nothing", async () => {
+        process.env.AILK_BOOKING_BOT_CHECK = "off";
+        await twoBookings();
+        expect(checkBotIdMock).not.toHaveBeenCalled();
+        expect(warnSpy).not.toHaveBeenCalled();
+      });
+    });
+  });
+
+  describe("AC-5 — only the booking, and only after the local refusals", () => {
+    beforeEach(() => {
+      checkBotIdMock.mockResolvedValue(BOT);
+    });
+
+    const isChecked = (e: { method: string; path: string }) =>
+      BOT_CHECKED_ROUTES.some((r) => r.method === e.method && r.path === e.path);
+
+    it.each(ENTRIES.filter((e) => !isChecked(e)))(
+      "$method $path forwards with no BotID call",
+      async (entry) => {
+        const res = await handleRelay(entryRequest(entry));
+        expect(res.status).toBe(201);
+        expect(fetchMock).toHaveBeenCalledTimes(1);
+        expect(checkBotIdMock).not.toHaveBeenCalled();
+      },
+    );
+
+    it("a cross-site booking answers 403 cross_site with no BotID call", async () => {
+      const res = await handleRelay(
+        relayRequest(BOOK, { headers: { "sec-fetch-site": "cross-site" } }),
+      );
+      expect(res.status).toBe(403);
+      expect(await errorCode(res)).toBe("cross_site");
+      expect(checkBotIdMock).not.toHaveBeenCalled();
+    });
+
+    it("an over-budget booking answers 429 with no BotID call", async () => {
+      const visitor = { "x-forwarded-for": "203.0.113.9" };
+      for (let i = 0; i < 8; i++) {
+        await handleRelay(
+          relayRequest(`/v1/schedule/availability${QUERY}`, { method: "GET", headers: visitor }),
+        );
+      }
+      const res = await handleRelay(relayRequest(BOOK, { headers: visitor }));
+      expect(res.status).toBe(429);
+      expect(await errorCode(res)).toBe("rate_limited");
+      expect(checkBotIdMock).not.toHaveBeenCalled();
+    });
+
+    it("a non-JSON booking answers 415 with no BotID call", async () => {
+      const res = await handleRelay(
+        relayRequest(BOOK, { headers: { "content-type": "text/plain" } }),
+      );
+      expect(res.status).toBe(415);
+      expect(checkBotIdMock).not.toHaveBeenCalled();
+    });
+
+    it("an oversized booking answers 413 with no BotID call", async () => {
+      const res = await handleRelay(
+        relayRequest(BOOK, { body: "x".repeat(1_048_577) }),
+      );
+      expect(res.status).toBe(413);
+      expect(checkBotIdMock).not.toHaveBeenCalled();
+    });
+
+    it("BOT_CHECKED_ROUTES is the three lead pairs and the booking pair, frozen, and RELAY_ROUTES' own entries", () => {
+      expect(BOT_CHECKED_ROUTES).toEqual([
+        { method: "POST", path: "/v1/leads/submit" },
+        { method: "POST", path: "/v1/leads/subscribe" },
+        { method: "POST", path: "/v1/leads/callback" },
+        { method: "POST", path: BOOK },
+      ]);
+      expect(Object.isFrozen(BOT_CHECKED_ROUTES)).toBe(true);
+      for (const checked of BOT_CHECKED_ROUTES) {
+        expect(checked).toBe(
+          RELAY_ROUTES.find((r) => r.method === checked.method && r.path === checked.path),
+        );
+      }
+    });
+  });
+});
+
+// The write bot check (#9255, spec
+// docs/specs/9255-an-edge-bot-challenge-in-spec.md §5.1 AC-3): the relay's
+// three lead routes join the booking's check.
+describe("the write bot check on the lead routes (#9255)", () => {
+  const LEAD_ROUTES = ["/v1/leads/submit", "/v1/leads/subscribe", "/v1/leads/callback"];
+  const BOT = {
+    isHuman: false,
+    isBot: true,
+    isVerifiedBot: false,
+    bypassed: false,
+  };
+  const HUMAN = { ...BOT, isHuman: true, isBot: false };
+
+  let warnSpy: jest.SpyInstance;
+
+  beforeEach(() => {
+    checkBotIdMock.mockReset();
+    process.env.VERCEL = "1";
+    warnSpy = jest.spyOn(console, "warn").mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    warnSpy.mockRestore();
+  });
+
+  it.each(LEAD_ROUTES)("POST %s: a bot answers 403 bot_detected with no hub call", async (path) => {
+    checkBotIdMock.mockResolvedValue(BOT);
+    const res = await handleRelay(relayRequest(path));
+    expect(res.status).toBe(403);
+    expect(await errorCode(res)).toBe("bot_detected");
+    expect(fetchMock).not.toHaveBeenCalled();
+    expect(checkBotIdMock).toHaveBeenCalledTimes(1);
+    expect(warnSpy).toHaveBeenCalledWith("[relay] bot refused", {
+      path,
+      outcome: "bot-detected",
+    });
+  });
+
+  it.each(LEAD_ROUTES)(
+    "POST %s: a check that throws answers 503 bot_check_unavailable with no hub call",
+    async (path) => {
+      checkBotIdMock.mockRejectedValue(new Error("token abc"));
+      const res = await handleRelay(relayRequest(path));
+      expect(res.status).toBe(503);
+      expect(await errorCode(res)).toBe("bot_check_unavailable");
+      expect(fetchMock).not.toHaveBeenCalled();
+      expect(errorSpy).toHaveBeenCalledWith("[relay] bot check failed", {
+        path,
+        outcome: "bot-check-failed",
+        error: "Error",
+      });
+      expect(JSON.stringify(errorSpy.mock.calls)).not.toContain("token abc");
+    },
+  );
+
+  it.each(LEAD_ROUTES)(
+    "POST %s: a human forwards once, exactly as with the check off",
+    async (path) => {
+      checkBotIdMock.mockResolvedValue(HUMAN);
+      const botIdHeaders = { "x-is-human": "{}", "x-path": path, "x-method": "POST" };
+
+      delete process.env.VERCEL;
+      expect((await handleRelay(relayRequest(path, { headers: botIdHeaders }))).status).toBe(201);
+      process.env.VERCEL = "1";
+      expect((await handleRelay(relayRequest(path, { headers: botIdHeaders }))).status).toBe(201);
+
+      expect(checkBotIdMock).toHaveBeenCalledTimes(1);
+      expect(fetchMock).toHaveBeenCalledTimes(2);
+      const [off, on] = fetchMock.mock.calls.map(([url, init]) => ({
+        url,
+        method: init.method,
+        body: init.body,
+        headers: [...new Headers(init.headers).entries()],
+      }));
+      expect(on).toEqual(off);
+      expect(on?.url).toBe(`${HUB}${path}`);
+    },
+  );
+
+  it.each([
+    { method: "GET", path: "/v1/schedule/availability" },
+    { method: "POST", path: "/v1/commerce/invoices" },
+  ])("$method $path forwards with no BotID call", async (entry) => {
+    checkBotIdMock.mockResolvedValue(BOT);
+    const res = await handleRelay(entryRequest(entry));
+    expect(res.status).toBe(201);
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    expect(checkBotIdMock).not.toHaveBeenCalled();
+  });
+
+  it("AILK_BOT_CHECK=off forwards a lead with no BotID call", async () => {
+    process.env.AILK_BOT_CHECK = "off";
+    checkBotIdMock.mockResolvedValue(BOT);
+    const res = await handleRelay(relayRequest("/v1/leads/submit"));
+    expect(res.status).toBe(201);
+    expect(checkBotIdMock).not.toHaveBeenCalled();
+  });
+
+  it("AILK_BOOKING_BOT_CHECK=off leaves the lead routes checked", async () => {
+    process.env.AILK_BOOKING_BOT_CHECK = "off";
+    checkBotIdMock.mockResolvedValue(BOT);
+    const res = await handleRelay(relayRequest("/v1/leads/submit"));
+    expect(res.status).toBe(403);
+    expect(await errorCode(res)).toBe("bot_detected");
+    expect(fetchMock).not.toHaveBeenCalled();
+  });
+});