@tribe-nest/forge 3.59.0 → 3.61.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tribe-nest/forge",
-  "version": "3.59.0",
+  "version": "3.61.0",
   "publishConfig": {
     "access": "public"
   },
@@ -35,6 +35,7 @@
     "@tribe-nest/media-protocol": "^1.0.0",
     "@tribe-nest/seating-core": "^1.0.0",
     "axios": "^1.7.9",
+    "cobe": "2.0.1",
     "libphonenumber-js": "^1.13.13",
     "lucide-react": "^0.510.0",
     "react-hook-form": "^7.60.0",

package/src/_tests/testCommunity.tsx

@@ -0,0 +1,28 @@
+import type { ReactNode } from "react";
+import { CommunityProvider } from "../contexts/CommunityContext";
+import type { PublicCommunity } from "../data/queries/useCommunities";
+
+/**
+ * A community for specs. Member-content hooks throw outside a
+ * `<CommunityProvider>`, so a spec that renders one wraps it in `InCommunity`.
+ * `initialData` makes the id known on the first render, with no request.
+ */
+export const TEST_COMMUNITY: PublicCommunity = {
+  id: "11111111-1111-4111-8111-111111111111",
+  name: "Fan Club",
+  slug: "fan-club",
+  description: "Where the fans are.",
+  coverUrl: null,
+  logoUrl: null,
+  category: "Music",
+  tags: [],
+  memberCount: 42,
+};
+
+export function InCommunity({ children, community = TEST_COMMUNITY }: { children: ReactNode; community?: PublicCommunity }) {
+  return (
+    <CommunityProvider community={community.slug} initialData={community}>
+      {children}
+    </CommunityProvider>
+  );
+}

package/src/contexts/CartContext.tsx

@@ -1,6 +1,7 @@
 "use client";
 import type { IBookingFee, ProductDeliveryType } from "../types/models";
-import { useCallback, useContext, useMemo, useState } from "react";
+import { useCallback, useContext, useMemo, useRef, useState } from "react";
+import { trackMeta } from "../utils/metaEvents";
 import { createSharedContext } from "../runtime/registry";
 import type { ReactNode } from "react";
 import { useEffect } from "react";
@@ -333,6 +334,15 @@ export function CartProvider({ children }: { children: ReactNode }) {
         return false;
       }
       setCartItems((prev) => [...prev, next]);
+      // Meta AddToCart, only for a line that is new: a duplicate updates the
+      // line and adds nothing.
+      trackMeta("AddToCart", {
+        content_ids: [item.productId],
+        content_name: item.title,
+        content_type: "product",
+        value: Number(item.price) * (item.quantity || 1),
+        num_items: item.quantity || 1,
+      });
       return true;
     },
     [cartItems],
@@ -392,7 +402,30 @@ export function CartProvider({ children }: { children: ReactNode }) {
     }
   }, []);
 
+  // The latest selection, read by `setTickets` to tell an increase (an add,
+  // for Meta) from a decrease, outside the state updater (which must stay pure).
+  const ticketItemsRef = useRef(ticketItems);
+  ticketItemsRef.current = ticketItems;
+
   const setTickets = useCallback((item: TicketCartItem) => {
+    const before = ticketItemsRef.current.find((t) => t.eventId === item.eventId);
+    let added = 0;
+    let addedValue = 0;
+    for (const [ticketId, qty] of Object.entries(item.tickets)) {
+      const increase = qty - (before?.tickets[ticketId] ?? 0);
+      if (increase <= 0) continue;
+      added += increase;
+      addedValue += increase * Number(item.ticketMeta[ticketId]?.price ?? 0);
+    }
+    if (added > 0) {
+      trackMeta("AddToCart", {
+        content_ids: [item.eventId],
+        content_name: item.eventTitle,
+        content_type: "product",
+        value: Number.isFinite(addedValue) ? addedValue : undefined,
+        num_items: added,
+      });
+    }
     setTicketItems((prev) => [...prev.filter((t) => t.eventId !== item.eventId), item]);
     setCartOpen(true);
   }, []);

