@tribe-nest/forge 3.59.0 → 3.61.0

package/src/data/queries/useCommunityModeration.ts

@@ -0,0 +1,327 @@
+import { keepPreviousData, useMutation, useQuery, useQueryClient, type QueryClient } from "@tanstack/react-query";
+import { useCommunityScope } from "../../contexts/CommunityContext";
+import { communityKeys, type CommunityPost, type CommunityReply } from "./useCommunity";
+
+/**
+ * Moderation from the site (community parity §4), on the member session.
+ *
+ * Base path `/public/community-moderation`. The server authorises every call by
+ * the caller's role in the community of the ROW acted on (a moderator there, or
+ * an owner/admin of the profile) and answers 404 otherwise, so these hooks
+ * never decide who may moderate. `useCommunityCanModerate` decides only whether
+ * the tools are shown. There is no ban here: only an admin bans, from the
+ * dashboard.
+ */
+
+// ── Types (mirror apps/backend/src/routes/public/communityModeration) ────────
+
+/** One open report (ModerationReport.getQueue). */
+export interface CommunityModerationReport {
+  id: string;
+  profileId: string;
+  communityId: string | null;
+  entityType: "community_post" | "community_reply" | string;
+  entityId: string;
+  /** The post to open: the post itself for a post report, the reply's post for a reply report. */
+  postId: string | null;
+  reason: string | null;
+  reporterAccountId: string;
+  status: "pending" | "resolved" | "dismissed" | string;
+  resolvedAt: string | null;
+  resolvedBy: string | null;
+  createdAt: string;
+  updatedAt: string;
+  reporterFirstName: string | null;
+  reporterLastName: string | null;
+  /** The first 240 characters of the reported post or reply. */
+  contentPreview: string | null;
+  /** The reported content is already hidden (removed). */
+  contentHidden: boolean;
+}
+
+/** A post held for approval. */
+export interface CommunityPendingPost {
+  id: string;
+  spaceId: string;
+  spaceName: string | null;
+  title: string | null;
+  bodyText: string | null;
+  authorAccountId: string;
+  authorName: string | null;
+  /** `approval_new_member`, `approval_all` or `keyword:<word>`. See `describeHoldReason`. */
+  moderationReason: string | null;
+  createdAt: string;
+}
+
+/** A reply held for approval. */
+export interface CommunityPendingReply {
+  id: string;
+  postId: string;
+  postTitle: string | null;
+  bodyText: string | null;
+  authorAccountId: string;
+  authorName: string | null;
+  moderationReason: string | null;
+  createdAt: string;
+}
+
+export interface CommunityModerationQueue {
+  reports: { data: CommunityModerationReport[]; total: number };
+  pending: { posts: CommunityPendingPost[]; replies: CommunityPendingReply[] };
+}
+
+export type CommunityModerationLogAction =
+  | "hold"
+  | "approve"
+  | "reject"
+  | "pin"
+  | "unpin"
+  | "lock"
+  | "unlock"
+  | "remove"
+  | "restore"
+  | "mute"
+  | "unmute"
+  | "ban"
+  | "unban"
+  | "role_member"
+  | "role_moderator"
+  | "adjust_points"
+  | "report_resolved"
+  | "report_resolved_hidden"
+  | "report_dismissed";
+
+export interface CommunityModerationLogEntry {
+  id: string;
+  action: CommunityModerationLogAction | string;
+  entityType: "community_post" | "community_reply" | string | null;
+  entityId: string | null;
+  /** Null: the system held it (approval mode or a blocked word). */
+  actorAccountId: string | null;
+  targetAccountId: string | null;
+  reason: string | null;
+  createdAt: string;
+  actorName: string | null;
+  targetName: string | null;
+}
+
+export interface CommunityModerationLogPage {
+  data: CommunityModerationLogEntry[];
+  total: number;
+  page: number;
+  pageSize: number;
+  hasNextPage: boolean;
+}
+
+export type CommunityPostModerationAction =
+  | "pin"
+  | "unpin"
+  | "lock"
+  | "unlock"
+  | "remove"
+  | "restore"
+  | "approve"
+  | "reject";
+
+export type CommunityReplyModerationAction = "remove" | "restore" | "approve" | "reject";
+
+const BASE = "/public/community-moderation";
+
+// ── Reads ────────────────────────────────────────────────────────────────────
+
+/** Open reports and held posts and replies for this community (GET /queue). */
+export function useCommunityModerationQueue(enabled = true) {
+  const { client, profileId, communityId } = useCommunityScope("useCommunityModerationQueue()");
+  return useQuery<CommunityModerationQueue>({
+    queryKey: communityKeys.moderationQueue(communityId),
+    queryFn: async () => {
+      const res = await client.get(`${BASE}/queue`, { params: { profileId, communityId } });
+      return res.data;
+    },
+    enabled: enabled && !!profileId && !!communityId && !!client,
+  });
+}
+
+/** One page of this community's moderation log, newest first (GET /log). */
+export function useCommunityModerationLog(page = 1, limit = 20, enabled = true) {
+  const { client, profileId, communityId } = useCommunityScope("useCommunityModerationLog()");
+  return useQuery<CommunityModerationLogPage>({
+    queryKey: [...communityKeys.moderationLog(communityId, page), limit],
+    queryFn: async () => {
+      const res = await client.get(`${BASE}/log`, { params: { profileId, communityId, page, limit } });
+      return res.data;
+    },
+    // Paging keeps the current page on screen until the next one lands.
+    placeholderData: keepPreviousData,
+    enabled: enabled && !!profileId && !!communityId && !!client,
+  });
+}
+
+// ── Cache helpers ────────────────────────────────────────────────────────────
+
+type Patchable = { id: string };
+
+/** Patch one post wherever it is cached: every space feed and the post itself. */
+export function patchCommunityPost(queryClient: QueryClient, postId: string, patch: Partial<CommunityPost>) {
+  const apply = <T extends Patchable>(item: T): T => (item.id === postId ? { ...item, ...patch } : item);
+  queryClient.setQueriesData({ queryKey: ["public-community-posts"] }, (old: any) => {
+    if (!old?.pages?.length) return old;
+    return { ...old, pages: old.pages.map((page: any) => ({ ...page, data: page.data.map(apply) })) };
+  });
+  queryClient.setQueryData(communityKeys.post(postId), (old: CommunityPost | undefined) => (old ? apply(old) : old));
+}
+
+/** Patch one reply wherever it is cached (every loaded thread). */
+export function patchCommunityReply(queryClient: QueryClient, replyId: string, patch: Partial<CommunityReply>) {
+  const apply = <T extends Patchable>(item: T): T => (item.id === replyId ? { ...item, ...patch } : item);
+  queryClient.setQueriesData({ queryKey: ["public-community-replies"] }, (old: any) => {
+    if (!old?.pages?.length) return old;
+    return { ...old, pages: old.pages.map((page: any) => ({ ...page, data: page.data.map(apply) })) };
+  });
+}
+
+function invalidateModeration(queryClient: QueryClient, communityId: string | undefined) {
+  queryClient.invalidateQueries({ queryKey: communityKeys.moderationQueue(communityId) });
+  queryClient.invalidateQueries({ queryKey: ["public-community-moderation-log", communityId] });
+}
+
+// ── Actions ──────────────────────────────────────────────────────────────────
+
+/**
+ * Pin, unpin, lock, unlock, remove, restore, approve or reject a post
+ * (POST /posts/:id/<action>). `reason` is read by remove and reject (max 500).
+ * Approving or rejecting something that is not pending answers 409.
+ *
+ * A removal is marked in the cache (`archivedAt`) rather than dropped, so the
+ * card can offer an undo in place. A reload drops it; the moderation log keeps
+ * the way back.
+ */
+export function useModerateCommunityPost() {
+  const { client, profileId, communityId } = useCommunityScope("useModerateCommunityPost()");
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (input: { postId: string; action: CommunityPostModerationAction; reason?: string }) => {
+      const reason = input.reason?.trim() || undefined;
+      const res = await client.post(`${BASE}/posts/${input.postId}/${input.action}`, { profileId, reason });
+      return { result: res.data as unknown, input };
+    },
+    onSuccess: ({ input }) => {
+      const { postId, action } = input;
+      switch (action) {
+        case "pin":
+        case "unpin":
+          patchCommunityPost(queryClient, postId, { isPinned: action === "pin" });
+          // Pinned posts sort first, so the feed order changes.
+          queryClient.invalidateQueries({ queryKey: ["public-community-posts"] });
+          break;
+        case "lock":
+        case "unlock":
+          patchCommunityPost(queryClient, postId, { isLocked: action === "lock" });
+          break;
+        case "remove":
+          patchCommunityPost(queryClient, postId, { archivedAt: new Date().toISOString() });
+          break;
+        case "restore":
+          patchCommunityPost(queryClient, postId, { archivedAt: null });
+          // Restored from the log, the post is in no cache yet: fetch it back into its feed.
+          queryClient.invalidateQueries({ queryKey: ["public-community-posts"] });
+          break;
+        case "approve":
+          patchCommunityPost(queryClient, postId, { status: "published", moderationReason: null });
+          queryClient.invalidateQueries({ queryKey: ["public-community-posts"] });
+          break;
+        case "reject":
+          patchCommunityPost(queryClient, postId, { status: "rejected" });
+          break;
+      }
+      invalidateModeration(queryClient, communityId);
+    },
+  });
+}
+
+/** Remove, restore, approve or reject a reply (POST /replies/:id/<action>). */
+export function useModerateCommunityReply() {
+  const { client, profileId, communityId } = useCommunityScope("useModerateCommunityReply()");
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (input: {
+      replyId: string;
+      action: CommunityReplyModerationAction;
+      reason?: string;
+      /** The reply's post, when known, so its thread and reply count refresh. */
+      postId?: string;
+    }) => {
+      const reason = input.reason?.trim() || undefined;
+      const res = await client.post(`${BASE}/replies/${input.replyId}/${input.action}`, { profileId, reason });
+      return { result: res.data as unknown, input };
+    },
+    onSuccess: ({ input }) => {
+      const { replyId, action, postId } = input;
+      if (action === "remove") patchCommunityReply(queryClient, replyId, { archivedAt: new Date().toISOString() });
+      if (action === "restore") {
+        patchCommunityReply(queryClient, replyId, { archivedAt: null });
+        // Restored from the log, the post is unknown: refresh every loaded thread.
+        if (!postId) queryClient.invalidateQueries({ queryKey: ["public-community-replies"] });
+      }
+      if (action === "approve") {
+        patchCommunityReply(queryClient, replyId, { status: "published", moderationReason: null });
+        if (postId) queryClient.invalidateQueries({ queryKey: communityKeys.replies(postId) });
+      }
+      if (action === "reject") patchCommunityReply(queryClient, replyId, { status: "rejected" });
+      // The post's reply count moves with remove, restore and approve.
+      if (postId && action !== "reject") queryClient.invalidateQueries({ queryKey: communityKeys.post(postId) });
+      invalidateModeration(queryClient, communityId);
+    },
+  });
+}
+
+/**
+ * Close a report (POST /reports/:id/resolve): `resolved` (optionally hiding the
+ * reported content) or `dismissed`.
+ */
+export function useResolveCommunityReport() {
+  const { client, profileId, communityId } = useCommunityScope("useResolveCommunityReport()");
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (input: { reportId: string; action: "resolved" | "dismissed"; hideContent?: boolean }) => {
+      const res = await client.post(`${BASE}/reports/${input.reportId}/resolve`, {
+        profileId,
+        action: input.action,
+        hideContent: input.hideContent ?? false,
+      });
+      return { result: res.data as unknown, input };
+    },
+    onSuccess: ({ input }) => {
+      invalidateModeration(queryClient, communityId);
+      if (input.hideContent) {
+        // The hidden post or reply leaves every feed and thread it sits in.
+        queryClient.invalidateQueries({ queryKey: ["public-community-posts"] });
+        queryClient.invalidateQueries({ queryKey: ["public-community-post"] });
+        queryClient.invalidateQueries({ queryKey: ["public-community-replies"] });
+      }
+    },
+  });
+}
+
+/**
+ * Mute a member in THIS community until a time, or unmute them with
+ * `mutedUntil: null` (POST /members/:accountId/mute).
+ */
+export function useMuteCommunityMember() {
+  const { client, profileId, communityId } = useCommunityScope("useMuteCommunityMember()");
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (input: { accountId: string; mutedUntil: string | null }) => {
+      const res = await client.post(`${BASE}/members/${input.accountId}/mute`, {
+        profileId,
+        communityId,
+        mutedUntil: input.mutedUntil,
+      });
+      return { result: res.data as unknown, input };
+    },
+    onSuccess: ({ input }) => {
+      queryClient.invalidateQueries({ queryKey: communityKeys.member(communityId, input.accountId) });
+      invalidateModeration(queryClient, communityId);
+    },
+  });
+}

