@domino-sdk/relay 1.61.0 → 1.63.0

package/dist/{chunk-SKGTNTLF.js → chunk-LZWXCBUB.js}

@@ -1,47 +1,57 @@
 import {
   createRelayAction,
   withActionId
-} from "./chunk-QEAS4ZGS.js";
+} from "./chunk-AQOL3SK5.js";
 import {
+  setPluginTransport
+} from "./chunk-MTKRIQEU.js";
+import {
+  authProvidersSchema,
   collectionPassSchema,
+  consentInputSchema,
   creatorAccountProviderSchema,
   creatorAccountsSchema,
-  participantActivityQuerySchema,
-  participantActivitySchema,
+  memberConsentListSchema,
+  memberConsentSchema,
   participantDeliveriesSchema,
   participantEntitlementsSchema,
   questClaimInputSchema,
   questEnrollmentInputSchema,
   questEnrollmentSchema,
-  questExperienceSchema,
   questOutcomePageSchema,
   questOutcomeQuerySchema,
   questOutcomeSchema,
   rewardDeliveriesSchema,
   rewardDeliveryQuerySchema
-} from "./chunk-QNUHWK7R.js";
+} from "./chunk-EHUSD3O2.js";
+import {
+  participantActivityQuerySchema,
+  participantActivitySchema,
+  questExperienceSchema
+} from "./chunk-4NOFSGAL.js";
 import {
-  badgeSchema,
   engagementBoundaryPageSchema,
   engagementPageQuerySchema,
   engagementPageSchema,
-  leaderboardDefinitionResponseSchema,
-  leaderboardHistoryPageSchema,
-  leaderboardHistoryQuerySchema,
-  leaderboardPageSchema,
-  leaderboardPlacementSchema,
-  leaderboardQuerySchema,
-  memberBadgesSchema,
   offerSchema,
   redemptionSchema,
   referralAcceptSchema,
   referralDefinitionSchema,
   referralHistorySchema,
   referralSummarySchema
-} from "./chunk-3Y3L2F54.js";
+} from "./chunk-QR6HH4DI.js";
 import {
   AVATAR_UPLOAD_LIMIT,
   avatarUploadTypes,
+  badgeCatalogSchema,
+  badgeSchema,
+  leaderboardDefinitionResponseSchema,
+  leaderboardHistoryPageSchema,
+  leaderboardHistoryQuerySchema,
+  leaderboardPageSchema,
+  leaderboardPlacementSchema,
+  leaderboardQuerySchema,
+  memberBadgesSchema,
   ownProfileSchema,
   pointBalancesSchema,
   pointHistoryPageSchema,
@@ -52,83 +62,85 @@ import {
   profileReferralSchema,
   profileSummarySchema,
   profileUpdateSchema
-} from "./chunk-SE4PFJPT.js";
+} from "./chunk-W7YSMSGC.js";
+import {
+  createHttpExchange,
+  untilAborted,
+  withQuery
+} from "./chunk-ICXZZNPS.js";
 import {
   PARTICIPANT_TIMEOUT,
   lifetime,
-  retryAfter,
   retrying,
   validTimeout
-} from "./chunk-XBV2CK2H.js";
-import {
-  clientIdentity
-} from "./chunk-EN3M5Z4J.js";
+} from "./chunk-3RFP6GT5.js";
 import {
   exchangeResultSchema,
   exchangeSchema,
   memberSummarySchema,
   participantSessionSchema,
   sessionMember
-} from "./chunk-PPB7HALD.js";
+} from "./chunk-N4BDKS6Y.js";
 import {
-  RelayError,
-  RelayErrorCode,
   accountConnectionSchema,
   attemptSchema,
-  authProviderSchema,
   campaignEnrollmentInputSchema,
   campaignEnrollmentSchema,
   campaignWithdrawalInputSchema,
-  clientError,
   contentPerformancePageSchema,
   contentPerformanceQuerySchema,
   contentQualificationPageSchema,
   contentQualificationQuerySchema,
   evidenceSchema,
   identifier,
-  isRelayError,
-  isRequestError,
   knownResponse,
   linkedWalletSchema,
   memberProgressSchema,
   missingPrerequisiteSchema,
   pageQuerySchema,
-  parseInput,
   questSubmissionResultSchema,
   questSubmissionSchema,
   quizEvidenceSchema,
+  signInAccountSchema,
+  signInProviderInputSchema,
   submissionEvidenceSchema,
   submitSchema,
   telegramAccountConnectionSchema,
   telegramMiniAppSignInSchema,
-  telegramSignInMethodsSchema,
   tieredRewardReferenceSchema,
   validateSubmissionValue,
   valueEvidenceSchema,
   walletAddressInput,
   walletAddressInputSchema,
   walletMessageChallengeSchema,
-  walletSignInNetworksSchema,
   walletSignatureSchema,
   walletUnlinkInputSchema
-} from "./chunk-ZDJLPN4L.js";
+} from "./chunk-ID3BZXFZ.js";
+import {
+  RelayError,
+  RelayErrorCode,
+  clientError,
+  isRelayError,
+  isRequestError,
+  parseInput
+} from "./chunk-GLH6MEI2.js";
 
 // src/legacy-submissions.ts
 import * as z from "zod";
