@tribe-nest/forge 3.64.0 → 3.67.0

package/src/i18n/en.json

@@ -20,6 +20,7 @@
   "forge.account_dashboard.booking_duration": "{minutes} minutes",
   "forge.account_dashboard.booking_join_label": "Join:",
   "forge.account_dashboard.booking_join_video": "Join video call",
+  "forge.account_dashboard.booking_part_of": "Part of a {count}-session booking",
   "forge.account_dashboard.booking_video_call": "Video call on this site",
   "forge.account_dashboard.booking_video_closed": "Video call: this session's room has closed",
   "forge.account_dashboard.booking_video_opens_at": "Video call: the room opens {datetime}",
@@ -184,8 +185,25 @@
   "forge.account_dashboard.waitlist_ticket_line_other": "{title} · {quantity} tickets",
   "forge.account_dashboard.waitlists_empty": "You're not on any waitlists.",
   "forge.account_dashboard.waitlists_title": "My Waitlists",
+  "forge.ai_agent_call_room.connecting": "Connecting…",
+  "forge.ai_agent_call_room.listening": "{name} is listening",
+  "forge.ai_agent_call_room.no_mic": "We could not use your microphone. Allow it in your browser, then call again.",
+  "forge.ai_agent_call_room.speaking": "{name} is speaking",
+  "forge.ai_agent_widget.aria_call": "Call us",
   "forge.ai_agent_widget.aria_close": "Close",
   "forge.ai_agent_widget.aria_open": "Open chat assistant",
+  "forge.ai_agent_widget.aria_show_call": "Show the call",
+  "forge.ai_agent_widget.call_again": "Call again",
+  "forge.ai_agent_widget.call_back_to_chat": "Back to chat",
+  "forge.ai_agent_widget.call_connecting": "Connecting…",
+  "forge.ai_agent_widget.call_ended": "Call ended.",
+  "forge.ai_agent_widget.call_error_busy": "All our lines are busy. Please try again in a few minutes.",
+  "forge.ai_agent_widget.call_error_check_failed": "We could not start the call. Please try again.",
+  "forge.ai_agent_widget.call_error_failed": "We could not connect your call. Please try again.",
+  "forge.ai_agent_widget.call_error_too_many": "You have called several times recently. Please try again later.",
+  "forge.ai_agent_widget.call_error_unavailable": "Calls are not available right now.",
+  "forge.ai_agent_widget.call_hang_up": "Hang up",
+  "forge.ai_agent_widget.call_try_again": "Try again",
   "forge.ai_agent_widget.default_greeting": "Hi! Ask me anything.",
   "forge.ai_agent_widget.default_title": "Assistant",
   "forge.ai_agent_widget.input_placeholder": "Type a message…",
@@ -365,7 +383,10 @@
   "forge.broadcast_poll.votes_other": "{count} votes",
   "forge.broadcast_poll.your_vote": "(your vote)",
   "forge.broadcast_ticket_purchase.buy_tickets": "Buy tickets",
+  "forge.broadcast_ticket_purchase.free": "Free",
+  "forge.broadcast_ticket_purchase.free_to_price": "Free to {price}",
   "forge.broadcast_ticket_purchase.from_price": "From {price}",
+  "forge.broadcast_ticket_purchase.reserve": "Reserve",
   "forge.broadcast_watch.leave": "Leave broadcast",
   "forge.broadcast_watch.load_error": "Unable to load broadcast",
   "forge.bundle_confirmation.continue_shopping": "Continue shopping",
@@ -693,17 +714,33 @@
   "forge.checkout_confirmation.total_paid": "Total paid",
   "forge.checkout_confirmation.view_orders": "View your orders",
   "forge.coaching_booking.aria_close": "Close",
+  "forge.coaching_booking.aria_next_month": "Next month",
   "forge.coaching_booking.aria_next_week": "Next week",
+  "forge.coaching_booking.aria_prev_month": "Previous month",
   "forge.coaching_booking.aria_prev_week": "Previous week",
   "forge.coaching_booking.back": "Back",