package/src/data/queries/useCommunityWiki.ts

@@ -0,0 +1,137 @@
+import { useQuery } from "@tanstack/react-query";
+import { useCommunityScope } from "../../contexts/CommunityContext";
+import { isNotFound, useViewerAccountId } from "./useCommunities";
+
+/**
+ * A community's wiki (community parity §5.1), read on the site.
+ *
+ * `GET /public/communities/:slug/wiki` lists the pages this viewer may see, in
+ * order: public pages for everyone, plus members-only pages for a member. A
+ * members-only page their tier does not open comes back `locked`, with the
+ * tiers that open it and no content. `GET /public/communities/:slug/wiki/:page`
+ * returns one page's content, and answers 404 for a page the viewer may not
+ * read. Both take an optional session, so both are keyed per account.
+ */
+
+export interface CommunityWikiTier {
+  id: string;
+  name: string;
+}
+
+/** One row of the page list. */
+export interface CommunityWikiPageSummary {
+  id: string;
+  title: string;
+  slug: string;
+  isPublic: boolean;
+  /** Listed for this member, but their tier does not open it. */
+  locked: boolean;
+  /** The tiers that open a locked page. Empty when it is not locked. */
+  unlockTiers: CommunityWikiTier[];
+  /**
+   * The level that opens a locked page, when the member's level is what is
+   * missing. Null otherwise (and on older servers, absent).
+   */
+  unlockLevel?: number | null;
+  updatedAt: string;
+}
+
+/** One readable page. `content` is Lexical editor JSON from the Knowledge Base editor. */
+export interface CommunityWikiPage {
+  id: string;
+  title: string;
+  slug: string;
+  isPublic: boolean;
+  content: unknown;
+  updatedAt: string;
+}
+
+export const communityWikiKeys = {
+  list: (profileId: string | undefined, slug: string | undefined, accountId: string | null) =>
+    ["public-community-wiki", profileId, slug, accountId] as const,
+  page: (
+    profileId: string | undefined,
+    slug: string | undefined,
+    pageSlug: string | undefined,
+    accountId: string | null,
+  ) => ["public-community-wiki-page", profileId, slug, pageSlug, accountId] as const,
+  media: (
+    profileId: string | undefined,
+    slug: string | undefined,
+    pageSlug: string | undefined,
+    mediaId: string | undefined,
+    accountId: string | null,
+  ) => ["public-community-wiki-media", profileId, slug, pageSlug, mediaId, accountId] as const,
+};
+
+/** A short-lived signed read for a private wiki image. */
+export interface CommunityWikiMediaUrl {
+  url: string;
+  expiresInSeconds: number;
+}
+
+/**
+ * How long a signed image address is trusted before it is asked for again:
+ * a minute short of its expiry, and never under 30 seconds.
+ */
+export function wikiMediaRefreshMs(expiresInSeconds: number | undefined): number {
+  const seconds = typeof expiresInSeconds === "number" && expiresInSeconds > 0 ? expiresInSeconds : 600;
+  return Math.max(30, seconds - 60) * 1000;
+}
+
+const enc = (value: string) => encodeURIComponent(value);
+
+/** The wiki pages this viewer may see listed, in order. */
+export function useCommunityWikiPages(opts: { enabled?: boolean } = {}) {
+  const { client, profileId, slug } = useCommunityScope("useCommunityWikiPages()");
+  const accountId = useViewerAccountId();
+  return useQuery<CommunityWikiPageSummary[]>({
+    queryKey: communityWikiKeys.list(profileId, slug, accountId),
+    queryFn: async () => (await client.get(`/public/communities/${enc(slug!)}/wiki`, { params: { profileId } })).data,
+    enabled: opts.enabled !== false && !!slug && !!profileId && !!client,
+    retry: (count, error) => !isNotFound(error) && count < 2,
+  });
+}
+
+/** One wiki page's content. A 404 means this viewer may not read it (locked, hidden or gone). */
+export function useCommunityWikiPageContent(pageSlug: string | undefined, opts: { enabled?: boolean } = {}) {
+  const { client, profileId, slug } = useCommunityScope("useCommunityWikiPageContent()");
+  const accountId = useViewerAccountId();
+  return useQuery<CommunityWikiPage>({
+    queryKey: communityWikiKeys.page(profileId, slug, pageSlug, accountId),
+    queryFn: async () =>
+      (await client.get(`/public/communities/${enc(slug!)}/wiki/${enc(pageSlug!)}`, { params: { profileId } })).data,
+    enabled: opts.enabled !== false && !!slug && !!pageSlug && !!profileId && !!client,
+    retry: (count, error) => !isNotFound(error) && count < 2,
+  });
+}
+
+/**
+ * A signed address for a PRIVATE wiki image (`kbmedia:<id>` in a page body),
+ * from `GET /public/communities/:slug/wiki/:page/media/:mediaId`. The server
+ * signs only for a viewer who may read that page, only for media the page
+ * embeds, and answers 404 otherwise. The address lives 10 minutes, so it is
+ * fetched again shortly before it expires. Never cached beyond this viewer.
+ */
+export function useCommunityWikiMediaUrl(
+  pageSlug: string | undefined,
+  mediaId: string | undefined,
+  opts: { enabled?: boolean } = {},
+) {
+  const { client, profileId, slug } = useCommunityScope("useCommunityWikiMediaUrl()");
+  const accountId = useViewerAccountId();
+  return useQuery<CommunityWikiMediaUrl>({
+    queryKey: communityWikiKeys.media(profileId, slug, pageSlug, mediaId, accountId),
+    queryFn: async () =>
+      (
+        await client.get(`/public/communities/${enc(slug!)}/wiki/${enc(pageSlug!)}/media/${enc(mediaId!)}`, {
+          params: { profileId },
+        })
+      ).data,
+    enabled: opts.enabled !== false && !!slug && !!pageSlug && !!mediaId && !!profileId && !!client,
+    retry: (count, error) => !isNotFound(error) && count < 2,
+    staleTime: (query) => wikiMediaRefreshMs(query.state.data?.expiresInSeconds),
+    refetchInterval: (query) => (query.state.data ? wikiMediaRefreshMs(query.state.data.expiresInSeconds) : false),
+    refetchOnWindowFocus: true,
+  });
+}

