@domino-sdk/relay 1.11.1 → 1.14.0

package/dist/react/index.js

@@ -8,23 +8,25 @@ import {
   discoverSolanaWallets,
   readSignInMethods,
   signInOptionsFrom
-} from "../chunk-PUDL4JBY.js";
-import "../chunk-XK5E4HAS.js";
+} from "../chunk-6DD7DVNQ.js";
+import "../chunk-VBHFJH3P.js";
 import {
   createRelayAction
-} from "../chunk-X7ECZ3AK.js";
-import "../chunk-T657WO56.js";
+} from "../chunk-XMBM2XD5.js";
+import "../chunk-LLMJ2SUT.js";
+import "../chunk-UJACD6K2.js";
 import {
   RelayError,
   RelayErrorCode,
   asRelayError,
+  clientError,
   isRelayError
-} from "../chunk-ZFABFKIY.js";
+} from "../chunk-2UAVZCMH.js";
 import "../chunk-6QJ3LADK.js";
 import {
   isRequestError
 } from "../chunk-NPGENI7K.js";
-import "../chunk-AGFUDCNM.js";
+import "../chunk-C3CB4WIQ.js";
 import {
   sessionMember
 } from "../chunk-PT5STHFH.js";
@@ -70,35 +72,41 @@ var QueryCache = class {
   get disposed() {
     return this.#disposed;
   }
-  snapshot(key) {
-    return this.#entries.get(hashKey(key))?.state ?? LOADING;
+  snapshot(key, fallback = LOADING) {
+    return this.#entries.get(hashKey(key))?.state ?? fallback;
   }
-  /** Starts observing `key`, reading it now unless a read is cached or in flight. */
-  subscribe(key, read, options, listener) {
-    if (this.#disposed) {
-      return () => {
-      };
-    }
+  /** The entry for `key`, created with `seed` as its value when there is none yet. */
+  #entry(key, read, seed) {
     const hash = hashKey(key);
     let entry = this.#entries.get(hash);
     if (!entry) {
       entry = {
         key,
         read,
-        state: LOADING,
+        state: seed ? { status: "ready", data: seed.data, error: null } : LOADING,
         listeners: /* @__PURE__ */ new Set(),
         intervals: /* @__PURE__ */ new Map(),
         focus: /* @__PURE__ */ new Set(),
+        stale: /* @__PURE__ */ new Map(),
         controller: null,
         pending: null,
-        settledAt: 0,
+        settledAt: seed?.at ?? 0,
         version: 0,
         timer: void 0,
         unused: void 0
       };
       this.#entries.set(hash, entry);
     }
-    const current = entry;
+    return entry;
+  }
+  /** Starts observing `key`, reading it now unless a read is cached or in flight. */
+  subscribe(key, read, options, listener, seed) {
+    if (this.#disposed) {
+      return () => {
+      };
+    }
+    const hash = hashKey(key);
+    const current = this.#entry(key, read, seed);
     const token = {};
     const unseen = current.listeners.size === 0;
     current.read = read;
@@ -110,7 +118,11 @@ var QueryCache = class {
     if (options.refetchOnFocus) {
       current.focus.add(token);
     }
-    if (!current.pending && (current.settledAt === 0 || unseen && Date.now() - current.settledAt >= STALE_MS)) {
+    if (options.staleMs !== void 0 && options.staleMs >= 0) {
+      current.stale.set(token, options.staleMs);
+    }
+    const staleMs = current.stale.size > 0 ? Math.min(...current.stale.values()) : STALE_MS;
+    if (!current.pending && (current.settledAt === 0 || unseen && Date.now() - current.settledAt >= staleMs)) {
       void this.#fetch(current, false);
     } else {
       this.#schedule(current);
@@ -119,6 +131,7 @@ var QueryCache = class {
       current.listeners.delete(listener);
       current.intervals.delete(token);
       current.focus.delete(token);
+      current.stale.delete(token);
       if (current.listeners.size === 0 && !this.#disposed) {
         clearTimeout(current.timer);
         current.unused = setTimeout(() => {
@@ -129,6 +142,29 @@ var QueryCache = class {
       }
     };
   }
+  /**
+   * Reads `key` unless it has a value or a read in flight, for a component that suspends until it
+   * has one: settles when the read does. A value nobody comes to show is forgotten like any other.
+   */
+  ensure(key, read, seed) {
+    if (this.#disposed) {
+      return Promise.resolve();
+    }
+    const hash = hashKey(key);
+    const entry = this.#entry(key, read, seed);
+    if (entry.listeners.size === 0) {
+      clearTimeout(entry.unused);
+      entry.unused = setTimeout(() => {
+        if (entry.listeners.size === 0) {
+          this.#drop(hash, entry);
+        }
+      }, UNUSED_MS);
+    }
+    if (entry.pending) {
+      return entry.pending;
+    }
+    return entry.settledAt === 0 ? this.#fetch(entry, false) : Promise.resolve();
+  }
   /** Reads `key` again now, replacing any read in flight. */
   refresh(key) {
     const entry = this.#entries.get(hashKey(key));
@@ -173,12 +209,13 @@ var QueryCache = class {
   }
   /**
    * 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.
+   * may have started before the change. Does nothing for a key nobody has read. Returns whether it
+   * applied.
    */
   set(key, data) {
     const entry = this.#entries.get(hashKey(key));
     if (this.#disposed || !entry) {
-      return;
+      return false;
     }
     entry.controller?.abort();
     entry.controller = null;
@@ -187,6 +224,7 @@ var QueryCache = class {
     entry.settledAt = Date.now();
     this.#write(entry, { status: "ready", data, error: null });
     this.#schedule(entry);
+    return true;
   }
   version(key) {
     return this.#entries.get(hashKey(key))?.version ?? -1;
@@ -394,13 +432,26 @@ function useActivity(options = {}) {
 
 // src/react/action.ts
 import { useCallback as useCallback2, useRef as useRef2, useState as useState2 } from "react";
+var IDLE = Object.freeze({
+  status: "idle",
+  data: void 0,
+  error: null
+});
+function actionError(cause) {
+  return isRequestError(cause) && !isRelayError(cause) ? new RelayError(cause.message, {
+    kind: cause.kind,
+    status: cause.status,
+    code: cause.code,
+    uncertain: cause.uncertain,
+    operationId: cause.operationId,
+    replaySafe: cause.recovery === "replay",
+    retryAfter: cause.retryAfter,
+    cause
+  }) : asRelayError(cause);
+}
 function useRelayAction(scope) {
   const owner = useRef2({ scope, action: createRelayAction() });
-  const [state, setState] = useState2({
-    owner: owner.current,
-    busy: false,
-    error: null
-  });
+  const [state, setState] = useState2({ owner: owner.current, ...IDLE });
   if (owner.current.scope !== scope) {
     owner.current = { scope, action: createRelayAction() };
   }
@@ -411,33 +462,29 @@ function useRelayAction(scope) {
         return { ok: false };
       }
       const result = task ? current2.action.run(task) : current2.action.retry();
-      setState({ owner: current2, busy: true, error: null });
+      setState({
+        owner: current2,
+        status: "pending",
+        data: void 0,
+        error: null
+      });
       try {
         const value = await result;
         if (owner.current === current2) {
-          setState({ owner: current2, busy: false, error: null });
+          setState({
+            owner: current2,
+            status: "success",
+            data: value,
+            error: null
+          });
         }
         return { ok: true, value };
       } catch (caught) {
+        const error = actionError(current2.action.error ?? caught);
         if (owner.current === current2) {
-          const cause = current2.action.error ?? caught;
-          const error = isRequestError(cause) && !isRelayError(cause) ? new RelayError(cause.message, {
-            kind: cause.kind,
-            status: cause.status,
-            code: cause.code,
-            uncertain: cause.uncertain,
-            operationId: cause.operationId,
-            replaySafe: cause.recovery === "replay",
-            retryAfter: cause.retryAfter,
-            cause
-          }) : asRelayError(cause);
-          setState({
-            owner: current2,
-            busy: false,
-            error
-          });
+          setState({ owner: current2, status: "error", data: void 0, error });
         }
-        return { ok: false };
+        return { ok: false, error };
       }
     },
     []
@@ -448,31 +495,232 @@ function useRelayAction(scope) {
     if (!current2.action.settle()) {
       return false;
     }
-    setState({ owner: current2, busy: false, error: null });
+    setState({ owner: current2, ...IDLE });
     return true;
   }, []);
-  const current = state.owner === owner.current ? state : { busy: false, error: null };
+  const reset = useCallback2(() => {
+    const current2 = owner.current;
+    if (!current2.action.busy && current2.action.actionId === void 0) {
+      setState({ owner: current2, ...IDLE });
+    }
+  }, []);
+  const current = state.owner === owner.current ? state : IDLE;
+  const isPending = current.status === "pending";
   return {
     run: execute,
     retry,
     settle,
-    busy: current.busy,
-    error: current.error
+    reset,
+    status: current.status,
+    isPending,
+    data: current.data,
+    error: current.error,
+    /** @deprecated Use `isPending`. Removed in 2.0.0. */
+    busy: isPending
   };
 }
 
-// src/react/provider.tsx
-import { useEffect as useEffect3, useMemo as useMemo2 } from "react";
+// src/react/mutation.ts
+import { useCallback as useCallback4, useLayoutEffect as useLayoutEffect3, useMemo as useMemo2, useRef as useRef4 } from "react";
 
-// src/react/experience.tsx
+// src/react/query.ts
 import {
-  createContext as createContext2,
   useCallback as useCallback3,
-  useContext as useContext2,
+  useEffect as useEffect2,
+  useLayoutEffect as useLayoutEffect2,
   useMemo,
+  useRef as useRef3,
+  useState as useState3,
   useSyncExternalStore as useSyncExternalStore2
 } from "react";
 
+// src/react/feed.ts
+function feedOwner(session) {
+  return JSON.stringify([
+    session.organization,
+    session.project,
+    session.environment,
+    sessionMember(session)
+  ]);
+}
+var ActivityFeed = class {
+  /** The provider scope the feed was started for. */
+  scope;
+  owner;
+  #client;
+  #intervalMs;
+  #on;
+  #observer = null;
+  #generation = {};
+  #session;
+  #cursor;
+  /** The feed knows where it starts: events from now on are new. */
+  #ready = false;
+  /** A read answered since the feed (re)started. */
+  #answered = false;
+  #disposed = false;
+  /** When a read last answered, for a focus that should not read again so soon. */
+  settledAt = 0;
+  constructor(client, session, options, on) {
+    this.scope = options.scope;
+    this.owner = feedOwner(session);
+    this.#client = client;
+    this.#session = session.id;
+    this.#intervalMs = options.intervalMs;
+    this.#on = on;
+    this.#start(options.cursor, session);
+  }
+  /** The cursor after the last events read, for the same member's next session. */
+  get cursor() {
+    return this.#cursor;
+  }
+  /** True once the feed knows where it starts. */
+  get ready() {
+    return this.#ready;
+  }
+  refresh() {
+    return this.#observer?.refresh() ?? Promise.resolve();
+  }
+  dispose() {
+    this.#disposed = true;
+    this.#observer?.dispose();
+    this.#observer = null;
+  }
+  #start(cursor, session) {
+    this.#observer?.dispose();
+    const generation = {};
+    this.#generation = generation;
+    this.#cursor = cursor;
+    this.#ready = cursor !== void 0;
+    this.#answered = false;
+    this.#observer = this.#client.me.activity.observe(() => {
+    }, {
+      cursor,
+      // Without a cursor, and whenever the client drops it for another session, start from the
+      // newest event rather than replay the member's history.
+      start: "latest",
+      // The provider knows the session: the first poll reads the feed at once.
+      session,
+      intervalMs: this.#intervalMs,
+      maxBackoffMs: Math.max(6e4, this.#intervalMs),
+      onState: (state) => {
+        if (!this.#disposed && this.#generation === generation) {
+          this.#observe(state, cursor !== void 0);
+        }
+      }
+    });
+  }
+  #observe(state, carried) {
+    switch (state.kind) {
+      case "loading":
+        return;
+      case "session": {
+        const session = state.session;
+        if ((session?.id ?? null) === this.#session) {
+          return;
+        }
+        if (session && feedOwner(session) === this.owner) {
+          this.#session = session.id;
+          this.#start(this.#cursor, session);
+        } else {
+          this.dispose();
+        }
+        this.#on.session(session);
+        return;
+      }
+      case "ready":
+        this.settledAt = Date.now();
+        this.#answered = true;
+        this.#cursor = state.progress.nextCursor;
+        if (this.#ready) {
+          this.#on.events(state.progress.items);
+        } else {
+          this.#ready = true;
+        }
+        return;
+      case "error": {
+        this.settledAt = Date.now();
+        const error = relayError(state.error);
+        const status = error.kind === "http" ? error.status : void 0;
+        if (status === 400 && !this.#answered && carried) {
+          this.#start(void 0);
+        } else if (status === 404 || status === 400 && !this.#answered) {
+          this.#on.missing();
+        }
+        return;
+      }
+      default: {
+        const _exhaustive = state;
+        return _exhaustive;
+      }
+    }
+  }
+};
+
+// src/react/keys.ts
+var relayKeys = {
+  /** `useExperience`: invalidating it reads the quest experience again. */
+  experience: ["experience"],
+  /** `useMe`. */
+  me: ["me"],
+  /** `useAccounts`. */
+  accounts: ["accounts"],
+  /** `useWallets`. */
+  wallets: ["wallets"],
+  /** `useMyProfile`, `useProfile`, `useProfileCompletions`, `useProfileReferral`. */
+  profiles: ["profiles"],
+  /** `useLeaderboard`, `useLeaderboardPlacement`. */
+  leaderboards: ["leaderboards"],
+  /** `useReferralSummary`. */
+  referrals: ["referrals"],
+  /** `usePointLedgers`. */
+  pointLedgers: ["point-ledgers"],
+  /** `useTieredRewards`. */
+  tieredRewards: ["tiered-rewards"],
+  /** `useSignInMethods`. */
+  signInMethods: ["sign-in-methods"],
+  /** `useEntitlements`, `useDeliveries`. */
+  rewards: ["rewards"],
+  /** `useBalances`, `usePointHistory`. */
+  balances: ["balances"],
+  /** `useQuestOutcomes`. */
+  outcomes: ["outcomes"],
+  /** `useOffers`, `useRedeemOffer`. */
+  offers: ["offers"]
+};
+var rewardKeys = {
+  entitlements: [...relayKeys.rewards, "entitlements"],
+  deliveries: [...relayKeys.rewards, "deliveries"]
+};
+var completionChanges = [
+  relayKeys.rewards,
+  relayKeys.balances,
+  relayKeys.leaderboards,
+  relayKeys.profiles,
+  relayKeys.referrals,
+  relayKeys.offers
+];
+var activityChanges = {
+  "attempt.accepted": [
+    relayKeys.experience,
+    relayKeys.outcomes,
+    ...completionChanges
+  ],
+  "attempt.rejected": [relayKeys.experience, relayKeys.outcomes],
+  "attempt.review": [relayKeys.experience, relayKeys.outcomes],
+  "points.awarded": [
+    relayKeys.balances,
+    relayKeys.leaderboards,
+    relayKeys.offers,
+    rewardKeys.deliveries
+  ],
+  "entitlement.granted": [relayKeys.experience, relayKeys.rewards],
+  "entitlement.collected": [relayKeys.experience, relayKeys.rewards],
+  "delivery.updated": [rewardKeys.deliveries],
+  "referral.qualified": [relayKeys.referrals, relayKeys.profiles],
+  unknown: [relayKeys.experience]
+};
+
 // src/react/role-delivery.ts
 function sanitizeDeliveries(deliveries) {
   return deliveries.map(({ quest, status, revokedAt, reconciliation }) => ({
@@ -578,113 +826,6 @@ function watchRoleDeliveries(options) {
   };
 }
 
-// src/react/use-role-deliveries.ts
-import { useEffect as useEffect2, useState as useState3 } from "react";
-var NONE = Object.freeze([]);
-function useRoleDeliveries(relay, member, completions) {
-  const [state, setState] = useState3(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 = useCallback3(() => 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.completion.kind !== "progress" && view.completed;
@@ -956,6 +1097,9 @@ function scopeKey(session) {
 function isVisible() {
   return typeof document === "undefined" || document.visibilityState !== "hidden";
 }
+var ACTIVITY_MS = 5e3;
+var SNAPSHOT_MS = 3e4;
+var FOCUS_GAP_MS = 2e3;
 var RelayStore = class {
   client;
   #session = LOADING;
@@ -971,8 +1115,28 @@ var RelayStore = class {
   #sessionRead = null;
   /** The completions the experience last showed, and for whom. */
   #completions = null;
-  constructor(client) {
+  #polling;
+  #feed = null;
+  /** Relay answered that it has no activity feed: the experience observer carries on alone. */
+  #feedMissing = false;
+  /**
+   * The experience read in flight was asked for by an `attempt.accepted` event, which already
+   * read what a completion changes.
+   */
+  #readForAcceptance = false;
+  /** The latest experience read the store asked for. */
+  #experienceRead = Promise.resolve();
+  #shownAt = 0;
+  #focusReadAt = 0;
+  /** The first cache of this mount: a public read's `initialData` seeds only it. */
+  #firstCache = null;
+  #settled = null;
+  constructor(client, polling = {}) {
     this.client = client;
+    this.#polling = {
+      activityMs: polling.activityMs ?? ACTIVITY_MS,
+      snapshotMs: polling.snapshotMs ?? SNAPSHOT_MS
+    };
   }
   /** `refreshSession` with one identity per store, for hooks to hand out as `refresh`. */
   rereadSession = () => this.refreshSession();
@@ -991,23 +1155,41 @@ var RelayStore = class {
   get experience() {
     return this.#experienceView;
   }
+  /** The first query cache of this mount, the only one a public read's `initialData` seeds. */
+  get firstCache() {
+    return this.#firstCache;
+  }
+  /** Settles once the session is known (or failed to read), for a component that suspends. */
+  settled() {
+    if (this.#session.status !== "loading") {
+      return Promise.resolve();
+    }
+    if (!this.#settled) {
+      let resolve = () => {
+      };
+      const promise = new Promise((done) => {
+        resolve = done;
+      });
+      this.#settled = { promise, resolve };
+    }
+    return this.#settled.promise;
+  }
   /** Starts observing; the returned function stops every read, timer and listener. */
   mount() {
     this.#mounted = true;
-    if (isVisible()) {
-      this.#startObserver();
-    }
+    this.#feedMissing = false;
+    this.#startObserver();
     void this.refreshSession();
     const onVisibility = () => {
       if (isVisible()) {
-        this.#startObserver();
+        this.#shownAt = Date.now();
         this.#scope?.cache.resume();
-      } else {
-        this.#observer?.dispose();
-        this.#observer = null;
       }
     };
-    const onFocus = () => this.#scope?.cache.focus();
+    const onFocus = () => {
+      this.#scope?.cache.focus();
+      this.#readOnFocus();
+    };
     if (typeof window !== "undefined") {
       document.addEventListener("visibilitychange", onVisibility);
       window.addEventListener("focus", onFocus);
@@ -1020,11 +1202,13 @@ var RelayStore = class {
       }
       this.#observer?.dispose();
       this.#observer = null;
+      this.#stopFeed();
       this.#sessionRead?.abort();
       this.#sessionRead = null;
       this.#sessionVersion++;
       this.#scope?.cache.dispose();
       this.#scope = null;
+      this.#firstCache = null;
       this.#session = LOADING;
       this.#experience = { owner: null, state: LOADING };
       this.#emit();
@@ -1078,8 +1262,21 @@ var RelayStore = class {
     this.#setSession({ status: "ready", data: null, error: null });
     this.#emit();
   }
-  refreshExperience() {
-    return this.#observer?.refresh() ?? Promise.resolve();
+  /**
+   * Reads the experience again. With a feed, it is read first: the events it finds read the
+   * experience and whatever else they changed, so a change the participant just made shows its
+   * effects at once, and the experience is read only once.
+   */
+  async refreshExperience() {
+    const feed = this.#feed;
+    if (feed?.ready) {
+      const before = this.#experienceRead;
+      await feed.refresh();
+      if (this.#experienceRead !== before) {
+        return this.#experienceRead;
+      }
+    }
+    return this.#readExperience(false);
   }
   /**
    * Marks queries out of date (see `QueryCache.invalidate`). The `["experience"]` key, or no keys at
@@ -1094,90 +1291,179 @@ var RelayStore = class {
     return Promise.all(reads).then(() => {
     });
   }
+  #readExperience(forAcceptance) {
+    this.#readForAcceptance = forAcceptance && isVisible();
+    this.#experienceRead = this.#observer?.refresh() ?? Promise.resolve();
+    return this.#experienceRead;
+  }
+  /** The window regained focus: read for changes, unless that just happened. */
+  #readOnFocus() {
+    const now = Date.now();
+    const last = Math.max(
+      this.#shownAt,
+      this.#focusReadAt,
+      this.#feed?.settledAt ?? 0
+    );
+    if (now - last < FOCUS_GAP_MS || !this.#scope) {
+      return;
+    }
+    this.#focusReadAt = now;
+    if (this.#feed) {
+      void this.#feed.refresh();
+    } else if (!this.#scope.member) {
+      void this.refreshSession();
+    }
+    if (this.#scope.member && (!this.#feed || this.#experience.state.error)) {
+      void this.#readExperience(false);
+    }
+  }
+  /** Follows the signed-in member's activity feed while there is one; stops it otherwise. */
+  #syncFeed() {
+    const scope = this.#scope;
+    const available = typeof this.client.me?.activity?.observe === "function";
+    const wanted = this.#mounted && available && !this.#feedMissing && scope?.member ? scope : null;
+    const previous = this.#feed;
+    if (previous && previous.scope === wanted?.key) {
+      return;
+    }
+    this.#stopFeed();
+    if (!wanted?.session) {
+      return;
+    }
+    const feed = new ActivityFeed(
+      this.client,
+      wanted.session,
+      {
+        scope: wanted.key,
+        intervalMs: this.#polling.activityMs,
+        // The same member's new session carries on where the last one left off.
+        cursor: previous?.owner === feedOwner(wanted.session) ? previous.cursor : void 0
+      },
+      {
+        events: (events) => this.#applyEvents(events),
+        session: () => void this.refreshSession(),
+        missing: () => {
+          this.#feedMissing = true;
+          this.#stopFeed();
+        }
+      }
+    );
+    this.#feed = feed;
+  }
+  #stopFeed() {
+    const feed = this.#feed;
+    this.#feed = null;
+    feed?.dispose();
+  }
+  /** Reads again, once each, the queries the events change. */
+  #applyEvents(events) {
+    const keys = /* @__PURE__ */ new Map();
+    for (const event of events) {
+      for (const key of activityChanges[event.kind] ?? activityChanges.unknown) {
+        keys.set(hashKey(key), key);
+      }
+    }
+    if (keys.delete(hashKey(relayKeys.experience))) {
+      void this.#readExperience(
+        events.some((event) => event.kind === "attempt.accepted")
+      );
+    }
+    if (keys.size > 0) {
+      void this.#scope?.cache.invalidate([...keys.values()]);
+    }
+  }
   #startObserver() {
     if (this.#observer || !this.#mounted) {
       return;
     }
     this.#starting = true;
+    const { snapshotMs } = this.#polling;
     try {
-      this.#observer = this.client.quests.observe((observation) => {
-        switch (observation.kind) {
-          case "loading":
-            if (this.#starting) {
+      this.#observer = this.client.quests.observe(
+        (observation) => {
+          switch (observation.kind) {
+            case "loading":
+              this.#readForAcceptance = false;
+              if (this.#starting) {
+                return;
+              }
+              this.#sessionVersion++;
+              this.#sessionRead?.abort();
               return;
-            }
-            this.#sessionVersion++;
-            this.#sessionRead?.abort();
-            return;
-          case "session":
-            this.#sessionVersion++;
-            this.#setSession({
-              status: "ready",
-              data: observation.session,
-              error: null
-            });
-            break;
-          case "ready":
-            this.#sessionVersion++;
-            this.#setSession({
-              status: "ready",
-              data: observation.session,
-              error: null
-            });
-            this.#completed(observation.progress);
-            this.#experience = {
-              owner: observation.progress.member,
-              state: {
+            case "session":
+              this.#sessionVersion++;
+              this.#setSession({
+                status: "ready",
+                data: observation.session,
+                error: null
+              });
+              break;
+            case "ready":
+              this.#sessionVersion++;
+              this.#setSession({
                 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)
-                    })
-                  )
-                },
+                data: observation.session,
                 error: null
+              });
+              this.#completed(observation.progress, this.#readForAcceptance);
+              this.#readForAcceptance = false;
+              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 }
+              };
+              if (this.#session.status === "loading") {
+                void this.refreshSession();
               }
-            };
-            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 }
-            };
-            if (this.#session.status === "loading") {
-              void this.refreshSession();
+              break;
             }
-            break;
           }
-        }
-        this.#emit();
-      });
+          this.#emit();
+        },
+        // A failed read retries within seconds, not after the slow interval.
+        { intervalMs: snapshotMs, maxBackoffMs: snapshotMs, retryMs: 3e3 }
+      );
     } finally {
       this.#starting = false;
     }
   }
   /**
    * 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.
+   * the participant submitted it or Domino completed it by itself: read them again, unless the
+   * `attempt.accepted` event that asked for this read already did.
    */
