@domino-sdk/relay 1.16.0 → 1.18.0

package/dist/react/index.js

@@ -8,37 +8,205 @@ import {
   discoverSolanaWallets,
   readSignInMethods,
   signInOptionsFrom
-} from "../chunk-3YCCHTCU.js";
-import "../chunk-Y6SRF54G.js";
+} from "../chunk-BWW3XLEE.js";
+import "../chunk-4VWMY4II.js";
 import {
   createRelayAction
-} from "../chunk-XMBM2XD5.js";
-import "../chunk-LLMJ2SUT.js";
-import "../chunk-UJACD6K2.js";
+} from "../chunk-T47OFHHX.js";
+import "../chunk-IE4QOQUI.js";
+import "../chunk-XSLRNFIY.js";
+import "../chunk-5P5PTZ3T.js";
+import "../chunk-I525XMUY.js";
+import {
+  sessionMember
+} from "../chunk-YXAK2637.js";
 import {
   RelayError,
   RelayErrorCode,
   asRelayError,
   clientError,
-  isRelayError
-} from "../chunk-2UAVZCMH.js";
-import "../chunk-6QJ3LADK.js";
-import {
+  isRelayError,
   isRequestError
-} from "../chunk-NPGENI7K.js";
-import "../chunk-YT3QKV2L.js";
-import {
-  sessionMember
-} from "../chunk-PT5STHFH.js";
-import "../chunk-46C33ASD.js";
+} from "../chunk-EMLDFUTV.js";
 