+  "forge.coaching_booking.basket_count_package": "{picked} of {count} picked",
+  "forge.coaching_booking.basket_count_range": "{picked} picked, up to {max}",
+  "forge.coaching_booking.basket_empty": "No time picked yet",
+  "forge.coaching_booking.basket_full_limit": "That is the {max} session limit. Remove one to choose a different time.",
+  "forge.coaching_booking.basket_full_package": "All {count} sessions picked. Remove one to choose a different time.",
+  "forge.coaching_booking.basket_more": "{count} more to pick",
+  "forge.coaching_booking.basket_title_many": "Your sessions",
+  "forge.coaching_booking.basket_title_package": "Your {count} sessions",
+  "forge.coaching_booking.basket_title_single": "Your session",
   "forge.coaching_booking.confirm_booking": "Confirm Booking",
   "forge.coaching_booking.confirm_email_placeholder": "Confirm email",
   "forge.coaching_booking.confirm_leave": "Are you sure you want to leave checkout?",
   "forge.coaching_booking.consent": "By continuing, you agree to receive booking confirmations and important updates about your session via email.",
   "forge.coaching_booking.continue": "Continue",
   "forge.coaching_booking.continue_to_payment": "Continue to payment",
+  "forge.coaching_booking.continue_with_total": "Continue, {amount}",
+  "forge.coaching_booking.day_has_times": "{date}, times available",
+  "forge.coaching_booking.day_no_times": "{date}, no times",
   "forge.coaching_booking.details_subtitle": "Please provide your contact information for the booking.",
   "forge.coaching_booking.details_title": "Contact Information",
+  "forge.coaching_booking.done": "Done",
+  "forge.coaching_booking.duration_short": "{minutes} min",
   "forge.coaching_booking.email_invalid_hint": "Please enter a valid email address",
   "forge.coaching_booking.email_mismatch_hint": "Email addresses do not match",
   "forge.coaching_booking.email_placeholder": "Email",
@@ -715,14 +752,29 @@
   "forge.coaching_booking.first_name_placeholder": "First name",
   "forge.coaching_booking.last_name_placeholder": "Last name",
   "forge.coaching_booking.loading_slots": "Loading available slots…",
+  "forge.coaching_booking.next_available": "Next available",
   "forge.coaching_booking.no_slots": "No available slots for this week.",
+  "forge.coaching_booking.no_times_day": "No open times on this day.",
+  "forge.coaching_booking.no_times_month": "No open times this month.",
   "forge.coaching_booking.not_found": "Coaching session not found.",
+  "forge.coaching_booking.not_picked_yet": "Not picked yet",
+  "forge.coaching_booking.package_help_body": "You pick every session now and pay once. Each session can be rescheduled on its own later, under the cancellation and reschedule terms shown at checkout.",
+  "forge.coaching_booking.package_help_label": "How does a package work?",
+  "forge.coaching_booking.package_one_price": "{count} sessions, one price",
+  "forge.coaching_booking.package_total": "{price} for all {count}",
   "forge.coaching_booking.pay": "Pay {amount}",
   "forge.coaching_booking.payment_not_configured": "Payment is not configured.",
   "forge.coaching_booking.payment_subtitle": "Complete your purchase to secure your booking.",
   "forge.coaching_booking.payment_title": "Payment",
+  "forge.coaching_booking.per_session_calc": "{count} × {price}",
+  "forge.coaching_booking.pick_a_time": "Pick a time",
+  "forge.coaching_booking.pick_day": "Pick a highlighted day to see its times.",
+  "forge.coaching_booking.pick_more": "Pick {count} more",
   "forge.coaching_booking.preparing_payment": "Preparing payment…",
+  "forge.coaching_booking.price_per_session": "{price} per session",
   "forge.coaching_booking.processing": "Processing…",
+  "forge.coaching_booking.remove": "Remove",
+  "forge.coaching_booking.remove_time": "Remove {time}",
   "forge.coaching_booking.reserving": "Reserving…",
   "forge.coaching_booking.select_placeholder": "Select…",
   "forge.coaching_booking.slot_title": "Select Availability",
@@ -756,6 +808,7 @@
   "forge.coaching_confirmation.row_paid": "Paid",
   "forge.coaching_confirmation.row_reference": "Reference",
   "forge.coaching_confirmation.row_session": "Session",
+  "forge.coaching_confirmation.row_session_n": "Session {index} of {count}",
   "forge.coaching_confirmation.row_tax": "Tax",
   "forge.coaching_confirmation.status_unknown": "unresolved",
   "forge.coaching_confirmation.tax_included": "Includes {amount} tax",
