@globus/sdk 4.0.0-rc.1 → 4.0.0-rc.2

package/dist/cjs/core/storage/memory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory.js","sourceRoot":"","sources":["../../../../src/core/storage/memory.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;AAEA,MAAa,aAAa;IAA1B;QACE,iCAA0C,EAAE,EAAC;IAqB/C,CAAC;IAnBC,GAAG,CAAC,GAAW;QACb,OAAO,uBAAA,IAAI,8BAAS,CAAC,GAAG,CAAC,KAAK,SAAS,CAAC,CAAC,CAAC,uBAAA,IAAI,8BAAS,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;IACtE,CAAC;IAED,GAAG,CAAC,GAAW,EAAE,KAAc;QAC7B,uBAAA,IAAI,8BAAS,CAAC,GAAG,CAAC,GAAG,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;IACjF,CAAC;IAED,MAAM,CAAC,GAAW;QAChB,OAAO,uBAAA,IAAI,8BAAS,CAAC,GAAG,CAAC,CAAC;IAC5B,CAAC;IAED,IAAI;QACF,OAAO,MAAM,CAAC,IAAI,CAAC,uBAAA,IAAI,8BAAS,CAAC,CAAC;IACpC,CAAC;IAED,KAAK;QACH,uBAAA,IAAI,0BAAY,EAAE,MAAA,CAAC;IACrB,CAAC;CACF;AAtBD,sCAsBC"}

package/dist/cjs/core/url.d.ts

@@ -0,0 +1,31 @@
+import { Environment, Service } from './global.js';
+import type { GCSConfiguration } from '../services/globus-connect-server/index.js';
+import { SDKOptions } from '../services/types.js';
+/**
+ * An extremely simplified parameter serializer based on our current needs.
+ *
+ * **This is intended for internal @globus/sdk use only.**
+ *
+ * @private
+ */
+export declare function stringifyParameters(parameters: {
+    [key: string]: string | number | boolean | Array<string | number | null | undefined> | null | undefined;
+}): string;
+/**
+ * Return the base URL for a service (based on the environment).
+ * @param service The service to build the URL for.
+ * @param path The path to the resource.
+ * @param environment The environment to use.
+ */
+export declare function getServiceURL(service: Service, path?: string, environment?: Environment): URL;
+/**
+ * Build a URL for a service or GCSConfiguration.
+ *
+ * @param service The service identifier or GCSConfiguration object to build the URL for.
+ * @param path The path to the resource.
+ * @param options Additional options for the URL.
+ */
+export declare function build(serviceOrConfiguration: Service | GCSConfiguration, path: string, options?: {
+    search?: Parameters<typeof stringifyParameters>[0];
+}, sdkOptions?: SDKOptions): string;
+//# sourceMappingURL=url.d.ts.map

package/dist/cjs/core/url.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"url.d.ts","sourceRoot":"","sources":["../../../src/core/url.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqC,WAAW,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AACtF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,4CAA4C,CAAC;AACnF,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAElD;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,UAAU,EAAE;IAC9C,CAAC,GAAG,EAAE,MAAM,GACR,MAAM,GACN,MAAM,GACN,OAAO,GACP,KAAK,CAAC,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC,GACzC,IAAI,GACJ,SAAS,CAAC;CACf,UAeA;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,OAAO,EAChB,IAAI,SAAK,EACT,WAAW,GAAE,WAA8B,GAC1C,GAAG,CAGL;AAED;;;;;;GAMG;AACH,wBAAgB,KAAK,CACnB,sBAAsB,EAAE,OAAO,GAAG,gBAAgB,EAClD,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE;IACR,MAAM,CAAC,EAAE,UAAU,CAAC,OAAO,mBAAmB,CAAC,CAAC,CAAC,CAAC,CAAC;CACpD,EACD,UAAU,CAAC,EAAE,UAAU,UAYxB"}

