@tribe-nest/forge 3.21.0 → 3.23.0

package/src/data/queries/useMyTickets.ts

@@ -49,8 +49,65 @@ export type MyTicketPass = {
   ownerEmail?: string | null;
   /** Set once the pass has been scanned at the door. */
   checkedInAt?: string | null;
+  /**
+   * Does the CALLER hold this pass right now?
+   *
+   * Not the same question as "is it on my order", and the difference is the one
+   * that trips people up. A purchaser who named guests at checkout owns passes
+   * carrying their guests' addresses from the moment they are written, and a
+   * transfer moves the holder without touching the order. Every pass-scoped
+   * endpoint — transfer, wallet, QR — resolves the HOLDER, so a control drawn
+   * on a pass the caller does not hold can only ever 404.
+   *
+   * Optional because it is newer than the endpoint. `myTicketHeldPassIds`
+   * treats its absence as "assume held", which is the old behaviour.
+   */
+  isHolder?: boolean;
+  /**
+   * The caller's OWN live transfer on this pass, straight from the API.
+   *
+   * Only ever a transfer THIS reader sent (the server matches `from_email`) and
+   * only while it is `pending`, so it never exposes the operator-only chain of
+   * previous holders. `null` when nothing is in flight.
+   *
+   * This is what replaced `localStorage` as the source of truth for "you have a
+   * transfer out on this ticket": the id used to exist nowhere but the response
+   * to the sender's own send, so the same person on a second device had nothing
+   * to withdraw.
+   */
+  pendingTransfer?: MyTicketPendingTransfer | null;
+};
+
+/** The live claim window, computed server-side on every read. */
+export type MyTicketTransferWindow = {
+  /** The claim link still works right now. */
+  open: boolean;
+  /** Whole seconds left when the server answered. `null` when there is no window. */
+  secondsRemaining: number | null;
+  /** The instant the link dies. */
+  expiresAt: string | null;
+};
+
+/**
+ * A pending transfer as the SENDER may see it — deliberately narrow.
+ *
+ * An id to address the withdraw endpoint with, the recipient THIS caller typed
+ * themselves, and the two timestamps that make "sent 2 hours ago, expires in
+ * 46" renderable. No token, no previous holder, no account ids.
+ */
+export type MyTicketPendingTransfer = {
+  id: string;
+  status: string;
+  toName: string | null;
+  toEmail: string;
+  expiresAt: string;
+  createdAt: string;
+  window: MyTicketTransferWindow;
 };
 
