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

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

@@ -3,10 +3,13 @@ import {
   pointLedgerReferenceSchema,
   questExperienceSchema,
   rewardDeliveriesSchema
-} from "./chunk-UFXBQ6FN.js";
+} from "./chunk-MRIURJE3.js";
 import {
   AVATAR_UPLOAD_LIMIT,
+  RelayError,
+  RelayErrorCode,
   avatarUploadTypes,
+  clientError,
   engagementBoundaryPageSchema,
   engagementPageQuerySchema,
   engagementPageSchema,
@@ -16,6 +19,7 @@ import {
   leaderboardQuerySchema,
   linkedWalletSchema,
   ownProfileSchema,
+  parseInput,
   profileCompletionPageSchema,
   profileCompletionQuerySchema,
   profileReferralSchema,
@@ -27,20 +31,18 @@ import {
   referralSummarySchema,
   walletAddressInput,
   walletAddressInputSchema,
-  walletChallengeInputSchema,
-  walletChallengeSchema,
-  walletConnectionSchema,
   walletMessageChallengeSchema,
-  walletProofSchema,
   walletSignInNetworksSchema,
   walletSignatureSchema,
   walletUnlinkInputSchema
-} from "./chunk-DJZB5RY5.js";
+} from "./chunk-V7EZUZ3Z.js";
 import {
   exchangeResultSchema,
+  exchangeSchema,
   memberSummarySchema,
-  sessionSchema
-} from "./chunk-ADSP377G.js";
+  participantSessionSchema,
+  sessionMember
+} from "./chunk-QBOHLT7M.js";
 import {
   accountConnectionSchema,
   attemptSchema,
@@ -55,33 +57,17 @@ import {
   contentQualificationPageSchema,
   contentQualificationQuerySchema,
   contentReleaseInputSchema,
-  entitlementSchema,
-  errorSchema,
   evidenceSchema,
   identifier,
   memberProgressSchema,
-  publishedReleaseSchema,
+  pageQuerySchema,
   quizEvidenceSchema,
-  snapshotSchema,
   submissionEvidenceSchema,
-  templateSchema,
+  submitSchema,
   tieredRewardReferenceSchema,
   validateSubmissionValue,
   valueEvidenceSchema
-} from "./chunk-UW6R2QGT.js";
-
-// src/errors.ts
-var RelayError = class extends Error {
-  constructor(message, status, missing = [], code) {
-    super(message);
-    this.status = status;
-    this.missing = missing;
-    this.code = code;
-  }
-  status;
-  missing;
-  code;
-};
+} from "./chunk-VARGF4JS.js";
 
 // src/submissions.ts
 import { z } from "zod";