-// src/react/activity.ts
+// src/react/context.ts
+import { createContext, useContext } from "react";
+var StoreContext = createContext(null);
+function useStore() {
+  const store = useContext(StoreContext);
+  if (!store) {
+    throw new Error("Domino hooks require <RelayProvider>");
+  }
+  return store;
+}
+function useRelay() {
+  return useStore().client;
+}
+
+// src/react/keys.ts
+var relayKeys = {
+  /** `useExperience`: invalidating it reads the quest experience again. */
+  experience: ["experience"],
+  /** `useMe`. */
+  me: ["me"],
+  /** `useAccounts`. */
+  accounts: ["accounts"],
+  /** `useWallets`. */
+  wallets: ["wallets"],
+  /** `useMyProfile`, `useProfile`, `useProfileCompletions`, `useProfileReferral`. */
+  profiles: ["profiles"],
+  /** `useLeaderboard`, `useLeaderboardPlacement`. */
+  leaderboards: ["leaderboards"],
+  /** `useReferralSummary`. */
+  referrals: ["referrals"],
+  /** `usePointLedgers`. */
+  pointLedgers: ["point-ledgers"],
+  badges: ["badges"],
+  /** `useTieredRewards`. */
+  tieredRewards: ["tiered-rewards"],
+  /** `useSignInMethods`. */
+  signInMethods: ["sign-in-methods"],
+  /** `useEntitlements`, `useDeliveries`. */
+  rewards: ["rewards"],
+  /** `useBalances`, `usePointHistory`. */
+  balances: ["balances"],
+  /** `useQuestOutcomes`. */
+  outcomes: ["outcomes"],
+  /** `useOffers`, `useRedeemOffer`. */
+  offers: ["offers"]
+};
+var rewardKeys = {
+  entitlements: [...relayKeys.rewards, "entitlements"],
+  deliveries: [...relayKeys.rewards, "deliveries"]
+};
+var completionChanges = [
+  relayKeys.rewards,
+  relayKeys.balances,
+  relayKeys.badges,
+  relayKeys.leaderboards,
+  relayKeys.profiles,
+  relayKeys.referrals,
+  relayKeys.offers
+];
+var activityChanges = {
+  "attempt.accepted": [
+    relayKeys.experience,
+    relayKeys.outcomes,
+    ...completionChanges
+  ],
+  "attempt.rejected": [relayKeys.experience, relayKeys.outcomes],
+  "attempt.review": [relayKeys.experience, relayKeys.outcomes],
+  "points.awarded": [
+    relayKeys.balances,
+    relayKeys.leaderboards,
+    relayKeys.offers,
+    rewardKeys.deliveries
+  ],
+  "entitlement.granted": [relayKeys.experience, relayKeys.rewards],
+  "entitlement.collected": [relayKeys.experience, relayKeys.rewards],
+  "delivery.updated": [rewardKeys.deliveries],
+  "referral.qualified": [relayKeys.referrals, relayKeys.profiles],
+  unknown: [relayKeys.experience]
+};
+
+// src/react/action.ts
+import { useCallback, useRef, useState } from "react";
+var IDLE = Object.freeze({
+  status: "idle",
+  data: void 0,
+  error: null
+});
+function actionError(cause) {
+  return isRequestError(cause) && !isRelayError(cause) ? new RelayError(cause.message, {
+    kind: cause.kind,
+    status: cause.status,
+    code: cause.code,
+    uncertain: cause.uncertain,
+    operationId: cause.operationId,
+    replaySafe: cause.recovery === "replay",
+    retryAfter: cause.retryAfter,
+    cause
+  }) : asRelayError(cause);
+}
+function useRelayAction(scope) {
+  const owner = useRef({ scope, action: createRelayAction() });
+  const [state, setState] = useState({ owner: owner.current, ...IDLE });
+  if (owner.current.scope !== scope) {
+    owner.current = { scope, action: createRelayAction() };
+  }
+  const execute = useCallback(
+    async (task) => {
+      const current2 = owner.current;
+      if (current2.action.busy) {
+        return { ok: false };
+      }
+      const result = task ? current2.action.run(task) : current2.action.retry();
+      setState({
+        owner: current2,
+        status: "pending",
+        data: void 0,
+        error: null
+      });
+      try {
+        const value = await result;
+        if (owner.current === current2) {
+          setState({
+            owner: current2,
+            status: "success",
+            data: value,
+            error: null
+          });
+        }
+        return { ok: true, value };
+      } catch (caught) {
+        const error = actionError(current2.action.error ?? caught);
+        if (owner.current === current2) {
+          setState({ owner: current2, status: "error", data: void 0, error });
+        }
+        return { ok: false, error };
+      }
+    },
+    []
+  );
+  const retry = useCallback(() => execute(), [execute]);
+  const settle = useCallback(() => {
+    const current2 = owner.current;
+    if (!current2.action.settle()) {
+      return false;
+    }
+    setState({ owner: current2, ...IDLE });
+    return true;
+  }, []);
+  const reset = useCallback(() => {
+    const current2 = owner.current;
+    if (!current2.action.busy && current2.action.actionId === void 0) {
+      setState({ owner: current2, ...IDLE });
+    }
+  }, []);
+  const current = state.owner === owner.current ? state : IDLE;
+  const isPending = current.status === "pending";
+  return {
+    run: execute,
+    retry,
+    settle,
+    reset,
+    status: current.status,
+    isPending,
+    data: current.data,
+    error: current.error,
+    /** @deprecated Use `isPending`. Removed in 2.0.0. */
+    busy: isPending
+  };
+}
+
+// src/react/query.ts
 import {
-  useCallback,
+  useCallback as useCallback2,
   useEffect,
   useLayoutEffect,
-  useRef,
-  useState,
+  useMemo,
+  useRef as useRef2,
+  useState as useState2,
   useSyncExternalStore
 } from "react";
 
@@ -287,252 +455,47 @@ var QueryCache = class {
           entry.version++;
           this.#write(entry, { status: "ready", data, error: null });
         }
