@tribe-nest/forge 3.54.0 → 3.58.0

package/src/types/models.ts

@@ -307,6 +307,116 @@ export type MembershipTier = {
   welcomeMessageContent?: string | null;
   cancellationMessageSubject?: string | null;
   cancellationMessageContent?: string | null;
+  /**
+   * How a fan gets onto this tier (curated access). `open` is the ordinary
+   * checkout; `invite` needs a live invite for the signed-in email (and the
+   * tier is only listed when the request carried that invite's token);
+   * `application` means the fan applies and the business approves. Optional,
+   * because an older API build sends nothing, which reads as `open`.
+   */
+  joinMode?: MembershipJoinMode;
+  /**
+   * The signed-in fan's most recent open application on this tier (or their
+   * latest declined one), so the tier card can show where it stands instead of
+   * a join button. Absent when signed out or on an older API build.
+   */
+  myApplication?: MembershipTierMyApplication | null;
+  /**
+   * Free trial length in days on a paid tier (1 to 90), or null for no trial.
+   * A card is still collected; the first charge is on today + trialDays.
+   */
+  trialDays?: number | null;
+  /**
+   * False once the signed-in fan has had a trial with this business (one per
+   * fan per business, any tier). Absent when signed out: treat as eligible.
+   */
+  trialEligible?: boolean;
+  /**
+   * Questions the fan answers before paying or joining, on every join mode.
+   * Null or absent when the tier asks nothing.
+   */
+  questionnaire?: QuestionnaireQuestion[] | null;
+};
+
+/** How a fan gets onto a membership tier. */
+export type MembershipJoinMode = "open" | "invite" | "application";
+
+/**
+ * Where an application to a membership tier stands.
+ *
+ *   card_pending    paid tier: card step started, not confirmed. Not yet visible to the business.
+ *   pending         lodged and waiting for a decision; holds a seat
+ *   approved        approved; the subscription is being created
+ *   payment_failed  approved, but the saved card was declined; the fan can finish at checkout
+ *   joined          the membership exists
+ *   declined        not approved
+ *   withdrawn       withdrawn by the fan, or closed because the tier filled (`closedReason: "tier_full"`)
+ *   expired         the window to finish a failed payment lapsed
+ */
+export type MembershipApplicationStatus =
+  | "card_pending"
+  | "pending"
+  | "approved"
+  | "payment_failed"
+  | "joined"
+  | "declined"
+  | "withdrawn"
+  | "expired";
+
+/** The slice of an application the public tier list carries per tier. */
+export type MembershipTierMyApplication = {
+  id: string;
+  status: MembershipApplicationStatus;
+  paymentWindowExpiresAt: string | null;
+};
+
+export type MembershipApplication = {
+  id: string;
+  profileId: string;
+  membershipTierId: string;
+  /** Present on list payloads. */
+  membershipTierName?: string;
+  accountId: string;
+  status: MembershipApplicationStatus;
+  /** Null on a free tier. */
+  billingCycle: "month" | "year" | null;
+  /** What will be charged per cycle, in major units. Null on a free tier. */
+  amount: number | null;
+  currency: string | null;
+  /** A note from an older checkout. Current checkouts ask the tier's questions instead. */
+  message: string | null;
+  /** The fan's answers to the tier's questions, as given when applying. */
+  questionnaire?: QuestionnaireAnswer[] | null;
+  /** e.g. "Visa •••• 4242", set once the card is confirmed. */
+  instrumentLabel: string | null;
+  decidedAt: string | null;
+  decisionNote: string | null;
+  /** `"tier_full"`, `"expired"`, or the provider's decline reason on `payment_failed`. */
+  closedReason: string | null;
+  /** The deadline to finish a `payment_failed` application. */
+  paymentWindowExpiresAt: string | null;
+  membershipId: string | null;
+  createdAt: string;
+  updatedAt: string;
+};
+
+/** What `POST /public/membership-applications` answers. */
+export type ApplyForMembershipResult = {
+  application: MembershipApplication;
+  /** True on a paid tier until the card is confirmed. */
+  requiresCard: boolean;
+  /** A Stripe SetupIntent secret (`seti_..._secret_...`) when `requiresCard`. */
+  clientSecret: string | null;
+};
+
+/** What `GET /public/membership-invites/info` answers for a live invite. */
+export type MembershipInviteInfo = {
+  membershipTierId: string;
+  membershipTierName: string;
+  profileId: string;
+  /** The address the invite was sent to; the fan must be signed in with it. */
+  email: string;
+  expiresAt: string;
 };
 
 /**
@@ -346,6 +456,10 @@ export interface Membership {
   subscriptionAmount: number;
   subscriptionCurrency: string;
   billingCycle: string;
+  /** Set when the membership started with a free trial: when the first charge is due. */
+  trialEndsAt?: string | null;
+  /** The fan's answers to the tier's questions, as given when joining. */
+  questionnaire?: QuestionnaireAnswer[] | null;
 }
 
 // ---- Public auth -------------------------------------------------------------