+/** How the caller comes to be looking at an order. */
+export type MyTicketRole = "purchaser" | "holder";
+
 export type MyTicketItem = {
   id: string;
   quantity: number;
@@ -78,6 +135,27 @@ export type MyTicket = {
   eventStatus: string | null;
   items: MyTicketItem[];
   cancellation: TicketCancellation;
+  /**
+   * `purchaser` — they paid for this order. `holder` — a pass out of it was
+   * TRANSFERRED to them and they bought nothing.
+   *
+   * A holder's row is scrubbed server-side: `totalAmount` and every line price
+   * are null, lines they hold no pass on are gone, and `cancellation.canCancel`
+   * is false (cancelling refunds the sender's money and voids every seat, which
+   * is not a gift recipient's call). Render the money block only for a
+   * purchaser — `Number(null)` is `0`, and a confident "$0.00" on somebody
+   * else's purchase is worse than saying nothing.
+   *
+   * Optional: an older API build emits no role, and treating that as
+   * `purchaser` reproduces exactly the previous behaviour.
+   */
+  role?: MyTicketRole;
+  /**
+   * The event's `.ics`, both forms — what lets the portal offer Apple Calendar
+   * rather than only the three template providers. Null for a cancelled show.
+   */
+  calendarUrl?: string | null;
+  calendarWebcalUrl?: string | null;
   /**
    * Not emitted by the API, which nests passes under each ITEM. Tolerated by
    * `myTicketPassIds` so an order-level shape would not need a frontend change.
@@ -111,6 +189,40 @@ export function myTicketPassIds(ticket: Pick<MyTicket, "passes" | "items">): str
   return [...seen];
 }
 
+/** Every pass on an order, flattened — the objects, not just the ids. */
+export function myTicketPasses(ticket: Pick<MyTicket, "passes" | "items">): MyTicketPass[] {
+  const seen = new Map<string, MyTicketPass>();
+  const collect = (passes?: MyTicketPass[]) => {
+    for (const pass of passes ?? []) {
+      if (typeof pass?.id === "string" && /^TN-\d+$/.test(pass.id) && !seen.has(pass.id)) {
+        seen.set(pass.id, pass);
+      }
+    }
+  };
+
+  collect(ticket.passes);
+  for (const item of ticket.items ?? []) collect(item.passes);
+
+  return [...seen.values()];
+}
+
+/**
+ * The passes the caller can actually ACT on — transfer, wallet, QR.
+ *
+ * Every pass-scoped endpoint resolves the current HOLDER, so drawing those
+ * controls on a pass the caller merely paid for (a named guest's seat, a ticket
+ * already claimed by somebody else) produced a 404 with no explanation. The
+ * affordance is now drawn from the server's own `isHolder`.
+ *
+ * A pass with no `isHolder` at all is treated as held: that is an older API
+ * build, and the previous behaviour was to offer the control for every pass.
+ */
+export function myTicketHeldPassIds(ticket: Pick<MyTicket, "passes" | "items">): string[] {
+  return myTicketPasses(ticket)
+    .filter((pass) => pass.isHolder !== false)
+    .map((pass) => pass.id);
+}
+
 /**
  * The buyer is resolved from the SESSION server-side — `accountId` here only
  * gates the query on being signed in and keys the cache. It is never sent, and

package/src/data/queries/useOrders.ts

@@ -56,6 +56,16 @@ export type CreateOrderResult = {
   totalAmount: number;
   subTotal: number;
   shippingCosts?: { deliveryGroupId: string; amount: number; currency: string }[];
+  /**
+   * When the stock reserved for this cart goes back on sale, ISO-8601.
+   *
+   * `null` when nothing was reserved — an order that already settled (a free
+   * one), a cart of digital/service items, or a profile with inventory holds
+   * switched off. `start-payment` restarts this clock and reports the newer
+   * instant, so treat that one as authoritative once it arrives; this is what
+   * bridges the gap while it is in flight.
+   */
+  holdExpiresAt?: string | null;
 };
 
 /** Create a cart/product order (the step before start-payment). */

package/src/data/queries/usePassTransfers.ts

@@ -37,21 +37,27 @@ import { useForge } from "../../provider/ForgeProvider";
  *    cancelled transfer are all its answers to give, each with a distinct
  *    message.
  *
- * ## Why there is a local store for pending sends
+ * ## Where a pending transfer comes from — the SERVER, now
  *
  * `GET /public/events/passes/:passId/transfers` is gated on the operator
- * permission `events.read` — the chain names every previous holder, which the
- * current one has no business reading — and nothing on `/public/events/my-tickets`
- * carries transfer state. So a BUYER has no endpoint that lists their own
- * pending transfer back to them: the only place a transfer id ever appears is
- * the response to their own send.
+ * permission `events.read` and stays that way: the chain names every previous
+ * holder, which the current one has no business reading. For a while that left
+ * a buyer with no endpoint listing their own pending transfer back to them —
+ * the id existed nowhere but the response to their own send — so this file
+ * remembered it in `localStorage`, exactly as `useEventWaitlist` does for an
+ * anonymous joiner's entry id.
  *
- * That id is remembered in `localStorage`, exactly as `useEventWaitlist` does
- * for an anonymous joiner's entry id and for the same reason — it is the only
- * way the browser that performed an action can show it again. It is a
- * convenience, not a source of truth: the durable copy is the recipient's email,
- * and every cancel is still decided by the server. A buyer on another device
- * sees no pending transfer, which is a gap in the API rather than in this file.
+ * `/public/events/my-tickets` now carries `pendingTransfer` on each pass:
+ * `status = 'pending'` AND a `from_email` match on the reader, so the only row
+ * that can surface is one the reader sent. **That is the source of truth.** A
+ * sender who signed in on a second device can see and withdraw a transfer they
+ * started on the first, which is the case `localStorage` could never serve.
+ *
+ * The local store is KEPT, demoted to what it always really was: a same-render
+ * bridge. `my-tickets` is a paginated query that has to round-trip before the
+ * new row appears, and a just-sent transfer vanishing for a second reads as a
+ * failed send. `mergePendingTransfers` below prefers the server's copy whenever
+ * it has one, so the two can never both draw a row.
  */
 
 /** The lifecycle, restated (Forge cannot import from the API). */
@@ -202,13 +208,67 @@ export const forgetPassTransfer = (transferId: string) => {
  * The remembered pending sends, as a REACTIVE read.
  *
  * There is no query to invalidate, so a plain read would leave a just-sent
- * transfer invisible until a reload.
+ * transfer invisible until `my-tickets` refetches.
  */
 export function usePendingPassTransfers(passId?: string): RememberedPassTransfer[] {
   const all = useSyncExternalStore(subscribe, snapshot, serverSnapshot);
   return useMemo(() => (passId ? all.filter((entry) => entry.passId === passId) : all), [all, passId]);
 }
 
+/** One pending transfer, however the caller came by it. */
+export type PendingTransferView = {
+  /** The id the withdraw endpoint takes. */
+  transferId: string;
+  toEmail: string;
+  /** The instant the claim link dies. `null` when unknown (a local-only row). */
+  expiresAt: string | null;
+  /** False once the window has lapsed — server-computed, never re-derived. */
+  open: boolean;
+  /** True when this came off `my-tickets` rather than out of `localStorage`. */
+  fromServer: boolean;
+};
+
+/**
+ * The pending transfer to DRAW for one pass — the server's if it has one, the
+ * local bridge otherwise.
+ *
+ * De-duplication matters more than it looks: one live transfer per pass is a
+ * DATABASE guarantee (a partial unique index), so two rows on screen would be a
+ * lie about the ticket's state and would offer two "withdraw" buttons for one
+ * thing. The server wins whenever it answers, because it also knows whether the
+ * window is still open.
+ *
+ * `null` means nothing is in flight — a pass with no outstanding transfer, on
+ * any device.
+ */
+export function mergePendingTransfer(
+  serverTransfer: { id: string; toEmail: string; expiresAt: string; window?: { open: boolean } } | null | undefined,
+  remembered: RememberedPassTransfer[],
+): PendingTransferView | null {
+  if (serverTransfer) {
+    return {
+      transferId: serverTransfer.id,
+      toEmail: serverTransfer.toEmail,
+      expiresAt: serverTransfer.expiresAt ?? null,
+      // A lapsed-but-unswept transfer is still `pending` and still withdrawable;
+      // the server says `open: false` and the UI says so too rather than hiding
+      // a live row the sender cannot otherwise address.
+      open: serverTransfer.window?.open ?? true,
+      fromServer: true,
+    };
+  }
+
+  const local = remembered[0];
+  if (!local) return null;
+  return {
+    transferId: local.transferId,
+    toEmail: local.toEmail,
+    expiresAt: local.expiresAt,
+    open: true,
+    fromServer: false,
+  };
+}
+
 // ── Hooks ───────────────────────────────────────────────────────────────────
 
 /**

package/src/data/queries/usePaymentFlow.ts

@@ -1,6 +1,12 @@
-import { useEffect, useRef } from "react";
+import { useCallback, useEffect, useMemo, useRef } from "react";
 import type { PaymentFlowResult, PaymentStartResponse } from "../../types/models";
 import { PaymentProviderName } from "../../types/models";
+import {
+  hasPaystackSession,
+  openPaystackCheckout,
+  type PaystackCheckoutHandlers,
+  type PaystackCheckoutOutcome,
+} from "../../utils/paystackCheckout";
 import { useForge } from "../../provider/ForgeProvider";
 import { useMutation } from "@tanstack/react-query";
 
@@ -15,42 +21,80 @@ export interface UsePaymentFlowOptions {
   autoStart?: boolean;
   /** Gate auto-start on extra readiness (default true). */
   enabled?: boolean;
-  /** Redirect to the Paystack checkout URL on success (default true). */
+  /**
+   * Handle the Paystack checkout automatically once the charge starts: open the
+   * inline modal, falling back to the hosted page when it cannot open
+   * (default true). `false` means "I will drive it myself": call
+   * `openPaystackCheckout()` from a button.
+   *
+   * The name is historical (it used to mean "redirect to the hosted page") and
+   * is deliberately kept: renaming it would break compiling sites for no gain.
+   */
   paystackRedirect?: boolean;
+  /**
+   * Paystack modal callbacks. Omit `onPaystackSuccess` to keep the redirect
+   * leg's behaviour, which is to navigate to `returnUrl`, and that is what leaves
+   * every finalise page unchanged.
+   */
+  onPaystackSuccess?: PaystackCheckoutHandlers["onSuccess"];
+  /** The fan closed the modal. NOT a failure, so leave them able to retry. */
+  onPaystackDismiss?: PaystackCheckoutHandlers["onDismiss"];
+  onPaystackError?: PaystackCheckoutHandlers["onError"];
 }
 
 /**
  * Starts a payment against any `/public/<domain>/.../start-payment` endpoint and
  * normalizes the result: resolves the provider (the field is named differently
- * per domain) and, for Paystack, redirects to the hosted checkout. The Stripe
- * UI (Elements + confirm) stays in the app — this hook only owns the data.
+ * per domain) and, for Paystack, opens the inline checkout modal so the fan
+ * pays without leaving the creator's site. The Stripe UI (Elements + confirm)
+ * stays in the app; this hook only owns the data.
  */
 export function usePaymentFlow(opts: UsePaymentFlowOptions) {
   const { client, profileId } = useForge();
   const { path, body, returnUrl, autoStart = true, enabled = true, paystackRedirect = true } = opts;
   const startedRef = useRef(false);
 
+  // Callbacks are read through a ref so a caller passing inline arrows does not
+  // re-trigger the auto-open effect on every render.
+  const handlersRef = useRef<PaystackCheckoutHandlers>({});
+  handlersRef.current = {
+    onSuccess: opts.onPaystackSuccess,
+    onDismiss: opts.onPaystackDismiss,
+    onError: opts.onPaystackError,
+  };
+
   const mutation = useMutation<PaymentFlowResult, unknown, Record<string, unknown> | undefined>({
     mutationFn: async (override) => {
       // override wins — click-driven flows pass a just-created orderId/returnUrl.
       const res = await client.post(path as string, { ...body, profileId, returnUrl, ...(override ?? {}) });
       const data = res.data as PaymentStartResponse;
       const provider = (data.paymentProvider ?? data.paymentProviderName) as PaymentProviderName | undefined;
-
-      if (
-        paystackRedirect &&
-        provider === PaymentProviderName.Paystack &&
-        data.paymentSecret &&
-        typeof window !== "undefined"
-      ) {
-        window.location.href = data.paymentSecret;
-      }
-
       return { ...data, provider };
     },
   });
 
   const { mutate, mutateAsync } = mutation;
+  const result = mutation.data ?? null;
+  const isPaystack = result?.provider === PaymentProviderName.Paystack;
+
+  const session = useMemo(
+    () => ({ accessCode: result?.accessCode, checkoutUrl: result?.checkoutUrl, returnUrl }),
+    [result?.accessCode, result?.checkoutUrl, returnUrl],
+  );
+
+  /**
+   * Open the Paystack modal for the charge that has already been started.
+   * Safe to call again after a dismissal: the access code still opens the same
+   * session, which is what makes "closed it by accident" recoverable.
+   */
+  const openPaystack = useCallback(async (): Promise<PaystackCheckoutOutcome> => {
+    if (!hasPaystackSession(session)) return "unavailable";
+    return openPaystackCheckout(session, {
+      onSuccess: handlersRef.current.onSuccess,
+      onDismiss: handlersRef.current.onDismiss,
+      onError: handlersRef.current.onError,
+    });
+  }, [session]);
 
   useEffect(() => {
     if (autoStart && enabled && path && returnUrl && profileId && !startedRef.current) {
@@ -60,11 +104,32 @@ export function usePaymentFlow(opts: UsePaymentFlowOptions) {
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [autoStart, enabled, path, returnUrl, profileId]);
 
+  // Auto-open, once per started charge. Keyed on the charge rather than a bare
+  // boolean so a coupon that re-mints the session opens the NEW one, and a fan
+  // who dismissed the modal is not immediately re-interrupted by it.
+  const autoOpenedRef = useRef<string | null>(null);
+  useEffect(() => {
+    if (!paystackRedirect || !isPaystack) return;
+    const key = result?.paymentId || result?.accessCode;
+    if (!key || autoOpenedRef.current === key) return;
+    autoOpenedRef.current = key;
+    void openPaystack();
+  }, [paystackRedirect, isPaystack, result?.paymentId, result?.accessCode, openPaystack]);
+
   return {
-    result: mutation.data ?? null,
-    clientSecret: mutation.data?.paymentSecret,
-    paymentId: mutation.data?.paymentId,
-    provider: mutation.data?.provider,
+    result,
+    /** STRIPE: the PaymentIntent client secret. Undefined on Paystack. */
+    clientSecret: result?.paymentSecret,
+    paymentId: result?.paymentId,
+    provider: result?.provider,
+    /** PAYSTACK: the inline checkout session. Undefined on Stripe. */
+    accessCode: result?.accessCode,
+    /** PAYSTACK: the hosted page used only when the modal cannot open. */
+    checkoutUrl: result?.checkoutUrl,
+    isPaystack,
+    /** True once there is a Paystack session a pay button can open. */
+    canOpenPaystack: hasPaystackSession(session),
+    openPaystackCheckout: openPaystack,
     isStarting: mutation.isPending,
     error: mutation.error,
     /**
@@ -86,6 +151,7 @@ export function usePaymentFlow(opts: UsePaymentFlowOptions) {
      */
     reset: () => {
       startedRef.current = false;
+      autoOpenedRef.current = null;
       mutation.reset();
     },
   };

package/src/data/queries/useShipping.ts

@@ -82,7 +82,12 @@ export type ApplyCouponResult = {
   discountAmount: number;
   chargedAmount: number;
   chargedCurrency: string;
+  /** STRIPE: the re-issued PaymentIntent client secret. */
   paymentSecret?: string;
+  /** PAYSTACK: the re-issued inline-checkout session. */
+  accessCode?: string;
+  /** PAYSTACK: the hosted page for the re-issued session (runtime fallback). */
+  checkoutUrl?: string;
   paymentId?: string;
   /** Re-quoted sales tax for the re-issued payment intent (display only). */
   taxQuote?: import("../../types/models").PublicTaxQuote;

package/src/data/queries/useSubscriptions.ts

@@ -16,11 +16,38 @@ export type CreateSubscriptionInput = {
   attributionRefId?: string;
 };
 
-/** Create a paid membership subscription (returns the payment client secret). */
+/**
+ * The two things subscribing can produce.
+ *
+ * A member with no live subscription gets a provider session to pay with:
+ * `clientSecret` on Stripe, `accessCode` + `checkoutUrl` on Paystack. A member
+ * who ALREADY subscribes to this artist is changing tier: the server moves their
+ * existing subscription onto the new price with proration, so there is nothing
+ * to pay right now: `requiresPayment` is false, `changed` is true and no
+ * session is issued. Branch on `requiresPayment`, never on the presence of a
+ * secret alone. A Paystack subscription has never had one, and reading its
+ * absence as "nothing to pay" hands out the tier for free.
+ */
+export type CreateSubscriptionResult = {
+  membershipId: string;
+  subscriptionId: string;
+  /** STRIPE ONLY. */
+  clientSecret?: string;
+  /** PAYSTACK ONLY: inline checkout session. */
+  accessCode?: string;
+  /** PAYSTACK ONLY: hosted page, the runtime fallback. */
+  checkoutUrl?: string;
+  currentPeriodStart?: string;
+  currentPeriodEnd?: string;
+  requiresPayment?: boolean;
+  changed?: boolean;
+};
+
+/** Subscribe to a paid tier, or move an existing subscription onto another one. */
 export function useCreateSubscription() {
   const { client, profileId } = useForge();
 
-  return useMutation<{ subscriptionId: string; clientSecret: string }, unknown, CreateSubscriptionInput>({
+  return useMutation<CreateSubscriptionResult, unknown, CreateSubscriptionInput>({
     mutationFn: async (body) => {
       const res = await client.post("/public/payments/subscriptions", { ...body, profileId });
       return res.data;
@@ -40,11 +67,30 @@ export function useCreateFreeSubscription() {
   });
 }
 
-/** Cancel the member's active paid subscription. */
+export type CancelMembershipResult = {
+  membershipId: string;
+  /** The status AFTER cancelling — still `active` while a paid period runs out. */
+  status: string;
+  /** True when the cancellation was scheduled rather than applied immediately. */
+  cancelAtPeriodEnd: boolean;
+  /** ISO date benefits actually stop. Null when they already have. */
+  accessUntil: string | null;
+};
+
+/**
+ * Cancel the member's membership.
+ *
+ * Cancelling a paid, paid-up membership does NOT take effect now: the server
+ * schedules it for the end of the period they have already paid for and the
+ * member keeps their benefits until `accessUntil`. Free tiers (and any
+ * membership with nothing paid up) end immediately. Works for every membership
+ * the member can still use — including one whose card is failing, which used to
+ * be rejected with an error the UI never showed.
+ */
 export function useCancelMembership() {
   const { client, profileId } = useForge();
 
-  return useMutation<unknown, unknown, { membershipId: string }>({
+  return useMutation<CancelMembershipResult, unknown, { membershipId: string }>({
     mutationFn: async ({ membershipId }) => {
       const res = await client.post("/public/payments/subscriptions/cancel", {
         membershipId,

package/src/index.ts

@@ -127,6 +127,11 @@ export * from "./utils/landing";
 export * from "./utils/metaPixel";
 export * from "./utils/cookieConsent";
 export * from "./utils/structuredData";
+// Paystack inline checkout: the ONE implementation of the popup, exported so a
+// hand-rolled payment surface (or `apps/client`) drives it through the same
+// lazy load, the same runtime fallback and the same return-leg navigation
+// rather than growing a second copy.
+export * from "./utils/paystackCheckout";
 // The per-booking checkout credential + where it is kept across the payment
 // redirect. Exported so a host that drives the booking endpoints itself can
 // hold the secret the same way the built-in flows do.

package/src/server/index.ts

@@ -47,6 +47,14 @@ import type {
   CollectionSearchResult,
 } from "../types/models";
 import { collectionParamsToQuery, splitCollectionQuery } from "../data/collectionParams";
+// SEO context for structured data. Pure functions over plain data, so this is
+// safe in the React-free server entry.
+import {
+  seoContextFromSiteConfig,
+  type ReviewSchemaReview,
+  type SiteSeoContext,
+} from "../utils/structuredData";
+export type { SiteSeoContext };
 import type { SiteConfig } from "../data/queries/useWebsite";
 
 /**
@@ -121,6 +129,50 @@ export function fetchSiteConfig(opts: { apiUrl: string; profileId?: string }): P
   return getJson<SiteConfig>(opts.apiUrl, "/public/websites/site-config", { profileId: opts.profileId });
 }
 
+/**
+ * A sample of an entity's published reviews, for the `review` array in its
+ * JSON-LD. Sorted by "helpful" so the sample Google reads is the useful one.
+ *
+ * Purely an enrichment: the star snippet comes from `aggregateRating`, which
+ * every detail payload already carries. Only call this when the entity HAS
+ * reviews — the sample is worth one round trip for a reviewed thing and worth
+ * none for an unreviewed one.
+ */
+export async function fetchEntityReviewsServer(opts: {
+  apiUrl: string;
+  profileId?: string;
+  entityType: "product" | "course" | "coaching_product";
+  entityId: string;
+  limit?: number;
+}): Promise<ReviewSchemaReview[]> {
+  if (!opts.profileId) return [];
+  const res = await getJson<{ data: ReviewSchemaReview[] }>(opts.apiUrl, "/public/reviews", {
+    profileId: opts.profileId,
+    entityType: opts.entityType,
+    entityId: opts.entityId,
+    page: "1",
+    limit: String(opts.limit ?? 5),
+    sort: "helpful",
+  });
+  return res?.data ?? [];
+}
+
+/**
+ * The tenant facts the JSON-LD builders need (settlement currency + creator
+ * name), for a detail route's OWN loader.
+ *
+ * Fetched per route rather than read off the root match on purpose: during SSR
+ * a child `head()` sees the root match with `loaderData: null`, so the root's
+ * site config is invisible there. Pair it with the entity fetch in one
+ * `Promise.all` and the extra round trip costs nothing wall-clock.
+ */
+export async function fetchSeoContextServer(opts: {
+  apiUrl: string;
+  profileId?: string;
+}): Promise<SiteSeoContext> {
+  return seoContextFromSiteConfig(await fetchSiteConfig(opts));
+}
+
 /** The API's unauthenticated liveness route — no tenant, no params, no body. */
 const PROBE_PATH = "/healthcheck";
 

package/src/server/platform.ts

@@ -376,7 +376,7 @@ export async function handlePlatformEvent(
       ),
       budget,
       `Handler for "${event.event}" took longer than ${budget}ms. Move the slow part into ` +
-        `enqueueAppJob() and return — the platform's delivery attempt times out before this finishes.`,
+        `enqueueAppJob() and return. The platform's delivery attempt times out before this finishes.`,
     );
   } catch (err) {
     // 500 so the platform retries. Writes already made carry keys derived from