@domino-sdk/relay 1.62.0 → 1.65.0

package/dist/{chunk-5TEYFX6X.js → chunk-SE7XHQFP.js}

@@ -5,7 +5,7 @@ import {
   isKnownTrackerSource,
   trackerDataSchema,
   xAccountRoles
-} from "./chunk-MK425RXJ.js";
+} from "./chunk-HNR6G3GV.js";
 
 // src/quest-shape.ts
 function validateQuestShape(description, options = {}) {
@@ -83,7 +83,7 @@ function sourceRoles(source) {
       return ["author", ...source.accounts ?? []];
   }
 }
-var discordSchemas = /* @__PURE__ */ new Map();
+var discordSchemas = /* @__PURE__ */ (() => /* @__PURE__ */ new Map())();
 function discordDataSchema(source) {
   const key = source.kind === "discord-messages" && source.text ? "messages-text" : source.kind;
   let schema = discordSchemas.get(key);

package/dist/{chunk-CZFXGGEK.js → chunk-U66GUVSG.js}

@@ -110,10 +110,10 @@ function participantRoutePattern(path) {
   });
   return new RegExp("^" + source.join("") + "$");
 }
-var compiled = participantRoutes.map((route) => ({
+var compiled = /* @__PURE__ */ (() => participantRoutes.map((route) => ({
   ...route,
   pattern: participantRoutePattern(route.path)
-}));
+})))();
 function isParticipantRoute(path, method) {
   return compiled.some(
     (route) => route.method === method && route.pattern.test(path)

package/dist/{chunk-KDR2VAJP.js → chunk-UYVJZR33.js}

@@ -1,10 +1,10 @@
 // src/host-environment.ts
 import * as z from "zod";
 var hostEnvironmentPath = "/__domino/environment";
-var hostEnvironmentSchema = z.object({
+var hostEnvironmentSchema = /* @__PURE__ */ (() => z.object({
   environment: z.enum(["test", "live"]),
   kind: z.enum(["staging", "preview", "live"])
-});
+}))();
 var pending;
 async function readHostEnvironment() {
   try {

package/dist/chunk-UZ765UGH.js

@@ -0,0 +1,18 @@
+// src/origins.ts
+var loopbackHosts = [
+  "localhost",
+  "127.0.0.1",
+  "[::1]"
+];
+function secureOrLoopbackOrigin(url, options = {}) {
+  return url.protocol === "https:" || url.protocol === "http:" && (loopbackHosts.includes(url.hostname) || (options.localHosts ?? []).includes(url.hostname));
+}
+function bareOrigin(url) {
+  return !url.username && !url.password && !url.search && !url.hash && url.pathname === "/";
+}
+
+export {
+  loopbackHosts,
+  secureOrLoopbackOrigin,
+  bareOrigin
+};

package/dist/{chunk-GKIFABGN.js → chunk-VBYOAT46.js}

@@ -1,10 +1,21 @@
 import {
   createRelayAction,
   withActionId
-} from "./chunk-Y322OTCH.js";
+} from "./chunk-E22XSC4L.js";
 import {
   setPluginTransport
-} from "./chunk-6WCIWXUV.js";
+} from "./chunk-EUEW2APU.js";
+import {
+  createHttpExchange,
+  untilAborted,
+  withQuery
+} from "./chunk-7H4MRVQF.js";
+import {
+  PARTICIPANT_TIMEOUT,
+  lifetime,
+  retrying,
+  validTimeout
+} from "./chunk-DLABJSBO.js";
 import {
   authProvidersSchema,
   collectionPassSchema,
@@ -23,12 +34,17 @@ import {
   questOutcomeSchema,
   rewardDeliveriesSchema,
   rewardDeliveryQuerySchema
-} from "./chunk-CICDIBOF.js";
+} from "./chunk-MPTE7EIV.js";
 import {
+  exchangeResultSchema,
+  exchangeSchema,
+  memberSummarySchema,
   participantActivityQuerySchema,
   participantActivitySchema,
-  questExperienceSchema
-} from "./chunk-D26YNACF.js";
+  participantSessionSchema,
+  questExperienceSchema,
+  sessionMember
+} from "./chunk-R2KZFX6E.js";
 import {
   engagementBoundaryPageSchema,
   engagementPageQuerySchema,
@@ -39,20 +55,36 @@ import {
   referralDefinitionSchema,
   referralHistorySchema,
   referralSummarySchema
-} from "./chunk-GTDW453U.js";
+} from "./chunk-NG4GZ54I.js";
 import {
   AVATAR_UPLOAD_LIMIT,
+  accountConnectionSchema,
+  attemptSchema,
   avatarUploadTypes,
   badgeCatalogSchema,
   badgeSchema,
+  campaignEnrollmentInputSchema,
+  campaignEnrollmentSchema,
+  campaignWithdrawalInputSchema,
+  contentPerformancePageSchema,
+  contentPerformanceQuerySchema,
+  contentQualificationPageSchema,
+  contentQualificationQuerySchema,
+  evidenceSchema,
+  identifier,
+  knownResponse,
   leaderboardDefinitionResponseSchema,
   leaderboardHistoryPageSchema,
   leaderboardHistoryQuerySchema,
   leaderboardPageSchema,
   leaderboardPlacementSchema,
   leaderboardQuerySchema,
+  linkedWalletSchema,
   memberBadgesSchema,
+  memberProgressSchema,
+  missingPrerequisiteSchema,
   ownProfileSchema,
+  pageQuerySchema,
   pointBalancesSchema,
   pointHistoryPageSchema,
   pointHistoryQuerySchema,
@@ -61,40 +93,7 @@ import {
   profileCompletionQuerySchema,
   profileReferralSchema,
   profileSummarySchema,
-  profileUpdateSchema
-} from "./chunk-WSBYWVTZ.js";
-import {
-  PARTICIPANT_TIMEOUT,
-  clientIdentity,
-  lifetime,
-  retryAfter,
-  retrying,
-  validTimeout
-} from "./chunk-3PYYGFSB.js";
-import {
-  exchangeResultSchema,
-  exchangeSchema,
-  memberSummarySchema,
-  participantSessionSchema,
-  sessionMember
-} from "./chunk-XJFYAXET.js";
-import {
-  accountConnectionSchema,
-  attemptSchema,
-  campaignEnrollmentInputSchema,
-  campaignEnrollmentSchema,
-  campaignWithdrawalInputSchema,
-  contentPerformancePageSchema,
-  contentPerformanceQuerySchema,
-  contentQualificationPageSchema,
-  contentQualificationQuerySchema,
-  evidenceSchema,
-  identifier,
-  knownResponse,
-  linkedWalletSchema,
-  memberProgressSchema,
-  missingPrerequisiteSchema,
-  pageQuerySchema,
+  profileUpdateSchema,
   questSubmissionResultSchema,
   questSubmissionSchema,
   quizEvidenceSchema,
@@ -112,7 +111,7 @@ import {
   walletMessageChallengeSchema,
   walletSignatureSchema,
   walletUnlinkInputSchema
-} from "./chunk-MK425RXJ.js";
+} from "./chunk-HNR6G3GV.js";
 import {
   RelayError,
   RelayErrorCode,
@@ -120,24 +119,24 @@ import {
   isRelayError,
   isRequestError,
   parseInput
-} from "./chunk-K2KS3JLY.js";
+} from "./chunk-EOUEAOWJ.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"),
@@ -163,15 +162,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"
@@ -806,7 +805,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 = () => {
 }) {
@@ -1121,14 +1120,14 @@ function questActions(submission, latest) {
 }
 
 // src/client.ts
-var authStartSchema = z2.strictObject({
+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;
@@ -1144,24 +1143,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;
     }
@@ -1170,59 +1161,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);
 }
@@ -1236,158 +1181,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)) {
@@ -1400,7 +1215,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();
@@ -1410,7 +1225,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
@@ -1869,7 +1684,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));
@@ -2344,11 +2160,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 })
@@ -2356,6 +2174,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
@@ -2388,7 +2207,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 }),