@@ -911,6 +1025,19 @@ export type QuestionnaireQuestion = {
   optional?: boolean;
 };
 
+/**
+ * A fan's answer to one {@link QuestionnaireQuestion}, as sent at checkout and
+ * as stored on what the checkout created. `answer` is `""` for an optional
+ * question left blank.
+ */
+export type QuestionnaireAnswer = {
+  id: string;
+  question: string;
+  type: string;
+  options?: string[];
+  answer: string;
+};
+
 /**
  * S.6 — the cancellation terms a buyer is entitled to read BEFORE they pay.
  *
@@ -1170,6 +1297,16 @@ export interface IEvent {
    * than trusting its absence.
    */
   hasApprovalTiers?: boolean;
+  /**
+   * This event sells RESERVED seats from a bound seat map (seating wave 2).
+   *
+   * When true, `GET /public/events/:id/seating` returns the frozen layout and
+   * the per-seat availability, and a tier that has seats on that map requires
+   * `seats[ticketId]` on the order. Optional on the wire: an API build that
+   * predates seat maps sends nothing, and a renderer must treat absent as
+   * "general admission only", which is exactly what every event was before.
+   */
+  hasSeatMap?: boolean;
   media: IMedia[];
   slug: string;
   /**

package/src/ui/analytics/ForgeAnalytics.tsx

@@ -4,6 +4,7 @@ import { useSiteConfig } from "../../data/queries/useWebsite";
 import { initMetaPixelScoped, fireMetaEventSingle } from "../../utils/metaPixel";
 import { setCurrentPageEventId, isProfilePixelSuppressed } from "../../utils/analyticsBus";
 import { useCookieConsent } from "../headless/consent/useCookieConsent";
+import { createEngagementTracker, scrollDepthOf, type EngagementTracker } from "../../utils/engagementTracker";
 
 export interface ForgeAnalyticsProps {
   /**
@@ -58,6 +59,11 @@ function currentPage(): string {
   return window.location.pathname + window.location.search;
 }
 
+/** Engaged means the visitor can see the page and it has focus. */
+function isEngaged(): boolean {
+  return typeof document !== "undefined" && document.visibilityState === "visible" && document.hasFocus();
+}
+
 /**
  * Drop-in website analytics. Render once, high in the tree (inside
  * `ForgeProvider`), and it wires the site into the platform's analytics:
@@ -65,6 +71,8 @@ function currentPage(): string {
  * - Auto page views on every navigation → `POST /public/websites/track-event`,
  *   surfaced in the admin analytics dashboard (visits, pages, geo).
  * - Auto click tracking on links/buttons (opt out with `trackClicks={false}`).
+ * - Time on page and scroll depth, as `engagement` events (engaged time only:
+ *   visible and focused).
  * - Optional Meta Pixel: pass `metaPixelId` to init the pixel and mirror each
  *   page view as a Meta `PageView` (event-id matched for CAPI de-dup).
  *
@@ -95,8 +103,19 @@ export function ForgeAnalytics({
   // runs regardless but only stores a device session once the visitor turns
   // Performance on — otherwise it stays cookieless (backend derives the id).
   const storeSession = cookieless ? perfConsent : true;
-  const { track } = useTrackEvent({ storeSession });
+  const { track, trackBeacon } = useTrackEvent({ storeSession });
   const lastPage = useRef<string | null>(null);
+  // Time on page. Pings go by beacon: most are sent as the page is hidden or
+  // unloaded, which cancels an ordinary request.
+  const beaconRef = useRef(trackBeacon);
+  beaconRef.current = trackBeacon;
+  const engagement = useRef<EngagementTracker | null>(null);
+  if (engagement.current === null) {
+    engagement.current = createEngagementTracker({
+      now: () => Date.now(),
+      send: (ping) => beaconRef.current("engagement", ping),
+    });
+  }
 
   // Consent gates. The Meta Pixel always needs `marketing`. First-party analytics
   // needs `performance` — UNLESS it's cookieless (stores nothing without consent),
@@ -129,6 +148,10 @@ export function ForgeAnalytics({
       // can dedupe against the same page view.
       setCurrentPageEventId(eventId);
       if (firstPartyOn) {
+        // Close the previous page's time before this page view is recorded, so
+        // the ping lands on the page it measured.
+        engagement.current?.flush();
+        engagement.current?.start(currentPathname(), isEngaged());
         track("page_view", {
           // `pathname` (full resolved path) is what the admin "top pages" report
           // groups on; `page` keeps the query string for detail.
@@ -178,6 +201,37 @@ export function ForgeAnalytics({
     };
   }, [firstPartyOn, metaOn, pixelId, track]);
 
+  // Engagement: first-party only, like the page views it belongs to.
+  useEffect(() => {
+    const tracker = engagement.current;
+    if (!firstPartyOn || !tracker || typeof window === "undefined") return;
+
+    const pause = () => {
+      tracker.deactivate();
+      tracker.flush();
+    };
+    const resume = () => {
+      if (isEngaged()) tracker.activate();
+    };
+    const onVisibility = () => (document.visibilityState === "visible" ? resume() : pause());
+    const onScroll = () => tracker.scrolled(scrollDepthOf(document, window));
+
+    onScroll();
+    document.addEventListener("visibilitychange", onVisibility);
+    window.addEventListener("blur", pause);
+    window.addEventListener("focus", resume);
+    window.addEventListener("pagehide", pause);
+    window.addEventListener("scroll", onScroll, { passive: true });
+    return () => {
+      pause();
+      document.removeEventListener("visibilitychange", onVisibility);
+      window.removeEventListener("blur", pause);
+      window.removeEventListener("focus", resume);
+      window.removeEventListener("pagehide", pause);
+      window.removeEventListener("scroll", onScroll);
+    };
+  }, [firstPartyOn]);
+
   // Click tracking — first-party only, one delegated listener for the document.
   useEffect(() => {
     if (!firstPartyOn || !trackClicks || typeof document === "undefined") return;

package/src/ui/analytics/_tests/ForgeAnalytics.engagement.spec.tsx

@@ -0,0 +1,78 @@
+// @vitest-environment jsdom
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { render, act, cleanup } from "@testing-library/react";
+
+/**
+ * The wiring around the engagement tracker: which page a ping is attributed
+ * to, and which transport carries it. The ordering on an SPA navigation is the
+ * part that breaks quietly: send the ping after the new page view and every
+ * page's time lands on the page the visitor went to next.
+ */
+
+const calls: { via: "track" | "beacon"; eventType: string; data: Record<string, unknown> }[] = [];
+
+vi.mock("../../../data/queries/useAnalytics", () => ({
+  newEventId: () => "evt",
+  useTrackEvent: () => ({
+    track: (eventType: string, data: Record<string, unknown>) => calls.push({ via: "track", eventType, data }),
+    trackBeacon: (eventType: string, data: Record<string, unknown>) => calls.push({ via: "beacon", eventType, data }),
+  }),
+}));
+vi.mock("../../../data/queries/useWebsite", () => ({ useSiteConfig: () => ({ data: undefined }) }));
+vi.mock("../../headless/consent/useCookieConsent", () => ({
+  useCookieConsent: () => ({ performance: true, marketing: false }),
+}));
+
+import { ForgeAnalytics } from "../ForgeAnalytics";
+
+describe("<ForgeAnalytics /> engagement", () => {
+  beforeEach(() => {
+    calls.length = 0;
+    vi.useFakeTimers({ toFake: ["Date"] });
+    vi.setSystemTime(0);
+    vi.spyOn(document, "hasFocus").mockReturnValue(true);
+    window.history.replaceState({}, "", "/first");
+  });
+
+  afterEach(() => {
+    cleanup();
+    vi.useRealTimers();
+    vi.restoreAllMocks();
+  });
+
+  const events = () => calls.map((c) => [c.via, c.eventType, c.data.pathname, c.data.engagedMs]);
+
+  it("flushes the old page's time by beacon BEFORE the next page view", () => {
+    render(<ForgeAnalytics trackClicks={false} />);
+    vi.setSystemTime(7000);
+    act(() => window.history.pushState({}, "", "/second"));
+
+    expect(events()).toEqual([
+      ["track", "page_view", "/first", undefined],
+      ["beacon", "engagement", "/first", 7000],
+      ["track", "page_view", "/second", undefined],
+    ]);
+  });
+
+  it("sends a ping when the window loses focus, and stops the clock until it returns", () => {
+    render(<ForgeAnalytics trackClicks={false} />);
+    vi.setSystemTime(4000);
+    act(() => void window.dispatchEvent(new Event("blur")));
+    vi.setSystemTime(100_000);
+    act(() => void window.dispatchEvent(new Event("focus")));
+    vi.setSystemTime(103_000);
+    act(() => void window.dispatchEvent(new Event("pagehide")));
+
+    expect(events().filter((e) => e[1] === "engagement")).toEqual([
+      ["beacon", "engagement", "/first", 4000],
+      ["beacon", "engagement", "/first", 3000],
+    ]);
+  });
+
+  it("records nothing, pings included, when disabled", () => {
+    render(<ForgeAnalytics enabled={false} />);
+    vi.setSystemTime(10_000);
+    act(() => void window.dispatchEvent(new Event("pagehide")));
+    expect(calls).toEqual([]);
+  });
+});