package/src/contexts/CommunityContext.tsx

@@ -0,0 +1,192 @@
+"use client";
+import { useContext, useEffect, useMemo, type ReactNode } from "react";
+import { useQueryClient } from "@tanstack/react-query";
+import { createSharedContext } from "../runtime/registry";
+import { useForge } from "../provider/ForgeProvider";
+import {
+  communitiesKeys,
+  usePublicCommunity,
+  useViewerAccountId,
+  type CommunityDetail,
+  type PublicCommunity,
+} from "../data/queries/useCommunities";
+
+/**
+ * Which community the surrounding UI is about.
+ *
+ * A profile can run several communities, each fully isolated (members, tiers,
+ * feed, spaces, collections, chat, calls, identity). So every member-content
+ * hook has to be told WHICH one, and it is told by this provider rather than by
+ * an argument threaded through every component: the hosted pages fill it from
+ * the `$slug` in the URL, and a creator's own page wraps a section in it.
+ *
+ *     <CommunityProvider community="fan-club">
+ *       <CommunityHome />
+ *     </CommunityProvider>
+ *
+ * A member-content hook used outside it THROWS. That is deliberate: guessing
+ * ("the first community", "any membership on the profile") is exactly the
+ * cross-community leak this model exists to prevent, and a developer error at
+ * build time is far cheaper than a fan reading the wrong community's feed.
+ *
+ * The context is shared across bundles (`createSharedContext`), so a provider a
+ * site mounts is the one the hosted pages bundle reads, and vice versa.
+ */
+
+export interface CommunityContextValue {
+  /** The community, once loaded. */
+  community: PublicCommunity | undefined;
+  /** Its id. Known before the community loads when the provider was given an id. */
+  communityId: string | undefined;
+  /** Its slug. Known before the community loads when the provider was given a slug. */
+  slug: string | undefined;
+  isLoading: boolean;
+  /** True when the server answered that no such live community exists. */
+  notFound: boolean;
+  /** What the provider was given: a slug or an id. */
+  ref: string;
+}
+
+const CommunityContext = createSharedContext<CommunityContextValue | null>("community", null);
+
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+
+/** True when a community reference is an id rather than a slug. */
+export function isCommunityId(ref: string): boolean {
+  return UUID_RE.test(ref);
+}
+
+export interface CommunityProviderProps {
+  /** The community's slug (as in `/i/communities/<slug>`) or its id. */
+  community: string;
+  /**
+   * The community when the host already has it (SSR, a list it came from).
+   * Seeds the cache so nothing below waits on a request. Optional.
+   */
+  initialData?: PublicCommunity;
+  children: ReactNode;
+}
+
+/**
+ * Supplies one community to every hook and component below it. See the file
+ * docblock for why a member-content hook refuses to run without one.
+ */
+export function CommunityProvider({ community: ref, initialData, children }: CommunityProviderProps) {
+  const { profileId } = useForge();
+  const queryClient = useQueryClient();
+  const accountId = useViewerAccountId();
+
+  // Seed the detail cache from `initialData` so `community` is there on the
+  // first render. The seed carries no tiers or viewer, so the real read still
+  // runs and replaces it.
+  useEffect(() => {
+    if (!initialData || !profileId) return;
+    const key = communitiesKeys.detail(profileId, ref, {}, accountId);
+    if (!queryClient.getQueryData(key)) {
+      queryClient.setQueryData<CommunityDetail>(
+        key,
+        { community: initialData, tiers: [], viewer: EMPTY_VIEWER, invite: null },
+        { updatedAt: 0 },
+      );
+    }
+  }, [initialData, profileId, ref, accountId, queryClient]);
+
+  const detail = usePublicCommunity(ref);
+  const community = detail.data?.community ?? initialData;
+  const byId = isCommunityId(ref);
+
+  const value = useMemo<CommunityContextValue>(
+    () => ({
+      community,
+      communityId: community?.id ?? (byId ? ref : undefined),
+      slug: community?.slug ?? (byId ? undefined : ref),
+      isLoading: !community && detail.isLoading,
+      notFound: !community && (detail.error as { response?: { status?: number } } | null)?.response?.status === 404,
+      ref,
+    }),
+    [community, byId, ref, detail.isLoading, detail.error],
+  );
+
+  return <CommunityContext.Provider value={value}>{children}</CommunityContext.Provider>;
+}
+
+const EMPTY_VIEWER = {
+  state: "none" as const,
+  membership: null,
+  application: null,
+  upgradeTiers: [],
+  canInteract: false,
+};
+
+/** Thrown by any member-content hook used outside `<CommunityProvider>`. */
+export class MissingCommunityProviderError extends Error {
+  constructor(hookName: string) {
+    super(
+      `${hookName} must be used inside <CommunityProvider community="<slug or id>">. ` +
+        "A creator can run several communities, so Forge will not guess which one this is. " +
+        "Wrap the page (or section) in <CommunityProvider>, or pass `community` to the component that accepts it.",
+    );
+    this.name = "MissingCommunityProviderError";
+  }
+}
+
+/**
+ * The surrounding community. Throws outside `<CommunityProvider>`.
+ *
+ * `communityId` can be undefined for a moment while a slug resolves, so data
+ * hooks gate on it rather than on the provider alone.
+ */
+export function useCommunityContext(): CommunityContextValue {
+  const ctx = useContext(CommunityContext);
+  if (!ctx) throw new MissingCommunityProviderError("useCommunityContext()");
+  return ctx;
+}
+
+/** The surrounding community, or null outside a provider. For components that work either way. */
+export function useOptionalCommunityContext(): CommunityContextValue | null {
+  return useContext(CommunityContext);
+}
+
+/**
+ * What a member-content data hook needs: the API client, the profile and the
+ * community. Throws `MissingCommunityProviderError` naming the calling hook.
+ */
+export function useCommunityScope(hookName: string) {
+  const ctx = useContext(CommunityContext);
+  if (!ctx) throw new MissingCommunityProviderError(hookName);
+  const { client, profileId } = useForge();
+  return { client, profileId, communityId: ctx.communityId, slug: ctx.slug };
+}
+
+// ---- The upgrade sheet opener ----------------------------------------------------
+
+/**
+ * Lets any locked item inside a community ("Unlock with {tier}") open the
+ * community's ONE upgrade sheet, wherever it is drawn. `CommunityHome` provides
+ * it; a custom member area can provide its own. Absent, locked items fall back
+ * to a link to the community's About page with the tier preselected.
+ */
+export interface CommunityUpgradeOpener {
+  /** Open the upgrade sheet, optionally preselecting the tier that unlocks the item. */
+  openUpgrade: (tierId?: string | null) => void;
+}
+
+const CommunityUpgradeOpenerContext = createSharedContext<CommunityUpgradeOpener | null>(
+  "communityUpgradeOpener",
+  null,
+);
+
+export function CommunityUpgradeOpenerProvider({
+  value,
+  children,
+}: {
+  value: CommunityUpgradeOpener;
+  children: ReactNode;
+}) {
+  return <CommunityUpgradeOpenerContext.Provider value={value}>{children}</CommunityUpgradeOpenerContext.Provider>;
+}
+
+/** The surrounding upgrade opener, or null when no community home provides one. */
+export function useCommunityUpgradeOpener(): CommunityUpgradeOpener | null {
+  return useContext(CommunityUpgradeOpenerContext);
+}