@@ -764,6 +817,10 @@
   "forge.coaching_detail.about_title": "About this session",
   "forge.coaching_detail.duration_minutes": "{minutes} minutes",
   "forge.coaching_detail.not_found": "Coaching session not found.",
+  "forge.coaching_detail.price_for_sessions": "for {count} sessions",
+  "forge.coaching_detail.price_per_session_suffix": "per session",
+  "forge.coaching_detail.price_save": "Save {amount}",
+  "forge.coaching_detail.price_up_to": "Book up to {max} at once",
   "forge.cohort_checkout.aria_close": "Close",
   "forge.cohort_checkout.authorise_future_payments": "Authorise the later payments on this plan.",
   "forge.cohort_checkout.back": "Back",
@@ -1428,7 +1485,10 @@
   "forge.event_detail.location_virtual": "Virtual",
   "forge.event_detail.not_found": "Event not found.",
   "forge.event_detail.presale_only": "Tickets for this event are presale only.",
+  "forge.event_detail.price_free": "Free",
+  "forge.event_detail.price_free_to": "Free to {max}",
   "forge.event_detail.price_from_label": "From",
+  "forge.event_detail.reserve": "Reserve",
   "forge.event_seat_picker.dismiss": "Dismiss",
   "forge.event_seat_picker.empty": "There are no seats to choose from yet.",
   "forge.event_seat_picker.help_body": "Tap a seat to choose it and tap it again to let it go. Pinch or scroll to zoom, drag to move around the map. Grey seats are not available. Best available picks the lowest seats together for you.",
@@ -1487,6 +1547,7 @@
   "forge.event_tickets.expires_hours_soon_other": "⏰ Expires in {count} hours!",
   "forge.event_tickets.field_required": "This field is required",
   "forge.event_tickets.first_name_placeholder": "First name",
+  "forge.event_tickets.free": "Free",
   "forge.event_tickets.invalid_email": "Please enter a valid email address",
   "forge.event_tickets.item_label_event": "This event",
   "forge.event_tickets.item_label_ticket": "This ticket",
@@ -1514,6 +1575,7 @@
   "forge.event_tickets.pwyw_range_min_max": "(minimum {min}, up to {max})",
   "forge.event_tickets.remove_discount": "Remove discount",
   "forge.event_tickets.request_tickets": "Request tickets",
+  "forge.event_tickets.reserve": "Reserve",
   "forge.event_tickets.seat_best_available": "Best available",
   "forge.event_tickets.seat_remove_aria": "Remove {seat}",
   "forge.event_tickets.seats_left_one": "{count} seat left",
@@ -2228,6 +2290,7 @@
   "forge.review_form.title_placeholder": "Sum it up in a few words",
   "forge.review_form.update_submit": "Update review",
   "forge.seat_legend.aria_label": "Map key",
+  "forge.seat_legend.free": "Free",
   "forge.seat_legend.left_one": "{count} left",
   "forge.seat_legend.left_other": "{count} left",
   "forge.seat_legend.selected": "Selected",

package/src/provider/ForgeProvider.tsx