package/src/data/queries/useCourses.ts

@@ -1,4 +1,5 @@
 import type { PaginatedData, PillarDiscountQuote, PublicCourse } from "../../types/models";
+import { readMetaSignals } from "../../utils/metaEvents";
 import { useForge } from "../../provider/ForgeProvider";
 import { useMutation, useQuery } from "@tanstack/react-query";
 
@@ -79,6 +80,7 @@ export function useCreateCourseBooking(courseId?: string) {
         courseId,
         profileId,
         ...body,
+        metaSignals: readMetaSignals(),
       });
       return res.data;
     },

package/src/data/queries/useEmailSignIn.ts

@@ -0,0 +1,79 @@
+import { useMutation } from "@tanstack/react-query";
+import { useForge } from "../../provider/ForgeProvider";
+import type { PublicAuthUser } from "../../types/models";
+
+/**
+ * Email-first sign-in (`/public/sessions/email/*`): the fan types an email, we
+ * email a 6-digit code, and the code decides the rest. Someone with an account
+ * on this site is signed in by the code alone; someone new is asked their name
+ * and then signed in. The fan never chooses between "Create account" and
+ * "Sign in", and the start answer is the same whether or not the address has an
+ * account, so it cannot be used to find out who has one.
+ *
+ * These are the raw calls. A `signed_in` answer carries a session, which only
+ * `PublicAuthContext.adoptSession` may store; `useEmailCodeSignIn` wires the
+ * two together.
+ */
+
+/** A session minted by the email flow: the same account shape `/public/sessions/verify` returns. */
+export interface EmailSignInSession {
+  status: "signed_in";
+  account: PublicAuthUser;
+  token: string;
+  refreshToken: string;
+  associationId: string;
+}
+
+/** `POST /public/sessions/email/start`. */
+export interface EmailSignInStarted {
+  status: "code_sent";
+  email: string;
+}
+
+/** `POST /public/sessions/email/verify`: either a session, or a ticket for the name step. Both are HTTP 200. */
+export type EmailSignInVerified = EmailSignInSession | { status: "needs_profile"; ticket: string };
+
+export interface CompleteEmailSignUpInput {
+  email: string;
+  /** The 64-character ticket `verify` answered with. */
+  ticket: string;
+  firstName: string;
+  lastName: string;
+  acceptedPrivacy?: boolean;
+}
+
+/** Email a code to `email`. Throttled server-side to one per 60 seconds. */
+export function useStartEmailSignIn() {
+  const { client, profileId } = useForge();
+  return useMutation<EmailSignInStarted, unknown, { email: string }>({
+    mutationFn: async ({ email }) => (await client.post("/public/sessions/email/start", { profileId, email })).data,
+  });
+}
+
+/** Redeem the code. Branch on `status`, never on the HTTP code. */
+export function useVerifyEmailSignIn() {
+  const { client, profileId } = useForge();
+  return useMutation<EmailSignInVerified, unknown, { email: string; code: string }>({
+    mutationFn: async ({ email, code }) =>
+      (await client.post("/public/sessions/email/verify", { profileId, email, code })).data,
+  });
+}
+
+/** Create the account for a verified address with no account yet, and sign in. */
+export function useCompleteEmailSignUp() {
+  const { client, profileId } = useForge();
+  return useMutation<EmailSignInSession, unknown, CompleteEmailSignUpInput>({
+    mutationFn: async ({ email, ticket, firstName, lastName, acceptedPrivacy }) =>
+      (
+        await client.post("/public/sessions/email/complete", {
+          profileId,
+          email,
+          ticket,
+          firstName,
+          lastName,
+          acceptedTerms: true,
+          ...(acceptedPrivacy === undefined ? {} : { acceptedPrivacy }),
+        })
+      ).data,
+  });
+}