package/src/contexts/PublicAuthContext.tsx

@@ -31,7 +31,7 @@ import {
   storeTokenPair,
 } from "../client/tokenStorage";
 
-// Kept for compat — the canonical constants live in client/tokenStorage.ts.
+// Kept for compat. The canonical constants live in client/tokenStorage.ts.
 export const ACCESS_TOKEN_KEY = PUBLIC_ACCESS_TOKEN_KEY;
 export { PUBLIC_ACCESS_TOKEN_KEY };
 
@@ -129,7 +129,7 @@ function PublicAuthProvider({ children }: AuthProviderProps) {
   }, []);
 
   const { data: currencies } = useQuery({
-    // profileId scopes the cache — supportedCurrencies is narrowed to the tenant's
+    // profileId scopes the cache: supportedCurrencies is narrowed to the tenant's
     // connected account (must match useCurrencies' key so they share one fetch).
     queryKey: ["public-currencies", profileId],
     queryFn: async () => {
@@ -241,6 +241,17 @@ function PublicAuthProvider({ children }: AuthProviderProps) {
     }
   };
 
+  /**
+   * Sign in with a session another call already minted (the email-first flow's
+   * `signed_in` answers). The same three steps every sign-in here ends with:
+   * store the token pair, hand the access token to the client, record the user.
+   */
+  const adoptSession = (session: { token: string; refreshToken?: string; account: PublicAuthUser }) => {
+    storeTokenPair(PUBLIC_ACCESS_TOKEN_KEY, PUBLIC_REFRESH_TOKEN_KEY, session.token, session.refreshToken);
+    setToken(session.token);
+    dispatch({ type: Types.Login, payload: { user: session.account } });
+  };
+
   const resendLoginCode = async (email: string) => {
     // /public/sessions requires the profile context.
     await client.post("/public/sessions/resend-code", { email, profileId });
@@ -303,7 +314,7 @@ function PublicAuthProvider({ children }: AuthProviderProps) {
         ...data,
       });
       // No token: signup issues no session until the emailed code is redeemed
-      // (see PublicAuthChallenge). Keep the caller's data — `verifyRegistration`
+      // (see PublicAuthChallenge). Keep the caller's data: `verifyRegistration`
       // needs the coupon/consent flags again to finish the job.
       const { email } = response.data as { status: "verify_email"; email: string };
       dispatch({ type: Types.Loading, payload: { isLoading: false } });
@@ -372,6 +383,7 @@ function PublicAuthProvider({ children }: AuthProviderProps) {
         validateLoginCredentials,
         verifyLoginCode,
         resendLoginCode,
+        adoptSession,
         logout,
         register,
         verifyRegistration,

package/src/data/queries/_tests/metaSignals.spec.tsx

@@ -0,0 +1,130 @@
+// @vitest-environment jsdom
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { act, renderHook } from "@testing-library/react";
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import type { ReactNode } from "react";
+
+/**
+ * Every request that creates a visitor record carries `metaSignals`, which is
+ * what lets a server event sent later (from a worker, with no request) still
+ * match the visitor. A create response that carries `metaEvent` means the
+ * server queued that event: the browser fires only its pixel twin.
+ */
+
+const post = vi.fn();
+
+vi.mock("../../../provider/ForgeProvider", () => ({
+  useForge: () => ({ client: { post }, profileId: "profile-1" }),
+}));
+
+import { useSubmitPublicForm } from "../useForms";
+import { useJoinEmailList } from "../useLeadMagnet";
+import { useCreateOrder } from "../useOrders";
+import { useUpdateCoachingBooking } from "../useCoachingAvailability";
+import { resetMetaPolicy, setMetaPolicy } from "../../../utils/metaEvents";
+import { saveCookieConsent, GRANT_ALL, DENY_ALL } from "../../../utils/cookieConsent";
+
+const wrapper = ({ children }: { children: ReactNode }) => {
+  const queryClient = new QueryClient({ defaultOptions: { mutations: { retry: false } } });
+  return <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>;
+};
+
+let fbq: ReturnType<typeof vi.fn>;
+let fetchSpy: ReturnType<typeof vi.fn>;
+const pixel = () => fbq.mock.calls.filter((c) => c[0] === "trackSingle");
+
+beforeEach(() => {
+  post.mockReset();
+  resetMetaPolicy();
+  window.localStorage.clear();
+  document.cookie = "_fbp=fb.1.1.2; path=/";
+  fbq = vi.fn();
+  (window as unknown as { fbq: unknown }).fbq = fbq;
+  fetchSpy = vi.fn().mockResolvedValue({ ok: true });
+  vi.stubGlobal("fetch", fetchSpy);
+  window.history.replaceState({}, "", "/contact");
+  setMetaPolicy({
+    pixelId: "555",
+    enabled: true,
+    requireConsent: true,
+    apiUrl: "https://api.test",
+    subdomain: "artist",
+    currency: "USD",
+    resolved: true,
+  });
+});
+
+afterEach(() => {
+  vi.unstubAllGlobals();
+  resetMetaPolicy();
+  document.cookie = "_fbp=; path=/; max-age=0";
+});
+
+describe("useSubmitPublicForm", () => {
+  it("attaches metaSignals and fires the pixel copy of the server's Lead", async () => {
+    saveCookieConsent(GRANT_ALL);
+    post.mockResolvedValue({ data: { id: "sub-1", metaEvent: { name: "Lead", eventId: "sub-1", customData: { content_name: "Contact" } } } });
+    const { result } = renderHook(() => useSubmitPublicForm("form-1"), { wrapper });
+
+    await act(async () => {
+      await result.current.mutateAsync({ answers: [], respondentEmail: "a@b.test" });
+    });
+
+    expect(post).toHaveBeenCalledWith("/public/forms/form-1/submit", {
+      answers: [],
+      respondentEmail: "a@b.test",
+      idempotencyKey: expect.any(String),
+      metaSignals: { pageUrl: "http://localhost:3000/contact", marketingConsent: true, fbp: "fb.1.1.2" },
+    });
+    expect(pixel()).toEqual([["trackSingle", "555", "Lead", { content_name: "Contact" }, { eventID: "sub-1" }]]);
+    // The server already queued its copy.
+    expect(fetchSpy).not.toHaveBeenCalled();
+  });
+
+  it("sends consent false and no Meta ids when marketing was declined, and fires no pixel", async () => {
+    saveCookieConsent(DENY_ALL);
+    post.mockResolvedValue({ data: { id: "sub-2", metaEvent: { name: "Lead", eventId: "sub-2" } } });
+    const { result } = renderHook(() => useSubmitPublicForm("form-1"), { wrapper });
+
+    await act(async () => {
+      await result.current.mutateAsync([]);
+    });
+
+    expect(post.mock.calls[0][1].metaSignals).toEqual({ pageUrl: "http://localhost:3000/contact", marketingConsent: false });
+    expect(pixel()).toEqual([]);
+  });
+});
+
+describe("other create requests", () => {
+  beforeEach(() => saveCookieConsent(GRANT_ALL));
+
+  it("useJoinEmailList attaches metaSignals and fires CompleteRegistration from the response", async () => {
+    post.mockResolvedValue({ data: { metaEvent: { name: "CompleteRegistration", eventId: "subscriber-1" } } });
+    const { result } = renderHook(() => useJoinEmailList(), { wrapper });
+    await act(async () => {
+      await result.current.mutateAsync({ email: "a@b.test", emailListId: "list-1" });
+    });
+    expect(post.mock.calls[0][1]).toMatchObject({ email: "a@b.test", profileId: "profile-1", metaSignals: { marketingConsent: true } });
+    expect(pixel()).toEqual([["trackSingle", "555", "CompleteRegistration", {}, { eventID: "subscriber-1" }]]);
+  });
+
+  it("useUpdateCoachingBooking fires Schedule from the response", async () => {
+    post.mockResolvedValue({ data: { bookingId: "b-1", isConfirmed: true, metaEvent: { name: "Schedule", eventId: "b-1" } } });
+    const { result } = renderHook(() => useUpdateCoachingBooking("coach-1"), { wrapper });
+    await act(async () => {
+      await result.current.mutateAsync({ bookingId: "b-1", email: "a@b.test", firstName: "A", lastName: "B", confirmIfFree: true });
+    });
+    expect(post.mock.calls[0][1].metaSignals).toMatchObject({ marketingConsent: true, fbp: "fb.1.1.2" });
+    expect(pixel()).toEqual([["trackSingle", "555", "Schedule", {}, { eventID: "b-1" }]]);
+  });
+
+  it("useCreateOrder attaches metaSignals and fires nothing itself", async () => {
+    post.mockResolvedValue({ data: { orderId: "o-1", totalAmount: 10, subTotal: 10 } });
+    const { result } = renderHook(() => useCreateOrder(), { wrapper });
+    await act(async () => {
+      await result.current.mutateAsync({ amount: 10, email: "a@b.test", cartItems: [] });
+    });
+    expect(post.mock.calls[0][1]).toMatchObject({ amount: 10, profileId: "profile-1", metaSignals: { marketingConsent: true } });
+    expect(pixel()).toEqual([]);
+  });
+});

package/src/data/queries/useAccount.ts

@@ -1,6 +1,6 @@
 import type { IPublicOrder, IPublicPost, PaginatedData } from "../../types/models";
 import { useForge } from "../../provider/ForgeProvider";
-import { useMutation, useQuery } from "@tanstack/react-query";
+import { useInfiniteQuery, useMutation, useQuery } from "@tanstack/react-query";
 
 /** Orders placed by the signed-in member on this profile. */
 export function useUserOrders(accountId?: string) {
@@ -40,6 +40,11 @@ export type NotificationPreferences = {
 };
 
 /** The member's notification-type preferences for this profile. */
+/**
+ * @deprecated Reads `newPosts` / `chatMessages`, which the server never sends:
+ * the preferences endpoint speaks the `"<type>.<channel>"` matrix. Use
+ * `useNotificationMatrix` and `useUpdateNotificationMatrix`.
+ */
 export function useNotificationPreferences(enabled = true) {
   const { client, profileId } = useForge();
 
@@ -55,7 +60,11 @@ export function useNotificationPreferences(enabled = true) {
   });
 }
 
-/** Update one notification-type preference. */
+/**
+ * @deprecated Sends `{ newPosts: false }`, which the server drops without an
+ * error (it accepts only `"<type>.<channel>"` keys), so nothing is ever saved.
+ * Use `useUpdateNotificationMatrix`.
+ */
 export function useUpdateNotificationPreference() {
   const { client, profileId } = useForge();
 
@@ -69,3 +78,25 @@ export function useUpdateNotificationPreference() {
     },
   });
 }
+
+/**
+ * Every order, a page at a time, for a list with a "Show more" button.
+ *
+ * `useUserOrders` sends no page, so the server's default of 10 applies and a
+ * buyer with more orders than that never saw the older ones. `/public/orders`
+ * returns a bare array with no total, so a FULL page is the only sign that
+ * another may follow; an exact multiple costs one extra, empty request.
+ */
+export function useUserOrdersPaged(accountId?: string, limit = 20) {
+  const { client, profileId } = useForge();
+  return useInfiniteQuery({
+    queryKey: ["user-orders", accountId, profileId, "paged", limit],
+    initialPageParam: 1,
+    queryFn: async ({ pageParam }) => {
+      const res = await client.get("/public/orders", { params: { profileId, page: pageParam, limit } });
+      return res.data as IPublicOrder[];
+    },
+    getNextPageParam: (last, pages) => (last.length === limit ? pages.length + 1 : undefined),
+    enabled: !!accountId && !!profileId && !!client,
+  });
+}

package/src/data/queries/useAnalytics.ts

@@ -5,7 +5,7 @@ import { useForge } from "../../provider/ForgeProvider";
  * server-side CAPI twin, and for correlating first-party events. */
 export function newEventId(): string {
   if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") return crypto.randomUUID();
-  // Fallback for older runtimes — not cryptographically strong, only needs to be
+  // Fallback for older runtimes: not cryptographically strong, only needs to be
   // unique enough to pair a pixel + CAPI event.
   return `evt_${Date.now().toString(36)}_${Math.abs(hashString(String(performance?.now?.() ?? Date.now()))).toString(36)}`;
 }
@@ -33,7 +33,7 @@ export function getAnalyticsSessionId(subdomain: string): string | null {
     }
     return sessionId;
   } catch {
-    // Private mode / storage disabled — fall back to an ephemeral per-load id.
+    // Private mode / storage disabled: fall back to an ephemeral per-load id.
     return `${subdomain}_${Date.now()}`;
   }
 }
