@domino-sdk/relay 1.62.0 → 1.63.0

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

@@ -1,10 +1,10 @@
 import {
   createRelayAction,
   withActionId
-} from "./chunk-Y322OTCH.js";
+} from "./chunk-AQOL3SK5.js";
 import {
   setPluginTransport
-} from "./chunk-6WCIWXUV.js";
+} from "./chunk-MTKRIQEU.js";
 import {
   authProvidersSchema,
   collectionPassSchema,
@@ -23,12 +23,12 @@ import {
   questOutcomeSchema,
   rewardDeliveriesSchema,
   rewardDeliveryQuerySchema
-} from "./chunk-CICDIBOF.js";
+} from "./chunk-EHUSD3O2.js";
 import {
   participantActivityQuerySchema,
   participantActivitySchema,
   questExperienceSchema
-} from "./chunk-D26YNACF.js";
+} from "./chunk-4NOFSGAL.js";
 import {
   engagementBoundaryPageSchema,
   engagementPageQuerySchema,
@@ -39,7 +39,7 @@ import {
   referralDefinitionSchema,
   referralHistorySchema,
   referralSummarySchema
-} from "./chunk-GTDW453U.js";
+} from "./chunk-QR6HH4DI.js";
 import {
   AVATAR_UPLOAD_LIMIT,
   avatarUploadTypes,
@@ -62,22 +62,25 @@ import {
   profileReferralSchema,
   profileSummarySchema,
   profileUpdateSchema
-} from "./chunk-WSBYWVTZ.js";
+} from "./chunk-W7YSMSGC.js";
+import {
+  createHttpExchange,
+  untilAborted,
+  withQuery
+} from "./chunk-ICXZZNPS.js";
 import {
   PARTICIPANT_TIMEOUT,
-  clientIdentity,
   lifetime,
-  retryAfter,
   retrying,
   validTimeout
-} from "./chunk-3PYYGFSB.js";
+} from "./chunk-3RFP6GT5.js";
 import {
   exchangeResultSchema,
   exchangeSchema,
   memberSummarySchema,
   participantSessionSchema,
   sessionMember
-} from "./chunk-XJFYAXET.js";
+} from "./chunk-N4BDKS6Y.js";
 import {
   accountConnectionSchema,
   attemptSchema,
@@ -112,7 +115,7 @@ import {
   walletMessageChallengeSchema,
   walletSignatureSchema,
   walletUnlinkInputSchema
-} from "./chunk-MK425RXJ.js";
+} from "./chunk-ID3BZXFZ.js";
 import {
   RelayError,
   RelayErrorCode,
@@ -120,24 +123,24 @@ import {
   isRelayError,
   isRequestError,
   parseInput
-} from "./chunk-K2KS3JLY.js";
+} 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"),
@@ -163,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"
@@ -806,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 = () => {
 }) {
@@ -1121,14 +1124,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 +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;
     }
@@ -1170,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);
 }
@@ -1236,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)) {
@@ -1400,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();
@@ -1410,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
@@ -1869,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));
@@ -2344,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 })
@@ -2356,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
@@ -2388,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 }),

package/dist/{chunk-6WCIWXUV.js → chunk-MTKRIQEU.js}

@@ -1,10 +1,10 @@
 import {
   RelayErrorCode,
   clientError
-} from "./chunk-K2KS3JLY.js";
+} from "./chunk-GLH6MEI2.js";
 
 // src/plugin-client.ts
-var transportKey = /* @__PURE__ */ Symbol.for("@domino-sdk/relay:plugin-transport");
+var transportKey = /* @__PURE__ */ (() => /* @__PURE__ */ Symbol.for("@domino-sdk/relay:plugin-transport"))();
 function setPluginTransport(client, transport) {
   Object.defineProperty(client, transportKey, { value: transport });
 }

package/dist/{chunk-4OC7REYX.js → chunk-MWMCQLCG.js}

@@ -6,7 +6,7 @@ var capabilityErrorCodes = [
   "author-error"
 ];
 var isKnown = (code) => capabilityErrorCodes.includes(code);
