perimeterx-js-core 0.29.0 → 0.30.1

package/lib/cjs/activities/HttpActivityClient.js

@@ -63,24 +63,21 @@ var HttpActivityClient = /** @class */ (function () {
      */
     HttpActivityClient.prototype.sendActivities = function (context) {
         return __awaiter(this, void 0, void 0, function () {
-            var activities, e_1;
+            var activities;
             return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _a.trys.push([0, 2, , 3]);
-                        activities = this.createActivities(context);
-                        if (!activities || activities.length === 0) {
-                            context.logger.debug('no activities to send');
-                            return [2 /*return*/, true];
-                        }
-                        return [4 /*yield*/, this.postActivities(activities, context.logger)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                    case 2:
-                        e_1 = _a.sent();
-                        context.logger.error("unable to send activities - ".concat(e_1));
-                        return [2 /*return*/, false];
-                    case 3: return [2 /*return*/];
+                try {
+                    activities = this.createActivities(context);
+                    if (!activities || activities.length === 0) {
+                        context.logger.debug('no activities to send');
+                        return [2 /*return*/, true];
+                    }
+                    return [2 /*return*/, this.postActivities(activities, context.logger)];
                 }
+                catch (e) {
+                    context.logger.error("unable to send activities - ".concat(e));
+                    return [2 /*return*/, false];
+                }
+                return [2 /*return*/];
             });
         });
     };
@@ -171,11 +168,12 @@ var HttpActivityClient = /** @class */ (function () {
      */
     HttpActivityClient.prototype.postActivities = function (activities, logger) {
         return __awaiter(this, void 0, void 0, function () {
-            var url, method, headers, body, req, res;
+            var url, method, headers, body, req, res, e_1;
             var _a;
             return __generator(this, function (_b) {
                 switch (_b.label) {
                     case 0:
+                        _b.trys.push([0, 2, , 3]);
                         url = "".concat(this.config.backendCollectorUrl).concat(constants_1.ACTIVITIES_ENDPOINT);
                         method = http_1.HttpMethod.POST;
                         headers = (_a = {},
@@ -192,6 +190,11 @@ var HttpActivityClient = /** @class */ (function () {
                     case 1:
                         res = _b.sent();
                         return [2 /*return*/, (res === null || res === void 0 ? void 0 : res.status) === 200];
+                    case 2:
+                        e_1 = _b.sent();
+                        logger.error("failed to post activities - ".concat(e_1));
+                        return [2 /*return*/, false];
+                    case 3: return [2 /*return*/];
                 }
             });
         });

package/lib/cjs/config/ConfigurationBase.js

@@ -782,6 +782,13 @@ var ConfigurationBase = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
+    Object.defineProperty(ConfigurationBase.prototype, "awaitAsyncHttpRequests", {
+        get: function () {
+            return true;
+        },
+        enumerable: false,
+        configurable: true
+    });
     Object.defineProperty(ConfigurationBase.prototype, "isPostEnforceEnabled", {
         get: function () {
             return true;

package/lib/cjs/enforcer/utils.js

@@ -66,9 +66,7 @@ var createEnforcerProducts = function (config, products, base64Utils, hashUtils,
     var _a;
     var botDefender = (products === null || products === void 0 ? void 0 : products.bd) || new products_1.BotDefender(config, { base64Utils: base64Utils, ipRangeChecker: ipRangeChecker, urlUtils: urlUtils });
     var accountDefender = (products === null || products === void 0 ? void 0 : products.ad) || new products_1.AccountDefender(config, { base64Utils: base64Utils });
-    var credentialIntelligence = config.ciEnabled
-        ? (products === null || products === void 0 ? void 0 : products.ci) || new products_1.CredentialIntelligence(config, { hashUtils: hashUtils, urlUtils: urlUtils })
-        : undefined;
+    var credentialIntelligence = (products === null || products === void 0 ? void 0 : products.ci) || new products_1.CredentialIntelligence(config, { hashUtils: hashUtils, urlUtils: urlUtils });
     var hypeSaleChallenge = (products === null || products === void 0 ? void 0 : products.hsc) || new products_1.HypeSaleChallenge(config, { base64Utils: base64Utils });
     return _a = {},
         _a[products_1.ProductName.BOT_DEFENDER] = botDefender,

package/lib/cjs/flow/EndEnforcerFlow.js

@@ -23,8 +23,8 @@ var EndEnforcerFlow = /** @class */ (function (_super) {
     function EndEnforcerFlow(config, _a) {
         var logServiceClient = _a.logServiceClient, telemetry = _a.telemetry, remoteConfigManager = _a.remoteConfigManager, activityClient = _a.activityClient;
         var phases = [
-            new phase_1.SendAsyncActivitiesPhase(activityClient),
-            new phase_1.SendTelemetryActivityPhase(telemetry),
+            new phase_1.SendAsyncActivitiesPhase(config, activityClient),
+            new phase_1.SendTelemetryActivityPhase(config, telemetry),
         ];
         if (remoteConfigManager) {
             phases.push(new phase_1.UpdateRemoteConfigPhase(config, remoteConfigManager));

package/lib/cjs/phase/impl/SendAsyncActivitiesPhase.js

@@ -42,16 +42,20 @@ var action_1 = require("../../action/index.js");
  * The `SendAsyncActivitiesPhase` class is responsible for sending all necessary asynchronous activities based on the context.
  */
 var SendAsyncActivitiesPhase = /** @class */ (function () {
-    function SendAsyncActivitiesPhase(activityClient) {
+    function SendAsyncActivitiesPhase(config, activityClient) {
+        this.config = config;
         this.activityClient = activityClient;
     }
     SendAsyncActivitiesPhase.prototype.execute = function (context) {
         return __awaiter(this, void 0, void 0, function () {
+            var promise;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
                         if (![action_1.Action.PASS_REQUEST, action_1.Action.BLOCK, action_1.Action.SIMULATED_BLOCK].includes(context.action)) return [3 /*break*/, 2];
-                        return [4 /*yield*/, this.activityClient.sendActivities(context)];
+                        promise = this.activityClient.sendActivities(context);
+                        if (!this.config.awaitAsyncHttpRequests) return [3 /*break*/, 2];
+                        return [4 /*yield*/, promise];
                     case 1:
                         _a.sent();
                         _a.label = 2;

package/lib/cjs/phase/impl/SendLogsPhase.js

@@ -41,16 +41,20 @@ exports.SendLogsPhase = void 0;
  * The `SendLogsPhase` class is responsible for sending logs to the HUMAN logging service.
  */
 var SendLogsPhase = /** @class */ (function () {
-    function SendLogsPhase(_config, logServiceClient) {
+    function SendLogsPhase(config, logServiceClient) {
+        this.config = config;
         this.logServiceClient = logServiceClient;
     }
     SendLogsPhase.prototype.execute = function (context) {
         return __awaiter(this, void 0, void 0, function () {
+            var promise;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
                         if (!context.shouldSendLogs) return [3 /*break*/, 2];
-                        return [4 /*yield*/, this.logServiceClient.sendLogs(context)];
+                        promise = this.logServiceClient.sendLogs(context);
+                        if (!this.config.awaitAsyncHttpRequests) return [3 /*break*/, 2];
+                        return [4 /*yield*/, promise];
                     case 1:
                         _a.sent();
                         _a.label = 2;

package/lib/cjs/phase/impl/SendTelemetryActivityPhase.js

@@ -41,16 +41,20 @@ exports.SendTelemetryActivityPhase = void 0;
  * The `SendTelemetryActivityPhase` class is responsible for sending the telemetry activity if necessary.
  */
 var SendTelemetryActivityPhase = /** @class */ (function () {
-    function SendTelemetryActivityPhase(telemetry) {
+    function SendTelemetryActivityPhase(config, telemetry) {
+        this.config = config;
         this.telemetry = telemetry;
     }
     SendTelemetryActivityPhase.prototype.execute = function (context) {
         return __awaiter(this, void 0, void 0, function () {
+            var promise;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
                         if (!context.shouldSendTelemetry) return [3 /*break*/, 2];
-                        return [4 /*yield*/, this.telemetry.sendTelemetry(context)];
+                        promise = this.telemetry.sendTelemetry(context);
+                        if (!this.config.awaitAsyncHttpRequests) return [3 /*break*/, 2];
+                        return [4 /*yield*/, promise];
                     case 1:
                         _a.sent();
                         _a.label = 2;

package/lib/cjs/products/credential_intelligence/CredentialIntelligence.js

@@ -55,7 +55,9 @@ var constants_1 = require("./constants.js");
 var CredentialIntelligence = /** @class */ (function () {
     function CredentialIntelligence(config, options) {
         this.config = config;
-        this.endpointManager = new endpoint_1.CredentialEndpointManager(this.initializeCredentialIntelligenceEndpoints(config, options));
+        this.options = options;
+        this.remoteConfigVersion = config.remoteConfigVersion;
+        this.endpointManager = new endpoint_1.CredentialEndpointManager(this.initializeCredentialIntelligenceEndpoints(this.config, this.options));
     }
     CredentialIntelligence.prototype.enrichContextFromRequest = function (context) {
         return __awaiter(this, void 0, void 0, function () {
@@ -63,6 +65,12 @@ var CredentialIntelligence = /** @class */ (function () {
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
+                        if (!this.config.ciEnabled) {
+                            return [2 /*return*/, null];
+                        }
+                        if (this.shouldRefreshCredentialIntelligenceEndpoints()) {
+                            this.refreshCredentialIntelligenceEndpoints();
+                        }
                         endpointIndex = this.endpointManager.getEndpointIndex(context);
                         if (endpointIndex === -1) {
                             return [2 /*return*/, null];
@@ -159,14 +167,30 @@ var CredentialIntelligence = /** @class */ (function () {
         request.headers.set(constants_1.ADDITIONAL_S2S_URL_HEADER_NAME, "".concat(this.config.backendCollectorUrl).concat(activities_1.ACTIVITIES_ENDPOINT));
     };
     CredentialIntelligence.prototype.initializeCredentialIntelligenceEndpoints = function (config, options) {
-        return config.ciEndpoints.map(function (endpointConfig) {
+        var _this = this;
+        return config.ciEndpoints
+            .map(function (endpointConfig) {
             var _a;
-            var matcher = endpoint_1.CredentialIntelligenceEndpointMatcherFactory.create(endpointConfig);
-            var extractor = endpoint_1.CredentialExtractorFactory.create(endpointConfig, options.urlUtils);
-            var protocol = endpoint_1.CredentialIntelligenceHashProtocolFactory.create(((_a = endpointConfig.protocol) !== null && _a !== void 0 ? _a : config.ciDefaultVersion), options.hashUtils);
-            var loginSuccessfulParser = endpoint_1.LoginSuccessfulParserFactory.create(config, endpointConfig);
-            return new endpoint_1.CredentialEndpoint(matcher, extractor, protocol, loginSuccessfulParser);
-        });
+            try {
+                var matcher = endpoint_1.CredentialIntelligenceEndpointMatcherFactory.create(endpointConfig);
+                var extractor = endpoint_1.CredentialExtractorFactory.create(endpointConfig, options.urlUtils);
+                var protocol = endpoint_1.CredentialIntelligenceHashProtocolFactory.create(((_a = endpointConfig.protocol) !== null && _a !== void 0 ? _a : config.ciDefaultVersion), options.hashUtils);
+                var loginSuccessfulParser = endpoint_1.LoginSuccessfulParserFactory.create(config, endpointConfig);
+                return new endpoint_1.CredentialEndpoint(matcher, extractor, protocol, loginSuccessfulParser);
+            }
+            catch (error) {
+                _this.config.logger.error("caught error initializing credential intelligence endpoint: ".concat(error));
+                return null;
+            }
+        })
+            .filter(function (endpoint) { return endpoint !== null; });
+    };
+    CredentialIntelligence.prototype.shouldRefreshCredentialIntelligenceEndpoints = function () {
+        return this.remoteConfigVersion !== this.config.remoteConfigVersion;
+    };
+    CredentialIntelligence.prototype.refreshCredentialIntelligenceEndpoints = function () {
+        this.remoteConfigVersion = this.config.remoteConfigVersion;
+        this.endpointManager = new endpoint_1.CredentialEndpointManager(this.initializeCredentialIntelligenceEndpoints(this.config, this.options));
     };
     return CredentialIntelligence;
 }());

package/lib/cjs/utils/constants.js

@@ -15,4 +15,4 @@ exports.PUSH_DATA_FEATURE_HEADER_NAME = 'x-px-feature';
 exports.EMAIL_ADDRESS_REGEX = /^[a-zA-Z0-9_+&*-]+(?:\.[a-zA-Z0-9_+&*-]+)*@(?:[a-zA-Z0-9-]+\.)+[a-zA-Z]{2,7}$/;
 exports.URL_REGEX = /^(https?:)\/\/(([^@\s:\/]+):?([^@\s\/]*)@)?(([^:\/?#]*)(?:\:([0-9]+))?)(\/?[^?#]*)(\?[^#]*|)(#.*|)$/;
 exports.REGEX_STRUCTURE = /^\/(.+?)\/([gimsuyvd]*)$/;
-exports.CORE_MODULE_VERSION = 'JS Core 0.29.0';
+exports.CORE_MODULE_VERSION = 'JS Core 0.30.1';

package/lib/esm/activities/HttpActivityClient.js

@@ -31,7 +31,7 @@ export class HttpActivityClient {
                 context.logger.debug('no activities to send');
                 return true;
             }
-            return await this.postActivities(activities, context.logger);
+            return this.postActivities(activities, context.logger);
         }
         catch (e) {
             context.logger.error(`unable to send activities - ${e}`);
@@ -124,16 +124,22 @@ export class HttpActivityClient {
      * @protected
      */
     async postActivities(activities, logger) {
-        const url = `${this.config.backendCollectorUrl}${ACTIVITIES_ENDPOINT}`;
-        const method = HttpMethod.POST;
-        const headers = {
-            [CONTENT_TYPE_HEADER_NAME]: [ContentType.APPLICATION_JSON],
-            [AUTHORIZATION_HEADER_NAME]: [getAuthorizationHeader(this.config.authToken)],
-        };
-        const body = activities.length === 1 ? JSON.stringify(activities[0]) : JSON.stringify(activities);
-        logger.debug(`sending ${activities.map(({ type }) => `${type} activity`).join(', ')} to ${url}`);
-        const req = new OutgoingRequestImpl({ url, method, headers, body });
-        const res = await this.httpClient.send(req, { timeoutMs: this.config.asyncTimeout });
-        return res?.status === 200;
+        try {
+            const url = `${this.config.backendCollectorUrl}${ACTIVITIES_ENDPOINT}`;
+            const method = HttpMethod.POST;
+            const headers = {
+                [CONTENT_TYPE_HEADER_NAME]: [ContentType.APPLICATION_JSON],
+                [AUTHORIZATION_HEADER_NAME]: [getAuthorizationHeader(this.config.authToken)],
+            };
+            const body = activities.length === 1 ? JSON.stringify(activities[0]) : JSON.stringify(activities);
+            logger.debug(`sending ${activities.map(({ type }) => `${type} activity`).join(', ')} to ${url}`);
+            const req = new OutgoingRequestImpl({ url, method, headers, body });
+            const res = await this.httpClient.send(req, { timeoutMs: this.config.asyncTimeout });
+            return res?.status === 200;
+        }
+        catch (e) {
+            logger.error(`failed to post activities - ${e}`);
+            return false;
+        }
     }
 }

package/lib/esm/config/ConfigurationBase.js

@@ -408,6 +408,9 @@ export class ConfigurationBase {
     get enableBlockedUrlOnCaptchaBlockPage() {
         return true;
     }
+    get awaitAsyncHttpRequests() {
+        return true;
+    }
     get isPostEnforceEnabled() {
         return true;
     }

package/lib/esm/enforcer/utils.js

@@ -68,9 +68,7 @@ export const createEnforcerInitializationBlock = (config, options) => {
 export const createEnforcerProducts = (config, products, base64Utils, hashUtils, urlUtils, ipRangeChecker) => {
     const botDefender = products?.bd || new BotDefender(config, { base64Utils, ipRangeChecker, urlUtils });
     const accountDefender = products?.ad || new AccountDefender(config, { base64Utils });
-    const credentialIntelligence = config.ciEnabled
-        ? products?.ci || new CredentialIntelligence(config, { hashUtils, urlUtils })
-        : undefined;
+    const credentialIntelligence = products?.ci || new CredentialIntelligence(config, { hashUtils, urlUtils });
     const hypeSaleChallenge = products?.hsc || new HypeSaleChallenge(config, { base64Utils });
     return {
         [ProductName.BOT_DEFENDER]: botDefender,

package/lib/esm/flow/EndEnforcerFlow.js

@@ -3,8 +3,8 @@ import { Flow } from './Flow.js';
 export class EndEnforcerFlow extends Flow {
     constructor(config, { logServiceClient, telemetry, remoteConfigManager, activityClient, }) {
         const phases = [
-            new SendAsyncActivitiesPhase(activityClient),
-            new SendTelemetryActivityPhase(telemetry),
+            new SendAsyncActivitiesPhase(config, activityClient),
+            new SendTelemetryActivityPhase(config, telemetry),
         ];
         if (remoteConfigManager) {
             phases.push(new UpdateRemoteConfigPhase(config, remoteConfigManager));

package/lib/esm/phase/impl/SendAsyncActivitiesPhase.js

@@ -3,13 +3,19 @@ import { Action } from '../../action/index.js';
  * The `SendAsyncActivitiesPhase` class is responsible for sending all necessary asynchronous activities based on the context.
  */
 export class SendAsyncActivitiesPhase {
+    config;
     activityClient;
-    constructor(activityClient) {
+    constructor(config, activityClient) {
+        this.config = config;
         this.activityClient = activityClient;
     }
     async execute(context) {
         if ([Action.PASS_REQUEST, Action.BLOCK, Action.SIMULATED_BLOCK].includes(context.action)) {
-            await this.activityClient.sendActivities(context);
+            // ensure error handling is done in the sendActivities method
+            const promise = this.activityClient.sendActivities(context);
+            if (this.config.awaitAsyncHttpRequests) {
+                await promise;
+            }
         }
         return { done: false };
     }

package/lib/esm/phase/impl/SendLogsPhase.js

@@ -2,13 +2,19 @@
  * The `SendLogsPhase` class is responsible for sending logs to the HUMAN logging service.
  */
 export class SendLogsPhase {
+    config;
     logServiceClient;
-    constructor(_config, logServiceClient) {
+    constructor(config, logServiceClient) {
+        this.config = config;
         this.logServiceClient = logServiceClient;
     }
     async execute(context) {
         if (context.shouldSendLogs) {
-            await this.logServiceClient.sendLogs(context);
+            // ensure error handling is done in the sendLogs method
+            const promise = this.logServiceClient.sendLogs(context);
+            if (this.config.awaitAsyncHttpRequests) {
+                await promise;
+            }
         }
         return { done: false };
     }

package/lib/esm/phase/impl/SendTelemetryActivityPhase.js

@@ -2,13 +2,19 @@
  * The `SendTelemetryActivityPhase` class is responsible for sending the telemetry activity if necessary.
  */
 export class SendTelemetryActivityPhase {
+    config;
     telemetry;
-    constructor(telemetry) {
+    constructor(config, telemetry) {
+        this.config = config;
         this.telemetry = telemetry;
     }
     async execute(context) {
         if (context.shouldSendTelemetry) {
-            await this.telemetry.sendTelemetry(context);
+            // ensure error handling is done in the sendTelemetry method
+            const promise = this.telemetry.sendTelemetry(context);
+            if (this.config.awaitAsyncHttpRequests) {
+                await promise;
+            }
         }
         return { done: false };
     }

package/lib/esm/products/credential_intelligence/CredentialIntelligence.js

@@ -4,12 +4,22 @@ import { CredentialEndpoint, CredentialEndpointManager, CredentialExtractorFacto
 import { ADDITIONAL_S2S_ACTIVITY_HEADER_NAME, ADDITIONAL_S2S_URL_HEADER_NAME, COMPROMISED_CREDENTIALS_HEADER_VALUE, } from './constants.js';
 export class CredentialIntelligence {
     config;
+    options;
+    remoteConfigVersion;
     endpointManager;
     constructor(config, options) {
         this.config = config;
-        this.endpointManager = new CredentialEndpointManager(this.initializeCredentialIntelligenceEndpoints(config, options));
+        this.options = options;
+        this.remoteConfigVersion = config.remoteConfigVersion;
+        this.endpointManager = new CredentialEndpointManager(this.initializeCredentialIntelligenceEndpoints(this.config, this.options));
     }
     async enrichContextFromRequest(context) {
+        if (!this.config.ciEnabled) {
+            return null;
+        }
+        if (this.shouldRefreshCredentialIntelligenceEndpoints()) {
+            this.refreshCredentialIntelligenceEndpoints();
+        }
         const endpointIndex = this.endpointManager.getEndpointIndex(context);
         if (endpointIndex === -1) {
             return null;
@@ -66,12 +76,27 @@ export class CredentialIntelligence {
         request.headers.set(ADDITIONAL_S2S_URL_HEADER_NAME, `${this.config.backendCollectorUrl}${ACTIVITIES_ENDPOINT}`);
     }
     initializeCredentialIntelligenceEndpoints(config, options) {
-        return config.ciEndpoints.map((endpointConfig) => {
-            const matcher = CredentialIntelligenceEndpointMatcherFactory.create(endpointConfig);
-            const extractor = CredentialExtractorFactory.create(endpointConfig, options.urlUtils);
-            const protocol = CredentialIntelligenceHashProtocolFactory.create((endpointConfig.protocol ?? config.ciDefaultVersion), options.hashUtils);
-            const loginSuccessfulParser = LoginSuccessfulParserFactory.create(config, endpointConfig);
-            return new CredentialEndpoint(matcher, extractor, protocol, loginSuccessfulParser);
-        });
+        return config.ciEndpoints
+            .map((endpointConfig) => {
+            try {
+                const matcher = CredentialIntelligenceEndpointMatcherFactory.create(endpointConfig);
+                const extractor = CredentialExtractorFactory.create(endpointConfig, options.urlUtils);
+                const protocol = CredentialIntelligenceHashProtocolFactory.create((endpointConfig.protocol ?? config.ciDefaultVersion), options.hashUtils);
+                const loginSuccessfulParser = LoginSuccessfulParserFactory.create(config, endpointConfig);
+                return new CredentialEndpoint(matcher, extractor, protocol, loginSuccessfulParser);
+            }
+            catch (error) {
+                this.config.logger.error(`caught error initializing credential intelligence endpoint: ${error}`);
+                return null;
+            }
+        })
+            .filter((endpoint) => endpoint !== null);
+    }
+    shouldRefreshCredentialIntelligenceEndpoints() {
+        return this.remoteConfigVersion !== this.config.remoteConfigVersion;
+    }
+    refreshCredentialIntelligenceEndpoints() {
+        this.remoteConfigVersion = this.config.remoteConfigVersion;
+        this.endpointManager = new CredentialEndpointManager(this.initializeCredentialIntelligenceEndpoints(this.config, this.options));
     }
 }

package/lib/esm/utils/constants.js

@@ -12,4 +12,4 @@ export const PUSH_DATA_FEATURE_HEADER_NAME = 'x-px-feature';
 export const EMAIL_ADDRESS_REGEX = /^[a-zA-Z0-9_+&*-]+(?:\.[a-zA-Z0-9_+&*-]+)*@(?:[a-zA-Z0-9-]+\.)+[a-zA-Z]{2,7}$/;
 export const URL_REGEX = /^(https?:)\/\/(([^@\s:\/]+):?([^@\s\/]*)@)?(([^:\/?#]*)(?:\:([0-9]+))?)(\/?[^?#]*)(\?[^#]*|)(#.*|)$/;
 export const REGEX_STRUCTURE = /^\/(.+?)\/([gimsuyvd]*)$/;
-export const CORE_MODULE_VERSION = 'JS Core 0.29.0';
+export const CORE_MODULE_VERSION = 'JS Core 0.30.1';

package/lib/types/config/ConfigurationBase.d.ts

@@ -144,5 +144,6 @@ export declare abstract class ConfigurationBase<Req, Res, Added, Removed extends
     get snippetInjectionEnabled(): boolean;
     get createCustomSnippet(): CustomSnippetFunction<Req, Res, Added, Removed> | null;
     get enableBlockedUrlOnCaptchaBlockPage(): boolean;
+    get awaitAsyncHttpRequests(): boolean;
     get isPostEnforceEnabled(): boolean;
 }

package/lib/types/config/IConfiguration.d.ts

@@ -396,6 +396,10 @@ export interface IConfiguration<Req, Res, Added, Removed> {
      * Whether the enforcer has access to the HTTP response, which is required for the postEnforce function call
      */
     readonly isPostEnforceEnabled: boolean;
+    /**
+     * Whether to await asynchronous HTTP requests (e.g., async activities, remote logger, telemetry)
+     */
+    readonly awaitAsyncHttpRequests: boolean;
     /**
      * The version of the token the enforcer is able to parse.
      */

package/lib/types/phase/impl/SendAsyncActivitiesPhase.d.ts

@@ -1,3 +1,4 @@
+import { IConfiguration } from '../../config';
 import { IContext } from '../../context';
 import { IActivityClient } from '../../activities';
 import { PhaseResult } from '../PhaseResult';
@@ -5,8 +6,9 @@ import { IPhase } from '../IPhase';
 /**
  * The `SendAsyncActivitiesPhase` class is responsible for sending all necessary asynchronous activities based on the context.
  */
-export declare class SendAsyncActivitiesPhase<Req, Res> implements IPhase<Req, Res> {
+export declare class SendAsyncActivitiesPhase<Req, Res, Added, Removed> implements IPhase<Req, Res> {
+    protected readonly config: IConfiguration<Req, Res, Added, Removed>;
     protected readonly activityClient: IActivityClient<Req, Res>;
-    constructor(activityClient: IActivityClient<Req, Res>);
+    constructor(config: IConfiguration<Req, Res, Added, Removed>, activityClient: IActivityClient<Req, Res>);
     execute(context: IContext<Req, Res>): Promise<PhaseResult>;
 }

package/lib/types/phase/impl/SendLogsPhase.d.ts

@@ -7,7 +7,8 @@ import { ILogServiceClient } from '../../logger';
  * The `SendLogsPhase` class is responsible for sending logs to the HUMAN logging service.
  */
 export declare class SendLogsPhase<Req, Res, Added, Removed> implements IPhase<Req, Res> {
+    private readonly config;
     private readonly logServiceClient;
-    constructor(_config: IConfiguration<Req, Res, Added, Removed>, logServiceClient: ILogServiceClient<Req, Res>);
+    constructor(config: IConfiguration<Req, Res, Added, Removed>, logServiceClient: ILogServiceClient<Req, Res>);
     execute(context: IContext<Req, Res>): Promise<PhaseResult>;
 }

package/lib/types/phase/impl/SendTelemetryActivityPhase.d.ts

@@ -2,12 +2,14 @@ import { IPhase } from '../IPhase';
 import { PhaseResult } from '../PhaseResult';
 import { IContext } from '../../context';
 import { ITelemetry } from '../../telemetry';
+import { IConfiguration } from '../../config';
 /**
  * The `SendTelemetryActivityPhase` class is responsible for sending the telemetry activity if necessary.
  */
-export declare class SendTelemetryActivityPhase<Req, Res> implements IPhase<Req, Res> {
+export declare class SendTelemetryActivityPhase<Req, Res, Added, Removed> implements IPhase<Req, Res> {
+    protected readonly config: IConfiguration<Req, Res, Added, Removed>;
     protected readonly telemetry: ITelemetry<Req, Res>;
-    constructor(telemetry: ITelemetry<Req, Res>);
+    constructor(config: IConfiguration<Req, Res, Added, Removed>, telemetry: ITelemetry<Req, Res>);
     execute(context: IContext<Req, Res>): Promise<PhaseResult>;
     protected sendTelemetry(context: IContext<Req, Res>): Promise<void>;
 }

package/lib/types/products/credential_intelligence/CredentialIntelligence.d.ts

@@ -11,7 +11,9 @@ export type CredentialIntelligenceOptions = {
 };
 export declare class CredentialIntelligence<Req, Res, Added, Removed> implements ICredentialIntelligence<Req, Res> {
     protected readonly config: IConfiguration<Req, Res, Added, Removed>;
-    protected readonly endpointManager: CredentialEndpointManager<Req, Res>;
+    protected readonly options: CredentialIntelligenceOptions;
+    protected remoteConfigVersion: number;
+    protected endpointManager: CredentialEndpointManager<Req, Res>;
     constructor(config: IConfiguration<Req, Res, Added, Removed>, options: CredentialIntelligenceOptions);
     enrichContextFromRequest(context: ReadonlyContext<Req, Res>): Promise<CredentialIntelligenceData | null>;
     enrichContextFromRiskApi(context: ReadonlyContext<Req, Res>): Promise<Partial<CredentialIntelligenceData> | null>;
@@ -23,4 +25,6 @@ export declare class CredentialIntelligence<Req, Res, Added, Removed> implements
     protected shouldSetAdditionalS2SActivityHeaders(): boolean;
     protected setAdditionalS2SActivityHeaders(request: IIncomingRequest<Req>, context: ReadonlyContext<Req, Res>): void;
     protected initializeCredentialIntelligenceEndpoints(config: IConfiguration<Req, Res, Added, Removed>, options: CredentialIntelligenceOptions): ICredentialEndpoint<Req, Res>[];
+    protected shouldRefreshCredentialIntelligenceEndpoints(): boolean;
+    protected refreshCredentialIntelligenceEndpoints(): void;
 }

package/lib/types/utils/constants.d.ts

@@ -12,4 +12,4 @@ export declare const PUSH_DATA_FEATURE_HEADER_NAME = "x-px-feature";
 export declare const EMAIL_ADDRESS_REGEX: RegExp;
 export declare const URL_REGEX: RegExp;
 export declare const REGEX_STRUCTURE: RegExp;
-export declare const CORE_MODULE_VERSION = "JS Core 0.29.0";
+export declare const CORE_MODULE_VERSION = "JS Core 0.30.1";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "perimeterx-js-core",
-  "version": "0.29.0",
+  "version": "0.30.1",
   "description": "",
   "type": "module",
   "typesVersions": {