@domino-sdk/relay 1.0.0-next.8 → 1.0.0

package/dist/{chunk-V5R2DMGY.js → chunk-GZ6FJAXN.js}

@@ -1,9 +1,18 @@
 import {
   collectionPassSchema,
-  pointLedgerReferenceSchema,
+  participantActivityQuerySchema,
+  participantActivitySchema,
+  participantDeliveriesSchema,
+  participantEntitlementsSchema,
+  questClaimInputSchema,
+  questEnrollmentInputSchema,
+  questEnrollmentSchema,
   questExperienceSchema,
+  questOutcomePageSchema,
+  questOutcomeQuerySchema,
+  questOutcomeSchema,
   rewardDeliveriesSchema
-} from "./chunk-MRIURJE3.js";
+} from "./chunk-EYH5RDIE.js";
 import {
   AVATAR_UPLOAD_LIMIT,
   RelayError,
@@ -18,13 +27,19 @@ import {
   leaderboardPlacementSchema,
   leaderboardQuerySchema,
   linkedWalletSchema,
+  offerSchema,
   ownProfileSchema,
   parseInput,
+  pointBalancesSchema,
+  pointHistoryPageSchema,
+  pointHistoryQuerySchema,
+  pointLedgerReferenceSchema,
   profileCompletionPageSchema,
   profileCompletionQuerySchema,
   profileReferralSchema,
   profileSummarySchema,
   profileUpdateSchema,
+  redemptionSchema,
   referralAcceptSchema,
   referralDefinitionSchema,
   referralHistorySchema,
@@ -35,31 +50,36 @@ import {
   walletSignInNetworksSchema,
   walletSignatureSchema,
   walletUnlinkInputSchema
-} from "./chunk-V7EZUZ3Z.js";
+} from "./chunk-36HTX2BM.js";
+import {
+  PARTICIPANT_TIMEOUT,
+  lifetime,
+  retryAfter,
+  retrying,
+  validTimeout
+} from "./chunk-6QJ3LADK.js";
 import {
   exchangeResultSchema,
   exchangeSchema,
   memberSummarySchema,
   participantSessionSchema,
   sessionMember
-} from "./chunk-QBOHLT7M.js";
+} from "./chunk-XFMSUPNS.js";
 import {
   accountConnectionSchema,
   attemptSchema,
   authProviderSchema,
-  contentAdmissionPageSchema,
-  contentAdmissionQuerySchema,
-  contentAdmissionSchema,
-  contentEnrollmentInputSchema,
-  contentEnrollmentSchema,
+  campaignEnrollmentInputSchema,
+  campaignEnrollmentSchema,
+  campaignWithdrawalInputSchema,
   contentPerformancePageSchema,
   contentPerformanceQuerySchema,
   contentQualificationPageSchema,
   contentQualificationQuerySchema,
-  contentReleaseInputSchema,
   evidenceSchema,
   identifier,
   memberProgressSchema,
+  missingPrerequisiteSchema,
   pageQuerySchema,
   quizEvidenceSchema,
   submissionEvidenceSchema,
@@ -67,7 +87,7 @@ import {
   tieredRewardReferenceSchema,
   validateSubmissionValue,
   valueEvidenceSchema
-} from "./chunk-VARGF4JS.js";
+} from "./chunk-JON5SESL.js";
 
 // src/submissions.ts
 import { z } from "zod";