-      } catch (cause) {
-        if (!counts()) {
-          return;
-        }
-        const error = relayError(cause);
-        if (error.code === RelayErrorCode.StaleSession) {
-          this.#onStaleSession();
-        }
-        const gone = error.kind === "http" && error.status === 404 || error.code === RelayErrorCode.StaleSession;
-        entry.version++;
-        this.#write(
-          entry,
-          entry.state.status === "ready" && !gone ? { status: "ready", data: entry.state.data, error } : { status: "error", data: void 0, error }
-        );
-      } finally {
-        if (counts()) {
-          entry.controller = null;
-          entry.pending = null;
-          entry.settledAt = Date.now();
-          this.#schedule(entry);
-        }
-      }
-    })();
-    entry.pending = pending;
-    return pending;
-  }
-  /** Arms the poll for the shortest interval anyone on screen asked for. */
-  #schedule(entry) {
-    clearTimeout(entry.timer);
-    if (this.#disposed || entry.pending || entry.listeners.size === 0 || entry.intervals.size === 0) {
-      return;
-    }
-    const interval = Math.min(...entry.intervals.values());
-    const wait = Math.max(0, entry.settledAt + interval - Date.now());
-    entry.timer = setTimeout(() => {
-      if (visible()) {
-        void this.#fetch(entry, false);
-      }
-    }, wait);
-  }
-};
-
-// src/react/context.ts
-import { createContext, useContext } from "react";
-var StoreContext = createContext(null);
-function useStore() {
-  const store = useContext(StoreContext);
-  if (!store) {
-    throw new Error("Domino hooks require <RelayProvider>");
-  }
-  return store;
-}
-function useRelay() {
-  return useStore().client;
-}
-
-// src/react/activity.ts
-function useActivity(options = {}) {
-  const store = useStore();
-  const scope = useSyncExternalStore(
-    store.subscribe,
-    () => store.scope,
-    () => null
-  );
-  const session = useSyncExternalStore(
-    store.subscribe,
-    () => store.session,
-    () => LOADING
-  );
-  const callback = useRef(options.onEvent);
-  useLayoutEffect(() => {
-    callback.current = options.onEvent;
-  }, [options.onEvent]);
-  const observer = useRef(null);
-  const [state, setState] = useState(null);
-  const { cursor, intervalMs } = options;
-  useEffect(() => {
-    if (!scope?.member) {
-      return;
-    }
-    let active = true;
-    const watch = store.client.me.activity.observe(
-      (event) => callback.current?.(event),
-      {
-        cursor,
-        intervalMs,
-        onState: (observation) => {
-          if (!active) {
-            return;
-          }
-          if (observation.kind === "ready") {
-            setState((prior) => {
-              const items = prior?.owner === scope.key && prior.value.status === "ready" ? prior.value.data.items : [];
-              const combined = new Map(
-                [...items, ...observation.progress.items].map((event) => [
-                  event.id,
-                  event
-                ])
-              );
-              return {
-                owner: scope.key,
-                value: {
-                  status: "ready",
-                  data: {
-                    ...observation.progress,
-                    items: [...combined.values()].slice(-100)
-                  },
-                  error: null
-                }
-              };
-            });
-          } else if (observation.kind === "error") {
-            setState((prior) => ({
-              owner: scope.key,
-              value: prior?.owner === scope.key && prior.value.status === "ready" ? { ...prior.value, error: relayError(observation.error) } : {
-                status: "error",
-                data: void 0,
-                error: relayError(observation.error)
-              }
-            }));
-          } else if (observation.kind === "loading") {
-            setState({ owner: scope.key, value: LOADING });
-          }
-        }
-      }
-    );
-    observer.current = watch;
-    return () => {
-      active = false;
-      watch.dispose();
-      if (observer.current === watch) {
-        observer.current = null;
-      }
-    };
-  }, [store, scope?.key, cursor, intervalMs]);
-  const refresh = useCallback(
-    () => observer.current?.refresh() ?? Promise.resolve(),
-    []
-  );
-  const value = session.status === "error" ? session : !scope ? LOADING : !scope.member ? { status: "signed-out", data: void 0, error: null } : state?.owner === scope.key ? state.value : LOADING;
-  return { ...value, refresh };
-}
-
-// src/react/action.ts
-import { useCallback as useCallback2, useRef as useRef2, useState as useState2 } from "react";
-var IDLE = Object.freeze({
-  status: "idle",
-  data: void 0,
-  error: null
-});
-function actionError(cause) {
-  return isRequestError(cause) && !isRelayError(cause) ? new RelayError(cause.message, {
-    kind: cause.kind,
-    status: cause.status,
-    code: cause.code,
-    uncertain: cause.uncertain,
-    operationId: cause.operationId,
-    replaySafe: cause.recovery === "replay",
-    retryAfter: cause.retryAfter,
-    cause
-  }) : asRelayError(cause);
-}
-function useRelayAction(scope) {
-  const owner = useRef2({ scope, action: createRelayAction() });
-  const [state, setState] = useState2({ owner: owner.current, ...IDLE });
-  if (owner.current.scope !== scope) {
-    owner.current = { scope, action: createRelayAction() };
-  }
-  const execute = useCallback2(
-    async (task) => {
-      const current2 = owner.current;
-      if (current2.action.busy) {
-        return { ok: false };
-      }
-      const result = task ? current2.action.run(task) : current2.action.retry();
-      setState({
-        owner: current2,
-        status: "pending",
-        data: void 0,
-        error: null
-      });
-      try {
-        const value = await result;
-        if (owner.current === current2) {
-          setState({
-            owner: current2,
-            status: "success",
-            data: value,
-            error: null
-          });
+      } catch (cause) {
+        if (!counts()) {
+          return;
         }
-        return { ok: true, value };
-      } catch (caught) {
-        const error = actionError(current2.action.error ?? caught);
-        if (owner.current === current2) {
-          setState({ owner: current2, status: "error", data: void 0, error });
+        const error = relayError(cause);
+        if (error.code === RelayErrorCode.StaleSession) {
+          this.#onStaleSession();
+        }
+        const gone = error.kind === "http" && error.status === 404 || error.code === RelayErrorCode.StaleSession;
+        entry.version++;
+        this.#write(
+          entry,
+          entry.state.status === "ready" && !gone ? { status: "ready", data: entry.state.data, error } : { status: "error", data: void 0, error }
+        );
+      } finally {
+        if (counts()) {
+          entry.controller = null;
+          entry.pending = null;
+          entry.settledAt = Date.now();
+          this.#schedule(entry);
         }
-        return { ok: false, error };
       }
-    },
-    []
-  );
-  const retry = useCallback2(() => execute(), [execute]);
-  const settle = useCallback2(() => {
-    const current2 = owner.current;
-    if (!current2.action.settle()) {
-      return false;
-    }
-    setState({ owner: current2, ...IDLE });
-    return true;
-  }, []);
-  const reset = useCallback2(() => {
-    const current2 = owner.current;
-    if (!current2.action.busy && current2.action.actionId === void 0) {
-      setState({ owner: current2, ...IDLE });
+    })();
+    entry.pending = pending;
+    return pending;
+  }
+  /** Arms the poll for the shortest interval anyone on screen asked for. */
+  #schedule(entry) {
+    clearTimeout(entry.timer);
+    if (this.#disposed || entry.pending || entry.listeners.size === 0 || entry.intervals.size === 0) {
+      return;
     }
-  }, []);
-  const current = state.owner === owner.current ? state : IDLE;
-  const isPending = current.status === "pending";
-  return {
-    run: execute,
-    retry,
-    settle,
-    reset,
-    status: current.status,
-    isPending,
-    data: current.data,
-    error: current.error,
-    /** @deprecated Use `isPending`. Removed in 2.0.0. */
-    busy: isPending
-  };
-}
-
-// src/react/mutation.ts
-import { useCallback as useCallback4, useLayoutEffect as useLayoutEffect3, useMemo as useMemo2, useRef as useRef4 } from "react";
-
-// src/react/query.ts
-import {
-  useCallback as useCallback3,
-  useEffect as useEffect2,
-  useLayoutEffect as useLayoutEffect2,
-  useMemo,
-  useRef as useRef3,
-  useState as useState3,
-  useSyncExternalStore as useSyncExternalStore2
-} from "react";
+    const interval = Math.min(...entry.intervals.values());
+    const wait = Math.max(0, entry.settledAt + interval - Date.now());
+    entry.timer = setTimeout(() => {
+      if (visible()) {
+        void this.#fetch(entry, false);
+      }
+    }, wait);
+  }
+};
 
 // src/react/feed.ts
 function feedOwner(session) {
@@ -657,70 +620,6 @@ var ActivityFeed = class {
   }
 };
 