-var capabilityFailureSchema = z.looseObject({
+var capabilityFailureSchema = /* @__PURE__ */ (() => z.looseObject({
   code: z.string().min(1),
   message: z.string().min(1),
   /**
@@ -16,8 +16,8 @@ var capabilityFailureSchema = z.looseObject({
    * handles and moves past is final for the attempt; one that escapes the evaluation is retried.
    */
   retryable: z.boolean()
-});
-var brand = /* @__PURE__ */ Symbol.for("@domino-sdk/relay/CapabilityError");
+}))();
+var brand = /* @__PURE__ */ (() => /* @__PURE__ */ Symbol.for("@domino-sdk/relay/CapabilityError"))();
 var CapabilityError = class _CapabilityError extends Error {
   code;
   retryable;

package/dist/{chunk-XJFYAXET.js → chunk-N4BDKS6Y.js}

@@ -1,43 +1,43 @@
 import {
   identifier
-} from "./chunk-MK425RXJ.js";
+} from "./chunk-ID3BZXFZ.js";
 
 // src/auth.ts
 import * as z from "zod";
-var authScopeSchema = z.object({
+var authScopeSchema = /* @__PURE__ */ (() => z.object({
   organization: identifier,
   project: identifier,
   environment: z.enum(["test", "live"])
-}).strict();
-var principalSchema = z.discriminatedUnion("kind", [
+}).strict())();
+var principalSchema = /* @__PURE__ */ (() => z.discriminatedUnion("kind", [
   z.object({ kind: z.literal("member"), member: identifier }),
   z.object({ kind: z.literal("staff"), subject: identifier }),
   z.object({ kind: z.literal("operator"), subject: identifier })
-]);
-var sessionSchema = z.object({
+]))();
+var sessionSchema = /* @__PURE__ */ (() => z.object({
   ...authScopeSchema.shape,
   id: identifier,
   principal: principalSchema,
   expiresAt: z.number()
-});
-var knownPrincipalKinds = principalSchema.options.map(
+}))();
+var knownPrincipalKinds = /* @__PURE__ */ (() => principalSchema.options.map(
   (option) => option.shape.kind.value
-);
-var participantPrincipalSchema = z.union([
+))();
+var participantPrincipalSchema = /* @__PURE__ */ (() => z.union([
   principalSchema,
   z.object({ kind: z.string().min(1) }).refine((principal) => !knownPrincipalKinds.includes(principal.kind))
-]);
-var participantSessionSchema = z.object({
+]))();
+var participantSessionSchema = /* @__PURE__ */ (() => z.object({
   ...authScopeSchema.shape,
   id: identifier,
   principal: participantPrincipalSchema,
   expiresAt: z.number()
-});
+}))();
 function sessionMember(session) {
   const principal = session?.principal;
   return principal?.kind === "member" && "member" in principal ? principal.member : null;
 }
-var memberSummarySchema = z.object({
+var memberSummarySchema = /* @__PURE__ */ (() => z.object({
   member: identifier,
   avatarSeed: z.string().min(1).max(100),
   /**
@@ -64,15 +64,15 @@ var memberSummarySchema = z.object({
     now: z.number().int().nonnegative(),
     offsetMs: z.number().int()
   }).optional()
-});
-var exchangeSchema = authScopeSchema.extend({
+}))();
+var exchangeSchema = /* @__PURE__ */ (() => authScopeSchema.extend({
   identity: z.object({ issuer: identifier, subject: z.string().min(1).max(200) }).strict(),
   role: z.enum(["member", "staff", "operator"])
-}).strict();
-var exchangeResultSchema = z.object({
+}).strict())();
+var exchangeResultSchema = /* @__PURE__ */ (() => z.object({
   token: z.string(),
   session: sessionSchema
-});
+}))();
 
 export {
   authScopeSchema,

package/dist/{chunk-E6IKQHTX.js → chunk-N4LNEGQX.js}

@@ -4,10 +4,10 @@ import {
   imageFieldsSchema,
   imageInspectionSchema,
   imageSightingsSchema
-} from "./chunk-QYPMPWVX.js";
+} from "./chunk-7X67QLPB.js";
 import {
   photoResultSchema
-} from "./chunk-MK425RXJ.js";
+} from "./chunk-ID3BZXFZ.js";
 
 // src/image-results.ts
 import * as z from "zod";