@@ -434,6 +454,20 @@ function observeProgress(transport, listener, options = {}, onDispose = () => {
   let timer;
   let sessionId;
   let failures = 0;
+  const visible = () => typeof document === "undefined" || document.visibilityState !== "hidden";
+  const visibility = () => {
+    if (visible()) {
+      void refresh();
+    } else {
+      controller?.abort();
+      if (timer !== void 0) {
+        clearTimeout(timer);
+      }
+    }
+  };
+  if (typeof document !== "undefined") {
+    document.addEventListener("visibilitychange", visibility);
+  }
   function clear() {
     controller?.abort();
     if (timer !== void 0) {
@@ -445,7 +479,7 @@ function observeProgress(transport, listener, options = {}, onDispose = () => {
     }
   }
   async function refresh() {
-    if (disposed) {
+    if (disposed || !visible()) {
       return;
     }
     controller?.abort();
@@ -509,6 +543,9 @@ function observeProgress(transport, listener, options = {}, onDispose = () => {
         return;
       }
       disposed = true;
+      if (typeof document !== "undefined") {
+        document.removeEventListener("visibilitychange", visibility);
+      }
       controller?.abort();
       if (timer !== void 0) {
         clearTimeout(timer);
@@ -569,7 +606,7 @@ function questActions(submission, latest) {
         input: "none",
         release: view.release,
         recoverPrevious: true,
-        repeatable: view.completion.kind === "keyed"
+        repeatable: view.completion.kind === "keyed" || view.completion.kind === "progress"
       });
       return {
         kind: "status",
@@ -587,7 +624,7 @@ function questActions(submission, latest) {
           input: kind,
           release: view.release,
           recoverPrevious: true,
-          repeatable: view.completion.kind === "keyed"
+          repeatable: view.completion.kind === "keyed" || view.completion.kind === "progress"
         });
         return {
           kind,
@@ -618,7 +655,7 @@ function questActions(submission, latest) {
           input: "photo",
           release: view.release,
           recoverPrevious: true,
-          repeatable: view.completion.kind === "keyed"
+          repeatable: view.completion.kind === "keyed" || view.completion.kind === "progress"
         });
         return {
           kind: "photo",
@@ -634,7 +671,7 @@ function questActions(submission, latest) {
           input: "quiz",
           release: view.release,
           recoverPrevious: true,
-          repeatable: view.completion.kind === "keyed"
+          repeatable: view.completion.kind === "keyed" || view.completion.kind === "progress"
         });
         return {
           kind: "quiz",
@@ -650,7 +687,7 @@ function questActions(submission, latest) {
           input: "none",
           release: view.release,
           recoverPrevious: true,
-          repeatable: view.completion.kind === "keyed"
+          repeatable: view.completion.kind === "keyed" || view.completion.kind === "progress"
         });
         return {
           kind: "claim",
@@ -666,22 +703,35 @@ function questActions(submission, latest) {
 }
 
 // src/client.ts
-var TIMEOUT_MS = 15e3;
-var missingEntrySchema = z2.object({ quest: identifier, title: z2.string() });
 function errorBody(value) {
   const body = value !== null && typeof value === "object" ? value : {};
   return {
     message: typeof body.error === "string" && body.error.trim() ? body.error : void 0,
     code: typeof body.code === "string" && body.code.trim() ? body.code : void 0,
     missing: Array.isArray(body.missing) ? body.missing.flatMap((entry) => {
-      const parsed = missingEntrySchema.safeParse(entry);
+      const parsed = missingPrerequisiteSchema.safeParse(entry);
       return parsed.success ? [parsed.data] : [];
     }) : []
   };
 }
-async function fromSigner(step) {
+async function fromSigner(step, signal) {
+  let stop;
   try {
-    return await step();
+    return await new Promise((resolve, reject) => {
+      stop = () => reject(
+        new RelayError("The request was cancelled", {
+          kind: "aborted",
+          code: RelayErrorCode.Aborted,
+          cause: signal?.reason
+        })
+      );
+      if (signal?.aborted) {
+        stop();
+        return;
+      }
+      signal?.addEventListener("abort", stop, { once: true });
+      step().then(resolve, reject);
+    });
   } catch (error) {
     if (error instanceof RelayError) {
       throw error;
@@ -691,8 +741,16 @@ async function fromSigner(step) {
       RelayErrorCode.WalletSigner,
       { cause: error }
     );
+  } finally {
+    if (stop) {
+      signal?.removeEventListener("abort", stop);
+    }
   }
 }
+var invalidTimeout = () => clientError(
+  "timeout must be a positive, finite number of milliseconds",
+  RelayErrorCode.InvalidInput
+);
 var uncertainStatuses = /* @__PURE__ */ new Set([500, 502, 504]);
 var methodOf = (call) => call.method ?? (call.json === void 0 ? "GET" : "POST");
 function withQuery(path, values) {
@@ -705,22 +763,27 @@ function withQuery(path, values) {
   const search = params.toString();
   return search ? path + "?" + search : path;
 }
-function interrupted(call, error, stage) {
+function interrupted(call, life, error, stage) {
   const details = {
     status: stage.status,
+    retryAfter: stage.headers ? retryAfter(stage.headers) : void 0,
     operationId: call.operationId,
-    uncertain: stage.sent && methodOf(call) !== "GET",
+    replaySafe: call.replaySafe,
+    uncertain: stage.sent && methodOf(call) !== "GET" && // An error status whose body broke off still refused the write, unless the status itself
+    // does not prove that (500, 502, 504).
+    (!stage.refused || uncertainStatuses.has(stage.status ?? 0)),
     cause: error
   };
-  if (call.options?.signal?.aborted) {
+  const ended = life.ended();
+  if (ended === "aborted") {
     return new RelayError("The request was cancelled", {
       ...details,
       kind: "aborted",
       code: RelayErrorCode.Aborted
     });
   }
-  if (call.deadline?.aborted) {
-    return new RelayError("Relay did not respond in time", {
+  if (ended === "timeout") {
+    return new RelayError(`Relay did not respond within ${life.timeout} ms`, {
       ...details,
       kind: "timeout",
       code: RelayErrorCode.Timeout
@@ -732,7 +795,11 @@ function interrupted(call, error, stage) {
   );
 }
 function createRelayClient(options) {
-  async function send(path, call = {}) {
+  if (options.timeout !== void 0 && !validTimeout(options.timeout)) {
+    throw invalidTimeout();
+  }
+  const clientTimeout = options.timeout ?? PARTICIPANT_TIMEOUT;
+  async function send(path, call, life) {
     const method = methodOf(call);
     const headers = new Headers(call.headers);
     let body2 = call.body;
@@ -758,11 +825,8 @@ function createRelayClient(options) {
     if (method !== "GET") {
       headers.set("X-Relay-CSRF", "1");
     }
-    const caller = call.options?.signal;
-    const deadline = AbortSignal.timeout(TIMEOUT_MS);
-    call.deadline = deadline;
-    if (caller?.aborted) {
-      throw interrupted(call, caller.reason, { sent: false });
+    if (life.signal.aborted) {
+      throw interrupted(call, life, life.reason(), { sent: false });
     }
     let response;
     try {
@@ -770,13 +834,23 @@ function createRelayClient(options) {
         method,
         headers,
         body: body2,
-        signal: caller ? AbortSignal.any([caller, deadline]) : deadline
+        signal: life.signal
       });
     } catch (error) {
-      throw interrupted(call, error, { sent: true });
+      throw interrupted(call, life, error, { sent: true });
     }
     if (!response.ok) {
-      const text = await response.text().catch(() => "");
+      let text;
+      try {
+        text = await response.text();
+      } catch (error) {
+        throw interrupted(call, life, error, {
+          sent: true,
+          status: response.status,
+          headers: response.headers,
+          refused: true
+        });
+      }
       let value = null;
       try {
         value = JSON.parse(text);
@@ -789,16 +863,40 @@ function createRelayClient(options) {
         code,
         missing,
         operationId: call.operationId,
-        uncertain: methodOf(call) !== "GET" && uncertainStatuses.has(response.status)
+        replaySafe: call.replaySafe,
+        uncertain: methodOf(call) !== "GET" && uncertainStatuses.has(response.status),
+        retryAfter: retryAfter(response.headers)
       });
     }
     return response;
   }
-  async function body(response, call, reader) {
+  async function exchange(path, call, receive) {
+    const timeout = call.options?.timeout ?? clientTimeout;
+    if (!validTimeout(timeout)) {
+      throw invalidTimeout();
+    }
+    const life = lifetime(timeout, call.options?.signal);
+    try {
+      return await retrying(
+        life,
+        {
+          replaySafe: methodOf(call) === "GET" || (call.replaySafe ?? call.operationId !== void 0)
+        },
+        async () => receive(await send(path, call, life), life)
+      );
+    } finally {
+      life.end();
+    }
+  }
+  async function body(response, call, life, reader) {
     try {
       return await reader(response);
     } catch (error) {
-      throw interrupted(call, error, { sent: true, status: response.status });
+      throw interrupted(call, life, error, {
+        sent: true,
+        status: response.status,
+        headers: response.headers
+      });
     }
   }
   function invalidResponse(status, call, cause) {
@@ -809,14 +907,15 @@ function createRelayClient(options) {
         code: RelayErrorCode.InvalidResponse,
         status,
         operationId: call.operationId,
+        replaySafe: call.replaySafe,
         // Relay accepted the write, but this client cannot tell what it did.
         uncertain: methodOf(call) !== "GET",
         cause
       }
     );
   }
-  async function read(response, schema, call) {
-    const text = await body(response, call, (value2) => value2.text());
+  async function read(response, schema, call, life) {
+    const text = await body(response, call, life, (value2) => value2.text());
     let value;
     try {
       value = JSON.parse(text);
@@ -830,38 +929,48 @@ function createRelayClient(options) {
     return parsed.data;
   }
   async function request(path, schema, call = {}) {
-    return read(await send(path, call), schema, call);
+    return exchange(
+      path,
+      call,
+      (response, life) => read(response, schema, call, life)
+    );
   }
-  async function walletRequest(path, schema, call = {}) {
-    for (let attempt = 0; ; attempt++) {
-      let response;
-      try {
-        response = await send(path, call);
-      } catch (error) {
-        const transient = error instanceof RelayError && (error.kind === "network" || error.kind === "timeout" || error.kind === "http" && [500, 502, 503, 504].includes(error.status ?? 0));
-        if (!transient || attempt === 2) {
-          throw error;
-        }
-        await new Promise(
-          (resolve) => setTimeout(resolve, attempt === 0 ? 250 : 750)
-        );
-        continue;
-      }
-      return read(response, schema, call);
-    }
+  const unusedChallengeExpires = true;
+  async function linkVerify(value, session) {
+    const proof = parseInput(walletSignatureSchema, value);
+    return request("/v1/me/wallets/verify", linkedWalletSchema, {
+      json: proof,
+      options: session,
+      operationId: proof.challenge
+    });
   }
   const readSession = (requestOptions) => request("/v1/auth/session", participantSessionSchema.nullable(), {
-    options: { signal: requestOptions?.signal }
+    options: {
+      signal: requestOptions?.signal,
+      timeout: requestOptions?.timeout
+    }
   });
   async function bound(requestOptions = {}) {
     if (requestOptions.session) {
       return requestOptions;
     }
-    const session = await readSession(requestOptions);
+    const timeout = requestOptions.timeout ?? clientTimeout;
+    if (!validTimeout(timeout)) {
+      throw invalidTimeout();
+    }
+    const started = Date.now();
+    const session = await readSession({ ...requestOptions, timeout });
     if (session?.principal.kind !== "member") {
       throw clientError("Sign in to continue", RelayErrorCode.NotSignedIn);
     }
-    return { ...requestOptions, session: session.id };
+    const remaining = timeout - (Date.now() - started);
+    if (remaining <= 0) {
+      throw new RelayError(`Relay did not respond within ${timeout} ms`, {
+        kind: "timeout",
+        code: RelayErrorCode.Timeout
+      });
+    }
+    return { ...requestOptions, session: session.id, timeout: remaining };
   }
   const submission = submissions(
     {
@@ -914,6 +1023,25 @@ function createRelayClient(options) {
   const ok = z2.object({ ok: z2.literal(true) });
   const acknowledged = z2.object({ ok: z2.boolean() });
   return {
+    offers: {
+      /** Offers available to this participant, including stock and per-member availability. */
+      list: (requestOptions) => request("/v1/offers", z2.array(offerSchema), {
+        options: requestOptions
+      }),
+      /** Redeems one offer. Persist `actionId` to retry after an uncertain result. */
+      redeem: (offer, input = {}, requestOptions) => {
+        const actionId = identifier.parse(input.actionId ?? crypto.randomUUID());
+        return request(
+          `/v1/offers/${identifier.parse(offer)}/redeem`,
+          redemptionSchema,
+          {
+            json: { actionId },
+            options: requestOptions,
+            operationId: actionId
+          }
+        );
+      }
+    },
     referrals: {
       list: (requestOptions) => request("/v1/referrals", z2.array(referralDefinitionSchema), {
         options: requestOptions
@@ -936,6 +1064,14 @@ function createRelayClient(options) {
         });
       }
     },
+    rewards: {
+      /** The signed-in member's earned rewards, including pickup allocation and collection state. */
+      entitlements: (options2) => request("/v1/me/entitlements", participantEntitlementsSchema, {
+        options: options2
+      }),
+      /** Point awards, current tier entitlements, and integration delivery states. */
+      deliveries: (options2) => request("/v1/me/deliveries", participantDeliveriesSchema, { options: options2 })
+    },
     tieredRewards: {
       /**
        * The project's tiered rewards with their keys. Entitlements and reward
@@ -997,7 +1133,8 @@ function createRelayClient(options) {
       }),
       /**
        * Uploads a JPEG, PNG or WebP of at most 5 MB as the member's avatar. The server crops it to
-       * a 512×512 WebP without metadata. Retrying with the same `uploadId` is idempotent.
+       * a 512×512 WebP without metadata. The client never resends it: retrying with the same
+       * `uploadId` and file stores no second picture, but only before another upload replaces it.
        */
       uploadAvatar: async (file, requestOptions = {}) => {
         if (!avatarUploadTypes.includes(file.type)) {
@@ -1022,7 +1159,10 @@ function createRelayClient(options) {
             "X-Relay-Upload-ID": operationId
           },
           options: rest,
-          operationId
+          operationId,
+          // Relay keeps no receipt for an upload ID: replaying an upload another one replaced
+          // would make it current again. Retry only on purpose, with the same file.
+          replaySafe: false
         });
       },
       /**
@@ -1058,6 +1198,45 @@ function createRelayClient(options) {
     },
     quests: {
       get: getQuest,
+      /**
+       * Enrolls the signed-in member in a quest whose tracker trigger requires enrollment. Activity
+       * counts from then on; earlier activity is historical, or skipped with `before-enrollment`
+       * on a quest that counts from enrollment. Enrolling again returns the first enrollment.
+       */
+      enroll: async (value, requestOptions) => {
+        const body2 = parseInput(questEnrollmentInputSchema, value);
+        return request("/v1/quests/enrollments", questEnrollmentSchema, {
+          json: body2,
+          options: requestOptions,
+          operationId: body2.actionId
+        });
+      },
+      /**
+       * Claims one of the signed-in member's outcomes skipped as `historical`, on a quest whose
+       * historical policy is `"claim"` (`outcome.claimable`). Relay decides it again with
+       * historical activity released and returns the outcome; a rule that still fails rejects
+       * with a `RelayError` whose code is that rule's skip code.
+       */
+      claim: async (value, requestOptions) => {
+        const body2 = parseInput(questClaimInputSchema, value);
+        return request("/v1/quests/claims", questOutcomeSchema, {
+          json: body2,
+          options: requestOptions,
+          operationId: body2.actionId
+        });
+      },
+      /**
+       * Why automatic quests did or did not run for the signed-in member's activity, newest first:
+       * each admission, and each skip with its stable code.
+       */
+      outcomes: async (query = {}, requestOptions) => request(
+        withQuery(
+          "/v1/quests/outcomes",
+          parseInput(questOutcomeQuerySchema, query)
+        ),
+        questOutcomePageSchema,
+        { options: requestOptions }
+      ),
       /** Retries verification of the quest's failed attempt. */
       retry: async (view, requestOptions) => {
         if (view.trigger.kind === "automatic") {
@@ -1106,25 +1285,43 @@ function createRelayClient(options) {
         return { refresh: observer.refresh, dispose: observer.dispose };
       }
     },
+    campaigns: {
+      /** Enrolls the signed-in member once in every quest of a campaign that requires it. */
+      enroll: async (value, requestOptions) => {
+        const body2 = parseInput(campaignEnrollmentInputSchema, value);
+        return request("/v1/campaigns/enrollments", campaignEnrollmentSchema, {
+          json: body2,
+          options: requestOptions,
+          operationId: body2.actionId
+        });
+      },
+      /** Pauses the signed-in member's campaign enrollment without erasing its history. */
+      withdraw: async (value, requestOptions) => {
+        const body2 = parseInput(campaignWithdrawalInputSchema, value);
+        return request(
+          "/v1/campaigns/enrollments/withdraw",
+          campaignEnrollmentSchema,
+          {
+            json: body2,
+            options: requestOptions,
+            operationId: body2.actionId
+          }
+        );
+      }
+    },
     /** The signed-in member's linked Solana, EVM and Cosmos wallets for this project. */
     wallets: {
-      list: (requestOptions) => walletRequest(
+      list: (requestOptions) => request(
         "/v1/me/wallets",
         z2.object({ wallets: z2.array(linkedWalletSchema) }),
         { options: requestOptions }
       ).then((result) => result.wallets),
-      challenge: async (value, requestOptions) => walletRequest(
-        "/v1/me/wallets/challenge",
-        walletMessageChallengeSchema,
-        {
-          json: parseInput(walletAddressInputSchema, value),
-          options: await bound(requestOptions)
-        }
-      ),
-      verify: async (value, requestOptions) => walletRequest("/v1/me/wallets/verify", linkedWalletSchema, {
-        json: parseInput(walletSignatureSchema, value),
-        options: await bound(requestOptions)
+      challenge: async (value, requestOptions) => request("/v1/me/wallets/challenge", walletMessageChallengeSchema, {
+        json: parseInput(walletAddressInputSchema, value),
+        options: await bound(requestOptions),
+        replaySafe: unusedChallengeExpires
       }),
+      verify: async (value, requestOptions) => linkVerify(value, await bound(requestOptions)),
       /** The address stays bound to this member: another member still cannot link it. */
       unlink: async (wallet, requestOptions) => request("/v1/me/wallets/unlink", ok, {
         json: parseInput(walletUnlinkInputSchema, {
@@ -1133,30 +1330,36 @@ function createRelayClient(options) {
         }),
         options: requestOptions
       }),
-      /** Asks the signer for its address, signs the returned challenge, and links the wallet. */
+      /**
+       * Asks the signer for its address, signs the returned challenge, and links the wallet. The
+       * session read and the challenge share one deadline, and the verification gets its own:
+       * the time the member takes in the wallet counts against neither.
+       */
       link: async (signer, requestOptions) => {
         const session = await bound(requestOptions);
-        const challenge = await walletRequest(
+        const challenge = await request(
           "/v1/me/wallets/challenge",
           walletMessageChallengeSchema,
           {
             json: parseInput(
               walletAddressInputSchema,
-              await fromSigner(() => walletAddressInput(signer))
+              await fromSigner(
+                () => walletAddressInput(signer),
+                requestOptions?.signal
+              )
             ),
-            options: session
+            options: session,
+            replaySafe: unusedChallengeExpires
           }
         );
         const proof = await fromSigner(
-          () => signer.sign(challenge.message, challenge.address)
+          () => signer.sign(challenge.message, challenge.address),
+          requestOptions?.signal
+        );
+        return linkVerify(
+          { challenge: challenge.id, ...proof },
+          { ...requestOptions, session: session.session }
         );
-        return walletRequest("/v1/me/wallets/verify", linkedWalletSchema, {
-          json: parseInput(walletSignatureSchema, {
-            challenge: challenge.id,
-            ...proof
-          }),
-          options: session
-        });
       }
     },
     auth: {
@@ -1170,8 +1373,8 @@ function createRelayClient(options) {
             })
           ),
           email: z2.boolean(),
-          /** The wallet sign-in this project enabled; older servers omit it. */
-          wallets: walletSignInNetworksSchema.default([]),
+          /** The wallet sign-in this project enabled. */
+          wallets: walletSignInNetworksSchema,
           demo: z2.boolean()
         }),
         { options: requestOptions }
@@ -1230,13 +1433,17 @@ function createRelayClient(options) {
             {
               json: parseInput(
                 walletAddressInputSchema,
-                await fromSigner(() => walletAddressInput(signer))
+                await fromSigner(
+                  () => walletAddressInput(signer),
+                  requestOptions?.signal
+                )
               ),
               options: requestOptions
             }
           );
           const proof = await fromSigner(
-            () => signer.sign(challenge.message, challenge.address)
+            () => signer.sign(challenge.message, challenge.address),
+            requestOptions?.signal
           );
           return changeSession(
             () => request("/v1/auth/wallet/verify", participantSessionSchema, {
@@ -1271,6 +1478,57 @@ function createRelayClient(options) {
       })
     },
     me: {
+      activity: {
+        list: (query = {}, options2) => {
+          const parsed = parseInput(participantActivityQuerySchema, query);
+          return request(
+            withQuery("/v1/me/activity", parsed),
+            participantActivitySchema,
+            { options: options2 }
+          );
+        },
+        observe: (listener, options2 = {}) => {
+          let cursor = options2.cursor;
+          let owner;
+          const observer = observeProgress(
+            {
+              session: (signal) => readSession({ signal }),
+              progress: (session, signal) => request(
+                withQuery("/v1/me/activity", { cursor }),
+                participantActivitySchema,
+                { options: { session, signal } }
+              )
+            },
+            (state) => {
+              if (state.kind === "session") {
+                if (owner !== void 0 && owner !== (state.session?.id ?? null)) {
+                  cursor = void 0;
+                }
+                owner = state.session?.id ?? null;
+              }
+              if (state.kind === "ready") {
+                for (const event of state.progress.items) {
+                  listener(event);
+                }
+                cursor = state.progress.nextCursor;
+                if (state.progress.items.length === 50) {
+                  queueMicrotask(() => void observer.refresh());
+                }
+              }
+              options2.onState?.(state);
+            },
+            {
+              intervalMs: options2.intervalMs ?? 5e3,
+              maxBackoffMs: options2.maxBackoffMs
+            },
+            () => observers.delete(observer)
+          );
+          observers.add(observer);
+          observer.clear();
+          void observer.refresh();
+          return { refresh: observer.refresh, dispose: observer.dispose };
+        }
+      },
       /** The signed-in member, and the seed of their generated avatar: `defaultAvatar(avatarSeed)`. */
       get: async (requestOptions) => request("/v1/me", memberSummarySchema, { options: requestOptions }),
       observeProgress: (listener, observeOptions) => {
@@ -1301,6 +1559,22 @@ function createRelayClient(options) {
       rewardDeliveries: (requestOptions) => request("/v1/reward-deliveries", rewardDeliveriesSchema, {
         options: requestOptions
       }),
+      /**
+       * `{ items }`: the member's balance in each of the project's point ledgers, in the project's
+       * ledger order, zero in a ledger they have no entries in.
+       */
+      balances: (requestOptions) => request("/v1/me/points", pointBalancesSchema, {
+        options: requestOptions
+      }),
+      /** The member's own entries in one ledger, by key or ID, most recently recorded first. */
+      pointHistory: async (query, requestOptions) => {
+        const { ledger, cursor } = parseInput(pointHistoryQuerySchema, query);
+        return request(
+          withQuery(`/v1/me/points/${ledger}/history`, { cursor }),
+          pointHistoryPageSchema,
+          { options: requestOptions }
+        );
+      },
       /** Claims a quest for the signed-in member. Quest controllers (`quests.open`) call this. */
       claim: async (value, requestOptions) => {
         const claim = parseInput(submitSchema.omit({ member: true }), value);
@@ -1321,19 +1595,21 @@ function createRelayClient(options) {
     evidence: {
       async download(id, requestOptions) {
         const call = { options: requestOptions };
-        const response = await send(
+        return exchange(
           `/v1/evidence/${parseInput(identifier, id)}`,
-          call
+          call,
+          (response, life) => {
+            const type = response.headers.get("Content-Type");
+            if (type !== "image/jpeg" && type !== "image/png") {
+              throw invalidResponse(
+                response.status,
+                call,
+                new Error("Unexpected evidence content type")
+              );
+            }
+            return body(response, call, life, (value) => value.blob());
+          }
         );
-        const type = response.headers.get("Content-Type");
-        if (type !== "image/jpeg" && type !== "image/png") {
-          throw invalidResponse(
-            response.status,
-            call,
-            new Error("Unexpected evidence content type")
-          );
-        }
-        return body(response, call, (value) => value.blob());
       }
     },
     engagement: {
@@ -1372,31 +1648,7 @@ function createRelayClient(options) {
         ),
         contentQualificationPageSchema,
         { options: requestOptions }
-      ),
-      admissions: async (query, requestOptions) => request(
-        withQuery(
-          "/v1/content/admissions",
-          parseInput(contentAdmissionQuerySchema, query)
-        ),
-        contentAdmissionPageSchema,
-        { options: requestOptions }
-      ),
-      enroll: async (value, requestOptions) => {
-        const body2 = parseInput(contentEnrollmentInputSchema, value);
-        return request("/v1/content/enrollments", contentEnrollmentSchema, {
-          json: body2,
-          options: requestOptions,
-          operationId: body2.actionId
-        });
-      },
-      claim: async (value, requestOptions) => {
-        const body2 = parseInput(contentReleaseInputSchema, value);
-        return request("/v1/content/claims", contentAdmissionSchema, {
-          json: body2,
-          options: requestOptions,
-          operationId: body2.actionId
-        });
-      }
+      )
     }
   };
 }