-  #completed(progress) {
+  #completed(progress, alreadyRead) {
     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) {
+    if (previous?.member === progress.member && previous.mark !== mark && !alreadyRead) {
       void this.#scope?.cache.invalidate(completionChanges);
     }
   }
@@ -1195,6 +1481,7 @@ var RelayStore = class {
     this.#scope?.cache.dispose();
     if (key === null) {
       this.#scope = null;
+      this.#syncFeed();
       return;
     }
     const session = next.status === "ready" ? next.data : null;
@@ -1204,6 +1491,8 @@ var RelayStore = class {
       member: sessionMember(session),
       cache: new QueryCache(session?.id, () => void this.refreshSession())
     };
+    this.#firstCache ??= this.#scope.cache;
+    this.#syncFeed();
   }
   #deriveExperience() {
     const session = this.#session;
@@ -1221,6 +1510,10 @@ var RelayStore = class {
   }
   #emit() {
     const experience = this.#deriveExperience();
+    if (this.#settled && this.#session.status !== "loading") {
+      this.#settled.resolve();
+      this.#settled = null;
+    }
     if (experience !== this.#experienceView) {
       this.#experienceView = experience;
     }
@@ -1230,35 +1523,7 @@ var RelayStore = class {
   }
 };
 
-// src/react/provider.tsx
-import { jsx as jsx2 } from "react/jsx-runtime";
-function RelayProvider({
-  client,
-  baseUrl = "/relay",
-  children
-}) {
-  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 useCallback4,
-  useEffect as useEffect4,
-  useLayoutEffect as useLayoutEffect2,
-  useMemo as useMemo3,
-  useRef as useRef3,
-  useState as useState4,
-  useSyncExternalStore as useSyncExternalStore3
-} from "react";
 function useLatest(value) {
   const ref = useRef3(value);
   useLayoutEffect2(() => {
@@ -1268,17 +1533,34 @@ function useLatest(value) {
 }
 function useSessionSnapshot(store) {
   const get = () => store.session;
-  return useSyncExternalStore3(store.subscribe, get, get);
+  return useSyncExternalStore2(store.subscribe, get, get);
 }
 function useScope(store) {
   const get = () => store.scope;
-  return useSyncExternalStore3(store.subscribe, get, get);
+  return useSyncExternalStore2(store.subscribe, get, get);
+}
+function isInitializer(value) {
+  return typeof value === "function";
 }
-function useCached(cache, key, read, options) {
+function useSeed(key, initialData) {
   const hash = key ? hashKey(key) : null;
-  const { intervalMs, refetchOnFocus } = options;
-  const latest = useLatest({ key, read });
-  const subscribe = useCallback4(
+  return useMemo(() => {
+    if (initialData === void 0) {
+      return null;
+    }
+    const data = isInitializer(initialData) ? initialData() : initialData;
+    return {
+      seed: { data, at: Date.now() },
+      shown: { status: "ready", data, error: null }
+    };
+  }, [hash]);
+}
+function useCached(cache, key, read, options, seeded = null) {
+  const { intervalMs, refetchOnFocus, staleMs } = options;
+  const active = options.enabled === false ? null : key;
+  const hash = active ? hashKey(active) : null;
+  const latest = useLatest({ key: active, read });
+  const subscribe = useCallback3(
     (listener) => {
       const { key: current } = latest.current;
       if (!cache || !current) {
@@ -1288,41 +1570,89 @@ function useCached(cache, key, read, options) {
       return cache.subscribe(
         current,
         (context) => latest.current.read(context),
-        { intervalMs, refetchOnFocus },
-        listener
+        { intervalMs, refetchOnFocus, staleMs },
+        listener,
+        seeded?.seed
       );
     },
     // `hash` stands for the key.
-    [cache, hash, intervalMs, refetchOnFocus]
+    [cache, hash, intervalMs, refetchOnFocus, staleMs, seeded]
   );
-  const get = () => cache && key ? cache.snapshot(key) : LOADING;
-  const snapshot = useSyncExternalStore3(subscribe, get, get);
-  const refresh = useCallback4(
+  const get = () => {
+    const fallback = seeded?.shown ?? LOADING;
+    return cache && active ? cache.snapshot(active, fallback) : fallback;
+  };
+  const snapshot = useSyncExternalStore2(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]);
+  return useMemo(() => ({ ...snapshot, refresh }), [snapshot, refresh]);
+}
+function selected(query, select) {
+  return query.status === "ready" ? { ...query, data: select(query.data) } : query;
+}
+function suspend(query, store, cache, key, read, seed) {
+  if (query.status === "error") {
+    throw query.error;
+  }
+  if (query.status !== "loading" || !key) {
+    return;
+  }
+  if (typeof window === "undefined") {
+    throw new Error("Domino suspense queries read in the browser");
+  }
+  throw cache ? cache.ensure(key, read, seed) : store.settled();
 }
 function useRelayQuery(key, read, options = {}) {
   const store = useStore();
   const scope = useScope(store);
-  return useCached(scope?.cache ?? null, key, read, options);
+  const cache = scope?.cache ?? null;
+  const seeded = useSeed(key, options.initialData);
+  const seed = !cache || cache === store.firstCache ? seeded : null;
+  const query = useCached(cache, key, read, options, seed);
+  const { select } = options;
+  if (options.suspense) {
+    suspend(
+      query,
+      store,
+      cache,
+      options.enabled === false ? null : key,
+      read,
+      seed?.seed
+    );
+  }
+  return useMemo(
+    () => select ? selected(query, select) : query,
+    [query, select]
+  );
 }
 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
+  const cache = member ? scope.cache : null;
+  const query = useCached(cache, member ? key : null, read, options);
+  const gated = useMemberGate(store, member, query);
+  if (options.suspense) {
+    suspend(
+      gated,
+      store,
+      cache,
+      options.enabled === false ? null : key,
+      read,
+      void 0
+    );
+  }
+  const { select } = options;
+  return useMemo(
+    () => select ? selected(gated, select) : gated,
+    [gated, select]
   );
-  return useMemberGate(store, member, query);
 }
 function useMemberGate(store, member, query) {
   const session = useSessionSnapshot(store);
-  return useMemo3(() => {
+  return useMemo(() => {
     if (session.status === "loading") {
       return { ...LOADING, refresh: query.refresh };
     }
@@ -1337,7 +1667,8 @@ function useMemberGate(store, member, query) {
     return member ? query : { ...SIGNED_OUT, refresh: query.refresh };
   }, [session, member, query, store]);
 }
-function usePages(cache, key, read, options) {
+function usePages(cache, requested, read, options) {
+  const key = options.enabled === false ? null : requested;
   const hash = key ? hashKey(key) : null;
   const query = useCached(
     cache,
@@ -1345,17 +1676,17 @@ function usePages(cache, key, read, options) {
     (context) => read(context),
     options
   );
-  const [more, setMore] = useState4(null);
+  const [more, setMore] = useState3(null);
   const busy = useRef3(null);
   const latest = useLatest({ key, read, query });
-  useEffect4(
+  useEffect2(
     () => () => {
       busy.current?.abort();
       busy.current = null;
     },
     [cache, hash]
   );
-  const loadMore = useCallback4(async () => {
+  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;
@@ -1391,7 +1722,7 @@ function usePages(cache, key, read, options) {
     }
   }, [cache, hash]);
   const mine = more && more.owner.cache === cache && more.owner.hash === hash ? more : null;
-  return useMemo3(
+  return useMemo(
     () => ({
       ...query,
       loadMore,
@@ -1417,7 +1748,7 @@ function useMemberPages(key, read, options = {}) {
     options
   );
   const gate = useMemberGate(store, member, pages);
-  return useMemo3(
+  return useMemo(
     () => gate === pages ? pages : {
       ...gate,
       loadMore: pages.loadMore,
@@ -1429,13 +1760,33 @@ function useMemberPages(key, read, options = {}) {
 }
 function useInvalidate() {
   const store = useStore();
-  return useCallback4((keys = []) => store.invalidate(keys), [store]);
+  return useCallback3((keys = []) => store.invalidate(keys), [store]);
+}
+function isUpdater(update) {
+  return typeof update === "function";
+}
+function useSetQueryData() {
+  const store = useStore();
+  return useCallback3(
+    (key, update) => {
+      const cache = store.scope?.cache;
+      if (!cache) {
+        return false;
+      }
+      const current = cache.snapshot(key);
+      return cache.set(
+        key,
+        isUpdater(update) ? update(current.status === "ready" ? current.data : void 0) : update
+      );
+    },
+    [store]
+  );
 }
 function useSession() {
   const store = useStore();
   const session = useSessionSnapshot(store);
   const refresh = store.rereadSession;
-  return useMemo3(
+  return useMemo(
     () => ({
       ...session,
       refresh,
@@ -1447,41 +1798,227 @@ function useSession() {
 function useAction() {
   const session = useScopeSession();
   const store = useStore();
-  const scope = useMemo3(() => ({ store, session }), [store, session]);
+  const scope = useMemo(() => ({ store, session }), [store, session]);
   const {
     run: execute,
     retry: replay,
-    busy,
-    error: actionError,
-    settle
+    isPending,
+    error: actionError2,
+    settle,
+    reset: resetAction
   } = useRelayAction(scope);
-  const run = useCallback4(
+  const run = useCallback3(
     async (task) => (await execute(task)).ok,
     [execute]
   );
-  const retry = useCallback4(async () => (await replay()).ok, [replay]);
-  return { busy, actionError, run, retry, settle };
+  const retry = useCallback3(async () => (await replay()).ok, [replay]);
+  return { isPending, actionError: actionError2, resetAction, run, retry, settle };
 }
 function useScopeSession() {
   const store = useStore();
   return useScope(store)?.session?.id;
 }
 
+// src/react/mutation.ts
+function useMutation(mutation, options = {}) {
+  const store = useStore();
+  const invalidate = useInvalidate();
+  const session = useScopeSession();
+  const scope = useMemo2(() => ({ store, session }), [store, session]);
+  const action = useRelayAction(scope);
+  const { run, retry, reset, settle } = action;
+  const latest = useRef4({ mutation, options });
+  const ran = useRef4(null);
+  useLayoutEffect3(() => {
+    latest.current = { mutation, options };
+  });
+  const after = useCallback4(
+    async (result) => {
+      if (!result.ok) {
+        throw result.error ?? clientError(
+          "Another change is still running; wait for it to finish",
+          RelayErrorCode.InvalidInput
+        );
+      }
+      const { invalidates } = latest.current.options;
+      const keys = typeof invalidates === "function" ? ran.current ? invalidates(result.value, ran.current.variables) : [] : invalidates;
+      if (keys?.length) {
+        await invalidate(keys);
+      }
+      return result.value;
+    },
+    [invalidate]
+  );
+  const mutateAsync = useCallback4(
+    async (variables) => {
+      const write = latest.current.mutation;
+      const result = await run((actionId) => {
+        ran.current = { variables };
+        return write(variables, { actionId, session });
+      });
+      return after(result);
+    },
+    [run, after, session]
+  );
+  const mutate = useCallback4(
+    (variables) => {
+      mutateAsync(variables).catch(() => {
+      });
+    },
+    [mutateAsync]
+  );
+  const replay = useCallback4(async () => {
+    try {
+      return await after(await retry());
+    } catch {
+      return null;
+    }
+  }, [retry, after]);
+  const shape = useMemo2(
+    () => ({
+      mutate,
+      mutateAsync,
+      status: action.status,
+      isPending: action.isPending,
+      data: action.data,
+      error: action.error,
+      reset,
+      settle
+    }),
+    [
+      mutate,
+      mutateAsync,
+      action.status,
+      action.isPending,
+      action.data,
+      action.error,
+      reset,
+      settle
+    ]
+  );
+  return { mutation: shape, replay };
+}
+function useRelayMutation(mutation, options = {}) {
+  return useMutation(mutation, options).mutation;
+}
+
+// src/react/provider.tsx
+import { useEffect as useEffect4, useMemo as useMemo4 } from "react";
+
+// src/react/experience.tsx
+import {
+  createContext as createContext2,
+  useCallback as useCallback5,
+  useContext as useContext2,
+  useMemo as useMemo3,
+  useSyncExternalStore as useSyncExternalStore3
+} from "react";
+
+// src/react/use-role-deliveries.ts
+import { useEffect as useEffect3, useState as useState4 } from "react";
+var NONE = Object.freeze([]);
+function useRoleDeliveries(relay, member, completions) {
+  const [state, setState] = useState4(null);
+  useEffect3(() => {
+    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 useSyncExternalStore3(store.subscribe, get, get);
+}
+function DeliveriesProvider({ children }) {
+  const store = useStore();
+  const experience = useExperienceSnapshot();
+  const member = useSyncExternalStore3(
+    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 = useCallback5(() => store.refreshExperience(), [store]);
+  return useMemo3(
+    () => ({ ...experience, refresh, deliveries }),
+    [experience, refresh, deliveries]
+  );
+}
+
+// src/react/provider.tsx
+import { jsx as jsx2 } from "react/jsx-runtime";
+function RelayProvider({
+  client,
+  baseUrl = "/relay",
+  polling,
+  children
+}) {
+  const origin = client ? null : baseUrl;
+  const activityMs = polling?.activityMs;
+  const snapshotMs = polling?.snapshotMs;
+  const store = useMemo4(
+    () => new RelayStore(
+      client ?? createBrowserRelayClient({ baseUrl: origin ?? baseUrl }),
+      { activityMs, snapshotMs }
+    ),
+    // A given client ignores `baseUrl`; `polling` is compared by value.
+    [client, origin, activityMs, snapshotMs]
+  );
+  useEffect4(() => store.mount(), [store]);
+  return /* @__PURE__ */ jsx2(StoreContext, { value: store, children: /* @__PURE__ */ jsx2(DeliveriesProvider, { children }) });
+}
+
 // src/react/rewards.ts
 function useEntitlements(options = {}) {
   const relay = useRelay();
   return useMemberQuery(
-    [...relayKeys.rewards, "entitlements"],
+    rewardKeys.entitlements,
     (context) => relay.rewards.entitlements(context),
-    { intervalMs: 5e3, ...options }
+    { intervalMs: 3e4, ...options }
   );
 }
 function useDeliveries(options = {}) {
   const relay = useRelay();
   return useMemberQuery(
-    [...relayKeys.rewards, "deliveries"],
+    rewardKeys.deliveries,
     (context) => relay.rewards.deliveries(context),
-    { intervalMs: 5e3, ...options }
+    { intervalMs: 3e4, ...options }
   );
 }
 
@@ -1507,11 +2044,11 @@ function questGroups(experience, order = []) {
 
 // src/react/use-quest.ts
 import {
-  useCallback as useCallback5,
+  useCallback as useCallback6,
   useEffect as useEffect5,
-  useLayoutEffect as useLayoutEffect3,
-  useMemo as useMemo4,
-  useRef as useRef4,
+  useLayoutEffect as useLayoutEffect4,
+  useMemo as useMemo5,
+  useRef as useRef5,
   useState as useState5
 } from "react";
 function useQuest(observed) {
@@ -1522,7 +2059,7 @@ function useQuest(observed) {
   const [notice, setNotice] = useState5(null);
   const [error, setError] = useState5(null);
   const [busy, setBusy] = useState5(false);
-  const lock = useRef4(false);
+  const lock = useRef5(false);
   const [discardedAttempt, setDiscardedAttempt] = useState5(null);
   const [saved, setSaved] = useState5("none");
   const [recoveryRevision, setRecoveryRevision] = useState5(0);
@@ -1551,7 +2088,7 @@ function useQuest(observed) {
       active = false;
     };
   }, [relay, quest, release, completed, attempt, busy, recoveryRevision]);
-  const run = useCallback5(
+  const run = useCallback6(
     async (action) => {
       if (lock.current) {
         return;
@@ -1582,11 +2119,11 @@ function useQuest(observed) {
     },
     [store]
   );
-  const shown = useRef4(view);
-  useLayoutEffect3(() => {
+  const shown = useRef5(view);
+  useLayoutEffect4(() => {
     shown.current = view;
   });
-  const actions = useMemo4(
+  const actions = useMemo5(
     () => ({
       restart: async () => {
         if (lock.current) {
@@ -1659,7 +2196,7 @@ function useQuest(observed) {
     [relay, run]
   );
   const startingFresh = view.attempt?.id === discardedAttempt && view.attempt?.status === "failed";
-  return useMemo4(
+  return useMemo5(
     () => ({
       /** The newest known version of the quest. Render this, not the prop. */
       view,
@@ -1667,6 +2204,9 @@ function useQuest(observed) {
       draft,
       notice,
       error,
+      /** True while `submit`, `resume`, `retry` or `restart` runs. */
+      isPending: busy,
+      /** @deprecated Use `isPending`. Removed in 2.0.0. */
       busy,
       saved,
       /** Review and explicitly restart this terminally retired saved submission. */
@@ -1692,10 +2232,10 @@ function useQuest(observed) {
 }
 
 // src/react/auth.ts
-import { useCallback as useCallback6, useMemo as useMemo6, useRef as useRef5, useState as useState7 } from "react";
+import { useCallback as useCallback7, useMemo as useMemo7, useRef as useRef6, useState as useState7 } from "react";
 
 // src/react/wallets.ts
-import { useEffect as useEffect6, useMemo as useMemo5, useState as useState6 } from "react";
+import { useEffect as useEffect6, useMemo as useMemo6, useState as useState6 } from "react";
 function useWallets() {
   const relay = useRelay();
   const invalidate = useInvalidate();
@@ -1705,8 +2245,8 @@ function useWallets() {
     (options) => relay.wallets.list(options),
     { refetchOnFocus: true }
   );
-  const { busy, actionError, run, retry, settle } = useAction();
-  const actions = useMemo5(() => {
+  const { isPending, actionError: actionError2, resetAction, run, retry, settle } = useAction();
+  const actions = useMemo6(() => {
     const changed = () => void invalidate([relayKeys.wallets, relayKeys.experience]);
     return {
       /** Links the wallet to the member the list was read for; another session is refused. */
@@ -1723,9 +2263,19 @@ function useWallets() {
       })
     };
   }, [relay, invalidate, session, run]);
-  return useMemo5(
-    () => ({ ...query, busy, actionError, retry, settle, ...actions }),
-    [query, busy, actionError, retry, settle, actions]
+  return useMemo6(
+    () => ({
+      ...query,
+      isPending,
+      /** @deprecated Use `isPending`. Removed in 2.0.0. */
+      busy: isPending,
+      actionError: actionError2,
+      resetAction,
+      retry,
+      settle,
+      ...actions
+    }),
+    [query, isPending, actionError2, resetAction, retry, settle, actions]
   );
 }
 function discoverChains(key) {
@@ -1793,15 +2343,15 @@ function useMe() {
 function useSignIn() {
   const relay = useRelay();
   const [challenge, setChallengeState] = useState7(null);
-  const latest = useRef5(null);
+  const latest = useRef6(null);
   const [busy, setBusy] = useState7(false);
-  const lock = useRef5(false);
+  const lock = useRef6(false);
   const [error, setError] = useState7(null);
-  const setChallenge = useCallback6((value) => {
+  const setChallenge = useCallback7((value) => {
     latest.current = value;
     setChallengeState(value);
   }, []);
-  const run = useCallback6(
+  const run = useCallback7(
     async (task, fallback) => {
       if (lock.current) {
         return;
@@ -1820,14 +2370,14 @@ function useSignIn() {
     },
     []
   );
-  const sendCode = useCallback6(
+  const sendCode = useCallback7(
     (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 = useCallback6(
+  const verifyCode = useCallback7(
     (code) => run(async () => {
       const sent = latest.current;
       if (!sent) {
@@ -1838,18 +2388,19 @@ function useSignIn() {
     }, "That code didn't work. Check it, or request a new one."),
     [relay, run, setChallenge]
   );
-  const startOver = useCallback6(() => {
+  const startOver = useCallback7(() => {
     setChallenge(null);
     setError(null);
   }, [setChallenge]);
-  const withProvider = useCallback6(
+  const reset = useCallback7(() => setError(null), []);
+  const withProvider = useCallback7(
     (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 = useCallback6(
+  const withWallet = useCallback7(
     (signer) => run(async () => {
       await relay.auth.wallet.signIn(signer);
       setChallenge(null);
@@ -1857,10 +2408,15 @@ function useSignIn() {
     [relay, run, setChallenge]
   );
   const codeSent = challenge !== null;
-  return useMemo6(
+  return useMemo7(
     () => ({
+      /** True while a sign-in action runs. */
+      isPending: busy,
+      /** @deprecated Use `isPending`. Removed in 2.0.0. */
       busy,
       error,
+      /** Clears `error`, keeping a code already sent. */
+      reset,
       /** True once a code was sent and the form should ask for it. */
       codeSent,
       sendCode,
@@ -1873,6 +2429,7 @@ function useSignIn() {
     [
       busy,
       error,
+      reset,
       codeSent,
       sendCode,
       verifyCode,
@@ -1884,26 +2441,28 @@ function useSignIn() {
 }
 function useSignOut() {
   const store = useStore();
-  const [busy, setBusy] = useState7(false);
-  const lock = useRef5(false);
-  const signOut = useCallback6(async () => {
+  const { mutation } = useMutation(() => store.signOut());
+  const { mutateAsync } = mutation;
+  const lock = useRef6(false);
+  const signOut = useCallback7(async () => {
     if (lock.current) {
       return;
     }
     lock.current = true;
-    setBusy(true);
     try {
-      await store.signOut();
+      await mutateAsync();
     } finally {
       lock.current = false;
-      setBusy(false);
     }
-  }, [store]);
-  return useMemo6(() => ({ busy, signOut }), [busy, signOut]);
+  }, [mutateAsync]);
+  return useMemo7(
+    () => ({ ...mutation, signOut, busy: mutation.isPending }),
+    [mutation, signOut]
+  );
 }
 function useSignInOptions(input = {}) {
   const chains = JSON.stringify(cosmosChainList(input.cosmos));
-  const cosmos = useMemo6(
+  const cosmos = useMemo7(
     () => JSON.parse(chains),
     [chains]
   );
@@ -1912,6 +2471,7 @@ function useSignInOptions(input = {}) {
   const {
     busy,
     error,
+    reset,
     codeSent,
     startOver,
     sendCode,
@@ -1919,7 +2479,7 @@ function useSignInOptions(input = {}) {
     withProvider,
     withWallet
   } = useSignIn();
-  const built = useMemo6(() => {
+  const built = useMemo7(() => {
     if (!methods) {
       return null;
     }
@@ -1938,22 +2498,24 @@ function useSignInOptions(input = {}) {
     });
   }, [methods, wallets, cosmos, withProvider, sendCode, verifyCode, withWallet]);
   const methodsError = methods?.error ?? null;
-  return useMemo6(
+  return useMemo7(
     () => ({
       options: built?.options ?? null,
       unavailable: built?.unavailable ?? NONE_UNAVAILABLE,
       methodsError,
+      isPending: busy,
       busy,
       error,
+      reset,
       codeSent,
       startOver
     }),
-    [built, methodsError, busy, error, codeSent, startOver]
+    [built, methodsError, busy, error, reset, codeSent, startOver]
   );
 }
 
 // src/react/accounts.ts
-import { useMemo as useMemo7 } from "react";
+import { useMemo as useMemo8 } from "react";
 function isConnected(accounts, provider) {
   return Boolean(
     accounts?.some(
@@ -1970,8 +2532,8 @@ function useAccounts() {
     (options) => relay.auth.accounts(options),
     { refetchOnFocus: true }
   );
-  const { busy, actionError, run, retry, settle } = useAction();
-  const actions = useMemo7(
+  const { isPending, actionError: actionError2, resetAction, run, retry, settle } = useAction();
+  const actions = useMemo8(
     () => ({
       connect: (provider) => run(async () => {
         const { url } = await relay.auth.start(provider, "connect", {
@@ -1991,22 +2553,34 @@ function useAccounts() {
     [relay, invalidate, session, run]
   );
   const accounts = query.data;
-  return useMemo7(
+  return useMemo8(
     () => ({
       ...query,
-      busy,
-      actionError,
+      isPending,
+      /** @deprecated Use `isPending`. Removed in 2.0.0. */
+      busy: isPending,
+      actionError: actionError2,
+      resetAction,
       retry,
       settle,
       isConnected: (provider) => isConnected(accounts, provider),
       ...actions
     }),
-    [query, busy, actionError, retry, settle, accounts, actions]
+    [
+      query,
+      isPending,
+      actionError2,
+      resetAction,
+      retry,
+      settle,
+      accounts,
+      actions
+    ]
   );
 }
 
 // src/react/profiles.ts
-import { useMemo as useMemo8 } from "react";
+import { useMemo as useMemo9 } from "react";
 var MINE = [...relayKeys.profiles, "mine"];
 function useMyProfile() {
   const relay = useRelay();
@@ -2017,8 +2591,8 @@ function useMyProfile() {
     (options) => relay.profiles.mine(options),
     { refetchOnFocus: true }
   );
-  const { busy, actionError, run, retry, settle } = useAction();
-  const actions = useMemo8(() => {
+  const { isPending, actionError: actionError2, resetAction, run, retry, settle } = useAction();
+  const actions = useMemo9(() => {
     const change = (task) => run(async (actionId) => {
       const cache = store.scope?.cache;
       const saved = await task(actionId);
@@ -2041,9 +2615,19 @@ function useMyProfile() {
       )
     };
   }, [relay, store, session, run]);
-  return useMemo8(
-    () => ({ ...query, busy, actionError, retry, settle, ...actions }),
-    [query, busy, actionError, retry, settle, actions]
+  return useMemo9(
+    () => ({
+      ...query,
+      isPending,
+      /** @deprecated Use `isPending`. Removed in 2.0.0. */
+      busy: isPending,
+      actionError: actionError2,
+      resetAction,
+      retry,
+      settle,
+      ...actions
+    }),
+    [query, isPending, actionError2, resetAction, retry, settle, actions]
   );
 }
 function useProfile(id, options = {}) {
@@ -2084,7 +2668,7 @@ function useProfileCompletions(profile, options = {}) {
 }
 
 // src/react/referrals.ts
-import { useCallback as useCallback7, useEffect as useEffect7, useMemo as useMemo9, useRef as useRef6, useState as useState8 } from "react";
+import { useCallback as useCallback8, useEffect as useEffect7, useMemo as useMemo10, useRef as useRef7, useState as useState8 } from "react";
 var PENDING = "domino:pending-referral";
 var CODE = /^[a-zA-Z0-9_-]{1,100}$/;
 function captureReferralCode(param = "ref") {
@@ -2117,8 +2701,8 @@ function useInvitation(param = "ref") {
     const code = captureReferralCode(param);
     return code ? { status: "pending", code } : { status: "none" };
   });
-  const started = useRef6(null);
-  const pending = useRef6({
+  const started = useRef7(null);
+  const pending = useRef7({
     member,
     relay,
     session,
@@ -2134,7 +2718,7 @@ function useInvitation(param = "ref") {
       action: createRelayAction()
     };
   }
-  const accept = useCallback7(
+  const accept = useCallback8(
     async (code) => {
       const owner = pending.current;
       if (owner.action.busy) {
@@ -2179,7 +2763,7 @@ function useInvitation(param = "ref") {
       void accept(state.code);
     }
   }, [member, state, accept]);
-  return useMemo9(() => ({ invitation: state, accept }), [state, accept]);
+  return useMemo10(() => ({ invitation: state, accept }), [state, accept]);
 }
 function useReferralSummary(options = {}) {
   const relay = useRelay();
@@ -2189,7 +2773,7 @@ function useReferralSummary(options = {}) {
     (request) => relay.referrals.summary(request),
     { intervalMs }
   );
-  return useMemo9(() => {
+  return useMemo10(() => {
     let link = null;
     if (query.data && typeof window !== "undefined") {
       const url = new URL(path, window.location.origin);
@@ -2246,7 +2830,7 @@ function useQuestOutcomes(query = {}) {
 }
 
 // src/react/offers.ts
-import { useCallback as useCallback8, useMemo as useMemo10 } from "react";
+import { useCallback as useCallback9, useMemo as useMemo11 } from "react";
 function useOffers() {
   const relay = useRelay();
   return useRelayQuery(
@@ -2256,34 +2840,19 @@ function useOffers() {
 }
 function useRedeemOffer() {
   const relay = useRelay();
-  const invalidate = useInvalidate();
-  const session = useScopeSession();
-  const scope = useMemo10(() => ({ relay, session }), [relay, session]);
-  const {
-    run,
-    retry: replay,
-    settle,
-    busy,
-    error
-  } = useRelayAction(scope);
-  const refresh = useCallback8(
-    async (result) => {
-      const redemption = result.ok ? result.value : null;
-      if (redemption) {
-        await invalidate([relayKeys.offers, relayKeys.balances]);
-      }
-      return redemption;
-    },
-    [invalidate]
+  const { mutation, replay } = useMutation(
+    (offer, { actionId, session }) => relay.offers.redeem(offer, { actionId }, { session }),
+    { invalidates: [relayKeys.offers, relayKeys.balances] }
+  );
+  const { mutateAsync } = mutation;
+  const redeem = useCallback9(
+    (offer) => mutateAsync(offer).catch(() => null),
+    [mutateAsync]
   );
-  const redeem = useCallback8(
-    (offer) => run(
-      (actionId) => relay.offers.redeem(offer, { actionId }, { session })
-    ).then(refresh),
-    [run, relay, session, refresh]
+  return useMemo11(
+    () => ({ ...mutation, redeem, retry: replay, busy: mutation.isPending }),
+    [mutation, redeem, replay]
   );
-  const retry = useCallback8(() => replay().then(refresh), [replay, refresh]);
-  return { redeem, retry, settle, busy, error };
 }
 
 // src/react/references.ts
@@ -2343,9 +2912,11 @@ export {
   useReferralSummary,
   useRelay,
   useRelayAction,
+  useRelayMutation,
   useRelayPages,
   useRelayQuery,
   useSession,
+  useSetQueryData,
   useSignIn,
   useSignInMethods,
   useSignInOptions,