-// src/react/keys.ts
-var relayKeys = {
-  /** `useExperience`: invalidating it reads the quest experience again. */
-  experience: ["experience"],
-  /** `useMe`. */
-  me: ["me"],
-  /** `useAccounts`. */
-  accounts: ["accounts"],
-  /** `useWallets`. */
-  wallets: ["wallets"],
-  /** `useMyProfile`, `useProfile`, `useProfileCompletions`, `useProfileReferral`. */
-  profiles: ["profiles"],
-  /** `useLeaderboard`, `useLeaderboardPlacement`. */
-  leaderboards: ["leaderboards"],
-  /** `useReferralSummary`. */
-  referrals: ["referrals"],
-  /** `usePointLedgers`. */
-  pointLedgers: ["point-ledgers"],
-  /** `useTieredRewards`. */
-  tieredRewards: ["tiered-rewards"],
-  /** `useSignInMethods`. */
-  signInMethods: ["sign-in-methods"],
-  /** `useEntitlements`, `useDeliveries`. */
-  rewards: ["rewards"],
-  /** `useBalances`, `usePointHistory`. */
-  balances: ["balances"],
-  /** `useQuestOutcomes`. */
-  outcomes: ["outcomes"],
-  /** `useOffers`, `useRedeemOffer`. */
-  offers: ["offers"]
-};
-var rewardKeys = {
-  entitlements: [...relayKeys.rewards, "entitlements"],
-  deliveries: [...relayKeys.rewards, "deliveries"]
-};
-var completionChanges = [
-  relayKeys.rewards,
-  relayKeys.balances,
-  relayKeys.leaderboards,
-  relayKeys.profiles,
-  relayKeys.referrals,
-  relayKeys.offers
-];
-var activityChanges = {
-  "attempt.accepted": [
-    relayKeys.experience,
-    relayKeys.outcomes,
-    ...completionChanges
-  ],
-  "attempt.rejected": [relayKeys.experience, relayKeys.outcomes],
-  "attempt.review": [relayKeys.experience, relayKeys.outcomes],
-  "points.awarded": [
-    relayKeys.balances,
-    relayKeys.leaderboards,
-    relayKeys.offers,
-    rewardKeys.deliveries
-  ],
-  "entitlement.granted": [relayKeys.experience, relayKeys.rewards],
-  "entitlement.collected": [relayKeys.experience, relayKeys.rewards],
-  "delivery.updated": [rewardKeys.deliveries],
-  "referral.qualified": [relayKeys.referrals, relayKeys.profiles],
-  unknown: [relayKeys.experience]
-};
-
 // src/react/role-delivery.ts
 function sanitizeDeliveries(deliveries) {
   return deliveries.map(({ quest, status, revokedAt, reconciliation }) => ({
@@ -1525,19 +1424,19 @@ var RelayStore = class {
 
 // src/react/query.ts
 function useLatest(value) {
-  const ref = useRef3(value);
-  useLayoutEffect2(() => {
+  const ref = useRef2(value);
+  useLayoutEffect(() => {
     ref.current = value;
   });
   return ref;
 }
 function useSessionSnapshot(store) {
   const get = () => store.session;
-  return useSyncExternalStore2(store.subscribe, get, get);
+  return useSyncExternalStore(store.subscribe, get, get);
 }
 function useScope(store) {
   const get = () => store.scope;
-  return useSyncExternalStore2(store.subscribe, get, get);
+  return useSyncExternalStore(store.subscribe, get, get);
 }
 function isInitializer(value) {
   return typeof value === "function";
@@ -1560,7 +1459,7 @@ function useCached(cache, key, read, options, seeded = null) {
   const active = options.enabled === false ? null : key;
   const hash = active ? hashKey(active) : null;
   const latest = useLatest({ key: active, read });
-  const subscribe = useCallback3(
+  const subscribe = useCallback2(
     (listener) => {
       const { key: current } = latest.current;
       if (!cache || !current) {
@@ -1582,8 +1481,8 @@ function useCached(cache, key, read, options, seeded = null) {
     const fallback = seeded?.shown ?? LOADING;
     return cache && active ? cache.snapshot(active, fallback) : fallback;
   };
-  const snapshot = useSyncExternalStore2(subscribe, get, get);
-  const refresh = useCallback3(
+  const snapshot = useSyncExternalStore(subscribe, get, get);
+  const refresh = useCallback2(
     () => cache && latest.current.key ? cache.refresh(latest.current.key) : Promise.resolve(),
     [cache, hash]
   );
@@ -1676,17 +1575,17 @@ function usePages(cache, requested, read, options) {
     (context) => read(context),
     options
   );
-  const [more, setMore] = useState3(null);
-  const busy = useRef3(null);
+  const [more, setMore] = useState2(null);
+  const busy = useRef2(null);
   const latest = useLatest({ key, read, query });
-  useEffect2(
+  useEffect(
     () => () => {
       busy.current?.abort();
       busy.current = null;
     },
     [cache, hash]
   );
-  const loadMore = useCallback3(async () => {
+  const loadMore = useCallback2(async () => {
     const { key: current, read: reader, query: shown } = latest.current;
     if (!cache || !current || busy.current || shown.status !== "ready" || shown.data.nextCursor === null) {
       return;
@@ -1760,14 +1659,14 @@ function useMemberPages(key, read, options = {}) {
 }
 function useInvalidate() {
   const store = useStore();
-  return useCallback3((keys = []) => store.invalidate(keys), [store]);
+  return useCallback2((keys = []) => store.invalidate(keys), [store]);
 }
 function isUpdater(update) {
   return typeof update === "function";
 }
 function useSetQueryData() {
   const store = useStore();
-  return useCallback3(
+  return useCallback2(
     (key, update) => {
       const cache = store.scope?.cache;
       if (!cache) {
@@ -1807,11 +1706,11 @@ function useAction() {
     settle,
     reset: resetAction
   } = useRelayAction(scope);
-  const run = useCallback3(
+  const run = useCallback2(
     async (task) => (await execute(task)).ok,
     [execute]
   );
-  const retry = useCallback3(async () => (await replay()).ok, [replay]);
+  const retry = useCallback2(async () => (await replay()).ok, [replay]);
   return { isPending, actionError: actionError2, resetAction, run, retry, settle };
 }
 function useScopeSession() {
@@ -1819,7 +1718,126 @@ function useScopeSession() {
   return useScope(store)?.session?.id;
 }
 
+// src/react/badges.ts
+function useBadgeCatalog() {
+  const relay = useRelay();
+  return useRelayQuery(
+    [...relayKeys.badges, "catalog"],
+    (options) => relay.badges.list(options)
+  );
+}
+function useBadges() {
+  const relay = useRelay();
+  return useMemberQuery(
+    [...relayKeys.badges, "mine"],
+    (options) => relay.me.badges(options)
+  );
+}
+function useProfileBadges(profile) {
+  const relay = useRelay();
+  return useRelayQuery(
+    [...relayKeys.profiles, profile, "badges"],
+    (options) => relay.profiles.badges(profile, options)
+  );
+}
+
+// src/react/activity.ts
+import {
+  useCallback as useCallback3,
+  useEffect as useEffect2,
+  useLayoutEffect as useLayoutEffect2,
+  useRef as useRef3,
+  useState as useState3,
+  useSyncExternalStore as useSyncExternalStore2
+} from "react";
+function useActivity(options = {}) {
+  const store = useStore();
+  const scope = useSyncExternalStore2(
+    store.subscribe,
+    () => store.scope,
+    () => null
+  );
+  const session = useSyncExternalStore2(
+    store.subscribe,
+    () => store.session,
+    () => LOADING
+  );
+  const callback = useRef3(options.onEvent);
+  useLayoutEffect2(() => {
+    callback.current = options.onEvent;
+  }, [options.onEvent]);
+  const observer = useRef3(null);
+  const [state, setState] = useState3(null);
+  const { cursor, intervalMs } = options;
+  useEffect2(() => {
+    if (!scope?.member) {
+      return;
+    }
+    let active = true;
+    const watch = store.client.me.activity.observe(
+      (event) => callback.current?.(event),
+      {
+        cursor,
+        intervalMs,
+        onState: (observation) => {
+          if (!active) {
+            return;
+          }
+          if (observation.kind === "ready") {
+            setState((prior) => {
+              const items = prior?.owner === scope.key && prior.value.status === "ready" ? prior.value.data.items : [];
+              const combined = new Map(
+                [...items, ...observation.progress.items].map((event) => [
+                  event.id,
+                  event
+                ])
+              );
+              return {
+                owner: scope.key,
+                value: {
+                  status: "ready",
+                  data: {
+                    ...observation.progress,
+                    items: [...combined.values()].slice(-100)
+                  },
+                  error: null
+                }
+              };
+            });
+          } else if (observation.kind === "error") {
+            setState((prior) => ({
+              owner: scope.key,
+              value: prior?.owner === scope.key && prior.value.status === "ready" ? { ...prior.value, error: relayError(observation.error) } : {
+                status: "error",
+                data: void 0,
+                error: relayError(observation.error)
+              }
+            }));
+          } else if (observation.kind === "loading") {
+            setState({ owner: scope.key, value: LOADING });
+          }
+        }
+      }
+    );
+    observer.current = watch;
+    return () => {
+      active = false;
+      watch.dispose();
+      if (observer.current === watch) {
+        observer.current = null;
+      }
+    };
+  }, [store, scope?.key, cursor, intervalMs]);
+  const refresh = useCallback3(
+    () => observer.current?.refresh() ?? Promise.resolve(),
+    []
+  );
+  const value = session.status === "error" ? session : !scope ? LOADING : !scope.member ? { status: "signed-out", data: void 0, error: null } : state?.owner === scope.key ? state.value : LOADING;
+  return { ...value, refresh };
+}
+
 // src/react/mutation.ts
+import { useCallback as useCallback4, useLayoutEffect as useLayoutEffect3, useMemo as useMemo2, useRef as useRef4 } from "react";
 function useMutation(mutation, options = {}) {
   const store = useStore();
   const invalidate = useInvalidate();
@@ -2888,6 +2906,8 @@ export {
   roleDeliveryStatus,
   useAccounts,
   useActivity,
+  useBadgeCatalog,
+  useBadges,
   useBalances,
   useDeliveries,
   useEntitlements,
@@ -2904,6 +2924,7 @@ export {
   usePointHistory,
   usePointLedgers,
   useProfile,
+  useProfileBadges,
   useProfileCompletions,
   useProfileReferral,
   useQuest,