@@ -44,7 +44,7 @@ export interface TrackEventOptions {
   /**
    * Store a session id in `sessionStorage` and send it with events. Default
    * `true`. Set `false` for cookieless, Plausible-style analytics: nothing is
-   * written to the device and no id is sent — the backend derives a rotating
+   * written to the device and no id is sent; the backend derives a rotating
    * per-day visitor hash instead, so the "visits" metric still works without
    * needing storage consent.
    */
@@ -53,7 +53,7 @@ export interface TrackEventOptions {
 
 /**
  * The first-party website-analytics primitive. Returns a `track(eventType,
- * eventData)` function that posts to `POST /public/websites/track-event` — the
+ * eventData)` function that posts to `POST /public/websites/track-event`, the
  * same feed the platform's admin analytics dashboard reads (visits, page views,
  * clicks, geo). The backend enriches each event with geo-IP + user agent.
  *
@@ -68,7 +68,7 @@ export function useTrackEvent(opts?: TrackEventOptions) {
 
   const buildPayload = useCallback(
     (eventData: Record<string, unknown>) => {
-      // Cookieless mode omits the sessionId entirely — the backend derives a
+      // Cookieless mode omits the sessionId entirely; the backend derives a
       // rotating per-day visitor hash so nothing touches the device.
       const sessionId = storeSession && subdomain ? getAnalyticsSessionId(subdomain) : undefined;
       const payload: Record<string, unknown> = { ...eventData };
@@ -133,5 +133,5 @@ export function useTrackEvent(opts?: TrackEventOptions) {
     [apiUrl, subdomain, buildPayload],
   );
 
-  return { track, trackBeacon };
+  return { track, trackBeacon, apiUrl, subdomain };
 }

package/src/data/queries/useCallChat.ts

@@ -22,7 +22,7 @@ type ReactionRow = { emoji: string; count: number; reactedByMe: boolean };
 type MessageWithReactions = ChatMessage & { reactions?: ReactionRow[] };
 
 const senderName = (message: MessageWithReactions): string =>
-  [message.senderFirstName, message.senderLastName].filter(Boolean).join(" ").trim() || message.senderAccountId;
+  [message.senderFirstName, message.senderLastName].filter(Boolean).join(" ").trim() || (message.senderAccountId ?? "");
 
 export function useCallChat(callId: string | undefined): CallStageChat | undefined {
   const { client, profileId } = useForge();
@@ -145,7 +145,7 @@ export function useCallChat(callId: string | undefined): CallStageChat | undefin
       id: message.id,
       content: message.content,
       senderName: senderName(message),
-      senderKey: message.senderAccountId,
+      senderKey: message.senderAccountId ?? message.senderAgentId ?? "",
       at: message.createdAt,
       reactions: message.reactions ?? [],
     }));