@@ -130,15 +116,20 @@ function submissions(transport, configuredStore, namespace) {
     input: "photo"
   }) {
     if (!configuredStore) {
-      throw new Error(
-        "Submissions require durable storage. Use createBrowserRelayClient or provide a SubmissionStore."
+      throw clientError(
+        "Submissions require durable storage. Use createBrowserRelayClient or provide a SubmissionStore.",
+        RelayErrorCode.SubmissionStorage
       );
     }
     const store = configuredStore;
-    identifier.parse(quest);
+    parseInput(identifier, quest);
     const session = await transport.session();
-    if (session?.principal.kind !== "member") {
-      throw new Error("Sign in to submit an activity");
+    const member = sessionMember(session);
+    if (!session || !member) {
+      throw clientError(
+        "Sign in to submit an activity",
+        RelayErrorCode.NotSignedIn
+      );
     }
     const sessionId = session.id;
     const key = JSON.stringify([
@@ -147,14 +138,15 @@ function submissions(transport, configuredStore, namespace) {
       session.organization,
       session.environment,
       session.project,
-      session.principal.member,
+      member,
       quest
     ]);
     async function currentSession() {
       const current = await transport.session();
       if (current?.id !== sessionId) {
-        throw new Error(
-          "Your session changed. Reopen the submission before continuing."
+        throw clientError(
+          "Your session changed. Reopen the submission before continuing.",
+          RelayErrorCode.StaleSession
         );
       }
     }
@@ -165,15 +157,17 @@ function submissions(transport, configuredStore, namespace) {
       }
       const parsed = recordSchema.safeParse(saved);
       if (!parsed.success || parsed.data.quest !== quest) {
-        throw new Error(
-          "Saved submission could not be read. Do not create another claim until it is recovered."
+        throw clientError(
+          "Saved submission could not be read. Do not create another claim until it is recovered.",
+          RelayErrorCode.SubmissionStorage
         );
       }
       const record = parsed.data;
       const input = record.stage === "review" ? record.draft?.kind : "input" in record ? record.input.kind : "photo";
       if (!options.recoverPrevious && input !== options.input) {
-        throw new Error(
-          "Saved submission uses a different input type. Reopen it with its original type to recover it."
+        throw clientError(
+          "Saved submission uses a different input type. Reopen it with its original type to recover it.",
+          RelayErrorCode.SubmissionConflict
         );
       }
       return record;
@@ -222,11 +216,12 @@ function submissions(transport, configuredStore, namespace) {
           await store.write(key, null);
           throw error;
         }
-        if (error instanceof RelayError && error.status === 409 && (error.code === "quest-updated" || error.code === "stale-quiz") && record.stage === "claim") {
+        const changed = !(error instanceof RelayError) || error.status !== 409 ? null : error.code === "quest-updated" ? "quest-updated" : error.code === "stale-quiz" ? "stale-quiz" : null;
+        if (changed && error instanceof RelayError && record.stage === "claim") {
           const draft = "input" in record ? record.input : "file" in record && record.file ? { kind: "photo", file: record.file } : null;
           await store.write(
             key,
-            error.code === "quest-updated" ? {
+            changed === "quest-updated" ? {
               id: record.id,
               quest,
               release: record.release,
@@ -234,7 +229,7 @@ function submissions(transport, configuredStore, namespace) {
               draft
             } : null
           );
-          throw new QuestUpdatedError(error.message, error.code, draft);
+          throw new QuestUpdatedError(error.message, changed, draft, error);
         }
         throw error;
       }
@@ -260,8 +255,9 @@ function submissions(transport, configuredStore, namespace) {
           );
         }
         if (existing && existing.stage !== "submitted" && existing.stage !== "review") {
-          throw new Error(
-            "A submission is unfinished. Resume it before choosing new input."
+          throw clientError(
+            "A submission is unfinished. Resume it before choosing new input.",
+            RelayErrorCode.SubmissionConflict
           );
         }
         if (existing?.stage === "submitted") {
@@ -286,14 +282,16 @@ function submissions(transport, configuredStore, namespace) {
             return;
           }
           if (record.stage !== "submitted") {
-            throw new Error(
-              "Resume the unfinished submission before starting over."
+            throw clientError(
+              "Resume the unfinished submission before starting over.",
+              RelayErrorCode.SubmissionConflict
             );
           }
           const attempt = await claim(record);
           if (attempt.status !== "failed" && attempt.status !== "rejected" && !(options.repeatable && attempt.status === "accepted")) {
-            throw new Error(
-              "Only a failed or rejected submission can be discarded."
+            throw clientError(
+              "Only a failed or rejected submission can be discarded.",
+              RelayErrorCode.SubmissionConflict
             );
           }
           await store.write(key, null);
@@ -315,7 +313,10 @@ function submissions(transport, configuredStore, namespace) {
           await currentSession();
           const record = await read();
           if (!record) {
-            throw new Error("There is no saved submission to resume");
+            throw clientError(
+              "There is no saved submission to resume",
+              RelayErrorCode.SubmissionConflict
+            );
           }
           return resumeRecord(record);
         });
@@ -326,7 +327,7 @@ function submissions(transport, configuredStore, namespace) {
       return {
         ...handle,
         submit(value) {
-          const input = valueEvidenceSchema.parse({ kind, value });
+          const input = parseInput(valueEvidenceSchema, { kind, value });
           return submit({
             id: crypto.randomUUID(),
             quest,
@@ -341,7 +342,7 @@ function submissions(transport, configuredStore, namespace) {
       return {
         ...handle,
         submit(answers, version) {
-          const input = quizEvidenceSchema.parse({
+          const input = parseInput(quizEvidenceSchema, {
             kind: "quiz",
             answers,
             ...version || options.release ? { release: version?.release ?? options.release } : {}
@@ -374,12 +375,18 @@ function submissions(transport, configuredStore, namespace) {
       ...handle,
       async submit(file) {
         if (!["image/jpeg", "image/png"].includes(file.type) || file.size === 0 || file.size > 5 * 1024 * 1024) {
-          throw new Error("Choose a JPG or PNG photo under 5 MB");
+          throw clientError(
+            "Choose a JPG or PNG photo under 5 MB",
+            RelayErrorCode.InvalidInput
+          );
         }
         const bytes = new Uint8Array(await file.slice(0, 4).arrayBuffer());
         const signature = file.type === "image/png" ? [137, 80, 78, 71] : [255, 216, 255];
         if (!signature.every((byte, index) => bytes[index] === byte)) {
-          throw new Error("Image content does not match its file type");
+          throw clientError(
+            "Image content does not match its file type",
+            RelayErrorCode.InvalidInput
+          );
         }
         return submit({
           id: crypto.randomUUID(),
@@ -394,11 +401,18 @@ function submissions(transport, configuredStore, namespace) {
   return open;
 }
 var QuestUpdatedError = class extends RelayError {
-  constructor(message, code, draft) {
-    super(message, 409, [], code);
+  constructor(message, code, draft, source) {
+    super(message, {
+      kind: source?.kind ?? "client",
+      status: source?.status,
+      code,
+      operationId: source?.operationId,
+      cause: source
+    });
     this.draft = draft;
   }
   draft;
+  name = "QuestUpdatedError";
 };
 
 // src/client.ts
@@ -410,8 +424,9 @@ function observeProgress(transport, listener, options = {}, onDispose = () => {
   const interval = options.intervalMs ?? 1500;
   const maximum = options.maxBackoffMs ?? 3e4;
   if (!Number.isFinite(interval) || interval <= 0 || !Number.isFinite(maximum) || maximum < interval) {
-    throw new Error(
-      "Progress polling requires a positive interval and a maximum at least as large"
+    throw clientError(
+      "Progress polling requires a positive interval and a maximum at least as large",
+      RelayErrorCode.InvalidInput
     );
   }
   let disposed = false;
@@ -449,7 +464,8 @@ function observeProgress(transport, listener, options = {}, onDispose = () => {
         sessionId = session?.id ?? null;
         listener({ kind: "session", session });
       }
-      if (session?.principal.kind === "member") {
+      const member = sessionMember(session);
+      if (session && member) {
         const progress = await transport.progress(session.id, request.signal);
         if (!current()) {
           return;
@@ -458,7 +474,7 @@ function observeProgress(transport, listener, options = {}, onDispose = () => {
         if (!current()) {
           return;
         }
-        if (confirmed?.id !== session.id || progress.member !== session.principal.member) {
+        if (confirmed?.id !== session.id || progress.member !== member) {
           sessionId = void 0;
           listener({ kind: "loading" });
           return;
@@ -581,14 +597,17 @@ function questActions(submission, latest) {
           resume: () => run(handle.resume),
           submit: (value) => run(() => {
             if (view.trigger.kind !== "manual" || view.trigger.input !== "text" && view.trigger.input !== "url") {
-              throw new Error("Quest input changed");
+              throw clientError(
+                "Quest input changed",
+                RelayErrorCode.QuestUpdated
+              );
             }
             const problem = validateSubmissionValue(
               { kind, value },
               view.trigger
             );
             if (problem) {
-              throw new Error(problem);
+              throw clientError(problem, RelayErrorCode.InvalidInput);
             }
             return handle.submit(value);
           })
@@ -647,9 +666,76 @@ 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);
+      return parsed.success ? [parsed.data] : [];
+    }) : []
+  };
+}
+async function fromSigner(step) {
+  try {
+    return await step();
+  } catch (error) {
+    if (error instanceof RelayError) {
+      throw error;
+    }
+    throw clientError(
+      error instanceof Error && error.message ? error.message : "The wallet did not complete the request",
+      RelayErrorCode.WalletSigner,
+      { cause: error }
+    );
+  }
+}
+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, error, stage) {
+  const details = {
+    status: stage.status,
+    operationId: call.operationId,
+    uncertain: stage.sent && methodOf(call) !== "GET",
+    cause: error
+  };
+  if (call.options?.signal?.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", {
+      ...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) {
-  async function send(path, init = {}) {
-    const headers = new Headers(init.headers);
+  async function send(path, call = {}) {
+    const method = methodOf(call);
+    const headers = new Headers(call.headers);
+    let body2 = call.body;
     if (options.token) {
       headers.set("Authorization", `Bearer ${options.token}`);
     }
@@ -662,38 +748,97 @@ function createRelayClient(options) {
     if (options.environment) {
       headers.set("X-Relay-Environment", options.environment);
     }
-    if (init.method && init.method !== "GET") {
+    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");
     }
-    const response = await fetch(options.baseUrl + path, {
-      ...init,
-      signal: init.signal ? AbortSignal.any([init.signal, AbortSignal.timeout(15e3)]) : AbortSignal.timeout(15e3),
-      headers
-    });
+    const caller = call.options?.signal;
+    const deadline = AbortSignal.timeout(TIMEOUT_MS);
+    call.deadline = deadline;
+    if (caller?.aborted) {
+      throw interrupted(call, caller.reason, { sent: false });
+    }
+    let response;
+    try {
+      response = await fetch(options.baseUrl + path, {
+        method,
+        headers,
+        body: body2,
+        signal: caller ? AbortSignal.any([caller, deadline]) : deadline
+      });
+    } catch (error) {
+      throw interrupted(call, error, { sent: true });
+    }
     if (!response.ok) {
-      const value = await response.json().catch(() => null);
-      const error = errorSchema.safeParse(value);
-      throw new RelayError(
-        error.success ? error.data.error : `Request failed (${response.status})`,
-        response.status,
-        error.success ? error.data.missing : [],
-        error.success ? error.data.code : void 0
-      );
+      const text = await response.text().catch(() => "");
+      let value = null;
+      try {
+        value = JSON.parse(text);
+      } catch {
+      }
+      const { message, code, missing } = errorBody(value);
+      throw new RelayError(message ?? `Request failed (${response.status})`, {
+        kind: "http",
+        status: response.status,
+        code,
+        missing,
+        operationId: call.operationId,
+        uncertain: methodOf(call) !== "GET" && uncertainStatuses.has(response.status)
+      });
     }
     return response;
   }
-  async function request(path, schema, init = {}) {
-    const response = await send(path, init);
-    const value = await response.json();
-    return schema.parse(value);
+  async function body(response, call, reader) {
+    try {
+      return await reader(response);
+    } catch (error) {
+      throw interrupted(call, error, { sent: true, status: response.status });
+    }
+  }
+  function invalidResponse(status, call, cause) {
+    return new RelayError(
+      "Relay sent a response this SDK version cannot read. Update @domino-sdk/relay.",
+      {
+        kind: "invalid-response",
+        code: RelayErrorCode.InvalidResponse,
+        status,
+        operationId: call.operationId,
+        // Relay accepted the write, but this client cannot tell what it did.
+        uncertain: methodOf(call) !== "GET",
+        cause
+      }
+    );
   }
-  async function walletRequest(path, schema, init = {}) {
+  async function read(response, schema, call) {
+    const text = await body(response, call, (value2) => value2.text());
+    let value;
+    try {
+      value = JSON.parse(text);
+    } catch (error) {
+      throw invalidResponse(response.status, call, error);
+    }
+    const parsed = schema.safeParse(value);
+    if (!parsed.success) {
+      throw invalidResponse(response.status, call, parsed.error);
+    }
+    return parsed.data;
+  }
+  async function request(path, schema, call = {}) {
+    return read(await send(path, call), schema, call);
+  }
+  async function walletRequest(path, schema, call = {}) {
     for (let attempt = 0; ; attempt++) {
       let response;
       try {
-        response = await send(path, init);
+        response = await send(path, call);
       } catch (error) {
-        const transient = error instanceof RelayError && [500, 502, 503, 504].includes(error.status) || error instanceof TypeError || error instanceof DOMException && error.name === "TimeoutError";
+        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;
         }
@@ -702,54 +847,40 @@ function createRelayClient(options) {
         );
         continue;
       }
-      const value = await response.json();
-      return schema.parse(value);
+      return read(response, schema, call);
     }
   }
-  function query(path, values) {
-    const params = new URLSearchParams();
-    for (const [key, value] of Object.entries(values)) {
-      if (value !== void 0) {
-        params.set(key, String(value));
-      }
+  const readSession = (requestOptions) => request("/v1/auth/session", participantSessionSchema.nullable(), {
+    options: { signal: requestOptions?.signal }
+  });
+  async function bound(requestOptions = {}) {
+    if (requestOptions.session) {
+      return requestOptions;
     }
-    return path + "?" + params;
-  }
-  function json(body) {
-    return {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(body)
-    };
-  }
-  function sessionHeaders(session) {
-    return { "Content-Type": "application/json", "X-Relay-Session": session };
+    const session = await readSession(requestOptions);
+    if (session?.principal.kind !== "member") {
+      throw clientError("Sign in to continue", RelayErrorCode.NotSignedIn);
+    }
+    return { ...requestOptions, session: session.id };
   }
   const submission = submissions(
     {
-      session: () => request("/v1/auth/session", sessionSchema.nullable()),
+      session: () => readSession(),
       upload: (file, action, session) => request("/v1/me/evidence", evidenceSchema, {
         method: "POST",
-        headers: {
-          "Content-Type": file.type,
-          "X-Relay-Upload-ID": action,
-          "X-Relay-Session": session
-        },
-        body: file
+        body: file,
+        headers: { "Content-Type": file.type, "X-Relay-Upload-ID": action },
+        options: { session },
+        operationId: action
       }),
-      claim: (input, session) => request("/v1/me/attempts", attemptSchema, {
-        ...json(input),
-        headers: {
-          "Content-Type": "application/json",
-          "X-Relay-Session": session
-        }
+      claim: async (claim, session) => request("/v1/me/attempts", attemptSchema, {
+        json: claim,
+        options: { session },
+        operationId: claim.actionId
       }),
       retry: (attempt, session) => request(`/v1/attempts/${attempt}/retry`, attemptSchema, {
-        ...json({}),
-        headers: {
-          "Content-Type": "application/json",
-          "X-Relay-Session": session
-        }
+        json: {},
+        options: { session }
       })
     },
     options.submissionStore,
@@ -768,180 +899,205 @@ function createRelayClient(options) {
       }
     }
   }
-  const experience = () => request("/v1/me/experience", questExperienceSchema);
-  async function getQuest(id) {
-    const quest = (await experience()).quests.find(
+  const experience = (requestOptions) => request("/v1/me/experience", questExperienceSchema, {
+    options: requestOptions
+  });
+  async function getQuest(id, requestOptions) {
+    const quest = (await experience(requestOptions)).quests.find(
       (q) => q.quest === id || q.key === id
     );
     if (!quest) {
-      throw new RelayError("Quest not found", 404);
+      throw clientError("Quest not found", RelayErrorCode.NotFound);
     }
     return quest;
   }
+  const ok = z2.object({ ok: z2.literal(true) });
+  const acknowledged = z2.object({ ok: z2.boolean() });
   return {
     referrals: {
-      list: () => request("/v1/referrals", z2.array(referralDefinitionSchema)),
-      summary: () => request("/v1/referrals/me", referralSummarySchema),
-      history: (before) => request(
-        query("/v1/referrals/history", { before }),
-        referralHistorySchema
+      list: (requestOptions) => request("/v1/referrals", z2.array(referralDefinitionSchema), {
+        options: requestOptions
+      }),
+      summary: (requestOptions) => request("/v1/referrals/me", referralSummarySchema, {
+        options: requestOptions
+      }),
+      /** The member's referral point history, newest first. */
+      history: async (query = {}, requestOptions) => request(
+        withQuery("/v1/referrals/history", parseInput(pageQuerySchema, query)),
+        referralHistorySchema,
+        { options: requestOptions }
       ),
-      accept: (input) => request("/v1/referrals/accept", z2.object({ ok: z2.literal(true) }), {
-        method: "POST",
-        body: JSON.stringify(referralAcceptSchema.parse(input))
-      })
+      accept: async (value, requestOptions) => {
+        const body2 = parseInput(referralAcceptSchema, value);
+        return request("/v1/referrals/accept", ok, {
+          json: body2,
+          options: requestOptions,
+          operationId: body2.actionId
+        });
+      }
     },
     tieredRewards: {
       /**
        * The project's tiered rewards with their keys. Entitlements and reward
        * definitions name them by ID: use this to find the ID for a key.
        */
-      list: () => request("/v1/tiered-rewards", z2.array(tieredRewardReferenceSchema))
+      list: (requestOptions) => request("/v1/tiered-rewards", z2.array(tieredRewardReferenceSchema), {
+        options: requestOptions
+      })
     },
     pointLedgers: {
       /**
        * The project's point ledgers with their keys and names. Reads return
        * ledger IDs: use this to find the ID for a key, or a ledger's name.
        */
-      list: () => request("/v1/point-ledgers", z2.array(pointLedgerReferenceSchema))
+      list: (requestOptions) => request("/v1/point-ledgers", z2.array(pointLedgerReferenceSchema), {
+        options: requestOptions
+      })
     },
     leaderboards: {
-      list: () => request("/v1/leaderboards", z2.array(leaderboardDefinitionSchema)),
-      standings: (board, options2 = {}) => {
-        const parsed = leaderboardQuerySchema.parse(options2);
-        return request(
-          query(`/v1/leaderboards/${identifier.parse(board)}`, parsed),
-          leaderboardPageSchema
-        );
-      },
+      list: (requestOptions) => request("/v1/leaderboards", z2.array(leaderboardDefinitionSchema), {
+        options: requestOptions
+      }),
+      standings: async (board, query = {}, requestOptions) => request(
+        withQuery(
+          `/v1/leaderboards/${parseInput(identifier, board)}`,
+          parseInput(leaderboardQuerySchema, query)
+        ),
+        leaderboardPageSchema,
+        { options: requestOptions }
+      ),
       /**
        * A profile's current rank and score on `board` (`profile.id` from a leaderboard row or
        * `profiles.mine()`). Needs the board's access, like `standings`; a profile this viewer
        * cannot see is a 404, as in `profiles.get`.
        */
-      placement: (board, profile) => request(
-        `/v1/leaderboards/${identifier.parse(board)}/profiles/${identifier.parse(profile)}`,
-        leaderboardPlacementSchema
+      placement: async (board, profile, requestOptions) => request(
+        `/v1/leaderboards/${parseInput(identifier, board)}/profiles/${parseInput(identifier, profile)}`,
+        leaderboardPlacementSchema,
+        { options: requestOptions }
       )
     },
     /**
      * Participant profiles: the display name and avatar other participants see where the project
-     * enables profiles in Console. Render an avatar with `avatarSrc(profile.avatar)`.
+     * enables profiles in Console. Render an avatar with `avatarSrc(profile.avatar)` from
+     * `@domino-sdk/relay/avatar`.
      */
     profiles: {
       /** The signed-in member's own profile, whatever the project shows to others. */
-      mine: () => request("/v1/me/profile", ownProfileSchema),
+      mine: (requestOptions) => request("/v1/me/profile", ownProfileSchema, {
+        options: requestOptions
+      }),
       /**
        * Changes the member's own name, avatar choice or visibility; omitted fields stay, and null
-       * returns to the default. `session` (the ID the app read) makes a changed session a 409.
+       * returns to the default.
        */
-      update: async (input, options2 = {}) => request("/v1/me/profile", ownProfileSchema, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          ...options2.session ? { "X-Relay-Session": options2.session } : {}
-        },
-        body: JSON.stringify(profileUpdateSchema.parse(input))
+      update: async (value, requestOptions) => request("/v1/me/profile", ownProfileSchema, {
+        json: parseInput(profileUpdateSchema, value),
+        options: requestOptions
       }),
       /**
        * 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.
        */
-      uploadAvatar: async (file, options2 = {}) => {
+      uploadAvatar: async (file, requestOptions = {}) => {
         if (!avatarUploadTypes.includes(file.type)) {
-          throw new RelayError("Use a JPEG, PNG or WebP image", 400);
+          throw clientError(
+            "Use a JPEG, PNG or WebP image",
+            RelayErrorCode.InvalidInput
+          );
         }
         if (file.size > AVATAR_UPLOAD_LIMIT) {
-          throw new RelayError("Use an image smaller than 5 MB", 413);
+          throw clientError(
+            "Use an image smaller than 5 MB",
+            RelayErrorCode.InvalidInput
+          );
         }
+        const { uploadId, ...rest } = requestOptions;
+        const operationId = parseInput(identifier, uploadId ?? crypto.randomUUID());
         return request("/v1/me/profile/avatar", ownProfileSchema, {
           method: "POST",
+          body: file,
           headers: {
             "Content-Type": file.type,
-            "X-Relay-Upload-ID": identifier.parse(
-              options2.uploadId ?? crypto.randomUUID()
-            ),
-            ...options2.session ? { "X-Relay-Session": options2.session } : {}
+            "X-Relay-Upload-ID": operationId
           },
-          body: file
+          options: rest,
+          operationId
         });
       },
       /**
        * A profile's name and avatar by its public ID (`profile.id` from a leaderboard row or
        * `mine()`). A profile that is missing, hidden or not visible to this viewer is a 404.
        */
-      get: (profile) => request(
-        `/v1/profiles/${identifier.parse(profile)}`,
-        profileSummarySchema
+      get: async (profile, requestOptions) => request(
+        `/v1/profiles/${parseInput(identifier, profile)}`,
+        profileSummarySchema,
+        { options: requestOptions }
       ),
       /**
        * A page of the profile's completions of quests that show on profiles, most recently
-       * completed first. Pass the page's `nextCursor` as `cursor` for the next one.
+       * completed first.
        */
-      completions: (profile, options2 = {}) => request(
-        query(
-          `/v1/profiles/${identifier.parse(profile)}/completions`,
-          profileCompletionQuerySchema.parse(options2)
+      completions: async (profile, query = {}, requestOptions) => request(
+        withQuery(
+          `/v1/profiles/${parseInput(identifier, profile)}/completions`,
+          parseInput(profileCompletionQuerySchema, query)
         ),
-        profileCompletionPageSchema
+        profileCompletionPageSchema,
+        { options: requestOptions }
       ),
       /**
        * The profile's invited and qualified counts and milestones in one referral program. Needs
        * a signed-in participant, as referral programs do.
        */
-      referral: (profile, program) => request(
-        `/v1/profiles/${identifier.parse(profile)}/referrals/${identifier.parse(program)}`,
-        profileReferralSchema
+      referral: async (profile, program, requestOptions) => request(
+        `/v1/profiles/${parseInput(identifier, profile)}/referrals/${parseInput(identifier, program)}`,
+        profileReferralSchema,
+        { options: requestOptions }
       )
     },
     quests: {
       get: getQuest,
-      retry: async (view) => {
+      /** Retries verification of the quest's failed attempt. */
+      retry: async (view, requestOptions) => {
         if (view.trigger.kind === "automatic") {
-          throw new Error(
-            "Automatic quests recover without participant retries."
+          throw clientError(
+            "Automatic quests recover without participant retries.",
+            RelayErrorCode.RetryUnavailable
           );
         }
         if (!view.attempt || view.attempt.status !== "failed") {
-          throw new Error("There is no failed attempt to retry.");
-        }
-        const session = await request(
-          "/v1/auth/session",
-          sessionSchema.nullable()
-        );
-        if (session?.principal.kind !== "member") {
-          throw new Error("Sign in to retry verification.");
+          throw clientError(
+            "There is no failed attempt to retry.",
+            RelayErrorCode.RetryUnavailable
+          );
         }
         return request(`/v1/attempts/${view.attempt.id}/retry`, attemptSchema, {
-          ...json({}),
-          headers: {
-            "Content-Type": "application/json",
-            "X-Relay-Session": session.id
-          }
+          json: {},
+          options: await bound(requestOptions)
         });
       },
       experience,
-      collection: async (id) => {
-        const collection = (await experience()).collections.find(
+      collection: async (id, requestOptions) => {
+        const collection = (await experience(requestOptions)).collections.find(
           (c) => c.id === id || c.key === id
         );
         if (!collection) {
-          throw new RelayError("Collection not found", 404);
+          throw clientError("Collection not found", RelayErrorCode.NotFound);
         }
         return collection;
       },
-      open: questActions(submission, getQuest),
-      observe: (listener, options2) => {
+      open: questActions(submission, (id) => getQuest(id)),
+      observe: (listener, observeOptions) => {
         const observer = observeProgress(
           {
-            session: (signal) => request("/v1/auth/session", sessionSchema.nullable(), { signal }),
+            session: (signal) => readSession({ signal }),
             progress: (session, signal) => request("/v1/me/experience", questExperienceSchema, {
-              signal,
-              headers: { "X-Relay-Session": session }
+              options: { session, signal }
             })
           },
           listener,
-          options2,
+          observeOptions,
           () => observers.delete(observer)
         );
         observers.add(observer);
@@ -952,75 +1108,59 @@ function createRelayClient(options) {
     },
     /** The signed-in member's linked Solana, EVM and Cosmos wallets for this project. */
     wallets: {
-      list: () => walletRequest(
+      list: (requestOptions) => walletRequest(
         "/v1/me/wallets",
-        z2.object({ wallets: z2.array(linkedWalletSchema) })
+        z2.object({ wallets: z2.array(linkedWalletSchema) }),
+        { options: requestOptions }
       ).then((result) => result.wallets),
-      challenge: (input, session) => walletRequest(
+      challenge: async (value, requestOptions) => walletRequest(
         "/v1/me/wallets/challenge",
         walletMessageChallengeSchema,
         {
-          ...json(walletAddressInputSchema.parse(input)),
-          headers: sessionHeaders(session)
+          json: parseInput(walletAddressInputSchema, value),
+          options: await bound(requestOptions)
         }
       ),
-      verify: (input, session) => walletRequest("/v1/me/wallets/verify", linkedWalletSchema, {
-        ...json(walletSignatureSchema.parse(input)),
-        headers: sessionHeaders(session)
+      verify: async (value, requestOptions) => walletRequest("/v1/me/wallets/verify", linkedWalletSchema, {
+        json: parseInput(walletSignatureSchema, value),
+        options: await bound(requestOptions)
       }),
       /** The address stays bound to this member: another member still cannot link it. */
-      unlink: (wallet) => request(
-        "/v1/me/wallets/unlink",
-        z2.object({ ok: z2.literal(true) }),
-        json(
-          walletUnlinkInputSchema.parse({
-            chain: wallet.chain,
-            address: wallet.address
-          })
-        )
-      ),
+      unlink: async (wallet, requestOptions) => request("/v1/me/wallets/unlink", ok, {
+        json: parseInput(walletUnlinkInputSchema, {
+          chain: wallet.chain,
+          address: wallet.address
+        }),
+        options: requestOptions
+      }),
       /** Asks the signer for its address, signs the returned challenge, and links the wallet. */
-      link: async (signer) => {
-        const session = await request(
-          "/v1/auth/session",
-          sessionSchema.nullable()
-        );
-        if (!session) {
-          throw new RelayError("Sign in to continue", 401);
-        }
+      link: async (signer, requestOptions) => {
+        const session = await bound(requestOptions);
         const challenge = await walletRequest(
           "/v1/me/wallets/challenge",
           walletMessageChallengeSchema,
           {
-            ...json(
-              walletAddressInputSchema.parse(await walletAddressInput(signer))
+            json: parseInput(
+              walletAddressInputSchema,
+              await fromSigner(() => walletAddressInput(signer))
             ),
-            headers: sessionHeaders(session.id)
+            options: session
           }
         );
-        const proof = await signer.sign(challenge.message, challenge.address);
+        const proof = await fromSigner(
+          () => signer.sign(challenge.message, challenge.address)
+        );
         return walletRequest("/v1/me/wallets/verify", linkedWalletSchema, {
-          ...json(
-            walletSignatureSchema.parse({ challenge: challenge.id, ...proof })
-          ),
-          headers: sessionHeaders(session.id)
+          json: parseInput(walletSignatureSchema, {
+            challenge: challenge.id,
+            ...proof
+          }),
+          options: session
         });
       }
     },
-    /** @deprecated Use `wallets` (multi-chain). This reads and replaces the newest Solana wallet. */
-    wallet: {
-      connection: () => walletRequest("/v1/me/wallet", walletConnectionSchema.nullable()),
-      challenge: (input, session) => walletRequest("/v1/me/wallet/challenge", walletChallengeSchema, {
-        ...json(walletChallengeInputSchema.parse(input)),
-        headers: sessionHeaders(session)
-      }),
-      verify: (input, session) => walletRequest("/v1/me/wallet/verify", walletConnectionSchema, {
-        ...json(walletProofSchema.parse(input)),
-        headers: sessionHeaders(session)
-      })
-    },
     auth: {
-      providers: () => request(
+      providers: (requestOptions) => request(
         "/v1/auth/providers",
         z2.object({
           providers: z2.array(
@@ -1033,108 +1173,116 @@ function createRelayClient(options) {
           /** The wallet sign-in this project enabled; older servers omit it. */
           wallets: walletSignInNetworksSchema.default([]),
           demo: z2.boolean()
-        })
-      ),
-      start: (provider, mode) => request(
-        "/v1/auth/start",
-        z2.object({ url: z2.string() }),
-        json({ provider, mode })
-      ),
-      emailStart: (email) => request(
-        "/v1/auth/email/start",
-        z2.object({ challenge: z2.string() }),
-        json({ email })
-      ),
-      emailVerify: (challenge, code) => changeSession(
-        () => request(
-          "/v1/auth/email/verify",
-          sessionSchema,
-          json({ challenge, code })
-        )
+        }),
+        { options: requestOptions }
       ),
+      start: async (provider, mode, requestOptions) => request("/v1/auth/start", z2.object({ url: z2.string() }), {
+        json: {
+          provider: parseInput(authProviderSchema, provider),
+          mode: parseInput(z2.enum(["sign-in", "connect"]), mode)
+        },
+        options: requestOptions
+      }),
+      emailStart: async (email, requestOptions) => request("/v1/auth/email/start", z2.object({ challenge: z2.string() }), {
+        json: { email: parseInput(z2.email().max(254), email.trim()) },
+        options: requestOptions
+      }),
+      emailVerify: async (challenge, code, requestOptions) => {
+        const body2 = {
+          challenge: parseInput(z2.string().min(1).max(200), challenge),
+          code: parseInput(
+            z2.string().regex(/^\d{6}$/, "Enter the 6-digit code"),
+            code.trim()
+          )
+        };
+        return changeSession(
+          () => request("/v1/auth/email/verify", participantSessionSchema, {
+            json: body2,
+            options: requestOptions
+          })
+        );
+      },
       /**
        * Sign in, or sign up, with a Solana, EVM or Cosmos wallet where the project enabled it
        * (`providers().wallets`). A wallet the member linked while signed in cannot sign in.
        */
       wallet: {
         /** A sign-in challenge for the wallet's address; binds the flow to this browser. */
-        start: (input) => request(
-          "/v1/auth/wallet/start",
-          walletMessageChallengeSchema,
-          json(walletAddressInputSchema.parse(input))
-        ),
+        start: async (value, requestOptions) => request("/v1/auth/wallet/start", walletMessageChallengeSchema, {
+          json: parseInput(walletAddressInputSchema, value),
+          options: requestOptions
+        }),
         /** Verifies the signed challenge and starts the session. Not retried: start again instead. */
-        verify: (proof) => changeSession(
-          () => request(
-            "/v1/auth/wallet/verify",
-            sessionSchema,
-            json(walletSignatureSchema.parse(proof))
-          )
+        verify: (proof, requestOptions) => changeSession(
+          () => request("/v1/auth/wallet/verify", participantSessionSchema, {
+            json: parseInput(walletSignatureSchema, proof),
+            options: requestOptions
+          })
         ),
         /**
-         * Asks the signer for its address, signs the challenge and starts the session. Throws a
-         * `RelayError` with status 403 when the project has not enabled this wallet family.
+         * Asks the signer for its address, signs the challenge and starts the session. Rejects with
+         * an `http` `RelayError` (status 403) when the project has not enabled this wallet family.
          */
-        signIn: async (signer) => {
+        signIn: async (signer, requestOptions) => {
           const challenge = await request(
             "/v1/auth/wallet/start",
             walletMessageChallengeSchema,
-            json(
-              walletAddressInputSchema.parse(await walletAddressInput(signer))
-            )
+            {
+              json: parseInput(
+                walletAddressInputSchema,
+                await fromSigner(() => walletAddressInput(signer))
+              ),
+              options: requestOptions
+            }
+          );
+          const proof = await fromSigner(
+            () => signer.sign(challenge.message, challenge.address)
           );
-          const proof = await signer.sign(challenge.message, challenge.address);
           return changeSession(
-            () => request(
-              "/v1/auth/wallet/verify",
-              sessionSchema,
-              json(
-                walletSignatureSchema.parse({
-                  challenge: challenge.id,
-                  ...proof
-                })
-              )
-            )
+            () => request("/v1/auth/wallet/verify", participantSessionSchema, {
+              json: parseInput(walletSignatureSchema, {
+                challenge: challenge.id,
+                ...proof
+              }),
+              options: requestOptions
+            })
           );
         }
       },
-      accounts: () => request("/v1/auth/accounts", z2.array(accountConnectionSchema)),
-      disconnect: (provider) => request(
-        "/v1/auth/accounts/disconnect",
-        z2.object({ ok: z2.boolean() }),
-        json({ provider })
-      ),
-      connections: () => request(
-        "/v1/auth/connections",
-        z2.array(
-          z2.object({
-            provider: z2.string(),
-            subject: z2.string(),
-            signInEnabled: z2.boolean()
-          })
-        )
-      ),
-      session: () => request("/v1/auth/session", sessionSchema.nullable()),
-      signOut: () => changeSession(
-        () => request("/v1/auth/logout", z2.object({ ok: z2.boolean() }), json({}))
+      /** The member's connected sign-in accounts, one per provider. */
+      accounts: (requestOptions) => request("/v1/auth/accounts", z2.array(accountConnectionSchema), {
+        options: requestOptions
+      }),
+      disconnect: async (provider, requestOptions) => request("/v1/auth/accounts/disconnect", acknowledged, {
+        json: { provider: parseInput(authProviderSchema, provider) },
+        options: requestOptions
+      }),
+      session: (requestOptions) => readSession(requestOptions),
+      signOut: (requestOptions) => changeSession(
+        () => request("/v1/auth/logout", acknowledged, {
+          json: {},
+          options: requestOptions
+        })
       ),
       /** Local development only. Existing hosted apps use createParticipantBackend from /portal-proxy. */
-      exchange: (input) => request("/v1/auth/exchange", exchangeResultSchema, json(input))
+      exchange: async (value, requestOptions) => request("/v1/auth/exchange", exchangeResultSchema, {
+        json: parseInput(exchangeSchema, value),
+        options: requestOptions
+      })
     },
     me: {
       /** The signed-in member, and the seed of their generated avatar: `defaultAvatar(avatarSeed)`. */
-      get: () => request("/v1/me", memberSummarySchema),
-      observeProgress: (listener, options2) => {
+      get: async (requestOptions) => request("/v1/me", memberSummarySchema, { options: requestOptions }),
+      observeProgress: (listener, observeOptions) => {
         const observer = observeProgress(
           {
-            session: (signal) => request("/v1/auth/session", sessionSchema.nullable(), { signal }),
+            session: (signal) => readSession({ signal }),
             progress: (session, signal) => request("/v1/me/progress", memberProgressSchema, {
-              signal,
-              headers: { "X-Relay-Session": session }
+              options: { session, signal }
             })
           },
           listener,
-          options2,
+          observeOptions,
           () => observers.delete(observer)
         );
         observers.add(observer);
@@ -1143,147 +1291,117 @@ function createRelayClient(options) {
         return { refresh: observer.refresh, dispose: observer.dispose };
       },
       submission,
-      collectionPass: (entitlement, session) => request("/v1/me/collection-pass", collectionPassSchema, {
-        ...json({ entitlement: identifier.parse(entitlement) }),
-        headers: {
-          "Content-Type": "application/json",
-          "X-Relay-Session": session
-        }
+      collectionPass: async (entitlement, requestOptions) => request("/v1/me/collection-pass", collectionPassSchema, {
+        json: { entitlement: parseInput(identifier, entitlement) },
+        options: await bound(requestOptions)
       }),
-      /** @deprecated The participant API does not verify passes. Verify them on your server and call `POST /management/v1/passes/verify`. */
-      linkPass: (code) => request("/v1/me/pass", attemptSchema, json({ code })),
-      progress: () => request("/v1/me/progress", memberProgressSchema),
-      rewardDeliveries: () => request("/v1/reward-deliveries", rewardDeliveriesSchema),
-      claim: (input, options2) => request("/v1/me/attempts", attemptSchema, {
-        ...json(input),
-        headers: {
-          "Content-Type": "application/json",
-          ...options2 ? { "X-Relay-Session": options2.session } : {}
-        }
+      progress: (requestOptions) => request("/v1/me/progress", memberProgressSchema, {
+        options: requestOptions
       }),
-      upload: (file) => request("/v1/me/evidence", evidenceSchema, {
+      rewardDeliveries: (requestOptions) => request("/v1/reward-deliveries", rewardDeliveriesSchema, {
+        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);
+        return request("/v1/me/attempts", attemptSchema, {
+          json: claim,
+          options: requestOptions,
+          operationId: claim.actionId
+        });
+      },
+      /** Uploads a photo as the signed-in member's evidence. */
+      upload: (file, requestOptions) => request("/v1/me/evidence", evidenceSchema, {
         method: "POST",
+        body: file,
         headers: { "Content-Type": file.type },
-        body: file
+        options: requestOptions
       })
     },
     evidence: {
       async download(id, requestOptions) {
+        const call = { options: requestOptions };
         const response = await send(
-          `/v1/evidence/${identifier.parse(id)}`,
-          requestOptions
+          `/v1/evidence/${parseInput(identifier, id)}`,
+          call
         );
         const type = response.headers.get("Content-Type");
         if (type !== "image/jpeg" && type !== "image/png") {
-          throw new RelayError("Unexpected evidence content type", 502);
+          throw invalidResponse(
+            response.status,
+            call,
+            new Error("Unexpected evidence content type")
+          );
         }
-        return response.blob();
+        return body(response, call, (value) => value.blob());
       }
     },
-    /** @deprecated The participant API accepts only member sessions and rejects this staff call. Use the management API with a management key instead. */
-    lookupMember: (issuer, subject) => request(
-      "/v1/members/lookup",
-      z2.object({ member: z2.string() }),
-      json({ issuer, subject })
-    ),
-    /** @deprecated Removed from the participant API. Build quests with `domino` and `@domino-sdk/relay/build`. */
-    journeyTemplate: () => request("/v1/journey-template", z2.array(templateSchema)),
-    /** @deprecated Removed from the participant API. Build quests with `domino` and `@domino-sdk/relay/build`. */
-    template: () => request("/v1/template", templateSchema),
-    /** @deprecated The participant API accepts only member sessions and rejects this staff call. Use the management API with a management key instead. */
-    snapshot: () => request("/v1/snapshot", snapshotSchema),
-    /** @deprecated The participant API rejects publication. Publish with `domino deploy` or the management API. */
-    publish: (release) => request("/v1/releases", publishedReleaseSchema, json(release)),
-    /** @deprecated The participant API rejects publication. Publish with `domino deploy` or the management API. */
-    publishBatch: (releases) => request(
-      "/v1/releases/batch",
-      z2.array(publishedReleaseSchema),
-      json({ releases })
-    ),
-    progress: (member) => request(
-      `/v1/members/${encodeURIComponent(member)}/progress`,
-      memberProgressSchema
-    ),
-    /** @deprecated The participant API accepts only member sessions and rejects this staff call. Use the management API with a management key instead. */
-    beginHandover: (id, input) => request(`/v1/entitlements/${id}/begin`, entitlementSchema, json(input)),
-    /** @deprecated The participant API accepts only member sessions and rejects this staff call. Use the management API with a management key instead. */
-    confirmHandover: (id, input) => request(`/v1/entitlements/${id}/confirm`, entitlementSchema, json(input)),
-    upload: (member, file) => request(
-      `/v1/evidence?member=${encodeURIComponent(member)}`,
-      evidenceSchema,
-      {
-        method: "POST",
-        headers: { "Content-Type": file.type },
-        body: file
-      }
-    ),
     engagement: {
-      boundaries: (input) => request(
-        "/v1/engagement/boundaries?" + new URLSearchParams(
-          Object.entries(engagementPageQuerySchema.parse(input)).flatMap(
-            ([key, value]) => value === void 0 ? [] : [[key, String(value)]]
-          )
-        ).toString(),
-        engagementBoundaryPageSchema
+      /** The member's engagement settlements for one post under one rule, newest first. */
+      page: async (query, requestOptions) => request(
+        withQuery(
+          "/v1/engagement/history",
+          parseInput(engagementPageQuerySchema, query)
+        ),
+        engagementPageSchema,
+        { options: requestOptions }
       ),
-      page: (input) => request(
-        "/v1/engagement/history?" + new URLSearchParams(
-          Object.entries(engagementPageQuerySchema.parse(input)).flatMap(
-            ([key, value]) => value === void 0 ? [] : [[key, String(value)]]
-          )
-        ).toString(),
-        engagementPageSchema
+      /** The formula boundaries the member's settlements for one post crossed, newest first. */
+      boundaries: async (query, requestOptions) => request(
+        withQuery(
+          "/v1/engagement/boundaries",
+          parseInput(engagementPageQuerySchema, query)
+        ),
+        engagementBoundaryPageSchema,
+        { options: requestOptions }
       )
     },
     content: {
-      performance: (input) => request(
-        "/v1/content/performance?" + new URLSearchParams(
-          Object.entries(
-            contentPerformanceQuerySchema.parse(input)
-          ).flatMap(
-            ([key, value]) => value === void 0 ? [] : [[key, String(value)]]
-          )
-        ).toString(),
-        contentPerformancePageSchema
-      ),
-      qualifications: (input) => request(
-        "/v1/content/qualifications?" + new URLSearchParams(
-          Object.entries(
-            contentQualificationQuerySchema.parse(input)
-          ).flatMap(
-            ([key, value]) => value === void 0 ? [] : [[key, String(value)]]
-          )
-        ).toString(),
-        contentQualificationPageSchema
+      performance: async (query, requestOptions) => request(
+        withQuery(
+          "/v1/content/performance",
+          parseInput(contentPerformanceQuerySchema, query)
+        ),
+        contentPerformancePageSchema,
+        { options: requestOptions }
       ),
-      admissions: (input) => request(
-        "/v1/content/admissions?" + new URLSearchParams(
-          Object.entries(contentAdmissionQuerySchema.parse(input)).flatMap(
-            ([key, value]) => value === void 0 ? [] : [[key, value]]
-          )
-        ).toString(),
-        contentAdmissionPageSchema
+      qualifications: async (query, requestOptions) => request(
+        withQuery(
+          "/v1/content/qualifications",
+          parseInput(contentQualificationQuerySchema, query)
+        ),
+        contentQualificationPageSchema,
+        { options: requestOptions }
       ),
-      enroll: (input) => request(
-        "/v1/content/enrollments",
-        contentEnrollmentSchema,
-        json(contentEnrollmentInputSchema.parse(input))
+      admissions: async (query, requestOptions) => request(
+        withQuery(
+          "/v1/content/admissions",
+          parseInput(contentAdmissionQuerySchema, query)
+        ),
+        contentAdmissionPageSchema,
+        { options: requestOptions }
       ),
-      claim: (input) => request(
-        "/v1/content/claims",
-        contentAdmissionSchema,
-        json(contentReleaseInputSchema.parse(input))
-      )
-    },
-    submit: (input) => request("/v1/attempts", attemptSchema, json(input)),
-    retry: (id) => request(`/v1/attempts/${id}/retry`, attemptSchema, json({})),
-    /** @deprecated The participant API accepts only member sessions and rejects this staff call. Use the management API with a management key instead. */
-    decide: (id, input) => request(`/v1/attempts/${id}/review`, attemptSchema, json(input))
+      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
+        });
+      }
+    }
   };
 }
 
 export {
-  RelayError,
   QuestUpdatedError,
   createRelayClient
 };