@domino-sdk/relay 1.0.0-next.2 → 1.0.0-next.34

package/dist/react/index.js

@@ -8,45 +8,401 @@ import {
   discoverSolanaWallets,
   readSignInMethods,
   signInOptionsFrom
-} from "../chunk-FDWRBMB3.js";
+} from "../chunk-ZVIRG24J.js";
+import "../chunk-GZ6FJAXN.js";
+import "../chunk-EYH5RDIE.js";
 import {
-  RelayError,
-  avatarSrc,
-  defaultAvatar,
-  walletAvatarSeed
-} from "../chunk-4KNTMNXA.js";
-import "../chunk-B76BAJ25.js";
-import "../chunk-VH4OQ5VX.js";
-import "../chunk-ONDBQSMU.js";
-import "../chunk-NKGJEYZM.js";
+  RelayErrorCode,
+  asRelayError,
+  isRelayError
+} from "../chunk-36HTX2BM.js";
+import "../chunk-6QJ3LADK.js";
+import "../chunk-NPGENI7K.js";
+import {
+  sessionMember
+} from "../chunk-XFMSUPNS.js";
+import "../chunk-JON5SESL.js";
 
-// src/react/provider.tsx
-import { useState as useState3 } from "react";
+// src/react/activity.ts
+import {
+  useCallback,
+  useEffect,
+  useLayoutEffect,
+  useRef,
+  useState,
+  useSyncExternalStore
+} from "react";
+
+// src/react/cache.ts
+var LOADING = Object.freeze({
+  status: "loading",
+  data: void 0,
+  error: null
+});
+var UNUSED_MS = 5 * 6e4;
+var STALE_MS = 3e4;
+var relayError = (cause, fallback) => asRelayError(cause, fallback);
+function hashKey(key) {
+  return JSON.stringify(key);
+}
+function startsWith(key, prefix) {
+  return prefix.every((part, index) => key[index] === part);
+}
+function visible() {
+  return typeof document === "undefined" || document.visibilityState !== "hidden";
+}
+var QueryCache = class {
+  session;
+  #entries = /* @__PURE__ */ new Map();
+  #disposed = false;
+  #onStaleSession;
+  constructor(session, onStaleSession) {
+    this.session = session;
+    this.#onStaleSession = onStaleSession;
+  }
+  get disposed() {
+    return this.#disposed;
+  }
+  snapshot(key) {
+    return this.#entries.get(hashKey(key))?.state ?? LOADING;
+  }
+  /** Starts observing `key`, reading it now unless a read is cached or in flight. */
+  subscribe(key, read, options, listener) {
+    if (this.#disposed) {
+      return () => {
+      };
+    }
+    const hash = hashKey(key);
+    let entry = this.#entries.get(hash);
+    if (!entry) {
+      entry = {
+        key,
+        read,
+        state: LOADING,
+        listeners: /* @__PURE__ */ new Set(),
+        intervals: /* @__PURE__ */ new Map(),
+        focus: /* @__PURE__ */ new Set(),
+        controller: null,
+        pending: null,
+        settledAt: 0,
+        version: 0,
+        timer: void 0,
+        unused: void 0
+      };
+      this.#entries.set(hash, entry);
+    }
+    const current = entry;
+    const token = {};
+    const unseen = current.listeners.size === 0;
+    current.read = read;
+    clearTimeout(current.unused);
+    current.listeners.add(listener);
+    if (options.intervalMs !== void 0 && options.intervalMs > 0) {
+      current.intervals.set(token, options.intervalMs);
+    }
+    if (options.refetchOnFocus) {
+      current.focus.add(token);
+    }
+    if (!current.pending && (current.settledAt === 0 || unseen && Date.now() - current.settledAt >= STALE_MS)) {
+      void this.#fetch(current, false);
+    } else {
+      this.#schedule(current);
+    }
+    return () => {
+      current.listeners.delete(listener);
+      current.intervals.delete(token);
+      current.focus.delete(token);
+      if (current.listeners.size === 0 && !this.#disposed) {
+        clearTimeout(current.timer);
+        current.unused = setTimeout(() => {
+          if (current.listeners.size === 0) {
+            this.#drop(hash, current);
+          }
+        }, UNUSED_MS);
+      }
+    };
+  }
+  /** Reads `key` again now, replacing any read in flight. */
+  refresh(key) {
+    const entry = this.#entries.get(hashKey(key));
+    return entry ? this.#fetch(entry, true) : Promise.resolve();
+  }
+  /**
+   * Marks every query under each prefix out of date: those on screen are read again at once, the
+   * rest are dropped. A read in flight is replaced, because it may have started before the change.
+   * No prefixes means every query.
+   */
+  invalidate(prefixes) {
+    const reads = [];
+    for (const [hash, entry] of this.#entries) {
+      if (prefixes.length > 0 && !prefixes.some((prefix) => startsWith(entry.key, prefix))) {
+        continue;
+      }
+      if (entry.listeners.size > 0) {
+        reads.push(this.#fetch(entry, true));
+      } else {
+        this.#drop(hash, entry);
+      }
+    }
+    return Promise.all(reads).then(() => {
+    });
+  }
+  /**
+   * Changes the cached value of `key` with `update`, unless a read wrote a newer value since
+   * `version` (from `version(key)`). Returns whether it applied.
+   */
+  update(key, version, update) {
+    const entry = this.#entries.get(hashKey(key));
+    if (this.#disposed || !entry || entry.version !== version || entry.state.status !== "ready") {
+      return false;
+    }
+    entry.version++;
+    this.#write(entry, {
+      status: "ready",
+      data: update(entry.state.data),
+      error: null
+    });
+    return true;
+  }
+  /**
+   * Replaces the cached value of `key` with one a change returned, cancelling a read in flight that
+   * may have started before the change. Does nothing for a key nobody has read.
+   */
+  set(key, data) {
+    const entry = this.#entries.get(hashKey(key));
+    if (this.#disposed || !entry) {
+      return;
+    }
+    entry.controller?.abort();
+    entry.controller = null;
+    entry.pending = null;
+    entry.version++;
+    entry.settledAt = Date.now();
+    this.#write(entry, { status: "ready", data, error: null });
+    this.#schedule(entry);
+  }
+  version(key) {
+    return this.#entries.get(hashKey(key))?.version ?? -1;
+  }
+  /** The tab became visible again: read whatever came due while it was hidden. */
+  resume() {
+    for (const entry of this.#entries.values()) {
+      this.#schedule(entry);
+    }
+  }
+  /** The window regained focus. */
+  focus() {
+    for (const entry of this.#entries.values()) {
+      if (entry.focus.size > 0 && entry.listeners.size > 0) {
+        void this.#fetch(entry, false);
+      }
+    }
+  }
+  /** Stops every read and timer for good. Answers that arrive later are dropped. */
+  dispose() {
+    this.#disposed = true;
+    for (const [hash, entry] of this.#entries) {
+      this.#drop(hash, entry);
+    }
+  }
+  #drop(hash, entry) {
+    entry.controller?.abort();
+    entry.controller = null;
+    entry.pending = null;
+    clearTimeout(entry.timer);
+    clearTimeout(entry.unused);
+    if (this.#entries.get(hash) === entry) {
+      this.#entries.delete(hash);
+    }
+  }
+  #write(entry, state) {
+    entry.state = state;
+    for (const listener of [...entry.listeners]) {
+      listener();
+    }
+  }
+  #fetch(entry, replace) {
+    if (this.#disposed) {
+      return Promise.resolve();
+    }
+    if (entry.pending && !replace) {
+      return entry.pending;
+    }
+    entry.controller?.abort();
+    clearTimeout(entry.timer);
+    const controller = new AbortController();
+    entry.controller = controller;
+    const counts = () => !this.#disposed && entry.controller === controller;
+    const pending = (async () => {
+      try {
+        const data = await Promise.resolve().then(
+          () => entry.read({ signal: controller.signal, session: this.session })
+        );
+        if (counts()) {
+          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 ClientContext = createContext(null);
-function useRelay() {
-  const client = useContext(ClientContext);
-  if (!client) {
+var StoreContext = createContext(null);
+function useStore() {
+  const store = useContext(StoreContext);
+  if (!store) {
     throw new Error("Domino hooks require <RelayProvider>");
   }
-  return client;
+  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/provider.tsx
+import { useEffect as useEffect3, useMemo as useMemo2 } from "react";
+
 // src/react/experience.tsx
 import {
   createContext as createContext2,
+  useCallback as useCallback2,
   useContext as useContext2,
-  useEffect as useEffect2,
   useMemo,
-  useRef,
-  useState as useState2
+  useSyncExternalStore as useSyncExternalStore2
 } from "react";
 
 // src/react/role-delivery.ts
 function sanitizeDeliveries(deliveries) {
-  return deliveries.map(({ quest, status }) => ({ quest, status }));
+  return deliveries.map(({ quest, status, revokedAt, reconciliation }) => ({
+    quest,
+    status: reconciliation ? reconciliation.status === "granted" ? "delivered" : reconciliation.status : revokedAt ? "revoked" : status
+  }));
 }
 function completionMark(quests) {
   return quests.filter((q) => q.completed || q.completionCount > 0).map((q) => `${q.quest}:${Math.max(q.completionCount, 1)}`).sort().join(",");
@@ -54,19 +410,37 @@ function completionMark(quests) {
 function hasPending(deliveries) {
   return deliveries.some((d) => d.status === "pending");
 }
-function roleDeliveryLabel(deliveries, quest) {
-  const mine = deliveries.filter((d) => d.quest === quest);
+function roleDeliveryStatus(deliveries, quest) {
+  const mine = sanitizeDeliveries(deliveries).filter((d) => d.quest === quest);
   if (!mine.length) {
     return null;
   }
   if (hasPending(mine)) {
-    return "Role delivery pending";
+    return "pending";
+  }
+  return mine.some((d) => d.status === "failed") ? "failed" : mine.every((d) => d.status === "delivered") ? "granted" : mine.find((d) => d.status !== "delivered")?.status ?? "unknown";
+}
+function roleDeliveryLabel(status) {
+  switch (status) {
+    case "pending":
+      return "Role delivery pending";
+    case "failed":
+      return "Role delivery failed";
+    case "granted":
+      return "Role granted";
+    case "removed":
+    case "revoked":
+      return "Role reward revoked";
+    case "preserved":
+      return "Role managed by the organizer";
+    default:
+      return status === null ? null : "Role status unavailable";
   }
-  return mine.some((d) => d.status === "failed") ? "Role delivery failed" : "Role granted";
 }
 var PENDING_POLL_MS = 5e3;
 var RETRY_DELAYS_MS = [1e3, 4e3];
 function watchRoleDeliveries(options) {
+  const visible2 = options.visible ?? (() => typeof document === "undefined" || document.visibilityState !== "hidden");
   const schedule = options.schedule ?? ((run2, ms) => {
     const timer = setTimeout(run2, ms);
     return () => clearTimeout(timer);
@@ -82,6 +456,10 @@ function watchRoleDeliveries(options) {
     if (!active || reading) {
       return;
     }
+    if (!visible2()) {
+      resting = true;
+      return;
+    }
     reading = true;
     resting = false;
     try {
@@ -124,256 +502,656 @@ function watchRoleDeliveries(options) {
   };
 }
 
+// src/react/use-role-deliveries.ts
+import { useEffect as useEffect2, useState as useState2 } from "react";
+var NONE = Object.freeze([]);
+function useRoleDeliveries(relay, member, completions) {
+  const [state, setState] = useState2(null);
+  useEffect2(() => {
+    if (!member || !completions) {
+      return;
+    }
+    const watch = watchRoleDeliveries({
+      read: async () => (await relay.me.rewardDeliveries()).deliveries,
+      onChange: (deliveries) => setState({ member, deliveries })
+    });
+    const wake = () => {
+      if (document.visibilityState === "visible") {
+        watch.wake();
+      }
+    };
+    window.addEventListener("focus", wake);
+    document.addEventListener("visibilitychange", wake);
+    return () => {
+      watch.dispose();
+      window.removeEventListener("focus", wake);
+      document.removeEventListener("visibilitychange", wake);
+    };
+  }, [relay, member, completions]);
+  return member && completions && state?.member === member ? state.deliveries : NONE;
+}
+
+// src/react/experience.tsx
+import { jsx } from "react/jsx-runtime";
+var Deliveries = createContext2(Object.freeze([]));
+function useExperienceSnapshot() {
+  const store = useStore();
+  const get = () => store.experience;
+  return useSyncExternalStore2(store.subscribe, get, get);
+}
+function DeliveriesProvider({ children }) {
+  const store = useStore();
+  const experience = useExperienceSnapshot();
+  const member = useSyncExternalStore2(
+    store.subscribe,
+    () => store.scope?.member ?? null,
+    () => null
+  );
+  const ready = experience.status === "ready";
+  const deliveries = useRoleDeliveries(
+    store.client,
+    ready ? member : null,
+    ready ? completionMark([
+      ...experience.data.quests,
+      ...experience.data.collections.flatMap((c) => c.quests)
+    ]) : ""
+  );
+  return /* @__PURE__ */ jsx(Deliveries, { value: deliveries, children });
+}
+function useExperience() {
+  const store = useStore();
+  const experience = useExperienceSnapshot();
+  const deliveries = useContext2(Deliveries);
+  const refresh = useCallback2(() => store.refreshExperience(), [store]);
+  return useMemo(
+    () => ({ ...experience, refresh, deliveries }),
+    [experience, refresh, deliveries]
+  );
+}
+
+// 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 completionChanges = [
+  relayKeys.rewards,
+  relayKeys.balances,
+  relayKeys.leaderboards,
+  relayKeys.profiles,
+  relayKeys.referrals,
+  relayKeys.offers
+];
+
 // src/react/status.ts
 function isFinished(view) {
-  return view.availability.kind === "completed" || view.completion.kind !== "keyed" && view.completed;
+  return view.availability.kind === "completed" || view.completion.kind !== "keyed" && view.completion.kind !== "progress" && view.completed;
 }
 function isAutomatic(view) {
   return view.trigger.kind === "automatic";
 }
 function runsSilently(view) {
-  return view.trigger.kind === "automatic" && (view.completion.kind === "keyed" || Boolean(view.trigger.observation));
+  return view.trigger.kind === "automatic" && (view.completion.kind === "keyed" || Boolean(view.trigger.tracker));
 }
-function completionCountLabel(view) {
-  if (view.completion.kind !== "keyed" || view.completionCount < 1) {
+function completionCountText(view) {
+  if (view.completion.kind !== "keyed" && view.completion.kind !== "progress" || view.completionCount < 1) {
     return null;
   }
   return view.completionCount === 1 ? "Completed once" : `Completed ${view.completionCount.toLocaleString()} times`;
 }
 function canRepeat(view) {
-  return view.completion.kind === "keyed" && view.attempt?.status === "accepted" && canSubmit(view);
+  return (view.completion.kind === "keyed" || view.completion.kind === "progress") && view.attempt?.status === "accepted" && canSubmit(view);
 }
 function visibleQuests(quests) {
   return quests.filter((q) => q.visibility !== "hidden");
 }
 function questStatus(view) {
+  return knownStatus(view);
+}
+function knownStatus(view) {
   if (isFinished(view)) {
-    return { tone: "done", label: "Completed" };
+    return { tone: "done", code: "completed" };
   }
   if (view.lifecycle === "paused") {
-    return {
-      tone: "off",
-      label: "Paused",
-      detail: "This activity is paused for now."
-    };
+    return { tone: "off", code: "paused" };
   }
   if (view.lifecycle === "archived") {
+    return { tone: "off", code: "closed" };
+  }
+  if (view.attempt?.status === "deferred") {
     return {
-      tone: "off",
-      label: "Closed",
-      detail: "This activity is no longer running."
+      tone: "waiting",
+      code: view.attempt.code === "evaluator-progress" ? "evaluator-progress" : "evaluator-deferred",
+      reason: view.attempt.reason ?? ""
     };
   }
   const availability = view.availability;
-  if (view.streak && availability.kind !== "locked") {
-    const streak = view.streak;
-    if (streak.milestone.status === "budget-exhausted") {
-      return {
-        tone: "attention",
-        label: "Milestone reached",
-        detail: "Your qualifying days are saved. This milestone's reward budget was exhausted."
-      };
-    }
-    const deadline = new Intl.DateTimeFormat("en", {
-      timeZone: streak.timeZone,
-      month: "short",
-      day: "numeric",
-      hour: "numeric",
-      minute: "2-digit",
-      timeZoneName: "short"
-    }).format(streak.nextBoundary);
+  if (availability.kind === "blocked") {
     return {
-      tone: streak.todayQualified ? "waiting" : "open",
-      label: `${streak.current} / ${streak.goal} days`,
-      detail: streak.todayQualified ? `Today counts. Your next community day starts ${deadline}. Best streak: ${streak.best} days.` : `Complete today's activity before ${deadline} ${streak.current ? "to keep your streak" : "to start your streak"}. Best streak: ${streak.best} days.`
+      tone: availability.reason === "paused" || availability.reason === "outside-window" ? "off" : availability.reason === "budget-exhausted" ? "attention" : "locked",
+      code: availability.reason
     };
   }
-  if (runsSilently(view) && availability.kind !== "locked") {
+  const ownSubmission = view.trigger.kind === "manual" && view.trigger.actor !== "staff";
+  const submissionFirst = ownSubmission && (availability.kind === "checking" || availability.kind === "needs-review" || availability.kind === "retryable");
+  if (view.counter && availability.kind !== "locked" && !submissionFirst) {
+    const currentAchievement = view.counter.latest?.window === view.counter.window.key ? view.counter.latest : null;
+    if (currentAchievement?.status === "revoked") {
+      return { tone: "attention", code: "counter-revoked" };
+    }
     return {
-      tone: "waiting",
-      label: "Automatic",
-      detail: view.completion.kind === "keyed" ? [
-        completionCountLabel(view),
-        "This counts by itself each time you qualify."
-      ].filter(Boolean).join(". ") : "This updates by itself when you qualify."
+      tone: currentAchievement?.status === "budget-exhausted" ? "attention" : ownSubmission ? "open" : "waiting",
+      code: currentAchievement?.status === "budget-exhausted" ? "counter-budget-exhausted" : "counter"
     };
   }
-  if (isAutomatic(view) && availability.kind !== "locked") {
+  if (view.streak && availability.kind !== "locked" && !submissionFirst) {
+    const rejected = ownSubmission && view.attempt?.status === "rejected" ? { reason: view.attempt.reason ?? "" } : {};
+    if (view.streak.milestone.status === "budget-exhausted") {
+      return { tone: "attention", code: "streak-budget-exhausted", ...rejected };
+    }
     return {
-      tone: "waiting",
-      label: "In progress",
-      detail: "This updates by itself when you qualify."
+      tone: "reason" in rejected ? "attention" : view.streak.todayQualified ? "waiting" : "open",
+      code: "streak",
+      ...rejected
     };
   }
+  if (runsSilently(view) && availability.kind !== "locked") {
+    return { tone: "waiting", code: "automatic" };
+  }
+  if (isAutomatic(view) && availability.kind !== "locked") {
+    return { tone: "waiting", code: "in-progress" };
+  }
   switch (availability.kind) {
     case "completed":
-      return { tone: "done", label: "Completed" };
+      return { tone: "done", code: "completed" };
     case "locked":
-      return {
-        tone: "locked",
-        label: "Locked",
-        detail: `Complete ${list(availability.missing.map((m) => m.title))} first.`
-      };
+      return { tone: "locked", code: "locked" };
     case "checking":
-      return {
-        tone: "waiting",
-        label: "Checking",
-        detail: "Your submission is being verified."
-      };
+      return { tone: "waiting", code: "checking" };
     case "needs-review":
-      return {
-        tone: "waiting",
-        label: "In review",
-        detail: "A person is reviewing your submission."
-      };
+      return { tone: "waiting", code: "in-review" };
     case "retryable":
-      return {
-        tone: "attention",
-        label: "Didn't go through",
-        detail: "Verification couldn't run. Try again. Nothing was lost."
-      };
+      return { tone: "attention", code: "retryable" };
     case "staff-required":
-      return {
-        tone: "waiting",
-        label: "Waiting for staff",
-        detail: "A staff member confirms this activity for you."
-      };
+      return { tone: "waiting", code: "staff-required" };
     case "automatic":
-      return {
-        tone: "waiting",
-        label: "In progress",
-        detail: "This updates by itself when you qualify."
-      };
+      return { tone: "waiting", code: "in-progress" };
     case "available":
       return view.attempt?.status === "rejected" ? {
         tone: "attention",
-        label: "Try again",
-        detail: view.attempt.reason ?? "That submission wasn't accepted."
-      } : { tone: "open", label: "Ready" };
+        code: "rejected",
+        reason: view.attempt.reason ?? ""
+      } : { tone: "open", code: "ready" };
+  }
+}
+function questStatusText(view) {
+  const status = knownStatus(view);
+  const words = (label, detail) => detail === void 0 ? { ...status, label } : { ...status, label, detail };
+  const rejection = status.reason === void 0 ? null : sentence(status.reason || "That submission wasn't accepted.");
+  switch (status.code) {
+    case "completed":
+      return words("Completed");
+    case "paused":
+      return words("Paused", "This activity is paused for now.");
+    case "closed":
+      return words("Closed", "This activity is no longer running.");
+    case "counter":
+      return words(
+        `${view.counter?.current ?? 0} / ${view.counter?.goal ?? 0} actions`,
+        "Distinct qualifying actions count toward this goal."
+      );
+    case "counter-revoked":
+      return words(
+        "Achievement revoked",
+        "The reward was corrected. Its qualifying actions remain recorded."
+      );
+    case "counter-budget-exhausted":
+      return words(
+        "Goal reached; budget exhausted",
+        "Your qualifying actions are saved. This achievement did not grant a reward."
+      );
+    case "streak-budget-exhausted":
+      return words(
+        "Milestone reached",
+        rejection ?? "Your qualifying days are saved. This milestone's reward budget was exhausted."
+      );
+    case "streak": {
+      const streak = view.streak;
+      const deadline = new Intl.DateTimeFormat("en", {
+        timeZone: streak.timeZone,
+        month: "short",
+        day: "numeric",
+        hour: "numeric",
+        minute: "2-digit",
+        timeZoneName: "short"
+      }).format(streak.nextBoundary);
+      const progress = streak.todayQualified ? `Today counts. Your next day starts ${deadline}. Best streak: ${streak.best} days.` : `Complete today's activity before ${deadline} ${streak.current ? "to keep your streak" : "to start your streak"}. Best streak: ${streak.best} days.`;
+      return words(
+        `${streak.current} / ${streak.goal} days`,
+        rejection ? `${rejection} ${progress}` : progress
+      );
+    }
+    case "automatic":
+      return words(
+        "Automatic",
+        view.completion.kind === "keyed" ? [
+          completionCountText(view),
+          "This counts by itself each time you qualify."
+        ].filter(Boolean).join(". ") : "This updates by itself when you qualify."
+      );
+    case "in-progress":
+      return words("In progress", "This updates by itself when you qualify.");
+    case "locked":
+      return words(
+        "Locked",
+        view.availability.kind === "locked" ? sentence(
+          capitalize(list(view.availability.missing.map(prerequisiteText)))
+        ) : void 0
+      );
+    case "budget-exhausted":
+      return words(
+        "Budget reached",
+        view.availability.kind === "blocked" && view.availability.resetsAt !== void 0 ? `This quest's reward budget resets at ${new Date(view.availability.resetsAt).toISOString()}.` : "This quest's reward budget has been used."
+      );
+    case "connection-required":
+      return words("Connect an account", "Connect the required account first.");
+    case "wallet-required":
+      return words("Connect a wallet", "Connect the required wallet first.");
+    case "outside-window":
+      return words(
+        "Not open",
+        view.availability.kind === "blocked" && view.availability.resetsAt !== void 0 ? `This quest opens at ${new Date(view.availability.resetsAt).toISOString()}.` : "This quest's availability window has ended."
+      );
+    case "enrollment-required":
+      return words(
+        "Enroll",
+        view.campaign ? `Enroll in ${quote(view.campaign.title)} first.` : "Enroll in this campaign first."
+      );
+    case "evaluator-deferred":
+      return words("Waiting to check again", status.reason);
+    case "evaluator-progress":
+      return words("In progress", status.reason);
+    case "checking":
+      return words("Checking", "Your submission is being verified.");
+    case "in-review":
+      return words("In review", "A person is reviewing your submission.");
+    case "retryable":
+      return words(
+        "Didn't go through",
+        "Verification couldn't run. Try again. Nothing was lost."
+      );
+    case "staff-required":
+      return words(
+        "Waiting for staff",
+        "A staff member confirms this activity for you."
+      );
+    case "rejected":
+      return words(
+        "Try again",
+        status.reason || "That submission wasn't accepted."
+      );
+    case "ready":
+      return words("Ready");
   }
 }
 function canSubmit(view) {
-  return !isFinished(view) && !isAutomatic(view) && view.lifecycle === "active" && view.availability.kind === "available";
+  return !isFinished(view) && !(view.counter?.repeat === "once" && view.counter.settled > 0) && !isAutomatic(view) && view.lifecycle === "active" && view.availability.kind === "available";
 }
 function progressOf(quests) {
   const counted = quests.filter(
-    (q) => q.lifecycle !== "archived" && q.completion.kind !== "keyed"
+    (q) => q.lifecycle !== "archived" && q.completion.kind !== "keyed" && q.completion.kind !== "progress"
   );
   return {
     total: counted.length,
     done: counted.filter(isFinished).length
   };
 }
+function sentence(text) {
+  const trimmed = text.trim();
+  return /[.!?]$/.test(trimmed) ? trimmed : `${trimmed}.`;
+}
 function list(items) {
-  return new Intl.ListFormat("en", { type: "conjunction" }).format(
-    items.map((item) => `\u201C${item}\u201D`)
-  );
+  return new Intl.ListFormat("en", { type: "conjunction" }).format(items);
+}
+function prerequisiteText(prerequisite) {
+  switch (prerequisite.kind) {
+    case "completion":
+      return prerequisite.scope === "ever" ? `complete ${quote(prerequisite.title)} first` : `complete ${quote(prerequisite.title)} in this ${prerequisite.period}`;
+    case "balance":
+      return `hold ${prerequisite.minimum.toLocaleString()} ${prerequisite.title}`;
+    case "group":
+      return `join ${quote(prerequisite.title)}`;
+  }
+}
+function capitalize(value) {
+  return value ? value[0].toUpperCase() + value.slice(1) : value;
+}
+function quote(value) {
+  return `\u201C${value}\u201D`;
 }
 
-// src/react/use-role-deliveries.ts
-import { useEffect, useState } from "react";
-function useRoleDeliveries(relay, member, completions) {
-  const [state, setState] = useState(null);
-  useEffect(() => {
-    if (!member || !completions) {
-      return;
+// src/react/store.ts
+var SIGNED_OUT = Object.freeze({
+  status: "signed-out",
+  data: void 0,
+  error: null
+});
+function scopeKey(session) {
+  if (!session) {
+    return "visitor";
+  }
+  const principal = session.principal;
+  return JSON.stringify([
+    session.organization,
+    session.project,
+    session.environment,
+    principal.kind,
+    sessionMember(session) ?? principal.subject ?? null,
+    session.id
+  ]);
+}
+function isVisible() {
+  return typeof document === "undefined" || document.visibilityState !== "hidden";
+}
+var RelayStore = class {
+  client;
+  #session = LOADING;
+  #scope = null;
+  #experience = { owner: null, state: LOADING };
+  #experienceView = LOADING;
+  #listeners = /* @__PURE__ */ new Set();
+  #observer = null;
+  #starting = false;
+  #mounted = false;
+  /** Bumped by every session the store learns of, so an older read cannot overwrite a newer one. */
+  #sessionVersion = 0;
+  #sessionRead = null;
+  /** The completions the experience last showed, and for whom. */
+  #completions = null;
+  constructor(client) {
+    this.client = client;
+  }
+  /** `refreshSession` with one identity per store, for hooks to hand out as `refresh`. */
+  rereadSession = () => this.refreshSession();
+  subscribe = (listener) => {
+    this.#listeners.add(listener);
+    return () => {
+      this.#listeners.delete(listener);
+    };
+  };
+  get session() {
+    return this.#session;
+  }
+  get scope() {
+    return this.#scope;
+  }
+  get experience() {
+    return this.#experienceView;
+  }
+  /** Starts observing; the returned function stops every read, timer and listener. */
+  mount() {
+    this.#mounted = true;
+    if (isVisible()) {
+      this.#startObserver();
     }
-    const watch = watchRoleDeliveries({
-      read: async () => (await relay.me.rewardDeliveries()).deliveries,
-      onChange: (deliveries) => setState({ member, deliveries })
-    });
-    const wake = () => {
-      if (document.visibilityState === "visible") {
-        watch.wake();
+    void this.refreshSession();
+    const onVisibility = () => {
+      if (isVisible()) {
+        this.#startObserver();
+        this.#scope?.cache.resume();
+      } else {
+        this.#observer?.dispose();
+        this.#observer = null;
       }
     };
-    window.addEventListener("focus", wake);
-    document.addEventListener("visibilitychange", wake);
+    const onFocus = () => this.#scope?.cache.focus();
+    if (typeof window !== "undefined") {
+      document.addEventListener("visibilitychange", onVisibility);
+      window.addEventListener("focus", onFocus);
+    }
     return () => {
-      watch.dispose();
-      window.removeEventListener("focus", wake);
-      document.removeEventListener("visibilitychange", wake);
+      this.#mounted = false;
+      if (typeof window !== "undefined") {
+        document.removeEventListener("visibilitychange", onVisibility);
+        window.removeEventListener("focus", onFocus);
+      }
+      this.#observer?.dispose();
+      this.#observer = null;
+      this.#sessionRead?.abort();
+      this.#sessionRead = null;
+      this.#sessionVersion++;
+      this.#scope?.cache.dispose();
+      this.#scope = null;
+      this.#session = LOADING;
+      this.#experience = { owner: null, state: LOADING };
+      this.#emit();
     };
-  }, [relay, member, completions]);
-  return member && completions && state?.member === member ? state.deliveries : [];
-}
-
-// src/react/experience.tsx
-import { jsx } from "react/jsx-runtime";
-var Context = createContext2(null);
-function ExperienceProvider({ children }) {
-  const relay = useRelay();
-  const [experience, setExperience] = useState2({
-    status: "loading"
-  });
-  const [owner, setOwner] = useState2(null);
-  const [member, setMember] = useState2(null);
-  const observer = useRef(null);
-  useEffect2(() => {
-    const subscription = relay.quests.observe((observation) => {
-      if (observation.kind === "session" || observation.kind === "ready") {
-        const principal = observation.session?.principal;
-        setMember(principal?.kind === "member" ? principal.member : null);
-      } else if (observation.kind === "loading") {
-        setMember(null);
+  }
+  /** Reads the session again now, without waiting for the experience observer. */
+  async refreshSession() {
+    if (!this.#mounted) {
+      return;
+    }
+    const version = ++this.#sessionVersion;
+    this.#sessionRead?.abort();
+    const controller = new AbortController();
+    this.#sessionRead = controller;
+    try {
+      const session = await this.client.auth.session({
+        signal: controller.signal
+      });
+      if (version === this.#sessionVersion && this.#mounted) {
+        const before = this.#scope?.key;
+        this.#setSession({ status: "ready", data: session, error: null });
+        this.#emit();
+        if (before !== void 0 && this.#scope?.key !== before) {
+          void this.#observer?.refresh();
+        }
+      }
+    } catch (cause) {
+      if (version === this.#sessionVersion && this.#mounted) {
+        this.#failSession(relayError(cause));
+        this.#emit();
       }
-      if (observation.kind === "ready") {
-        setOwner(observation.progress.member);
+    } finally {
+      if (this.#sessionRead === controller) {
+        this.#sessionRead = null;
       }
-      setExperience((previous) => {
+    }
+  }
+  /**
+   * Signs the participant out through the client, and drops their scope as soon as Relay confirms:
+   * the previous member's values never wait on the next session read, which may fail. Only the
+   * scope that signed out is dropped: someone who signed in while the request was in flight stays.
+   */
+  async signOut() {
+    const scope = this.#scope;
+    await this.client.auth.signOut();
+    if (!this.#mounted || this.#scope !== scope) {
+      return;
+    }
+    this.#sessionVersion++;
+    this.#sessionRead?.abort();
+    this.#setSession({ status: "ready", data: null, error: null });
+    this.#emit();
+  }
+  refreshExperience() {
+    return this.#observer?.refresh() ?? Promise.resolve();
+  }
+  /**
+   * Marks queries out of date (see `QueryCache.invalidate`). The `["experience"]` key, or no keys at
+   * all, also reads the quest experience again.
+   */
+  invalidate(keys) {
+    const reads = [];
+    if (keys.length === 0 || keys.some((key) => key[0] === "experience")) {
+      reads.push(this.refreshExperience());
+    }
+    reads.push(this.#scope?.cache.invalidate(keys) ?? Promise.resolve());
+    return Promise.all(reads).then(() => {
+    });
+  }
+  #startObserver() {
+    if (this.#observer || !this.#mounted) {
+      return;
+    }
+    this.#starting = true;
+    try {
+      this.#observer = this.client.quests.observe((observation) => {
         switch (observation.kind) {
           case "loading":
-            return { status: "loading" };
+            if (this.#starting) {
+              return;
+            }
+            this.#sessionVersion++;
+            this.#sessionRead?.abort();
+            return;
           case "session":
-            return observation.session?.principal.kind === "member" ? previous : { status: "signed-out" };
+            this.#sessionVersion++;
+            this.#setSession({
+              status: "ready",
+              data: observation.session,
+              error: null
+            });
+            break;
           case "ready":
-            return {
+            this.#sessionVersion++;
+            this.#setSession({
               status: "ready",
-              // Hidden quests never reach the UI, on any poll.
-              quests: visibleQuests(observation.progress.quests),
-              collections: observation.progress.collections.map(
-                (collection) => ({
-                  ...collection,
-                  quests: visibleQuests(collection.quests)
-                })
-              ),
-              stale: null
+              data: observation.session,
+              error: null
+            });
+            this.#completed(observation.progress);
+            this.#experience = {
+              owner: observation.progress.member,
+              state: {
+                status: "ready",
+                // Hidden quests never reach the UI, on any poll.
+                data: {
+                  entitlements: observation.progress.entitlements,
+                  quests: visibleQuests(observation.progress.quests),
+                  collections: observation.progress.collections.map(
+                    (collection) => ({
+                      ...collection,
+                      quests: visibleQuests(collection.quests)
+                    })
+                  )
+                },
+                error: null
+              }
+            };
+            break;
+          case "error": {
+            const error = relayError(observation.error);
+            const previous = this.#experience;
+            this.#experience = previous.state.status === "ready" ? {
+              owner: previous.owner,
+              state: { ...previous.state, error }
+            } : {
+              owner: this.#scope?.member ?? null,
+              state: { status: "error", data: void 0, error }
             };
-          case "error":
-            return previous.status === "ready" ? { ...previous, stale: observation.error.message } : { status: "error", message: observation.error.message };
+            if (this.#session.status === "loading") {
+              void this.refreshSession();
+            }
+            break;
+          }
         }
+        this.#emit();
       });
-    });
-    observer.current = subscription;
-    return () => subscription.dispose();
-  }, [relay]);
-  const mine = experience.status === "ready" && member !== null && member === owner;
-  const deliveries = useRoleDeliveries(
-    relay,
-    mine ? member : null,
-    mine ? completionMark([
-      ...experience.quests,
-      ...experience.collections.flatMap((c) => c.quests)
-    ]) : ""
-  );
-  const value = useMemo(
-    () => ({
-      experience,
-      member: mine ? member : null,
-      deliveries,
-      refresh: async () => observer.current?.refresh()
-    }),
-    [experience, mine, member, deliveries]
-  );
-  return /* @__PURE__ */ jsx(Context, { value, children });
-}
-function useExperience() {
-  const value = useContext2(Context);
-  if (!value) {
-    throw new Error("useExperience requires <RelayProvider>");
+    } finally {
+      this.#starting = false;
+    }
   }
-  return value;
-}
+  /**
+   * A new completion changes points, scores, profile completions and referral progress, whether
+   * the participant submitted it or Domino completed it by itself: read them again.
+   */
+  #completed(progress) {
+    const mark = completionMark([
+      ...progress.quests,
+      ...progress.collections.flatMap((collection) => collection.quests)
+    ]);
+    const previous = this.#completions;
+    this.#completions = { member: progress.member, mark };
+    if (previous?.member === progress.member && previous.mark !== mark) {
+      void this.#scope?.cache.invalidate(completionChanges);
+    }
+  }
+  #failSession(error) {
+    this.#setSession(
+      this.#session.status === "ready" ? { ...this.#session, error } : { status: "error", data: void 0, error }
+    );
+  }
+  #setSession(next) {
+    this.#session = next;
+    const key = next.status === "loading" ? null : next.status === "error" ? "unknown" : scopeKey(next.data);
+    if (key === (this.#scope?.key ?? null)) {
+      return;
+    }
+    this.#scope?.cache.dispose();
+    if (key === null) {
+      this.#scope = null;
+      return;
+    }
+    const session = next.status === "ready" ? next.data : null;
+    this.#scope = {
+      key,
+      session,
+      member: sessionMember(session),
+      cache: new QueryCache(session?.id, () => void this.refreshSession())
+    };
+  }
+  #deriveExperience() {
+    const session = this.#session;
+    if (session.status === "loading") {
+      return LOADING;
+    }
+    if (session.status === "error") {
+      return session;
+    }
+    const member = this.#scope?.member ?? null;
+    if (!member) {
+      return SIGNED_OUT;
+    }
+    return this.#experience.owner === member ? this.#experience.state : LOADING;
+  }
+  #emit() {
+    const experience = this.#deriveExperience();
+    if (experience !== this.#experienceView) {
+      this.#experienceView = experience;
+    }
+    for (const listener of [...this.#listeners]) {
+      listener();
+    }
+  }
+};
 
 // src/react/provider.tsx
 import { jsx as jsx2 } from "react/jsx-runtime";
@@ -382,10 +1160,252 @@ function RelayProvider({
   baseUrl = "/relay",
   children
 }) {
-  const [value] = useState3(
-    () => client ?? createBrowserRelayClient({ baseUrl })
+  const origin = client ? null : baseUrl;
+  const store = useMemo2(
+    () => new RelayStore(
+      client ?? createBrowserRelayClient({ baseUrl: origin ?? baseUrl })
+    ),
+    // A given client ignores `baseUrl`.
+    [client, origin]
+  );
+  useEffect3(() => store.mount(), [store]);
+  return /* @__PURE__ */ jsx2(StoreContext, { value: store, children: /* @__PURE__ */ jsx2(DeliveriesProvider, { children }) });
+}
+
+// src/react/query.ts
+import {
+  useCallback as useCallback3,
+  useEffect as useEffect4,
+  useLayoutEffect as useLayoutEffect2,
+  useMemo as useMemo3,
+  useRef as useRef2,
+  useState as useState3,
+  useSyncExternalStore as useSyncExternalStore3
+} from "react";
+function useLatest(value) {
+  const ref = useRef2(value);
+  useLayoutEffect2(() => {
+    ref.current = value;
+  });
+  return ref;
+}
+function useSessionSnapshot(store) {
+  const get = () => store.session;
+  return useSyncExternalStore3(store.subscribe, get, get);
+}
+function useScope(store) {
+  const get = () => store.scope;
+  return useSyncExternalStore3(store.subscribe, get, get);
+}
+function useCached(cache, key, read, options) {
+  const hash = key ? hashKey(key) : null;
+  const { intervalMs, refetchOnFocus } = options;
+  const latest = useLatest({ key, read });
+  const subscribe = useCallback3(
+    (listener) => {
+      const { key: current } = latest.current;
+      if (!cache || !current) {
+        return () => {
+        };
+      }
+      return cache.subscribe(
+        current,
+        (context) => latest.current.read(context),
+        { intervalMs, refetchOnFocus },
+        listener
+      );
+    },
+    // `hash` stands for the key.
+    [cache, hash, intervalMs, refetchOnFocus]
+  );
+  const get = () => cache && key ? cache.snapshot(key) : LOADING;
+  const snapshot = useSyncExternalStore3(subscribe, get, get);
+  const refresh = useCallback3(
+    () => cache && latest.current.key ? cache.refresh(latest.current.key) : Promise.resolve(),
+    [cache, hash]
+  );
+  return useMemo3(() => ({ ...snapshot, refresh }), [snapshot, refresh]);
+}
+function useRelayQuery(key, read, options = {}) {
+  const store = useStore();
+  const scope = useScope(store);
+  return useCached(scope?.cache ?? null, key, read, options);
+}
+function useMemberQuery(key, read, options = {}) {
+  const store = useStore();
+  const scope = useScope(store);
+  const member = scope?.member ?? null;
+  const query = useCached(
+    member ? scope.cache : null,
+    member ? key : null,
+    read,
+    options
+  );
+  return useMemberGate(store, member, query);
+}
+function useMemberGate(store, member, query) {
+  const session = useSessionSnapshot(store);
+  return useMemo3(() => {
+    if (session.status === "loading") {
+      return { ...LOADING, refresh: query.refresh };
+    }
+    if (session.status === "error") {
+      return {
+        status: "error",
+        data: void 0,
+        error: session.error,
+        refresh: store.rereadSession
+      };
+    }
+    return member ? query : { ...SIGNED_OUT, refresh: query.refresh };
+  }, [session, member, query, store]);
+}
+function usePages(cache, key, read, options) {
+  const hash = key ? hashKey(key) : null;
+  const query = useCached(
+    cache,
+    key,
+    (context) => read(context),
+    options
+  );
+  const [more, setMore] = useState3(null);
+  const busy = useRef2(null);
+  const latest = useLatest({ key, read, query });
+  useEffect4(
+    () => () => {
+      busy.current?.abort();
+      busy.current = null;
+    },
+    [cache, hash]
+  );
+  const loadMore = useCallback3(async () => {
+    const { key: current, read: reader, query: shown } = latest.current;
+    if (!cache || !current || busy.current || shown.status !== "ready" || shown.data.nextCursor === null) {
+      return;
+    }
+    const owner = { cache, hash };
+    const version = cache.version(current);
+    const controller = new AbortController();
+    busy.current = controller;
+    setMore({ owner, loading: true, error: null });
+    try {
+      const page = await reader({
+        signal: controller.signal,
+        session: cache.session,
+        cursor: shown.data.nextCursor
+      });
+      if (busy.current === controller) {
+        cache.update(current, version, (data) => ({
+          items: [...data.items, ...page.items],
+          nextCursor: page.nextCursor
+        }));
+      }
+    } catch (cause) {
+      if (busy.current === controller) {
+        setMore({ owner, loading: false, error: relayError(cause) });
+      }
+    } finally {
+      if (busy.current === controller) {
+        busy.current = null;
+        setMore(
+          (value) => value?.owner === owner ? { ...value, loading: false } : value
+        );
+      }
+    }
+  }, [cache, hash]);
+  const mine = more && more.owner.cache === cache && more.owner.hash === hash ? more : null;
+  return useMemo3(
+    () => ({
+      ...query,
+      loadMore,
+      loadingMore: mine?.loading ?? false,
+      loadMoreError: mine?.error ?? null
+    }),
+    [query, loadMore, mine]
+  );
+}
+function useRelayPages(key, read, options = {}) {
+  const store = useStore();
+  const scope = useScope(store);
+  return usePages(scope?.cache ?? null, key, read, options);
+}
+function useMemberPages(key, read, options = {}) {
+  const store = useStore();
+  const scope = useScope(store);
+  const member = scope?.member ?? null;
+  const pages = usePages(
+    member ? scope.cache : null,
+    member ? key : null,
+    read,
+    options
+  );
+  const gate = useMemberGate(store, member, pages);
+  return useMemo3(
+    () => gate === pages ? pages : {
+      ...gate,
+      loadMore: pages.loadMore,
+      loadingMore: false,
+      loadMoreError: null
+    },
+    [gate, pages]
+  );
+}
+function useInvalidate() {
+  const store = useStore();
+  return useCallback3((keys = []) => store.invalidate(keys), [store]);
+}
+function useSession() {
+  const store = useStore();
+  const session = useSessionSnapshot(store);
+  const refresh = store.rereadSession;
+  return useMemo3(
+    () => ({
+      ...session,
+      refresh,
+      member: session.status === "ready" ? sessionMember(session.data) : null
+    }),
+    [session, refresh]
+  );
+}
+function useAction() {
+  const [busy, setBusy] = useState3(false);
+  const [actionError, setActionError] = useState3(null);
+  const run = useCallback3(async (task) => {
+    setBusy(true);
+    setActionError(null);
+    try {
+      await task();
+      return true;
+    } catch (cause) {
+      setActionError(relayError(cause));
+      return false;
+    } finally {
+      setBusy(false);
+    }
+  }, []);
+  return { busy, actionError, run };
+}
+function useScopeSession() {
+  const store = useStore();
+  return useScope(store)?.session?.id;
+}
+
+// src/react/rewards.ts
+function useEntitlements(options = {}) {
+  const relay = useRelay();
+  return useMemberQuery(
+    [...relayKeys.rewards, "entitlements"],
+    (context) => relay.rewards.entitlements(context),
+    { intervalMs: 5e3, ...options }
+  );
+}
+function useDeliveries(options = {}) {
+  const relay = useRelay();
+  return useMemberQuery(
+    [...relayKeys.rewards, "deliveries"],
+    (context) => relay.rewards.deliveries(context),
+    { intervalMs: 5e3, ...options }
   );
-  return /* @__PURE__ */ jsx2(ClientContext, { value, children: /* @__PURE__ */ jsx2(ExperienceProvider, { children }) });
 }
 
 // src/react/quest-groups.ts
@@ -409,10 +1429,17 @@ function questGroups(experience, order = []) {
 }
 
 // src/react/use-quest.ts
-import { useCallback, useEffect as useEffect3, useState as useState4 } from "react";
+import {
+  useCallback as useCallback4,
+  useEffect as useEffect5,
+  useLayoutEffect as useLayoutEffect3,
+  useMemo as useMemo4,
+  useRef as useRef3,
+  useState as useState4
+} from "react";
 function useQuest(observed) {
-  const relay = useRelay();
-  const { refresh } = useExperience();
+  const store = useStore();
+  const relay = store.client;
   const [latest, setLatest] = useState4(null);
   const [draft, setDraft] = useState4(null);
   const [notice, setNotice] = useState4(null);
@@ -421,12 +1448,12 @@ function useQuest(observed) {
   const [discardedAttempt, setDiscardedAttempt] = useState4(null);
   const [saved, setSaved] = useState4("none");
   const [receipt, setReceipt] = useState4(null);
-  useEffect3(() => setLatest(null), [observed.release]);
+  useEffect5(() => setLatest(null), [observed.release]);
   const view = latest ?? observed;
   const { quest, release } = view;
   const completed = isFinished(view) || isAutomatic(view);
   const attempt = view.attempt?.id;
-  useEffect3(() => {
+  useEffect5(() => {
     let active = true;
     relay.quests.open(view).then((controller) => controller.status()).then((status) => {
       if (!active) {
@@ -441,7 +1468,7 @@ function useQuest(observed) {
       active = false;
     };
   }, [relay, quest, release, completed, attempt, busy]);
-  const run = useCallback(
+  const run = useCallback4(
     async (action) => {
       setBusy(true);
       setError(null);
@@ -457,158 +1484,140 @@ function useQuest(observed) {
           setReceipt(result.attempt.id);
           setNotice("received");
         }
-        await refresh();
+        await store.refreshExperience();
       } catch (cause) {
-        setError(
-          cause instanceof Error ? cause.message : "Something went wrong."
-        );
+        setError(asRelayError(cause, "Something went wrong."));
       } finally {
         setBusy(false);
       }
     },
-    [refresh]
+    [store]
   );
-  return {
-    /** The newest known version of the quest. Render this, not the prop. */
-    view,
-    /** Input recovered after the quest changed. Prefill the form with it. */
-    draft,
-    notice,
-    error,
-    busy,
-    saved,
-    /** The attempt the last "received" notice is about. */
-    receipt,
-    startingFresh: view.attempt?.id === discardedAttempt && view.attempt?.status === "failed",
-    restart: async () => {
-      setBusy(true);
-      setError(null);
-      try {
-        await (await relay.quests.open(view)).discard();
-        setDiscardedAttempt(view.attempt?.id ?? null);
-        setSaved("none");
-        setDraft(null);
-        setNotice(null);
-      } catch (cause) {
-        setError(
-          cause instanceof Error ? cause.message : "Could not start a new submission."
-        );
-      } finally {
-        setBusy(false);
-      }
-    },
-    submit: (input) => run(async () => {
-      if (view.connections.length) {
-        const accounts = await relay.auth.accounts();
-        const missing = view.connections.find(
-          (provider) => !accounts.some(
-            (account) => account.provider === provider && account.configured && account.status === "connected"
-          )
-        );
-        if (missing) {
-          throw new Error(`Connect ${missing} before verifying.`);
+  const shown = useRef3(view);
+  useLayoutEffect3(() => {
+    shown.current = view;
+  });
+  const actions = useMemo4(
+    () => ({
+      restart: async () => {
+        const current = shown.current;
+        setBusy(true);
+        setError(null);
+        try {
+          await (await relay.quests.open(current)).discard();
+          setDiscardedAttempt(current.attempt?.id ?? null);
+          setSaved("none");
+          setDraft(null);
+          setNotice(null);
+        } catch (cause) {
+          setError(asRelayError(cause, "Could not start a new submission."));
+        } finally {
+          setBusy(false);
         }
-      }
-      const controller = await relay.quests.open(view);
-      if ((controller.kind === "text" || controller.kind === "url") && input.kind === controller.kind) {
-        return controller.submit(input.value);
-      }
-      if (controller.kind === "claim" && input.kind === "claim") {
-        return controller.submit();
-      }
-      if (controller.kind === "quiz" && input.kind === "quiz") {
-        return controller.submit(input.answers);
-      }
-      if (controller.kind === "photo" && input.kind === "photo") {
-        return controller.submit(input.file);
-      }
-      throw new Error("This activity changed. Reload and try again.");
+      },
+      submit: (input) => run(async () => {
+        const current = shown.current;
+        if (current.connections.length) {
+          const accounts = await relay.auth.accounts();
+          const missing = current.connections.find(
+            (provider) => !accounts.some(
+              (account) => account.provider === provider && account.configured && account.status === "connected"
+            )
+          );
+          if (missing) {
+            throw new Error(`Connect ${missing} before verifying.`);
+          }
+        }
+        const controller = await relay.quests.open(current);
+        if ((controller.kind === "text" || controller.kind === "url") && input.kind === controller.kind) {
+          return controller.submit(input.value);
+        }
+        if (controller.kind === "claim" && input.kind === "claim") {
+          return controller.submit();
+        }
+        if (controller.kind === "quiz" && input.kind === "quiz") {
+          return controller.submit(input.answers);
+        }
+        if (controller.kind === "photo" && input.kind === "photo") {
+          return controller.submit(input.file);
+        }
+        throw new Error("This activity changed. Reload and try again.");
+      }),
+      /** Finish an interrupted submission, or reopen an outdated draft. */
+      resume: () => run(async () => (await relay.quests.open(shown.current)).resume()),
+      /**
+       * Re-run verification that failed to run. Never creates a new attempt.
+       * Domino refuses this for automatic quests, so never offer it for them.
+       */
+      retry: () => run(async () => {
+        const current = shown.current;
+        if (isAutomatic(current)) {
+          throw new Error("This activity updates by itself.");
+        }
+        return {
+          kind: "submitted",
+          attempt: await relay.quests.retry(current)
+        };
+      })
+    }),
+    [relay, run]
+  );
+  const startingFresh = view.attempt?.id === discardedAttempt && view.attempt?.status === "failed";
+  return useMemo4(
+    () => ({
+      /** The newest known version of the quest. Render this, not the prop. */
+      view,
+      /** Input recovered after the quest changed. Prefill the form with it. */
+      draft,
+      notice,
+      error,
+      busy,
+      saved,
+      /** The attempt the last "received" notice is about. */
+      receipt,
+      startingFresh,
+      ...actions
     }),
-    /** Finish an interrupted submission, or reopen an outdated draft. */
-    resume: () => run(async () => (await relay.quests.open(view)).resume()),
-    /**
-     * Re-run verification that failed to run. Never creates a new attempt.
-     * Domino refuses this for automatic quests, so never offer it for them.
-     */
-    retry: () => run(async () => {
-      if (isAutomatic(view)) {
-        throw new Error("This activity updates by itself.");
-      }
-      return {
-        kind: "submitted",
-        attempt: await relay.quests.retry(view)
-      };
-    })
-  };
+    [view, draft, notice, error, busy, saved, receipt, startingFresh, actions]
+  );
 }
 
 // src/react/auth.ts
-import { useCallback as useCallback3, useEffect as useEffect5, useMemo as useMemo2, useRef as useRef2, useState as useState6 } from "react";
+import { useCallback as useCallback5, useMemo as useMemo6, useRef as useRef4, useState as useState6 } from "react";
 
 // src/react/wallets.ts
-import { useCallback as useCallback2, useEffect as useEffect4, useState as useState5 } from "react";
-var WALLETS_CHANGED = "relay-wallets-changed";
+import { useEffect as useEffect6, useMemo as useMemo5, useState as useState5 } from "react";
 function useWallets() {
   const relay = useRelay();
-  const { member } = useExperience();
-  const [wallets, setWallets] = useState5(null);
-  const [error, setError] = useState5(null);
-  const [busy, setBusy] = useState5(false);
-  const refresh = useCallback2(async () => {
-    try {
-      setWallets(await relay.wallets.list());
-      setError(null);
-    } catch (cause) {
-      setError(
-        cause instanceof Error && cause.message ? cause.message : "Could not load linked wallets."
-      );
-    }
-  }, [relay]);
-  useEffect4(() => {
-    if (!member) {
-      setWallets(null);
-      return;
-    }
-    const update = () => void refresh();
-    update();
-    window.addEventListener("focus", update);
-    window.addEventListener(WALLETS_CHANGED, update);
-    return () => {
-      window.removeEventListener("focus", update);
-      window.removeEventListener(WALLETS_CHANGED, update);
+  const invalidate = useInvalidate();
+  const session = useScopeSession();
+  const query = useMemberQuery(
+    relayKeys.wallets,
+    (options) => relay.wallets.list(options),
+    { refetchOnFocus: true }
+  );
+  const { busy, actionError, run } = useAction();
+  const actions = useMemo5(() => {
+    const changed = () => void invalidate([relayKeys.wallets, relayKeys.experience]);
+    return {
+      /** Links the wallet to the member the list was read for; another session is refused. */
+      link: (signer) => run(async () => {
+        await relay.wallets.link(signer, { session });
+        changed();
+      }),
+      unlink: (wallet) => run(async () => {
+        await relay.wallets.unlink(
+          { chain: wallet.chain, address: wallet.address },
+          { session }
+        );
+        changed();
+      })
     };
-  }, [member, refresh]);
-  async function run(task, fallback) {
-    setBusy(true);
-    setError(null);
-    try {
-      await task();
-    } catch (cause) {
-      setError(
-        cause instanceof Error && cause.message ? cause.message : fallback
-      );
-    } finally {
-      setBusy(false);
-    }
-  }
-  return {
-    /** Null until read, and while nobody is signed in. */
-    wallets,
-    error,
-    busy,
-    refresh,
-    link: (signer) => run(async () => {
-      await relay.wallets.link(signer);
-      window.dispatchEvent(new Event(WALLETS_CHANGED));
-    }, "Couldn't link this wallet. Try again."),
-    unlink: (wallet) => run(async () => {
-      await relay.wallets.unlink({
-        chain: wallet.chain,
-        address: wallet.address
-      });
-      window.dispatchEvent(new Event(WALLETS_CHANGED));
-    }, "Couldn't unlink this wallet. Try again.")
-  };
+  }, [relay, invalidate, session, run]);
+  return useMemo5(
+    () => ({ ...query, busy, actionError, ...actions }),
+    [query, busy, actionError, actions]
+  );
 }
 function discoverChains(key) {
   return JSON.parse(key).flatMap(
@@ -618,7 +1627,7 @@ function discoverChains(key) {
 function useWalletDiscovery(options = {}) {
   const chains = JSON.stringify(cosmosChainList(options.cosmos));
   const [found, setFound] = useState5({ evm: [], solana: [], cosmos: [] });
-  useEffect4(() => {
+  useEffect6(() => {
     let active = true;
     const solana = discoverSolanaWallets();
     const cosmos = discoverChains(chains);
@@ -641,7 +1650,7 @@ function useSignInWallets(networks, options = {}) {
   const key = networks ? `${networks.join(" ")}
 ${chains}` : null;
   const [found, setFound] = useState5(null);
-  useEffect4(() => {
+  useEffect6(() => {
     if (key === null) {
       return;
     }
@@ -663,73 +1672,47 @@ ${chains}` : null;
 }
 
 // src/react/auth.ts
+var NONE_UNAVAILABLE = [];
 function useSignInMethods() {
   const relay = useRelay();
-  const [methods, setMethods] = useState6(null);
-  useEffect5(() => {
-    let active = true;
-    void readSignInMethods(relay).then((result) => {
-      if (active) {
-        setMethods(result);
-      }
-    });
-    return () => {
-      active = false;
-    };
-  }, [relay]);
-  return methods;
+  return useRelayQuery(relayKeys.signInMethods, () => readSignInMethods(relay));
 }
 function useMe() {
   const relay = useRelay();
-  const { member } = useExperience();
-  const [me, setMe] = useState6(null);
-  useEffect5(() => {
-    if (!member) {
-      setMe(null);
-      return;
-    }
-    let active = true;
-    void relay.me.get().then((value) => active && setMe(value)).catch(() => active && setMe(null));
-    return () => {
-      active = false;
-    };
-  }, [relay, member]);
-  return me;
+  return useMemberQuery(relayKeys.me, (options) => relay.me.get(options));
 }
 function useSignIn() {
   const relay = useRelay();
   const [challenge, setChallengeState] = useState6(null);
-  const latest = useRef2(null);
+  const latest = useRef4(null);
   const [busy, setBusy] = useState6(false);
   const [error, setError] = useState6(null);
-  const setChallenge = useCallback3((value) => {
+  const setChallenge = useCallback5((value) => {
     latest.current = value;
     setChallengeState(value);
   }, []);
-  const run = useCallback3(
+  const run = useCallback5(
     async (task, fallback) => {
       setBusy(true);
       setError(null);
       try {
         await task();
       } catch (cause) {
-        setError(
-          cause instanceof Error && cause.message ? cause.message : fallback
-        );
+        setError(asRelayError(cause, fallback));
       } finally {
         setBusy(false);
       }
     },
     []
   );
-  const sendCode = useCallback3(
+  const sendCode = useCallback5(
     (email) => run(async () => {
       setChallenge(null);
       setChallenge((await relay.auth.emailStart(email)).challenge);
     }, "Couldn't send a code. Check the address and try again."),
     [relay, run, setChallenge]
   );
-  const verifyCode = useCallback3(
+  const verifyCode = useCallback5(
     (code) => run(async () => {
       const sent = latest.current;
       if (!sent) {
@@ -740,59 +1723,70 @@ function useSignIn() {
     }, "That code didn't work. Check it, or request a new one."),
     [relay, run, setChallenge]
   );
-  const startOver = useCallback3(() => {
+  const startOver = useCallback5(() => {
     setChallenge(null);
     setError(null);
   }, [setChallenge]);
-  const withProvider = useCallback3(
+  const withProvider = useCallback5(
     (provider) => run(async () => {
       const { url } = await relay.auth.start(provider, "sign-in");
       window.location.assign(url);
     }, "Couldn't start sign-in. Try again."),
     [relay, run]
   );
-  const withWallet = useCallback3(
+  const withWallet = useCallback5(
     (signer) => run(async () => {
       await relay.auth.wallet.signIn(signer);
       setChallenge(null);
     }, "Couldn't sign in with this wallet. Try again."),
     [relay, run, setChallenge]
   );
-  return {
-    busy,
-    error,
-    /** True once a code was sent and the form should ask for it. */
-    codeSent: challenge !== null,
-    sendCode,
-    verifyCode,
-    startOver,
-    withProvider,
-    /** Signs in, or signs up, with a wallet; the wallet asks the participant to sign a message. */
-    withWallet
-  };
+  const codeSent = challenge !== null;
+  return useMemo6(
+    () => ({
+      busy,
+      error,
+      /** True once a code was sent and the form should ask for it. */
+      codeSent,
+      sendCode,
+      verifyCode,
+      startOver,
+      withProvider,
+      /** Signs in, or signs up, with a wallet; the wallet asks the participant to sign a message. */
+      withWallet
+    }),
+    [
+      busy,
+      error,
+      codeSent,
+      sendCode,
+      verifyCode,
+      startOver,
+      withProvider,
+      withWallet
+    ]
+  );
 }
 function useSignOut() {
-  const relay = useRelay();
+  const store = useStore();
   const [busy, setBusy] = useState6(false);
-  return {
-    busy,
-    signOut: async () => {
-      setBusy(true);
-      try {
-        await relay.auth.signOut();
-      } finally {
-        setBusy(false);
-      }
+  const signOut = useCallback5(async () => {
+    setBusy(true);
+    try {
+      await store.signOut();
+    } finally {
+      setBusy(false);
     }
-  };
+  }, [store]);
+  return useMemo6(() => ({ busy, signOut }), [busy, signOut]);
 }
 function useSignInOptions(input = {}) {
   const chains = JSON.stringify(cosmosChainList(input.cosmos));
-  const cosmos = useMemo2(
+  const cosmos = useMemo6(
     () => JSON.parse(chains),
     [chains]
   );
-  const methods = useSignInMethods();
+  const methods = useSignInMethods().data ?? null;
   const wallets = useSignInWallets(methods?.wallets, { cosmos });
   const {
     busy,
@@ -804,7 +1798,7 @@ function useSignInOptions(input = {}) {
     withProvider,
     withWallet
   } = useSignIn();
-  const built = useMemo2(() => {
+  const built = useMemo6(() => {
     if (!methods) {
       return null;
     }
@@ -822,20 +1816,23 @@ function useSignInOptions(input = {}) {
       }
     });
   }, [methods, wallets, cosmos, withProvider, sendCode, verifyCode, withWallet]);
-  return {
-    options: built?.options ?? null,
-    unavailable: built?.unavailable ?? [],
-    methodsError: methods?.error ?? null,
-    busy,
-    error,
-    codeSent,
-    startOver
-  };
+  const methodsError = methods?.error ?? null;
+  return useMemo6(
+    () => ({
+      options: built?.options ?? null,
+      unavailable: built?.unavailable ?? NONE_UNAVAILABLE,
+      methodsError,
+      busy,
+      error,
+      codeSent,
+      startOver
+    }),
+    [built, methodsError, busy, error, codeSent, startOver]
+  );
 }
 
 // src/react/accounts.ts
-import { useCallback as useCallback4, useEffect as useEffect6, useState as useState7 } from "react";
-var CHANGED = "relay-accounts-changed";
+import { useMemo as useMemo7 } from "react";
 function isConnected(accounts, provider) {
   return Boolean(
     accounts?.some(
@@ -845,304 +1842,124 @@ function isConnected(accounts, provider) {
 }
 function useAccounts() {
   const relay = useRelay();
-  const { member } = useExperience();
-  const [accounts, setAccounts] = useState7(null);
-  const [error, setError] = useState7(null);
-  const [busy, setBusy] = useState7(false);
-  const refresh = useCallback4(async () => {
-    try {
-      setAccounts(await relay.auth.accounts());
-      setError(null);
-    } catch (cause) {
-      setError(
-        cause instanceof Error && cause.message ? cause.message : "Could not load connected accounts."
-      );
-    }
-  }, [relay]);
-  useEffect6(() => {
-    if (!member) {
-      setAccounts(null);
-      return;
-    }
-    const update = () => void refresh();
-    update();
-    window.addEventListener("focus", update);
-    window.addEventListener(CHANGED, update);
-    return () => {
-      window.removeEventListener("focus", update);
-      window.removeEventListener(CHANGED, update);
-    };
-  }, [member, refresh]);
-  async function run(task, fallback) {
-    setBusy(true);
-    setError(null);
-    try {
-      await task();
-    } catch (cause) {
-      setError(
-        cause instanceof Error && cause.message ? cause.message : fallback
-      );
-    } finally {
-      setBusy(false);
-    }
-  }
-  return {
-    /** Null until read, and while nobody is signed in. */
-    accounts,
-    error,
-    busy,
-    refresh,
-    isConnected: (provider) => isConnected(accounts, provider),
-    connect: (provider) => run(async () => {
-      const { url } = await relay.auth.start(provider, "connect");
-      window.location.assign(url);
-    }, "Couldn't start connecting. Try again."),
-    disconnect: (provider) => run(async () => {
-      await relay.auth.disconnect(provider);
-      window.dispatchEvent(new Event(CHANGED));
-    }, "Couldn't disconnect. Try again.")
-  };
+  const invalidate = useInvalidate();
+  const session = useScopeSession();
+  const query = useMemberQuery(
+    relayKeys.accounts,
+    (options) => relay.auth.accounts(options),
+    { refetchOnFocus: true }
+  );
+  const { busy, actionError, run } = useAction();
+  const actions = useMemo7(
+    () => ({
+      connect: (provider) => run(async () => {
+        const { url } = await relay.auth.start(provider, "connect", {
+          session
+        });
+        window.location.assign(url);
+      }),
+      disconnect: (provider) => run(async () => {
+        await relay.auth.disconnect(provider, { session });
+        void invalidate([
+          relayKeys.accounts,
+          relayKeys.experience,
+          relayKeys.profiles
+        ]);
+      })
+    }),
+    [relay, invalidate, session, run]
+  );
+  const accounts = query.data;
+  return useMemo7(
+    () => ({
+      ...query,
+      busy,
+      actionError,
+      isConnected: (provider) => isConnected(accounts, provider),
+      ...actions
+    }),
+    [query, busy, actionError, accounts, actions]
+  );
 }
 
 // src/react/profiles.ts
-import { useCallback as useCallback5, useEffect as useEffect7, useRef as useRef3, useState as useState8 } from "react";
-var PROFILE_CHANGED = "relay-profile-changed";
+import { useMemo as useMemo8 } from "react";
+var MINE = [...relayKeys.profiles, "mine"];
 function useMyProfile() {
   const relay = useRelay();
-  const { member } = useExperience();
-  const [profile, setProfile] = useState8(null);
-  const [error, setError] = useState8(null);
-  const [busy, setBusy] = useState8(false);
-  const session = useRef3(null);
-  const refresh = useCallback5(async () => {
-    try {
-      const [current, value] = await Promise.all([
-        relay.auth.session(),
-        relay.profiles.mine()
+  const store = useStore();
+  const session = useScopeSession();
+  const query = useMemberQuery(
+    MINE,
+    (options) => relay.profiles.mine(options),
+    { refetchOnFocus: true }
+  );
+  const { busy, actionError, run } = useAction();
+  const actions = useMemo8(() => {
+    const change = (task) => run(async () => {
+      const cache = store.scope?.cache;
+      const saved = await task();
+      cache?.set(MINE, saved);
+      void cache?.invalidate([
+        [...relayKeys.profiles, "get"],
+        relayKeys.leaderboards
       ]);
-      session.current = current?.id ?? null;
-      setProfile(value);
-      setError(null);
-    } catch (cause) {
-      setError(
-        cause instanceof Error && cause.message ? cause.message : "Could not load your profile."
-      );
-    }
-  }, [relay]);
-  useEffect7(() => {
-    if (!member) {
-      setProfile(null);
-      session.current = null;
-      return;
-    }
-    const update = () => void refresh();
-    update();
-    window.addEventListener("focus", update);
-    window.addEventListener(PROFILE_CHANGED, update);
-    return () => {
-      window.removeEventListener("focus", update);
-      window.removeEventListener(PROFILE_CHANGED, update);
-    };
-  }, [member, refresh]);
-  async function run(task, fallback) {
-    setBusy(true);
-    setError(null);
-    try {
-      const value = await task(session.current ?? void 0);
-      setProfile(value);
-      window.dispatchEvent(new Event(PROFILE_CHANGED));
-      return true;
-    } catch (cause) {
-      setError(
-        cause instanceof Error && cause.message ? cause.message : fallback
-      );
-      return false;
-    } finally {
-      setBusy(false);
-    }
-  }
-  return {
-    /** Null until read, and while nobody is signed in. */
-    profile,
-    error,
-    busy,
-    refresh,
-    /** Resolves true once saved; a failure sets `error`. */
-    update: (input) => run(
-      (value) => relay.profiles.update(input, { session: value }),
-      "Couldn't save your profile. Try again."
-    ),
-    /** Uploads a JPEG, PNG or WebP of at most 5 MB as the avatar; resolves true once saved. */
-    uploadAvatar: (file) => run(
-      (value) => relay.profiles.uploadAvatar(file, {
-        uploadId: crypto.randomUUID(),
-        session: value
-      }),
-      "Couldn't upload this picture. Try again."
-    )
-  };
-}
-function useProfileRead(read, intervalMs, fallback) {
-  const { member } = useExperience();
-  const [state, setState] = useState8({
-    status: "loading"
-  });
-  const refresh = useCallback5(async () => {
-    try {
-      const value = await read();
-      setState({ status: "ready", value, stale: null });
-    } catch (cause) {
-      if (cause instanceof RelayError && cause.status === 404) {
-        setState({ status: "missing" });
-        return;
-      }
-      const message = cause instanceof Error && cause.message ? cause.message : fallback;
-      setState(
-        (previous) => previous.status === "ready" ? { ...previous, stale: message } : { status: "error", message }
-      );
-    }
-  }, [read, fallback]);
-  useEffect7(() => {
-    setState({ status: "loading" });
-    void refresh();
-    const timer = setInterval(() => {
-      if (document.visibilityState === "visible") {
-        void refresh();
-      }
-    }, intervalMs);
-    const changed = () => void refresh();
-    window.addEventListener(PROFILE_CHANGED, changed);
-    return () => {
-      clearInterval(timer);
-      window.removeEventListener(PROFILE_CHANGED, changed);
+    });
+    return {
+      update: (input) => change(() => relay.profiles.update(input, { session })),
+      /** Uploads a JPEG, PNG or WebP of at most 5 MB as the avatar. */
+      uploadAvatar: (file) => change(
+        () => relay.profiles.uploadAvatar(file, {
+          uploadId: crypto.randomUUID(),
+          session
+        })
+      )
     };
-  }, [refresh, member, intervalMs]);
-  return { state, refresh };
+  }, [relay, store, session, run]);
+  return useMemo8(
+    () => ({ ...query, busy, actionError, ...actions }),
+    [query, busy, actionError, actions]
+  );
 }
 function useProfile(id, options = {}) {
   const relay = useRelay();
-  const read = useCallback5(() => relay.profiles.get(id), [relay, id]);
-  const { state, refresh } = useProfileRead(
-    read,
-    options.intervalMs ?? 6e4,
-    "Could not load the profile."
+  return useRelayQuery(
+    [...relayKeys.profiles, "get", id],
+    (request) => relay.profiles.get(id, request),
+    { intervalMs: options.intervalMs ?? 6e4 }
   );
-  const value = state.status === "ready" ? { status: "ready", profile: state.value, stale: state.stale } : state;
-  return { ...value, refresh };
 }
 function useLeaderboardPlacement(board, profile, options = {}) {
   const relay = useRelay();
-  const read = useCallback5(
-    () => relay.leaderboards.placement(board, profile),
-    [relay, board, profile]
+  return useRelayQuery(
+    [...relayKeys.leaderboards, board, "placement", profile],
+    (request) => relay.leaderboards.placement(board, profile, request),
+    { intervalMs: options.intervalMs ?? 3e4 }
   );
-  const { state, refresh } = useProfileRead(
-    read,
-    options.intervalMs ?? 3e4,
-    "Could not load the leaderboard placement."
-  );
-  return { ...state, refresh };
 }
 function useProfileReferral(profile, program, options = {}) {
   const relay = useRelay();
-  const read = useCallback5(
-    () => relay.profiles.referral(profile, program),
-    [relay, profile, program]
-  );
-  const { state, refresh } = useProfileRead(
-    read,
-    options.intervalMs ?? 6e4,
-    "Could not load referral progress."
+  return useMemberQuery(
+    [...relayKeys.profiles, "referral", profile, program],
+    (request) => relay.profiles.referral(profile, program, request),
+    { intervalMs: options.intervalMs ?? 6e4 }
   );
-  return { ...state, refresh };
 }
 function useProfileCompletions(profile, options = {}) {
   const relay = useRelay();
-  const { member } = useExperience();
   const { limit = 20 } = options;
-  const [state, setState] = useState8({
-    status: "loading"
-  });
-  const cursor = useRef3(null);
-  const generation = useRef3(0);
-  const paging = useRef3({ ready: false, busy: false });
-  const load = useCallback5(
-    async (first) => {
-      if (first) {
-        generation.current++;
-        paging.current = { ready: false, busy: false };
-      } else {
-        if (!paging.current.ready || paging.current.busy || cursor.current === null) {
-          return;
-        }
-        paging.current.busy = true;
-        setState(
-          (previous) => previous.status === "ready" ? { ...previous, loading: true, error: null } : previous
-        );
-      }
-      const current = generation.current;
-      const own = paging.current;
-      try {
-        const page = await relay.profiles.completions(profile, {
-          limit,
-          ...!first && cursor.current ? { cursor: cursor.current } : {}
-        });
-        if (current !== generation.current) {
-          return;
-        }
-        cursor.current = page.nextCursor;
-        own.ready = true;
-        setState((previous) => ({
-          status: "ready",
-          items: !first && previous.status === "ready" ? [...previous.items, ...page.items] : page.items,
-          more: page.nextCursor !== null,
-          loading: false,
-          error: null
-        }));
-      } catch (cause) {
-        if (current !== generation.current) {
-          return;
-        }
-        if (first && cause instanceof RelayError && cause.status === 404) {
-          setState({ status: "missing" });
-          return;
-        }
-        const message = cause instanceof Error && cause.message ? cause.message : "Could not load completed quests.";
-        setState(
-          (previous) => !first && previous.status === "ready" ? { ...previous, loading: false, error: message } : { status: "error", message }
-        );
-      } finally {
-        if (!first) {
-          own.busy = false;
-        }
-      }
-    },
-    [relay, profile, limit]
+  return useRelayPages(
+    [...relayKeys.profiles, "completions", profile, limit],
+    ({ cursor, ...request }) => relay.profiles.completions(
+      profile,
+      cursor ? { limit, cursor } : { limit },
+      request
+    )
   );
-  useEffect7(() => {
-    setState({ status: "loading" });
-    cursor.current = null;
-    void load(true);
-    const changed = () => void load(true);
-    window.addEventListener(PROFILE_CHANGED, changed);
-    return () => {
-      generation.current++;
-      window.removeEventListener(PROFILE_CHANGED, changed);
-    };
-  }, [load, member]);
-  return {
-    ...state,
-    refresh: () => load(true),
-    /**
-     * Appends the next page; does nothing while one loads, while the first page reloads, or when
-     * there is none.
-     */
-    loadMore: () => load(false)
-  };
 }
 
 // src/react/referrals.ts
-import { useCallback as useCallback6, useEffect as useEffect8, useRef as useRef4, useState as useState9 } from "react";
+import { useCallback as useCallback6, useEffect as useEffect7, useMemo as useMemo9, useRef as useRef5, useState as useState7 } from "react";
 var PENDING = "domino:pending-referral";
 var CODE = /^[a-zA-Z0-9_-]{1,100}$/;
 function captureReferralCode(param = "ref") {
@@ -1167,12 +1984,13 @@ function forgetReferralCode() {
 }
 function useInvitation(param = "ref") {
   const relay = useRelay();
-  const { member } = useExperience();
-  const [state, setState] = useState9(() => {
+  const invalidate = useInvalidate();
+  const { member } = useSession();
+  const [state, setState] = useState7(() => {
     const code = captureReferralCode(param);
     return code ? { status: "pending", code } : { status: "none" };
   });
-  const started = useRef4(null);
+  const started = useRef5(null);
   const accept = useCallback6(
     async (code) => {
       setState({ status: "accepting", code });
@@ -1180,152 +1998,189 @@ function useInvitation(param = "ref") {
         await relay.referrals.accept({ code, actionId: `accept-${code}` });
         forgetReferralCode();
         setState({ status: "accepted", code });
+        void invalidate([relayKeys.referrals, relayKeys.profiles]);
       } catch (cause) {
-        const refused = cause instanceof RelayError && cause.status >= 400 && cause.status < 500;
+        const refused = isRelayError(cause) && (cause.kind === "http" && cause.status !== void 0 && cause.status >= 400 && cause.status < 500 && cause.status !== 429 || cause.code === RelayErrorCode.InvalidInput);
         if (refused) {
           forgetReferralCode();
         }
         setState({
           status: refused ? "rejected" : "failed",
           code,
-          reason: cause instanceof Error && cause.message ? cause.message : "That invitation code couldn't be used."
+          error: asRelayError(cause, "That invitation code couldn't be used.")
         });
       }
     },
-    [relay]
+    [relay, invalidate]
   );
-  useEffect8(() => {
+  useEffect7(() => {
     if (member && state.status === "pending" && started.current !== `${member}:${state.code}`) {
       started.current = `${member}:${state.code}`;
       void accept(state.code);
     }
   }, [member, state, accept]);
-  return { invitation: state, accept };
+  return useMemo9(() => ({ invitation: state, accept }), [state, accept]);
 }
 function useReferralSummary(options = {}) {
   const relay = useRelay();
-  const { member } = useExperience();
-  const [summary, setSummary] = useState9(null);
-  const [error, setError] = useState9(null);
-  const refresh = useCallback6(async () => {
-    try {
-      setSummary(await relay.referrals.summary());
-      setError(null);
-    } catch (cause) {
-      setError(
-        cause instanceof Error && cause.message ? cause.message : "Could not load your invitations."
-      );
-    }
-  }, [relay]);
-  useEffect8(() => {
-    setSummary(null);
-    if (member) {
-      void refresh();
+  const { path = "/", param = "ref", intervalMs = 6e4 } = options;
+  const query = useMemberQuery(
+    [...relayKeys.referrals, "summary"],
+    (request) => relay.referrals.summary(request),
+    { intervalMs }
+  );
+  return useMemo9(() => {
+    let link = null;
+    if (query.data && typeof window !== "undefined") {
+      const url = new URL(path, window.location.origin);
+      url.searchParams.set(param, query.data.code);
+      link = url.toString();
     }
-  }, [member, refresh]);
-  let link = null;
-  if (summary && typeof window !== "undefined") {
-    const url = new URL(options.path ?? "/", window.location.origin);
-    url.searchParams.set(options.param ?? "ref", summary.code);
-    link = url.toString();
-  }
-  return { summary, link, error, refresh };
+    return { ...query, link };
+  }, [query, path, param]);
 }
 
 // src/react/leaderboards.ts
-import { useCallback as useCallback7, useEffect as useEffect9, useState as useState10 } from "react";
 function useLeaderboard(board, options = {}) {
   const relay = useRelay();
-  const { member } = useExperience();
   const { limit = 25, intervalMs = 3e4 } = options;
-  const [state, setState] = useState10({ status: "loading" });
-  const refresh = useCallback7(async () => {
-    try {
-      const page = await relay.leaderboards.standings(board, { limit });
-      setState({ status: "ready", page, stale: null });
-    } catch (cause) {
-      const message = cause instanceof Error && cause.message ? cause.message : "Could not load the leaderboard.";
-      setState(
-        (previous) => previous.status === "ready" ? { ...previous, stale: message } : { status: "error", message }
-      );
-    }
-  }, [relay, board, limit]);
-  useEffect9(() => {
-    void refresh();
-    const timer = setInterval(() => {
-      if (document.visibilityState === "visible") {
-        void refresh();
+  return useRelayQuery(
+    [...relayKeys.leaderboards, board, "standings", limit],
+    (request) => relay.leaderboards.standings(board, { limit }, request),
+    { intervalMs }
+  );
+}
+
+// src/react/balances.ts
+function useBalances() {
+  const relay = useRelay();
+  return useMemberQuery(
+    relayKeys.balances,
+    (options) => relay.me.balances(options)
+  );
+}
+function usePointHistory(ledger) {
+  const relay = useRelay();
+  return useMemberPages(
+    [...relayKeys.balances, "history", ledger],
+    ({ cursor, ...options }) => relay.me.pointHistory(cursor ? { ledger, cursor } : { ledger }, options)
+  );
+}
+
+// src/react/outcomes.ts
+function useQuestOutcomes(query = {}) {
+  const relay = useRelay();
+  const { quest, state, code } = query;
+  return useMemberPages(
+    [...relayKeys.outcomes, quest ?? "", state ?? "", code ?? ""],
+    ({ cursor, ...options }) => relay.quests.outcomes(
+      {
+        ...quest ? { quest } : {},
+        ...state ? { state } : {},
+        ...code ? { code } : {},
+        ...cursor ? { cursor } : {}
+      },
+      options
+    )
+  );
+}
+
+// src/react/offers.ts
+import { useCallback as useCallback7, useState as useState8 } from "react";
+function useOffers() {
+  const relay = useRelay();
+  return useRelayQuery(
+    relayKeys.offers,
+    (options) => relay.offers.list(options)
+  );
+}
+function useRedeemOffer() {
+  const relay = useRelay();
+  const invalidate = useInvalidate();
+  const [busy, setBusy] = useState8(false);
+  const [error, setError] = useState8(null);
+  const redeem = useCallback7(
+    async (offer) => {
+      if (busy) {
+        return null;
+      }
+      setBusy(true);
+      setError(null);
+      try {
+        const redemption = await relay.offers.redeem(offer);
+        await invalidate([relayKeys.offers, relayKeys.balances]);
+        return redemption;
+      } catch (cause) {
+        setError(asRelayError(cause, "This offer could not be redeemed."));
+        return null;
+      } finally {
+        setBusy(false);
       }
-    }, intervalMs);
-    return () => clearInterval(timer);
-  }, [refresh, member, intervalMs]);
-  return { ...state, refresh };
+    },
+    [busy, invalidate, relay]
+  );
+  return { redeem, busy, error };
 }
 
 // src/react/references.ts
-import { useCallback as useCallback8, useEffect as useEffect10, useState as useState11 } from "react";
-function useReferences(read, failure) {
-  const relay = useRelay();
-  const [state, setState] = useState11({ status: "loading" });
-  const refresh = useCallback8(async () => {
-    try {
-      setState({ status: "ready", items: await read(relay) });
-    } catch (cause) {
-      setState({
-        status: "error",
-        message: cause instanceof Error && cause.message ? cause.message : failure
-      });
-    }
-  }, [relay, read, failure]);
-  useEffect10(() => {
-    void refresh();
-  }, [refresh]);
-  return { ...state, refresh };
-}
-var readPointLedgers = (relay) => relay.pointLedgers.list();
-var readTieredRewards = (relay) => relay.tieredRewards.list();
 function usePointLedgers() {
-  return useReferences(readPointLedgers, "Could not load point ledgers.");
+  const relay = useRelay();
+  return useRelayQuery(
+    relayKeys.pointLedgers,
+    (options) => relay.pointLedgers.list(options)
+  );
 }
 function useTieredRewards() {
-  return useReferences(readTieredRewards, "Could not load tiered rewards.");
+  const relay = useRelay();
+  return useRelayQuery(
+    relayKeys.tieredRewards,
+    (options) => relay.tieredRewards.list(options)
+  );
 }
 export {
-  PENDING_POLL_MS,
-  PROFILE_CHANGED,
-  RETRY_DELAYS_MS,
   RelayProvider,
-  avatarSrc,
   canRepeat,
   canSubmit,
   captureReferralCode,
-  completionCountLabel,
-  completionMark,
-  defaultAvatar,
-  hasPending,
+  completionCountText,
   isAutomatic,
   isConnected,
   isFinished,
   progressOf,
   questGroups,
   questStatus,
+  questStatusText,
+  relayKeys,
   roleDeliveryLabel,
-  runsSilently,
-  sanitizeDeliveries,
+  roleDeliveryStatus,
   useAccounts,
+  useActivity,
+  useBalances,
+  useDeliveries,
+  useEntitlements,
   useExperience,
+  useInvalidate,
   useInvitation,
   useLeaderboard,
   useLeaderboardPlacement,
   useMe,
+  useMemberPages,
+  useMemberQuery,
   useMyProfile,
+  useOffers,
+  usePointHistory,
   usePointLedgers,
   useProfile,
   useProfileCompletions,
   useProfileReferral,
   useQuest,
+  useQuestOutcomes,
+  useRedeemOffer,
   useReferralSummary,
   useRelay,
+  useRelayPages,
+  useRelayQuery,
+  useSession,
   useSignIn,
   useSignInMethods,
   useSignInOptions,
@@ -1333,8 +2188,5 @@ export {
   useSignOut,
   useTieredRewards,
   useWalletDiscovery,
-  useWallets,
-  visibleQuests,
-  walletAvatarSeed,
-  watchRoleDeliveries
+  useWallets
 };