package/src/ui/headless/checkout/_tests/bundleCoupon.spec.ts

@@ -69,7 +69,9 @@ describe("bundleCouponSummary — applying", () => {
   it("claims no payment when the bundle had no intent to replace", () => {
     // A bundle that has not reached start-payment yet: the client's own
     // start-payment will pick the new figure up, so nothing may supersede it.
-    const next = bundleCouponSummary(answer({ paymentSecret: "", paymentId: "", chargedAmount: 0, chargedCurrency: "" }));
+    const next = bundleCouponSummary(
+      answer({ paymentSecret: "", paymentId: "", chargedAmount: 0, chargedCurrency: "" }),
+    );
 
     expect(next.paymentUpdate).toBeNull();
     expect(next.chargedTotal).toBeNull();

package/src/ui/headless/checkout/_tests/cartResume.spec.ts

@@ -103,16 +103,12 @@ describe("resumeLineToCartItem", () => {
   it("should keep an add-on bound to the event it hangs off", () => {
     // Without this the rebuilt bundle has an add-on with no base and the server
     // refuses the whole checkout, with nothing on screen explaining why.
-    const item = resumeLineToCartItem(
-      productLine({ attachedTo: { type: "event", entityId: "event-1" } }),
-    );
+    const item = resumeLineToCartItem(productLine({ attachedTo: { type: "event", entityId: "event-1" } }));
     expect(item?.attachedTo).toEqual({ type: "event", entityId: "event-1" });
   });
 
   it("should carry the chosen variant's options so the cart can name it", () => {
-    expect(resumeLineToCartItem(productLine())?.options).toEqual([
-      { axis: "Size", value: "L", swatchHex: null },
-    ]);
+    expect(resumeLineToCartItem(productLine())?.options).toEqual([{ axis: "Size", value: "L", swatchHex: null }]);
   });
 
   it("should refuse a line with no variant rather than invent one", () => {
@@ -192,10 +188,7 @@ describe("partitionResumeLines", () => {
       title: "Tour poster",
       attachedTo: { type: "event", entityId: "event-1" },
     });
-    const parts = partitionResumeLines([
-      ticketLine({ available: false, unavailableReason: "sold_out" }),
-      poster,
-    ]);
+    const parts = partitionResumeLines([ticketLine({ available: false, unavailableReason: "sold_out" }), poster]);
 
     expect(parts.restoredLines).toEqual([]);
     expect(parts.droppedLines).toEqual([poster]);

package/src/ui/headless/checkout/_tests/seatConflict.spec.ts

@@ -0,0 +1,187 @@
+import { describe, it, expect } from "vitest";
+import { pruneSeatsFromTicketItem, type TicketCartItem } from "../../../../contexts/CartContext";
+import { cartToCheckoutLines } from "../../../../data/queries/useCheckouts";
+import {
+  cartHasSeatedLines,
+  findSeatConflict,
+  seatedLinesOf,
+  seatsTakenConflict,
+  seatsTakenIdsOf,
+} from "../seatConflict";
+import { buildLayout, buildSeating, seatAt, STALLS_TIER, GA_TIER } from "../../event/_tests/seatingFixture";
+
+/**
+ * Reserved seats riding in the bundle cart (seating wave 2, docs §12): what
+ * the cart line carries, what the create body sends, how a conflict is found
+ * and how the line is pruned. Pure, so no provider tree.
+ */
+
+const seating = buildSeating(buildLayout());
+const a1 = seatAt(seating, "Stalls", "A", "1");
+const a2 = seatAt(seating, "Stalls", "A", "2");
+
+const line = (overrides: Partial<TicketCartItem> = {}): TicketCartItem => ({
+  eventId: "ev-seated",
+  eventSlug: "seated-show",
+  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,
+  ...overrides,
+});
+
+describe("cartToCheckoutLines with seats", () => {
+  it("puts the seat ids on the seated tier's line and nothing on the GA line", () => {
+    const lines = cartToCheckoutLines([], [line()]);
+    expect(lines).toEqual([
+      {
+        type: "event_ticket",
+        eventId: "ev-seated",
+        ticketId: STALLS_TIER,
+        quantity: 2,
+        price: 40,
+        seatIds: [a1, a2],
+        title: "Stalls",
+        coverImage: undefined,
+      },
+      {
+        type: "event_ticket",
+        eventId: "ev-seated",
+        ticketId: GA_TIER,
+        quantity: 1,
+        price: 20,
+        title: "Standing",
+        coverImage: undefined,
+      },
+    ]);
+    expect(lines[1]).not.toHaveProperty("seatIds");
+  });
+});
+
+describe("seatedLinesOf / cartHasSeatedLines", () => {
+  it("names only the tiers that carry seats and are still in the selection", () => {
+    expect(seatedLinesOf(line())).toEqual([{ ticketId: STALLS_TIER, seatIds: [a1, a2] }]);
+    expect(cartHasSeatedLines([line()])).toBe(true);
+    expect(cartHasSeatedLines([line({ tickets: { [GA_TIER]: 1 } })])).toBe(false);
+    const plain = line({ tickets: { [GA_TIER]: 1 }, ticketMeta: { [GA_TIER]: { title: "Standing", price: 20 } } });
+    expect(cartHasSeatedLines([plain])).toBe(false);
+  });
+});
+
+describe("findSeatConflict", () => {
+  it("is null while every seat still reads available", () => {
+    expect(findSeatConflict(line(), seating)).toBeNull();
+  });
+
+  it("names a seat that no longer reads available, with the cart's label", () => {
+    const taken = buildSeating(buildLayout(), ["Stalls/A/2"]);
+    expect(findSeatConflict(line(), taken)).toEqual({
+      eventId: "ev-seated",
+      eventSlug: "seated-show",
+      eventTitle: "Seated show",
+      seatIds: [a2],
+      labels: ["Stalls · Row A · Seat 2"],
+    });
+  });
+
+  it("treats a seat the read no longer lists as gone, labelled from the read when the cart has no label", () => {
+    const rebound = { ...seating, seats: seating.seats.filter((s) => s.id !== a1) };
+    const noLabels = line({
+      ticketMeta: { [STALLS_TIER]: { title: "Stalls", price: 40, seatIds: [a1, a2] } },
+    });
+    const conflict = findSeatConflict(noLabels, rebound);
+    expect(conflict?.seatIds).toEqual([a1]);
+    // Not in the read either, so the id is the last resort.
+    expect(conflict?.labels).toEqual([a1]);
+    const stillListed = findSeatConflict(noLabels, buildSeating(buildLayout(), ["Stalls/A/1"]));
+    expect(stillListed?.labels).toEqual(["Stalls · Row A · Seat 1"]);
+  });
+
+  it("is null when the event has no map any more: the server decides", () => {
+    expect(findSeatConflict(line(), null)).toBeNull();
+    expect(findSeatConflict(line(), undefined)).toBeNull();
+  });
+});
+
+describe("seatsTakenIdsOf", () => {
+  const err = (status: number, data: unknown) => ({ response: { status, data } });
+
+  it("reads the ids off a 409 SEATS_TAKEN", () => {
+    expect(seatsTakenIdsOf(err(409, { code: "SEATS_TAKEN", details: { eventSeatIds: [a1] } }))).toEqual([a1]);
+    // The code alone, with no ids: still a seat conflict, to be re-read.
+    expect(seatsTakenIdsOf(err(409, { code: "SEATS_TAKEN" }))).toEqual([]);
+  });
+
+  it("is null for every other refusal, including another 409", () => {
+    expect(seatsTakenIdsOf(err(409, { code: "INVENTORY_HOLD_EXPIRED" }))).toBeNull();
+    expect(seatsTakenIdsOf(err(400, { code: "seats_required", details: { eventSeatIds: [a1] } }))).toBeNull();
+    expect(seatsTakenIdsOf(new Error("network"))).toBeNull();
+    expect(seatsTakenIdsOf(undefined)).toBeNull();
+  });
+});
+
+describe("seatsTakenConflict", () => {
+  it("attributes the named seats to the event whose line holds them", () => {
+    const other = line({ eventId: "ev-other", eventSlug: "other", eventTitle: "Other", tickets: { [GA_TIER]: 1 } });
+    expect(seatsTakenConflict([other, line()], [a2, "es-unknown"])).toEqual({
+      eventId: "ev-seated",
+      eventSlug: "seated-show",
+      eventTitle: "Seated show",
+      seatIds: [a2],
+      labels: ["Stalls · Row A · Seat 2"],
+    });
+  });
+
+  it("is null when no line holds any of the ids", () => {
+    expect(seatsTakenConflict([line()], ["es-unknown"])).toBeNull();
+    expect(seatsTakenConflict([line()], [])).toBeNull();
+  });
+});
+
+describe("pruneSeatsFromTicketItem", () => {
+  it("takes the seats out of their tier, shrinking its quantity, and leaves the GA tier alone", () => {
+    expect(pruneSeatsFromTicketItem(line(), [a2])).toEqual(
+      line({
+        tickets: { [STALLS_TIER]: 1, [GA_TIER]: 1 },
+        ticketMeta: {
+          [STALLS_TIER]: {
+            title: "Stalls",
+            price: 40,
+            seatIds: [a1],
+            seats: [{ id: a1, label: "Stalls · Row A · Seat 1" }],
+          },
+          [GA_TIER]: { title: "Standing", price: 20 },
+        },
+      }),
+    );
+  });
+
+  it("drops a tier left with no seat, and keeps the event while another tier remains", () => {
+    const pruned = pruneSeatsFromTicketItem(line(), [a1, a2]);
+    expect(pruned?.tickets).toEqual({ [GA_TIER]: 1 });
+    expect(pruned?.ticketMeta).toEqual({ [GA_TIER]: { title: "Standing", price: 20 } });
+  });
+
+  it("returns null when nothing is left, so the event leaves the cart", () => {
+    const seatedOnly = line({
+      tickets: { [STALLS_TIER]: 2 },
+      ticketMeta: { [STALLS_TIER]: line().ticketMeta[STALLS_TIER]! },
+    });
+    expect(pruneSeatsFromTicketItem(seatedOnly, [a1, a2])).toBeNull();
+  });
+
+  it("never substitutes: an id it does not hold changes nothing", () => {
+    expect(pruneSeatsFromTicketItem(line(), ["es-unknown"])).toEqual(line());
+  });
+});

package/src/ui/headless/checkout/_tests/useCartResume.spec.tsx

@@ -140,10 +140,7 @@ describe("useCartResume: an add-on never lands without its ticket", () => {
     // The basket this used to build is one the server refuses outright: an
     // add-on with no base. The buyer reached the payment screen, was turned
     // away, and nothing on the page ever named the poster as the reason.
-    const { result } = await resume([
-      ticketLine({ available: false, unavailableReason: "sold_out" }),
-      addon,
-    ]);
+    const { result } = await resume([ticketLine({ available: false, unavailableReason: "sold_out" }), addon]);
 
     // Nothing survived, so nothing is written to the basket at all. Before the
     // fix this was called with the poster as its only item.
@@ -152,16 +149,11 @@ describe("useCartResume: an add-on never lands without its ticket", () => {
   });
 
   it("tells the buyer the add-on was left out rather than dropping it silently", async () => {
-    const { result } = await resume([
-      ticketLine({ available: false, unavailableReason: "sold_out" }),
-      addon,
-    ]);
+    const { result } = await resume([ticketLine({ available: false, unavailableReason: "sold_out" }), addon]);
 
     expect(result.current.droppedLines.map((line) => line.title)).toEqual(["Tour poster"]);
     // Not smuggled into the server's own list: nothing about it is unavailable.
-    expect(result.current.unavailableLines.map((line) => line.title)).toEqual([
-      "General Admission",
-    ]);
+    expect(result.current.unavailableLines.map((line) => line.title)).toEqual(["General Admission"]);
   });
 
   it("leaves an orphaned add-on out of the count and the subtotal", async () => {