-var common = {
+var common = /* @__PURE__ */ (() => ({
   id: identifier,
   quest: identifier,
   release: identifier.optional()
-};
-var claimInputSchema = z.union([
+}))();
+var claimInputSchema = /* @__PURE__ */ (() => z.union([
   submissionEvidenceSchema,
   z.object({ kind: z.literal("none") }).strict()
-]);
-var draftSchema = z.union([
+]))();
+var draftSchema = /* @__PURE__ */ (() => z.union([
   claimInputSchema,
   z.object({ kind: z.literal("photo"), file: z.instanceof(Blob) })
-]);
-var activeRecordSchema = z.union([
+]))();
+var activeRecordSchema = /* @__PURE__ */ (() => z.union([
   z.object({
     ...common,
     stage: z.literal("review"),
@@ -154,15 +166,15 @@ var activeRecordSchema = z.union([
     input: claimInputSchema,
     attempt: identifier
   })
-]);
-var recordSchema = z.union([
+]))();
+var recordSchema = /* @__PURE__ */ (() => z.union([
   activeRecordSchema,
   z.object({
     ...common,
     stage: z.literal("retired"),
     previous: activeRecordSchema
   })
-]);
+]))();
 function legacySubmissions(transport, configuredStore, namespace) {
   async function open(quest, options = {
     input: "photo"
@@ -797,7 +809,7 @@ import * as z2 from "zod";
 
 // src/progress.ts
 function sessionEnded(error) {
-  return isRequestError(error) && (error.code === RelayErrorCode.StaleSession || error.code === RelayErrorCode.NotSignedIn);
+  return isRequestError(error) && (error.code === RelayErrorCode.StaleSession || error.code === RelayErrorCode.NotSignedIn || error.code === RelayErrorCode.Unauthenticated);
 }
 function observeProgress(transport, listener, options = {}, onDispose = () => {
 }) {
@@ -1112,14 +1124,14 @@ function questActions(submission, latest) {
 }
 
 // src/client.ts
-var authStartSchema = z2.strictObject({
-  provider: authProviderSchema,
+var authStartSchema = /* @__PURE__ */ (() => z2.strictObject({
+  provider: signInProviderInputSchema,
   mode: z2.enum(["sign-in", "connect"])
-});
-var emailVerificationSchema = z2.strictObject({
+}))();
+var emailVerificationSchema = /* @__PURE__ */ (() => z2.strictObject({
   challenge: z2.string().min(1).max(200),
   code: z2.string().transform((code) => code.trim()).pipe(z2.string().regex(/^\d{6}$/, "Enter the 6-digit code"))
-});
+}))();
 function errorBody(value) {
   const body = value !== null && typeof value === "object" ? value : {};
   const window = body.window === "tracker" ? "tracker" : body.window === "quest" ? "quest" : void 0;
@@ -1135,24 +1147,16 @@ function errorBody(value) {
   };
 }
 async function fromSigner(step, signal) {
-  let stop;
   try {
-    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);
-    });
+    return await untilAborted(step, signal);
   } catch (error) {
+    if (signal?.aborted && error === signal.reason) {
+      throw new RelayError("The request was cancelled", {
+        kind: "aborted",
+        code: RelayErrorCode.Aborted,
+        cause: error
+      });
+    }
     if (error instanceof RelayError) {
       throw error;
     }
@@ -1161,59 +1165,13 @@ async function fromSigner(step, signal) {
       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) {
-  const params = new URLSearchParams();
-  for (const [key, value] of Object.entries(values)) {
-    if (value !== void 0) {
-      params.set(key, String(value));
-    }
-  }
-  const search = params.toString();
-  return search ? path + "?" + search : path;
-}
-function interrupted(call, life, error, stage) {
-  const details = {
-    status: stage.status,
-    retryAfter: stage.headers ? retryAfter(stage.headers) : void 0,
-    operationId: call.operationId,
-    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
-  };
-  const ended = life.ended();
-  if (ended === "aborted") {
-    return new RelayError("The request was cancelled", {
-      ...details,
-      kind: "aborted",
-      code: RelayErrorCode.Aborted
-    });
-  }
-  if (ended === "timeout") {
-    return new RelayError(`Relay did not respond within ${life.timeout} ms`, {
-      ...details,
-      kind: "timeout",
-      code: RelayErrorCode.Timeout
-    });
-  }
-  return new RelayError(
-    stage.status === void 0 ? "Could not reach Relay" : "Relay's response was cut off",
-    { ...details, kind: "network", code: RelayErrorCode.Network }
-  );
-}
 function createRelayClient(options) {
   return relayClient(options);
 }
@@ -1227,158 +1185,28 @@ function relayClient(options) {
       RelayErrorCode.InvalidInput
     );
   }
-  try {
-    const headers = new Headers(options.headers);
-    if (options.token) {
-      headers.set("Authorization", `Bearer ${options.token}`);
-    }
-    headers.set("X-Relay-Organization", options.organization ?? "");
-    headers.set("X-Relay-Project", options.project ?? "");
-  } catch (error) {
-    throw clientError(
-      "headers, token, organization and project must be valid HTTP header values",
-      RelayErrorCode.InvalidInput,
-      { cause: error }
-    );
-  }
   const clientTimeout = options.timeout ?? PARTICIPANT_TIMEOUT;
-  async function credential(call, life) {
-    if (!options.getToken) {
-      return options.token;
-    }
-    const getToken = options.getToken;
-    try {
-      return await new Promise((resolve, reject) => {
-        const stop = () => reject(life.signal.reason);
-        life.signal.addEventListener("abort", stop, { once: true });
-        getToken().then(resolve, reject).finally(() => life.signal.removeEventListener("abort", stop));
-      });
-    } catch (error) {
-      if (life.signal.aborted) {
-        throw interrupted(call, life, error, { sent: false });
-      }
-      throw new RelayError("Could not get a Relay credential", {
-        // A token source that could not reach its own service failed like a network call.
-        kind: error instanceof TypeError ? "network" : "client",
-        code: RelayErrorCode.Credential,
-        operationId: call.operationId,
-        replaySafe: call.replaySafe,
-        cause: error
-      });
-    }
-  }
-  async function send(path, call, life) {
-    if (life.signal.aborted) {
-      throw interrupted(call, life, life.reason(), { sent: false });
-    }
-    const method = methodOf(call);
-    const token = await credential(call, life);
-    let headers;
-    let body2 = call.body;
-    try {
-      headers = new Headers(options.headers);
-      new Headers(call.headers).forEach(
-        (value, name) => headers.set(name, value)
-      );
-      headers.set("X-Domino-Client", clientIdentity());
-      if (token) {
-        try {
-          headers.set("Authorization", `Bearer ${token}`);
-        } catch (error) {
-          throw new RelayError(
-            "getToken returned a value that is not a token",
-            {
-              kind: "client",
-              code: RelayErrorCode.Credential,
-              operationId: call.operationId,
-              replaySafe: call.replaySafe,
-              cause: error
-            }
-          );
-        }
-      } else if (options.getToken) {
-        headers.delete("Authorization");
-      }
-      if (options.organization) {
-        headers.set("X-Relay-Organization", options.organization);
-      }
-      if (options.project) {
-        headers.set("X-Relay-Project", options.project);
-      }
-      if (options.environment) {
-        headers.set("X-Relay-Environment", options.environment);
-      }
-      if (call.options?.session) {
-        headers.set("X-Relay-Session", call.options.session);
-      }
-      if (call.json !== void 0) {
-        headers.set("Content-Type", "application/json");
-        body2 = JSON.stringify(call.json);
-      }
-      if (method !== "GET") {
-        headers.set("X-Relay-CSRF", "1");
-      }
-    } catch (error) {
-      if (isRelayError(error)) {
-        throw error;
-      }
-      throw clientError(
-        "The request has a header or body that cannot be sent",
-        RelayErrorCode.InvalidInput,
-        {
-          operationId: call.operationId,
-          replaySafe: call.replaySafe,
-          cause: error
-        }
-      );
-    }
-    if (life.signal.aborted) {
-      throw interrupted(call, life, life.reason(), { sent: false });
-    }
-    let response;
-    try {
-      response = await (options.fetch ?? fetch)(options.baseUrl + path, {
-        method,
-        headers,
-        body: body2,
-        signal: life.signal
-      });
-    } catch (error) {
-      throw interrupted(call, life, error, { sent: true });
-    }
-    if (!response.ok) {
-      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);
-      } catch {
-      }
-      const { message, code, window, missing, retryAt } = errorBody(value);
-      throw new RelayError(message ?? `Request failed (${response.status})`, {
-        kind: "http",
-        status: response.status,
-        code,
-        window,
-        missing,
-        ...retryAt === void 0 ? {} : { retryAt },
-        operationId: call.operationId,
-        replaySafe: call.replaySafe,
-        uncertain: methodOf(call) !== "GET" && uncertainStatuses.has(response.status),
-        retryAfter: retryAfter(response.headers)
-      });
-    }
-    return response;
-  }
+  const http = createHttpExchange(options, {
+    csrf: true,
+    session: (call) => call.options?.session,
+    messages: {
+      aborted: "The request was cancelled",
+      timeout: (milliseconds) => `Relay did not respond within ${milliseconds} ms`,
+      network: (status) => status === void 0 ? "Could not reach Relay" : "Relay's response was cut off",
+      credential: "Could not get a Relay credential",
+      invalidToken: "getToken returned a value that is not a token",
+      invalidOptions: "headers, token, organization and project must be valid HTTP header values",
+      unsendable: "The request has a header or body that cannot be sent"
+    },
+    // Unlike the management client's, a write that failed to connect stays uncertain: this client
+    // does not read the socket error that would prove it was never sent.
+    makeError: (message, details, call) => new RelayError(message, {
+      ...details,
+      operationId: call?.operationId,
+      replaySafe: call?.replaySafe
+    }),
+    parseRefusal: errorBody
+  });
   async function exchange(path, call, receive) {
     const timeout = call.options?.timeout ?? clientTimeout;
     if (!validTimeout(timeout)) {
@@ -1391,7 +1219,7 @@ function relayClient(options) {
         {
           replaySafe: methodOf(call) === "GET" || (call.replaySafe ?? call.operationId !== void 0)
         },
-        async () => receive(await send(path, call, life), life)
+        async () => receive(await http.send(path, call, call, life), life)
       );
     } finally {
       life.end();
@@ -1401,7 +1229,7 @@ function relayClient(options) {
     try {
       return await reader(response);
     } catch (error) {
-      throw interrupted(call, life, error, {
+      throw http.interrupted(error, methodOf(call), call, life, {
         sent: true,
         status: response.status,
         headers: response.headers
@@ -1593,7 +1421,26 @@ function relayClient(options) {
   }
   const ok = z2.object({ ok: z2.literal(true) });
   const acknowledged = z2.object({ ok: z2.boolean() });
-  return {
+  const pluginProofSchema = z2.string().min(1, "Pass the vendor's signed proof").max(8192);
+  const signInMethod = (path, field) => {
+    const body2 = (proof, mode) => ({
+      [field]: parseInput(pluginProofSchema, proof),
+      mode
+    });
+    return {
+      signIn: (proof, requestOptions) => changeSession(
+        () => request(path, participantSessionSchema, {
+          json: body2(proof, "sign-in"),
+          options: requestOptions
+        })
+      ),
+      connect: async (proof, requestOptions) => request(path, acknowledged, {
+        json: body2(proof, "connect"),
+        options: requestOptions
+      })
+    };
+  };
+  const client = {
     /** Owns one action key across uncertain writes. Reuse the helper until a definite answer. */
     action: createRelayAction,
     /** A JSON call using an explicit tolerant response schema from `@domino-sdk/relay/schema`. */
@@ -1682,7 +1529,17 @@ function relayClient(options) {
       })
     },
     badges: {
-      list: (options2) => request("/v1/badges", z2.array(badgeSchema), { options: options2 })
+      /**
+       * The project's active badge catalog, as an array.
+       *
+       * @deprecated Use `catalog`, which answers `{ items }` like `me.badges`. Removed in 2.0.0.
+       */
+      list: (options2) => request("/v1/badges", z2.array(badgeSchema), { options: options2 }),
+      /**
+       * The project's active badge catalog, oldest definition first, in `items`. Archived badges
+       * are left out. Open to signed-out visitors.
+       */
+      catalog: (options2) => request("/v1/badges/catalog", badgeCatalogSchema, { options: options2 })
     },
     pointLedgers: {
       /**
@@ -1831,7 +1688,8 @@ function relayClient(options) {
        * 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.
+       * with a `RelayError` whose code is that rule's skip code. This claim is of a skipped
+       * outcome; `me.claim` submits an attempt.
        */
       claim: async (value, requestOptions) => {
         const body2 = parseInput(questClaimInputSchema, withActionId(value));
@@ -1925,6 +1783,34 @@ function relayClient(options) {
         );
       }
     },
+    /**
+     * The signed-in member's marketing consent, per channel. The app shows the checkbox and sends
+     * the wording beside it; Relay records the choice with its own time, and only members who
+     * opted in reach the project's destinations.
+     *
+     * @experimental A minor release can change the consent API.
+     */
+    consent: {
+      /**
+       * The member's current consent on each channel they chose on. A channel missing from the
+       * list has no record, which is not the same as withdrawn.
+       */
+      get: (requestOptions) => request("/v1/me/consent", memberConsentListSchema, {
+        options: requestOptions
+      }),
+      /**
+       * Grants (`granted: true`, with the `wording` the member saw) or withdraws one channel.
+       * Repeating the current state and wording records nothing and answers the current state.
+       */
+      set: async (value, requestOptions) => {
+        const body2 = parseInput(consentInputSchema, withActionId(value));
+        return request("/v1/me/consent", memberConsentSchema, {
+          json: body2,
+          options: requestOptions,
+          operationId: body2.actionId
+        });
+      }
+    },
     /** The signed-in member's linked Solana, EVM and Cosmos wallets for this project. */
     wallets: {
       list: (requestOptions) => request(
@@ -1979,27 +1865,9 @@ function relayClient(options) {
       }
     },
     auth: {
-      providers: (requestOptions) => request(
-        "/v1/auth/providers",
-        z2.object({
-          providers: z2.array(
-            z2.object({
-              provider: authProviderSchema,
-              configured: z2.boolean()
-            })
-          ),
-          email: z2.boolean(),
-          /** The wallet sign-in this project enabled. */
-          wallets: walletSignInNetworksSchema,
-          demo: z2.boolean(),
-          /**
-           * Telegram's sign-in, which is not one of `providers` in SDK 1.x. Absent from Relay
-           * versions without Telegram.
-           */
-          telegram: telegramSignInMethodsSchema.optional()
-        }),
-        { options: requestOptions }
-      ),
+      providers: (requestOptions) => request("/v1/auth/providers", authProvidersSchema, {
+        options: requestOptions
+      }),
       start: authStart,
       emailStart: async (email2, requestOptions) => request("/v1/auth/email/start", z2.object({ challenge: z2.string() }), {
         json: {
@@ -2064,12 +1932,15 @@ function relayClient(options) {
       },
       /**
        * Telegram sign-in and the member's Telegram account. Telegram is not an `AuthProvider` in
-       * SDK 1.x, so `accounts()`, `start()` and `disconnect()` leave it out and these take its place.
+       * SDK 1.x, so `accounts()` leaves it out; `signInAccounts()`, `start()` and `disconnect()`
+       * take it like any other sign-in provider. Mini App sign-in is Telegram's own.
        */
       telegram: {
         /**
          * Leaves for Telegram Login when the platform configured it (`providers().telegram.login`):
          * `"sign-in"` signs in, or signs up; `"connect"` links Telegram to the signed-in member.
+         *
+         * @deprecated Use `auth.start({ provider: "telegram", mode })`. Removed in 2.0.0.
          */
         start: async (mode, requestOptions) => request("/v1/auth/start", z2.object({ url: z2.string() }), {
           json: {
@@ -2078,13 +1949,21 @@ function relayClient(options) {
           },
           options: requestOptions
         }),
-        /** The member's Telegram account. */
+        /**
+         * The member's Telegram account.
+         *
+         * @deprecated Use the `"telegram"` entry of `auth.signInAccounts()`. Removed in 2.0.0.
+         */
         account: (requestOptions) => request(
           "/v1/auth/accounts/telegram",
           telegramAccountConnectionSchema,
           { options: requestOptions }
         ),
-        /** Unlinks the member's Telegram account, as `disconnect()` does for the other providers. */
+        /**
+         * Unlinks the member's Telegram account, as `disconnect()` does for the other providers.
+         *
+         * @deprecated Use `auth.disconnect("telegram")`. Removed in 2.0.0.
+         */
         disconnect: async (requestOptions) => request("/v1/auth/accounts/disconnect", acknowledged, {
           json: { provider: "telegram" },
           options: requestOptions
@@ -2094,6 +1973,9 @@ function relayClient(options) {
          * (`providers().telegram.miniApp`). Pass the Mini App's signed launch data,
          * `telegramMiniAppInitData()`. Relay checks Telegram's signature for the project's bot and
          * accepts launch data at most five minutes old, once.
+         *
+         * @deprecated Use `relay.telegram.miniApp` from `@domino-sdk/relay/telegram`
+         * (`withTelegram(relay)`). Removed in 2.0.0.
          */
         miniApp: {
           /** Signs in, or signs up, as the Telegram user who opened the Mini App. */
@@ -2144,12 +2026,20 @@ function relayClient(options) {
           options: requestOptions
         })
       },
-      /** The member's connected sign-in accounts, one per provider. */
+      /** The member's connected sign-in accounts, one per `AuthProvider`. */
       accounts: (requestOptions) => request("/v1/auth/accounts", z2.array(accountConnectionSchema), {
         options: requestOptions
       }),
+      /**
+       * The member's account on every sign-in provider the platform has, one entry each, Telegram
+       * included: `accounts()` with an open `provider`, as `providers().signInProviders` lists them.
+       */
+      signInAccounts: (requestOptions) => request("/v1/auth/sign-in-accounts", z2.array(signInAccountSchema), {
+        options: requestOptions
+      }),
+      /** Unlinks the member's account on `provider`, any of `signInAccounts()`'s. */
       disconnect: async (provider, requestOptions) => request("/v1/auth/accounts/disconnect", acknowledged, {
-        json: { provider: parseInput(authProviderSchema, provider) },
+        json: { provider: parseInput(signInProviderInputSchema, provider) },
         options: requestOptions
       }),
       session: (requestOptions) => readSession(requestOptions),
@@ -2159,7 +2049,13 @@ function relayClient(options) {
           options: requestOptions
         })
       ),
-      /** Local development only. Existing hosted apps use createParticipantBackend from /portal-proxy. */
+      /**
+       * @deprecated `POST /v1/auth/exchange` refuses this body with 400: the route takes
+       * `{ subject, accounts?, previousToken? }` with an identity integration server key as the
+       * bearer, which a participant client does not hold. A server signs a user in with
+       * `exchangeParticipant` from `@domino-sdk/relay/portal-proxy`; a hosted app proxies with
+       * `createParticipantBackend` from the same entry. Removed in 2.0.0.
+       */
       exchange: async (value, requestOptions) => request("/v1/auth/exchange", exchangeResultSchema, {
         json: parseInput(exchangeSchema, value),
         options: requestOptions
@@ -2168,6 +2064,12 @@ function relayClient(options) {
     me: {
       badges: (options2) => request("/v1/me/badges", memberBadgesSchema, { options: options2 }),
       activity: {
+        /**
+         * One page of the signed-in member's activity feed, oldest event first. A feed never
+         * ends: every page, even an empty one, answers a `nextCursor` to read from next, so a
+         * loop such as `paginate` never finishes on its own. Stop when a page comes back empty
+         * or after as many events as you need, or follow the feed with `observe`.
+         */
         list: async (query = {}, options2) => {
           const parsed = parseInput(participantActivityQuerySchema, query);
           return request(
@@ -2229,7 +2131,12 @@ function relayClient(options) {
        * The signed-in member, the seed of their generated avatar (`defaultAvatar(avatarSeed)`), and
        * their own verified sign-in email addresses: `email` (or null) and `emails`.
        */
-      get: async (requestOptions) => request("/v1/me", memberSummarySchema, { options: requestOptions }),
+      get: async (requestOptions) => {
+        const me = await request("/v1/me", memberSummarySchema, {
+          options: requestOptions
+        });
+        return { ...me, clock: me.clock ?? { now: Date.now(), offsetMs: 0 } };
+      },
       observeProgress: (listener, observeOptions) => {
         const observer = observeProgress(
           {
@@ -2257,11 +2164,13 @@ function relayClient(options) {
       }),
       /**
        * The member's reward deliveries, newest first, one page at a time. Pass a page's
-       * `nextCursor` back as `cursor` for older ones; `limit` is 1 to 500, 500 by default.
+       * `nextCursor` back as `cursor` for older ones; `limit` is 1 to 500, 500 by default. The
+       * page answers its deliveries as `items` (and, for 1.x callers, as `deliveries`), so
+       * `paginate((cursor) => relay.me.rewardDeliveries({ cursor }))` reads them all.
        */
-      rewardDeliveries: (requestOptions = {}) => {
+      rewardDeliveries: async (requestOptions = {}) => {
         const { cursor, limit, ...options2 } = requestOptions;
-        return request(
+        const page = await request(
           withQuery(
             "/v1/reward-deliveries",
             parseInput(rewardDeliveryQuerySchema, { cursor, limit })
@@ -2269,6 +2178,7 @@ function relayClient(options) {
           rewardDeliveriesSchema,
           { options: options2 }
         );
+        return { ...page, items: page.items ?? page.deliveries };
       },
       /**
        * `{ items }`: the member's balance in each of the project's point ledgers, in the project's
@@ -2301,7 +2211,11 @@ function relayClient(options) {
           { options: requestOptions }
         );
       },
-      /** Claims a quest for the signed-in member. Quest controllers (`quests.open`) call this. */
+      /**
+       * Submits an attempt at a quest for the signed-in member, whatever input the quest takes;
+       * a quest whose interaction is `"claim"` takes none. Quest controllers (`quests.open`) call
+       * this. `quests.claim` is different: it claims an outcome skipped as historical.
+       */
       claim: async (value, requestOptions) => {
         const claim = parseInput(
           submitSchema.omit({ member: true }),
@@ -2396,6 +2310,8 @@ function relayClient(options) {
       )
     }
   };
+  setPluginTransport(client, { signInMethod });
+  return client;
 }
 
 export {