@auth0/auth0-server-js 1.12.1 → 1.14.0

package/dist/index.cjs

@@ -23,37 +23,40 @@ __export(index_exports, {
   AbstractStateStore: () => AbstractStateStore,
   AbstractTransactionStore: () => AbstractTransactionStore,
   BackchannelLogoutError: () => BackchannelLogoutError,
-  ChangePasswordError: () => import_auth0_auth_js4.ChangePasswordError,
+  ChangePasswordError: () => import_auth0_auth_js5.ChangePasswordError,
   CookieTransactionStore: () => CookieTransactionStore,
+  EnterpriseConnectNotSupportedError: () => import_auth0_auth_js6.EnterpriseConnectNotSupportedError,
   InvalidConfigurationError: () => InvalidConfigurationError,
   IssuerValidationError: () => IssuerValidationError,
-  MfaChallengeError: () => import_auth0_auth_js2.MfaChallengeError,
-  MfaEnrollmentError: () => import_auth0_auth_js2.MfaEnrollmentError,
-  MfaListAuthenticatorsError: () => import_auth0_auth_js2.MfaListAuthenticatorsError,
-  MfaVerifyError: () => import_auth0_auth_js2.MfaVerifyError,
-  MissingClientAuthError: () => import_auth0_auth_js5.MissingClientAuthError,
+  MfaChallengeError: () => import_auth0_auth_js3.MfaChallengeError,
+  MfaEnrollmentError: () => import_auth0_auth_js3.MfaEnrollmentError,
+  MfaListAuthenticatorsError: () => import_auth0_auth_js3.MfaListAuthenticatorsError,
+  MfaVerifyError: () => import_auth0_auth_js3.MfaVerifyError,
+  MissingClientAuthError: () => import_auth0_auth_js6.MissingClientAuthError,
   MissingRequiredArgumentError: () => MissingRequiredArgumentError,
   MissingSessionError: () => MissingSessionError,
   MissingTransactionError: () => MissingTransactionError,
-  OrganizationValidationError: () => import_auth0_auth_js5.OrganizationValidationError,
-  PasskeyChallengeError: () => import_auth0_auth_js3.PasskeyChallengeError,
-  PasskeyGetTokenError: () => import_auth0_auth_js3.PasskeyGetTokenError,
-  PasskeyRegisterError: () => import_auth0_auth_js3.PasskeyRegisterError,
-  PasswordlessStartError: () => import_auth0_auth_js5.PasswordlessStartError,
-  PasswordlessVerifyError: () => import_auth0_auth_js5.PasswordlessVerifyError,
+  OrganizationValidationError: () => import_auth0_auth_js6.OrganizationValidationError,
+  PasskeyChallengeError: () => import_auth0_auth_js4.PasskeyChallengeError,
+  PasskeyGetTokenError: () => import_auth0_auth_js4.PasskeyGetTokenError,
+  PasskeyRegisterError: () => import_auth0_auth_js4.PasskeyRegisterError,
+  PasswordlessStartError: () => import_auth0_auth_js6.PasswordlessStartError,
+  PasswordlessVerifyError: () => import_auth0_auth_js6.PasswordlessVerifyError,
   ServerClient: () => ServerClient,
   ServerDatabaseClient: () => ServerDatabaseClient,
   ServerMfaClient: () => ServerMfaClient,
   ServerPasskeyClient: () => ServerPasskeyClient,
   SessionExpiredError: () => SessionExpiredError,
-  SignUpError: () => import_auth0_auth_js4.SignUpError,
+  SignUpError: () => import_auth0_auth_js5.SignUpError,
   StartLinkUserError: () => StartLinkUserError,
   StatefulStateStore: () => StatefulStateStore,
   StatelessStateStore: () => StatelessStateStore,
-  TokenExchangeError: () => import_auth0_auth_js5.TokenExchangeError,
+  TokenExchangeError: () => import_auth0_auth_js6.TokenExchangeError,
   TokenExchangeErrorCode: () => TokenExchangeErrorCode,
-  TokenRevocationError: () => import_auth0_auth_js5.TokenRevocationError,
-  isMfaRequiredError: () => import_auth0_auth_js5.isMfaRequiredError
+  TokenRevocationError: () => import_auth0_auth_js6.TokenRevocationError,
+  UserInfoError: () => import_auth0_auth_js6.UserInfoError,
+  isFederatedDomain: () => import_auth0_auth_js6.isFederatedDomain,
+  isMfaRequiredError: () => import_auth0_auth_js6.isMfaRequiredError
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -224,7 +227,7 @@ function updateStateDataForConnectionTokenSet(options, stateData, tokenEndpointR
 }
 
 // src/server-client.ts
-var import_auth0_auth_js = require("@auth0/auth0-auth-js");
+var import_auth0_auth_js2 = require("@auth0/auth0-auth-js");
 
 // src/utils.ts
 var DEFAULT_SCOPES = "openid profile email offline_access";
@@ -262,7 +265,7 @@ function getTelemetryConfig(config) {
   return {
     enabled: true,
     name: config?.name ?? "@auth0/auth0-server-js",
-    version: config?.version ?? "1.12.1"
+    version: config?.version ?? "1.14.0"
   };
 }
 
@@ -282,8 +285,8 @@ var ServerMfaClient = class {
    * @returns Promise resolving to an array of enrolled authenticators
    * @throws {MfaListAuthenticatorsError} When the request fails
    */
-  async listAuthenticators(options) {
-    return this.#options.authClient.mfa.listAuthenticators(options);
+  async listAuthenticators(options, requestOptions) {
+    return this.#options.authClient.mfa.listAuthenticators(options, requestOptions);
   }
   /**
    * Enrolls a new MFA authenticator for the user.
@@ -292,8 +295,8 @@ var ServerMfaClient = class {
    * @returns Promise resolving to enrollment response with authenticator details
    * @throws {MfaEnrollmentError} When enrollment fails
    */
-  async enrollAuthenticator(options) {
-    return this.#options.authClient.mfa.enrollAuthenticator(options);
+  async enrollAuthenticator(options, requestOptions) {
+    return this.#options.authClient.mfa.enrollAuthenticator(options, requestOptions);
   }
   /**
    * Initiates an MFA challenge for user verification.
@@ -302,8 +305,8 @@ var ServerMfaClient = class {
    * @returns Promise resolving to challenge response with challenge details
    * @throws {MfaChallengeError} When the challenge fails
    */
-  async challengeAuthenticator(options) {
-    return this.#options.authClient.mfa.challengeAuthenticator(options);
+  async challengeAuthenticator(options, requestOptions) {
+    return this.#options.authClient.mfa.challengeAuthenticator(options, requestOptions);
   }
   /**
    * Verifies an MFA challenge and completes the authentication flow.
@@ -317,8 +320,8 @@ var ServerMfaClient = class {
    * @returns The tokens returned by Auth0 after successful verification
    * @throws {MfaVerifyError} When verification fails (e.g. invalid token, wrong code)
    */
-  async verify(options, storeOptions) {
-    const tokenResponse = await this.#options.authClient.mfa.verify(options);
+  async verify(options, storeOptions, requestOptions) {
+    const tokenResponse = await this.#options.authClient.mfa.verify(options, requestOptions);
     const audience = options.audience ?? this.#options.defaultAudience;
     const existingStateData = await this.#options.stateStore.get(
       this.#options.stateStoreIdentifier,
@@ -381,10 +384,10 @@ var ServerPasskeyClient = class {
    *
    * @returns A promise resolving to the signup challenge.
    */
-  async register(options, storeOptions) {
+  async register(options, storeOptions, requestOptions) {
     const domain = await this.#options.resolveDomain(storeOptions);
     const authClient = this.#options.getAuthClient(domain);
-    return authClient.passkey.register(options);
+    return authClient.passkey.register(options, requestOptions);
   }
   /**
    * Requests a passkey login challenge for an existing user.
@@ -406,10 +409,10 @@ var ServerPasskeyClient = class {
    *
    * @returns A promise resolving to the login challenge.
    */
-  async challenge(options, storeOptions) {
+  async challenge(options, storeOptions, requestOptions) {
     const domain = await this.#options.resolveDomain(storeOptions);
     const authClient = this.#options.getAuthClient(domain);
-    return authClient.passkey.challenge(options);
+    return authClient.passkey.challenge(options, requestOptions);
   }
   /**
    * Completes a passkey authentication flow (signup or login) by exchanging the
@@ -431,7 +434,7 @@ var ServerPasskeyClient = class {
    *
    * @returns A promise resolving to an object containing the authorizationDetails (when RAR was used).
    */
-  async getToken(options, storeOptions) {
+  async getToken(options, storeOptions, requestOptions) {
     const scope = ensureOpenIdScope(options.scope ?? this.#options.defaultScope);
     const audience = options.audience ?? this.#options.defaultAudience;
     const domain = await this.#options.resolveDomain(storeOptions);
@@ -440,7 +443,7 @@ var ServerPasskeyClient = class {
       ...options,
       scope,
       audience
-    });
+    }, requestOptions);
     const existingStateData = await this.#options.stateStore.get(this.#options.stateStoreIdentifier, storeOptions);
     const stateData = updateStateData(audience ?? "default", existingStateData, tokenEndpointResponse, { domain });
     await this.#options.stateStore.set(this.#options.stateStoreIdentifier, stateData, true, storeOptions);
@@ -473,9 +476,9 @@ var ServerDatabaseClient = class {
    *
    * @returns A promise resolving to the created user result with a normalized `id` field.
    */
-  async signUp(options, storeOptions) {
+  async signUp(options, storeOptions, requestOptions) {
     const domain = await this.#options.resolveDomain(storeOptions);
-    return this.#options.getAuthClient(domain).database.signUp(options);
+    return this.#options.getAuthClient(domain).database.signUp(options, requestOptions);
   }
   /**
    * Requests a password-change email for a database connection user.
@@ -491,11 +494,52 @@ var ServerDatabaseClient = class {
    *
    * @returns A promise resolving to the server's plain-text confirmation message.
    */
-  async changePassword(options, storeOptions) {
+  async changePassword(options, storeOptions, requestOptions) {
     const domain = await this.#options.resolveDomain(storeOptions);
-    return this.#options.getAuthClient(domain).database.changePassword(options);
+    return this.#options.getAuthClient(domain).database.changePassword(options, requestOptions);
+  }
+};
+
+// src/enterprise-connect.ts
+var import_auth0_auth_js = require("@auth0/auth0-auth-js");
+var EC_ALLOWED_METHODS = /* @__PURE__ */ new Set([
+  "startInteractiveLogin",
+  "startEnterpriseLogin",
+  "completeInteractiveLogin",
+  "logout",
+  "customTokenExchange",
+  "handleBackchannelLogout"
+]);
+var EC_ALLOWED_GETTERS = /* @__PURE__ */ new Set(["authClient"]);
+var NullStateStore = class {
+  async get() {
+    return void 0;
+  }
+  async set() {
+  }
+  async delete() {
+  }
+  async deleteByLogoutToken() {
   }
 };
+function applyEnterpriseConnectRestrictions(instance) {
+  const proto = Object.getPrototypeOf(instance);
+  for (const [name, desc] of Object.entries(Object.getOwnPropertyDescriptors(proto))) {
+    if (name === "constructor") continue;
+    if (desc.get && !EC_ALLOWED_GETTERS.has(name)) {
+      Object.defineProperty(instance, name, {
+        get: () => {
+          throw new import_auth0_auth_js.EnterpriseConnectNotSupportedError(name);
+        },
+        configurable: true
+      });
+    } else if (typeof desc.value === "function" && !EC_ALLOWED_METHODS.has(name)) {
+      instance[name] = () => {
+        throw new import_auth0_auth_js.EnterpriseConnectNotSupportedError(name);
+      };
+    }
+  }
+}
 
 // src/server-client.ts
 var normalizeDomain = (value) => {
@@ -514,7 +558,7 @@ var decodeIssuer = (token) => {
 var ID_TOKEN_TYPE = "urn:ietf:params:oauth:token-type:id_token";
 var ID_TOKEN_EXPIRY_SKEW_SECONDS = 30;
 var actorUnavailableError = (message) => {
-  const error = new import_auth0_auth_js.TokenExchangeError(message);
+  const error = new import_auth0_auth_js2.TokenExchangeError(message);
   error.code = TokenExchangeErrorCode.ACTOR_UNAVAILABLE;
   return error;
 };
@@ -535,6 +579,7 @@ var ServerClient = class {
   #transactionStoreIdentifier;
   #stateStore;
   #stateStoreIdentifier;
+  #enterpriseConnect;
   #authClientOptions;
   #staticDomain;
   #authClient;
@@ -605,16 +650,36 @@ var ServerClient = class {
   }
   constructor(options) {
     this.#options = options;
+    this.#enterpriseConnect = !!options.enterpriseConnect;
     this.#stateStoreIdentifier = this.#options.stateIdentifier || "__a0_session";
     this.#transactionStoreIdentifier = this.#options.transactionIdentifier || "__a0_tx";
     this.#transactionStore = options.transactionStore;
-    this.#stateStore = options.stateStore;
-    if (!this.#options.stateStore) {
+    if (!this.#enterpriseConnect && !this.#options.stateStore) {
       throw new MissingRequiredArgumentError("stateStore");
     }
+    this.#stateStore = this.#enterpriseConnect ? new NullStateStore() : this.#options.stateStore;
     if (!this.#options.transactionStore) {
       throw new MissingRequiredArgumentError("transactionStore");
     }
+    if (this.#enterpriseConnect) {
+      if (typeof this.#options.domain === "function") {
+        throw new InvalidConfigurationError(
+          "Enterprise Connect requires a static domain string. DomainResolver is not supported because isFederatedDomain needs a concrete domain."
+        );
+      }
+      const scope = this.#options.authorizationParams?.scope ?? "";
+      if (scope.includes("offline_access")) {
+        console.warn(
+          '[Auth0] Enterprise Connect: "offline_access" in scope has no effect. B2B Integration clients are not issued refresh tokens.'
+        );
+      }
+      if (this.#options.organization || this.#options.authorizationParams?.organization) {
+        console.warn(
+          '[Auth0] Enterprise Connect: static "organization" is set. The organization is resolved per login by HRD from the login_hint email domain. A static value routes all enterprise users to the same organization.'
+        );
+      }
+      applyEnterpriseConnectRestrictions(this);
+    }
     if (typeof this.#options.domain !== "string" && typeof this.#options.domain !== "function") {
       throw new InvalidConfigurationError("domain must be a string or resolver function");
     }
@@ -631,7 +696,7 @@ var ServerClient = class {
     if (typeof this.#options.domain === "string") {
       const domain = normalizeDomain(this.#options.domain);
       this.#staticDomain = domain;
-      this.#authClient = new import_auth0_auth_js.AuthClient({
+      this.#authClient = new import_auth0_auth_js2.AuthClient({
         domain,
         ...this.#authClientOptions,
         telemetry: getTelemetryConfig(this.#options.telemetry)
@@ -668,7 +733,7 @@ var ServerClient = class {
     return normalizeDomain(this.#options.domain);
   }
   #createAuthClient(domain) {
-    return new import_auth0_auth_js.AuthClient({
+    return new import_auth0_auth_js2.AuthClient({
       domain,
       ...this.#authClientOptions,
       telemetry: getTelemetryConfig(this.#options.telemetry)
@@ -705,6 +770,33 @@ var ServerClient = class {
     const resolvedDomain = await this.#resolveDomain(storeOptions);
     return sessionDomain === resolvedDomain;
   }
+  /**
+   * Starts the Enterprise Connect login flow. Performs WebFinger domain discovery
+   * and, if the email domain is federated, initiates an interactive login with `login_hint`.
+   *
+   * @param options Options including the user's email and optional returnTo URL.
+   * @param storeOptions Optional options passed to the Transaction Store.
+   *
+   * @returns A URL to redirect to (federated domain) or null (not federated / invalid email).
+   */
+  async startEnterpriseLogin(options, storeOptions) {
+    const parts = options.email.split("@");
+    if (parts.length !== 2 || !parts[0] || !parts[1]) return null;
+    const emailDomain = parts[1].toLowerCase();
+    const domain = await this.#resolveDomain(storeOptions);
+    const isFederated = await (0, import_auth0_auth_js2.isFederatedDomain)(domain, emailDomain, {
+      customFetch: this.#options.customFetch,
+      telemetry: getTelemetryConfig(this.#options.telemetry)
+    });
+    if (!isFederated) return null;
+    return this.startInteractiveLogin(
+      {
+        authorizationParams: { login_hint: options.email },
+        appState: options.returnTo ? { returnTo: options.returnTo } : void 0
+      },
+      storeOptions
+    );
+  }
   /**
    * Starts the interactive login process, and returns a URL to redirect the user-agent to to request authorization at Auth0.
    *
@@ -726,12 +818,13 @@ var ServerClient = class {
     if (!redirectUri) {
       throw new MissingRequiredArgumentError("authorizationParams.redirect_uri");
     }
-    const scope = ensureOpenIdScope(options?.authorizationParams?.scope ?? this.#options.authorizationParams?.scope);
+    const rawScope = ensureOpenIdScope(options?.authorizationParams?.scope ?? this.#options.authorizationParams?.scope);
+    const scope = this.#enterpriseConnect ? rawScope.split(" ").filter((s) => s !== "offline_access").join(" ") : rawScope;
     const perLoginAuthParamsOrganization = typeof options?.authorizationParams?.organization === "string" ? options.authorizationParams.organization : void 0;
     const clientAuthParamsOrganization = typeof this.#options.authorizationParams?.organization === "string" ? this.#options.authorizationParams.organization : void 0;
     const resolvedOrganization = options?.organization ?? perLoginAuthParamsOrganization ?? this.#options.organization ?? clientAuthParamsOrganization;
     if (resolvedOrganization !== void 0 && !resolvedOrganization.trim()) {
-      throw new import_auth0_auth_js.OrganizationValidationError("organization must not be blank");
+      throw new import_auth0_auth_js2.OrganizationValidationError("organization must not be blank");
     }
     const hasInvitation = !!(options?.invitation || options?.authorizationParams?.invitation);
     if (hasInvitation && !resolvedOrganization) {
@@ -768,6 +861,7 @@ var ServerClient = class {
    * Takes an URL, extract the Authorization Code flow query parameters and requests a token.
    * @param url The URl from which the query params should be extracted to exchange for a token.
    * @param storeOptions Optional options used to pass to the Transaction and State Store.
+   * @param requestOptions Optional per-request options (signal, headers, customFetch). Applied to the code-for-token exchange.
    *
    * @throws {MissingTransactionError} When no transaction was found.
    * @throws {TokenByCodeError} If there was an issue requesting the access token.
@@ -775,8 +869,16 @@ var ServerClient = class {
    * @throws {SessionExpiredError} When the ID token's `session_expiry` is already in the past at login (the session is born expired); nothing is persisted.
    *
    * @returns A promise resolving to an object, containing the original appState (if present) and the authorizationDetails (when RAR was used).
+   * In Enterprise Connect mode, also includes `idTokenClaims` and `user`.
+   *
+   * @remarks
+   * This method does not support the `fullResponse` opt-in in v1. It accepts
+   * `url` and `storeOptions` with no intermediate options object; adding
+   * `fullResponse` would require a new options parameter and is deferred to
+   * a later revision.
+   * TODO(#<issue-number>): add fullResponse overload to completeInteractiveLogin in a future minor.
    */
-  async completeInteractiveLogin(url, storeOptions) {
+  async completeInteractiveLogin(url, storeOptions, requestOptions) {
     const transactionData = await this.#transactionStore.get(this.#transactionStoreIdentifier, storeOptions);
     if (!transactionData) {
       throw new MissingTransactionError();
@@ -787,8 +889,18 @@ var ServerClient = class {
       // TransactionData.codeVerifier is optional only to accommodate magic-link transactions.
       codeVerifier: transactionData.codeVerifier,
       organization: transactionData.organization
-    });
+    }, requestOptions);
     await this.#transactionStore.delete(this.#transactionStoreIdentifier, storeOptions);
+    if (this.#enterpriseConnect) {
+      const claims = tokenEndpointResponse.claims;
+      const user = claims ? Object.fromEntries(Object.entries(claims).filter(([, v]) => v !== void 0)) : void 0;
+      return {
+        appState: transactionData.appState,
+        authorizationDetails: tokenEndpointResponse.authorizationDetails,
+        idTokenClaims: claims,
+        user
+      };
+    }
     const existingStateData = await this.#stateStore.get(this.#stateStoreIdentifier, storeOptions);
     const stateData = applySessionExpiryAtLogin(
       updateStateData(transactionData.audience ?? "default", existingStateData, tokenEndpointResponse, {
@@ -797,7 +909,10 @@ var ServerClient = class {
       tokenEndpointResponse.claims
     );
     await this.#stateStore.set(this.#stateStoreIdentifier, stateData, true, storeOptions);
-    return { appState: transactionData.appState, authorizationDetails: tokenEndpointResponse.authorizationDetails };
+    return {
+      appState: transactionData.appState,
+      authorizationDetails: tokenEndpointResponse.authorizationDetails
+    };
   }
   /**
    * Starts the user linking process, and returns a URL to redirect the user-agent to to request authorization at Auth0.
@@ -851,14 +966,15 @@ var ServerClient = class {
    * Takes an URL, extract the Authorization Code flow query parameters and requests a token.
    * @param url The URl from which the query params should be extracted to exchange for a token.
    * @param storeOptions Optional options used to pass to the Transaction and State Store.
+   * @param requestOptions Optional per-request options (signal, headers, customFetch). Applied to the code-for-token exchange.
    *
    * @throws {MissingTransactionError} When no transaction was found.
    * @throws {TokenByCodeError} If there was an issue requesting the access token.
    *
    * @returns A promise resolving to an object, containing the original appState (if present).
    */
-  async completeLinkUser(url, storeOptions) {
-    const result = await this.completeInteractiveLogin(url, storeOptions);
+  async completeLinkUser(url, storeOptions, requestOptions) {
+    const result = await this.completeInteractiveLogin(url, storeOptions, requestOptions);
     return {
       appState: result.appState
     };
@@ -914,43 +1030,44 @@ var ServerClient = class {
    * Takes an URL, extract the Authorization Code flow query parameters and requests a token.
    * @param url The URl from which the query params should be extracted to exchange for a token.
    * @param storeOptions Optional options used to pass to the Transaction and State Store.
+   * @param requestOptions Optional per-request options (signal, headers, customFetch). Applied to the code-for-token exchange.
    *
    * @throws {MissingTransactionError} When no transaction was found.
    * @throws {TokenByCodeError} If there was an issue requesting the access token.
    *
    * @returns A promise resolving to an object, containing the original appState (if present).
    */
-  async completeUnlinkUser(url, storeOptions) {
-    const result = await this.completeInteractiveLogin(url, storeOptions);
+  async completeUnlinkUser(url, storeOptions, requestOptions) {
+    const result = await this.completeInteractiveLogin(url, storeOptions, requestOptions);
     return {
       appState: result.appState
     };
   }
-  /**
-   * Logs in using Client-Initiated Backchannel Authentication.
-   *
-   * Using Client-Initiated Backchannel Authentication requires the feature to be enabled in the Auth0 dashboard.
-   * @see https://auth0.com/docs/get-started/authentication-and-authorization-flow/client-initiated-backchannel-authentication-flow
-   * @param options Options used to configure the backchannel login process.
-   * @param storeOptions Optional options used to pass to the Transaction and State Store.
-   *
-   * @throws {BackchannelAuthenticationError} If there was an issue when doing backchannel authentication.
-   * @throws {SessionExpiredError} When the ID token's `session_expiry` is already in the past at login (the session is born expired); nothing is persisted.
-   *
-   * @returns A promise resolving to an object, containing the authorizationDetails (when RAR was used).
-   */
-  async loginBackchannel(options, storeOptions) {
+  async loginBackchannel(options, storeOptions, requestOptions) {
     const scope = ensureOpenIdScope(options.authorizationParams?.scope ?? this.#options.authorizationParams?.scope);
     const domain = await this.#resolveDomain(storeOptions);
     const authClient = this.#getAuthClient(domain);
-    const tokenEndpointResponse = await authClient.backchannelAuthentication({
-      bindingMessage: options.bindingMessage,
-      loginHint: options.loginHint,
-      authorizationParams: {
-        ...options.authorizationParams,
-        scope
-      }
-    });
+    let response;
+    let tokenEndpointResponse;
+    if (options.fullResponse) {
+      const authJsResult = await authClient.backchannelAuthentication({
+        bindingMessage: options.bindingMessage,
+        loginHint: options.loginHint,
+        authorizationParams: { ...options.authorizationParams, scope },
+        fullResponse: true
+      }, requestOptions);
+      tokenEndpointResponse = authJsResult.data;
+      response = authJsResult.response;
+    } else {
+      tokenEndpointResponse = await authClient.backchannelAuthentication({
+        bindingMessage: options.bindingMessage,
+        loginHint: options.loginHint,
+        authorizationParams: {
+          ...options.authorizationParams,
+          scope
+        }
+      }, requestOptions);
+    }
     const existingStateData = await this.#stateStore.get(this.#stateStoreIdentifier, storeOptions);
     const stateData = applySessionExpiryAtLogin(
       updateStateData(this.#options.authorizationParams?.audience ?? "default", existingStateData, tokenEndpointResponse, {
@@ -959,9 +1076,16 @@ var ServerClient = class {
       tokenEndpointResponse.claims
     );
     await this.#stateStore.set(this.#stateStoreIdentifier, stateData, true, storeOptions);
-    return {
+    const result = {
       authorizationDetails: tokenEndpointResponse.authorizationDetails
     };
+    if (options.fullResponse) {
+      if (!response) {
+        throw new import_auth0_auth_js2.MissingCapturedResponseError();
+      }
+      return { data: result, response };
+    }
+    return result;
   }
   /**
    * Starts a passwordless flow by sending a one-time code (OTP) or a magic link.
@@ -984,6 +1108,7 @@ var ServerClient = class {
    *
    * @param options Discriminated start options.
    * @param storeOptions Optional options passed to the resolver / stores.
+   * @param requestOptions Optional per-request options (signal, headers, customFetch). Applied to the `/passwordless/start` request.
    *
    * @throws {PasswordlessStartError} If the request fails, or if a magic link is requested without a `redirectUri`.
    *
@@ -1000,43 +1125,52 @@ var ServerClient = class {
    *   redirectUri: 'https://app.example.com/auth/callback',
    * });
    */
-  async startPasswordless(options, storeOptions) {
+  async startPasswordless(options, storeOptions, requestOptions) {
     const domain = await this.#resolveDomain(storeOptions);
     const authClient = this.#getAuthClient(domain);
     if (options.connection === "sms") {
-      await authClient.passwordless.sendSms({
-        phoneNumber: options.phoneNumber,
-        language: options.language
-      });
+      await authClient.passwordless.sendSms(
+        {
+          phoneNumber: options.phoneNumber,
+          language: options.language
+        },
+        requestOptions
+      );
       return;
     }
     if (options.send !== "link") {
-      await authClient.passwordless.sendEmail({
-        email: options.email,
-        send: "code",
-        language: options.language
-      });
+      await authClient.passwordless.sendEmail(
+        {
+          email: options.email,
+          send: "code",
+          language: options.language
+        },
+        requestOptions
+      );
       return;
     }
     if (!options.redirectUri || typeof options.redirectUri !== "string") {
-      throw new import_auth0_auth_js.PasswordlessStartError("redirectUri is required to start a passwordless magic-link login.");
+      throw new import_auth0_auth_js2.PasswordlessStartError("redirectUri is required to start a passwordless magic-link login.");
     }
     const state = crypto.randomUUID();
     const scope = ensureOpenIdScope(options.scope ?? this.#options.authorizationParams?.scope);
     const audience = options.audience ?? this.#options.authorizationParams?.audience;
-    await authClient.passwordless.sendEmail({
-      email: options.email,
-      send: "link",
-      language: options.language,
-      authParams: {
-        ...options.authParams,
-        redirect_uri: options.redirectUri,
-        response_type: "code",
-        scope,
-        ...audience ? { audience } : {},
-        state
-      }
-    });
+    await authClient.passwordless.sendEmail(
+      {
+        email: options.email,
+        send: "link",
+        language: options.language,
+        authParams: {
+          ...options.authParams,
+          redirect_uri: options.redirectUri,
+          response_type: "code",
+          scope,
+          ...audience ? { audience } : {},
+          state
+        }
+      },
+      requestOptions
+    );
     const transactionState = {
       audience,
       domain,
@@ -1044,42 +1178,42 @@ var ServerClient = class {
     };
     await this.#transactionStore.set(this.#transactionStoreIdentifier, transactionState, false, storeOptions);
   }
-  /**
-   * Completes a passwordless OTP login and persists the resulting session.
-   *
-   * Discriminated on `connection` to mirror the `@auth0/nextjs-auth0` `passwordless.verify()`
-   * surface. Non-redirect flow: no PKCE and no transaction store (mirrors
-   * {@link ServerClient#loginBackchannel}). The `openid` scope is always ensured by this layer.
-   *
-   * Note: the state store is read-then-written; if your deployment performs concurrent
-   * logins for the same session identifier, use a state store with atomic/serializable
-   * writes to avoid last-write-wins races.
-   *
-   * @param options Discriminated completion options (`connection`, identifier, `verificationCode`).
-   * @param storeOptions Optional options passed to the resolver / stores.
-   *
-   * @throws {PasswordlessVerifyError} If the code is invalid, expired, or rate-limited. When the
-   *   connection requires MFA, the server responds with `mfa_required`; narrow the thrown error
-   *   with `isMfaRequiredError(error)` to read `cause.mfa_token`.
-   *
-   * @returns A promise resolving to the authorizationDetails (when RAR was used).
-   */
-  async completePasswordless(options, storeOptions) {
+  async completePasswordless(options, storeOptions, requestOptions) {
     const scope = ensureOpenIdScope(options.authorizationParams?.scope ?? this.#options.authorizationParams?.scope);
     const audience = options.authorizationParams?.audience ?? this.#options.authorizationParams?.audience;
     const domain = await this.#resolveDomain(storeOptions);
     const authClient = this.#getAuthClient(domain);
-    const tokenEndpointResponse = options.connection === "sms" ? await authClient.getTokenByPasswordlessSms({
-      phoneNumber: options.phoneNumber,
-      code: options.verificationCode,
-      audience,
-      scope
-    }) : await authClient.getTokenByPasswordlessEmail({
-      email: options.email,
-      code: options.verificationCode,
-      audience,
-      scope
-    });
+    let response;
+    let tokenEndpointResponse;
+    if (options.fullResponse) {
+      const authJsResult = options.connection === "sms" ? await authClient.getTokenByPasswordlessSms({
+        phoneNumber: options.phoneNumber,
+        code: options.verificationCode,
+        audience,
+        scope,
+        fullResponse: true
+      }, requestOptions) : await authClient.getTokenByPasswordlessEmail({
+        email: options.email,
+        code: options.verificationCode,
+        audience,
+        scope,
+        fullResponse: true
+      }, requestOptions);
+      tokenEndpointResponse = authJsResult.data;
+      response = authJsResult.response;
+    } else {
+      tokenEndpointResponse = options.connection === "sms" ? await authClient.getTokenByPasswordlessSms({
+        phoneNumber: options.phoneNumber,
+        code: options.verificationCode,
+        audience,
+        scope
+      }, requestOptions) : await authClient.getTokenByPasswordlessEmail({
+        email: options.email,
+        code: options.verificationCode,
+        audience,
+        scope
+      }, requestOptions);
+    }
     const existingStateData = await this.#stateStore.get(this.#stateStoreIdentifier, storeOptions);
     const stateData = updateStateData(
       this.#options.authorizationParams?.audience ?? "default",
@@ -1088,9 +1222,16 @@ var ServerClient = class {
       { domain }
     );
     await this.#stateStore.set(this.#stateStoreIdentifier, stateData, true, storeOptions);
-    return {
+    const result = {
       authorizationDetails: tokenEndpointResponse.authorizationDetails
     };
+    if (options.fullResponse) {
+      if (!response) {
+        throw new import_auth0_auth_js2.MissingCapturedResponseError();
+      }
+      return { data: result, response };
+    }
+    return result;
   }
   /**
    * Completes a passwordless magic-link login and persists the resulting session.
@@ -1102,6 +1243,7 @@ var ServerClient = class {
    *
    * @param url The callback URL containing the authorization `code` and `state`.
    * @param storeOptions Optional options passed to the resolver / stores.
+   * @param requestOptions Optional per-request options (signal, headers, customFetch). Applied to the code exchange.
    *
    * @throws {MissingTransactionError} If no magic-link transaction was found.
    * @throws {PasswordlessVerifyError} If the returned `state` is missing or does not match.
@@ -1112,7 +1254,7 @@ var ServerClient = class {
    * @example
    * const result = await serverClient.completePasswordlessMagicLink(callbackUrl, storeOptions);
    */
-  async completePasswordlessMagicLink(url, storeOptions) {
+  async completePasswordlessMagicLink(url, storeOptions, requestOptions) {
     const transactionData = await this.#transactionStore.get(this.#transactionStoreIdentifier, storeOptions);
     if (!transactionData) {
       throw new MissingTransactionError();
@@ -1120,11 +1262,11 @@ var ServerClient = class {
     const expectedState = typeof transactionData.state === "string" ? transactionData.state : void 0;
     const returnedState = url.searchParams.get("state");
     if (!returnedState || !expectedState || returnedState !== expectedState) {
-      throw new import_auth0_auth_js.PasswordlessVerifyError("State mismatch on magic-link callback");
+      throw new import_auth0_auth_js2.PasswordlessVerifyError("State mismatch on magic-link callback");
     }
     const domain = transactionData.domain ?? await this.#resolveDomain(storeOptions);
     const authClient = this.#getAuthClient(domain);
-    const tokenEndpointResponse = await authClient.getTokenByMagicLinkCode(url, { expectedState });
+    const tokenEndpointResponse = await authClient.getTokenByMagicLinkCode(url, { expectedState }, requestOptions);
     const existingStateData = await this.#stateStore.get(this.#stateStoreIdentifier, storeOptions);
     const stateData = updateStateData(transactionData.audience ?? "default", existingStateData, tokenEndpointResponse, {
       domain
@@ -1137,6 +1279,12 @@ var ServerClient = class {
   }
   /**
    * Retrieves the user from the store, or undefined if no user found.
+   *
+   * This does not accept `RequestOptions`. It is a pure read from the state store and makes no
+   * network call, so a per-request `signal`/`headers`/`customFetch` could not take effect. The
+   * exclusion is deliberate: a parameter that can never do anything costs the public surface more
+   * than the asymmetry with `getAccessToken`/`getAccessTokenForConnection`/`revokeRefreshToken` does.
+   *
    * @param storeOptions Optional options used to pass to the Transaction and State Store.
    * @returns The user, or undefined if no user found in the store.
    */
@@ -1179,6 +1327,34 @@ var ServerClient = class {
       return sessionData;
     }
   }
+  /**
+   * Retrieves the OIDC UserInfo claims for a given access token.
+   *
+   * The access token must be supplied explicitly by the caller. This method does NOT read
+   * the token from the session and does NOT trigger a refresh. The token must be accepted by
+   * the `/userinfo` endpoint:
+   * - Without Multi-Resource Refresh Tokens (MRRT): pass a default OIDC access token, one
+   *   obtained without an explicit `audience` parameter.
+   * - With MRRT: tokens are audience-bound, so request the userinfo endpoint as the audience
+   *   (e.g. `https://<domain>/userinfo`) when obtaining the token. A token bound to a
+   *   different resource-server audience is rejected by `/userinfo`.
+   *
+   * `/userinfo` is a bearer-protected resource and requires no client authentication, so this
+   * works for public clients: the supplied access token is the only credential used.
+   *
+   * @param options Options containing the access token and an optional expected subject
+   *                for OIDC subject-consistency validation.
+   * @param storeOptions Optional store options, used to resolve the domain in resolver mode.
+   * @param requestOptions Optional per-request options (signal, headers, customFetch) forwarded
+   *                to the underlying `/userinfo` request.
+   * @throws {UserInfoError} When the `/userinfo` request fails or the subject check fails.
+   * @returns A Promise resolving to the UserInfo claims.
+   */
+  async getUserInfo(options, storeOptions, requestOptions) {
+    const domain = await this.#resolveDomain(storeOptions);
+    const authClient = this.#getAuthClient(domain);
+    return authClient.getUserInfo(options, requestOptions);
+  }
   /**
    * Retrieves the access token from the store, or calls Auth0 when the access token is expired and a refresh token is available in the store.
    * Also updates the store when a new token was retrieved from Auth0.
@@ -1187,19 +1363,30 @@ var ServerClient = class {
    * request an access token for that audience/scope (Multi-Resource Refresh Tokens). Tokens are cached per
    * audience and scope combination.
    *
-   * @param options Optional options for requesting a specific audience/scope.
+   * When `options.fullResponse` is `true`, the method returns an {@link ApiResponse} envelope containing both
+   * the token set and the raw {@link Response} from the token endpoint. The cache is bypassed in this case,
+   * forcing a refresh-token call even when a valid cached token exists, because the `Response` can only be
+   * produced by a live HTTP call.
+   *
+   * @param options Optional options for requesting a specific audience/scope or enabling full response.
    * @param storeOptions Optional options used to pass to the Transaction and State Store.
+   * @param requestOptions Optional per-request options (signal, headers, customFetch). Only supported with the options form (second overload). A cache hit returns before any network call, so `requestOptions` (including `signal`) is a no-op on that path; it applies only to the refresh-token exchange on a cache miss.
+   *
+   * @remarks
+   * Legacy single-argument form: `getAccessToken(storeOptions?)`. If your `TStoreOptions` type
+   * contains `audience` or `scope` keys, use the explicit two-argument form instead:
+   * `getAccessToken({}, storeOptions)` to avoid call-site routing ambiguity.
    *
    * @throws {TokenByRefreshTokenError} If the refresh token was not found or there was an issue requesting the access token. When the cause is `mfa_required`, use `isMfaRequiredError(error)` to narrow the error and read `cause.mfa_token`.
    * @throws {SessionExpiredError} When the session's `session_expiry` ceiling has been reached; the session is cleared and no refresh is attempted — the user must re-authenticate.
    *
-   * @returns The Token Set, containing the access token, as well as additional information.
+   * @returns The Token Set when `fullResponse` is omitted, or an {@link ApiResponse} envelope when `fullResponse: true`.
    */
-  async getAccessToken(tokenOptionsOrStoreOptions, storeOptions) {
+  async getAccessToken(tokenOptionsOrStoreOptions, storeOptions, requestOptions) {
     const hasTokenOptions = (
       // If second arg exists, first arg must be GetAccessTokenOptions
-      storeOptions !== void 0 || // OR if first arg has audience/scope properties
-      !!tokenOptionsOrStoreOptions && typeof tokenOptionsOrStoreOptions === "object" && ("audience" in tokenOptionsOrStoreOptions || "scope" in tokenOptionsOrStoreOptions)
+      storeOptions !== void 0 || // OR if first arg has audience, scope, or fullResponse properties
+      !!tokenOptionsOrStoreOptions && typeof tokenOptionsOrStoreOptions === "object" && ("audience" in tokenOptionsOrStoreOptions || "scope" in tokenOptionsOrStoreOptions || "fullResponse" in tokenOptionsOrStoreOptions)
     );
     const [resolvedOptions, resolvedStoreOptions] = hasTokenOptions ? [tokenOptionsOrStoreOptions, storeOptions] : [void 0, tokenOptionsOrStoreOptions];
     const stateData = await this.#stateStore.get(this.#stateStoreIdentifier, resolvedStoreOptions);
@@ -1227,10 +1414,12 @@ var ServerClient = class {
       (tokenSet2) => tokenSet2.audience === audience && (!scope || compareScopes(tokenSet2.scope, scope))
     );
     if (tokenSet && tokenSet.expiresAt > Date.now() / 1e3) {
-      return tokenSet;
+      if (!resolvedOptions?.fullResponse) {
+        return tokenSet;
+      }
     }
     if (!stateData?.refreshToken) {
-      throw new import_auth0_auth_js.TokenByRefreshTokenError(
+      throw new import_auth0_auth_js2.TokenByRefreshTokenError(
         "The access token has expired and a refresh token was not provided. The user needs to re-authenticate."
       );
     }
@@ -1244,35 +1433,38 @@ var ServerClient = class {
         ...scope && { scope }
       }
     };
-    const tokenEndpointResponse = await this.#getAuthClient(domainForSession).getTokenByRefreshToken(tokenByRefreshTokenOptions);
+    let response;
+    let tokenEndpointResponse;
+    if (resolvedOptions?.fullResponse) {
+      const authJsResult = await this.#getAuthClient(domainForSession).getTokenByRefreshToken({
+        ...tokenByRefreshTokenOptions,
+        fullResponse: true
+      }, requestOptions);
+      tokenEndpointResponse = authJsResult.data;
+      response = authJsResult.response;
+    } else {
+      tokenEndpointResponse = await this.#getAuthClient(domainForSession).getTokenByRefreshToken(tokenByRefreshTokenOptions, requestOptions);
+    }
     const existingStateData = await this.#stateStore.get(this.#stateStoreIdentifier, resolvedStoreOptions);
     const updatedStateData = updateStateData(audience, existingStateData, tokenEndpointResponse, {
       domain: domainForSession
     });
     await this.#stateStore.set(this.#stateStoreIdentifier, updatedStateData, false, resolvedStoreOptions);
-    return {
+    const returnTokenSet = {
       accessToken: tokenEndpointResponse.accessToken,
       scope: tokenEndpointResponse.scope,
       expiresAt: tokenEndpointResponse.expiresAt,
       audience
     };
+    if (resolvedOptions?.fullResponse) {
+      if (!response) {
+        throw new import_auth0_auth_js2.MissingCapturedResponseError();
+      }
+      return { data: returnTokenSet, response };
+    }
+    return returnTokenSet;
   }
-  /**
-   * Retrieves an access token for a connection.
-   *
-   * This method attempts to obtain an access token for a specified connection.
-   * It first checks if a refresh token exists in the store.
-   * If no refresh token is found, it throws an `AccessTokenForConnectionError` indicating
-   * that the refresh token was not found.
-   *
-   * @param options - Options for retrieving an access token for a connection.
-   * @param storeOptions Optional options used to pass to the Transaction and State Store.
-   *
-   * @throws {TokenForConnectionError} If the refresh token was not found or there was an issue requesting the access token.
-   *
-   * @returns The Connection Token Set, containing the access token for the connection, as well as additional information.
-   */
-  async getAccessTokenForConnection(options, storeOptions) {
+  async getAccessTokenForConnection(options, storeOptions, requestOptions) {
     const stateData = await this.#stateStore.get(this.#stateStoreIdentifier, storeOptions);
     const sessionDomain = stateData ? this.#getSessionDomain(stateData) : this.#staticDomain;
     if (this.#isResolverMode()) {
@@ -1291,19 +1483,34 @@ var ServerClient = class {
       (tokenSet) => tokenSet.connection === options.connection
     );
     if (connectionTokenSet && connectionTokenSet.expiresAt > Date.now() / 1e3) {
-      return connectionTokenSet;
+      if (!options.fullResponse) {
+        return connectionTokenSet;
+      }
     }
     if (!stateData?.refreshToken) {
-      throw new import_auth0_auth_js.TokenForConnectionError(
+      throw new import_auth0_auth_js2.TokenForConnectionError(
         "A refresh token was not found but is required to be able to retrieve an access token for a connection."
       );
     }
     const domainForSession = sessionDomain;
-    const tokenEndpointResponse = await this.#getAuthClient(domainForSession).getTokenForConnection({
-      connection: options.connection,
-      loginHint: options.loginHint,
-      refreshToken: stateData.refreshToken
-    });
+    let response;
+    let tokenEndpointResponse;
+    if (options.fullResponse) {
+      const authJsResult = await this.#getAuthClient(domainForSession).getTokenForConnection({
+        connection: options.connection,
+        loginHint: options.loginHint,
+        refreshToken: stateData.refreshToken,
+        fullResponse: true
+      }, requestOptions);
+      tokenEndpointResponse = authJsResult.data;
+      response = authJsResult.response;
+    } else {
+      tokenEndpointResponse = await this.#getAuthClient(domainForSession).getTokenForConnection({
+        connection: options.connection,
+        loginHint: options.loginHint,
+        refreshToken: stateData.refreshToken
+      }, requestOptions);
+    }
     const updatedStateData = updateStateDataForConnectionTokenSet(
       options,
       {
@@ -1313,13 +1520,20 @@ var ServerClient = class {
       tokenEndpointResponse
     );
     await this.#stateStore.set(this.#stateStoreIdentifier, updatedStateData, false, storeOptions);
-    return {
+    const returnConnectionTokenSet = {
       accessToken: tokenEndpointResponse.accessToken,
       scope: tokenEndpointResponse.scope,
       expiresAt: tokenEndpointResponse.expiresAt,
       connection: options.connection,
       loginHint: options.loginHint
     };
+    if (options.fullResponse) {
+      if (!response) {
+        throw new import_auth0_auth_js2.MissingCapturedResponseError();
+      }
+      return { data: returnConnectionTokenSet, response };
+    }
+    return returnConnectionTokenSet;
   }
   /**
    * Revokes the refresh token stored in the current session, or an explicitly supplied token.
@@ -1331,12 +1545,13 @@ var ServerClient = class {
    *
    * @param options Optionally supply a token to revoke instead of reading from the session.
    * @param storeOptions Optional options passed to the StateStore.
+   * @param requestOptions Optional per-request options (signal, headers, customFetch). Applied to the revocation request.
    *
    * @throws {MissingRequiredArgumentError} If `options.token` is an empty string.
    * @throws {MissingSessionError} If no refresh token is found in the session and none was provided.
    * @throws {TokenRevocationError} If the revocation request fails.
    */
-  async revokeRefreshToken(options = {}, storeOptions) {
+  async revokeRefreshToken(options = {}, storeOptions, requestOptions) {
     if (options.token !== void 0 && options.token.length === 0) {
       throw new MissingRequiredArgumentError("options.token must not be an empty string.");
     }
@@ -1360,18 +1575,27 @@ var ServerClient = class {
     } else {
       authClient = this.authClient;
     }
-    await authClient.revokeToken({ token: refreshToken, tokenTypeHint: "refresh_token" });
+    await authClient.revokeToken({ token: refreshToken, tokenTypeHint: "refresh_token" }, requestOptions);
   }
   /**
    * Logs the user out and returns a URL to redirect the user-agent to after they log out.
    * @param options Options used to configure the logout process.
    * @param storeOptions Optional options used to pass to the Transaction and State Store.
+   * @param requestOptions Optional per-request options (signal, headers, customFetch). Applied to the token revocation ONLY. Building the logout URL is local string work and issues no request, so nothing here can affect it.
    * @returns {URL}
    */
-  async logout(options, storeOptions) {
+  async logout(options, storeOptions, requestOptions) {
+    if (this.#enterpriseConnect) {
+      if (options.federated === false) {
+        console.warn(
+          "[Auth0] Enterprise Connect: logout() called with federated=false. The enterprise IdP session will remain active; the user may silently re-authenticate on the next login."
+        );
+      }
+      return this.authClient.buildLogoutUrl({ returnTo: options.returnTo, federated: options.federated ?? true });
+    }
     if (!this.#isResolverMode()) {
       try {
-        await this.revokeRefreshToken({}, storeOptions);
+        await this.revokeRefreshToken({}, storeOptions, requestOptions);
       } catch {
       }
       await this.#stateStore.delete(this.#stateStoreIdentifier, storeOptions);
@@ -1387,39 +1611,33 @@ var ServerClient = class {
     const domainMatches = sessionDomain === resolvedDomain;
     if (domainMatches) {
       try {
-        await this.revokeRefreshToken({}, storeOptions);
+        await this.revokeRefreshToken({}, storeOptions, requestOptions);
       } catch {
       }
       await this.#stateStore.delete(this.#stateStoreIdentifier, storeOptions);
     }
     return authClient.buildLogoutUrl(options);
   }
-  /**
-   * Exchanges a custom token for Auth0 tokens and persists the resulting session (RFC 8693).
-   *
-   * Calls the token endpoint using the RFC 8693 Token Exchange grant, then stores the
-   * resulting tokens in the StateStore — effectively logging the user in without an
-   * interactive browser flow. Use this when the caller already holds a trusted external
-   * token (e.g. a Google ID token, a legacy system token) and wants to establish an
-   * Auth0 session from it.
-   *
-   * Requires a Token Exchange Profile configured in your Auth0 tenant.
-   *
-   * @param options Options for the custom token exchange, including the subject token and its type.
-   * @param storeOptions Optional options passed to the StateStore.
-   *
-   * @throws {TokenExchangeError} If the exchange fails or the subject token is invalid.
-   * @throws {MissingClientAuthError} If client credentials are not configured.
-   *
-   * @returns A promise resolving to an object containing `authorizationDetails` when RAR was used.
-   */
-  async loginWithCustomTokenExchange(options, storeOptions) {
+  async loginWithCustomTokenExchange(options, storeOptions, requestOptions) {
     const domain = await this.#resolveDomain(storeOptions);
     const authClient = this.#getAuthClient(domain);
-    const tokenEndpointResponse = await authClient.exchangeToken({
-      ...options,
-      scope: ensureOpenIdScope(options.scope)
-    });
+    let response;
+    let tokenEndpointResponse;
+    if (options.fullResponse) {
+      const { fullResponse: _, ...rest } = options;
+      const authJsResult = await authClient.exchangeToken({
+        ...rest,
+        scope: ensureOpenIdScope(options.scope),
+        fullResponse: true
+      }, requestOptions);
+      tokenEndpointResponse = authJsResult.data;
+      response = authJsResult.response;
+    } else {
+      tokenEndpointResponse = await authClient.exchangeToken({
+        ...options,
+        scope: ensureOpenIdScope(options.scope)
+      }, requestOptions);
+    }
     const existingStateData = await this.#stateStore.get(this.#stateStoreIdentifier, storeOptions);
     const stateData = updateStateData(
       this.#options.authorizationParams?.audience ?? "default",
@@ -1428,30 +1646,25 @@ var ServerClient = class {
       { domain }
     );
     await this.#stateStore.set(this.#stateStoreIdentifier, stateData, true, storeOptions);
-    return { authorizationDetails: tokenEndpointResponse.authorizationDetails };
+    const result = {
+      authorizationDetails: tokenEndpointResponse.authorizationDetails
+    };
+    if (options.fullResponse) {
+      if (!response) {
+        throw new import_auth0_auth_js2.MissingCapturedResponseError();
+      }
+      return { data: result, response };
+    }
+    return result;
   }
-  /**
-   * Exchanges a custom token for Auth0 tokens without establishing a session (RFC 8693).
-   *
-   * Performs the same RFC 8693 Token Exchange as `loginWithCustomTokenExchange` but
-   * returns the raw token response without writing anything to the StateStore. Use this
-   * for delegation or impersonation flows where you need downstream tokens but do not
-   * want to create or modify the current user session.
-   *
-   * Requires a Token Exchange Profile configured in your Auth0 tenant.
-   *
-   * @param options Options for the custom token exchange, including the subject token and its type.
-   * @param storeOptions Optional options passed to the StateStore (used only for domain resolution in resolver mode).
-   *
-   * @throws {TokenExchangeError} If the exchange fails or the subject token is invalid.
-   * @throws {MissingClientAuthError} If client credentials are not configured.
-   *
-   * @returns A promise resolving to the token response from Auth0.
-   */
-  async customTokenExchange(options, storeOptions) {
+  async customTokenExchange(options, storeOptions, requestOptions) {
     const domain = await this.#resolveDomain(storeOptions);
     const authClient = this.#getAuthClient(domain);
-    return authClient.exchangeToken(options);
+    if (options.fullResponse) {
+      const { fullResponse: _, ...rest } = options;
+      return authClient.exchangeToken({ ...rest, fullResponse: true }, requestOptions);
+    }
+    return authClient.exchangeToken(options, requestOptions);
   }
   /**
    * Requests a Session Transfer Token (STT) for impersonation via session transfer (RFC 8693).
@@ -1475,8 +1688,17 @@ var ServerClient = class {
    * {@link ServerClient.buildSessionTransferRedirect}, which is forwarded to the target's
    * `/authorize` on the redirect.
    *
+   * @remarks
+   * If the actor's ID token has expired, an internal refresh is performed before the
+   * session transfer token exchange. This refresh call is NOT guarded by the caller's
+   * requestOptions.signal — if the signal fires during this step, the abort is ignored.
+   * Only the final exchangeToken call respects the signal.
+   * Thread requestOptions into #resolveSessionTransferActor in a future minor if
+   * callers need full-request abort coverage.
+   *
    * @param options Options including the developer-supplied `subjectToken`/`subjectTokenType` and an optional explicit `actor`.
    * @param storeOptions Optional options used to read the agent session (for the actor) and resolve the request domain.
+   * @param requestOptions Optional per-request options (signal, headers, customFetch). Applied to the STT exchange only. Resolving the actor may refresh an expired agent session ID token, and that refresh is an internal call outside the caller's per-request scope, so it does not receive these options.
    *
    * @throws {TokenExchangeError} With code `actor_unavailable` when no explicit actor is given and no usable session ID token can be resolved — no logged-in agent, a session that belongs to a different domain in resolver mode, or an expired ID token that cannot be refreshed (raised client-side, before any network call). With the default code when the exchange itself fails; a server-side `setactor_required` or `session_transfer_disabled` condition is surfaced via `cause.error` / `cause.error_description`. An organization the tenant rejects also surfaces here.
    * @throws {MissingClientAuthError} When client credentials are not configured (STT requires a confidential client).
@@ -1485,7 +1707,7 @@ var ServerClient = class {
    *
    * @returns A promise resolving to a {@link SessionTransferTokenResult} containing the STT and its metadata.
    */
-  async requestSessionTransferToken(options, storeOptions) {
+  async requestSessionTransferToken(options, storeOptions, requestOptions) {
     if (!options.subjectToken || !options.subjectToken.trim()) {
       throw new MissingRequiredArgumentError("subjectToken");
     }
@@ -1493,7 +1715,7 @@ var ServerClient = class {
       throw new MissingRequiredArgumentError("subjectTokenType");
     }
     if (options.organization !== void 0 && !options.organization.trim()) {
-      throw new import_auth0_auth_js.OrganizationValidationError("organization must not be blank");
+      throw new import_auth0_auth_js2.OrganizationValidationError("organization must not be blank");
     }
     const domain = await this.#resolveDomain(storeOptions);
     const actor = await this.#resolveSessionTransferActor(options.actor, domain, storeOptions);
@@ -1511,7 +1733,7 @@ var ServerClient = class {
       // `/authorize`; neither implies the other.
       organization: options.organization,
       extra: options.extra
-    });
+    }, requestOptions);
     return {
       sessionTransferToken: response.accessToken,
       // Surface exactly what the server returned — never fabricate the URN, so a non-STT
@@ -1567,7 +1789,7 @@ var ServerClient = class {
     url.searchParams.set("session_transfer_token", result.sessionTransferToken);
     if (options?.organization !== void 0) {
       if (!options.organization.trim()) {
-        throw new import_auth0_auth_js.OrganizationValidationError("organization must not be blank");
+        throw new import_auth0_auth_js2.OrganizationValidationError("organization must not be blank");
       }
       url.searchParams.set("organization", options.organization);
     }
@@ -1635,6 +1857,11 @@ var ServerClient = class {
   }
   /**
    * Handles the backchannel logout process by verifying the logout token and deleting the session from the store if the logout token was considered valid.
+   *
+   * This does not accept `RequestOptions`. Verification does fetch JWKS, but the auth-js method it
+   * delegates to, `verifyLogoutToken`, takes no `requestOptions`, so there is nothing to forward.
+   * That fetch always uses the client's configured `customFetch`.
+   *
    * @param logoutToken The logout token to verify and use to delete the session from the store.
    * @param storeOptions Optional options used to pass to the Transaction and State Store.
    *
@@ -1787,7 +2014,7 @@ var AbstractTransactionStore = class extends AbstractStore {
 };
 
 // src/index.ts
-var import_auth0_auth_js5 = require("@auth0/auth0-auth-js");
+var import_auth0_auth_js6 = require("@auth0/auth0-auth-js");
 
 // src/store/cookie-transaction-store.ts
 var CookieTransactionStore = class extends AbstractTransactionStore {
@@ -1984,13 +2211,13 @@ var StatelessStateStore = class extends AbstractSessionStore {
 };
 
 // src/mfa/index.ts
-var import_auth0_auth_js2 = require("@auth0/auth0-auth-js");
+var import_auth0_auth_js3 = require("@auth0/auth0-auth-js");
 
 // src/passkey/index.ts
-var import_auth0_auth_js3 = require("@auth0/auth0-auth-js");
+var import_auth0_auth_js4 = require("@auth0/auth0-auth-js");
 
 // src/database/index.ts
-var import_auth0_auth_js4 = require("@auth0/auth0-auth-js");
+var import_auth0_auth_js5 = require("@auth0/auth0-auth-js");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AbstractStateStore,
@@ -1998,6 +2225,7 @@ var import_auth0_auth_js4 = require("@auth0/auth0-auth-js");
   BackchannelLogoutError,
   ChangePasswordError,
   CookieTransactionStore,
+  EnterpriseConnectNotSupportedError,
   InvalidConfigurationError,
   IssuerValidationError,
   MfaChallengeError,
@@ -2026,6 +2254,8 @@ var import_auth0_auth_js4 = require("@auth0/auth0-auth-js");
   TokenExchangeError,
   TokenExchangeErrorCode,
   TokenRevocationError,
+  UserInfoError,
+  isFederatedDomain,
   isMfaRequiredError
 });
 //# sourceMappingURL=index.cjs.map