@tribe-nest/forge 3.57.0 → 3.58.0

package/src/ui/headless/event/_tests/useEventCheckoutSeats.spec.tsx

@@ -0,0 +1,443 @@
+// @vitest-environment jsdom
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { act, renderHook, waitFor } from "@testing-library/react";
+import axios, { type AxiosAdapter, type InternalAxiosRequestConfig } from "axios";
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import type { ReactNode } from "react";
+import { ForgeClientProvider } from "../../../../provider/ForgeProvider";
+import { PublicAuthProvider } from "../../../../contexts/PublicAuthContext";
+import { CartProvider } from "../../../../contexts/CartContext";
+import { useEventCheckout } from "../useEventCheckout";
+import { buildLayout, buildSeating, GA_TIER, seatAt, seatingEvent, STALLS_TIER, TABLE_TIER } from "./seatingFixture";
+import type { PublicEventSeating } from "../../../../data/queries/useEvents";
+
+/**
+ * Seat selection inside the ticket checkout (seating wave 2), through the
+ * REAL hook with only the network faked.
+ *
+ * The rules under test are the ones a buyer would otherwise discover by being
+ * refused: a seated tier's quantity IS its seat selection, the per-person cap
+ * applies to seats, the order carries the seats, and seats another buyer took
+ * leave the selection with their names rather than as a generic failure.
+ */
+
+const PROFILE_ID = "profile-1";
+const SLUG = seatingEvent.slug;
+const EVENT_ID = seatingEvent.id;
+
+type Sent = { method: string; url: string; body: Record<string, unknown> };
+let sent: Sent[] = [];
+let realAdapter: AxiosAdapter | undefined;
+let seating: PublicEventSeating;
+let orderResponse: Record<string, unknown> | { reject: Record<string, unknown> };
+
+function installAdapter() {
+  sent = [];
+  const adapter: AxiosAdapter = async (config: InternalAxiosRequestConfig) => {
+    const url = config.url ?? "";
+    const body = typeof config.data === "string" ? (JSON.parse(config.data) as Record<string, unknown>) : {};
+    sent.push({ method: (config.method ?? "get").toLowerCase(), url, body });
+    const ok = (data: unknown) => ({ data, status: 200, statusText: "OK", headers: {}, config }) as never;
+
+    if (url.includes(`/public/events/${EVENT_ID}/seating`)) return ok(seating);
+    if (url.includes(`/public/events/${SLUG}`)) return ok(seatingEvent);
+    if (url.includes(`/public/events/${EVENT_ID}/orders`)) {
+      if ("reject" in orderResponse) {
+        throw Object.assign(new Error("Conflict"), {
+          isAxiosError: true,
+          config,
+          response: { status: 409, statusText: "Conflict", headers: {}, config, data: orderResponse.reject },
+        });
+      }
+      return ok(orderResponse);
+    }
+    if (url.includes(`/public/events/${EVENT_ID}/start-payment`)) {
+      return ok({ paymentSecret: "pi_secret", paymentId: "pi_1", paymentProvider: "stripe", totalAmount: 80 });
+    }
+    if (url.includes("/public/currencies")) {
+      return ok({ supportedCurrencies: ["USD"], userCurrency: "USD", exchangeRates: {} });
+    }
+    return ok({});
+  };
+  realAdapter = axios.defaults.adapter as AxiosAdapter | undefined;
+  axios.defaults.adapter = adapter;
+}
+
+const wrapper = ({ children }: { children: ReactNode }) => (
+  <QueryClientProvider
+    client={new QueryClient({ defaultOptions: { queries: { retry: false }, mutations: { retry: false } } })}
+  >
+    <ForgeClientProvider apiUrl="http://api.test" profileId={PROFILE_ID}>
+      <PublicAuthProvider>
+        <CartProvider>{children}</CartProvider>
+      </PublicAuthProvider>
+    </ForgeClientProvider>
+  </QueryClientProvider>
+);
+
+const mount = async () => {
+  const hook = renderHook(() => useEventCheckout(SLUG), { wrapper });
+  await waitFor(() => expect(hook.result.current.event?.id).toBe(EVENT_ID));
+  await waitFor(() => expect(hook.result.current.seating.isFetched).toBe(true));
+  return hook;
+};
+
+const fillDetails = (result: { current: ReturnType<typeof useEventCheckout> }) =>
+  act(() => {
+    result.current.setFirstName("Fan");
+    result.current.setLastName("Person");
+    result.current.setEmail("fan@example.com");
+  });
+
+const labelsOf = (result: { current: ReturnType<typeof useEventCheckout> }, tierId: string) =>
+  (result.current.selectedSeats[tierId] ?? []).map((id) => result.current.seating.byId.get(id)?.label);
+
+beforeEach(() => {
+  localStorage.clear();
+  seating = buildSeating(buildLayout());
+  orderResponse = {
+    orderId: "order-1",
+    totalAmount: 80,
+    subTotal: 80,
+    feeAmount: 0,
+    holdExpiresAt: "2026-12-01T18:00:00.000Z",
+  };
+  installAdapter();
+});
+
+afterEach(() => {
+  if (realAdapter) axios.defaults.adapter = realAdapter;
+  localStorage.clear();
+});
+
+describe("useEventCheckout: reserved seats", () => {
+  it("a seated tier's quantity is the size of its seat selection", async () => {
+    const { result } = await mount();
+    expect(result.current.isSeatedTier(STALLS_TIER)).toBe(true);
+    expect(result.current.isSeatedTier(TABLE_TIER)).toBe(true);
+    // Mapped through a GA area, so no seats: a plain quantity tier.
+    expect(result.current.isSeatedTier(GA_TIER)).toBe(false);
+    const a1 = seatAt(seating, "Stalls", "A", "1");
+    const a2 = seatAt(seating, "Stalls", "A", "2");
+
+    act(() => {
+      expect(result.current.toggleSeat(STALLS_TIER, a1)).toEqual({ ok: true, selected: true });
+    });
+    act(() => {
+      expect(result.current.toggleSeat(STALLS_TIER, a2)).toEqual({ ok: true, selected: true });
+    });
+    expect(result.current.selectedTickets).toEqual({ [STALLS_TIER]: 2 });
+    expect(result.current.ticketCount).toBe(2);
+    expect(result.current.subTotal).toBe(80);
+
+    act(() => {
+      expect(result.current.toggleSeat(STALLS_TIER, a1)).toEqual({ ok: true, selected: false });
+    });
+    expect(result.current.selectedTickets).toEqual({ [STALLS_TIER]: 1 });
+    expect(result.current.selectedSeats).toEqual({ [STALLS_TIER]: [a2] });
+
+    act(() => result.current.clearSeats(STALLS_TIER));
+    expect(result.current.selectedTickets).toEqual({});
+    expect(result.current.hasSeatedSelection).toBe(false);
+  });
+
+  it("the +/- stepper picks and drops best-available seats on a seated tier", async () => {
+    const { result } = await mount();
+    act(() => result.current.setTicketQty(STALLS_TIER, 2));
+    expect(labelsOf(result, STALLS_TIER)).toEqual(["Stalls · Row A · Seat 1", "Stalls · Row A · Seat 2"]);
+    expect(result.current.selectedTickets).toEqual({ [STALLS_TIER]: 2 });
+
+    // "+" adds the neighbour, building the party rather than scattering it.
+    act(() => result.current.setTicketQty(STALLS_TIER, 3));
+    expect(labelsOf(result, STALLS_TIER)).toEqual([
+      "Stalls · Row A · Seat 1",
+      "Stalls · Row A · Seat 2",
+      "Stalls · Row A · Seat 3",
+    ]);
+
+    // "-" drops the most recently picked seat, not the first.
+    act(() => result.current.setTicketQty(STALLS_TIER, 1));
+    expect(labelsOf(result, STALLS_TIER)).toEqual(["Stalls · Row A · Seat 1"]);
+    act(() => result.current.setTicketQty(STALLS_TIER, 0));
+    expect(result.current.selectedSeats).toEqual({});
+
+    // A GA tier with no seats on the map keeps the plain number.
+    act(() => result.current.setTicketQty(GA_TIER, 2));
+    expect(result.current.selectedTickets).toEqual({ [GA_TIER]: 2 });
+    expect(result.current.selectedSeats).toEqual({});
+  });
+
+  it("best available picks the lowest contiguous run and replaces the selection", async () => {
+    seating = buildSeating(buildLayout(), ["Stalls/A/2"]);
+    const { result } = await mount();
+    let picked = 0;
+    act(() => {
+      picked = result.current.pickBestAvailable(STALLS_TIER, 3);
+    });
+    expect(picked).toBe(3);
+    expect(labelsOf(result, STALLS_TIER)).toEqual([
+      "Stalls · Row B · Seat 1",
+      "Stalls · Row B · Seat 2",
+      "Stalls · Row B · Seat 3",
+    ]);
+    act(() => {
+      picked = result.current.pickBestAvailable(STALLS_TIER, 2);
+    });
+    expect(picked).toBe(2);
+    expect(labelsOf(result, STALLS_TIER)).toEqual(["Stalls · Row A · Seat 3", "Stalls · Row A · Seat 4"]);
+  });
+
+  it("maxPerPerson stops a fourth seat on a tier capped at three, by tap and by stepper", async () => {
+    const { result } = await mount();
+    const ids = ["1", "2", "3", "4"].map((n) => seatAt(seating, "Stalls", "A", n));
+    for (const id of ids.slice(0, 3)) {
+      act(() => {
+        expect(result.current.toggleSeat(STALLS_TIER, id).ok).toBe(true);
+      });
+    }
+    act(() => {
+      expect(result.current.toggleSeat(STALLS_TIER, ids[3]!)).toEqual({ ok: false, reason: "max" });
+    });
+    expect(result.current.selectedTickets).toEqual({ [STALLS_TIER]: 3 });
+
+    act(() => result.current.setTicketQty(STALLS_TIER, 5));
+    expect(result.current.selectedTickets).toEqual({ [STALLS_TIER]: 3 });
+    let picked = 0;
+    act(() => {
+      picked = result.current.pickBestAvailable(STALLS_TIER, 8);
+    });
+    expect(picked).toBe(3);
+  });
+
+  it("refuses an unavailable seat and a seat of another tier", async () => {
+    seating = buildSeating(buildLayout(), ["Stalls/A/1"]);
+    const { result } = await mount();
+    const a1 = seatAt(seating, "Stalls", "A", "1");
+    const table1 = seatAt(seating, "Table 1", "", "1");
+    act(() => {
+      expect(result.current.toggleSeat(STALLS_TIER, a1)).toEqual({ ok: false, reason: "unavailable" });
+      expect(result.current.toggleSeat(STALLS_TIER, table1)).toEqual({ ok: false, reason: "unknown" });
+      expect(result.current.toggleSeat(TABLE_TIER, table1).ok).toBe(true);
+    });
+    expect(result.current.selectedTickets).toEqual({ [TABLE_TIER]: 1 });
+  });
+
+  it("continueToPayment sends the seats per seated tier, and nothing extra on a GA-only cart", async () => {
+    const { result } = await mount();
+    const b1 = seatAt(seating, "Stalls", "B", "1");
+    const b2 = seatAt(seating, "Stalls", "B", "2");
+    act(() => {
+      result.current.toggleSeat(STALLS_TIER, b1);
+    });
+    act(() => {
+      result.current.toggleSeat(STALLS_TIER, b2);
+    });
+    await fillDetails(result);
+    await act(async () => {
+      await result.current.continueToPayment();
+    });
+
+    const order = sent.find((r) => r.method === "post" && r.url.includes("/orders"));
+    expect(order?.body).toMatchObject({
+      items: { [STALLS_TIER]: 2 },
+      seats: { [STALLS_TIER]: [b1, b2] },
+      email: "fan@example.com",
+    });
+    await waitFor(() => expect(result.current.step).toBe("payment"));
+    expect(result.current.seatSummary).toEqual([
+      {
+        ticketId: STALLS_TIER,
+        title: "Stalls",
+        seats: [
+          { id: b1, label: "Stalls · Row B · Seat 1" },
+          { id: b2, label: "Stalls · Row B · Seat 2" },
+        ],
+      },
+    ]);
+
+    // A cart with no seated selection posts the body it always did.
+    sent = [];
+    const ga = await mount();
+    act(() => ga.result.current.setTicketQty(GA_TIER, 2));
+    await fillDetails(ga.result);
+    await act(async () => {
+      await ga.result.current.continueToPayment();
+    });
+    const gaOrder = sent.find((r) => r.method === "post" && r.url.includes("/orders"));
+    expect(gaOrder?.body).toMatchObject({ items: { [GA_TIER]: 2 } });
+    expect(gaOrder?.body).not.toHaveProperty("seats");
+  });
+
+  it("a 409 seats_taken drops the named seats, refreshes the read, names them, and returns to the tickets step", async () => {
+    const { result } = await mount();
+    const a1 = seatAt(seating, "Stalls", "A", "1");
+    const a2 = seatAt(seating, "Stalls", "A", "2");
+    act(() => {
+      result.current.toggleSeat(STALLS_TIER, a1);
+    });
+    act(() => {
+      result.current.toggleSeat(STALLS_TIER, a2);
+    });
+    await fillDetails(result);
+    act(() => result.current.goToDetails());
+    expect(result.current.step).toBe("details");
+
+    orderResponse = { reject: { message: "Some of those seats were just taken.", details: { eventSeatIds: [a2] } } };
+    // The refreshed read agrees: A2 is gone.
+    seating = buildSeating(buildLayout(), ["Stalls/A/2"]);
+    const seatingReadsBefore = sent.filter((r) => r.url.includes("/seating")).length;
+
+    await act(async () => {
+      await result.current.continueToPayment();
+    });
+
+    expect(result.current.step).toBe("tickets");
+    expect(result.current.selectedSeats).toEqual({ [STALLS_TIER]: [a1] });
+    expect(result.current.selectedTickets).toEqual({ [STALLS_TIER]: 1 });
+    expect(result.current.seatsTaken).toEqual({ labels: ["Stalls · Row A · Seat 2"] });
+    // Not a generic failure, and not a coupon or a gate.
+    expect(result.current.error).toBeNull();
+    expect(result.current.gateRefusal).toBeNull();
+    await waitFor(() =>
+      expect(sent.filter((r) => r.url.includes("/seating")).length).toBeGreaterThan(seatingReadsBefore),
+    );
+    expect(sent.some((r) => r.url.includes("/start-payment"))).toBe(false);
+
+    act(() => result.current.dismissSeatsTaken());
+    expect(result.current.seatsTaken).toBeNull();
+  });
+
+  it("a selected seat that reads unavailable on a later poll is dropped with the same notice", async () => {
+    const { result } = await mount();
+    const a1 = seatAt(seating, "Stalls", "A", "1");
+    const a2 = seatAt(seating, "Stalls", "A", "2");
+    act(() => {
+      result.current.toggleSeat(STALLS_TIER, a1);
+    });
+    act(() => {
+      result.current.toggleSeat(STALLS_TIER, a2);
+    });
+    expect(result.current.selectedTickets).toEqual({ [STALLS_TIER]: 2 });
+
+    seating = buildSeating(buildLayout(), ["Stalls/A/1"]);
+    await act(async () => {
+      await result.current.seating.refetch();
+    });
+
+    await waitFor(() => expect(result.current.selectedSeats).toEqual({ [STALLS_TIER]: [a2] }));
+    expect(result.current.seatsTaken).toEqual({ labels: ["Stalls · Row A · Seat 1"] });
+    expect(result.current.selectedTickets).toEqual({ [STALLS_TIER]: 1 });
+  });
+
+  it("a seated selection goes to the bundle cart with its seat ids and labels, and a GA line is unchanged", async () => {
+    const { result } = await mount();
+    const a1 = seatAt(seating, "Stalls", "A", "1");
+    const a2 = seatAt(seating, "Stalls", "A", "2");
+    act(() => {
+      result.current.toggleSeat(STALLS_TIER, a1);
+    });
+    act(() => {
+      result.current.toggleSeat(STALLS_TIER, a2);
+    });
+    act(() => result.current.setTicketQty(GA_TIER, 1));
+    expect(result.current.hasSeatedSelection).toBe(true);
+
+    let added: boolean | undefined;
+    act(() => {
+      added = result.current.addTicketsToCart();
+    });
+    expect(added).toBe(true);
+    expect(result.current.ticketsInCart).toBe(true);
+    expect(result.current.error).toBeNull();
+
+    // The persisted line, as the cart and the bundle checkout will read it.
+    const saved = JSON.parse(localStorage.getItem("tribenest-cart") ?? "{}") as {
+      tickets: {
+        eventId: string;
+        eventSlug: string;
+        tickets: Record<string, number>;
+        ticketMeta: Record<string, unknown>;
+      }[];
+    };
+    expect(saved.tickets).toHaveLength(1);
+    const line = saved.tickets[0]!;
+    expect(line.eventId).toBe(EVENT_ID);
+    expect(line.eventSlug).toBe(SLUG);
+    // A seated tier's quantity is its seat count.
+    expect(line.tickets).toEqual({ [STALLS_TIER]: 2, [GA_TIER]: 1 });
+    expect(line.ticketMeta[STALLS_TIER]).toEqual({
+      title: "Stalls",
+      price: 40,
+      seatIds: [a1, a2],
+      seats: [
+        { id: a1, label: "Stalls · Row A · Seat 1" },
+        { id: a2, label: "Stalls · Row A · Seat 2" },
+      ],
+    });
+    // A general admission tier carries no seat fields at all.
+    expect(line.ticketMeta[GA_TIER]).toEqual({ title: "Standing", price: 20 });
+  });
+
+  it("restores a seated selection the cart already holds for this event, dropping a seat that has since gone", async () => {
+    const a1 = seatAt(seating, "Stalls", "A", "1");
+    const a2 = seatAt(seating, "Stalls", "A", "2");
+    localStorage.setItem(
+      "tribenest-cart",
+      JSON.stringify({
+        items: [],
+        tickets: [
+          {
+            eventId: EVENT_ID,
+            eventSlug: SLUG,
+            eventTitle: "Seated show",
+            tickets: { [STALLS_TIER]: 2, [GA_TIER]: 1 },
+            ticketMeta: {
+              [STALLS_TIER]: {
+                title: "Stalls",
+                price: 40,
+                seatIds: [a1, a2],
+                seats: [
+                  { id: a1, label: "Stalls · Row A · Seat 1" },
+                  { id: a2, label: "Stalls · Row A · Seat 2" },
+                ],
+              },
+              [GA_TIER]: { title: "Standing", price: 20 },
+            },
+            bookingFee: null,
+          },
+        ],
+      }),
+    );
+    // A2 went to somebody else while the buyer was away.
+    seating = buildSeating(buildLayout(), ["Stalls/A/2"]);
+    const { result } = await mount();
+
+    await waitFor(() => expect(result.current.selectedSeats).toEqual({ [STALLS_TIER]: [a1] }));
+    // The GA line came back too, so re-adding the event keeps the whole line.
+    expect(result.current.selectedTickets).toEqual({ [STALLS_TIER]: 1, [GA_TIER]: 1 });
+    expect(result.current.seatsTaken).toEqual({ labels: ["Stalls · Row A · Seat 2"] });
+    expect(result.current.ticketsInCart).toBe(true);
+  });
+
+  it("a plain ticket line in the cart restores nothing", async () => {
+    localStorage.setItem(
+      "tribenest-cart",
+      JSON.stringify({
+        items: [],
+        tickets: [
+          {
+            eventId: EVENT_ID,
+            eventSlug: SLUG,
+            eventTitle: "Seated show",
+            tickets: { [GA_TIER]: 2 },
+            ticketMeta: { [GA_TIER]: { title: "Standing", price: 20 } },
+            bookingFee: null,
+          },
+        ],
+      }),
+    );
+    const { result } = await mount();
+    expect(result.current.selectedTickets).toEqual({});
+    expect(result.current.ticketsInCart).toBe(true);
+  });
+});