@@ -55,7 +55,7 @@ export interface ForgeClientProviderProps {
 }
 
 /**
- * Low-level tenant/client provider — supplies the `useForge()` context (Axios
+ * Low-level tenant/client provider: supplies the `useForge()` context (Axios
  * client, tenant ids, token). Most sites use the all-in-one `<ForgeProvider>`
  * (which wraps this plus query/content/auth/cart/audio/site-config/theme); reach
  * for `ForgeClientProvider` only when composing the tree yourself.
@@ -126,6 +126,12 @@ export const ForgeClientProvider = ({
   return <ForgeContext.Provider value={value}>{children}</ForgeContext.Provider>;
 };
 
+/**
+ * The Forge context, or `null` outside a `<ForgeProvider>`. For components that
+ * also render standalone and only enrich themselves when a provider is present.
+ */
+export const useOptionalForge = (): ForgeContextValue | null => useContext(ForgeContext);
+
 /** Access the Forge context. Throws if used outside a `<ForgeProvider>`. */
 export const useForge = (): ForgeContextValue => {
   const ctx = useContext(ForgeContext);

package/src/types/models.ts

@@ -1097,6 +1097,17 @@ export type CoachingProduct = {
   reviewAggregate?: IReviewAggregate | null;
   /** The seller's CURRENT cancellation terms — present on the detail endpoint only. */
   cancellation?: CancellationTermsView | null;
+  /**
+   * How the product is sold. Absent on older backends, which means one session.
+   * `package`: exactly `packageSessionCount` sessions for `packagePrice`, and
+   * `price` is the single-session price shown as the saving (0 = none).
+   * `per_session`: 1 to `maxSessionsPerBooking` sessions at `price` each.
+   * The buyer picks every session in one booking.
+   */
+  pricingMode?: "single" | "package" | "per_session";
+  packageSessionCount?: number | null;
+  packagePrice?: string | number | null;
+  maxSessionsPerBooking?: number | null;
 };
 
 // ---- Membership gates (S.4) --------------------------------------------------
@@ -1862,6 +1873,8 @@ export type CoachingBooking = {
   productTitle?: string | null;
   durationMinutes?: number | null;
   timezone?: string | null;
+  /** Every session of a multi-session booking, earliest first. Absent for one session. */
+  sessions?: { startTime: string; endTime: string }[];
   /**
    * The session's `.ics`, both forms — see {@link CalendarFeedLinks}. Null
    * unless the booking is CONFIRMED: a held slot is not a session, and offering

package/src/ui/format/_tests/ticketPrice.spec.ts

@@ -0,0 +1,58 @@
+import { describe, expect, it } from "vitest";
+import { isFreeTicket, isSingleFreeTicketEvent, summarizeTicketPrices } from "../ticketPrice";
+
+const tier = (price: number, payWhatYouWant = false) => ({ price, payWhatYouWant });
+
+describe("isFreeTicket", () => {
+  it("is true for a zero price", () => {
+    expect(isFreeTicket(tier(0))).toBe(true);
+  });
+
+  it("is false for a paid tier", () => {
+    expect(isFreeTicket(tier(12))).toBe(false);
+  });
+
+  it("is false for a PWYW tier with a zero floor: the floor is not a gift", () => {
+    expect(isFreeTicket(tier(0, true))).toBe(false);
+  });
+
+  it("reads a decimal string price from the wire", () => {
+    expect(isFreeTicket({ price: "0.00" as unknown as number })).toBe(true);
+  });
+});
+
+describe("summarizeTicketPrices", () => {
+  it("all free reads free", () => {
+    expect(summarizeTicketPrices([tier(0), tier(0)])).toEqual({ kind: "free" });
+  });
+
+  it("free and paid reads free to the dearest tier", () => {
+    expect(summarizeTicketPrices([tier(0), tier(25), tier(40)])).toEqual({ kind: "free_to", max: 40 });
+  });
+
+  it("all paid keeps the cheapest tier", () => {
+    expect(summarizeTicketPrices([tier(40), tier(25)])).toEqual({ kind: "from", min: 25 });
+  });
+
+  it("a zero-floor PWYW tier keeps the From wording", () => {
+    expect(summarizeTicketPrices([tier(0, true), tier(20)])).toEqual({ kind: "from", min: 0 });
+  });
+
+  it("no tiers summarise to nothing", () => {
+    expect(summarizeTicketPrices([])).toBeNull();
+    expect(summarizeTicketPrices(undefined)).toBeNull();
+  });
+});
+
+describe("isSingleFreeTicketEvent", () => {
+  it("one free tier is a reservation", () => {
+    expect(isSingleFreeTicketEvent([tier(0)])).toBe(true);
+  });
+
+  it("two free tiers, one paid tier, or one PWYW tier are not", () => {
+    expect(isSingleFreeTicketEvent([tier(0), tier(0)])).toBe(false);
+    expect(isSingleFreeTicketEvent([tier(10)])).toBe(false);
+    expect(isSingleFreeTicketEvent([tier(0, true)])).toBe(false);
+    expect(isSingleFreeTicketEvent([])).toBe(false);
+  });
+});

package/src/ui/format/bookingPricing.ts

@@ -0,0 +1,55 @@
+import type { CoachingProduct } from "../../types/models";
+
+/**
+ * How a booking product is priced when one booking can hold several sessions.
+ *
+ * Mirrors the backend's `db/types/bookingPricing.ts`, which is the authority:
+ * the server re-prices at reserve and at the details step, so these numbers
+ * are only ever what the buyer is SHOWN before that. Kept in Forge rather than
+ * imported because the storefront ships without the backend.
+ */
+export type BookingPricingMode = "single" | "package" | "per_session";
+
+type PricingFields = Pick<CoachingProduct, "price"> &
+  Partial<Pick<CoachingProduct, "pricingMode" | "packageSessionCount" | "packagePrice" | "maxSessionsPerBooking">>;
+
+export function bookingPricingMode(product: PricingFields | null | undefined): BookingPricingMode {
+  const mode = product?.pricingMode;
+  return mode === "package" || mode === "per_session" ? mode : "single";
+}
+
+/** The number of sessions one booking must hold, inclusive. */
+export function bookingSessionRange(product: PricingFields | null | undefined): { min: number; max: number } {
+  const mode = bookingPricingMode(product);
+  if (mode === "package") {
+    const n = Math.max(1, Number(product?.packageSessionCount ?? 1));
+    return { min: n, max: n };
+  }
+  if (mode === "per_session") return { min: 1, max: Math.max(1, Number(product?.maxSessionsPerBooking ?? 1)) };
+  return { min: 1, max: 1 };
+}
+
+const money = (value: unknown) => {
+  const n = Number(value ?? 0);
+  return Number.isFinite(n) && n > 0 ? Math.round(n * 100) / 100 : 0;
+};
+
+/** The gross price of `sessionCount` sessions, before any discount or tax. */
+export function bookingGrossAmount(product: PricingFields | null | undefined, sessionCount: number): number {
+  const mode = bookingPricingMode(product);
+  if (mode === "package") return money(product?.packagePrice);
+  if (mode === "per_session") return Math.round(money(product?.price) * 100 * sessionCount) / 100;
+  return money(product?.price);
+}
+
+/**
+ * What a package saves against buying its sessions one at a time. 0 when the
+ * creator gave no single-session price, or the package is not cheaper.
+ */
+export function packageSaving(product: PricingFields | null | undefined): number {
+  if (bookingPricingMode(product) !== "package") return 0;
+  const single = money(product?.price);
+  const count = Number(product?.packageSessionCount ?? 0);
+  if (!single || !count) return 0;
+  return Math.max(0, Math.round((single * count - money(product?.packagePrice)) * 100) / 100);
+}

package/src/ui/format/ticketPrice.ts

@@ -0,0 +1,52 @@
+import type { ITicket } from "../../types/models";
+import { isPayWhatYouWant } from "./pwyw";
+
+/**
+ * Free event tickets, as a buyer-facing surface has to word them.
+ *
+ * A tier priced at zero is FREE, and "$0.00" reads as a price, not as a gift.
+ * Every surface that quotes a ticket price runs it through these helpers so a
+ * free tier says "Free" everywhere, and a checkout with nothing to pay says
+ * "Reserve" rather than "Pay $0.00".
+ *
+ * Pay-what-you-want is the exception that matters: on a PWYW tier `price` is
+ * the FLOOR, so a zero floor means "pay what you like, from nothing", not
+ * "free". Those tiers keep their existing "From" wording.
+ */
+
+type PricedTicket = Pick<ITicket, "price"> & Partial<Pick<ITicket, "payWhatYouWant">>;
+
+/** A tier with nothing to pay: priced at zero and not pay-what-you-want. */
+export const isFreeTicket = (ticket: PricedTicket): boolean =>
+  !isPayWhatYouWant(ticket as ITicket) && Number(ticket.price) === 0;
+
+/**
+ * The one-line price summary an event page shows beside its buy button.
+ *
+ * - every tier free: `free`
+ * - some free, some paid: `free_to` with the dearest tier, so the page reads
+ *   "Free to $40" instead of "From $0.00"
+ * - none free: `from` with the cheapest tier, which is the existing wording
+ *
+ * `null` for no tiers at all, so the caller renders nothing.
+ */
+export type TicketPriceSummary =
+  | { kind: "free" }
+  | { kind: "free_to"; max: number }
+  | { kind: "from"; min: number };
+
+export function summarizeTicketPrices(tickets: readonly PricedTicket[] | null | undefined): TicketPriceSummary | null {
+  if (!tickets || tickets.length === 0) return null;
+  const free = tickets.filter(isFreeTicket);
+  if (free.length === tickets.length) return { kind: "free" };
+  const prices = tickets.map((ticket) => Number(ticket.price)).filter((price) => Number.isFinite(price));
+  if (free.length > 0) return { kind: "free_to", max: Math.max(...prices) };
+  return { kind: "from", min: prices.length ? Math.min(...prices) : 0 };
+}
+
+/**
+ * The event sells exactly one tier and it is free, so the call to action is a
+ * reservation, not a purchase ("Reserve" rather than "Buy tickets").
+ */
+export const isSingleFreeTicketEvent = (tickets: readonly PricedTicket[] | null | undefined): boolean =>
+  !!tickets && tickets.length === 1 && isFreeTicket(tickets[0]);

package/src/ui/headless/agent/_tests/callChallenge.spec.ts

@@ -0,0 +1,85 @@
+import { createHash } from "node:crypto";
+import { describe, expect, it } from "vitest";
+import { leadingZeroBits, solveCallChallenge } from "../callChallenge";
+
+/**
+ * The bot check in front of "Call us". The backend (`callGuard.ts`) accepts a
+ * solution when SHA-256 of `${challenge}:${solution}` starts with `difficulty`
+ * zero bits, so the thing worth pinning is that what the browser finds is what
+ * the server would accept, checked here with Node's own hash rather than the
+ * Web Crypto the solver uses.
+ */
+
+function serverLeadingZeroBits(digest: Buffer): number {
+  let bits = 0;
+  for (const byte of digest) {
+    if (byte === 0) {
+      bits += 8;
+      continue;
+    }
+    let b = byte;
+    while ((b & 0x80) === 0) {
+      bits++;
+      b <<= 1;
+    }
+    break;
+  }
+  return bits;
+}
+
+describe("leadingZeroBits", () => {
+  it("counts whole zero bytes and the zero bits of the first non-zero byte", () => {
+    expect(leadingZeroBits(new Uint8Array([0xff]))).toBe(0);
+    expect(leadingZeroBits(new Uint8Array([0x01]))).toBe(7);
+    expect(leadingZeroBits(new Uint8Array([0x00, 0x80]))).toBe(8);
+    expect(leadingZeroBits(new Uint8Array([0x00, 0x00, 0x0f]))).toBe(20);
+  });
+
+  it("counts every bit of an all-zero digest", () => {
+    expect(leadingZeroBits(new Uint8Array(4))).toBe(32);
+  });
+});
+
+describe("solveCallChallenge", () => {
+  it("finds a solution the server's check accepts, at the production difficulty", async () => {
+    const challenge = "v1.eyJhIjoxfQ.c2ln";
+    const solution = await solveCallChallenge(challenge, 16);
+    expect(solution).toMatch(/^\d{1,12}$/);
+    const digest = createHash("sha256").update(`${challenge}:${solution}`).digest();
+    expect(serverLeadingZeroBits(digest)).toBeGreaterThanOrEqual(16);
+  });
+
+  it("returns the SMALLEST solution, so a batch boundary changes nothing", async () => {
+    const challenge = "small-batches";
+    const a = await solveCallChallenge(challenge, 10, { batchSize: 7, yieldToPage: async () => undefined });
+    const b = await solveCallChallenge(challenge, 10, { batchSize: 1000 });
+    expect(a).toBe(b);
+    for (let n = 0; n < Number(a); n++) {
+      const digest = createHash("sha256").update(`${challenge}:${n}`).digest();
+      expect(serverLeadingZeroBits(digest)).toBeLessThan(10);
+    }
+  });
+
+  it("gives the page a turn after every batch it did not solve in", async () => {
+    const solution = Number(await solveCallChallenge("yield-check", 12, { batchSize: 64 }));
+    let yields = 0;
+    await solveCallChallenge("yield-check", 12, {
+      batchSize: 64,
+      yieldToPage: async () => {
+        yields++;
+      },
+    });
+    expect(yields).toBe(Math.floor(solution / 64));
+  });
+
+  it("stops when the call is hung up while it works", async () => {
+    const controller = new AbortController();
+    const solving = solveCallChallenge("abort-me", 40, {
+      signal: controller.signal,
+      yieldToPage: async () => {
+        controller.abort();
+      },
+    });
+    await expect(solving).rejects.toMatchObject({ name: "AbortError" });
+  });
+});