package/src/data/queries/useEvents.ts

@@ -1,4 +1,5 @@
 import type { AppliedDiscountCoupon, IEvent } from "../../types/models";
+import { readMetaSignals } from "../../utils/metaEvents";
 import type { SeatAttributes, SeatMapDocument } from "@tribe-nest/seating-core";
 import { useForge } from "../../provider/ForgeProvider";
 import { useMutation, useQuery } from "@tanstack/react-query";
@@ -262,7 +263,11 @@ export function useCreateEventOrder(eventId?: string) {
 
   return useMutation<CreateEventOrderResult, unknown, CreateEventOrderInput>({
     mutationFn: async (body) => {
-      const res = await client.post(`/public/events/${eventId}/orders`, { ...body, profileId });
+      const res = await client.post(`/public/events/${eventId}/orders`, {
+        ...body,
+        profileId,
+        metaSignals: readMetaSignals(),
+      });
       return res.data;
     },
   });

package/src/data/queries/useForms.ts

@@ -1,4 +1,5 @@
 import { useRef } from "react";
+import { fireServerMetaEvent, readMetaSignals } from "../../utils/metaEvents";
 import type { FormData, FormAnswerEntry } from "../../types/models";
 import { useForge } from "../../provider/ForgeProvider";
 import { useMutation, useQuery } from "@tanstack/react-query";
@@ -63,14 +64,17 @@ export function useSubmitPublicForm(formId?: string) {
       const res = await client.post(`/public/forms/${formId}/submit`, {
         ...payload,
         idempotencyKey: keyRef.current,
+        metaSignals: readMetaSignals(),
       });
       return res.data;
     },
     // Rotate only once the write has landed. A failed submit keeps the key so
     // the retry is recognised as the same act; a successful one starts a fresh
     // act, so a form left mounted for corrections records each as its own.
-    onSuccess: () => {
+    onSuccess: (data) => {
       keyRef.current = newIdempotencyKey();
+      // The server queued Lead for this submission; fire its pixel twin.
+      fireServerMetaEvent(data);
     },
   });
 }

package/src/data/queries/useLeadMagnet.ts

@@ -1,4 +1,5 @@
 import { useForge } from "../../provider/ForgeProvider";
+import { fireServerMetaEvent, readMetaSignals, type ServerMetaEvent } from "../../utils/metaEvents";
 import { useMutation, useQuery } from "@tanstack/react-query";
 
 export type LeadMagnetMedia = {
@@ -71,11 +72,14 @@ export type JoinEmailListInput = {
 export function useJoinEmailList() {
   const { client, profileId } = useForge();
 
-  return useMutation<{ requiresConfirmation?: boolean }, unknown, JoinEmailListInput>({
+  return useMutation<{ requiresConfirmation?: boolean; metaEvent?: ServerMetaEvent }, unknown, JoinEmailListInput>({
     mutationFn: async (body) => {
-      const res = await client.post(`/public/email-lists/join`, { ...body, profileId });
+      const res = await client.post(`/public/email-lists/join`, { ...body, profileId, metaSignals: readMetaSignals() });
       return res.data;
     },
+    // Active immediately (no double opt-in): the server queued
+    // CompleteRegistration; fire its pixel twin.
+    onSuccess: (data) => fireServerMetaEvent(data),
   });
 }