package/src/ui/headless/event/_tests/useEventSeating.spec.tsx

@@ -0,0 +1,154 @@
+// @vitest-environment jsdom
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { renderHook, waitFor } from "@testing-library/react";
+import axios, { type AxiosAdapter, type InternalAxiosRequestConfig } from "axios";
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import type { ReactNode } from "react";
+import { ForgeClientProvider } from "../../../../provider/ForgeProvider";
+import { bestAvailableSeats, indexEventSeats, useEventSeating } from "../useEventSeating";
+import { buildLayout, buildSeating, seatAt, STALLS_TIER, TABLE_TIER } from "./seatingFixture";
+
+/**
+ * The joined seating read (seating wave 2).
+ *
+ * The network is faked at the axios adapter, so what is asserted is the
+ * request that goes over the wire and the index built from what comes back:
+ * every seat reachable by event id and by layout id, availability counted per
+ * tier, and the read polled while the picker is open.
+ */
+
+const PROFILE_ID = "profile-1";
+const EVENT_ID = "ev-seated";
+
+let realAdapter: AxiosAdapter | undefined;
+let seatingRequests: { url: string; params: Record<string, unknown> }[] = [];
+let seatingResponse: unknown;
+
+function installAdapter() {
+  seatingRequests = [];
+  const adapter: AxiosAdapter = async (config: InternalAxiosRequestConfig) => {
+    const url = config.url ?? "";
+    const ok = (data: unknown) => ({ data, status: 200, statusText: "OK", headers: {}, config }) as never;
+    if (url.includes(`/public/events/${EVENT_ID}/seating`)) {
+      seatingRequests.push({ url, params: (config.params ?? {}) as Record<string, unknown> });
+      return ok(seatingResponse);
+    }
+    return ok({});
+  };
+  realAdapter = axios.defaults.adapter as AxiosAdapter | undefined;
+  axios.defaults.adapter = adapter;
+}
+
+const wrapper = ({ children }: { children: ReactNode }) => (
+  <QueryClientProvider client={new QueryClient({ defaultOptions: { queries: { retry: false } } })}>
+    <ForgeClientProvider apiUrl="http://api.test" profileId={PROFILE_ID}>
+      {children}
+    </ForgeClientProvider>
+  </QueryClientProvider>
+);
+
+beforeEach(() => {
+  installAdapter();
+  seatingResponse = buildSeating(buildLayout(), ["Stalls/A/2"]);
+});
+
+afterEach(() => {
+  if (realAdapter) axios.defaults.adapter = realAdapter;
+});
+
+describe("useEventSeating", () => {
+  it("reads the seating for the tenant and indexes it by event id and by layout id", async () => {
+    const { result } = renderHook(() => useEventSeating(EVENT_ID, { pollMs: 0 }), { wrapper });
+    await waitFor(() => expect(result.current.seating).toBeTruthy());
+
+    expect(seatingRequests[0]?.url).toContain(`/public/events/${EVENT_ID}/seating`);
+    expect(seatingRequests[0]?.params).toMatchObject({ profileId: PROFILE_ID });
+
+    // 8 stalls seats + 4 table seats. The GA area has no seats.
+    expect(result.current.seats).toHaveLength(12);
+    expect(result.current.byId.size).toBe(12);
+    expect(result.current.bySource.size).toBe(12);
+
+    const a1 = seatAt(seatingResponse as never, "Stalls", "A", "1");
+    const entry = result.current.byId.get(a1)!;
+    expect(entry.label).toBe("Stalls · Row A · Seat 1");
+    expect(entry.eventTicketId).toBe(STALLS_TIER);
+    expect(result.current.bySource.get(entry.sourceSeatId)).toBe(entry);
+
+    const tableSeat = result.current.seats.find((s) => s.eventTicketId === TABLE_TIER)!;
+    expect(tableSeat.label).toBe("Table 1 · Seat 1");
+    expect(tableSeat.rowLabel).toBe("");
+
+    // A2 is unavailable, so the stalls tier has 7 left and the table all 4.
+    expect(result.current.availableByTier).toEqual({ [STALLS_TIER]: 7, [TABLE_TIER]: 4 });
+    // The GA area maps a category to the standing tier, but puts no seat on the
+    // map, so that tier is NOT seated and keeps its plain quantity.
+    expect([...result.current.seatedTierIds].sort()).toEqual([STALLS_TIER, TABLE_TIER].sort());
+  });
+
+  it("polls while enabled, and requests nothing while disabled", async () => {
+    const polling = renderHook(() => useEventSeating(EVENT_ID, { pollMs: 30 }), { wrapper });
+    await waitFor(() => expect(polling.result.current.seating).toBeTruthy());
+    await waitFor(() => expect(seatingRequests.length).toBeGreaterThanOrEqual(3), { timeout: 3000 });
+    // Unmounted, so the poll below cannot be its.
+    polling.unmount();
+
+    installAdapter();
+    const disabled = renderHook(() => useEventSeating(EVENT_ID, { enabled: false, pollMs: 30 }), { wrapper });
+    await new Promise((resolve) => setTimeout(resolve, 120));
+    expect(seatingRequests).toHaveLength(0);
+    expect(disabled.result.current.isLoading).toBe(false);
+    expect(disabled.result.current.seating).toBeUndefined();
+  });
+
+  it("an event with no seat map reads null and indexes nothing", async () => {
+    seatingResponse = null;
+    const { result } = renderHook(() => useEventSeating(EVENT_ID, { pollMs: 0 }), { wrapper });
+    await waitFor(() => expect(result.current.isFetched).toBe(true));
+    expect(result.current.seating).toBeNull();
+    expect(result.current.seats).toEqual([]);
+    expect(result.current.availableByTier).toEqual({});
+    expect(result.current.seatedTierIds.size).toBe(0);
+  });
+});
+
+describe("bestAvailableSeats", () => {
+  const seating = buildSeating(buildLayout(), ["Stalls/A/2"]);
+  const { seats } = indexEventSeats(seating);
+  const labels = (picked: { label: string }[]) => picked.map((s) => s.label);
+
+  it("picks the lowest contiguous run, skipping a row an unavailable seat breaks", () => {
+    // Row A holds 1, 3, 4: no run of three. Row B is the first that does.
+    expect(labels(bestAvailableSeats(seats, STALLS_TIER, 3))).toEqual([
+      "Stalls · Row B · Seat 1",
+      "Stalls · Row B · Seat 2",
+      "Stalls · Row B · Seat 3",
+    ]);
+    // A run of two exists in row A, after the gap.
+    expect(labels(bestAvailableSeats(seats, STALLS_TIER, 2))).toEqual(["Stalls · Row A · Seat 3", "Stalls · Row A · Seat 4"]);
+  });
+
+  it("falls back to the lowest seats when no row has a long enough run", () => {
+    expect(labels(bestAvailableSeats(seats, STALLS_TIER, 5))).toEqual([
+      "Stalls · Row A · Seat 1",
+      "Stalls · Row A · Seat 3",
+      "Stalls · Row A · Seat 4",
+      "Stalls · Row B · Seat 1",
+      "Stalls · Row B · Seat 2",
+    ]);
+  });
+
+  it("never offers an unavailable seat, an excluded seat, or another tier's seat", () => {
+    const a1 = seatAt(seating, "Stalls", "A", "1");
+    const picked = bestAvailableSeats(seats, STALLS_TIER, 8, new Set([a1]));
+    expect(picked).toHaveLength(6);
+    expect(picked.every((s) => s.eventTicketId === STALLS_TIER && s.status === "available" && s.id !== a1)).toBe(true);
+    expect(bestAvailableSeats(seats, "t-ga", 1)).toEqual([]);
+  });
+
+  it("adds a neighbour of a seat already held before any lower seat", () => {
+    const b2 = seats.find((s) => s.label === "Stalls · Row B · Seat 2")!;
+    const picked = bestAvailableSeats(seats, STALLS_TIER, 1, new Set([b2.id]), [b2]);
+    expect(labels(picked)).toEqual(["Stalls · Row B · Seat 1"]);
+  });
+});