package/dist/cjs/core/url.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringifyParameters = stringifyParameters;
+exports.getServiceURL = getServiceURL;
+exports.build = build;
+const global_js_1 = require("./global.js");
+/**
+ * An extremely simplified parameter serializer based on our current needs.
+ *
+ * **This is intended for internal @globus/sdk use only.**
+ *
+ * @private
+ */
+function stringifyParameters(parameters) {
+    const search = new URLSearchParams();
+    Array.from(Object.entries(parameters)).forEach(([key, value]) => {
+        if (Array.isArray(value)) {
+            /**
+             * Arrays are converted to comma-separated strings.
+             */
+            search.set(key, value.join(','));
+        }
+        else if (value !== undefined) {
+            search.set(key, String(value));
+        }
+    });
+    return search.toString();
+}
+/**
+ * Return the base URL for a service (based on the environment).
+ * @param service The service to build the URL for.
+ * @param path The path to the resource.
+ * @param environment The environment to use.
+ */
+function getServiceURL(service, path = '', environment = (0, global_js_1.getEnvironment)()) {
+    const base = (0, global_js_1.getServiceBaseUrl)(service, environment);
+    return new URL(path, base);
+}
+/**
+ * Build a URL for a service or GCSConfiguration.
+ *
+ * @param service The service identifier or GCSConfiguration object to build the URL for.
+ * @param path The path to the resource.
+ * @param options Additional options for the URL.
+ */
+function build(serviceOrConfiguration, path, options, sdkOptions) {
+    let url;
+    if (typeof serviceOrConfiguration === 'object') {
+        url = new URL(path, serviceOrConfiguration.host);
+    }
+    else {
+        url = getServiceURL(serviceOrConfiguration, path, sdkOptions === null || sdkOptions === void 0 ? void 0 : sdkOptions.environment);
+    }
+    if (options && options.search) {
+        url.search = stringifyParameters(options.search);
+    }
+    return url.toString();
+}
+//# sourceMappingURL=url.js.map

package/dist/cjs/core/url.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"url.js","sourceRoot":"","sources":["../../../src/core/url.ts"],"names":[],"mappings":";;AAWA,kDAuBC;AAQD,sCAOC;AASD,sBAkBC;AA5ED,2CAAsF;AAItF;;;;;;GAMG;AACH,SAAgB,mBAAmB,CAAC,UAQnC;IACC,MAAM,MAAM,GAAG,IAAI,eAAe,EAAE,CAAC;IAErC,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE,EAAE;QAC9D,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;YACzB;;eAEG;YACH,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;QACnC,CAAC;aAAM,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;YAC/B,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;QACjC,CAAC;IACH,CAAC,CAAC,CAAC;IAEH,OAAO,MAAM,CAAC,QAAQ,EAAE,CAAC;AAC3B,CAAC;AAED;;;;;GAKG;AACH,SAAgB,aAAa,CAC3B,OAAgB,EAChB,IAAI,GAAG,EAAE,EACT,cAA2B,IAAA,0BAAc,GAAE;IAE3C,MAAM,IAAI,GAAG,IAAA,6BAAiB,EAAC,OAAO,EAAE,WAAW,CAAC,CAAC;IACrD,OAAO,IAAI,GAAG,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;AAC7B,CAAC;AAED;;;;;;GAMG;AACH,SAAgB,KAAK,CACnB,sBAAkD,EAClD,IAAY,EACZ,OAEC,EACD,UAAuB;IAEvB,IAAI,GAAG,CAAC;IACR,IAAI,OAAO,sBAAsB,KAAK,QAAQ,EAAE,CAAC;QAC/C,GAAG,GAAG,IAAI,GAAG,CAAC,IAAI,EAAE,sBAAsB,CAAC,IAAI,CAAC,CAAC;IACnD,CAAC;SAAM,CAAC;QACN,GAAG,GAAG,aAAa,CAAC,sBAAsB,EAAE,IAAI,EAAE,UAAU,aAAV,UAAU,uBAAV,UAAU,CAAE,WAAW,CAAC,CAAC;IAC7E,CAAC;IACD,IAAI,OAAO,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;QAC9B,GAAG,CAAC,MAAM,GAAG,mBAAmB,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;IACnD,CAAC;IACD,OAAO,GAAG,CAAC,QAAQ,EAAE,CAAC;AACxB,CAAC"}

package/dist/cjs/index.d.ts

