@tribe-nest/forge 3.59.0 → 3.60.0

package/src/data/queries/useCommunity.ts

@@ -1,5 +1,5 @@
 import { useInfiniteQuery, useMutation, useQuery, useQueryClient, type QueryClient } from "@tanstack/react-query";
-import { useForge } from "../../provider/ForgeProvider";
+import { useCommunityScope } from "../../contexts/CommunityContext";
 import { useChatSocket } from "./useChat";
 
 // ── Types (mirror apps/backend/src/routes/public/community + models) ─────────
@@ -17,7 +17,7 @@ export interface CommunitySpace {
   order: number;
   archivedAt: string | null;
   createdAt: string;
-  /** Gating tiers — empty array = open to every member. */
+  /** Gating tiers: empty array = open to every member. */
   tiers: { id: string; name: string }[];
   /** Only present on the member list query. */
   postCount?: number | null;
@@ -234,35 +234,37 @@ export function communityMemberName(
 }
 
 // Query keys are exported so the realtime layer (and creators) can patch the
-// same caches the data hooks populate — mirrors chatKeys in useChat.ts.
+// same caches the data hooks populate: mirrors chatKeys in useChat.ts.
 export const communityKeys = {
-  spaces: (profileId?: string) => ["public-community-spaces", profileId] as const,
+  // Scoped by COMMUNITY, not profile: a profile runs several, and one cache
+  // entry per profile would show community A's spaces inside community B.
+  spaces: (communityId?: string) => ["public-community-spaces", communityId] as const,
   spaceMembers: (spaceId?: string) => ["public-community-space-members", spaceId] as const,
   posts: (spaceId?: string) => ["public-community-posts", spaceId] as const,
   post: (postId?: string) => ["public-community-post", postId] as const,
   replies: (postId?: string) => ["public-community-replies", postId] as const,
-  myProfile: (profileId?: string) => ["public-community-my-profile", profileId] as const,
-  member: (profileId?: string, accountId?: string) => ["public-community-member", profileId, accountId] as const,
-  notifications: (profileId?: string, unreadOnly?: boolean) =>
-    ["public-community-notifications", profileId, unreadOnly] as const,
-  unread: (profileId?: string) => ["public-community-unread", profileId] as const,
-  leaderboard: (profileId?: string, period?: string) => ["public-community-leaderboard", profileId, period] as const,
-  search: (profileId?: string, q?: string, spaceId?: string) =>
-    ["public-community-search", profileId, q, spaceId ?? null] as const,
+  myProfile: (communityId?: string) => ["public-community-my-profile", communityId] as const,
+  member: (communityId?: string, accountId?: string) => ["public-community-member", communityId, accountId] as const,
+  notifications: (communityId?: string, unreadOnly?: boolean) =>
+    ["public-community-notifications", communityId, unreadOnly] as const,
+  unread: (communityId?: string) => ["public-community-unread", communityId] as const,
+  leaderboard: (communityId?: string, period?: string) => ["public-community-leaderboard", communityId, period] as const,
+  search: (communityId?: string, q?: string, spaceId?: string) =>
+    ["public-community-search", communityId, q, spaceId ?? null] as const,
 };
 
 // ── Data hooks ───────────────────────────────────────────────────────────────
 
 /** Spaces the current member can access (GET /public/community/spaces). */
 export function useCommunitySpaces() {
-  const { client, profileId } = useForge();
+  const { client, profileId, communityId } = useCommunityScope("useCommunitySpaces()");
   return useQuery<CommunitySpace[]>({
-    queryKey: communityKeys.spaces(profileId),
+    queryKey: communityKeys.spaces(communityId),
     queryFn: async () => {
-      const res = await client.get("/public/community/spaces", { params: { profileId } });
+      const res = await client.get("/public/community/spaces", { params: { profileId, communityId } });
       return res.data;
     },
-    enabled: !!profileId && !!client,
+    enabled: !!profileId && !!communityId && !!client,
   });
 }
 
@@ -274,30 +276,30 @@ export interface SpaceMembershipResult {
 /** Patch one space's isJoined/memberCount inside the spaces list cache. */
 export function setSpaceMembership(
   queryClient: QueryClient,
-  profileId: string | undefined,
+  communityId: string | undefined,
   spaceId: string,
   membership: SpaceMembershipResult,
 ) {
-  queryClient.setQueryData(communityKeys.spaces(profileId), (old: CommunitySpace[] | undefined) =>
+  queryClient.setQueryData(communityKeys.spaces(communityId), (old: CommunitySpace[] | undefined) =>
     old?.map((s) => (s.id === spaceId ? { ...s, ...membership } : s)),
   );
 }
 
 /**
  * Join a space (POST /public/community/spaces/:id/join). Tiers still govern
- * who can access a space — joining opts into new-post notifications/digests
+ * who can access a space: joining opts into new-post notifications/digests
  * and the roster. Interacting (post/reply/react) auto-joins server-side.
  */
 export function useJoinCommunitySpace() {
-  const { client, profileId } = useForge();
+  const { client, profileId, communityId } = useCommunityScope("useJoinCommunitySpace()");
   const queryClient = useQueryClient();
   return useMutation({
     mutationFn: async (spaceId: string) => {
-      const res = await client.post(`/public/community/spaces/${spaceId}/join`, { profileId });
+      const res = await client.post(`/public/community/spaces/${spaceId}/join`, { profileId, communityId });
       return { ...(res.data as SpaceMembershipResult), spaceId };
     },
     onSuccess: ({ spaceId, ...membership }) => {
-      setSpaceMembership(queryClient, profileId, spaceId, membership);
+      setSpaceMembership(queryClient, communityId, spaceId, membership);
       queryClient.invalidateQueries({ queryKey: communityKeys.spaceMembers(spaceId) });
     },
   });
@@ -305,15 +307,15 @@ export function useJoinCommunitySpace() {
 
 /** Leave a space (POST /public/community/spaces/:id/leave). Always explicit. */
 export function useLeaveCommunitySpace() {
-  const { client, profileId } = useForge();
+  const { client, profileId, communityId } = useCommunityScope("useLeaveCommunitySpace()");
   const queryClient = useQueryClient();
   return useMutation({
     mutationFn: async (spaceId: string) => {
-      const res = await client.post(`/public/community/spaces/${spaceId}/leave`, { profileId });
+      const res = await client.post(`/public/community/spaces/${spaceId}/leave`, { profileId, communityId });
       return { ...(res.data as SpaceMembershipResult), spaceId };
     },
     onSuccess: ({ spaceId, ...membership }) => {
-      setSpaceMembership(queryClient, profileId, spaceId, membership);
+      setSpaceMembership(queryClient, communityId, spaceId, membership);
       queryClient.invalidateQueries({ queryKey: communityKeys.spaceMembers(spaceId) });
     },
   });
@@ -321,81 +323,81 @@ export function useLeaveCommunitySpace() {
 
 /** Paginated joined-member roster for a space. */
 export function useCommunitySpaceMembers(spaceId?: string, limit = 50) {
-  const { client, profileId } = useForge();
+  const { client, profileId, communityId } = useCommunityScope("useCommunitySpaceMembers()");
   return useInfiniteQuery<CommunitySpaceMembersPage>({
     queryKey: communityKeys.spaceMembers(spaceId),
     queryFn: async ({ pageParam = 1 }) => {
       const res = await client.get(`/public/community/spaces/${spaceId}/members`, {
-        params: { profileId, page: pageParam, limit },
+        params: { profileId, communityId, page: pageParam, limit },
       });
       return res.data;
     },
     initialPageParam: 1,
     getNextPageParam: (lastPage) => (lastPage.hasNextPage ? lastPage.page + 1 : undefined),
-    enabled: !!spaceId && !!client && !!profileId,
+    enabled: !!spaceId && !!client && !!profileId && !!communityId,
   });
 }
 
 /** Paginated posts for a space, pinned first then most recent activity. */
 export function useCommunitySpacePosts(spaceId?: string, limit = 20) {
-  const { client, profileId } = useForge();
+  const { client, profileId, communityId } = useCommunityScope("useCommunitySpacePosts()");
   return useInfiniteQuery<CommunityPostsPage>({
     queryKey: communityKeys.posts(spaceId),
     queryFn: async ({ pageParam = 1 }) => {
       const res = await client.get(`/public/community/spaces/${spaceId}/posts`, {
-        params: { profileId, page: pageParam, limit },
+        params: { profileId, communityId, page: pageParam, limit },
       });
       return res.data;
     },
     initialPageParam: 1,
     getNextPageParam: (lastPage) => (lastPage.hasNextPage ? lastPage.page + 1 : undefined),
-    enabled: !!spaceId && !!client && !!profileId,
+    enabled: !!spaceId && !!client && !!profileId && !!communityId,
   });
 }
 
 /**
  * A single post (GET /public/community/posts/:id). The endpoint also returns a
- * replies page — we request the minimum (limit=1) and let the dedicated
+ * replies page: we request the minimum (limit=1) and let the dedicated
  * replies hook own pagination, so both caches stay simple.
  */
 export function useCommunityPost(postId?: string) {
-  const { client, profileId } = useForge();
+  const { client, profileId, communityId } = useCommunityScope("useCommunityPost()");
   return useQuery<CommunityPost>({
     queryKey: communityKeys.post(postId),
     queryFn: async () => {
       const res = await client.get(`/public/community/posts/${postId}`, {
-        params: { profileId, page: 1, limit: 1 },
+        params: { profileId, communityId, page: 1, limit: 1 },
       });
       return res.data.post;
     },
-    enabled: !!postId && !!client && !!profileId,
+    enabled: !!postId && !!client && !!profileId && !!communityId,
   });
 }
 
 /**
  * Flat, chronological reply pages for a post (GET /public/community/posts/:id/replies).
- * `parentReplyId` is included on every row — assemble the tree with
+ * `parentReplyId` is included on every row: assemble the tree with
  * `buildReplyTree` (data nesting is unlimited; the 3-level display cap is a UI concern).
  */
 export function useCommunityReplies(postId?: string, limit = 100) {
-  const { client, profileId } = useForge();
+  const { client, profileId, communityId } = useCommunityScope("useCommunityReplies()");
   return useInfiniteQuery<CommunityRepliesPage>({
     queryKey: communityKeys.replies(postId),
     queryFn: async ({ pageParam = 1 }) => {
       const res = await client.get(`/public/community/posts/${postId}/replies`, {
-        params: { profileId, page: pageParam, limit },
+        params: { profileId, communityId, page: pageParam, limit },
       });
       return res.data;
     },
     initialPageParam: 1,
     getNextPageParam: (lastPage) => (lastPage.hasNextPage ? lastPage.page + 1 : undefined),
-    enabled: !!postId && !!client && !!profileId,
+    enabled: !!postId && !!client && !!profileId && !!communityId,
   });
 }
 
 export interface CreateCommunityPostInput {
   title?: string;
-  /** Lexical editor state — build one from plain text with `buildLexicalState`. */
+  /** Lexical editor state: build one from plain text with `buildLexicalState`. */
   body: unknown;
   attachments?: CommunityAttachmentInput[];
   mentionedAccountIds?: string[];
@@ -403,16 +405,16 @@ export interface CreateCommunityPostInput {
 
 /** Create a post in a space (POST /public/community/spaces/:id/posts). */
 export function useCreateCommunityPost(spaceId?: string) {
-  const { client, profileId } = useForge();
+  const { client, profileId, communityId } = useCommunityScope("useCreateCommunityPost()");
   const queryClient = useQueryClient();
   return useMutation({
     mutationFn: async (input: CreateCommunityPostInput) => {
-      const res = await client.post(`/public/community/spaces/${spaceId}/posts`, { profileId, ...input });
+      const res = await client.post(`/public/community/spaces/${spaceId}/posts`, { profileId, communityId, ...input });
       return res.data as CommunityPost;
     },
     onSuccess: (post) => {
       prependPostToFeed(queryClient, spaceId, post);
-      queryClient.invalidateQueries({ queryKey: communityKeys.spaces(profileId) });
+      queryClient.invalidateQueries({ queryKey: communityKeys.spaces(communityId) });
     },
   });
 }
@@ -424,19 +426,19 @@ export interface CreateCommunityReplyInput {
   mentionedAccountIds?: string[];
 }
 
-/** Reply to a post — optionally nested under another reply. */
+/** Reply to a post: optionally nested under another reply. */
 export function useCreateCommunityReply(postId?: string) {
-  const { client, profileId } = useForge();
+  const { client, profileId, communityId } = useCommunityScope("useCreateCommunityReply()");
   const queryClient = useQueryClient();
   return useMutation({
     mutationFn: async (input: CreateCommunityReplyInput) => {
-      const res = await client.post(`/public/community/posts/${postId}/replies`, { profileId, ...input });
+      const res = await client.post(`/public/community/posts/${postId}/replies`, { profileId, communityId, ...input });
       return res.data as CommunityReply;
     },
     onSuccess: (reply) => {
       appendReplyToThread(queryClient, postId, reply);
       // Replying implicitly joins the post's space server-side.
-      queryClient.invalidateQueries({ queryKey: communityKeys.spaces(profileId) });
+      queryClient.invalidateQueries({ queryKey: communityKeys.spaces(communityId) });
     },
   });
 }
@@ -452,7 +454,7 @@ export interface ToggleReactionResult {
 
 /** Toggle an emoji reaction (POST /public/community/:entityType/:id/react). */
 export function useToggleCommunityReaction() {
-  const { client, profileId } = useForge();
+  const { client, profileId, communityId } = useCommunityScope("useToggleCommunityReaction()");
   const queryClient = useQueryClient();
   return useMutation({
     mutationFn: async (input: {
@@ -465,6 +467,7 @@ export function useToggleCommunityReaction() {
     }) => {
       const res = await client.post(`/public/community/${input.entityType}/${input.entityId}/react`, {
         profileId,
+        communityId,
         emoji: input.emoji,
       });
       return { ...(res.data as ToggleReactionResult), input };
@@ -472,14 +475,14 @@ export function useToggleCommunityReaction() {
     onSuccess: ({ reactions, input }) => {
       setReactionSummary(queryClient, input, reactions);
       // Adding a reaction implicitly joins the space server-side.
-      queryClient.invalidateQueries({ queryKey: communityKeys.spaces(profileId) });
+      queryClient.invalidateQueries({ queryKey: communityKeys.spaces(communityId) });
     },
   });
 }
 
 /** Report a post or reply to the moderators. */
 export function useReportCommunityContent() {
-  const { client, profileId } = useForge();
+  const { client, profileId, communityId } = useCommunityScope("useReportCommunityContent()");
   return useMutation({
     mutationFn: async (input: {
       entityId: string;
@@ -488,6 +491,7 @@ export function useReportCommunityContent() {
     }) => {
       const res = await client.post(`/public/community/posts/${input.entityId}/report`, {
         profileId,
+        communityId,
         entityType: input.entityType,
         reason: input.reason,
       });
@@ -496,22 +500,22 @@ export function useReportCommunityContent() {
   });
 }
 
-/** The member's own community profile — created on first read (GET /public/community/me). */
+/** The member's own community profile: created on first read (GET /public/community/me). */
 export function useMyCommunityProfile(enabled = true) {
-  const { client, profileId } = useForge();
+  const { client, profileId, communityId } = useCommunityScope("useMyCommunityProfile()");
   return useQuery<CommunityMemberProfile>({
-    queryKey: communityKeys.myProfile(profileId),
+    queryKey: communityKeys.myProfile(communityId),
     queryFn: async () => {
-      const res = await client.get("/public/community/me", { params: { profileId } });
+      const res = await client.get("/public/community/me", { params: { profileId, communityId } });
       return res.data;
     },
-    enabled: enabled && !!profileId && !!client,
+    enabled: enabled && !!profileId && !!communityId && !!client,
   });
 }
 
 /** Update display name / bio / avatar / digest cadence (PUT /public/community/me). */
 export function useUpdateMyCommunityProfile() {
-  const { client, profileId } = useForge();
+  const { client, profileId, communityId } = useCommunityScope("useUpdateMyCommunityProfile()");
   const queryClient = useQueryClient();
   return useMutation({
     mutationFn: async (input: {
@@ -520,127 +524,127 @@ export function useUpdateMyCommunityProfile() {
       avatarUrl?: string | null;
       digestCadence?: CommunityDigestCadence;
     }) => {
-      const res = await client.put("/public/community/me", { profileId, ...input });
+      const res = await client.put("/public/community/me", { profileId, communityId, ...input });
       return res.data as CommunityMemberProfile;
     },
     onSuccess: (profile) => {
-      queryClient.setQueryData(communityKeys.myProfile(profileId), profile);
-      queryClient.invalidateQueries({ queryKey: communityKeys.member(profileId, profile?.accountId) });
+      queryClient.setQueryData(communityKeys.myProfile(communityId), profile);
+      queryClient.invalidateQueries({ queryKey: communityKeys.member(communityId, profile?.accountId) });
     },
   });
 }
 
 /** Another member's profile + recent activity (filtered to spaces you can read). */
 export function useCommunityMemberProfile(accountId?: string) {
-  const { client, profileId } = useForge();
+  const { client, profileId, communityId } = useCommunityScope("useCommunityMemberProfile()");
   return useQuery<CommunityMemberProfile>({
-    queryKey: communityKeys.member(profileId, accountId),
+    queryKey: communityKeys.member(communityId, accountId),
     queryFn: async () => {
-      const res = await client.get(`/public/community/profile/${accountId}`, { params: { profileId } });
+      const res = await client.get(`/public/community/profile/${accountId}`, { params: { profileId, communityId } });
       return res.data;
     },
-    enabled: !!accountId && !!profileId && !!client,
+    enabled: !!accountId && !!profileId && !!communityId && !!client,
   });
 }
 
 /** In-app inbox (GET /public/community/notifications). Returns { data, unreadCount }. */
 export function useCommunityNotifications({ unreadOnly = false, limit = 50 } = {}) {
-  const { client, profileId } = useForge();
+  const { client, profileId, communityId } = useCommunityScope("useCommunityNotifications()");
   return useQuery<{ data: CommunityNotificationItem[]; unreadCount: number }>({
-    queryKey: communityKeys.notifications(profileId, unreadOnly),
+    queryKey: communityKeys.notifications(communityId, unreadOnly),
     queryFn: async () => {
       const res = await client.get("/public/community/notifications", {
-        params: { profileId, page: 1, limit, unreadOnly },
+        params: { profileId, communityId, page: 1, limit, unreadOnly },
       });
       return res.data;
     },
-    enabled: !!profileId && !!client,
+    enabled: !!profileId && !!communityId && !!client,
   });
 }
 
 /** Unread count for the bell, polled every 30s (same cadence as chat unread counts). */
 export function useCommunityUnreadCount(enabled = true) {
-  const { client, profileId } = useForge();
+  const { client, profileId, communityId } = useCommunityScope("useCommunityUnreadCount()");
   return useQuery<number>({
-    queryKey: communityKeys.unread(profileId),
+    queryKey: communityKeys.unread(communityId),
     queryFn: async () => {
       const res = await client.get("/public/community/notifications", {
-        params: { profileId, page: 1, limit: 1, unreadOnly: true },
+        params: { profileId, communityId, page: 1, limit: 1, unreadOnly: true },
       });
       return res.data.unreadCount as number;
     },
-    enabled: enabled && !!profileId && !!client,
+    enabled: enabled && !!profileId && !!communityId && !!client,
     refetchInterval: 30000,
   });
 }
 
-/** Mark notifications read — omit ids to mark ALL unread as read. */
+/** Mark notifications read: omit ids to mark ALL unread as read. */
 export function useMarkCommunityNotificationsRead() {
-  const { client, profileId } = useForge();
+  const { client, profileId, communityId } = useCommunityScope("useMarkCommunityNotificationsRead()");
   const queryClient = useQueryClient();
   return useMutation({
     mutationFn: async (ids?: string[]) => {
-      await client.post("/public/community/notifications/mark-read", { profileId, ids });
+      await client.post("/public/community/notifications/mark-read", { profileId, communityId, ids });
     },
     onSuccess: () => {
       queryClient.invalidateQueries({ queryKey: ["public-community-notifications"] });
-      queryClient.invalidateQueries({ queryKey: communityKeys.unread(profileId) });
+      queryClient.invalidateQueries({ queryKey: communityKeys.unread(communityId) });
     },
   });
 }
 
 /** Points leaderboard (GET /public/community/leaderboard?period=all|7|30). */
 export function useCommunityLeaderboard(period: CommunityLeaderboardPeriod = "all", limit = 20) {
-  const { client, profileId } = useForge();
+  const { client, profileId, communityId } = useCommunityScope("useCommunityLeaderboard()");
   return useQuery<CommunityLeaderboardEntry[]>({
-    queryKey: communityKeys.leaderboard(profileId, period),
+    queryKey: communityKeys.leaderboard(communityId, period),
     queryFn: async () => {
-      const res = await client.get("/public/community/leaderboard", { params: { profileId, period, limit } });
+      const res = await client.get("/public/community/leaderboard", { params: { profileId, communityId, period, limit } });
       return res.data;
     },
-    enabled: !!profileId && !!client,
+    enabled: !!profileId && !!communityId && !!client,
   });
 }
 
 /**
  * Member directory for @mention autocomplete. There is no dedicated public
  * member-search endpoint yet, so this reads the all-time leaderboard at its max
- * page size (100) — every community_profiles row ranked by points — and filters
+ * page size (100) (every community_profiles row ranked by points) and filters
  * client-side.
  */
 export function useCommunityMentionDirectory() {
-  const { client, profileId } = useForge();
+  const { client, profileId, communityId } = useCommunityScope("useCommunityMentionDirectory()");
   return useQuery<CommunityLeaderboardEntry[]>({
-    queryKey: communityKeys.leaderboard(profileId, "mention-directory"),
+    queryKey: communityKeys.leaderboard(communityId, "mention-directory"),
     queryFn: async () => {
       const res = await client.get("/public/community/leaderboard", {
-        params: { profileId, period: "all", limit: 100 },
+        params: { profileId, communityId, period: "all", limit: 100 },
       });
       return res.data;
     },
-    enabled: !!profileId && !!client,
+    enabled: !!profileId && !!communityId && !!client,
     staleTime: 60_000,
   });
 }
 
 /**
  * FTS over posts + replies (min 2 chars). Scopes to spaces the member can read;
- * pass `spaceId` (a space uuid OR its per-profile slug) to scope to one space —
+ * pass `spaceId` (a space uuid OR its per-profile slug) to scope to one space:
  * scoping can only narrow, never widen, access. Backward-compatible: called with
  * just a query it searches every accessible space (prior behavior).
  */
 export function useCommunitySearch(q: string, spaceId?: string) {
-  const { client, profileId } = useForge();
+  const { client, profileId, communityId } = useCommunityScope("useCommunitySearch()");
   const trimmed = q.trim();
   return useQuery<CommunitySearchResults>({
-    queryKey: communityKeys.search(profileId, trimmed, spaceId),
+    queryKey: communityKeys.search(communityId, trimmed, spaceId),
     queryFn: async () => {
       const res = await client.get("/public/community/search", {
-        params: { profileId, q: trimmed, page: 1, limit: 20, ...(spaceId ? { spaceId } : {}) },
+        params: { profileId, communityId, q: trimmed, page: 1, limit: 20, ...(spaceId ? { spaceId } : {}) },
       });
       return res.data;
     },
-    enabled: trimmed.length >= 2 && !!profileId && !!client,
+    enabled: trimmed.length >= 2 && !!profileId && !!communityId && !!client,
   });
 }
 

package/src/data/queries/useMembership.ts

@@ -6,12 +6,13 @@ import type {
   QuestionnaireAnswer,
 } from "../../types/models";
 import { useForge } from "../../provider/ForgeProvider";
+import { useOptionalCommunityContext } from "../../contexts/CommunityContext";
 import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
 
 /**
  * The membership invite token this visitor arrived holding, read from the
- * `invite` search param of the CURRENT url (the invite email links to
- * `/i/membership/checkout?membershipTierId=X&invite=TOKEN`).
+ * `invite` search param of the CURRENT url (the invite email links to the
+ * community's About page, `/i/communities/<slug>?invite=TOKEN`).
  *
  * Deliberately not stored anywhere: it is a bearer credential, and the durable
  * copy is the email. Returns undefined on the server and when absent.
@@ -31,10 +32,17 @@ export interface UseGetMembershipTiersOptions {
    * `null` forwards nothing even when the url carries one.
    */
   inviteToken?: string | null;
+  /**
+   * The community whose tiers to list. Omitted, the surrounding
+   * `<CommunityProvider>` is used; outside one, every live tier on the profile
+   * comes back (a members-only gate on a product can name tiers from any
+   * community). Each tier carries its `communityId` either way.
+   */
+  communityId?: string | null;
 }
 
 /**
- * `opts.enabled` gates the request on top of the usual profile/client checks —
+ * `opts.enabled` gates the request on top of the usual profile/client checks:
  * for a caller that only needs tier NAMES when something is actually gated, and
  * must not add a request to every ungated storefront. Defaults to on, so every
  * existing caller is unchanged.
@@ -44,22 +52,34 @@ export interface UseGetMembershipTiersOptions {
  */
 export function useGetMembershipTiers(opts: UseGetMembershipTiersOptions = {}) {
   const { client, profileId } = useForge();
+  const context = useOptionalCommunityContext();
   const inviteToken = opts.inviteToken === undefined ? readMembershipInviteFromUrl() : (opts.inviteToken ?? undefined);
+  // `null` asks for the whole profile even inside a provider.
+  const communityId = opts.communityId === undefined ? context?.communityId : (opts.communityId ?? undefined);
+  // Inside a provider whose slug has not resolved yet, wait rather than list the whole profile.
+  const waitingForCommunity = opts.communityId === undefined && !!context && !context.communityId;
 
   return useQuery<MembershipTier[]>({
-    // The token is appended only when present, so the no-invite key stays the
-    // one every existing cache seed (SSR, specs) already writes.
-    queryKey: inviteToken ? ["membership-tiers", profileId, inviteToken] : ["membership-tiers", profileId],
+    // The community and the token are appended only when present, so the
+    // profile-wide key stays the one every existing cache seed (SSR, specs)
+    // already writes.
+    queryKey: [
+      "membership-tiers",
+      profileId,
+      ...(communityId ? [{ communityId }] : []),
+      ...(inviteToken ? [inviteToken] : []),
+    ],
     queryFn: async () => {
       const res = await client.get("/public/membership-tiers", {
         params: {
           profileId: profileId,
+          ...(communityId ? { communityId } : {}),
           ...(inviteToken ? { inviteToken } : {}),
         },
       });
       return res.data;
     },
-    enabled: !!profileId && !!client && opts.enabled !== false,
+    enabled: !!profileId && !!client && !waitingForCommunity && opts.enabled !== false,
   });
 }
 
@@ -109,6 +129,10 @@ export type ApplyForMembershipInput = {
   questionnaire?: QuestionnaireAnswer[];
   /** Where Stripe returns after a redirect-based card confirmation. */
   returnUrl?: string;
+  /** A per-email invite token (`?invite=`). The community comes from the tier. */
+  inviteToken?: string;
+  /** A shareable invite link token (`?join=`). */
+  joinToken?: string;
 };
 
 /** Invalidate everything an application changes: the tier cards and the fan's list. */
@@ -118,6 +142,7 @@ function useInvalidateApplications() {
     Promise.all([
       queryClient.invalidateQueries({ queryKey: ["membership-tiers"] }),
       queryClient.invalidateQueries({ queryKey: ["my-membership-applications"] }),
+      queryClient.invalidateQueries({ queryKey: ["public-communities"] }),
     ]);
 }