@@ -0,0 +1,76 @@
+/**
+ * @module @globus/sdk
+ * @description `@globus/sdk` provides modules for interacting with the various APIs that make up the Globus platform.
+ *
+ * ### Key Concepts
+ * - All service methods return a `Promise` that resolves to a [Fetch API Response object](https://developer.mozilla.org/en-US/docs/Web/API/Response).
+ *    - Under the hood, we are returning the result of a composed [`fetch`](https://developer.mozilla.org/en-US/docs/Web/API/fetch).
+ * - All service methods accept a `ServiceMethodOptions` object to pass query parameters, a payload, and headers.
+ * - All service methods support a tail argument to pass options to the SDK, including the composed `fetch` call.
+ *
+ * #### Service Method Names
+ *
+ * Basic CRUD operations provided by services are exposed as the following:
+ *
+ * | Service Method Name | HTTP Method | Description                  | Example |
+ * | --------------------| ----------- | ---------------------------- | ------- |
+ * | `get`               | `GET`       | Fetch a single resource.     | `transfer.endpoint.get()` |
+ * | `getAll`            | `GET`       | Fetch a list of resources.   | `flows.flows.getAll()`    |
+ * | `create`            | `POST`      | Create a new resource.       | `gcs.roles.create()`      |
+ * | `update`            | `PUT`       | Update an existing resource. | `gcs.endpoint.update()`   |
+ * | `patch`             | `PATCH`     | Update an existing resource. | `gcs.endpoint.patch()`    |
+ * | `remove`            | `DELETE`    | Delete an existing resource. | `gcs.collections.remove()`|
+ *
+ * Methods that do not map to obvious CRUD operations are named according to the resource. i.e., `groups.groups.getMyGroups()`, `transfer.endpointSearch()`, `search.query.post()`
+ *
+ * @example <caption>Using the SDK to search for endpoints via Transfer API.</caption>
+ * import { transfer } from "@globus/sdk";
+ *
+ * const result = await (
+ *   await globus.transfer.endpointSearch(
+ *     {
+ *        query: { filter_fulltext: "Globus Tutorial" }
+ *        headers: {
+ *          Authorization: "Bearer MY_ACCESS_TOKEN",
+ *        },
+ *     },
+ *     {
+ *       fetch: {
+ *         // Provide parameters to the underlying `fetch` call.
+ *         // https://developer.mozilla.org/en-US/docs/Web/API/fetch#parameters
+ *         options: {
+ *           priority: "high"
+ *         },
+ *       },
+ *     }
+ *   )
+ * ).json();
+ *
+ * @example <caption>Using the SDK to fetch a single flow from the Flows API.</caption>
+ * import { flows } from "@globus/sdk";
+ *
+ * const result = await (await flows.flows.get("452bbea3-5e3b-45a5-af08-50179839a4e8")).json();
+ */
+/**
+ * Core
+ */
+export * as info from './core/info/index.js';
+export * as logger from './core/logger.js';
+export * as authorization from './core/authorization/index.js';
+export * as errors from './core/errors.js';
+/**
+ * Services
+ */
+export * as auth from './services/auth/index.js';
+export * as transfer from './services/transfer/index.js';
+export * as search from './services/search/index.js';
+export * as groups from './services/groups/index.js';
+export * as flows from './services/flows/index.js';
+export * as gcs from './services/globus-connect-server/index.js';
+export * as timer from './services/timer/index.js';
+export * as compute from './services/compute/index.js';
+/**
+ * Applications
+ */
+export * as webapp from './apps/web.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/cjs/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AAOH;;GAEG;AACH,OAAO,KAAK,IAAI,MAAM,sBAAsB,CAAC;AAC7C,OAAO,KAAK,MAAM,MAAM,kBAAkB,CAAC;AAC3C,OAAO,KAAK,aAAa,MAAM,+BAA+B,CAAC;AAC/D,OAAO,KAAK,MAAM,MAAM,kBAAkB,CAAC;AAE3C;;GAEG;AACH,OAAO,KAAK,IAAI,MAAM,0BAA0B,CAAC;AACjD,OAAO,KAAK,QAAQ,MAAM,8BAA8B,CAAC;AACzD,OAAO,KAAK,MAAM,MAAM,4BAA4B,CAAC;AACrD,OAAO,KAAK,MAAM,MAAM,4BAA4B,CAAC;AACrD,OAAO,KAAK,KAAK,MAAM,2BAA2B,CAAC;AACnD,OAAO,KAAK,GAAG,MAAM,2CAA2C,CAAC;AACjE,OAAO,KAAK,KAAK,MAAM,2BAA2B,CAAC;AACnD,OAAO,KAAK,OAAO,MAAM,6BAA6B,CAAC;AAEvD;;GAEG;AACH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC"}

package/dist/cjs/index.js

@@ -483,11 +483,11 @@ async function serviceRequest(config, options, passedSdkOptions) {
     ...injectedFetchOptions.headers
   };
   const manager = sdkOptions?.manager;
-  let token;
+  let token2;
   if (config.resource_server && manager) {
-    token = manager.tokens.getByResourceServer(config.resource_server);
-    if (token) {
-      headers["Authorization"] = `Bearer ${token.access_token}`;
+    token2 = manager.tokens.getByResourceServer(config.resource_server);
+    if (token2) {
+      headers["Authorization"] = `Bearer ${token2.access_token}`;
     }
   }
   if (config.scope && manager) {
@@ -495,9 +495,9 @@ async function serviceRequest(config, options, passedSdkOptions) {
       // For `GCSConfiguration` objects, the `endpoint_id` is the resource server.
       config.service.endpoint_id
     );
-    token = manager.tokens.getByResourceServer(resourceServer);
-    if (token) {
-      headers["Authorization"] = `Bearer ${token.access_token}`;
+    token2 = manager.tokens.getByResourceServer(resourceServer);
+    if (token2) {
+      headers["Authorization"] = `Bearer ${token2.access_token}`;
     }
   }
   let body = options?.body;
@@ -529,7 +529,7 @@ async function serviceRequest(config, options, passedSdkOptions) {
     handler = injectedFetchOptions.__callable.bind(this);
     delete init.__callable;
   }
-  if (config.preventRetry || !manager || !token || !isRefreshToken(token)) {
+  if (config.preventRetry || !manager || !token2 || !isRefreshToken(token2)) {
     return handler(url2, init);
   }
   const initialResponse = await handler(url2, init);
@@ -551,7 +551,7 @@ async function serviceRequest(config, options, passedSdkOptions) {
   }
   const shouldAttemptTokenRefresh = initialResponse.status === 401 && !hasAuthorizationRequirements;
   if (shouldAttemptTokenRefresh) {
-    const newToken = await manager.refreshToken(token);
+    const newToken = await manager.refreshToken(token2);
     if (!newToken) {
       return initialResponse;
     }
@@ -600,9 +600,11 @@ __export(oauth2_exports, {
 // src/services/auth/service/oauth2/token.ts
 var token_exports = {};
 __export(token_exports, {
+  exchange: () => exchange,
   introspect: () => introspect,
   refresh: () => refresh,
   revoke: () => revoke,
+  token: () => token,
   validate: () => validate
 });
 function serialize(payload) {
@@ -615,9 +617,10 @@ function injectServiceOptions(options) {
      * The `token` service methods always expect a form-encoded body. We still allow
      * end-consumers to pass a raw body, but if `payload` is provided it is serialized.
      */
-    body: serialize(options.payload),
+    body: options.payload ? serialize(options.payload) : void 0,
     headers: {
       ...options?.headers || {},
+      Accept: "application/json",
       /**
        * Force the `Content-Type` header to be `application/x-www-form-urlencoded` and `charset=UTF-8`.
        */
@@ -625,6 +628,20 @@ function injectServiceOptions(options) {
     }
   };
 }
+var token = function(options = {}, sdkOptions) {
+  return serviceRequest(
+    {
+      service: ID7,
+      scope: void 0,
+      path: `/v2/oauth2/token`,
+      method: "POST" /* POST */,
+      preventRetry: true
+    },
+    injectServiceOptions(options),
+    sdkOptions
+  );
+};
+var exchange = token;
 var introspect = function(options, sdkOptions) {
   if (!options?.payload) {
     throw new Error(`'payload' is required for introspect`);
@@ -801,27 +818,71 @@ var Event = class {
   }
 };
 
+// src/core/authorization/pkce.ts
+function isSupported() {
+  return "crypto" in globalThis;
+}
+function getCrypto() {
+  return "webcrypto" in globalThis.crypto ? globalThis.crypto.webcrypto : globalThis.crypto;
+}
+var encode = (value) => btoa(value).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+async function sha256(input) {
+  const hashBuffer = await getCrypto().subtle.digest("SHA-256", new TextEncoder().encode(input));
+  return String.fromCharCode(...new Uint8Array(hashBuffer));
+}
+var CHARSET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+var PKCE_SAFE_CHARSET = `${CHARSET}-._~`;
+function generateCodeVerifier() {
+  return Array.from(getCrypto().getRandomValues(new Uint8Array(43))).map((v) => PKCE_SAFE_CHARSET[v % PKCE_SAFE_CHARSET.length]).join("");
+}
+async function generateCodeChallenge(verifier) {
+  const hashed = await sha256(verifier);
+  return encode(hashed);
+}
+function generateState() {
+  return Array.from(getCrypto().getRandomValues(new Uint8Array(16))).map((v) => CHARSET[v % CHARSET.length]).join("");
+}
+
 // src/core/authorization/RedirectTransport.ts
-var import_js_pkce = __toESM(require("js-pkce"));
+var KEYS = {
+  PKCE_STATE: "pkce_state",
+  PKCE_CODE_VERIFIER: "pkce_code_verifier"
+};
 function resetPKCE() {
-  sessionStorage.removeItem("pkce_state");
-  sessionStorage.removeItem("pkce_code_verifier");
+  sessionStorage.removeItem(KEYS.PKCE_STATE);
+  sessionStorage.removeItem(KEYS.PKCE_CODE_VERIFIER);
 }
-var RedirectTransport = class {
-  #pkce;
-  #params = {};
+var RedirectTransport = class _RedirectTransport {
+  #options;
   constructor(options) {
-    const { params, ...config } = options;
-    this.#pkce = new import_js_pkce.default({
-      ...config
-    });
-    this.#params = {
-      ...params
-    };
+    this.#options = options;
+    if (_RedirectTransport.supported === false) {
+      throw new Error("RedirectTransport is not supported in this environment.");
+    }
   }
-  send() {
-    resetPKCE();
-    window.location.assign(this.#pkce.authorizeUrl(this.#params));
+  static supported = isSupported();
+  /**
+   * For the redirect transport, sending the request will redirect the user to the authorization endpoint, initiating the OAuth flow.
+   */
+  async send() {
+    const verifier = generateCodeVerifier();
+    const challenge = await generateCodeChallenge(verifier);
+    const state = generateState();
+    sessionStorage.setItem(KEYS.PKCE_CODE_VERIFIER, verifier);
+    sessionStorage.setItem(KEYS.PKCE_STATE, state);
+    const params = {
+      response_type: "code",
+      client_id: this.#options.client,
+      scope: this.#options.scopes || "",
+      redirect_uri: this.#options.redirect,
+      state,
+      code_challenge: challenge,
+      code_challenge_method: "S256",
+      ...this.#options.params || {}
+    };
+    const url2 = new URL(getAuthorizationEndpoint());
+    url2.search = new URLSearchParams(params).toString();
+    window.location.assign(url2.toString());
   }
   /**
    * Parse the current URL for the authorization code (`?code=...`) and exchange it for an access token when available.
@@ -830,9 +891,35 @@ var RedirectTransport = class {
   async getToken(options = { shouldReplace: true }) {
     const url2 = new URL(window.location.href);
     const params = new URLSearchParams(url2.search);
-    if (!params.get("code")) return void 0;
-    const response = await this.#pkce.exchangeForAccessToken(url2.toString());
+    if (params.get("error")) {
+      throw new Error(
+        params.get("error_description") || "An error occurred during the authorization process."
+      );
+    }
+    const code = params.get("code");
+    if (!code) return void 0;
+    const state = sessionStorage.getItem(KEYS.PKCE_STATE);
+    const verifier = sessionStorage.getItem(KEYS.PKCE_CODE_VERIFIER);
     resetPKCE();
+    if (params.get("state") !== state) {
+      throw new Error("Invalid State");
+    }
+    if (!verifier) {
+      throw new Error("Invalid Code Verifier");
+    }
+    const payload = {
+      code,
+      client_id: this.#options.client,
+      /**
+       * Retrieve the code verifier from session storage.
+       */
+      code_verifier: verifier,
+      redirect_uri: this.#options.redirect,
+      grant_type: "authorization_code"
+    };
+    const response = await (await oauth2_exports.token.exchange({
+      payload
+    })).json();
     if (options.shouldReplace) {
       params.delete("code");
       params.delete("state");
@@ -846,15 +933,15 @@ var RedirectTransport = class {
 // src/core/authorization/TokenLookup.ts
 function getTokenFromStorage(key) {
   const raw = getStorage().get(key) || "null";
-  let token = null;
+  let token2 = null;
   try {
     const parsed = JSON.parse(raw);
     if (isToken(parsed)) {
-      token = parsed;
+      token2 = parsed;
     }
   } catch (e) {
   }
-  return token;
+  return token2;
 }
 var TokenLookup = class {
   #manager;
@@ -989,8 +1076,8 @@ var AuthorizationManager = class {
    * @see {@link https://docs.globus.org/api/auth/reference/#oidc_userinfo_endpoint}
    */
   get user() {
-    const token = this.getGlobusAuthToken();
-    return token && token.id_token ? (0, import_jwt_decode.jwtDecode)(token.id_token) : null;
+    const token2 = this.getGlobusAuthToken();
+    return token2 && token2.id_token ? (0, import_jwt_decode.jwtDecode)(token2.id_token) : null;
   }
   /**
    * Attempt to refresh all of the tokens managed by the instance.
@@ -999,9 +1086,9 @@ var AuthorizationManager = class {
   async refreshTokens() {
     log("debug", "AuthorizationManager.refreshTokens");
     const tokens = await Promise.allSettled(
-      this.tokens.getAll().map((token) => {
-        if (isRefreshToken(token)) {
-          return this.refreshToken(token);
+      this.tokens.getAll().map((token2) => {
+        if (isRefreshToken(token2)) {
+          return this.refreshToken(token2);
         }
         return Promise.resolve(null);
       })
@@ -1013,13 +1100,13 @@ var AuthorizationManager = class {
    * Use the `refresh_token` attribute of a token to obtain a new access token.
    * @param token The well-formed token with a `refresh_token` attribute.
    */
-  async refreshToken(token) {
-    log("debug", `AuthorizationManager.refreshToken | resource_server=${token.resource_server}`);
+  async refreshToken(token2) {
+    log("debug", `AuthorizationManager.refreshToken | resource_server=${token2.resource_server}`);
     try {
       const response = await (await oauth2_exports.token.refresh({
         payload: {
           client_id: this.configuration.client,
-          refresh_token: token.refresh_token,
+          refresh_token: token2.refresh_token,
           grant_type: "refresh_token"
         }
       })).json();
@@ -1028,7 +1115,7 @@ var AuthorizationManager = class {
         return response;
       }
     } catch (error) {
-      log("error", `AuthorizationManager.refreshToken | resource_server=${token.resource_server}`);
+      log("error", `AuthorizationManager.refreshToken | resource_server=${token2.resource_server}`);
     }
     return null;
   }
@@ -1053,10 +1140,10 @@ var AuthorizationManager = class {
   }
   async #emitAuthenticatedState() {
     const isAuthenticated = this.authenticated;
-    const token = this.getGlobusAuthToken() ?? void 0;
+    const token2 = this.getGlobusAuthToken() ?? void 0;
     await this.events.authenticated.dispatch({
       isAuthenticated,
-      token
+      token: token2
     });
   }
   /**
@@ -1079,31 +1166,27 @@ var AuthorizationManager = class {
     return `${scopes}${this.configuration.useRefreshTokens ? " offline_access" : ""}`;
   }
   #buildTransport(overrides) {
-    const scopes = this.#withOfflineAccess(
-      overrides?.requested_scopes ?? (this.configuration.scopes || "")
-    );
+    const scopes = this.#withOfflineAccess(overrides?.scopes ?? (this.configuration.scopes || ""));
     return new RedirectTransport({
-      client_id: this.configuration.client,
-      authorization_endpoint: getAuthorizationEndpoint(),
-      token_endpoint: getTokenEndpoint(),
-      redirect_uri: this.configuration.redirect,
-      requested_scopes: scopes,
-      ...overrides
+      client: this.configuration.client,
+      redirect: this.configuration.redirect,
+      scopes,
+      ...overrides,
       // @todo Decide if we want to include the `include_consented_scopes` parameter by default.
-      // params: {
-      //   include_consented_scopes: true,
-      //   ...overrides?.params,
-      // },
+      params: {
+        // include_consented_scopes: true,
+        ...overrides?.params
+      }
     });
   }
   /**
    * Initiate the login process by redirecting to the Globus Auth login page.
    */
-  login(options = { additionalParams: {} }) {
+  async login(options = { additionalParams: {} }) {
     log("debug", "AuthorizationManager.login");
     this.reset();
     const transport = this.#buildTransport({ params: options?.additionalParams });
-    transport.send();
+    await transport.send();
   }
   /**
    * This method will attempt to complete the PKCE protocol flow.
@@ -1121,7 +1204,7 @@ var AuthorizationManager = class {
       this.addTokenResponse(response);
     }
   }
-  handleErrorResponse(response, options) {
+  async handleErrorResponse(response, options) {
     const opts = typeof options === "boolean" ? {
       ...DEFAULT_HANDLE_ERROR_OPTIONS,
       execute: options
@@ -1133,32 +1216,41 @@ var AuthorizationManager = class {
       "debug",
       `AuthorizationManager.handleErrorResponse | response=${JSON.stringify(response)} execute=${opts.execute}`
     );
-    let handler = () => {
+    let handler = async () => {
     };
     if (isAuthorizationRequirementsError(response)) {
       log(
         "debug",
         "AuthorizationManager.handleErrorResponse | error=AuthorizationRequirementsError"
       );
-      handler = () => this.handleAuthorizationRequirementsError(response, {
-        additionalParams: opts.additionalParams
-      });
+      handler = async () => {
+        await this.handleAuthorizationRequirementsError(response, {
+          additionalParams: opts.additionalParams
+        });
+      };
     }
     if (isConsentRequiredError(response)) {
       log("debug", "AuthorizationManager.handleErrorResponse | error=ConsentRequiredError");
-      handler = () => this.handleConsentRequiredError(response, { additionalParams: opts.additionalParams });
+      handler = async () => {
+        await this.handleConsentRequiredError(response, {
+          additionalParams: opts.additionalParams
+        });
+      };
     }
     if ("code" in response && response["code"] === "AuthenticationFailed") {
       log("debug", "AuthorizationManager.handleErrorResponse | error=AuthenticationFailed");
-      handler = () => this.revoke();
+      handler = async () => {
+        await this.revoke();
+      };
     }
-    return opts.execute === true ? handler() : handler;
+    const returnValue = opts.execute === true ? await handler() : handler;
+    return returnValue;
   }
   /**
    * Process a well-formed Authorization Requirements error response from a Globus service
    * and redirect the user to the Globus Auth login page with the necessary parameters.
    */
-  handleAuthorizationRequirementsError(response, options) {
+  async handleAuthorizationRequirementsError(response, options) {
     this.#transport = this.#buildTransport({
       params: {
         prompt: "login",
@@ -1166,30 +1258,30 @@ var AuthorizationManager = class {
         ...options?.additionalParams
       }
     });
-    this.#transport.send();
+    await this.#transport.send();
   }
   /**
    * Process a well-formed `ConsentRequired` error response from a Globus service
    * and redirect the user to the Globus Auth login page with the necessary parameters.
    */
-  handleConsentRequiredError(response, options) {
+  async handleConsentRequiredError(response, options) {
     this.#transport = this.#buildTransport({
-      requested_scopes: this.#withOfflineAccess(response.required_scopes.join(" ")),
+      scopes: this.#withOfflineAccess(response.required_scopes.join(" ")),
       params: {
         ...options?.additionalParams
       }
     });
-    this.#transport.send();
+    await this.#transport.send();
   }
   /**
    * Add a Globus Auth token response to storage, if `other_tokens` are present they are also added.
    * This method is mostly used internally by the `AuthorizationManager`, but can be used by downstream
    * consumers to add tokens to storage if necessary.
    */
-  addTokenResponse = (token) => {
-    getStorage().set(`${this.configuration.client}:${token.resource_server}`, token);
-    if ("other_tokens" in token) {
-      token.other_tokens?.forEach(this.addTokenResponse);
+  addTokenResponse = (token2) => {
+    getStorage().set(`${this.configuration.client}:${token2.resource_server}`, token2);
+    if ("other_tokens" in token2) {
+      token2.other_tokens?.forEach(this.addTokenResponse);
     }
     this.#checkAuthorizationState();
   };
@@ -1208,12 +1300,12 @@ var AuthorizationManager = class {
   /**
    * Revoke a token from a resource server.
    */
-  #revokeToken(token) {
-    log("debug", `AuthorizationManager.revokeToken | resource_server=${token.resource_server}`);
+  #revokeToken(token2) {
+    log("debug", `AuthorizationManager.revokeToken | resource_server=${token2.resource_server}`);
     return oauth2_exports.token.revoke({
       payload: {
         client_id: this.configuration.client,
-        token: token.access_token
+        token: token2.access_token
       }
     });
   }